From e5888a1ffdae813d7575f5fb02275c6bb07e5199 Mon Sep 17 00:00:00 2001 From: Taru Karttunen Date: Wed, 30 Mar 2011 15:46:40 +0300 Subject: Import sources from 2011-03-30 iso image --- sys/src/cmd/postscript/postdaisy/postdaisy.c | 1225 ++++++++++++++++++++++++++ 1 file changed, 1225 insertions(+) create mode 100755 sys/src/cmd/postscript/postdaisy/postdaisy.c (limited to 'sys/src/cmd/postscript/postdaisy/postdaisy.c') diff --git a/sys/src/cmd/postscript/postdaisy/postdaisy.c b/sys/src/cmd/postscript/postdaisy/postdaisy.c new file mode 100755 index 000000000..8588cf9af --- /dev/null +++ b/sys/src/cmd/postscript/postdaisy/postdaisy.c @@ -0,0 +1,1225 @@ +/* + * + * postdaisy - PostScript translator for Diablo 1640 files. + * + * A program that translates Diablo 1640 files into PostScript. Absolutely nothing + * is guaranteed. Quite a few things haven't been implemented, and what's been + * done isn't well tested. Most of the documentation used to write this program + * was taken from the 'Diablo Emulator' section of a recent Imagen manual. + * + * Some of document comments that are generated may not be right. Most of the test + * files I used produced a trailing blank page. I've put a check in formfeed() that + * won't print the last page if it doesn't contain any text, but PAGES comments may + * not be right. The DOCUMENTFONTS comment will also be wrong if auto underline or + * bold printing have been turned on by escape commands. + * + * The brute force approach used to implement horizontal and vertical tabs leaves + * much to be desired, and may not work for very small initial hmi and vmi values. + * At the very least I should have used malloc() to get space for the two tabstop + * arrays after hmi and vmi are known! + * + * Reverse printing mode hasn't been tested at all, but what's here should be + * close even though it's not efficient. + * + * The PostScript prologue is copied from *prologue before any of the input files + * are translated. The program expects that the following PostScript procedures + * are defined in that file: + * + * setup + * + * mark ... setup - + * + * Handles special initialization stuff that depends on how this program + * was called. Expects to find a mark followed by key/value pairs on the + * stack. The def operator is applied to each pair up to the mark, then + * the default state is set up. + * + * pagesetup + * + * page pagesetup - + * + * Does whatever is needed to set things up for the next page. Expects to + * find the current page number on the stack. + * + * t + * + * mark str1 x1 str2 x2 ... strn xn y hmi t mark + * + * Handles all the text on the stack. Characters in the strings are + * printed using hmi as the character advance, and all strings are at + * vertical position y. Each string is begins at the horizontal position + * that preceeds it. + * + * f + * + * font f - + * + * Use font f, where f is the full PostScript font name. Only used when + * we switch to auto underline (Courier-Italic) or bold (Courier-Bold) + * printing. + * + * done + * + * done + * + * Makes sure the last page is printed. Only needed when we're printing + * more than one page on each sheet of paper. + * + * Many default values, like the magnification and orientation, are defined in + * the prologue, which is where they belong. If they're changed (by options), an + * appropriate definition is made after the prologue is added to the output file. + * The -P option passes arbitrary PostScript through to the output file. Among + * other things it can be used to set (or change) values that can't be accessed by + * other options. + * + */ + +#include +#include +#include +#ifdef plan9 +#define isascii(c) ((unsigned char)(c)<=0177) +#endif +#include +#include + +#include "comments.h" /* PostScript file structuring comments */ +#include "gen.h" /* general purpose definitions */ +#include "path.h" /* for the prologue */ +#include "ext.h" /* external variable declarations */ +#include "postdaisy.h" /* a few special definitions */ + +char *optnames = "a:c:f:h:l:m:n:o:p:r:s:v:x:y:A:C:E:J:L:P:DI"; + +char *prologue = POSTDAISY; /* default PostScript prologue */ +char *formfile = FORMFILE; /* stuff for multiple pages per sheet */ + +int formsperpage = 1; /* page images on each piece of paper */ +int copies = 1; /* and this many copies of each sheet */ + +char htabstops[COLUMNS]; /* horizontal */ +char vtabstops[ROWS]; /* and vertical tabs */ + +int res = RES; /* input file resolution - sort of */ + +int hmi = HMI; /* horizontal motion index - 1/120 inch */ +int vmi = VMI; /* vertical motion index - 1/48 inch */ +int ohmi = HMI; /* original hmi */ +int ovmi = VMI; /* and vmi - for tabs and char size */ + +int hpos = 0; /* current horizontal */ +int vpos = 0; /* and vertical position */ + +int lastx = -1; /* printer's last horizontal */ +int lasty = -1; /* and vertical position */ +int lasthmi = -1; /* hmi for current text strings */ + +int lastc = -1; /* last printed character */ +int prevx = -1; /* at this position */ + +int leftmargin = LEFTMARGIN; /* page margins */ +int rightmargin = RIGHTMARGIN; +int topmargin = TOPMARGIN; +int bottommargin = BOTTOMMARGIN; + +int stringcount = 0; /* number of strings on the stack */ +int stringstart = 1; /* column where current one starts */ +int advance = 1; /* -1 if in backward print mode */ + +int lfiscr = OFF; /* line feed implies carriage return */ +int crislf = OFF; /* carriage return implies line feed */ + +int linespp = 0; /* lines per page if it's positive */ +int markedpage = FALSE; /* helps prevent trailing blank page */ +int page = 0; /* page we're working on */ +int printed = 0; /* printed this many pages */ + +Fontmap fontmap[] = FONTMAP; /* for translating font names */ +char *fontname = "Courier"; /* use this PostScript font */ +int shadowprint = OFF; /* automatic bold printing if ON */ + +FILE *fp_in; /* read from this file */ +FILE *fp_out = stdout; /* and write stuff here */ +FILE *fp_acct = NULL; /* for accounting data */ + +/*****************************************************************************/ + +main(agc, agv) + + int agc; + char *agv[]; + +{ + +/* + * + * A simple program that translates Diablo 1640 files into PostScript. Nothing + * is guaranteed - the program not well tested and doesn't implement everything. + * + */ + + argc = agc; /* other routines may want them */ + argv = agv; + + prog_name = argv[0]; /* really just for error messages */ + + init_signals(); /* sets up interrupt handling */ + header(); /* PostScript header comments */ + options(); /* handle the command line options */ + setup(); /* for PostScript */ + arguments(); /* followed by each input file */ + done(); /* print the last page etc. */ + account(); /* job accounting data */ + + exit(x_stat); /* not much could be wrong */ + +} /* End of main */ + +/*****************************************************************************/ + +init_signals() + +{ + +/* + * + * Makes sure we handle interrupts. + * + */ + + if ( signal(SIGINT, interrupt) == SIG_IGN ) { + signal(SIGINT, SIG_IGN); + signal(SIGQUIT, SIG_IGN); + signal(SIGHUP, SIG_IGN); + } else { + signal(SIGHUP, interrupt); + signal(SIGQUIT, interrupt); + } /* End else */ + + signal(SIGTERM, interrupt); + +} /* End of init_signals */ + +/*****************************************************************************/ + +header() + +{ + + int ch; /* return value from getopt() */ + int old_optind = optind; /* for restoring optind - should be 1 */ + +/* + * + * Scans the option list looking for things, like the prologue file, that we need + * right away but could be changed from the default. Doing things this way is an + * attempt to conform to Adobe's latest file structuring conventions. In particular + * they now say there should be nothing executed in the prologue, and they have + * added two new comments that delimit global initialization calls. Once we know + * where things really are we write out the job header, follow it by the prologue, + * and then add the ENDPROLOG and BEGINSETUP comments. + * + */ + + while ( (ch = getopt(argc, argv, optnames)) != EOF ) + if ( ch == 'L' ) + prologue = optarg; + else if ( ch == '?' ) + error(FATAL, ""); + + optind = old_optind; /* get ready for option scanning */ + + fprintf(stdout, "%s", CONFORMING); + fprintf(stdout, "%s %s\n", VERSION, PROGRAMVERSION); + fprintf(stdout, "%s %s\n", DOCUMENTFONTS, ATEND); + fprintf(stdout, "%s %s\n", PAGES, ATEND); + fprintf(stdout, "%s", ENDCOMMENTS); + + if ( cat(prologue) == FALSE ) + error(FATAL, "can't read %s", prologue); + + if ( DOROUND ) + cat(ROUNDPAGE); + + fprintf(stdout, "%s", ENDPROLOG); + fprintf(stdout, "%s", BEGINSETUP); + fprintf(stdout, "mark\n"); + +} /* End of header */ + +/*****************************************************************************/ + +options() + +{ + + int ch; /* return value from getopt() */ + int n; /* for CR and LF modes */ + +/* + * + * Reads and processes the command line options. Added the -P option so arbitrary + * PostScript code can be passed through. Expect it could be useful for changing + * definitions in the prologue for which options have not been defined. + * + * Although any PostScript font can be used, things will only work for constant + * width fonts. + * + */ + + while ( (ch = getopt(argc, argv, optnames)) != EOF ) { + switch ( ch ) { + case 'a': /* aspect ratio */ + fprintf(stdout, "/aspectratio %s def\n", optarg); + break; + + case 'c': /* copies */ + copies = atoi(optarg); + fprintf(stdout, "/#copies %s store\n", optarg); + break; + + case 'f': /* use this PostScript font */ + fontname = get_font(optarg); + fprintf(stdout, "/font /%s def\n", fontname); + break; + + case 'h': /* default character spacing */ + ohmi = hmi = atoi(optarg) * HSCALE; + fprintf(stdout, "/hmi %s def\n", optarg); + break; + + case 'l': /* lines per page */ + linespp = atoi(optarg); + break; + + case 'm': /* magnification */ + fprintf(stdout, "/magnification %s def\n", optarg); + break; + + case 'n': /* forms per page */ + formsperpage = atoi(optarg); + fprintf(stdout, "%s %s\n", FORMSPERPAGE, optarg); + fprintf(stdout, "/formsperpage %s def\n", optarg); + break; + + case 'o': /* output page list */ + out_list(optarg); + break; + + case 'p': /* landscape or portrait mode */ + if ( *optarg == 'l' ) + fprintf(stdout, "/landscape true def\n"); + else fprintf(stdout, "/landscape false def\n"); + break; + + case 'r': /* set CR and LF modes */ + n = atoi(optarg); + if ( n & 01 ) + lfiscr = ON; + else lfiscr = OFF; + if ( n & 02 ) + crislf = ON; + else crislf = OFF; + break; + + case 's': /* point size */ + fprintf(stdout, "/pointsize %s def\n", optarg); + break; + + case 'v': /* default line spacing */ + ovmi = vmi = atoi(optarg) * VSCALE; + break; + + case 'x': /* shift things horizontally */ + fprintf(stdout, "/xoffset %s def\n", optarg); + break; + + case 'y': /* and vertically on the page */ + fprintf(stdout, "/yoffset %s def\n", optarg); + break; + + case 'A': /* force job accounting */ + case 'J': + if ( (fp_acct = fopen(optarg, "a")) == NULL ) + error(FATAL, "can't open accounting file %s", optarg); + break; + + case 'C': /* copy file straight to output */ + if ( cat(optarg) == FALSE ) + error(FATAL, "can't read %s", optarg); + break; + + case 'E': /* text font encoding */ + fontencoding = optarg; + break; + + case 'L': /* PostScript prologue file */ + prologue = optarg; + break; + + case 'P': /* PostScript pass through */ + fprintf(stdout, "%s\n", optarg); + break; + + case 'R': /* special global or page level request */ + saverequest(optarg); + break; + + case 'D': /* debug flag */ + debug = ON; + break; + + case 'I': /* ignore FATAL errors */ + ignore = ON; + break; + + case '?': /* don't understand the option */ + error(FATAL, ""); + break; + + default: /* don't know what to do for ch */ + error(FATAL, "missing case for option %c\n", ch); + break; + } /* End switch */ + } /* End while */ + + argc -= optind; /* get ready for non-option args */ + argv += optind; + +} /* End of options */ + +/*****************************************************************************/ + +char *get_font(name) + + char *name; /* name the user asked for */ + +{ + + int i; /* for looking through fontmap[] */ + +/* + * + * Called from options() to map a user's font name into a legal PostScript name. + * If the lookup fails *name is returned to the caller. That should let you choose + * any PostScript font, although things will only work well for constant width + * fonts. + * + */ + + for ( i = 0; fontmap[i].name != NULL; i++ ) + if ( strcmp(name, fontmap[i].name) == 0 ) + return(fontmap[i].val); + + return(name); + +} /* End of get_font */ + +/*****************************************************************************/ + +setup() + +{ + +/* + * + * Handles things that must be done after the options are read but before the + * input files are processed. + * + */ + + writerequest(0, stdout); /* global requests eg. manual feed */ + setencoding(fontencoding); + fprintf(stdout, "setup\n"); + + if ( formsperpage > 1 ) { + if ( cat(formfile) == FALSE ) + error(FATAL, "can't read %s", formfile); + fprintf(stdout, "%d setupforms\n", formsperpage); + } /* End if */ + + fprintf(stdout, "%s", ENDSETUP); + +} /* End of setup */ + +/*****************************************************************************/ + +arguments() + +{ + +/* + * + * Makes sure all the non-option command line arguments are processed. If we get + * here and there aren't any arguments left, or if '-' is one of the input files + * we'll process stdin. + * + */ + + fp_in = stdin; + + if ( argc < 1 ) + text(); + else { /* at least one argument is left */ + while ( argc > 0 ) { + if ( strcmp(*argv, "-") == 0 ) + fp_in = stdin; + else if ( (fp_in = fopen(*argv, "r")) == NULL ) + error(FATAL, "can't open %s", *argv); + text(); + if ( fp_in != stdin ) + fclose(fp_in); + argc--; + argv++; + } /* End while */ + } /* End else */ + +} /* End of arguments */ + +/*****************************************************************************/ + +done() + +{ + +/* + * + * Finished with all the input files, so mark the end of the pages, make sure the + * last page is printed, and restore the initial environment. + * + */ + + fprintf(stdout, "%s", TRAILER); + fprintf(stdout, "done\n"); + fprintf(stdout, "%s %s\n", DOCUMENTFONTS, fontname); + fprintf(stdout, "%s %d\n", PAGES, printed); + +} /* End of done */ + +/*****************************************************************************/ + +account() + +{ + +/* + * + * Writes an accounting record to *fp_acct provided it's not NULL. Accounting + * is requested using the -A or -J options. + * + */ + + if ( fp_acct != NULL ) + fprintf(fp_acct, " print %d\n copies %d\n", printed, copies); + +} /* End of account */ + +/*****************************************************************************/ + +text() + +{ + + int ch; /* next input character */ + +/* + * + * Translates the next input file into PostScript. The redirect(-1) call forces + * the initial output to go to /dev/null - so the stuff formfeed() does at the + * end of each page doesn't go to stdout. + * + */ + + redirect(-1); /* get ready for the first page */ + formfeed(); /* force PAGE comment etc. */ + inittabs(); + + while ( (ch = getc(fp_in)) != EOF ) + switch ( ch ) { + case '\010': /* backspace */ + backspace(); + break; + + case '\011': /* horizontal tab */ + htab(); + break; + + case '\012': /* new line */ + linefeed(); + break; + + case '\013': /* vertical tab */ + vtab(); + break; + + case '\014': /* form feed */ + formfeed(); + break; + + case '\015': /* carriage return */ + carriage(); + break; + + case '\016': /* extended character set - SO */ + break; + + case '\017': /* extended character set - SI */ + break; + + case '\031': /* next char from supplementary set */ + break; + + case '\033': /* 2 or 3 byte escape sequence */ + escape(); + break; + + default: + oput(ch); + break; + } /* End switch */ + + formfeed(); /* next file starts on a new page? */ + +} /* End of text */ + +/*****************************************************************************/ + +inittabs() + +{ + + int i; /* loop index */ + +/* + * + * Initializes the horizontal and vertical tab arrays. The way tabs are handled is + * quite inefficient and may not work for all initial hmi or vmi values. + * + */ + + for ( i = 0; i < COLUMNS; i++ ) + htabstops[i] = ((i % 8) == 0) ? ON : OFF; + + for ( i = 0; i < ROWS; i++ ) + vtabstops[i] = ((i * ovmi) > BOTTOMMARGIN) ? ON : OFF; + +} /* End of inittabs */ + +/*****************************************************************************/ + +cleartabs() + +{ + + int i; /* loop index */ + +/* + * + * Clears all horizontal and vertical tab stops. + * + */ + + for ( i = 0; i < ROWS; i++ ) + htabstops[i] = OFF; + + for ( i = 0; i < COLUMNS; i++ ) + vtabstops[i] = OFF; + +} /* End of cleartabs */ + +/*****************************************************************************/ + +formfeed() + +{ + +/* + * + * Called whenever we've finished with the last page and want to get ready for the + * next one. Also used at the beginning and end of each input file, so we have to + * be careful about what's done. I've added a simple test before the showpage that + * should eliminate the extra blank page that was put out at the end of many jobs, + * but the PAGES comments may be wrong. + * + */ + + if ( fp_out == stdout ) /* count the last page */ + printed++; + + endline(); /* print the last line */ + + fprintf(fp_out, "cleartomark\n"); + if ( feof(fp_in) == 0 || markedpage == TRUE ) + fprintf(fp_out, "showpage\n"); + fprintf(fp_out, "saveobj restore\n"); + fprintf(fp_out, "%s %d %d\n", ENDPAGE, page, printed); + + if ( ungetc(getc(fp_in), fp_in) == EOF ) + redirect(-1); + else redirect(++page); + + fprintf(fp_out, "%s %d %d\n", PAGE, page, printed+1); + fprintf(fp_out, "/saveobj save def\n"); + fprintf(fp_out, "mark\n"); + writerequest(printed+1, fp_out); + fprintf(fp_out, "%d pagesetup\n", printed+1); + + vgoto(topmargin); + hgoto(leftmargin); + + markedpage = FALSE; + +} /* End of formfeed */ + +/*****************************************************************************/ + +linefeed() + +{ + + int line = 0; /* current line - based on ovmi */ + +/* + * + * Adjust our current vertical position. If we've passed the bottom of the page + * or exceeded the number of lines per page, print it and go to the upper left + * corner of the next page. This routine is also called from carriage() if crislf + * is ON. + * + */ + + vmot(vmi); + + if ( lfiscr == ON ) + hgoto(leftmargin); + + if ( linespp > 0 ) /* means something so see where we are */ + line = vpos / ovmi + 1; + + if ( vpos > bottommargin || line > linespp ) + formfeed(); + +} /* End of linefeed */ + +/*****************************************************************************/ + +carriage() + +{ + +/* + * + * Handles carriage return character. If crislf is ON we'll generate a line feed + * every time we get a carriage return character. + * + */ + + if ( shadowprint == ON ) /* back to normal mode */ + changefont(fontname); + + advance = 1; + shadowprint = OFF; + + hgoto(leftmargin); + + if ( crislf == ON ) + linefeed(); + +} /* End of carriage */ + +/*****************************************************************************/ + +htab() + +{ + + int col; /* 'column' we'll be at next */ + int i; /* loop index */ + +/* + * + * Tries to figure out where the next tab stop is. Wasn't positive about this + * one, since hmi can change. I'll assume columns are determined by the original + * value of hmi. That fixes them on the page, which seems to make more sense than + * letting them float all over the place. + * + */ + + endline(); + + col = hpos/ohmi + 1; + for ( i = col; i < ROWS; i++ ) + if ( htabstops[i] == ON ) { + col = i; + break; + } /* End if */ + + hgoto(col * ohmi); + lastx = hpos; + +} /* End of htab */ + +/*****************************************************************************/ + +vtab() + +{ + + int line; /* line we'll be at next */ + int i; /* loop index */ + +/* + * + * Looks for the next vertical tab stop in the vtabstops[] array and moves to that + * line. If we don't find a tab we'll just move down one line - shouldn't happen. + * + */ + + endline(); + + line = vpos/ovmi + 1; + for ( i = line; i < COLUMNS; i++ ) + if ( vtabstops[i] == ON ) { + line = i; + break; + } /* End if */ + + vgoto(line * ovmi); + +} /* End of vtab */ + +/*****************************************************************************/ + +backspace() + +{ + +/* + * + * Moves backwards a distance equal to the current value of hmi, but don't go + * past the left margin. + * + */ + + endline(); + + if ( hpos - leftmargin >= hmi ) + hmot(-hmi); + else hgoto(leftmargin); /* maybe just ignore the backspace?? */ + + lastx = hpos; + +} /* End of backspace */ + +/*****************************************************************************/ + +escape() + +{ + + int ch; /* control character */ + +/* + * + * Handles special codes that are expected to follow an escape character. The + * initial escape character is followed by one or two bytes. + * + */ + + switch ( ch = getc(fp_in) ) { + case 'T': /* top margin */ + topmargin = vpos; + break; + + case 'L': /* bottom margin */ + bottommargin = vpos; + break; + + case 'C': /* clear top and bottom margins */ + bottommargin = BOTTOMMARGIN; + topmargin = TOPMARGIN; + break; + + case '9': /* left margin */ + leftmargin = hpos; + break; + + case '0': /* right margin */ + rightmargin = hpos; + break; + + case '1': /* set horizontal tab */ + htabstops[hpos/ohmi] = ON; + break; + + case '8': /* clear horizontal tab at hpos */ + htabstops[hpos/ohmi] = OFF; + break; + + case '-': /* set vertical tab */ + vtabstops[vpos/ovmi] = ON; + break; + + case '2': /* clear all tabs */ + cleartabs(); + break; + + case '\014': /* set lines per page */ + linespp = getc(fp_in); + break; + + case '\037': /* set hmi to next byte minus 1 */ + hmi = HSCALE * (getc(fp_in) - 1); + break; + + case 'S': /* reset hmi to default */ + hmi = ohmi; + break; + + case '\011': /* move to column given by next byte */ + hgoto((getc(fp_in)-1) * ohmi); + break; + + case '?': /* do carriage return after line feed */ + lfiscr = ON; + break; + + case '!': /* don't generate carriage return */ + lfiscr = OFF; + break; + + case '5': /* forward print mode */ + advance = 1; + break; + + case '6': /* backward print mode */ + advance = -1; + break; + + case '\036': /* set vmi to next byte minus 1 */ + vmi = VSCALE * (getc(fp_in) - 1); + break; + + case '\013': /* move to line given by next byte */ + vgoto((getc(fp_in)-1) * ovmi); + break; + + case 'U': /* positive half line feed */ + vmot(vmi/2); + break; + + case 'D': /* negative half line feed */ + vmot(-vmi/2); + break; + + case '\012': /* negative line feed */ + vmot(-vmi); + break; + + case '\015': /* clear all margins */ + bottommargin = BOTTOMMARGIN; + topmargin = TOPMARGIN; + leftmargin = BOTTOMMARGIN; + rightmargin = RIGHTMARGIN; + break; + + case 'E': /* auto underscore - use italic font */ + changefont("/Courier-Oblique"); + break; + + case 'R': /* disable auto underscore */ + changefont(fontname); + break; + + case 'O': /* bold/shadow printing */ + case 'W': + changefont("/Courier-Bold"); + shadowprint = ON; + break; + + case '&': /* disable bold printing */ + changefont(fontname); + shadowprint = OFF; + break; + + case '/': /* ignored 2 byte escapes */ + case '\\': + case '<': + case '>': + case '%': + case '=': + case '.': + case '4': + case 'A': + case 'B': + case 'M': + case 'N': + case 'P': + case 'Q': + case 'X': + case '\010': + break; + + case ',': /* ignored 3 byte escapes */ + case '\016': + case '\021': + getc(fp_in); + break; + + case '3': /* graphics mode - should quit! */ + case '7': + case 'G': + case 'V': + case 'Y': + case 'Z': + error(FATAL, "graphics mode is not implemented"); + break; + + default: + error(FATAL, "missing case for escape o%o\n", ch); + break; + } /* End switch */ + +} /* End of escape */ + +/*****************************************************************************/ + +vmot(n) + + int n; /* move this far vertically */ + +{ + +/* + * + * Move vertically n units from where we are. + * + */ + + vpos += n; + +} /* End of vmot */ + +/*****************************************************************************/ + +vgoto(n) + + int n; /* new vertical position */ + +{ + +/* + * + * Moves to absolute vertical position n. + * + */ + + vpos = n; + +} /* End of vgoto */ + +/*****************************************************************************/ + +hmot(n) + + int n; /* move this horizontally */ + +{ + +/* + * + * Moves horizontally n units from our current position. + * + */ + + hpos += n * advance; + + if ( hpos < leftmargin ) + hpos = leftmargin; + +} /* End of hmot */ + +/*****************************************************************************/ + +hgoto(n) + + int n; /* go to this horizontal position */ + +{ + +/* + * + * Moves to absolute horizontal position n. + * + */ + + hpos = n; + +} /* End of hgoto */ + +/*****************************************************************************/ + +changefont(name) + + char *name; + +{ + +/* + * + * Changes the current font. Used to get in and out of auto underscore and bold + * printing. + * + */ + + endline(); + fprintf(fp_out, "%s f\n", name); + +} /* End of changefont */ + +/*****************************************************************************/ + +startline() + +{ + +/* + * + * Called whenever we want to be certain we're ready to start pushing characters + * into an open string on the stack. If stringcount is positive we've already + * started, so there's nothing to do. The first string starts in column 1. + * + */ + + if ( stringcount < 1 ) { + putc('(', fp_out); + stringstart = lastx = hpos; + lasty = vpos; + lasthmi = hmi; + lastc = -1; + prevx = -1; + stringcount = 1; + } /* End if */ + +} /* End of startline */ + +/*****************************************************************************/ + +endline() + +{ + +/* + * + * Generates a call to the PostScript procedure that processes the text on the + * the stack - provided stringcount is positive. + * + */ + + if ( stringcount > 0 ) + fprintf(fp_out, ")%d %d %d t\n", stringstart, lasty, lasthmi); + + stringcount = 0; + +} /* End of endline */ + +/*****************************************************************************/ + +endstring() + +{ + +/* + * + * Takes the string we've been working on and adds it to the output file. Called + * when we need to adjust our horizontal position before starting a new string. + * Also called from endline() when we're done with the current line. + * + */ + + if ( stringcount > 0 ) { + fprintf(fp_out, ")%d(", stringstart); + lastx = stringstart = hpos; + stringcount++; + } /* End if */ + +} /* End of endstring */ + +/*****************************************************************************/ + +oput(ch) + + int ch; /* next output character */ + +{ + +/* + * + * Responsible for adding all printing characters from the input file to the + * open string on top of the stack. The only other characters that end up in + * that string are the quotes required for special characters. Reverse printing + * mode hasn't been tested but it should be close. hpos and lastx should disagree + * each time (except after startline() does something), and that should force a + * call to endstring() for every character. + * + */ + + if ( stringcount > 100 ) /* don't put too much on the stack */ + endline(); + + if ( vpos != lasty ) + endline(); + + if ( advance == -1 ) /* for reverse printing - move first */ + hmot(hmi); + + startline(); + + if ( lastc != ch || hpos != prevx ) { + if ( lastx != hpos ) + endstring(); + + if ( isascii(ch) && isprint(ch) ) { + if ( ch == '\\' || ch == '(' || ch == ')' ) + putc('\\', fp_out); + putc(ch, fp_out); + } else fprintf(fp_out, "\\%.3o", ch & 0377); + + lastc = ch; + prevx = hpos; + lastx += lasthmi; + } /* End if */ + + if ( advance != -1 ) + hmot(hmi); + + markedpage = TRUE; + +} /* End of oput */ + +/*****************************************************************************/ + +redirect(pg) + + int pg; /* next page we're printing */ + +{ + + static FILE *fp_null = NULL; /* if output is turned off */ + +/* + * + * If we're not supposed to print page pg, fp_out will be directed to /dev/null, + * otherwise output goes to stdout. + * + */ + + if ( pg >= 0 && in_olist(pg) == ON ) + fp_out = stdout; + else if ( (fp_out = fp_null) == NULL ) + fp_out = fp_null = fopen("/dev/null", "w"); + +} /* End of redirect */ + +/*****************************************************************************/ + -- cgit v1.2.3