![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Lpostprint.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / postscript / postprint|
Return to Lpostprint.c CVS log | Up to [Research Unix] / researchv10no / cmd / postscript / postprint |
1.1 ! root 1: /* ! 2: * ! 3: * postprint - PostScript translator for ASCII files. ! 4: * ! 5: * A simple program that translates ASCII files into PostScript. All it really ! 6: * does is expand tabs and backspaces, handle character quoting, print text lines, ! 7: * and control when pages are started based on the requested number of lines per ! 8: * page. ! 9: * ! 10: * The PostScript prologue is copied from *prologue before any of the input files ! 11: * are translated. The program expects that the following procedures are defined ! 12: * 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: * l ! 31: * ! 32: * string l - ! 33: * ! 34: * Prints string starting in the first column and then goes to the next ! 35: * line. ! 36: * ! 37: * L ! 38: * ! 39: * mark string column string column ... L mark ! 40: * ! 41: * Prints each string on the stack starting at the horizontal position ! 42: * selected by column. Used when tabs and spaces can be sufficiently well ! 43: * compressed to make the printer overhead worthwhile. Always used when ! 44: * we have to back up. ! 45: * ! 46: * done ! 47: * ! 48: * done ! 49: * ! 50: * Makes sure the last page is printed. Only needed when we're printing ! 51: * more than one page on each sheet of paper. ! 52: * ! 53: * Almost everything has been changed in this version of postprint. The program ! 54: * is more intelligent, especially about tabs, spaces, and backspacing, and as a ! 55: * result output files usually print faster. Output files also now conform to ! 56: * Adobe's file structuring conventions, which is undoubtedly something I should ! 57: * have done in the first version of the program. If the number of lines per page ! 58: * is set to 0, which can be done using the -l option, pointsize will be used to ! 59: * guess a reasonable value. The estimate is based on the values of LINESPP, ! 60: * POINTSIZE, and pointsize, and assumes LINESPP lines would fit on a page if ! 61: * we printed in size POINTSIZE. Selecting a point size using the -s option and ! 62: * adding -l0 to the command line forces the guess to be made. ! 63: * ! 64: * Many default values, like the magnification and orientation, are defined in ! 65: * the prologue, which is where they belong. If they're changed (by options), an ! 66: * appropriate definition is made after the prologue is added to the output file. ! 67: * The -P option passes arbitrary PostScript through to the output file. Among ! 68: * other things it can be used to set (or change) values that can't be accessed by ! 69: * other options. ! 70: * ! 71: */ ! 72: ! 73: #include <stdio.h> ! 74: #include <signal.h> ! 75: #include <ctype.h> ! 76: #include <fcntl.h> ! 77: ! 78: #include "comments.h" /* PostScript file structuring comments */ ! 79: #include "gen.h" /* general purpose definitions */ ! 80: #include "path.h" /* for the prologue */ ! 81: #include "ext.h" /* external variable declarations */ ! 82: #include "postprint.h" /* a few special definitions */ ! 83: ! 84: char *optnames = "a:c:ef:l:m:n:o:p:r:s:t:x:y:A:C:E:J:L:P:R:DI"; ! 85: ! 86: char *prologue = POSTPRINT; /* default PostScript prologue */ ! 87: char *formfile = FORMFILE; /* stuff for multiple pages per sheet */ ! 88: ! 89: int formsperpage = 1; /* page images on each piece of paper */ ! 90: int copies = 1; /* and this many copies of each sheet */ ! 91: ! 92: int linespp = LINESPP; /* number of lines per page */ ! 93: int pointsize = POINTSIZE; /* in this point size */ ! 94: int tabstops = TABSTOPS; /* tabs set at these columns */ ! 95: int crmode = 0; /* carriage return mode - 0, 1, or 2 */ ! 96: int extended = TRUE; /* use escapes for unprintable chars */ ! 97: ! 98: int col = 1; /* next character goes in this column */ ! 99: int line = 1; /* on this line */ ! 100: ! 101: int stringcount = 0; /* number of strings on the stack */ ! 102: int stringstart = 1; /* column where current one starts */ ! 103: ! 104: Fontmap fontmap[] = FONTMAP; /* for translating font names */ ! 105: char *fontname = "Courier"; /* use this PostScript font */ ! 106: ! 107: int page = 0; /* page we're working on */ ! 108: int printed = 0; /* printed this many pages */ ! 109: ! 110: FILE *fp_in = stdin; /* read from this file */ ! 111: FILE *fp_out = stdout; /* and write stuff here */ ! 112: FILE *fp_acct = NULL; /* for accounting data */ ! 113: ! 114: /*****************************************************************************/ ! 115: ! 116: main(agc, agv) ! 117: ! 118: int agc; ! 119: char *agv[]; ! 120: ! 121: { ! 122: ! 123: /* ! 124: * ! 125: * A simple program that translates ASCII files into PostScript. If there's more ! 126: * than one input file, each begins on a new page. ! 127: * ! 128: */ ! 129: ! 130: argc = agc; /* other routines may want them */ ! 131: argv = agv; ! 132: ! 133: prog_name = argv[0]; /* really just for error messages */ ! 134: ! 135: init_signals(); /* sets up interrupt handling */ ! 136: header(); /* PostScript header and prologue */ ! 137: options(); /* handle the command line options */ ! 138: setup(); /* for PostScript */ ! 139: arguments(); /* followed by each input file */ ! 140: done(); /* print the last page etc. */ ! 141: account(); /* job accounting data */ ! 142: ! 143: exit(x_stat); /* not much could be wrong */ ! 144: ! 145: } /* End of main */ ! 146: ! 147: /*****************************************************************************/ ! 148: ! 149: init_signals() ! 150: ! 151: { ! 152: ! 153: /* ! 154: * ! 155: * Makes sure we handle interrupts. ! 156: * ! 157: */ ! 158: ! 159: if ( signal(SIGINT, interrupt) == SIG_IGN ) { ! 160: signal(SIGINT, SIG_IGN); ! 161: signal(SIGQUIT, SIG_IGN); ! 162: signal(SIGHUP, SIG_IGN); ! 163: } else { ! 164: signal(SIGHUP, interrupt); ! 165: signal(SIGQUIT, interrupt); ! 166: } /* End else */ ! 167: ! 168: signal(SIGTERM, interrupt); ! 169: ! 170: } /* End of init_signals */ ! 171: ! 172: /*****************************************************************************/ ! 173: ! 174: header() ! 175: ! 176: { ! 177: ! 178: int ch; /* return value from getopt() */ ! 179: int old_optind = optind; /* for restoring optind - should be 1 */ ! 180: ! 181: /* ! 182: * ! 183: * Scans the option list looking for things, like the prologue file, that we need ! 184: * right away but could be changed from the default. Doing things this way is an ! 185: * attempt to conform to Adobe's latest file structuring conventions. In particular ! 186: * they now say there should be nothing executed in the prologue, and they have ! 187: * added two new comments that delimit global initialization calls. Once we know ! 188: * where things really are we write out the job header, follow it by the prologue, ! 189: * and then add the ENDPROLOG and BEGINSETUP comments. ! 190: * ! 191: */ ! 192: ! 193: while ( (ch = getopt(argc, argv, optnames)) != EOF ) ! 194: if ( ch == 'L' ) ! 195: prologue = optarg; ! 196: else if ( ch == '?' ) ! 197: error(FATAL, ""); ! 198: ! 199: optind = old_optind; /* get ready for option scanning */ ! 200: ! 201: fprintf(stdout, "%s", CONFORMING); ! 202: fprintf(stdout, "%s %s\n", VERSION, PROGRAMVERSION); ! 203: fprintf(stdout, "%s %s\n", DOCUMENTFONTS, ATEND); ! 204: fprintf(stdout, "%s %s\n", PAGES, ATEND); ! 205: fprintf(stdout, "%s", ENDCOMMENTS); ! 206: ! 207: if ( cat(prologue) == FALSE ) ! 208: error(FATAL, "can't read %s", prologue); ! 209: ! 210: if ( DOROUND ) ! 211: cat(ROUNDPAGE); ! 212: ! 213: fprintf(stdout, "%s", ENDPROLOG); ! 214: fprintf(stdout, "%s", BEGINSETUP); ! 215: fprintf(stdout, "mark\n"); ! 216: ! 217: } /* End of header */ ! 218: ! 219: /*****************************************************************************/ ! 220: ! 221: options() ! 222: ! 223: { ! 224: ! 225: int ch; /* return value from getopt() */ ! 226: ! 227: /* ! 228: * ! 229: * Reads and processes the command line options. Added the -P option so arbitrary ! 230: * PostScript code can be passed through. Expect it could be useful for changing ! 231: * definitions in the prologue for which options have not been defined. ! 232: * ! 233: * Although any PostScript font can be used, things will only work well for ! 234: * constant width fonts. ! 235: * ! 236: */ ! 237: ! 238: while ( (ch = getopt(argc, argv, optnames)) != EOF ) { ! 239: switch ( ch ) { ! 240: ! 241: case 'a': /* aspect ratio */ ! 242: fprintf(stdout, "/aspectratio %s def\n", optarg); ! 243: break; ! 244: ! 245: case 'c': /* copies */ ! 246: copies = atoi(optarg); ! 247: fprintf(stdout, "/#copies %s store\n", optarg); ! 248: break; ! 249: ! 250: case 'e': /* obsolete - it's now always on */ ! 251: extended = TRUE; ! 252: break; ! 253: ! 254: case 'f': /* use this PostScript font */ ! 255: fontname = get_font(optarg); ! 256: fprintf(stdout, "/font /%s def\n", fontname); ! 257: break; ! 258: ! 259: case 'l': /* lines per page */ ! 260: linespp = atoi(optarg); ! 261: break; ! 262: ! 263: case 'm': /* magnification */ ! 264: fprintf(stdout, "/magnification %s def\n", optarg); ! 265: break; ! 266: ! 267: case 'n': /* forms per page */ ! 268: formsperpage = atoi(optarg); ! 269: fprintf(stdout, "%s %s\n", FORMSPERPAGE, optarg); ! 270: fprintf(stdout, "/formsperpage %s def\n", optarg); ! 271: break; ! 272: ! 273: case 'o': /* output page list */ ! 274: out_list(optarg); ! 275: break; ! 276: ! 277: case 'p': /* landscape or portrait mode */ ! 278: if ( *optarg == 'l' ) ! 279: fprintf(stdout, "/landscape true def\n"); ! 280: else fprintf(stdout, "/landscape false def\n"); ! 281: break; ! 282: ! 283: case 'r': /* carriage return mode */ ! 284: crmode = atoi(optarg); ! 285: break; ! 286: ! 287: case 's': /* point size */ ! 288: pointsize = atoi(optarg); ! 289: fprintf(stdout, "/pointsize %s def\n", optarg); ! 290: break; ! 291: ! 292: case 't': /* tabstops */ ! 293: tabstops = atoi(optarg); ! 294: break; ! 295: ! 296: case 'x': /* shift things horizontally */ ! 297: fprintf(stdout, "/xoffset %s def\n", optarg); ! 298: break; ! 299: ! 300: case 'y': /* and vertically on the page */ ! 301: fprintf(stdout, "/yoffset %s def\n", optarg); ! 302: break; ! 303: ! 304: case 'A': /* force job accounting */ ! 305: case 'J': ! 306: if ( (fp_acct = fopen(optarg, "a")) == NULL ) ! 307: error(FATAL, "can't open accounting file %s", optarg); ! 308: break; ! 309: ! 310: case 'C': /* copy file straight to output */ ! 311: if ( cat(optarg) == FALSE ) ! 312: error(FATAL, "can't read %s", optarg); ! 313: break; ! 314: ! 315: case 'E': /* text font encoding */ ! 316: fontencoding = optarg; ! 317: break; ! 318: ! 319: case 'L': /* PostScript prologue file */ ! 320: prologue = optarg; ! 321: break; ! 322: ! 323: case 'P': /* PostScript pass through */ ! 324: fprintf(stdout, "%s\n", optarg); ! 325: break; ! 326: ! 327: case 'R': /* special global or page level request */ ! 328: saverequest(optarg); ! 329: break; ! 330: ! 331: case 'D': /* debug flag */ ! 332: debug = ON; ! 333: break; ! 334: ! 335: case 'I': /* ignore FATAL errors */ ! 336: ignore = ON; ! 337: break; ! 338: ! 339: case '?': /* don't understand the option */ ! 340: error(FATAL, ""); ! 341: break; ! 342: ! 343: default: /* don't know what to do for ch */ ! 344: error(FATAL, "missing case for option %c\n", ch); ! 345: break; ! 346: } /* End switch */ ! 347: } /* End while */ ! 348: ! 349: argc -= optind; /* get ready for non-option args */ ! 350: argv += optind; ! 351: ! 352: } /* End of options */ ! 353: ! 354: /*****************************************************************************/ ! 355: ! 356: char *get_font(name) ! 357: ! 358: char *name; /* name the user asked for */ ! 359: ! 360: { ! 361: ! 362: int i; /* for looking through fontmap[] */ ! 363: ! 364: /* ! 365: * ! 366: * Called from options() to map a user's font name into a legal PostScript name. ! 367: * If the lookup fails *name is returned to the caller. That should let you choose ! 368: * any PostScript font, although things will only work well for constant width ! 369: * fonts. ! 370: * ! 371: */ ! 372: ! 373: for ( i = 0; fontmap[i].name != NULL; i++ ) ! 374: if ( strcmp(name, fontmap[i].name) == 0 ) ! 375: return(fontmap[i].val); ! 376: ! 377: return(name); ! 378: ! 379: } /* End of get_font */ ! 380: ! 381: /*****************************************************************************/ ! 382: ! 383: setup() ! 384: ! 385: { ! 386: ! 387: /* ! 388: * ! 389: * Handles things that must be done after the options are read but before the ! 390: * input files are processed. linespp (lines per page) can be set using the -l ! 391: * option. If it's not positive we calculate a reasonable value using the ! 392: * requested point size - assuming LINESPP lines fit on a page in point size ! 393: * POINTSIZE. ! 394: * ! 395: */ ! 396: ! 397: writerequest(0, stdout); /* global requests eg. manual feed */ ! 398: setencoding(fontencoding); ! 399: fprintf(stdout, "setup\n"); ! 400: ! 401: if ( formsperpage > 1 ) { ! 402: if ( cat(formfile) == FALSE ) ! 403: error(FATAL, "can't read %s", formfile); ! 404: fprintf(stdout, "%d setupforms\n", formsperpage); ! 405: } /* End if */ ! 406: ! 407: fprintf(stdout, "%s", ENDSETUP); ! 408: ! 409: if ( linespp <= 0 ) ! 410: linespp = LINESPP * POINTSIZE / pointsize; ! 411: ! 412: } /* End of setup */ ! 413: ! 414: /*****************************************************************************/ ! 415: ! 416: arguments() ! 417: ! 418: { ! 419: ! 420: /* ! 421: * ! 422: * Makes sure all the non-option command line arguments are processed. If we get ! 423: * here and there aren't any arguments left, or if '-' is one of the input files ! 424: * we'll translate stdin. ! 425: * ! 426: */ ! 427: ! 428: if ( argc < 1 ) ! 429: text(); ! 430: else { /* at least one argument is left */ ! 431: while ( argc > 0 ) { ! 432: if ( strcmp(*argv, "-") == 0 ) ! 433: fp_in = stdin; ! 434: else if ( (fp_in = fopen(*argv, "r")) == NULL ) ! 435: error(FATAL, "can't open %s", *argv); ! 436: text(); ! 437: if ( fp_in != stdin ) ! 438: fclose(fp_in); ! 439: argc--; ! 440: argv++; ! 441: } /* End while */ ! 442: } /* End else */ ! 443: ! 444: } /* End of arguments */ ! 445: ! 446: /*****************************************************************************/ ! 447: ! 448: done() ! 449: ! 450: { ! 451: ! 452: /* ! 453: * ! 454: * Finished with all the input files, so mark the end of the pages with a TRAILER ! 455: * comment, make sure the last page prints, and add things like the PAGES comment ! 456: * that can only be determined after all the input files have been read. ! 457: * ! 458: */ ! 459: ! 460: fprintf(stdout, "%s", TRAILER); ! 461: fprintf(stdout, "done\n"); ! 462: fprintf(stdout, "%s %s\n", DOCUMENTFONTS, fontname); ! 463: fprintf(stdout, "%s %d\n", PAGES, printed); ! 464: ! 465: } /* End of done */ ! 466: ! 467: /*****************************************************************************/ ! 468: ! 469: account() ! 470: ! 471: { ! 472: ! 473: /* ! 474: * ! 475: * Writes an accounting record to *fp_acct provided it's not NULL. Accounting is ! 476: * requested using the -A or -J options. ! 477: * ! 478: */ ! 479: ! 480: if ( fp_acct != NULL ) ! 481: fprintf(fp_acct, " print %d\n copies %d\n", printed, copies); ! 482: ! 483: } /* End of account */ ! 484: ! 485: /*****************************************************************************/ ! 486: ! 487: text() ! 488: ! 489: { ! 490: ! 491: int ch; /* next input character */ ! 492: ! 493: /* ! 494: * ! 495: * Translates *fp_in into PostScript. Intercepts space, tab, backspace, newline, ! 496: * return, and formfeed. Everything else goes to oput(), which handles quoting ! 497: * (if needed) and escapes for nonascii characters if extended is TRUE. The ! 498: * redirect(-1) call forces the initial output to go to /dev/null - so stuff ! 499: * that formfeed() does at the end of each page goes to /dev/null rather than ! 500: * the real output file. ! 501: * ! 502: */ ! 503: ! 504: redirect(-1); /* get ready for the first page */ ! 505: formfeed(); /* force PAGE comment etc. */ ! 506: ! 507: while ( (ch = getc(fp_in)) != EOF ) ! 508: switch ( ch ) { ! 509: case '\n': ! 510: newline(); ! 511: break; ! 512: ! 513: case '\t': ! 514: case '\b': ! 515: case ' ': ! 516: spaces(ch); ! 517: break; ! 518: ! 519: case '\014': ! 520: formfeed(); ! 521: break; ! 522: ! 523: case '\r': ! 524: if ( crmode == 1 ) ! 525: spaces(ch); ! 526: else if ( crmode == 2 ) ! 527: newline(); ! 528: break; ! 529: ! 530: default: ! 531: oput(ch); ! 532: break; ! 533: } /* End switch */ ! 534: ! 535: formfeed(); /* next file starts on a new page? */ ! 536: ! 537: } /* End of text */ ! 538: ! 539: /*****************************************************************************/ ! 540: ! 541: formfeed() ! 542: ! 543: { ! 544: ! 545: /* ! 546: * ! 547: * Called whenever we've finished with the last page and want to get ready for the ! 548: * next one. Also used at the beginning and end of each input file, so we have to ! 549: * be careful about what's done. The first time through (up to the redirect() call) ! 550: * output goes to /dev/null. ! 551: * ! 552: * Adobe now recommends that the showpage operator occur after the page level ! 553: * restore so it can be easily redefined to have side-effects in the printer's VM. ! 554: * Although it seems reasonable I haven't implemented it, because it makes other ! 555: * things, like selectively setting manual feed or choosing an alternate paper ! 556: * tray, clumsy - at least on a per page basis. ! 557: * ! 558: */ ! 559: ! 560: if ( fp_out == stdout ) /* count the last page */ ! 561: printed++; ! 562: ! 563: endline(); /* print the last line */ ! 564: ! 565: fprintf(fp_out, "cleartomark\n"); ! 566: fprintf(fp_out, "showpage\n"); ! 567: fprintf(fp_out, "saveobj restore\n"); ! 568: fprintf(fp_out, "%s %d %d\n", ENDPAGE, page, printed); ! 569: ! 570: if ( ungetc(getc(fp_in), fp_in) == EOF ) ! 571: redirect(-1); ! 572: else redirect(++page); ! 573: ! 574: fprintf(fp_out, "%s %d %d\n", PAGE, page, printed+1); ! 575: fprintf(fp_out, "/saveobj save def\n"); ! 576: fprintf(fp_out, "mark\n"); ! 577: writerequest(printed+1, fp_out); ! 578: fprintf(fp_out, "%d pagesetup\n", printed+1); ! 579: ! 580: line = 1; ! 581: ! 582: } /* End of formfeed */ ! 583: ! 584: /*****************************************************************************/ ! 585: ! 586: newline() ! 587: ! 588: { ! 589: ! 590: /* ! 591: * ! 592: * Called when we've read a newline character. The call to startline() ensures ! 593: * that at least an empty string is on the stack. ! 594: * ! 595: */ ! 596: ! 597: startline(); ! 598: endline(); /* print the current line */ ! 599: ! 600: if ( ++line > linespp ) /* done with this page */ ! 601: formfeed(); ! 602: ! 603: } /* End of newline */ ! 604: ! 605: /*****************************************************************************/ ! 606: ! 607: spaces(ch) ! 608: ! 609: int ch; /* next input character */ ! 610: ! 611: { ! 612: ! 613: int endcol; /* ending column */ ! 614: int i; /* final distance - in spaces */ ! 615: ! 616: /* ! 617: * ! 618: * Counts consecutive spaces, tabs, and backspaces and figures out where the next ! 619: * string should start. Once that's been done we try to choose an efficient way ! 620: * to output the required number of spaces. The choice is between using procedure ! 621: * l with a single string on the stack and L with several string and column pairs. ! 622: * We usually break even, in terms of the size of the output file, if we need four ! 623: * consecutive spaces. More means using L decreases the size of the file. For now ! 624: * if there are less than 6 consecutive spaces we just add them to the current ! 625: * string, otherwise we end that string, follow it by its starting position, and ! 626: * begin a new one that starts at endcol. Backspacing is always handled this way. ! 627: * ! 628: */ ! 629: ! 630: startline(); /* so col makes sense */ ! 631: endcol = col; ! 632: ! 633: do { ! 634: if ( ch == ' ' ) ! 635: endcol++; ! 636: else if ( ch == '\t' ) ! 637: endcol += tabstops - ((endcol - 1) % tabstops); ! 638: else if ( ch == '\b' ) ! 639: endcol--; ! 640: else if ( ch == '\r' ) ! 641: endcol = 1; ! 642: else break; ! 643: } while ( ch = getc(fp_in) ); /* if ch is 0 we'd quit anyway */ ! 644: ! 645: ungetc(ch, fp_in); /* wasn't a space, tab, or backspace */ ! 646: ! 647: if ( endcol < 1 ) /* can't move past left edge */ ! 648: endcol = 1; ! 649: ! 650: if ( (i = endcol - col) >= 0 && i < 6 ) ! 651: for ( ; i > 0; i-- ) ! 652: oput((int)' '); ! 653: else { ! 654: fprintf(fp_out, ")%d(", stringstart-1); ! 655: stringcount++; ! 656: col = stringstart = endcol; ! 657: } /* End else */ ! 658: ! 659: } /* End of spaces */ ! 660: ! 661: /*****************************************************************************/ ! 662: ! 663: startline() ! 664: ! 665: { ! 666: ! 667: /* ! 668: * ! 669: * Called whenever we want to be certain we're ready to start pushing characters ! 670: * into an open string on the stack. If stringcount is positive we've already ! 671: * started, so there's nothing to do. The first string starts in column 1. ! 672: * ! 673: */ ! 674: ! 675: if ( stringcount < 1 ) { ! 676: putc('(', fp_out); ! 677: stringstart = col = 1; ! 678: stringcount = 1; ! 679: } /* End if */ ! 680: ! 681: } /* End of startline */ ! 682: ! 683: /*****************************************************************************/ ! 684: ! 685: endline() ! 686: ! 687: { ! 688: ! 689: /* ! 690: * ! 691: * Generates a call to the PostScript procedure that processes all the text on ! 692: * the stack - provided stringcount is positive. If one string is on the stack ! 693: * the fast procedure (ie. l) is used to print the line, otherwise the slower ! 694: * one that processes string and column pairs is used. ! 695: * ! 696: */ ! 697: ! 698: if ( stringcount == 1 ) ! 699: fprintf(fp_out, ")l\n"); ! 700: else if ( stringcount > 1 ) ! 701: fprintf(fp_out, ")%d L\n", stringstart-1); ! 702: ! 703: stringcount = 0; ! 704: ! 705: } /* End of endline */ ! 706: ! 707: /*****************************************************************************/ ! 708: ! 709: oput(ch) ! 710: ! 711: int ch; /* next output character */ ! 712: ! 713: { ! 714: ! 715: /* ! 716: * ! 717: * Responsible for adding all printing characters from the input file to the ! 718: * open string on top of the stack. ! 719: * ! 720: */ ! 721: ! 722: if ( isascii(ch) && isprint(ch) ) { ! 723: startline(); ! 724: if ( ch == '(' || ch == ')' || ch == '\\' ) ! 725: putc('\\', fp_out); ! 726: putc(ch, fp_out); ! 727: col++; ! 728: } else if ( extended == TRUE ) { ! 729: startline(); ! 730: fprintf(fp_out, "\\%.3o", ch & 0377); ! 731: col++; ! 732: } /* End if */ ! 733: ! 734: } /* End of oput */ ! 735: ! 736: /*****************************************************************************/ ! 737: ! 738: redirect(pg) ! 739: ! 740: int pg; /* next page we're printing */ ! 741: ! 742: { ! 743: ! 744: static FILE *fp_null = NULL; /* if output is turned off */ ! 745: ! 746: /* ! 747: * ! 748: * If we're not supposed to print page pg, fp_out will be directed to /dev/null, ! 749: * otherwise output goes to stdout. ! 750: * ! 751: */ ! 752: ! 753: if ( pg >= 0 && in_olist(pg) == ON ) ! 754: fp_out = stdout; ! 755: else if ( (fp_out = fp_null) == NULL ) ! 756: fp_out = fp_null = fopen("/dev/null", "w"); ! 757: ! 758: } /* End of redirect */ ! 759: ! 760: /*****************************************************************************/ ! 761:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.