![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to n5.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 n5.c CVS log | Up to [Research Unix] / researchv8dc / cmd / troff |
1.1 root 1: #include "tdef.h"
2: #include <sgtty.h>
3: #include "ext.h"
4:
5: /*
6: * troff5.c
7: *
8: * misc processing requests
9: */
10:
11: int iflist[NIF];
12: int ifx;
13:
14: casead()
15: {
16: register i;
17:
18: ad = 1;
19: /*leave admod alone*/
20: if (skip())
21: return;
22: switch (i = cbits(getch())) {
23: case 'r': /*right adj, left ragged*/
24: admod = 2;
25: break;
26: case 'l': /*left adj, right ragged*/
27: admod = ad = 0; /*same as casena*/
28: break;
29: case 'c': /*centered adj*/
30: admod = 1;
31: break;
32: case 'b':
33: case 'n':
34: admod = 0;
35: break;
36: case '0':
37: case '2':
38: case '4':
39: ad = 0;
40: case '1':
41: case '3':
42: case '5':
43: admod = (i - '0') / 2;
44: }
45: }
46:
47:
48: casena()
49: {
50: ad = 0;
51: }
52:
53:
54: casefi()
55: {
56: tbreak();
57: fi++;
58: pendnf = 0;
59: lnsize = LNSIZE;
60: }
61:
62:
63: casenf()
64: {
65: tbreak();
66: fi = 0;
67: }
68:
69:
70: casers()
71: {
72: dip->nls = 0;
73: }
74:
75:
76: casens()
77: {
78: dip->nls++;
79: }
80:
81:
82: chget(c)
83: int c;
84: {
85: tchar i;
86:
87: if (skip() || ismot(i = getch()) || cbits(i) == ' ' || cbits(i) == '\n') {
88: ch = i;
89: return(c);
90: } else
91: return(i & BYTEMASK);
92: }
93:
94:
95: casecc()
96: {
97: cc = chget('.');
98: }
99:
100:
101: casec2()
102: {
103: c2 = chget('\'');
104: }
105:
106:
107: casehc()
108: {
109: ohc = chget(OHC);
110: }
111:
112:
113: casetc()
114: {
115: tabc = chget(0);
116: }
117:
118:
119: caselc()
120: {
121: dotc = chget(0);
122: }
123:
124:
125: casehy()
126: {
127: register i;
128:
129: hyf = 1;
130: if (skip())
131: return;
132: noscale++;
133: i = atoi();
134: noscale = 0;
135: if (nonumb)
136: return;
137: hyf = max(i, 0);
138: }
139:
140:
141: casenh()
142: {
143: hyf = 0;
144: }
145:
146:
147: max(aa, bb)
148: int aa, bb;
149: {
150: if (aa > bb)
151: return(aa);
152: else
153: return(bb);
154: }
155:
156:
157: casece()
158: {
159: register i;
160:
161: noscale++;
162: skip();
163: i = max(atoi(), 0);
164: if (nonumb)
165: i = 1;
166: tbreak();
167: ce = i;
168: noscale = 0;
169: }
170:
171:
172: casein()
173: {
174: register i;
175:
176: if (skip())
177: i = in1;
178: else
179: i = max(hnumb(&in), 0);
180: tbreak();
181: in1 = in;
182: in = i;
183: if (!nc) {
184: un = in;
185: setnel();
186: }
187: }
188:
189:
190: casell()
191: {
192: register i;
193:
194: if (skip())
195: i = ll1;
196: else
197: i = max(hnumb(&ll), INCH / 10);
198: ll1 = ll;
199: ll = i;
200: setnel();
201: }
202:
203:
204: caselt()
205: {
206: register i;
207:
208: if (skip())
209: i = lt1;
210: else
211: i = max(hnumb(<), 0);
212: lt1 = lt;
213: lt = i;
214: }
215:
216:
217: caseti()
218: {
219: register i;
220:
221: if (skip())
222: return;
223: i = max(hnumb(&in), 0);
224: tbreak();
225: un1 = i;
226: setnel();
227: }
228:
229:
230: casels()
231: {
232: register i;
233:
234: noscale++;
235: if (skip())
236: i = ls1;
237: else
238: i = max(inumb(&ls), 1);
239: ls1 = ls;
240: ls = i;
241: noscale = 0;
242: }
243:
244:
245: casepo()
246: {
247: register i;
248:
249: if (skip())
250: i = po1;
251: else
252: i = max(hnumb(&po), 0);
253: po1 = po;
254: po = i;
255: #ifndef NROFF
256: if (!ascii)
257: esc += po - po1;
258: #endif
259: }
260:
261:
262: casepl()
263: {
264: register i;
265:
266: skip();
267: if ((i = vnumb(&pl)) == 0)
268: pl = 11 * INCH; /*11in*/
269: else
270: pl = i;
271: if (numtab[NL].val > pl)
272: numtab[NL].val = pl;
273: }
274:
275:
276: casewh()
277: {
278: register i, j, k;
279:
280: lgf++;
281: skip();
282: i = vnumb((int *)0);
283: if (nonumb)
284: return;
285: skip();
286: j = getrq();
287: if ((k = findn(i)) != NTRAP) {
288: mlist[k] = j;
289: return;
290: }
291: for (k = 0; k < NTRAP; k++)
292: if (mlist[k] == 0)
293: break;
294: if (k == NTRAP) {
295: flusho();
296: errprint("cannot plant trap.");
297: return;
298: }
299: mlist[k] = j;
300: nlist[k] = i;
301: }
302:
303:
304: casech()
305: {
306: register i, j, k;
307:
308: lgf++;
309: skip();
310: if (!(j = getrq()))
311: return;
312: else
313: for (k = 0; k < NTRAP; k++)
314: if (mlist[k] == j)
315: break;
316: if (k == NTRAP)
317: return;
318: skip();
319: i = vnumb((int *)0);
320: if (nonumb)
321: mlist[k] = 0;
322: nlist[k] = i;
323: }
324:
325:
326: findn(i)
327: int i;
328: {
329: register k;
330:
331: for (k = 0; k < NTRAP; k++)
332: if ((nlist[k] == i) && (mlist[k] != 0))
333: break;
334: return(k);
335: }
336:
337:
338: casepn()
339: {
340: register i;
341:
342: skip();
343: noscale++;
344: i = max(inumb(&numtab[PN].val), 0);
345: noscale = 0;
346: if (!nonumb) {
347: npn = i;
348: npnflg++;
349: }
350: }
351:
352:
353: casebp()
354: {
355: register i;
356: register struct s *savframe;
357:
358: if (dip != d)
359: return;
360: savframe = frame;
361: skip();
362: if ((i = inumb(&numtab[PN].val)) < 0)
363: i = 0;
364: tbreak();
365: if (!nonumb) {
366: npn = i;
367: npnflg++;
368: } else if (dip->nls)
369: return;
370: eject(savframe);
371: }
372:
373:
374: casetm(ab)
375: int ab;
376: {
377: register i;
378: char tmbuf[NTM];
379:
380: lgf++;
381: copyf++;
382: skip();
383: for (i = 0; i < NTM - 2; )
384: if ((tmbuf[i++] = getch()) == '\n')
385: break;
386: if (i == NTM - 2)
387: tmbuf[i++] = '\n';
388: tmbuf[i] = 0;
389: if (ab) /* truncate output */
390: obufp = obuf; /* should be a function in n2.c */
391: flusho();
392: fdprintf(stderr, "%s", tmbuf);
393: copyf--;
394: lgf--;
395: }
396:
397:
398: casesp(a)
399: int a;
400: {
401: register i, j, savlss;
402:
403: tbreak();
404: if (dip->nls || trap)
405: return;
406: i = findt1();
407: if (!a) {
408: skip();
409: j = vnumb((int *)0);
410: if (nonumb)
411: j = lss;
412: } else
413: j = a;
414: if (j == 0)
415: return;
416: if (i < j)
417: j = i;
418: savlss = lss;
419: if (dip != d)
420: i = dip->dnl;
421: else
422: i = numtab[NL].val;
423: if ((i + j) < 0)
424: j = -i;
425: lss = j;
426: newline(0);
427: lss = savlss;
428: }
429:
430:
431: casert()
432: {
433: register a, *p;
434:
435: skip();
436: if (dip != d)
437: p = &dip->dnl;
438: else
439: p = &numtab[NL].val;
440: a = vnumb(p);
441: if (nonumb)
442: a = dip->mkline;
443: if ((a < 0) || (a >= *p))
444: return;
445: nb++;
446: casesp(a - *p);
447: }
448:
449:
450: caseem()
451: {
452: lgf++;
453: skip();
454: em = getrq();
455: }
456:
457:
458: casefl()
459: {
460: tbreak();
461: flusho();
462: }
463:
464:
465: caseev()
466: {
467: register nxev;
468:
469: if (skip()) {
470: e0:
471: if (evi == 0)
472: return;
473: nxev = evlist[--evi];
474: goto e1;
475: }
476: noscale++;
477: nxev = atoi();
478: noscale = 0;
479: if (nonumb)
480: goto e0;
481: flushi();
482: if ((nxev >= NEV) || (nxev < 0) || (evi >= EVLSZ)) {
483: flusho();
484: errprint("cannot do ev.");
485: if (error)
486: done2(040);
487: else
488: edone(040);
489: return;
490: }
491: evlist[evi++] = ev;
492: e1:
493: if (ev == nxev)
494: return;
495: #ifdef INCORE
496: { extern tchar corebuf[];
497: envcopy((struct env *) &corebuf[ev * sizeof(env)/sizeof(tchar)], &env);
498: envcopy(&env, (struct env *) &corebuf[nxev * sizeof(env)/sizeof(tchar)]);
499: }
500: #else
501: lseek(ibf, ev * (long)sizeof(env), 0);
502: write(ibf, (char *) & env, sizeof(env));
503: lseek(ibf, nxev * (long)sizeof(env), 0);
504: read(ibf, (char *) & env, sizeof(env));
505: #endif
506: ev = nxev;
507: }
508:
509: envcopy(e1, e2) /* copy env e2 to e1 */
510: struct env *e1, *e2;
511: {
512: *e1 = *e2;
513: }
514:
515:
516: caseel()
517: {
518: if (--ifx < 0) {
519: ifx = 0;
520: iflist[0] = 0;
521: }
522: caseif(2);
523: }
524:
525:
526: caseie()
527: {
528: if (ifx >= NIF) {
529: errprint("if-else overflow.");
530: ifx = 0;
531: edone(040);
532: }
533: caseif(1);
534: ifx++;
535: }
536:
537:
538: caseif(x)
539: int x;
540: {
541: extern int falsef;
542: register notflag, true;
543: tchar i;
544:
545: if (x == 2) {
546: notflag = 0;
547: true = iflist[ifx];
548: goto i1;
549: }
550: true = 0;
551: skip();
552: if ((cbits(i = getch())) == '!') {
553: notflag = 1;
554: } else {
555: notflag = 0;
556: ch = i;
557: }
558: i = atoi();
559: if (!nonumb) {
560: if (i > 0)
561: true++;
562: goto i1;
563: }
564: i = getch();
565: switch (cbits(i)) {
566: case 'e':
567: if (!(numtab[PN].val & 01))
568: true++;
569: break;
570: case 'o':
571: if (numtab[PN].val & 01)
572: true++;
573: break;
574: #ifdef NROFF
575: case 'n':
576: true++;
577: case 't':
578: #endif
579: #ifndef NROFF
580: case 't':
581: true++;
582: case 'n':
583: #endif
584: case ' ':
585: break;
586: default:
587: true = cmpstr(i);
588: }
589: i1:
590: true ^= notflag;
591: if (x == 1)
592: iflist[ifx] = !true;
593: if (true) {
594: i2:
595: while ((cbits(i = getch())) == ' ')
596: ;
597: if (cbits(i) == LEFT)
598: goto i2;
599: ch = i;
600: nflush++;
601: } else {
602: copyf++;
603: falsef++;
604: eatblk(0);
605: copyf--;
606: falsef--;
607: }
608: }
609:
610: eatblk(inblk)
611: int inblk;
612: { register int cnt, i;
613:
614: cnt = 0;
615: do {
616: if (ch) {
617: i = cbits(ch);
618: ch = 0;
619: } else
620: i = cbits(getch0());
621: if (i == ESC)
622: cnt++;
623: else {
624: if (cnt == 1)
625: switch (i) {
626: case '{': i = LEFT; break;
627: case '}': i = RIGHT; break;
628: case '\n': i = 'x'; break;
629: }
630: cnt = 0;
631: }
632: if (i == LEFT) eatblk(1);
633: } while ((!inblk && (i != '\n')) || (inblk && (i != RIGHT)));
634: if (i == '\n')
635: nlflg++;
636: }
637:
638:
639: cmpstr(c)
640: tchar c;
641: {
642: register j, delim;
643: register tchar i;
644: register val;
645: int savapts, savapts1, savfont, savfont1, savpts, savpts1;
646: tchar string[1280];
647: register tchar *sp;
648:
649: if (ismot(c))
650: return(0);
651: delim = cbits(c);
652: savapts = apts;
653: savapts1 = apts1;
654: savfont = font;
655: savfont1 = font1;
656: savpts = pts;
657: savpts1 = pts1;
658: sp = string;
659: while ((j = cbits(i = getch()))!=delim && j!='\n' && sp<&string[1280-1])
660: *sp++ = i;
661: if (sp >= string + 1280) {
662: errprint("too-long string compare.");
663: edone(0100);
664: }
665: if (nlflg) {
666: val = sp==string;
667: goto rtn;
668: }
669: *sp++ = 0;
670: apts = savapts;
671: apts1 = savapts1;
672: font = savfont;
673: font1 = savfont1;
674: pts = savpts;
675: pts1 = savpts1;
676: mchbits();
677: val = 1;
678: sp = string;
679: while ((j = cbits(i = getch())) != delim && j != '\n') {
680: if (*sp != i) {
681: eat(delim);
682: val = 0;
683: goto rtn;
684: }
685: sp++;
686: }
687: if (*sp)
688: val = 0;
689: rtn:
690: apts = savapts;
691: apts1 = savapts1;
692: font = savfont;
693: font1 = savfont1;
694: pts = savpts;
695: pts1 = savpts1;
696: mchbits();
697: return(val);
698: }
699:
700:
701: caserd()
702: {
703:
704: lgf++;
705: skip();
706: getname();
707: if (!iflg) {
708: if (quiet) {
709: ttys.sg_flags &= ~ECHO;
710: stty(0, &ttys);
711: flusho();
712: fdprintf(stderr, "\007"); /*bell*/
713: } else {
714: if (nextf[0]) {
715: fdprintf(stderr, "%s:", nextf);
716: } else {
717: fdprintf(stderr, "\007"); /*bell*/
718: }
719: }
720: }
721: collect();
722: tty++;
723: pushi(NBLIST*BLK, PAIR('r','d'));
724: }
725:
726:
727: rdtty()
728: {
729: char onechar;
730:
731: onechar = 0;
732: if (read(0, &onechar, 1) == 1) {
733: if (onechar == '\n')
734: tty++;
735: else
736: tty = 1;
737: if (tty != 3)
738: return(onechar);
739: }
740: popi();
741: tty = 0;
742: if (quiet) {
743: ttys.sg_flags |= ECHO;
744: stty(0, &ttys);
745: }
746: return(0);
747: }
748:
749:
750: caseec()
751: {
752: eschar = chget('\\');
753: }
754:
755:
756: caseeo()
757: {
758: eschar = 0;
759: }
760:
761:
762: caseta()
763: {
764: register i;
765:
766: tabtab[0] = nonumb = 0;
767: for (i = 0; ((i < (NTAB - 1)) && !nonumb); i++) {
768: if (skip())
769: break;
770: tabtab[i] = max(hnumb(&tabtab[max(i-1,0)]), 0) & TABMASK;
771: if (!nonumb)
772: switch (cbits(ch)) {
773: case 'C':
774: tabtab[i] |= CTAB;
775: break;
776: case 'R':
777: tabtab[i] |= RTAB;
778: break;
779: default: /*includes L*/
780: break;
781: }
782: nonumb = ch = 0;
783: }
784: tabtab[i] = 0;
785: }
786:
787:
788: casene()
789: {
790: register i, j;
791:
792: skip();
793: i = vnumb((int *)0);
794: if (nonumb)
795: i = lss;
796: if (i > (j = findt1())) {
797: i = lss;
798: lss = j;
799: dip->nls = 0;
800: newline(0);
801: lss = i;
802: }
803: }
804:
805:
806: casetr()
807: {
808: register i, j;
809: tchar k;
810:
811: lgf++;
812: skip();
813: while ((i = cbits(k=getch())) != '\n') {
814: if (ismot(k))
815: return;
816: if (ismot(k = getch()))
817: return;
818: if ((j = cbits(k)) == '\n')
819: j = ' ';
820: trtab[i] = j;
821: }
822: }
823:
824:
825: casecu()
826: {
827: cu++;
828: caseul();
829: }
830:
831:
832: caseul()
833: {
834: register i;
835:
836: noscale++;
837: if (skip())
838: i = 1;
839: else
840: i = atoi();
841: if (ul && (i == 0)) {
842: font = sfont;
843: ul = cu = 0;
844: }
845: if (i) {
846: if (!ul) {
847: sfont = font;
848: font = ulfont;
849: }
850: ul = i;
851: }
852: noscale = 0;
853: mchbits();
854: }
855:
856:
857: caseuf()
858: {
859: register i, j;
860:
861: if (skip() || !(i = getrq()) || i == 'S' || (j = findft(i)) == -1)
862: ulfont = ULFONT; /*default underline position*/
863: else
864: ulfont = j;
865: #ifdef NROFF
866: if (ulfont == FT)
867: ulfont = ULFONT;
868: #endif
869: }
870:
871:
872: caseit()
873: {
874: register i;
875:
876: lgf++;
877: it = itmac = 0;
878: noscale++;
879: skip();
880: i = atoi();
881: skip();
882: if (!nonumb && (itmac = getrq()))
883: it = i;
884: noscale = 0;
885: }
886:
887:
888: casemc()
889: {
890: register i;
891:
892: if (icf > 1)
893: ic = 0;
894: icf = 0;
895: if (skip())
896: return;
897: ic = getch();
898: icf = 1;
899: skip();
900: i = max(hnumb((int *)0), 0);
901: if (!nonumb)
902: ics = i;
903: }
904:
905:
906: casemk()
907: {
908: register i, j;
909:
910: if (dip != d)
911: j = dip->dnl;
912: else
913: j = numtab[NL].val;
914: if (skip()) {
915: dip->mkline = j;
916: return;
917: }
918: if ((i = getrq()) == 0)
919: return;
920: numtab[findr(i)].val = j;
921: }
922:
923:
924: casesv()
925: {
926: register i;
927:
928: skip();
929: if ((i = vnumb((int *)0)) < 0)
930: return;
931: if (nonumb)
932: i = 1;
933: sv += i;
934: caseos();
935: }
936:
937:
938: caseos()
939: {
940: register savlss;
941:
942: if (sv <= findt1()) {
943: savlss = lss;
944: lss = sv;
945: newline(0);
946: lss = savlss;
947: sv = 0;
948: }
949: }
950:
951:
952: casenm()
953: {
954: register i;
955:
956: lnmod = nn = 0;
957: if (skip())
958: return;
959: lnmod++;
960: noscale++;
961: i = inumb(&numtab[LN].val);
962: if (!nonumb)
963: numtab[LN].val = max(i, 0);
964: getnm(&ndf, 1);
965: getnm(&nms, 0);
966: getnm(&ni, 0);
967: noscale = 0;
968: nmbits = chbits;
969: }
970:
971:
972: getnm(p, min)
973: int *p, min;
974: {
975: register i;
976:
977: eat(' ');
978: if (skip())
979: return;
980: i = atoi();
981: if (nonumb)
982: return;
983: *p = max(i, min);
984: }
985:
986:
987: casenn()
988: {
989: noscale++;
990: skip();
991: nn = max(atoi(), 1);
992: noscale = 0;
993: }
994:
995:
996: caseab()
997: {
998: casetm(1);
999: done3(0);
1000: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.