home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume11 / tek2ps < prev    next >
Text File  |  1987-09-15  |  19KB  |  756 lines
  1. Subject:  v11i049:  Tektronix4014 to PostScript filter
  2. Newsgroups: comp.sources.unix
  3. Sender: sources
  4. Approved: rs@uunet.UU.NET
  5.  
  6. Submitted-by: Michael S. Fischbein <msf@ames-nas.arpa>
  7. Posting-number: Volume 11, Issue 49
  8. Archive-name: tek2ps
  9.  
  10. Here's my first contribution to the wonderful world of public domain source
  11. codes, with a tip of the hat to the GNU Manifesto.
  12.  
  13. I've used several of the postings, so I thought I'd deliver this small piece
  14. up to the net.  We have several plot programs that have been developed or
  15. customized over the years, but they ALL support 4014s.  So, we now have a
  16. fast way to get good quality hardcopy.  Hope some other people can use it
  17.  
  18. Just thought I'd explain one code peculiarity: the use of fprintf(stdout,....
  19. throughout is because I was originally going to add a -o outputfile option.
  20. Redirecting stdout seemed a better choice once it was written.
  21.         mike
  22.  
  23. # This is a shell archive.  Remove anything before this line,
  24. # then unpack it by saving it in a file and typing "sh file".
  25. #
  26. # Contents:  Makefile README pstek.pro tek.h tek2ps.c tek2ps.doc
  27.  
  28. echo x - Makefile
  29. sed 's/^@//' > "Makefile" <<'@//E*O*F Makefile//'
  30. # %W% Makefile
  31. CFLAGS=-g
  32.  
  33. OBJ=tek2ps.o
  34.  
  35. all: tek2ps
  36.  
  37. tek2ps: ${OBJ} tek.h
  38.     cc ${CFLAGS} -o $@ ${OBJ}
  39.  
  40. @//E*O*F Makefile//
  41.  
  42. echo x - README
  43. sed 's/^@//' > "README" <<'@//E*O*F README//'
  44. This program will filter tektronix style plots to postscript output,
  45. letting you use your laserprinter instead of the thermal printer that
  46. tektronix has been selling since the dark ages.
  47.  
  48. I haven't been able to really test the defocussed Z axis stuff (no plot
  49. programs that we have use it).
  50.  
  51. I have put as much as possible into the prolog file so a user can fairly
  52. easily change the defaults I like to those he or she likes.  The tough
  53. part about figuring out how this works is understanding the Tek addressing
  54. schemes.  Other than that, it is pretty simple.  There is one `undocumented'
  55. flag: -d, which enables more verbose messages when an otherwise ignored
  56. character is encountered.  Usually, these are padding characters (4010s
  57. are very slow by modern standards).
  58.  
  59. BE SURE TO EDIT THE PROGRAM (tek2ps.c, find def_pro) AND DOCUMENTATION
  60. (tek2ps.doc, about the tenth line) to put the correct location
  61. for the default prolog file in!
  62.  
  63. Any corrections or additions?  Let me know at:
  64.  
  65. Michael Fischbein                 msf@prandtl.arpa
  66.                                   msf@prandtl.arc.nasa.gov
  67.                   ...!seismo!decuac!csmunix!icase!msf
  68.  
  69. @//E*O*F README//
  70.  
  71. echo x - pstek.pro
  72. sed 's/^@//' > "pstek.pro" <<'@//E*O*F pstek.pro//'
  73. %!PS-Adobe-1.0
  74. %%DocumentFonts:  Courier 
  75. %%Title: pstek prolog file, version 1.0 @(#)pstek.pro    1.10
  76. %%Creator: Michael Fischbein
  77. %% Copyright 1987 Michael Fischbein.  Commercial reproduction prohibited;
  78. %% non-profit reproduction and distribution encouraged.
  79. %%CreationDate: %?% 5 June 1987
  80. %%For: tektronics-to-PS converter
  81. %%BoundingBox: 40 40 540 540
  82. %%EndComments
  83.  
  84. % Font definitions (make 3/4 functions to avoid scaling if not needed)
  85. /FntH /Courier findfont 80 scalefont def
  86. /DFntL { /FntL /Courier findfont 73.4 scalefont def } def
  87. /DFntM { /FntM /Courier findfont 50.2 scalefont def } def
  88. /DFntS { /FntS /Courier findfont 44 scalefont def } def
  89.  
  90. % tektronix line styles
  91. /NV { [] 0 setdash } def    % normal vectors
  92. /DV { [8] 0 setdash } def    % dotted vectors
  93. /DDV { [8 8 32 8] 0 setdash } def    % dot-dash vectors
  94. /SDV { [32 8] 0 setdash } def    % short-dash vectors
  95. /LDV { [64 8] 0 setdash } def    % long-dash vectors
  96.  
  97. % Defocussed Z axis and Focussed Z axis
  98. /DZ { .5 setgray } def
  99. /FZ {  0 setgray } def
  100.  
  101. /PR    % char x y -> -  prints character
  102. {    moveto show } def
  103.  
  104. /NP    % - -> - new page
  105. % change default scale and orentation to match tek's
  106. {    572 40 translate    % leave a border
  107.     90 rotate
  108.     % .71707 .692308 scale    % 0-1023X, 0-780Y
  109.     .1730769 .17626953 scale    %0-4096X, 0-3120Y
  110. } def
  111.  
  112. /DP    % tsizey -> - erase and home
  113. {    clippath 1 setgray fill
  114.     0 setgray
  115.     0 exch moveto
  116. } def
  117.  
  118. FntH  setfont
  119.  
  120. NP
  121.  
  122. @//E*O*F pstek.pro//
  123.  
  124. echo x - tek.h
  125. sed 's/^@//' > "tek.h" <<'@//E*O*F tek.h//'
  126. /* t2ps header file @(#)tek.h    1.10 (Copyright) Michael Fischbein */
  127. /* Copyright 1987 Michael Fischbein.  Commercial reproduction prohibited; */
  128. /* non-profit reproduction and distribution encouraged. */
  129. #define XDIM 4096
  130. #define YDIM 3120
  131.  
  132. #define FALSE 0
  133. #define TRUE (~FALSE)
  134.  
  135. /* 4014 modes */
  136. #define ALPHA 0
  137. #define GRAPH 1
  138. #define INCRE 2
  139. #define LCEMD 3
  140. #define PTPLT 4
  141.  
  142. /* type sizes (char/line, or lines/page)  (for 12bit) */
  143. #define CHUGEX 55
  144. #define CLARGEX 51
  145. #define CMEDX 34
  146. #define CSMALLX 31
  147. #define CHUGEY 89
  148. #define CLARGEY 82
  149. #define CMEDY 54
  150. #define CSMALLY 49
  151.  
  152. /* ASCII */
  153. #define NUL 0
  154. #define SOH 1
  155. #define STX 2
  156. #define ETX 3
  157. #define EOT 4
  158. #define ENQ 5
  159. #define ACK 6
  160. #define BEL 7
  161. #define BS  8
  162. #define HT  9
  163. #define LF  10
  164. #define VT  11
  165. #define FF  12
  166. #define NL  13
  167. #define CR  13
  168. #define SO  14
  169. #define SI  15
  170. #define DLE 16
  171. #define DC1 17
  172. #define DC2 18
  173. #define DC3 19
  174. #define DC4 20
  175. #define NAK 21
  176. #define SYN 22
  177. #define ETB 23
  178. #define CAN 24
  179. #define EM  25
  180. #define SUB 26
  181. #define ESC 27
  182. #define FS  28
  183. #define GS  29
  184. #define RS  30
  185. #define US  31
  186. #define SPACE 32
  187. #define DEL 127
  188.  
  189. @//E*O*F tek.h//
  190.  
  191. echo x - tek2ps.c
  192. sed 's/^@//' > "tek2ps.c" <<'@//E*O*F tek2ps.c//'
  193. #include <stdio.h>
  194. #include <ctype.h>
  195. #include "tek.h"
  196.  
  197. extern char    *optarg;
  198. extern int    optind;
  199. extern double    atof();
  200.  
  201. /* output filter for tektronics 4010-graphics files to generate postscript
  202.  * files.  This does a simple-minded byte by byte translation to predefined
  203.  * PS routines, contained in a prolog file.
  204.  * Defaults:
  205.  * input:    stdin
  206.  * output:    stdout
  207.  * prolog:    ~msf/tek2ps/pstek.pro
  208.  */
  209.  
  210. main(argc, argv)
  211.     int    argc;
  212.     char    *argv[];
  213. {
  214. #ifndef lint
  215.     static char    sccsid[]=" @(#)t2p.c    1.10 tek2ps (Copyright) M. Fischbein  Commercial reproduction prohibited; non-profit reproduction and distribution encouraged.";
  216. #endif
  217.     static char    def_pro[]="/mnt/cmb/msf/tek2ps/pstek.pro";
  218.     char        *pro_fn = def_pro;
  219.     FILE        *pro_fp, *infile = stdin;
  220.     int        c, mode=ALPHA, tsizex=CHUGEX, tsizey=CHUGEY, oldmode;
  221.     int        cx=0, cy=YDIM-CHUGEY, leftmargin=0;
  222.     int        used_large=FALSE, used_med=FALSE, used_small=FALSE;
  223.     int        dark_vector, HiX=0, HiY=0, LoY=0, LoX=0, BX=0, BY=0;
  224.     int        gotLoY=FALSE, debug=FALSE, beamon, pr_on_er=FALSE;
  225.     double        scale_factor=1.0;
  226.  
  227.     /* first, parse command line */
  228.     while ((c = getopt (argc, argv, "s:p:de")) != EOF) {
  229.         switch (c) {
  230.         case 'p' :    /* use custom prolog */
  231.             pro_fn = optarg;
  232.             break;
  233.  
  234.         case 'd' :    /* toggle debugging */
  235.             if (debug) {
  236.                 debug = FALSE;
  237.             } else {
  238.                 debug = TRUE;
  239.             }
  240.             break;
  241.  
  242.         case 'e':    /* turn on print-before-erase */
  243.                 /* and erase-after-print */
  244.             pr_on_er = TRUE;
  245.             break;
  246.  
  247.         case 's':    /* set scale option */
  248.             scale_factor = atof(optarg)/100.;
  249.             break;
  250.         default:
  251.             fprintf(stderr, "Usage: %s [-p prologfile] [-de] [input]\n", argv[0]);
  252.             
  253.         }
  254.     }
  255.  
  256.     /* next, copy the prolog file */
  257.     if( (pro_fp = fopen(pro_fn, "r")) == NULL) {
  258.         fprintf(stderr, "Can't open prolog file %s\n", pro_fn);
  259.         exit(1);
  260.     }
  261.     while ((c = getc(pro_fp)) != EOF) {
  262.         putc((char) c, stdout);
  263.     }
  264.     fclose(pro_fp);
  265.  
  266.     /* check for named file (loop if more than one) */
  267.     do {    /* should indent here */
  268.     if (optind < argc) {
  269.         if ((infile = fopen( argv[optind], "r")) == NULL) {
  270.             fprintf(stderr, "Can't open input file %s\n", argv[optind]);
  271.             exit(1);
  272.         }
  273.     }
  274.     /* check for scale factor */
  275.     if (scale_factor != 1.0) {    /* I know floating pt equality is
  276.                      * a bad idea, but if the option is not
  277.                      * present I explicity initialize to
  278.                      * 1.0, so the bit pattern should be
  279.                      * identical portably
  280.                      */
  281.         fprintf(stdout,"%f %f scale\n", scale_factor, scale_factor);
  282.     }
  283.  
  284.     /* Now,  read a byte and figure out what to do about it */
  285.     while ((c = getc(infile)) != EOF) { /* should indent below */
  286.     switch (mode) {
  287.     case ALPHA:
  288.         if ( isgraph((char) c) ) {    /* normal printing char */
  289.             /* put char at current position */
  290.             fprintf(stdout,"(%c) %d %d PR\n", (char) c, cx, cy);
  291.             /* increment current postion, wrt type size */
  292.             if ((cx += tsizex) > XDIM) {
  293.                 /* new line or margin */
  294.                 if((cy -= tsizey) < 0) {
  295.                     cy = YDIM - tsizey;
  296.                     leftmargin = leftmargin ? 0 : XDIM/2;
  297.                 }
  298.                 cx = leftmargin;
  299.             }
  300.         } else { /* isn't normal printing character */
  301.         switch (c) {
  302.         case ( HT ):
  303.         case ( SPACE ):
  304.             if ((cx += tsizex) > XDIM) {
  305.                 /* new line or margin */
  306.                 if((cy -= tsizey) < 0) {
  307.                     cy = YDIM - tsizey;
  308.                     leftmargin = leftmargin ? 0 : XDIM/2;
  309.                 }
  310.                 cx = leftmargin;
  311.             }
  312.             break;
  313.  
  314.         case ( CR ):
  315.         case ( LF ):
  316.             if ((cy -= tsizey) < 0) {
  317.                 cy = YDIM - tsizey;
  318.                 leftmargin = leftmargin ? 0 : XDIM/2;
  319.             }
  320.             cx = leftmargin;
  321.             break;
  322.  
  323.         case ( BS ):
  324.             if ((cx -= tsizex) < 0) {
  325.                 cx = XDIM;
  326.             }
  327.             break;
  328.  
  329.         case ( VT ):
  330.             if ((cy += tsizey) > YDIM) {
  331.                 cy = 0;
  332.             }
  333.             break;
  334.  
  335.         case ( GS ):
  336.             mode = GRAPH;
  337.             dark_vector = TRUE;
  338.             break;
  339.  
  340.         case ( RS ):
  341.             mode = INCRE;
  342.             break;
  343.         
  344.         case ( FS ):
  345.             mode = PTPLT;
  346.             break;
  347.  
  348.         case ( US ):    /* put in ALPHA mode, already there */
  349.         case ( BEL ):
  350.         case ( SYN ):    /* padding character, ignore*/
  351.         case ( NUL ):    /* padding character, ignore*/
  352.             break;
  353.  
  354.         case ( ESC ):
  355.             oldmode = ALPHA;
  356.             mode = LCEMD;
  357.             break;
  358.  
  359.         default :
  360.             if (debug) fprintf(stderr, "Unknown ALPHA mode character 0x%02x\n", c);
  361.             break;
  362.         }    /* end of switch on non-printing char in ALPHA mode */
  363.         }    /* end of printing vs non-printing char in ALPHA mode */
  364.     break;    /* end of ALPHA mode */
  365.  
  366.     case PTPLT:
  367.     case GRAPH:
  368.         if ( (char) c > US ) {    /* first, handle vector case */
  369.             if( (char) c < '@') { /* High byte */
  370.                 if (gotLoY) {    /* must be HiX */
  371.                     HiX = ((char) c & 0x1f) << 7;
  372.                 } else {    /* must be HiY */
  373.                     HiY = ((char) c & 0x1f) << 7;
  374.                 }
  375.             } else if ( (char) c < '`') {    /* Lo X: plot */
  376.                 gotLoY = FALSE;
  377.                 LoX = (c & 0x1f) << 2;
  378.                 /* now actually do a plot */
  379.                 if (dark_vector) {
  380.                     dark_vector = FALSE;
  381.                     cx = HiX + LoX + BX;
  382.                     cy = HiY + LoY + BY;
  383.                     fprintf(stdout,"%d %d moveto\n",cx, cy);
  384.                 } else { /* draw the line */
  385.                     cx = HiX + LoX + BX;
  386.                     cy = HiY + LoY + BY;
  387.                     if (mode == GRAPH)  {
  388.                         fprintf(stdout,"%d %d lineto stroke %d %d moveto\n", cx, cy, cx, cy);
  389.                     } else {    /* mode == PTPLT */
  390.                         fprintf(stdout,"%d %d moveto %d %d 1 0 360 arc\n", cx, cy, cx, cy);
  391.                     }
  392.                 }
  393.             } else {    /* Lo Y or extra byte */
  394.                 if (gotLoY) {    /* previous LoY => extra byte */
  395.                     BX = (LoY & 0x0c) >> 2;
  396.                     BY = (LoY & 0x30) >> 4;
  397.                     LoY = (c & 0x1f) << 2;
  398.                     /* gotLoY stays TRUE */
  399.                 } else {    /* assume is LoY */
  400.                     LoY = (c & 0x1f) << 2;
  401.                     gotLoY = TRUE;
  402.                 }
  403.             }
  404.         } else /* end of GRAPH mode vector address parsing*/
  405.         /* so, it isn't a vector address */
  406.         switch ( c ) {
  407.         case ( NUL ): /* padding */
  408.         case ( SYN ): /* padding */
  409.         case ( BEL ): /* ignore */
  410.             break;
  411.  
  412.         case ( LF ):
  413.             cy -= tsizey;
  414.             fprintf(stdout, "%d %d moveto\n", cx, cy);
  415.             break;
  416.  
  417.         case ( CR ):
  418.             mode = ALPHA;
  419.             leftmargin = 0;
  420.             break;
  421.  
  422.         case ( RS ):
  423.             mode = INCRE;
  424.             break;
  425.  
  426.         case ( FS ):
  427.             fprintf(stderr,"special point plot not implemented\n");
  428.             break;
  429.  
  430.         case ( GS ):
  431.             dark_vector = TRUE;
  432.             break;
  433.  
  434.         case ( US ):
  435.             mode = ALPHA;
  436.             break;
  437.  
  438.         case ( ESC ):
  439.             oldmode = GRAPH;
  440.             mode = LCEMD;
  441.             break;
  442.  
  443.         default :
  444.             if (debug) fprintf(stderr, "Unknown GRAPH mode character 0x%02x\n", c);
  445.             break;
  446.         }    /* end of switch on non-vector char in GRAPH mode */
  447.     break;    /* end of GRAPH mode */
  448.  
  449.     case INCRE:
  450.         /* could do with bit masking and check for control, */
  451.         /* but this is is simpler. (Let the compiler work). */
  452.         switch ( c ) {
  453.         case ( 32 ):
  454.             fprintf(stdout,"stroke %d %d moveto\n", cx, cy);
  455.             beamon = FALSE;
  456.             break;
  457.  
  458.         case ( 80 ):
  459.             fprintf(stdout,"%d %d moveto\n", cx, cy);
  460.             beamon = TRUE;
  461.             break;
  462.  
  463.         case ( 68 ):    /* N */
  464.             if (++cy > YDIM) cy = YDIM;
  465.             if (beamon) fprintf(stdout,"%d %d lineto\n", cx, cy);
  466.             break;
  467.             
  468.         case ( 69 ):    /* NE */
  469.             if (++cy > YDIM) cy = YDIM;
  470.             if (++cx > XDIM) cx = XDIM;
  471.             if (beamon) fprintf(stdout,"%d %d lineto\n", cx, cy);
  472.             break;
  473.  
  474.         case ( 65 ):    /* E */
  475.             if (++cx > XDIM) cx = XDIM;
  476.             if (beamon) fprintf(stdout,"%d %d lineto\n", cx, cy);
  477.             break;
  478.  
  479.         case ( 73 ):    /* SE */
  480.             if (--cy < 0) cy = 0;
  481.             if (++cx > XDIM) cx = XDIM;
  482.             if (beamon) fprintf(stdout,"%d %d lineto\n", cx, cy);
  483.             break;
  484.  
  485.         case ( 72 ):    /* S */
  486.             if (--cy < 0) cy = 0;
  487.             if (beamon) fprintf(stdout,"%d %d lineto\n", cx, cy);
  488.             break;
  489.  
  490.         case ( 74 ):    /* SW */
  491.             if (--cy < 0) cy = 0;
  492.             if (--cx < 0) cx = 0;
  493.             if (beamon) fprintf(stdout,"%d %d lineto\n", cx, cy);
  494.             break;
  495.  
  496.         case ( 66 ):    /* W */
  497.             if (--cx < 0) cx = 0;
  498.             if (beamon) fprintf(stdout,"%d %d lineto\n", cx, cy);
  499.             break;
  500.  
  501.         case ( 70 ):    /* NW */
  502.             if (++cy > YDIM) cy = YDIM;
  503.             if (--cx < 0) cx = 0;
  504.             if (beamon) fprintf(stdout,"%d %d lineto\n", cx, cy);
  505.             break;
  506.  
  507.         case ( ESC ):
  508.             if (beamon) fprintf(stdout,"stroke %d %d moveto\n", cx, cy);
  509.             oldmode = INCRE;
  510.             mode = LCEMD;
  511.             break;
  512.  
  513.         case ( FS ):
  514.             if (beamon) fprintf(stdout,"stroke %d %d moveto\n", cx, cy);
  515.             mode = PTPLT;
  516.             break;
  517.  
  518.         case ( GS ):
  519.             if (beamon) fprintf(stdout,"stroke %d %d moveto\n", cx, cy);
  520.             mode = GRAPH;
  521.             dark_vector = TRUE;
  522.             break;
  523.  
  524.         case ( RS ):
  525.             break;
  526.  
  527.         case ( US ):
  528.             if (beamon) fprintf(stdout,"stroke %d %d moveto\n", cx, cy);
  529.             mode = ALPHA;
  530.             break;
  531.  
  532.         default:
  533.             if (debug) fprintf(stderr,"Unknown incremental mode character 0x%02x\n", c);
  534.             break;
  535.         }    /* end of INCR switch on c */
  536.     break;    /* end of INCREmental mode */
  537.  
  538.     case LCEMD:
  539.         if ((c > 95) && (c < 117)) {
  540.             /* set Z axis */
  541.             if ((char) c & 0x08) {
  542.                 fprintf(stdout,"DZ\n");
  543.             } else {
  544.                 fprintf(stdout,"FZ\n");
  545.             }
  546.             /* set vector type */
  547.             switch ((char) c & 0x07) {
  548.             case 0:    /* normal vectors */
  549.                 fprintf(stdout,"NV\n");
  550.                 break;
  551.  
  552.             case 1:    /* dotted vectors */
  553.                 fprintf(stdout,"DV\n");
  554.                 break;
  555.  
  556.             case 2:    /* dot-dash vectors */
  557.                 fprintf(stdout,"DDV\n");
  558.                 break;
  559.  
  560.             case 3:    /* short-dash vectors */
  561.                 fprintf(stdout,"SDV\n");
  562.                 break;
  563.  
  564.             case 4:    /* long-dash vectors */
  565.                 fprintf(stdout,"LDV\n");
  566.                 break;
  567.  
  568.             default:    /* error */
  569.                 if (debug) fprintf(stderr,"Unknown beam selector 0x%02x\n", (char) c);
  570.                 break;
  571.             }
  572.         } else {
  573.             switch ( c ) {
  574.             case ( FF ):    /* erase */
  575.                 if (pr_on_er) {
  576.                     fprintf(stdout,"showpage\nNP\n");
  577.                     if (scale_factor != 1.0) {
  578.                         fprintf(stdout,"%f %f scale\n", scale_factor, scale_factor);
  579.                     }
  580.                 }
  581.                 fprintf(stdout, "%d DP\n", tsizey);
  582.                 cx = 0; cy = YDIM - tsizey;
  583.                 break;
  584.  
  585.             case ( '8' ):
  586.                 /* default size */
  587.                 fprintf(stdout, "FntH setfont\n");
  588.                 tsizex = CHUGEX; tsizey = CHUGEY;
  589.                 break;
  590.  
  591.             case ( '9' ):
  592.                 if (! used_large ) {
  593.                     used_large = TRUE;
  594.                     fprintf(stdout,"DFntL\n");
  595.                 }
  596.                 fprintf(stdout, "FntL setfont\n");
  597.                 tsizex = CLARGEX; tsizey = CLARGEY;
  598.                 break;
  599.  
  600.             case ( ':' ):
  601.                 tsizex = CMEDX; tsizey = CMEDY;
  602.                 if (! used_med ) {
  603.                     used_med = TRUE;
  604.                     fprintf(stdout,"DFntM\n");
  605.                 }
  606.                 fprintf(stdout, "FntM setfont\n");
  607.                 break;
  608.  
  609.             case ( ';' ):
  610.                 tsizex = CSMALLX; tsizey = CSMALLY;
  611.                 if (! used_small ) {
  612.                     used_small = TRUE;
  613.                     fprintf(stdout,"DFntS\n");
  614.                 }
  615.                 fprintf(stdout, "FntS setfont\n");
  616.                 break;
  617.  
  618.             case ( BS ):
  619.                 if ((cx -= tsizex) < 0) {
  620.                     cx = XDIM;
  621.                 }
  622.                 break;
  623.  
  624.             case ( HT ):
  625.             case ( SPACE ):
  626.                 if ((cx += tsizex) > XDIM) {
  627.                     /* new line or margin */
  628.                     if((cy -= tsizey) < 0) {
  629.                         cy = YDIM - tsizey;
  630.                         leftmargin = leftmargin ? 0 : XDIM/2;
  631.                     }
  632.                     cx = leftmargin;
  633.                 }
  634.                 break;
  635.  
  636.             case ( VT ):
  637.                 if ((cy += tsizey) > YDIM) {
  638.                     cy = 0;
  639.                 }
  640.                 break;
  641.  
  642.             case ( GS ):
  643.                 mode = GRAPH;
  644.                 dark_vector = TRUE;
  645.                 break;
  646.  
  647.             case ( LF ):
  648.             case ( CR ):
  649.             case ( DEL ):
  650.             case ( NUL ):
  651.             case ( ESC ):
  652.             case ( BEL ):
  653.             case ( SYN ):
  654.                 ungetc( (char) ESC, infile);
  655.                 break;
  656.  
  657.             case ( ETB ):    /* make copy: print & start new page */
  658.                 if (pr_on_er) {
  659.                     fprintf(stdout, "showpage\nNP\n");
  660.                     if (scale_factor != 1.0) {
  661.                         fprintf(stdout,"%f %f scale\n", scale_factor, scale_factor);
  662.                     }
  663.                     cx = 0; cy = YDIM - tsizey;
  664.                 } else {
  665.                     fprintf(stdout, "copypage\n");
  666.                 }
  667.                 break;
  668.  
  669.             case ( SO ):
  670.             case ( SI ):
  671.                 if (debug) fprintf(stderr, "No alternate character set implemented\n");
  672.                 break;
  673.  
  674.             case ( CAN ):
  675.             case ( SUB ):
  676.             case ( ENQ ):
  677.                 if (debug) fprintf(stderr, "GIN and BYPASS  modes not implemented\n");
  678.                 break;
  679.  
  680.             case ( '?' ):
  681.                 ungetc( (char) DEL, infile);
  682.                 break;
  683.  
  684.             default :
  685.                 if (debug) fprintf(stderr, "Unknown LCE mode character 0x%02x ignored\n", c);
  686.                 break;
  687.             }    /* end of LCE mode switch */
  688.         }
  689.     mode = oldmode;
  690.     break;
  691.  
  692.     default:
  693.         if (debug) fprintf(stderr, "Unknown major mode %d\n", mode);
  694.         break;
  695.     } /* end of mode switch */
  696.     } /* end of main input loop */
  697.     fprintf(stdout,"showpage\n");
  698.     } while ( ++optind < argc );
  699. }
  700.  
  701. @//E*O*F tek2ps.c//
  702.  
  703. echo x - tek2ps.doc
  704. sed 's/^@//' > "tek2ps.doc" <<'@//E*O*F tek2ps.doc//'
  705. @.EV
  706. @.T1 tek2ps 1
  707. @.SH NAME
  708. tek2ps \- convert Tektronix\*R 4014 commands to PostScript\*R
  709. @.SH SYNTAX
  710. tek2ps [-p \fIprologfile\fR] [-e] [-s \fIscale] files
  711. @.SH OPTIONS
  712. @.IP -p
  713. will use the named prologfile instead of the default (currently
  714. /mnt/cmb/msf/tek2ps/tekps.pro).
  715. @.IP -e
  716. will make `erase' (ESC FF) and `hardcopy' (ESC ETB) synonymous: each will
  717. print the current page and then erase it.  The default will erase without
  718. printing or print without erasing.
  719. @.IP -s
  720. will scale the entire plot by the per centage specified.  The default maps
  721. the Tektronix screen to an 8.5 x 11 inch sheet of paper.
  722. @.SH DESCRIPTION
  723. @.PP
  724. Tek2ps will take any output designed to be displayed on a Tektronix 4014
  725. terminal and translate it to PostScript suitable for sending to any PostScript
  726. device.  Some manual editing will probably be required if the PostScript
  727. is to be included in another file.  Tek2ps supports 10 and 12-bit addressing
  728. modes, incremental plots, and defocussed Z axis.  It does
  729. @.I not
  730. support crosshair (GIN) mode or special point plot (6-bit greyscale).
  731. @.PP
  732. Multiple
  733. @.I files
  734. may be specified; if none are listed standard input is read.  Output is to
  735. standard output.
  736. @.SH EXAMPLE
  737. plot -T4014 myplot | tek2ps | lpr -Plw
  738. @.SH SPECIAL CONSIDERATIONS
  739. @.PP
  740. If you place multiple screens in a single file, you must either use the
  741. hardcopy command followed by an erase to prevent overwriting, or the
  742. -e option.
  743. @.SH FILES
  744. /mnt/cmb/msf/tek2ps/tekps.pro
  745. @.SH SEE ALSO
  746. graph(1), plot(1)
  747. @.SH BUGS
  748. Tek2ps will not support crosshair (GIN) mode or special point plot
  749. (6-bit greyscale).
  750. @.SH AUTHOR
  751. Michael Fischbein
  752.  
  753. @//E*O*F tek2ps.doc//
  754.  
  755. exit 0
  756.