![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to posttek.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / postscript / posttek|
Return to posttek.c CVS log | Up to [Research Unix] / researchv10no / cmd / postscript / posttek |
1.1 root 1: /*
2: *
3: * posttek - PostScript translator for tektronix 4014 files
4: *
5: * A program that can be used to translate tektronix 4014 files into PostScript.
6: * Most of the code was borrowed from the tektronix 4014 emulator that was written
7: * for DMDs. Things have been cleaned up some, but there's still plently that
8: * could be done.
9: *
10: * The PostScript prologue is copied from *prologue before any of the input files
11: * are translated. The program expects that the following PostScript procedures
12: * are defined 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: * v
31: *
32: * mark dx1 dy1 ... dxn dyn x y v mark
33: *
34: * Draws the vector described by the numbers on the stack. The top two
35: * numbers are the starting point. The rest are relative displacements
36: * from the preceeding point. Must make sure we don't put too much on
37: * the stack!
38: *
39: * t
40: *
41: * x y string t -
42: *
43: * Prints the string that's on the top of the stack starting at point
44: * (x, y).
45: *
46: * p
47: *
48: * x y p -
49: *
50: * Marks the point (x, y) with a circle whose radius varies with the
51: * current intensity setting.
52: *
53: * i
54: *
55: * percent focus i -
56: *
57: * Changes the size of the circle used to mark individual points to
58: * percent of maximum for focused mode (focus=1) or defocused mode
59: * (focus=0). The implementation leaves much to be desired!
60: *
61: * l
62: *
63: * mark array l mark
64: *
65: * Set the line drawing mode according to the description given in array.
66: * The arrays that describe the different line styles are declared in
67: * STYLES (file posttek.h). The array really belongs in the prologue!
68: *
69: * w
70: *
71: * n w -
72: *
73: * Adjusts the line width for vector drawing. Used to select normal (n=0)
74: * or defocused (n=1) mode.
75: *
76: * f
77: *
78: * size f -
79: *
80: * Changes the size of the font that's used to print characters in alpha
81: * mode. size is the tektronix character width and is used to choose an
82: * appropriate point size in the current font.
83: *
84: * done
85: *
86: * done
87: *
88: * Makes sure the last page is printed. Only needed when we're printing
89: * more than one page on each sheet of paper.
90: *
91: * The default line width is zero, which forces lines to be one pixel wide. That
92: * works well on 'write to black' engines but won't be right for 'write to white'
93: * engines. The line width can be changed using the -w option, or you can change
94: * the initialization of linewidth in the prologue.
95: *
96: * Many default values, like the magnification and orientation, are defined in
97: * the prologue, which is where they belong. If they're changed (by options), an
98: * appropriate definition is made after the prologue is added to the output file.
99: * The -P option passes arbitrary PostScript through to the output file. Among
100: * other things it can be used to set (or change) values that can't be accessed by
101: * other options.
102: *
103: */
104:
105: #include <stdio.h>
106: #include <signal.h>
107: #include <fcntl.h>
108:
109: #include "comments.h" /* PostScript file structuring comments */
110: #include "gen.h" /* general purpose definitions */
111: #include "path.h" /* for the prologue */
112: #include "ext.h" /* external variable definitions */
113: #include "posttek.h" /* control codes and other definitions */
114:
115: char *optnames = "a:c:f:m:n:o:p:w:x:y:A:C:E:J:L:P:R:DI";
116:
117: char *prologue = POSTTEK; /* default PostScript prologue */
118: char *formfile = FORMFILE; /* stuff for multiple pages per sheet */
119:
120: int formsperpage = 1; /* page images on each piece of paper */
121: int copies = 1; /* and this many copies of each sheet */
122:
123: int charheight[] = CHARHEIGHT; /* height */
124: int charwidth[] = CHARWIDTH; /* and width arrays for tek characters */
125: int tekfont = TEKFONT; /* index into charheight[] and charwidth[] */
126:
127: char intensity[] = INTENSITY; /* special point intensity array */
128: char *styles[] = STYLES; /* description of line styles */
129: int linestyle = 0; /* index into styles[] */
130: int linetype = 0; /* 0 for normal, 1 for defocused */
131:
132: int dispmode = ALPHA; /* current tektronix state */
133: int points = 0; /* points making up the current vector */
134: int characters = 0; /* characters waiting to be printed */
135: int pen = UP; /* just for point plotting */
136: int margin = 0; /* left edge - ALPHA state */
137:
138: Point cursor; /* should be current cursor position */
139:
140: Fontmap fontmap[] = FONTMAP; /* for translating font names */
141: char *fontname = "Courier"; /* use this PostScript font */
142:
143: int page = 0; /* page we're working on */
144: int printed = 0; /* printed this many pages */
145:
146: FILE *fp_in; /* read from this file */
147: FILE *fp_out = stdout; /* and write stuff here */
148: FILE *fp_acct = NULL; /* for accounting data */
149:
150: /*****************************************************************************/
151:
152: main(agc, agv)
153:
154: int agc;
155: char *agv[];
156:
157: {
158:
159: /*
160: *
161: * A simple program that can be used to translate tektronix 4014 files into
162: * PostScript. Most of the code was taken from the DMD tektronix 4014 emulator,
163: * although things have been cleaned up some.
164: *
165: */
166:
167: argv = agv; /* so everyone can use them */
168: argc = agc;
169:
170: prog_name = argv[0]; /* just for error messages */
171:
172: init_signals(); /* sets up interrupt handling */
173: header(); /* PostScript header comments */
174: options(); /* handle the command line options */
175: setup(); /* for PostScript */
176: arguments(); /* followed by each input file */
177: done(); /* print the last page etc. */
178: account(); /* job accounting data */
179:
180: exit(x_stat); /* nothing could be wrong */
181:
182: } /* End of main */
183:
184: /*****************************************************************************/
185:
186: init_signals()
187:
188: {
189:
190: /*
191: *
192: * Make sure we handle interrupts.
193: *
194: */
195:
196: if ( signal(SIGINT, interrupt) == SIG_IGN ) {
197: signal(SIGINT, SIG_IGN);
198: signal(SIGQUIT, SIG_IGN);
199: signal(SIGHUP, SIG_IGN);
200: } else {
201: signal(SIGHUP, interrupt);
202: signal(SIGQUIT, interrupt);
203: } /* End else */
204:
205: signal(SIGTERM, interrupt);
206:
207: } /* End of init_signals */
208:
209: /*****************************************************************************/
210:
211: header()
212:
213: {
214:
215: int ch; /* return value from getopt() */
216: int old_optind = optind; /* for restoring optind - should be 1 */
217:
218: /*
219: *
220: * Scans the option list looking for things, like the prologue file, that we need
221: * right away but could be changed from the default. Doing things this way is an
222: * attempt to conform to Adobe's latest file structuring conventions. In particular
223: * they now say there should be nothing executed in the prologue, and they have
224: * added two new comments that delimit global initialization calls. Once we know
225: * where things really are we write out the job header, follow it by the prologue,
226: * and then add the ENDPROLOG and BEGINSETUP comments.
227: *
228: */
229:
230: while ( (ch = getopt(argc, argv, optnames)) != EOF )
231: if ( ch == 'L' )
232: prologue = optarg;
233: else if ( ch == '?' )
234: error(FATAL, "");
235:
236: optind = old_optind; /* get ready for option scanning */
237:
238: fprintf(stdout, "%s", CONFORMING);
239: fprintf(stdout, "%s %s\n", VERSION, PROGRAMVERSION);
240: fprintf(stdout, "%s %s\n", DOCUMENTFONTS, ATEND);
241: fprintf(stdout, "%s %s\n", PAGES, ATEND);
242: fprintf(stdout, "%s", ENDCOMMENTS);
243:
244: if ( cat(prologue) == FALSE )
245: error(FATAL, "can't read %s", prologue);
246:
247: fprintf(stdout, "%s", ENDPROLOG);
248: fprintf(stdout, "%s", BEGINSETUP);
249: fprintf(stdout, "mark\n");
250:
251: } /* End of header */
252:
253: /*****************************************************************************/
254:
255: options()
256:
257: {
258:
259: int ch; /* value returned by getopt() */
260:
261: /*
262: *
263: * Reads and processes the command line options. Added the -P option so arbitrary
264: * PostScript code can be passed through. Expect it could be useful for changing
265: * definitions in the prologue for which options have not been defined.
266: *
267: */
268:
269: while ( (ch = getopt(argc, argv, optnames)) != EOF ) {
270: switch ( ch ) {
271: case 'a': /* aspect ratio */
272: fprintf(stdout, "/aspectratio %s def\n", optarg);
273: break;
274:
275: case 'c': /* copies */
276: copies = atoi(optarg);
277: fprintf(stdout, "/#copies %s store\n", optarg);
278: break;
279:
280: case 'f': /* use this PostScript font */
281: fontname = get_font(optarg);
282: fprintf(stdout, "/font /%s def\n", fontname);
283: break;
284:
285: case 'm': /* magnification */
286: fprintf(stdout, "/magnification %s def\n", optarg);
287: break;
288:
289: case 'n': /* forms per page */
290: formsperpage = atoi(optarg);
291: fprintf(stdout, "%s %s\n", FORMSPERPAGE, optarg);
292: fprintf(stdout, "/formsperpage %s def\n", optarg);
293: break;
294:
295: case 'o': /* output page list */
296: out_list(optarg);
297: break;
298:
299: case 'p': /* landscape or portrait mode */
300: if ( *optarg == 'l' )
301: fprintf(stdout, "/landscape true def\n");
302: else fprintf(stdout, "/landscape false def\n");
303: break;
304:
305: case 'w': /* line width */
306: fprintf(stdout, "/linewidth %s def\n", optarg);
307: break;
308:
309: case 'x': /* shift horizontally */
310: fprintf(stdout, "/xoffset %s def\n", optarg);
311: break;
312:
313: case 'y': /* and vertically on the page */
314: fprintf(stdout, "/yoffset %s def\n", optarg);
315: break;
316:
317: case 'A': /* force job accounting */
318: case 'J':
319: if ( (fp_acct = fopen(optarg, "a")) == NULL )
320: error(FATAL, "can't open accounting file %s", optarg);
321: break;
322:
323: case 'C': /* copy file straight to output */
324: if ( cat(optarg) == FALSE )
325: error(FATAL, "can't read %s", optarg);
326: break;
327:
328: case 'E': /* text font encoding */
329: fontencoding = optarg;
330: break;
331:
332: case 'L': /* PostScript prologue file */
333: prologue = optarg;
334: break;
335:
336: case 'P': /* PostScript pass through */
337: fprintf(stdout, "%s\n", optarg);
338: break;
339:
340: case 'R': /* special global or page level request */
341: saverequest(optarg);
342: break;
343:
344: case 'D': /* debug flag */
345: debug = ON;
346: break;
347:
348: case 'I': /* ignore FATAL errors */
349: ignore = ON;
350: break;
351:
352: case '?': /* don't know the option */
353: error(FATAL, "");
354: break;
355:
356: default: /* don't know what to do for ch */
357: error(FATAL, "missing case for option %c", ch);
358: break;
359: } /* End switch */
360: } /* End while */
361:
362: argc -= optind;
363: argv += optind;
364:
365: } /* End of options */
366:
367: /*****************************************************************************/
368:
369: char *get_font(name)
370:
371: char *name; /* name the user asked for */
372:
373: {
374:
375: int i; /* for looking through fontmap[] */
376:
377: /*
378: *
379: * Called from options() to map a user's font name into a legal PostScript name.
380: * If the lookup fails *name is returned to the caller. That should let you choose
381: * any PostScript font.
382: *
383: */
384:
385: for ( i = 0; fontmap[i].name != NULL; i++ )
386: if ( strcmp(name, fontmap[i].name) == 0 )
387: return(fontmap[i].val);
388:
389: return(name);
390:
391: } /* End of get_font */
392:
393: /*****************************************************************************/
394:
395: setup()
396:
397: {
398:
399: /*
400: *
401: * Handles things that must be done after the options are read but before the
402: * input files are processed.
403: *
404: */
405:
406: writerequest(0, stdout); /* global requests eg. manual feed */
407: setencoding(fontencoding);
408: fprintf(stdout, "setup\n");
409:
410: if ( formsperpage > 1 ) {
411: if ( cat(formfile) == FALSE )
412: error(FATAL, "can't read %s", formfile);
413: fprintf(stdout, "%d setupforms\n", formsperpage);
414: } /* End if */
415:
416: fprintf(stdout, "%s", ENDSETUP);
417:
418: } /* End of setup */
419:
420: /*****************************************************************************/
421:
422: arguments()
423:
424: {
425:
426: /*
427: *
428: * Makes sure all the non-option command line arguments are processed. If we get
429: * here and there aren't any arguments left, or if '-' is one of the input files
430: * we'll process stdin.
431: *
432: */
433:
434: if ( argc < 1 )
435: statemachine(fp_in = stdin);
436: else { /* at least one argument is left */
437: while ( argc > 0 ) {
438: if ( strcmp(*argv, "-") == 0 )
439: fp_in = stdin;
440: else if ( (fp_in = fopen(*argv, "r")) == NULL )
441: error(FATAL, "can't open %s", *argv);
442: statemachine(fp_in);
443: if ( fp_in != stdin )
444: fclose(fp_in);
445: argc--;
446: argv++;
447: } /* End while */
448: } /* End else */
449:
450: } /* End of arguments */
451:
452: /*****************************************************************************/
453:
454: done()
455:
456: {
457:
458: /*
459: *
460: * Finished with all the input files, so mark the end of the pages with a TRAILER
461: * comment, make sure the last page prints, and add things like the PAGES comment
462: * that can only be determined after all the input files have been read.
463: *
464: */
465:
466: fprintf(stdout, "%s", TRAILER);
467: fprintf(stdout, "done\n");
468: fprintf(stdout, "%s %s\n", DOCUMENTFONTS, fontname);
469: fprintf(stdout, "%s %d\n", PAGES, printed);
470:
471: } /* End of done */
472:
473: /*****************************************************************************/
474:
475: account()
476:
477: {
478:
479: /*
480: *
481: * Writes an accounting record to *fp_acct provided it's not NULL. Accounting
482: * is requested using the -A or -J options.
483: *
484: */
485:
486: if ( fp_acct != NULL )
487: fprintf(fp_acct, " print %d\n copies %d\n", printed, copies);
488:
489: } /* End of account */
490:
491: /*****************************************************************************/
492:
493: statemachine(fp)
494:
495: FILE *fp; /* used to set fp_in */
496:
497: {
498:
499: /*
500: *
501: * Controls the translation of the next input file. Tektronix states (dispmode)
502: * are typically changed in control() and esc().
503: *
504: */
505:
506: redirect(-1); /* get ready for the first page */
507: formfeed();
508: dispmode = RESET;
509:
510: while ( 1 )
511: switch ( dispmode ) {
512: case RESET:
513: reset();
514: break;
515:
516: case ALPHA:
517: alpha();
518: break;
519:
520: case GIN:
521: gin();
522: break;
523:
524: case GRAPH:
525: graph();
526: break;
527:
528: case POINT:
529: case SPECIALPOINT:
530: point();
531: break;
532:
533: case INCREMENTAL:
534: incremental();
535: break;
536:
537: case EXIT:
538: formfeed();
539: return;
540: } /* End switch */
541:
542: } /* End of statemachine */
543:
544: /*****************************************************************************/
545:
546: reset()
547:
548: {
549:
550: /*
551: *
552: * Called to reset things, typically only at the beginning of each input file.
553: *
554: */
555:
556: tekfont = -1;
557: home();
558: setfont(TEKFONT);
559: setmode(ALPHA);
560:
561: } /* End of reset */
562:
563: /*****************************************************************************/
564:
565: alpha()
566:
567: {
568:
569: int c; /* next character */
570: int x, y; /* cursor will be here when we're done */
571:
572: /*
573: *
574: * Takes care of printing characters in the current font.
575: *
576: */
577:
578: if ( (c = nextchar()) == OUTMODED )
579: return;
580:
581: if ( (c < 040) && ((c = control(c)) <= 0) )
582: return;
583:
584: x = cursor.x; /* where the cursor is right now */
585: y = cursor.y;
586:
587: switch ( c ) {
588: case DEL:
589: return;
590:
591: case BS:
592: if ((x -= charwidth[tekfont]) < margin)
593: x = TEKXMAX - charwidth[tekfont];
594: break;
595:
596: case NL:
597: y -= charheight[tekfont];
598: break;
599:
600: case CR:
601: x = margin;
602: break;
603:
604: case VT:
605: if ((y += charheight[tekfont]) >= TEKYMAX)
606: y = 0;
607: break;
608:
609: case HT:
610: case ' ':
611: default:
612: if ( characters++ == 0 )
613: fprintf(fp_out, "%d %d (", cursor.x, cursor.y);
614: switch ( c ) {
615: case '(':
616: case ')':
617: case '\\':
618: putc('\\', fp_out);
619:
620: default:
621: putc(c, fp_out);
622: } /* End switch */
623: x += charwidth[tekfont];
624: move(x, y);
625: break;
626: } /* End switch */
627:
628: if (x >= TEKXMAX) {
629: x = margin;
630: y -= charheight[tekfont];
631: } /* End if */
632:
633: if (y < 0) {
634: y = TEKYMAX - charheight[tekfont];
635: x -= margin;
636: margin = (TEKXMAX/2) - margin;
637: if ((x += margin) > TEKXMAX)
638: x -= margin;
639: } /* End if */
640:
641: if ( y != cursor.y || x != cursor.x )
642: text();
643:
644: move(x, y);
645:
646: } /* End of alpha */
647:
648: /*****************************************************************************/
649:
650: graph()
651:
652: {
653:
654: int c; /* next character */
655: int b; /* for figuring out loy */
656: int x, y; /* next point in the vector */
657: static int hix, hiy; /* upper */
658: static int lox, loy; /* and lower part of the address */
659: static int extra; /* for extended addressing */
660:
661: /*
662: *
663: * Handles things when we're in GRAPH, POINT, or SPECIALPOINT mode.
664: *
665: */
666:
667: if ((c = nextchar()) < 040) {
668: control(c);
669: return;
670: } /* End if */
671:
672: if ((c & 0140) == 040) { /* new hiy */
673: hiy = c & 037;
674: do
675: if (((c = nextchar()) < 040) && ((c = control(c)) == OUTMODED))
676: return;
677: while (c == 0);
678: } /* End if */
679:
680: if ((c & 0140) == 0140) { /* new loy */
681: b = c & 037;
682: do
683: if (((c = nextchar()) < 040) && ((c = control(c)) == OUTMODED))
684: return;
685: while (c == 0);
686: if ((c & 0140) == 0140) { /* no, it was extra */
687: extra = b;
688: loy = c & 037;
689: do
690: if (((c = nextchar()) < 040) && ((c = control(c)) == OUTMODED))
691: return;
692: while (c == 0);
693: } else loy = b;
694: } /* End if */
695:
696: if ((c & 0140) == 040) { /* new hix */
697: hix = c & 037;
698: do
699: if (((c = nextchar()) < 040) && ((c = control(c)) == OUTMODED))
700: return;
701: while (c == 0);
702: } /* End if */
703:
704: lox = c & 037; /* this should be lox */
705: if (extra & 020)
706: margin = TEKXMAX/2;
707:
708: x = (hix<<7) | (lox<<2) | (extra & 03);
709: y = (hiy<<7) | (loy<<2) | ((extra & 014)>>2);
710:
711: if ( points > 100 ) { /* don't put too much on the stack */
712: draw();
713: points = 1;
714: } /* End if */
715:
716: if ( points++ )
717: fprintf(fp_out, "%d %d\n", cursor.x - x, cursor.y - y);
718:
719: move(x, y); /* adjust the cursor */
720:
721: } /* End of graph */
722:
723: /*****************************************************************************/
724:
725: point()
726:
727: {
728:
729: int c; /* next input character */
730:
731: /*
732: *
733: * Special point mode permits gray scaling by varying the size of the stored
734: * point, which is controlled by an intensity character that preceeds each point
735: * address.
736: *
737: */
738:
739: if ( dispmode == SPECIALPOINT ) {
740: if ( (c = nextchar()) < 040 || c > 0175 )
741: return(control(c));
742:
743: fprintf(fp_out, "%d %d i\n", intensity[c - ' '], c & 0100);
744: } /* End if */
745:
746: graph();
747: draw();
748:
749: } /* End of point */
750:
751: /*****************************************************************************/
752:
753: incremental()
754:
755: {
756:
757: int c; /* for the next few characters */
758: int x, y; /* cursor position when we're done */
759:
760: /*
761: *
762: * Handles incremental plot mode. It's entered after the RS control code and is
763: * used to mark points relative to our current position. It's typically followed
764: * by one or two bytes that set the pen state and are used to increment the
765: * current position.
766: *
767: */
768:
769: if ( (c = nextchar()) == OUTMODED )
770: return;
771:
772: if ( (c < 040) && ((c = control(c)) <= 0) )
773: return;
774:
775: x = cursor.x; /* where we are right now */
776: y = cursor.y;
777:
778: if ( c & 060 )
779: pen = ( c & 040 ) ? UP : DOWN;
780:
781: if ( c & 04 ) y++;
782: if ( c & 010 ) y--;
783: if ( c & 01 ) x++;
784: if ( c & 02 ) x--;
785:
786: move(x, y);
787:
788: if ( pen == DOWN ) {
789: points = 1;
790: draw();
791: } /* End if */
792:
793: } /* End of incremental */
794:
795: /*****************************************************************************/
796:
797: gin()
798:
799: {
800:
801: /*
802: *
803: * All we really have to do for GIN mode is make sure it's properly ended.
804: *
805: */
806:
807: control(nextchar());
808:
809: } /* End of gin */
810:
811: /*****************************************************************************/
812:
813: control(c)
814:
815: int c; /* check this control character */
816:
817: {
818:
819: /*
820: *
821: * Checks character c and does special things, like mode changes, that depend
822: * not only on the character, but also on the current state. If the mode changed
823: * becuase of c, OUTMODED is returned to the caller. In all other cases the
824: * return value is c or 0, if c doesn't make sense in the current mode.
825: *
826: */
827:
828: switch ( c ) {
829: case BEL:
830: return(0);
831:
832: case BS:
833: case HT:
834: case VT:
835: return(dispmode == ALPHA ? c : 0);
836:
837: case CR:
838: if ( dispmode != ALPHA ) {
839: setmode(ALPHA);
840: ungetc(c, fp_in);
841: return(OUTMODED);
842: } else return(c);
843:
844: case FS:
845: if ( (dispmode == ALPHA) || (dispmode == GRAPH) ) {
846: setmode(POINT);
847: return(OUTMODED);
848: } /* End if */
849: return(0);
850:
851: case GS:
852: if ( (dispmode == ALPHA) || (dispmode == GRAPH) ) {
853: setmode(GRAPH);
854: return(OUTMODED);
855: } /* End if */
856: return(0);
857:
858: case NL:
859: ungetc(CR, fp_in);
860: return(dispmode == ALPHA ? c : 0);
861:
862: case RS:
863: if ( dispmode != GIN ) {
864: setmode(INCREMENTAL);
865: return(OUTMODED);
866: } /* End if */
867: return(0);
868:
869: case US:
870: if ( dispmode == ALPHA )
871: return(0);
872: setmode(ALPHA);
873: return(OUTMODED);
874:
875: case ESC:
876: return(esc());
877:
878: case OUTMODED:
879: return(c);
880:
881: default:
882: return(c < 040 ? 0 : c);
883: } /* End switch */
884:
885: } /* End of control */
886:
887: /*****************************************************************************/
888:
889: esc()
890:
891: {
892:
893: int c; /* next input character */
894: int ignore; /* skip it if nonzero */
895:
896: /*
897: *
898: * Handles tektronix escape code. Called from control() whenever an ESC character
899: * is found in the input file.
900: *
901: */
902:
903: do {
904: c = nextchar();
905: ignore = 0;
906: switch ( c ) {
907: case CAN:
908: return(0);
909:
910: case CR:
911: ignore = 1;
912: break;
913:
914: case ENQ:
915: setmode(ALPHA);
916: return(OUTMODED);
917:
918: case ETB:
919: return(0);
920:
921: case FF:
922: formfeed();
923: setmode(ALPHA);
924: return(OUTMODED);
925:
926: case FS:
927: if ( (dispmode == INCREMENTAL) || ( dispmode == GIN) )
928: return(0);
929: setmode(SPECIALPOINT);
930: return(OUTMODED);
931:
932: case SI:
933: case SO:
934: return(0);
935:
936: case SUB:
937: setmode(GIN);
938: return(OUTMODED);
939:
940: case OUTMODED:
941: return(OUTMODED);
942:
943: case '8':
944: case '9':
945: case ':':
946: case ';':
947: setfont(c - '8');
948: return(0);
949:
950: default:
951: if ( c == '?' && dispmode == GRAPH )
952: return(DEL);
953: if ( (c<'`') || (c>'w') )
954: break;
955: c -= '`';
956: if ( (c & 010) != linetype )
957: fprintf(fp_out, "%d w\n", (linetype = (c & 010))/010);
958: if ( ((c + 1) & 7) >= 6 )
959: break;
960: if ( (c + 1) & 7 )
961: if ( (c & 7) != linestyle ) {
962: linestyle = c & 7;
963: setmode(dispmode);
964: fprintf(fp_out, "%s l\n", styles[linestyle]);
965: } /* End if */
966: return(0);
967: } /* End switch */
968:
969: } while (ignore);
970:
971: return(0);
972:
973: } /* End of esc */
974:
975: /*****************************************************************************/
976:
977: move(x, y)
978:
979: int x, y; /* move the cursor here */
980:
981: {
982:
983: /*
984: *
985: * Moves the cursor to the point (x, y).
986: *
987: */
988:
989: cursor.x = x;
990: cursor.y = y;
991:
992: } /* End of move */
993:
994: /*****************************************************************************/
995:
996: setmode(mode)
997:
998: int mode; /* this should be the new mode */
999:
1000: {
1001:
1002: /*
1003: *
1004: * Makes sure the current mode is properly ended and then sets dispmode to mode.
1005: *
1006: */
1007:
1008: switch ( dispmode ) {
1009: case ALPHA:
1010: text();
1011: break;
1012:
1013: case GRAPH:
1014: draw();
1015: break;
1016:
1017: case INCREMENTAL:
1018: pen = UP;
1019: break;
1020: } /* End switch */
1021:
1022: dispmode = mode;
1023:
1024: } /* End of setmode */
1025:
1026: /*****************************************************************************/
1027:
1028: home()
1029:
1030: {
1031:
1032: /*
1033: *
1034: * Makes sure the cursor is positioned at the upper left corner of the page.
1035: *
1036: */
1037:
1038: margin = 0;
1039: move(0, TEKYMAX);
1040:
1041: } /* End of home */
1042:
1043: /*****************************************************************************/
1044:
1045: setfont(newfont)
1046:
1047: int newfont; /* use this font next */
1048:
1049: {
1050:
1051: /*
1052: *
1053: * Generates the call to the procedure that's responsible for changing the
1054: * tektronix font (really just the size).
1055: *
1056: */
1057:
1058: if ( newfont != tekfont ) {
1059: setmode(dispmode);
1060: fprintf(fp_out, "%d f\n", charwidth[newfont]);
1061: } /* End if */
1062:
1063: tekfont = newfont;
1064:
1065: } /* End of setfont */
1066:
1067: /*****************************************************************************/
1068:
1069: text()
1070:
1071: {
1072:
1073: /*
1074: *
1075: * Makes sure any text we've put on the stack is printed.
1076: *
1077: */
1078:
1079: if ( dispmode == ALPHA && characters > 0 )
1080: fprintf(fp_out, ") t\n");
1081:
1082: characters = 0;
1083:
1084: } /* End of text */
1085:
1086: /*****************************************************************************/
1087:
1088: draw()
1089:
1090: {
1091:
1092: /*
1093: *
1094: * Called whenever we need to draw a vector or plot a point. Nothing will be
1095: * done if points is 0 or if it's 1 and we're in GRAPH mode.
1096: *
1097: */
1098:
1099: if ( points > 1 ) /* it's a vector */
1100: fprintf(fp_out, "%d %d v\n", cursor.x, cursor.y);
1101: else if ( points == 1 && dispmode != GRAPH )
1102: fprintf(fp_out, "%d %d p\n", cursor.x, cursor.y);
1103:
1104: points = 0;
1105:
1106: } /* End of draw */
1107:
1108: /*****************************************************************************/
1109:
1110: formfeed()
1111:
1112: {
1113:
1114: /*
1115: *
1116: * Usually called when we've finished the last page and want to get ready for the
1117: * next one. Also used at the beginning and end of each input file, so we have to
1118: * be careful about exactly what's done.
1119: *
1120: */
1121:
1122: setmode(dispmode); /* end any outstanding text or graphics */
1123:
1124: if ( fp_out == stdout ) /* count the last page */
1125: printed++;
1126:
1127: fprintf(fp_out, "cleartomark\n");
1128: fprintf(fp_out, "showpage\n");
1129: fprintf(fp_out, "saveobj restore\n");
1130: fprintf(fp_out, "%s %d %d\n", ENDPAGE, page, printed);
1131:
1132: if ( ungetc(getc(fp_in), fp_in) == EOF )
1133: redirect(-1);
1134: else redirect(++page);
1135:
1136: fprintf(fp_out, "%s %d %d\n", PAGE, page, printed+1);
1137: fprintf(fp_out, "/saveobj save def\n");
1138: fprintf(fp_out, "mark\n");
1139: writerequest(printed+1, fp_out);
1140: fprintf(fp_out, "%d pagesetup\n", printed+1);
1141: fprintf(fp_out, "%d f\n", charwidth[tekfont]);
1142: fprintf(fp_out, "%s l\n", styles[linestyle]);
1143:
1144: home();
1145:
1146: } /* End of formfeed */
1147:
1148: /*****************************************************************************/
1149:
1150: nextchar()
1151:
1152: {
1153:
1154: int ch; /* next input character */
1155:
1156: /*
1157: *
1158: * Reads the next character from the current input file and returns it to the
1159: * caller. When we're finished with the file dispmode is set to EXIT and OUTMODED
1160: * is returned to the caller.
1161: *
1162: */
1163:
1164: if ( (ch = getc(fp_in)) == EOF ) {
1165: setmode(EXIT);
1166: ch = OUTMODED;
1167: } /* End if */
1168:
1169: return(ch);
1170:
1171: } /* End of nextchar */
1172:
1173: /*****************************************************************************/
1174:
1175: redirect(pg)
1176:
1177: int pg; /* next page we're printing */
1178:
1179: {
1180:
1181: static FILE *fp_null = NULL; /* if output is turned off */
1182:
1183: /*
1184: *
1185: * If we're not supposed to print page pg, fp_out will be directed to /dev/null,
1186: * otherwise output goes to stdout.
1187: *
1188: */
1189:
1190: if ( pg >= 0 && in_olist(pg) == ON )
1191: fp_out = stdout;
1192: else if ( (fp_out = fp_null) == NULL )
1193: fp_out = fp_null = fopen("/dev/null", "w");
1194:
1195: } /* End of redirect */
1196:
1197: /*****************************************************************************/
1198:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.