Return to text.c CVS log

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

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

1.1     ! root        1: #include "e.h"
        !             2: #include "y.tab.h"
        !             3: #include <ctype.h>
        !             4: 
        !             5: #define        CSSIZE  400
        !             6: char   cs[CSSIZE+20];  /* text string converted into this */
        !             7: char   *csp;           /* next spot in cs[] */
        !             8: char   *psp;           /* next character in input token */
        !             9: 
        !            10: int    lf, rf;         /* temporary spots for left and right fonts */
        !            11: int    lastft;         /* last \f added */
        !            12: int    nextft;         /* next \f to be added */
        !            13: 
        !            14: text(t, p1)    /* convert text string p1 of type t */
        !            15:        int t;
        !            16:        char *p1;
        !            17: {
        !            18:        int c;
        !            19:        char *p;
        !            20:        tbl *tp;
        !            21: 
        !            22:        yyval = salloc();
        !            23:        ebase[yyval] = 0;
        !            24:        eht[yyval] = EM(1.0, ps);       /* ht in ems of orig size */
        !            25:        eps[yyval] = ps;
        !            26:        lfont[yyval] = rfont[yyval] = ROM;
        !            27:        if (t == QTEXT) {
        !            28:                for (p = p1; *p; p++)   /* scan for embedded \f's */
        !            29:                        if (*p == '\\' && *(p+1) == 'f')
        !            30:                                break;
        !            31:                if (*p)         /* if found \f, leave it alone and hope */
        !            32:                        p = p1;
        !            33:                else {
        !            34:                        sprintf(cs, "\\f%s%s\\fP", ftp->name, p1);
        !            35:                        p = cs;
        !            36:                }
        !            37:        } else if (t == SPACE)
        !            38:                p = "\\ ";
        !            39:        else if (t == THIN)
        !            40:                p = "\\|";
        !            41:        else if (t == TAB)
        !            42:                p = "\\t";
        !            43:        else if ((tp = lookup(restbl, p1, NULL)) != NULL) {
        !            44:                p = tp->defn;
        !            45:        } else {
        !            46:                lf = rf = 0;
        !            47:                /* sprintf(cs, "\\f%s", ftp->name); */
        !            48:                lastft = 0;
        !            49:                csp = cs;
        !            50:                for (psp = p1; (c = *psp++) != '\0'; ) {
        !            51:                        nextft = ft;
        !            52:                        rf = trans(c, p1);
        !            53:                        if (lf == 0)
        !            54:                                lf = rf;        /* save first */
        !            55:                        if (csp-cs > CSSIZE)
        !            56:                                error(FATAL,"converted token %.25s... too long",p1);
        !            57:                }
        !            58:                sadd("\\fP");
        !            59:                *csp = '\0';
        !            60:                p = cs;
        !            61:                lfont[yyval] = lf;
        !            62:                rfont[yyval] = rf;
        !            63:        }
        !            64:        dprintf(".\t%dtext: S%d <- %s; b=%g,h=%g,lf=%c,rf=%c,ps=%d\n",
        !            65:                t, yyval, p, ebase[yyval], eht[yyval], lfont[yyval], rfont[yyval], ps);
        !            66:        printf(".ds %d \"%s\n", yyval, p);
        !            67: }
        !            68: 
        !            69: trans(c, p1)
        !            70:        int c;
        !            71:        char *p1;
        !            72: {
        !            73:        int f;
        !            74: 
        !            75:        f = ROM;
        !            76:        switch (c) {
        !            77:        case '0': case '1': case '2': case '3': case '4':
        !            78:        case '5': case '6': case '7': case '8': case '9':
        !            79:        case ':': case ';': case '!': case '%': case '?':
        !            80:        case '(': case '[': case ']':
        !            81:                if (rf == ITAL)
        !            82:                        shim();
        !            83:                roman(c);
        !            84:                break;
        !            85:        case ')':
        !            86:                if (rf == ITAL)
        !            87:                        halfshim();
        !            88:                roman(c);
        !            89:                break;
        !            90:        case ',':
        !            91:                roman(c);
        !            92:                halfshim();
        !            93:                f = rf;
        !            94:                break;
        !            95:        case '.':
        !            96:                if (rf == ROM)
        !            97:                        roman(c);
        !            98:                else
        !            99:                        cadd(c);
        !           100:                f = rf;
        !           101:                break;
        !           102:        case '|':
        !           103:                if (rf == ITAL && ttype != DEV202)
        !           104:                        shim();
        !           105:                shim(); roman(c); shim();
        !           106:                break;
        !           107:        case '=':
        !           108:                if (rf == ITAL)
        !           109:                        shim();
        !           110:                name4('e','q');
        !           111:                break;
        !           112:        case '+':
        !           113:                if (rf == ITAL)
        !           114:                        shim();
        !           115:                name4('p','l');
        !           116:                break;
        !           117:        case '>': case '<':
        !           118:                if (rf == ITAL)
        !           119:                        shim();
        !           120:                if (*psp == '=') {      /* look ahead for == <= >= */
        !           121:                        name4(c,'=');
        !           122:                        psp++;
        !           123:                } else {
        !           124:                        cadd(c);  
        !           125:                }
        !           126:                break;
        !           127:        case '-':
        !           128:                if (rf == ITAL)
        !           129:                        shim();
        !           130:                if (*psp == '>') {
        !           131:                        name4('-','>');
        !           132:                        halfshim();
        !           133:                        psp++;
        !           134:                } else {
        !           135:                        name4('m','i');
        !           136:                }
        !           137:                break;
        !           138:        case '/':
        !           139:                halfshim();
        !           140:                cadd('/');
        !           141:                halfshim();
        !           142:                break;
        !           143:        case '~': case ' ':
        !           144:                shim(); shim();
        !           145:                break;
        !           146:        case '^':
        !           147:                shim();
        !           148:                break;
        !           149:        case '\\':      /* troff - pass only \(xx without comment */
        !           150:                if (rf == ITAL)
        !           151:                        shim();
        !           152:                cadd('\\');
        !           153:                cadd(c = *psp++);
        !           154:                if (c == '(' && *psp && *(psp+1)) {
        !           155:                        cadd(*psp++);
        !           156:                        cadd(*psp++);
        !           157:                } else
        !           158:                        fprintf(stderr, "eqn warning: unquoted troff command \\%c, line %d, file %s\n",
        !           159:                                c, curfile->lineno, curfile->fname);
        !           160:                break;
        !           161:        case '\'':
        !           162:                name4('f','m');
        !           163:                break;
        !           164: 
        !           165:        case 'f':
        !           166:                if (ft == ITAL) {
        !           167:                        if (psp == p1+1 || !isalnum(*(psp-2)))
        !           168:                                halfshim();
        !           169:                        cadd('f');
        !           170:                        if (!isalpha(*psp) && *psp != '\0')     /* add \| except in text */
        !           171:                                shim();
        !           172:                        f = ITAL;
        !           173:                }
        !           174:                else
        !           175:                        cadd('f');
        !           176:                break;
        !           177:        case 'j':
        !           178:                if (ft == ITAL) {
        !           179:                        sadd("\\^j");
        !           180:                        f = ITAL;
        !           181:                }
        !           182:                else
        !           183:                        cadd('j');
        !           184:                break;
        !           185:        default:
        !           186:                cadd(c);
        !           187:                f = ft==ITAL ? ITAL : ROM;
        !           188:                break;
        !           189:        }
        !           190:        return(f);
        !           191: }
        !           192: 
        !           193: shim() /* add a \| space */
        !           194: {
        !           195:        sadd("\\|");
        !           196: }
        !           197: 
        !           198: halfshim()     /* add a \^ space */
        !           199: {
        !           200:        sadd("\\^");
        !           201: }
        !           202: 
        !           203: roman(c)       /* add char c in "roman" font */
        !           204:        int c;
        !           205: {
        !           206:        nextft = ROM;
        !           207:        cadd(c);
        !           208: }
        !           209: 
        !           210: name4(c1,c2)
        !           211:        int c1, c2;
        !           212: {
        !           213:        sadd("\\(");
        !           214:        cadd(c1);
        !           215:        cadd(c2);
        !           216: }
        !           217: 
        !           218: sadd(s)                /* add string s to cs */
        !           219:        char *s;
        !           220: {
        !           221:        while (*s)
        !           222:                cadd(*s++);
        !           223: }
        !           224: 
        !           225: cadd(c)                /* add char c to end of cs */
        !           226:        int c;
        !           227: {
        !           228:        char *p;
        !           229: 
        !           230:        if (lastft != nextft) {
        !           231:                if (lastft != 0) {
        !           232:                        *csp++ = '\\';
        !           233:                        *csp++ = 'f';
        !           234:                        *csp++ = 'P';
        !           235:                }
        !           236:                *csp++ = '\\';
        !           237:                *csp++ = 'f';
        !           238:                if (ftp == ftstack) {   /* bottom level */
        !           239:                        if (ftp->ft == ITAL)    /* usual case */
        !           240:                                *csp++ = nextft;
        !           241:                        else            /* gfont set, use it */
        !           242:                                for (p = ftp->name; *csp = *p++; )
        !           243:                                        csp++;
        !           244:                } else {        /* inside some kind of font ... */
        !           245:                        for (p = ftp->name; *csp = *p++; )
        !           246:                                csp++;
        !           247:                }
        !           248:                lastft = nextft;
        !           249:        }
        !           250:        *csp++ = c;
        !           251: }

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