utils/Burg/be.c

   1 char rcsid_be[] = "$Id$";
   2
   3 #include <stdio.h>
   4 #include <string.h>
   5 #include "b.h"
   6 #include "fe.h"
   7
   8 #define ERROR_VAL 0
   9
  10 FILE *outfile;
  11 const char *prefix = "burm";
  12
  13 static void doKids ARGS((RuleAST));
  14 static void doLabel ARGS((Operator));
  15 static void doLayout ARGS((RuleAST));
  16 static void doMakeTable ARGS((Operator));
  17 static void doVector ARGS((RuleAST));
  18 static void layoutNts ARGS((PatternAST));
  19 static void makeIndex_Map ARGS((Dimension));
  20 static void makePvector ARGS((void));
  21 static void makeState ARGS((void));
  22 static void printPatternAST ARGS((PatternAST));
  23 static void printPatternAST_int ARGS((PatternAST));
  24 static void setVectors ARGS((PatternAST));
  25 static void trailing_zeroes ARGS((int));
  26 static int seminal ARGS((int from, int to));
  27 static void printRule ARGS((RuleAST, const char *));
  28
  29 static void
  30 doLabel(op) Operator op;
  31 {
  32         fprintf(outfile, "\tcase %d:\n", op->num);
  33
  34         switch (op->arity) {
  35         default:
  36                 assert(0);
  37                 break;
  38         case 0:
  39                 fprintf(outfile, "\t\treturn %d;\n", op->table->transition[0]->num);
  40                 break;
  41         case 1:
  42                 if (op->table->rules) {
  43                         fprintf(outfile, "\t\treturn %s_%s_transition[l];\n", prefix, op->name);
  44                 } else {
  45                         fprintf(outfile, "\t\treturn %d;\n", ERROR_VAL);
  46                 }
  47                 break;
  48         case 2:
  49                 if (op->table->rules) {
  50                         fprintf(outfile, "\t\treturn %s_%s_transition[%s_%s_imap_1[l]][%s_%s_imap_2[r]];\n", prefix, op->name, prefix, op->name, prefix, op->name);
  51                 } else {
  52                         fprintf(outfile, "\t\treturn %d;\n", ERROR_VAL);
  53                 }
  54                 break;
  55         }
  56 }
  57
  58 int
  59 opsOfArity(arity) int arity;
  60 {
  61         int c;
  62         List l;
  63
  64         c = 0;
  65         for (l = operators; l; l = l->next) {
  66                 Operator op = (Operator) l->x;
  67                 if (op->arity == arity) {
  68                         fprintf(outfile, "\tcase %d:\n", op->num);
  69                         c++;
  70                 }
  71         }
  72         return c;
  73 }
  74
  75 static void
  76 trailing_zeroes(z) int z;
  77 {
  78         int i;
  79
  80         for (i = 0; i < z; i++) {
  81                 fprintf(outfile, ", 0");
  82         }
  83 }
  84
  85 void
  86 makeLabel()
  87 {
  88         int flag;
  89
  90         fprintf(outfile, "#ifdef __STDC__\n");
  91         fprintf(outfile, "int %s_label(%s_NODEPTR_TYPE n) {\n", prefix, prefix);
  92         fprintf(outfile, "#else\n");
  93         fprintf(outfile, "int %s_label(n) %s_NODEPTR_TYPE n; {\n", prefix, prefix);
  94         fprintf(outfile, "#endif\n");
  95
  96         fprintf(outfile,
  97         "\t%s_assert(n, %s_PANIC(\"NULL pointer passed to %s_label\\n\"));\n",
  98                                 prefix, prefix, prefix);
  99         fprintf(outfile, "\tswitch (%s_OP_LABEL(n)) {\n", prefix);
 100         fprintf(outfile, "\tdefault: %s_PANIC(\"Bad op %%d in %s_label\\n\", %s_OP_LABEL(n)); abort(); return 0;\n",
 101                         prefix, prefix, prefix);
 102
 103         flag = opsOfArity(0);
 104         if (flag > 0) {
 105                 fprintf(outfile, "\t\treturn %s_STATE_LABEL(n) = %s_state(%s_OP_LABEL(n)",
 106                                         prefix, prefix, prefix);
 107                 trailing_zeroes(max_arity);
 108                 fprintf(outfile, ");\n");
 109         }
 110         flag = opsOfArity(1);
 111         if (flag > 0) {
 112                 fprintf(outfile, "\t\treturn %s_STATE_LABEL(n) = %s_state(%s_OP_LABEL(n), %s_label(%s_LEFT_CHILD(n))",
 113                                         prefix, prefix, prefix, prefix, prefix);
 114                 trailing_zeroes(max_arity-1);
 115                 fprintf(outfile, ");\n");
 116         }
 117         flag = opsOfArity(2);
 118         if (flag > 0) {
 119                 fprintf(outfile, "\t\treturn %s_STATE_LABEL(n) = %s_state(%s_OP_LABEL(n), %s_label(%s_LEFT_CHILD(n)), %s_label(%s_RIGHT_CHILD(n))",
 120                                         prefix, prefix, prefix, prefix, prefix, prefix, prefix);
 121                 trailing_zeroes(max_arity-2);
 122                 fprintf(outfile, ");\n");
 123
 124         }
 125         fprintf(outfile, "\t}\n");
 126         fprintf(outfile, "}\n");
 127 }
 128
 129 static void
 130 makeState()
 131 {
 132         fprintf(outfile, "int %s_state(int op, int l, int r) {\n", prefix);
 133         fprintf(outfile,
 134         "\t%s_assert(l >= 0 && l < %d, PANIC(\"Bad state %%d passed to %s_state\\n\", l));\n",
 135                                 prefix, globalMap->count, prefix);
 136         fprintf(outfile,
 137         "\t%s_assert(r >= 0 && r < %d, PANIC(\"Bad state %%d passed to %s_state\\n\", r));\n",
 138                                 prefix, globalMap->count, prefix);
 139         fprintf(outfile, "\tswitch (op) {\n");
 140         fprintf(outfile, "\tdefault: %s_PANIC(\"Bad op %%d in %s_state\\n\", op); abort(); return 0;\n", prefix, prefix);
 141
 142         foreachList((ListFn) doLabel, operators);
 143
 144         fprintf(outfile, "\t}\n");
 145         fprintf(outfile, "}\n");
 146 }
 147
 148 static char cumBuf[4000];
 149 static int vecIndex;
 150 char vecBuf[4000];
 151
 152 static void
 153 setVectors(ast) PatternAST ast;
 154 {
 155         char old[4000];
 156
 157         switch (ast->sym->tag) {
 158         default:
 159                 assert(0);
 160                 break;
 161         case NONTERMINAL:
 162                 sprintf(old, "\t\tkids[%d] = %s;\n", vecIndex, vecBuf);
 163                 strcat(cumBuf, old);
 164                 vecIndex++;
 165                 return;
 166         case OPERATOR:
 167                 switch (ast->sym->u.op->arity) {
 168                 default:
 169                         assert(0);
 170                         break;
 171                 case 0:
 172                         return;
 173                 case 1:
 174                         strcpy(old, vecBuf);
 175                         sprintf(vecBuf, "%s_LEFT_CHILD(%s)", prefix, old);
 176                         setVectors((PatternAST) ast->children->x);
 177                         strcpy(vecBuf, old);
 178                         return;
 179                 case 2:
 180                         strcpy(old, vecBuf);
 181                         sprintf(vecBuf, "%s_LEFT_CHILD(%s)", prefix, old);
 182                         setVectors((PatternAST) ast->children->x);
 183
 184                         sprintf(vecBuf, "%s_RIGHT_CHILD(%s)", prefix, old);
 185                         setVectors((PatternAST) ast->children->next->x);
 186                         strcpy(vecBuf, old);
 187                         return;
 188                 }
 189                 break;
 190         }
 191 }
 192
 193 #define MAX_VECTOR      10
 194
 195 void
 196 makeRuleTable()
 197 {
 198         int s,nt;
 199
 200         fprintf(outfile, "static short %s_RuleNo[%d][%d] = {\n", prefix, globalMap->count, last_user_nonterminal-1);
 201         for (s = 0; s < globalMap->count; s++) {
 202                 Item_Set ts = globalMap->set[s];
 203                 if (s > 0) {
 204                         fprintf(outfile, ",\n");
 205                 }
 206                 fprintf(outfile, "/* state %d */\n", s);
 207                 fprintf(outfile, "{");
 208                 for (nt = 1; nt < last_user_nonterminal; nt++) {
 209                         if (nt > 1) {
 210                                 fprintf(outfile, ",");
 211                                 if (nt % 10 == 1) {
 212                                         fprintf(outfile, "\t/* state %d; Nonterminals %d-%d */\n", s, nt-10, nt-1);
 213                                 }
 214                         }
 215                         if (ts->closed[nt].rule) {
 216                                 ts->closed[nt].rule->used = 1;
 217                                 fprintf(outfile, "%5d", ts->closed[nt].rule->erulenum);
 218                         } else {
 219                                 fprintf(outfile, "%5d", ERROR_VAL);
 220                         }
 221                 }
 222                 fprintf(outfile, "}");
 223         }
 224         fprintf(outfile, "};\n");
 225 }
 226
 227 static void
 228 makeIndex_Map(d) Dimension d;
 229 {
 230         int s;
 231
 232         for (s = 0; s < globalMap->count; s++) {
 233                 if (s > 0) {
 234                         fprintf(outfile, ",");
 235                         if (s % 10 == 0) {
 236                                 fprintf(outfile, "\t/* %d-%d */\n", s-10, s-1);
 237                         }
 238                 }
 239                 fprintf(outfile, "%5d", d->map->set[d->index_map.class[s]->num]->num);
 240         }
 241         fprintf(outfile, "};\n");
 242 }
 243
 244 static void
 245 doMakeTable(op) Operator op;
 246 {
 247         int s;
 248         int i,j;
 249         Dimension d;
 250
 251         switch (op->arity) {
 252         default:
 253                 assert(0);
 254                 break;
 255         case 0:
 256                 return;
 257         case 1:
 258                 if (!op->table->rules) {
 259                         return;
 260                 }
 261                 d = op->table->dimen[0];
 262                 fprintf(outfile, "static short %s_%s_transition[%d] = {\n", prefix, op->name, globalMap->count);
 263                 for (s = 0; s < globalMap->count; s++) {
 264                         if (s > 0) {
 265                                 fprintf(outfile, ", ");
 266                                 if (s % 10 == 0) {
 267                                         fprintf(outfile, "\t/* %d-%d */\n", s-10, s-1);
 268                                 }
 269                         }
 270                         fprintf(outfile, "%5d", op->table->transition[d->map->set[d->index_map.class[s]->num]->num]->num);
 271                 }
 272                 fprintf(outfile, "};\n");
 273                 break;
 274         case 2:
 275                 if (!op->table->rules) {
 276                         return;
 277                 }
 278                 fprintf(outfile, "static short %s_%s_imap_1[%d] = {\n", prefix, op->name, globalMap->count);
 279                 makeIndex_Map(op->table->dimen[0]);
 280                 fprintf(outfile, "static short %s_%s_imap_2[%d] = {\n", prefix, op->name, globalMap->count);
 281                 makeIndex_Map(op->table->dimen[1]);
 282
 283                 fprintf(outfile, "static short %s_%s_transition[%d][%d] = {", prefix, op->name,
 284                                                 op->table->dimen[0]->map->count,
 285                                                 op->table->dimen[1]->map->count);
 286                 for (i = 0; i < op->table->dimen[0]->map->count; i++) {
 287                         if (i > 0) {
 288                                 fprintf(outfile, ",");
 289                         }
 290                         fprintf(outfile, "\n");
 291                         fprintf(outfile, "{");
 292                         for (j = 0; j < op->table->dimen[1]->map->count; j++) {
 293                                 Item_Set *ts = transLval(op->table, i, j);
 294                                 if (j > 0) {
 295                                         fprintf(outfile, ",");
 296                                 }
 297                                 fprintf(outfile, "%5d", (*ts)->num);
 298                         }
 299                         fprintf(outfile, "}\t/* row %d */", i);
 300                 }
 301                 fprintf(outfile, "\n};\n");
 302
 303                 break;
 304         }
 305 }
 306
 307 void
 308 makeTables()
 309 {
 310         foreachList((ListFn) doMakeTable, operators);
 311 }
 312
 313 RuleAST *pVector;
 314
 315 void
 316 makeLHSmap()
 317 {
 318         int i;
 319
 320         if (!pVector) {
 321                 makePvector();
 322         }
 323
 324         fprintf(outfile, "short %s_lhs[] = {\n", prefix);
 325         for (i = 0; i <= max_erule_num; i++) {
 326                 if (pVector[i]) {
 327                         fprintf(outfile, "\t%s_%s_NT,\n", prefix, pVector[i]->lhs);
 328                 } else {
 329                         fprintf(outfile, "\t0,\n");
 330                 }
 331         }
 332         fprintf(outfile, "};\n\n");
 333 }
 334
 335 static int seminal(int from, int to)
 336 {
 337         return allpairs[from][to].rule ? allpairs[from][to].rule->erulenum : 0;
 338
 339         /*
 340         int tmp, last;
 341         tmp = 0;
 342         for (;;) {
 343                 last = tmp;
 344                 tmp = allpairs[to][from].rule ? allpairs[to][from].rule->erulenum : 0;
 345                 if (!tmp) {
 346                         break;
 347                 }
 348                 assert(pVector[tmp]);
 349                 to = pVector[tmp]->rule->pat->children[0]->num;
 350         }
 351         return last;
 352         */
 353 }
 354
 355 void
 356 makeClosureArray()
 357 {
 358         int i, j;
 359
 360         if (!pVector) {
 361                 makePvector();
 362         }
 363
 364         fprintf(outfile, "short %s_closure[%d][%d] = {\n", prefix, last_user_nonterminal, last_user_nonterminal);
 365         for (i = 0; i < last_user_nonterminal; i++) {
 366                 fprintf(outfile, "\t{");
 367                 for (j = 0; j < last_user_nonterminal; j++) {
 368                         if (j > 0 && j%10 == 0) {
 369                                 fprintf(outfile, "\n\t ");
 370                         }
 371                         fprintf(outfile, " %4d,", seminal(i,j));
 372                 }
 373                 fprintf(outfile, "},\n");
 374         }
 375         fprintf(outfile, "};\n");
 376 }
 377
 378 void
 379 makeCostVector(z,d) int z; DeltaCost d;
 380 {
 381         fprintf(outfile, "\t{");
 382 #ifdef NOLEX
 383         if (z) {
 384                 fprintf(outfile, "%5d", d);
 385         } else {
 386                 fprintf(outfile, "%5d", 0);
 387         }
 388 #else
 389         {
 390         int j;
 391         for (j = 0; j < DELTAWIDTH; j++) {
 392                 if (j > 0) {
 393                         fprintf(outfile, ",");
 394                 }
 395                 if (z) {
 396                         fprintf(outfile, "%5d", d[j]);
 397                 } else {
 398                         fprintf(outfile, "%5d", 0);
 399                 }
 400         }
 401         }
 402 #endif /* NOLEX */
 403         fprintf(outfile, "}");
 404 }
 405
 406 void
 407 makeCostArray()
 408 {
 409         int i;
 410
 411         if (!pVector) {
 412                 makePvector();
 413         }
 414
 415         fprintf(outfile, "short %s_cost[][%d] = {\n", prefix, DELTAWIDTH);
 416         for (i = 0; i <= max_erule_num; i++) {
 417                 makeCostVector(pVector[i] != 0, pVector[i] ? pVector[i]->rule->delta : 0);
 418                 fprintf(outfile, ", /* ");
 419                 printRule(pVector[i], "(none)");
 420                 fprintf(outfile, " = %d */\n", i);
 421         }
 422         fprintf(outfile, "};\n");
 423 }
 424
 425 void
 426 makeStateStringArray()
 427 {
 428         int s;
 429         int nt;
 430         int states;
 431
 432         states = globalMap->count;
 433         fprintf(outfile, "\nconst char * %s_state_string[] = {\n", prefix);
 434         fprintf(outfile, "\" not a state\", /* state 0 */\n");
 435         for (s = 0; s < states-1; s++) {
 436                 fprintf(outfile, "\t\"");
 437                 printRepresentative(outfile, sortedStates[s]);
 438                 fprintf(outfile, "\", /* state #%d */\n", s+1);
 439         }
 440         fprintf(outfile, "};\n");
 441 }
 442
 443 void
 444 makeDeltaCostArray()
 445 {
 446         int s;
 447         int nt;
 448         int states;
 449
 450         states = globalMap->count;
 451         fprintf(outfile, "\nshort %s_delta_cost[%d][%d][%d] = {\n", prefix, states, last_user_nonterminal, DELTAWIDTH);
 452         fprintf(outfile, "{{0}}, /* state 0 */\n");
 453         for (s = 0; s < states-1; s++) {
 454                 fprintf(outfile, "{ /* state #%d: ", s+1);
 455                 printRepresentative(outfile, sortedStates[s]);
 456                 fprintf(outfile, " */\n");
 457                 fprintf(outfile, "\t{0},\n");
 458                 for (nt = 1; nt < last_user_nonterminal; nt++) {
 459                         makeCostVector(1, sortedStates[s]->closed[nt].delta);
 460                         fprintf(outfile, ", /* ");
 461                         if (sortedStates[s]->closed[nt].rule) {
 462                                 int erulenum = sortedStates[s]->closed[nt].rule->erulenum;
 463                                 printRule(pVector[erulenum], "(none)");
 464                                 fprintf(outfile, " = %d */", erulenum);
 465                         } else {
 466                                 fprintf(outfile, "(none) */");
 467                         }
 468                         fprintf(outfile, "\n");
 469                 }
 470                 fprintf(outfile, "},\n");
 471         }
 472         fprintf(outfile, "};\n");
 473 }
 474
 475 static void
 476 printPatternAST_int(p) PatternAST p;
 477 {
 478         List l;
 479
 480         if (p) {
 481                 switch (p->sym->tag) {
 482                 case NONTERMINAL:
 483                         fprintf(outfile, "%5d,", -p->sym->u.nt->num);
 484                         break;
 485                 case OPERATOR:
 486                         fprintf(outfile, "%5d,", p->sym->u.op->num);
 487                         break;
 488                 default:
 489                         assert(0);
 490                 }
 491                 if (p->children) {
 492                         for (l = p->children; l; l = l->next) {
 493                                 PatternAST pat = (PatternAST) l->x;
 494                                 printPatternAST_int(pat);
 495                         }
 496                 }
 497         }
 498 }
 499
 500 static void
 501 printPatternAST(p) PatternAST p;
 502 {
 503         List l;
 504
 505         if (p) {
 506                 fprintf(outfile, "%s", p->op);
 507                 if (p->children) {
 508                         fprintf(outfile, "(");
 509                         for (l = p->children; l; l = l->next) {
 510                                 PatternAST pat = (PatternAST) l->x;
 511                                 if (l != p->children) {
 512                                         fprintf(outfile, ", ");
 513                                 }
 514                                 printPatternAST(pat);
 515                         }
 516                         fprintf(outfile, ")");
 517                 }
 518         }
 519 }
 520
 521 static void
 522 layoutNts(ast) PatternAST ast;
 523 {
 524         char out[30];
 525
 526         switch (ast->sym->tag) {
 527         default:
 528                 assert(0);
 529                 break;
 530         case NONTERMINAL:
 531                 sprintf(out, "%d, ", ast->sym->u.nt->num);
 532                 strcat(cumBuf, out);
 533                 return;
 534         case OPERATOR:
 535                 switch (ast->sym->u.op->arity) {
 536                 default:
 537                         assert(0);
 538                         break;
 539                 case 0:
 540                         return;
 541                 case 1:
 542                         layoutNts((PatternAST) ast->children->x);
 543                         return;
 544                 case 2:
 545                         layoutNts((PatternAST) ast->children->x);
 546                         layoutNts((PatternAST) ast->children->next->x);
 547                         return;
 548                 }
 549                 break;
 550         }
 551 }
 552
 553 static void
 554 doVector(ast) RuleAST ast;
 555 {
 556         if (pVector[ast->rule->erulenum]) {
 557                 fprintf(stderr, "ERROR: non-unique external rule number: (%d)\n", ast->rule->erulenum);
 558                 exit(1);
 559         }
 560         pVector[ast->rule->erulenum] = ast;
 561 }
 562
 563 static void
 564 makePvector()
 565 {
 566         pVector = (RuleAST*) zalloc((max_erule_num+1) * sizeof(RuleAST));
 567         foreachList((ListFn) doVector, ruleASTs);
 568 }
 569
 570 static void
 571 doLayout(ast) RuleAST ast;
 572 {
 573         sprintf(cumBuf, "{ ");
 574         layoutNts(ast->pat);
 575         strcat(cumBuf, "0 }");
 576 }
 577
 578 void
 579 makeNts()
 580 {
 581         int i;
 582         int new;
 583         StrTable nts;
 584
 585         nts = newStrTable();
 586
 587         if (!pVector) {
 588                 makePvector();
 589         }
 590
 591         for (i = 0; i <= max_erule_num; i++) {
 592                 if (pVector[i]) {
 593                         doLayout(pVector[i]);
 594                         pVector[i]->nts = addString(nts, cumBuf, i, &new);
 595                         if (new) {
 596                                 char ename[50];
 597
 598                                 sprintf(ename, "%s_r%d_nts", prefix, i);
 599                                 pVector[i]->nts->ename = (char*) zalloc(strlen(ename)+1);
 600                                 strcpy(pVector[i]->nts->ename, ename);
 601                                 fprintf(outfile, "static short %s[] =", ename);
 602                                 fprintf(outfile, "%s;\n", cumBuf);
 603                         }
 604                 }
 605         }
 606
 607         fprintf(outfile, "short *%s_nts[] = {\n", prefix);
 608         for (i = 0; i <= max_erule_num; i++) {
 609                 if (pVector[i]) {
 610                         fprintf(outfile, "\t%s,\n", pVector[i]->nts->ename);
 611                 } else {
 612                         fprintf(outfile, "\t0,\n");
 613                 }
 614         }
 615         fprintf(outfile, "};\n");
 616 }
 617
 618 static void
 619 printRule(RuleAST r, const char *d)
 620 {
 621         if (r) {
 622                 fprintf(outfile, "%s: ", r->rule->lhs->name);
 623                 printPatternAST(r->pat);
 624         } else {
 625                 fprintf(outfile, "%s", d);
 626         }
 627 }
 628
 629 void
 630 makeRuleDescArray()
 631 {
 632         int i;
 633
 634         if (!pVector) {
 635                 makePvector();
 636         }
 637
 638         if (last_user_nonterminal != max_nonterminal) {
 639                 /* not normal form */
 640                 fprintf(outfile, "short %s_rule_descriptor_0[] = { 0, 0 };\n", prefix);
 641         } else {
 642                 fprintf(outfile, "short %s_rule_descriptor_0[] = { 0, 1 };\n", prefix);
 643         }
 644         for (i = 1; i <= max_erule_num; i++) {
 645                 if (pVector[i]) {
 646                         Operator o;
 647                         NonTerminal t;
 648
 649                         fprintf(outfile, "short %s_rule_descriptor_%d[] = {", prefix, i);
 650                         fprintf(outfile, "%5d,", -pVector[i]->rule->lhs->num);
 651                         printPatternAST_int(pVector[i]->pat);
 652                         fprintf(outfile, " };\n");
 653                 }
 654         }
 655
 656         fprintf(outfile, "/* %s_rule_descriptors[0][1] = 1 iff grammar is normal form. */\n", prefix);
 657         fprintf(outfile, "short * %s_rule_descriptors[] = {\n", prefix);
 658         fprintf(outfile, "\t%s_rule_descriptor_0,\n", prefix);
 659         for (i = 1; i <= max_erule_num; i++) {
 660                 if (pVector[i]) {
 661                         fprintf(outfile, "\t%s_rule_descriptor_%d,\n", prefix, i);
 662                 } else {
 663                         fprintf(outfile, "\t%s_rule_descriptor_0,\n", prefix);
 664                 }
 665         }
 666         fprintf(outfile, "};\n");
 667 }
 668
 669
 670 void
 671 makeRuleDescArray2()
 672 {
 673         int i;
 674
 675         if (!pVector) {
 676                 makePvector();
 677         }
 678
 679         fprintf(outfile, "struct { int lhs, op, left, right; } %s_rule_struct[] = {\n", prefix);
 680         if (last_user_nonterminal != max_nonterminal) {
 681                 /* not normal form */
 682                 fprintf(outfile, "\t{-1},");
 683         } else {
 684                 fprintf(outfile, "\t{0},");
 685         }
 686         fprintf(outfile, " /* 0 if normal form, -1 if not normal form */\n");
 687         for (i = 1; i <= max_erule_num; i++) {
 688                 fprintf(outfile, "\t");
 689                 if (pVector[i]) {
 690                         Operator o;
 691                         NonTerminal t1, t2;
 692
 693                         fprintf(outfile, "{");
 694                         fprintf(outfile, "%5d, %5d, %5d, %5d",
 695                                 pVector[i]->rule->lhs->num,
 696                                 (o = pVector[i]->rule->pat->op) ? o->num : 0,
 697                                 (t1 = pVector[i]->rule->pat->children[0]) ? t1->num : 0,
 698                                 (t2 = pVector[i]->rule->pat->children[1]) ? t2->num : 0
 699                                 );
 700                         fprintf(outfile, "} /* ");
 701                         printRule(pVector[i], "0");
 702                         fprintf(outfile, " = %d */", i);
 703                 } else {
 704                         fprintf(outfile, "{0}");
 705                 }
 706                 fprintf(outfile, ",\n");
 707         }
 708         fprintf(outfile, "};\n");
 709 }
 710
 711 void
 712 makeStringArray()
 713 {
 714         int i;
 715
 716         if (!pVector) {
 717                 makePvector();
 718         }
 719
 720         fprintf(outfile, "const char *%s_string[] = {\n", prefix);
 721         for (i = 0; i <= max_erule_num; i++) {
 722                 fprintf(outfile, "\t");
 723                 if (pVector[i]) {
 724                         fprintf(outfile, "\"");
 725                         printRule(pVector[i], "0");
 726                         fprintf(outfile, "\"");
 727                 } else {
 728                         fprintf(outfile, "0");
 729                 }
 730                 fprintf(outfile, ",\n");
 731         }
 732         fprintf(outfile, "};\n");
 733         fprintf(outfile, "int %s_max_rule = %d;\n", prefix, max_erule_num);
 734         fprintf(outfile, "#define %s_Max_rule %d\n", prefix, max_erule_num);
 735 }
 736
 737 void
 738 makeRule()
 739 {
 740         fprintf(outfile, "int %s_rule(int state, int goalnt) {\n", prefix);
 741         fprintf(outfile,
 742         "\t%s_assert(state >= 0 && state < %d, PANIC(\"Bad state %%d passed to %s_rule\\n\", state));\n",
 743                                 prefix, globalMap->count, prefix);
 744         fprintf(outfile,
 745         "\t%s_assert(goalnt >= 1 && goalnt < %d, PANIC(\"Bad goalnt %%d passed to %s_rule\\n\", state));\n",
 746                                 prefix, max_nonterminal, prefix);
 747         fprintf(outfile, "\treturn %s_RuleNo[state][goalnt-1];\n", prefix);
 748         fprintf(outfile, "};\n");
 749 }
 750
 751 static StrTable kids;
 752
 753 static void
 754 doKids(ast) RuleAST ast;
 755 {
 756         int new;
 757
 758         vecIndex = 0;
 759         cumBuf[0] = 0;
 760         strcpy(vecBuf, "p");
 761         setVectors(ast->pat);
 762
 763         ast->kids = addString(kids, cumBuf, ast->rule->erulenum, &new);
 764
 765 }
 766
 767 void
 768 makeKids()
 769 {
 770         List e;
 771         IntList r;
 772
 773         kids = newStrTable();
 774
 775         fprintf(outfile, "#ifdef __STDC__\n");
 776         fprintf(outfile, "%s_NODEPTR_TYPE * %s_kids(%s_NODEPTR_TYPE p, int rulenumber, %s_NODEPTR_TYPE *kids) {\n", prefix, prefix, prefix, prefix);
 777         fprintf(outfile, "#else\n");
 778         fprintf(outfile, "%s_NODEPTR_TYPE * %s_kids(p, rulenumber, kids) %s_NODEPTR_TYPE p; int rulenumber; %s_NODEPTR_TYPE *kids; {\n", prefix, prefix, prefix, prefix);
 779         fprintf(outfile, "#endif\n");
 780
 781         fprintf(outfile,
 782         "\t%s_assert(p, %s_PANIC(\"NULL node pointer passed to %s_kids\\n\"));\n",
 783                                 prefix, prefix, prefix);
 784         fprintf(outfile,
 785         "\t%s_assert(kids, %s_PANIC(\"NULL kids pointer passed to %s_kids\\n\"));\n",
 786                                 prefix, prefix, prefix);
 787         fprintf(outfile, "\tswitch (rulenumber) {\n");
 788         fprintf(outfile, "\tdefault:\n");
 789         fprintf(outfile, "\t\t%s_PANIC(\"Unknown Rule %%d in %s_kids;\\n\", rulenumber);\n", prefix, prefix);
 790         fprintf(outfile, "\t\tabort();\n");
 791         fprintf(outfile, "\t\t/* NOTREACHED */\n");
 792
 793         foreachList((ListFn) doKids, ruleASTs);
 794
 795         for (e = kids->elems; e; e = e->next) {
 796                 StrTableElement el = (StrTableElement) e->x;
 797                 for (r = el->erulenos; r; r = r->next) {
 798                         int i = r->x;
 799                         fprintf(outfile, "\tcase %d:\n", i);
 800                 }
 801                 fprintf(outfile, "%s", el->str);
 802                 fprintf(outfile, "\t\tbreak;\n");
 803         }
 804         fprintf(outfile, "\t}\n");
 805         fprintf(outfile, "\treturn kids;\n");
 806         fprintf(outfile, "}\n");
 807 }
 808
 809 void
 810 makeOpLabel()
 811 {
 812         fprintf(outfile, "#ifdef __STDC__\n");
 813         fprintf(outfile, "int %s_op_label(%s_NODEPTR_TYPE p) {\n", prefix, prefix);
 814         fprintf(outfile, "#else\n");
 815         fprintf(outfile, "int %s_op_label(p) %s_NODEPTR_TYPE p; {\n", prefix, prefix);
 816         fprintf(outfile, "#endif\n");
 817         fprintf(outfile,
 818         "\t%s_assert(p, %s_PANIC(\"NULL pointer passed to %s_op_label\\n\"));\n",
 819                                 prefix, prefix, prefix);
 820         fprintf(outfile, "\treturn %s_OP_LABEL(p);\n", prefix);
 821         fprintf(outfile, "}\n");
 822 }
 823
 824 void
 825 makeStateLabel()
 826 {
 827         fprintf(outfile, "#ifdef __STDC__\n");
 828         fprintf(outfile, "int %s_state_label(%s_NODEPTR_TYPE p) {\n", prefix, prefix);
 829         fprintf(outfile, "#else\n");
 830         fprintf(outfile, "int %s_state_label(p) %s_NODEPTR_TYPE p; {\n", prefix, prefix);
 831         fprintf(outfile, "#endif\n");
 832
 833         fprintf(outfile,
 834         "\t%s_assert(p, %s_PANIC(\"NULL pointer passed to %s_state_label\\n\"));\n",
 835                                 prefix, prefix, prefix);
 836         fprintf(outfile, "\treturn %s_STATE_LABEL(p);\n", prefix);
 837         fprintf(outfile, "}\n");
 838 }
 839
 840 void
 841 makeChild()
 842 {
 843         fprintf(outfile, "#ifdef __STDC__\n");
 844         fprintf(outfile, "%s_NODEPTR_TYPE %s_child(%s_NODEPTR_TYPE p, int index) {\n", prefix, prefix, prefix);
 845         fprintf(outfile, "#else\n");
 846         fprintf(outfile, "%s_NODEPTR_TYPE %s_child(p, index) %s_NODEPTR_TYPE p; int index; {\n", prefix, prefix, prefix);
 847         fprintf(outfile, "#endif\n");
 848
 849         fprintf(outfile,
 850         "\t%s_assert(p, %s_PANIC(\"NULL pointer passed to %s_child\\n\"));\n",
 851                                 prefix, prefix, prefix);
 852         fprintf(outfile, "\tswitch (index) {\n");
 853         fprintf(outfile, "\tcase 0:\n");
 854         fprintf(outfile, "\t\treturn %s_LEFT_CHILD(p);\n", prefix);
 855         fprintf(outfile, "\tcase 1:\n");
 856         fprintf(outfile, "\t\treturn %s_RIGHT_CHILD(p);\n", prefix);
 857         fprintf(outfile, "\t}\n");
 858         fprintf(outfile, "\t%s_PANIC(\"Bad index %%d in %s_child;\\n\", index);\n", prefix, prefix);
 859         fprintf(outfile, "\tabort();\n");
 860         fprintf(outfile, "\treturn 0;\n");
 861         fprintf(outfile, "}\n");
 862 }
 863
 864 static Operator *opVector;
 865 static int maxOperator;
 866
 867 void
 868 makeOperatorVector()
 869 {
 870         List l;
 871
 872         maxOperator = 0;
 873         for (l = operators; l; l = l->next) {
 874                 Operator op = (Operator) l->x;
 875                 if (op->num > maxOperator) {
 876                         maxOperator = op->num;
 877                 }
 878         }
 879         opVector = (Operator*) zalloc((maxOperator+1) * sizeof(*opVector));
 880         for (l = operators; l; l = l->next) {
 881                 Operator op = (Operator) l->x;
 882                 if (opVector[op->num]) {
 883                         fprintf(stderr, "ERROR: Non-unique external symbol number (%d)\n", op->num);
 884                         exit(1);
 885                 }
 886                 opVector[op->num] = op;
 887         }
 888 }
 889
 890 void
 891 makeOperators()
 892 {
 893         int i;
 894
 895         if (!opVector) {
 896                 makeOperatorVector();
 897         }
 898         fprintf(outfile, "const char * %s_opname[] = {\n", prefix);
 899         for (i = 0; i <= maxOperator; i++) {
 900                 if (i > 0) {
 901                         fprintf(outfile, ", /* %d */\n", i-1);
 902                 }
 903                 if (opVector[i]) {
 904                         fprintf(outfile, "\t\"%s\"", opVector[i]->name);
 905                 } else {
 906                         fprintf(outfile, "\t0");
 907                 }
 908         }
 909         fprintf(outfile, "\n};\n");
 910         fprintf(outfile, "char %s_arity[] = {\n", prefix);
 911         for (i = 0; i <= maxOperator; i++) {
 912                 if (i > 0) {
 913                         fprintf(outfile, ", /* %d */\n", i-1);
 914                 }
 915                 fprintf(outfile, "\t%d", opVector[i] ? opVector[i]->arity : -1);
 916         }
 917         fprintf(outfile, "\n};\n");
 918         fprintf(outfile, "int %s_max_op = %d;\n", prefix, maxOperator);
 919         fprintf(outfile, "int %s_max_state = %d;\n", prefix, globalMap->count-1);
 920         fprintf(outfile, "#define %s_Max_state %d\n", prefix, globalMap->count-1);
 921 }
 922
 923 void
 924 makeDebug()
 925 {
 926         fprintf(outfile, "#ifdef DEBUG\n");
 927         fprintf(outfile, "int %s_debug;\n", prefix);
 928         fprintf(outfile, "#endif /* DEBUG */\n");
 929 }
 930
 931 void
 932 makeSimple()
 933 {
 934         makeRuleTable();
 935         makeTables();
 936         makeRule();
 937         makeState();
 938 }
 939
 940 void
 941 startOptional()
 942 {
 943         fprintf(outfile, "#ifdef %s_STATE_LABEL\n", prefix);
 944         fprintf(outfile, "#define %s_INCLUDE_EXTRA\n", prefix);
 945         fprintf(outfile, "#else\n");
 946         fprintf(outfile, "#ifdef STATE_LABEL\n");
 947         fprintf(outfile, "#define %s_INCLUDE_EXTRA\n", prefix);
 948         fprintf(outfile, "#define %s_STATE_LABEL \tSTATE_LABEL\n", prefix);
 949         fprintf(outfile, "#define %s_NODEPTR_TYPE\tNODEPTR_TYPE\n", prefix);
 950         fprintf(outfile, "#define %s_LEFT_CHILD  \tLEFT_CHILD\n", prefix);
 951         fprintf(outfile, "#define %s_OP_LABEL    \tOP_LABEL\n", prefix);
 952         fprintf(outfile, "#define %s_RIGHT_CHILD \tRIGHT_CHILD\n", prefix);
 953         fprintf(outfile, "#endif /* STATE_LABEL */\n");
 954         fprintf(outfile, "#endif /* %s_STATE_LABEL */\n\n", prefix);
 955
 956         fprintf(outfile, "#ifdef %s_INCLUDE_EXTRA\n\n", prefix);
 957
 958 }
 959
 960 void
 961 makeNonterminals()
 962 {
 963         List l;
 964
 965         for (l = nonterminals; l; l = l->next) {
 966                 NonTerminal nt = (NonTerminal) l->x;
 967                 if (nt->num < last_user_nonterminal) {
 968                         fprintf(outfile, "#define %s_%s_NT %d\n", prefix, nt->name, nt->num);
 969                 }
 970         }
 971         fprintf(outfile, "#define %s_NT %d\n", prefix, last_user_nonterminal-1);
 972 }
 973
 974 void
 975 makeNonterminalArray()
 976 {
 977         int i;
 978         List l;
 979         NonTerminal *nta;
 980
 981         nta = (NonTerminal *) zalloc(sizeof(*nta) * last_user_nonterminal);
 982
 983         for (l = nonterminals; l; l = l->next) {
 984                 NonTerminal nt = (NonTerminal) l->x;
 985                 if (nt->num < last_user_nonterminal) {
 986                         nta[nt->num] = nt;
 987                 }
 988         }
 989
 990         fprintf(outfile, "const char *%s_ntname[] = {\n", prefix);
 991         fprintf(outfile, "\t\"Error: Nonterminals are > 0\",\n");
 992         for (i = 1; i < last_user_nonterminal; i++) {
 993                 fprintf(outfile, "\t\"%s\",\n", nta[i]->name);
 994         }
 995         fprintf(outfile, "\t0\n");
 996         fprintf(outfile, "};\n\n");
 997
 998         zfree(nta);
 999 }
