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