![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to n9.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / cmd / troff|
Return to n9.c CVS log | Up to [Research Unix] / researchv9 / cmd / troff |
1.1 root 1: #include "tdef.h"
2: #ifdef NROFF
3: #include "tw.h"
4: #endif
5: #include "ext.h"
6:
7: /*
8: * troff9.c
9: *
10: * misc functions
11: */
12:
13: tchar setz()
14: {
15: tchar i;
16:
17: if (!ismot(i = getch()))
18: i |= ZBIT;
19: return(i);
20: }
21:
22: setline()
23: {
24: register tchar *i;
25: tchar c;
26: int length;
27: int w, cnt, delim, rem, temp;
28: tchar linebuf[NC];
29:
30: if (ismot(c = getch()))
31: return;
32: delim = cbits(c);
33: vflag = 0;
34: dfact = EM;
35: length = quant(atoi(), HOR);
36: dfact = 1;
37: if (!length) {
38: eat(delim);
39: return;
40: }
41: s0:
42: if ((cbits(c = getch())) == delim) {
43: ch = c;
44: c = RULE | chbits;
45: } else if (cbits(c) == FILLER)
46: goto s0;
47: w = width(c);
48: i = linebuf;
49: if (length < 0) {
50: *i++ = makem(length);
51: length = -length;
52: }
53: if (!(cnt = length / w)) {
54: *i++ = makem(-(temp = ((w - length) / 2)));
55: *i++ = c;
56: *i++ = makem(-(w - length - temp));
57: goto s1;
58: }
59: if (rem = length % w) {
60: if (cbits(c) == RULE || cbits(c) == UNDERLINE || cbits(c) == ROOTEN)
61: *i++ = c | ZBIT;
62: *i++ = makem(rem);
63: }
64: if (cnt) {
65: *i++ = RPT;
66: *i++ = cnt;
67: *i++ = c;
68: }
69: s1:
70: *i++ = 0;
71: eat(delim);
72: pushback(linebuf);
73: }
74:
75:
76: eat(c)
77: register int c;
78: {
79: register i;
80:
81: while ((i = cbits(getch())) != c && i != '\n')
82: ;
83: return(i);
84: }
85:
86:
87: setov()
88: {
89: register j, k;
90: tchar i, o[NOV+1];
91: int delim, w[NOV+1];
92:
93: if (ismot(i = getch()))
94: return;
95: delim = cbits(i);
96: for (k = 0; k < NOV && (j = cbits(i = getch())) != delim && j != '\n'; k++) {
97: o[k] = i;
98: w[k] = width(i);
99: }
100: o[k] = w[k] = 0;
101: if (o[0])
102: for (j = 1; j; ) {
103: j = 0;
104: for (k = 1; o[k] ; k++) {
105: if (w[k-1] < w[k]) {
106: j++;
107: i = w[k];
108: w[k] = w[k-1];
109: w[k-1] = i;
110: i = o[k];
111: o[k] = o[k-1];
112: o[k-1] = i;
113: }
114: }
115: }
116: else
117: return;
118: *pbp++ = makem(w[0] / 2);
119: for (k = 0; o[k]; k++)
120: ;
121: while (k>0) {
122: k--;
123: *pbp++ = makem(-((w[k] + w[k+1]) / 2));
124: *pbp++ = o[k];
125: }
126: }
127:
128:
129: setbra()
130: {
131: register k;
132: tchar i, *j, dwn;
133: int cnt, delim;
134: tchar brabuf[NC];
135:
136: if (ismot(i = getch()))
137: return;
138: delim = cbits(i);
139: j = brabuf + 1;
140: cnt = 0;
141: #ifdef NROFF
142: dwn = (2 * t.Halfline) | MOT | VMOT;
143: #endif
144: #ifndef NROFF
145: dwn = EM | MOT | VMOT;
146: #endif
147: while ((k = cbits(i = getch())) != delim && k != '\n' && j <= brabuf + NC - 4) {
148: *j++ = i | ZBIT;
149: *j++ = dwn;
150: cnt++;
151: }
152: if (--cnt < 0)
153: return;
154: else if (!cnt) {
155: ch = *(j - 2);
156: return;
157: }
158: *j = 0;
159: #ifdef NROFF
160: *--j = *brabuf = (cnt * t.Halfline) | MOT | NMOT | VMOT;
161: #endif
162: #ifndef NROFF
163: *--j = *brabuf = (cnt * EM) / 2 | MOT | NMOT | VMOT;
164: #endif
165: *--j &= ~ZBIT;
166: pushback(brabuf);
167: }
168:
169:
170: setvline()
171: {
172: register i;
173: tchar c, rem, ver, neg;
174: int cnt, delim, v;
175: tchar vlbuf[NC];
176: register tchar *vlp;
177:
178: if (ismot(c = getch()))
179: return;
180: delim = cbits(c);
181: dfact = lss;
182: vflag++;
183: i = quant(atoi(), VERT);
184: dfact = 1;
185: if (!i) {
186: eat(delim);
187: vflag = 0;
188: return;
189: }
190: if ((cbits(c = getch())) == delim) {
191: c = BOXRULE | chbits; /*default box rule*/
192: } else
193: getch();
194: c |= ZBIT;
195: neg = 0;
196: if (i < 0) {
197: i = -i;
198: neg = NMOT;
199: }
200: #ifdef NROFF
201: v = 2 * t.Halfline;
202: #endif
203: #ifndef NROFF
204: v = EM;
205: #endif
206: cnt = i / v;
207: rem = makem(i % v) | neg;
208: ver = makem(v) | neg;
209: vlp = vlbuf;
210: if (!neg)
211: *vlp++ = ver;
212: if (absmot(rem) != 0) {
213: *vlp++ = c;
214: *vlp++ = rem;
215: }
216: while (vlp < vlbuf + NC - 3 && cnt--) {
217: *vlp++ = c;
218: *vlp++ = ver;
219: }
220: *(vlp - 2) &= ~ZBIT;
221: if (!neg)
222: vlp--;
223: *vlp++ = 0;
224: pushback(vlbuf);
225: vflag = 0;
226: }
227:
228: #define NPAIR (NC/2-6) /* max pairs in spline, etc. */
229:
230: setdraw() /* generate internal cookies for a drawing function */
231: {
232: int i, j, k, dx[NPAIR], dy[NPAIR], delim, type;
233: tchar c, drawbuf[NC];
234:
235: /* input is \D'f dx dy dx dy ... c' (or at least it had better be) */
236: /* this does drawing function f with character c and the */
237: /* specified dx,dy pairs interpreted as appropriate */
238: /* pairs are deltas from last point, except for radii */
239:
240: /* l dx dy: line from here by dx,dy */
241: /* c x: circle of diameter x, left side here */
242: /* e x y: ellipse of diameters x,y, left side here */
243: /* a dx1 dy1 dx2 dy2:
244: ccw arc: ctr at dx1,dy1, then end at dx2,dy2 from there */
245: /* ~ dx1 dy1 dx2 dy2...:
246: spline to dx1,dy1 to dx2,dy2 ... */
247: /* f dx dy ...: f is any other char: like spline */
248:
249: if (ismot(c = getch()))
250: return;
251: delim = cbits(c);
252: type = cbits(getch());
253: for (i = 0; i < NPAIR ; i++) {
254: c = getch();
255: if (cbits(c) == delim)
256: break;
257: /* ought to pick up optional drawing character */
258: if (cbits(c) != ' ')
259: ch = c;
260: vflag = 0;
261: dfact = EM;
262: dx[i] = quant(atoi(), HOR);
263: if (dx[i] > MAXMOT)
264: dx[i] = MAXMOT;
265: else if (dx[i] < -MAXMOT)
266: dx[i] = -MAXMOT;
267: if (cbits((c = getch())) == delim) { /* spacer */
268: dy[i++] = 0;
269: break;
270: }
271: vflag = 1;
272: dfact = lss;
273: dy[i] = quant(atoi(), VERT);
274: if (dy[i] > MAXMOT)
275: dy[i] = MAXMOT;
276: else if (dy[i] < -MAXMOT)
277: dy[i] = -MAXMOT;
278: }
279: dfact = 1;
280: vflag = 0;
281: #ifndef NROFF
282: drawbuf[0] = DRAWFCN | chbits | ZBIT;
283: drawbuf[1] = type | chbits | ZBIT;
284: drawbuf[2] = '.' | chbits | ZBIT; /* use default drawing character */
285: for (k = 0, j = 3; k < i; k++) {
286: drawbuf[j++] = MOT | ((dx[k] >= 0) ? dx[k] : (NMOT | -dx[k]));
287: drawbuf[j++] = MOT | VMOT | ((dy[k] >= 0) ? dy[k] : (NMOT | -dy[k]));
288: }
289: if (type == DRAWELLIPSE) {
290: drawbuf[5] = drawbuf[4] | NMOT; /* so the net vertical is zero */
291: j = 6;
292: }
293: drawbuf[j++] = DRAWFCN | chbits | ZBIT; /* marks end for ptout */
294: drawbuf[j] = 0;
295: pushback(drawbuf);
296: #endif
297: }
298:
299:
300: casefc()
301: {
302: register i;
303: tchar j;
304:
305: gchtab[fc] &= ~FCBIT;
306: fc = IMP;
307: padc = ' ';
308: if (skip() || ismot(j = getch()) || (i = cbits(j)) == '\n')
309: return;
310: fc = i;
311: gchtab[fc] |= FCBIT;
312: if (skip() || ismot(ch) || (ch = cbits(ch)) == fc)
313: return;
314: padc = ch;
315: }
316:
317:
318: tchar
319: setfield(x)
320: int x;
321: {
322: register tchar ii, jj, *fp;
323: register i, j;
324: int length, ws, npad, temp, type;
325: tchar **pp, *padptr[NPP];
326: tchar fbuf[FBUFSZ];
327: int savfc, savtc, savlc;
328: tchar rchar;
329: int savepos;
330:
331: if (x == tabch)
332: rchar = tabc | chbits;
333: else if (x == ldrch)
334: rchar = dotc | chbits;
335: temp = npad = ws = 0;
336: savfc = fc;
337: savtc = tabch;
338: savlc = ldrch;
339: tabch = ldrch = fc = IMP;
340: savepos = numtab[HP].val;
341: gchtab[tabch] &= ~TABBIT;
342: gchtab[ldrch] &= ~LDRBIT;
343: gchtab[fc] &= ~FCBIT;
344: gchtab[IMP] |= TABBIT|LDRBIT|FCBIT;
345: for (j = 0; ; j++) {
346: if ((tabtab[j] & TABMASK) == 0) {
347: if (x == savfc)
348: errprint("zero field width.");
349: jj = 0;
350: goto rtn;
351: }
352: if ((length = ((tabtab[j] & TABMASK) - numtab[HP].val)) > 0 )
353: break;
354: }
355: type = tabtab[j] & ~TABMASK;
356: fp = fbuf;
357: pp = padptr;
358: if (x == savfc) {
359: while (1) {
360: j = cbits(ii = getch());
361: jj = width(ii);
362: widthp = jj;
363: numtab[HP].val += jj;
364: if (j == padc) {
365: npad++;
366: *pp++ = fp;
367: if (pp > padptr + NPP - 1)
368: break;
369: goto s1;
370: } else if (j == savfc)
371: break;
372: else if (j == '\n') {
373: temp = j;
374: nlflg = 0;
375: break;
376: }
377: ws += jj;
378: s1:
379: *fp++ = ii;
380: if (fp > fbuf + FBUFSZ - 3)
381: break;
382: }
383: if (!npad) {
384: npad++;
385: *pp++ = fp;
386: *fp++ = 0;
387: }
388: *fp++ = temp;
389: *fp++ = 0;
390: temp = i = (j = length - ws) / npad;
391: i = (i / HOR) * HOR;
392: if ((j -= i * npad) < 0)
393: j = -j;
394: ii = makem(i);
395: if (temp < 0)
396: ii |= NMOT;
397: for (; npad > 0; npad--) {
398: *(*--pp) = ii;
399: if (j) {
400: j -= HOR;
401: (*(*pp)) += HOR;
402: }
403: }
404: pushback(fbuf);
405: jj = 0;
406: } else if (type == 0) {
407: /*plain tab or leader*/
408: if ((j = width(rchar)) > 0) {
409: int nchar = length / j;
410: while (nchar-->0 && pbp < &pbbuf[NC-3]) {
411: numtab[HP].val += j;
412: widthp = j;
413: *pbp++ = rchar;
414: }
415: length %= j;
416: }
417: if (length)
418: jj = length | MOT;
419: else
420: jj = getch0();
421: } else {
422: /*center tab*/
423: /*right tab*/
424: while ((j = cbits(ii = getch())) != savtc && j != '\n' && j != savlc) {
425: jj = width(ii);
426: ws += jj;
427: numtab[HP].val += jj;
428: widthp = jj;
429: *fp++ = ii;
430: if (fp > fbuf + FBUFSZ - 3)
431: break;
432: }
433: *fp++ = ii;
434: *fp++ = 0;
435: if (type == RTAB)
436: length -= ws;
437: else
438: length -= ws / 2; /*CTAB*/
439: pushback(fbuf);
440: if ((j = width(rchar)) != 0 && length > 0) {
441: int nchar = length / j;
442: while (nchar-- > 0 && pbp < &pbbuf[NC-3])
443: *pbp++ = rchar;
444: length %= j;
445: }
446: length = (length / HOR) * HOR;
447: jj = makem(length);
448: nlflg = 0;
449: }
450: rtn:
451: gchtab[fc] &= ~FCBIT;
452: gchtab[tabch] &= ~TABBIT;
453: gchtab[ldrch] &= ~LDRBIT;
454: fc = savfc;
455: tabch = savtc;
456: ldrch = savlc;
457: gchtab[fc] |= FCBIT;
458: gchtab[tabch] = TABBIT;
459: gchtab[ldrch] |= LDRBIT;
460: numtab[HP].val = savepos;
461: return(jj);
462: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.