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