utils/Burg/plank.c

   1 char rcsid_plank[] = "$Id$";
   2
   3 #include <stdio.h>
   4 #include <string.h>
   5 #include <stdlib.h>
   6 #include "b.h"
   7 #include "fe.h"
   8
   9 #define ERROR_VAL 0
  10
  11 int speedflag = 0;
  12
  13 Item_Set *sortedStates;
  14 static struct stateMapTable smt;
  15 int exceptionTolerance = 0;
  16 static int plankSize = 32;
  17
  18 static Plank newPlank ARGS((void));
  19 static PlankMap newPlankMap ARGS((int));
  20 static StateMap newStateMap ARGS((void));
  21 static Exception newException ARGS((int, int));
  22 static void enterStateMap ARGS((PlankMap, short *, int, int *));
  23 static List assemblePlanks ARGS((void));
  24 static void assignRules ARGS((RuleAST));
  25 static int stateCompare ARGS((Item_Set *, Item_Set *));
  26 static int ruleCompare ARGS((RuleAST *, RuleAST *));
  27 static void renumber ARGS((void));
  28 static short * newVector ARGS((void));
  29 static int width ARGS((int));
  30 static PlankMap mapToPmap ARGS((Dimension));
  31 static void doDimPmaps ARGS((Operator));
  32 static void doNonTermPmaps ARGS((NonTerminal));
  33 static void makePmaps ARGS((void));
  34 static void outPlank ARGS((Plank));
  35 static void purgePlanks ARGS((List));
  36 static void inToEx ARGS((void));
  37 static void makePlankRuleMacros ARGS((void));
  38 static void makePlankRule ARGS((void));
  39 static void exceptionSwitch ARGS((List, const char *, const char *, const char *, int, const char *));
  40 static void doPlankLabel ARGS((Operator));
  41 static void doPlankLabelSafely ARGS((Operator));
  42 static void doPlankLabelMacrosSafely ARGS((Operator));
  43 static void makePlankState ARGS((void));
  44
  45 static Plank
  46 newPlank()
  47 {
  48         Plank p;
  49         char buf[50];
  50         static int num = 0;
  51
  52         p = (Plank) zalloc(sizeof(struct plank));
  53         sprintf(buf, "%s_plank_%d", prefix, num++);
  54         p->name = (char *) zalloc(strlen(buf)+1);
  55         strcpy(p->name, buf);
  56         return p;
  57 }
  58
  59 static PlankMap
  60 newPlankMap(offset) int offset;
  61 {
  62         PlankMap im;
  63
  64         im = (PlankMap) zalloc(sizeof(struct plankMap));
  65         im->offset = offset;
  66         return im;
  67 }
  68
  69 static StateMap
  70 newStateMap()
  71 {
  72         char buf[50];
  73         static int num = 0;
  74
  75         StateMap sm;
  76
  77         sm = (StateMap) zalloc(sizeof(struct stateMap));
  78         sprintf(buf, "f%d", num++);
  79         sm->fieldname = (char *) zalloc(strlen(buf)+1);
  80         strcpy(sm->fieldname, buf);
  81         return sm;
  82 }
  83
  84 static Exception
  85 newException(index, value) int index; int value;
  86 {
  87         Exception e;
  88
  89         e = (Exception) zalloc(sizeof(struct except));
  90         e->index = index;
  91         e->value = value;
  92         return e;
  93 }
  94
  95 static void
  96 enterStateMap(im, v, width, new) PlankMap im; short * v; int width; int *new;
  97 {
  98         int i;
  99         StateMap sm;
 100         List l;
 101         int size;
 102
 103         assert(im);
 104         assert(v);
 105         assert(width > 0);
 106         size = globalMap->count;
 107
 108         for (l = smt.maps; l; l = l->next) {
 109                 int ecount;
 110
 111                 sm = (StateMap) l->x;
 112                 ecount = 0;
 113                 for (i = 0; i < size; i++) {
 114                         if (v[i] != -1 && sm->value[i] != -1 && v[i] != sm->value[i]) {
 115                                 if (++ecount > exceptionTolerance) {
 116                                         goto again;
 117                                 }
 118                         }
 119                 }
 120                 for (i = 0; i < size; i++) {
 121                         assert(v[i] >= 0);
 122                         assert(sm->value[i] >= 0);
 123                         if (v[i] == -1) {
 124                                 continue;
 125                         }
 126                         if (sm->value[i] == -1) {
 127                                 sm->value[i] = v[i];
 128                         } else if (v[i] != sm->value[i]) {
 129                                 im->exceptions = newList(newException(i,v[i]), im->exceptions);
 130                         }
 131                 }
 132                 im->values = sm;
 133                 if (width > sm->width) {
 134                         sm->width = width;
 135                 }
 136                 *new = 0;
 137                 return;
 138         again: ;
 139         }
 140         sm = newStateMap();
 141         im->values = sm;
 142         sm->value = v;
 143         sm->width = width;
 144         *new = 1;
 145         smt.maps = newList(sm, smt.maps);
 146 }
 147
 148 static List
 149 assemblePlanks()
 150 {
 151         List planks = 0;
 152         Plank pl;
 153         List p;
 154         List s;
 155
 156         for (s = smt.maps; s; s = s->next) {
 157                 StateMap sm = (StateMap) s->x;
 158                 for (p = planks; p; p = p->next) {
 159                         pl = (Plank) p->x;
 160                         if (sm->width <= plankSize - pl->width) {
 161                                 pl->width += sm->width;
 162                                 pl->fields = newList(sm, pl->fields);
 163                                 sm->plank = pl;
 164                                 goto next;
 165                         }
 166                 }
 167                 pl = newPlank();
 168                 pl->width = sm->width;
 169                 pl->fields = newList(sm, 0);
 170                 sm->plank = pl;
 171                 planks = appendList(pl, planks);
 172         next: ;
 173         }
 174         return planks;
 175 }
 176
 177 RuleAST *sortedRules;
 178
 179 static int count;
 180
 181 static void
 182 assignRules(ast) RuleAST ast;
 183 {
 184         sortedRules[count++] = ast;
 185 }
 186
 187 static int
 188 stateCompare(s, t) Item_Set *s; Item_Set *t;
 189 {
 190         return strcmp((*s)->op->name, (*t)->op->name);
 191 }
 192
 193 static int
 194 ruleCompare(s, t) RuleAST *s; RuleAST *t;
 195 {
 196         return strcmp((*s)->lhs, (*t)->lhs);
 197 }
 198
 199 void
 200 dumpSortedStates()
 201 {
 202         int i;
 203
 204         printf("dump Sorted States: ");
 205         for (i = 0; i < globalMap->count; i++) {
 206                 printf("%d ", sortedStates[i]->num);
 207         }
 208         printf("\n");
 209 }
 210
 211 void
 212 dumpSortedRules()
 213 {
 214         int i;
 215
 216         printf("dump Sorted Rules: ");
 217         for (i = 0; i < max_ruleAST; i++) {
 218                 printf("%d ", sortedRules[i]->rule->erulenum);
 219         }
 220         printf("\n");
 221 }
 222
 223 static void
 224 renumber()
 225 {
 226         int i;
 227         Operator previousOp;
 228         NonTerminal previousLHS;
 229         int base_counter;
 230
 231         sortedStates = (Item_Set*) zalloc(globalMap->count * sizeof(Item_Set));
 232         for (i = 1; i < globalMap->count; i++) {
 233                 sortedStates[i-1] = globalMap->set[i];
 234         }
 235         qsort(sortedStates, globalMap->count-1, sizeof(Item_Set), (int(*)(const void *, const void *))stateCompare);
 236         previousOp = 0;
 237         for (i = 0; i < globalMap->count-1; i++) {
 238                 sortedStates[i]->newNum = i;
 239                 sortedStates[i]->op->stateCount++;
 240                 if (previousOp != sortedStates[i]->op) {
 241                         sortedStates[i]->op->baseNum = i;
 242                         previousOp = sortedStates[i]->op;
 243                 }
 244         }
 245
 246         sortedRules = (RuleAST*) zalloc(max_ruleAST * sizeof(RuleAST));
 247         count = 0;
 248         foreachList((ListFn) assignRules, ruleASTs);
 249         qsort(sortedRules, max_ruleAST, sizeof(RuleAST), (int(*)(const void *, const void *))ruleCompare);
 250         previousLHS = 0;
 251         base_counter = 0;
 252         for (i = 0; i < max_ruleAST; i++) {
 253                 if (previousLHS != sortedRules[i]->rule->lhs) {
 254                         sortedRules[i]->rule->lhs->baseNum = base_counter;
 255                         previousLHS = sortedRules[i]->rule->lhs;
 256                         base_counter++; /* make space for 0 */
 257                 }
 258                 sortedRules[i]->rule->newNum = base_counter;
 259                 sortedRules[i]->rule->lhs->ruleCount++;
 260                 sortedRules[i]->rule->lhs->sampleRule = sortedRules[i]->rule; /* kludge for diagnostics */
 261                 base_counter++;
 262         }
 263 }
 264
 265 static short *
 266 newVector()
 267 {
 268         short *p;
 269         p = (short *) zalloc(globalMap->count* sizeof(short));
 270         return p;
 271 }
 272
 273 static int
 274 width(v) int v;
 275 {
 276         int c;
 277
 278         for (c = 0; v; v >>= 1) {
 279                 c++;
 280         }
 281         return c;
 282
 283 }
 284
 285 static PlankMap
 286 mapToPmap(d) Dimension d;
 287 {
 288         PlankMap im;
 289         short *v;
 290         int i;
 291         int new;
 292
 293         if (d->map->count == 1) {
 294                 return 0;
 295         }
 296         assert(d->map->count > 1);
 297         im = newPlankMap(0);
 298         v = newVector();
 299         for (i = 0; i < globalMap->count-1; i++) {
 300                 int index = d->map->set[d->index_map.class[sortedStates[i]->num]->num]->num;
 301                 assert(index >= 0);
 302                 v[i+1] = index;
 303         }
 304         v[0] = 0;
 305         enterStateMap(im, v, width(d->map->count), &new);
 306         if (!new) {
 307                 zfree(v);
 308         }
 309         return im;
 310 }
 311
 312 static void
 313 doDimPmaps(op) Operator op;
 314 {
 315         int i, j;
 316         Dimension d;
 317         short *v;
 318         PlankMap im;
 319         int new;
 320
 321         if (!op->table->rules) {
 322                 return;
 323         }
 324         switch (op->arity) {
 325         case 0:
 326                 break;
 327         case 1:
 328                 d = op->table->dimen[0];
 329                 if (d->map->count > 1) {
 330                         v = newVector();
 331                         im = newPlankMap(op->baseNum);
 332                         for (i = 0; i < globalMap->count-1; i++) {
 333                                 int index = d->map->set[d->index_map.class[sortedStates[i]->num]->num]->num;
 334                                 if (index) {
 335                                         Item_Set *ts = transLval(op->table, index, 0);
 336                                         v[i+1] = (*ts)->newNum - op->baseNum+1;
 337                                         assert(v[i+1] >= 0);
 338                                 }
 339                         }
 340                         enterStateMap(im, v, width(d->map->count-1), &new);
 341                         if (!new) {
 342                                 zfree(v);
 343                         }
 344                         d->pmap = im;
 345                 }
 346                 break;
 347         case 2:
 348                 if (op->table->dimen[0]->map->count == 1 && op->table->dimen[1]->map->count == 1) {
 349                         op->table->dimen[0]->pmap = 0;
 350                         op->table->dimen[1]->pmap = 0;
 351                 } else if (op->table->dimen[0]->map->count == 1) {
 352                         v = newVector();
 353                         im = newPlankMap(op->baseNum);
 354                         d = op->table->dimen[1];
 355                         for (i = 0; i < globalMap->count-1; i++) {
 356                                 int index = d->map->set[d->index_map.class[sortedStates[i]->num]->num]->num;
 357                                 if (index) {
 358                                         Item_Set *ts = transLval(op->table, 1, index);
 359                                         v[i+1] = (*ts)->newNum - op->baseNum+1;
 360                                         assert(v[i+1] >= 0);
 361                                 }
 362                         }
 363                         enterStateMap(im, v, width(d->map->count-1), &new);
 364                         if (!new) {
 365                                 zfree(v);
 366                         }
 367                         d->pmap = im;
 368                 } else if (op->table->dimen[1]->map->count == 1) {
 369                         v = newVector();
 370                         im = newPlankMap(op->baseNum);
 371                         d = op->table->dimen[0];
 372                         for (i = 0; i < globalMap->count-1; i++) {
 373                                 int index = d->map->set[d->index_map.class[sortedStates[i]->num]->num]->num;
 374                                 if (index) {
 375                                         Item_Set *ts = transLval(op->table, index, 1);
 376                                         v[i +1] = (*ts)->newNum - op->baseNum +1;
 377                                         assert(v[i +1] >= 0);
 378                                 }
 379                         }
 380                         enterStateMap(im, v, width(d->map->count-1), &new);
 381                         if (!new) {
 382                                 zfree(v);
 383                         }
 384                         d->pmap = im;
 385                 } else {
 386                         op->table->dimen[0]->pmap = mapToPmap(op->table->dimen[0]);
 387                         op->table->dimen[1]->pmap = mapToPmap(op->table->dimen[1]);
 388                         /* output table */
 389                         fprintf(outfile, "static unsigned %s %s_%s_transition[%d][%d] = {",
 390                                 op->stateCount <= 255 ? "char" : "short",
 391                                 prefix,
 392                                 op->name,
 393                                 op->table->dimen[0]->map->count,
 394                                 op->table->dimen[1]->map->count);
 395                         for (i = 0; i < op->table->dimen[0]->map->count; i++) {
 396                                 if (i > 0) {
 397                                         fprintf(outfile, ",");
 398                                 }
 399                                 fprintf(outfile, "\n{");
 400                                 for (j = 0; j < op->table->dimen[1]->map->count; j++) {
 401                                         Item_Set *ts = transLval(op->table, i, j);
 402                                         short diff;
 403                                         if (j > 0) {
 404                                                 fprintf(outfile, ",");
 405                                                 if (j % 10 == 0) {
 406                                                         fprintf(outfile, "\t/* row %d, cols %d-%d*/\n",
 407                                                                 i,
 408                                                                 j-10,
 409                                                                 j-1);
 410                                                 }
 411                                         }
 412                                         if ((*ts)->num > 0) {
 413                                                 diff = (*ts)->newNum - op->baseNum +1;
 414                                         } else {
 415                                                 diff = 0;
 416                                         }
 417                                         fprintf(outfile, "%5d", diff);
 418                                 }
 419                                 fprintf(outfile, "}\t/* row %d */", i);
 420                         }
 421                         fprintf(outfile, "\n};\n");
 422                 }
 423                 break;
 424         default:
 425                 assert(0);
 426         }
 427 }
 428
 429 static NonTerminal *ntVector;
 430
 431 static void
 432 doNonTermPmaps(n) NonTerminal n;
 433 {
 434         short *v;
 435         PlankMap im;
 436         int new;
 437         int i;
 438
 439         ntVector[n->num] = n;
 440         if (n->num >= last_user_nonterminal) {
 441                 return;
 442         }
 443         if (n->ruleCount <= 0) {
 444                 return;
 445         }
 446         im = newPlankMap(n->baseNum);
 447         v = newVector();
 448         for (i = 0; i < globalMap->count-1; i++) {
 449                 Rule r = globalMap->set[sortedStates[i]->num]->closed[n->num].rule;
 450                 if (r) {
 451                         r->used = 1;
 452                         v[i+1] = r->newNum - n->baseNum /*safely*/;
 453                         assert(v[i+1] >= 0);
 454                 }
 455         }
 456         enterStateMap(im, v, width(n->ruleCount+1), &new);
 457         if (!new) {
 458                 zfree(v);
 459         }
 460         n->pmap = im;
 461 }
 462
 463 static void
 464 makePmaps()
 465 {
 466         foreachList((ListFn) doDimPmaps, operators);
 467         ntVector = (NonTerminal*) zalloc((max_nonterminal) * sizeof(NonTerminal));
 468         foreachList((ListFn) doNonTermPmaps, nonterminals);
 469 }
 470
 471 static void
 472 outPlank(p) Plank p;
 473 {
 474         List f;
 475         int i;
 476
 477         fprintf(outfile, "static struct {\n");
 478
 479         for (f = p->fields; f; f = f->next) {
 480                 StateMap sm = (StateMap) f->x;
 481                 fprintf(outfile, "\tunsigned int %s:%d;\n", sm->fieldname, sm->width);
 482         }
 483
 484         fprintf(outfile, "} %s[] = {\n", p->name);
 485
 486         for (i = 0; i < globalMap->count; i++) {
 487                 fprintf(outfile, "\t{");
 488                 for (f = p->fields; f; f = f->next) {
 489                         StateMap sm = (StateMap) f->x;
 490                         fprintf(outfile, "%4d,", sm->value[i] == -1 ? ERROR_VAL : sm->value[i]);
 491                 }
 492                 fprintf(outfile, "},\t/* row %d */\n", i);
 493         }
 494
 495         fprintf(outfile, "};\n");
 496 }
 497
 498 static void
 499 purgePlanks(planks) List planks;
 500 {
 501         List p;
 502
 503         for (p = planks; p; p = p->next) {
 504                 Plank x = (Plank) p->x;
 505                 outPlank(x);
 506         }
 507 }
 508
 509 static void
 510 inToEx()
 511 {
 512         int i;
 513         int counter;
 514
 515         fprintf(outfile, "static short %s_eruleMap[] = {\n", prefix);
 516         counter = 0;
 517         for (i = 0; i < max_ruleAST; i++) {
 518                 if (counter > 0) {
 519                         fprintf(outfile, ",");
 520                         if (counter % 10 == 0) {
 521                                 fprintf(outfile, "\t/* %d-%d */\n", counter-10, counter-1);
 522                         }
 523                 }
 524                 if (counter < sortedRules[i]->rule->newNum) {
 525                         assert(counter == sortedRules[i]->rule->newNum-1);
 526                         fprintf(outfile, "%5d", 0);
 527                         counter++;
 528                         if (counter > 0) {
 529                                 fprintf(outfile, ",");
 530                                 if (counter % 10 == 0) {
 531                                         fprintf(outfile, "\t/* %d-%d */\n", counter-10, counter-1);
 532                                 }
 533                         }
 534                 }
 535                 fprintf(outfile, "%5d", sortedRules[i]->rule->erulenum);
 536                 counter++;
 537         }
 538         fprintf(outfile, "\n};\n");
 539 }
 540
 541 static void
 542 makePlankRuleMacros()
 543 {
 544         int i;
 545
 546         for (i = 1; i < last_user_nonterminal; i++) {
 547                 List es;
 548                 PlankMap im = ntVector[i]->pmap;
 549                 fprintf(outfile, "#define %s_%s_rule(state)\t", prefix, ntVector[i]->name);
 550                 if (im) {
 551                         fprintf(outfile, "%s_eruleMap[", prefix);
 552                         for (es = im->exceptions; es; es = es->next) {
 553                                 Exception e = (Exception) es->x;
 554                                 fprintf(outfile, "((state) == %d ? %d :",
 555                                                 e->index, e->value);
 556                         }
 557                         fprintf(outfile, "%s[state].%s",
 558                                 im->values->plank->name,
 559                                 im->values->fieldname);
 560                         for (es = im->exceptions; es; es = es->next) {
 561                                 fprintf(outfile, ")");
 562                         }
 563                         fprintf(outfile, " +%d]", im->offset);
 564
 565                 } else {
 566                         /* nonterminal never appears on LHS. */
 567                         assert(ntVector[i] ==  start);
 568                         fprintf(outfile, "0");
 569                 }
 570                 fprintf(outfile, "\n");
 571         }
 572         fprintf(outfile, "\n");
 573 }
 574
 575 static void
 576 makePlankRule()
 577 {
 578         int i;
 579
 580         makePlankRuleMacros();
 581
 582         fprintf(outfile, "#ifdef __STDC__\n");
 583         fprintf(outfile, "int %s_rule(int state, int goalnt) {\n", prefix);
 584         fprintf(outfile, "#else\n");
 585         fprintf(outfile, "int %s_rule(state, goalnt) int state; int goalnt; {\n", prefix);
 586         fprintf(outfile, "#endif\n");
 587
 588         fprintf(outfile,
 589         "\t%s_assert(state >= 0 && state < %d, %s_PANIC(\"Bad state %%d passed to %s_rule\\n\", state));\n",
 590                                 prefix, globalMap->count, prefix, prefix);
 591         fprintf(outfile, "\tswitch(goalnt) {\n");
 592
 593         for (i = 1; i < last_user_nonterminal; i++) {
 594                 fprintf(outfile, "\tcase %d:\n", i);
 595                 fprintf(outfile, "\t\treturn %s_%s_rule(state);\n", prefix, ntVector[i]->name);
 596         }
 597         fprintf(outfile, "\tdefault:\n");
 598         fprintf(outfile, "\t\t%s_PANIC(\"Unknown nonterminal %%d in %s_rule;\\n\", goalnt);\n", prefix, prefix);
 599         fprintf(outfile, "\t\tabort();\n");
 600         fprintf(outfile, "\t\treturn 0;\n");
 601         fprintf(outfile, "\t}\n");
 602         fprintf(outfile, "}\n");
 603 }
 604
 605 static void
 606 exceptionSwitch(es, sw, pre, post, offset, def) List es; const char *sw; const char *pre; const char *post; int offset; const char *def;
 607 {
 608         if (es) {
 609                 fprintf(outfile, "\t\tswitch (%s) {\n", sw);
 610                 for (; es; es = es->next) {
 611                         Exception e = (Exception) es->x;
 612                         fprintf(outfile, "\t\tcase %d: %s %d; %s\n", e->index, pre, e->value+offset, post);
 613                 }
 614                 if (def) {
 615                         fprintf(outfile, "\t\tdefault: %s;\n", def);
 616                 }
 617                 fprintf(outfile, "\t\t}\n");
 618         } else {
 619                 if (def) {
 620                         fprintf(outfile, "\t\t%s;\n", def);
 621                 }
 622         }
 623 }
 624
 625 static void
 626 doPlankLabel(op) Operator op;
 627 {
 628         PlankMap im0;
 629         PlankMap im1;
 630         char buf[100];
 631
 632         fprintf(outfile, "\tcase %d:\n", op->num);
 633         switch (op->arity) {
 634         case 0:
 635                 fprintf(outfile, "\t\treturn %d;\n", op->table->transition[0]->newNum);
 636                 break;
 637         case 1:
 638                 im0 = op->table->dimen[0]->pmap;
 639                 if (im0) {
 640                         exceptionSwitch(im0->exceptions, "l", "return ", "", im0->offset, 0);
 641                         fprintf(outfile, "\t\treturn %s[l].%s + %d;\n",
 642                                 im0->values->plank->name, im0->values->fieldname, im0->offset);
 643                 } else {
 644                         Item_Set *ts = transLval(op->table, 1, 0);
 645                         if (*ts) {
 646                                 fprintf(outfile, "\t\treturn %d;\n", (*ts)->newNum);
 647                         } else {
 648                                 fprintf(outfile, "\t\treturn %d;\n", ERROR_VAL);
 649                         }
 650                 }
 651                 break;
 652         case 2:
 653                 im0 = op->table->dimen[0]->pmap;
 654                 im1 = op->table->dimen[1]->pmap;
 655                 if (!im0 && !im1) {
 656                         Item_Set *ts = transLval(op->table, 1, 1);
 657                         if (*ts) {
 658                                 fprintf(outfile, "\t\treturn %d;\n", (*ts)->newNum);
 659                         } else {
 660                                 fprintf(outfile, "\t\treturn %d;\n", ERROR_VAL);
 661                         }
 662                 } else if (!im0) {
 663                         exceptionSwitch(im1->exceptions, "r", "return ", "", im1->offset, 0);
 664                         fprintf(outfile, "\t\treturn %s[r].%s + %d;\n",
 665                                 im1->values->plank->name, im1->values->fieldname, im1->offset);
 666                 } else if (!im1) {
 667                         exceptionSwitch(im0->exceptions, "l", "return ", "", im0->offset, 0);
 668                         fprintf(outfile, "\t\treturn %s[l].%s + %d;\n",
 669                                 im0->values->plank->name, im0->values->fieldname, im0->offset);
 670                 } else {
 671                         assert(im0->offset == 0);
 672                         assert(im1->offset == 0);
 673                         sprintf(buf, "l = %s[l].%s",
 674                                 im0->values->plank->name, im0->values->fieldname);
 675                         exceptionSwitch(im0->exceptions, "l", "l =", "break;", 0, buf);
 676                         sprintf(buf, "r = %s[r].%s",
 677                                 im1->values->plank->name, im1->values->fieldname);
 678                         exceptionSwitch(im1->exceptions, "r", "r =", "break;", 0, buf);
 679
 680                         fprintf(outfile, "\t\treturn %s_%s_transition[l][r] + %d;\n",
 681                                 prefix,
 682                                 op->name,
 683                                 op->baseNum);
 684                 }
 685                 break;
 686         default:
 687                 assert(0);
 688         }
 689 }
 690
 691 static void
 692 doPlankLabelMacrosSafely(op) Operator op;
 693 {
 694         PlankMap im0;
 695         PlankMap im1;
 696
 697         switch (op->arity) {
 698         case -1:
 699                 fprintf(outfile, "#define %s_%s_state\t0\n", prefix, op->name);
 700                 break;
 701         case 0:
 702                 fprintf(outfile, "#define %s_%s_state", prefix, op->name);
 703                 fprintf(outfile, "\t%d\n", op->table->transition[0]->newNum+1);
 704                 break;
 705         case 1:
 706                 fprintf(outfile, "#define %s_%s_state(l)", prefix, op->name);
 707                 im0 = op->table->dimen[0]->pmap;
 708                 if (im0) {
 709                         if (im0->exceptions) {
 710                                 List es = im0->exceptions;
 711                                 assert(0);
 712                                 fprintf(outfile, "\t\tswitch (l) {\n");
 713                                 for (; es; es = es->next) {
 714                                         Exception e = (Exception) es->x;
 715                                         fprintf(outfile, "\t\tcase %d: return %d;\n", e->index, e->value ? e->value+im0->offset : 0);
 716                                 }
 717                                 fprintf(outfile, "\t\t}\n");
 718                         }
 719                         if (speedflag) {
 720                                 fprintf(outfile, "\t( %s[l].%s + %d )\n",
 721                                         im0->values->plank->name, im0->values->fieldname,
 722                                         im0->offset);
 723                         } else {
 724                                 fprintf(outfile, "\t( (%s_TEMP = %s[l].%s) ? %s_TEMP + %d : 0 )\n",
 725                                         prefix,
 726                                         im0->values->plank->name, im0->values->fieldname,
 727                                         prefix,
 728                                         im0->offset);
 729                         }
 730                 } else {
 731                         Item_Set *ts = transLval(op->table, 1, 0);
 732                         if (*ts) {
 733                                 fprintf(outfile, "\t%d\n", (*ts)->newNum+1);
 734                         } else {
 735                                 fprintf(outfile, "\t%d\n", 0);
 736                         }
 737                 }
 738                 break;
 739         case 2:
 740                 fprintf(outfile, "#define %s_%s_state(l,r)", prefix, op->name);
 741
 742                 im0 = op->table->dimen[0]->pmap;
 743                 im1 = op->table->dimen[1]->pmap;
 744                 if (!im0 && !im1) {
 745                         Item_Set *ts = transLval(op->table, 1, 1);
 746                         assert(0);
 747                         if (*ts) {
 748                                 fprintf(outfile, "\t\treturn %d;\n", (*ts)->newNum+1);
 749                         } else {
 750                                 fprintf(outfile, "\t\treturn %d;\n", 0);
 751                         }
 752                 } else if (!im0) {
 753                         assert(0);
 754                         if (im1->exceptions) {
 755                                 List es = im1->exceptions;
 756                                 fprintf(outfile, "\t\tswitch (r) {\n");
 757                                 for (; es; es = es->next) {
 758                                         Exception e = (Exception) es->x;
 759                                         fprintf(outfile, "\t\tcase %d: return %d;\n", e->index, e->value ? e->value+im1->offset : 0);
 760                                 }
 761                                 fprintf(outfile, "\t\t}\n");
 762                         }
 763                         fprintf(outfile, "\t\tstate = %s[r].%s; offset = %d;\n",
 764                                 im1->values->plank->name, im1->values->fieldname, im1->offset);
 765                         fprintf(outfile, "\t\tbreak;\n");
 766                 } else if (!im1) {
 767                         assert(0);
 768                         if (im0->exceptions) {
 769                                 List es = im0->exceptions;
 770                                 fprintf(outfile, "\t\tswitch (l) {\n");
 771                                 for (; es; es = es->next) {
 772                                         Exception e = (Exception) es->x;
 773                                         fprintf(outfile, "\t\tcase %d: return %d;\n", e->index, e->value ? e->value+im0->offset : 0);
 774                                 }
 775                                 fprintf(outfile, "\t\t}\n");
 776                         }
 777                         fprintf(outfile, "\t\tstate = %s[l].%s; offset = %d;\n",
 778                                 im0->values->plank->name, im0->values->fieldname, im0->offset);
 779                         fprintf(outfile, "\t\tbreak;\n");
 780                 } else {
 781                         assert(im0->offset == 0);
 782                         assert(im1->offset == 0);
 783                         /*
 784                         sprintf(buf, "l = %s[l].%s",
 785                                 im0->values->plank->name, im0->values->fieldname);
 786                         exceptionSwitch(im0->exceptions, "l", "l =", "break;", 0, buf);
 787                         sprintf(buf, "r = %s[r].%s",
 788                                 im1->values->plank->name, im1->values->fieldname);
 789                         exceptionSwitch(im1->exceptions, "r", "r =", "break;", 0, buf);
 790
 791                         fprintf(outfile, "\t\tstate = %s_%s_transition[l][r]; offset = %d;\n",
 792                                 prefix,
 793                                 op->name,
 794                                 op->baseNum);
 795                         fprintf(outfile, "\t\tbreak;\n");
 796                         */
 797
 798                         if (speedflag) {
 799                                 fprintf(outfile, "\t( %s_%s_transition[%s[l].%s][%s[r].%s] + %d)\n",
 800                                         prefix,
 801                                         op->name,
 802                                         im0->values->plank->name, im0->values->fieldname,
 803                                         im1->values->plank->name, im1->values->fieldname,
 804                                         op->baseNum);
 805                         } else {
 806                                 fprintf(outfile, "\t( (%s_TEMP = %s_%s_transition[%s[l].%s][%s[r].%s]) ? ",
 807                                         prefix,
 808                                         prefix,
 809                                         op->name,
 810                                         im0->values->plank->name, im0->values->fieldname,
 811                                         im1->values->plank->name, im1->values->fieldname);
 812                                 fprintf(outfile, "%s_TEMP + %d : 0 )\n",
 813                                         prefix,
 814                                         op->baseNum);
 815                         }
 816                 }
 817                 break;
 818         default:
 819                 assert(0);
 820         }
 821 }
 822 static void
 823 doPlankLabelSafely(op) Operator op;
 824 {
 825         fprintf(outfile, "\tcase %d:\n", op->num);
 826         switch (op->arity) {
 827         case -1:
 828                 fprintf(outfile, "\t\treturn 0;\n");
 829                 break;
 830         case 0:
 831                 fprintf(outfile, "\t\treturn %s_%s_state;\n", prefix, op->name);
 832                 break;
 833         case 1:
 834                 fprintf(outfile, "\t\treturn %s_%s_state(l);\n", prefix, op->name);
 835                 break;
 836         case 2:
 837                 fprintf(outfile, "\t\treturn %s_%s_state(l,r);\n", prefix, op->name);
 838                 break;
 839         default:
 840                 assert(0);
 841         }
 842 }
 843
 844 static void
 845 makePlankState()
 846 {
 847         fprintf(outfile, "\n");
 848         fprintf(outfile, "int %s_TEMP;\n", prefix);
 849         foreachList((ListFn) doPlankLabelMacrosSafely, operators);
 850         fprintf(outfile, "\n");
 851
 852         fprintf(outfile, "#ifdef __STDC__\n");
 853         switch (max_arity) {
 854         case -1:
 855                 fprintf(stderr, "ERROR: no terminals in grammar.\n");
 856                 exit(1);
 857         case 0:
 858                 fprintf(outfile, "int %s_state(int op) {\n", prefix);
 859                 fprintf(outfile, "#else\n");
 860                 fprintf(outfile, "int %s_state(op) int op; {\n", prefix);
 861                 break;
 862         case 1:
 863                 fprintf(outfile, "int %s_state(int op, int l) {\n", prefix);
 864                 fprintf(outfile, "#else\n");
 865                 fprintf(outfile, "int %s_state(op, l) int op; int l; {\n", prefix);
 866                 break;
 867         case 2:
 868                 fprintf(outfile, "int %s_state(int op, int l, int r) {\n", prefix);
 869                 fprintf(outfile, "#else\n");
 870                 fprintf(outfile, "int %s_state(op, l, r) int op; int l; int r; {\n", prefix);
 871                 break;
 872         default:
 873                 assert(0);
 874         }
 875         fprintf(outfile, "#endif\n");
 876
 877         fprintf(outfile, "\tregister int %s_TEMP;\n", prefix);
 878
 879         fprintf(outfile, "#ifndef NDEBUG\n");
 880
 881         fprintf(outfile, "\tswitch (op) {\n");
 882         opsOfArity(2);
 883         if (max_arity >= 2) {
 884                 fprintf(outfile,
 885                 "\t\t%s_assert(r >= 0 && r < %d, %s_PANIC(\"Bad state %%d passed to %s_state\\n\", r));\n",
 886                                 prefix, globalMap->count, prefix, prefix);
 887                 fprintf(outfile, "\t\t/*FALLTHROUGH*/\n");
 888         }
 889         opsOfArity(1);
 890         if (max_arity > 1) {
 891                 fprintf(outfile,
 892                 "\t\t%s_assert(l >= 0 && l < %d, %s_PANIC(\"Bad state %%d passed to %s_state\\n\", l));\n",
 893                                 prefix, globalMap->count, prefix, prefix);
 894                 fprintf(outfile, "\t\t/*FALLTHROUGH*/\n");
 895         }
 896         opsOfArity(0);
 897         fprintf(outfile, "\t\tbreak;\n");
 898         fprintf(outfile, "\t}\n");
 899         fprintf(outfile, "#endif\n");
 900
 901         fprintf(outfile, "\tswitch (op) {\n");
 902         fprintf(outfile,"\tdefault: %s_PANIC(\"Unknown op %%d in %s_state\\n\", op); abort(); return 0;\n",
 903                 prefix, prefix);
 904         foreachList((ListFn) doPlankLabelSafely, operators);
 905         fprintf(outfile, "\t}\n");
 906
 907         fprintf(outfile, "}\n");
 908 }
 909
 910 void
 911 makePlanks()
 912 {
 913         List planks;
 914         renumber();
 915         makePmaps();
 916         planks = assemblePlanks();
 917         purgePlanks(planks);
 918         inToEx();
 919         makePlankRule();
 920         makePlankState();
 921 }