![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to postdmd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / post.src / postdmd|
Return to postdmd.c CVS log | Up to [Research Unix] / researchv10no / cmd / post.src / postdmd |
1.1 ! root 1: /* ! 2: * ! 3: * postdmd - PostScript translator for DMD bitmap files. ! 4: * ! 5: * A simple program that can be used to print DMD bitmaps on PostScript printers. ! 6: * Much of the code was borrowed from abm, which was written by Guy Riddle. ! 7: * ! 8: * Although the program supports two different input bitmap formats, by far the ! 9: * most important is the Eighth (and Ninth) Edition bitfile format. A bitmap in ! 10: * the bitfile format begins with a 10 byte header with the first two bytes set to ! 11: * zero. The next 8 bytes set the x and y coordinates of the bitmap's origin and ! 12: * corner (ie. the upper left and lower right corners). The compressed raster data ! 13: * follows the header and consists of control bytes followed an appropriate number ! 14: * of data bytes. Control bytes (ie. n) less than 127 means read the next 2*n bytes ! 15: * of raster data directly from the input file, while if n is larger than 128 we ! 16: * read two bytes from the input file and replicate the bytes n-128 times. After ! 17: * each scan line is recovered it's exclusive-or'd with the preceeding line to ! 18: * generate the real raster data. ! 19: * ! 20: * After each raster line is recovered postdmd encodes it in a slightly different ! 21: * format that's designed to be unpacked by a PostScript procedure that's defined ! 22: * in the prologue. By default no exclusive-or'ing is done and packing of pattern ! 23: * data can be based on any number of bytes rather than just the next two bytes. ! 24: * By default 6 byte patterns are used, but any number can be selected with the -b ! 25: * option. A non-positive argument (eg. -b0) disables all pattern encoding. Larger ! 26: * patterns increase the size of the output file, but reduce the work load that's ! 27: * forced on the PostScript interpreter. The default choices I've made (ie. 6 byte ! 28: * patterns and no exclusive-or'ing) do a decent balancing job across currently ! 29: * available PostScript printers. Larger patterns (eg. -b16) increase the output ! 30: * file size, but may be appropriate if you're running at a high baud rate (eg. ! 31: * 19.2KB), while smaller patter size (eg. -b4) may help if you've got a printer ! 32: * with a fast processor (eg. a PS-810). ! 33: * ! 34: * The encoding produced by the program (and decoded on the printer) looks like, ! 35: * ! 36: * bytes patterns count ! 37: * ! 38: * where bytes and count are decimal integers and patterns is a hex string. Bytes ! 39: * is the number of bytes represented by the hex patterns and count is the number ! 40: * of additional times the patterns should be repeated. For example, ! 41: * ! 42: * 2 FFFF 4 ! 43: * 5 FFFFFFFFFF 1 ! 44: * 10 FFFFFFFFFFFFFFFFFFFF 0 ! 45: * ! 46: * all represent 10 consecutive bytes of ones. Scanlines are terminated by a 0 on ! 47: * a line by itself. ! 48: * ! 49: * The PostScript prologue is copied from *prologue before any of the input files ! 50: * are translated. The program expects that the following PostScript procedures ! 51: * are defined in that file: ! 52: * ! 53: * setup ! 54: * ! 55: * mark ... setup - ! 56: * ! 57: * Handles special initialization stuff that depends on how this program ! 58: * was called. Expects to find a mark followed by key/value pairs on the ! 59: * stack. The def operator is applied to each pair up to the mark, then ! 60: * the default state is set up. ! 61: * ! 62: * pagesetup ! 63: * ! 64: * page pagesetup - ! 65: * ! 66: * Does whatever is needed to set things up for the next page. Expects ! 67: * to find the current page number on the stack. ! 68: * ! 69: * bitmap ! 70: * ! 71: * v8format flip scanlength scanlines bitmap - ! 72: * ! 73: * Prints the bitmap that's read from standard input. The bitmap consists ! 74: * of scanlines lines, each of which includes scanlength pixels. If ! 75: * v8format is true the picture is assumed to be an Eighth Edition bitmap, ! 76: * and the exclusive-or'ing will be done on the printer. ! 77: * ! 78: * done ! 79: * ! 80: * done ! 81: * ! 82: * Makes sure the last page is printed. Only needed when we're printing ! 83: * more than one page on each sheet of paper. ! 84: * ! 85: * Many default values, like the magnification and orientation, are defined in ! 86: * the prologue, which is where they belong. If they're changed (by options), an ! 87: * appropriate definition is made after the prologue is added to the output file. ! 88: * The -P option passes arbitrary PostScript through to the output file. Among ! 89: * other things it can be used to set (or change) values that can't be accessed by ! 90: * other options. ! 91: * ! 92: */ ! 93: ! 94: #include <stdio.h> ! 95: #include <signal.h> ! 96: #include <ctype.h> ! 97: #include <fcntl.h> ! 98: ! 99: #include "comments.h" /* PostScript file structuring comments */ ! 100: #include "gen.h" /* general purpose definitions */ ! 101: #include "path.h" /* for the prologue */ ! 102: #include "ext.h" /* external variable declarations */ ! 103: ! 104: char *optnames = "a:b:c:fm:n:o:p:ux:y:A:C:E:J:L:P:DI"; ! 105: ! 106: char *prologue = POSTDMD; /* default PostScript prologue */ ! 107: char *formfile = FORMFILE; /* stuff for multiple pages per sheet */ ! 108: ! 109: int bbox[2] = {0, 0}; /* upper right coordinates only */ ! 110: ! 111: int formsperpage = 1; /* page images on each piece of paper */ ! 112: int copies = 1; /* and this many copies of each sheet */ ! 113: ! 114: int bytespp = 6; /* bytes per pattern - on output */ ! 115: int flip = FALSE; /* ones complement the bitmap */ ! 116: int v8undo = TRUE; /* xor'ing done on host if TRUE */ ! 117: int v8format = FALSE; /* for Eighth Edition bitmaps */ ! 118: ! 119: int page = 0; /* last page we worked on */ ! 120: int printed = 0; /* and the number of pages printed */ ! 121: ! 122: int patterns; /* 16 bit patterns per scan line */ ! 123: int scanlines; /* lines in the bitmap */ ! 124: int patcount = 0; /* should be patterns * scanlines */ ! 125: ! 126: char *raster = NULL; /* next raster line */ ! 127: char *prevrast = NULL; /* and the previous one - v8format */ ! 128: char *rptr; /* next free byte in raster */ ! 129: char *eptr; /* one past the last byte in raster */ ! 130: ! 131: FILE *fp_in = NULL; /* read from this file */ ! 132: FILE *fp_out = stdout; /* and write stuff here */ ! 133: FILE *fp_acct = NULL; /* for accounting data */ ! 134: ! 135: /*****************************************************************************/ ! 136: ! 137: main(agc, agv) ! 138: ! 139: int agc; ! 140: char *agv[]; ! 141: ! 142: { ! 143: ! 144: /* ! 145: * ! 146: * A simple program that translates DMD bitmap files into PostScript. There can ! 147: * be more than one bitmap per file, but none can be split across input files. ! 148: * Each bitmap goes on a page by itself. ! 149: * ! 150: */ ! 151: ! 152: argc = agc; /* other routines may want them */ ! 153: argv = agv; ! 154: ! 155: prog_name = argv[0]; /* really just for error messages */ ! 156: ! 157: init_signals(); /* sets up interrupt handling */ ! 158: header(); /* PostScript header comments */ ! 159: options(); /* handle the command line options */ ! 160: setup(); /* for PostScript */ ! 161: arguments(); /* followed by each input file */ ! 162: done(); /* print the last page etc. */ ! 163: account(); /* job accounting data */ ! 164: ! 165: exit(x_stat); /* not much could be wrong */ ! 166: ! 167: } /* End of main */ ! 168: ! 169: /*****************************************************************************/ ! 170: ! 171: init_signals() ! 172: ! 173: { ! 174: ! 175: /* ! 176: * ! 177: * Make sure we handle interrupts. ! 178: * ! 179: */ ! 180: ! 181: if ( signal(SIGINT, interrupt) == SIG_IGN ) { ! 182: signal(SIGINT, SIG_IGN); ! 183: signal(SIGQUIT, SIG_IGN); ! 184: signal(SIGHUP, SIG_IGN); ! 185: } else { ! 186: signal(SIGHUP, interrupt); ! 187: signal(SIGQUIT, interrupt); ! 188: } /* End else */ ! 189: ! 190: signal(SIGTERM, interrupt); ! 191: ! 192: } /* End of init_signals */ ! 193: ! 194: /*****************************************************************************/ ! 195: ! 196: header() ! 197: ! 198: { ! 199: ! 200: int ch; /* return value from getopt() */ ! 201: int old_optind = optind; /* for restoring optind - should be 1 */ ! 202: ! 203: /* ! 204: * ! 205: * Scans the option list looking for things, like the prologue file, that we need ! 206: * right away but could be changed from the default. Doing things this way is an ! 207: * attempt to conform to Adobe's latest file structuring conventions. In particular ! 208: * they now say there should be nothing executed in the prologue, and they have ! 209: * added two new comments that delimit global initialization calls. Once we know ! 210: * where things really are we write out the job header, follow it by the prologue, ! 211: * and then add the ENDPROLOG and BEGINSETUP comments. ! 212: * ! 213: */ ! 214: ! 215: while ( (ch = getopt(argc, argv, optnames)) != EOF ) ! 216: if ( ch == 'L' ) ! 217: prologue = optarg; ! 218: else if ( ch == '?' ) ! 219: error(FATAL, ""); ! 220: ! 221: optind = old_optind; /* get ready for option scanning */ ! 222: ! 223: fprintf(stdout, "%s", CONFORMING); ! 224: fprintf(stdout, "%s %s\n", VERSION, PROGRAMVERSION); ! 225: fprintf(stdout, "%s %s\n", DOCUMENTFONTS, ATEND); ! 226: fprintf(stdout, "%s %s\n", PAGES, ATEND); ! 227: fprintf(stdout, "%s", ENDCOMMENTS); ! 228: ! 229: if ( cat(prologue) == FALSE ) ! 230: error(FATAL, "can't read %s", prologue); ! 231: ! 232: fprintf(stdout, "%s", ENDPROLOG); ! 233: fprintf(stdout, "%s", BEGINSETUP); ! 234: fprintf(stdout, "mark\n"); ! 235: ! 236: } /* End of header */ ! 237: ! 238: /*****************************************************************************/ ! 239: ! 240: options() ! 241: ! 242: { ! 243: ! 244: int ch; /* return value from getopt() */ ! 245: ! 246: /* ! 247: * ! 248: * Reads and processes the command line options. Added the -P option so arbitrary ! 249: * PostScript code can be passed through. Expect it could be useful for changing ! 250: * definitions in the prologue for which options have not been defined. ! 251: * ! 252: */ ! 253: ! 254: while ( (ch = getopt(argc, argv, optnames)) != EOF ) { ! 255: switch ( ch ) { ! 256: case 'a': /* aspect ratio */ ! 257: fprintf(stdout, "/aspectratio %s def\n", optarg); ! 258: break; ! 259: ! 260: case 'b': /* bytes per pattern */ ! 261: bytespp = atoi(optarg); ! 262: break; ! 263: ! 264: case 'c': /* copies */ ! 265: copies = atoi(optarg); ! 266: fprintf(stdout, "/#copies %s store\n", optarg); ! 267: break; ! 268: ! 269: case 'f': /* ones complement - sort of */ ! 270: flip = TRUE; ! 271: break; ! 272: ! 273: case 'm': /* magnification */ ! 274: fprintf(stdout, "/magnification %s def\n", optarg); ! 275: break; ! 276: ! 277: case 'n': /* forms per page */ ! 278: formsperpage = atoi(optarg); ! 279: fprintf(stdout, "%s %s\n", FORMSPERPAGE, optarg); ! 280: fprintf(stdout, "/formsperpage %s def\n", optarg); ! 281: break; ! 282: ! 283: case 'o': /* output page list */ ! 284: out_list(optarg); ! 285: break; ! 286: ! 287: case 'p': /* landscape or portrait mode */ ! 288: if ( *optarg == 'l' ) ! 289: fprintf(stdout, "/landscape true def\n"); ! 290: else fprintf(stdout, "/landscape false def\n"); ! 291: break; ! 292: ! 293: case 'u': /* don't undo Eighth Edition bitmaps */ ! 294: v8undo = FALSE; ! 295: break; ! 296: ! 297: case 'x': /* shift things horizontally */ ! 298: fprintf(stdout, "/xoffset %s def\n", optarg); ! 299: break; ! 300: ! 301: case 'y': /* and vertically on the page */ ! 302: fprintf(stdout, "/yoffset %s def\n", optarg); ! 303: break; ! 304: ! 305: case 'A': /* force job accounting */ ! 306: case 'J': ! 307: if ( (fp_acct = fopen(optarg, "a")) == NULL ) ! 308: error(FATAL, "can't open accounting file %s", optarg); ! 309: break; ! 310: ! 311: case 'C': /* copy file straight to output */ ! 312: if ( cat(optarg) == FALSE ) ! 313: error(FATAL, "can't read %s", optarg); ! 314: break; ! 315: ! 316: case 'E': /* text font encoding - unnecessary */ ! 317: fontencoding = optarg; ! 318: break; ! 319: ! 320: case 'L': /* PostScript prologue file */ ! 321: prologue = optarg; ! 322: break; ! 323: ! 324: case 'P': /* PostScript pass through */ ! 325: fprintf(stdout, "%s\n", optarg); ! 326: break; ! 327: ! 328: case 'R': /* special global or page level request */ ! 329: saverequest(optarg); ! 330: break; ! 331: ! 332: case 'D': /* debug flag */ ! 333: debug = ON; ! 334: break; ! 335: ! 336: case 'I': /* ignore FATAL errors */ ! 337: ignore = ON; ! 338: break; ! 339: ! 340: case '?': /* don't understand the option */ ! 341: error(FATAL, ""); ! 342: break; ! 343: ! 344: default: /* don't know what to do for ch */ ! 345: error(FATAL, "missing case for option %c\n", ch); ! 346: break; ! 347: } /* End switch */ ! 348: } /* End while */ ! 349: ! 350: argc -= optind; /* get ready for non-option args */ ! 351: argv += optind; ! 352: ! 353: } /* End of options */ ! 354: ! 355: /*****************************************************************************/ ! 356: ! 357: setup() ! 358: ! 359: { ! 360: ! 361: /* ! 362: * ! 363: * Handles things that must be done after the options are read but before the ! 364: * input files are processed. ! 365: * ! 366: */ ! 367: ! 368: writerequest(0, stdout); /* global requests eg. manual feed */ ! 369: setencoding(fontencoding); /* unnecessary */ ! 370: fprintf(stdout, "setup\n"); ! 371: ! 372: if ( formsperpage > 1 ) { /* followed by stuff for multiple pages */ ! 373: if ( cat(formfile) == FALSE ) ! 374: error(FATAL, "can't read %s", formfile); ! 375: fprintf(stdout, "%d setupforms\n", formsperpage); ! 376: } /* End if */ ! 377: ! 378: fprintf(stdout, "%s", ENDSETUP); ! 379: ! 380: } /* End of setup */ ! 381: ! 382: /*****************************************************************************/ ! 383: ! 384: arguments() ! 385: ! 386: { ! 387: ! 388: FILE *fp; /* next input file */ ! 389: ! 390: /* ! 391: * ! 392: * Makes sure all the non-option command line arguments are processed. If we get ! 393: * here and there aren't any arguments left, or if '-' is one of the input files ! 394: * we'll process stdin. ! 395: * ! 396: */ ! 397: ! 398: if ( argc < 1 ) ! 399: bitmap(stdin); ! 400: else { /* at least one argument is left */ ! 401: while ( argc > 0 ) { ! 402: if ( strcmp(*argv, "-") == 0 ) ! 403: fp = stdin; ! 404: else if ( (fp = fopen(*argv, "r")) == NULL ) ! 405: error(FATAL, "can't open %s", *argv); ! 406: bitmap(fp); ! 407: if ( fp != stdin ) ! 408: fclose(fp); ! 409: argc--; ! 410: argv++; ! 411: } /* End while */ ! 412: } /* End else */ ! 413: ! 414: } /* End of arguments */ ! 415: ! 416: /*****************************************************************************/ ! 417: ! 418: done() ! 419: ! 420: { ! 421: ! 422: /* ! 423: * ! 424: * Finished with all the input files, so mark the end of the pages with a TRAILER ! 425: * comment, make sure the last page prints, and add things like the PAGES comment ! 426: * that can only be determined after all the input files have been read. ! 427: * ! 428: */ ! 429: ! 430: fprintf(stdout, "%s", TRAILER); ! 431: fprintf(stdout, "done\n"); ! 432: fprintf(stdout, "%s 0 0 %d %d\n", BOUNDINGBOX, (bbox[0]*72+100)/100, (bbox[1]*72+100)/100); ! 433: fprintf(stdout, "%s %d\n", PAGES, printed); ! 434: ! 435: } /* End of done */ ! 436: ! 437: /*****************************************************************************/ ! 438: ! 439: account() ! 440: ! 441: { ! 442: ! 443: /* ! 444: * ! 445: * Writes an accounting record to *fp_acct provided it's not NULL. Accounting is ! 446: * requested using the -A or -J options. ! 447: * ! 448: */ ! 449: ! 450: if ( fp_acct != NULL ) ! 451: fprintf(fp_acct, " print %d\n copies %d\n", printed, copies); ! 452: ! 453: } /* End of account */ ! 454: ! 455: /*****************************************************************************/ ! 456: ! 457: bitmap(fp) ! 458: ! 459: FILE *fp; /* next input file */ ! 460: ! 461: { ! 462: ! 463: int count; /* pattern repeats this many times */ ! 464: long total; /* expect this many patterns */ ! 465: ! 466: /* ! 467: * ! 468: * Reads all the bitmaps from the next input file, translates each one into ! 469: * PostScript, and arranges to have one bitmap printed on each page. Multiple ! 470: * bitmaps per input file work. ! 471: * ! 472: */ ! 473: ! 474: fp_in = fp; /* everyone reads from this file */ ! 475: ! 476: while ( dimensions() == TRUE ) { ! 477: patcount = 0; ! 478: total = scanlines * patterns; ! 479: ! 480: bbox[0] = MAX(bbox[0], patterns*16); /* for BoundingBox comment */ ! 481: bbox[1] = MAX(bbox[1], scanlines); ! 482: ! 483: redirect(++page); ! 484: fprintf(fp_out, "%s %d %d\n", PAGE, page, printed+1); ! 485: fprintf(fp_out, "/saveobj save def\n"); ! 486: writerequest(printed+1, fp_out); ! 487: ! 488: fprintf(fp_out, "%s ", (v8format == TRUE && v8undo == FALSE) ? "true" : "false"); ! 489: fprintf(fp_out, "%s ", (flip == TRUE) ? "true" : "false"); ! 490: fprintf(fp_out, "%d %d bitmap\n", patterns * 16, scanlines); ! 491: ! 492: while ( patcount != total && (count = getc(fp)) != EOF ) { ! 493: addrast(count); ! 494: patcount += (count & 0177); ! 495: if ( patcount % patterns == 0 ) ! 496: putrast(); ! 497: } /* End while */ ! 498: ! 499: if ( debug == ON ) ! 500: fprintf(stderr, "patterns = %d, scanlines = %d, patcount = %d\n", patterns, scanlines, patcount); ! 501: ! 502: if ( total != patcount ) ! 503: error(FATAL, "bitmap format error"); ! 504: ! 505: if ( fp_out == stdout ) printed++; ! 506: ! 507: fprintf(fp_out, "showpage\n"); ! 508: fprintf(fp_out, "saveobj restore\n"); ! 509: fprintf(fp_out, "%s %d %d\n", ENDPAGE, page, printed); ! 510: } /* End while */ ! 511: ! 512: } /* End of bitmap */ ! 513: ! 514: /*****************************************************************************/ ! 515: ! 516: dimensions() ! 517: ! 518: { ! 519: ! 520: int ox, oy; /* coordinates of the origin */ ! 521: int cx, cy; /* and right corner of the bitmap */ ! 522: int i; /* loop index */ ! 523: ! 524: /* ! 525: * ! 526: * Determines the dimensions and type of the next bitmap. Eighth edition bitmaps ! 527: * have a zero in the first 16 bits. If valid dimensions are read TRUE is returned ! 528: * to the caller. Changed so the check of whether we're done (by testing scanlines ! 529: * or patterns) comes before the malloc(). ! 530: * ! 531: */ ! 532: ! 533: if ( (scanlines = getint()) == 0 ) { ! 534: ox = getint(); ! 535: oy = getint(); ! 536: cx = getint(); ! 537: cy = getint(); ! 538: scanlines = cy - oy; ! 539: patterns = (cx - ox + 15) / 16; ! 540: v8format = TRUE; ! 541: } else patterns = getint(); ! 542: ! 543: if ( scanlines <= 0 || patterns <= 0 ) /* done - don't do the malloc() */ ! 544: return(FALSE); ! 545: ! 546: if ( raster != NULL ) free(raster); ! 547: if ( prevrast != NULL ) free(prevrast); ! 548: ! 549: if ( (rptr = raster = (char *) malloc(patterns * 2)) == NULL ) ! 550: error(FATAL, "no memory"); ! 551: ! 552: if ( (prevrast = (char *) malloc(patterns * 2)) == NULL ) ! 553: error(FATAL, "no memory"); ! 554: ! 555: for ( i = 0; i < patterns * 2; i++ ) ! 556: *(prevrast+i) = 0377; ! 557: ! 558: eptr = rptr + patterns * 2; ! 559: ! 560: return(TRUE); ! 561: ! 562: } /* End of dimensions */ ! 563: ! 564: /*****************************************************************************/ ! 565: ! 566: addrast(count) ! 567: ! 568: int count; /* repeat count for next pattern */ ! 569: ! 570: { ! 571: ! 572: int size; /* number of bytes in next pattern */ ! 573: int l, h; /* high and low bytes */ ! 574: int i, j; /* loop indices */ ! 575: ! 576: /* ! 577: * ! 578: * Reads the input file and adds the appropriate number of bytes to the output ! 579: * raster line. If count has bit 7 on, one 16 bit pattern is read and repeated ! 580: * count & 0177 times. If bit 7 is off, count is the number of patterns read from ! 581: * fp_in - each one repeated once. ! 582: * ! 583: */ ! 584: ! 585: if ( count & 0200 ) { ! 586: size = 1; ! 587: count &= 0177; ! 588: } else { ! 589: size = count; ! 590: count = 1; ! 591: } /* End else */ ! 592: ! 593: for ( i = size; i > 0; i-- ) { ! 594: if ( (l = getc(fp_in)) == EOF || (h = getc(fp_in)) == EOF ) ! 595: return; ! 596: for ( j = count; j > 0; j-- ) { ! 597: *rptr++ = l; ! 598: *rptr++ = h; ! 599: } /* End for */ ! 600: } /* End for */ ! 601: ! 602: } /* End of addrast */ ! 603: ! 604: /*****************************************************************************/ ! 605: ! 606: putrast() ! 607: ! 608: { ! 609: ! 610: char *p1, *p2; /* starting and ending patterns */ ! 611: int n; /* set to bytes per pattern */ ! 612: int i; /* loop index */ ! 613: ! 614: /* ! 615: * ! 616: * Takes the scanline that's been saved in *raster, encodes it according to the ! 617: * value that's been assigned to bytespp, and writes the result to *fp_out. Each ! 618: * line in the output bitmap is terminated by a 0 on a line by itself. ! 619: * ! 620: */ ! 621: ! 622: n = (bytespp <= 0) ? 2 * patterns : bytespp; ! 623: ! 624: if ( v8format == TRUE && v8undo == TRUE ) ! 625: for ( i = 0; i < patterns * 2; i++ ) ! 626: *(raster+i) = (*(prevrast+i) ^= *(raster+i)); ! 627: ! 628: for ( p1 = raster, p2 = raster + n; p1 < eptr; p1 = p2 ) ! 629: if ( patncmp(p1, n) == TRUE ) { ! 630: while ( patncmp(p2, n) == TRUE ) p2 += n; ! 631: p2 += n; ! 632: fprintf(fp_out, "%d ", n); ! 633: for ( i = 0; i < n; i++, p1++ ) ! 634: fprintf(fp_out, "%.2X", ((int) *p1) & 0377); ! 635: fprintf(fp_out, " %d\n", (p2 - p1) / n); ! 636: } else { ! 637: while ( p2 < eptr && patncmp(p2, n) == FALSE ) p2 += n; ! 638: if ( p2 > eptr ) p2 = eptr; ! 639: fprintf(fp_out, "%d ", p2 - p1); ! 640: while ( p1 < p2 ) ! 641: fprintf(fp_out, "%.2X", ((int) *p1++) & 0377); ! 642: fprintf(fp_out, " 0\n"); ! 643: } /* End else */ ! 644: ! 645: fprintf(fp_out, "0\n"); ! 646: ! 647: rptr = raster; ! 648: ! 649: } /* End of putrast */ ! 650: ! 651: /*****************************************************************************/ ! 652: ! 653: patncmp(p1, n) ! 654: ! 655: char *p1; /* first patterns starts here */ ! 656: int n; /* and extends this many bytes */ ! 657: ! 658: { ! 659: ! 660: char *p2; /* address of the second pattern */ ! 661: ! 662: /* ! 663: * ! 664: * Compares the two n byte patterns *p1 and *(p1+n). FALSE is returned if they're ! 665: * different or extend past the end of the current raster line. ! 666: * ! 667: */ ! 668: ! 669: p2 = p1 + n; ! 670: ! 671: for ( ; n > 0; n--, p1++, p2++ ) ! 672: if ( p2 >= eptr || *p1 != *p2 ) ! 673: return(FALSE); ! 674: ! 675: return(TRUE); ! 676: ! 677: } /* End of patncmp */ ! 678: ! 679: /*****************************************************************************/ ! 680: ! 681: getint() ! 682: ! 683: { ! 684: ! 685: int h, l; /* high and low bytes */ ! 686: ! 687: /* ! 688: * ! 689: * Reads the next two bytes from *fp_in and returns the resulting integer. ! 690: * ! 691: */ ! 692: ! 693: if ( (l = getc(fp_in)) == EOF || (h = getc(fp_in)) == EOF ) ! 694: return(-1); ! 695: ! 696: return((h & 0377) << 8 | (l & 0377)); ! 697: ! 698: } /* End of getint */ ! 699: ! 700: /*****************************************************************************/ ! 701: ! 702: redirect(pg) ! 703: ! 704: int pg; /* next page we're printing */ ! 705: ! 706: { ! 707: ! 708: static FILE *fp_null = NULL; /* if output is turned off */ ! 709: ! 710: /* ! 711: * ! 712: * If we're not supposed to print page pg, fp_out will be directed to /dev/null, ! 713: * otherwise output goes to stdout. ! 714: * ! 715: */ ! 716: ! 717: if ( pg >= 0 && in_olist(pg) == ON ) ! 718: fp_out = stdout; ! 719: else if ( (fp_out = fp_null) == NULL ) ! 720: fp_out = fp_null = fopen("/dev/null", "w"); ! 721: ! 722: } /* End of redirect */ ! 723: ! 724: /*****************************************************************************/ ! 725:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.