1000
1001 void
1002 endOptional()
1003 {
1004         fprintf(outfile, "#endif /* %s_INCLUDE_EXTRA */\n", prefix);
1005 }
1006
1007 void
1008 startBurm()
1009 {
1010         fprintf(outfile, "#ifndef %s_PANIC\n", prefix);
1011         fprintf(outfile, "#define %s_PANIC\tPANIC\n", prefix);
1012         fprintf(outfile, "#endif /* %s_PANIC */\n", prefix);
1013         fprintf(outfile, "#ifdef __STDC__\n");
1014         fprintf(outfile, "extern void abort(void);\n");
1015         fprintf(outfile, "#else\n");
1016         fprintf(outfile, "extern void abort();\n");
1017         fprintf(outfile, "#endif\n");
1018         fprintf(outfile, "#ifdef NDEBUG\n");
1019         fprintf(outfile, "#define %s_assert(x,y)\t;\n", prefix);
1020         fprintf(outfile, "#else\n");
1021         fprintf(outfile, "#define %s_assert(x,y)\tif(!(x)) {y; abort();}\n", prefix);
1022         fprintf(outfile, "#endif\n");
1023 }
1024
1025 void
1026 reportDiagnostics()
1027 {
1028         List l;
1029
1030         for (l = operators; l; l = l->next) {
1031                 Operator op = (Operator) l->x;
1032                 if (!op->ref) {
1033                         fprintf(stderr, "warning: Unreferenced Operator: %s\n", op->name);
1034                 }
1035         }
1036         for (l = rules; l; l = l->next) {
1037                 Rule r = (Rule) l->x;
1038                 if (!r->used && r->num < max_ruleAST) {
1039                         fprintf(stderr, "warning: Unused Rule: #%d\n", r->erulenum);
1040                 }
1041         }
1042         if (!start->pmap) {
1043                 fprintf(stderr, "warning: Start Nonterminal (%s) does not appear on LHS.\n", start->name);
1044         }
1045
1046         fprintf(stderr, "start symbol = \"%s\"\n", start->name);
1047         fprintf(stderr, "# of states = %d\n", globalMap->count-1);
1048         fprintf(stderr, "# of nonterminals = %d\n", max_nonterminal-1);
1049         fprintf(stderr, "# of user nonterminals = %d\n", last_user_nonterminal-1);
1050         fprintf(stderr, "# of rules = %d\n", max_rule);
1051         fprintf(stderr, "# of user rules = %d\n", max_ruleAST);
1052 }