Return to gram.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / B / src / bed

Annotation of 43BSD/contrib/B/src/bed/gram.c, revision 1.1

1.1     ! root        1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
        !             2: static char rcsid[] = "$Header: gram.c,v 2.5 85/08/22 16:03:16 timo Exp $";
        !             3: 
        !             4: /*
        !             5:  * B editor -- All routines referencing the grammar table are in this file.
        !             6:  */
        !             7: 
        !             8: #include "b.h"
        !             9: #include "feat.h"
        !            10: #include "bobj.h"
        !            11: #include "node.h"
        !            12: #include "gram.h"
        !            13: #include "supr.h"
        !            14: #include "tabl.h"
        !            15: 
        !            16: extern bool dflag;
        !            17: 
        !            18: #include <ctype.h>
        !            19: 
        !            20: 
        !            21: /*
        !            22:  * Test whether sym is in the given class.
        !            23:  */
        !            24: 
        !            25: Visible bool
        !            26: isinclass(sym, ci)
        !            27:        register int sym;
        !            28:        struct classinfo *ci;
        !            29: {
        !            30:        register classptr cp;
        !            31: 
        !            32:        Assert(ci && ci->c_class);
        !            33:        if (sym == Hole)
        !            34:                return !isinclass(Optional, ci);
        !            35:        for (cp = ci->c_class; *cp; ++cp)
        !            36:                if (sym == *cp)
        !            37:                        return Yes;
        !            38:        return No;
        !            39: }
        !            40: 
        !            41: 
        !            42: /*
        !            43:  * Deliver the representation array for the given node.
        !            44:  * If the node is actually just a "text" value, construct
        !            45:  * one in static storage -- which is overwritten at each call.
        !            46:  * In this case there are two deficiencies: the next call to
        !            47:  * noderepr which uses the same feature overwrites the reply
        !            48:  * value of the previous call, AND if the text value itself
        !            49:  * is changed, the representation may change, too.
        !            50:  * In practical use this is no problem at all, however.
        !            51:  */
        !            52: 
        !            53: Visible string *
        !            54: noderepr(n)
        !            55:        register node n;
        !            56: {
        !            57:        register int sym;
        !            58: 
        !            59:        if (n && Type(n) == Tex) {
        !            60:                static string buf[2];
        !            61:                buf[0] = Str((value)n);
        !            62:                return buf;
        !            63:        }
        !            64:        sym = symbol(n);
        !            65:        return table[sym].r_repr;
        !            66: }
        !            67: 
        !            68: 
        !            69: /*
        !            70:  * Deliver the prototype node for the given symbol.
        !            71:  */
        !            72: 
        !            73: Visible node
        !            74: gram(sym)
        !            75:        register int sym;
        !            76: {
        !            77:        Assert(sym == 0 || sym > 0 && sym < TABLEN && table[sym].r_symbol);
        !            78:        return table[sym].r_node;
        !            79: }
        !            80: 
        !            81: #ifdef SAVEBUF
        !            82: 
        !            83: /*
        !            84:  * Deliver the name of a symbol.
        !            85:  */
        !            86: 
        !            87: Visible string
        !            88: symname(sym)
        !            89:        int sym;
        !            90: {
        !            91:        static char buf[20];
        !            92: 
        !            93:        if (sym >= 0 && sym < TABLEN && table[sym].r_name)
        !            94:                return table[sym].r_name;
        !            95:        sprintf(buf, "%d", sym);
        !            96:        return buf;
        !            97: }
        !            98: 
        !            99: 
        !           100: /*
        !           101:  * Find the symbol corresponding to a given name.
        !           102:  * Return -1 if not found.
        !           103:  */
        !           104: 
        !           105: Visible int
        !           106: nametosym(str)
        !           107:        register string str;
        !           108: {
        !           109:        register int sym;
        !           110:        register string name;
        !           111: 
        !           112:        for (sym = 0; sym < TABLEN; ++sym) {
        !           113:                name = table[sym].r_name;
        !           114:                if (name && Strequ(name, str))
        !           115:                        return sym;
        !           116:        }
        !           117:        return -1;
        !           118: }
        !           119: 
        !           120: #endif SAVEBUF
        !           121: 
        !           122: /*
        !           123:  * Test whether `sym' may replace the node in the path `p'.
        !           124:  */
        !           125: 
        !           126: Visible bool
        !           127: allowed(p, sym)
        !           128:        register path p;
        !           129:        register int sym;
        !           130: {
        !           131:        register path pa = parent(p);
        !           132:        register int ich = ichild(p);
        !           133:        register int sympa = pa ? symbol(tree(pa)) : Rootsymbol;
        !           134: 
        !           135:        Assert(sympa >= 0 && sympa < TABLEN && ich > 0 && ich <= MAXCHILD);
        !           136:        return isinclass(sym, table[sympa].r_class[ich-1]);
        !           137: }
        !           138: 
        !           139: 
        !           140: /*
        !           141:  * Initialize (and verify) the grammar table.
        !           142:  */
        !           143: 
        !           144: Visible Procedure
        !           145: initgram()
        !           146: {
        !           147:        register int sym;
        !           148:        register int nch;
        !           149:        register struct classinfo **cp;
        !           150:        register struct classinfo *sp;
        !           151:        node ch[MAXCHILD];
        !           152: 
        !           153: #ifndef NDEBUG
        !           154:        if (dflag)
        !           155:                fprintf(stderr, "*** initgram();\n\r");
        !           156: #endif NDEBUG
        !           157:        /* Set the node pointers in the table and check the representations.
        !           158:           The code assumes Optional and Hole are the last
        !           159:           symbols in the table, i.e. the first processed by the loop. */
        !           160: 
        !           161:        for (sym = TABLEN-1; sym >= 0; --sym) {
        !           162:                if (table[sym].r_symbol != sym) {
        !           163:                        if (sym != Hole && sym != Optional && table[sym].r_symbol == 0)
        !           164:                                continue; /* Disabled table entry */
        !           165:                        syserr("initgram: table order (%s=%d, should be %d)",
        !           166:                                table[sym].r_name, table[sym].r_symbol, sym);
        !           167:                }
        !           168:                cp = table[sym].r_class;
        !           169:                for (nch = 0; nch < MAXCHILD && (sp = cp[nch]); ++nch)
        !           170:                        ch[nch] =
        !           171:                                table[sp->c_class[0] == Optional ?
        !           172:                                        Optional : Hole].r_node;
        !           173:                table[sym].r_node = newnode(nch, sym, ch);
        !           174:                fix((value) table[sym].r_node);
        !           175:        }
        !           176: 
        !           177:        initcodes();
        !           178: #ifdef USERSUGG
        !           179:        initclasses();
        !           180: #endif USERSUGG
        !           181: }
        !           182: 
        !           183: 
        !           184: #ifdef USERSUGG
        !           185: 
        !           186: /*
        !           187:  * Add built-in commands to the suggestion tables.
        !           188:  */
        !           189: 
        !           190: Hidden Procedure
        !           191: initclasses()
        !           192: {
        !           193:        register int i;
        !           194:        register int j;
        !           195:        register struct table *tp;
        !           196: 
        !           197:        for (i = 0; i < TABLEN; ++i) {
        !           198:                tp = &table[i];
        !           199:                if (tp->r_symbol != i || i == Suggestion)
        !           200:                        continue; /* Dead entry */
        !           201:                for (j = 0; j < MAXCHILD && tp->r_class[j]; ++j) {
        !           202:                        if (isinclass(Suggestion, tp->r_class[j]))
        !           203:                                makesugg(tp->r_class[j]->c_class);
        !           204:                }
        !           205:        }
        !           206: }
        !           207: 
        !           208: 
        !           209: /*
        !           210:  * Extract suggestions from class list.
        !           211:  */
        !           212: 
        !           213: Hidden Procedure
        !           214: makesugg(cp)
        !           215:        classptr cp;
        !           216: {
        !           217:        struct table *tp;
        !           218:        string *rp;
        !           219:        char buffer[1000];
        !           220:        string bp;
        !           221:        string sp;
        !           222:        int i;
        !           223:        int nch;
        !           224: 
        !           225:        for (; *cp; ++cp) {
        !           226:                if (*cp >= TABLEN || *cp < 0)
        !           227:                        continue;
        !           228:                tp = &table[*cp];
        !           229:                rp = tp->r_repr;
        !           230:                if (rp[0] && isupper(rp[0][0])) {
        !           231:                        bp = buffer;
        !           232:                        nch = nchildren(tp->r_node);
        !           233:                        for (i = 0; i <= nch; ++i) {
        !           234:                                if (rp[i]) {
        !           235:                                        for (sp = rp[i]; *sp >= ' '; ++sp)
        !           236:                                                *bp++ = *sp;
        !           237:                                }
        !           238:                                if (i < nch && !isinclass(Optional, tp->r_class[i]))
        !           239:                                        *bp++ = '?';
        !           240:                        }
        !           241:                        if (bp > buffer) {
        !           242:                                *bp = 0;
        !           243:                                addsugg(buffer, Yes);
        !           244:                        }
        !           245:                }
        !           246:        }
        !           247: }
        !           248: 
        !           249: #endif USERSUGG
        !           250: 
        !           251: 
        !           252: /*
        !           253:  * Compaction scheme for characters to save space in grammar tables
        !           254:  * by combining characters with similar properties (digits, l.c. letters).
        !           255:  */
        !           256: 
        !           257: #define RANGE 128 /* ASCII characters are in {0 .. RANGE-1} */
        !           258: 
        !           259: Visible char code_array[RANGE];
        !           260: Visible char invcode_array[RANGE];
        !           261: Visible int lastcode;
        !           262: 
        !           263: Hidden Procedure
        !           264: initcodes()
        !           265: {
        !           266:        register int c;
        !           267: 
        !           268:        code_array['\n'] = ++lastcode;
        !           269:        invcode_array[lastcode] = '\n';
        !           270:        for (c = ' '; c <= '0'; ++c) {
        !           271:                code_array[c] = ++lastcode;
        !           272:                invcode_array[lastcode] = c;
        !           273:        }
        !           274:        for (; c <= '9'; ++c)
        !           275:                code_array[c] = lastcode;
        !           276:        for (; c <= 'a'; ++c) {
        !           277:                code_array[c] = ++lastcode;
        !           278:                invcode_array[lastcode] = c;
        !           279:        }
        !           280:        for (; c <= 'z'; ++c)
        !           281:                code_array[c] = lastcode;
        !           282:        for (; c < RANGE; ++c) {
        !           283:                code_array[c] = ++lastcode;
        !           284:                invcode_array[lastcode] = c;
        !           285:        }
        !           286: }
        !           287: 
        !           288: 
        !           289: /*
        !           290:  * Set the root of the grammar to the given symbol.  It must exist.
        !           291:  */
        !           292: 
        !           293: Visible Procedure
        !           294: setroot(name)
        !           295:        string name;
        !           296: {
        !           297:        register int k;
        !           298:        register int i;
        !           299: 
        !           300:        for (k = 1; k < TABLEN; ++k) {
        !           301:                if (table[k].r_name && Strequ(name, table[k].r_name)) {
        !           302:                        table[Rootsymbol].r_symbol = table[k].r_symbol;
        !           303:                        table[Rootsymbol].r_name = table[k].r_name;
        !           304:                        for (i = 0; i < MAXCHILD; ++i) {
        !           305:                                table[Rootsymbol].r_repr[i] = table[k].r_repr[i];
        !           306:                                table[Rootsymbol].r_class[i] = table[k].r_class[i];
        !           307:                        }
        !           308:                        table[Rootsymbol].r_repr[i] = table[k].r_repr[i];
        !           309:                        table[Rootsymbol].r_node = table[k].r_node;
        !           310:                        table[Rootsymbol].r_symbol = Rootsymbol;
        !           311:                        return;
        !           312:                }
        !           313:        }
        !           314:        syserr("Can't set root of grammar to <%s>", name);
        !           315: }
        !           316: 
        !           317: 
        !           318: /*
        !           319:  * The remainder of this file is specific for the currently used grammar.
        !           320:  */
        !           321: 
        !           322: 
        !           323: #include "boot.h" /* Has static data, so should be included only once! */
        !           324: #include "syms.h"
        !           325: 
        !           326: Visible struct table *table = b_grammar;
        !           327: 
        !           328: 
        !           329: /*
        !           330:  * Table indicating which symbols are used to form lists of items.
        !           331:  * Consulted via predicate 'issublist' in "gram.c".
        !           332:  */
        !           333: 
        !           334: Hidden classelem Asublists[] = {
        !           335:        E_plus, F_e_plus, 
        !           336:        And, And_kw, Or, Or_kw,
        !           337:        0,
        !           338: };
        !           339: 
        !           340: Hidden struct classinfo sublists[] = {Asublists};
        !           341: 
        !           342: 
        !           343: /*
        !           344:  * Predicate telling whether two symbols can form lists together.
        !           345:  * This is important for list whose elements must alternate in some
        !           346:  * way, as is the case for [KEYWORD [expression] ]*.
        !           347:  *
        !           348:  * This code must be in this file, otherwise the names and values
        !           349:  * of the symbols would have to be made public.
        !           350:  */
        !           351: 
        !           352: Visible bool
        !           353: samelevel(sym, sym1)
        !           354:        register int sym;
        !           355:        register int sym1;
        !           356: {
        !           357:        register int zzz;
        !           358: 
        !           359:        if (sym1 == sym)
        !           360:                return Yes;
        !           361:        if (sym1 < sym)
        !           362:                zzz = sym, sym = sym1, sym1 = zzz; /* Ensure sym <= sym1 */
        !           363:        /* Now always sym < sym1 */
        !           364:        return sym == Kw_plus && sym1 == E_plus
        !           365:                || sym == F_kw_plus && sym1 == F_e_plus
        !           366:                || sym == And && sym1 == And_kw
        !           367:                || sym == Or && sym1 == Or_kw;
        !           368: }
        !           369: 
        !           370: 
        !           371: /*
        !           372:  * Predicate to tell whether a symbol can form chained lists.
        !           373:  * By definition, all right-recursive symbols can do so;
        !           374:  * in addition, those listed in the class 'sublists' can do
        !           375:  * it, too (this is used for lists formed of alternating members
        !           376:  * such as KW expr KW ...).
        !           377:  */
        !           378: 
        !           379: Visible bool
        !           380: issublist(sym)
        !           381:        register int sym;
        !           382: {
        !           383:        register int i;
        !           384:        register string repr;
        !           385: 
        !           386:        Assert(sym < TABLEN);
        !           387:        if (isinclass(sym, sublists))
        !           388:                return Yes;
        !           389:        repr = table[sym].r_repr[0];
        !           390:        if (Fw_positive(repr))
        !           391:                return No;
        !           392:        for (i = 0; i < MAXCHILD && table[sym].r_class[i]; ++i)
        !           393:                ;
        !           394:        if (i <= 0)
        !           395:                return No;
        !           396:        repr = table[sym].r_repr[i];
        !           397:        if (!Fw_zero(repr))
        !           398:                return No;
        !           399:        return isinclass(sym, table[sym].r_class[i-1]);
        !           400: }

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