Return to main.c CVS log

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

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

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