Return to auto.c CVS log

Up to [MW Coherent from dump] / coherent / a / usr / src / libl

Annotation of coherent/a/usr/src/libl/auto.c, revision 1.1

1.1     ! root        1: /* (-lgl
        !             2:  *     COHERENT Version 3.1
        !             3:  *     Copyright (c) 1982, 1990 by Mark Williams Company.
        !             4:  *     All rights reserved. May not be copied without permission.
        !             5:  -lgl) */
        !             6: #include "lexlib.h"
        !             7: #include "lextype.h"
        !             8: 
        !             9: char   yytext[YYTSIZE];
        !            10: struct ll_queue ll_tq;
        !            11: int *ll_ctxt = yy_lextab;
        !            12: int    ll_cc;
        !            13: int    ll_lc = '\n';
        !            14: int    ll_tf;
        !            15: int    ll_lf;
        !            16: int    ll_tokn;
        !            17: int    ll_tlen;
        !            18: int    ll_more;
        !            19: int    yyscon;
        !            20: int    yyleng;
        !            21: int    yyline;
        !            22: 
        !            23: char   inpovf[] = "input buffer overflow";
        !            24: char   yytovf[] = "yytext overflow";
        !            25: 
        !            26: _lltk()
        !            27: {
        !            28:        ll_tlen = 0;
        !            29:        ll_tokn = MAXINT;
        !            30:        {
        !            31:                register int **clist, **nlist, **llist;
        !            32:                register int **tlist;
        !            33:                register c;
        !            34: 
        !            35:                clist = yy_clist;
        !            36:                nlist = yy_nlist;
        !            37:                llist = yy_llist;
        !            38:        loop:
        !            39:                ll_cc = 0;
        !            40:                *clist++ = ll_ctxt;
        !            41:                *clist-- = NULL;
        !            42:                do {
        !            43:                        _llex(ll_cc, clist, nlist, llist);
        !            44:                        tlist = nlist;
        !            45:                        nlist = clist;
        !            46:                        clist = tlist;
        !            47:                        *nlist = NULL;
        !            48:                        if (*llist != NULL) {
        !            49:                                c = ll_cc;
        !            50:                                do {
        !            51:                                        _llex(c, llist, nlist, llist);
        !            52:                                        tlist = nlist;
        !            53:                                        nlist = llist;
        !            54:                                        llist = tlist;
        !            55:                                        *nlist = NULL;
        !            56:                                        ++c;
        !            57:                                } while (*llist != NULL);
        !            58:                        }
        !            59:                        ++ll_cc;
        !            60:                } while (*clist != NULL);
        !            61:                ll_tf = 0;
        !            62:                if (ll_tokn == MAXINT) {
        !            63:                        if ((c=(qct(ll_tq)?qgt(ll_tq):_llic())) == EOF) {
        !            64:                                ll_lc = '\n';
        !            65:                                return (0);
        !            66:                        }
        !            67:                        ll_lc = c;
        !            68:                        _lloc(c);
        !            69:                        goto loop;
        !            70:                }
        !            71:        }
        !            72:        {
        !            73:                register char *pc;
        !            74:                register i;
        !            75: 
        !            76:                pc = yytext;
        !            77:                if (ll_more) {
        !            78:                        pc += yyleng;
        !            79:                        ll_more = 0;
        !            80:                } else {
        !            81:                        yyleng = 0;
        !            82:                }
        !            83:                i = ll_tlen;
        !            84:                if ((yyleng += i) > sizeof(yytext))
        !            85:                                error(yytovf);
        !            86:                while (i--)
        !            87:                        *pc++ = qgt(ll_tq);
        !            88:                *pc = '\0';
        !            89:                if (pc-- > yytext)
        !            90:                        ll_lc = *pc;
        !            91:        }
        !            92:        return (ll_tokn);
        !            93: }
        !            94: 
        !            95: _llex(n, clist, nlist, llist)
        !            96: int **clist, **nlist, **llist;
        !            97: {
        !            98:        register int **listp, *statep;
        !            99:        register int c;
        !           100:        register int **clistp;
        !           101: 
        !           102:        c = MAXUCHAR + 1;
        !           103:        clistp = clist;
        !           104:        while ((statep=*clistp++) != NULL) {
        !           105:                switch (*statep & LR_MASK) {
        !           106:                _list:
        !           107:                        while (*listp != statep)
        !           108:                                if (*listp++ == NULL) {
        !           109:                                        *listp-- = NULL;
        !           110:                                        *listp = statep;
        !           111:                                        break;
        !           112:                                }
        !           113:                        break;
        !           114:                _look:
        !           115:                        --clistp;
        !           116:                        if (qct(ll_tq) <= n)
        !           117:                                if (n >= QSIZE)
        !           118:                                        error(inpovf);
        !           119:                                else
        !           120:                                        qpt(ll_tq, c=_llic());
        !           121:                        else
        !           122:                                c = qlk(ll_tq, n);
        !           123:                        break;
        !           124:                case LX_STOP:
        !           125:                        break;
        !           126:                case LX_LINK:
        !           127:                        ++statep;
        !           128:                        listp = clist;
        !           129:                        while (*listp != statep)
        !           130:                                if (*listp++ == NULL) {
        !           131:                                        *listp-- = NULL;
        !           132:                                        *listp = statep;
        !           133:                                        break;
        !           134:                                }
        !           135:                        --statep;
        !           136:                case LX_JUMP:
        !           137:                        statep += *statep >> LR_SHFT;
        !           138:                        listp = clist;
        !           139:                        goto _list;
        !           140:                case LX_LOOK:
        !           141:                        ++statep;
        !           142:                        listp = llist;
        !           143:                        goto _list;
        !           144:                case LX_ACPT:
        !           145:                        if ((*statep>>LR_SHFT)<ll_tokn || ll_cc>ll_tlen)
        !           146:                                if (ll_tf == 0
        !           147:                                ||  ll_cc < ll_lf
        !           148:                                ||  ll_tf > *statep
        !           149:                                   ){
        !           150:                                        ll_tokn = (*statep>>LR_SHFT);
        !           151:                                        ll_tlen = ll_cc;
        !           152:                                }
        !           153:                        break;
        !           154:                case LX_CHAR:
        !           155:                        if (c > MAXUCHAR)
        !           156:                                goto _look;
        !           157:                        if (c == (*statep++>>LR_SHFT)) {
        !           158:                                listp = nlist;
        !           159:                                goto _list;
        !           160:                        }
        !           161:                        break;
        !           162:                case LX_CLAS:
        !           163:                        if (c > MAXUCHAR)
        !           164:                                goto _look;
        !           165:                        if (c & ~MAXUCHAR)
        !           166:                                break;
        !           167:                        if (yy_lxctab[(*statep>>LR_SHFT)*((MAXUCHAR+1)/NBINT)
        !           168:                            +(c/NBINT)] & yy_lxbtab[c&((1<<LOGINT)-1)]) {
        !           169:                                ++statep;
        !           170:                                listp = nlist;
        !           171:                                goto _list;
        !           172:                        }
        !           173:                        break;
        !           174:                case LX_BLIN:
        !           175:                        if (ll_lc == '\n') {
        !           176:                                ++statep;
        !           177:                                listp = clist;
        !           178:                                goto _list;
        !           179:                        }
        !           180:                        break;
        !           181:                case LX_ELIN:
        !           182:                        if (c > MAXUCHAR)
        !           183:                                goto _look;
        !           184:                        if (c=='\n' || c==EOF) {
        !           185:                                ++statep;
        !           186:                                listp = clist;
        !           187:                                goto _list;
        !           188:                        }
        !           189:                        break;
        !           190:                case LX_ANYC:
        !           191:                        if (c > MAXUCHAR)
        !           192:                                goto _look;
        !           193:                        if (c!='\n' && c!=EOF) {
        !           194:                                ++statep;
        !           195:                                listp = nlist;
        !           196:                                goto _list;
        !           197:                        }
        !           198:                        break;
        !           199:                case LX_SCON:
        !           200:                        if (yyscon == (*statep++>>LR_SHFT)) {
        !           201:                                listp = clist;
        !           202:                                goto _list;
        !           203:                        }
        !           204:                        break;
        !           205:                }
        !           206:        }
        !           207: }

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