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