123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794 |
- /*
- *
- * postprint - PostScript translator for ASCII files.
- *
- * A simple program that translates ASCII files into PostScript. All it really
- * does is expand tabs and backspaces, handle character quoting, print text lines,
- * and control when pages are started based on the requested number of lines per
- * page.
- *
- * The PostScript prologue is copied from *prologue before any of the input files
- * are translated. The program expects that the following procedures are defined
- * in that file:
- *
- * setup
- *
- * mark ... setup -
- *
- * Handles special initialization stuff that depends on how the program
- * was called. Expects to find a mark followed by key/value pairs on the
- * stack. The def operator is applied to each pair up to the mark, then
- * the default state is set up.
- *
- * pagesetup
- *
- * page pagesetup -
- *
- * Does whatever is needed to set things up for the next page. Expects
- * to find the current page number on the stack.
- *
- * l
- *
- * string l -
- *
- * Prints string starting in the first column and then goes to the next
- * line.
- *
- * L
- *
- * mark string column string column ... L mark
- *
- * Prints each string on the stack starting at the horizontal position
- * selected by column. Used when tabs and spaces can be sufficiently well
- * compressed to make the printer overhead worthwhile. Always used when
- * we have to back up.
- *
- * LL
- *
- * mark string column string column ... LL mark
- *
- * Like L, but only used to prevent potential PostScript stack overflow
- * from too many string/column pairs. Stays on the current line. It will
- * not be needed often!!
- *
- * done
- *
- * done
- *
- * Makes sure the last page is printed. Only needed when we're printing
- * more than one page on each sheet of paper.
- *
- * Almost everything has been changed in this version of postprint. The program
- * is more intelligent, especially about tabs, spaces, and backspacing, and as a
- * result output files usually print faster. Output files also now conform to
- * Adobe's file structuring conventions, which is undoubtedly something I should
- * have done in the first version of the program. If the number of lines per page
- * is set to 0, which can be done using the -l option, pointsize will be used to
- * guess a reasonable value. The estimate is based on the values of LINESPP,
- * POINTSIZE, and pointsize, and assumes LINESPP lines would fit on a page if
- * we printed in size POINTSIZE. Selecting a point size using the -s option and
- * adding -l0 to the command line forces the guess to be made.
- *
- * Many default values, like the magnification and orientation, are defined in
- * the prologue, which is where they belong. If they're changed (by options), an
- * appropriate definition is made after the prologue is added to the output file.
- * The -P option passes arbitrary PostScript through to the output file. Among
- * other things it can be used to set (or change) values that can't be accessed by
- * other options.
- *
- */
- #include <stdio.h>
- #include <signal.h>
- #include <ctype.h>
- #ifdef plan9
- #define isascii(c) ((unsigned char)(c)<=0177)
- #endif
- #include <sys/types.h>
- #include <fcntl.h>
- #include "comments.h" /* PostScript file structuring comments */
- #include "gen.h" /* general purpose definitions */
- #include "path.h" /* for the prologue */
- #include "ext.h" /* external variable declarations */
- #include "postprint.h" /* a few special definitions */
- char *optnames = "a:c:ef:l:m:n:o:p:r:s:t:x:y:A:C:E:J:L:P:R:DI";
- char *prologue = POSTPRINT; /* default PostScript prologue */
- char *formfile = FORMFILE; /* stuff for multiple pages per sheet */
- int formsperpage = 1; /* page images on each piece of paper */
- int copies = 1; /* and this many copies of each sheet */
- int linespp = LINESPP; /* number of lines per page */
- int pointsize = POINTSIZE; /* in this point size */
- int tabstops = TABSTOPS; /* tabs set at these columns */
- int crmode = 0; /* carriage return mode - 0, 1, or 2 */
- int extended = TRUE; /* use escapes for unprintable chars */
- int col = 1; /* next character goes in this column */
- int line = 1; /* on this line */
- int stringcount = 0; /* number of strings on the stack */
- int stringstart = 1; /* column where current one starts */
- Fontmap fontmap[] = FONTMAP; /* for translating font names */
- char *fontname = "Courier"; /* use this PostScript font */
- int page = 0; /* page we're working on */
- int printed = 0; /* printed this many pages */
- FILE *fp_in = stdin; /* read from this file */
- FILE *fp_out = stdout; /* and write stuff here */
- FILE *fp_acct = NULL; /* for accounting data */
- /*****************************************************************************/
- main(agc, agv)
- int agc;
- char *agv[];
- {
- /*
- *
- * A simple program that translates ASCII files into PostScript. If there's more
- * than one input file, each begins on a new page.
- *
- */
- argc = agc; /* other routines may want them */
- argv = agv;
- prog_name = argv[0]; /* really just for error messages */
- init_signals(); /* sets up interrupt handling */
- header(); /* PostScript header and prologue */
- options(); /* handle the command line options */
- setup(); /* for PostScript */
- arguments(); /* followed by each input file */
- done(); /* print the last page etc. */
- account(); /* job accounting data */
- exit(x_stat); /* not much could be wrong */
- } /* End of main */
- /*****************************************************************************/
- init_signals()
- {
- /*
- *
- * Makes sure we handle interrupts.
- *
- */
- if ( signal(SIGINT, interrupt) == SIG_IGN ) {
- signal(SIGINT, SIG_IGN);
- signal(SIGQUIT, SIG_IGN);
- signal(SIGHUP, SIG_IGN);
- } else {
- signal(SIGHUP, interrupt);
- signal(SIGQUIT, interrupt);
- } /* End else */
- signal(SIGTERM, interrupt);
- } /* End of init_signals */
- /*****************************************************************************/
- header()
- {
- int ch; /* return value from getopt() */
- int old_optind = optind; /* for restoring optind - should be 1 */
- /*
- *
- * Scans the option list looking for things, like the prologue file, that we need
- * right away but could be changed from the default. Doing things this way is an
- * attempt to conform to Adobe's latest file structuring conventions. In particular
- * they now say there should be nothing executed in the prologue, and they have
- * added two new comments that delimit global initialization calls. Once we know
- * where things really are we write out the job header, follow it by the prologue,
- * and then add the ENDPROLOG and BEGINSETUP comments.
- *
- */
- while ( (ch = getopt(argc, argv, optnames)) != EOF )
- if ( ch == 'L' )
- prologue = optarg;
- else if ( ch == '?' )
- error(FATAL, "");
- optind = old_optind; /* get ready for option scanning */
- fprintf(stdout, "%s", CONFORMING);
- fprintf(stdout, "%s %s\n", VERSION, PROGRAMVERSION);
- fprintf(stdout, "%s %s\n", DOCUMENTFONTS, ATEND);
- fprintf(stdout, "%s %s\n", PAGES, ATEND);
- fprintf(stdout, "%s", ENDCOMMENTS);
- if ( cat(prologue) == FALSE )
- error(FATAL, "can't read %s", prologue);
- if ( DOROUND )
- cat(ROUNDPAGE);
- fprintf(stdout, "%s", ENDPROLOG);
- fprintf(stdout, "%s", BEGINSETUP);
- fprintf(stdout, "mark\n");
- } /* End of header */
- /*****************************************************************************/
- options()
- {
- int ch; /* return value from getopt() */
- /*
- *
- * Reads and processes the command line options. Added the -P option so arbitrary
- * PostScript code can be passed through. Expect it could be useful for changing
- * definitions in the prologue for which options have not been defined.
- *
- * Although any PostScript font can be used, things will only work well for
- * constant width fonts.
- *
- */
- while ( (ch = getopt(argc, argv, optnames)) != EOF ) {
- switch ( ch ) {
- case 'a': /* aspect ratio */
- fprintf(stdout, "/aspectratio %s def\n", optarg);
- break;
- case 'c': /* copies */
- copies = atoi(optarg);
- fprintf(stdout, "/#copies %s store\n", optarg);
- break;
- case 'e': /* obsolete - it's now always on */
- extended = TRUE;
- break;
- case 'f': /* use this PostScript font */
- fontname = get_font(optarg);
- fprintf(stdout, "/font /%s def\n", fontname);
- break;
- case 'l': /* lines per page */
- linespp = atoi(optarg);
- break;
- case 'm': /* magnification */
- fprintf(stdout, "/magnification %s def\n", optarg);
- break;
- case 'n': /* forms per page */
- formsperpage = atoi(optarg);
- fprintf(stdout, "%s %s\n", FORMSPERPAGE, optarg);
- fprintf(stdout, "/formsperpage %s def\n", optarg);
- break;
- case 'o': /* output page list */
- out_list(optarg);
- break;
- case 'p': /* landscape or portrait mode */
- if ( *optarg == 'l' )
- fprintf(stdout, "/landscape true def\n");
- else fprintf(stdout, "/landscape false def\n");
- break;
- case 'r': /* carriage return mode */
- crmode = atoi(optarg);
- break;
- case 's': /* point size */
- pointsize = atoi(optarg);
- fprintf(stdout, "/pointsize %s def\n", optarg);
- break;
- case 't': /* tabstops */
- tabstops = atoi(optarg);
- break;
- case 'x': /* shift things horizontally */
- fprintf(stdout, "/xoffset %s def\n", optarg);
- break;
- case 'y': /* and vertically on the page */
- fprintf(stdout, "/yoffset %s def\n", optarg);
- break;
- case 'A': /* force job accounting */
- case 'J':
- if ( (fp_acct = fopen(optarg, "a")) == NULL )
- error(FATAL, "can't open accounting file %s", optarg);
- break;
- case 'C': /* copy file straight to output */
- if ( cat(optarg) == FALSE )
- error(FATAL, "can't read %s", optarg);
- break;
- case 'E': /* text font encoding */
- fontencoding = optarg;
- break;
- case 'L': /* PostScript prologue file */
- prologue = optarg;
- break;
- case 'P': /* PostScript pass through */
- fprintf(stdout, "%s\n", optarg);
- break;
- case 'R': /* special global or page level request */
- saverequest(optarg);
- break;
- case 'D': /* debug flag */
- debug = ON;
- break;
- case 'I': /* ignore FATAL errors */
- ignore = ON;
- break;
- case '?': /* don't understand the option */
- error(FATAL, "");
- break;
- default: /* don't know what to do for ch */
- error(FATAL, "missing case for option %c\n", ch);
- break;
- } /* End switch */
- } /* End while */
- argc -= optind; /* get ready for non-option args */
- argv += optind;
- } /* End of options */
- /*****************************************************************************/
- char *get_font(name)
- char *name; /* name the user asked for */
- {
- int i; /* for looking through fontmap[] */
- /*
- *
- * Called from options() to map a user's font name into a legal PostScript name.
- * If the lookup fails *name is returned to the caller. That should let you choose
- * any PostScript font, although things will only work well for constant width
- * fonts.
- *
- */
- for ( i = 0; fontmap[i].name != NULL; i++ )
- if ( strcmp(name, fontmap[i].name) == 0 )
- return(fontmap[i].val);
- return(name);
- } /* End of get_font */
- /*****************************************************************************/
- setup()
- {
- /*
- *
- * Handles things that must be done after the options are read but before the
- * input files are processed. linespp (lines per page) can be set using the -l
- * option. If it's not positive we calculate a reasonable value using the
- * requested point size - assuming LINESPP lines fit on a page in point size
- * POINTSIZE.
- *
- */
- writerequest(0, stdout); /* global requests eg. manual feed */
- setencoding(fontencoding);
- fprintf(stdout, "setup\n");
- if ( formsperpage > 1 ) {
- if ( cat(formfile) == FALSE )
- error(FATAL, "can't read %s", formfile);
- fprintf(stdout, "%d setupforms\n", formsperpage);
- } /* End if */
- fprintf(stdout, "%s", ENDSETUP);
- if ( linespp <= 0 )
- linespp = LINESPP * POINTSIZE / pointsize;
- } /* End of setup */
- /*****************************************************************************/
- arguments()
- {
- /*
- *
- * Makes sure all the non-option command line arguments are processed. If we get
- * here and there aren't any arguments left, or if '-' is one of the input files
- * we'll translate stdin.
- *
- */
- if ( argc < 1 )
- text();
- else { /* at least one argument is left */
- while ( argc > 0 ) {
- if ( strcmp(*argv, "-") == 0 )
- fp_in = stdin;
- else if ( (fp_in = fopen(*argv, "r")) == NULL )
- error(FATAL, "can't open %s", *argv);
- text();
- if ( fp_in != stdin )
- fclose(fp_in);
- argc--;
- argv++;
- } /* End while */
- } /* End else */
- } /* End of arguments */
- /*****************************************************************************/
- done()
- {
- /*
- *
- * Finished with all the input files, so mark the end of the pages with a TRAILER
- * comment, make sure the last page prints, and add things like the PAGES comment
- * that can only be determined after all the input files have been read.
- *
- */
- fprintf(stdout, "%s", TRAILER);
- fprintf(stdout, "done\n");
- fprintf(stdout, "%s %s\n", DOCUMENTFONTS, fontname);
- fprintf(stdout, "%s %d\n", PAGES, printed);
- } /* End of done */
- /*****************************************************************************/
- account()
- {
- /*
- *
- * Writes an accounting record to *fp_acct provided it's not NULL. Accounting is
- * requested using the -A or -J options.
- *
- */
- if ( fp_acct != NULL )
- fprintf(fp_acct, " print %d\n copies %d\n", printed, copies);
- } /* End of account */
- /*****************************************************************************/
- text()
- {
- int ch; /* next input character */
- /*
- *
- * Translates *fp_in into PostScript. Intercepts space, tab, backspace, newline,
- * return, and formfeed. Everything else goes to oput(), which handles quoting
- * (if needed) and escapes for nonascii characters if extended is TRUE. The
- * redirect(-1) call forces the initial output to go to /dev/null - so stuff
- * that formfeed() does at the end of each page goes to /dev/null rather than
- * the real output file.
- *
- */
- redirect(-1); /* get ready for the first page */
- formfeed(); /* force PAGE comment etc. */
- while ( (ch = getc(fp_in)) != EOF )
- switch ( ch ) {
- case '\n':
- newline();
- break;
- case '\t':
- case '\b':
- case ' ':
- spaces(ch);
- break;
- case '\014':
- formfeed();
- break;
- case '\r':
- if ( crmode == 1 )
- spaces(ch);
- else if ( crmode == 2 )
- newline();
- break;
- default:
- oput(ch);
- break;
- } /* End switch */
- formfeed(); /* next file starts on a new page? */
- } /* End of text */
- /*****************************************************************************/
- formfeed()
- {
- /*
- *
- * Called whenever we've finished with the last page and want to get ready for the
- * next one. Also used at the beginning and end of each input file, so we have to
- * be careful about what's done. The first time through (up to the redirect() call)
- * output goes to /dev/null.
- *
- * Adobe now recommends that the showpage operator occur after the page level
- * restore so it can be easily redefined to have side-effects in the printer's VM.
- * Although it seems reasonable I haven't implemented it, because it makes other
- * things, like selectively setting manual feed or choosing an alternate paper
- * tray, clumsy - at least on a per page basis.
- *
- */
- if ( fp_out == stdout ) /* count the last page */
- printed++;
- endline(); /* print the last line */
- fprintf(fp_out, "cleartomark\n");
- fprintf(fp_out, "showpage\n");
- fprintf(fp_out, "saveobj restore\n");
- fprintf(fp_out, "%s %d %d\n", ENDPAGE, page, printed);
- if ( ungetc(getc(fp_in), fp_in) == EOF )
- redirect(-1);
- else redirect(++page);
- fprintf(fp_out, "%s %d %d\n", PAGE, page, printed+1);
- fprintf(fp_out, "/saveobj save def\n");
- fprintf(fp_out, "mark\n");
- writerequest(printed+1, fp_out);
- fprintf(fp_out, "%d pagesetup\n", printed+1);
- line = 1;
- } /* End of formfeed */
- /*****************************************************************************/
- newline()
- {
- /*
- *
- * Called when we've read a newline character. The call to startline() ensures
- * that at least an empty string is on the stack.
- *
- */
- startline();
- endline(); /* print the current line */
- if ( ++line > linespp ) /* done with this page */
- formfeed();
- } /* End of newline */
- /*****************************************************************************/
- spaces(ch)
- int ch; /* next input character */
- {
- int endcol; /* ending column */
- int i; /* final distance - in spaces */
- /*
- *
- * Counts consecutive spaces, tabs, and backspaces and figures out where the next
- * string should start. Once that's been done we try to choose an efficient way
- * to output the required number of spaces. The choice is between using procedure
- * l with a single string on the stack and L with several string and column pairs.
- * We usually break even, in terms of the size of the output file, if we need four
- * consecutive spaces. More means using L decreases the size of the file. For now
- * if there are less than 6 consecutive spaces we just add them to the current
- * string, otherwise we end that string, follow it by its starting position, and
- * begin a new one that starts at endcol. Backspacing is always handled this way.
- *
- */
- startline(); /* so col makes sense */
- endcol = col;
- do {
- if ( ch == ' ' )
- endcol++;
- else if ( ch == '\t' )
- endcol += tabstops - ((endcol - 1) % tabstops);
- else if ( ch == '\b' )
- endcol--;
- else if ( ch == '\r' )
- endcol = 1;
- else break;
- } while ( ch = getc(fp_in) ); /* if ch is 0 we'd quit anyway */
- ungetc(ch, fp_in); /* wasn't a space, tab, or backspace */
- if ( endcol < 1 ) /* can't move past left edge */
- endcol = 1;
- if ( (i = endcol - col) >= 0 && i < 6 )
- for ( ; i > 0; i-- )
- oput((int)' ');
- else {
- endstring();
- col = stringstart = endcol;
- } /* End else */
- } /* End of spaces */
- /*****************************************************************************/
- startline()
- {
- /*
- *
- * Called whenever we want to be certain we're ready to start pushing characters
- * into an open string on the stack. If stringcount is positive we've already
- * started, so there's nothing to do. The first string starts in column 1.
- *
- */
- if ( stringcount < 1 ) {
- putc('(', fp_out);
- stringstart = col = 1;
- stringcount = 1;
- } /* End if */
- } /* End of startline */
- /*****************************************************************************/
- endstring()
- {
- /*
- *
- * End the current string and start a new one.
- *
- */
- if ( stringcount > 100 ) { /* don't put too much on the stack */
- fprintf(fp_out, ")%d LL\n(", stringstart-1);
- stringcount = 2; /* kludge - don't let endline() use l */
- } else {
- fprintf(fp_out, ")%d(", stringstart-1);
- stringcount++;
- } /* End else */
- } /* End of endstring */
- /*****************************************************************************/
- endline()
- {
- /*
- *
- * Generates a call to the PostScript procedure that processes all the text on
- * the stack - provided stringcount is positive. If one string is on the stack
- * the fast procedure (ie. l) is used to print the line, otherwise the slower
- * one that processes string and column pairs is used.
- *
- */
- if ( stringcount == 1 )
- fprintf(fp_out, ")l\n");
- else if ( stringcount > 1 )
- fprintf(fp_out, ")%d L\n", stringstart-1);
- stringcount = 0;
- } /* End of endline */
- /*****************************************************************************/
- oput(ch)
- int ch; /* next output character */
- {
- /*
- *
- * Responsible for adding all printing characters from the input file to the
- * open string on top of the stack.
- *
- */
- if ( isascii(ch) && isprint(ch) ) {
- startline();
- if ( ch == '(' || ch == ')' || ch == '\\' )
- putc('\\', fp_out);
- putc(ch, fp_out);
- col++;
- } else if ( extended == TRUE ) {
- startline();
- fprintf(fp_out, "\\%.3o", ch & 0377);
- col++;
- } /* End if */
- } /* End of oput */
- /*****************************************************************************/
- redirect(pg)
- int pg; /* next page we're printing */
- {
- static FILE *fp_null = NULL; /* if output is turned off */
- /*
- *
- * If we're not supposed to print page pg, fp_out will be directed to /dev/null,
- * otherwise output goes to stdout.
- *
- */
- if ( pg >= 0 && in_olist(pg) == ON )
- fp_out = stdout;
- else if ( (fp_out = fp_null) == NULL )
- fp_out = fp_null = fopen("/dev/null", "w");
- } /* End of redirect */
- /*****************************************************************************/
|