![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ipmetrics.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 ipmetrics.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / dipress / src / bin / ipmetrics |
1.1 root 1: /*
2: *
3: * Copyright (c) 1984, 1985 Xerox Corp.
4: *
5: * Module: ipmetrics
6: * Owner: Moore
7: * args:
8: * name (name of the input metrics file)
9: *
10: * Description:
11: * This program reads an Interpress file, executes it and produces a
12: * set of Troff printer description files.
13: *
14: * The metrics file will be read from the file "name.ip",
15: * where name is read from the command line. The ".ip"
16: * extension will not be added if it is already present in the
17: * name.
18: *
19: * HISTORY
20: * 04-Feb-86 lee at Xerox, WRC
21: * Added the ability to execute several masters instead of just one.
22: *
23: * 06-Jan-86 Lee Moore(lee) at Xerox, WRC
24: * Converted for use with ipmetrics.
25: *
26: *
27: * K. Knox, 28-Mar-85 15:04:13, Created first version.
28: *
29: */
30:
31: #include <stdio.h>
32: #include <strings.h>
33: #include "stack.h"
34: #include "token.h"
35: #include "config.h"
36: #include "ipmetrics.h"
37:
38: #define TRUE 1
39: #define FALSE 0
40:
41: enum TypesettingSystems { none, Troff, TeX};
42:
43: extern char *getstring();
44: extern unsigned char *malloc();
45:
46: extern unsigned char **getvector();
47:
48: struct FontConfig *ReadConfigFile();
49: enum TypesettingSystems getargs();
50:
51: char *LibraryDirectory = "../lib",
52: LibraryDirStorage[1024];
53:
54:
55: #define err0 "ipmetrics: No input ip file name!\n"
56: #define err1 "ipmetrics: ip file could not be found, %s!\n"
57:
58: FILE *fpin;
59: int fdout;
60: char DeviceName1[MAXTOKENSIZE];
61: char *DeviceName = DeviceName1;
62:
63:
64: main(argc, argv)
65: int argc;
66: char *argv[];
67: {
68: enum TypesettingSystems system;
69: struct FontConfig *configChain;
70:
71: system = getargs(argc, argv);
72: printf("reading description file... "); fflush(stdout);
73: configChain = ReadConfigFile();
74: printf("writing font files... "); fflush(stdout);
75: InitFontFiles(system, configChain);
76: WriteEachFont(system, configChain);
77: CleanUpFontFiles(system, configChain);
78: printf("done.\n");
79: exit(0);
80: }
81:
82: InitFontFiles(system, configChain)
83: enum TypesettingSystems system;
84: struct FontConfig *configChain; {
85: switch( system ) {
86: case Troff:
87: InitTroff();
88: break;
89:
90: case TeX:
91: break;
92:
93: default:
94: printf("ipmetrics: internal error\n");
95: }
96: }
97:
98: CleanUpFontFiles(system, configChain)
99: enum TypesettingSystems system;
100: struct FontConfig *configChain; {
101: switch( system ) {
102: case Troff:
103: CleanUpTroff(configChain);
104: break;
105:
106: case TeX:
107: CleanUpTeX(configChain);
108: break;
109:
110: default:
111: printf("ipmetrics: internal error\n");
112: }
113: }
114:
115:
116: enum TypesettingSystems
117: getargs(argc, argv)
118: int argc;
119: char *argv[];
120: {
121: char *filename,
122: c;
123: extern int optind;
124: extern char *optarg;
125: enum TypesettingSystems system = Troff;
126:
127: while ((c = getopt(argc, argv, "d:tT")) != EOF)
128: switch (c) {
129: case 'd':
130: strncpy(LibraryDirStorage, optarg, sizeof(LibraryDirStorage));
131: LibraryDirectory = LibraryDirStorage;
132: break;
133:
134: case 't':
135: system = Troff;
136: break;
137:
138: case 'T':
139: system = TeX;
140: break;
141:
142: default:
143: printf("ipmetrics: option '%c' not allowed\n");
144: }
145:
146: if (argc == optind) { /* at least one argument */
147: error(err0);
148: exit(1);
149: }
150:
151: for( ; optind < argc ; optind++ ) {
152: /* Open input IP file. */
153: fdout = 1;
154: filename = (char *) malloc((unsigned) strlen(argv[optind])+1+strlen(".ip"));
155: strcpy(filename, argv[optind]);
156:
157: if (strcmp(".ip", rindex(filename, '.')) != 0)
158: strcat(filename, ".ip");
159:
160: fpin = fopen(filename, "r");
161:
162: if (fpin == NULL)
163: error(err1, filename);
164:
165: printf("executing %s... ", filename); fflush(stdout);
166: parse(fpin);
167: }
168:
169: return system;
170: }
171:
172: /*
173: * read the font configuration file
174: */
175: struct FontConfig *
176: ReadConfigFile() {
177: int n;
178: char token[MAXTOKENSIZE];
179: struct TokenState *ts;
180: struct FontConfig **last,
181: *p,
182: *configChain;
183:
184: last = &configChain;
185: ts = InitTokenStream(stdin);
186: GetToken(ts, token, MAXTOKENSIZE);
187:
188: if( strcmp(token, "device") != 0 ) {
189: fprintf(stderr, "first token in %s, not 'device'\n", token);
190: exit(1); }
191:
192: GetToken(ts, DeviceName, MAXTOKENSIZE);
193: printf(" device is %s\n", DeviceName);
194:
195: while( !EndOfFile(ts) ) {
196: p = (struct FontConfig *) malloc((unsigned) sizeof(struct FontConfig));
197:
198: GetToken(ts, p->FontPt1, MAXTOKENSIZE);
199: GetToken(ts, p->FontPt2, MAXTOKENSIZE);
200: GetToken(ts, p->FontPt3, MAXTOKENSIZE);
201: GetToken(ts, p->TroffName, MAXTOKENSIZE);
202:
203: if( !EndOfLine(ts) )
204: GetToken(ts, p->MapFile, MAXTOKENSIZE);
205: else
206: p->MapFile[0] = '\0';
207:
208: p->Next = NULL;
209: *last = p;
210: last = &p->Next;
211: }
212:
213: return configChain;
214: }
215:
216: WriteEachFont(system, configChain)
217: enum TypesettingSystems system;
218: struct FontConfig *configChain;
219: {
220: unsigned char *fontVec;
221: int tableIndex;
222:
223: tableIndex = 0;
224:
225: while (!stackempty()) {
226: fontVec = pop(0, 0);
227:
228: switch( system ) {
229: case Troff:
230: PerTroffFont(configChain, fontVec);
231: tableIndex++; /* necessary? */
232: break;
233:
234: case TeX:
235: PerTeXFont(configChain, fontVec);
236: break;
237:
238: default:
239: printf("ipmetrics: internal error\n");
240: }
241:
242: free((char *) fontVec); }
243: }
244:
245:
246: GetFontNameProperty(fontDescVec, CName)
247: unsigned char *fontDescVec;
248: char *CName[3]; {
249: unsigned char *nameProperty,
250: **nameVec;
251: int i;
252:
253: if( (nameProperty = GetStringProp("name", fontDescVec)) == NULL ) {
254: printf("ipmetrics: can't find 'name' property\n");
255: return FALSE;
256: }
257:
258: nameVec = getvector(nameProperty);
259:
260: for( i = 0; i < 3; i++ ) {
261: if( gettype(nameVec[i]) != type_string ) {
262: printf("name vector not of type string\n");
263: free((char *) nameVec);
264: return FALSE;
265: }
266:
267: if( getsubtype(nameVec[i]) != subtype_identifier ) {
268: printf("name subtype not an identifier\n");
269: free((char *) nameVec);
270: return FALSE;
271: }
272:
273: CName[i] = getstring(nameVec[i], subtype_identifier);
274: }
275:
276: free((char *) nameVec);
277: return TRUE;
278: }
279:
280:
281: unsigned char *
282: GetStringProp(propName, list)
283: char *propName;
284: unsigned char *list; {
285: int i,
286: vecLength;
287: char *candidate;
288: unsigned char **listArray;
289:
290: if( gettype(list) != type_vector ) {
291: printf("ipmetric: non-vector found in stack!\n");
292: return NULL;}
293:
294: if( getsubtype(list) != subtype_general ) {
295: printf("ipmetric: vector sub-type is not 'general'\n");
296: return NULL; }
297:
298: if( (vecLength = getdepth(list)) & 01 ) {
299: printf("ipmetrics: property vector is of odd length\n");
300: return NULL;}
301:
302: listArray = getvector(list);
303:
304: for( i = 0; i < vecLength; i += 2 ) {
305: if( ! checktype(listArray[i], type_string, subtype_identifier) ) {
306: printf("ipmetrics: property of incorrect type\n");
307: return NULL;}
308:
309: candidate = getstring(listArray[i], subtype_identifier);
310:
311: if( strcmp(propName, candidate) == 0 )
312: return listArray[i+1];
313: }
314: free((char *) listArray);
315: return NULL;
316: }
317:
318:
319: unsigned char *
320: GetIntegerProp(property, list)
321: int property;
322: unsigned char *list; {
323: int i,
324: vecLength;
325: int candidate;
326: unsigned char **listArray;
327:
328: if( gettype(list) != type_vector ) {
329: printf("ipmetric: non-vector found in stack!\n");
330: return NULL;}
331:
332: if( getsubtype(list) != subtype_general ) {
333: printf("ipmetric: vector sub-type is not 'general'\n");
334: return NULL; }
335:
336: if( (vecLength = getdepth(list)) & 01 ) {
337: printf("ipmetrics: property vector is of odd length\n");
338: return NULL;}
339:
340: listArray = getvector(list);
341:
342: for( i = 0; i < vecLength; i += 2 ) {
343: if( ! checktype(listArray[i], type_number, subtype_integer) ) {
344: printf("ipmetrics: property of incorrect type\n");
345: return NULL;}
346:
347: candidate = getint(listArray[i], subtype_identifier);
348:
349: if( property == candidate )
350: return listArray[i+1];
351: }
352:
353: free((char *) listArray);
354: return NULL;
355: }
356:
357:
358:
359: printitem(ptr, element)
360: unsigned char *ptr;
361: int element;
362: {
363: printf("Element: %d\n", element);
364: printf("Length: %d\n", getlength(ptr));
365: switch (gettype(ptr))
366: {
367: case type_number: printnumber(ptr); break;
368: case type_string: printstring(ptr); break;
369: case type_vector: printvector(ptr); break;
370: case type_operator: printoperator(ptr); break;
371: case type_pixelarray: printpixelarray(ptr); break;
372: case type_transformation: printtransformation(ptr); break;
373: case type_integers: printintegers(ptr); break;
374: default: printf("Type: unknown\n"); break;
375: }
376: }
377:
378: printnumber(ptr)
379: unsigned char *ptr;
380: {
381: printf("Type: number\n");
382: switch (getsubtype(ptr))
383: {
384: case subtype_integer: printinteger(ptr); break;
385: case subtype_rational: printrational(ptr); break;
386: default: printf("Subtype: unknown\n"); break;
387: }
388: }
389:
390: printinteger(ptr)
391: unsigned char *ptr;
392: {
393: printf("Subtype: integer\n");
394: printf("Value: %d\n", getint(ptr));
395: }
396:
397: printrational(ptr)
398: unsigned char *ptr;
399: {
400: printf("Subtype: rational\n");
401: printf("Value: %f/%f\n", getnumerator(ptr), getdenominator(ptr));
402: }
403:
404: printstring(ptr)
405: unsigned char *ptr;
406: {
407: printf("Type: string\n");
408: switch (getsubtype(ptr))
409: {
410: case subtype_identifier: printidentifier(ptr); break;
411: case subtype_string: printsubstring(ptr); break;
412: default: printf("Subtype: unknown\n"); break;
413: }
414: }
415:
416: printidentifier(ptr)
417: unsigned char *ptr;
418: {
419: printf("Subtype: identifier\n");
420: printf("Identifier: %s\n", getstring(ptr, subtype_identifier));
421: }
422:
423: printsubstring(ptr)
424: unsigned char *ptr;
425: {
426: printf("Subtype: string\n");
427: printf("String: %s\n", getstring(ptr, subtype_string));
428: }
429:
430: printvector(ptr)
431: unsigned char *ptr;
432: {
433: printf("Type: vector\n");
434: switch (getsubtype(ptr))
435: {
436: case subtype_general: printvec(ptr, "general"); break;
437: case subtype_integers: printvec(ptr, "integers"); break;
438: case subtype_samples: printvec(ptr, "samples"); break;
439: default: printf("Subtype: unknown\n"); break;
440: }
441: }
442:
443: printvec(ptr, string)
444: unsigned char *ptr;
445: char *string;
446: {
447: int n, depth;
448: unsigned char **array;
449:
450: depth = getdepth(ptr);
451: printf("Subtype: %s\n", string);
452: printf("Depth: %d\n", depth);
453: array = getvector(ptr);
454:
455: for (n=0; n < depth; n++) printitem(array[n], n);
456:
457: free((char *) array);
458: }
459:
460: printoperator(ptr)
461: unsigned char *ptr;
462: {
463: printf("Type: operator\n");
464: switch (getsubtype(ptr))
465: {
466: case subtype_decompressop: printop(ptr, "decompressop"); break;
467: case subtype_colorop: printop(ptr, "colorop"); break;
468: case subtype_colormodelop: printop(ptr, "colormodelop"); break;
469: default: printf("Subtype: unknown\n"); break;
470: }
471: }
472:
473: printop(ptr, string)
474: unsigned char *ptr;
475: char *string;
476: {
477: int n, depth;
478: unsigned char **array;
479:
480: depth = getdepth(ptr);
481: printf("Subtype: %s\n", string);
482: printf("Depth: %d\n", depth);
483: array = getoperator(ptr);
484:
485: for (n=0; n < depth; n++) printitem(array[n], n);
486:
487: free((char *) array);
488: }
489:
490: printpixelarray(ptr)
491: unsigned char *ptr;
492: {
493: }
494:
495: printtransformation(ptr)
496: unsigned char *ptr;
497: {
498: double *array;
499:
500: array = gettransformation(ptr);
501: printf("Type: transformation\n");
502: printf("A: %f\n", array[0]);
503: printf("B: %f\n", array[1]);
504: printf("C: %f\n", array[2]);
505: printf("D: %f\n", array[3]);
506: printf("E: %f\n", array[4]);
507: printf("F: %f\n", array[5]);
508: free((char *) array);
509: }
510:
511: printintegers(ptr)
512: unsigned char *ptr;
513: {
514: printf("Type: integers\n");
515: printf("Bytes/Integer: %d\n", getbytesPerInteger(ptr));
516: printf("Bytepos: %ld\n", getbytepos(ptr));
517: printf("ByteLength: %ld\n", getbytelength(ptr));
518: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.