![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to font.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / picasso|
Return to font.c CVS log | Up to [Research Unix] / researchv10no / cmd / picasso |
1.1 root 1: /*
2: *
3: * Typesetter font tables routines - for postprocessors.
4: *
5: */
6:
7: /*
8: * A slightly modified version of the dpost original -- DBK
9: */
10:
11: #include <stdio.h>
12: #include <ctype.h>
13:
14: #include "font.h" /* font table definitions */
15:
16: TrFont *mount[MAXFONTS+1]; /* mount table - pointers into fonts[] */
17: TrFont fonts[MAXFONTS+2]; /* font data - guarantee one empty slot */
18:
19: int fcount; /* entries in fonts[] */
20: int mcount; /* fonts currently in memory */
21: int mlimit = MAXFONTS+1; /* and the most we'll allow */
22:
23: char *chnames[MAXCH]; /* special character hash table */
24: int nchnames; /* number of entries in chnames[] */
25:
26: extern int devres;
27: extern int unitwidth;
28: extern int nfonts;
29: extern char **lfonts;
30:
31: /*****************************************************************************/
32:
33: getdesc(path)
34:
35: char *path;
36:
37: {
38:
39: char buf[150];
40: FILE *fp;
41: int n;
42:
43: /*
44: *
45: * Read a typesetter description file. Font and size lists are discarded. Only
46: * used to get to the start of the next command.
47: *
48: */
49:
50: if ( (fp = fopen(path, "r")) == NULL )
51: return(-1);
52:
53: while ( fscanf(fp, "%s", buf) != EOF ) {
54: if ( strcmp(buf, "res") == 0 )
55: fscanf(fp, "%d", &devres);
56: else if ( strcmp(buf, "unitwidth") == 0 )
57: fscanf(fp, "%d", &unitwidth);
58: else if ( strcmp(buf, "sizes") == 0 )
59: while ( fscanf(fp, "%d", &n) != EOF && n != 0 ) ;
60: else if ( strcmp(buf, "inmemory") == 0 )
61: fscanf(fp, "%d", &mlimit);
62: else if ( strcmp(buf, "fonts") == 0 ) {
63: fscanf(fp, "%d", &nfonts);
64: if (nfonts > 0)
65: lfonts = (char **) malloc(nfonts * sizeof (char *));
66: for ( n = 0; n < nfonts; n++ ) {
67: fscanf(fp, "%s", buf);
68: lfonts[n] = strsave(buf);
69: }
70: } else if ( strcmp(buf, "charset") == 0 ) {
71: while ( fscanf(fp, "%s", buf) != EOF )
72: chadd(buf);
73: break;
74: } /* End if */
75: skipline(fp);
76: } /* End while */
77:
78: fclose(fp);
79: return(1);
80:
81: } /* End of getdesc */
82:
83: /*****************************************************************************/
84:
85: getfont(path, fpos)
86:
87: char *path;
88: TrFont *fpos;
89:
90: {
91:
92: FILE *fin;
93: Chwid chtemp[MAXCH];
94: static Chwid chinit;
95: int i, nw, n, wid, code;
96: int nospace = 1;
97: char buf[150], ch[20], s1[10], s2[10], s3[10], cmd[30];
98:
99:
100: /*
101: *
102: * Read a width table from path into *fpos. Skip unnamed characters, spacewidth,
103: * ligatures, ascender/descender entries, and anything else not recognized. All
104: * calls should come through mountfont().
105: *
106: */
107:
108: if ( fpos->state == INMEMORY )
109: return(1);
110:
111: if ( (fin = fopen(path, "r")) == NULL )
112: return(-1);
113:
114: if ( fpos->state == NEWFONT ) {
115: if ( ++fcount > MAXFONTS+1 )
116: return(-1);
117: fpos->path = strsave(path);
118: } /* End if */
119:
120: if ( ++mcount > mlimit && mcount > nfonts+1 )
121: freefonts();
122:
123: for ( i = 0; i < 128-32; i++ )
124: chtemp[i] = chinit;
125:
126: while ( fscanf(fin, "%s", cmd) != EOF ) {
127: if ( strcmp(cmd, "name") == 0 ) {
128: release(fpos->name);
129: fscanf(fin, "%s", buf);
130: fpos->name = strsave(buf);
131: } else if ( strcmp(cmd, "fontname") == 0 ) {
132: release(fpos->fontname);
133: fscanf(fin, "%s", buf);
134: fpos->fontname = strsave(buf);
135: } else if ( strcmp(cmd, "special") == 0 )
136: fpos->specfont = 1;
137: else if ( strcmp(cmd, "named") == 0 ) /* in prologue or somewhere else */
138: fpos->flags |= NAMED;
139: else if (strcmp(cmd, "spacewidth") == 0) {
140: fscanf(fin, "%d", &wid);
141: chtemp[0].wid = wid;
142: chtemp[0].num = ' ';
143: nospace = 0;
144: }
145: else if ( strcmp(cmd, "charset") == 0 ) {
146: skipline(fin);
147: nw = 128-32;
148: while ( fgets(buf, sizeof(buf), fin) != NULL ) {
149: sscanf(buf, "%s %s %s %s", ch, s1, s2, s3);
150: if ( s1[0] != '"' ) { /* not a synonym */
151: sscanf(s1, "%d", &wid);
152: if (s3[0] == '0')
153: sscanf(s3, "%o", &code);
154: else sscanf(s3, "%d", &code);
155: } /* End if */
156: if ( strlen(ch) == 1 ) { /* it's ascii */
157: n = ch[0] - 32; /* origin omits non-graphics */
158: chtemp[n].num = ch[0];
159: chtemp[n].wid = wid;
160: chtemp[n].code = code;
161: } else if ( strcmp(ch, "---") != 0 ) { /* ignore unnamed chars */
162: if ( (n = chindex(ch)) == -1 ) /* global? */
163: n = chadd(ch);
164: chtemp[nw].num = n;
165: chtemp[nw].wid = wid;
166: chtemp[nw].code = code;
167: nw++;
168: } /* End else */
169: } /* End while */
170: break;
171: } /* End else */
172: skipline(fin);
173: } /* End while */
174:
175: fclose(fin);
176:
177: if (nospace) {
178: chtemp[0].wid = 25;
179: chtemp[0].num = ' ';
180: }
181:
182: fpos->wp = (Chwid *)allocate(nw * sizeof(Chwid));
183: for ( i = 0; i < nw; i++ )
184: fpos->wp[i] = chtemp[i];
185:
186: fpos->nchars = nw;
187: fpos->state = INMEMORY;
188:
189: return(1);
190:
191: } /* End of getfont */
192:
193: /*****************************************************************************/
194:
195: mountfont(path, m)
196:
197: char *path;
198: int m;
199:
200: {
201:
202: TrFont *fpos;
203:
204: /*
205: *
206: * Mount font table from file path at position m. Mounted fonts are guaranteed
207: * to be in memory.
208: *
209: */
210:
211: if ( m < 0 || m > MAXFONTS )
212: return(-1);
213:
214: if ( mount[m] != NULL ) {
215: if ( strcmp(path, mount[m]->path) == 0 ) {
216: if ( mount[m]->state == INMEMORY )
217: return(1);
218: } else {
219: mount[m]->mounted--;
220: mount[m] = NULL;
221: } /* End else */
222: } /* End if */
223:
224: mount[m] = fpos = &fonts[findfont(path)];
225: mount[m]->mounted++;
226: return(getfont(path, fpos));
227:
228: } /* End of mountfont */
229:
230: /*****************************************************************************/
231:
232: freefonts()
233:
234: {
235:
236: int n;
237:
238: /*
239: *
240: * Release memory used by all unmounted fonts - except for the path string.
241: *
242: */
243:
244: for ( n = 0; n < MAXFONTS+2; n++ )
245: if ( fonts[n].state == INMEMORY && fonts[n].mounted == 0 ) {
246: release(fonts[n].wp);
247: fonts[n].wp = NULL;
248: fonts[n].state = RELEASED;
249: mcount--;
250: } /* End if */
251:
252: } /* End of freefonts */
253:
254: /*****************************************************************************/
255:
256: findfont(path)
257:
258: char *path;
259:
260: {
261:
262: register n;
263:
264: /*
265: *
266: * Look for path in the fonts table. Returns the index where it was found or can
267: * be inserted (if not found).
268: *
269: */
270:
271: for ( n = hash(path, MAXFONTS+2); fonts[n].state != NEWFONT; n = (n+1) % (MAXFONTS+2) )
272: if ( strcmp(path, fonts[n].path) == 0 )
273: break;
274: return(n);
275:
276: } /* End of findfont */
277:
278: /*****************************************************************************/
279:
280: mounted(m)
281:
282: int m;
283:
284: {
285:
286: /*
287: *
288: * Return 1 if a font is mounted at position m.
289: *
290: */
291:
292: return((m >= 0 && m <= MAXFONTS && mount[m] != NULL) ? 1 : 0);
293:
294: } /* End of mounted */
295:
296: /*****************************************************************************/
297:
298: onfont(c, m)
299:
300: int c;
301: int m;
302:
303: {
304:
305: register TrFont *fp;
306: register Chwid *cp, *ep;
307:
308: /*
309: *
310: * Returns the position of character c in the font mounted at m, or -1 if the
311: * character is not found.
312: *
313: */
314:
315: if ( mounted(m) ) {
316: fp = mount[m];
317: if ( c < 128 ) {
318: if ( fp->wp[c-32].num == c ) /* ascii at front */
319: return c - 32;
320: else return -1;
321: } /* End if */
322:
323: cp = &fp->wp[128-32];
324: ep = &fp->wp[fp->nchars];
325: for ( ; cp < ep; cp++ ) /* search others */
326: if ( cp->num == c )
327: return cp - &fp->wp[0];
328: } /* End if */
329:
330: return -1;
331:
332: } /* End of onfont */
333:
334: /*****************************************************************************/
335:
336: chwidth(n, m)
337:
338: int n;
339: int m;
340:
341: {
342:
343: /*
344: *
345: * Return width of the character at position n in the font mounted at m. Skip
346: * bounds checks - assume it's already been done.
347: *
348: */
349:
350: return(mount[m]->wp[n].wid);
351:
352: } /* End of chwidth */
353:
354: /*****************************************************************************/
355:
356: chcode(n, m)
357:
358: int n;
359: int m;
360:
361: {
362:
363: /*
364: *
365: * Return typesetter code for the character at position n in the font mounted
366: * at m. Skip bounds checks - assume it's already been done.
367: *
368: */
369:
370: return(mount[m]->wp[n].code);
371:
372: } /* End of chcode */
373:
374: /*****************************************************************************/
375:
376: chindex(s)
377:
378: char *s;
379:
380: {
381:
382: register i;
383:
384: /*
385: *
386: * Look for s in global character name table. Hash table is guaranteed to have
387: * at least one empty slot (by chadd()) so the loop terminate.
388: *
389: */
390:
391: for ( i = hash(s, MAXCH); chnames[i] != NULL; i = (i+1) % MAXCH )
392: if ( strcmp(s, chnames[i]) == 0 )
393: return(i+128);
394: return(-1);
395:
396: } /* End of chindex */
397:
398: /*****************************************************************************/
399:
400: chadd(s)
401:
402: char *s;
403:
404: {
405:
406: register i;
407:
408: /*
409: *
410: * Add s to the global character name table. Leave one empty slot so loops
411: * terminate.
412: *
413: */
414:
415: if ( nchnames >= MAXCH - 1 )
416: yyerror("out of table space adding character %s", s);
417:
418: for ( i = hash(s, MAXCH); chnames[i] != NULL; i = (i+1) % MAXCH ) ;
419:
420: nchnames++;
421: chnames[i] = strsave(s);
422:
423: return(i+128);
424:
425: } /* End of chadd */
426:
427: /*****************************************************************************/
428:
429: char *chname(n)
430:
431: int n;
432:
433: {
434:
435: /*
436: *
437: * Returns string for the character with index n.
438: *
439: */
440:
441: return(chnames[n-128]);
442:
443: } /* End of chname */
444:
445: /*****************************************************************************/
446:
447: hash(s, l)
448:
449: char *s;
450: int l;
451:
452: {
453:
454: register i;
455:
456: /*
457: *
458: * Return the hash index for string s in a table of length l. Probably should
459: * make i unsigned and mod once at the end.
460: *
461: */
462:
463: for ( i = 0; *s != '\0'; s++ )
464: i = (i * 10 + *s) % l;
465: return(i);
466:
467: } /* End of hash */
468:
469: /*****************************************************************************/
470:
471: char *strsave(s)
472:
473: char *s;
474:
475: {
476:
477: char *ptr = NULL;
478:
479: /*
480: *
481: * Make a permanent copy of string s.
482: *
483: */
484:
485: if ( s != NULL ) {
486: ptr = (char *)allocate(strlen(s)+1);
487: strcpy(ptr, s);
488: } /* End if */
489: return(ptr);
490:
491: } /* End of strsave */
492:
493: /*****************************************************************************/
494:
495: char *allocate(count)
496:
497: int count;
498:
499: {
500:
501: char *ptr;
502:
503: /*
504: *
505: * Allocates count bytes. Free unmounted fonts if the first attempt fails. To
506: * be absolutely correct all memory allocation should be done by this routine.
507: *
508: */
509:
510: if ( (ptr = (char *)malloc(count)) == NULL ) {
511: freefonts();
512: if ( (ptr = (char *)malloc(count)) == NULL )
513: yyerror("out of space in allocate (font.c)");
514: } /* End if */
515: return(ptr);
516:
517: } /* End of allocate */
518:
519: /*****************************************************************************/
520:
521: release(ptr)
522:
523: char *ptr;
524:
525: {
526:
527: /*
528: *
529: * Free memory provided ptr isn't NULL.
530: *
531: */
532:
533: if ( ptr != NULL )
534: free(ptr);
535:
536: } /* End of release */
537:
538: /*****************************************************************************/
539:
540: dumpmount(m)
541:
542: int m;
543:
544: {
545:
546: /*
547: *
548: * Dumps the font mounted at position n.
549: *
550: */
551:
552: if ( mount[m] != NULL )
553: dumpfont((mount[m] - &fonts[0]));
554: else fprintf(stderr, "no font mounted at %d\n", m);
555:
556: } /* End of dumpmount */
557:
558: /*****************************************************************************/
559:
560: dumpfont(n)
561:
562: int n;
563:
564: {
565:
566: int i;
567: TrFont *fpos;
568: char *str;
569:
570: /*
571: *
572: * Dump of everything known about the font saved at fonts[n].
573: *
574: */
575:
576: fpos = &fonts[n];
577:
578: if ( fpos->state ) {
579: fprintf(stderr, "path %s\n", fpos->path);
580: fprintf(stderr, "state %d\n", fpos->state);
581: fprintf(stderr, "flags %d\n", fpos->flags);
582: fprintf(stderr, "mounted %d\n", fpos->mounted);
583: fprintf(stderr, "nchars %d\n", fpos->nchars);
584: fprintf(stderr, "special %d\n", fpos->specfont);
585: fprintf(stderr, "name %s\n", fpos->name);
586: fprintf(stderr, "fontname %s\n", fpos->fontname);
587: if ( fpos->state == INMEMORY ) {
588: fprintf(stderr, "charset\n");
589: for ( i = 0; i < fpos->nchars; i++ ) {
590: if ( fpos->wp[i].num > 0 ) {
591: if ( fpos->wp[i].num < 128 )
592: fprintf(stderr, "%c\t%d\t%d\n", fpos->wp[i].num,
593: fpos->wp[i].wid, fpos->wp[i].code);
594: else {
595: str = chname(fpos->wp[i].num);
596: if ( *str == '#' && isdigit(*(str+1)) && isdigit(*(str+2)) )
597: str = "---";
598: fprintf(stderr, "%s\t%d\t%d\n", str, fpos->wp[i].wid,
599: fpos->wp[i].code);
600: } /* End else */
601: } /* End if */
602: } /* End for */
603: } else fprintf(stderr, "charset: not in memory\n");
604: } else fprintf(stderr, "empty font: %d\n", n);
605:
606: putc('\n', stderr);
607:
608: } /* End of dumpfont */
609:
610: /*****************************************************************************/
611:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.