Return to main.c CVS log

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

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

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

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