![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Opostdaisy.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / postscript / postdaisy|
Return to Opostdaisy.c CVS log | Up to [Research Unix] / researchv10no / cmd / postscript / postdaisy |
1.1 root 1: /*
2: *
3: * postdaisy - PostScript translator for Diablo 1640 files.
4: *
5: * A program that translates Diablo 1640 files into PostScript. Absolutely nothing
6: * is guaranteed. Quite a few things haven't been implemented, and what's been
7: * done isn't well tested. Most of the documentation used to write this program
8: * was taken from the 'Diablo Emulator' section of a recent Imagen manual.
9: *
10: * Some of document comments that are generated may not be right. Most of the test
11: * files I used produced a trailing blank page. I've put a check in formfeed() that
12: * won't print the last page if it doesn't contain any text, but PAGES comments may
13: * not be right. The DOCUMENTFONTS comment will also be wrong if auto underline or
14: * bold printing have been turned on by escape commands.
15: *
16: * The brute force approach used to implement horizontal and vertical tabs leaves
17: * much to be desired, and may not work for very small initial hmi and vmi values.
18: * At the very least I should have used malloc() to get space for the two tabstop
19: * arrays after hmi and vmi are known!
20: *
21: * Reverse printing mode hasn't been tested at all, but what's here should be
22: * close even though it's not efficient.
23: *
24: * The PostScript prologue is copied from *prologue before any of the input files
25: * are translated. The program expects that the following PostScript procedures
26: * are defined in that file:
27: *
28: * setup
29: *
30: * mark ... setup -
31: *
32: * Handles special initialization stuff that depends on how this program
33: * was called. Expects to find a mark followed by key/value pairs on the
34: * stack. The def operator is applied to each pair up to the mark, then
35: * the default state is set up.
36: *
37: * pagesetup
38: *
39: * page pagesetup -
40: *
41: * Does whatever is needed to set things up for the next page. Expects to
42: * find the current page number on the stack.
43: *
44: * t
45: *
46: * mark str1 x1 str2 x2 ... strn xn y hmi t mark
47: *
48: * Handles all the text on the stack. Characters in the strings are
49: * printed using hmi as the character advance, and all strings are at
50: * vertical position y. Each string is begins at the horizontal position
51: * that preceeds it.
52: *
53: * f
54: *
55: * font f -
56: *
57: * Use font f, where f is the full PostScript font name. Only used when
58: * we switch to auto underline (Courier-Italic) or bold (Courier-Bold)
59: * printing.
60: *
61: * done
62: *
63: * done
64: *
65: * Makes sure the last page is printed. Only needed when we're printing
66: * more than one page on each sheet of paper.
67: *
68: * Many default values, like the magnification and orientation, are defined in
69: * the prologue, which is where they belong. If they're changed (by options), an
70: * appropriate definition is made after the prologue is added to the output file.
71: * The -P option passes arbitrary PostScript through to the output file. Among
72: * other things it can be used to set (or change) values that can't be accessed by
73: * other options.
74: *
75: */
76:
77: #include <stdio.h>
78: #include <signal.h>
79: #include <ctype.h>
80: #include <fcntl.h>
81:
82: #include "comments.h" /* PostScript file structuring comments */
83: #include "gen.h" /* general purpose definitions */
84: #include "path.h" /* for the prologue */
85: #include "ext.h" /* external variable declarations */
86: #include "postdaisy.h" /* a few special definitions */
87:
88: char *optnames = "a:c:f:h:l:m:n:o:p:r:s:v:x:y:A:C:E:J:L:P:DI";
89:
90: char *prologue = POSTDAISY; /* default PostScript prologue */
91: char *formfile = FORMFILE; /* stuff for multiple pages per sheet */
92:
93: int formsperpage = 1; /* page images on each piece of paper */
94: int copies = 1; /* and this many copies of each sheet */
95:
96: char htabstops[COLUMNS]; /* horizontal */
97: char vtabstops[ROWS]; /* and vertical tabs */
98:
99: int res = RES; /* input file resolution - sort of */
100:
101: int hmi = HMI; /* horizontal motion index - 1/120 inch */
102: int vmi = VMI; /* vertical motion index - 1/48 inch */
103: int ohmi = HMI; /* original hmi */
104: int ovmi = VMI; /* and vmi - for tabs and char size */
105:
106: int hpos = 0; /* current horizontal */
107: int vpos = 0; /* and vertical position */
108:
109: int lastx = -1; /* printer's last horizontal */
110: int lasty = -1; /* and vertical position */
111: int lasthmi = -1; /* hmi for current text strings */
112:
113: int lastc = -1; /* last printed character */
114: int prevx = -1; /* at this position */
115:
116: int leftmargin = LEFTMARGIN; /* page margins */
117: int rightmargin = RIGHTMARGIN;
118: int topmargin = TOPMARGIN;
119: int bottommargin = BOTTOMMARGIN;
120:
121: int stringcount = 0; /* number of strings on the stack */
122: int stringstart = 1; /* column where current one starts */
123: int advance = 1; /* -1 if in backward print mode */
124:
125: int lfiscr = OFF; /* line feed implies carriage return */
126: int crislf = OFF; /* carriage return implies line feed */
127:
128: int linespp = 0; /* lines per page if it's positive */
129: int markedpage = FALSE; /* helps prevent trailing blank page */
130: int page = 0; /* page we're working on */
131: int printed = 0; /* printed this many pages */
132:
133: Fontmap fontmap[] = FONTMAP; /* for translating font names */
134: char *fontname = "Courier"; /* use this PostScript font */
135: int shadowprint = OFF; /* automatic bold printing if ON */
136:
137: FILE *fp_in; /* read from this file */
138: FILE *fp_out = stdout; /* and write stuff here */
139: FILE *fp_acct = NULL; /* for accounting data */
140:
141: /*****************************************************************************/
142:
143: main(agc, agv)
144:
145: int agc;
146: char *agv[];
147:
148: {
149:
150: /*
151: *
152: * A simple program that translates Diablo 1640 files into PostScript. Nothing
153: * is guaranteed - the program not well tested and doesn't implement everything.
154: *
155: */
156:
157: argc = agc; /* other routines may want them */
158: argv = agv;
159:
160: prog_name = argv[0]; /* really just for error messages */
161:
162: init_signals(); /* sets up interrupt handling */
163: header(); /* PostScript header comments */
164: options(); /* handle the command line options */
165: setup(); /* for PostScript */
166: arguments(); /* followed by each input file */
167: done(); /* print the last page etc. */
168: account(); /* job accounting data */
169:
170: exit(x_stat); /* not much could be wrong */
171:
172: } /* End of main */
173:
174: /*****************************************************************************/
175:
176: init_signals()
177:
178: {
179:
180: int interrupt(); /* signal handler */
181:
182: /*
183: *
184: * Makes sure we handle interrupts.
185: *
186: */
187:
188: if ( signal(SIGINT, interrupt) == SIG_IGN ) {
189: signal(SIGINT, SIG_IGN);
190: signal(SIGQUIT, SIG_IGN);
191: signal(SIGHUP, SIG_IGN);
192: } else {
193: signal(SIGHUP, interrupt);
194: signal(SIGQUIT, interrupt);
195: } /* End else */
196:
197: signal(SIGTERM, interrupt);
198:
199: } /* End of init_signals */
200:
201: /*****************************************************************************/
202:
203: header()
204:
205: {
206:
207: int ch; /* return value from getopt() */
208: int old_optind = optind; /* for restoring optind - should be 1 */
209:
210: /*
211: *
212: * Scans the option list looking for things, like the prologue file, that we need
213: * right away but could be changed from the default. Doing things this way is an
214: * attempt to conform to Adobe's latest file structuring conventions. In particular
215: * they now say there should be nothing executed in the prologue, and they have
216: * added two new comments that delimit global initialization calls. Once we know
217: * where things really are we write out the job header, follow it by the prologue,
218: * and then add the ENDPROLOG and BEGINSETUP comments.
219: *
220: */
221:
222: while ( (ch = getopt(argc, argv, optnames)) != EOF )
223: if ( ch == 'L' )
224: prologue = optarg;
225: else if ( ch == '?' )
226: error(FATAL, "");
227:
228: optind = old_optind; /* get ready for option scanning */
229:
230: fprintf(stdout, "%s", CONFORMING);
231: fprintf(stdout, "%s %s\n", VERSION, PROGRAMVERSION);
232: fprintf(stdout, "%s %s\n", DOCUMENTFONTS, ATEND);
233: fprintf(stdout, "%s %s\n", PAGES, ATEND);
234: fprintf(stdout, "%s", ENDCOMMENTS);
235:
236: if ( cat(prologue) == FALSE )
237: error(FATAL, "can't read %s", prologue);
238:
239: if ( DOROUND )
240: cat(ROUNDPAGE);
241:
242: fprintf(stdout, "%s", ENDPROLOG);
243: fprintf(stdout, "%s", BEGINSETUP);
244: fprintf(stdout, "mark\n");
245:
246: } /* End of header */
247:
248: /*****************************************************************************/
249:
250: options()
251:
252: {
253:
254: int ch; /* return value from getopt() */
255: int n; /* for CR and LF modes */
256:
257: /*
258: *
259: * Reads and processes the command line options. Added the -P option so arbitrary
260: * PostScript code can be passed through. Expect it could be useful for changing
261: * definitions in the prologue for which options have not been defined.
262: *
263: * Although any PostScript font can be used, things will only work for constant
264: * width fonts.
265: *
266: */
267:
268: while ( (ch = getopt(argc, argv, optnames)) != EOF ) {
269: switch ( ch ) {
270: case 'a': /* aspect ratio */
271: fprintf(stdout, "/aspectratio %s def\n", optarg);
272: break;
273:
274: case 'c': /* copies */
275: copies = atoi(optarg);
276: fprintf(stdout, "/#copies %s store\n", optarg);
277: break;
278:
279: case 'f': /* use this PostScript font */
280: fontname = get_font(optarg);
281: fprintf(stdout, "/font /%s def\n", fontname);
282: break;
283:
284: case 'h': /* default character spacing */
285: ohmi = hmi = atoi(optarg) * HSCALE;
286: fprintf(stdout, "/hmi %s def\n", optarg);
287: break;
288:
289: case 'l': /* lines per page */
290: linespp = atoi(optarg);
291: break;
292:
293: case 'm': /* magnification */
294: fprintf(stdout, "/magnification %s def\n", optarg);
295: break;
296:
297: case 'n': /* forms per page */
298: formsperpage = atoi(optarg);
299: fprintf(stdout, "%s %s\n", FORMSPERPAGE, optarg);
300: fprintf(stdout, "/formsperpage %s def\n", optarg);
301: break;
302:
303: case 'o': /* output page list */
304: out_list(optarg);
305: break;
306:
307: case 'p': /* landscape or portrait mode */
308: if ( *optarg == 'l' )
309: fprintf(stdout, "/landscape true def\n");
310: else fprintf(stdout, "/landscape false def\n");
311: break;
312:
313: case 'r': /* set CR and LF modes */
314: n = atoi(optarg);
315: if ( n & 01 )
316: lfiscr = ON;
317: else lfiscr = OFF;
318: if ( n & 02 )
319: crislf = ON;
320: else crislf = OFF;
321: break;
322:
323: case 's': /* point size */
324: fprintf(stdout, "/pointsize %s def\n", optarg);
325: break;
326:
327: case 'v': /* default line spacing */
328: ovmi = vmi = atoi(optarg) * VSCALE;
329: break;
330:
331: case 'x': /* shift things horizontally */
332: fprintf(stdout, "/xoffset %s def\n", optarg);
333: break;
334:
335: case 'y': /* and vertically on the page */
336: fprintf(stdout, "/yoffset %s def\n", optarg);
337: break;
338:
339: case 'A': /* force job accounting */
340: case 'J':
341: if ( (fp_acct = fopen(optarg, "a")) == NULL )
342: error(FATAL, "can't open accounting file %s", optarg);
343: break;
344:
345: case 'C': /* copy file straight to output */
346: if ( cat(optarg) == FALSE )
347: error(FATAL, "can't read %s", optarg);
348: break;
349:
350: case 'E': /* text font encoding */
351: fontencoding = optarg;
352: break;
353:
354: case 'L': /* PostScript prologue file */
355: prologue = optarg;
356: break;
357:
358: case 'P': /* PostScript pass through */
359: fprintf(stdout, "%s\n", optarg);
360: break;
361:
362: case 'R': /* special global or page level request */
363: saverequest(optarg);
364: break;
365:
366: case 'D': /* debug flag */
367: debug = ON;
368: break;
369:
370: case 'I': /* ignore FATAL errors */
371: ignore = ON;
372: break;
373:
374: case '?': /* don't understand the option */
375: error(FATAL, "");
376: break;
377:
378: default: /* don't know what to do for ch */
379: error(FATAL, "missing case for option %c\n", ch);
380: break;
381: } /* End switch */
382: } /* End while */
383:
384: argc -= optind; /* get ready for non-option args */
385: argv += optind;
386:
387: } /* End of options */
388:
389: /*****************************************************************************/
390:
391: char *get_font(name)
392:
393: char *name; /* name the user asked for */
394:
395: {
396:
397: int i; /* for looking through fontmap[] */
398:
399: /*
400: *
401: * Called from options() to map a user's font name into a legal PostScript name.
402: * If the lookup fails *name is returned to the caller. That should let you choose
403: * any PostScript font, although things will only work well for constant width
404: * fonts.
405: *
406: */
407:
408: for ( i = 0; fontmap[i].name != NULL; i++ )
409: if ( strcmp(name, fontmap[i].name) == 0 )
410: return(fontmap[i].val);
411:
412: return(name);
413:
414: } /* End of get_font */
415:
416: /*****************************************************************************/
417:
418: setup()
419:
420: {
421:
422: /*
423: *
424: * Handles things that must be done after the options are read but before the
425: * input files are processed.
426: *
427: */
428:
429: writerequest(0, stdout); /* global requests eg. manual feed */
430: setencoding(fontencoding);
431: fprintf(stdout, "setup\n");
432:
433: if ( formsperpage > 1 ) {
434: if ( cat(formfile) == FALSE )
435: error(FATAL, "can't read %s", formfile);
436: fprintf(stdout, "%d setupforms\n", formsperpage);
437: } /* End if */
438:
439: fprintf(stdout, "%s", ENDSETUP);
440:
441: } /* End of setup */
442:
443: /*****************************************************************************/
444:
445: arguments()
446:
447: {
448:
449: /*
450: *
451: * Makes sure all the non-option command line arguments are processed. If we get
452: * here and there aren't any arguments left, or if '-' is one of the input files
453: * we'll process stdin.
454: *
455: */
456:
457: fp_in = stdin;
458:
459: if ( argc < 1 )
460: text();
461: else { /* at least one argument is left */
462: while ( argc > 0 ) {
463: if ( strcmp(*argv, "-") == 0 )
464: fp_in = stdin;
465: else if ( (fp_in = fopen(*argv, "r")) == NULL )
466: error(FATAL, "can't open %s", *argv);
467: text();
468: if ( fp_in != stdin )
469: fclose(fp_in);
470: argc--;
471: argv++;
472: } /* End while */
473: } /* End else */
474:
475: } /* End of arguments */
476:
477: /*****************************************************************************/
478:
479: done()
480:
481: {
482:
483: /*
484: *
485: * Finished with all the input files, so mark the end of the pages, make sure the
486: * last page is printed, and restore the initial environment.
487: *
488: */
489:
490: fprintf(stdout, "%s", TRAILER);
491: fprintf(stdout, "done\n");
492: fprintf(stdout, "%s %s\n", DOCUMENTFONTS, fontname);
493: fprintf(stdout, "%s %d\n", PAGES, printed);
494:
495: } /* End of done */
496:
497: /*****************************************************************************/
498:
499: account()
500:
501: {
502:
503: /*
504: *
505: * Writes an accounting record to *fp_acct provided it's not NULL. Accounting
506: * is requested using the -A or -J options.
507: *
508: */
509:
510: if ( fp_acct != NULL )
511: fprintf(fp_acct, " print %d\n copies %d\n", printed, copies);
512:
513: } /* End of account */
514:
515: /*****************************************************************************/
516:
517: text()
518:
519: {
520:
521: int ch; /* next input character */
522:
523: /*
524: *
525: * Translates the next input file into PostScript. The redirect(-1) call forces
526: * the initial output to go to /dev/null - so the stuff formfeed() does at the
527: * end of each page doesn't go to stdout.
528: *
529: */
530:
531: redirect(-1); /* get ready for the first page */
532: formfeed(); /* force PAGE comment etc. */
533: inittabs();
534:
535: while ( (ch = getc(fp_in)) != EOF )
536: switch ( ch ) {
537: case '\010': /* backspace */
538: backspace();
539: break;
540:
541: case '\011': /* horizontal tab */
542: htab();
543: break;
544:
545: case '\012': /* new line */
546: linefeed();
547: break;
548:
549: case '\013': /* vertical tab */
550: vtab();
551: break;
552:
553: case '\014': /* form feed */
554: formfeed();
555: break;
556:
557: case '\015': /* carriage return */
558: carriage();
559: break;
560:
561: case '\016': /* extended character set - SO */
562: break;
563:
564: case '\017': /* extended character set - SI */
565: break;
566:
567: case '\031': /* next char from supplementary set */
568: break;
569:
570: case '\033': /* 2 or 3 byte escape sequence */
571: escape();
572: break;
573:
574: default:
575: if ( isascii(ch) && isprint(ch) )
576: oput(ch);
577: break;
578: } /* End switch */
579:
580: formfeed(); /* next file starts on a new page? */
581:
582: } /* End of text */
583:
584: /*****************************************************************************/
585:
586: inittabs()
587:
588: {
589:
590: int i; /* loop index */
591:
592: /*
593: *
594: * Initializes the horizontal and vertical tab arrays. The way tabs are handled is
595: * quite inefficient and may not work for all initial hmi or vmi values.
596: *
597: */
598:
599: for ( i = 0; i < COLUMNS; i++ )
600: htabstops[i] = ((i % 8) == 0) ? ON : OFF;
601:
602: for ( i = 0; i < ROWS; i++ )
603: vtabstops[i] = ((i * ovmi) > BOTTOMMARGIN) ? ON : OFF;
604:
605: } /* End of inittabs */
606:
607: /*****************************************************************************/
608:
609: cleartabs()
610:
611: {
612:
613: int i; /* loop index */
614:
615: /*
616: *
617: * Clears all horizontal and vertical tab stops.
618: *
619: */
620:
621: for ( i = 0; i < ROWS; i++ )
622: htabstops[i] = OFF;
623:
624: for ( i = 0; i < COLUMNS; i++ )
625: vtabstops[i] = OFF;
626:
627: } /* End of cleartabs */
628:
629: /*****************************************************************************/
630:
631: formfeed()
632:
633: {
634:
635: /*
636: *
637: * Called whenever we've finished with the last page and want to get ready for the
638: * next one. Also used at the beginning and end of each input file, so we have to
639: * be careful about what's done. I've added a simple test before the showpage that
640: * should eliminate the extra blank page that was put out at the end of many jobs,
641: * but the PAGES comments may be wrong.
642: *
643: */
644:
645: if ( fp_out == stdout ) /* count the last page */
646: printed++;
647:
648: endline(); /* print the last line */
649:
650: fprintf(fp_out, "cleartomark\n");
651: if ( feof(fp_in) == 0 || markedpage == TRUE )
652: fprintf(fp_out, "showpage\n");
653: fprintf(fp_out, "saveobj restore\n");
654: fprintf(fp_out, "%s %d %d\n", ENDPAGE, page, printed);
655:
656: if ( ungetc(getc(fp_in), fp_in) == EOF )
657: redirect(-1);
658: else redirect(++page);
659:
660: fprintf(fp_out, "%s %d %d\n", PAGE, page, printed+1);
661: fprintf(fp_out, "/saveobj save def\n");
662: fprintf(fp_out, "mark\n");
663: writerequest(printed+1, fp_out);
664: fprintf(fp_out, "%d pagesetup\n", printed+1);
665:
666: vgoto(topmargin);
667: hgoto(leftmargin);
668:
669: markedpage = FALSE;
670:
671: } /* End of formfeed */
672:
673: /*****************************************************************************/
674:
675: linefeed()
676:
677: {
678:
679: int line = 0; /* current line - based on ovmi */
680:
681: /*
682: *
683: * Adjust our current vertical position. If we've passed the bottom of the page
684: * or exceeded the number of lines per page, print it and go to the upper left
685: * corner of the next page. This routine is also called from carriage() if crislf
686: * is ON.
687: *
688: */
689:
690: vmot(vmi);
691:
692: if ( lfiscr == ON )
693: hgoto(leftmargin);
694:
695: if ( linespp > 0 ) /* means something so see where we are */
696: line = vpos / ovmi + 1;
697:
698: if ( vpos > bottommargin || line > linespp )
699: formfeed();
700:
701: } /* End of linefeed */
702:
703: /*****************************************************************************/
704:
705: carriage()
706:
707: {
708:
709: /*
710: *
711: * Handles carriage return character. If crislf is ON we'll generate a line feed
712: * every time we get a carriage return character.
713: *
714: */
715:
716: if ( shadowprint == ON ) /* back to normal mode */
717: changefont(fontname);
718:
719: advance = 1;
720: shadowprint = OFF;
721:
722: hgoto(leftmargin);
723:
724: if ( crislf == ON )
725: linefeed();
726:
727: } /* End of carriage */
728:
729: /*****************************************************************************/
730:
731: htab()
732:
733: {
734:
735: int col; /* 'column' we'll be at next */
736: int i; /* loop index */
737:
738: /*
739: *
740: * Tries to figure out where the next tab stop is. Wasn't positive about this
741: * one, since hmi can change. I'll assume columns are determined by the original
742: * value of hmi. That fixes them on the page, which seems to make more sense than
743: * letting them float all over the place.
744: *
745: */
746:
747: endline();
748:
749: col = hpos/ohmi + 1;
750: for ( i = col; i < ROWS; i++ )
751: if ( htabstops[i] == ON ) {
752: col = i;
753: break;
754: } /* End if */
755:
756: hgoto(col * ohmi);
757: lastx = hpos;
758:
759: } /* End of htab */
760:
761: /*****************************************************************************/
762:
763: vtab()
764:
765: {
766:
767: int line; /* line we'll be at next */
768: int i; /* loop index */
769:
770: /*
771: *
772: * Looks for the next vertical tab stop in the vtabstops[] array and moves to that
773: * line. If we don't find a tab we'll just move down one line - shouldn't happen.
774: *
775: */
776:
777: endline();
778:
779: line = vpos/ovmi + 1;
780: for ( i = line; i < COLUMNS; i++ )
781: if ( vtabstops[i] == ON ) {
782: line = i;
783: break;
784: } /* End if */
785:
786: vgoto(line * ovmi);
787:
788: } /* End of vtab */
789:
790: /*****************************************************************************/
791:
792: backspace()
793:
794: {
795:
796: /*
797: *
798: * Moves backwards a distance equal to the current value of hmi, but don't go
799: * past the left margin.
800: *
801: */
802:
803: endline();
804:
805: if ( hpos - leftmargin >= hmi )
806: hmot(-hmi);
807: else hgoto(leftmargin); /* maybe just ignore the backspace?? */
808:
809: lastx = hpos;
810:
811: } /* End of backspace */
812:
813: /*****************************************************************************/
814:
815: escape()
816:
817: {
818:
819: int ch; /* control character */
820:
821: /*
822: *
823: * Handles special codes that are expected to follow an escape character. The
824: * initial escape character is followed by one or two bytes.
825: *
826: */
827:
828: switch ( ch = getc(fp_in) ) {
829: case 'T': /* top margin */
830: topmargin = vpos;
831: break;
832:
833: case 'L': /* bottom margin */
834: bottommargin = vpos;
835: break;
836:
837: case 'C': /* clear top and bottom margins */
838: bottommargin = BOTTOMMARGIN;
839: topmargin = TOPMARGIN;
840: break;
841:
842: case '9': /* left margin */
843: leftmargin = hpos;
844: break;
845:
846: case '0': /* right margin */
847: rightmargin = hpos;
848: break;
849:
850: case '1': /* set horizontal tab */
851: htabstops[hpos/ohmi] = ON;
852: break;
853:
854: case '8': /* clear horizontal tab at hpos */
855: htabstops[hpos/ohmi] = OFF;
856: break;
857:
858: case '-': /* set vertical tab */
859: vtabstops[vpos/ovmi] = ON;
860: break;
861:
862: case '2': /* clear all tabs */
863: cleartabs();
864: break;
865:
866: case '\014': /* set lines per page */
867: linespp = getc(fp_in);
868: break;
869:
870: case '\037': /* set hmi to next byte minus 1 */
871: hmi = HSCALE * (getc(fp_in) - 1);
872: break;
873:
874: case 'S': /* reset hmi to default */
875: hmi = ohmi;
876: break;
877:
878: case '\011': /* move to column given by next byte */
879: hgoto((getc(fp_in)-1) * ohmi);
880: break;
881:
882: case '?': /* do carriage return after line feed */
883: lfiscr = ON;
884: break;
885:
886: case '!': /* don't generate carriage return */
887: lfiscr = OFF;
888: break;
889:
890: case '5': /* forward print mode */
891: advance = 1;
892: break;
893:
894: case '6': /* backward print mode */
895: advance = -1;
896: break;
897:
898: case '\036': /* set vmi to next byte minus 1 */
899: vmi = VSCALE * (getc(fp_in) - 1);
900: break;
901:
902: case '\013': /* move to line given by next byte */
903: vgoto((getc(fp_in)-1) * ovmi);
904: break;
905:
906: case 'U': /* positive half line feed */
907: vmot(vmi/2);
908: break;
909:
910: case 'D': /* negative half line feed */
911: vmot(-vmi/2);
912: break;
913:
914: case '\012': /* negative line feed */
915: vmot(-vmi);
916: break;
917:
918: case '\015': /* clear all margins */
919: bottommargin = BOTTOMMARGIN;
920: topmargin = TOPMARGIN;
921: leftmargin = BOTTOMMARGIN;
922: rightmargin = RIGHTMARGIN;
923: break;
924:
925: case 'E': /* auto underscore - use italic font */
926: changefont("/Courier-Oblique");
927: break;
928:
929: case 'R': /* disable auto underscore */
930: changefont(fontname);
931: break;
932:
933: case 'O': /* bold/shadow printing */
934: case 'W':
935: changefont("/Courier-Bold");
936: shadowprint = ON;
937: break;
938:
939: case '&': /* disable bold printing */
940: changefont(fontname);
941: shadowprint = OFF;
942: break;
943:
944: case '/': /* ignored 2 byte escapes */
945: case '\\':
946: case '<':
947: case '>':
948: case '%':
949: case '=':
950: case '.':
951: case '4':
952: case 'A':
953: case 'B':
954: case 'M':
955: case 'N':
956: case 'P':
957: case 'Q':
958: case 'X':
959: case '\010':
960: break;
961:
962: case ',': /* ignored 3 byte escapes */
963: case '\016':
964: case '\021':
965: getc(fp_in);
966: break;
967:
968: case '3': /* graphics mode - should quit! */
969: case '7':
970: case 'G':
971: case 'V':
972: case 'Y':
973: case 'Z':
974: error(FATAL, "graphics mode is not implemented");
975: break;
976:
977: default:
978: error(FATAL, "missing case for escape o%o\n", ch);
979: break;
980: } /* End switch */
981:
982: } /* End of escape */
983:
984: /*****************************************************************************/
985:
986: vmot(n)
987:
988: int n; /* move this far vertically */
989:
990: {
991:
992: /*
993: *
994: * Move vertically n units from where we are.
995: *
996: */
997:
998: vpos += n;
999:
1000: } /* End of vmot */
1001:
1002: /*****************************************************************************/
1003:
1004: vgoto(n)
1005:
1006: int n; /* new vertical position */
1007:
1008: {
1009:
1010: /*
1011: *
1012: * Moves to absolute vertical position n.
1013: *
1014: */
1015:
1016: vpos = n;
1017:
1018: } /* End of vgoto */
1019:
1020: /*****************************************************************************/
1021:
1022: hmot(n)
1023:
1024: int n; /* move this horizontally */
1025:
1026: {
1027:
1028: /*
1029: *
1030: * Moves horizontally n units from our current position.
1031: *
1032: */
1033:
1034: hpos += n * advance;
1035:
1036: if ( hpos < leftmargin )
1037: hpos = leftmargin;
1038:
1039: } /* End of hmot */
1040:
1041: /*****************************************************************************/
1042:
1043: hgoto(n)
1044:
1045: int n; /* go to this horizontal position */
1046:
1047: {
1048:
1049: /*
1050: *
1051: * Moves to absolute horizontal position n.
1052: *
1053: */
1054:
1055: hpos = n;
1056:
1057: } /* End of hgoto */
1058:
1059: /*****************************************************************************/
1060:
1061: changefont(name)
1062:
1063: char *name;
1064:
1065: {
1066:
1067: /*
1068: *
1069: * Changes the current font. Used to get in and out of auto underscore and bold
1070: * printing.
1071: *
1072: */
1073:
1074: endline();
1075: fprintf(fp_out, "%s f\n", name);
1076:
1077: } /* End of changefont */
1078:
1079: /*****************************************************************************/
1080:
1081: startline()
1082:
1083: {
1084:
1085: /*
1086: *
1087: * Called whenever we want to be certain we're ready to start pushing characters
1088: * into an open string on the stack. If stringcount is positive we've already
1089: * started, so there's nothing to do. The first string starts in column 1.
1090: *
1091: */
1092:
1093: if ( stringcount < 1 ) {
1094: putc('(', fp_out);
1095: stringstart = lastx = hpos;
1096: lasty = vpos;
1097: lasthmi = hmi;
1098: lastc = -1;
1099: prevx = -1;
1100: stringcount = 1;
1101: } /* End if */
1102:
1103: } /* End of startline */
1104:
1105: /*****************************************************************************/
1106:
1107: endline()
1108:
1109: {
1110:
1111: /*
1112: *
1113: * Generates a call to the PostScript procedure that processes the text on the
1114: * the stack - provided stringcount is positive.
1115: *
1116: */
1117:
1118: if ( stringcount > 0 )
1119: fprintf(fp_out, ")%d %d %d t\n", stringstart, lasty, lasthmi);
1120:
1121: stringcount = 0;
1122:
1123: } /* End of endline */
1124:
1125: /*****************************************************************************/
1126:
1127: endstring()
1128:
1129: {
1130:
1131: /*
1132: *
1133: * Takes the string we've been working on and adds it to the output file. Called
1134: * when we need to adjust our horizontal position before starting a new string.
1135: * Also called from endline() when we're done with the current line.
1136: *
1137: */
1138:
1139: if ( stringcount > 0 ) {
1140: fprintf(fp_out, ")%d(", stringstart);
1141: lastx = stringstart = hpos;
1142: stringcount++;
1143: } /* End if */
1144:
1145: } /* End of endstring */
1146:
1147: /*****************************************************************************/
1148:
1149: oput(ch)
1150:
1151: int ch; /* next output character */
1152:
1153: {
1154:
1155: /*
1156: *
1157: * Responsible for adding all printing characters from the input file to the
1158: * open string on top of the stack. The only other characters that end up in
1159: * that string are the quotes required for special characters. Reverse printing
1160: * mode hasn't been tested but it should be close. hpos and lastx should disagree
1161: * each time (except after startline() does something), and that should force a
1162: * call to endstring() for every character.
1163: *
1164: */
1165:
1166: if ( stringcount > 100 ) /* don't put too much on the stack */
1167: endline();
1168:
1169: if ( vpos != lasty )
1170: endline();
1171:
1172: if ( advance == -1 ) /* for reverse printing - move first */
1173: hmot(hmi);
1174:
1175: startline();
1176:
1177: if ( lastc != ch || hpos != prevx ) {
1178: if ( lastx != hpos )
1179: endstring();
1180:
1181: if ( ch == '\\' || ch == '(' || ch == ')' )
1182: putc('\\', fp_out);
1183: putc(ch, fp_out);
1184:
1185: lastc = ch;
1186: prevx = hpos;
1187: lastx += lasthmi;
1188: } /* End if */
1189:
1190: if ( advance != -1 )
1191: hmot(hmi);
1192:
1193: markedpage = TRUE;
1194:
1195: } /* End of oput */
1196:
1197: /*****************************************************************************/
1198:
1199: redirect(pg)
1200:
1201: int pg; /* next page we're printing */
1202:
1203: {
1204:
1205: static FILE *fp_null = NULL; /* if output is turned off */
1206:
1207: /*
1208: *
1209: * If we're not supposed to print page pg, fp_out will be directed to /dev/null,
1210: * otherwise output goes to stdout.
1211: *
1212: */
1213:
1214: if ( pg >= 0 && in_olist(pg) == ON )
1215: fp_out = stdout;
1216: else if ( (fp_out = fp_null) == NULL )
1217: fp_out = fp_null = fopen("/dev/null", "w");
1218:
1219: } /* End of redirect */
1220:
1221: /*****************************************************************************/
1222:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.