/* * * 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 #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() { int interrupt(); /* signal handler */ /* * * 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: if ( isascii(ch) && isprint(ch) ) 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 ( ch == '\\' || ch == '(' || ch == ')' ) putc('\\', fp_out); putc(ch, fp_out); 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 */ /*****************************************************************************/