Return to main.c CVS log

Up to [Research Unix] / researchv9 / cmd / eqn

Annotation of researchv9/cmd/eqn/main.c, revision 1.1

1.1     ! root        1: # include "e.h"
        !             2: #define        MAXLINE 3600    /* maximum input line */
        !             3: 
        !             4: char   in[MAXLINE];    /* input buffer */
        !             5: int    noeqn;
        !             6: char   *cmdname;
        !             7: 
        !             8: main(argc,argv)
        !             9:        int argc;
        !            10:        char *argv[];
        !            11: {
        !            12:        exit(eqn(argc, argv));
        !            13: }
        !            14: 
        !            15: eqn(argc,argv)
        !            16:        int argc;
        !            17:        char *argv[];
        !            18: {
        !            19:        int i, type;
        !            20:        char *p, *getenv(), buf[20];
        !            21: 
        !            22:        cmdname = argv[0];
        !            23:        if (p = getenv("TYPESETTER"))
        !            24:                typesetter = p;
        !            25:        while (argc > 1 && argv[1][0] == '-') {
        !            26:                switch (argv[1][1]) {
        !            27: 
        !            28:                case 'd':
        !            29:                        if (argv[1][2] == '\0')
        !            30:                                dbg++;
        !            31:                        else {
        !            32:                                lefteq = argv[1][2];
        !            33:                                righteq = argv[1][3];
        !            34:                        }
        !            35:                        break;
        !            36:                case 's': szstack[0] = gsize = atoi(&argv[1][2]); break;
        !            37:                case 'p': deltaps = atoi(&argv[1][2]); dps_set = 1; break;
        !            38:                case 'm': minsize = atoi(&argv[1][2]); break;
        !            39:                case 'f': strcpy(ftstack[0].name,&argv[1][2]); break;
        !            40:                case 'e': noeqn++; break;
        !            41:                case 'T': typesetter = &argv[1][2]; break;
        !            42:                default:
        !            43:                        fprintf(stderr, "%s: unknown option %s\n", cmdname, argv[1]);
        !            44:                        break;
        !            45:                }
        !            46:                argc--;
        !            47:                argv++;
        !            48:        }
        !            49:        settype(typesetter);
        !            50:        sprintf(buf, "\"%s\"", typesetter);
        !            51:        lookup(deftbl, strsave(typesetter), strsave(buf));
        !            52:        init_tbl();     /* install other keywords in tables */
        !            53:        curfile = infile;
        !            54:        pushsrc(File, curfile);
        !            55:        if (argc <= 1) {
        !            56:                curfile->fin = stdin;
        !            57:                curfile->fname = strsave("-");
        !            58:                getdata();
        !            59:        } else
        !            60:                while (argc-- > 1) {
        !            61:                        if (strcmp(*++argv, "-") == 0)
        !            62:                                curfile->fin = stdin;
        !            63:                        else if ((curfile->fin = fopen(*argv, "r")) == NULL)
        !            64:                                fatal("can't open file %s", *argv);
        !            65:                        curfile->fname = strsave(*argv);
        !            66:                        getdata();
        !            67:                        if (curfile->fin != stdin)
        !            68:                                fclose(curfile->fin);
        !            69:                }
        !            70:        return 0;
        !            71: }
        !            72: 
        !            73: settype(s)     /* initialize data for particular typesetter */
        !            74:        char *s;        /* the minsize could profitably come from the */
        !            75: {                      /* troff description file /usr/lib/font/dev.../DESC.out */
        !            76:        if (strcmp(s, "202") == 0)
        !            77:                { minsize = 5; ttype = DEV202; }
        !            78:        else if (strcmp(s, "aps") == 0)
        !            79:                { minsize = 5; ttype = DEVAPS; }
        !            80:        else if (strcmp(s, "cat") == 0)
        !            81:                { minsize = 6; ttype = DEVCAT; }
        !            82:        else
        !            83:                { minsize = 6; ttype = DEVCAT; }
        !            84: }
        !            85: 
        !            86: getdata()
        !            87: {
        !            88:        register FILE *fin;
        !            89:        int i, type, ln;
        !            90:        char fname[100];
        !            91:        extern int errno;
        !            92: 
        !            93:        errno = 0;
        !            94:        fin = curfile->fin;
        !            95:        curfile->lineno = 0;
        !            96:        printf(".lf 1 %s\n", curfile->fname);
        !            97:        while ((type = getline(in)) != EOF) {
        !            98:                if (in[0] == '.' && in[1] == 'E' && in[2] == 'Q') {
        !            99:                        for (i = 11; i < 100; i++)
        !           100:                                used[i] = 0;
        !           101:                        printf("%s", in);
        !           102:                        if (markline) { /* turn off from last time */
        !           103:                                printf(".nr MK 0\n");
        !           104:                                markline = 0;
        !           105:                        }
        !           106:                        display = 1;
        !           107:                        init();
        !           108:                        yyparse();
        !           109:                        if (eqnreg > 0) {
        !           110:                                if (markline)
        !           111:                                        printf(".nr MK %d\n", markline); /* for -ms macros */
        !           112:                                printf(".if %gm>\\n(.v .ne %gm\n", eqnht, eqnht);
        !           113:                                printf(".rn %d 10\n", eqnreg);
        !           114:                                if (!noeqn)
        !           115:                                        printf("\\&\\*(10\n");
        !           116:                        }
        !           117:                        printf(".EN");
        !           118:                        while (putchar(input()) != '\n')
        !           119:                                ;
        !           120:                        printf(".lf %d\n", curfile->lineno+1);
        !           121:                }
        !           122:                else if (type == lefteq)
        !           123:                        inline();
        !           124:                else if (in[0] == '.' && in[1] == 'l' && in[2] == 'f') {
        !           125:                        if (sscanf(in+3, "%d %s", &ln, fname) == 2) {
        !           126:                                free(curfile->fname);
        !           127:                                printf(".lf %d %s\n", curfile->lineno = ln, curfile->fname = strsave(fname));
        !           128:                        } else
        !           129:                                printf(".lf %d\n", curfile->lineno = ln);
        !           130:                } else
        !           131:                        printf("%s", in);
        !           132:        }
        !           133:        return(0);
        !           134: }
        !           135: 
        !           136: getline(s)
        !           137:        register char *s;
        !           138: {
        !           139:        register c;
        !           140: 
        !           141:        while ((c=input()) != '\n' && c != EOF && c != lefteq) {
        !           142:                if (s >= in+MAXLINE) {
        !           143:                        error("input line too long: %.20s\n", in);
        !           144:                        in[MAXLINE] = '\0';
        !           145:                        break;
        !           146:                }
        !           147:                *s++ = c;
        !           148:        }
        !           149:        if (c != lefteq)
        !           150:                *s++ = c;
        !           151:        *s = '\0';
        !           152:        return(c);
        !           153: }
        !           154: 
        !           155: inline()
        !           156: {
        !           157:        int ds, n, sz1 = 0;
        !           158: 
        !           159:        n = curfile->lineno;
        !           160:        if (szstack[0] != 0)
        !           161:                printf(".nr %d \\n(.s\n", sz1 = salloc());
        !           162:        ds = salloc();
        !           163:        printf(".rm %d \n", ds);
        !           164:        display = 0;
        !           165:        do {
        !           166:                if (*in)
        !           167:                        printf(".as %d \"%s\n", ds, in);
        !           168:                init();
        !           169:                yyparse();
        !           170:                if (eqnreg > 0) {
        !           171:                        printf(".as %d \\*(%d\n", ds, eqnreg);
        !           172:                        sfree(eqnreg);
        !           173:                        printf(".lf %d\n", curfile->lineno+1);
        !           174:                }
        !           175:        } while (getline(in) == lefteq);
        !           176:        if (*in)
        !           177:                printf(".as %d \"%s", ds, in);
        !           178:        if (sz1)
        !           179:                printf("\\s\\n(%d", sz1);
        !           180:        printf("\\*(%d\n", ds);
        !           181:        printf(".lf %d\n", curfile->lineno+1);
        !           182:        if (curfile->lineno > n+3)
        !           183:                fprintf(stderr, "eqn warning: multi-line %c...%c, lines %d-%d, file %s\n",
        !           184:                        lefteq, righteq, n, curfile->lineno, curfile->fname); 
        !           185:        sfree(ds);
        !           186:        if (sz1) sfree(sz1);
        !           187: }
        !           188: 
        !           189: putout(p1)
        !           190:        int p1;
        !           191: {
        !           192:        float before, after;
        !           193:        extern float BeforeSub, AfterSub;
        !           194: 
        !           195:        dprintf(".\tanswer <- S%d, h=%g,b=%g\n",p1, eht[p1], ebase[p1]);
        !           196:        eqnht = eht[p1];
        !           197:        before = eht[p1] - ebase[p1] - BeforeSub;       /* leave room for sub or superscript */
        !           198:        after = ebase[p1] - AfterSub;
        !           199:        if (spaceval || before > 0.01 || after > 0.01) {
        !           200:                printf(".ds %d ", p1);  /* used to be \\x'0' here:  why? */
        !           201:                if (spaceval != NULL)
        !           202:                        printf("\\x'0-%s'", spaceval);
        !           203:                else if (before > 0.01)
        !           204:                        printf("\\x'0-%gm'", before);
        !           205:                printf("\\*(%d", p1);
        !           206:                if (spaceval == NULL && after > 0.01)
        !           207:                        printf("\\x'%gm'", after);
        !           208:                putchar('\n');
        !           209:        }
        !           210:        if (szstack[0] != 0)
        !           211:                printf(".ds %d %s\\*(%d\\s\\n(99\n", p1, DPS(gsize,gsize), p1);
        !           212:        eqnreg = p1;
        !           213:        if (spaceval != NULL) {
        !           214:                free(spaceval);
        !           215:                spaceval = NULL;
        !           216:        }
        !           217: }
        !           218: 
        !           219: init()
        !           220: {
        !           221:        synerr = 0;
        !           222:        ct = 0;
        !           223:        ps = gsize;
        !           224:        ftp = ftstack;
        !           225:        ft = ftp->ft;
        !           226:        nszstack = 0;
        !           227:        if (szstack[0] != 0)    /* absolute gsize in effect */
        !           228:                printf(".nr 99 \\n(.s\n");
        !           229: }
        !           230: 
        !           231: salloc()
        !           232: {
        !           233:        int i;
        !           234: 
        !           235:        for (i = 11; i < 100; i++)
        !           236:                if (used[i] == 0) {
        !           237:                        used[i]++;
        !           238:                        return(i);
        !           239:                }
        !           240:        error(FATAL, "no eqn strings left (%d)", i);
        !           241:        return(0);
        !           242: }
        !           243: 
        !           244: sfree(n)
        !           245:        int n;
        !           246: {
        !           247:        used[n] = 0;
        !           248: }
        !           249: 
        !           250: nrwid(n1, p, n2)
        !           251:        int n1, p, n2;
        !           252: {
        !           253:        printf(".nr %d 0\\w'%s\\*(%d'\n", n1, DPS(gsize,p), n2);        /* 0 defends against - width */
        !           254: }
        !           255: 
        !           256: char *ABSPS(dn)        /* absolute size dn in printable form \sd or \s(dd (dd >= 40) */
        !           257:        int dn;
        !           258: {
        !           259:        static char buf[100], *lb = buf;
        !           260:        char *p;
        !           261: 
        !           262:        if (lb > buf + sizeof(buf) - 10)
        !           263:                lb = buf;
        !           264:        p = lb;
        !           265:        *lb++ = '\\';
        !           266:        *lb++ = 's';
        !           267:        if (dn >= 10) {         /* \s(dd only works in new troff */
        !           268:                if (dn >= 40)
        !           269:                        *lb++ = '(';
        !           270:                *lb++ = dn/10 + '0';
        !           271:                *lb++ = dn%10 + '0';
        !           272:        } else {
        !           273:                *lb++ = dn + '0';
        !           274:        }
        !           275:        *lb++ = '\0';   
        !           276:        return p;
        !           277: }
        !           278: 
        !           279: char *DPS(f, t)        /* delta ps (t-f) in printable form \s+d or \s-d or \s+-(dd */
        !           280:        int f, t;
        !           281: {
        !           282:        static char buf[100], *lb = buf;
        !           283:        char *p;
        !           284:        int dn;
        !           285: 
        !           286:        if (lb > buf + sizeof(buf) - 10)
        !           287:                lb = buf;
        !           288:        p = lb;
        !           289:        *lb++ = '\\';
        !           290:        *lb++ = 's';
        !           291:        dn = EFFPS(t) - EFFPS(f);
        !           292:        if (szstack[nszstack] != 0)     /* absolute */
        !           293:                dn = EFFPS(t);          /* should do proper \s(dd */
        !           294:        else if (dn >= 0)
        !           295:                *lb++ = '+';
        !           296:        else {
        !           297:                *lb++ = '-';
        !           298:                dn = -dn;
        !           299:        }
        !           300:        if (dn >= 10) {         /* \s+(dd only works in new troff */
        !           301:                *lb++ = '(';
        !           302:                *lb++ = dn/10 + '0';
        !           303:                *lb++ = dn%10 + '0';
        !           304:        } else {
        !           305:                *lb++ = dn + '0';
        !           306:        }
        !           307:        *lb++ = '\0';   
        !           308:        return p;
        !           309: }
        !           310: 
        !           311: EFFPS(n)       /* effective value of n */
        !           312:        int n;
        !           313: {
        !           314:        if (n >= minsize)
        !           315:                return n;
        !           316:        else
        !           317:                return minsize;
        !           318: }
        !           319: 
        !           320: double EM(m, ps)       /* convert m to ems in gsize */
        !           321:        double m;
        !           322:        int ps;
        !           323: {
        !           324:        m *= (float) EFFPS(ps) / gsize;
        !           325:        if (m <= 0.001 && m >= -0.001)
        !           326:                return 0;
        !           327:        else
        !           328:                return m;
        !           329: }
        !           330: 
        !           331: double REL(m, ps)      /* convert m to ems in ps */
        !           332:        double m;
        !           333:        int ps;
        !           334: {
        !           335:        m *= (float) gsize / EFFPS(ps);
        !           336:        if (m <= 0.001 && m >= -0.001)
        !           337:                return 0;
        !           338:        else
        !           339:                return m;
        !           340: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.