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