contrib/byacc/reader.c

   1 /* $Id: reader.c,v 1.58 2014/10/06 22:15:08 tom Exp $ */
   2
   3 #include "defs.h"
   4
   5 /*  The line size must be a positive integer.  One hundred was chosen   */
   6 /*  because few lines in Yacc input grammars exceed 100 characters.     */
   7 /*  Note that if a line exceeds LINESIZE characters, the line buffer    */
   8 /*  will be expanded to accomodate it.                                  */
   9
  10 #define LINESIZE 100
  11
  12 #define L_CURL  '{'
  13 #define R_CURL  '}'
  14 #define L_PAREN '('
  15 #define R_PAREN ')'
  16 #define L_BRAC  '['
  17 #define R_BRAC  ']'
  18
  19 /* the maximum number of arguments (inherited attributes) to a non-terminal */
  20 /* this is a hard limit, but seems more than adequate */
  21 #define MAXARGS 20
  22
  23 static void start_rule(bucket *bp, int s_lineno);
  24 #if defined(YYBTYACC)
  25 static void copy_destructor(void);
  26 static char *process_destructor_XX(char *code, char *tag);
  27 #endif
  28
  29 static char *cache;
  30 static int cinc, cache_size;
  31
  32 int ntags;
  33 static int tagmax, havetags;
  34 static char **tag_table;
  35
  36 static char saw_eof;
  37 char unionized;
  38 char *cptr, *line;
  39 static int linesize;
  40
  41 static bucket *goal;
  42 static Value_t prec;
  43 static int gensym;
  44 static char last_was_action;
  45
  46 static int maxitems;
  47 static bucket **pitem;
  48
  49 static int maxrules;
  50 static bucket **plhs;
  51
  52 static size_t name_pool_size;
  53 static char *name_pool;
  54
  55 char line_format[] = "#line %d \"%s\"\n";
  56
  57 param *lex_param;
  58 param *parse_param;
  59
  60 #if defined(YYBTYACC)
  61 int destructor = 0;     /* =1 if at least one %destructor */
  62
  63 static bucket *default_destructor[3] =
  64 {0, 0, 0};
  65
  66 #define UNTYPED_DEFAULT 0
  67 #define TYPED_DEFAULT   1
  68 #define TYPE_SPECIFIED  2
  69
  70 static bucket *
  71 lookup_type_destructor(char *tag)
  72 {
  73     const char fmt[] = "%.*s destructor";
  74     char name[1024] = "\0";
  75     bucket *bp, **bpp = &default_destructor[TYPE_SPECIFIED];
  76
  77     while ((bp = *bpp) != NULL)
  78     {
  79         if (bp->tag == tag)
  80             return (bp);
  81         bpp = &bp->link;
  82     }
  83
  84     sprintf(name, fmt, (int)(sizeof(name) - sizeof(fmt)), tag);
  85     *bpp = bp = make_bucket(name);
  86     bp->tag = tag;
  87
  88     return (bp);
  89 }
  90 #endif /* defined(YYBTYACC) */
  91
  92 static void
  93 cachec(int c)
  94 {
  95     assert(cinc >= 0);
  96     if (cinc >= cache_size)
  97     {
  98         cache_size += 256;
  99         cache = TREALLOC(char, cache, cache_size);
 100         NO_SPACE(cache);
 101     }
 102     cache[cinc] = (char)c;
 103     ++cinc;
 104 }
 105
 106 static void
 107 get_line(void)
 108 {
 109     FILE *f = input_file;
 110     int c;
 111     int i;
 112
 113     if (saw_eof || (c = getc(f)) == EOF)
 114     {
 115         if (line)
 116         {
 117             FREE(line);
 118             line = 0;
 119         }
 120         cptr = 0;
 121         saw_eof = 1;
 122         return;
 123     }
 124
 125     if (line == 0 || linesize != (LINESIZE + 1))
 126     {
 127         if (line)
 128             FREE(line);
 129         linesize = LINESIZE + 1;
 130         line = TMALLOC(char, linesize);
 131         NO_SPACE(line);
 132     }
 133
 134     i = 0;
 135     ++lineno;
 136     for (;;)
 137     {
 138         line[i++] = (char)c;
 139         if (c == '\n')
 140             break;
 141         if ((i + 3) >= linesize)
 142         {
 143             linesize += LINESIZE;
 144             line = TREALLOC(char, line, linesize);
 145             NO_SPACE(line);
 146         }
 147         c = getc(f);
 148         if (c == EOF)
 149         {
 150             line[i++] = '\n';
 151             saw_eof = 1;
 152             break;
 153         }
 154     }
 155     line[i] = '\0';
 156     cptr = line;
 157     return;
 158 }
 159
 160 static char *
 161 dup_line(void)
 162 {
 163     char *p, *s, *t;
 164
 165     if (line == 0)
 166         return (0);
 167     s = line;
 168     while (*s != '\n')
 169         ++s;
 170     p = TMALLOC(char, s - line + 1);
 171     NO_SPACE(p);
 172
 173     s = line;
 174     t = p;
 175     while ((*t++ = *s++) != '\n')
 176         continue;
 177     return (p);
 178 }
 179
 180 static void
 181 skip_comment(void)
 182 {
 183     char *s;
 184
 185     int st_lineno = lineno;
 186     char *st_line = dup_line();
 187     char *st_cptr = st_line + (cptr - line);
 188
 189     s = cptr + 2;
 190     for (;;)
 191     {
 192         if (*s == '*' && s[1] == '/')
 193         {
 194             cptr = s + 2;
 195             FREE(st_line);
 196             return;
 197         }
 198         if (*s == '\n')
 199         {
 200             get_line();
 201             if (line == 0)
 202                 unterminated_comment(st_lineno, st_line, st_cptr);
 203             s = cptr;
 204         }
 205         else
 206             ++s;
 207     }
 208 }
 209
 210 static int
 211 next_inline(void)
 212 {
 213     char *s;
 214
 215     if (line == 0)
 216     {
 217         get_line();
 218         if (line == 0)
 219             return (EOF);
 220     }
 221
 222     s = cptr;
 223     for (;;)
 224     {
 225         switch (*s)
 226         {
 227         case '/':
 228             if (s[1] == '*')
 229             {
 230                 cptr = s;
 231                 skip_comment();
 232                 s = cptr;
 233                 break;
 234             }
 235             else if (s[1] == '/')
 236             {
 237                 get_line();
 238                 if (line == 0)
 239                     return (EOF);
 240                 s = cptr;
 241                 break;
 242             }
 243             /* FALLTHRU */
 244
 245         default:
 246             cptr = s;
 247             return (*s);
 248         }
 249     }
 250 }
 251
 252 static int
 253 nextc(void)
 254 {
 255     int ch;
 256     int finish = 0;
 257
 258     do
 259     {
 260         switch (ch = next_inline())
 261         {
 262         case '\n':
 263             get_line();
 264             break;
 265         case ' ':
 266         case '\t':
 267         case '\f':
 268         case '\r':
 269         case '\v':
 270         case ',':
 271         case ';':
 272             ++cptr;
 273             break;
 274         case '\\':
 275             ch = '%';
 276             /* FALLTHRU */
 277         default:
 278             finish = 1;
 279             break;
 280         }
 281     }
 282     while (!finish);
 283
 284     return ch;
 285 }
 286 /* *INDENT-OFF* */
 287 static struct keyword
 288 {
 289     char name[13];
 290     int token;
 291 }
 292 keywords[] = {
 293     { "binary",      NONASSOC },
 294 #if defined(YYBTYACC)
 295     { "destructor",  DESTRUCTOR },
 296 #endif
 297     { "expect",      EXPECT },
 298     { "expect-rr",   EXPECT_RR },
 299     { "ident",       IDENT },
 300     { "left",        LEFT },
 301     { "lex-param",   LEX_PARAM },
 302 #if defined(YYBTYACC)
 303     { "locations",   LOCATIONS },
 304 #endif
 305     { "nonassoc",    NONASSOC },
 306     { "parse-param", PARSE_PARAM },
 307     { "pure-parser", PURE_PARSER },
 308     { "right",       RIGHT },
 309     { "start",       START },
 310     { "term",        TOKEN },
 311     { "token",       TOKEN },
 312     { "token-table", TOKEN_TABLE },
 313     { "type",        TYPE },
 314     { "union",       UNION },
 315     { "yacc",        POSIX_YACC },
 316 };
 317 /* *INDENT-ON* */
 318
 319 static int
 320 compare_keys(const void *a, const void *b)
 321 {
 322     const struct keyword *p = (const struct keyword *)a;
 323     const struct keyword *q = (const struct keyword *)b;
 324     return strcmp(p->name, q->name);
 325 }
 326
 327 static int
 328 keyword(void)
 329 {
 330     int c;
 331     char *t_cptr = cptr;
 332     struct keyword *key;
 333
 334     c = *++cptr;
 335     if (isalpha(c))
 336     {
 337         cinc = 0;
 338         for (;;)
 339         {
 340             if (isalpha(c))
 341             {
 342                 if (isupper(c))
 343                     c = tolower(c);
 344                 cachec(c);
 345             }
 346             else if (isdigit(c)
 347                      || c == '-'
 348                      || c == '.'
 349                      || c == '$')
 350             {
 351                 cachec(c);
 352             }
 353             else if (c == '_')
 354             {
 355                 /* treat keywords spelled with '_' as if it were '-' */
 356                 cachec('-');
 357             }
 358             else
 359             {
 360                 break;
 361             }
 362             c = *++cptr;
 363         }
 364         cachec(NUL);
 365
 366         if ((key = bsearch(cache, keywords,
 367                            sizeof(keywords) / sizeof(*key),
 368                            sizeof(*key), compare_keys)))
 369             return key->token;
 370     }
 371     else
 372     {
 373         ++cptr;
 374         if (c == L_CURL)
 375             return (TEXT);
 376         if (c == '%' || c == '\\')
 377             return (MARK);
 378         if (c == '<')
 379             return (LEFT);
 380         if (c == '>')
 381             return (RIGHT);
 382         if (c == '0')
 383             return (TOKEN);
 384         if (c == '2')
 385             return (NONASSOC);
 386     }
 387     syntax_error(lineno, line, t_cptr);
 388 }
 389
 390 static void
 391 copy_ident(void)
 392 {
 393     int c;
 394     FILE *f = output_file;
 395
 396     c = nextc();
 397     if (c == EOF)
 398         unexpected_EOF();
 399     if (c != '"')
 400         syntax_error(lineno, line, cptr);
 401     ++outline;
 402     fprintf(f, "#ident \"");
 403     for (;;)
 404     {
 405         c = *++cptr;
 406         if (c == '\n')
 407         {
 408             fprintf(f, "\"\n");
 409             return;
 410         }
 411         putc(c, f);
 412         if (c == '"')
 413         {
 414             putc('\n', f);
 415             ++cptr;
 416             return;
 417         }
 418     }
 419 }
 420
 421 static char *
 422 copy_string(int quote)
 423 {
 424     struct mstring *temp = msnew();
 425     int c;
 426     int s_lineno = lineno;
 427     char *s_line = dup_line();
 428     char *s_cptr = s_line + (cptr - line - 1);
 429
 430     for (;;)
 431     {
 432         c = *cptr++;
 433         mputc(temp, c);
 434         if (c == quote)
 435         {
 436             FREE(s_line);
 437             return msdone(temp);
 438         }
 439         if (c == '\n')
 440             unterminated_string(s_lineno, s_line, s_cptr);
 441         if (c == '\\')
 442         {
 443             c = *cptr++;
 444             mputc(temp, c);
 445             if (c == '\n')
 446             {
 447                 get_line();
 448                 if (line == 0)
 449                     unterminated_string(s_lineno, s_line, s_cptr);
 450             }
 451         }
 452     }
 453 }
 454
 455 static char *
 456 copy_comment(void)
 457 {
 458     struct mstring *temp = msnew();
 459     int c;
 460
 461     c = *cptr;
 462     if (c == '/')
 463     {
 464         mputc(temp, '*');
 465         while ((c = *++cptr) != '\n')
 466         {
 467             mputc(temp, c);
 468             if (c == '*' && cptr[1] == '/')
 469                 mputc(temp, ' ');
 470         }
 471         mputc(temp, '*');
 472         mputc(temp, '/');
 473     }
 474     else if (c == '*')
 475     {
 476         int c_lineno = lineno;
 477         char *c_line = dup_line();
 478         char *c_cptr = c_line + (cptr - line - 1);
 479
 480         mputc(temp, c);
 481         ++cptr;
 482         for (;;)
 483         {
 484             c = *cptr++;
 485             mputc(temp, c);
 486             if (c == '*' && *cptr == '/')
 487             {
 488                 mputc(temp, '/');
 489                 ++cptr;
 490                 FREE(c_line);
 491                 return msdone(temp);
 492             }
 493             if (c == '\n')
 494             {
 495                 get_line();
 496                 if (line == 0)
 497                     unterminated_comment(c_lineno, c_line, c_cptr);
 498             }
 499         }
 500     }
 501     return msdone(temp);
 502 }
 503
 504 static void
 505 copy_text(void)
 506 {
 507     int c;
 508     FILE *f = text_file;
 509     int need_newline = 0;
 510     int t_lineno = lineno;
 511     char *t_line = dup_line();
 512     char *t_cptr = t_line + (cptr - line - 2);
 513
 514     if (*cptr == '\n')
 515     {
 516         get_line();
 517         if (line == 0)
 518             unterminated_text(t_lineno, t_line, t_cptr);
 519     }
 520     if (!lflag)
 521         fprintf(f, line_format, lineno, input_file_name);
 522
 523   loop:
 524     c = *cptr++;
 525     switch (c)
 526     {
 527     case '\n':
 528         putc('\n', f);
 529         need_newline = 0;
 530         get_line();
 531         if (line)
 532             goto loop;
 533         unterminated_text(t_lineno, t_line, t_cptr);
 534
 535     case '\'':
 536     case '"':
 537         putc(c, f);
 538         {
 539             char *s = copy_string(c);
 540             fputs(s, f);
 541             free(s);
 542         }
 543         need_newline = 1;
 544         goto loop;
 545
 546     case '/':
 547         putc(c, f);
 548         {
 549             char *s = copy_comment();
 550             fputs(s, f);
 551             free(s);
 552         }
 553         need_newline = 1;
 554         goto loop;
 555
 556     case '%':
 557     case '\\':
 558         if (*cptr == R_CURL)
 559         {
 560             if (need_newline)
 561                 putc('\n', f);
 562             ++cptr;
 563             FREE(t_line);
 564             return;
 565         }
 566         /* FALLTHRU */
 567
 568     default:
 569         putc(c, f);
 570         need_newline = 1;
 571         goto loop;
 572     }
 573 }
 574
 575 static void
 576 puts_both(const char *s)
 577 {
 578     fputs(s, text_file);
 579     if (dflag)
 580         fputs(s, union_file);
 581 }
 582
 583 static void
 584 putc_both(int c)
 585 {
 586     putc(c, text_file);
 587     if (dflag)
 588         putc(c, union_file);
 589 }
 590
 591 static void
 592 copy_union(void)
 593 {
 594     int c;
 595     int depth;
 596     int u_lineno = lineno;
 597     char *u_line = dup_line();
 598     char *u_cptr = u_line + (cptr - line - 6);
 599
 600     if (unionized)
 601         over_unionized(cptr - 6);
 602     unionized = 1;
 603
 604     if (!lflag)
 605         fprintf(text_file, line_format, lineno, input_file_name);
 606
 607     puts_both("#ifdef YYSTYPE\n");
 608     puts_both("#undef  YYSTYPE_IS_DECLARED\n");
 609     puts_both("#define YYSTYPE_IS_DECLARED 1\n");
 610     puts_both("#endif\n");
 611     puts_both("#ifndef YYSTYPE_IS_DECLARED\n");
 612     puts_both("#define YYSTYPE_IS_DECLARED 1\n");
 613     puts_both("typedef union");
 614
 615     depth = 0;
 616   loop:
 617     c = *cptr++;
 618     putc_both(c);
 619     switch (c)
 620     {
 621     case '\n':
 622         get_line();
 623         if (line == 0)
 624             unterminated_union(u_lineno, u_line, u_cptr);
 625         goto loop;
 626
 627     case L_CURL:
 628         ++depth;
 629         goto loop;
 630
 631     case R_CURL:
 632         if (--depth == 0)
 633         {
 634             puts_both(" YYSTYPE;\n");
 635             puts_both("#endif /* !YYSTYPE_IS_DECLARED */\n");
 636             FREE(u_line);
 637             return;
 638         }
 639         goto loop;
 640
 641     case '\'':
 642     case '"':
 643         {
 644             char *s = copy_string(c);
 645             puts_both(s);
 646             free(s);
 647         }
 648         goto loop;
 649
 650     case '/':
 651         {
 652             char *s = copy_comment();
 653             puts_both(s);
 654             free(s);
 655         }
 656         goto loop;
 657
 658     default:
 659         goto loop;
 660     }
 661 }
 662
 663 static char *
 664 after_blanks(char *s)
 665 {
 666     while (*s != '\0' && isspace(UCH(*s)))
 667         ++s;
 668     return s;
 669 }
 670
 671 /*
 672  * Trim leading/trailing blanks, and collapse multiple embedded blanks to a
 673  * single space.  Return index to last character in the buffer.
 674  */
 675 static int
 676 trim_blanks(char *buffer)
 677 {
 678     if (*buffer != '\0')
 679     {
 680         char *d = buffer;
 681         char *s = after_blanks(d);
 682
 683         while ((*d++ = *s++) != '\0')
 684         {
 685             ;
 686         }
 687
 688         --d;
 689         while ((--d != buffer) && isspace(UCH(*d)))
 690             *d = '\0';
 691
 692         for (s = d = buffer; (*d++ = *s++) != '\0';)
 693         {
 694             if (isspace(UCH(*s)))
 695             {
 696                 *s = ' ';
 697                 while (isspace(UCH(*s)))
 698                 {
 699                     *s++ = ' ';
 700                 }
 701                 --s;
 702             }
 703         }
 704     }
 705
 706     return (int)strlen(buffer) - 1;
 707 }
 708
 709 /*
 710  * Scan forward in the current line-buffer looking for a right-curly bracket.
 711  *
 712  * Parameters begin with a left-curly bracket, and continue until there are no
 713  * more interesting characters after the last right-curly bracket on the
 714  * current line.  Bison documents parameters as separated like this:
 715  *      {type param1} {type2 param2}
 716  * but also accepts commas (although some versions of bison mishandle this)
 717  *      {type param1,  type2 param2}
 718  */
 719 static int
 720 more_curly(void)
 721 {
 722     char *save = cptr;
 723     int result = 0;
 724     int finish = 0;
 725     do
 726     {
 727         switch (next_inline())
 728         {
 729         case 0:
 730         case '\n':
 731             finish = 1;
 732             break;
 733         case R_CURL:
 734             finish = 1;
 735             result = 1;
 736             break;
 737         }
 738         ++cptr;
 739     }
 740     while (!finish);
 741     cptr = save;
 742     return result;
 743 }
 744
 745 static void
 746 save_param(int k, char *buffer, int name, int type2)
 747 {
 748     param *head, *p;
 749
 750     p = TMALLOC(param, 1);
 751     NO_SPACE(p);
 752
 753     p->type2 = strdup(buffer + type2);
 754     NO_SPACE(p->type2);
 755     buffer[type2] = '\0';
 756     (void)trim_blanks(p->type2);
 757
 758     p->name = strdup(buffer + name);
 759     NO_SPACE(p->name);
 760     buffer[name] = '\0';
 761     (void)trim_blanks(p->name);
 762
 763     p->type = strdup(buffer);
 764     NO_SPACE(p->type);
 765     (void)trim_blanks(p->type);
 766
 767     if (k == LEX_PARAM)
 768         head = lex_param;
 769     else
 770         head = parse_param;
 771
 772     if (head != NULL)
 773     {
 774         while (head->next)
 775             head = head->next;
 776         head->next = p;
 777     }
 778     else
 779     {
 780         if (k == LEX_PARAM)
 781             lex_param = p;
 782         else
 783             parse_param = p;
 784     }
 785     p->next = NULL;
 786 }
 787
 788 /*
 789  * Keep a linked list of parameters.  This may be multi-line, if the trailing
 790  * right-curly bracket is absent.
 791  */
 792 static void
 793 copy_param(int k)
 794 {
 795     int c;
 796     int name, type2;
 797     int curly = 0;
 798     char *buf = 0;
 799     int i = -1;
 800     size_t buf_size = 0;
 801     int st_lineno = lineno;
 802     char *comma;
 803
 804     do
 805     {
 806         int state = curly;
 807         c = next_inline();
 808         switch (c)
 809         {
 810         case EOF:
 811             unexpected_EOF();
 812             break;
 813         case L_CURL:
 814             if (curly == 1)
 815             {
 816                 goto oops;
 817             }
 818             curly = 1;
 819             st_lineno = lineno;
 820             break;
 821         case R_CURL:
 822             if (curly != 1)
 823             {
 824                 goto oops;
 825             }
 826             curly = 2;
 827             break;
 828         case '\n':
 829             if (curly == 0)
 830             {
 831                 goto oops;
 832             }
 833             break;
 834         case '%':
 835             if ((curly == 1) && (cptr == line))
 836             {
 837                 lineno = st_lineno;
 838                 missing_brace();
 839             }
 840             /* FALLTHRU */
 841         case '"':
 842         case '\'':
 843             goto oops;
 844         default:
 845             if (curly == 0 && !isspace(UCH(c)))
 846             {
 847                 goto oops;
 848             }
 849             break;
 850         }
 851         if (buf == 0)
 852         {
 853             buf_size = (size_t) linesize;
 854             buf = TMALLOC(char, buf_size);
 855         }
 856         else if (c == '\n')
 857         {
 858             get_line();
 859             if (line == 0)
 860                 unexpected_EOF();
 861             --cptr;
 862             buf_size += (size_t) linesize;
 863             buf = TREALLOC(char, buf, buf_size);
 864         }
 865         NO_SPACE(buf);
 866         if (curly)
 867         {
 868             if ((state == 2) && (c == L_CURL))
 869             {
 870                 buf[++i] = ',';
 871             }
 872             else if ((state == 2) && isspace(UCH(c)))
 873             {
 874                 ;
 875             }
 876             else if ((c != L_CURL) && (c != R_CURL))
 877             {
 878                 buf[++i] = (char)c;
 879             }
 880         }
 881         cptr++;
 882     }
 883     while (curly < 2 || more_curly());
 884
 885     if (i == 0)
 886     {
 887         if (curly == 1)
 888         {
 889             lineno = st_lineno;
 890             missing_brace();
 891         }
 892         goto oops;
 893     }
 894
 895     buf[i--] = '\0';
 896     i = trim_blanks(buf);
 897
 898     comma = buf - 1;
 899     do
 900     {
 901         char *parms = (comma + 1);
 902         comma = strchr(parms, ',');
 903         if (comma != 0)
 904             *comma = '\0';
 905
 906         (void)trim_blanks(parms);
 907         i = (int)strlen(parms) - 1;
 908         if (i < 0)
 909         {
 910             goto oops;
 911         }
 912
 913         if (parms[i] == ']')
 914         {
 915             int level = 1;
 916             while (i >= 0 && level > 0 && parms[i] != '[')
 917             {
 918                 if (parms[i] == ']')
 919                     ++level;
 920                 else if (parms[i] == '[')
 921                     --level;
 922                 i--;
 923             }
 924             if (i <= 0)
 925                 unexpected_EOF();
 926             type2 = i--;
 927         }
 928         else
 929         {
 930             type2 = i + 1;
 931         }
 932
 933         while (i > 0 && (isalnum(UCH(parms[i])) || UCH(parms[i]) == '_'))
 934             i--;
 935
 936         if (!isspace(UCH(parms[i])) && parms[i] != '*')
 937             goto oops;
 938
 939         name = i + 1;
 940
 941         save_param(k, parms, name, type2);
 942     }
 943     while (comma != 0);
 944     FREE(buf);
 945     return;
 946
 947   oops:
 948     FREE(buf);
 949     syntax_error(lineno, line, cptr);
 950 }
 951
 952 static int
 953 hexval(int c)
 954 {
 955     if (c >= '0' && c <= '9')
 956         return (c - '0');
 957     if (c >= 'A' && c <= 'F')
 958         return (c - 'A' + 10);
 959     if (c >= 'a' && c <= 'f')
 960         return (c - 'a' + 10);
 961     return (-1);
 962 }
 963
 964 static bucket *
 965 get_literal(void)
 966 {
 967     int c, quote;
 968     int i;
 969     int n;
 970     char *s;
 971     bucket *bp;
 972     int s_lineno = lineno;
 973     char *s_line = dup_line();
 974     char *s_cptr = s_line + (cptr - line);
 975
 976     quote = *cptr++;
 977     cinc = 0;
 978     for (;;)
 979     {
 980         c = *cptr++;
 981         if (c == quote)
 982             break;
 983         if (c == '\n')
 984             unterminated_string(s_lineno, s_line, s_cptr);
 985         if (c == '\\')
 986         {
 987             char *c_cptr = cptr - 1;
 988
 989             c = *cptr++;
 990             switch (c)
 991             {
 992             case '\n':
 993                 get_line();
 994                 if (line == 0)
 995                     unterminated_string(s_lineno, s_line, s_cptr);
 996                 continue;
 997
 998             case '0':
 999             case '1':
1000             case '2':
1001             case '3':
1002             case '4':
1003             case '5':
1004             case '6':
1005             case '7':
1006                 n = c - '0';
1007                 c = *cptr;
1008                 if (IS_OCTAL(c))
1009                 {
1010                     n = (n << 3) + (c - '0');
1011                     c = *++cptr;
1012                     if (IS_OCTAL(c))
1013                     {
1014                         n = (n << 3) + (c - '0');
1015                         ++cptr;
1016                     }
1017                 }
1018                 if (n > MAXCHAR)
1019                     illegal_character(c_cptr);
1020                 c = n;
1021                 break;
1022
1023             case 'x':
1024                 c = *cptr++;
1025                 n = hexval(c);
1026                 if (n < 0 || n >= 16)
1027                     illegal_character(c_cptr);
1028                 for (;;)
1029                 {
1030                     c = *cptr;
1031                     i = hexval(c);
1032                     if (i < 0 || i >= 16)
1033                         break;
1034                     ++cptr;
1035                     n = (n << 4) + i;
1036                     if (n > MAXCHAR)
1037                         illegal_character(c_cptr);
1038                 }
1039                 c = n;
1040                 break;
1041
1042             case 'a':
1043                 c = 7;
1044                 break;
1045             case 'b':
1046                 c = '\b';
1047                 break;
1048             case 'f':
1049                 c = '\f';
1050                 break;
1051             case 'n':
1052                 c = '\n';
1053                 break;
1054             case 'r':
1055                 c = '\r';
1056                 break;
1057             case 't':
1058                 c = '\t';
1059                 break;
1060             case 'v':
1061                 c = '\v';
1062                 break;
1063             }
1064         }
1065         cachec(c);
1066     }
1067     FREE(s_line);
1068
1069     n = cinc;
1070     s = TMALLOC(char, n);
1071     NO_SPACE(s);
1072
1073     for (i = 0; i < n; ++i)
1074         s[i] = cache[i];
1075
1076     cinc = 0;
1077     if (n == 1)
1078         cachec('\'');
1079     else
1080         cachec('"');
1081
1082     for (i = 0; i < n; ++i)
1083     {
1084         c = UCH(s[i]);
1085         if (c == '\\' || c == cache[0])
1086         {
1087             cachec('\\');
1088             cachec(c);
1089         }
1090         else if (isprint(c))
1091             cachec(c);
1092         else
1093         {
1094             cachec('\\');
1095             switch (c)
1096             {
1097             case 7:
1098                 cachec('a');
1099                 break;
1100             case '\b':
1101                 cachec('b');
1102                 break;
1103             case '\f':
1104                 cachec('f');
1105                 break;
1106             case '\n':
1107                 cachec('n');
1108                 break;
1109             case '\r':
1110                 cachec('r');
1111                 break;
1112             case '\t':
1113                 cachec('t');
1114                 break;
1115             case '\v':
1116                 cachec('v');
1117                 break;
1118             default:
1119                 cachec(((c >> 6) & 7) + '0');
1120                 cachec(((c >> 3) & 7) + '0');
1121                 cachec((c & 7) + '0');
1122                 break;
1123             }
1124         }
1125     }
1126
1127     if (n == 1)
1128         cachec('\'');
1129     else
1130         cachec('"');
1131
1132     cachec(NUL);
1133     bp = lookup(cache);
1134     bp->class = TERM;
1135     if (n == 1 && bp->value == UNDEFINED)
1136         bp->value = UCH(*s);
1137     FREE(s);
1138
1139     return (bp);
1140 }
1141
1142 static int
1143 is_reserved(char *name)
1144 {
1145     char *s;
1146
1147     if (strcmp(name, ".") == 0 ||
1148         strcmp(name, "$accept") == 0 ||
1149         strcmp(name, "$end") == 0)
1150         return (1);
1151
1152     if (name[0] == '$' && name[1] == '$' && isdigit(UCH(name[2])))
1153     {
1154         s = name + 3;
1155         while (isdigit(UCH(*s)))
1156             ++s;
1157         if (*s == NUL)
1158             return (1);
1159     }
1160
1161     return (0);
1162 }
1163
1164 static bucket *
1165 get_name(void)
1166 {
1167     int c;
1168
1169     cinc = 0;
1170     for (c = *cptr; IS_IDENT(c); c = *++cptr)
1171         cachec(c);
1172     cachec(NUL);
1173
1174     if (is_reserved(cache))
1175         used_reserved(cache);
1176
1177     return (lookup(cache));
1178 }
1179
1180 static Value_t
1181 get_number(void)
1182 {
1183     int c;
1184     Value_t n;
1185
1186     n = 0;
1187     for (c = *cptr; isdigit(c); c = *++cptr)
1188         n = (Value_t) (10 * n + (c - '0'));
1189
1190     return (n);
1191 }
1192
1193 static char *
1194 cache_tag(char *tag, size_t len)
1195 {
1196     int i;
1197     char *s;
1198
1199     for (i = 0; i < ntags; ++i)
1200     {
1201         if (strncmp(tag, tag_table[i], len) == 0 &&
1202             tag_table[i][len] == NUL)
1203             return (tag_table[i]);
1204     }
1205
1206     if (ntags >= tagmax)
1207     {
1208         tagmax += 16;
1209         tag_table =
1210             (tag_table
1211              ? TREALLOC(char *, tag_table, tagmax)
1212              : TMALLOC(char *, tagmax));
1213         NO_SPACE(tag_table);
1214     }
1215
1216     s = TMALLOC(char, len + 1);
1217     NO_SPACE(s);
1218
1219     strncpy(s, tag, len);
1220     s[len] = 0;
1221     tag_table[ntags++] = s;
1222     return s;
1223 }
1224
1225 static char *
1226 get_tag(void)
1227 {
1228     int c;
1229     int t_lineno = lineno;
1230     char *t_line = dup_line();
1231     char *t_cptr = t_line + (cptr - line);
1232
1233     ++cptr;
1234     c = nextc();
1235     if (c == EOF)
1236         unexpected_EOF();
1237     if (!isalpha(c) && c != '_' && c != '$')
1238         illegal_tag(t_lineno, t_line, t_cptr);
1239
1240     cinc = 0;
1241     do
1242     {
1243         cachec(c);
1244         c = *++cptr;
1245     }
1246     while (IS_IDENT(c));
1247     cachec(NUL);
1248
1249     c = nextc();
1250     if (c == EOF)
1251         unexpected_EOF();
1252     if (c != '>')
1253         illegal_tag(t_lineno, t_line, t_cptr);
1254     ++cptr;
1255
1256     FREE(t_line);
1257     havetags = 1;
1258     return cache_tag(cache, (size_t) cinc);
1259 }
1260
1261 #if defined(YYBTYACC)
1262 static char *
1263 scan_id(void)
1264 {
1265     char *b = cptr;
1266
1267     while (isalnum(*cptr) || *cptr == '_' || *cptr == '$')
1268         cptr++;
1269     return cache_tag(b, (size_t) (cptr - b));
1270 }
1271 #endif
1272
1273 static void
1274 declare_tokens(int assoc)
1275 {
1276     int c;
1277     bucket *bp;
1278     Value_t value;
1279     char *tag = 0;
1280
1281     if (assoc != TOKEN)
1282         ++prec;
1283
1284     c = nextc();
1285     if (c == EOF)
1286         unexpected_EOF();
1287     if (c == '<')
1288     {
1289         tag = get_tag();
1290         c = nextc();
1291         if (c == EOF)
1292             unexpected_EOF();
1293     }
1294
1295     for (;;)
1296     {
1297         if (isalpha(c) || c == '_' || c == '.' || c == '$')
1298             bp = get_name();
1299         else if (c == '\'' || c == '"')
1300             bp = get_literal();
1301         else
1302             return;
1303
1304         if (bp == goal)
1305             tokenized_start(bp->name);
1306         bp->class = TERM;
1307
1308         if (tag)
1309         {
1310             if (bp->tag && tag != bp->tag)
1311                 retyped_warning(bp->name);
1312             bp->tag = tag;
1313         }
1314
1315         if (assoc != TOKEN)
1316         {
1317             if (bp->prec && prec != bp->prec)
1318                 reprec_warning(bp->name);
1319             bp->assoc = (Assoc_t) assoc;
1320             bp->prec = prec;
1321         }
1322
1323         c = nextc();
1324         if (c == EOF)
1325             unexpected_EOF();
1326
1327         if (isdigit(c))
1328         {
1329             value = get_number();
1330             if (bp->value != UNDEFINED && value != bp->value)
1331                 revalued_warning(bp->name);
1332             bp->value = value;
1333             c = nextc();
1334             if (c == EOF)
1335                 unexpected_EOF();
1336         }
1337     }
1338 }
1339
1340 /*
1341  * %expect requires special handling
1342  * as it really isn't part of the yacc
1343  * grammar only a flag for yacc proper.
1344  */
1345 static void
1346 declare_expect(int assoc)
1347 {
1348     int c;
1349
1350     if (assoc != EXPECT && assoc != EXPECT_RR)
1351         ++prec;
1352
1353     /*
1354      * Stay away from nextc - doesn't
1355      * detect EOL and will read to EOF.
1356      */
1357     c = *++cptr;
1358     if (c == EOF)
1359         unexpected_EOF();
1360
1361     for (;;)
1362     {
1363         if (isdigit(c))
1364         {
1365             if (assoc == EXPECT)
1366                 SRexpect = get_number();
1367             else
1368                 RRexpect = get_number();
1369             break;
1370         }
1371         /*
1372          * Looking for number before EOL.
1373          * Spaces, tabs, and numbers are ok,
1374          * words, punc., etc. are syntax errors.
1375          */
1376         else if (c == '\n' || isalpha(c) || !isspace(c))
1377         {
1378             syntax_error(lineno, line, cptr);
1379         }
1380         else
1381         {
1382             c = *++cptr;
1383             if (c == EOF)
1384                 unexpected_EOF();
1385         }
1386     }
1387 }
1388
1389 #if defined(YYBTYACC)
1390 static void
1391 declare_argtypes(bucket *bp)
1392 {
1393     char *tags[MAXARGS];
1394     int args = 0, c;
1395
1396     if (bp->args >= 0)
1397         retyped_warning(bp->name);
1398     cptr++;                     /* skip open paren */
1399     for (;;)
1400     {
1401         c = nextc();
1402         if (c == EOF)
1403             unexpected_EOF();
1404         if (c != '<')
1405             syntax_error(lineno, line, cptr);
1406         tags[args++] = get_tag();
1407         c = nextc();
1408         if (c == R_PAREN)
1409             break;
1410         if (c == EOF)
1411             unexpected_EOF();
1412     }
1413     cptr++;                     /* skip close paren */
1414     bp->args = args;
1415     bp->argnames = TMALLOC(char *, args);
1416     NO_SPACE(bp->argnames);
1417     bp->argtags = CALLOC(sizeof(char *), args + 1);
1418     NO_SPACE(bp->argtags);
1419     while (--args >= 0)
1420     {
1421         bp->argtags[args] = tags[args];
1422         bp->argnames[args] = NULL;
1423     }
1424 }
1425 #endif
1426
1427 static void
1428 declare_types(void)
1429 {
1430     int c;
1431     bucket *bp;
1432     char *tag = NULL;
1433
1434     c = nextc();
1435     if (c == EOF)
1436         unexpected_EOF();
1437     if (c == '<')
1438         tag = get_tag();
1439
1440     for (;;)
1441     {
1442         c = nextc();
1443         if (c == EOF)
1444             unexpected_EOF();
1445         if (isalpha(c) || c == '_' || c == '.' || c == '$')
1446         {
1447             bp = get_name();
1448 #if defined(YYBTYACC)
1449             if (nextc() == L_PAREN)
1450                 declare_argtypes(bp);
1451             else
1452                 bp->args = 0;
1453 #endif
1454         }
1455         else if (c == '\'' || c == '"')
1456         {
1457             bp = get_literal();
1458 #if defined(YYBTYACC)
1459             bp->args = 0;
1460 #endif
1461         }
1462         else
1463             return;
1464
1465         if (tag)
1466         {
1467             if (bp->tag && tag != bp->tag)
1468                 retyped_warning(bp->name);
1469             bp->tag = tag;
1470         }
1471     }
1472 }
1473
1474 static void
1475 declare_start(void)
1476 {
1477     int c;
1478     bucket *bp;
1479
1480     c = nextc();
1481     if (c == EOF)
1482         unexpected_EOF();
1483     if (!isalpha(c) && c != '_' && c != '.' && c != '$')
1484         syntax_error(lineno, line, cptr);
1485     bp = get_name();
1486     if (bp->class == TERM)
1487         terminal_start(bp->name);
1488     if (goal && goal != bp)
1489         restarted_warning();
1490     goal = bp;
1491 }
1492
1493 static void
1494 read_declarations(void)
1495 {
1496     int c, k;
1497
1498     cache_size = 256;
1499     cache = TMALLOC(char, cache_size);
1500     NO_SPACE(cache);
1501
1502     for (;;)
1503     {
1504         c = nextc();
1505         if (c == EOF)
1506             unexpected_EOF();
1507         if (c != '%')
1508             syntax_error(lineno, line, cptr);
1509         switch (k = keyword())
1510         {
1511         case MARK:
1512             return;
1513
1514         case IDENT:
1515             copy_ident();
1516             break;
1517
1518         case TEXT:
1519             copy_text();
1520             break;
1521
1522         case UNION:
1523             copy_union();
1524             break;
1525
1526         case TOKEN:
1527         case LEFT:
1528         case RIGHT:
1529         case NONASSOC:
1530             declare_tokens(k);
1531             break;
1532
1533         case EXPECT:
1534         case EXPECT_RR:
1535             declare_expect(k);
1536             break;
1537
1538         case TYPE:
1539             declare_types();
1540             break;
1541
1542         case START:
1543             declare_start();
1544             break;
1545
1546         case PURE_PARSER:
1547             pure_parser = 1;
1548             break;
1549
1550         case PARSE_PARAM:
1551         case LEX_PARAM:
1552             copy_param(k);
1553             break;
1554
1555         case TOKEN_TABLE:
1556             token_table = 1;
1557             break;
1558
1559 #if defined(YYBTYACC)
1560         case LOCATIONS:
1561             locations = 1;
1562             break;
1563
1564         case DESTRUCTOR:
1565             destructor = 1;
1566             copy_destructor();
1567             break;
1568 #endif
1569
1570         case POSIX_YACC:
1571             /* noop for bison compatibility. byacc is already designed to be posix
1572              * yacc compatible. */
1573             break;
1574         }
1575     }
1576 }
1577
1578 static void
1579 initialize_grammar(void)
1580 {
1581     nitems = 4;
1582     maxitems = 300;
1583
1584     pitem = TMALLOC(bucket *, maxitems);
1585     NO_SPACE(pitem);
1586
1587     pitem[0] = 0;
1588     pitem[1] = 0;
1589     pitem[2] = 0;
1590     pitem[3] = 0;
1591
1592     nrules = 3;
1593     maxrules = 100;
1594
1595     plhs = TMALLOC(bucket *, maxrules);
1596     NO_SPACE(plhs);
1597
1598     plhs[0] = 0;
1599     plhs[1] = 0;
1600     plhs[2] = 0;
1601
1602     rprec = TMALLOC(Value_t, maxrules);
1603     NO_SPACE(rprec);
1604
1605     rprec[0] = 0;
1606     rprec[1] = 0;
1607     rprec[2] = 0;
1608
1609     rassoc = TMALLOC(Assoc_t, maxrules);
1610     NO_SPACE(rassoc);
1611
1612     rassoc[0] = TOKEN;
1613     rassoc[1] = TOKEN;
1614     rassoc[2] = TOKEN;
1615 }
1616
1617 static void
1618 expand_items(void)
1619 {
1620     maxitems += 300;
1621     pitem = TREALLOC(bucket *, pitem, maxitems);
1622     NO_SPACE(pitem);
1623 }
1624
1625 static void
1626 expand_rules(void)
1627 {
1628     maxrules += 100;
1629
1630     plhs = TREALLOC(bucket *, plhs, maxrules);
1631     NO_SPACE(plhs);
1632
1633     rprec = TREALLOC(Value_t, rprec, maxrules);
1634     NO_SPACE(rprec);
1635
1636     rassoc = TREALLOC(Assoc_t, rassoc, maxrules);
1637     NO_SPACE(rassoc);
1638 }
1639
1640 /* set immediately prior to where copy_args() could be called, and incremented by
1641    the various routines that will rescan the argument list as appropriate */
1642 static int rescan_lineno;
1643 #if defined(YYBTYACC)
1644
1645 static char *
1646 copy_args(int *alen)
1647 {
1648     struct mstring *s = msnew();
1649     int depth = 0, len = 1;
1650     char c, quote = 0;
1651     int a_lineno = lineno;
1652     char *a_line = dup_line();
1653     char *a_cptr = a_line + (cptr - line - 1);
1654
1655     while ((c = *cptr++) != R_PAREN || depth || quote)
1656     {
1657         if (c == ',' && !quote && !depth)
1658         {
1659             len++;
1660             mputc(s, 0);
1661             continue;
1662         }
1663         mputc(s, c);
1664         if (c == '\n')
1665         {
1666             get_line();
1667             if (!line)
1668             {
1669                 if (quote)
1670                     unterminated_string(a_lineno, a_line, a_cptr);
1671                 else
1672                     unterminated_arglist(a_lineno, a_line, a_cptr);
1673             }
1674         }
1675         else if (quote)
1676         {
1677             if (c == quote)
1678                 quote = 0;
1679             else if (c == '\\')
1680             {
1681                 if (*cptr != '\n')
1682                     mputc(s, *cptr++);
1683             }
1684         }
1685         else
1686         {
1687             if (c == L_PAREN)
1688                 depth++;
1689             else if (c == R_PAREN)
1690                 depth--;
1691             else if (c == '\"' || c == '\'')
1692                 quote = c;
1693         }
1694     }
1695     if (alen)
1696         *alen = len;
1697     FREE(a_line);
1698     return msdone(s);
1699 }
1700
1701 static char *
1702 parse_id(char *p, char **save)
1703 {
1704     char *b;
1705
1706     while (isspace(*p))
1707         if (*p++ == '\n')
1708             rescan_lineno++;
1709     if (!isalpha(*p) && *p != '_')
1710         return NULL;
1711     b = p;
1712     while (isalnum(*p) || *p == '_' || *p == '$')
1713         p++;
1714     if (save)
1715     {
1716         *save = cache_tag(b, (size_t) (p - b));
1717     }
1718     return p;
1719 }
1720
1721 static char *
1722 parse_int(char *p, int *save)
1723 {
1724     int neg = 0, val = 0;
1725
1726     while (isspace(*p))
1727         if (*p++ == '\n')
1728             rescan_lineno++;
1729     if (*p == '-')
1730     {
1731         neg = 1;
1732         p++;
1733     }
1734     if (!isdigit(*p))
1735         return NULL;
1736     while (isdigit(*p))
1737         val = val * 10 + *p++ - '0';
1738     if (neg)
1739         val = -val;
1740     if (save)
1741         *save = val;
1742     return p;
1743 }
1744
1745 static void
1746 parse_arginfo(bucket *a, char *args, int argslen)
1747 {
1748     char *p = args, *tmp;
1749     int i, redec = 0;
1750
1751     if (a->args > 0)
1752     {
1753         if (a->args != argslen)
1754             arg_number_disagree_warning(rescan_lineno, a->name);
1755         redec = 1;
1756     }
1757     else
1758     {
1759         if ((a->args = argslen) == 0)
1760             return;
1761         a->argnames = TMALLOC(char *, argslen);
1762         NO_SPACE(a->argnames);
1763         a->argtags = TMALLOC(char *, argslen);
1764         NO_SPACE(a->argtags);
1765     }
1766     if (!args)
1767         return;
1768     for (i = 0; i < argslen; i++)
1769     {
1770         while (isspace(*p))
1771             if (*p++ == '\n')
1772                 rescan_lineno++;
1773         if (*p++ != '$')
1774             bad_formals();
1775         while (isspace(*p))
1776             if (*p++ == '\n')
1777                 rescan_lineno++;
1778         if (*p == '<')
1779         {
1780             havetags = 1;
1781             if (!(p = parse_id(p + 1, &tmp)))
1782                 bad_formals();
1783             while (isspace(*p))
1784                 if (*p++ == '\n')
1785                     rescan_lineno++;
1786             if (*p++ != '>')
1787                 bad_formals();
1788             if (redec)
1789             {
1790                 if (a->argtags[i] != tmp)
1791                     arg_type_disagree_warning(rescan_lineno, i + 1, a->name);
1792             }
1793             else
1794                 a->argtags[i] = tmp;
1795         }
1796         else if (!redec)
1797             a->argtags[i] = NULL;
1798         if (!(p = parse_id(p, &a->argnames[i])))
1799             bad_formals();
1800         while (isspace(*p))
1801             if (*p++ == '\n')
1802                 rescan_lineno++;
1803         if (*p++)
1804             bad_formals();
1805     }
1806     free(args);
1807 }
1808
1809 static char *
1810 compile_arg(char **theptr, char *yyvaltag)
1811 {
1812     char *p = *theptr;
1813     struct mstring *c = msnew();
1814     int i, j, n;
1815     Value_t *offsets = NULL, maxoffset;
1816     bucket **rhs;
1817
1818     maxoffset = 0;
1819     n = 0;
1820     for (i = nitems - 1; pitem[i]; --i)
1821     {
1822         n++;
1823         if (pitem[i]->class != ARGUMENT)
1824             maxoffset++;
1825     }
1826     if (maxoffset > 0)
1827     {
1828         offsets = TMALLOC(Value_t, maxoffset + 1);
1829         NO_SPACE(offsets);
1830
1831         for (j = 0, i++; i < nitems; i++)
1832             if (pitem[i]->class != ARGUMENT)
1833                 offsets[++j] = (Value_t) (i - nitems + 1);
1834     }
1835     rhs = pitem + nitems - 1;
1836
1837     if (yyvaltag)
1838         msprintf(c, "yyval.%s = ", yyvaltag);
1839     else
1840         msprintf(c, "yyval = ");
1841     while (*p)
1842     {
1843         if (*p == '$')
1844         {
1845             char *tag = NULL;
1846             if (*++p == '<')
1847                 if (!(p = parse_id(++p, &tag)) || *p++ != '>')
1848                     illegal_tag(rescan_lineno, NULL, NULL);
1849             if (isdigit(*p) || *p == '-')
1850             {
1851                 int val;
1852                 if (!(p = parse_int(p, &val)))
1853                     dollar_error(rescan_lineno, NULL, NULL);
1854                 if (val <= 0)
1855                     i = val - n;
1856                 else if (val > maxoffset)
1857                 {
1858                     dollar_warning(rescan_lineno, val);
1859                     i = val - maxoffset;
1860                 }
1861                 else if (maxoffset > 0)
1862                 {
1863                     i = offsets[val];
1864                     if (!tag && !(tag = rhs[i]->tag) && havetags)
1865                         untyped_rhs(val, rhs[i]->name);
1866                 }
1867                 msprintf(c, "yystack.l_mark[%d]", i);
1868                 if (tag)
1869                     msprintf(c, ".%s", tag);
1870                 else if (havetags)
1871                     unknown_rhs(val);
1872             }
1873             else if (isalpha(*p) || *p == '_')
1874             {
1875                 char *arg;
1876                 if (!(p = parse_id(p, &arg)))
1877                     dollar_error(rescan_lineno, NULL, NULL);
1878                 for (i = plhs[nrules]->args - 1; i >= 0; i--)
1879                     if (arg == plhs[nrules]->argnames[i])
1880                         break;
1881                 if (i < 0)
1882                     unknown_arg_warning(rescan_lineno, "$", arg, NULL, NULL);
1883                 else if (!tag)
1884                     tag = plhs[nrules]->argtags[i];
1885                 msprintf(c, "yystack.l_mark[%d]", i - plhs[nrules]->args + 1
1886                          - n);
1887                 if (tag)
1888                     msprintf(c, ".%s", tag);
1889                 else if (havetags)
1890                     untyped_arg_warning(rescan_lineno, "$", arg);
1891             }
1892             else
1893                 dollar_error(rescan_lineno, NULL, NULL);
1894         }
1895         else if (*p == '@')
1896         {
1897             at_error(rescan_lineno, NULL, NULL);
1898         }
1899         else
1900         {
1901             if (*p == '\n')
1902                 rescan_lineno++;
1903             mputc(c, *p++);
1904         }
1905     }
1906     *theptr = p;
1907     if (maxoffset > 0)
1908         FREE(offsets);
1909     return msdone(c);
1910 }
1911
1912 #define ARG_CACHE_SIZE  1024
1913 static struct arg_cache
1914 {
1915     struct arg_cache *next;
1916     char *code;
1917     int rule;
1918 }
1919  *arg_cache[ARG_CACHE_SIZE];
1920
1921 static int
1922 lookup_arg_cache(char *code)
1923 {
1924     struct arg_cache *entry;
1925
1926     entry = arg_cache[strnshash(code) % ARG_CACHE_SIZE];
1927     while (entry)
1928     {
1929         if (!strnscmp(entry->code, code))
1930             return entry->rule;
1931         entry = entry->next;
1932     }
1933     return -1;
1934 }
1935
1936 static void
1937 insert_arg_cache(char *code, int rule)
1938 {
1939     struct arg_cache *entry = NEW(struct arg_cache);
1940     int i;
1941
1942     NO_SPACE(entry);
1943     i = strnshash(code) % ARG_CACHE_SIZE;
1944     entry->code = code;
1945     entry->rule = rule;
1946     entry->next = arg_cache[i];
1947     arg_cache[i] = entry;
1948 }
1949
1950 static void
1951 clean_arg_cache(void)
1952 {
1953     struct arg_cache *e, *t;
1954     int i;
1955
1956     for (i = 0; i < ARG_CACHE_SIZE; i++)
1957     {
1958         for (e = arg_cache[i]; (t = e); e = e->next, FREE(t))
1959             free(e->code);
1960         arg_cache[i] = NULL;
1961     }
1962 }
1963 #endif
1964
1965 static void
1966 advance_to_start(void)
1967 {
1968     int c;
1969     bucket *bp;
1970     char *s_cptr;
1971     int s_lineno;
1972 #if defined(YYBTYACC)
1973     char *args = NULL;
1974     int argslen = 0;
1975 #endif
1976
1977     for (;;)
1978     {
1979         c = nextc();
1980         if (c != '%')
1981             break;
1982         s_cptr = cptr;
1983         switch (keyword())
1984         {
1985         case MARK:
1986             no_grammar();
1987
1988         case TEXT:
1989             copy_text();
1990             break;
1991
1992         case START:
1993             declare_start();
1994             break;
1995
1996         default:
1997             syntax_error(lineno, line, s_cptr);
1998         }
1999     }
2000
2001     c = nextc();
2002     if (!isalpha(c) && c != '_' && c != '.' && c != '_')
2003         syntax_error(lineno, line, cptr);
2004     bp = get_name();
2005     if (goal == 0)
2006     {
2007         if (bp->class == TERM)
2008             terminal_start(bp->name);
2009         goal = bp;
2010     }
2011
2012     s_lineno = lineno;
2013     c = nextc();
2014     if (c == EOF)
2015         unexpected_EOF();
2016     rescan_lineno = lineno;     /* line# for possible inherited args rescan */
2017 #if defined(YYBTYACC)
2018     if (c == L_PAREN)
2019     {
2020         ++cptr;
2021         args = copy_args(&argslen);
2022         NO_SPACE(args);
2023         c = nextc();
2024     }
2025 #endif
2026     if (c != ':')
2027         syntax_error(lineno, line, cptr);
2028     start_rule(bp, s_lineno);
2029 #if defined(YYBTYACC)
2030     parse_arginfo(bp, args, argslen);
2031 #endif
2032     ++cptr;
2033 }
2034
2035 static void
2036 start_rule(bucket *bp, int s_lineno)
2037 {
2038     if (bp->class == TERM)
2039         terminal_lhs(s_lineno);
2040     bp->class = NONTERM;
2041     if (!bp->index)
2042         bp->index = nrules;
2043     if (nrules >= maxrules)
2044         expand_rules();
2045     plhs[nrules] = bp;
2046     rprec[nrules] = UNDEFINED;
2047     rassoc[nrules] = TOKEN;
2048 }
2049
2050 static void
2051 end_rule(void)
2052 {
2053     int i;
2054
2055     if (!last_was_action && plhs[nrules]->tag)
2056     {
2057         if (pitem[nitems - 1])
2058         {
2059             for (i = nitems - 1; (i > 0) && pitem[i]; --i)
2060                 continue;
2061             if (pitem[i + 1] == 0 || pitem[i + 1]->tag != plhs[nrules]->tag)
2062                 default_action_warning();
2063         }
2064         else
2065         {
2066             default_action_warning();
2067         }
2068     }
2069
2070     last_was_action = 0;
2071     if (nitems >= maxitems)
2072         expand_items();
2073     pitem[nitems] = 0;
2074     ++nitems;
2075     ++nrules;
2076 }
2077
2078 static void
2079 insert_empty_rule(void)
2080 {
2081     bucket *bp, **bpp;
2082
2083     assert(cache);
2084     sprintf(cache, "$$%d", ++gensym);
2085     bp = make_bucket(cache);
2086     last_symbol->next = bp;
2087     last_symbol = bp;
2088     bp->tag = plhs[nrules]->tag;
2089     bp->class = ACTION;
2090 #if defined(YYBTYACC)
2091     bp->args = 0;
2092 #endif
2093
2094     nitems = (Value_t) (nitems + 2);
2095     if (nitems > maxitems)
2096         expand_items();
2097     bpp = pitem + nitems - 1;
2098     *bpp-- = bp;
2099     while ((bpp[0] = bpp[-1]) != 0)
2100         --bpp;
2101
2102     if (++nrules >= maxrules)
2103         expand_rules();
2104     plhs[nrules] = plhs[nrules - 1];
2105     plhs[nrules - 1] = bp;
2106     rprec[nrules] = rprec[nrules - 1];
2107     rprec[nrules - 1] = 0;
2108     rassoc[nrules] = rassoc[nrules - 1];
2109     rassoc[nrules - 1] = TOKEN;
2110 }
2111
2112 #if defined(YYBTYACC)
2113 static char *
2114 insert_arg_rule(char *arg, char *tag)
2115 {
2116     int line_number = rescan_lineno;
2117     char *code = compile_arg(&arg, tag);
2118     int rule = lookup_arg_cache(code);
2119     FILE *f = action_file;
2120
2121     if (rule < 0)
2122     {
2123         rule = nrules;
2124         insert_arg_cache(code, rule);
2125         fprintf(f, "case %d:\n", rule - 2);
2126         if (!lflag)
2127             fprintf(f, line_format, line_number, input_file_name);
2128         fprintf(f, "%s;\n", code);
2129         fprintf(f, "break;\n");
2130         insert_empty_rule();
2131         plhs[rule]->tag = tag;
2132         plhs[rule]->class = ARGUMENT;
2133     }
2134     else
2135     {
2136         if (++nitems > maxitems)
2137             expand_items();
2138         pitem[nitems - 1] = plhs[rule];
2139         free(code);
2140     }
2141     return arg + 1;
2142 }
2143 #endif
2144
2145 static void
2146 add_symbol(void)
2147 {
2148     int c;
2149     bucket *bp;
2150     int s_lineno = lineno;
2151 #if defined(YYBTYACC)
2152     char *args = NULL;
2153     int argslen = 0;
2154 #endif
2155
2156     c = *cptr;
2157     if (c == '\'' || c == '"')
2158         bp = get_literal();
2159     else
2160         bp = get_name();
2161
2162     c = nextc();
2163     rescan_lineno = lineno;     /* line# for possible inherited args rescan */
2164 #if defined(YYBTYACC)
2165     if (c == L_PAREN)
2166     {
2167         ++cptr;
2168         args = copy_args(&argslen);
2169         NO_SPACE(args);
2170         c = nextc();
2171     }
2172 #endif
2173     if (c == ':')
2174     {
2175         end_rule();
2176         start_rule(bp, s_lineno);
2177 #if defined(YYBTYACC)
2178         parse_arginfo(bp, args, argslen);
2179 #endif
2180         ++cptr;
2181         return;
2182     }
2183
2184     if (last_was_action)
2185         insert_empty_rule();
2186     last_was_action = 0;
2187
2188 #if defined(YYBTYACC)
2189     if (bp->args < 0)
2190         bp->args = argslen;
2191     if (argslen == 0 && bp->args > 0 && pitem[nitems - 1] == NULL)
2192     {
2193         int i;
2194         if (plhs[nrules]->args != bp->args)
2195             wrong_number_args_warning("default ", bp->name);
2196         for (i = bp->args - 1; i >= 0; i--)
2197             if (plhs[nrules]->argtags[i] != bp->argtags[i])
2198                 wrong_type_for_arg_warning(i + 1, bp->name);
2199     }
2200     else if (bp->args != argslen)
2201         wrong_number_args_warning("", bp->name);
2202     if (bp->args > 0 && argslen > 0)
2203     {
2204         char *ap;
2205         int i;
2206         for (ap = args, i = 0; i < argslen; i++)
2207             ap = insert_arg_rule(ap, bp->argtags[i]);
2208         free(args);
2209     }
2210 #endif /* defined(YYBTYACC) */
2211
2212     if (++nitems > maxitems)
2213         expand_items();
2214     pitem[nitems - 1] = bp;
2215 }
2216
2217 static void
2218 copy_action(void)
2219 {
2220     int c;
2221     int i, j, n;
2222     int depth;
2223 #if defined(YYBTYACC)
2224     int trialaction = 0;
2225     int haveyyval = 0;
2226 #endif
2227     char *tag;
2228     FILE *f = action_file;
2229     int a_lineno = lineno;
2230     char *a_line = dup_line();
2231     char *a_cptr = a_line + (cptr - line);
2232     Value_t *offsets = NULL, maxoffset;
2233     bucket **rhs;
2234
2235     if (last_was_action)
2236         insert_empty_rule();
2237     last_was_action = 1;
2238
2239     fprintf(f, "case %d:\n", nrules - 2);
2240 #if defined(YYBTYACC)
2241     if (backtrack)
2242     {
2243         if (*cptr != L_BRAC)
2244             fprintf(f, "  if (!yytrial)\n");
2245         else
2246             trialaction = 1;
2247     }
2248 #endif
2249     if (!lflag)
2250         fprintf(f, line_format, lineno, input_file_name);
2251     if (*cptr == '=')
2252         ++cptr;
2253
2254     /* avoid putting curly-braces in first column, to ease editing */
2255     if (*after_blanks(cptr) == L_CURL)
2256     {
2257         putc('\t', f);
2258         cptr = after_blanks(cptr);
2259     }
2260
2261     maxoffset = 0;
2262     n = 0;
2263     for (i = nitems - 1; pitem[i]; --i)
2264     {
2265         ++n;
2266         if (pitem[i]->class != ARGUMENT)
2267             maxoffset++;
2268     }
2269     if (maxoffset > 0)
2270     {
2271         offsets = TMALLOC(Value_t, maxoffset + 1);
2272         NO_SPACE(offsets);
2273
2274         for (j = 0, i++; i < nitems; i++)
2275         {
2276             if (pitem[i]->class != ARGUMENT)
2277             {
2278                 offsets[++j] = (Value_t) (i - nitems + 1);
2279             }
2280         }
2281     }
2282     rhs = pitem + nitems - 1;
2283
2284     depth = 0;
2285   loop:
2286     c = *cptr;
2287     if (c == '$')
2288     {
2289         if (cptr[1] == '<')
2290         {
2291             int d_lineno = lineno;
2292             char *d_line = dup_line();
2293             char *d_cptr = d_line + (cptr - line);
2294
2295             ++cptr;
2296             tag = get_tag();
2297             c = *cptr;
2298             if (c == '$')
2299             {
2300                 fprintf(f, "yyval.%s", tag);
2301                 ++cptr;
2302                 FREE(d_line);
2303                 goto loop;
2304             }
2305             else if (isdigit(c))
2306             {
2307                 i = get_number();
2308                 if (i == 0)
2309                     fprintf(f, "yystack.l_mark[%d].%s", -n, tag);
2310                 else if (i > maxoffset)
2311                 {
2312                     dollar_warning(d_lineno, i);
2313                     fprintf(f, "yystack.l_mark[%d].%s", i - maxoffset, tag);
2314                 }
2315                 else if (offsets)
2316                     fprintf(f, "yystack.l_mark[%d].%s", offsets[i], tag);
2317                 FREE(d_line);
2318                 goto loop;
2319             }
2320             else if (c == '-' && isdigit(UCH(cptr[1])))
2321             {
2322                 ++cptr;
2323                 i = -get_number() - n;
2324                 fprintf(f, "yystack.l_mark[%d].%s", i, tag);
2325                 FREE(d_line);
2326                 goto loop;
2327             }
2328 #if defined(YYBTYACC)
2329             else if (isalpha(c) || c == '_')
2330             {
2331                 char *arg = scan_id();
2332                 for (i = plhs[nrules]->args - 1; i >= 0; i--)
2333                     if (arg == plhs[nrules]->argnames[i])
2334                         break;
2335                 if (i < 0)
2336                     unknown_arg_warning(d_lineno, "$", arg, d_line, d_cptr);
2337                 fprintf(f, "yystack.l_mark[%d].%s", i - plhs[nrules]->args +
2338                         1 - n, tag);
2339                 FREE(d_line);
2340                 goto loop;
2341             }
2342 #endif
2343             else
2344                 dollar_error(d_lineno, d_line, d_cptr);
2345         }
2346         else if (cptr[1] == '$')
2347         {
2348             if (havetags)
2349             {
2350                 tag = plhs[nrules]->tag;
2351                 if (tag == 0)
2352                     untyped_lhs();
2353                 fprintf(f, "yyval.%s", tag);
2354             }
2355             else
2356                 fprintf(f, "yyval");
2357             cptr += 2;
2358 #if defined(YYBTYACC)
2359             haveyyval = 1;
2360 #endif
2361             goto loop;
2362         }
2363         else if (isdigit(UCH(cptr[1])))
2364         {
2365             ++cptr;
2366             i = get_number();
2367             if (havetags && offsets)
2368             {
2369                 if (i <= 0 || i > maxoffset)
2370                     unknown_rhs(i);
2371                 tag = rhs[offsets[i]]->tag;
2372                 if (tag == 0)
2373                     untyped_rhs(i, rhs[offsets[i]]->name);
2374                 fprintf(f, "yystack.l_mark[%d].%s", offsets[i], tag);
2375             }
2376             else
2377             {
2378                 if (i == 0)
2379                     fprintf(f, "yystack.l_mark[%d]", -n);
2380                 else if (i > maxoffset)
2381                 {
2382                     dollar_warning(lineno, i);
2383                     fprintf(f, "yystack.l_mark[%d]", i - maxoffset);
2384                 }
2385                 else if (offsets)
2386                     fprintf(f, "yystack.l_mark[%d]", offsets[i]);
2387             }
2388             goto loop;
2389         }
2390         else if (cptr[1] == '-')
2391         {
2392             cptr += 2;
2393             i = get_number();
2394             if (havetags)
2395                 unknown_rhs(-i);
2396             fprintf(f, "yystack.l_mark[%d]", -i - n);
2397             goto loop;
2398         }
2399 #if defined(YYBTYACC)
2400         else if (isalpha(cptr[1]) || cptr[1] == '_')
2401         {
2402             char *arg;
2403             ++cptr;
2404             arg = scan_id();
2405             for (i = plhs[nrules]->args - 1; i >= 0; i--)
2406                 if (arg == plhs[nrules]->argnames[i])
2407                     break;
2408             if (i < 0)
2409                 unknown_arg_warning(lineno, "$", arg, line, cptr);
2410             tag = (i < 0 ? NULL : plhs[nrules]->argtags[i]);
2411             fprintf(f, "yystack.l_mark[%d]", i - plhs[nrules]->args + 1 - n);
2412             if (tag)
2413                 fprintf(f, ".%s", tag);
2414             else if (havetags)
2415                 untyped_arg_warning(lineno, "$", arg);
2416             goto loop;
2417         }
2418 #endif
2419     }
2420 #if defined(YYBTYACC)
2421     if (c == '@')
2422     {
2423         if (!locations)
2424         {
2425             int l_lineno = lineno;
2426             char *l_line = dup_line();
2427             char *l_cptr = l_line + (cptr - line);
2428             syntax_error(l_lineno, l_line, l_cptr);
2429         }
2430         if (cptr[1] == '$')
2431         {
2432             fprintf(f, "yyloc");
2433             cptr += 2;
2434             goto loop;
2435         }
2436         else if (isdigit(UCH(cptr[1])))
2437         {
2438             ++cptr;
2439             i = get_number();
2440             if (i == 0)
2441                 fprintf(f, "yystack.p_mark[%d]", -n);
2442             else if (i > maxoffset)
2443             {
2444                 at_warning(lineno, i);
2445                 fprintf(f, "yystack.p_mark[%d]", i - maxoffset);
2446             }
2447             else if (offsets)
2448                 fprintf(f, "yystack.p_mark[%d]", offsets[i]);
2449             goto loop;
2450         }
2451     }
2452 #endif
2453     if (isalpha(c) || c == '_' || c == '$')
2454     {
2455         do
2456         {
2457             putc(c, f);
2458             c = *++cptr;
2459         }
2460         while (isalnum(c) || c == '_' || c == '$');
2461         goto loop;
2462     }
2463     ++cptr;
2464 #if defined(YYBTYACC)
2465     if (backtrack)
2466     {
2467         if (trialaction && c == L_BRAC && depth == 0)
2468         {
2469             ++depth;
2470             putc(L_CURL, f);
2471             goto loop;
2472         }
2473         if (trialaction && c == R_BRAC && depth == 1)
2474         {
2475             --depth;
2476             putc(R_CURL, f);
2477             c = nextc();
2478             if (c == L_BRAC && !haveyyval)
2479             {
2480                 goto loop;
2481             }
2482             if (c == L_CURL && !haveyyval)
2483             {
2484                 fprintf(f, "  if (!yytrial)\n");
2485                 if (!lflag)
2486                     fprintf(f, line_format, lineno, input_file_name);
2487                 trialaction = 0;
2488                 goto loop;
2489             }
2490             fprintf(f, "\nbreak;\n");
2491             FREE(a_line);
2492             if (maxoffset > 0)
2493                 FREE(offsets);
2494             return;
2495         }
2496     }
2497 #endif
2498     putc(c, f);
2499     switch (c)
2500     {
2501     case '\n':
2502         get_line();
2503         if (line)
2504             goto loop;
2505         unterminated_action(a_lineno, a_line, a_cptr);
2506
2507     case ';':
2508         if (depth > 0)
2509             goto loop;
2510         fprintf(f, "\nbreak;\n");
2511         free(a_line);
2512         if (maxoffset > 0)
2513             FREE(offsets);
2514         return;
2515
2516 #if defined(YYBTYACC)
2517     case L_BRAC:
2518         if (backtrack)
2519             ++depth;
2520         goto loop;
2521
2522     case R_BRAC:
2523         if (backtrack)
2524             --depth;
2525         goto loop;
2526 #endif
2527
2528     case L_CURL:
2529         ++depth;
2530         goto loop;
2531
2532     case R_CURL:
2533         if (--depth > 0)
2534             goto loop;
2535 #if defined(YYBTYACC)
2536         if (backtrack)
2537         {
2538             c = nextc();
2539             if (c == L_BRAC && !haveyyval)
2540             {
2541                 trialaction = 1;
2542                 goto loop;
2543             }
2544             if (c == L_CURL && !haveyyval)
2545             {
2546                 fprintf(f, "  if (!yytrial)\n");
2547                 if (!lflag)
2548                     fprintf(f, line_format, lineno, input_file_name);
2549                 goto loop;
2550             }
2551         }
2552 #endif
2553         fprintf(f, "\nbreak;\n");
2554         free(a_line);
2555         if (maxoffset > 0)
2556             FREE(offsets);
2557         return;
2558
2559     case '\'':
2560     case '"':
2561         {
2562             char *s = copy_string(c);
2563             fputs(s, f);
2564             free(s);
2565         }
2566         goto loop;
2567
2568     case '/':
2569         {
2570             char *s = copy_comment();
2571             fputs(s, f);
2572             free(s);
2573         }
2574         goto loop;
2575
2576     default:
2577         goto loop;
2578     }
2579 }
2580
2581 #if defined(YYBTYACC)
2582 static void
2583 copy_destructor(void)
2584 {
2585     int c;
2586     int depth;
2587     char *tag;
2588     bucket *bp;
2589     struct mstring *destructor_text = msnew();
2590     char *code_text;
2591     int a_lineno;
2592     char *a_line;
2593     char *a_cptr;
2594
2595     if (!lflag)
2596         msprintf(destructor_text, line_format, lineno, input_file_name);
2597
2598     cptr = after_blanks(cptr);
2599     if (*cptr == L_CURL)
2600         /* avoid putting curly-braces in first column, to ease editing */
2601         mputc(destructor_text, '\t');
2602     else
2603         syntax_error(lineno, line, cptr);
2604
2605     a_lineno = lineno;
2606     a_line = dup_line();
2607     a_cptr = a_line + (cptr - line);
2608
2609     depth = 0;
2610   loop:
2611     c = *cptr;
2612     if (c == '$')
2613     {
2614         if (cptr[1] == '<')
2615         {
2616             int d_lineno = lineno;
2617             char *d_line = dup_line();
2618             char *d_cptr = d_line + (cptr - line);
2619
2620             ++cptr;
2621             tag = get_tag();
2622             c = *cptr;
2623             if (c == '$')
2624             {
2625                 msprintf(destructor_text, "(*val).%s", tag);
2626                 ++cptr;
2627                 FREE(d_line);
2628                 goto loop;
2629             }
2630             else
2631                 dollar_error(d_lineno, d_line, d_cptr);
2632         }
2633         else if (cptr[1] == '$')
2634         {
2635             /* process '$$' later; replacement is context dependent */
2636             msprintf(destructor_text, "$$");
2637             cptr += 2;
2638             goto loop;
2639         }
2640     }
2641     if (c == '@' && cptr[1] == '$')
2642     {
2643         if (!locations)
2644         {
2645             int l_lineno = lineno;
2646             char *l_line = dup_line();
2647             char *l_cptr = l_line + (cptr - line);
2648             syntax_error(l_lineno, l_line, l_cptr);
2649         }
2650         msprintf(destructor_text, "(*loc)");
2651         cptr += 2;
2652         goto loop;
2653     }
2654     if (isalpha(c) || c == '_' || c == '$')
2655     {
2656         do
2657         {
2658             mputc(destructor_text, c);
2659             c = *++cptr;
2660         }
2661         while (isalnum(c) || c == '_' || c == '$');
2662         goto loop;
2663     }
2664     ++cptr;
2665     mputc(destructor_text, c);
2666     switch (c)
2667     {
2668     case '\n':
2669         get_line();
2670         if (line)
2671             goto loop;
2672         unterminated_action(a_lineno, a_line, a_cptr);
2673
2674     case L_CURL:
2675         ++depth;
2676         goto loop;
2677
2678     case R_CURL:
2679         if (--depth > 0)
2680             goto loop;
2681         goto process_symbols;
2682
2683     case '\'':
2684     case '"':
2685         {
2686             char *s = copy_string(c);
2687             msprintf(destructor_text, "%s", s);
2688             free(s);
2689         }
2690         goto loop;
2691
2692     case '/':
2693         {
2694             char *s = copy_comment();
2695             msprintf(destructor_text, "%s", s);
2696             free(s);
2697         }
2698         goto loop;
2699
2700     default:
2701         goto loop;
2702     }
2703   process_symbols:
2704     code_text = msdone(destructor_text);
2705     for (;;)
2706     {
2707         c = nextc();
2708         if (c == EOF)
2709             unexpected_EOF();
2710         if (c == '<')
2711         {
2712             if (cptr[1] == '>')
2713             {                   /* "no semantic type" default destructor */
2714                 cptr += 2;
2715                 if ((bp = default_destructor[UNTYPED_DEFAULT]) == NULL)
2716                 {
2717                     static char untyped_default[] = "<>";
2718                     bp = make_bucket("untyped default");
2719                     bp->tag = untyped_default;
2720                     default_destructor[UNTYPED_DEFAULT] = bp;
2721                 }
2722                 if (bp->destructor != NULL)
2723                     destructor_redeclared_warning(a_lineno, a_line, a_cptr);
2724                 else
2725                     /* replace "$$" with "(*val)" in destructor code */
2726                     bp->destructor = process_destructor_XX(code_text, NULL);
2727             }
2728             else if (cptr[1] == '*' && cptr[2] == '>')
2729             {                   /* "no per-symbol or per-type" default destructor */
2730                 cptr += 3;
2731                 if ((bp = default_destructor[TYPED_DEFAULT]) == NULL)
2732                 {
2733                     static char typed_default[] = "<*>";
2734                     bp = make_bucket("typed default");
2735                     bp->tag = typed_default;
2736                     default_destructor[TYPED_DEFAULT] = bp;
2737                 }
2738                 if (bp->destructor != NULL)
2739                     destructor_redeclared_warning(a_lineno, a_line, a_cptr);
2740                 else
2741                 {
2742                     /* postpone re-processing destructor $$s until end of grammar spec */
2743                     bp->destructor = TMALLOC(char, strlen(code_text) + 1);
2744                     NO_SPACE(bp->destructor);
2745                     strcpy(bp->destructor, code_text);
2746                 }
2747             }
2748             else
2749             {                   /* "semantic type" default destructor */
2750                 tag = get_tag();
2751                 bp = lookup_type_destructor(tag);
2752                 if (bp->destructor != NULL)
2753                     destructor_redeclared_warning(a_lineno, a_line, a_cptr);
2754                 else
2755                     /* replace "$$" with "(*val).tag" in destructor code */
2756                     bp->destructor = process_destructor_XX(code_text, tag);
2757             }
2758         }
2759         else if (isalpha(c) || c == '_' || c == '.' || c == '$')
2760         {                       /* "symbol" destructor */
2761             bp = get_name();
2762             if (bp->destructor != NULL)
2763                 destructor_redeclared_warning(a_lineno, a_line, a_cptr);
2764             else
2765             {
2766                 /* postpone re-processing destructor $$s until end of grammar spec */
2767                 bp->destructor = TMALLOC(char, strlen(code_text) + 1);
2768                 NO_SPACE(bp->destructor);
2769                 strcpy(bp->destructor, code_text);
2770             }
2771         }
2772         else
2773             break;
2774     }
2775     free(a_line);
2776     free(code_text);
2777 }
2778
2779 static char *
2780 process_destructor_XX(char *code, char *tag)
2781 {
2782     int c;
2783     int quote;
2784     int depth;
2785     struct mstring *new_code = msnew();
2786     char *codeptr = code;
2787
2788     depth = 0;
2789   loop:                 /* step thru code */
2790     c = *codeptr;
2791     if (c == '$' && codeptr[1] == '$')
2792     {
2793         codeptr += 2;
2794         if (tag == NULL)
2795             msprintf(new_code, "(*val)");
2796         else
2797             msprintf(new_code, "(*val).%s", tag);
2798         goto loop;
2799     }
2800     if (isalpha(c) || c == '_' || c == '$')
2801     {
2802         do
2803         {
2804             mputc(new_code, c);
2805             c = *++codeptr;
2806         }
2807         while (isalnum(c) || c == '_' || c == '$');
2808         goto loop;
2809     }
2810     ++codeptr;
2811     mputc(new_code, c);
2812     switch (c)
2813     {
2814     case L_CURL:
2815         ++depth;
2816         goto loop;
2817
2818     case R_CURL:
2819         if (--depth > 0)
2820             goto loop;
2821         return msdone(new_code);
2822
2823     case '\'':
2824     case '"':
2825         quote = c;
2826         for (;;)
2827         {
2828             c = *codeptr++;
2829             mputc(new_code, c);
2830             if (c == quote)
2831                 goto loop;
2832             if (c == '\\')
2833             {
2834                 c = *codeptr++;
2835                 mputc(new_code, c);
2836             }
2837         }
2838
2839     case '/':
2840         c = *codeptr;
2841         if (c == '*')
2842         {
2843             mputc(new_code, c);
2844             ++codeptr;
2845             for (;;)
2846             {
2847                 c = *codeptr++;
2848                 mputc(new_code, c);
2849                 if (c == '*' && *codeptr == '/')
2850                 {
2851                     mputc(new_code, '/');
2852                     ++codeptr;
2853                     goto loop;
2854                 }
2855             }
2856         }
2857         goto loop;
2858
2859     default:
2860         goto loop;
2861     }
2862 }
2863 #endif /* defined(YYBTYACC) */
2864
2865 static int
2866 mark_symbol(void)
2867 {
2868     int c;
2869     bucket *bp = NULL;
2870
2871     c = cptr[1];
2872     if (c == '%' || c == '\\')
2873     {
2874         cptr += 2;
2875         return (1);
2876     }
2877
2878     if (c == '=')
2879         cptr += 2;
2880     else if ((c == 'p' || c == 'P') &&
2881              ((c = cptr[2]) == 'r' || c == 'R') &&
2882              ((c = cptr[3]) == 'e' || c == 'E') &&
2883              ((c = cptr[4]) == 'c' || c == 'C') &&
2884              ((c = cptr[5], !IS_IDENT(c))))
2885         cptr += 5;
2886     else
2887         syntax_error(lineno, line, cptr);
2888
2889     c = nextc();
2890     if (isalpha(c) || c == '_' || c == '.' || c == '$')
2891         bp = get_name();
2892     else if (c == '\'' || c == '"')
2893         bp = get_literal();
2894     else
2895     {
2896         syntax_error(lineno, line, cptr);
2897     }
2898
2899     if (rprec[nrules] != UNDEFINED && bp->prec != rprec[nrules])
2900         prec_redeclared();
2901
2902     rprec[nrules] = bp->prec;
2903     rassoc[nrules] = bp->assoc;
2904     return (0);
2905 }
2906
2907 static void
2908 read_grammar(void)
2909 {
2910     int c;
2911
2912     initialize_grammar();
2913     advance_to_start();
2914
2915     for (;;)
2916     {
2917         c = nextc();
2918         if (c == EOF)
2919             break;
2920         if (isalpha(c)
2921             || c == '_'
2922             || c == '.'
2923             || c == '$'
2924             || c == '\''
2925             || c == '"')
2926             add_symbol();
2927 #if defined(YYBTYACC)
2928         else if (c == L_CURL || c == '=' || (backtrack && c == L_BRAC))
2929 #else
2930         else if (c == L_CURL || c == '=')
2931 #endif
2932             copy_action();
2933         else if (c == '|')
2934         {
2935             end_rule();
2936             start_rule(plhs[nrules - 1], 0);
2937             ++cptr;
2938         }
2939         else if (c == '%')
2940         {
2941             if (mark_symbol())
2942                 break;
2943         }
2944         else
2945             syntax_error(lineno, line, cptr);
2946     }
2947     end_rule();
2948 #if defined(YYBTYACC)
2949     if (goal->args > 0)
2950         start_requires_args(goal->name);
2951 #endif
2952 }
2953
2954 static void
2955 free_tags(void)
2956 {
2957     int i;
2958
2959     if (tag_table == 0)
2960         return;
2961
2962     for (i = 0; i < ntags; ++i)
2963     {
2964         assert(tag_table[i]);
2965         FREE(tag_table[i]);
2966     }
2967     FREE(tag_table);
2968 }
2969
2970 static void
2971 pack_names(void)
2972 {
2973     bucket *bp;
2974     char *p, *s, *t;
2975
2976     name_pool_size = 13;        /* 13 == sizeof("$end") + sizeof("$accept") */
2977     for (bp = first_symbol; bp; bp = bp->next)
2978         name_pool_size += strlen(bp->name) + 1;
2979
2980     name_pool = TMALLOC(char, name_pool_size);
2981     NO_SPACE(name_pool);
2982
2983     strcpy(name_pool, "$accept");
2984     strcpy(name_pool + 8, "$end");
2985     t = name_pool + 13;
2986     for (bp = first_symbol; bp; bp = bp->next)
2987     {
2988         p = t;
2989         s = bp->name;
2990         while ((*t++ = *s++) != 0)
2991             continue;
2992         FREE(bp->name);
2993         bp->name = p;
2994     }
2995 }
2996
2997 static void
2998 check_symbols(void)
2999 {
3000     bucket *bp;
3001
3002     if (goal->class == UNKNOWN)
3003         undefined_goal(goal->name);
3004
3005     for (bp = first_symbol; bp; bp = bp->next)
3006     {
3007         if (bp->class == UNKNOWN)
3008         {
3009             undefined_symbol_warning(bp->name);
3010             bp->class = TERM;
3011         }
3012     }
3013 }
3014
3015 static void
3016 protect_string(char *src, char **des)
3017 {
3018     unsigned len;
3019     char *s;
3020     char *d;
3021
3022     *des = src;
3023     if (src)
3024     {
3025         len = 1;
3026         s = src;
3027         while (*s)
3028         {
3029             if ('\\' == *s || '"' == *s)
3030                 len++;
3031             s++;
3032             len++;
3033         }
3034
3035         *des = d = TMALLOC(char, len);
3036         NO_SPACE(d);
3037
3038         s = src;
3039         while (*s)
3040         {
3041             if ('\\' == *s || '"' == *s)
3042                 *d++ = '\\';
3043             *d++ = *s++;
3044         }
3045         *d = '\0';
3046     }
3047 }
3048
3049 static void
3050 pack_symbols(void)
3051 {
3052     bucket *bp;
3053     bucket **v;
3054     Value_t i, j, k, n;
3055 #if defined(YYBTYACC)
3056     Value_t max_tok_pval;
3057 #endif
3058
3059     nsyms = 2;
3060     ntokens = 1;
3061     for (bp = first_symbol; bp; bp = bp->next)
3062     {
3063         ++nsyms;
3064         if (bp->class == TERM)
3065             ++ntokens;
3066     }
3067     start_symbol = (Value_t) ntokens;
3068     nvars = (Value_t) (nsyms - ntokens);
3069
3070     symbol_name = TMALLOC(char *, nsyms);
3071     NO_SPACE(symbol_name);
3072
3073     symbol_value = TMALLOC(Value_t, nsyms);
3074     NO_SPACE(symbol_value);
3075
3076     symbol_prec = TMALLOC(Value_t, nsyms);
3077     NO_SPACE(symbol_prec);
3078
3079     symbol_assoc = TMALLOC(char, nsyms);
3080     NO_SPACE(symbol_assoc);
3081
3082 #if defined(YYBTYACC)
3083     symbol_pval = TMALLOC(Value_t, nsyms);
3084     NO_SPACE(symbol_pval);
3085
3086     if (destructor)
3087     {
3088         symbol_destructor = CALLOC(sizeof(char *), nsyms);
3089         NO_SPACE(symbol_destructor);
3090
3091         symbol_type_tag = CALLOC(sizeof(char *), nsyms);
3092         NO_SPACE(symbol_type_tag);
3093     }
3094 #endif
3095
3096     v = TMALLOC(bucket *, nsyms);
3097     NO_SPACE(v);
3098
3099     v[0] = 0;
3100     v[start_symbol] = 0;
3101
3102     i = 1;
3103     j = (Value_t) (start_symbol + 1);
3104     for (bp = first_symbol; bp; bp = bp->next)
3105     {
3106         if (bp->class == TERM)
3107             v[i++] = bp;
3108         else
3109             v[j++] = bp;
3110     }
3111     assert(i == ntokens && j == nsyms);
3112
3113     for (i = 1; i < ntokens; ++i)
3114         v[i]->index = i;
3115
3116     goal->index = (Index_t) (start_symbol + 1);
3117     k = (Value_t) (start_symbol + 2);
3118     while (++i < nsyms)
3119         if (v[i] != goal)
3120         {
3121             v[i]->index = k;
3122             ++k;
3123         }
3124
3125     goal->value = 0;
3126     k = 1;
3127     for (i = (Value_t) (start_symbol + 1); i < nsyms; ++i)
3128     {
3129         if (v[i] != goal)
3130         {
3131             v[i]->value = k;
3132             ++k;
3133         }
3134     }
3135
3136     k = 0;
3137     for (i = 1; i < ntokens; ++i)
3138     {
3139         n = v[i]->value;
3140         if (n > 256)
3141         {
3142             for (j = k++; j > 0 && symbol_value[j - 1] > n; --j)
3143                 symbol_value[j] = symbol_value[j - 1];
3144             symbol_value[j] = n;
3145         }
3146     }
3147
3148     assert(v[1] != 0);
3149
3150     if (v[1]->value == UNDEFINED)
3151         v[1]->value = 256;
3152
3153     j = 0;
3154     n = 257;
3155     for (i = 2; i < ntokens; ++i)
3156     {
3157         if (v[i]->value == UNDEFINED)
3158         {
3159             while (j < k && n == symbol_value[j])
3160             {
3161                 while (++j < k && n == symbol_value[j])
3162                     continue;
3163                 ++n;
3164             }
3165             v[i]->value = n;
3166             ++n;
3167         }
3168     }
3169
3170     symbol_name[0] = name_pool + 8;
3171     symbol_value[0] = 0;
3172     symbol_prec[0] = 0;
3173     symbol_assoc[0] = TOKEN;
3174 #if defined(YYBTYACC)
3175     symbol_pval[0] = 0;
3176     max_tok_pval = 0;
3177 #endif
3178     for (i = 1; i < ntokens; ++i)
3179     {
3180         symbol_name[i] = v[i]->name;
3181         symbol_value[i] = v[i]->value;
3182         symbol_prec[i] = v[i]->prec;
3183         symbol_assoc[i] = v[i]->assoc;
3184 #if defined(YYBTYACC)
3185         symbol_pval[i] = v[i]->value;
3186         if (symbol_pval[i] > max_tok_pval)
3187             max_tok_pval = symbol_pval[i];
3188         if (destructor)
3189         {
3190             symbol_destructor[i] = v[i]->destructor;
3191             symbol_type_tag[i] = v[i]->tag;
3192         }
3193 #endif
3194     }
3195     symbol_name[start_symbol] = name_pool;
3196     symbol_value[start_symbol] = -1;
3197     symbol_prec[start_symbol] = 0;
3198     symbol_assoc[start_symbol] = TOKEN;
3199 #if defined(YYBTYACC)
3200     symbol_pval[start_symbol] = (Value_t) (max_tok_pval + 1);
3201 #endif
3202     for (++i; i < nsyms; ++i)
3203     {
3204         k = v[i]->index;
3205         symbol_name[k] = v[i]->name;
3206         symbol_value[k] = v[i]->value;
3207         symbol_prec[k] = v[i]->prec;
3208         symbol_assoc[k] = v[i]->assoc;
3209 #if defined(YYBTYACC)
3210         symbol_pval[k] = (Value_t) ((max_tok_pval + 1) + v[i]->value + 1);
3211         if (destructor)
3212         {
3213             symbol_destructor[k] = v[i]->destructor;
3214             symbol_type_tag[k] = v[i]->tag;
3215         }
3216 #endif
3217     }
3218
3219     if (gflag)
3220     {
3221         symbol_pname = TMALLOC(char *, nsyms);
3222         NO_SPACE(symbol_pname);
3223
3224         for (i = 0; i < nsyms; ++i)
3225             protect_string(symbol_name[i], &(symbol_pname[i]));
3226     }
3227
3228     FREE(v);
3229 }
3230
3231 static void
3232 pack_grammar(void)
3233 {
3234     int i;
3235     Value_t j;
3236     Assoc_t assoc;
3237     Value_t prec2;
3238
3239     ritem = TMALLOC(Value_t, nitems);
3240     NO_SPACE(ritem);
3241
3242     rlhs = TMALLOC(Value_t, nrules);
3243     NO_SPACE(rlhs);
3244
3245     rrhs = TMALLOC(Value_t, nrules + 1);
3246     NO_SPACE(rrhs);
3247
3248     rprec = TREALLOC(Value_t, rprec, nrules);
3249     NO_SPACE(rprec);
3250
3251     rassoc = TREALLOC(Assoc_t, rassoc, nrules);
3252     NO_SPACE(rassoc);
3253
3254     ritem[0] = -1;
3255     ritem[1] = goal->index;
3256     ritem[2] = 0;
3257     ritem[3] = -2;
3258     rlhs[0] = 0;
3259     rlhs[1] = 0;
3260     rlhs[2] = start_symbol;
3261     rrhs[0] = 0;
3262     rrhs[1] = 0;
3263     rrhs[2] = 1;
3264
3265     j = 4;
3266     for (i = 3; i < nrules; ++i)
3267     {
3268 #if defined(YYBTYACC)
3269         if (plhs[i]->args > 0)
3270         {
3271             if (plhs[i]->argnames)
3272             {
3273                 FREE(plhs[i]->argnames);
3274                 plhs[i]->argnames = NULL;
3275             }
3276             if (plhs[i]->argtags)
3277             {
3278                 FREE(plhs[i]->argtags);
3279                 plhs[i]->argtags = NULL;
3280             }
3281         }
3282 #endif /* defined(YYBTYACC) */
3283         rlhs[i] = plhs[i]->index;
3284         rrhs[i] = j;
3285         assoc = TOKEN;
3286         prec2 = 0;
3287         while (pitem[j])
3288         {
3289             ritem[j] = pitem[j]->index;
3290             if (pitem[j]->class == TERM)
3291             {
3292                 prec2 = pitem[j]->prec;
3293                 assoc = pitem[j]->assoc;
3294             }
3295             ++j;
3296         }
3297         ritem[j] = (Value_t) - i;
3298         ++j;
3299         if (rprec[i] == UNDEFINED)
3300         {
3301             rprec[i] = prec2;
3302             rassoc[i] = assoc;
3303         }
3304     }
3305     rrhs[i] = j;
3306
3307     FREE(plhs);
3308     FREE(pitem);
3309 #if defined(YYBTYACC)
3310     clean_arg_cache();
3311 #endif
3312 }
3313
3314 static void
3315 print_grammar(void)
3316 {
3317     int i, k;
3318     size_t j, spacing = 0;
3319     FILE *f = verbose_file;
3320
3321     if (!vflag)
3322         return;
3323
3324     k = 1;
3325     for (i = 2; i < nrules; ++i)
3326     {
3327         if (rlhs[i] != rlhs[i - 1])
3328         {
3329             if (i != 2)
3330                 fprintf(f, "\n");
3331             fprintf(f, "%4d  %s :", i - 2, symbol_name[rlhs[i]]);
3332             spacing = strlen(symbol_name[rlhs[i]]) + 1;
3333         }
3334         else
3335         {
3336             fprintf(f, "%4d  ", i - 2);
3337             j = spacing;
3338             while (j-- != 0)
3339                 putc(' ', f);
3340             putc('|', f);
3341         }
3342
3343         while (ritem[k] >= 0)
3344         {
3345             fprintf(f, " %s", symbol_name[ritem[k]]);
3346             ++k;
3347         }
3348         ++k;
3349         putc('\n', f);
3350     }
3351 }
3352
3353 #if defined(YYBTYACC)
3354 static void
3355 finalize_destructors(void)
3356 {
3357     int i;
3358     bucket *bp;
3359     char *tag;
3360
3361     for (i = 2; i < nsyms; ++i)
3362     {
3363         tag = symbol_type_tag[i];
3364         if (symbol_destructor[i] == NULL)
3365         {
3366             if (tag == NULL)
3367             {                   /* use <> destructor, if there is one */
3368                 if ((bp = default_destructor[UNTYPED_DEFAULT]) != NULL)
3369                 {
3370                     symbol_destructor[i] = TMALLOC(char,
3371                                                    strlen(bp->destructor) + 1);
3372                     NO_SPACE(symbol_destructor[i]);
3373                     strcpy(symbol_destructor[i], bp->destructor);
3374                 }
3375             }
3376             else
3377             {                   /* use type destructor for this tag, if there is one */
3378                 bp = lookup_type_destructor(tag);
3379                 if (bp->destructor != NULL)
3380                 {
3381                     symbol_destructor[i] = TMALLOC(char,
3382                                                    strlen(bp->destructor) + 1);
3383                     NO_SPACE(symbol_destructor[i]);
3384                     strcpy(symbol_destructor[i], bp->destructor);
3385                 }
3386                 else
3387                 {               /* use <*> destructor, if there is one */
3388                     if ((bp = default_destructor[TYPED_DEFAULT]) != NULL)
3389                         /* replace "$$" with "(*val).tag" in destructor code */
3390                         symbol_destructor[i]
3391                             = process_destructor_XX(bp->destructor, tag);
3392                 }
3393             }
3394         }
3395         else
3396         {                       /* replace "$$" with "(*val)[.tag]" in destructor code */
3397             symbol_destructor[i]
3398                 = process_destructor_XX(symbol_destructor[i], tag);
3399         }
3400     }
3401     /* 'symbol_type_tag[]' elements are freed by 'free_tags()' */
3402     DO_FREE(symbol_type_tag);   /* no longer needed */
3403     if ((bp = default_destructor[UNTYPED_DEFAULT]) != NULL)
3404     {
3405         FREE(bp->name);
3406         /* 'bp->tag' is a static value, don't free */
3407         FREE(bp->destructor);
3408         FREE(bp);
3409     }
3410     if ((bp = default_destructor[TYPED_DEFAULT]) != NULL)
3411     {
3412         FREE(bp->name);
3413         /* 'bp->tag' is a static value, don't free */
3414         FREE(bp->destructor);
3415         FREE(bp);
3416     }
3417     if ((bp = default_destructor[TYPE_SPECIFIED]) != NULL)
3418     {
3419         bucket *p;
3420         for (; bp; bp = p)
3421         {
3422             p = bp->link;
3423             FREE(bp->name);
3424             /* 'bp->tag' freed by 'free_tags()' */
3425             FREE(bp->destructor);
3426             FREE(bp);
3427         }
3428     }
3429 }
3430 #endif /* defined(YYBTYACC) */
3431
3432 void
3433 reader(void)
3434 {
3435     write_section(code_file, banner);
3436     create_symbol_table();
3437     read_declarations();
3438     read_grammar();
3439     free_symbol_table();
3440     pack_names();
3441     check_symbols();
3442     pack_symbols();
3443     pack_grammar();
3444     free_symbols();
3445     print_grammar();
3446 #if defined(YYBTYACC)
3447     if (destructor)
3448         finalize_destructors();
3449 #endif
3450     free_tags();
3451 }
3452
3453 #ifdef NO_LEAKS
3454 static param *
3455 free_declarations(param * list)
3456 {
3457     while (list != 0)
3458     {
3459         param *next = list->next;
3460         free(list->type);
3461         free(list->name);
3462         free(list->type2);
3463         free(list);
3464         list = next;
3465     }
3466     return list;
3467 }
3468
3469 void
3470 reader_leaks(void)
3471 {
3472     lex_param = free_declarations(lex_param);
3473     parse_param = free_declarations(parse_param);
3474
3475     DO_FREE(line);
3476     DO_FREE(rrhs);
3477     DO_FREE(rlhs);
3478     DO_FREE(rprec);
3479     DO_FREE(ritem);
3480     DO_FREE(rassoc);
3481     DO_FREE(cache);
3482     DO_FREE(name_pool);
3483     DO_FREE(symbol_name);
3484     DO_FREE(symbol_prec);
3485     DO_FREE(symbol_assoc);
3486     DO_FREE(symbol_value);
3487 #if defined(YYBTYACC)
3488     DO_FREE(symbol_pval);
3489     DO_FREE(symbol_destructor);
3490     DO_FREE(symbol_type_tag);
3491 #endif
3492 }
3493 #endif