![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to postprint.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / postscript / postprint|
Return to postprint.c CVS log | Up to [Research Unix] / researchv10no / cmd / postscript / postprint |
1.1 root 1: /*
2: *
3: * postprint - PostScript translator for ASCII files.
4: *
5: * A simple program that translates ASCII files into PostScript. All it really
6: * does is expand tabs and backspaces, handle character quoting, print text lines,
7: * and control when pages are started based on the requested number of lines per
8: * page.
9: *
10: * The PostScript prologue is copied from *prologue before any of the input files
11: * are translated. The program expects that the following procedures are defined
12: * in that file:
13: *
14: * setup
15: *
16: * mark ... setup -
17: *
18: * Handles special initialization stuff that depends on how the program
19: * was called. Expects to find a mark followed by key/value pairs on the
20: * stack. The def operator is applied to each pair up to the mark, then
21: * the default state is set up.
22: *
23: * pagesetup
24: *
25: * page pagesetup -
26: *
27: * Does whatever is needed to set things up for the next page. Expects
28: * to find the current page number on the stack.
29: *
30: * l
31: *
32: * string l -
33: *
34: * Prints string starting in the first column and then goes to the next
35: * line.
36: *
37: * L
38: *
39: * mark string column string column ... L mark
40: *
41: * Prints each string on the stack starting at the horizontal position
42: * selected by column. Used when tabs and spaces can be sufficiently well
43: * compressed to make the printer overhead worthwhile. Always used when
44: * we have to back up.
45: *
46: * LL
47: *
48: * mark string column string column ... LL mark
49: *
50: * Like L, but only used to prevent potential PostScript stack overflow
51: * from too many string/column pairs. Stays on the current line. It will
52: * not be needed often!!
53: *
54: * done
55: *
56: * done
57: *
58: * Makes sure the last page is printed. Only needed when we're printing
59: * more than one page on each sheet of paper.
60: *
61: * Almost everything has been changed in this version of postprint. The program
62: * is more intelligent, especially about tabs, spaces, and backspacing, and as a
63: * result output files usually print faster. Output files also now conform to
64: * Adobe's file structuring conventions, which is undoubtedly something I should
65: * have done in the first version of the program. If the number of lines per page
66: * is set to 0, which can be done using the -l option, pointsize will be used to
67: * guess a reasonable value. The estimate is based on the values of LINESPP,
68: * POINTSIZE, and pointsize, and assumes LINESPP lines would fit on a page if
69: * we printed in size POINTSIZE. Selecting a point size using the -s option and
70: * adding -l0 to the command line forces the guess to be made.
71: *
72: * Many default values, like the magnification and orientation, are defined in
73: * the prologue, which is where they belong. If they're changed (by options), an
74: * appropriate definition is made after the prologue is added to the output file.
75: * The -P option passes arbitrary PostScript through to the output file. Among
76: * other things it can be used to set (or change) values that can't be accessed by
77: * other options.
78: *
79: */
80:
81: #include <stdio.h>
82: #include <signal.h>
83: #include <ctype.h>
84: #include <fcntl.h>
85:
86: #include "comments.h" /* PostScript file structuring comments */
87: #include "gen.h" /* general purpose definitions */
88: #include "path.h" /* for the prologue */
89: #include "ext.h" /* external variable declarations */
90: #include "postprint.h" /* a few special definitions */
91:
92: char *optnames = "a:c:ef:l:m:n:o:p:r:s:t:x:y:A:C:E:J:L:P:R:DI";
93:
94: char *prologue = POSTPRINT; /* default PostScript prologue */
95: char *formfile = FORMFILE; /* stuff for multiple pages per sheet */
96:
97: int formsperpage = 1; /* page images on each piece of paper */
98: int copies = 1; /* and this many copies of each sheet */
99:
100: int linespp = LINESPP; /* number of lines per page */
101: int pointsize = POINTSIZE; /* in this point size */
102: int tabstops = TABSTOPS; /* tabs set at these columns */
103: int crmode = 0; /* carriage return mode - 0, 1, or 2 */
104: int extended = TRUE; /* use escapes for unprintable chars */
105:
106: int col = 1; /* next character goes in this column */
107: int line = 1; /* on this line */
108:
109: int stringcount = 0; /* number of strings on the stack */
110: int stringstart = 1; /* column where current one starts */
111:
112: Fontmap fontmap[] = FONTMAP; /* for translating font names */
113: char *fontname = "Courier"; /* use this PostScript font */
114:
115: int page = 0; /* page we're working on */
116: int printed = 0; /* printed this many pages */
117:
118: FILE *fp_in = stdin; /* read from this file */
119: FILE *fp_out = stdout; /* and write stuff here */
120: FILE *fp_acct = NULL; /* for accounting data */
121:
122: /*****************************************************************************/
123:
124: main(agc, agv)
125:
126: int agc;
127: char *agv[];
128:
129: {
130:
131: /*
132: *
133: * A simple program that translates ASCII files into PostScript. If there's more
134: * than one input file, each begins on a new page.
135: *
136: */
137:
138: argc = agc; /* other routines may want them */
139: argv = agv;
140:
141: prog_name = argv[0]; /* really just for error messages */
142:
143: init_signals(); /* sets up interrupt handling */
144: header(); /* PostScript header and prologue */
145: options(); /* handle the command line options */
146: setup(); /* for PostScript */
147: arguments(); /* followed by each input file */
148: done(); /* print the last page etc. */
149: account(); /* job accounting data */
150:
151: exit(x_stat); /* not much could be wrong */
152:
153: } /* End of main */
154:
155: /*****************************************************************************/
156:
157: init_signals()
158:
159: {
160:
161: /*
162: *
163: * Makes sure we handle interrupts.
164: *
165: */
166:
167: if ( signal(SIGINT, interrupt) == SIG_IGN ) {
168: signal(SIGINT, SIG_IGN);
169: signal(SIGQUIT, SIG_IGN);
170: signal(SIGHUP, SIG_IGN);
171: } else {
172: signal(SIGHUP, interrupt);
173: signal(SIGQUIT, interrupt);
174: } /* End else */
175:
176: signal(SIGTERM, interrupt);
177:
178: } /* End of init_signals */
179:
180: /*****************************************************************************/
181:
182: header()
183:
184: {
185:
186: int ch; /* return value from getopt() */
187: int old_optind = optind; /* for restoring optind - should be 1 */
188:
189: /*
190: *
191: * Scans the option list looking for things, like the prologue file, that we need
192: * right away but could be changed from the default. Doing things this way is an
193: * attempt to conform to Adobe's latest file structuring conventions. In particular
194: * they now say there should be nothing executed in the prologue, and they have
195: * added two new comments that delimit global initialization calls. Once we know
196: * where things really are we write out the job header, follow it by the prologue,
197: * and then add the ENDPROLOG and BEGINSETUP comments.
198: *
199: */
200:
201: while ( (ch = getopt(argc, argv, optnames)) != EOF )
202: if ( ch == 'L' )
203: prologue = optarg;
204: else if ( ch == '?' )
205: error(FATAL, "");
206:
207: optind = old_optind; /* get ready for option scanning */
208:
209: fprintf(stdout, "%s", CONFORMING);
210: fprintf(stdout, "%s %s\n", VERSION, PROGRAMVERSION);
211: fprintf(stdout, "%s %s\n", DOCUMENTFONTS, ATEND);
212: fprintf(stdout, "%s %s\n", PAGES, ATEND);
213: fprintf(stdout, "%s", ENDCOMMENTS);
214:
215: if ( cat(prologue) == FALSE )
216: error(FATAL, "can't read %s", prologue);
217:
218: if ( DOROUND )
219: cat(ROUNDPAGE);
220:
221: fprintf(stdout, "%s", ENDPROLOG);
222: fprintf(stdout, "%s", BEGINSETUP);
223: fprintf(stdout, "mark\n");
224:
225: } /* End of header */
226:
227: /*****************************************************************************/
228:
229: options()
230:
231: {
232:
233: int ch; /* return value from getopt() */
234:
235: /*
236: *
237: * Reads and processes the command line options. Added the -P option so arbitrary
238: * PostScript code can be passed through. Expect it could be useful for changing
239: * definitions in the prologue for which options have not been defined.
240: *
241: * Although any PostScript font can be used, things will only work well for
242: * constant width fonts.
243: *
244: */
245:
246: while ( (ch = getopt(argc, argv, optnames)) != EOF ) {
247: switch ( ch ) {
248:
249: case 'a': /* aspect ratio */
250: fprintf(stdout, "/aspectratio %s def\n", optarg);
251: break;
252:
253: case 'c': /* copies */
254: copies = atoi(optarg);
255: fprintf(stdout, "/#copies %s store\n", optarg);
256: break;
257:
258: case 'e': /* obsolete - it's now always on */
259: extended = TRUE;
260: break;
261:
262: case 'f': /* use this PostScript font */
263: fontname = get_font(optarg);
264: fprintf(stdout, "/font /%s def\n", fontname);
265: break;
266:
267: case 'l': /* lines per page */
268: linespp = atoi(optarg);
269: break;
270:
271: case 'm': /* magnification */
272: fprintf(stdout, "/magnification %s def\n", optarg);
273: break;
274:
275: case 'n': /* forms per page */
276: formsperpage = atoi(optarg);
277: fprintf(stdout, "%s %s\n", FORMSPERPAGE, optarg);
278: fprintf(stdout, "/formsperpage %s def\n", optarg);
279: break;
280:
281: case 'o': /* output page list */
282: out_list(optarg);
283: break;
284:
285: case 'p': /* landscape or portrait mode */
286: if ( *optarg == 'l' )
287: fprintf(stdout, "/landscape true def\n");
288: else fprintf(stdout, "/landscape false def\n");
289: break;
290:
291: case 'r': /* carriage return mode */
292: crmode = atoi(optarg);
293: break;
294:
295: case 's': /* point size */
296: pointsize = atoi(optarg);
297: fprintf(stdout, "/pointsize %s def\n", optarg);
298: break;
299:
300: case 't': /* tabstops */
301: tabstops = atoi(optarg);
302: break;
303:
304: case 'x': /* shift things horizontally */
305: fprintf(stdout, "/xoffset %s def\n", optarg);
306: break;
307:
308: case 'y': /* and vertically on the page */
309: fprintf(stdout, "/yoffset %s def\n", optarg);
310: break;
311:
312: case 'A': /* force job accounting */
313: case 'J':
314: if ( (fp_acct = fopen(optarg, "a")) == NULL )
315: error(FATAL, "can't open accounting file %s", optarg);
316: break;
317:
318: case 'C': /* copy file straight to output */
319: if ( cat(optarg) == FALSE )
320: error(FATAL, "can't read %s", optarg);
321: break;
322:
323: case 'E': /* text font encoding */
324: fontencoding = optarg;
325: break;
326:
327: case 'L': /* PostScript prologue file */
328: prologue = optarg;
329: break;
330:
331: case 'P': /* PostScript pass through */
332: fprintf(stdout, "%s\n", optarg);
333: break;
334:
335: case 'R': /* special global or page level request */
336: saverequest(optarg);
337: break;
338:
339: case 'D': /* debug flag */
340: debug = ON;
341: break;
342:
343: case 'I': /* ignore FATAL errors */
344: ignore = ON;
345: break;
346:
347: case '?': /* don't understand the option */
348: error(FATAL, "");
349: break;
350:
351: default: /* don't know what to do for ch */
352: error(FATAL, "missing case for option %c\n", ch);
353: break;
354: } /* End switch */
355: } /* End while */
356:
357: argc -= optind; /* get ready for non-option args */
358: argv += optind;
359:
360: } /* End of options */
361:
362: /*****************************************************************************/
363:
364: char *get_font(name)
365:
366: char *name; /* name the user asked for */
367:
368: {
369:
370: int i; /* for looking through fontmap[] */
371:
372: /*
373: *
374: * Called from options() to map a user's font name into a legal PostScript name.
375: * If the lookup fails *name is returned to the caller. That should let you choose
376: * any PostScript font, although things will only work well for constant width
377: * fonts.
378: *
379: */
380:
381: for ( i = 0; fontmap[i].name != NULL; i++ )
382: if ( strcmp(name, fontmap[i].name) == 0 )
383: return(fontmap[i].val);
384:
385: return(name);
386:
387: } /* End of get_font */
388:
389: /*****************************************************************************/
390:
391: setup()
392:
393: {
394:
395: /*
396: *
397: * Handles things that must be done after the options are read but before the
398: * input files are processed. linespp (lines per page) can be set using the -l
399: * option. If it's not positive we calculate a reasonable value using the
400: * requested point size - assuming LINESPP lines fit on a page in point size
401: * POINTSIZE.
402: *
403: */
404:
405: writerequest(0, stdout); /* global requests eg. manual feed */
406: setencoding(fontencoding);
407: fprintf(stdout, "setup\n");
408:
409: if ( formsperpage > 1 ) {
410: if ( cat(formfile) == FALSE )
411: error(FATAL, "can't read %s", formfile);
412: fprintf(stdout, "%d setupforms\n", formsperpage);
413: } /* End if */
414:
415: fprintf(stdout, "%s", ENDSETUP);
416:
417: if ( linespp <= 0 )
418: linespp = LINESPP * POINTSIZE / pointsize;
419:
420: } /* End of setup */
421:
422: /*****************************************************************************/
423:
424: arguments()
425:
426: {
427:
428: /*
429: *
430: * Makes sure all the non-option command line arguments are processed. If we get
431: * here and there aren't any arguments left, or if '-' is one of the input files
432: * we'll translate stdin.
433: *
434: */
435:
436: if ( argc < 1 )
437: text();
438: else { /* at least one argument is left */
439: while ( argc > 0 ) {
440: if ( strcmp(*argv, "-") == 0 )
441: fp_in = stdin;
442: else if ( (fp_in = fopen(*argv, "r")) == NULL )
443: error(FATAL, "can't open %s", *argv);
444: text();
445: if ( fp_in != stdin )
446: fclose(fp_in);
447: argc--;
448: argv++;
449: } /* End while */
450: } /* End else */
451:
452: } /* End of arguments */
453:
454: /*****************************************************************************/
455:
456: done()
457:
458: {
459:
460: /*
461: *
462: * Finished with all the input files, so mark the end of the pages with a TRAILER
463: * comment, make sure the last page prints, and add things like the PAGES comment
464: * that can only be determined after all the input files have been read.
465: *
466: */
467:
468: fprintf(stdout, "%s", TRAILER);
469: fprintf(stdout, "done\n");
470: fprintf(stdout, "%s %s\n", DOCUMENTFONTS, fontname);
471: fprintf(stdout, "%s %d\n", PAGES, printed);
472:
473: } /* End of done */
474:
475: /*****************************************************************************/
476:
477: account()
478:
479: {
480:
481: /*
482: *
483: * Writes an accounting record to *fp_acct provided it's not NULL. Accounting is
484: * requested using the -A or -J options.
485: *
486: */
487:
488: if ( fp_acct != NULL )
489: fprintf(fp_acct, " print %d\n copies %d\n", printed, copies);
490:
491: } /* End of account */
492:
493: /*****************************************************************************/
494:
495: text()
496:
497: {
498:
499: int ch; /* next input character */
500:
501: /*
502: *
503: * Translates *fp_in into PostScript. Intercepts space, tab, backspace, newline,
504: * return, and formfeed. Everything else goes to oput(), which handles quoting
505: * (if needed) and escapes for nonascii characters if extended is TRUE. The
506: * redirect(-1) call forces the initial output to go to /dev/null - so stuff
507: * that formfeed() does at the end of each page goes to /dev/null rather than
508: * the real output file.
509: *
510: */
511:
512: redirect(-1); /* get ready for the first page */
513: formfeed(); /* force PAGE comment etc. */
514:
515: while ( (ch = getc(fp_in)) != EOF )
516: switch ( ch ) {
517: case '\n':
518: newline();
519: break;
520:
521: case '\t':
522: case '\b':
523: case ' ':
524: spaces(ch);
525: break;
526:
527: case '\014':
528: formfeed();
529: break;
530:
531: case '\r':
532: if ( crmode == 1 )
533: spaces(ch);
534: else if ( crmode == 2 )
535: newline();
536: break;
537:
538: default:
539: oput(ch);
540: break;
541: } /* End switch */
542:
543: formfeed(); /* next file starts on a new page? */
544:
545: } /* End of text */
546:
547: /*****************************************************************************/
548:
549: formfeed()
550:
551: {
552:
553: /*
554: *
555: * Called whenever we've finished with the last page and want to get ready for the
556: * next one. Also used at the beginning and end of each input file, so we have to
557: * be careful about what's done. The first time through (up to the redirect() call)
558: * output goes to /dev/null.
559: *
560: * Adobe now recommends that the showpage operator occur after the page level
561: * restore so it can be easily redefined to have side-effects in the printer's VM.
562: * Although it seems reasonable I haven't implemented it, because it makes other
563: * things, like selectively setting manual feed or choosing an alternate paper
564: * tray, clumsy - at least on a per page basis.
565: *
566: */
567:
568: if ( fp_out == stdout ) /* count the last page */
569: printed++;
570:
571: endline(); /* print the last line */
572:
573: fprintf(fp_out, "cleartomark\n");
574: fprintf(fp_out, "showpage\n");
575: fprintf(fp_out, "saveobj restore\n");
576: fprintf(fp_out, "%s %d %d\n", ENDPAGE, page, printed);
577:
578: if ( ungetc(getc(fp_in), fp_in) == EOF )
579: redirect(-1);
580: else redirect(++page);
581:
582: fprintf(fp_out, "%s %d %d\n", PAGE, page, printed+1);
583: fprintf(fp_out, "/saveobj save def\n");
584: fprintf(fp_out, "mark\n");
585: writerequest(printed+1, fp_out);
586: fprintf(fp_out, "%d pagesetup\n", printed+1);
587:
588: line = 1;
589:
590: } /* End of formfeed */
591:
592: /*****************************************************************************/
593:
594: newline()
595:
596: {
597:
598: /*
599: *
600: * Called when we've read a newline character. The call to startline() ensures
601: * that at least an empty string is on the stack.
602: *
603: */
604:
605: startline();
606: endline(); /* print the current line */
607:
608: if ( ++line > linespp ) /* done with this page */
609: formfeed();
610:
611: } /* End of newline */
612:
613: /*****************************************************************************/
614:
615: spaces(ch)
616:
617: int ch; /* next input character */
618:
619: {
620:
621: int endcol; /* ending column */
622: int i; /* final distance - in spaces */
623:
624: /*
625: *
626: * Counts consecutive spaces, tabs, and backspaces and figures out where the next
627: * string should start. Once that's been done we try to choose an efficient way
628: * to output the required number of spaces. The choice is between using procedure
629: * l with a single string on the stack and L with several string and column pairs.
630: * We usually break even, in terms of the size of the output file, if we need four
631: * consecutive spaces. More means using L decreases the size of the file. For now
632: * if there are less than 6 consecutive spaces we just add them to the current
633: * string, otherwise we end that string, follow it by its starting position, and
634: * begin a new one that starts at endcol. Backspacing is always handled this way.
635: *
636: */
637:
638: startline(); /* so col makes sense */
639: endcol = col;
640:
641: do {
642: if ( ch == ' ' )
643: endcol++;
644: else if ( ch == '\t' )
645: endcol += tabstops - ((endcol - 1) % tabstops);
646: else if ( ch == '\b' )
647: endcol--;
648: else if ( ch == '\r' )
649: endcol = 1;
650: else break;
651: } while ( ch = getc(fp_in) ); /* if ch is 0 we'd quit anyway */
652:
653: ungetc(ch, fp_in); /* wasn't a space, tab, or backspace */
654:
655: if ( endcol < 1 ) /* can't move past left edge */
656: endcol = 1;
657:
658: if ( (i = endcol - col) >= 0 && i < 6 )
659: for ( ; i > 0; i-- )
660: oput((int)' ');
661: else {
662: endstring();
663: col = stringstart = endcol;
664: } /* End else */
665:
666: } /* End of spaces */
667:
668: /*****************************************************************************/
669:
670: startline()
671:
672: {
673:
674: /*
675: *
676: * Called whenever we want to be certain we're ready to start pushing characters
677: * into an open string on the stack. If stringcount is positive we've already
678: * started, so there's nothing to do. The first string starts in column 1.
679: *
680: */
681:
682: if ( stringcount < 1 ) {
683: putc('(', fp_out);
684: stringstart = col = 1;
685: stringcount = 1;
686: } /* End if */
687:
688: } /* End of startline */
689:
690: /*****************************************************************************/
691:
692: endstring()
693:
694: {
695:
696: /*
697: *
698: * End the current string and start a new one.
699: *
700: */
701:
702: if ( stringcount > 100 ) { /* don't put too much on the stack */
703: fprintf(fp_out, ")%d LL\n(", stringstart-1);
704: stringcount = 2; /* kludge - don't let endline() use l */
705: } else {
706: fprintf(fp_out, ")%d(", stringstart-1);
707: stringcount++;
708: } /* End else */
709:
710: } /* End of endstring */
711:
712: /*****************************************************************************/
713:
714: endline()
715:
716: {
717:
718: /*
719: *
720: * Generates a call to the PostScript procedure that processes all the text on
721: * the stack - provided stringcount is positive. If one string is on the stack
722: * the fast procedure (ie. l) is used to print the line, otherwise the slower
723: * one that processes string and column pairs is used.
724: *
725: */
726:
727: if ( stringcount == 1 )
728: fprintf(fp_out, ")l\n");
729: else if ( stringcount > 1 )
730: fprintf(fp_out, ")%d L\n", stringstart-1);
731:
732: stringcount = 0;
733:
734: } /* End of endline */
735:
736: /*****************************************************************************/
737:
738: oput(ch)
739:
740: int ch; /* next output character */
741:
742: {
743:
744: /*
745: *
746: * Responsible for adding all printing characters from the input file to the
747: * open string on top of the stack.
748: *
749: */
750:
751: if ( isascii(ch) && isprint(ch) ) {
752: startline();
753: if ( ch == '(' || ch == ')' || ch == '\\' )
754: putc('\\', fp_out);
755: putc(ch, fp_out);
756: col++;
757: } else if ( extended == TRUE ) {
758: startline();
759: fprintf(fp_out, "\\%.3o", ch & 0377);
760: col++;
761: } /* End if */
762:
763: } /* End of oput */
764:
765: /*****************************************************************************/
766:
767: redirect(pg)
768:
769: int pg; /* next page we're printing */
770:
771: {
772:
773: static FILE *fp_null = NULL; /* if output is turned off */
774:
775: /*
776: *
777: * If we're not supposed to print page pg, fp_out will be directed to /dev/null,
778: * otherwise output goes to stdout.
779: *
780: */
781:
782: if ( pg >= 0 && in_olist(pg) == ON )
783: fp_out = stdout;
784: else if ( (fp_out = fp_null) == NULL )
785: fp_out = fp_null = fopen("/dev/null", "w");
786:
787: } /* End of redirect */
788:
789: /*****************************************************************************/
790:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.