src/reader.c

   1 /* Input parser for Bison
   2
   3    Copyright (C) 1984, 1986, 1989, 1992, 1998, 2000, 2001, 2002, 2003,
   4    2005, 2006 Free Software Foundation, Inc.
   5
   6    This file is part of Bison, the GNU Compiler Compiler.
   7
   8    Bison is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2, or (at your option)
  11    any later version.
  12
  13    Bison is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with Bison; see the file COPYING.  If not, write to
  20    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21    Boston, MA 02110-1301, USA.  */
  22
  23 #include <config.h>
  24 #include "system.h"
  25
  26 #include <quotearg.h>
  27
  28 #include "complain.h"
  29 #include "conflicts.h"
  30 #include "files.h"
  31 #include "getargs.h"
  32 #include "gram.h"
  33 #include "muscle_tab.h"
  34 #include "reader.h"
  35 #include "symlist.h"
  36 #include "symtab.h"
  37 #include "scan-gram.h"
  38 #include "scan-code.h"
  39
  40 static void check_and_convert_grammar (void);
  41
  42 static symbol_list *grammar = NULL;
  43 static bool start_flag = false;
  44 merger_list *merge_functions;
  45
  46 /* Was %union seen?  */
  47 bool union_seen = false;
  48
  49 /* Was a tag seen?  */
  50 bool tag_seen = false;
  51
  52 /* Should rules have a default precedence?  */
  53 bool default_prec = true;
  54 \f
  55 /*-----------------------.
  56 | Set the start symbol.  |
  57 `-----------------------*/
  58
  59 void
  60 grammar_start_symbol_set (symbol *sym, location loc)
  61 {
  62   if (start_flag)
  63     complain_at (loc, _("multiple %s declarations"), "%start");
  64   else
  65     {
  66       start_flag = true;
  67       startsymbol = sym;
  68       startsymbol_location = loc;
  69     }
  70 }
  71
  72
  73 /*---------------------------------------------------------------------.
  74 | There are two prologues: one before the first %union and one after.  |
  75 | Augment the one specified by POST.                                   |
  76 `---------------------------------------------------------------------*/
  77
  78 void
  79 prologue_augment (const char *prologue, location loc, bool post)
  80 {
  81   struct obstack *oout =
  82     !post ? &pre_prologue_obstack : &post_prologue_obstack;
  83
  84   obstack_fgrow1 (oout, "]b4_syncline(%d, [[", loc.start.line);
  85   /* FIXME: Protection of M4 characters missing here.  See
  86      output.c:escaped_output.  */
  87   MUSCLE_OBSTACK_SGROW (oout,
  88                         quotearg_style (c_quoting_style, loc.start.file));
  89   obstack_sgrow (oout, "]])[\n");
  90   obstack_sgrow (oout, prologue);
  91 }
  92
  93 \f
  94
  95 /*------------------------------------------------------------------------.
  96 | Return the merger index for a merging function named NAME.  Records the |
  97 | function, if new, in MERGER_LIST.                                       |
  98 `------------------------------------------------------------------------*/
  99
 100 static int
 101 get_merge_function (uniqstr name)
 102 {
 103   merger_list *syms;
 104   merger_list head;
 105   int n;
 106
 107   if (! glr_parser)
 108     return 0;
 109
 110   head.next = merge_functions;
 111   for (syms = &head, n = 1; syms->next; syms = syms->next, n += 1)
 112     if (UNIQSTR_EQ (name, syms->next->name))
 113       break;
 114   if (syms->next == NULL)
 115     {
 116       syms->next = xmalloc (sizeof syms->next[0]);
 117       syms->next->name = uniqstr_new (name);
 118       /* After all symbol type declarations have been parsed, packgram invokes
 119          record_merge_function_type to set the type.  */
 120       syms->next->type = NULL;
 121       syms->next->next = NULL;
 122       merge_functions = head.next;
 123     }
 124   return n;
 125 }
 126
 127 /*-------------------------------------------------------------------------.
 128 | For the existing merging function with index MERGER, record the result   |
 129 | type as TYPE as required by the lhs of the rule whose %merge declaration |
 130 | is at DECLARATION_LOC.                                                   |
 131 `-------------------------------------------------------------------------*/
 132
 133 static void
 134 record_merge_function_type (int merger, uniqstr type, location declaration_loc)
 135 {
 136   int merger_find;
 137   merger_list *merge_function;
 138
 139   if (merger <= 0)
 140     return;
 141
 142   if (type == NULL)
 143     type = uniqstr_new ("");
 144
 145   merger_find = 1;
 146   for (merge_function = merge_functions;
 147        merge_function != NULL && merger_find != merger;
 148        merge_function = merge_function->next)
 149     merger_find += 1;
 150   aver (merge_function != NULL && merger_find == merger);
 151   if (merge_function->type != NULL && !UNIQSTR_EQ (merge_function->type, type))
 152     {
 153       complain_at (declaration_loc,
 154                    _("result type clash on merge function `%s': <%s> != <%s>"),
 155                    merge_function->name, type, merge_function->type);
 156       complain_at (merge_function->type_declaration_location,
 157                    _("previous declaration"));
 158     }
 159   merge_function->type = uniqstr_new (type);
 160   merge_function->type_declaration_location = declaration_loc;
 161 }
 162
 163 /*--------------------------------------.
 164 | Free all merge-function definitions.  |
 165 `--------------------------------------*/
 166
 167 void
 168 free_merger_functions (void)
 169 {
 170   merger_list *L0 = merge_functions;
 171   while (L0)
 172     {
 173       merger_list *L1 = L0->next;
 174       free (L0);
 175       L0 = L1;
 176     }
 177 }
 178
 179 \f
 180 /*-------------------------------------------------------------------.
 181 | Parse the input grammar into a one symbol_list structure.  Each    |
 182 | rule is represented by a sequence of symbols: the left hand side   |
 183 | followed by the contents of the right hand side, followed by a     |
 184 | null pointer instead of a symbol to terminate the rule.  The next  |
 185 | symbol is the lhs of the following rule.                           |
 186 |                                                                    |
 187 | All actions are copied out, labelled by the rule number they apply |
 188 | to.                                                                |
 189 `-------------------------------------------------------------------*/
 190
 191 /* The (currently) last symbol of GRAMMAR. */
 192 static symbol_list *grammar_end = NULL;
 193
 194 /* Append SYM to the grammar.  */
 195 static void
 196 grammar_symbol_append (symbol *sym, location loc)
 197 {
 198   symbol_list *p = symbol_list_sym_new (sym, loc);
 199
 200   if (grammar_end)
 201     grammar_end->next = p;
 202   else
 203     grammar = p;
 204
 205   grammar_end = p;
 206
 207   /* A null SYM stands for an end of rule; it is not an actual
 208      part of it.  */
 209   if (sym)
 210     ++nritems;
 211 }
 212
 213 /* The rule currently being defined, and the previous rule.
 214    CURRENT_RULE points to the first LHS of the current rule, while
 215    PREVIOUS_RULE_END points to the *end* of the previous rule (NULL).  */
 216 static symbol_list *current_rule = NULL;
 217 static symbol_list *previous_rule_end = NULL;
 218
 219
 220 /*----------------------------------------------.
 221 | Create a new rule for LHS in to the GRAMMAR.  |
 222 `----------------------------------------------*/
 223
 224 void
 225 grammar_current_rule_begin (symbol *lhs, location loc)
 226 {
 227   /* Start a new rule and record its lhs.  */
 228   ++nrules;
 229   previous_rule_end = grammar_end;
 230   grammar_symbol_append (lhs, loc);
 231   current_rule = grammar_end;
 232
 233   /* Mark the rule's lhs as a nonterminal if not already so.  */
 234   if (lhs->class == unknown_sym)
 235     {
 236       lhs->class = nterm_sym;
 237       lhs->number = nvars;
 238       ++nvars;
 239     }
 240   else if (lhs->class == token_sym)
 241     complain_at (loc, _("rule given for %s, which is a token"), lhs->tag);
 242 }
 243
 244
 245 /*----------------------------------------------------------------------.
 246 | A symbol should be used if it has a destructor, or if it is a         |
 247 | mid-rule symbol (i.e., the generated LHS replacing a mid-rule         |
 248 | action) that was assigned to, as in "exp: { $$ = 1; } { $$ = $1; }".  |
 249 `----------------------------------------------------------------------*/
 250
 251 static bool
 252 symbol_should_be_used (symbol_list const *s)
 253 {
 254   return (symbol_destructor_get (s->content.sym)
 255           || (s->midrule && s->midrule->used)
 256           || (s->midrule_parent_rule
 257               && symbol_list_n_get (s->midrule_parent_rule,
 258                                     s->midrule_parent_rhs_index)->used));
 259 }
 260
 261 /*----------------------------------------------------------------.
 262 | Check that the rule R is properly defined.  For instance, there |
 263 | should be no type clash on the default action.                  |
 264 `----------------------------------------------------------------*/
 265
 266 static void
 267 grammar_rule_check (const symbol_list *r)
 268 {
 269   /* Type check.
 270
 271      If there is an action, then there is nothing we can do: the user
 272      is allowed to shoot herself in the foot.
 273
 274      Don't worry about the default action if $$ is untyped, since $$'s
 275      value can't be used.  */
 276   if (!r->action && r->content.sym->type_name)
 277     {
 278       symbol *first_rhs = r->next->content.sym;
 279       /* If $$ is being set in default way, report if any type mismatch.  */
 280       if (first_rhs)
 281         {
 282           char const *lhs_type = r->content.sym->type_name;
 283           const char *rhs_type =
 284             first_rhs->type_name ? first_rhs->type_name : "";
 285           if (!UNIQSTR_EQ (lhs_type, rhs_type))
 286             warn_at (r->location,
 287                      _("type clash on default action: <%s> != <%s>"),
 288                      lhs_type, rhs_type);
 289         }
 290       /* Warn if there is no default for $$ but we need one.  */
 291       else
 292         warn_at (r->location,
 293                  _("empty rule for typed nonterminal, and no action"));
 294     }
 295
 296   /* Check that symbol values that should be used are in fact used.  */
 297   {
 298     symbol_list const *l = r;
 299     int n = 0;
 300     for (; l && l->content.sym; l = l->next, ++n)
 301       if (! (l->used
 302              || !symbol_should_be_used (l)
 303              /* The default action, $$ = $1, `uses' both.  */
 304              || (!r->action && (n == 0 || n == 1))))
 305         {
 306           if (n)
 307             warn_at (r->location, _("unused value: $%d"), n);
 308           else
 309             warn_at (r->location, _("unset value: $$"));
 310         }
 311   }
 312 }
 313
 314
 315 /*-------------------------------------.
 316 | End the currently being grown rule.  |
 317 `-------------------------------------*/
 318
 319 void
 320 grammar_current_rule_end (location loc)
 321 {
 322   /* Put an empty link in the list to mark the end of this rule  */
 323   grammar_symbol_append (NULL, grammar_end->location);
 324   current_rule->location = loc;
 325 }
 326
 327
 328 /*-------------------------------------------------------------------.
 329 | The previous action turns out the be a mid-rule action.  Attach it |
 330 | to the current rule, i.e., create a dummy symbol, attach it this   |
 331 | mid-rule action, and append this dummy nonterminal to the current  |
 332 | rule.                                                              |
 333 `-------------------------------------------------------------------*/
 334
 335 void
 336 grammar_midrule_action (void)
 337 {
 338   /* Since the action was written out with this rule's number, we must
 339      give the new rule this number by inserting the new rule before
 340      it.  */
 341
 342   /* Make a DUMMY nonterminal, whose location is that of the midrule
 343      action.  Create the MIDRULE.  */
 344   location dummy_location = current_rule->action_location;
 345   symbol *dummy = dummy_symbol_get (dummy_location);
 346   symbol_list *midrule = symbol_list_sym_new (dummy, dummy_location);
 347
 348   /* Make a new rule, whose body is empty, before the current one, so
 349      that the action just read can belong to it.  */
 350   ++nrules;
 351   ++nritems;
 352   /* Attach its location and actions to that of the DUMMY.  */
 353   midrule->location = dummy_location;
 354   midrule->action = current_rule->action;
 355   midrule->action_location = dummy_location;
 356   current_rule->action = NULL;
 357   /* The action has not been translated yet, so $$ use hasn't been
 358      detected yet.  */
 359   midrule->used = false;
 360
 361   if (previous_rule_end)
 362     previous_rule_end->next = midrule;
 363   else
 364     grammar = midrule;
 365
 366   /* End the dummy's rule.  */
 367   midrule->next = symbol_list_sym_new (NULL, dummy_location);
 368   midrule->next->next = current_rule;
 369
 370   previous_rule_end = midrule->next;
 371
 372   /* Insert the dummy nonterminal replacing the midrule action into
 373      the current rule.  Bind it to its dedicated rule.  */
 374   grammar_current_rule_symbol_append (dummy, dummy_location);
 375   grammar_end->midrule = midrule;
 376   midrule->midrule_parent_rule = current_rule;
 377   midrule->midrule_parent_rhs_index = symbol_list_length (current_rule->next);
 378 }
 379
 380 /* Set the precedence symbol of the current rule to PRECSYM. */
 381
 382 void
 383 grammar_current_rule_prec_set (symbol *precsym, location loc)
 384 {
 385   if (current_rule->ruleprec)
 386     complain_at (loc, _("only one %s allowed per rule"), "%prec");
 387   current_rule->ruleprec = precsym;
 388 }
 389
 390 /* Attach dynamic precedence DPREC to the current rule. */
 391
 392 void
 393 grammar_current_rule_dprec_set (int dprec, location loc)
 394 {
 395   if (! glr_parser)
 396     warn_at (loc, _("%s affects only GLR parsers"), "%dprec");
 397   if (dprec <= 0)
 398     complain_at (loc, _("%s must be followed by positive number"), "%dprec");
 399   else if (current_rule->dprec != 0)
 400     complain_at (loc, _("only one %s allowed per rule"), "%dprec");
 401   current_rule->dprec = dprec;
 402 }
 403
 404 /* Attach a merge function NAME with argument type TYPE to current
 405    rule. */
 406
 407 void
 408 grammar_current_rule_merge_set (uniqstr name, location loc)
 409 {
 410   if (! glr_parser)
 411     warn_at (loc, _("%s affects only GLR parsers"), "%merge");
 412   if (current_rule->merger != 0)
 413     complain_at (loc, _("only one %s allowed per rule"), "%merge");
 414   current_rule->merger = get_merge_function (name);
 415   current_rule->merger_declaration_location = loc;
 416 }
 417
 418 /* Attach SYM to the current rule.  If needed, move the previous
 419    action as a mid-rule action.  */
 420
 421 void
 422 grammar_current_rule_symbol_append (symbol *sym, location loc)
 423 {
 424   if (current_rule->action)
 425     grammar_midrule_action ();
 426   grammar_symbol_append (sym, loc);
 427 }
 428
 429 /* Attach an ACTION to the current rule.  */
 430
 431 void
 432 grammar_current_rule_action_append (const char *action, location loc)
 433 {
 434   if (current_rule->action)
 435     grammar_midrule_action ();
 436   /* After all symbol declarations have been parsed, packgram invokes
 437      translate_rule_action.  */
 438   current_rule->action = action;
 439   current_rule->action_location = loc;
 440 }
 441
 442 \f
 443 /*---------------------------------------------------------------.
 444 | Convert the rules into the representation using RRHS, RLHS and |
 445 | RITEM.                                                         |
 446 `---------------------------------------------------------------*/
 447
 448 static void
 449 packgram (void)
 450 {
 451   unsigned int itemno = 0;
 452   rule_number ruleno = 0;
 453   symbol_list *p = grammar;
 454
 455   ritem = xnmalloc (nritems + 1, sizeof *ritem);
 456
 457   /* This sentinel is used by build_relations in gram.c.  */
 458   *ritem++ = 0;
 459
 460   rules = xnmalloc (nrules, sizeof *rules);
 461
 462   /* Before invoking grammar_rule_check on any rule, make sure
 463      all actions have already been scanned in order to set `used' flags.
 464      Otherwise, checking that a midrule's $$ is set will not always work
 465      properly because the midrule check must forward-reference the midrule's
 466      parent rule.  */
 467   while (p)
 468     {
 469       if (p->action)
 470         p->action = translate_rule_action (p);
 471       if (p)
 472         p = p->next;
 473     }
 474
 475   p = grammar;
 476   while (p)
 477     {
 478       int rule_length = 0;
 479       symbol *ruleprec = p->ruleprec;
 480       record_merge_function_type (p->merger, p->content.sym->type_name,
 481                                   p->merger_declaration_location);
 482       rules[ruleno].user_number = ruleno;
 483       rules[ruleno].number = ruleno;
 484       rules[ruleno].lhs = p->content.sym;
 485       rules[ruleno].rhs = ritem + itemno;
 486       rules[ruleno].prec = NULL;
 487       rules[ruleno].dprec = p->dprec;
 488       rules[ruleno].merger = p->merger;
 489       rules[ruleno].precsym = NULL;
 490       rules[ruleno].location = p->location;
 491       rules[ruleno].useful = true;
 492       rules[ruleno].action = p->action;
 493       rules[ruleno].action_location = p->action_location;
 494
 495       /* Don't check the generated rule 0.  It has no action, so some rhs
 496          symbols may appear unused, but the parsing algorithm ensures that
 497          %destructor's are invoked appropriately.  */
 498       if (p != grammar)
 499         grammar_rule_check (p);
 500
 501       for (p = p->next; p && p->content.sym; p = p->next)
 502         {
 503           ++rule_length;
 504
 505           /* Don't allow rule_length == INT_MAX, since that might
 506              cause confusion with strtol if INT_MAX == LONG_MAX.  */
 507           if (rule_length == INT_MAX)
 508               fatal_at (rules[ruleno].location, _("rule is too long"));
 509
 510           /* item_number = symbol_number.
 511              But the former needs to contain more: negative rule numbers. */
 512           ritem[itemno++] =
 513             symbol_number_as_item_number (p->content.sym->number);
 514           /* A rule gets by default the precedence and associativity
 515              of its last token.  */
 516           if (p->content.sym->class == token_sym && default_prec)
 517             rules[ruleno].prec = p->content.sym;
 518         }
 519
 520       /* If this rule has a %prec,
 521          the specified symbol's precedence replaces the default.  */
 522       if (ruleprec)
 523         {
 524           rules[ruleno].precsym = ruleprec;
 525           rules[ruleno].prec = ruleprec;
 526         }
 527       /* An item ends by the rule number (negated).  */
 528       ritem[itemno++] = rule_number_as_item_number (ruleno);
 529       aver (itemno < ITEM_NUMBER_MAX);
 530       ++ruleno;
 531       aver (ruleno < RULE_NUMBER_MAX);
 532
 533       if (p)
 534         p = p->next;
 535     }
 536
 537   aver (itemno == nritems);
 538
 539   if (trace_flag & trace_sets)
 540     ritem_print (stderr);
 541 }
 542 \f
 543 /*------------------------------------------------------------------.
 544 | Read in the grammar specification and record it in the format     |
 545 | described in gram.h.  All actions are copied into ACTION_OBSTACK, |
 546 | in each case forming the body of a C function (YYACTION) which    |
 547 | contains a switch statement to decide which action to execute.    |
 548 `------------------------------------------------------------------*/
 549
 550 void
 551 reader (void)
 552 {
 553   /* Initialize the symbol table.  */
 554   symbols_new ();
 555
 556   /* Construct the accept symbol. */
 557   accept = symbol_get ("$accept", empty_location);
 558   accept->class = nterm_sym;
 559   accept->number = nvars++;
 560
 561   /* Construct the error token */
 562   errtoken = symbol_get ("error", empty_location);
 563   errtoken->class = token_sym;
 564   errtoken->number = ntokens++;
 565
 566   /* Construct a token that represents all undefined literal tokens.
 567      It is always token number 2.  */
 568   undeftoken = symbol_get ("$undefined", empty_location);
 569   undeftoken->class = token_sym;
 570   undeftoken->number = ntokens++;
 571
 572   /* Initialize the obstacks. */
 573   obstack_init (&pre_prologue_obstack);
 574   obstack_init (&post_prologue_obstack);
 575
 576   gram_in = xfopen (grammar_file, "r");
 577
 578   gram__flex_debug = trace_flag & trace_scan;
 579   gram_debug = trace_flag & trace_parse;
 580   gram_scanner_initialize ();
 581   gram_parse ();
 582
 583   if (! complaint_issued)
 584     check_and_convert_grammar ();
 585
 586   xfclose (gram_in);
 587 }
 588
 589
 590 /*-------------------------------------------------------------.
 591 | Check the grammar that has just been read, and convert it to |
 592 | internal form.                                               |
 593 `-------------------------------------------------------------*/
 594
 595 static void
 596 check_and_convert_grammar (void)
 597 {
 598   /* Grammar has been read.  Do some checking.  */
 599   if (nrules == 0)
 600     fatal (_("no rules in the input grammar"));
 601
 602   /* Report any undefined symbols and consider them nonterminals.  */
 603   symbols_check_defined ();
 604
 605   /* If the user did not define her ENDTOKEN, do it now. */
 606   if (!endtoken)
 607     {
 608       endtoken = symbol_get ("$end", empty_location);
 609       endtoken->class = token_sym;
 610       endtoken->number = 0;
 611       /* Value specified by POSIX.  */
 612       endtoken->user_token_number = 0;
 613     }
 614
 615   /* Find the start symbol if no %start.  */
 616   if (!start_flag)
 617     {
 618       symbol_list *node;
 619       for (node = grammar;
 620            node != NULL && symbol_is_dummy (node->content.sym);
 621            node = node->next)
 622         {
 623           for (node = node->next;
 624                node != NULL && node->content.sym != NULL;
 625                node = node->next)
 626             ;
 627         }
 628       aver (node != NULL);
 629       grammar_start_symbol_set (node->content.sym,
 630                                 node->content.sym->location);
 631     }
 632
 633   /* Insert the initial rule, whose line is that of the first rule
 634      (not that of the start symbol):
 635
 636      accept: %start EOF.  */
 637   {
 638     symbol_list *p = symbol_list_sym_new (accept, empty_location);
 639     p->location = grammar->location;
 640     p->next = symbol_list_sym_new (startsymbol, empty_location);
 641     p->next->next = symbol_list_sym_new (endtoken, empty_location);
 642     p->next->next->next = symbol_list_sym_new (NULL, empty_location);
 643     p->next->next->next->next = grammar;
 644     nrules += 1;
 645     nritems += 3;
 646     grammar = p;
 647   }
 648
 649   aver (nsyms <= SYMBOL_NUMBER_MAXIMUM && nsyms == ntokens + nvars);
 650
 651   /* Assign the symbols their symbol numbers.  Write #defines for the
 652      token symbols into FDEFINES if requested.  */
 653   symbols_pack ();
 654
 655   /* Convert the grammar into the format described in gram.h.  */
 656   packgram ();
 657
 658   /* The grammar as a symbol_list is no longer needed. */
 659   LIST_FREE (symbol_list, grammar);
 660 }