]>
git.saurik.com Git - bison.git/blob - src/reader.c
1 /* Input parser for bison
2 Copyright 1984, 1986, 1989, 1992, 1998, 2000
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. */
36 #include "conflicts.h"
38 /* Number of slots allocated (but not necessarily used yet) in `rline' */
39 static int rline_allocated
;
41 typedef struct symbol_list
43 struct symbol_list
*next
;
52 static symbol_list
*grammar
;
53 static int start_flag
;
54 static bucket
*startval
;
56 /* Nonzero if components of semantic values are used, implying
57 they must be unions. */
58 static int value_components_used
;
60 /* Nonzero if %union has been seen. */
63 /* Incremented for each %left, %right or %nonassoc seen */
66 /* Incremented for each generated symbol */
67 static int gensym_count
;
69 static bucket
*errtoken
;
70 static bucket
*undeftoken
;
73 /*===================\
75 \===================*/
78 skip_to_char (int target
)
82 complain (_(" Skipping to next \\n"));
84 complain (_(" Skipping to next %c"), target
);
87 c
= skip_white_space ();
88 while (c
!= target
&& c
!= EOF
);
94 /*---------------------------------------------------------.
95 | Read a signed integer from STREAM and return its value. |
96 `---------------------------------------------------------*/
99 read_signed_integer (FILE *stream
)
101 int c
= getc (stream
);
113 n
= 10 * n
+ (c
- '0');
122 /*--------------------------------------------------------------.
123 | Get the data type (alternative in the union) of the value for |
124 | symbol N in rule RULE. |
125 `--------------------------------------------------------------*/
128 get_type_name (int n
, symbol_list
* rule
)
135 complain (_("invalid $ value"));
145 if (rp
== NULL
|| rp
->sym
== NULL
)
147 complain (_("invalid $ value"));
153 return rp
->sym
->type_name
;
156 /*-----------------------------------------------------------------.
157 | Dump the string from FIN to FOUT and OOUT if non null. MATCH is |
158 | the delimiter of the string (either ' or "). |
159 `-----------------------------------------------------------------*/
162 copy_string (FILE *fin
, FILE *fout
, struct obstack
*oout
, int match
)
169 obstack_1grow (oout
, match
);
176 fatal (_("unterminated string at end of file"));
179 complain (_("unterminated string"));
181 c
= match
; /* invent terminator */
188 obstack_1grow (oout
, c
);
194 fatal (_("unterminated string at end of file"));
198 obstack_1grow (oout
, c
);
210 obstack_1grow (oout
, c
);
214 /*----------------------------------------------------------------.
215 | Dump the wannabee comment from IN to OUT1 and OUT2. In fact we |
216 | just saw a `/', which might or might not be a comment. In any |
217 | case, copy what we saw. |
219 | OUT2 might be NULL. |
220 `----------------------------------------------------------------*/
223 copy_comment2 (FILE *fin
, FILE *out1
,
224 struct obstack
*oout2
, struct obstack
*oout
)
230 /* We read a `/', output it. */
234 obstack_1grow (oout
, '/');
236 obstack_1grow (oout2
, '/');
238 switch ((c
= getc (fin
)))
254 obstack_1grow (oout
, c
);
256 obstack_1grow (oout2
, c
);
262 if (!cplus_comment
&& c
== '*')
269 obstack_1grow (oout
, c
);
271 obstack_1grow (oout2
, c
);
280 obstack_1grow (oout
, c
);
282 obstack_1grow (oout2
, c
);
292 obstack_1grow (oout
, c
);
294 obstack_1grow (oout2
, c
);
301 fatal (_("unterminated comment"));
307 obstack_1grow (oout
, c
);
309 obstack_1grow (oout2
, c
);
316 /*-------------------------------------------------------------------.
317 | Dump the comment (actually the current string starting with a `/') |
318 | from FIN to FOUT. |
319 `-------------------------------------------------------------------*/
322 copy_comment (FILE *fin
, FILE *fout
, struct obstack
*oout
)
324 copy_comment2 (fin
, fout
, NULL
, oout
);
328 /*-----------------------------------------------------------------.
329 | FIN is pointing to a location (i.e., a `@'). Output to FOUT a |
330 | reference to this location. STACK_OFFSET is the number of values |
331 | in the current rule so far, which says where to find `$0' with |
332 | respect to the top of the stack. |
333 `-----------------------------------------------------------------*/
336 copy_at (FILE *fin
, FILE *fout
, struct obstack
*oout
, int stack_offset
)
344 fprintf (fout
, "yyloc");
346 obstack_grow_literal_string (oout
, "yyloc");
349 else if (isdigit (c
) || c
== '-')
355 n
= read_signed_integer (fin
);
357 sprintf (buf
, "yylsp[%d]", n
- stack_offset
);
361 obstack_grow (oout
, buf
, strlen (buf
));
368 complain (_("%s is invalid"), quote (buf
));
373 /*-------------------------------------------------------------------.
374 | FIN is pointing to a wannabee semantic value (i.e., a `$'). |
376 | Possible inputs: $[<TYPENAME>]($|integer) |
378 | Output to FOUT a reference to this semantic value. STACK_OFFSET is |
379 | the number of values in the current rule so far, which says where |
380 | to find `$0' with respect to the top of the stack. |
381 `-------------------------------------------------------------------*/
384 copy_dollar (FILE *fin
, FILE *fout
, struct obstack
*oout
,
385 symbol_list
*rule
, int stack_offset
)
388 char *type_name
= NULL
;
390 /* Get the type name if explicit. */
393 read_type_name (fin
);
394 type_name
= token_buffer
;
395 value_components_used
= 1;
402 fputs ("yyval", fout
);
404 obstack_grow_literal_string (oout
, "yyval");
407 type_name
= get_type_name (0, rule
);
411 fprintf (fout
, ".%s", type_name
);
413 obstack_fgrow1 (oout
, ".%s", type_name
);
415 if (!type_name
&& typed
)
416 complain (_("$$ of `%s' has no declared type"),
419 else if (isdigit (c
) || c
== '-')
423 n
= read_signed_integer (fin
);
425 if (!type_name
&& n
> 0)
426 type_name
= get_type_name (n
, rule
);
429 fprintf (fout
, "yyvsp[%d]", n
- stack_offset
);
431 obstack_fgrow1 (oout
, "yyvsp[%d]", n
- stack_offset
);
436 fprintf (fout
, ".%s", type_name
);
438 obstack_fgrow1 (oout
, ".%s", type_name
);
440 if (!type_name
&& typed
)
441 complain (_("$%d of `%s' has no declared type"),
448 complain (_("%s is invalid"), quote (buf
));
452 /*-------------------------------------------------------------------.
453 | Copy the contents of a `%{ ... %}' into the definitions file. The |
454 | `%{' has already been read. Return after reading the `%}'. |
455 `-------------------------------------------------------------------*/
458 copy_definition (void)
461 /* -1 while reading a character if prev char was %. */
465 obstack_fgrow2 (&attrs_obstack
, "#line %d %s\n",
466 lineno
, quotearg_style (c_quoting_style
, infile
));
477 obstack_1grow (&attrs_obstack
, c
);
487 copy_string (finput
, 0, &attrs_obstack
, c
);
491 copy_comment (finput
, 0, &attrs_obstack
);
495 fatal ("%s", _("unterminated `%{' definition"));
498 obstack_1grow (&attrs_obstack
, c
);
507 obstack_1grow (&attrs_obstack
, '%');
514 /*-------------------------------------------------------------------.
515 | Parse what comes after %token or %nterm. For %token, WHAT_IS is |
516 | token_sym and WHAT_IS_NOT is nterm_sym. For %nterm, the arguments |
518 `-------------------------------------------------------------------*/
521 parse_token_decl (symbol_class what_is
, symbol_class what_is_not
)
526 /* The symbol being defined. */
527 struct bucket
*symbol
= NULL
;
529 /* After `%token' and `%nterm', any number of symbols maybe be
533 int tmp_char
= ungetc (skip_white_space (), finput
);
535 /* `%' (for instance from `%token', or from `%%' etc.) is the
536 only valid means to end this declaration. */
540 fatal (_("Premature EOF after %s"), token_buffer
);
548 if (token
== TYPENAME
)
550 typename
= xstrdup (token_buffer
);
551 value_components_used
= 1;
554 else if (token
== IDENTIFIER
&& *symval
->tag
== '\"' && symbol
)
557 warn (_("symbol `%s' used more than once as a literal string"),
559 else if (symbol
->alias
)
560 warn (_("symbol `%s' given more than one literal string"),
564 symval
->class = token_sym
;
565 symval
->type_name
= typename
;
566 symval
->user_token_number
= symbol
->user_token_number
;
567 symbol
->user_token_number
= SALIAS
;
568 symval
->alias
= symbol
;
569 symbol
->alias
= symval
;
570 /* symbol and symval combined are only one symbol */
576 else if (token
== IDENTIFIER
)
578 int oldclass
= symval
->class;
581 if (symbol
->class == what_is_not
)
582 complain (_("symbol %s redefined"), symbol
->tag
);
583 symbol
->class = what_is
;
584 if (what_is
== nterm_sym
&& oldclass
!= nterm_sym
)
585 symbol
->value
= nvars
++;
589 if (symbol
->type_name
== NULL
)
590 symbol
->type_name
= typename
;
591 else if (strcmp (typename
, symbol
->type_name
) != 0)
592 complain (_("type redeclaration for %s"), symbol
->tag
);
595 else if (symbol
&& token
== NUMBER
)
597 symbol
->user_token_number
= numval
;
602 complain (_("`%s' is invalid in %s"),
603 token_buffer
, (what_is
== token_sym
) ? "%token" : "%nterm");
611 /*------------------------------.
612 | Parse what comes after %start |
613 `------------------------------*/
616 parse_start_decl (void)
619 complain (_("multiple %s declarations"), "%start");
620 if (lex () != IDENTIFIER
)
621 complain (_("invalid %s declaration"), "%start");
629 /*-----------------------------------------------------------.
630 | read in a %type declaration and record its information for |
631 | get_type_name to access |
632 `-----------------------------------------------------------*/
635 parse_type_decl (void)
639 if (lex () != TYPENAME
)
641 complain ("%s", _("%type declaration has no <typename>"));
646 name
= xstrdup (token_buffer
);
651 int tmp_char
= ungetc (skip_white_space (), finput
);
656 fatal (_("Premature EOF after %s"), token_buffer
);
668 if (symval
->type_name
== NULL
)
669 symval
->type_name
= name
;
670 else if (strcmp (name
, symval
->type_name
) != 0)
671 complain (_("type redeclaration for %s"), symval
->tag
);
676 complain (_("invalid %%type declaration due to item: %s"),
685 /*----------------------------------------------------------------.
686 | Read in a %left, %right or %nonassoc declaration and record its |
688 `----------------------------------------------------------------*/
691 parse_assoc_decl (associativity assoc
)
696 lastprec
++; /* Assign a new precedence level, never 0. */
701 int tmp_char
= ungetc (skip_white_space (), finput
);
706 fatal (_("Premature EOF after %s"), token_buffer
);
713 name
= xstrdup (token_buffer
);
720 if (symval
->prec
!= 0)
721 complain (_("redefining precedence of %s"), symval
->tag
);
722 symval
->prec
= lastprec
;
723 symval
->assoc
= assoc
;
724 if (symval
->class == nterm_sym
)
725 complain (_("symbol %s redefined"), symval
->tag
);
726 symval
->class = token_sym
;
728 { /* record the type, if one is specified */
729 if (symval
->type_name
== NULL
)
730 symval
->type_name
= name
;
731 else if (strcmp (name
, symval
->type_name
) != 0)
732 complain (_("type redeclaration for %s"), symval
->tag
);
737 if (prev
== IDENTIFIER
)
739 symval
->user_token_number
= numval
;
745 ("invalid text (%s) - number should be after identifier"),
755 complain (_("unexpected item: %s"), token_buffer
);
766 /*--------------------------------------------------------------.
767 | Copy the union declaration into ATTRS_OBSTACK (and fdefines), |
768 | where it is made into the definition of YYSTYPE, the type of |
769 | elements of the parser value stack. |
770 `--------------------------------------------------------------*/
773 parse_union_decl (void)
779 complain (_("multiple %s declarations"), "%union");
784 obstack_fgrow2 (&attrs_obstack
, "\n#line %d %s\n",
785 lineno
, quotearg_style (c_quoting_style
, infile
));
787 obstack_1grow (&attrs_obstack
, '\n');
789 obstack_grow_literal_string (&attrs_obstack
, "typedef union");
791 obstack_grow_literal_string (&defines_obstack
, "typedef union");
797 obstack_1grow (&attrs_obstack
, c
);
799 obstack_1grow (&defines_obstack
, c
);
808 copy_comment2 (finput
, 0, &defines_obstack
, &attrs_obstack
);
817 complain (_("unmatched %s"), "`}'");
821 obstack_grow_literal_string (&attrs_obstack
, " YYSTYPE;\n");
823 obstack_grow_literal_string (&defines_obstack
, " YYSTYPE;\n");
824 /* JF don't choke on trailing semi */
825 c
= skip_white_space ();
837 /*-------------------------------------------------------.
838 | Parse the declaration %expect N which says to expect N |
839 | shift-reduce conflicts. |
840 `-------------------------------------------------------*/
843 parse_expect_decl (void)
845 int c
= skip_white_space ();
849 complain (_("argument of %%expect is not an integer"));
851 expected_conflicts
= read_signed_integer (finput
);
855 /*-------------------------------------------------------------------.
856 | Parse what comes after %thong. the full syntax is |
858 | %thong <type> token number literal |
860 | the <type> or number may be omitted. The number specifies the |
861 | user_token_number. |
863 | Two symbols are entered in the table, one for the token symbol and |
864 | one for the literal. Both are given the <type>, if any, from the |
865 | declaration. The ->user_token_number of the first is SALIAS and |
866 | the ->user_token_number of the second is set to the number, if |
867 | any, from the declaration. The two symbols are linked via |
868 | pointers in their ->alias fields. |
870 | During OUTPUT_DEFINES_TABLE, the symbol is reported thereafter, |
871 | only the literal string is retained it is the literal string that |
872 | is output to yytname |
873 `-------------------------------------------------------------------*/
876 parse_thong_decl (void)
879 struct bucket
*symbol
;
884 token
= lex (); /* fetch typename or first token */
885 if (token
== TYPENAME
)
887 typename
= xstrdup (token_buffer
);
888 value_components_used
= 1;
889 token
= lex (); /* fetch first token */
892 /* process first token */
894 if (token
!= IDENTIFIER
)
896 complain (_("unrecognized item %s, expected an identifier"),
901 symval
->class = token_sym
;
902 symval
->type_name
= typename
;
903 symval
->user_token_number
= SALIAS
;
906 token
= lex (); /* get number or literal string */
911 token
= lex (); /* okay, did number, now get literal */
916 /* process literal string token */
918 if (token
!= IDENTIFIER
|| *symval
->tag
!= '\"')
920 complain (_("expected string constant instead of %s"), token_buffer
);
924 symval
->class = token_sym
;
925 symval
->type_name
= typename
;
926 symval
->user_token_number
= usrtoknum
;
928 symval
->alias
= symbol
;
929 symbol
->alias
= symval
;
931 /* symbol and symval combined are only one symbol. */
936 /*----------------------------------------------------------------.
937 | Read from finput until `%%' is seen. Discard the `%%'. Handle |
938 | any `%' declarations, and copy the contents of any `%{ ... %}' |
939 | groups to ATTRS_OBSTACK. |
940 `----------------------------------------------------------------*/
943 read_declarations (void)
950 c
= skip_white_space ();
954 tok
= parse_percent_token ();
961 case PERCENT_LEFT_CURLY
:
966 parse_token_decl (token_sym
, nterm_sym
);
970 parse_token_decl (nterm_sym
, token_sym
);
986 parse_expect_decl ();
993 parse_assoc_decl (left_assoc
);
997 parse_assoc_decl (right_assoc
);
1001 parse_assoc_decl (non_assoc
);
1004 case SEMANTIC_PARSER
:
1005 if (!semantic_parser
)
1006 fguard
= xfopen (guardfile
, "w");
1007 semantic_parser
= 1;
1018 complain (_("unrecognized: %s"), token_buffer
);
1023 fatal (_("no input grammar"));
1028 complain (_("unknown character: %s"), quote (buf
));
1034 /*-------------------------------------------------------------------.
1035 | Assuming that a `{' has just been seen, copy everything up to the |
1036 | matching `}' into the actions file. STACK_OFFSET is the number of |
1037 | values in the current rule so far, which says where to find `$0' |
1038 | with respect to the top of the stack. |
1039 `-------------------------------------------------------------------*/
1042 copy_action (symbol_list
*rule
, int stack_offset
)
1048 /* offset is always 0 if parser has already popped the stack pointer */
1049 if (semantic_parser
)
1052 sprintf (buf
, "\ncase %d:\n", nrules
);
1053 obstack_grow (&action_obstack
, buf
, strlen (buf
));
1057 sprintf (buf
, "#line %d %s\n",
1058 lineno
, quotearg_style (c_quoting_style
, infile
));
1059 obstack_grow (&action_obstack
, buf
, strlen (buf
));
1061 obstack_1grow (&action_obstack
, '{');
1073 obstack_1grow (&action_obstack
, c
);
1078 obstack_1grow (&action_obstack
, c
);
1084 copy_string (finput
, 0, &action_obstack
, c
);
1088 copy_comment (finput
, 0, &action_obstack
);
1092 copy_dollar (finput
, 0, &action_obstack
,
1093 rule
, stack_offset
);
1097 copy_at (finput
, 0, &action_obstack
,
1102 fatal (_("unmatched %s"), "`{'");
1105 obstack_1grow (&action_obstack
, c
);
1111 /* above loop exits when c is '}' */
1115 obstack_1grow (&action_obstack
, c
);
1120 obstack_grow_literal_string (&action_obstack
,
1124 /*-------------------------------------------------------------------.
1125 | After `%guard' is seen in the input file, copy the actual guard |
1126 | into the guards file. If the guard is followed by an action, copy |
1127 | that into the actions file. STACK_OFFSET is the number of values |
1128 | in the current rule so far, which says where to find `$0' with |
1129 | respect to the top of the stack, for the simple parser in which |
1130 | the stack is not popped until after the guard is run. |
1131 `-------------------------------------------------------------------*/
1134 copy_guard (symbol_list
*rule
, int stack_offset
)
1140 /* offset is always 0 if parser has already popped the stack pointer */
1141 if (semantic_parser
)
1144 fprintf (fguard
, "\ncase %d:\n", nrules
);
1146 fprintf (fguard
, "#line %d %s\n",
1147 lineno
, quotearg_style (c_quoting_style
, infile
));
1153 while (brace_flag
? (count
> 0) : (c
!= ';'))
1174 complain (_("unmatched %s"), "`}'");
1175 c
= getc (finput
); /* skip it */
1181 copy_string (finput
, fguard
, 0, c
);
1185 copy_comment (finput
, fguard
, 0);
1189 copy_dollar (finput
, fguard
, 0, rule
, stack_offset
);
1193 copy_at (finput
, fguard
, 0, stack_offset
);
1197 fatal ("%s", _("unterminated %guard clause"));
1203 if (c
!= '}' || count
!= 0)
1207 c
= skip_white_space ();
1209 fprintf (fguard
, ";\n break;}");
1211 copy_action (rule
, stack_offset
);
1214 c
= getc (finput
); /* why not skip_white_space -wjh */
1216 copy_action (rule
, stack_offset
);
1224 record_rule_line (void)
1226 /* Record each rule's source line number in rline table. */
1228 if (nrules
>= rline_allocated
)
1230 rline_allocated
= nrules
* 2;
1231 rline
= XREALLOC (rline
, short, rline_allocated
);
1233 rline
[nrules
] = lineno
;
1237 /*-------------------------------------------------------------------.
1238 | Generate a dummy symbol, a nonterminal, whose name cannot conflict |
1239 | with the user's names. |
1240 `-------------------------------------------------------------------*/
1247 sprintf (token_buffer
, "@%d", ++gensym_count
);
1248 sym
= getsym (token_buffer
);
1249 sym
->class = nterm_sym
;
1250 sym
->value
= nvars
++;
1255 /*------------------------------------------------------------------.
1256 | read in a %type declaration and record its information for |
1257 | get_type_name to access. This is unused. It is only called from |
1258 | the #if 0 part of readgram |
1259 `------------------------------------------------------------------*/
1272 complain (_("invalid %s declaration"), "%type");
1276 name
= xstrdup (token_buffer
);
1291 if (symval
->type_name
== NULL
)
1292 symval
->type_name
= name
;
1293 else if (strcmp (name
, symval
->type_name
) != 0)
1294 complain (_("type redeclaration for %s"), symval
->tag
);
1306 /*------------------------------------------------------------------.
1307 | Parse the input grammar into a one symbol_list structure. Each |
1308 | rule is represented by a sequence of symbols: the left hand side |
1309 | followed by the contents of the right hand side, followed by a |
1310 | null pointer instead of a symbol to terminate the rule. The next |
1311 | symbol is the lhs of the following rule. |
1313 | All guards and actions are copied out to the appropriate files, |
1314 | labelled by the rule number they apply to. |
1315 `------------------------------------------------------------------*/
1326 /* Points to first symbol_list of current rule. its symbol is the
1329 /* Points to the symbol_list preceding crule. */
1330 symbol_list
*crule1
;
1336 while (t
!= TWO_PERCENTS
&& t
!= ENDFILE
)
1338 if (t
== IDENTIFIER
|| t
== BAR
)
1340 int action_flag
= 0;
1341 /* Number of symbols in rhs of this rule so far */
1343 int xactions
= 0; /* JF for error checking */
1344 bucket
*first_rhs
= 0;
1346 if (t
== IDENTIFIER
)
1359 complain (_("ill-formed rule: initial symbol not followed by colon"));
1364 if (nrules
== 0 && t
== BAR
)
1366 complain (_("grammar starts with vertical bar"));
1367 lhs
= symval
; /* BOGUS: use a random symval */
1369 /* start a new rule and record its lhs. */
1374 record_rule_line ();
1376 p
= XCALLOC (symbol_list
, 1);
1388 /* mark the rule's lhs as a nonterminal if not already so. */
1390 if (lhs
->class == unknown_sym
)
1392 lhs
->class = nterm_sym
;
1396 else if (lhs
->class == token_sym
)
1397 complain (_("rule given for %s, which is a token"), lhs
->tag
);
1399 /* read the rhs of the rule. */
1407 crule
->ruleprec
= symval
;
1411 if (!(t
== IDENTIFIER
|| t
== LEFT_CURLY
))
1414 /* If next token is an identifier, see if a colon follows it.
1415 If one does, exit this rule now. */
1416 if (t
== IDENTIFIER
)
1428 if (!first_rhs
) /* JF */
1430 /* Not followed by colon =>
1431 process as part of this rule's rhs. */
1434 /* If we just passed an action, that action was in the middle
1435 of a rule, so make a dummy rule to reduce it to a
1441 /* Since the action was written out with this rule's
1442 number, we must give the new rule this number by
1443 inserting the new rule before it. */
1445 /* Make a dummy nonterminal, a gensym. */
1448 /* Make a new rule, whose body is empty,
1449 before the current one, so that the action
1450 just read can belong to it. */
1453 record_rule_line ();
1454 p
= XCALLOC (symbol_list
, 1);
1460 crule1
= XCALLOC (symbol_list
, 1);
1462 crule1
->next
= crule
;
1464 /* Insert the dummy generated by that rule into this
1467 p
= XCALLOC (symbol_list
, 1);
1475 if (t
== IDENTIFIER
)
1478 p
= XCALLOC (symbol_list
, 1);
1483 else /* handle an action. */
1485 copy_action (crule
, rulelength
);
1487 xactions
++; /* JF */
1490 } /* end of read rhs of rule */
1492 /* Put an empty link in the list to mark the end of this rule */
1493 p
= XCALLOC (symbol_list
, 1);
1499 complain (_("two @prec's in a row"));
1501 crule
->ruleprec
= symval
;
1506 if (!semantic_parser
)
1507 complain (_("%%guard present but %%semantic_parser not specified"));
1509 copy_guard (crule
, rulelength
);
1512 else if (t
== LEFT_CURLY
)
1514 /* This case never occurs -wjh */
1516 complain (_("two actions at end of one rule"));
1517 copy_action (crule
, rulelength
);
1519 xactions
++; /* -wjh */
1522 /* If $$ is being set in default way, report if any type
1525 && first_rhs
&& lhs
->type_name
!= first_rhs
->type_name
)
1527 if (lhs
->type_name
== 0
1528 || first_rhs
->type_name
== 0
1529 || strcmp (lhs
->type_name
, first_rhs
->type_name
))
1530 complain (_("type clash (`%s' `%s') on default action"),
1531 lhs
->type_name
? lhs
->type_name
: "",
1532 first_rhs
->type_name
? first_rhs
->type_name
: "");
1534 /* Warn if there is no default for $$ but we need one. */
1535 else if (!xactions
&& !first_rhs
&& lhs
->type_name
!= 0)
1536 complain (_("empty rule for typed nonterminal, and no action"));
1541 /* these things can appear as alternatives to rules. */
1543 a) none of the documentation allows them
1544 b) most of them scan forward until finding a next %
1545 thus they may swallow lots of intervening rules
1547 else if (t
== TOKEN
)
1549 parse_token_decl (token_sym
, nterm_sym
);
1552 else if (t
== NTERM
)
1554 parse_token_decl (nterm_sym
, token_sym
);
1561 else if (t
== UNION
)
1563 parse_union_decl ();
1566 else if (t
== EXPECT
)
1568 parse_expect_decl ();
1571 else if (t
== START
)
1573 parse_start_decl ();
1580 complain (_("invalid input: %s"), token_buffer
);
1585 /* grammar has been read. Do some checking */
1587 if (nsyms
> MAXSHORT
)
1588 fatal (_("too many symbols (tokens plus nonterminals); maximum %d"),
1591 fatal (_("no rules in the input grammar"));
1593 /* JF put out same default YYSTYPE as YACC does */
1595 && !value_components_used
)
1597 /* We used to use `unsigned long' as YYSTYPE on MSDOS,
1598 but it seems better to be consistent.
1599 Most programs should declare their own type anyway. */
1600 obstack_grow_literal_string (&attrs_obstack
,
1601 "#ifndef YYSTYPE\n#define YYSTYPE int\n#endif\n");
1603 obstack_grow_literal_string (&defines_obstack
, "\
1605 # define YYSTYPE int\n\
1609 /* Report any undefined symbols and consider them nonterminals. */
1611 for (bp
= firstsymbol
; bp
; bp
= bp
->next
)
1612 if (bp
->class == unknown_sym
)
1615 ("symbol %s is used, but is not defined as a token and has no rules"),
1617 bp
->class = nterm_sym
;
1618 bp
->value
= nvars
++;
1621 ntokens
= nsyms
- nvars
;
1624 /*--------------------------------------------------------------.
1625 | For named tokens, but not literal ones, define the name. The |
1626 | value is the user token number. |
1627 `--------------------------------------------------------------*/
1630 output_token_defines (struct obstack
*oout
)
1636 for (bp
= firstsymbol
; bp
; bp
= bp
->next
)
1638 symbol
= bp
->tag
; /* get symbol */
1640 if (bp
->value
>= ntokens
)
1642 if (bp
->user_token_number
== SALIAS
)
1644 if ('\'' == *symbol
)
1645 continue; /* skip literal character */
1647 continue; /* skip error token */
1648 if ('\"' == *symbol
)
1650 /* use literal string only if given a symbol with an alias */
1652 symbol
= bp
->alias
->tag
;
1657 /* Don't #define nonliteral tokens whose names contain periods. */
1659 while ((c
= *cp
++) && c
!= '.');
1663 obstack_fgrow2 (oout
, "#define\t%s\t%d\n",
1665 ((translations
&& !raw_flag
)
1666 ? bp
->user_token_number
: bp
->value
));
1667 if (semantic_parser
)
1668 obstack_fgrow2 (oout
, "#define\tT%s\t%d\n", symbol
, bp
->value
);
1671 obstack_1grow (oout
, '\n');
1675 /*------------------------------------------------------------------.
1676 | Assign symbol numbers, and write definition of token names into |
1677 | FDEFINES. Set up vectors TAGS and SPREC of names and precedences |
1679 `------------------------------------------------------------------*/
1687 int last_user_token_number
;
1688 static char DOLLAR
[] = "$";
1690 /* int lossage = 0; JF set but not used */
1692 tags
= XCALLOC (char *, nsyms
+ 1);
1694 user_toknums
= XCALLOC (short, nsyms
+ 1);
1695 user_toknums
[0] = 0;
1697 sprec
= XCALLOC (short, nsyms
);
1698 sassoc
= XCALLOC (short, nsyms
);
1700 max_user_token_number
= 256;
1701 last_user_token_number
= 256;
1703 for (bp
= firstsymbol
; bp
; bp
= bp
->next
)
1705 if (bp
->class == nterm_sym
)
1707 bp
->value
+= ntokens
;
1711 /* this symbol and its alias are a single token defn.
1712 allocate a tokno, and assign to both check agreement of
1713 ->prec and ->assoc fields and make both the same */
1715 bp
->value
= bp
->alias
->value
= tokno
++;
1717 if (bp
->prec
!= bp
->alias
->prec
)
1719 if (bp
->prec
!= 0 && bp
->alias
->prec
!= 0
1720 && bp
->user_token_number
== SALIAS
)
1721 complain (_("conflicting precedences for %s and %s"),
1722 bp
->tag
, bp
->alias
->tag
);
1724 bp
->alias
->prec
= bp
->prec
;
1726 bp
->prec
= bp
->alias
->prec
;
1729 if (bp
->assoc
!= bp
->alias
->assoc
)
1731 if (bp
->assoc
!= 0 && bp
->alias
->assoc
!= 0
1732 && bp
->user_token_number
== SALIAS
)
1733 complain (_("conflicting assoc values for %s and %s"),
1734 bp
->tag
, bp
->alias
->tag
);
1736 bp
->alias
->assoc
= bp
->assoc
;
1738 bp
->assoc
= bp
->alias
->assoc
;
1741 if (bp
->user_token_number
== SALIAS
)
1742 continue; /* do not do processing below for SALIASs */
1745 else /* bp->class == token_sym */
1747 bp
->value
= tokno
++;
1750 if (bp
->class == token_sym
)
1752 if (translations
&& !(bp
->user_token_number
))
1753 bp
->user_token_number
= ++last_user_token_number
;
1754 if (bp
->user_token_number
> max_user_token_number
)
1755 max_user_token_number
= bp
->user_token_number
;
1758 tags
[bp
->value
] = bp
->tag
;
1759 user_toknums
[bp
->value
] = bp
->user_token_number
;
1760 sprec
[bp
->value
] = bp
->prec
;
1761 sassoc
[bp
->value
] = bp
->assoc
;
1769 token_translations
= XCALLOC (short, max_user_token_number
+ 1);
1771 /* initialize all entries for literal tokens to 2, the internal
1772 token number for $undefined., which represents all invalid
1774 for (j
= 0; j
<= max_user_token_number
; j
++)
1775 token_translations
[j
] = 2;
1777 for (bp
= firstsymbol
; bp
; bp
= bp
->next
)
1779 if (bp
->value
>= ntokens
)
1780 continue; /* non-terminal */
1781 if (bp
->user_token_number
== SALIAS
)
1783 if (token_translations
[bp
->user_token_number
] != 2)
1784 complain (_("tokens %s and %s both assigned number %d"),
1785 tags
[token_translations
[bp
->user_token_number
]],
1786 bp
->tag
, bp
->user_token_number
);
1787 token_translations
[bp
->user_token_number
] = bp
->value
;
1791 error_token_number
= errtoken
->value
;
1793 if (!no_parser_flag
)
1794 output_token_defines (&table_obstack
);
1796 if (startval
->class == unknown_sym
)
1797 fatal (_("the start symbol %s is undefined"), startval
->tag
);
1798 else if (startval
->class == token_sym
)
1799 fatal (_("the start symbol %s is a token"), startval
->tag
);
1801 start_symbol
= startval
->value
;
1805 output_token_defines (&defines_obstack
);
1809 if (spec_name_prefix
)
1810 obstack_fgrow1 (&defines_obstack
, "\nextern YYSTYPE %slval;\n",
1813 obstack_grow_literal_string (&defines_obstack
,
1814 "\nextern YYSTYPE yylval;\n");
1817 if (semantic_parser
)
1818 for (i
= ntokens
; i
< nsyms
; i
++)
1820 /* don't make these for dummy nonterminals made by gensym. */
1821 if (*tags
[i
] != '@')
1822 obstack_fgrow2 (&defines_obstack
,
1823 "#define\tNT%s\t%d\n", tags
[i
], i
);
1826 /* `fdefines' is now a temporary file, so we need to copy its
1827 contents in `done', so we can't close it here. */
1835 /*---------------------------------------------------------------.
1836 | Convert the rules into the representation using RRHS, RLHS and |
1838 `---------------------------------------------------------------*/
1849 ritem
= XCALLOC (short, nitems
+ 1);
1850 rlhs
= XCALLOC (short, nrules
) - 1;
1851 rrhs
= XCALLOC (short, nrules
) - 1;
1852 rprec
= XCALLOC (short, nrules
) - 1;
1853 rprecsym
= XCALLOC (short, nrules
) - 1;
1854 rassoc
= XCALLOC (short, nrules
) - 1;
1862 rlhs
[ruleno
] = p
->sym
->value
;
1863 rrhs
[ruleno
] = itemno
;
1864 ruleprec
= p
->ruleprec
;
1869 ritem
[itemno
++] = p
->sym
->value
;
1870 /* A rule gets by default the precedence and associativity
1871 of the last token in it. */
1872 if (p
->sym
->class == token_sym
)
1874 rprec
[ruleno
] = p
->sym
->prec
;
1875 rassoc
[ruleno
] = p
->sym
->assoc
;
1881 /* If this rule has a %prec,
1882 the specified symbol's precedence replaces the default. */
1885 rprec
[ruleno
] = ruleprec
->prec
;
1886 rassoc
[ruleno
] = ruleprec
->assoc
;
1887 rprecsym
[ruleno
] = ruleprec
->value
;
1890 ritem
[itemno
++] = -ruleno
;
1900 /*-------------------------------------------------------------------.
1901 | Read in the grammar specification and record it in the format |
1902 | described in gram.h. All guards are copied into the FGUARD file |
1903 | and all actions into ACTION_OBSTACK, in each case forming the body |
1904 | of a C function (YYGUARD or YYACTION) which contains a switch |
1905 | statement to decide which guard or action to execute. |
1906 `-------------------------------------------------------------------*/
1912 startval
= NULL
; /* start symbol not specified yet. */
1915 /* initially assume token number translation not needed. */
1918 /* Nowadays translations is always set to 1, since we give `error' a
1919 user-token-number to satisfy the Posix demand for YYERRCODE==256.
1927 rline_allocated
= 10;
1928 rline
= XCALLOC (short, rline_allocated
);
1935 semantic_parser
= 0;
1943 /* Initialize the symbol table. */
1945 /* Construct the error token */
1946 errtoken
= getsym ("error");
1947 errtoken
->class = token_sym
;
1948 errtoken
->user_token_number
= 256; /* Value specified by POSIX. */
1949 /* Construct a token that represents all undefined literal tokens.
1950 It is always token number 2. */
1951 undeftoken
= getsym ("$undefined.");
1952 undeftoken
->class = token_sym
;
1953 undeftoken
->user_token_number
= 2;
1955 /* Read the declaration section. Copy %{ ... %} groups to
1956 TABLE_OBSTACK and FDEFINES file. Also notice any %token, %left,
1957 etc. found there. */
1958 obstack_1grow (&table_obstack
, '\n');
1959 obstack_fgrow3 (&table_obstack
, "\
1960 /* %s, made from %s\n\
1961 by GNU bison %s. */\n\
1963 no_parser_flag
? "Bison-generated parse tables" : "A Bison parser",
1966 obstack_grow_literal_string (&table_obstack
,
1967 "#define YYBISON 1 /* Identify Bison output. */\n\n");
1968 read_declarations ();
1969 /* Start writing the guard and action files, if they are needed. */
1971 /* Read in the grammar, build grammar in list form. Write out
1972 guards and actions. */
1974 /* Now we know whether we need the line-number stack. If we do,
1975 write its type into the .tab.h file. */
1977 reader_output_yylsp (&defines_obstack
);
1978 /* Write closing delimiters for actions and guards. */
1981 obstack_grow_literal_string (&table_obstack
, "#define YYLSP_NEEDED 1\n\n");
1982 /* Assign the symbols their symbol numbers. Write #defines for the
1983 token symbols into FDEFINES if requested. */
1985 /* Convert the grammar into the format described in gram.h. */
1987 /* Free the symbol table data structure since symbols are now all
1988 referred to by symbol number. */
1993 /*------------------------------------------------------------------.
1994 | Define YYLTYPE. Cannot be in the skeleton since we might have to |
1995 | output it in the headers if --defines is used. |
1996 `------------------------------------------------------------------*/
1999 reader_output_yylsp (struct obstack
*oout
)
2002 obstack_grow_literal_string (oout
, "\
2005 typedef struct yyltype\n\
2008 int first_column;\n\
2014 # define YYLTYPE yyltype\n\