![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to troffgen.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 troffgen.c CVS log | Up to [Research Unix] / researchv10no / cmd / picasso |
1.1 root 1: /* Copyright (c) 1988 AT&T */
2: /* All Rights Reserved */
3:
4: /* THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T */
5: /* The copyright notice above does not evidence any */
6: /* actual or intended publication of such source code. */
7:
8: /* @(#)picasso:troffgen.c 1.0 */
9:
10: #include <string.h>
11: #include <ctype.h>
12: #include "font.h"
13: #include "picasso.h"
14: #include "y.tab.h"
15:
16: char esc = '\\';
17: char eqn_delim[] = "\0";
18:
19: /* the following table of troff names for special characters is in ASCII */
20: /* order of their names, so that a binary search could be done if desired. */
21: /* the font field MUST conform to the font initialization in fonts.c, with */
22: /* the "standard" Times Roman in position 0 and the symbol font as font 1. */
23:
24: struct trcode {char name[2]; char font; unsigned char value;}
25: trcode[] =
26: {'\0','\0','\0','\0', /* null entry, never matched. */
27: '!','=', 1, 0271, /* not equal */
28: '!','b', 1, 0313, /* not subset */
29: '!','m', 1, 0317, /* not member */
30: '"','a', 0, 0315, /* hungarumlaut accent */
31: '\'','\'',0,0272, /* right double quote */
32: '*','*', 1, '*', /* math star */
33:
34: '*','A', 1, 'A', '*','B', 1, 'B', '*','C', 1, 'X', /* greek */
35: '*','D', 1, 'D', '*','E', 1, 'E', '*','F', 1, 'F', /* alpha-*/
36: '*','G', 1, 'G', '*','H', 1, 'Q', '*','I', 1, 'I', /* bet. */
37: '*','K', 1, 'K', '*','L', 1, 'L', '*','M', 1, 'M',
38: '*','N', 1, 'N', '*','O', 1, 'O', '*','P', 1, 'P',
39: '*','Q', 1, 'Y', '*','R', 1, 'R', '*','S', 1, 'S',
40: '*','T', 1, 'T', '*','U', 1, 'U', '*','W', 1, 'W',
41: '*','X', 1, 'C', '*','Y', 1, 'H', '*','Z', 1, 'Z',
42: '*','a', 1, 'a', '*','b', 1, 'b', '*','c', 1, 'x',
43: '*','d', 1, 'd', '*','e', 1, 'e', '*','f', 1, 'f',
44: '*','g', 1, 'g', '*','h', 1, 'q', '*','i', 1, 'i',
45: '*','k', 1, 'k', '*','l', 1, 'l', '*','m', 1, 'm',
46: '*','n', 1, 'n', '*','o', 1, 'o', '*','p', 1, 'p',
47: '*','q', 1, 'y', '*','r', 1, 'r', '*','s', 1, 's',
48: '*','t', 1, 't', '*','u', 1, 'u', '*','w', 1, 'w',
49: '*','x', 1, 'c', '*','y', 1, 'h', '*','z', 1, 'z',
50:
51: '+','-', 1, 0261, /* plus-minus */
52: ',','a', 0, 0313, /* cedilla accent */
53: '-','>', 1, 0256, /* right arrow */
54: '-','a', 0, 0305, /* macron accent */
55: '.','a', 0, 0307, /* dot accent */
56: ':','a', 0, 0310, /* dieresis accent */
57: '<','-', 1, 0254, /* left arrow */
58: '<','=', 1, 0243, /* less than or equal */
59: '=','=', 1, 0272, /* identically equal */
60: '>','=', 1, 0263, /* greater than or equal */
61: 'C','O', 1, 0343, /* copyright (sanserif) */
62: 'C','R', 1, 0277, /* carriage return */
63: 'C','a', 0, 0316, /* ogonek accent */
64: 'I','f', 1, 0301, /* I (fraktur) */
65: 'L','B', 1, 0350, /* paren, left bottom */
66: 'L','T', 1, 0346, /* paren, left top */
67: 'O','+', 1, 0305, /* circled plus */
68: 'O','x', 1, 0304, /* circled times */
69: 'R','B', 1, 0370, /* paren, right bottom */
70: 'R','G', 1, 0342, /* registered (sanserif) */
71: 'R','T', 1, 0366, /* paren, right top */
72: 'R','f', 1, 0302, /* R (fraktur) */
73: 'T','M', 1, 0344, /* trademark (sanserif) */
74: 'U','a', 0, 0306, /* breve accent */
75: '^','a', 0, 0303, /* circumflex accent */
76: '`','`', 0, 0252, /* left double quote */
77: 'a','a', 0, 0302, /* circumflex accent */
78: 'a','b', 1, 0253, /* arrow both (left & right) */
79: 'a','f', 1, 0300, /* aleph */
80: 'a','h', 1, 0276, /* arrow horizontal extender */
81: 'a','n', 1, 0320, /* angle */
82: 'a','p', 1, '~', /* approximates */
83: 'a','v', 1, 0275, /* arrow vertical extender */
84: 'b','<', 1, 0341, /* left angle bracket */
85: 'b','>', 1, 0361, /* right angle bracket */
86: 'b','u', 0, 0267, /* bullet */
87: 'b','v', 1, 0352, /* bold vertical (extender) */
88: 'c','.', 1, 0327, /* centered dot */
89: 'c','a', 1, 0307, /* cap */
90: 'c','g', 1, '@', /* congruent to */
91: 'c','o', 1, 0323, /* copyright (serif) */
92: 'c','r', 0, 0250, /* currency */
93: 'c','t', 0, 0242, /* cent */
94: 'c','u', 1, 0310, /* cup */
95: 'd','a', 1, 0257, /* down arrow */
96: 'd','d', 0, 0263, /* double dagger */
97: 'd','e', 1, 0260, /* degree */
98: 'd','g', 0, 0262, /* dagger */
99: 'd','i', 1, 0270, /* divide */
100: 'e','l', 0, 0274, /* ellipsis */
101: 'e','m', 0, 0320, /* emdash */
102: 'e','n', 0, 0261, /* endash */
103: 'e','q', 1, '=', /* equals */
104: 'e','s', 1, 0306, /* empty set */
105: 'f','a', 1, '"', /* for all */
106: 'f','i', 0, 0256, /* fi ligature */
107: 'f','l', 0, 0257, /* fl ligature */
108: 'f','m', 1, 0242, /* minute (footmark) */
109: 'f','n', 0, 0246, /* florin */
110: 'f','r', 0, 0244, /* fraction bar */
111: 'g','a', 0, 0301, /* circumflex accent */
112: 'g','r', 1, 0321, /* gradient */
113: 'h','y', 0, '-', /* hyphen */
114: 'i','b', 1, 0315, /* improper subset */
115: 'i','f', 1, 0245, /* infinity */
116: 'i','p', 1, 0312, /* improper superset */
117: 'i','s', 1, 0362, /* integral sign */
118: 'l','&', 1, 0331, /* logical and */
119: 'l','b', 1, 0356, /* brace, left bottom */
120: 'l','c', 1, 0351, /* square bracket l. ceiling */
121: 'l','f', 1, 0353, /* square bracket l. floor */
122: 'l','k', 1, 0355, /* brace, left middle */
123: 'l','t', 1, 0354, /* brace, left top */
124: 'l','z', 1, 0340, /* lozenge */
125: 'l','|', 1, 0332, /* logical or */
126: 'm','i', 1, '-', /* minus */
127: 'm','o', 1, 0316, /* member of */
128: 'm','u', 1, 0264, /* multiply */
129: 'n','o', 1, 0330, /* logical not */
130: 'o','a', 0, 0312, /* ring accent */
131: 'o','r', 1, '|', /* or (vertical bar) */
132: 'p','d', 1, 0266, /* partial derivative */
133: 'p','g', 0, 0266, /* paragraph */
134: 'p','l', 1, '+', /* plus */
135: 'p','p', 1, '^', /* perpendicular */
136: 'p','s', 0, 0243, /* pound sterling */
137: 'p','t', 1, 0265, /* proportional to */
138: 'r','b', 1, 0376, /* brace, right bottom */
139: 'r','c', 1, 0371, /* square bracket r. ceiling */
140: 'r','f', 1, 0373, /* square bracket r. floor */
141: 'r','g', 1, 0322, /* registered (serif) */
142: 'r','k', 1, 0375, /* brace, right middle */
143: 'r','n', 1, '\'', /* root extender (en) */
144: 'r','t', 1, 0374, /* brace, right top */
145: 's','b', 1, 0314, /* subset */
146: 's','c', 0, 0247, /* section */
147: 's','l', 1, '/', /* slash */
148: 's','p', 1, 0311, /* superset */
149: 's','r', 1, 0326, /* square root */
150: 's','t', 1, '`', /* such that */
151: 't','e', 1, '$', /* there exists */
152: 't','f', 1, '\\', /* therefore */
153: 't','m', 1, 0324, /* trademark (serif) */
154: 't','s', 1, 'V', /* terminal sigma */
155: 'u','a', 1, 0255, /* up arrow */
156: 'u','l', 1, '_', /* underscore */
157: 'v','a', 0, 0317, /* caron accent */
158: 'w','s', 1, 0303, /* Weierstrass P */
159: 'y','n', 0, 0245, /* yen */
160: '~','a', 0, 0304, /* tilde accent */
161: '~','~', 1, 0273, /* approximately */
162:
163: '\0','\0','\0','\0', /* sentinel; loop terminus */
164: };
165:
166: int troffcode(str)
167: char *str;
168: {
169: int n;
170:
171: for (n = 1; trcode[n].name[0] != '\0'; n++)
172: if (str[0] == trcode[n].name[0] && str[1] == trcode[n].name[1])
173: return n;
174: return 0;
175: }
176:
177: static
178: troffparm(name, parm, prev)
179: char *name, *parm;
180: int *prev; /* the previous value */
181: {
182: extern double atof();
183: double r, s=0, t;
184:
185: while (isspace(*parm))
186: ++parm;
187: t = getfval(name);
188: if (*parm == '\0')
189: r = *prev;
190: else {
191: r = atof(parm);
192: if (*parm == '+' || *parm == '-')
193: s = t;
194: while (*parm && !isspace(*parm))
195: parm++;
196: switch (parm[-1]) {
197: case 'i': r *= 72; break;
198: case 'c': r *= (72.*50./127.); break;
199: case 'P': r *= 12; break;
200: case 'u': r /= 6; break;
201: }
202: }
203: *prev = t;
204: setfval(name, r+s);
205: }
206:
207: /* The following should be regarded as a kludge, since these values don't
208: get set by textsize = , etc. There is confusion between picasso's ideas
209: of these variables and troff's. */
210: static int ft; /* save previous font for \fP and .ft */
211: static int psize = 10, /* ditto previous point size */
212: vsize = 12; /* and vertical spacing */
213:
214: troff(s)
215: char *s;
216: {
217: int i, fp;
218:
219: if (s[1] == 'f' && s[2] == 't') {
220: for (s += 3; isspace(*s); ++s)
221: ;
222: i = getfval("textfont"); /* save current font */
223: if (s == '\0') /* reset previous */
224: fp = ft;
225: else if (isdigit(*s)) /* allow multi-digit nums */
226: fp = checkfont((double)atoi(s));
227: else
228: fp = setfont(tostring(s));
229: ft = i;
230: setfval("textfont", fp);
231: }
232: else if (s[1] == 'p' && s[2] == 's')
233: troffparm("textsize", s+3, &psize);
234: else if (s[1] == 'v' && s[2] == 's')
235: troffparm("textspace", s+3, &vsize);
236: else if (s[1] == 'e')
237: if (s[2] == 'o')
238: esc = '\0';
239: else if (s[2] == 'c') {
240: for (s += 3; isspace(*s); ++s)
241: ;
242: esc = *s ? *s : '\\';
243: }
244: }
245:
246: obj *troffgen(s)
247: YYSTYPE s;
248: {
249: troff(s.p);
250: save_one(CENTER, 0, 0, 0, s.p);
251: free(s.p);
252: return makenode(TROFF, 0, (int)getfval("curlayer"));
253: }
254:
255: char *parse_text (txt, fp, sp) /* split txt into substrings with */
256: char *txt; /* uniform font and pointsize; */
257: int *fp, *sp; /* some '\0' chars are put in txt.*/
258: {
259: extern int parsing;
260: static char buf[256];
261: static int n = 0,
262: lim = 0;
263: int i, j;
264: char *bp;
265:
266: if (n == 0) { /* new string; initialize */
267: lim = strlen(txt);
268: ft = *fp;
269: }
270: else if (n == lim) {
271: n = 0;
272: return NULL;
273: }
274: for (bp = buf; n < lim; ) {
275: if (txt[n] != esc && txt[n] != *eqn_delim)
276: *bp++ = txt[n++];
277: else if (txt[n] == *eqn_delim) {
278: if (!parsing) {
279: do n++;
280: while (txt[n] != eqn_delim[1] && n < lim);
281: n++;
282: continue;
283: }
284: if (bp > buf) { *bp = '\0'; return buf; }
285: eqn_save(".EQ");
286: while (txt[++n] != eqn_delim[1] && n < lim)
287: *bp++ = txt[n];
288: if (n < lim)
289: ++n;
290: strcpy(bp, "\n.EN");
291: eqn_save(buf);
292: eqn_gen(TEXT);
293: bp = buf;
294: *bp++ = '\0'; /* fudge, to prevent a 2nd save_one() */
295: }
296: else { /* fonts, sizes, troff codes */
297: switch (txt[n+1]) {
298: default:
299: *bp++ = txt[n++];
300: break;
301: case '&': /* zero-width char */
302: n += 2; /* discard it */
303: break;
304: case '(':
305: if ((i = troffcode(txt+n+2)) == 0)
306: *bp++ = txt[n++]; /* unknown */
307: else {
308: if (bp > buf && *fp != trcode[i].font)
309: { *bp = '\0'; return buf; }
310: *bp++ = trcode[i].value;
311: ft = *fp;
312: *fp = trcode[i].font;
313: txt[++n] = '\\';
314: txt[n+1] = 'f';
315: txt[n+2] = 'P'; /* restore old font */
316: }
317: break;
318: case 'N':
319: n += 3;
320: *bp++ = atoi(txt+n);
321: while (isdigit(txt[n])) n++;
322: break;
323: case 'f':
324: if (bp > buf) { *bp = '\0'; return buf; }
325: n += 2;
326: i = *fp; /* save current font */
327: if (txt[n] == 'P') { /* reset previous */
328: *fp = ft;
329: ++n;
330: }
331: else if (isdigit(txt[n]))
332: *fp = checkfont((double)(txt[n++]-'0'));
333: else {
334: if (txt[n] != '(')
335: *bp++ = txt[n++];
336: else {
337: *bp++ = txt[++n];
338: *bp++ = txt[++n];
339: ++n;
340: }
341: *bp = '\0';
342: *fp = setfont(tostring(bp=buf));
343: }
344: ft = i;
345: break;
346: case 's':
347: if (bp > buf) { *bp = '\0'; return buf; }
348: n += 2;
349: if (txt[n] == '+' || txt[n] == '-') {
350: if ((i = *sp) == 0)
351: i = getfval("textsize");
352: if (txt[n] == '-')
353: i = -i;
354: ++n;
355: }
356: else
357: i = 0;
358: j = 0;
359: if (i == 0 && txt[n] == '0'){/* use previous */
360: i = psize;
361: ++n;
362: }
363: else {
364: if (isdigit(txt[n]))
365: j = txt[n++] - '0';
366: if (j && isdigit(txt[n]))
367: j = j * 10 + txt[n++] - '0';
368: }
369: psize = *sp = (i < 0 ? -(i+j) : i+j);
370: break;
371: }
372: }
373: }
374: *bp = '\0';
375: if (bp != buf)
376: return buf;
377: else {
378: n = 0;
379: return NULL;
380: }
381: }
382:
383: int eqn_count = 0;
384: char psfname[L_tmpnam] = "";
385: char dpost[] = "dpost";
386: FILE *eqnfp = NULL,
387: *pipefp = NULL;
388: int no_eqn = 0;
389:
390: eqn_save(s)
391: char *s;
392: {
393: extern char *gwblib;
394: char *dp, private[64], buf[BUFSIZ];
395:
396: if (pipefp == NULL && !no_eqn){/* open up eqn|troff|dpost subprocess */
397: if (access("/usr/bin/eqn", 1)) /* kludge! */
398: no_eqn = 1;
399: else {
400: sprintf(private, "%s/%s", gwblib, dpost);
401: dp = access(private,1) ? dpost : private;
402: tmpnam(psfname);
403: sprintf(buf, "eqn|troff -Tpost|%s -B>%s", dp, psfname);
404: if ((pipefp = popen(buf, "w")) == NULL)
405: fatal("cannot pipe through eqn");
406: }
407: }
408: if (no_eqn) {
409: if (strncmp(s, ".EQ", 3) == 0 || strncmp(s, ".EN", 3) == 0 ||
410: strncmp(s, "delim", 5) == 0)
411: ;
412: else
413: savetext(CENTER, s);
414: return;
415: }
416: if (s[0] == '.' && s[1] == 'E' && s[2] == 'Q') {
417: double f = getfval("textfont");
418: sprintf(buf,".ft %s\n.ps %d\n.vs %d\n", mount[(int)f]->name,
419: (int)getfval("textsize"), (int)getfval("textspace"));
420: fputs(buf, pipefp);
421: }
422: fputs(s, pipefp);
423: fputc('\n', pipefp);
424: scan_delim(s);
425: }
426:
427: scan_delim(s)
428: char *s;
429: {
430: while (isspace(*s))
431: ++s;
432: /* probably eqn's syntax is less restrictive than the following */
433: if (strncmp(s,"delim",5)==0) {
434: for (s += 5; isspace(*s); ++s)
435: ;
436: if (strcmp(s,"off")==0)
437: eqn_delim[1] = eqn_delim[0] = '\0';
438: else {
439: eqn_delim[1] = eqn_delim[0] = *s;
440: if (*s++)
441: if (*s)
442: eqn_delim[1] = *s;
443: }
444: }
445: }
446:
447: eqn_gen(type)
448: int type;
449: {
450: extern int ntextlines;
451: obj *p;
452: char buf[8];
453:
454: if (!no_eqn) {
455: fputs(".bp\n", pipefp);
456: sprintf(buf, "%d", ++eqn_count);
457: save_one(EQNTXT, 0, 0, ntextlines, buf);
458: }
459: if (type == TROFF) {
460: p = makenode(TROFF, 0, (int)getfval("curlayer"));
461: checktextcolor(p);
462: codegen = 1;
463: }
464: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.