4.3BSD - /usr/src/new/B/src/bed/gram.c

   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: }

Defined functions

Defined variables

Defined macros