![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to troff.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / dipress / src / bin / ipmetrics|
Return to troff.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / dipress / src / bin / ipmetrics |
1.1 root 1: /*
2: * Copyright (c) 1984, 1985 Xerox Corp.
3: * Handle troff here
4: *
5: * note that Troff uses "fat points" of which there are exactly 72 per inch.
6: *
7: * HISTORY
8: * Nov, 1985 Lee Moore, Xerox Webster Research Center
9: * Created.
10: */
11:
12: #include <stdio.h>
13: #include <math.h>
14: #include "stack.h"
15: #include "token.h"
16: #include "config.h"
17: #include "ipmetrics.h"
18: #include "troff.h"
19:
20: #define TRUE 1
21: #define FALSE 0
22:
23:
24: /* the following value should be choosen so that none of the widths
25: * is greater than 256
26: */
27: #define UNITWIDTH 5 /* was 10 */
28:
29:
30: #define MAXSPECIALNAMES 221 /* maximum number of special characters.
31: * this constant is fixed in Troff
32: */
33:
34: #define public
35: #define private static
36:
37: public char *malloc();
38:
39: public char *DeviceName,
40: *LibraryDirectory;
41:
42: struct CharElement {
43: struct CharElement *Next;
44: char CharName[3]; };
45:
46: private struct CharElement *CharSet = NULL;
47:
48: private int SetOfPointSizes[MAXPOINTSIZE],
49: FontCount = 0;
50:
51: public
52: InitTroff() {
53: }
54:
55: public
56: CleanUpTroff(configChain)
57: struct FontConfig *configChain; {
58: struct FontConfig *p;
59:
60: WriteDescFile(configChain);
61: WriteFontMapFile(configChain);
62: WriteInstallFile(configChain);
63: WriteCleanUpFile(configChain);
64:
65: for( p = configChain; p != NULL; p = p->Next )
66: if( !p->SeenFlag )
67: printf("couldn't find: %s/%s/%s\n",
68: p->FontPt1, p->FontPt2, p->FontPt3);
69: }
70:
71: private
72: WriteDescFile(configChain)
73: struct FontConfig *configChain; {
74: int i;
75: FILE *deviceFile;
76: struct FontConfig *p;
77:
78: if( (deviceFile = fopen("DESC", "w")) == NULL ) {
79: printf("can't open 'DESC' for writing\n");
80: exit(1); }
81:
82: /* output boiler plate */
83: fprintf(deviceFile, "# describe the '%s' interpress device\n", DeviceName);
84: fprintf(deviceFile, "res %d\n", MICAS_PER_INCH);
85: fprintf(deviceFile, "hor 1\n");
86: fprintf(deviceFile, "vert 1\n");
87: fprintf(deviceFile, "unitwidth %d\n", UNITWIDTH);
88: fprintf(deviceFile, "paperwidth %d\n", PAGE_WIDTH_IN_MICAS);
89: fprintf(deviceFile, "paperlength %d\n", PAGE_HEIGHT_IN_MICAS);
90:
91: /* output sizes */
92: fprintf(deviceFile, "sizes ");
93:
94: for( i = 1; i < MAXPOINTSIZE; i++ )
95: if( SetOfPointSizes[i] )
96: fprintf(deviceFile," %d", i);
97:
98: fprintf(deviceFile, " 0\n");
99:
100: /* output fonts */
101: fprintf(deviceFile, "fonts %d ", FontCount);
102:
103: for( p = configChain; p != NULL; p = p->Next )
104: if( p->SeenFlag )
105: fprintf(deviceFile, "%s ", p->TroffName);
106:
107: fprintf(deviceFile, "\n");
108: PrintCharSet(deviceFile);
109: fclose(deviceFile); }
110:
111:
112:
113: private
114: WriteFontMapFile(configChain)
115: struct FontConfig *configChain; {
116: int i;
117: FILE *fontMapFile;
118: struct FontConfig *p;
119:
120: if( (fontMapFile = fopen(FONTMAPFILENAME, "w")) == NULL ) {
121: fprintf(stderr, "can't open the file '%s' for writing\n", FONTMAPFILENAME);
122: return; }
123:
124: for( p = configChain; p != NULL; p = p->Next )
125: if( p->SeenFlag )
126: fprintf(fontMapFile, "%s %s/%s/%s\n", p->TroffName,
127: p->FontPt1, p->FontPt2, p->FontPt3);
128:
129: fclose(fontMapFile);
130: chmod(FONTMAPFILENAME, 0755); }
131:
132:
133: private
134: WriteInstallFile(configChain)
135: struct FontConfig *configChain; {
136: int i;
137: FILE *installFile;
138: struct FontConfig *p;
139:
140: if( (installFile = fopen(INSTALLNAME, "w")) == NULL ) {
141: fprintf(stderr, "can't open the file 'install' for writing\n");
142: return; }
143:
144: fprintf(installFile, "#! /bin/sh\n");
145: fprintf(installFile, "if test ! -d %s/fonts/%s\n", LibraryDirectory, DeviceName);
146: fprintf(installFile, " then\n");
147: fprintf(installFile, " mkdir %s/fonts/%s\n", LibraryDirectory, DeviceName);
148: fprintf(installFile, " fi\n");
149: fprintf(installFile, "if test ! -d %s/fonts/%s/devipress\n", LibraryDirectory, DeviceName);
150: fprintf(installFile, " then\n");
151: fprintf(installFile, " mkdir %s/fonts/%s/devipress\n", LibraryDirectory, DeviceName);
152: fprintf(installFile, " fi\n");
153:
154:
155: for( p = configChain; p != NULL; p = p->Next )
156: if( p->SeenFlag )
157: fprintf(installFile, "cp %s %s/fonts/%s/devipress\n",
158: p->TroffName, LibraryDirectory, DeviceName);
159:
160: fprintf(installFile, "cp DESC %s/fonts/%s/devipress\n", LibraryDirectory,
161: DeviceName);
162: fprintf(installFile, "cp %s %s/fonts/%s/devipress\n", FONTMAPFILENAME,
163: LibraryDirectory, DeviceName);
164: fprintf(installFile, "cd %s/fonts/%s/devipress\n", LibraryDirectory,
165: DeviceName);
166: fprintf(installFile, "makedev DESC\n");
167: fprintf(installFile, "makextdev DESC\n");
168: fclose(installFile);
169: chmod(INSTALLNAME, 0755); }
170:
171:
172: /*
173: * write a file that rm's all the files created by this program
174: */
175:
176: private
177: WriteCleanUpFile(configChain)
178: struct FontConfig *configChain; {
179: int i;
180: FILE *cleanupFile;
181: struct FontConfig *p;
182:
183: if( (cleanupFile = fopen(CLEANUPNAME, "w")) == NULL ) {
184: fprintf(stderr, "can't open the file 'cleanup' for writing\n");
185: return; }
186:
187: fprintf(cleanupFile, "#! /bin/sh\n");
188:
189: for( p = configChain; p != NULL; p = p->Next )
190: if( p->SeenFlag )
191: fprintf(cleanupFile, "rm %s\n", p->TroffName);
192:
193: fprintf(cleanupFile, "rm DESC\n");
194: fprintf(cleanupFile, "rm %s\n", INSTALLNAME);
195: fprintf(cleanupFile, "rm %s\n", FONTMAPFILENAME);
196: fprintf(cleanupFile, "rm %s\n", CLEANUPNAME);
197: fclose(cleanupFile);
198: chmod(CLEANUPNAME, 0755); }
199:
200: /*
201: * called once per font on the stack
202: */
203:
204: public
205: PerTroffFont(configChain, fontDescVec)
206: struct FontConfig *configChain;
207: unsigned char *fontDescVec; {
208: unsigned char *charMetricsProperty,
209: *metricsProperty,
210: *width,
211: *charMetric;
212: char iSender[MAXTOKENSIZE],
213: iCharName[MAXTOKENSIZE],
214: fileType[MAXTOKENSIZE],
215: *fontName[3],
216: iCharSet[MAXTOKENSIZE],
217: iCharCode[MAXTOKENSIZE];
218: FILE *descFile,
219: *modelFile;
220: struct FontConfig *p;
221: struct TokenState *ts;
222: int charSet,
223: charNumber,
224: charIndex,
225: xWidth;
226:
227: if( !GetFontNameProperty(fontDescVec, fontName) ) {
228: fprintf(stderr, "ipmetrics: can't get font name\n");
229: return;
230: }
231:
232: if( (charMetricsProperty = GetStringProp("characterMetrics", fontDescVec))
233: == NULL ) {
234: printf("ipmetrics: can't find 'characterMetrics' property\n");
235: return; }
236:
237: for( p = configChain; p != NULL; p = p->Next ) {
238: if( !(strcmp(p->FontPt1, fontName[0]) == 0 &&
239: strcmp(p->FontPt2, fontName[1]) == 0 &&
240: strcmp(p->FontPt3, fontName[2]) == 0) )
241: continue;
242:
243: if( (descFile = fopen(p->TroffName , "w")) == NULL ) {
244: printf("ipmetrics: can't open %s for writing\n", p->TroffName);
245: return;}
246:
247: if( (modelFile = fopen(p->MapFile, "r")) == NULL ) {
248: printf("ipmetrics: can't open %s for reading\n", p->MapFile);
249: return;}
250:
251: p->SeenFlag = TRUE;
252: /* (void) strcpy(malloc((unsigned) 3), p->TroffName); */
253: FontCount++;
254:
255: ts = InitTokenStream(modelFile);
256:
257: fprintf(descFile, "#\n");
258: fprintf(descFile, "# %s/%s/%s for Interpress device %s\n", p->FontPt1, p->FontPt2, p->FontPt3, DeviceName);
259: fprintf(descFile, "name %s\n", p->TroffName);
260: fprintf(descFile, "internalname %d\n", FontCount);
261:
262: GetToken(ts, fileType, MAXTOKENSIZE);
263:
264: if( strcmp(fileType, "special") == 0 )
265: fprintf(descFile, "special\n");
266: else
267: ProcessTroffLigatures(charMetricsProperty, descFile);
268:
269: fprintf(descFile, "charset\n");
270:
271: while( !EndOfFile(ts) ) {
272: GetToken(ts, iCharSet, MAXTOKENSIZE);
273: sscanf(iCharSet, "%o", &charSet);
274: GetToken(ts, iCharCode, MAXTOKENSIZE);
275: sscanf(iCharCode, "%o", &charNumber);
276: GetToken(ts, iSender, MAXTOKENSIZE);
277: GetToken(ts, iCharName, MAXTOKENSIZE);
278: charIndex = Make16BitChar(charSet, charNumber);
279:
280: /* skip the rest of this loop if it's not in this font */
281: if( (charMetric =
282: GetIntegerProp(charIndex, charMetricsProperty)) == NULL )
283: continue;
284:
285: if( (width = GetStringProp("widthX", charMetric)) == NULL ){
286: printf("ipmetrics: can't find widthX property of %d\n",
287: charIndex);
288: continue;}
289:
290: if( gettype(width) != type_number ) {
291: printf("ipmetrics: width not of type number for %d\n",
292: charIndex);
293: continue;}
294:
295: if( getsubtype(width) != subtype_rational ) {
296: printf("ipmetrics: width not of subtype number for %d\n",
297: charIndex);
298: continue;}
299:
300: xWidth = (getnumerator(width)*UNITWIDTH*MICAS_PER_INCH +
301: (getdenominator(width) * POINTS_PER_INCH)/2)/
302: (getdenominator(width) * POINTS_PER_INCH);
303:
304: if( xWidth >= 256 )
305: printf("ipmetrics: warning width >= 256\n");
306:
307: fprintf(descFile, "%s\t%d\t%s\t", iCharName, xWidth,
308: iSender);
309:
310: if( charIndex < 0377 )
311: fprintf(descFile, "%d\n", charIndex);
312: else
313: fprintf(descFile, "0377\t0%o\n", charIndex);
314:
315: CheckForSpecialness(iCharName);
316:
317: while( !EndOfLine(ts) ) {
318: GetToken(ts, iCharName, MAXTOKENSIZE);
319: fprintf(descFile, "%s\t\"\n", iCharName);
320: CheckForSpecialness(iCharName);}}
321:
322: CloseTokenStream(ts);
323: fclose(descFile);
324: fclose(modelFile);
325: }
326:
327: if( (metricsProperty = GetStringProp("metrics", fontDescVec))
328: != NULL ) {
329: unsigned char *easyProperty;
330:
331: if( (easyProperty = GetStringProp("easy", metricsProperty))
332: != NULL )
333: ProcessEasy(easyProperty);
334: }
335: }
336:
337: /*
338: * assume that the font is in XC1-1-1 standard and find the ligatures
339: * that troff wants
340: */
341:
342: private
343: ProcessTroffLigatures(charMetricsVec, descFile)
344: unsigned char *charMetricsVec;
345: FILE *descFile; {
346: char ligatureNames[21];
347:
348: (void) strcpy(ligatureNames, "");
349:
350: if( GetIntegerProp(Make16BitChar(0360, 044), charMetricsVec) != NULL )
351: (void) strcat(ligatureNames, " fi");
352:
353: if( GetIntegerProp(Make16BitChar(0360, 045), charMetricsVec) != NULL )
354: (void) strcat(ligatureNames, " fl");
355:
356: if( GetIntegerProp(Make16BitChar(0360, 041), charMetricsVec) != NULL )
357: (void) strcat(ligatureNames, " ff");
358:
359: if( GetIntegerProp(Make16BitChar(0360, 042), charMetricsVec) != NULL )
360: (void) strcat(ligatureNames, " ffi");
361:
362: if( GetIntegerProp(Make16BitChar(0360, 043), charMetricsVec) != NULL )
363: (void) strcat(ligatureNames, " ffl");
364:
365: if( strcmp(ligatureNames, "") != 0 )
366: fprintf(descFile, "ligatures %s 0\n", ligatureNames);}
367:
368: /*
369: * Check to see if a character is special and add it to the "charset"
370: * in the DESC file if it is.
371: */
372:
373: private
374: CheckForSpecialness(s)
375: char *s; {
376: /* right now, if it two characters long, then it must be special */
377: if( strlen(s) == 2 )
378: AddToCharSet(s); }
379:
380: /*
381: * add a special character to the set of special characters. The set
382: * is implemented as a linked list.
383: */
384:
385: private
386: AddToCharSet(s)
387: char *s; {
388: struct CharElement **p,
389: *q;
390:
391: p = &CharSet;
392:
393: while( *p != NULL ) {
394: if( strcmp(s, (*p)->CharName) == 0 )
395: return;
396:
397: p = &(*p)->Next; }
398:
399: q = (struct CharElement *) malloc((unsigned) sizeof(struct CharElement));
400: (void) strcpy(q->CharName, s);
401: q->Next = NULL;
402: *p = q; }
403:
404: /*
405: * print out the list of special characters to the DESC file
406: */
407:
408: private
409: PrintCharSet(file)
410: FILE *file; {
411: int itemsPerLine;
412: struct CharElement *p;
413:
414: /* test to see if there is a char. set. ditroff requires this!
415: * you just can't have a null charset! */
416: if( CharSet == NULL )
417: return;
418:
419: fprintf(file, "charset\n");
420: itemsPerLine = 0;
421:
422: for( p = CharSet; p != NULL; p = p->Next ) {
423: fprintf(file, " %s", p->CharName);
424:
425: if( itemsPerLine++ > 20 ) {
426: fputc('\n', file);
427: itemsPerLine = 0; } }
428:
429: if( itemsPerLine != 0 )
430: fputc('\n', file); }
431:
432: /*
433: * Process the "easy" property of the "metrics" property. This
434: * will tell us what (viewing) sizes the font is available in.
435: */
436:
437: private
438: ProcessEasy(easyProperty)
439: unsigned char *easyProperty; {
440: int depth,
441: i;
442: unsigned char **array;
443:
444: if( gettype(easyProperty) != type_vector ||
445: getsubtype(easyProperty) != subtype_general ) {
446: printf("ipmetrics: wrong vector type in 'easy'\n");
447: return; }
448:
449: depth = getdepth(easyProperty);
450: array = getvector(easyProperty);
451:
452: for( i = 0; i < depth; i++ ) {
453: double *transform,
454: fPointSize;
455: int iPointSize;
456:
457: if( gettype(array[i]) != type_transformation ) {
458: printf("ipmetrics: transforms not found in 'easy'\n");
459: return; }
460:
461: transform = gettransformation(array[i]);
462:
463: if( transform[0] != transform[4] ) {
464: printf("ipmetrics: only square transforms in 'easy'\n");
465: return; }
466:
467: if( transform[1] != 0 || transform[2] != 0 ||
468: transform[3] != 0 || transform[5] != 0 ) {
469: printf("ipmetrics: troff doesn't support rotations\n");
470: return; }
471:
472: fPointSize = transform[0]*72*100000/2540;
473: iPointSize = fPointSize + 0.5;
474:
475: if( fabs(fPointSize - iPointSize) > .25 ) {
476: printf("ipmetrics: troff doesn't support fractional points: %f6.2\n", fPointSize);
477: return; }
478:
479: SetOfPointSizes[iPointSize] = 1;
480: free((char *) transform);
481: }
482:
483: free((char *) array);
484: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.