![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to makeaps.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / troff / devaps|
Return to makeaps.c CVS log | Up to [Research Unix] / researchv10no / cmd / troff / devaps |
1.1 ! root 1: /* ! 2: makedev: ! 3: read text info about a particular device ! 4: (e.g., cat, 202, aps5) from file, convert ! 5: it into internal (binary) form suitable for ! 6: fast reading by troff initialization (ptinit()). ! 7: ! 8: Usage: ! 9: ! 10: makedev DESC [ F ... ] ! 11: uses DESC to create a description file ! 12: using the information therein. ! 13: It creates the file DESC.out. ! 14: ! 15: makedev F ... ! 16: makes the font tables for fonts F only, ! 17: creates files F.out. ! 18: ! 19: DESC.out contains: ! 20: dev structure with fundamental sizes ! 21: list of sizes (nsizes+1) terminated by 0, as short's ! 22: indices of char names (nchtab * sizeof(short)) ! 23: char names as hy\0em\0... (lchname) ! 24: nfonts occurrences of ! 25: widths (nwidth) ! 26: kerning (nwidth) [ascender+descender only so far] ! 27: codes (nwidth) to drive actual typesetter ! 28: fitab (nchtab+128-32) ! 29: each of these is an array of char. ! 30: ! 31: dev.filesize contains the number of bytes ! 32: in the file, excluding the dev part itself. ! 33: ! 34: F.out contains the font header, width, kern, codes, and fitab. ! 35: Width, kern and codes are parallel arrays. ! 36: (Which suggests that they ought to be together?) ! 37: Later, we might allow for codes which are actually ! 38: sequences of formatting info so characters can be drawn. ! 39: */ ! 40: ! 41: #include "stdio.h" ! 42: #include "dev.h" ! 43: ! 44: #define BMASK 0377 ! 45: ! 46: #define SLANT_BIT 1 /* slant flag is bit 0 */ ! 47: #define FONT_BIT 2 /* font flag is bit 1 */ ! 48: #define RANGE_BIT 4 /* range flag is bit 2 */ ! 49: ! 50: #define SLANT_VAL 3 /* slant angle starts in bit 3 */ ! 51: #define RANGE_VAL 5 /* max range starts in bit 5 */ ! 52: ! 53: #define skipline(f) while(getc(f) != '\n') ! 54: ! 55: struct dev dev; ! 56: struct font font; ! 57: ! 58: #define NSIZE 100 /* maximum number of sizes */ ! 59: short size[NSIZE]; ! 60: #define NCH 256 /* max number of characters with funny names */ ! 61: char chname[5*NCH]; /* character names, including \0 for each */ ! 62: short chtab[NCH]; /* index of character in chname */ ! 63: ! 64: #define NFITAB (NCH + 128-32) /* includes ascii chars, but not non-graphics */ ! 65: char fitab[NFITAB]; /* font index table: position of char i on this font. */ ! 66: /* zero if not there */ ! 67: ! 68: #define FSIZE 200 /* size of a physical font (e.g., 102 for cat) */ ! 69: char width[FSIZE]; /* width table for a physical font */ ! 70: char kern[FSIZE]; /* ascender+descender info */ ! 71: char code[FSIZE]; /* actual device codes for a physical font */ ! 72: char alt_code[FSIZE]; /* code for alternate font */ ! 73: int alt_font[FSIZE]; /* alternate font to use */ ! 74: ! 75: int dbg = 0; /* debug flag */ ! 76: ! 77: ! 78: #define NFONT 10 /* max number of default fonts */ ! 79: char fname[NFONT][10]; /* temp space to hold default font names */ ! 80: ! 81: int fflag = 0; /* on if font table to be written */ ! 82: int fdout; /* output file descriptor */ ! 83: char *fout = "DESC.out"; ! 84: ! 85: main(argc, argv) ! 86: char *argv[]; ! 87: { ! 88: FILE *fin; ! 89: char cmd[100], *p; ! 90: int i, totfont, v; ! 91: ! 92: if ((fin = fopen("DESC", "r")) == NULL) { ! 93: fprintf(stderr, "makedev: can't open %s\n", argv[1]); ! 94: exit(1); ! 95: } ! 96: while (fscanf(fin, "%s", cmd) != EOF) { ! 97: if (cmd[0] == '#') /* comment */ ! 98: skipline(fin); ! 99: else if (strcmp(cmd, "debug") == 0) ! 100: dbg++; ! 101: else if (strcmp(cmd, "res") == 0) { ! 102: fscanf(fin, "%hd", &dev.res); ! 103: } else if (strcmp(cmd, "hor") == 0) { ! 104: fscanf(fin, "%hd", &dev.hor); ! 105: } else if (strcmp(cmd, "vert") == 0) { ! 106: fscanf(fin, "%hd", &dev.vert); ! 107: } else if (strcmp(cmd, "unitwidth") == 0) { ! 108: fscanf(fin, "%hd", &dev.unitwidth); ! 109: } else if (strcmp(cmd, "sizescale") == 0) { ! 110: fscanf(fin, "%hd", &dev.sizescale); ! 111: } else if (strcmp(cmd, "paperwidth") == 0) { ! 112: fscanf(fin, "%hd", &dev.paperwidth); ! 113: } else if (strcmp(cmd, "paperlength") == 0) { ! 114: fscanf(fin, "%hd", &dev.paperlength); ! 115: } else if (strcmp(cmd, "spare1") == 0) { ! 116: fscanf(fin, "%hd", &dev.spare1); ! 117: } else if (strcmp(cmd, "spare2") == 0) { ! 118: fscanf(fin, "%hd", &dev.spare2); ! 119: } else if (strcmp(cmd, "sizes") == 0) { ! 120: dev.nsizes = 0; ! 121: while (fscanf(fin, "%d", &v) != EOF && v != 0) ! 122: size[dev.nsizes++] = v; ! 123: size[dev.nsizes] = 0; /* need an extra 0 at the end */ ! 124: } else if (strcmp(cmd, "fonts") == 0) { ! 125: fscanf(fin, "%hd", &dev.nfonts); ! 126: for (i = 0; i < dev.nfonts; i++) ! 127: fscanf(fin, "%s", fname[i]); ! 128: } else if (strcmp(cmd, "charset") == 0) { ! 129: p = chname; ! 130: dev.nchtab = 0; ! 131: while (fscanf(fin, "%s", p) != EOF) { ! 132: chtab[dev.nchtab++] = p - chname; ! 133: while (*p++) /* skip to end of name */ ! 134: ; ! 135: } ! 136: dev.lchname = p - chname; ! 137: chtab[dev.nchtab++] = 0; /* terminate properly */ ! 138: } else ! 139: fprintf(stderr, "makedev: unknown command %s\n", cmd); ! 140: } ! 141: if (argc > 0 && strcmp(argv[1], "DESC") == 0) { ! 142: fdout = creat(fout, 0666); ! 143: if (fdout < 0) { ! 144: fprintf(stderr, "makedev: can't open %s\n", fout); ! 145: exit(1); ! 146: } ! 147: write(fdout, &dev, sizeof(struct dev)); ! 148: write(fdout, size, (dev.nsizes+1) * sizeof(size[0])); /* we need a 0 on the end */ ! 149: write(fdout, chtab, dev.nchtab * sizeof(chtab[0])); ! 150: write(fdout, chname, dev.lchname); ! 151: totfont = 0; ! 152: for (i = 0; i < dev.nfonts; i++) { ! 153: totfont += dofont(fname[i]); ! 154: write(fdout, &font, sizeof(struct font)); ! 155: write(fdout, width, font.nwfont & BMASK); ! 156: write(fdout, kern, font.nwfont & BMASK); ! 157: write(fdout, code, font.nwfont & BMASK); ! 158: write(fdout, fitab, dev.nchtab+128-32); ! 159: } ! 160: lseek(fdout, 0L, 0); /* back to beginning to install proper size */ ! 161: dev.filesize = /* excluding dev struct itself */ ! 162: (dev.nsizes+1) * sizeof(size[0]) ! 163: + dev.nchtab * sizeof(chtab[0]) ! 164: + dev.lchname * sizeof(char) ! 165: + totfont * sizeof(char); ! 166: write(fdout, &dev, sizeof(struct dev)); ! 167: close(fdout); ! 168: argc--; ! 169: argv++; ! 170: } ! 171: for (i = 1; i < argc; i++) ! 172: dofont(argv[i]); ! 173: exit(0); ! 174: } ! 175: ! 176: ! 177: /*****************************************************************************/ ! 178: ! 179: ! 180: dofont(name) ! 181: ! 182: ! 183: char *name; /* string containing name of font */ ! 184: ! 185: ! 186: { ! 187: ! 188: ! 189: FILE *fin; /* input file descriptor */ ! 190: int fdout; /* output file descriptor */ ! 191: int i, nw, spacewidth, n, v; ! 192: char buf[100], ch[10], s1[10], s2[10], s3[10], cmd[30]; ! 193: char s4[10]; /* used to check for extra info */ ! 194: int count; /* value returned from sscanf() */ ! 195: int dflt_range; /* default maximum range for font */ ! 196: int dflt_slant; /* default slant for this font */ ! 197: ! 198: ! 199: ! 200: /******************************************************************** ! 201: * * ! 202: * This routine is responsible for making the '.out' file for * ! 203: * the font specified by the parameter name. It also sets up some * ! 204: * of the data structures needed to make the DESC.out file in the * ! 205: * main routine. In addition I have changed this routine so that * ! 206: * we can add some typesetter dependent parameters to the font * ! 207: * files and have this information dumped out to a 'add' file * ! 208: * for this font, which can be read as needed by the aps driver. * ! 209: * * ! 210: ********************************************************************/ ! 211: ! 212: ! 213: ! 214: if ((fin = fopen(name, "r")) == NULL) { ! 215: fprintf(stderr, "makedev: can't open font %s\n", name); ! 216: exit(2); ! 217: } /* End if */ ! 218: ! 219: sprintf(cmd, "%s.out", name); /* output file is name.out */ ! 220: fdout = creat(cmd, 0666); /* create the '.out' font file */ ! 221: ! 222: font.specfont = 0; /* by default it isn't special font */ ! 223: font.ligfont = 0; /* it also has no ligatures either */ ! 224: font.spare1 = 0; /* all the flags are initially off */ ! 225: spacewidth = 0; /* tables may specify a spacewidth */ ! 226: dflt_range = 3; /* max range available on the APS-5 */ ! 227: dflt_slant = 0; /* no slant for this font yet */ ! 228: ! 229: for (i = 0; i < NFITAB; i++) /* initialize font index table */ ! 230: fitab[i] = 0; ! 231: ! 232: for (i = 0; i < FSIZE; i++) { /* initialize character tables */ ! 233: width[i] = kern[i] = code[i] = 0; ! 234: alt_font[i] = 0; ! 235: alt_code[i] = 0; ! 236: } /* End for */ ! 237: ! 238: while (fscanf(fin, "%s", cmd) != EOF) { /* read the font file */ ! 239: ! 240: if (strcmp(cmd, "name") == 0) ! 241: fscanf(fin, "%s", font.namefont); ! 242: else if (strcmp(cmd, "internalname") == 0) ! 243: fscanf(fin, "%s", font.intname); ! 244: else if (strcmp(cmd, "special") == 0) ! 245: font.specfont = 1; ! 246: else if (strcmp(cmd, "ligatures") == 0) { ! 247: skipline(fin); /* skip over any names for now */ ! 248: font.ligfont = 1; ! 249: } else if (strcmp(cmd, "spacewidth") == 0) { ! 250: fscanf(fin, "%d", &spacewidth); ! 251: width[0] = spacewidth; /* width of space on this font */ ! 252: } else if (strcmp(cmd, "charset") == 0) { ! 253: skipline(fin); ! 254: nw = 0; ! 255: ! 256: /* widths are origin 1 so fitab==0 can mean "not there" */ ! 257: ! 258: while (fgets(buf, 100, fin) != NULL) { /* read next line */ ! 259: ! 260: count = sscanf(buf, "%s %s %s %s %s", ch, s1, s2, s3, s4); ! 261: ! 262: if (s1[0] != '"') { /* it's a genuine new character */ ! 263: ! 264: nw++; ! 265: width[nw] = atoi(s1); ! 266: kern[nw] = atoi(s2); ! 267: ! 268: /* temporarily, pick up one byte as code */ ! 269: ! 270: if ( s3[0] == '0' ) /* code is in octal */ ! 271: sscanf(s3, "%o", &i); ! 272: else ! 273: sscanf(s3, "%d", &i); /* otherwise it is decimal */ ! 274: code[nw] = i; ! 275: ! 276: if ( count > 4 && font.spare1 ) /* process the rest */ ! 277: finish_line(buf, nw); ! 278: ! 279: } /* End if */ ! 280: ! 281: /* otherwise it's a synonym for previous character, ! 282: /* so leave previous values intact ! 283: */ ! 284: ! 285: if (strlen(ch) == 1) /* it's ascii */ ! 286: fitab[ch[0] - 32] = nw; /* fitab origin omits non-graphics */ ! 287: else { /* it has a funny name */ ! 288: for (i = 0; i < dev.nchtab; i++) ! 289: if (strcmp(&chname[chtab[i]], ch) == 0) { ! 290: fitab[i + 128-32] = nw; /* starts after the ascii */ ! 291: break; ! 292: } /* End if */ ! 293: ! 294: if (i >= dev.nchtab) ! 295: fprintf(stderr, "makedev: font %s: %s not in charset\n", name, ch); ! 296: } /* End else */ ! 297: ! 298: } /* End while */ ! 299: nw++; ! 300: font.nwfont = n = nw; ! 301: } else if ( strcmp(cmd, "alternate_font") == 0 ) ! 302: font.spare1 |= FONT_BIT; /* set alternate font bit */ ! 303: else if ( strcmp(cmd, "default_slant") == 0 ) { ! 304: font.spare1 &= ~(3 << SLANT_VAL); /* clear two slant val bits */ ! 305: font.spare1 |= SLANT_BIT; /* set font slant bit */ ! 306: fscanf(fin, "%d", &dflt_slant); /* read the default slant value */ ! 307: if ( dflt_slant > 0 ) /* encode it as 01 */ ! 308: font.spare1 |= (1 << SLANT_VAL); ! 309: else if ( dflt_slant < 0 ) /* encode it as 10 */ ! 310: font.spare1 |= (1 << (SLANT_VAL + 1)); ! 311: } else if ( strcmp(cmd, "max_range") == 0 ) { ! 312: font.spare1 |= RANGE_BIT; /* set range bit in spare1 */ ! 313: fscanf(fin, "%d", &dflt_range); /* read default font slant */ ! 314: if ( dflt_range < 1 || dflt_range > 4 ) { ! 315: fprintf(stderr, "makedev: illegal default range %d\n",dflt_range); ! 316: exit(1); ! 317: } /* End if */ ! 318: font.spare1 |= (dflt_range << RANGE_VAL); ! 319: } else if ( strcmp(cmd, "debug") == 0 ) ! 320: dbg++; ! 321: ! 322: } /* End while */ ! 323: ! 324: if (spacewidth == 0) ! 325: width[0] = dev.res * dev.unitwidth / 72 / 3; ! 326: fclose(fin); ! 327: ! 328: write(fdout, &font, sizeof(struct font)); ! 329: write(fdout, width, font.nwfont & BMASK); ! 330: write(fdout, kern, font.nwfont & BMASK); ! 331: write(fdout, code, font.nwfont & BMASK); ! 332: write(fdout, fitab, dev.nchtab+128-32); ! 333: close(fdout); ! 334: ! 335: if ( font.spare1 ) add_font(name); ! 336: ! 337: if ( dbg ) dump_font(); ! 338: ! 339: v = sizeof(struct font) + 3 * n + dev.nchtab + 128-32; ! 340: fprintf(stderr, "%3s: %3d chars, width %3d, size %3d\n", ! 341: font.namefont, nw, width[0], v); ! 342: return v; ! 343: ! 344: } /* End of dofont */ ! 345: ! 346: ! 347: /*****************************************************************************/ ! 348: ! 349: ! 350: finish_line(buf, nw) ! 351: ! 352: ! 353: char *buf; /* contains current input line */ ! 354: int nw; /* current index in char tables */ ! 355: ! 356: ! 357: { ! 358: ! 359: ! 360: char s[3][20]; /* used for special char commands */ ! 361: char v[3][20]; /* used to hold values */ ! 362: int count; /* number of vals read in sscanf() */ ! 363: int range; /* value of max range for character */ ! 364: int angle; /* value of slant angle for char */ ! 365: int i; /* for loop index */ ! 366: ! 367: ! 368: ! 369: /******************************************************************** ! 370: * * ! 371: * This routine is called from dofont() to finish scanning an * ! 372: * input line which has additional character information on it. * ! 373: * The line was read in dofont() and put in the buffer buf, while * ! 374: * the current index that we are using for the character tables is * ! 375: * the value of the parameter nw. The format of the additional * ! 376: * information that may appear in a line in the character set part * ! 377: * of a font file is shown below, * ! 378: * * ! 379: * slant l max_range m font n * ! 380: * * ! 381: * where l, m, and n are integers. Any or all of these commands * ! 382: * may appear on a given line after the normal code entry for the * ! 383: * current character. * ! 384: * * ! 385: ********************************************************************/ ! 386: ! 387: ! 388: ! 389: count = sscanf(buf,"%*s %*s %*s %*s %s %s %s %s %s %s",s[0],v[0],s[1],v[1],s[2],v[2]); ! 390: ! 391: if ( (count % 2 != 0) || (count == 0) ) { ! 392: fprintf(stderr, "makedev: format error in charset table\n"); ! 393: exit(1); ! 394: } /* End if */ ! 395: ! 396: alt_code[nw] = code[nw]; /* store real code in alt_code array */ ! 397: code[nw] = 128; /* turn bit 7 on */ ! 398: ! 399: for ( i = 0; i < count/2; i++ ) { /* process the strings */ ! 400: ! 401: if ( strcmp(s[i], "font") == 0 ) { /* have an alternate font */ ! 402: code[nw] |= FONT_BIT; /* turn font bit on */ ! 403: alt_font[nw] = atoi(v[i]); /* save this font number */ ! 404: } else if ( strcmp(s[i], "max_range") == 0 ) { ! 405: code[nw] &= ~(3 << RANGE_VAL); ! 406: code[nw] |= RANGE_BIT; ! 407: range = atoi(v[i]); ! 408: if ( range < 1 || range > 4 ) { ! 409: fprintf(stderr, "makedev: illegal range\n"); ! 410: exit(1); ! 411: } /* End if */ ! 412: code[nw] |= (range << RANGE_VAL); ! 413: } else if ( strcmp(s[i], "slant" ) == 0 ) { ! 414: code[nw] &= ~(3 << SLANT_VAL); ! 415: code[nw] |= SLANT_BIT; ! 416: angle = atoi(v[i]); ! 417: if ( angle > 0 ) /* set angle bits to 01 */ ! 418: code[nw] |= (1 << SLANT_VAL); ! 419: else if ( angle < 0 ) /* set angle bits to 10 */ ! 420: code[nw] |= (1 << (SLANT_VAL + 1)); ! 421: } else { /* illegal command - abort */ ! 422: fprintf(stderr, "makedev: illegal command\n"); ! 423: exit(1); ! 424: } /* End else */ ! 425: ! 426: } /* End for */ ! 427: if ( code[nw] & BMASK == 128 ) { ! 428: fprintf(stderr, "makedev: char code %d less than 129\n", code[nw]); ! 429: exit(1); ! 430: } /* End if */ ! 431: ! 432: } /* End of finish_line */ ! 433: ! 434: ! 435: /*****************************************************************************/ ! 436: ! 437: ! 438: add_font(name) ! 439: ! 440: ! 441: char *name; /* name of currnent font */ ! 442: ! 443: ! 444: { ! 445: ! 446: ! 447: int fdout; /* output file descriptor */ ! 448: int k; /* number of width entries */ ! 449: char cmd[30]; /* used to create output file */ ! 450: ! 451: ! 452: ! 453: /******************************************************************** ! 454: * * ! 455: * This routine is called from dofont() to write out the * ! 456: * additional information that was specified in the input font * ! 457: * file. As currently implemented the alternate code table and * ! 458: * the alternate font tables are always written to the output * ! 459: * file. * ! 460: * * ! 461: ********************************************************************/ ! 462: ! 463: ! 464: ! 465: sprintf(cmd, "%s.add", name); /* file will be 'name'.add */ ! 466: fdout = creat(cmd, 0666); /* create the '.add' file */ ! 467: ! 468: k = font.nwfont & BMASK; ! 469: ! 470: write(fdout, alt_font, FSIZE * sizeof(alt_font[0])); ! 471: write(fdout, alt_code, FSIZE); ! 472: ! 473: close(fdout); ! 474: ! 475: } /* End of add_font */ ! 476: ! 477: ! 478: /*****************************************************************************/ ! 479: ! 480: ! 481: dump_font() ! 482: ! 483: ! 484: { ! 485: ! 486: ! 487: int pos; /* position in character tables */ ! 488: int j; /* for loop index */ ! 489: int code_val; /* number in code table */ ! 490: ! 491: ! 492: ! 493: /******************************************************************** ! 494: * * ! 495: * This routine is called to dump the information that we have * ! 496: * read from the current font file. * ! 497: * * ! 498: ********************************************************************/ ! 499: ! 500: ! 501: ! 502: printf("DATA FOR FONT %s:\n\n", font.namefont); ! 503: ! 504: printf(" font structure data:\n"); ! 505: printf("\t\tfont.nwfont = %d\n", font.nwfont & BMASK); ! 506: printf("\t\tfont.specfont = %d\n", font.specfont & BMASK); ! 507: printf("\t\tfont.ligfont = %d\n", font.ligfont & BMASK); ! 508: printf("\t\tfont.spare1 = 0%o\n", font.spare1 & BMASK); ! 509: printf("\t\tfont.intname = %s\n\n", font.intname); ! 510: ! 511: printf(" CHAR WIDTH KERN CODE INDEX\n"); ! 512: ! 513: for ( j = 0; j < dev.nchtab + 128 - 32; j++ ) { ! 514: ! 515: if ( (pos = fitab[j] & BMASK) != 0 ) { ! 516: if ( j >= 96 ) ! 517: printf("%5s", &chname[chtab[j-96]]); ! 518: else printf("%5c", (j + 32) & BMASK); ! 519: printf("%10d", width[pos] & BMASK); ! 520: printf("%10d", kern[pos] & BMASK); ! 521: code_val = code[pos] & BMASK; ! 522: printf("%10d", code_val & BMASK); ! 523: printf("%10d", j); ! 524: ! 525: if ( code_val > 128 ) { ! 526: printf("%5d", alt_code[pos] & BMASK); ! 527: if ( code_val & SLANT_BIT ) ! 528: printf(" slant %d", (code_val >> SLANT_VAL) & 03); ! 529: if ( code_val & FONT_BIT ) ! 530: printf(" font %d", alt_font[pos]); ! 531: if ( code_val & RANGE_BIT ) ! 532: printf(" range %d", (code_val >> RANGE_VAL) & 03); ! 533: } /* End if */ ! 534: ! 535: printf("\n"); ! 536: } /* End if */ ! 537: ! 538: } /* End for */ ! 539: ! 540: printf("\n\n"); ! 541: ! 542: } /* End of dump_font */ ! 543: ! 544: ! 545: /*****************************************************************************/ ! 546: ! 547:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.