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