![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to maha.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / dipress / src / bin / maha|
Return to maha.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / dipress / src / bin / maha |
1.1 ! root 1: /* ! 2: * maharani - a czarina-like program that generates interpress files ! 3: * ! 4: * Written for Xerox Corporation by William LeFebvre ! 5: * ! 6: * Copyright (c) 1984, 1985, 1986 Xerox Corporation ! 7: * ! 8: * HISTORY ! 9: * 23-Sep-86 Lee Moore (lee) at Xerox Webster Research Center ! 10: * Added Jim Mayer's fix to the space allocator. ! 11: * ! 12: * 13-apr-86 Ed Flint (ed) at Xerox Webster Research Center ! 13: * do_file will reset to left margin when encountering carriage return ! 14: * ! 15: * 11-Feb-86 Lee Moore (lee) at Xerox Webster Research Center ! 16: * Added various suggestions from Larry Parmalee at Cornell U. ! 17: * 1) Margin adjustments. Margins vary according to portrait or ! 18: * landscape mode. If headings are suppressed, then that area ! 19: * is used for text. Room left to punch holes at left. ! 20: * 2) Baseline spacing is tightened up for smaller font sizes ! 21: * 3) options can now reset each other ! 22: * 4) added "-P" option to specifiy output device (for compatibility ! 23: * with lpr system stuff.) ! 24: * 5) Improved maha environment variable handling (pair up and eliminate ! 25: * double and single quotes). ! 26: * 6) Interpress file now has mode 600 (for security reasons) ! 27: * 7) Maximum line length increased. ! 28: * ! 29: * 13-Jan-86 Lee Moore (lee) at Xerox Webster Research Center ! 30: * Changed a call to strcpyn to strncpy. ! 31: * ! 32: * 8-apr-85 ed flint ! 33: * conditional compilation for vax11-c (vms) ! 34: * ! 35: * 26-mar-85 ed flint @ Xerox, WRC ! 36: * add fclose after do_file to prevent running out of open file descriptors ! 37: */ ! 38: ! 39: #ifdef vax11c ! 40: # include stdio ! 41: # include ssdef ! 42: # include ctype ! 43: # include descrip ! 44: #else ! 45: # include <stdio.h> ! 46: # include <pwd.h> ! 47: # include <strings.h> ! 48: # include <sys/types.h> ! 49: # include <sys/stat.h> ! 50: # include <sys/time.h> ! 51: #endif ! 52: ! 53: # include "iptokens.h" ! 54: # include "literal.h" ! 55: # include "operator.h" ! 56: ! 57: ! 58: /* ! 59: * the following defines a program that will queue an Interpress master ! 60: * for printing ! 61: */ ! 62: # define QIP "qip" ! 63: ! 64: # define Break_size 1024 ! 65: # define Default_universal_prefix "Xerox/XC1-1-1/" ! 66: # define Line_size 192 /* upped from 132 */ ! 67: ! 68: /* All page boundaries are computed in the 1/10 point co-ordinate system */ ! 69: /* ! 70: * Orig_y is an offset from the top of the page. It must be converted ! 71: * to a measurement from the bottom of the page (a calculation that is ! 72: * rotation-dependent). ! 73: */ ! 74: ! 75: # define INCH 720 ! 76: # define Half_INCH 360 ! 77: # define Sixth_INCH 120 /* one line at 6 lpi */ ! 78: # define Page_width (8 * INCH + Half_INCH) ! 79: # define Page_length (11 * INCH) ! 80: /* rflg ? Landscape mode : Portrait mode */ ! 81: # define Orig_x (rflg ? (1.5 * INCH/10) : (9 * INCH/10)) ! 82: # define Orig_y (rflg ? (Sixth_INCH * 8) : (Sixth_INCH * 5)) ! 83: # define Header_to_orig_x 0 ! 84: # define Header_to_orig_y (2 * Sixth_INCH) ! 85: ! 86: /* Frame variable defines */ ! 87: # define F_transform 0 ! 88: # define F_headfont 1 ! 89: # define F_bodyfont 2 ! 90: # define F_italicfont 3 ! 91: ! 92: # define No 0 ! 93: # define Yes 1 ! 94: ! 95: extern int errno; ! 96: ! 97: /* enum, perhaps? */ ! 98: typedef char boolean; ! 99: ! 100: /* routines that return something other than int */ ! 101: char *strecpy(); ! 102: char *allocate(); ! 103: char *next_arg(); ! 104: char *sbrk(); ! 105: char *getenv(); ! 106: char *itoa(); ! 107: char *rindex(); ! 108: ! 109: /* option flags */ ! 110: boolean lflg = No; /* line printer mode */ ! 111: boolean rflg = No; /* rotation - landscape mode */ ! 112: boolean tflg = No; /* omit title */ ! 113: ! 114: /* valued options */ ! 115: int columns = 1; ! 116: char *bodyfont_name = "Vintage-Printwheel/10"; ! 117: char *headfont_name = "Modern-Bold/12"; ! 118: char *italicfont_name = "Modern-Bold-Italic/12"; ! 119: char *banner = NULL; ! 120: char *copies = "1"; ! 121: char *printer = NULL; /* destination printer */ ! 122: char *header = "%f %t Page %p, line %l"; ! 123: char *name = NULL; ! 124: char *output = NULL; ! 125: char *pages = NULL; ! 126: ! 127: #ifdef vax11c ! 128: char *template = "IPPXXXXXX"; ! 129: #endif ! 130: ! 131: /* ! 132: * page characteristics: these variables define the extremes for the ! 133: * current page or column. 'column_separation' is the distance between ! 134: * the left sides of each column on the page. ! 135: */ ! 136: #ifndef notdef ! 137: int left_margin = (9 * INCH / 10); /* x origin in portrait mode */ ! 138: #else ! 139: int left_margin = Orig_x; ! 140: #endif ! 141: int right_margin; ! 142: int top_margin; ! 143: int bottom_margin; ! 144: int column_separation; ! 145: ! 146: /* sundries */ ! 147: boolean send_to_printer = Yes; ! 148: char real_header[256]; /* header built here */ ! 149: char *myname; /* name invoked with */ ! 150: char *filename; ! 151: int *page_select = NULL; /* array of page selections */ ! 152: int *curr_page_select; ! 153: int page_low; ! 154: int page_high; ! 155: int ipress_file; /* interpress file descriptor */ ! 156: int null_file; /* fd for /dev/null */ ! 157: int line_number; ! 158: int page_number; ! 159: int pages_printed = 0; /* total pages for this interpress file */ ! 160: int special_font = 0; /* fonts that require special handling */ ! 161: int line_spacing; ! 162: int tab_amount = 8; ! 163: #ifndef vax11c ! 164: struct passwd *pwd; /* passwd entry for this user */ ! 165: struct stat file_stat; /* stat of current file */ ! 166: #endif ! 167: ! 168: # define Font_Terminal 1 ! 169: ! 170: /* current arguments */ ! 171: int argc; ! 172: char **argv; ! 173: ! 174: /* font structure definition */ ! 175: struct font ! 176: { ! 177: char *ft_universal_name; ! 178: char *ft_leaf_name; ! 179: int ft_size; ! 180: }; ! 181: ! 182: /* fonts used */ ! 183: struct font headfont; ! 184: struct font bodyfont; ! 185: struct font italicfont; ! 186: ! 187: main(_argc, _argv) ! 188: ! 189: int _argc; ! 190: char **_argv; ! 191: ! 192: { ! 193: char *ptr; /* temporary pointers used for loops and such */ ! 194: char *src; ! 195: char *dest; ! 196: int length; ! 197: int i; ! 198: FILE *file; /* file currently processing */ ! 199: #ifdef vax11c ! 200: int error; ! 201: int retlen; ! 202: char command[256]; ! 203: $DESCRIPTOR(mahadesc,"MAHAENV"); ! 204: $DESCRIPTOR(cmddesc,command); ! 205: #endif ! 206: ! 207: /* get our name */ ! 208: if (_argc < 1) ! 209: { ! 210: exit(1); ! 211: } ! 212: ! 213: #ifdef vax11c ! 214: myname= _argv[0]; ! 215: #else ! 216: if ((myname = rindex(_argv[0], '/')) == NULL) ! 217: { ! 218: myname = _argv[0]; ! 219: } ! 220: else ! 221: { ! 222: myname++; ! 223: } ! 224: #endif ! 225: ! 226: /* get the options specified in the environment (defaults) */ ! 227: ! 228: #ifdef vax11c ! 229: if ( (error= lib$get_symbol(&mahadesc,&cmddesc,&retlen)) == SS$_NORMAL ) ! 230: { ! 231: if ( retlen != 0 ) ! 232: { ! 233: command[retlen & 0xff]= '\0'; /* null terminate string */ ! 234: src= command; ! 235: /* break the string up into null terminated arguments */ ! 236: /* half the length is a good upper bound on number of arguments */ ! 237: argv = (char **)allocate(strlen(src) / 2); ! 238: for (argc = 1, ptr = src; *ptr != '\0'; argc++) ! 239: { ! 240: while (*ptr == ' ') ! 241: ptr++; ! 242: argv[argc] = ptr; ! 243: while (*ptr != ' ' && *ptr != '\0') ! 244: { ! 245: if (*ptr == '"') ! 246: { ! 247: while (*++ptr != '"' && *ptr != '\0'); ! 248: } ! 249: else if (*ptr == '\'') ! 250: { ! 251: while (*++ptr != '\'' && *ptr != '\0'); ! 252: } ! 253: ptr++; ! 254: } ! 255: *ptr++ = '\0'; ! 256: } ! 257: ! 258: /* terminate the argument list */ ! 259: argv[argc] = NULL; ! 260: ! 261: /* process the options found in the environment */ ! 262: get_options(); ! 263: } ! 264: } ! 265: ! 266: #else ! 267: if ((src = getenv("MAHA")) != NULL) ! 268: { ! 269: /* break the string up into null terminated arguments */ ! 270: /* half the length is a good upper bound on number of arguments */ ! 271: argv = (char **)allocate(strlen(src) / 2); ! 272: for (argc = 1, ptr = src; *ptr != '\0'; argc++) ! 273: { ! 274: register char *dst; ! 275: char quote; ! 276: ! 277: while (*ptr == ' ') ! 278: ptr++; ! 279: argv[argc] = dst = ptr; ! 280: while (*ptr != ' ' && *ptr != '\0') ! 281: { ! 282: if (*ptr == '"' || *ptr == '\'') ! 283: { ! 284: quote = *ptr++; /* Save + skip quote */ ! 285: ! 286: while( *ptr != quote && *ptr != '\0') ! 287: *dst++ = *ptr++; ! 288: ! 289: if (*ptr != '\0') ! 290: ptr++; /* Skip closing quote */ ! 291: } ! 292: else ! 293: *dst++ = *ptr++; ! 294: } ! 295: if (*ptr != '\0') ! 296: ptr++; /* skip 1st trailing space */ ! 297: ! 298: *dst = '\0'; /* end arg. */ ! 299: } ! 300: ! 301: /* terminate the argument list */ ! 302: argv[argc] = NULL; ! 303: ! 304: /* process the options found in the environment */ ! 305: get_options(); ! 306: } ! 307: #endif ! 308: ! 309: /* use the real arguments */ ! 310: argc = _argc; ! 311: argv = _argv; ! 312: ! 313: /* process (real) arguments */ ! 314: get_options(); ! 315: ! 316: /* establish and verify the requested fonts */ ! 317: establish_font(headfont_name, &headfont); ! 318: establish_font(bodyfont_name, &bodyfont); ! 319: establish_font(italicfont_name, &italicfont); ! 320: ! 321: #ifndef vax11c ! 322: /* get passwd entry for future reference */ ! 323: pwd = getpwuid(geteuid()); ! 324: #endif ! 325: ! 326: /* setup output file */ ! 327: if (output == NULL) ! 328: { ! 329: ! 330: /* build a temporary file name */ ! 331: ! 332: #ifdef vax11c ! 333: output= mktemp(template); ! 334: #else ! 335: output = allocate(1 + 5 + 1 + 2 + 1); ! 336: (void) sprintf(output, "/tmp/@%d.ip", getpid()); ! 337: #endif ! 338: } ! 339: ! 340: #ifdef vax11c ! 341: if ((ipress_file = creat(output, 0, "rfm=udf")) == -1) ! 342: #else ! 343: if ((ipress_file = creat(output, 0600)) == -1) ! 344: #endif ! 345: { ! 346: system_error(output); ! 347: exit(1); ! 348: } ! 349: ip_select(ipress_file); ! 350: ! 351: #ifndef vax11c ! 352: /* open the null device for throwing away output */ ! 353: null_file = open("/dev/null", 1); ! 354: ! 355: /* set null strings to default values */ ! 356: if (name == NULL) ! 357: { ! 358: /* banner name defaults to full name from gecos field */ ! 359: name = pwd->pw_gecos; ! 360: ! 361: /* perform expansion and stripping */ ! 362: if ((ptr = index(name, ',')) != NULL) ! 363: { ! 364: *ptr = '\0'; /* this affects pwd->pw_gecos, too! */ ! 365: } ! 366: if (index(name, '&') != NULL) ! 367: { ! 368: name = allocate(strlen(name) + strlen(pwd->pw_name) + 1); ! 369: for (src = pwd->pw_gecos, dest = name; *src != '\0'; src++, dest++) ! 370: { ! 371: if (*src == '&') ! 372: { ! 373: for (ptr = pwd->pw_name; *ptr != '\0'; ptr++) ! 374: { ! 375: *dest++ = *ptr; ! 376: } ! 377: } ! 378: else ! 379: { ! 380: *dest = *src; ! 381: } ! 382: } ! 383: } ! 384: } ! 385: #endif ! 386: ! 387: if (banner == NULL) ! 388: { ! 389: /* banner defaults to file name(s) */ ! 390: if (argc == 0) ! 391: { ! 392: banner = "out of the blue"; ! 393: } ! 394: else ! 395: { ! 396: for (length = 0, i = 0; i < argc; i++) ! 397: { ! 398: length += strlen(argv[i]) + 2; ! 399: } ! 400: banner = allocate(length + 1); ! 401: for (ptr = banner, i = 0; i < argc; i++) ! 402: { ! 403: ptr = strecpy(ptr, argv[i]); ! 404: ptr = strecpy(ptr, ", "); ! 405: } ! 406: ptr -= 2; ! 407: *ptr = '\0'; ! 408: } ! 409: } ! 410: ! 411: /* unravel the page specifiation */ ! 412: /* we will never need more than strlen(pages) ints to hold the info */ ! 413: if (pages != NULL) ! 414: { ! 415: page_select = (int *)allocate(strlen(pages) * sizeof(int)); ! 416: unravel_pages(pages, page_select); ! 417: } ! 418: ! 419: /* write the preamble for the interpress file */ ! 420: AppendOp(OP_beginBlock); ! 421: AppendOp(OP_beginBody); /* preamble start */ ! 422: ! 423: /* setup font definitions in frame */ ! 424: SetupFont(headfont.ft_universal_name, ! 425: headfont.ft_size * 10., ! 426: F_headfont); ! 427: SetupFont(bodyfont.ft_universal_name, ! 428: bodyfont.ft_size * 10., ! 429: F_bodyfont); ! 430: SetupFont(italicfont.ft_universal_name, ! 431: headfont.ft_size * 10., /* use headfont's size */ ! 432: F_italicfont); ! 433: ! 434: /* remember special fonts */ ! 435: if (strcmp(bodyfont.ft_leaf_name, "Terminal") == 0) ! 436: { ! 437: special_font = Font_Terminal; ! 438: } ! 439: ! 440: /* save scaling transform that uses 1/10 point co-ordinate system */ ! 441: top_margin = (rflg ? Page_width : Page_length) - Orig_y; ! 442: ! 443: if (tflg) /* the user may not want headings... */ ! 444: top_margin += Header_to_orig_y; /* use heading area */ ! 445: ! 446: bottom_margin = 2 * Sixth_INCH; ! 447: right_margin = (rflg ? Page_length : Page_width) - Orig_x; ! 448: column_separation = (right_margin - Orig_x) / columns; ! 449: line_spacing = (bodyfont.ft_size + ! 450: ((bodyfont.ft_size > 8) ? 2 : 0)) * 10; ! 451: if (rflg) ! 452: { ! 453: /* we need a rotation transform, too */ ! 454: Rotate(90.); ! 455: Translate((double)Page_width, (double)0); ! 456: } ! 457: AppendRational(353L,10000000L); ! 458: AppendOp(OP_scale); ! 459: if (rflg) ! 460: { ! 461: AppendOp(OP_concat); ! 462: AppendOp(OP_concat); ! 463: } ! 464: AppendInteger((long) F_transform); ! 465: AppendOp(OP_fset); ! 466: ! 467: AppendOp(OP_endBody); /* end preamble */ ! 468: ! 469: if (argc == 0) ! 470: { ! 471: /* no filenames -- do standard input */ ! 472: filename = NULL; ! 473: do_file(stdin); ! 474: } ! 475: ! 476: for (; argc > 0; argc--, argv++) ! 477: { ! 478: filename = argv[0]; ! 479: if (strcmp(filename, "-") == 0) ! 480: { ! 481: /* this is really standard input */ ! 482: filename = NULL; ! 483: do_file(stdin); ! 484: } ! 485: else ! 486: { ! 487: /* open the file */ ! 488: if ((file = fopen(filename, "r")) == NULL) ! 489: { ! 490: system_error(filename); ! 491: } ! 492: else ! 493: { ! 494: do_file(file); ! 495: (void) fclose(file); ! 496: } ! 497: } ! 498: } ! 499: ! 500: /* wrap up the output */ ! 501: ip_select(ipress_file); ! 502: AppendOp(OP_endBlock); ! 503: ip_close(); ! 504: ! 505: /* send to the printer */ ! 506: if (send_to_printer) ! 507: { ! 508: if (pages_printed == 0) ! 509: { ! 510: /* don't print anything but remove temporary */ ! 511: #ifdef vax11c ! 512: delete(output); ! 513: #else ! 514: (void) unlink(output); ! 515: #endif ! 516: } ! 517: else ! 518: { ! 519: #ifdef vax11c ! 520: char buff[256]; ! 521: int wait= 0; ! 522: $DESCRIPTOR(buffdesc,buff); ! 523: ! 524: (void) strcpy(buff,"xpress/noformat "); ! 525: (void) strcat(buff,output); ! 526: buffdesc.dsc$w_length= strlen(buff); ! 527: if ( (error= lib$spawn(&buffdesc,0,0,&wait)) != SS$_NORMAL ) ! 528: { ! 529: fprintf(stderr,"\nFile %s contains interpress master\n",output); ! 530: exit(error); ! 531: } ! 532: delete(output); ! 533: #else ! 534: char *buff; ! 535: ! 536: /* exec a "qip" to queue the file */ ! 537: buff = allocate(strlen(name) + 1 + 1); ! 538: (void) strcpy(buff, "F"); ! 539: (void) strcat(buff, name); ! 540: ! 541: if (printer) ! 542: execlp(QIP, "qip", "-q", printer, "-c", copies, "-nc", "-nk", ! 543: "-t", banner, "-x", buff, output, 0); ! 544: else ! 545: execlp(QIP, "qip", "-c", copies, "-nc", "-nk", ! 546: "-t", banner, "-x", buff, output, 0); ! 547: ! 548: fprintf(stderr, "Can't execl the queing program: %s\n", QIP); ! 549: perror(QIP); ! 550: fprintf(stderr, "File %s contains interpress master.\n", output); ! 551: exit(1); ! 552: #endif ! 553: } ! 554: } ! 555: } ! 556: ! 557: get_options() ! 558: ! 559: { ! 560: while (--argc > 0) ! 561: { ! 562: argv++; ! 563: if (!process_arg()) ! 564: { ! 565: break; ! 566: } ! 567: } ! 568: } ! 569: ! 570: /* ! 571: * unravel_pages(str, spec) - unravel the page range specification in "str" ! 572: * into integer pairs in "spec". The first two ! 573: * ints in "spec" bound the first range of pages, ! 574: * the next two bound the second range, and so on. ! 575: * The array is terminated with the pair 0, 0. ! 576: */ ! 577: ! 578: unravel_pages(str, spec) ! 579: ! 580: char *str; ! 581: int *spec; ! 582: ! 583: { ! 584: int last_num = 0; ! 585: int this_num = 0; ! 586: register char ch; ! 587: boolean is_range = No; ! 588: boolean bad_spec = No; ! 589: boolean done = No; ! 590: ! 591: # define Start_new_num (last_num = this_num, this_num = 0) ! 592: ! 593: while (!done) ! 594: { ! 595: if ((ch = *str++) == '\0') ! 596: { ! 597: /* set "done" flag and pretend it's the end of a number */ ! 598: done = Yes; ! 599: ch = ','; ! 600: } ! 601: if (ch >= '0' && ch <= '9') ! 602: { ! 603: this_num *= 10; ! 604: this_num += ch - '0'; ! 605: } ! 606: else if (ch == '-') ! 607: { ! 608: if (this_num < last_num && *str != '\0') ! 609: { ! 610: bad_spec = Yes; ! 611: } ! 612: *spec++ = this_num; ! 613: Start_new_num; ! 614: is_range = Yes; ! 615: } ! 616: else if (ch == ',') ! 617: { ! 618: if (this_num < last_num) ! 619: { ! 620: bad_spec = Yes; ! 621: } ! 622: *spec++ = this_num; ! 623: if (is_range) ! 624: { ! 625: is_range = No; ! 626: } ! 627: else ! 628: { ! 629: *spec++ = this_num; ! 630: } ! 631: Start_new_num; ! 632: } ! 633: else ! 634: { ! 635: fprintf(stderr, "%s: bad character in page specification\n", ! 636: myname); ! 637: exit(1); ! 638: } ! 639: } ! 640: if (*--spec == 0) ! 641: { ! 642: *spec = 1 << 15; /* infinity */ ! 643: } ! 644: if (bad_spec) ! 645: { ! 646: fprintf(stderr, ! 647: "%s: pages should be given in non-descending order.\n", ! 648: myname); ! 649: } ! 650: } ! 651: ! 652: process_arg() ! 653: ! 654: { ! 655: register char ch; ! 656: register int temp; ! 657: register char *p1; ! 658: register char *p2; ! 659: ! 660: if (argv[0][0] == '-') ! 661: { ! 662: if ((ch = argv[0][1]) > '0' && ch <= '9') ! 663: { ! 664: /* this is a column count specifier */ ! 665: columns = ch - '0'; ! 666: } ! 667: else switch(ch) ! 668: { ! 669: case '\0': /* not an option */ ! 670: return(No); ! 671: ! 672: case 'b': ! 673: banner = next_arg(); ! 674: break; ! 675: ! 676: case 'c': ! 677: temp = atoi(copies = next_arg()); ! 678: if (temp < 1) ! 679: { ! 680: fprintf(stderr, ! 681: "%s: bogus number of copies; you only get one!\n", ! 682: myname); ! 683: copies = "1"; ! 684: } ! 685: break; ! 686: ! 687: case 'f': ! 688: bodyfont_name = next_arg(); ! 689: break; ! 690: ! 691: case 'F': ! 692: headfont_name = next_arg(); ! 693: break; ! 694: ! 695: case 'H': /* replace header */ ! 696: tflg = No; ! 697: header = next_arg(); ! 698: break; ! 699: ! 700: case 'h': /* append to header */ ! 701: tflg = No; ! 702: p1 = next_arg(); ! 703: p2 = allocate(strlen(header) + strlen(p1) + 1); ! 704: (void) strcpy(p2, header); ! 705: (void) strcat(p2, " "); ! 706: (void) strcat(p2, p1); ! 707: header = p2; ! 708: break; ! 709: ! 710: case 'l': ! 711: tflg = lflg = Yes; ! 712: break; ! 713: ! 714: case 'n': ! 715: name = next_arg(); ! 716: break; ! 717: ! 718: case 'o': ! 719: output = next_arg(); ! 720: send_to_printer = No; ! 721: break; ! 722: ! 723: case 'P': ! 724: printer = next_arg(); ! 725: break; ! 726: ! 727: case 'r': ! 728: rflg = Yes; ! 729: break; ! 730: ! 731: case 'R': ! 732: rflg = No; ! 733: break; ! 734: ! 735: case 's': ! 736: pages = next_arg(); ! 737: break; ! 738: ! 739: case 't': ! 740: tflg = Yes; ! 741: break; ! 742: ! 743: default: ! 744: fprintf(stderr, "%s: unknown option '%c'\n", myname, ch); ! 745: } ! 746: return(Yes); ! 747: } ! 748: else ! 749: { ! 750: return(No); ! 751: } ! 752: } ! 753: ! 754: char *next_arg() ! 755: ! 756: { ! 757: if (argv[0][2] == '\0') ! 758: { ! 759: if (--argc > 0) ! 760: { ! 761: return((++argv)[0]); ! 762: } ! 763: else ! 764: { ! 765: argv++; ! 766: return(NULL); ! 767: } ! 768: } ! 769: else ! 770: { ! 771: return(&(argv[0][2])); ! 772: } ! 773: } ! 774: ! 775: /* ! 776: * establish_font(name, font) - break apart the parts of the string "name" ! 777: * and fill in the structure pointed to by ! 778: * "font". Also, verify that the font requested ! 779: * actually exists. This routine also ! 780: * understands universal font names. ! 781: */ ! 782: ! 783: establish_font(name, font) ! 784: ! 785: char *name; ! 786: struct font *font; ! 787: ! 788: { ! 789: register char *unamep; ! 790: register char *ptr; ! 791: char *slashp; ! 792: register int size; ! 793: ! 794: if (name[0] != '/') ! 795: { ! 796: /* not a universal name -- put the default on the front */ ! 797: font->ft_universal_name = unamep = ! 798: allocate(strlen(Default_universal_prefix) + ! 799: strlen(name) + 1); ! 800: (void) strcpy(unamep, Default_universal_prefix); ! 801: (void) strcat(unamep, name); ! 802: } ! 803: else ! 804: { ! 805: /* already is a universal name -- just allocate space for it */ ! 806: font->ft_universal_name = unamep = allocate(strlen(name)); ! 807: ! 808: /* copy in the whole name, without the leading slash */ ! 809: (void) strcpy(unamep, name + 1); ! 810: } ! 811: ! 812: /* strip size off the end, if it is there */ ! 813: if ((slashp = ptr = rindex(unamep, '/')) != NULL) ! 814: { ! 815: register char ch; ! 816: ! 817: size = 0; ! 818: while ((ch = *++ptr) != '\0') ! 819: { ! 820: if (ch < '0' || ch > '9') ! 821: { ! 822: /* last element is not a number -- no point size */ ! 823: size = 0; ! 824: break; ! 825: } ! 826: ! 827: /* shift this digit in */ ! 828: size *= 10; ! 829: size += (ch - '0'); ! 830: } ! 831: ! 832: /* if no point size, use default */ ! 833: if (size == 0) ! 834: { ! 835: font->ft_size = 10; ! 836: } ! 837: else ! 838: { ! 839: font->ft_size = size; ! 840: *slashp = '\0'; ! 841: } ! 842: } ! 843: ! 844: /* set pointer to last element */ ! 845: if ((ptr = rindex(unamep, '/')) != NULL) ! 846: { ! 847: font->ft_leaf_name = ptr + 1; ! 848: } ! 849: else ! 850: { ! 851: font->ft_leaf_name = font->ft_universal_name; ! 852: } ! 853: } ! 854: ! 855: do_file(file) ! 856: ! 857: FILE *file; ! 858: ! 859: { ! 860: char *src; ! 861: char *dest; ! 862: char input_line[Line_size]; ! 863: char line_buffer[Line_size]; ! 864: char ch; ! 865: int current_line; ! 866: int lines_on_page; ! 867: int length; ! 868: int column; ! 869: ! 870: #ifndef vax11c ! 871: /* fstat it to get information displayed in the header */ ! 872: if (fstat(fileno(file), &file_stat) == -1) ! 873: { ! 874: system_error("fstat botched"); ! 875: return; ! 876: } ! 877: #endif ! 878: ! 879: /* reset essentials */ ! 880: page_number = 0; ! 881: line_number = 1; ! 882: lines_on_page = 0; ! 883: curr_page_select = page_select; ! 884: if (pages != NULL) ! 885: { ! 886: page_low = page_select[0]; ! 887: page_high = page_select[1]; ! 888: } ! 889: current_line = top_margin; ! 890: ! 891: /* ! 892: * Strangeness: page_number is incremented by page_start and ! 893: * line_number is incremented in the "while(fgets..." loop. ! 894: */ ! 895: ! 896: /* start the first page */ ! 897: page_start(); ! 898: ! 899: /* ! 900: * More strangeness: we had to set line_number to 1 to trick ! 901: * page_start into reporting the right line count in the header. Now ! 902: * we reset it to 0 before entering the read/print loop. ! 903: */ ! 904: line_number = 0; ! 905: ! 906: while (fgets(input_line, Line_size, file) != NULL) ! 907: { ! 908: /* new line */ ! 909: line_number++; ! 910: ! 911: /* remember the length */ ! 912: length = strlen(input_line); ! 913: ! 914: /* nuke any trailing newline */ ! 915: if (input_line[length - 1] == '\n') ! 916: { ! 917: input_line[--length] = '\0'; ! 918: } ! 919: ! 920: if (lflg ? lines_on_page >= 66 : current_line < bottom_margin) ! 921: { ! 922: /* start a new page */ ! 923: page_end(No); ! 924: page_start(); ! 925: lines_on_page = 0; ! 926: ! 927: /* remember, y goes backwards */ ! 928: current_line = top_margin; ! 929: } ! 930: ! 931: /* make sure that the line actually contains something */ ! 932: if (input_line[0] != '\0') ! 933: { ! 934: /* set x and y for the beginning of the line */ ! 935: Setxy((double)left_margin, (double)current_line); ! 936: ! 937: /* copy from input_line to line_buffer making any necessary ! 938: changes along the way */ ! 939: column = 0; ! 940: src = input_line; ! 941: dest = line_buffer; ! 942: while ((ch = *src) != '\0') ! 943: { ! 944: switch(ch) ! 945: { ! 946: case '\r': /* carriage return */ ! 947: *dest = '\0'; ! 948: if (line_buffer[0] != '\0') ! 949: { ! 950: ShowString(line_buffer); ! 951: } ! 952: Setxy((double)left_margin, (double)current_line); ! 953: dest= line_buffer; ! 954: break; ! 955: ! 956: case '\f': /* new page after this line */ ! 957: current_line = bottom_margin; ! 958: lines_on_page = 66; ! 959: break; ! 960: ! 961: case '\t': /* tab expansion */ ! 962: do ! 963: { ! 964: *dest++ = ' '; ! 965: column++; ! 966: } while (column % tab_amount != 0); ! 967: break; ! 968: ! 969: case '$': ! 970: *dest++ = '\244'; ! 971: column++; ! 972: break; ! 973: ! 974: case '-': ! 975: if (special_font == Font_Terminal) ! 976: { ! 977: /* heavy hackery here */ ! 978: *dest = '\0'; ! 979: ShowString(line_buffer); ! 980: Setyrel(-20.); ! 981: ShowString("\305"); ! 982: Setyrel(20.); ! 983: dest = line_buffer; ! 984: column++; ! 985: break; ! 986: } ! 987: /* else fall thru ... */ ! 988: ! 989: default: ! 990: *dest++ = ch; ! 991: column++; ! 992: } ! 993: src++; ! 994: } ! 995: *dest = '\0'; ! 996: if (line_buffer[0] != '\0') ! 997: { ! 998: ShowString(line_buffer); ! 999: } ! 1000: } ! 1001: ! 1002: /* advance the line counters */ ! 1003: current_line -= line_spacing; ! 1004: lines_on_page++; ! 1005: } ! 1006: ! 1007: /* wrap up the file */ ! 1008: page_end(Yes); ! 1009: } ! 1010: ! 1011: /* ! 1012: * page handling: a distinction is made between virtual pages and actual ! 1013: * pages. A virtual page is one series of lines from the file that appears ! 1014: * vertically on the printed page. The actual page is the page as the ! 1015: * printer prints it (a printed page, if you will). There may be several ! 1016: * virtual pages on one actual page. The page_start and page_end routines ! 1017: * that follow start and terminate virtual pages. The mapping between ! 1018: * virtual and actual pages is a function of the options specified by the ! 1019: * user. If the user requests two column output then there will be two ! 1020: * virtual pages for every actual page. These pages will sit side-by-side on ! 1021: * the actual page. The mapping is accomplished by changing the variables ! 1022: * left_margin and right_margin. "page_start" also handles printing of the ! 1023: * page header, since there is only one of these on every actual page. ! 1024: */ ! 1025: ! 1026: static int current_column; ! 1027: ! 1028: page_start() ! 1029: ! 1030: { ! 1031: boolean in_set; ! 1032: ! 1033: #ifdef vax11c ! 1034: long bintim; ! 1035: #endif ! 1036: ! 1037: /* reset the column count if starting a new file */ ! 1038: if (line_number == 1) ! 1039: { ! 1040: current_column = 0; ! 1041: } ! 1042: ! 1043: /* either move the left margin or put out a new page */ ! 1044: if (current_column != 0) ! 1045: { ! 1046: left_margin += column_separation; ! 1047: } ! 1048: else ! 1049: { ! 1050: /* increment page count and reset margin */ ! 1051: page_number++; ! 1052: left_margin = Orig_x; ! 1053: ! 1054: /* is it in the page specification set? */ ! 1055: if (page_select == NULL) ! 1056: { ! 1057: /* every page is in the set if there is no specification */ ! 1058: in_set = Yes; ! 1059: } ! 1060: else ! 1061: { ! 1062: if (page_low <= page_number && page_number <= page_high) ! 1063: { ! 1064: in_set = Yes; ! 1065: ip_select(ipress_file); ! 1066: if (page_number == page_high) ! 1067: { ! 1068: /* at the top of the current range -- time to move up */ ! 1069: curr_page_select += 2; ! 1070: page_low = curr_page_select[0]; ! 1071: page_high = curr_page_select[1]; ! 1072: } ! 1073: } ! 1074: else ! 1075: { ! 1076: /* not in set -- redirect output to null device */ ! 1077: in_set = No; ! 1078: ip_select(null_file); ! 1079: } ! 1080: } ! 1081: ! 1082: if (in_set) ! 1083: { ! 1084: register char *src; ! 1085: register char *dst; ! 1086: register char ch; ! 1087: ! 1088: /* increment total page count */ ! 1089: pages_printed++; ! 1090: ! 1091: /* output stuff for new ip page */ ! 1092: AppendOp(OP_beginBody); ! 1093: ! 1094: /* set the transformation */ ! 1095: Fget(F_transform); ! 1096: AppendOp(OP_concatt); ! 1097: ! 1098: /* build the header if we need to print it */ ! 1099: if (!tflg) ! 1100: { ! 1101: /* move characters from header to real_header */ ! 1102: /* and expand format items along the way. */ ! 1103: src = header; ! 1104: dst = real_header; ! 1105: while ((ch = *src) != '\0') ! 1106: { ! 1107: if (ch == '%') ! 1108: { ! 1109: switch(ch = *++src) ! 1110: { ! 1111: case 'f': /* file name */ ! 1112: dst = strecpy(dst, ! 1113: filename == NULL ? ! 1114: "Standard input" : ! 1115: filename); ! 1116: break; ! 1117: ! 1118: case 't': /* mtime */ ! 1119: #ifdef vax11c ! 1120: ! 1121: time(&bintim); ! 1122: strncpy(dst,ctime(&bintim), 24); ! 1123: dst += 24; ! 1124: #else ! 1125: /* ! 1126: * ctime returns a 26 character string that ! 1127: * has a newline and null at the end. ! 1128: * 26 - 2 == 24. ! 1129: */ ! 1130: if (file_stat.st_mtime != 0) ! 1131: { ! 1132: (void) strncpy(dst,ctime(&file_stat.st_mtime),24); ! 1133: dst += 24; ! 1134: } ! 1135: #endif ! 1136: break; ! 1137: ! 1138: case 'p': /* page number */ ! 1139: dst = itoa(dst, page_number); ! 1140: break; ! 1141: ! 1142: case 'l': /* line number */ ! 1143: dst = itoa(dst, line_number); ! 1144: break; ! 1145: ! 1146: case '\0': /* end of the string */ ! 1147: src--; /* maintain loop invariant */ ! 1148: break; ! 1149: ! 1150: default: /* copy the character */ ! 1151: *dst++ = ch; ! 1152: /* break; */ ! 1153: } ! 1154: } ! 1155: else ! 1156: { ! 1157: *dst++ = ch; ! 1158: } ! 1159: src++; ! 1160: } ! 1161: ! 1162: /* terminate the real header */ ! 1163: *dst = '\0'; ! 1164: ! 1165: /* display the header */ ! 1166: Setxy((double)(left_margin - Header_to_orig_x), ! 1167: (double)(top_margin + Header_to_orig_y)); ! 1168: Setfont(F_headfont); ! 1169: ShowString(real_header); ! 1170: } ! 1171: } ! 1172: } ! 1173: ! 1174: /* select the body font */ ! 1175: Setfont(F_bodyfont); ! 1176: } ! 1177: ! 1178: page_end(eof) ! 1179: ! 1180: int eof; ! 1181: ! 1182: { ! 1183: if ((current_column = ++current_column % columns) == 0 || eof) ! 1184: { ! 1185: AppendOp(OP_endBody); ! 1186: } ! 1187: } ! 1188: ! 1189: char *strecpy(dest, src) ! 1190: ! 1191: register char *src; ! 1192: register char *dest; ! 1193: ! 1194: { ! 1195: while (*dest++ = *src++) ! 1196: ; ! 1197: return(--dest); ! 1198: } ! 1199: ! 1200: char *itoa(buff, val) ! 1201: ! 1202: char *buff; ! 1203: int val; ! 1204: ! 1205: { ! 1206: char tbuff[12]; /* will build number here -- max of 10 digits */ ! 1207: register char *ptr = tbuff + 11; ! 1208: ! 1209: *ptr-- = '\0'; ! 1210: while (val != 0) ! 1211: { ! 1212: *ptr-- = (val % 10) + '0'; ! 1213: val /= 10; ! 1214: } ! 1215: return(strecpy(buff, ++ptr)); ! 1216: } ! 1217: ! 1218: /* ! 1219: * allocate(space) - allocate "space" bytes with sbrk. This routine uses a ! 1220: * fairly naive algorithm. It sbrk-s space in Break_size ! 1221: * chunks and allocates space from a chunk until a request ! 1222: * for more space than is left in the chunk is made. Then, ! 1223: * it allocates a new chunk. The unused space at the end ! 1224: * of the old chunk remains unused. This does NOT depend ! 1225: * on sbrk returning contiguous chunks of memory during the ! 1226: * life of the program. If the request is greater than ! 1227: * Break_size, the next multiple of Break_size greater ! 1228: * than the request size is chosen. ! 1229: */ ! 1230: ! 1231: char *allocate(space) ! 1232: ! 1233: int space; ! 1234: ! 1235: { ! 1236: static char *hi_water = NULL; ! 1237: static char *max_alloc = NULL; ! 1238: register char *ptr; ! 1239: ! 1240: if (hi_water == NULL || max_alloc + space > hi_water) ! 1241: { ! 1242: int alloc_size = (space <= Break_size ! 1243: ? Break_size ! 1244: : ((space + Break_size-1) / Break_size) * Break_size); ! 1245: ! 1246: hi_water = sbrk(alloc_size); ! 1247: ! 1248: if ((int)hi_water == -1) ! 1249: { ! 1250: system_error("out of space"); ! 1251: exit(1); ! 1252: } ! 1253: ! 1254: max_alloc = hi_water + alloc_size - 1; ! 1255: } ! 1256: ! 1257: ptr = hi_water; ! 1258: hi_water += space; ! 1259: return(ptr); ! 1260: } ! 1261: ! 1262: system_error(message) ! 1263: ! 1264: char *message; ! 1265: ! 1266: { ! 1267: int saved_errno; ! 1268: ! 1269: /* value of errno not preserved by fprintf */ ! 1270: saved_errno = errno; ! 1271: fprintf(stderr, "%s: ", myname); ! 1272: errno = saved_errno; ! 1273: perror(message); ! 1274: } ! 1275: ! 1276: #ifdef vax11c ! 1277: char *rindex(string, c) ! 1278: char *string, c; ! 1279: { ! 1280: register char *pos; ! 1281: ! 1282: pos = 0; ! 1283: do { ! 1284: if (*string == c) ! 1285: pos = string; ! 1286: } while (*string++); ! 1287: return(pos); ! 1288: } ! 1289: ! 1290: #endif ! 1291:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.