![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dcan.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / troff / Old|
Return to dcan.c CVS log | Up to [Research Unix] / researchv10no / cmd / troff / Old |
1.1 ! root 1: /* ! 2: * dcan ! 3: * driver for impress/imagen canon laser printer ! 4: */ ! 5: ! 6: /* ! 7: output language from troff: ! 8: all numbers are character strings ! 9: ! 10: sn size in points ! 11: fn font as number from 1-n ! 12: cx ascii character x ! 13: Cxyz funny char xyz. terminated by white space ! 14: Hn go to absolute horizontal position n ! 15: Vn go to absolute vertical position n (down is positive) ! 16: hn go n units horizontally (relative) ! 17: vn ditto vertically ! 18: nnc move right nn, then print c (exactly 2 digits!) ! 19: (this wart is an optimization that shrinks output file size ! 20: about 35% and run-time about 15% while preserving ascii-ness) ! 21: Dt ...\n draw operation 't': ! 22: Dl x y line from here by x,y ! 23: Dc d circle of diameter d with left side here ! 24: De x y ellipse of axes x,y with left side here ! 25: Da x y r arc counter-clockwise by x,y of radius r ! 26: D~ x y x y ... wiggly line by x,y then x,y ... ! 27: nb a end of line (information only -- no action needed) ! 28: b = space before line, a = after ! 29: p new page begins -- set v to 0 ! 30: #...\n comment ! 31: x ...\n device control functions: ! 32: x i init ! 33: x T s name of device is s ! 34: x r n h v resolution is n/inch ! 35: h = min horizontal motion, v = min vert ! 36: x p pause (can restart) ! 37: x s stop -- done for ever ! 38: x t generate trailer ! 39: x f n s font position n contains font s ! 40: x H n set character height to n ! 41: x S n set slant to N ! 42: ! 43: Subcommands like "i" are often spelled out like "init". ! 44: */ ! 45: ! 46: #include <stdio.h> ! 47: #include <signal.h> ! 48: #include <math.h> ! 49: #include <ctype.h> ! 50: #include "dev.h" ! 51: #include "/usr/bwk/imagen/src/imPcodes.h" ! 52: #include "glyph.h" ! 53: ! 54: #define abs(n) ((n) >= 0 ? (n) : -(n)) ! 55: ! 56: #define NFONT 10 ! 57: ! 58: int xx, yy; ! 59: int xoffset = 0; /* shift output right by this amount */ ! 60: int yoffset = -120; /* shift down (!) by this amount */ ! 61: /* -120 is 1/2 inch on canon */ ! 62: /* allows for 10 inch page -- */ ! 63: /* toss away 1/2 inch on top and bottom */ ! 64: float xfac = 1.0; /* scaling factor for x */ ! 65: float yfac = 1.0; /* scaling factor for y */ ! 66: int inputarea = 3; /* input area = 3 * 8k bytes */ ! 67: int rotate = 0; /* 0 => portrait, 1 => landscape */ ! 68: int output = 0; /* do we do output at all? */ ! 69: int pageno = -1; /* output page number */ ! 70: int nolist = 0; /* output page list if > 0 */ ! 71: int olist[20]; /* pairs of page numbers */ ! 72: ! 73: int erase = 1; ! 74: float aspect = 1; /* default aspect ratio */ ! 75: ! 76: struct dev dev; ! 77: struct font *fontbase[NFONT+1]; ! 78: short *pstab; ! 79: int nsizes = 1; ! 80: int nfonts; ! 81: int smnt; /* index of first special font */ ! 82: int nchtab; ! 83: char *chname; ! 84: short *chtab; ! 85: char *fitab[NFONT+1]; ! 86: char *widthtab[NFONT+1]; /* widtab would be a better name */ ! 87: char *codetab[NFONT+1]; /* device codes */ ! 88: ! 89: #define FATAL 1 ! 90: #define BMASK 0377 ! 91: int dbg = 0; ! 92: long lineno = 0; ! 93: int res = 972; /* input assumed computed according to this resolution */ ! 94: /* initial value to avoid 0 divide */ ! 95: FILE *tf = NULL; /* output file pointer */ ! 96: char *tempfile; ! 97: char *fontdir = "/usr/lib/font"; ! 98: char *bitdir = "/usr/lib/font/devcan"; ! 99: char *acctfile = "/usr/adm/dcanacct"; ! 100: int acctpages = 0; ! 101: int copies = 1; ! 102: char *username = "???"; ! 103: char *getlogin(); ! 104: extern char devname[]; ! 105: ! 106: FILE *fp = stdin; /* input file pointer */ ! 107: ! 108: main(argc, argv) ! 109: char *argv[]; ! 110: { ! 111: char buf[BUFSIZ]; ! 112: char *mktemp(); ! 113: int done(); ! 114: extern int DX, DY; ! 115: ! 116: username = getlogin(); ! 117: while (argc > 1 && argv[1][0] == '-') { ! 118: switch (argv[1][1]) { ! 119: case 'c': ! 120: copies = atoi(&argv[1][2]); ! 121: break; ! 122: case 'r': ! 123: rotate = !rotate; ! 124: break; ! 125: case 't': ! 126: tf = stdout; ! 127: break; ! 128: case 'x': ! 129: xoffset = atoi(&argv[1][2]); ! 130: break; ! 131: case 'y': ! 132: yoffset = atoi(&argv[1][2]); ! 133: break; ! 134: case 'f': ! 135: bitdir = argv[2]; ! 136: argv++; ! 137: argc--; ! 138: break; ! 139: case 'a': ! 140: aspect = atof(&argv[1][2]); ! 141: break; ! 142: case 'e': ! 143: erase = 0; ! 144: break; ! 145: case 'o': ! 146: outlist(&argv[1][2]); ! 147: break; ! 148: case 'i': /* set input area parameter */ ! 149: inputarea = atoi(&argv[1][2]); ! 150: if (inputarea < 1) ! 151: inputarea = 1; ! 152: else if (inputarea > 5) ! 153: inputarea = 5; ! 154: break; ! 155: case 'p': /* pixels of resolution */ ! 156: DX = DY = atoi(&argv[1][2]); ! 157: if (DX == 0) ! 158: DX = DY = 1; ! 159: break; ! 160: case 'd': ! 161: dbg = atoi(&argv[1][2]); ! 162: if (dbg == 0) dbg = 1; ! 163: tf = stdout; ! 164: break; ! 165: } ! 166: argc--; ! 167: argv++; ! 168: } ! 169: ! 170: signal(SIGINT, done); ! 171: signal(SIGHUP, done); ! 172: signal(SIGQUIT, done); ! 173: ! 174: tempfile = mktemp("/tmp/dcanXXXXX"); ! 175: if (tf != stdout) ! 176: if ((tf = fopen(tempfile, "w")) == NULL) ! 177: error(FATAL, "can't open temporary file %s", tempfile); ! 178: ! 179: if (argc <= 1) ! 180: conv(stdin); ! 181: else ! 182: while (--argc > 0) { ! 183: if (strcmp(*++argv, "-") == 0) ! 184: fp = stdin; ! 185: else if ((fp = fopen(*argv, "r")) == NULL) ! 186: error(FATAL, "can't open %s", *argv); ! 187: conv(fp); ! 188: fclose(fp); ! 189: } ! 190: fclose(tf); ! 191: sprintf(buf, "ipr -p %d -c %d %s", acctpages, copies, tempfile); ! 192: if(dbg){fprintf(stderr, "executing %s\n", buf); done();} ! 193: if (tf != stdout) { ! 194: system(buf); ! 195: account(); ! 196: } ! 197: done(); ! 198: } ! 199: ! 200: outlist(s) /* process list of page numbers to be printed */ ! 201: char *s; ! 202: { ! 203: int n1, n2, i; ! 204: ! 205: nolist = 0; ! 206: while (*s) { ! 207: n1 = 0; ! 208: if (isdigit(*s)) ! 209: do ! 210: n1 = 10 * n1 + *s++ - '0'; ! 211: while (isdigit(*s)); ! 212: else ! 213: n1 = -9999; ! 214: n2 = n1; ! 215: if (*s == '-') { ! 216: s++; ! 217: n2 = 0; ! 218: if (isdigit(*s)) ! 219: do ! 220: n2 = 10 * n2 + *s++ - '0'; ! 221: while (isdigit(*s)); ! 222: else ! 223: n2 = 9999; ! 224: } ! 225: olist[nolist++] = n1; ! 226: olist[nolist++] = n2; ! 227: if (*s != '\0') ! 228: s++; ! 229: } ! 230: olist[nolist] = 0; ! 231: if (dbg) ! 232: for (i=0; i<nolist; i += 2) ! 233: printf("%3d %3d\n", olist[i], olist[i+1]); ! 234: } ! 235: ! 236: in_olist(n) /* is n in olist? */ ! 237: int n; ! 238: { ! 239: int i; ! 240: ! 241: if (nolist == 0) ! 242: return(1); /* everything is included */ ! 243: for (i = 0; i < nolist; i += 2) ! 244: if (n >= olist[i] && n <= olist[i+1]) ! 245: return(1); ! 246: return(0); ! 247: } ! 248: ! 249: conv(fp) ! 250: register FILE *fp; ! 251: { ! 252: register int c, k; ! 253: int m, n, i, n1, m1; ! 254: char str[100], buf[300]; ! 255: ! 256: while ((c = getc(fp)) != EOF) { ! 257: switch (c) { ! 258: case '\n': /* when input is text */ ! 259: case ' ': ! 260: case 0: /* occasional noise creeps in */ ! 261: break; ! 262: case '0': case '1': case '2': case '3': case '4': ! 263: case '5': case '6': case '7': case '8': case '9': ! 264: /* two motion digits plus a character */ ! 265: hmot((c-'0')*10 + getc(fp)-'0'); ! 266: put1(getc(fp)); ! 267: break; ! 268: case 'c': /* single ascii character */ ! 269: put1(getc(fp)); ! 270: break; ! 271: case 'C': ! 272: fscanf(fp, "%s", str); ! 273: put1s(str); ! 274: break; ! 275: case 'D': /* draw function */ ! 276: fgets(buf, sizeof(buf), fp); ! 277: switch (buf[0]) { ! 278: case 'l': /* draw a line */ ! 279: sscanf(buf+1, "%d %d", &n, &m); ! 280: drawline(n, m, "."); ! 281: break; ! 282: case 'c': /* circle */ ! 283: sscanf(buf+1, "%d", &n); ! 284: drawcirc(n); ! 285: break; ! 286: case 'e': /* ellipse */ ! 287: sscanf(buf+1, "%d %d", &m, &n); ! 288: drawellip(m, n); ! 289: break; ! 290: case 'a': /* arc */ ! 291: sscanf(buf+1, "%d %d %d %d", &n, &m, &n1, &m1); ! 292: drawarc(n, m, n1, m1); ! 293: break; ! 294: case '~': /* wiggly line */ ! 295: drawwig(buf+1); ! 296: break; ! 297: default: ! 298: error(FATAL, "unknown drawing function %s\n", buf); ! 299: break; ! 300: } ! 301: break; ! 302: case 's': ! 303: fscanf(fp, "%d", &n); /* ignore fractional sizes */ ! 304: setsize(t_size(n)); ! 305: break; ! 306: case 'f': ! 307: fscanf(fp, "%s", str); ! 308: setfont(t_font(str)); ! 309: break; ! 310: case 'H': /* absolute horizontal motion */ ! 311: /* fscanf(fp, "%d", &n); */ ! 312: while ((c = getc(fp)) == ' ') ! 313: ; ! 314: k = 0; ! 315: do { ! 316: k = 10 * k + c - '0'; ! 317: } while (isdigit(c = getc(fp))); ! 318: ungetc(c, fp); ! 319: hgoto(k); ! 320: break; ! 321: case 'h': /* relative horizontal motion */ ! 322: /* fscanf(fp, "%d", &n); */ ! 323: while ((c = getc(fp)) == ' ') ! 324: ; ! 325: k = 0; ! 326: do { ! 327: k = 10 * k + c - '0'; ! 328: } while (isdigit(c = getc(fp))); ! 329: ungetc(c, fp); ! 330: hmot(k); ! 331: break; ! 332: case 'w': /* word space */ ! 333: break; ! 334: case 'V': ! 335: fscanf(fp, "%d", &n); ! 336: vgoto(n); ! 337: break; ! 338: case 'v': ! 339: fscanf(fp, "%d", &n); ! 340: vmot(n); ! 341: break; ! 342: case 'p': /* new page */ ! 343: fscanf(fp, "%d", &n); ! 344: t_page(n); ! 345: break; ! 346: case 'n': /* end of line */ ! 347: while (getc(fp) != '\n') ! 348: ; ! 349: t_newline(); ! 350: break; ! 351: case '#': /* comment */ ! 352: while (getc(fp) != '\n') ! 353: ; ! 354: break; ! 355: case 'x': /* device control */ ! 356: devcntrl(fp); ! 357: break; ! 358: default: ! 359: error(!FATAL, "unknown input character %o %c\n", c, c); ! 360: done(); ! 361: } ! 362: } ! 363: } ! 364: ! 365: devcntrl(fp) /* interpret device control functions */ ! 366: FILE *fp; ! 367: { ! 368: char str[20], str1[50], buf[50]; ! 369: int c, n; ! 370: ! 371: fscanf(fp, "%s", str); ! 372: switch (str[0]) { /* crude for now */ ! 373: case 'i': /* initialize */ ! 374: fileinit(); ! 375: t_init(0); ! 376: break; ! 377: case 'T': /* device name */ ! 378: fscanf(fp, "%s", devname); ! 379: break; ! 380: case 't': /* trailer */ ! 381: t_trailer(); ! 382: break; ! 383: case 'p': /* pause -- can restart */ ! 384: t_reset('p'); ! 385: break; ! 386: case 's': /* stop */ ! 387: t_reset('s'); ! 388: break; ! 389: case 'r': /* resolution assumed when prepared */ ! 390: fscanf(fp, "%d", &res); ! 391: break; ! 392: case 'f': /* font used */ ! 393: fscanf(fp, "%d %s", &n, str); ! 394: fgets(buf, sizeof buf, fp); /* in case there's a filename */ ! 395: ungetc('\n', fp); /* fgets goes too far */ ! 396: str1[0] = 0; /* in case there's nothing to come in */ ! 397: sscanf(buf, "%s", str1); ! 398: loadfont(n, str, str1); ! 399: break; ! 400: /* these don't belong here... */ ! 401: case 'H': /* char height */ ! 402: fscanf(fp, "%d", &n); ! 403: t_charht(n); ! 404: break; ! 405: case 'S': /* slant */ ! 406: fscanf(fp, "%d", &n); ! 407: t_slant(n); ! 408: break; ! 409: } ! 410: while ((c = getc(fp)) != '\n') /* skip rest of input line */ ! 411: if (c == EOF) ! 412: break; ! 413: } ! 414: ! 415: fileinit() /* read in font and code files, etc. */ ! 416: { ! 417: int i, fin, nw; ! 418: char *malloc(), *filebase, *p; ! 419: char temp[60]; ! 420: ! 421: /* open table for device, ! 422: /* read in resolution, size info, font info, etc. ! 423: /* and set params ! 424: */ ! 425: strcpy(devname, "202"); /* this is the only char set we have */ ! 426: /* the resolution, etc., is already in */ ! 427: sprintf(temp, "%s/dev%s/DESC.out", fontdir, devname); ! 428: if ((fin = open(temp, 0)) < 0) ! 429: error(FATAL, "can't open tables for %s\n", temp); ! 430: read(fin, &dev, sizeof(struct dev)); ! 431: nfonts = dev.nfonts; ! 432: nsizes = dev.nsizes; ! 433: nchtab = dev.nchtab; ! 434: filebase = malloc(dev.filesize); /* enough room for whole file */ ! 435: read(fin, filebase, dev.filesize); /* all at once */ ! 436: pstab = (short *) filebase; ! 437: chtab = pstab + nsizes + 1; ! 438: chname = (char *) (chtab + dev.nchtab); ! 439: p = chname + dev.lchname; ! 440: for (i = 0; i <= nfonts; i++) { ! 441: fontbase[i] = NULL; ! 442: widthtab[i] = codetab[i] = fitab[i] = NULL; ! 443: } ! 444: close(fin); ! 445: } ! 446: ! 447: fontprint(i) /* debugging print of font i (0,...) */ ! 448: { ! 449: int j, k, n; ! 450: char *p; ! 451: ! 452: printf("font %d:\n", i); ! 453: p = (char *) fontbase[i]; ! 454: n = fontbase[i]->nwfont & BMASK; ! 455: printf("base=0%o, nchars=%d, spec=%d, name=%s, widtab=0%o, fitab=0%o\n", ! 456: p, n, fontbase[i]->specfont, fontbase[i]->namefont, widthtab[i], fitab[i]); ! 457: printf("widths:\n"); ! 458: for (j=0; j <= n; j++) { ! 459: printf(" %2d", widthtab[i][j] & BMASK); ! 460: if (j % 20 == 19) printf("\n"); ! 461: } ! 462: printf("\ncodetab:\n"); ! 463: for (j=0; j <= n; j++) { ! 464: printf(" %2d", codetab[i][j] & BMASK); ! 465: if (j % 20 == 19) printf("\n"); ! 466: } ! 467: printf("\nfitab:\n"); ! 468: for (j=0; j <= dev.nchtab + 128-32; j++) { ! 469: printf(" %2d", fitab[i][j] & BMASK); ! 470: if (j % 20 == 19) printf("\n"); ! 471: } ! 472: printf("\n"); ! 473: } ! 474: ! 475: loadfont(n, s, s1) /* load font info for font s on position n (0...) */ ! 476: int n; ! 477: char *s, *s1; ! 478: { ! 479: char temp[60]; ! 480: int fin, nw, norig; ! 481: ! 482: if (n < 0 || n > NFONT) ! 483: error(FATAL, "illegal fp command %d %s", n, s); ! 484: if (fontbase[n] != NULL && strcmp(s, fontbase[n]->namefont) == 0) ! 485: return; ! 486: if (s1 == NULL || s1[0] == '\0') ! 487: sprintf(temp, "%s/dev%s/%s.out", fontdir, devname, s); ! 488: else ! 489: sprintf(temp, "%s/%s.out", s1, s); ! 490: if ((fin = open(temp, 0)) < 0) { ! 491: error(!FATAL, "can't open font table %s", temp); ! 492: return; ! 493: } ! 494: if (fontbase[n] != NULL) ! 495: free(fontbase[n]); ! 496: fontbase[n] = (struct font *) malloc(3*255 + dev.nchtab + ! 497: (128-32) + sizeof(struct font)); ! 498: if (fontbase[n] == NULL) ! 499: error(FATAL, "Out of space in loadfont %s\n", s); ! 500: read(fin, fontbase[n], 3*255 + nchtab+128-32 + sizeof(struct font)); ! 501: close(fin); ! 502: if (smnt == 0 && fontbase[n]->specfont == 1) ! 503: smnt = n; ! 504: nw = fontbase[n]->nwfont & BMASK; ! 505: widthtab[n] = (char *) fontbase[n] + sizeof(struct font); ! 506: codetab[n] = (char *) widthtab[n] + 2 * nw; ! 507: fitab[n] = (char *) widthtab[n] + 3 * nw; ! 508: t_fp(n, fontbase[n]->namefont, fontbase[n]->intname); ! 509: if (dbg > 1) fontprint(n); ! 510: } ! 511: ! 512: ! 513: error(f, s, a1, a2, a3, a4, a5, a6, a7) { ! 514: fprintf(stderr, "dcan: "); ! 515: fprintf(stderr, s, a1, a2, a3, a4, a5, a6, a7); ! 516: fprintf(stderr, " near line %ld\n", lineno); ! 517: if (f) ! 518: done(); ! 519: } ! 520: ! 521: ! 522: /* ! 523: Here beginneth all the stuff that really depends ! 524: on the canon (we hope). ! 525: */ ! 526: ! 527: #define RES 240 /* resolution of canon */ ! 528: #define MAXX (8*RES + RES/2) /* 8-1/2 inches? */ ! 529: #define MAXY (11 * RES) ! 530: #define WIDTH 8 ! 531: #define LOGWID 3 ! 532: #define K * 1024 /* clever, so watch out */ ! 533: ! 534: char devname[20] = "can"; ! 535: ! 536: int nglyph = 0; /* number of glyphs loaded */ ! 537: int totglyph = 0; /* total space used by glyphs sent down */ ! 538: int maxglyph = 16 K; /* maximum space for glyphs */ ! 539: ! 540: #define oput(c) if (output) xychar(c); else; ! 541: ! 542: /* input coordinate system: */ ! 543: ! 544: int size = 1; ! 545: int font = 1; /* current font */ ! 546: int hpos; /* horizontal position where we are supposed to be next (left = 0) */ ! 547: int vpos; /* current vertical position (down positive) */ ! 548: int DX = 10; /* step size in x for drawing */ ! 549: int DY = 10; /* step size in y for drawing */ ! 550: ! 551: /* canon coordinate system: */ ! 552: ! 553: int lastsize = -1; ! 554: int lastfont = -1; ! 555: int lastx = -1; ! 556: int lasty = -1; ! 557: int lastfam = -1; ! 558: ! 559: int drawdot = '.'; /* draw with this character */ ! 560: int drawsize = 1; /* shrink by this factor when drawing */ ! 561: ! 562: t_init(reinit) /* initialize device */ ! 563: int reinit; ! 564: { ! 565: int i; ! 566: ! 567: if (! reinit) { ! 568: for (i = 0; i < nchtab; i++) ! 569: if (strcmp(&chname[chtab[i]], "l.") == 0) ! 570: break; ! 571: if (i < nchtab) { ! 572: drawdot = i + 128; ! 573: drawsize = 1; ! 574: } else { ! 575: drawdot = '.'; ! 576: drawsize = 2; /* half size */ ! 577: } ! 578: ! 579: /* some Imagen-specific junk: */ ! 580: fprintf(tf, "%1d", inputarea); /* their kludge for setting */ ! 581: /* input area to x * 8k */ ! 582: maxglyph = 52 K - inputarea K - 4 K; ! 583: /* glyph area = 52K - input */ ! 584: fprintf(tf, " %s\n", username); ! 585: putc(0, tf); /* terminate this [so they say] */ ! 586: fprintf(tf, "%8.8s", "dcan1/24"); /* padding 8 bytes */ ! 587: /* ignored but needed */ ! 588: xfac = (float) RES / res * aspect; ! 589: yfac = (float) RES / res; ! 590: } ! 591: fflush(tf); ! 592: hpos = vpos = 0; ! 593: setsize(t_size(10)); /* start somewhere */ ! 594: } ! 595: ! 596: t_page(pg) /* do whatever new page functions */ ! 597: { ! 598: register int i, j, n; ! 599: register unsigned char *p; ! 600: static int firstpage = 1; ! 601: ! 602: pageno = pg; ! 603: if(dbg)fprintf(stderr, "t_page %d, output=%d\n", pg, output); ! 604: if (output != 0) { ! 605: /* beginning of first page, or */ ! 606: /* have just printed something, and seen p<n> for next one */ ! 607: /* ought to read in entire page, select needed glyphs */ ! 608: putc(AEND, tf); ! 609: firstpage = 0; ! 610: fflush(tf); ! 611: } ! 612: output = in_olist(pg); ! 613: if (output) { ! 614: if (totglyph >= maxglyph) { ! 615: clearglyphs(); ! 616: totglyph = 0; ! 617: } ! 618: putc(APAGE, tf); ! 619: acctpages++; ! 620: } ! 621: lastx = lasty = -1; ! 622: t_init(1); ! 623: } ! 624: ! 625: t_newline() /* do whatever for the end of a line */ ! 626: { ! 627: hpos = 0; ! 628: } ! 629: ! 630: t_size(n) /* convert integer to internal size number*/ ! 631: int n; ! 632: { ! 633: int i; ! 634: ! 635: if (n <= pstab[0]) ! 636: return(1); ! 637: else if (n >= pstab[nsizes-1]) ! 638: return(nsizes); ! 639: for (i = 0; n > pstab[i]; i++) ! 640: ; ! 641: return(i+1); ! 642: } ! 643: ! 644: t_charht(n) /* set character height to n */ ! 645: int n; ! 646: { ! 647: /* punt for now */ ! 648: } ! 649: ! 650: t_slant(n) /* set slant to n */ ! 651: int n; ! 652: { ! 653: /* punt for now */ ! 654: } ! 655: ! 656: t_font(s) /* convert string to internal font number */ ! 657: char *s; ! 658: { ! 659: int n; ! 660: ! 661: n = atoi(s); ! 662: if (n < 1 || n > nfonts) ! 663: n = 1; ! 664: return(n); ! 665: } ! 666: ! 667: t_reset(c) ! 668: { ! 669: int n; ! 670: ! 671: if (output) ! 672: acctpages++; ! 673: if (c == 's') { ! 674: putc(AEND, tf); ! 675: putc(AEOF, tf); ! 676: } ! 677: } ! 678: ! 679: account() /* record paper use */ ! 680: { ! 681: FILE *f = NULL; ! 682: ! 683: if (tf == stdout) ! 684: return; ! 685: f = fopen(acctfile, "a"); ! 686: if (f != NULL) { ! 687: if (username == NULL) ! 688: username = "???"; ! 689: fprintf(f, "%4d %s\n", acctpages, username); ! 690: } ! 691: } ! 692: ! 693: ! 694: t_trailer() ! 695: { ! 696: } ! 697: ! 698: hgoto(n) ! 699: { ! 700: hpos = n; /* this is where we want to be */ ! 701: /* before printing a character, */ ! 702: /* have to make sure it's true */ ! 703: } ! 704: ! 705: hmot(n) /* generate n units of horizontal motion */ ! 706: int n; ! 707: { ! 708: hpos += n; ! 709: } ! 710: ! 711: vgoto(n) ! 712: { ! 713: vpos = n; ! 714: } ! 715: ! 716: vmot(n) /* generate n units of vertical motion */ ! 717: int n; ! 718: { ! 719: vgoto(vpos + n); /* ignores rounding */ ! 720: } ! 721: ! 722: put1s(s) /* s is a funny char name */ ! 723: register char *s; ! 724: { ! 725: static int i = 0; ! 726: ! 727: if (!output) ! 728: return; ! 729: if (dbg) printf("%s ", s); ! 730: if (strcmp(s, &chname[chtab[i]]) != 0) ! 731: for (i = 0; i < nchtab; i++) ! 732: if (strcmp(&chname[chtab[i]], s) == 0) ! 733: break; ! 734: if (i < nchtab) ! 735: put1(i + 128); ! 736: else ! 737: i = 0; ! 738: } ! 739: ! 740: put1(c) /* output char c */ ! 741: register int c; ! 742: { ! 743: char *pw; ! 744: register char *p; ! 745: register int i, j, k; ! 746: int ofont, code, w; ! 747: ! 748: if (!output) ! 749: return; ! 750: c -= 32; ! 751: if (c <= 0) { ! 752: if (dbg) printf("non-exist 0%o\n", c+32); ! 753: return; ! 754: } ! 755: k = ofont = font; ! 756: i = fitab[font][c] & BMASK; ! 757: if (i != 0) { /* it's on this font */ ! 758: p = codetab[font]; ! 759: pw = widthtab[font]; ! 760: } else if (smnt > 0) { /* on special (we hope) */ ! 761: for (k=smnt, j=0; j <= nfonts; j++, k = (k+1) % (nfonts+1)) ! 762: if ((i = fitab[k][c] & BMASK) != 0) { ! 763: p = codetab[k]; ! 764: pw = widthtab[k]; ! 765: setfont(k); ! 766: break; ! 767: } ! 768: } ! 769: if (i == 0 || (code = p[i] & BMASK) == 0 || k > nfonts) { ! 770: if (dbg) printf("not found 0%o\n", c+32); ! 771: return; ! 772: } ! 773: if (dbg) { ! 774: if (isprint(c+32)) ! 775: printf("%c %d\n", c+32, code); ! 776: else ! 777: printf("%03o %d\n", c+32, code); ! 778: } else ! 779: oput(code); ! 780: if (font != ofont) ! 781: setfont(ofont); ! 782: } ! 783: ! 784: setsize(n) /* set point size to n (internal) */ ! 785: int n; ! 786: { ! 787: size = n; ! 788: } ! 789: ! 790: /* font position info: */ ! 791: ! 792: struct { ! 793: char *name; ! 794: int number; ! 795: } fontname[NFONT+1]; ! 796: ! 797: t_fp(n, s, si) /* font position n now contains font s, intname si */ ! 798: int n; ! 799: char *s, *si; ! 800: { ! 801: fontname[n].name = s; ! 802: fontname[n].number = atoi(si); ! 803: } ! 804: ! 805: setfont(n) /* set font to n */ ! 806: int n; ! 807: { ! 808: if (!output) ! 809: return; ! 810: if (n < 0 || n > NFONT) ! 811: error(FATAL, "illegal font %d\n", n); ! 812: font = n; ! 813: } ! 814: ! 815: done() ! 816: { ! 817: exit(0); ! 818: } ! 819: ! 820: /* ! 821: The following things manage raster font information. ! 822: The big problem is mapping desired font + size into ! 823: available font + size. For now, a file RASTERLIST ! 824: contains entries like ! 825: R 6 8 10 14 999 ! 826: I 8 10 12 999 ! 827: ... ! 828: This data is used to create an array "fontdata" that ! 829: describes legal fonts and sizes, and pointers to any ! 830: data from files that has actually been loaded. ! 831: */ ! 832: ! 833: struct fontdata { ! 834: char name[4]; /* e.g., "R" or "PA" */ ! 835: int size[10]; /* e.g., 6 8 10 14 0 */ ! 836: struct fontset *fsp[10]; /* either NULL or block of data */ ! 837: }; ! 838: ! 839: #define MAXFONT 20 /* no more than this many fonts forever */ ! 840: ! 841: struct fontdata fontdata[MAXFONT]; ! 842: int maxfonts = 0; /* how many actually used; set in initfontdata() */ ! 843: ! 844: struct Fontheader fh; ! 845: struct fontset { ! 846: int size; ! 847: int family; ! 848: struct Charparam *chp; ! 849: unsigned char *cdp; /* char data pointer */ ! 850: unsigned char *chused; /* bit-indexed; 1 if char downloaded */ ! 851: }; ! 852: ! 853: /* A global variable for the current font+size */ ! 854: struct fontset *fs; ! 855: int nfamily = 0; /* number of "families" (font+size) */ ! 856: ! 857: initfontdata() /* read RASTERLIST information */ ! 858: { ! 859: char name[100]; ! 860: FILE *fp; ! 861: int i, j, n; ! 862: ! 863: sprintf(name, "%s/RASTERLIST", bitdir); ! 864: if ((fp = fopen(name, "r")) == NULL) ! 865: error(FATAL, "can't open %s\n", name); ! 866: maxfonts = 0; ! 867: while (fscanf(fp, "%s", fontdata[maxfonts].name) != EOF) { ! 868: i = 0; ! 869: while (fscanf(fp, "%d", &n) != EOF && n < 100) { ! 870: fontdata[maxfonts].size[i] = n; ! 871: fontdata[maxfonts].fsp[i] = NULL; ! 872: i++; ! 873: } ! 874: fontdata[maxfonts].size[i] = 999; ! 875: if (++maxfonts > MAXFONT) ! 876: error(FATAL, "Too many fonts in RASTERLIST"); ! 877: } ! 878: fclose(fp); ! 879: if (dbg) { ! 880: fprintf(stderr, "initfontdata(): maxfonts=%d\n", maxfonts); ! 881: for (i = 0; i < maxfonts; i++) { ! 882: fprintf(stderr, "%.4s ", fontdata[i].name); ! 883: for (j = 0; fontdata[i].size[j] < 100; j++) ! 884: fprintf(stderr, " %3d", fontdata[i].size[j]); ! 885: fprintf(stderr, "\n"); ! 886: } ! 887: } ! 888: } ! 889: ! 890: getfontdata(f, s) /* causes loading of font information if needed */ ! 891: char *f; ! 892: int s; ! 893: { ! 894: int fd, n, i, j; ! 895: char name[100]; ! 896: static int first = 1; ! 897: ! 898: if (first) { ! 899: initfontdata(); ! 900: first = 0; ! 901: } ! 902: ! 903: for (i = 0; i < maxfonts; i++) ! 904: if (strcmp(f, fontdata[i].name) == 0) ! 905: break; ! 906: if (i >= maxfonts) /* the requested font wasn't there */ ! 907: i = 0; /* use the first one (probably R) */ ! 908: ! 909: /* find the best approximation to size s */ ! 910: for (j = 1; s >= fontdata[i].size[j]; j++) ! 911: ; ! 912: j--; ! 913: ! 914: /* open file if necessary */ ! 915: if (fontdata[i].fsp[j] == NULL) { ! 916: fs = (struct fontset *) malloc(sizeof(struct fontset)); ! 917: fontdata[i].fsp[j] = fs; ! 918: fs->chp = (struct Charparam *) malloc(256*sizeof(struct Charparam)); ! 919: sprintf(name, "%s/%s.%d%s", bitdir, ! 920: f, fontdata[i].size[j], rotate? "r" : ""); ! 921: fd = open(name, 0); ! 922: if (fd == -1) ! 923: error(FATAL, "can't open %s\n", name); ! 924: read(fd, &fh, sizeof(struct Fontheader)); ! 925: read(fd, fs->chp, 256*sizeof(struct Charparam)); ! 926: fs->size = fontdata[i].size[j]; ! 927: fs->family = nfamily; ! 928: nfamily += 2; /* even-odd leaves room for big fonts */ ! 929: fs->cdp = (unsigned char *) malloc(fh.f_size); ! 930: fs->chused = (unsigned char *) malloc(256/8); ! 931: read(fd, fs->cdp, fh.f_size); ! 932: close(fd); ! 933: } ! 934: fs = fontdata[i].fsp[j]; ! 935: } ! 936: ! 937: xychar(c) ! 938: register int c; ! 939: { ! 940: register unsigned char *p; ! 941: register struct Charparam *par; ! 942: register int x, y; ! 943: int i, n, rwid, ht, fam; ! 944: ! 945: x = hpos * xfac + 0.5; ! 946: x += xoffset; ! 947: y = vpos * yfac + 0.5; ! 948: y += yoffset; ! 949: ! 950: if (font != lastfont || size != lastsize) { ! 951: getfontdata(fontname[font].name, pstab[size-1]); ! 952: lastsize = size; ! 953: lastfont = font; ! 954: } ! 955: par = fs->chp + c; ! 956: p = fs->cdp + par->c_addr; ! 957: ! 958: fam = fs->family; ! 959: if (c > 127) ! 960: fam++; ! 961: if (fam != lastfam) { ! 962: putc(AF, tf); ! 963: putc(lastfam = fam, tf); ! 964: } ! 965: ! 966: /* first cut: ship each glyph as needed. */ ! 967: /* ignore memory use, efficiency, etc. */ ! 968: ! 969: if ( !bit(fs->chused, c) ) { /* 1st use of this character */ ! 970: nglyph++; ! 971: totglyph += glspace(par); ! 972: setbit(fs->chused, c); ! 973: putc(ASGLY, tf); ! 974: putint((fam << 7) | c, tf); ! 975: /* putc(par->c_width, tf); /* character width */ ! 976: putc(0, tf); /* zap nominal width because it's wrong */ ! 977: putc(par->c_left + par->c_right + 1, tf); ! 978: putc(par->c_left, tf); ! 979: /* this nonsense fixes a bug in output produced by rec.c: */ ! 980: /* when up is < 0 (and = 0?) size is one too big */ ! 981: rwid = (1 + par->c_left + par->c_right + WIDTH-1) / WIDTH; ! 982: ht = par->c_size / rwid; ! 983: par->c_down = ht - par->c_up; ! 984: putc(par->c_down + par->c_up, tf); ! 985: putc(par->c_up, tf); ! 986: for (i = par->c_size; i--; ) ! 987: putc(*p++, tf); ! 988: } ! 989: ! 990: if (y != lasty) { ! 991: putc(AV, tf); ! 992: putint(y<<1, tf); ! 993: lasty = y; ! 994: } ! 995: if (x != lastx) { ! 996: if (abs(x-lastx) > 127) { ! 997: putc(AH, tf); ! 998: putint(x<<1, tf); ! 999: } else { ! 1000: putc(AM, tf); ! 1001: putc(x-lastx, tf); ! 1002: putc(AM, tf); ! 1003: } ! 1004: } ! 1005: ! 1006: if (c <= 127) ! 1007: putc(c, tf); /* fails if c > 127, probably disastrously */ ! 1008: else ! 1009: putc(c-128, tf); ! 1010: /* lastx = x + par->c_width; */ ! 1011: lastx = x; ! 1012: } ! 1013: ! 1014: glspace(par) ! 1015: struct Charparam *par; ! 1016: { ! 1017: int n; ! 1018: ! 1019: /* works only for small glyphs right now */ ! 1020: ! 1021: n = 12 ! 1022: + ((par->c_left+par->c_right+1+15)/16 ) * (par->c_up+par->c_down) ! 1023: + 2; ! 1024: return n; ! 1025: } ! 1026: ! 1027: clearglyphs() /* remove "used" bits from all glyphs */ ! 1028: /* delete all families */ ! 1029: /* very conservative policy */ ! 1030: { ! 1031: int i, j, k; ! 1032: struct fontset *f; ! 1033: ! 1034: if (tf == stdout) fprintf(stderr, "clear %d glyphs (%d/%d) on page %d\n", ! 1035: nglyph, totglyph, maxglyph, pageno); ! 1036: for (i = 0; i < maxfonts; i++) ! 1037: for (j = 0; fontdata[i].size[j] < 999; j++) { ! 1038: f = fontdata[i].fsp[j]; ! 1039: if (f != NULL) { ! 1040: putc(ADELF, tf); ! 1041: putc(f->family, tf); ! 1042: for (k = 0; k < 256/8; k++) ! 1043: f->chused[k] = 0; ! 1044: } ! 1045: } ! 1046: } ! 1047: ! 1048: bit(p, n) /* return n-th bit of p[] */ ! 1049: char *p; ! 1050: int n; ! 1051: { ! 1052: return (p[n/8] >> (7 - n%8)) & 01; ! 1053: } ! 1054: ! 1055: setbit(p, n) /* set bit n of p[] */ ! 1056: char *p; ! 1057: int n; ! 1058: { ! 1059: p[n/8] |= 01 << (7 - n%8); ! 1060: } ! 1061: ! 1062: putint(n, f) ! 1063: int n; ! 1064: FILE *f; ! 1065: { ! 1066: putc(n >> 8, f); ! 1067: putc(n & 0377, f); ! 1068: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.