1 /* Input parser for bison
2 Copyright 1984, 1986, 1989, 1992, 1998, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of Bison, the GNU Compiler Compiler.
7 Bison is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 Bison is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with Bison; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
35 #include "conflicts.h"
36 #include "muscle_tab.h"
38 typedef struct symbol_list
40 struct symbol_list
*next
;
44 /* The action is attached to the LHS of a rule. */
48 /* The guard is attached to the LHS of a rule. */
55 static symbol_list
*grammar
;
56 static int start_flag
;
57 static bucket
*startval
;
59 /* Nonzero if components of semantic values are used, implying
60 they must be unions. */
61 static int value_components_used
;
63 /* Nonzero if %union has been seen. */
66 /* Incremented for each %left, %right or %nonassoc seen */
69 static bucket
*errtoken
= NULL
;
70 static bucket
*undeftoken
= NULL
;
71 static bucket
*eoftoken
= NULL
;
72 static bucket
*axiom
= NULL
;
75 symbol_list_new (bucket
*sym
)
77 symbol_list
*res
= XMALLOC (symbol_list
, 1);
91 /*===================\
93 \===================*/
96 skip_to_char (int target
)
100 complain (_(" Skipping to next \\n"));
102 complain (_(" Skipping to next %c"), target
);
105 c
= skip_white_space ();
106 while (c
!= target
&& c
!= EOF
);
112 /*---------------------------------------------------------.
113 | Read a signed integer from STREAM and return its value. |
114 `---------------------------------------------------------*/
117 read_signed_integer (FILE *stream
)
119 int c
= getc (stream
);
131 n
= 10 * n
+ (c
- '0');
140 /*--------------------------------------------------------------.
141 | Get the data type (alternative in the union) of the value for |
142 | symbol N in rule RULE. |
143 `--------------------------------------------------------------*/
146 get_type_name (int n
, symbol_list
*rule
)
153 complain (_("invalid $ value"));
163 if (rp
== NULL
|| rp
->sym
== NULL
)
165 complain (_("invalid $ value"));
171 return rp
->sym
->type_name
;
174 /*------------------------------------------------------------.
175 | Dump the string from FIN to OOUT if non null. MATCH is the |
176 | delimiter of the string (either ' or "). |
177 `------------------------------------------------------------*/
180 copy_string2 (FILE *fin
, struct obstack
*oout
, int match
, int store
)
185 obstack_1grow (oout
, match
);
192 fatal (_("unterminated string at end of file"));
195 complain (_("unterminated string"));
197 c
= match
; /* invent terminator */
201 obstack_1grow (oout
, c
);
207 fatal (_("unterminated string at end of file"));
208 obstack_1grow (oout
, c
);
218 obstack_1grow (oout
, c
);
224 copy_string (FILE *fin
, struct obstack
*oout
, int match
)
226 copy_string2 (fin
, oout
, match
, 1);
232 copy_identifier (FILE *fin
, struct obstack
*oout
)
236 while (isalnum (c
= getc (fin
)) || c
== '_')
237 obstack_1grow (oout
, c
);
243 /*------------------------------------------------------------------.
244 | Dump the wannabee comment from IN to OOUT. In fact we just saw a |
245 | `/', which might or might not be a comment. In any case, copy |
247 `------------------------------------------------------------------*/
250 copy_comment (FILE *fin
, struct obstack
*oout
)
256 /* We read a `/', output it. */
257 obstack_1grow (oout
, '/');
259 switch ((c
= getc (fin
)))
272 obstack_1grow (oout
, c
);
278 if (!cplus_comment
&& c
== '*')
282 obstack_1grow (oout
, c
);
288 obstack_1grow (oout
, c
);
295 obstack_1grow (oout
, c
);
302 fatal (_("unterminated comment"));
305 obstack_1grow (oout
, c
);
312 /*-----------------------------------------------------------------.
313 | FIN is pointing to a location (i.e., a `@'). Output to OOUT a |
314 | reference to this location. STACK_OFFSET is the number of values |
315 | in the current rule so far, which says where to find `$0' with |
316 | respect to the top of the stack. |
317 `-----------------------------------------------------------------*/
320 copy_at (FILE *fin
, struct obstack
*oout
, int stack_offset
)
327 obstack_sgrow (oout
, "yyloc");
330 else if (isdigit (c
) || c
== '-')
335 n
= read_signed_integer (fin
);
336 if (n
> stack_offset
)
337 complain (_("invalid value: %s%d"), "@", n
);
340 /* Offset is always 0 if parser has already popped the stack
342 obstack_fgrow1 (oout
, "yylsp[%d]",
343 n
- (semantic_parser
? 0 : stack_offset
));
351 complain (_("%s is invalid"), quote (buf
));
356 /*-------------------------------------------------------------------.
357 | FIN is pointing to a wannabee semantic value (i.e., a `$'). |
359 | Possible inputs: $[<TYPENAME>]($|integer) |
361 | Output to OOUT a reference to this semantic value. STACK_OFFSET is |
362 | the number of values in the current rule so far, which says where |
363 | to find `$0' with respect to the top of the stack. |
364 `-------------------------------------------------------------------*/
367 copy_dollar (FILE *fin
, struct obstack
*oout
,
368 symbol_list
*rule
, int stack_offset
)
371 const char *type_name
= NULL
;
373 /* Get the type name if explicit. */
376 read_type_name (fin
);
377 type_name
= token_buffer
;
378 value_components_used
= 1;
384 obstack_sgrow (oout
, "yyval");
387 type_name
= get_type_name (0, rule
);
389 obstack_fgrow1 (oout
, ".%s", type_name
);
390 if (!type_name
&& typed
)
391 complain (_("$$ of `%s' has no declared type"),
394 else if (isdigit (c
) || c
== '-')
398 n
= read_signed_integer (fin
);
400 if (n
> stack_offset
)
401 complain (_("invalid value: %s%d"), "$", n
);
404 if (!type_name
&& n
> 0)
405 type_name
= get_type_name (n
, rule
);
407 /* Offset is always 0 if parser has already popped the stack
409 obstack_fgrow1 (oout
, "yyvsp[%d]",
410 n
- (semantic_parser
? 0 : stack_offset
));
413 obstack_fgrow1 (oout
, ".%s", type_name
);
414 if (!type_name
&& typed
)
415 complain (_("$%d of `%s' has no declared type"),
423 complain (_("%s is invalid"), quote (buf
));
427 /*-------------------------------------------------------------------.
428 | Copy the contents of a `%{ ... %}' into the definitions file. The |
429 | `%{' has already been read. Return after reading the `%}'. |
430 `-------------------------------------------------------------------*/
433 copy_definition (void)
436 /* -1 while reading a character if prev char was %. */
441 obstack_fgrow2 (&attrs_obstack
, muscle_find ("linef"),
442 lineno
, quotearg_style (c_quoting_style
,
443 muscle_find ("filename")));
455 obstack_1grow (&attrs_obstack
, c
);
465 copy_string (finput
, &attrs_obstack
, c
);
469 copy_comment (finput
, &attrs_obstack
);
473 fatal ("%s", _("unterminated `%{' definition"));
476 obstack_1grow (&attrs_obstack
, c
);
485 obstack_1grow (&attrs_obstack
, '%');
492 /*-------------------------------------------------------------------.
493 | Parse what comes after %token or %nterm. For %token, WHAT_IS is |
494 | token_sym and WHAT_IS_NOT is nterm_sym. For %nterm, the arguments |
496 `-------------------------------------------------------------------*/
499 parse_token_decl (symbol_class what_is
, symbol_class what_is_not
)
501 token_t token
= tok_undef
;
502 char *typename
= NULL
;
504 /* The symbol being defined. */
505 struct bucket
*symbol
= NULL
;
507 /* After `%token' and `%nterm', any number of symbols maybe be
511 int tmp_char
= ungetc (skip_white_space (), finput
);
513 /* `%' (for instance from `%token', or from `%%' etc.) is the
514 only valid means to end this declaration. */
518 fatal (_("Premature EOF after %s"), token_buffer
);
521 if (token
== tok_comma
)
526 if (token
== tok_typename
)
528 typename
= xstrdup (token_buffer
);
529 value_components_used
= 1;
532 else if (token
== tok_identifier
&& *symval
->tag
== '\"' && symbol
)
535 warn (_("symbol `%s' used more than once as a literal string"),
537 else if (symbol
->alias
)
538 warn (_("symbol `%s' given more than one literal string"),
542 symval
->class = token_sym
;
543 symval
->type_name
= typename
;
544 symval
->user_token_number
= symbol
->user_token_number
;
545 symbol
->user_token_number
= SALIAS
;
546 symval
->alias
= symbol
;
547 symbol
->alias
= symval
;
548 /* symbol and symval combined are only one symbol */
553 else if (token
== tok_identifier
)
555 int oldclass
= symval
->class;
558 if (symbol
->class == what_is_not
)
559 complain (_("symbol %s redefined"), symbol
->tag
);
560 symbol
->class = what_is
;
561 if (what_is
== nterm_sym
&& oldclass
!= nterm_sym
)
562 symbol
->value
= nvars
++;
566 if (symbol
->type_name
== NULL
)
567 symbol
->type_name
= typename
;
568 else if (strcmp (typename
, symbol
->type_name
) != 0)
569 complain (_("type redeclaration for %s"), symbol
->tag
);
572 else if (symbol
&& token
== tok_number
)
574 symbol
->user_token_number
= numval
;
575 /* User defined EOF token? */
581 complain (_("`%s' is invalid in %s"),
583 (what_is
== token_sym
) ? "%token" : "%nterm");
591 /*------------------------------.
592 | Parse what comes after %start |
593 `------------------------------*/
596 parse_start_decl (void)
599 complain (_("multiple %s declarations"), "%start");
600 if (lex () != tok_identifier
)
601 complain (_("invalid %s declaration"), "%start");
609 /*-----------------------------------------------------------.
610 | read in a %type declaration and record its information for |
611 | get_type_name to access |
612 `-----------------------------------------------------------*/
615 parse_type_decl (void)
619 if (lex () != tok_typename
)
621 complain ("%s", _("%type declaration has no <typename>"));
626 name
= xstrdup (token_buffer
);
631 int tmp_char
= ungetc (skip_white_space (), finput
);
636 fatal (_("Premature EOF after %s"), token_buffer
);
648 if (symval
->type_name
== NULL
)
649 symval
->type_name
= name
;
650 else if (strcmp (name
, symval
->type_name
) != 0)
651 complain (_("type redeclaration for %s"), symval
->tag
);
656 complain (_("invalid %%type declaration due to item: %s"),
665 /*----------------------------------------------------------------.
666 | Read in a %left, %right or %nonassoc declaration and record its |
668 `----------------------------------------------------------------*/
671 parse_assoc_decl (associativity assoc
)
676 lastprec
++; /* Assign a new precedence level, never 0. */
681 int tmp_char
= ungetc (skip_white_space (), finput
);
686 fatal (_("Premature EOF after %s"), token_buffer
);
693 name
= xstrdup (token_buffer
);
700 if (symval
->prec
!= 0)
701 complain (_("redefining precedence of %s"), symval
->tag
);
702 symval
->prec
= lastprec
;
703 symval
->assoc
= assoc
;
704 if (symval
->class == nterm_sym
)
705 complain (_("symbol %s redefined"), symval
->tag
);
706 symval
->class = token_sym
;
708 { /* record the type, if one is specified */
709 if (symval
->type_name
== NULL
)
710 symval
->type_name
= name
;
711 else if (strcmp (name
, symval
->type_name
) != 0)
712 complain (_("type redeclaration for %s"), symval
->tag
);
717 if (prev
== tok_identifier
)
719 symval
->user_token_number
= numval
;
724 ("invalid text (%s) - number should be after identifier"),
734 complain (_("unexpected item: %s"), token_buffer
);
744 /*--------------------------------------------------------------.
745 | Copy the union declaration into the stype muscle |
746 | (and fdefines), where it is made into the definition of |
747 | YYSTYPE, the type of elements of the parser value stack. |
748 `--------------------------------------------------------------*/
751 parse_union_decl (void)
756 struct obstack union_obstack
;
758 complain (_("multiple %s declarations"), "%union");
762 obstack_init (&union_obstack
);
763 obstack_sgrow (&union_obstack
, "union");
769 /* If C contains '/', it is output by copy_comment (). */
771 obstack_1grow (&union_obstack
, c
);
780 copy_comment (finput
, &union_obstack
);
788 /* FIXME: Errr. How could this happen???. --akim */
790 complain (_("unmatched %s"), "`}'");
798 /* JF don't choke on trailing semi */
799 c
= skip_white_space ();
802 obstack_1grow (&union_obstack
, 0);
803 muscle_insert ("stype", obstack_finish (&union_obstack
));
807 /*-------------------------------------------------------.
808 | Parse the declaration %expect N which says to expect N |
809 | shift-reduce conflicts. |
810 `-------------------------------------------------------*/
813 parse_expect_decl (void)
815 int c
= skip_white_space ();
819 complain (_("argument of %%expect is not an integer"));
821 expected_conflicts
= read_signed_integer (finput
);
825 /*-------------------------------------------------------------------.
826 | Parse what comes after %thong. the full syntax is |
828 | %thong <type> token number literal |
830 | the <type> or number may be omitted. The number specifies the |
831 | user_token_number. |
833 | Two symbols are entered in the table, one for the token symbol and |
834 | one for the literal. Both are given the <type>, if any, from the |
835 | declaration. The ->user_token_number of the first is SALIAS and |
836 | the ->user_token_number of the second is set to the number, if |
837 | any, from the declaration. The two symbols are linked via |
838 | pointers in their ->alias fields. |
840 | During OUTPUT_DEFINES_TABLE, the symbol is reported thereafter, |
841 | only the literal string is retained it is the literal string that |
842 | is output to yytname |
843 `-------------------------------------------------------------------*/
846 parse_thong_decl (void)
849 struct bucket
*symbol
;
851 int usrtoknum
= SUNDEF
;
853 token
= lex (); /* fetch typename or first token */
854 if (token
== tok_typename
)
856 typename
= xstrdup (token_buffer
);
857 value_components_used
= 1;
858 token
= lex (); /* fetch first token */
861 /* process first token */
863 if (token
!= tok_identifier
)
865 complain (_("unrecognized item %s, expected an identifier"),
870 symval
->class = token_sym
;
871 symval
->type_name
= typename
;
872 symval
->user_token_number
= SALIAS
;
875 token
= lex (); /* get number or literal string */
877 if (token
== tok_number
)
880 token
= lex (); /* okay, did number, now get literal */
883 /* process literal string token */
885 if (token
!= tok_identifier
|| *symval
->tag
!= '\"')
887 complain (_("expected string constant instead of %s"), token_buffer
);
891 symval
->class = token_sym
;
892 symval
->type_name
= typename
;
893 symval
->user_token_number
= usrtoknum
;
895 symval
->alias
= symbol
;
896 symbol
->alias
= symval
;
898 /* symbol and symval combined are only one symbol. */
904 parse_muscle_decl (void)
906 int ch
= ungetc (skip_white_space (), finput
);
911 if (!isalpha (ch
) && ch
!= '_')
913 complain (_("invalid %s declaration"), "%define");
917 copy_identifier (finput
, &muscle_obstack
);
918 obstack_1grow (&muscle_obstack
, 0);
919 muscle_key
= obstack_finish (&muscle_obstack
);
922 ch
= skip_white_space ();
928 complain (_("invalid %s declaration"), "%define");
933 fatal (_("Premature EOF after %s"), "\"");
935 copy_string2 (finput
, &muscle_obstack
, '"', 0);
936 obstack_1grow (&muscle_obstack
, 0);
937 muscle_value
= obstack_finish (&muscle_obstack
);
939 /* Store the (key, value) pair in the environment. */
940 muscle_insert (muscle_key
, muscle_value
);
945 /*---------------------------------.
946 | Parse a double quoted parameter. |
947 `---------------------------------*/
950 parse_dquoted_param (const char *from
)
952 struct obstack param_obstack
;
953 const char *param
= NULL
;
956 obstack_init (¶m_obstack
);
957 c
= skip_white_space ();
961 complain (_("invalid %s declaration"), from
);
967 while ((c
= literalchar ()) != '"')
968 obstack_1grow (¶m_obstack
, c
);
970 obstack_1grow (¶m_obstack
, '\0');
971 param
= obstack_finish (¶m_obstack
);
973 if (c
!= '"' || strlen (param
) == 0)
975 complain (_("invalid %s declaration"), from
);
985 /*----------------------------------.
986 | Parse what comes after %skeleton. |
987 `----------------------------------*/
990 parse_skel_decl (void)
992 skeleton
= parse_dquoted_param ("%skeleton");
995 /*----------------------------------------------------------------.
996 | Read from finput until `%%' is seen. Discard the `%%'. Handle |
997 | any `%' declarations, and copy the contents of any `%{ ... %}' |
998 | groups to ATTRS_OBSTACK. |
999 `----------------------------------------------------------------*/
1002 read_declarations (void)
1006 int c
= skip_white_space ();
1010 token_t tok
= parse_percent_token ();
1014 case tok_two_percents
:
1017 case tok_percent_left_curly
:
1022 parse_token_decl (token_sym
, nterm_sym
);
1026 parse_token_decl (nterm_sym
, token_sym
);
1034 parse_start_decl ();
1038 parse_union_decl ();
1042 parse_expect_decl ();
1046 parse_thong_decl ();
1050 parse_assoc_decl (left_assoc
);
1054 parse_assoc_decl (right_assoc
);
1058 parse_assoc_decl (non_assoc
);
1062 parse_muscle_decl ();
1080 complain (_("unrecognized: %s"), token_buffer
);
1085 fatal (_("no input grammar"));
1090 complain (_("unknown character: %s"), quote (buf
));
1096 /*-------------------------------------------------------------------.
1097 | Assuming that a `{' has just been seen, copy everything up to the |
1098 | matching `}' into the actions file. STACK_OFFSET is the number of |
1099 | values in the current rule so far, which says where to find `$0' |
1100 | with respect to the top of the stack. |
1102 | This routine is used both for actions and guards. Only |
1103 | ACTION_OBSTACK is used, but this is fine, since we use only |
1104 | pointers to relevant portions inside this obstack. |
1105 `-------------------------------------------------------------------*/
1108 parse_braces (symbol_list
*rule
, int stack_offset
)
1116 while ((c
= getc (finput
)) != '}')
1120 obstack_1grow (&action_obstack
, c
);
1125 obstack_1grow (&action_obstack
, c
);
1131 copy_string (finput
, &action_obstack
, c
);
1135 copy_comment (finput
, &action_obstack
);
1139 copy_dollar (finput
, &action_obstack
,
1140 rule
, stack_offset
);
1144 copy_at (finput
, &action_obstack
,
1149 fatal (_("unmatched %s"), "`{'");
1152 obstack_1grow (&action_obstack
, c
);
1155 /* Above loop exits when C is '}'. */
1157 obstack_1grow (&action_obstack
, c
);
1160 obstack_1grow (&action_obstack
, '\0');
1165 parse_action (symbol_list
*rule
, int stack_offset
)
1167 rule
->action_line
= lineno
;
1168 parse_braces (rule
, stack_offset
);
1169 rule
->action
= obstack_finish (&action_obstack
);
1174 parse_guard (symbol_list
*rule
, int stack_offset
)
1177 if (t
!= tok_left_curly
)
1178 complain (_("invalid %s declaration"), "%guard");
1179 rule
->guard_line
= lineno
;
1180 parse_braces (rule
, stack_offset
);
1181 rule
->guard
= obstack_finish (&action_obstack
);
1186 /*-------------------------------------------------------------------.
1187 | Generate a dummy symbol, a nonterminal, whose name cannot conflict |
1188 | with the user's names. |
1189 `-------------------------------------------------------------------*/
1194 /* Incremented for each generated symbol */
1195 static int gensym_count
= 0;
1196 static char buf
[256];
1200 sprintf (buf
, "@%d", ++gensym_count
);
1202 sym
= getsym (token_buffer
);
1203 sym
->class = nterm_sym
;
1204 sym
->value
= nvars
++;
1208 /*-------------------------------------------------------------------.
1209 | Parse the input grammar into a one symbol_list structure. Each |
1210 | rule is represented by a sequence of symbols: the left hand side |
1211 | followed by the contents of the right hand side, followed by a |
1212 | null pointer instead of a symbol to terminate the rule. The next |
1213 | symbol is the lhs of the following rule. |
1215 | All guards and actions are copied out to the appropriate files, |
1216 | labelled by the rule number they apply to. |
1218 | Bison used to allow some %directives in the rules sections, but |
1219 | this is no longer consider appropriate: (i) the documented grammar |
1220 | doesn't claim it, (ii), it would promote bad style, (iii), error |
1221 | recovery for %directives consists in skipping the junk until a `%' |
1222 | is seen and helrp synchronizing. This scheme is definitely wrong |
1223 | in the rules section. |
1224 `-------------------------------------------------------------------*/
1231 symbol_list
*p
= NULL
;
1232 symbol_list
*p1
= NULL
;
1235 /* Points to first symbol_list of current rule. its symbol is the
1237 symbol_list
*crule
= NULL
;
1238 /* Points to the symbol_list preceding crule. */
1239 symbol_list
*crule1
= NULL
;
1243 while (t
!= tok_two_percents
&& t
!= tok_eof
)
1244 if (t
== tok_identifier
|| t
== tok_bar
)
1246 int action_flag
= 0;
1247 /* Number of symbols in rhs of this rule so far */
1249 int xactions
= 0; /* JF for error checking */
1250 bucket
*first_rhs
= 0;
1252 if (t
== tok_identifier
)
1265 complain (_("ill-formed rule: initial symbol not followed by colon"));
1270 if (nrules
== 0 && t
== tok_bar
)
1272 complain (_("grammar starts with vertical bar"));
1273 lhs
= symval
; /* BOGUS: use a random symval */
1275 /* start a new rule and record its lhs. */
1280 p
= symbol_list_new (lhs
);
1291 /* mark the rule's lhs as a nonterminal if not already so. */
1293 if (lhs
->class == unknown_sym
)
1295 lhs
->class = nterm_sym
;
1299 else if (lhs
->class == token_sym
)
1300 complain (_("rule given for %s, which is a token"), lhs
->tag
);
1302 /* read the rhs of the rule. */
1310 crule
->ruleprec
= symval
;
1314 if (!(t
== tok_identifier
|| t
== tok_left_curly
))
1317 /* If next token is an identifier, see if a colon follows it.
1318 If one does, exit this rule now. */
1319 if (t
== tok_identifier
)
1328 if (t1
== tok_colon
)
1331 if (!first_rhs
) /* JF */
1333 /* Not followed by colon =>
1334 process as part of this rule's rhs. */
1337 /* If we just passed an action, that action was in the middle
1338 of a rule, so make a dummy rule to reduce it to a
1342 /* Since the action was written out with this rule's
1343 number, we must give the new rule this number by
1344 inserting the new rule before it. */
1346 /* Make a dummy nonterminal, a gensym. */
1347 bucket
*sdummy
= gensym ();
1349 /* Make a new rule, whose body is empty, before the
1350 current one, so that the action just read can
1354 p
= symbol_list_new (sdummy
);
1355 /* Attach its lineno to that of the host rule. */
1356 p
->line
= crule
->line
;
1357 /* Move the action from the host rule to this one. */
1358 p
->action
= crule
->action
;
1359 p
->action_line
= crule
->action_line
;
1360 crule
->action
= NULL
;
1366 /* End of the rule. */
1367 crule1
= symbol_list_new (NULL
);
1368 crule1
->next
= crule
;
1372 /* Insert the dummy generated by that rule into this
1375 p
= symbol_list_new (sdummy
);
1382 if (t
== tok_identifier
)
1385 p
= symbol_list_new (symval
);
1389 else /* handle an action. */
1391 parse_action (crule
, rulelength
);
1393 xactions
++; /* JF */
1396 } /* end of read rhs of rule */
1398 /* Put an empty link in the list to mark the end of this rule */
1399 p
= symbol_list_new (NULL
);
1405 complain (_("two @prec's in a row"));
1407 crule
->ruleprec
= symval
;
1413 if (!semantic_parser
)
1414 complain (_("%%guard present but %%semantic_parser not specified"));
1416 parse_guard (crule
, rulelength
);
1420 if (t
== tok_left_curly
)
1422 /* This case never occurs -wjh */
1424 complain (_("two actions at end of one rule"));
1425 parse_action (crule
, rulelength
);
1427 xactions
++; /* -wjh */
1430 /* If $$ is being set in default way, report if any type
1433 && first_rhs
&& lhs
->type_name
!= first_rhs
->type_name
)
1435 if (lhs
->type_name
== 0
1436 || first_rhs
->type_name
== 0
1437 || strcmp (lhs
->type_name
, first_rhs
->type_name
))
1438 complain (_("type clash (`%s' `%s') on default action"),
1439 lhs
->type_name
? lhs
->type_name
: "",
1440 first_rhs
->type_name
? first_rhs
->type_name
: "");
1442 /* Warn if there is no default for $$ but we need one. */
1443 else if (!xactions
&& !first_rhs
&& lhs
->type_name
!= 0)
1444 complain (_("empty rule for typed nonterminal, and no action"));
1445 if (t
== tok_semicolon
)
1450 complain (_("invalid input: %s"), quote (token_buffer
));
1454 /* grammar has been read. Do some checking */
1457 fatal (_("no rules in the input grammar"));
1459 /* Report any undefined symbols and consider them nonterminals. */
1461 for (bp
= firstsymbol
; bp
; bp
= bp
->next
)
1462 if (bp
->class == unknown_sym
)
1465 ("symbol %s is used, but is not defined as a token and has no rules"),
1467 bp
->class = nterm_sym
;
1468 bp
->value
= nvars
++;
1471 /* Insert the initial rule, which line is that of the first rule
1472 (not that of the start symbol):
1474 axiom: %start EOF. */
1475 p
= symbol_list_new (axiom
);
1476 p
->line
= grammar
->line
;
1477 p
->next
= symbol_list_new (startval
);
1478 p
->next
->next
= symbol_list_new (eoftoken
);
1479 p
->next
->next
->next
= symbol_list_new (NULL
);
1480 p
->next
->next
->next
->next
= grammar
;
1486 if (nsyms
> MAXSHORT
)
1487 fatal (_("too many symbols (tokens plus nonterminals); maximum %d"),
1490 ntokens
= nsyms
- nvars
;
1493 /* At the end of the grammar file, some C source code must
1494 be stored. It is going to be associated to the epilogue
1497 read_additionnal_code (void)
1500 struct obstack el_obstack
;
1502 obstack_init (&el_obstack
);
1506 obstack_fgrow2 (&el_obstack
, muscle_find ("linef"),
1507 lineno
, quotearg_style (c_quoting_style
,
1508 muscle_find ("filename")));
1511 while ((c
= getc (finput
)) != EOF
)
1512 obstack_1grow (&el_obstack
, c
);
1514 obstack_1grow (&el_obstack
, 0);
1515 muscle_insert ("epilogue", obstack_finish (&el_obstack
));
1519 /*------------------------------------------------------------------.
1520 | Set TOKEN_TRANSLATIONS. Check that no two symbols share the same |
1522 `------------------------------------------------------------------*/
1525 token_translations_init (void)
1530 token_translations
= XCALLOC (short, max_user_token_number
+ 1);
1532 /* Initialize all entries for literal tokens to 2, the internal
1533 token number for $undefined., which represents all invalid
1535 for (i
= 0; i
<= max_user_token_number
; i
++)
1536 token_translations
[i
] = 2;
1538 for (bp
= firstsymbol
; bp
; bp
= bp
->next
)
1541 if (bp
->value
>= ntokens
)
1543 /* A token string alias? */
1544 if (bp
->user_token_number
== SALIAS
)
1547 assert (bp
->user_token_number
!= SUNDEF
);
1549 /* A token which translation has already been set? */
1550 if (token_translations
[bp
->user_token_number
] != 2)
1551 complain (_("tokens %s and %s both assigned number %d"),
1552 symbols
[token_translations
[bp
->user_token_number
]]->tag
,
1553 bp
->tag
, bp
->user_token_number
);
1554 token_translations
[bp
->user_token_number
] = bp
->value
;
1559 /*----------------------------------------------------------------.
1560 | Assign symbol numbers, and write definition of token names into |
1561 | FDEFINES. Set up vectors SYMBOL_TABLE, TAGS of symbols. |
1562 `----------------------------------------------------------------*/
1569 int last_user_token_number
;
1571 symbols
= XCALLOC (bucket
*, nsyms
);
1573 max_user_token_number
= 256;
1574 last_user_token_number
= 256;
1576 for (bp
= firstsymbol
; bp
; bp
= bp
->next
)
1578 if (bp
->class == nterm_sym
)
1580 bp
->value
+= ntokens
;
1584 /* This symbol and its alias are a single token defn.
1585 Allocate a tokno, and assign to both check agreement of
1586 prec and assoc fields and make both the same */
1587 if (bp
->value
== -1)
1589 if (bp
== eoftoken
|| bp
->alias
== eoftoken
)
1590 bp
->value
= bp
->alias
->value
= 0;
1593 bp
->value
= bp
->alias
->value
= tokno
++;
1597 if (bp
->prec
!= bp
->alias
->prec
)
1599 if (bp
->prec
!= 0 && bp
->alias
->prec
!= 0
1600 && bp
->user_token_number
== SALIAS
)
1601 complain (_("conflicting precedences for %s and %s"),
1602 bp
->tag
, bp
->alias
->tag
);
1604 bp
->alias
->prec
= bp
->prec
;
1606 bp
->prec
= bp
->alias
->prec
;
1609 if (bp
->assoc
!= bp
->alias
->assoc
)
1611 if (bp
->assoc
!= 0 && bp
->alias
->assoc
!= 0
1612 && bp
->user_token_number
== SALIAS
)
1613 complain (_("conflicting assoc values for %s and %s"),
1614 bp
->tag
, bp
->alias
->tag
);
1616 bp
->alias
->assoc
= bp
->assoc
;
1618 bp
->assoc
= bp
->alias
->assoc
;
1621 /* Do not do processing below for SALIASs. */
1622 if (bp
->user_token_number
== SALIAS
)
1626 else /* bp->class == token_sym */
1631 bp
->value
= tokno
++;
1634 if (bp
->class == token_sym
)
1636 if (bp
->user_token_number
== SUNDEF
)
1637 bp
->user_token_number
= ++last_user_token_number
;
1638 if (bp
->user_token_number
> max_user_token_number
)
1639 max_user_token_number
= bp
->user_token_number
;
1642 symbols
[bp
->value
] = bp
;
1645 token_translations_init ();
1647 error_token_number
= errtoken
->value
;
1649 if (startval
->class == unknown_sym
)
1650 fatal (_("the start symbol %s is undefined"), startval
->tag
);
1651 else if (startval
->class == token_sym
)
1652 fatal (_("the start symbol %s is a token"), startval
->tag
);
1654 start_symbol
= startval
->value
;
1658 /*---------------------------------------------------------------.
1659 | Convert the rules into the representation using RRHS, RLHS and |
1661 `---------------------------------------------------------------*/
1670 /* We use short to index items. */
1671 if (nitems
>= MAXSHORT
)
1672 fatal (_("too many items (max %d)"), MAXSHORT
);
1674 ritem
= XCALLOC (short, nitems
+ 1);
1675 rules
= XCALLOC (rule_t
, nrules
) - 1;
1683 bucket
*ruleprec
= p
->ruleprec
;
1684 rules
[ruleno
].lhs
= p
->sym
->value
;
1685 rules
[ruleno
].rhs
= itemno
;
1686 rules
[ruleno
].line
= p
->line
;
1687 rules
[ruleno
].useful
= TRUE
;
1688 rules
[ruleno
].action
= p
->action
;
1689 rules
[ruleno
].action_line
= p
->action_line
;
1690 rules
[ruleno
].guard
= p
->guard
;
1691 rules
[ruleno
].guard_line
= p
->guard_line
;
1696 ritem
[itemno
++] = p
->sym
->value
;
1697 /* A rule gets by default the precedence and associativity
1698 of the last token in it. */
1699 if (p
->sym
->class == token_sym
)
1701 rules
[ruleno
].prec
= p
->sym
->prec
;
1702 rules
[ruleno
].assoc
= p
->sym
->assoc
;
1708 /* If this rule has a %prec,
1709 the specified symbol's precedence replaces the default. */
1712 rules
[ruleno
].prec
= ruleprec
->prec
;
1713 rules
[ruleno
].assoc
= ruleprec
->assoc
;
1714 rules
[ruleno
].precsym
= ruleprec
->value
;
1717 ritem
[itemno
++] = -ruleno
;
1726 assert (nritems
== nitems
);
1729 ritem_print (stderr
);
1732 /*-------------------------------------------------------------------.
1733 | Read in the grammar specification and record it in the format |
1734 | described in gram.h. All guards are copied into the GUARD_OBSTACK |
1735 | and all actions into ACTION_OBSTACK, in each case forming the body |
1736 | of a C function (YYGUARD or YYACTION) which contains a switch |
1737 | statement to decide which guard or action to execute. |
1738 `-------------------------------------------------------------------*/
1744 startval
= NULL
; /* start symbol not specified yet. */
1754 semantic_parser
= 0;
1762 /* Initialize the muscle obstack. */
1763 obstack_init (&muscle_obstack
);
1765 /* Initialize the symbol table. */
1768 /* Construct the axiom symbol. */
1769 axiom
= getsym ("$axiom");
1770 axiom
->class = nterm_sym
;
1771 axiom
->value
= nvars
++;
1773 /* Construct the error token */
1774 errtoken
= getsym ("error");
1775 errtoken
->class = token_sym
;
1776 errtoken
->user_token_number
= 256; /* Value specified by POSIX. */
1778 /* Construct a token that represents all undefined literal tokens.
1779 It is always token number 2. */
1780 undeftoken
= getsym ("$undefined.");
1781 undeftoken
->class = token_sym
;
1782 undeftoken
->user_token_number
= 2;
1784 /* Initialize the obstacks. */
1785 obstack_init (&action_obstack
);
1786 obstack_init (&attrs_obstack
);
1787 obstack_init (&output_obstack
);
1789 finput
= xfopen (infile
, "r");
1791 /* Read the declaration section. Copy %{ ... %} groups to
1792 TABLE_OBSTACK and FDEFINES file. Also notice any %token, %left,
1793 etc. found there. */
1794 read_declarations ();
1796 /* If the user did not define her EOFTOKEN, do it now. */
1799 eoftoken
= getsym ("$");
1800 eoftoken
->class = token_sym
;
1801 /* Value specified by POSIX. */
1802 eoftoken
->user_token_number
= 0;
1805 /* Read in the grammar, build grammar in list form. Write out
1806 guards and actions. */
1808 /* Some C code is given at the end of the grammar file. */
1809 read_additionnal_code ();
1814 /* Assign the symbols their symbol numbers. Write #defines for the
1815 token symbols into FDEFINES if requested. */
1818 /* Convert the grammar into the format described in gram.h. */
1821 /* The grammar as a symbol_list is no longer needed. */
1822 LIST_FREE (symbol_list
, grammar
);