![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tc.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 tc.c CVS log | Up to [Research Unix] / researchv9 / cmd / troff |
1.1 root 1: /*
2: * drive 4014 scope
3: */
4:
5: /*
6: output language from troff:
7: all numbers are character strings
8:
9: sn size in points
10: fn font as number from 1-n
11: cx ascii character x
12: Cxyz funny char xyz. terminated by white space
13: Hn go to absolute horizontal position n
14: Vn go to absolute vertical position n (down is positive)
15: hn go n units horizontally (relative)
16: vn ditto vertically
17: nnc move right nn, then print c (exactly 2 digits!)
18: (this wart is an optimization that shrinks output file size
19: about 35% and run-time about 15% while preserving ascii-ness)
20: Dt ...\n draw operation 't':
21: Dl x y line from here by x,y
22: Dc d circle of diameter d with left side here
23: De x y ellipse of axes x,y with left side here
24: Da x y r arc counter-clockwise by x,y of radius r
25: D~ x y x y ... wiggly line by x,y then x,y ...
26: nb a end of line (information only -- no action needed)
27: b = space before line, a = after
28: p new page begins -- set v to 0
29: #...\n comment
30: x ...\n device control functions:
31: x i init
32: x T s name of device is s
33: x r n h v resolution is n/inch
34: h = min horizontal motion, v = min vert
35: x p pause (can restart)
36: x s stop -- done for ever
37: x t generate trailer
38: x f n s font position n contains font s
39: x H n set character height to n
40: x S n set slant to N
41:
42: Subcommands like "i" are often spelled out like "init".
43: */
44:
45: #include <stdio.h>
46: #include <signal.h>
47: #include <ctype.h>
48:
49: #include "dev.h"
50: #define NFONT 10
51:
52: int output = 0; /* do we do output at all? */
53: int nolist = 0; /* output page list if > 0 */
54: int olist[20]; /* pairs of page numbers */
55:
56: int erase = 1;
57: float aspect = 1.5; /* default aspect ratio */
58: int (*sigint)();
59: int (*sigquit)();
60:
61: struct dev dev;
62: struct font *fontbase[NFONT];
63: short psizes[] ={ 11, 16, 22, 36, 0}; /* approx sizes available */
64: short *pstab = psizes;
65: int nsizes = 4;
66: int pscode[] ={ ';', ':', '9', '8'};
67: int nfonts;
68: int smnt; /* index of first special font */
69: int nchtab;
70: char *chname;
71: short *chtab;
72: char *fitab[NFONT];
73: char *widthtab[NFONT]; /* widtab would be a better name */
74: char *codetab[NFONT]; /* device codes */
75:
76: #define FATAL 1
77: #define BMASK 0377
78: int keepon = 0;
79: int dbg = 0;
80: long lineno = 0;
81: int res = 972; /* input assumed computed according to this resolution */
82: /* initial value to avoid 0 divide */
83: FILE *tf = stdout; /* output file */
84: char *fontdir = "/usr/lib/font";
85: extern char devname[];
86:
87: FILE *fp = stdin; /* input file pointer */
88:
89: main(argc, argv)
90: char *argv[];
91: {
92: char buf[BUFSIZ];
93: float atof();
94: int done();
95:
96: setbuf(stdout, buf);
97: while (argc > 1 && argv[1][0] == '-') {
98: switch (argv[1][1]) {
99: case 'T':
100: if (strcmp(&argv[1][2], "cat") == 0) { /* use the old one */
101: if (fork() == 0) {
102: execv("/usr/bin/oldtc", argv);
103: fprintf(stderr, "tc: can't find oldtc\n");
104: }
105: wait();
106: exit(1);
107: }
108: break;
109: case 'a':
110: aspect = atof(&argv[1][2]);
111: break;
112: case 'e':
113: erase = 0;
114: break;
115: case 'o':
116: outlist(&argv[1][2]);
117: break;
118: case 'd':
119: dbg = atoi(&argv[1][2]);
120: if (dbg == 0) dbg = 1;
121: break;
122: case 'c':
123: keepon = 1;
124: break;
125: }
126: argc--;
127: argv++;
128: }
129:
130: sigint = signal(SIGINT, done);
131: sigquit = signal(SIGQUIT, SIG_IGN);
132: if (argc <= 1)
133: conv(stdin);
134: else
135: while (--argc > 0) {
136: if (strcmp(*++argv, "-") == 0)
137: fp = stdin;
138: else if ((fp = fopen(*argv, "r")) == NULL)
139: error(FATAL, "can't open %s", *argv);
140: conv(fp);
141: fclose(fp);
142: }
143: done();
144: }
145:
146: outlist(s) /* process list of page numbers to be printed */
147: char *s;
148: {
149: int n1, n2, i;
150:
151: nolist = 0;
152: while (*s) {
153: n1 = 0;
154: if (isdigit(*s))
155: do
156: n1 = 10 * n1 + *s++ - '0';
157: while (isdigit(*s));
158: else
159: n1 = -9999;
160: n2 = n1;
161: if (*s == '-') {
162: s++;
163: n2 = 0;
164: if (isdigit(*s))
165: do
166: n2 = 10 * n2 + *s++ - '0';
167: while (isdigit(*s));
168: else
169: n2 = 9999;
170: }
171: olist[nolist++] = n1;
172: olist[nolist++] = n2;
173: if (*s != '\0')
174: s++;
175: }
176: olist[nolist] = 0;
177: if (dbg)
178: for (i=0; i<nolist; i += 2)
179: printf("%3d %3d\n", olist[i], olist[i+1]);
180: }
181:
182: in_olist(n) /* is n in olist? */
183: int n;
184: {
185: int i;
186:
187: if (nolist == 0)
188: return(1); /* everything is included */
189: for (i = 0; i < nolist; i += 2)
190: if (n >= olist[i] && n <= olist[i+1])
191: return(1);
192: return(0);
193: }
194:
195: conv(fp)
196: register FILE *fp;
197: {
198: register int c, k;
199: int m, n, i, n1, m1;
200: char str[100], buf[300];
201:
202: while ((c = getc(fp)) != EOF) {
203: switch (c) {
204: case '\n': /* when input is text */
205: lineno++;
206: case ' ':
207: case 0: /* occasional noise creeps in */
208: break;
209: case '{': /* push down current environment */
210: t_push();
211: break;
212: case '}':
213: t_pop();
214: break;
215: case '0': case '1': case '2': case '3': case '4':
216: case '5': case '6': case '7': case '8': case '9':
217: /* two motion digits plus a character */
218: hmot((c-'0')*10 + getc(fp)-'0');
219: put1(getc(fp));
220: break;
221: case 'c': /* single ascii character */
222: put1(getc(fp));
223: break;
224: case 'C':
225: fscanf(fp, "%s", str);
226: put1s(str);
227: break;
228: case 't': /* straight text */
229: fgets(buf, sizeof(buf), fp);
230: lineno++;
231: t_text(buf);
232: break;
233: case 'D': /* draw function */
234: fgets(buf, sizeof(buf), fp);
235: lineno++;
236: switch (buf[0]) {
237: case 'l': /* draw a line */
238: sscanf(buf+1, "%d %d", &n, &m);
239: drawline(n, m, ".");
240: break;
241: case 'c': /* circle */
242: sscanf(buf+1, "%d", &n);
243: drawcirc(n);
244: break;
245: case 'e': /* ellipse */
246: sscanf(buf+1, "%d %d", &m, &n);
247: drawellip(m, n);
248: break;
249: case 'a': /* arc */
250: sscanf(buf+1, "%d %d %d %d", &n, &m, &n1, &m1);
251: drawarc(n, m, n1, m1);
252: break;
253: case '~': /* wiggly line */
254: drawwig(buf+1);
255: break;
256: default:
257: error(FATAL, "unknown drawing function %s\n", buf);
258: break;
259: }
260: break;
261: case 's':
262: fscanf(fp, "%d", &n); /* ignore fractional sizes */
263: setsize(t_size(n));
264: break;
265: case 'f':
266: fscanf(fp, "%s", str);
267: setfont(t_font(str));
268: break;
269: case 'H': /* absolute horizontal motion */
270: /* fscanf(fp, "%d", &n); */
271: while ((c = getc(fp)) == ' ')
272: ;
273: k = 0;
274: do {
275: k = 10 * k + c - '0';
276: } while (isdigit(c = getc(fp)));
277: ungetc(c, fp);
278: hgoto(k);
279: break;
280: case 'h': /* relative horizontal motion */
281: /* fscanf(fp, "%d", &n); */
282: while ((c = getc(fp)) == ' ')
283: ;
284: k = 0;
285: do {
286: k = 10 * k + c - '0';
287: } while (isdigit(c = getc(fp)));
288: ungetc(c, fp);
289: hmot(k);
290: break;
291: case 'w': /* word space */
292: break;
293: case 'V':
294: fscanf(fp, "%d", &n);
295: vgoto(n);
296: break;
297: case 'v':
298: fscanf(fp, "%d", &n);
299: vmot(n);
300: break;
301: case 'p': /* new page */
302: fscanf(fp, "%d", &n);
303: t_page(n);
304: break;
305: case 'n': /* end of line */
306: while (getc(fp) != '\n')
307: ;
308: t_newline();
309: break;
310: case '#': /* comment */
311: while (getc(fp) != '\n')
312: ;
313: lineno++;
314: break;
315: case 'x': /* device control */
316: devcntrl(fp);
317: lineno++;
318: break;
319: default:
320: error(!FATAL, "unknown input character %o %c\n", c, c);
321: while (getc(fp) != '\n')
322: ;
323: }
324: }
325: }
326:
327: devcntrl(fp) /* interpret device control functions */
328: FILE *fp;
329: {
330: char str[20];
331: int c, n;
332:
333: fscanf(fp, "%s", str);
334: switch (str[0]) { /* crude for now */
335: case 'i': /* initialize */
336: fileinit();
337: t_init(0);
338: break;
339: case 'T': /* device name */
340: fscanf(fp, "%s", devname);
341: break;
342: case 't': /* trailer */
343: t_trailer();
344: break;
345: case 'p': /* pause -- can restart */
346: t_reset('p');
347: break;
348: case 's': /* stop */
349: t_reset('s');
350: break;
351: case 'r': /* resolution assumed when prepared */
352: fscanf(fp, "%d", &res);
353: break;
354: case 'f': /* font used */
355: fscanf(fp, "%d %s", &n, str);
356: loadfont(n, str);
357: break;
358: }
359: while (getc(fp) != '\n') /* skip rest of input line */
360: ;
361: }
362:
363: fileinit() /* read in font and code files, etc. */
364: {
365: }
366:
367: fontprint(i) /* debugging print of font i (0,...) */
368: {
369: }
370:
371: loadcode(n, nw) /* load codetab on position n (0...); #chars is nw */
372: int n, nw;
373: {
374: }
375:
376: loadfont(n, s) /* load font info for font s on position n (1...) */
377: int n;
378: char *s;
379: {
380: }
381:
382: #define ESC 033
383: #define MAXY (3071-100)
384: #define US 037 /* text mode */
385: #define GS 035 /* graphics mode */
386: #define FF 014
387:
388: error(f, s, a1, a2, a3, a4, a5, a6, a7) {
389: fprintf(stderr, "%c%c%c", US, ESC, ';'); /* reset terminal sensibly */
390: fprintf(stderr, "tc: ");
391: fprintf(stderr, s, a1, a2, a3, a4, a5, a6, a7);
392: fprintf(stderr, " near line %ld\n", lineno);
393: if (f)
394: done(2);
395: }
396:
397:
398: /*
399: Here beginneth all the stuff that really depends
400: on the 202 (we hope).
401: */
402:
403:
404: char devname[20] = "4014";
405:
406: #define oput(c) if (output) putchar(c); else;
407:
408: int stopped = 0;
409: int ohx = -1;
410: int ohy = -1;
411: int oxb = -1;
412: int oly = -1;
413: int olx = -1;
414: int skip;
415: int size = 1;
416: int font = 1; /* current font */
417: int hpos; /* horizontal position where we are supposed to be next (left = 0) */
418: int vpos; /* current vertical position (down positive) */
419:
420: int horig; /* h origin of current block; hpos rel to this */
421: int vorig; /* v origin of current block; vpos rel to this */
422:
423: int DX = 10; /* step size in x for drawing */
424: int DY = 10; /* step size in y for drawing */
425: int drawdot = '.'; /* draw with this character */
426: int drawsize = 1; /* shrink by this factor when drawing */
427:
428: t_init(reinit) /* initialize device */
429: int reinit;
430: {
431: fflush(stdout);
432: stopped = 0;
433: if (erase) {
434: oput(ESC);
435: oput(FF);
436: oput(US);
437: }
438: hpos = vpos = 0;
439: setsize(t_size(10)); /* start somewhere */
440: sendpt();
441: }
442:
443: #define MAXSTATE 5
444:
445: struct state {
446: int ssize;
447: int sfont;
448: int shpos;
449: int svpos;
450: int shorig;
451: int svorig;
452: };
453: struct state state[MAXSTATE];
454: struct state *statep = state;
455:
456: t_push() /* begin a new block */
457: {
458: hflush();
459: statep->ssize = size;
460: statep->sfont = font;
461: statep->shorig = horig;
462: statep->svorig = vorig;
463: statep->shpos = hpos;
464: statep->svpos = vpos;
465: horig = hpos;
466: vorig = vpos;
467: hpos = vpos = 0;
468: if (statep++ >= state+MAXSTATE)
469: error(FATAL, "{ nested too deep");
470: hpos = vpos = 0;
471: }
472:
473: t_pop() /* pop to previous state */
474: {
475: if (--statep < state)
476: error(FATAL, "extra }");
477: size = statep->ssize;
478: font = statep->sfont;
479: hpos = statep->shpos;
480: vpos = statep->svpos;
481: horig = statep->shorig;
482: vorig = statep->svorig;
483: }
484:
485: int np; /* number of pages seen */
486: int npmax; /* high-water mark of np */
487: int pgnum[100]; /* their actual numbers */
488: long pgadr[100]; /* their seek addresses */
489:
490: t_page(n) /* do whatever new page functions */
491: {
492: long ftell();
493: int c, m, i;
494: char buf[100], *bp;
495:
496: pgnum[np++] = n;
497: pgadr[np] = ftell(fp);
498: if (np > npmax)
499: npmax = np;
500: if (output == 0) {
501: output = in_olist(n);
502: t_init(1);
503: return;
504: }
505: /* have just printed something, and seen p<n> for next one */
506: vgoto(11 * res - 100);
507: sendpt();
508: oput(US);
509: fflush(stdout);
510:
511:
512: if (keepon) {
513: t_init(1);
514: return;
515: }
516: next:
517: for (bp = buf; (*bp = readch()); )
518: if (*bp++ == '\n')
519: break;
520: *bp = 0;
521: switch (buf[0]) {
522: case 0:
523: done();
524: break;
525: case '\n':
526: if (stopped)
527: done();
528: output = in_olist(n);
529: t_init(1);
530: return;
531: case '!':
532: callunix(&buf[1]);
533: fputs("!\n", stderr);
534: break;
535: case 'e':
536: erase = 1 - erase;
537: break;
538: case 'a':
539: aspect = atof(&buf[1]);
540: break;
541: case '-':
542: case 'p':
543: m = atoi(&buf[1]) + 1;
544: if (fp == stdin) {
545: fputs("you can't; it's not a file\n", stderr);
546: break;
547: }
548: if (np - m <= 0) {
549: fputs("too far back\n", stderr);
550: break;
551: }
552: np -= m;
553: fseek(fp, pgadr[np], 0);
554: output = 1;
555: t_init(1);
556: return;
557: case '0': case '1': case '2': case '3': case '4':
558: case '5': case '6': case '7': case '8': case '9':
559: m = atoi(&buf[0]);
560: for (i = 0; i < npmax; i++)
561: if (m == pgnum[i])
562: break;
563: if (i >= npmax || fp == stdin) {
564: fputs("you can't\n", stderr);
565: break;
566: }
567: np = i + 1;
568: fseek(fp, pgadr[np], 0);
569: output = 1;
570: t_init(1);
571: return;
572: case 'o':
573: outlist(&buf[1]);
574: output = 0;
575: t_init(1);
576: return;
577: case '?':
578: fputs("!cmd unix cmd\n", stderr);
579: fputs("p print this page again\n", stderr);
580: fputs("-n go back n pages\n", stderr);
581: fputs("n print page n (previously printed)\n", stderr);
582: fputs("o... set the -o output list to ...\n", stderr);
583: fputs("en n=0 -> don't erase; n=1 -> erase\n", stderr);
584: fputs("an sets aspect ratio to n\n", stderr);
585: break;
586: default:
587: fputs("?\n", stderr);
588: break;
589: }
590: goto next;
591: }
592:
593: t_newline() /* do whatever for the end of a line */
594: {
595: hpos = 0;
596: }
597:
598: t_size(n) /* convert integer to internal size number*/
599: int n;
600: {
601: int i;
602:
603: if (n <= pstab[0])
604: return(1);
605: else if (n >= pstab[nsizes-1])
606: return(nsizes);
607: for (i = 0; n > pstab[i]; i++)
608: ;
609: return(i+1);
610: }
611:
612: t_font(s) /* convert string to internal font number */
613: char *s;
614: {
615: int n;
616:
617: n = atoi(s);
618: if (n < 1 || n > nfonts)
619: n = 1;
620: return(n);
621: }
622:
623: t_text(s) /* print string s as text */
624: char *s;
625: {
626: int c, w;
627: char str[100];
628:
629: if (!output)
630: return;
631: w = res / 2 * pstab[size-1] / 72;
632: while ((c = *s++) != '\n') {
633: if (c == '\\') {
634: switch (c = *s++) {
635: case '\\':
636: case 'e':
637: put1('\\');
638: break;
639: case '(':
640: str[0] = *s++;
641: str[1] = *s++;
642: str[2] = '\0';
643: put1s(str);
644: break;
645: }
646: } else {
647: put1(c);
648: }
649: hmot(w);
650: }
651: }
652:
653: t_reset(c)
654: {
655: int n;
656:
657: output = 1;
658: fflush(stdout);
659: if (c == 's') {
660: stopped = 1;
661: t_page(9999);
662: }
663: }
664:
665: t_trailer()
666: {
667: }
668:
669: hgoto(n)
670: {
671: hpos = n; /* this is where we want to be */
672: /* before printing a character, */
673: /* have to make sure it's true */
674: }
675:
676: hmot(n) /* generate n units of horizontal motion */
677: int n;
678: {
679: hgoto(hpos + n);
680: }
681:
682: hflush() /* actual horizontal output occurs here */
683: {
684: if (output)
685: sendpt();
686: }
687:
688: vgoto(n)
689: {
690: vpos = n;
691: }
692:
693: vmot(n) /* generate n units of vertical motion */
694: int n;
695: {
696: vgoto(vpos + n); /* ignores rounding */
697: }
698:
699: put1s(s) /* s is a funny char name */
700: char *s;
701: {
702: int i;
703: char *p;
704: extern char *spectab[];
705: static char prev[10] = "";
706: static int previ;
707:
708: if (!output)
709: return;
710: if (strcmp(s, prev) != 0) {
711: previ = -1;
712: for (i = 0; spectab[i] != 0; i += 2)
713: if (strcmp(spectab[i], s) == 0) {
714: strcpy(prev, s);
715: previ = i;
716: break;
717: }
718: }
719: if (previ >= 0) {
720: hflush();
721: oput(US);
722: for (p = spectab[previ+1]; *p; p++)
723: oput(*p);
724: } else
725: prev[0] = 0;
726: }
727:
728: put1(c) /* output char c */
729: int c;
730: {
731: if (!output)
732: return;
733: hflush();
734: oput(US);
735: oput(c);
736: }
737:
738: setsize(n) /* set point size to n (internal) */
739: int n;
740: {
741:
742: if (!output)
743: return;
744: if (n == size)
745: return; /* already there */
746: oput(ESC);
747: oput(pscode[n-1]);
748: size = n;
749: }
750:
751: t_fp(n, s) /* font position n now contains font s */
752: int n;
753: char *s;
754: {
755: }
756:
757: setfont(n) /* set font to n */
758: int n;
759: {
760: }
761:
762: done()
763: {
764: output = 1;
765: hgoto(0);
766: vgoto(11 * res - 100); /* bottom of page */
767: sendpt();
768: oput(US);
769: oput(ESC);
770: oput(';');
771: oput(US);
772: fflush(stdout);
773: exit(0);
774: }
775:
776: callunix(line)
777: char line[];
778: {
779: int rc, status, unixpid;
780: if( (unixpid=fork())==0 ) {
781: signal(SIGINT,sigint); signal(SIGQUIT,sigquit);
782: close(0); dup(2);
783: execl("/bin/sh", "-sh", "-c", line, 0);
784: exit(255);
785: }
786: else if(unixpid == -1)
787: return;
788: else{ signal(SIGINT, SIG_IGN); signal(SIGQUIT, SIG_IGN);
789: while( (rc = wait(&status)) != unixpid && rc != -1 ) ;
790: signal(SIGINT, done); signal(SIGQUIT,sigquit);
791: }
792: }
793: readch(){
794: char c;
795: if (read(2,&c,1)<1) c=0;
796: return(c);
797: }
798: sendpt(){
799: int hy,xb,ly,hx,lx;
800: int xx, yy;
801: float fx, fy;
802:
803:
804: fx = hpos + horig;
805: fy = vpos + vorig;
806: xx = (fx * MAXY / 11) / res * aspect + 0.5;
807: yy = MAXY - (fy * MAXY / 11) / res + 0.5;
808: oput(GS);
809: hy = ((yy>>7) & 037);
810: xb = ((xx & 03) + ((yy<<2) & 014) & 017);
811: ly = ((yy>>2) & 037);
812: hx = ((xx>>7) & 037);
813: lx = ((xx>>2) & 037);
814: if(hy != ohy)oput(hy | 040);
815: if(xb != oxb)oput(xb | 0140);
816: if((ly != oly) || (hx != ohx) || (xb != oxb))
817: oput(ly | 0140);
818: if(hx != ohx)oput(hx | 040);
819: oput(lx | 0100);
820: ohy = hy;
821: oxb = xb;
822: oly = ly;
823: ohx = hx;
824: olx = lx;
825: }
826:
827: char *spectab[] ={
828: "em", "--",
829: "en", "-",
830: "hy", "-",
831: "ff", "ff",
832: "fi", "fi",
833: "fl", "fl",
834: "Fi", "ffi",
835: "Fl", "ffl",
836: "ct", "\033\016Z\bM\033\017", /*cent sign*/
837: "de", "\033\016J\033\017", /*degree*/
838: "dg", "\033\016M\b_\033\017", /*dagger*/
839: "rg", "\033\016O\b&\033\017", /*registered*/
840: "bu", "\033\016O\b~\033\017", /*bullet*/
841: "fm", "'",
842: "co", "\033\016O\b#\033\017", /*copyright*/
843: "sq", "\033\016L\033\017", /*square*/
844: "*q", "\033\016(\bM\033\017", /*psi*/
845: "*h", "\033\016o\b_\033\017", /*theta*/
846: "*n", "v\b)", /*nu*/
847: "*m", "\033\016V\b,\033\017", /*mu*/
848: "*l", "\033\016)\b?\033\017", /*lambda*/
849: "*i", "\033\016I\033\017", /*iota*/
850: "*z", "S\b\033\016Z\033\017", /*zeta*/
851: "*s", "o\b\'", /*sigma*/
852: "*d", "o\b\033\0165\033\017", /*delta*/
853: "*b", "\033\016b\033\017", /*beta*/
854: "*c", "\033\016e\bc\033\017", /*xi*/
855: "*y", "j\b\033\016C\033\017", /*eta*/
856: "*f", "\033\016O\bM\033\017", /*phi*/
857: "*u", "\033\016(\033\017", /*upsilon*/
858: "*k", "\033\016k\033\017", /*kappa*/
859: "*p", "T\b\033\016S\033\017", /*pi*/
860: "da", "\033\016U\033\017", /*down arrow*/
861: "*a", "\033\016A\033\017", /*alpha*/
862: "or", "|",
863: "*x", "l\b/", /*chi*/
864: "*e", "\033\016E\033\017", /*epsilon*/
865: "*o", "\033\016O\033\017", /*omicron*/
866: "<-", "\033\016[\033\017", /*left arrow*/
867: "*r", "\033\016R\033\017", /*rho*/
868: "ua", "\033\016Y\033\017", /*up arrow*/
869: "*t", "\033\016N\033\017", /*tau*/
870: "ul", "_",
871: "ru", "_",
872: "\\_", "_",
873: "*Q", "I\b\033\016(\033\017", /*Psi*/
874: "bs", "\033\016O\bJ\033\017", /*bell system sign*/
875: "if", "\033\016W\bX\033\017", /*infinity*/
876: "*g", "`\b/", /*gamma*/
877: "ip", "\033\016X\bF\033\017", /*improper superset*/
878: "pt", "\033\016A\033\017", /*proportional to*/
879: "rh", "\033\016\\\b]\033\017", /*right hand*/
880: "*w", "\033\016W\033\017", /*omega*/
881: "gr", "\033\016G\033\017", /*gradient*/
882: "*F", "I\033\016\bO\033\017", /*Phi*/
883: "*H", "O\b=", /*Theta*/
884: "*W", "O\b_", /*Omega*/
885: "cu", "\033\016V\033\017", /*cup (union)*/
886: "rn", "\033\016@\033\017", /*root en*/
887: "ts", "s", /*terminal sigma*/
888: "*L", "\033\016)\bK\033\017", /*Lambda*/
889: "\\-", "-",
890: "*G", "\033\016S\bK\033\017", /*Gamma*/
891: "is", "\033\016i\033\017", /*integral sign*/
892: "Sl", "l",
893: "*P", "\033\016t\b'\033\017", /*Pi*/
894: "sb", "\033\016Z\033\017", /*subset of*/
895: "sp", "\033\016X\033\017", /*superset of*/
896: "ap", "\033\016T\033\017", /*approximates*/
897: "pd", "o\b`", /*partial derivative*/
898: "*D", "\033\016H\033\017", /*Delta*/
899: "sr", "\033\016I\b'\033\017", /*square root*/
900: "*S", ">\b\033\016F\b@\033\017", /*Sigma*/
901: "~~", "\033\016T\bF\033\017", /*approx =*/
902: "*C", "\033\016_\bF\b@\033\017", /*Xi*/
903: "sl", "/",
904: "ca", "\033\016C\033\017", /*cap (intersection)*/
905: "U", "\033\016y\033\017", /*Upsilon*/
906: "no", "\033\016|\033\017", /*not*/
907: "rc", "|", /*right ceiling (rt of ")*/
908: "lt", "|", /*left top (of big curly)*/
909: "bv", "|", /*bold vertical*/
910: "lk", "|", /*left center of big curly bracket*/
911: "lb", "|", /*left bottom*/
912: "rt", "|", /*right top*/
913: "rk", "|", /*right center of big curly bracket*/
914: "rb", "|", /*right bot*/
915: "rf", "|", /*right floor (rb of ")*/
916: "lf", "|", /*left floor (left bot of big sq bract)*/
917: "lc", "|", /*left ceiling (lt of ")*/
918: "mu", "\033\016=\033\017", /*multiply*/
919: "di", "\033\016+\033\017", /*divide*/
920: "+-", "+\b_", /*plus-minus*/
921: "<=", "\033\016$\033\017", /*<=*/
922: ">=", "\033\016^\033\017", /*>=*/
923: "==", "=\b_", /*identically equal*/
924: "!=", "\033\016*\033\017", /*not equal*/
925: "aa", "'",
926: "ga", "`",
927: "lh", "\033\016|\b[\033\017", /*left hand*/
928: "mo", "\033\016c\b_\033\017", /*member of*/
929: "es", "\033\016O\b/\033\017", /*empty set*/
930: "dd", "\033\016%\bM\033\017", /*dbl dagger*/
931: "br", "|", /*box rule*/
932: "vr", "|", /* vertical rule */
933: "ib", "\033\016Z\bF\033\017", /*improper subset*/
934: "ci", "\033\016O\033\017", /*circle*/
935: "eq", "=",
936: "pl", "+",
937: "mi", "-",
938: "12", "1/2",
939: "14", "1/4",
940: "34", "3/4",
941: "->", "\033\016]\033\017", /*right arrow*/
942: "sc", "g\b\033\016C\033\017", /*section mark*/
943: "**", "*",
944: "l.", ".",
945: "L.", ".",
946: "bx", "[\b]",
947: "ob", "o", /* open bullet */
948: "cd", ",", /* cedilla */
949: "..", "\033\016!\033\017", /* umlaut */
950: 0, 0,
951: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.