/* * pbmtextps.c - render text into a bitmap using a postscript interpreter * * Copyright (C) 2002 by James McCann. * * Permission to use, copy, modify, and distribute this software and its * documentation for any purpose and without fee is hereby granted, provided * that the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation. This software is provided "as is" without express or * implied warranty. * * PostScript is a registered trademark of Adobe Systems International. * * Additions by Bryan Henderson contributed to public domain by author. * * PostScript(R) Language Reference, Third Edition (a.k.a. "Red Book") * http://www.adobe.com/products/postscript/pdfs/PLRM.pdf * ISBN 0-201-37922-8 * * Postscript Font Naming Issues: * https://partners.adobe.com/public/developer/en/font/5088.FontNames.pdf * * Other resources: * http://partners.adobe.com/public/developer/ps/index_specs.html */ #define _XOPEN_SOURCE 500 /* Make sure popen() is in stdio.h, strdup() is in string.h */ #include #include #include #include #include #include #include "pm_c_util.h" #include "mallocvar.h" #include "nstring.h" #include "shhopt.h" #include "pm_system.h" #include "pbm.h" enum InputFmt {INPUT_LITERAL, INPUT_ASCIIHEX, INPUT_ASCII85}; static void validateFontName(const char * const name) { /*----------------------------------------------------------------------------- Validate font name string. Abort with error message if it contains anything other than the printable characters in the ASCII 7-bit range, or any character with a special meaning in PostScript. -----------------------------------------------------------------------------*/ unsigned int idx; if (name[0] == '\0') pm_error("Font name is empty string"); for (idx = 0; name[idx] != '\0'; ++idx) { char const c = name[idx]; if (c < 32 || c > 125) pm_error("Invalid character in font name"); else switch (c) { case '[': case ']': case '(': case ')': case '{': case '}': case '/': case '\\': case '<': case '>': case '%': case ' ': case '@': pm_error("Invalid character in font name"); } } } static void asciiHexEncode(const char * const inbuff, char * const outbuff) { /*----------------------------------------------------------------------------- Convert the input text string to ASCII-Hex encoding. Examples: "ABC abc 123" -> <4142432061626320313233> "FOO(BAR)FOO" -> <464f4f2842415229464f4f> -----------------------------------------------------------------------------*/ char const hexits[16] = "0123456789abcdef"; unsigned int idx; outbuff[0] = '<'; for (idx = 0; inbuff[idx] != '\0'; ++idx) { unsigned int const item = (unsigned char) inbuff[idx]; outbuff[1 + idx * 2 + 0] = hexits[item >> 4]; outbuff[1 + idx * 2 + 1] = hexits[item & 0xF]; } if (idx == 0) pm_message("Empty input string"); outbuff[1 + idx * 2] = '>'; outbuff[1 + idx * 2 + 1] = '\0'; } static void failForInvalidChar(char const c, const char * const type) { if (c >= 0x32 || c < 0x7F) pm_error("Invalid character '%c' in '%s' input string", c, type); else pm_error("Invalid character 0x%02x in '%s' input string", c, type); } static void formatNonemptyAsciiHex(const char * const inbuff, char * const outbuff, unsigned int const inLen) { unsigned int inIdx, outIdx; /* Cursors in input and output buffers, respectively */ unsigned int validCharCt; /* Number of valid hex characters we've processed so far in input */ unsigned int startIdx, endIdx; /* Limits of input buffer cursor ('inIdx') */ if (inbuff[0] == '<') { startIdx = 1; endIdx = inLen - 2; } else { startIdx = 0; endIdx = inLen - 1; } validCharCt = 0; /* No valid characters seen yet */ outIdx = 0; /* Start at beginning of output buffer */ outbuff[outIdx++] = '<'; for (inIdx = startIdx; inIdx <= endIdx; ++inIdx) { switch (inbuff[inIdx]) { case '<': case '>': pm_error("Misplaced character '%c' in Ascii Hex input string", inbuff[inIdx]); break; case '\f': case '\n': case '\r': case ' ': case '\t': /* ignore whitespace chars */ break; default: if ((inbuff [inIdx] >='0' && inbuff [inIdx] <='9') || (inbuff [inIdx] >='A' && inbuff [inIdx] <='F') || (inbuff [inIdx] >='a' && inbuff [inIdx] <='f')) { outbuff[outIdx++] = inbuff [inIdx]; ++validCharCt; } else failForInvalidChar(inbuff[inIdx], "Ascii Hex"); break; } } if (validCharCt == 0) pm_message("Empty Ascii Hex input string"); else if (validCharCt % 2 != 0) pm_error("Number of characters in Ascii Hex input string " "is not even"); outbuff[outIdx++] = '>'; outbuff[outIdx++] = '\0'; } static void formatAsciiHexString(const char * const inbuff, char * const outbuff, unsigned int const inLen) { /*---------------------------------------------------------------------------- Format the ASCII Hex input 'inbuff' as a Postscript ASCII Hex string, e.g. "<313233>". Input can be just the ASCII Hex (e.g. "313233") or already formatted (e.g. "<313233>"). Input may also contain white space, which we ignore -- our output never contains white space. Though in Postscript, an ASCII NUL character counts as white space, we consider it the end of the input. We consider white space outside of the <> delimiters to be an error. Abort with error message if there is anything other than valid hex digits in the ASCII hex string proper. This is necessary to prevent code injection. ----------------------------------------------------------------------------*/ if (inLen == 0 || (inLen == 2 && inbuff[0] == '<' && inbuff[inLen-1] == '>' )) { pm_message("Empty Ascii Hex input string"); strncpy(outbuff, "<>", 3); } else { if (inbuff[0] == '<' && inbuff[inLen-1] != '>' ) pm_error("Ascii Hex input string starts with '<' " "but does not end with '>'"); else if (inbuff[0] != '<' && inbuff[inLen-1] == '>' ) pm_error("Ascii Hex input string ends with '>' " "but does not start with '<'"); formatNonemptyAsciiHex(inbuff, outbuff, inLen); } } static void formatNonemptyAscii85(const char * const inbuff, char * const outbuff, unsigned int const inLen) { unsigned int inIdx, outIdx; /* Cursors in input and output buffers, respectively */ unsigned int seqPos; /* Position in 5-character Ascii-85 sequence where 'inIdx' points */ unsigned int startIdx, endIdx; /* Limits of input buffer cursor ('inIdx') */ if (inLen > 4 && inbuff[0] == '<' && inbuff[1] == '~' && inbuff[inLen-2] == '~' && inbuff[inLen-1] == '>') { startIdx = 2; endIdx = inLen - 3; } else { startIdx = 0; endIdx = inLen - 1; } seqPos = 0; /* No 5-character Ascii-85 sequence encountered yet */ outIdx = 0; /* Start filling output buffer from beginning */ outbuff[outIdx++] = '<'; outbuff[outIdx++] = '~'; for (inIdx = startIdx; inIdx <= endIdx; ++inIdx) { switch (inbuff[inIdx]) { case '~': pm_error("Misplaced character '~' in Ascii 85 input string"); break; case '\f': case '\n': case '\r': case ' ': case '\t': break; case 'z': /* z extension */ if (seqPos > 0) pm_error("Special 'z' character appears in the middle of a " "5-character Ascii-85 sequence, which is invalid"); else outbuff[outIdx++] = inbuff[inIdx]; break; default: /* valid Ascii 85 char */ if (inbuff [inIdx] >='!' && inbuff [inIdx] <='u') { outbuff[outIdx++] = inbuff[inIdx]; seqPos = (seqPos + 1) % 5; } else failForInvalidChar(inbuff[inIdx], "Ascii 85"); break; } } if (outIdx == 2) { pm_message("Empty Ascii 85 input string"); } outbuff[outIdx++] = '~'; outbuff[outIdx++] = '>'; outbuff[outIdx++] = '\0'; } static void formatAscii85String(const char * const inbuff, char * const outbuff, unsigned int const inLen) { /*---------------------------------------------------------------------------- Format the Ascii-85 input 'inbuff' as a Postscript Ascii-85 string, e.g. "<~313233~>". Input can be just the Ascii-85 (e.g. "313233") or already formatted (e.g. "<~313233~>"). Input may also contain white space, which we ignore -- our output never contains white space. Though in Postscript, an ASCII NUL character counts as white space, we consider it the end of the input. We consider white space outside of the <~~> delimiters to be an error. Abort with error message if we encounter anything other than valid Ascii-85 encoding characters in the string proper. Note that the Adobe variant does not support the "y" extention. ----------------------------------------------------------------------------*/ if (inLen == 0 || (inLen == 4 && strncmp (inbuff, "<~~>", 4) == 0)) { pm_message("Empty Ascii 85 input string"); strncpy(outbuff,"<~~>", 5); } else { if (inLen >= 2) { if (inbuff[0] == '<' && inbuff[1] == '~' && (inLen < 4 || inbuff[inLen-2] != '~' || inbuff[inLen-1] != '>' )) pm_error("Ascii 85 input string starts with '<~' " "but does not end with '~>'"); else if (inbuff[inLen-2] == '~' && inbuff[inLen-1] == '>' && (inLen < 4 || inbuff[0] != '<' || inbuff[1] != '~')) pm_error("Ascii 85 input string ends with '~>' " "but does not start with '<~'"); } formatNonemptyAscii85(inbuff, outbuff, inLen); } } static void combineArgs(int const argc, const char ** const argv, const char ** const textP, unsigned int * const textSizeP) { unsigned int totalTextSize; char * text; size_t * argSize; unsigned int i; size_t idx; MALLOCARRAY_NOFAIL(argSize, argc); /* argv[0] not accessed; argSize[0] not used */ for (i = 1, totalTextSize = 0; i < argc; ++i) { argSize[i] = strlen(argv[i]); totalTextSize += argSize[i]; } totalTextSize = totalTextSize + (argc - 2); /* adjust for spaces */ MALLOCARRAY(text, totalTextSize + 1); /* add one for \0 at end */ if (text == NULL) pm_error("out of memory allocating buffer for " "%u characters of text", totalTextSize); strncpy(text, argv[1], argSize[1]); for (i = 2, idx = argSize[1]; i < argc; ++i) { text[idx++] = ' '; strncpy(&text[idx], argv[i], argSize[i]); idx += argSize[i]; } assert(idx == totalTextSize); text[idx++] = '\0'; assert(strlen(text) == totalTextSize); *textP = text; *textSizeP = totalTextSize; free(argSize); } static void buildTextFromArgs(int const argc, const char ** const argv, const char ** const inputTextP, enum InputFmt const inputFmt) { /*---------------------------------------------------------------------------- Build the string of text to be included in the Postscript program to be rendered, from the arguments of this program. We encode it in either ASCII-Hex or ASCII-85 as opposed to using the plain text from the command line because 1) the command line might have Postscript control characters in it; and 2) the command line might have text in 8-bit or multibyte code, but a Postscript program is supposed to be entirely printable ASCII characters. Official Postscript specifications have a limit on the length of a program line, which means there is a limit on the length of text string such as we generate. But we don't worry about that because Ghostscript actually accepts very long program lines. -----------------------------------------------------------------------------*/ const char * text; /* All the arguments ('argv') concatenated */ unsigned int textSize; /* Length of 'text' */ if (argc-1 < 1) pm_error("No text"); combineArgs(argc, argv, &text, &textSize); switch (inputFmt) { case INPUT_LITERAL: { char * asciiHexText; MALLOCARRAY(asciiHexText, textSize * 2 + 3); if (!asciiHexText) pm_error("Unable to allocate memory for hex encoding of %u " "characters of text", textSize); asciiHexEncode(text, asciiHexText); *inputTextP = asciiHexText; } break; case INPUT_ASCIIHEX: { char * asciiHexText; MALLOCARRAY(asciiHexText, textSize + 3); if (!asciiHexText) pm_error("Unable to allocate memory for hex encoding of %u " "characters of text", textSize); formatAsciiHexString(text, asciiHexText, textSize); *inputTextP = asciiHexText; } break; case INPUT_ASCII85: { char * ascii85Text; MALLOCARRAY(ascii85Text, textSize + 5); if (!ascii85Text) pm_error("Unable to allocate memory for hex encoding of %u " "characters of text", textSize); formatAscii85String(text, ascii85Text, textSize); *inputTextP = ascii85Text; } break; } pm_strfree(text); } struct CmdlineInfo { /* All the information the user supplied in the command line, in a form easy for the program to use. */ unsigned int res; float fontsize; const char * font; float stroke; float ascent; float descent; float leftmargin; float rightmargin; float topmargin; float bottommargin; unsigned int pad; unsigned int verbose; unsigned int dump; const char * text; /* Text to render, in Postscript format, either Ascii-hex (e.g. <313233>) or Ascii-85 (e.g. <~aBc-~>) */ }; static void parseCommandLine(int argc, const char ** argv, struct CmdlineInfo * const cmdlineP) { /*--------------------------------------------------------------------------- Note that the file spec array we return is stored in the storage that was passed to us as the argv array. ---------------------------------------------------------------------------*/ optEntry * option_def; /* Instructions to OptParseOptions2 on how to parse our options. */ optStruct3 opt; unsigned int option_def_index; unsigned int cropSpec, ascentSpec, descentSpec; unsigned int leftmarginSpec, rightmarginSpec; unsigned int topmarginSpec, bottommarginSpec; unsigned int asciihexSpec, ascii85Spec; MALLOCARRAY_NOFAIL(option_def, 100); option_def_index = 0; /* incremented by OPTENTRY */ OPTENT3(0, "resolution", OPT_UINT, &cmdlineP->res, NULL, 0); OPTENT3(0, "font", OPT_STRING, &cmdlineP->font, NULL, 0); OPTENT3(0, "fontsize", OPT_FLOAT, &cmdlineP->fontsize, NULL, 0); OPTENT3(0, "stroke", OPT_FLOAT, &cmdlineP->stroke, NULL, 0); OPTENT3(0, "ascent", OPT_FLOAT, &cmdlineP->ascent, &ascentSpec, 0); OPTENT3(0, "descent", OPT_FLOAT, &cmdlineP->descent, &descentSpec, 0); OPTENT3(0, "leftmargin", OPT_FLOAT, &cmdlineP->leftmargin, &leftmarginSpec, 0); OPTENT3(0, "rightmargin", OPT_FLOAT, &cmdlineP->rightmargin, &rightmarginSpec, 0); OPTENT3(0, "topmargin", OPT_FLOAT, &cmdlineP->topmargin, &topmarginSpec, 0); OPTENT3(0, "bottommargin", OPT_FLOAT, &cmdlineP->bottommargin, &bottommarginSpec, 0); OPTENT3(0, "crop", OPT_FLAG, NULL, &cropSpec, 0); OPTENT3(0, "pad", OPT_FLAG, NULL, &cmdlineP->pad, 0); OPTENT3(0, "asciihex", OPT_FLAG, NULL, &asciihexSpec, 0); OPTENT3(0, "ascii85", OPT_FLAG, NULL, &ascii85Spec, 0); OPTENT3(0, "verbose", OPT_FLAG, NULL, &cmdlineP->verbose, 0); OPTENT3(0, "dump-ps", OPT_FLAG, NULL, &cmdlineP->dump, 0); /* Set the defaults */ cmdlineP->res = 150; cmdlineP->fontsize = 24; cmdlineP->font = "Times-Roman"; cmdlineP->stroke = -1; cmdlineP->ascent = 0; cmdlineP->descent = 0; cmdlineP->rightmargin = 0; cmdlineP->leftmargin = 0; cmdlineP->topmargin = 0; cmdlineP->bottommargin = 0; opt.opt_table = option_def; opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */ opt.allowNegNum = FALSE; pm_optParseOptions3(&argc, (char **)argv, opt, sizeof(opt), 0); validateFontName(cmdlineP->font); if (cmdlineP->res <= 0) pm_error("-resolution must be positive"); if (cmdlineP->fontsize <= 0) pm_error("-fontsize must be positive"); if (cmdlineP->ascent < 0) pm_error("-ascent must not be negative"); if (cmdlineP->descent < 0) pm_error("-descent must not be negative"); if (cmdlineP->leftmargin <0) pm_error("-leftmargin must not be negative"); if (cmdlineP->rightmargin <0) pm_error("-rightmargin must not be negative"); if (cmdlineP->topmargin <0) pm_error("-topmargin must not be negative"); if (cmdlineP->bottommargin <0) pm_error("-bottommargin must not be negative"); if (cropSpec) { if (ascentSpec || descentSpec || leftmarginSpec || rightmarginSpec || topmarginSpec || bottommarginSpec || cmdlineP->pad) pm_error("-crop cannot be specified with -ascent, -descent, " "-leftmargin, -rightmargin, " "-topmargin, -bottommargin or -pad"); } else { if (!descentSpec && !bottommarginSpec && !cmdlineP->pad) cmdlineP->descent = cmdlineP->fontsize * 1.5; if (!leftmarginSpec) cmdlineP->leftmargin = cmdlineP->fontsize / 2; } { enum InputFmt inputFmt; if (asciihexSpec) { if (ascii85Spec) pm_error("You cannot specify both -asciihex and -ascii85"); else inputFmt = INPUT_ASCIIHEX; } else if (ascii85Spec) inputFmt = INPUT_ASCII85; else inputFmt = INPUT_LITERAL; if (argc-1 < 1) pm_error("No text"); buildTextFromArgs(argc, argv, &cmdlineP->text, inputFmt); } free(option_def); } static void termCmdline(struct CmdlineInfo const cmdline) { pm_strfree(cmdline.text); } static const char * postscriptProgram(struct CmdlineInfo const cmdline) { /*----------------------------------------------------------------------------- In Postscript, the bottom of the page is row zero. Postscript allows negative values but negative regions are clipped from the output image. We make adjustments to ensure that nothing is lost. Postscript also allow fonts to have negative values in the bounding box coordinates. The bottom edge of "L" is row zero: this row is called the "baseline". The feet of "g" "p" "y" extend into negative region. In a similar manner the left edge of the bounding box may be negative. We add margins on the left and the bottom with "xorigin" and "yorigin" to provide for such characters. The sequence "textstring false charpath flattenpath pathbbox" determines the bounding box of the entire text when rendered. -----------------------------------------------------------------------------*/ /* C89 limits the size of a string constant, so we have to build the Postscript command in pieces. psVariable, psTemplate: Set variables. psFixed1: Scale font. Calculate pad metrics. psFixed2: Determine width, height, xorigin, yorigin. psFixed3: Render. psFixed4: Verbose mode: Report font name, metrics. We could add code to psFixed2 for handling right-to-left writing (Hebrew, Arabic) and vertical writing (Chinese, Korean, Japanese). */ const char * const psTemplate = "/FindFont {/%s findfont} def\n" "/fontsize %f def\n" "/pensize %f def\n" "/textstring %s def\n" "/ascent %f def\n" "/descent %f def\n" "/leftmargin %f def\n" "/rightmargin %f def\n" "/topmargin %f def\n" "/bottommargin %f def\n" "/pad %s def\n" "/verbose %s def\n"; const char * const psFixed1 = "FindFont fontsize scalefont\n" "pad { dup dup\n" " /FontMatrix get 3 get /yscale exch def\n" " /FontBBox get dup\n" " 1 get yscale mul neg /padbottom exch def\n" " 3 get yscale mul /padtop exch def}\n" " {/padbottom 0 def /padtop 0 def}\n" " ifelse\n" "setfont\n"; const char * const psFixed2 = "0 0 moveto\n" "textstring false charpath flattenpath pathbbox\n" "/BBtop exch def\n" "/BBright exch def\n" "/BBbottom exch neg def\n" "/BBleft exch neg def\n" "/max { 2 copy lt { exch } if pop } bind def\n" "/yorigin descent padbottom max BBbottom max bottommargin add def\n" "/xorigin leftmargin BBleft max def\n" "/width xorigin BBright add rightmargin add def\n" "/height ascent BBtop max padtop max topmargin add yorigin add def\n"; const char * const psFixed3 = "<> setpagedevice\n" "xorigin yorigin moveto\n" "pensize 0 lt\n" " {textstring show}\n" " {pensize setlinewidth 0 setgray\n" " textstring true charpath stroke}\n" " ifelse\n" "showpage\n"; const char * const psFixed4 = "verbose\n" " {xorigin yorigin moveto\n" " [(width height) width height] ==\n" " [(ascent descent) height yorigin sub yorigin] ==\n" " [(bounding box) \n" " textstring false charpath flattenpath pathbbox] ==\n" " [(Fontname) FindFont dup /FontName\n" " known\n" " {/FontName get}\n" " {pop (anonymous)}\n" " ifelse] ==}\n" " if"; const char * retval; const char * psVariable; /* According to Adobe, maximum line length in a Postscript program is 255 characters excluding the newline. The following may generated a line longer than that if 'cmdline.text' or 'cmdline.font' is long. However, Ghostscript accepts much longer lines, so we don't worry about that. */ pm_asprintf(&psVariable, psTemplate, cmdline.font, cmdline.fontsize, cmdline.stroke, cmdline.text, cmdline.ascent, cmdline.descent, cmdline.leftmargin, cmdline.rightmargin, cmdline.topmargin, cmdline.bottommargin, cmdline.pad ? "true" : "false", cmdline.verbose ? "true" : "false" ); pm_asprintf(&retval, "%s%s%s%s%s", psVariable, psFixed1, psFixed2, psFixed3, psFixed4); pm_strfree(psVariable); return retval; } static const char ** gsArgList(const char * const outputFilename, struct CmdlineInfo const cmdline) { unsigned int const maxArgCt = 50; const char ** retval; unsigned int argCt; /* Number of arguments in 'retval' so far */ assert(cmdline.res > 0); assert(cmdline.fontsize > 0); MALLOCARRAY_NOFAIL(retval, maxArgCt+2); argCt = 0; /* initial value */ pm_asprintf(&retval[argCt++], "ghostscript"); pm_asprintf(&retval[argCt++], "-r%d", cmdline.res); pm_asprintf(&retval[argCt++], "-sDEVICE=pbmraw"); pm_asprintf(&retval[argCt++], "-sOutputFile=%s", outputFilename); pm_asprintf(&retval[argCt++], "-q"); pm_asprintf(&retval[argCt++], "-dBATCH"); pm_asprintf(&retval[argCt++], "-dSAFER"); pm_asprintf(&retval[argCt++], "-dNOPAUSE"); pm_asprintf(&retval[argCt++], "-"); retval[argCt++] = NULL; assert(argCt < maxArgCt); return retval; } static void reportGhostScript(const char * const executableNm, const char ** const argList) { unsigned int i; pm_message("Running Ghostscript interpreter '%s'", executableNm); pm_message("Program arguments:"); for (i = 0; argList[i]; ++i) pm_message(" '%s'", argList[i]); } static void freeArgList(const char ** const argList) { unsigned int i; for (i = 0; argList[i]; ++i) pm_strfree(argList[i]); free(argList); } static void reportFontName(const char * const fontname) { pm_message("Font: '%s'", fontname); } static void reportMetrics(float const width, float const height, float const ascent, float const descent, float const BBoxleft, float const BBoxbottom, float const BBoxright, float const BBoxtop) { pm_message("-- Metrics in points. Bottom left is (0,0) --"); pm_message("Width: %f", width); pm_message("Height: %f", height); pm_message("Ascent: %f", ascent); pm_message("Descent: %f", descent); pm_message("BoundingBox_Left: %f", BBoxleft); pm_message("BoundingBox_Right: %f", BBoxright); pm_message("BoundingBox_Top: %f", BBoxtop); pm_message("BoundingBox_Bottom: %f", BBoxbottom); } static void acceptGSoutput(int const pipetosuckFd, void * const nullParams ) { /*----------------------------------------------------------------------------- Accept text written to stdout by the PostScript program. There are two kinds of output: (1) Metrics and fontname reported, when verbose is on. (2) Error messages from ghostscript. We read one line at a time. We cannot predict how long one line can be in case (2). In practice the "execute stack" report gets long. We provide by setting lineBuffSize to a large number. -----------------------------------------------------------------------------*/ unsigned int const lineBuffSize = 1024*32; FILE * const inFileP = fdopen(pipetosuckFd, "r"); float width, height, ascent, descent; float BBoxleft, BBoxbottom, BBoxright, BBoxtop; char * lineBuff; /* malloc'd */ char fontname [2048]; bool fontnameReported, widthHeightReported; bool ascentDescentReported, BBoxReported; assert(nullParams == NULL); fontnameReported = FALSE; /* Initial value */ widthHeightReported = FALSE; /* Initial value */ ascentDescentReported = FALSE; /* Initial value */ BBoxReported = FALSE; /* Initial value */ MALLOCARRAY_NOFAIL(lineBuff, lineBuffSize); while (fgets(lineBuff, lineBuffSize, inFileP) != NULL) { unsigned int rWidthHeight, rAscentDescent, rBBox, rFontname; rWidthHeight = sscanf(lineBuff, "[(width height) %f %f]", &width, &height); rAscentDescent = sscanf(lineBuff, "[(ascent descent) %f %f]", &ascent, &descent); rBBox = sscanf(lineBuff, "[(bounding box) %f %f %f %f]", &BBoxleft, &BBoxbottom, &BBoxright, &BBoxtop); rFontname = sscanf(lineBuff, "[(Fontname) /%2047s", fontname); if (rFontname == 1) fontnameReported = TRUE; else if (rWidthHeight == 2) widthHeightReported = TRUE; else if (rAscentDescent == 2) ascentDescentReported = TRUE; else if (rBBox == 4) BBoxReported = TRUE; else pm_message("[gs] %s", lineBuff); } if (fontnameReported) { fontname[strlen(fontname)-1] = 0; reportFontName(fontname); if (widthHeightReported && ascentDescentReported && BBoxReported) reportMetrics(width, height, ascent, descent, BBoxleft, BBoxbottom, BBoxright, BBoxtop); } fclose(inFileP); pm_strfree(lineBuff); } static void executeProgram(const char * const psProgram, const char * const outputFname, struct CmdlineInfo const cmdline) { const char * const executableNm = "gs"; const char ** const argList = gsArgList(outputFname, cmdline); struct bufferDesc feedBuffer; int termStatus; unsigned int bytesFed; bytesFed = 0; /* Initial value */ feedBuffer.buffer = (unsigned char *) psProgram; feedBuffer.size = strlen(psProgram); feedBuffer.bytesTransferredP = &bytesFed; if (cmdline.verbose) reportGhostScript(executableNm, argList); pm_system2_vp(executableNm, argList, &pm_feed_from_memory, &feedBuffer, cmdline.verbose ? &acceptGSoutput : &pm_accept_null, NULL, &termStatus); if (termStatus != 0) { const char * const msg = pm_termStatusDesc(termStatus); pm_error("Failed to run Ghostscript process. %s", msg); pm_strfree(msg); } freeArgList(argList); } static void writePbm(const char * const fileName, FILE * const ofP) { /*---------------------------------------------------------------------------- Write the PBM image that is in the file named 'fileName" to file *ofP. I.e. pbmtopbm. It's not a byte-for-byte copy because PBM allows the same image to be represented many ways (all of which we can accept as our input), but we use libnetpbm to write our output in its specific way. ----------------------------------------------------------------------------*/ FILE * ifP; int format; int cols, rows, row ; unsigned char * bitrow; ifP = pm_openr(fileName); pbm_readpbminit(ifP, &cols, &rows, &format); if (cols == 0 || rows == 0 || cols > INT_MAX - 10 || rows > INT_MAX - 10) pm_error("Abnormal output from gs program. " "width x height = %u x %u", cols, rows); pbm_writepbminit(ofP, cols, rows, 0); bitrow = pbm_allocrow_packed(cols); for (row = 0; row < rows; ++row) { pbm_readpbmrow_packed(ifP, bitrow, cols, format); pbm_writepbmrow_packed(ofP, bitrow, cols, 0); } pbm_freerow_packed(bitrow); pm_close(ifP); } static void generatePbm(struct CmdlineInfo const cmdline, FILE * const ofP) { const char * const psProgram = postscriptProgram(cmdline); const char * tempPbmFname; FILE * pbmFileP; pm_make_tmpfile(&pbmFileP, &tempPbmFname); assert(pbmFileP != NULL && tempPbmFname != NULL); fclose(pbmFileP); executeProgram(psProgram, tempPbmFname, cmdline); /* Although Ghostscript created a legal PBM file, it uses a different implementation of the format from libnetpbm's canonical output format, so instead of copying the content of 'tempPbmFname' to *ofP byte for byte, we copy it as a PBM image. */ writePbm(tempPbmFname, ofP); unlink(tempPbmFname); pm_strfree(tempPbmFname); pm_strfree(psProgram); } static void dumpPsProgram(struct CmdlineInfo const cmdline) { const char * psProgram; psProgram = postscriptProgram(cmdline); puts(psProgram); pm_strfree(psProgram); } int main(int argc, const char *argv[]) { struct CmdlineInfo cmdline; pm_proginit(&argc, argv); parseCommandLine(argc, argv, &cmdline); if (cmdline.dump) dumpPsProgram(cmdline); else generatePbm(cmdline, stdout); termCmdline(cmdline); return 0; }