![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to makemap.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / dimpress|
Return to makemap.c CVS log | Up to [Research Unix] / researchv10no / cmd / dimpress |
1.1 ! root 1: char xxxmakei10[] ="@(#)makei10.c 1.1"; ! 2: ! 3: #include <stdio.h> ! 4: #include "dev.h" ! 5: ! 6: ! 7: #define NON_FATAL 0 ! 8: #define FATAL 1 ! 9: #define NO 0 ! 10: #define YES 1 ! 11: ! 12: #define FNAME 4 /* longest allowed font name - at least 3 */ ! 13: #define DNAME 11 /* longest accepted device name */ ! 14: #define CLENGTH 2 /* max length of special char strings */ ! 15: #define FONTDIR 100 /* max length of *fontdir string */ ! 16: #define LINE_LENGTH 100 /* longest line in ASCII tables */ ! 17: #define MAXWIDTH 255 /* maximum number of width entries */ ! 18: #define MAXSYNS 75 /* no more synonyms than this */ ! 19: #define MAXBUILD 75 /* largest 'build' list */ ! 20: #define MAXFONTS 60 /* can map this many fonts */ ! 21: #define NFONT 10 /* search at most this many fonts */ ! 22: #define BMASK 0377 /* mask for lower eight bits */ ! 23: ! 24: #define FONTSIZE 3 * MAXWIDTH + nchtab + (128 - 32) + sizeof(struct Font) ! 25: #define PATHLENGTH FONTDIR + 2 * DNAME + FNAME + 5 ! 26: #define TARGDIR FONTDIR + DNAME + 5 ! 27: ! 28: ! 29: ! 30: char mdev[DNAME+1] = ""; /* raster tbls assume this device */ ! 31: char tdev[DNAME+1] = "i10"; /* target typesetter - Imagen */ ! 32: char *ndev; /* make ASCII tables for this device */ ! 33: ! 34: struct dev dev; /* *mdev DESC.out header goes here */ ! 35: struct Font *fontbase[NFONT]; /* each font's .out header stuff */ ! 36: ! 37: int nchtab; /* number of special chars in chtab */ ! 38: short *pstab; /* point size table - not needed */ ! 39: short *chtab; /* char's index in chname array */ ! 40: char *chname; /* special character strings */ ! 41: char *fontstart; /* can load fonts starting here */ ! 42: char *widthtab[NFONT]; /* font's width table - not needed */ ! 43: char *codetab[NFONT]; /* *mdev's codes for characters */ ! 44: char *fitab[NFONT]; /* position of characters on a font */ ! 45: ! 46: char mapped[MAXFONTS][FNAME+1]; /* mapped these fonts - ASCII names */ ! 47: char fmap[NFONT+1][FNAME+1]; /* names of *mdev's fonts that we search */ ! 48: char new[MAXSYNS][CLENGTH+1]; /* synonym for corresponding char in old[][] */ ! 49: char old[MAXSYNS][CLENGTH+1]; /* old character name */ ! 50: char bldlist[MAXBUILD+1][CLENGTH+1]; /* these chars will be built up */ ! 51: ! 52: int mapcount; /* mapped this many of *ndev's fonts */ ! 53: int syncount = 0; /* number of synonyms in *fontmap */ ! 54: int bldcount = 0; /* number of build chars in *fontmap */ ! 55: int fcount; /* number of original default fonts */ ! 56: int acount = 0; /* add this many fonts to default */ ! 57: int iname; /* internal name for 'related' fonts */ ! 58: int nfonts; /* number of *mdev's fonts to check */ ! 59: int fsize; /* all fonts given this much room */ ! 60: ! 61: char *fontdir = ".."; /* troff's font directory */ ! 62: char *srcdir = ".."; /* ASCII font files kept here */ ! 63: char targdir[TARGDIR] = "."; /* target device's font directory */ ! 64: char *rastdev = "RASTERDEV"; /* device name is in this file */ ! 65: char *fontmap = "FONTMAP"; /* font map file for device *ndev */ ! 66: ! 67: char addfont[(NFONT-1)*MAXFONTS*(FNAME+1)] = ""; /* additional default fonts */ ! 68: ! 69: char path[PATHLENGTH]; /* build file pathnames up here */ ! 70: ! 71: FILE *descin; /* *ndev's real ASCII DESC file */ ! 72: FILE *descout; /* new ASCII DESC file for *ndev */ ! 73: FILE *fontin; /* read font data from this ASCII file */ ! 74: FILE *fontout[NFONT+1]; /* ASCII output files for this font */ ! 75: FILE *fp_map; /* file pointer for *fontmap file */ ! 76: FILE *fp_error = stderr; /* error messages */ ! 77: ! 78: char **argv; /* so everyone can use them */ ! 79: int argc; ! 80: ! 81: int silent = NO; ! 82: ! 83: ! 84: ! 85: /*****************************************************************************/ ! 86: ! 87: ! 88: main(agc, agv) ! 89: ! 90: ! 91: int agc; ! 92: char *agv[]; ! 93: ! 94: ! 95: { ! 96: ! 97: ! 98: /******************************************************************** ! 99: * * ! 100: * This program takes troff's ASCII font and device tables for * ! 101: * one or more typesetters and converts them into a form that can * ! 102: * be used with the raster tables located in the target device's * ! 103: * font directory. These new tables are written into appropriate * ! 104: * 'dev' directories located in the *targdir directory. * ! 105: * * ! 106: * The program expects to find a file called RASTERDEV in * ! 107: * *targdir. The first string in this file is the name of the * ! 108: * device whose tables were used to make the raster files - the * ! 109: * rest of the file is skipped. In addition each new device must * ! 110: * have an appropriate 'dev' directory in *targdir, and each of * ! 111: * these directories must contain a file called FONTMAP, that * ! 112: * tells the program how to map *ndev's fonts. * ! 113: * * ! 114: * After the command line options are processed, the name of * ! 115: * the master device is read from the file *rastdev, provided the * ! 116: * string *mdev hasn't already been set. Then this device name is * ! 117: * used, in combination with *fontdir, to locate *mdev's binary * ! 118: * '.out' tables. Routine getdesc() reads the entire DESC.out * ! 119: * into memory, and then alloctes enough additional memory to hold * ! 120: * NFONT binary font files. Once this initialization stuff is done * ! 121: * the program enters a loop that treats the rest of the command * ! 122: * line arguments as device names. Each of these devices will have * ! 123: * a new set of ASCII font tables written out to the appropriate * ! 124: * 'dev' directory in *targdir. * ! 125: * * ! 126: * The first step for each new device is to essentially copy * ! 127: * the first part of its real ASCII DESC file from *fontdir to the * ! 128: * appropriate 'dev' directory in *targdir. Routine startdesc() * ! 129: * handles this job, but it only reads up to the default font * ! 130: * count in the real DESC file. Once it has the default font count * ! 131: * startdesc() has really finished its job. It doesn't even write * ! 132: * this number out to the new DESC file, because we are probably * ! 133: * going to be adding some default fonts to the new DESC file. * ! 134: * * ! 135: ********************************************************************/ ! 136: ! 137: ! 138: argv = agv; /* global so everyone can use them */ ! 139: argc = agc; ! 140: ! 141: getoptions(); ! 142: getmdev(); /* get 'master' device name */ ! 143: getdesc(); /* get *mdev's DESC.out file */ ! 144: ! 145: if ( silent == NO ) ! 146: printf("master device = %s\n\n", mdev); ! 147: ! 148: while ( --argc > 0 ) { /* got another device */ ! 149: ndev = *++argv; /* make tables for this guy */ ! 150: if ( silent == NO ) ! 151: printf("making tables for device %s\n", ndev); ! 152: startdesc(); /* up to default font list */ ! 153: makefonts(); /* for all fonts listed in FONTMAP */ ! 154: finishdesc(); /* complete *ndev's new DESC file */ ! 155: } /* End while */ ! 156: ! 157: } /* End of main */ ! 158: ! 159: ! 160: /*****************************************************************************/ ! 161: ! 162: ! 163: getoptions() ! 164: ! 165: ! 166: { ! 167: ! 168: ! 169: /******************************************************************** ! 170: * * ! 171: * Called from the main program to handle the command line * ! 172: * options. * ! 173: * * ! 174: ********************************************************************/ ! 175: ! 176: ! 177: while ( argc > 1 && argv[1][0] == '-' ) { ! 178: ! 179: switch ( argv[1][1] ) { ! 180: ! 181: case 's': ! 182: silent = YES; ! 183: break; ! 184: ! 185: case 'm': ! 186: strcpy(mdev, &argv[1][2]); ! 187: if ( strlen(mdev) > DNAME ) ! 188: error(FATAL, "device name %s too long", mdev); ! 189: break; ! 190: ! 191: case 'F': ! 192: fontdir = &argv[1][2]; ! 193: break; ! 194: ! 195: case 'S': ! 196: srcdir = &argv[1][2]; ! 197: break; ! 198: ! 199: default: ! 200: error(NON_FATAL, "illegal option %c", argv[1][1]); ! 201: break; ! 202: ! 203: } /* End switch */ ! 204: ! 205: argv++; ! 206: argc--; ! 207: ! 208: } /* End while */ ! 209: ! 210: } /* End of getoptions */ ! 211: ! 212: ! 213: /*****************************************************************************/ ! 214: ! 215: ! 216: getmdev() ! 217: ! 218: ! 219: { ! 220: ! 221: ! 222: FILE *fd; /* used for *rastdev file */ ! 223: ! 224: ! 225: /******************************************************************** ! 226: * * ! 227: * Called from the main program to get the name of the device * ! 228: * that was used to make the raster tables for the target device. * ! 229: * If the string *mdev has already been set, possibly by an * ! 230: * option, nothing is done. Otherwise we expect to find the name * ! 231: * as the first string in the file *targdir/*rastdev. * ! 232: * * ! 233: ********************************************************************/ ! 234: ! 235: ! 236: if ( *mdev != '\0' ) return; /* got the name somewhere else */ ! 237: ! 238: sprintf(path, "%s/%s", targdir, rastdev); ! 239: if ( (fd = fopen(path, "r")) == NULL ) ! 240: error(FATAL, "can't open file %s", path); ! 241: ! 242: if ( fscanf(fd, "%14s", mdev) != 1 ) ! 243: error(FATAL, "no device name in file %s", rastdev); ! 244: ! 245: if ( strlen(mdev) > DNAME ) ! 246: error(FATAL, "master device name %s too long", mdev); ! 247: ! 248: fclose(fd); /* won't need this file again */ ! 249: ! 250: } /* End of getmdev */ ! 251: ! 252: ! 253: /*****************************************************************************/ ! 254: ! 255: ! 256: getdesc() ! 257: ! 258: ! 259: { ! 260: ! 261: ! 262: int fin; /* DESC.out's file descriptor */ ! 263: char *filebase; /* memory block for DESC.out file */ ! 264: char *malloc(); /* memory allocation routine */ ! 265: ! 266: ! 267: /******************************************************************** ! 268: * * ! 269: * Called from the main program to read in the DESC.out file * ! 270: * for typesetter *mdev. Even though we only will use a small part * ! 271: * of this file, the whole thing is read into memory. I also * ! 272: * decided not to use the font space that is already allocated in * ! 273: * the DESC.out file. If you want to use this space just change * ! 274: * the initialization of fontstart. * ! 275: * * ! 276: ********************************************************************/ ! 277: ! 278: ! 279: sprintf(path, "%s/dev%s/DESC.out", fontdir, mdev); ! 280: if ( (fin = open(path, 0)) < 0 ) ! 281: error(FATAL, "can't open file %s", path); ! 282: ! 283: read(fin, &dev, sizeof(struct dev)); /* struct dev comes first */ ! 284: ! 285: nchtab = dev.nchtab; /* FONTSIZE needs this number */ ! 286: fsize = FONTSIZE; /* space given to each font */ ! 287: ! 288: if ( (filebase = malloc(dev.filesize)) == NULL ) ! 289: error(FATAL, "no memory available"); ! 290: ! 291: read(fin, filebase, dev.filesize); /* get rest of the DESC.out file */ ! 292: pstab = (short *) filebase; /* this table is never used */ ! 293: chtab = pstab + dev.nsizes + 1; ! 294: chname = (char *) (chtab + dev.nchtab); ! 295: ! 296: if ( (fontstart = malloc(NFONT * fsize)) == NULL ) ! 297: error(FATAL, "no memory available"); ! 298: ! 299: close(fin); /* won't need this guy again */ ! 300: ! 301: } /* End of getdesc */ ! 302: ! 303: ! 304: /*****************************************************************************/ ! 305: ! 306: ! 307: startdesc() ! 308: ! 309: ! 310: { ! 311: ! 312: ! 313: char cmd[LINE_LENGTH]; /* DESC file commands go here */ ! 314: int c; /* used as a character */ ! 315: ! 316: ! 317: /******************************************************************** ! 318: * * ! 319: * Called from main() to begin making *ndev's ASCII DESC file. * ! 320: * The real DESC file is read up to the default font list. Later * ! 321: * routine finishdesc() is called to complete the new DESC file. * ! 322: * I did things this way because we need to know the original * ! 323: * number of default fonts for device *ndev before we make the * ! 324: * new font tables, and we can't write the default font list out * ! 325: * to the new DESC file until we have built all the new font * ! 326: * tables for *ndev. * ! 327: * * ! 328: * Since I have claimed dev.spare2 in routine finishdesc() we * ! 329: * should probably check if the command we just read was 'spare2'. * ! 330: * I'll take care of this later on. * ! 331: * * ! 332: ********************************************************************/ ! 333: ! 334: ! 335: sprintf(path, "%s/dev%s/DESC", srcdir, ndev); ! 336: if ( (descin = fopen(path, "r")) == NULL ) ! 337: error(FATAL, "can't open file %s", path); ! 338: ! 339: sprintf(path, "%s/dev%s/DESC", targdir, ndev); ! 340: if ( (descout = fopen(path, "w")) == NULL ) ! 341: error(FATAL, "can't write file %s", path); ! 342: ! 343: while ( fscanf(descin, "%s", cmd) != EOF ) { ! 344: fprintf(descout, "%s", cmd); ! 345: if ( strcmp(cmd, "fonts") == 0 ) { ! 346: fscanf(descin, "%s", cmd); ! 347: fcount = atoi(cmd); ! 348: return; ! 349: } else if ( strcmp(cmd, "charset") == 0 ) ! 350: error(FATAL, "bad DESC file format"); ! 351: else while ( putc(c=getc(descin), descout) != '\n' && c != EOF ) ; ! 352: } /* End while */ ! 353: ! 354: error(FATAL, "bad DESC file"); /* shouldn't get here! */ ! 355: ! 356: } /* End of startdesc */ ! 357: ! 358: ! 359: /*****************************************************************************/ ! 360: ! 361: ! 362: finishdesc() ! 363: ! 364: ! 365: { ! 366: ! 367: ! 368: char fname[FNAME+1]; /* names of the default fonts */ ! 369: int i, j; /* for loop indices */ ! 370: int c; /* used as a char with getc() */ ! 371: ! 372: ! 373: /******************************************************************** ! 374: * * ! 375: * Called from the main program after all the fonts for *ndev * ! 376: * have been mapped. Routine startdesc() read *descin up to the * ! 377: * first default font name, and it wrote *descout up to the count * ! 378: * part of the default font list. Most likely we will now have * ! 379: * more default fonts than we started with, so dev.spare2 can be * ! 380: * used by post-processors to get at the original number. * ! 381: * * ! 382: ********************************************************************/ ! 383: ! 384: ! 385: fprintf(descout, " %d", fcount + acount); /* new default font count */ ! 386: ! 387: for ( i = 0; i < fcount; i++ ) { /* check each default font */ ! 388: fscanf(descin, "%s", fname); ! 389: fprintf(descout, " %s", fname); ! 390: for ( j = 0; j < mapcount; j++ ) /* did we map this font? */ ! 391: if ( strcmp(fname, &mapped[j][0]) == 0 ) ! 392: break; ! 393: if ( j >= mapcount ) /* didn't find it */ ! 394: error(NON_FATAL, "missing default font file %s", fname); ! 395: } /* End for */ ! 396: ! 397: fprintf(descout, "%s", addfont); /* finish the default font list */ ! 398: fprintf(descout, "\nspare2 %d", fcount); /* post-processor can use it */ ! 399: ! 400: while ( (c = getc(descin)) != EOF ) putc(c, descout); ! 401: ! 402: fclose(descin); /* may have more devices */ ! 403: fclose(descout); ! 404: ! 405: } /* End of finishdesc */ ! 406: ! 407: ! 408: /*****************************************************************************/ ! 409: ! 410: ! 411: makefonts() ! 412: ! 413: ! 414: { ! 415: ! 416: ! 417: char cmd[LINE_LENGTH]; /* font file commands go here */ ! 418: int c; /* used as a character */ ! 419: int i; /* for loop index */ ! 420: ! 421: ! 422: /******************************************************************** ! 423: * * ! 424: * Called from main() to make all the ASCII font files listed * ! 425: * in *ndev's FONTMAP file. All the stuff up to the charset part * ! 426: * of each ASCII font file is essentially copied into the new * ! 427: * font file. The name field is changed to the name of the second * ! 428: * font from appropriate lines in the FONTMAP file. All 'related' * ! 429: * fonts are given the same internal number. The lower eight bits * ! 430: * of this number contains the font position where post-processors * ! 431: * can expect to find related fonts to search if a character is * ! 432: * not found on the primary font. This additional search should be * ! 433: * done before checking the special fonts. The ligature stuff is * ! 434: * not really needed - leave it in for now. * ! 435: * * ! 436: ********************************************************************/ ! 437: ! 438: ! 439: mapcount = 0; /* fonts mapped so far for *ndev */ ! 440: ! 441: sprintf(path, "%s/dev%s/%s", targdir, ndev, fontmap); ! 442: if ( (fp_map = fopen(path, "r")) == NULL ) ! 443: error(FATAL, "can't open file %s", path); ! 444: ! 445: while ( readmap() != 0 ) { /* not done with FONTMAP file yet */ ! 446: ! 447: if ( silent == NO ) ! 448: printf("font %s\n", &mapped[mapcount][0]); ! 449: ! 450: for ( i = 1; i < NFONT + 1; i++ ) ! 451: fontout[i] = NULL; ! 452: ! 453: sprintf(path, "%s/dev%s/%s", srcdir, ndev, &mapped[mapcount][0]); ! 454: if ( (fontin = fopen(path, "r")) == NULL ) ! 455: error(FATAL, "can't open file %s", path); ! 456: ! 457: sprintf(path, "%s/dev%s/%s", targdir, ndev, &mapped[mapcount][0]); ! 458: if ( (fontout[0] = fopen(path, "w")) == NULL ) ! 459: error(FATAL, "can't open file %s", path); ! 460: ! 461: for ( i = 0; i < nfonts; i++ ) /* get the '.out' font files */ ! 462: loadfont(&fmap[i][0], i); ! 463: ! 464: iname = (mapcount * (BMASK + 1)) + fcount + acount + 1; ! 465: ! 466: while ( fscanf(fontin, "%s", cmd) == 1) { ! 467: fprintf(fontout[0], "%s", cmd); ! 468: if ( strcmp(cmd, "name") == 0 ) { ! 469: fprintf(fontout[0], " %s\n", &fmap[0][0]); ! 470: while ( (c = getc(fontin)) != '\n' && c != EOF ) ; ! 471: } else if ( strcmp(cmd, "internalname") == 0 ) { ! 472: fprintf(fontout[0], " %d\n", iname); ! 473: while ( (c = getc(fontin)) != '\n' && c != EOF ) ; ! 474: } else if ( strcmp(cmd, "ligatures") == 0 ) { ! 475: get_ligs(); ! 476: while ( (c = getc(fontin)) != '\n' && c != EOF ) ; ! 477: } else if ( strcmp(cmd, "charset") == 0 ) ! 478: copy_chars(); ! 479: else while ( putc(c=getc(fontin), fontout[0]) != '\n' && c != EOF ) ; ! 480: } /* End while */ ! 481: ! 482: mapcount++; /* finished mapping this font */ ! 483: ! 484: fclose(fontin); ! 485: for ( i = 0; i < NFONT + 1; i++ ) ! 486: if ( fontout[i] != NULL ) ! 487: fclose(fontout[i]); ! 488: ! 489: } /* End while */ ! 490: ! 491: fclose(fp_map); ! 492: ! 493: } /* End of makefonts */ ! 494: ! 495: ! 496: /*****************************************************************************/ ! 497: ! 498: ! 499: readmap() ! 500: ! 501: ! 502: { ! 503: ! 504: ! 505: char buff[20]; ! 506: int c; /* used as a character */ ! 507: ! 508: ! 509: /******************************************************************** ! 510: * * ! 511: * This routine continues reading the FONTMAP file until it * ! 512: * has processed the next font mapping instruction. Any 'build' * ! 513: * lists that are encountered replace the last list, and will * ! 514: * therefore apply to the next font map. The first font mentioned * ! 515: * in a font map line is the name of the primary font for the * ! 516: * current mapping instruction. This is *ndev's ASCII font file * ! 517: * that we will be reading and usually writing. The rest of the * ! 518: * fonts following the 'into' are the names of *mdev's fonts that * ! 519: * are searched when we do the character lookups. These searches * ! 520: * are done using the '.out' font files, which are read in from * ! 521: * *mdev's normal font directory. * ! 522: * * ! 523: ********************************************************************/ ! 524: ! 525: ! 526: if ( mapcount >= MAXFONTS ) ! 527: error(FATAL, "too many fonts in %s file", fontmap); ! 528: ! 529: while ( fscanf(fp_map, "%19s", buff) == 1 ) { ! 530: if ( strcmp(buff, "synonyms") == 0 ) ! 531: readsyns(); ! 532: else if ( strcmp(buff, "build") == 0 ) ! 533: readbuild(); ! 534: else if ( strcmp(buff, "nobuild") == 0 ) ! 535: bldcount = 0; ! 536: else if ( strcmp(buff, "map") == 0 ) ! 537: return(readfonts()); ! 538: else if ( buff[0] = '#' ) ! 539: while ( (c = getc(fp_map)) != '\n' && c != EOF ) ; ! 540: else error(FATAL, "don't know command %s", buff); ! 541: } /* End while */ ! 542: ! 543: return(0); ! 544: ! 545: } /* End of readmap */ ! 546: ! 547: ! 548: /*****************************************************************************/ ! 549: ! 550: ! 551: readfonts() ! 552: ! 553: ! 554: { ! 555: ! 556: ! 557: int c; /* character used with getc() */ ! 558: ! 559: ! 560: /******************************************************************** ! 561: * * ! 562: * Called from readmap() to read the next font map line for * ! 563: * device *ndev from the file *fp_map. * ! 564: * * ! 565: ********************************************************************/ ! 566: ! 567: ! 568: nfonts = 0; ! 569: ! 570: if ( fscanf(fp_map, "%s into", &mapped[mapcount][0]) != 1 ) ! 571: error(FATAL, "map file synatx error"); ! 572: ! 573: if ( FNAME < 3 ) /* we may have trouble later on */ ! 574: error(FATAL, "constant FNAME less than 3"); ! 575: ! 576: if ( strlen(&mapped[mapcount][0]) > FNAME ) ! 577: error(FATAL, "font name %s too long", &mapped[mapcount][0]); ! 578: ! 579: while ( nfonts < NFONT ) { ! 580: while ( (c = getc(fp_map)) == ' ' || c == '\t') ; ! 581: if ( c == '\n' || c == EOF ) ! 582: break; ! 583: ungetc(c, fp_map); ! 584: fscanf(fp_map, "%s", &fmap[nfonts][0]); ! 585: if ( strlen(&fmap[nfonts++][0]) > FNAME ) ! 586: error(FATAL, "font name %s too long", &fmap[nfonts-1][0]); ! 587: } /* End while */ ! 588: ! 589: if ( nfonts >= NFONT ) ! 590: while ( (c = getc(fp_map)) != '\n' && c != EOF ) ; ! 591: ! 592: strcpy(&fmap[nfonts][0], "bld"); ! 593: ! 594: return(nfonts); ! 595: ! 596: } /* End of readfonts */ ! 597: ! 598: ! 599: /*****************************************************************************/ ! 600: ! 601: ! 602: readbuild() ! 603: ! 604: ! 605: { ! 606: ! 607: ! 608: /******************************************************************** ! 609: * * ! 610: * Called from readmap() to read a 'build' list from *fontmap. * ! 611: * This list consists of those characters that will be built up * ! 612: * by the post-processor. They will be written out to a special * ! 613: * font file named *fmap[0].bld with a character code of 0. The * ! 614: * list is terminated by the string "end". * ! 615: * * ! 616: ********************************************************************/ ! 617: ! 618: ! 619: bldcount = 0; /* throw the last copy list out */ ! 620: ! 621: while ( bldcount < MAXBUILD ) { ! 622: if ( fscanf(fp_map, "%s", &bldlist[bldcount][0]) != 1 ) ! 623: error(FATAL, "bad build list format"); ! 624: ! 625: if ( strcmp(&bldlist[bldcount][0], "end") == 0 ) ! 626: return; ! 627: ! 628: if ( strlen(&bldlist[bldcount][0]) > CLENGTH ) ! 629: error(FATAL, "copy name %s too long", &bldlist[bldcount][0]); ! 630: ! 631: bldcount++; ! 632: } /* End while */ ! 633: ! 634: error(FATAL, "too many build characters"); ! 635: ! 636: } /* End of readbuild */ ! 637: ! 638: ! 639: /*****************************************************************************/ ! 640: ! 641: ! 642: readsyns() ! 643: ! 644: ! 645: { ! 646: ! 647: ! 648: /******************************************************************** ! 649: * * ! 650: * Called from readmap() to read a synonym list from the * ! 651: * *fontmap. The list is terminated by any pair of identical * ! 652: * character strings whose length is no more than CLENGTH. * ! 653: * This synonym stuff is probably not needed. It was added to the * ! 654: * program early on. * ! 655: * * ! 656: ********************************************************************/ ! 657: ! 658: ! 659: syncount = 0; /* throw the last list out */ ! 660: ! 661: while ( syncount < MAXSYNS ) { ! 662: if ( fscanf(fp_map, "%s %s", &new[syncount][0], &old[syncount][0]) != 2 ) ! 663: error(FATAL, "bad synonym list format"); ! 664: ! 665: if ( strlen(&new[syncount][0]) > CLENGTH ) ! 666: error(FATAL, "synonym name %s too long", &new[syncount][0]); ! 667: ! 668: if ( strlen(&old[syncount][0]) > CLENGTH ) ! 669: error(FATAL, "synonym name %s too long", &old[syncount][0]); ! 670: ! 671: if ( strcmp(&new[syncount][0], &old[syncount][0]) == 0 ) ! 672: return; ! 673: ! 674: syncount++; /* its a real synonym */ ! 675: } /* End while */ ! 676: ! 677: error(FATAL, "too many synonyms"); ! 678: ! 679: } /* End of readsyns */ ! 680: ! 681: ! 682: /*****************************************************************************/ ! 683: ! 684: ! 685: get_ligs() ! 686: ! 687: ! 688: { ! 689: ! 690: ! 691: char lig; ! 692: ! 693: ! 694: /******************************************************************** ! 695: * * ! 696: * Called from makefonts() to build up an appropriate ligature * ! 697: * list for the current font. This routine should not be needed * ! 698: * because the new tables will probably only be used by post- * ! 699: * processors, and they usually won't look at the font.ligfont * ! 700: * field. It is the right way to do things, so I decided to leave * ! 701: * the routine in for now - just in case. * ! 702: * * ! 703: ********************************************************************/ ! 704: ! 705: ! 706: lig = fontbase[0]->ligfont; ! 707: ! 708: if ( lig & LFI ) ! 709: fprintf(fontout[0], " fi"); ! 710: if ( lig & LFL ) ! 711: fprintf(fontout[0], " fl"); ! 712: if ( lig & LFF ) ! 713: fprintf(fontout[0], " ff"); ! 714: if ( lig & LFFI ) ! 715: fprintf(fontout[0], " ffi"); ! 716: if ( lig & LFFL ) ! 717: fprintf(fontout[0], " ffl"); ! 718: ! 719: fprintf(fontout[0], " 0\n"); ! 720: ! 721: } /* End of get_ligs */ ! 722: ! 723: ! 724: /*****************************************************************************/ ! 725: ! 726: ! 727: copy_chars() ! 728: ! 729: ! 730: { ! 731: ! 732: ! 733: char ch[10]; /* standard stuff from makedev */ ! 734: char width[10]; ! 735: char kern[10]; ! 736: char code[10]; ! 737: char nch[10]; /* look this char up - synonym */ ! 738: char buff[LINE_LENGTH]; /* next line from charset part */ ! 739: int index; /* found character on this font */ ! 740: int i; /* for loop index */ ! 741: ! 742: ! 743: /******************************************************************** ! 744: * * ! 745: * Called from makefonts() to copy the charset portion of the * ! 746: * current font file to the appropriate place in the *tdev * ! 747: * directory. * ! 748: * * ! 749: ********************************************************************/ ! 750: ! 751: ! 752: index = -1; /* needed because of synonyms */ ! 753: putc('\n', fontout[0]); /* comes after 'charset' command */ ! 754: ! 755: while ( fgets(buff, sizeof(buff), fontin) != NULL ) { ! 756: ! 757: if ( sscanf(buff, "%s %s %s %s", ch, width, kern, code) < 2 ) ! 758: continue; ! 759: ! 760: if ( width[0] == '"' ) { ! 761: if ( index >= 0 ) ! 762: fprintf(fontout[index], "%s\t%s\n", ch, width); ! 763: continue; ! 764: } /* End if */ ! 765: ! 766: strcpy(nch, ch); ! 767: for ( i = 0; i < syncount; i++ ) ! 768: if ( strcmp(ch, &old[i][0]) == 0 ) { ! 769: strcpy(nch, &new[i][0]); ! 770: break; ! 771: } /* End if */ ! 772: ! 773: if ( (index = lookup(code, nch)) < 0 ) { ! 774: if ( silent == NO ) ! 775: printf(" char %s not found\n", ch); ! 776: continue; ! 777: } else if ( fontout[index] == NULL ) ! 778: startfont(index); ! 779: ! 780: fprintf(fontout[index], "%s\t%s\t%s\t%s\n", ch, width, kern, code); ! 781: ! 782: } /* End while */ ! 783: ! 784: } /* End of copy_chars */ ! 785: ! 786: ! 787: /*****************************************************************************/ ! 788: ! 789: ! 790: startfont(index) ! 791: ! 792: ! 793: int index; /* font's name is in fmap[index] */ ! 794: ! 795: ! 796: { ! 797: ! 798: ! 799: char *nfont[2*FNAME+1]; /* name of the new font */ ! 800: ! 801: ! 802: /******************************************************************** ! 803: * * ! 804: * When this routine is called, we have found a character * ! 805: * from font mapped[mapcount] on fmap[index]. It is the first * ! 806: * time we needed this font so we have to create a new font file * ! 807: * with all the appropriate header stuff. This routine will never * ! 808: * be called with index equal to 0, since when a character is * ! 809: * found on fmap[0] it is written to *ndev's new ASCII font file * ! 810: * called mapped[mapcount][0]. This string is set in readfonts() * ! 811: * to the name of the first font in the current 'map' line in file * ! 812: * *fp_map, and the appropriate ASCII output file has already been * ! 813: * opened for writing in routine makefonts(). * ! 814: * * ! 815: ********************************************************************/ ! 816: ! 817: ! 818: strcat(strcat(strcpy(nfont, &mapped[mapcount][0]), "."), &fmap[index][0]); ! 819: ! 820: sprintf(path, "%s/dev%s/%s", targdir, ndev, nfont); ! 821: if ( (fontout[index] = fopen(path, "w")) == NULL ) ! 822: error(FATAL, "can't write file %s", path); ! 823: ! 824: fprintf(fontout[index], "name %s\n", index != nfonts ? &fmap[index][0] : &fmap[0][0]); ! 825: fprintf(fontout[index], "internalname %d\n", iname); ! 826: fprintf(fontout[index], "charset\n"); ! 827: ! 828: acount++; ! 829: strcat(strcat(addfont, " "), nfont); /* will be a default font */ ! 830: ! 831: } /* End of startfont */ ! 832: ! 833: ! 834: /*****************************************************************************/ ! 835: ! 836: ! 837: lookup(code, ch) ! 838: ! 839: ! 840: char *code; /* use this device code */ ! 841: char *ch; /* for this character */ ! 842: ! 843: ! 844: { ! 845: ! 846: ! 847: int buildit; /* did we find it in the build list? */ ! 848: int c; /* ch's index */ ! 849: int j; /* found on this font */ ! 850: int i; /* chars index on font j */ ! 851: ! 852: ! 853: /******************************************************************** ! 854: * * ! 855: * Called from copy_chars() to lookup the device code for the * ! 856: * character ch. If *ch isn't found we return -1, otherwise we * ! 857: * return the font's index where *ch was found. * ! 858: * * ! 859: ********************************************************************/ ! 860: ! 861: ! 862: buildit = 0; /* not in the build list */ ! 863: for ( i = 0; i < bldcount; i++ ) /* check the build list */ ! 864: if ( strcmp(ch, &bldlist[i][0]) == 0 ) { ! 865: strcpy(code, "0"); ! 866: buildit = 1; ! 867: } /* End if */ ! 868: ! 869: if ( ch[1] == '\0' ) /* ASCII character */ ! 870: c = ch[0]; ! 871: else { /* special troff character string */ ! 872: for ( c = 0; c < nchtab; c++ ) ! 873: if ( strcmp(&chname[chtab[c]], ch) == 0 ) ! 874: break; ! 875: if ( c >= nchtab ) ! 876: return(buildit == 0 ? -1 : nfonts); ! 877: c += 128; /* special chars start at 128 */ ! 878: } /* End if */ ! 879: ! 880: c -= 32; /* forget non-graphic characters */ ! 881: j = 0; ! 882: ! 883: while ( j < nfonts && (i = fitab[j][c] & BMASK) == 0 ) ! 884: j++; ! 885: ! 886: if ( j >= nfonts || i == 0 ) /* didn't find it on any font */ ! 887: return(buildit == 0 ? -1 : nfonts); ! 888: ! 889: sprintf(code, "%d", codetab[j][i] & BMASK); ! 890: return(j); ! 891: ! 892: } /* End of lookup */ ! 893: ! 894: ! 895: /*****************************************************************************/ ! 896: ! 897: ! 898: loadfont(str, pos) ! 899: ! 900: ! 901: char *str; /* name of the font to load */ ! 902: int pos; /* read font data into this position */ ! 903: ! 904: ! 905: { ! 906: ! 907: ! 908: char *fontpos; /* this font's position */ ! 909: int fin; /* font's .out file descriptor */ ! 910: int nw; /* number of width entries for font */ ! 911: ! 912: ! 913: /******************************************************************** ! 914: * * ! 915: * Called from makefonts() to load the .out file for font *str * ! 916: * from the 'master' device's real font directory. * ! 917: * * ! 918: ********************************************************************/ ! 919: ! 920: ! 921: sprintf(path, "%s/dev%s/%s.out", fontdir, mdev, str); ! 922: if ( (fin = open(path, 0)) < 0 ) ! 923: error(FATAL, "can't open file %s", path); ! 924: ! 925: fontpos = fontstart + (fsize * pos); ! 926: read(fin, fontpos, fsize); ! 927: ! 928: fontbase[pos] = (struct Font *) fontpos; ! 929: nw = fontbase[pos]->nwfont & BMASK; ! 930: ! 931: widthtab[pos] = (char *) fontpos + sizeof(struct Font); ! 932: codetab[pos] = (char *) widthtab[pos] + 2 * nw; ! 933: fitab[pos] = (char *) widthtab[pos] + 3 * nw; ! 934: ! 935: close(fin); ! 936: ! 937: } /* End of loadfont */ ! 938: ! 939: ! 940: /*****************************************************************************/ ! 941: ! 942: ! 943: error(kind, str, a1, a2) ! 944: ! 945: ! 946: int kind; ! 947: char *str; ! 948: unsigned a1, a2; ! 949: ! 950: ! 951: { ! 952: ! 953: ! 954: /******************************************************************** ! 955: * * ! 956: * Print the error message *str, and quit if the error was * ! 957: * FATAL. * ! 958: * * ! 959: ********************************************************************/ ! 960: ! 961: ! 962: fprintf(fp_error, "make%s: ", tdev); ! 963: ! 964: if ( kind == NON_FATAL ) ! 965: fprintf(fp_error, "warning - "); ! 966: ! 967: fprintf(fp_error, str, a1); ! 968: putc('\n', fp_error); ! 969: ! 970: if ( kind == FATAL ) ! 971: exit(1); ! 972: ! 973: } /* End of error */ ! 974: ! 975: ! 976: /*****************************************************************************/
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.