![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to n7.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / troff|
Return to n7.c CVS log | Up to [Research Unix] / researchv10no / cmd / troff |
1.1 root 1: #include "tdef.h"
2: #include "fns.h"
3: #include "ext.h"
4:
5: #define GETCH gettch
6: Tchar gettch(void);
7:
8:
9: /*
10: * troff7.c
11: *
12: * text
13: */
14:
15: int brflg;
16:
17: void tbreak(void)
18: {
19: int pad, k;
20: Tchar *i, j;
21: int resol;
22: int un0 = un;
23:
24: trap = 0;
25: if (nb)
26: return;
27: if (dip == d && numtab[NL].val == -1) {
28: newline(1);
29: return;
30: }
31: if (!nc) {
32: setnel();
33: if (!wch)
34: return;
35: if (pendw)
36: getword(1);
37: movword();
38: } else if (pendw && !brflg) {
39: getword(1);
40: movword();
41: }
42: *linep = dip->nls = 0;
43: if (NROFF && dip == d)
44: horiz(po);
45: if (lnmod)
46: donum();
47: lastl = ne;
48: if (brflg != 1) {
49: totout = 0;
50: } else if (ad) {
51: if ((lastl = ll - un) < ne)
52: lastl = ne;
53: }
54: if (admod && ad && (brflg != 2)) {
55: lastl = ne;
56: adsp = adrem = 0;
57: if (admod == 1)
58: un += quant(nel / 2, HOR);
59: else if (admod == 2)
60: un += nel;
61: }
62: totout++;
63: brflg = 0;
64: if (lastl + un > dip->maxl)
65: dip->maxl = lastl + un;
66: horiz(un);
67: if (NROFF) {
68: if (adrem % t.Adj)
69: resol = t.Hor;
70: else
71: resol = t.Adj;
72: } else
73: resol = HOR;
74:
75: lastl = ne + (nwd-1) * adsp + adrem;
76: for (i = line; nc > 0; ) {
77: if ((cbits(j = *i++)) == ' ') {
78: pad = 0;
79: do {
80: pad += width(j);
81: nc--;
82: } while ((cbits(j = *i++)) == ' ');
83: i--;
84: pad += adsp;
85: --nwd;
86: if (adrem) {
87: if (adrem < 0) {
88: pad -= resol;
89: adrem += resol;
90: } else if ((totout & 01) || adrem / resol >= nwd) {
91: pad += resol;
92: adrem -= resol;
93: }
94: }
95: pchar((Tchar) WORDSP);
96: horiz(pad);
97: } else {
98: pchar(j);
99: nc--;
100: }
101: }
102: if (ic) {
103: if ((k = ll - un0 - lastl + ics) > 0)
104: horiz(k);
105: pchar(ic);
106: }
107: if (icf)
108: icf++;
109: else
110: ic = 0;
111: ne = nwd = 0;
112: un = in;
113: setnel();
114: newline(0);
115: if (dip != d) {
116: if (dip->dnl > dip->hnl)
117: dip->hnl = dip->dnl;
118: } else {
119: if (numtab[NL].val > dip->hnl)
120: dip->hnl = numtab[NL].val;
121: }
122: for (k = ls - 1; k > 0 && !trap; k--)
123: newline(0);
124: spread = 0;
125: }
126:
127: void donum(void)
128: {
129: int i, nw;
130: int lnv = numtab[LN].val;
131:
132: nrbits = nmbits;
133: nw = width('1' | nrbits);
134: if (nn) {
135: nn--;
136: goto d1;
137: }
138: if (lnv % ndf) {
139: numtab[LN].val++;
140: d1:
141: un += nw * (nmwid + nms + ni);
142: return;
143: }
144: i = 0;
145: do { /* count digits in numtab[LN].val */
146: i++;
147: } while ((lnv /= 10) > 0);
148: horiz(nw * (ni + max(nmwid-i, 0)));
149: nform = 0;
150: fnumb(numtab[LN].val, pchar);
151: un += nw * nms;
152: numtab[LN].val++;
153: }
154:
155:
156: void text(void)
157: {
158: Tchar i;
159: static int spcnt;
160:
161: nflush++;
162: numtab[HP].val = 0;
163: if ((dip == d) && (numtab[NL].val == -1)) {
164: newline(1);
165: return;
166: }
167: setnel();
168: if (ce || !fi) {
169: nofill();
170: return;
171: }
172: if (pendw)
173: goto t4;
174: if (pendt)
175: if (spcnt)
176: goto t2;
177: else
178: goto t3;
179: pendt++;
180: if (spcnt)
181: goto t2;
182: while ((cbits(i = GETCH())) == ' ') {
183: spcnt++;
184: numtab[HP].val += sps;
185: widthp = sps;
186: }
187: if (nlflg) {
188: t1:
189: nflush = pendt = ch = spcnt = 0;
190: callsp();
191: return;
192: }
193: ch = i;
194: if (spcnt) {
195: t2:
196: tbreak();
197: if (nc || wch)
198: goto rtn;
199: un += spcnt * sps;
200: spcnt = 0;
201: setnel();
202: if (trap)
203: goto rtn;
204: if (nlflg)
205: goto t1;
206: }
207: t3:
208: if (spread)
209: goto t5;
210: if (pendw || !wch)
211: t4:
212: if (getword(0))
213: goto t6;
214: if (!movword())
215: goto t3;
216: t5:
217: if (nlflg)
218: pendt = 0;
219: adsp = adrem = 0;
220: if (ad) {
221: if (nwd == 1)
222: adsp = nel;
223: else
224: adsp = nel / (nwd - 1);
225: adsp = (adsp / HOR) * HOR;
226: adrem = nel - adsp*(nwd-1);
227: }
228: brflg = 1;
229: tbreak();
230: spread = 0;
231: if (!trap)
232: goto t3;
233: if (!nlflg)
234: goto rtn;
235: t6:
236: pendt = 0;
237: ckul();
238: rtn:
239: nflush = 0;
240: }
241:
242:
243: void nofill(void)
244: {
245: int j;
246: Tchar i;
247:
248: if (!pendnf) {
249: over = 0;
250: tbreak();
251: if (trap)
252: goto rtn;
253: if (nlflg) {
254: ch = nflush = 0;
255: callsp();
256: return;
257: }
258: adsp = adrem = 0;
259: nwd = 10000;
260: }
261: while ((j = (cbits(i = GETCH()))) != '\n') {
262: if (j == ohc)
263: continue;
264: if (j == CONT) {
265: pendnf++;
266: nflush = 0;
267: flushi();
268: ckul();
269: return;
270: }
271: j = width(i);
272: widthp = j;
273: numtab[HP].val += j;
274: storeline(i, j);
275: }
276: if (ce) {
277: ce--;
278: if ((i = quant(nel / 2, HOR)) > 0)
279: un += i;
280: }
281: if (!nc)
282: storeline((Tchar)FILLER, 0);
283: brflg = 2;
284: tbreak();
285: ckul();
286: rtn:
287: pendnf = nflush = 0;
288: }
289:
290:
291: void callsp(void)
292: {
293: int i;
294:
295: if (flss)
296: i = flss;
297: else
298: i = lss;
299: flss = 0;
300: casesp1(i);
301: }
302:
303:
304: void ckul(void)
305: {
306: if (ul && (--ul == 0)) {
307: cu = 0;
308: font = sfont;
309: mchbits();
310: }
311: if (it && --it == 0 && itmac)
312: control(itmac, 0);
313: }
314:
315:
316: void storeline(Tchar c, int w)
317: {
318: if (linep >= line + lnsize - 2) {
319: if (!over) {
320: flusho();
321: ERROR "Line overflow." WARN;
322: over++;
323: c = LEFTHAND;
324: w = -1;
325: *linep++ = c;
326: *linep++ = '\n'; nc++; /* other one comes later */
327: goto s1;
328: }
329: return;
330: }
331: *linep++ = c;
332: s1:
333: if (w == -1)
334: w = width(c);
335: ne += w;
336: nel -= w;
337: nc++;
338: }
339:
340:
341: void newline(int a)
342: {
343: int i, j, nlss;
344: int opn;
345:
346: if (a)
347: goto nl1;
348: if (dip != d) {
349: j = lss;
350: pchar1((Tchar)FLSS);
351: if (flss)
352: lss = flss;
353: i = lss + dip->blss;
354: dip->dnl += i;
355: pchar1((Tchar)i);
356: pchar1((Tchar)'\n');
357: lss = j;
358: dip->blss = flss = 0;
359: if (dip->alss) {
360: pchar1((Tchar)FLSS);
361: pchar1((Tchar)dip->alss);
362: pchar1((Tchar)'\n');
363: dip->dnl += dip->alss;
364: dip->alss = 0;
365: }
366: if (dip->ditrap && !dip->ditf && dip->dnl >= dip->ditrap && dip->dimac)
367: if (control(dip->dimac, 0)) {
368: trap++;
369: dip->ditf++;
370: }
371: return;
372: }
373: j = lss;
374: if (flss)
375: lss = flss;
376: nlss = dip->alss + dip->blss + lss;
377: numtab[NL].val += nlss;
378: if (TROFF && ascii) {
379: dip->alss = dip->blss = 0;
380: }
381: pchar1((Tchar)'\n');
382: flss = 0;
383: lss = j;
384: if (numtab[NL].val < pl)
385: goto nl2;
386: nl1:
387: ejf = dip->hnl = numtab[NL].val = 0;
388: ejl = frame;
389: if (donef) {
390: if ((!nc && !wch) || ndone)
391: done1(0);
392: ndone++;
393: donef = 0;
394: if (frame == stk)
395: nflush++;
396: }
397: opn = numtab[PN].val;
398: numtab[PN].val++;
399: if (npnflg) {
400: numtab[PN].val = npn;
401: npn = npnflg = 0;
402: }
403: nlpn:
404: if (numtab[PN].val == pfrom) {
405: print++;
406: pfrom = -1;
407: } else if (opn == pto) {
408: print = 0;
409: opn = -1;
410: chkpn();
411: goto nlpn;
412: }
413: if (print)
414: ptpage(numtab[PN].val); /* supposedly in a clean state so can pause */
415: if (stop && print) {
416: dpn++;
417: if (dpn >= stop) {
418: dpn = 0;
419: ptpause();
420: }
421: }
422: nl2:
423: trap = 0;
424: if (numtab[NL].val == 0) {
425: if ((j = findn(0)) != NTRAP)
426: trap = control(mlist[j], 0);
427: } else if ((i = findt(numtab[NL].val - nlss)) <= nlss) {
428: if ((j = findn1(numtab[NL].val - nlss + i)) == NTRAP) {
429: flusho();
430: ERROR "Trap botch." WARN;
431: done2(-5);
432: }
433: trap = control(mlist[j], 0);
434: }
435: }
436:
437:
438: findn1(int a)
439: {
440: int i, j;
441:
442: for (i = 0; i < NTRAP; i++) {
443: if (mlist[i]) {
444: if ((j = nlist[i]) < 0)
445: j += pl;
446: if (j == a)
447: break;
448: }
449: }
450: return(i);
451: }
452:
453:
454: void chkpn(void)
455: {
456: pto = *(pnp++);
457: pfrom = pto>=0 ? pto : -pto;
458: if (pto == -INT_MAX) {
459: flusho();
460: done1(0);
461: }
462: if (pto < 0) {
463: pto = -pto;
464: print++;
465: pfrom = 0;
466: }
467: }
468:
469:
470: findt(int a)
471: {
472: int i, j, k;
473:
474: k = INT_MAX;
475: if (dip != d) {
476: if (dip->dimac && (i = dip->ditrap - a) > 0)
477: k = i;
478: return(k);
479: }
480: for (i = 0; i < NTRAP; i++) {
481: if (mlist[i]) {
482: if ((j = nlist[i]) < 0)
483: j += pl;
484: if ((j -= a) <= 0)
485: continue;
486: if (j < k)
487: k = j;
488: }
489: }
490: i = pl - a;
491: if (k > i)
492: k = i;
493: return(k);
494: }
495:
496:
497: findt1(void)
498: {
499: int i;
500:
501: if (dip != d)
502: i = dip->dnl;
503: else
504: i = numtab[NL].val;
505: return(findt(i));
506: }
507:
508:
509: void eject(Stack *a)
510: {
511: int savlss;
512:
513: if (dip != d)
514: return;
515: ejf++;
516: if (a)
517: ejl = a;
518: else
519: ejl = frame;
520: if (trap)
521: return;
522: e1:
523: savlss = lss;
524: lss = findt(numtab[NL].val);
525: newline(0);
526: lss = savlss;
527: if (numtab[NL].val && !trap)
528: goto e1;
529: }
530:
531:
532: movword(void)
533: {
534: int w;
535: Tchar i, *wp;
536: int savwch, hys;
537:
538: over = 0;
539: wp = wordp;
540: if (!nwd) {
541: while (cbits(*wp++) == ' ') {
542: wch--;
543: wne -= sps;
544: }
545: wp--;
546: }
547: if (wne > nel && !hyoff && hyf && (!nwd || nel > 3 * sps) &&
548: (!(hyf & 02) || (findt1() > lss)))
549: hyphen(wp);
550: savwch = wch;
551: hyp = hyptr;
552: nhyp = 0;
553: while (*hyp && *hyp <= wp)
554: hyp++;
555: while (wch) {
556: if (hyoff != 1 && *hyp == wp) {
557: hyp++;
558: if (!wdstart || (wp > wdstart + 1 && wp < wdend &&
559: (!(hyf & 04) || wp < wdend - 1) && /* 04 => last 2 */
560: (!(hyf & 010) || wp > wdstart + 2))) { /* 010 => 1st 2 */
561: nhyp++;
562: storeline((Tchar)IMP, 0);
563: }
564: }
565: i = *wp++;
566: w = width(i);
567: wne -= w;
568: wch--;
569: storeline(i, w);
570: }
571: if (nel >= 0) {
572: nwd++;
573: return(0); /* line didn't fill up */
574: }
575: if (TROFF)
576: xbits((Tchar)HYPHEN, 1);
577: hys = width((Tchar)HYPHEN);
578: m1:
579: if (!nhyp) {
580: if (!nwd)
581: goto m3;
582: if (wch == savwch)
583: goto m4;
584: }
585: if (*--linep != IMP)
586: goto m5;
587: if (!(--nhyp))
588: if (!nwd)
589: goto m2;
590: if (nel < hys) {
591: nc--;
592: goto m1;
593: }
594: m2:
595: if ((i = cbits(*(linep - 1))) != '-' && i != EMDASH) {
596: *linep = (*(linep - 1) & SFMASK) | HYPHEN;
597: w = width(*linep);
598: nel -= w;
599: ne += w;
600: linep++;
601: }
602: m3:
603: nwd++;
604: m4:
605: wordp = wp;
606: return(1); /* line filled up */
607: m5:
608: nc--;
609: w = width(*linep);
610: ne -= w;
611: nel += w;
612: wne += w;
613: wch++;
614: wp--;
615: goto m1;
616: }
617:
618:
619: void horiz(int i)
620: {
621: vflag = 0;
622: if (i)
623: pchar(makem(i));
624: }
625:
626:
627: void setnel(void)
628: {
629: if (!nc) {
630: linep = line;
631: if (un1 >= 0) {
632: un = un1;
633: un1 = -1;
634: }
635: nel = ll - un;
636: ne = adsp = adrem = 0;
637: }
638: }
639:
640:
641: getword(int x)
642: {
643: int j, k;
644: Tchar i, *wp;
645: int noword;
646: int obits;
647:
648: noword = 0;
649: if (x)
650: if (pendw) {
651: *pendw = 0;
652: goto rtn;
653: }
654: if (wordp = pendw)
655: goto g1;
656: hyp = hyptr;
657: wordp = word;
658: over = wne = wch = 0;
659: hyoff = 0;
660: obits = chbits;
661: while (1) { /* picks up 1st char of word */
662: j = cbits(i = GETCH());
663: if (j == '\n') {
664: wne = wch = 0;
665: noword = 1;
666: goto rtn;
667: }
668: if (j == ohc) {
669: hyoff = 1; /* 1 => don't hyphenate */
670: continue;
671: }
672: if (j == ' ') {
673: numtab[HP].val += sps;
674: widthp = sps;
675: storeword(i, sps);
676: continue;
677: }
678: break;
679: }
680: storeword(' ' | obits, sps);
681: if (spflg) {
682: storeword(' ' | obits, sps);
683: spflg = 0;
684: }
685: g0:
686: if (j == CONT) {
687: pendw = wordp;
688: nflush = 0;
689: flushi();
690: return(1);
691: }
692: if (hyoff != 1) {
693: if (j == ohc) {
694: hyoff = 2;
695: *hyp++ = wordp;
696: if (hyp > hyptr + NHYP - 1)
697: hyp = hyptr + NHYP - 1;
698: goto g1;
699: }
700: if (((j == '-' || j == EMDASH)) && !(i & ZBIT)) /* zbit avoids \X */
701: if (wordp > word + 1) {
702: hyoff = 2;
703: *hyp++ = wordp + 1;
704: if (hyp > hyptr + NHYP - 1)
705: hyp = hyptr + NHYP - 1;
706: }
707: }
708: j = width(i);
709: numtab[HP].val += j;
710: storeword(i, j);
711: g1:
712: j = cbits(i = GETCH());
713: if (j != ' ') {
714: static char *sentchar = ".?!"; /* sentence terminators */
715: if (j != '\n')
716: goto g0;
717: wp = wordp-1; /* handle extra space at end of sentence */
718: while (wp >= word) {
719: j = cbits(*wp--);
720: if (j=='"' || j=='\'' || j==')' || j==']' || j=='*' || j==DAGGER)
721: continue;
722: for (k = 0; sentchar[k]; k++)
723: if (j == sentchar[k]) {
724: spflg++;
725: break;
726: }
727: break;
728: }
729: }
730: *wordp = 0;
731: numtab[HP].val += sps;
732: rtn:
733: for (wp = word; *wp; wp++) {
734: if (ismot(j))
735: break; /* drechsler */
736: j = cbits(*wp);
737: if (j == ' ')
738: continue;
739: if (!isdigit(j) && j != '-')
740: break;
741: }
742: if (*wp == 0) /* all numbers, so don't hyphenate */
743: hyoff = 1;
744: wdstart = 0;
745: wordp = word;
746: pendw = 0;
747: *hyp++ = 0;
748: setnel();
749: return(noword);
750: }
751:
752:
753: void storeword(Tchar c, int w)
754: {
755: if (wordp >= &word[WDSIZE - 3]) {
756: if (!over) {
757: flusho();
758: ERROR "Word overflow." WARN;
759: over++;
760: c = LEFTHAND;
761: w = -1;
762: goto s1;
763: }
764: return;
765: }
766: s1:
767: if (w == -1)
768: w = width(c);
769: widthp = w;
770: wne += w;
771: *wordp++ = c;
772: wch++;
773: }
774:
775:
776: Tchar gettch(void)
777: {
778: extern int c_isalnum;
779: Tchar i;
780: int j;
781:
782: if (TROFF)
783: return getch();
784:
785: i = getch();
786: j = cbits(i);
787: if (ismot(i) || fbits(i) != ulfont)
788: return(i);
789: if (cu) {
790: if (trtab[j] == ' ') {
791: setcbits(i, '_');
792: setfbits(i, FT); /* default */
793: }
794: return(i);
795: }
796: /* should test here for characters that ought to be underlined */
797: /* in the old nroff, that was the 200 bit on the width! */
798: /* for now, just do letters, digits and certain special chars */
799: if (j <= 127) {
800: if (!isalnum(j))
801: setfbits(i, FT);
802: } else {
803: if (j < c_isalnum)
804: setfbits(i, FT);
805: }
806: return(i);
807: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.