Future/bison
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/bison.git synced 2026-03-10 04:43:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

* src/reader.c (copy_at, copy_dollarm parse_braces, parse_action)

Browse Source 
(parse_guard): Rename the formal argument `stack_offset' as
`rule_length', which is more readable.
Adjust callers.
(copy_at, copy_dollar): Instead of outputting the hard coded
values of $$, $n and so forth, output invocation to b4_lhs_value,
b4_lhs_location, b4_rhs_value, and b4_rhs_location.
* data/bison.simple, data/bison.c++ (b4_lhs_value)
(b4_lhs_location, b4_rhs_value, and b4_rhs_location: New.
This commit is contained in:
Akim Demaille
2002-05-02 14:33:48 +00:00
parent 6cbfbcc58c
commit 82b6cb3fb2
5 changed files with 121 additions and 62 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
ChangeLog
View File

@@ -1,3 +1,15 @@
2002-05-02 Akim Demaille <akim@epita.fr>
* src/reader.c (copy_at, copy_dollarm parse_braces, parse_action)
(parse_guard): Rename the formal argument `stack_offset' as
`rule_length', which is more readable.
Adjust callers.
(copy_at, copy_dollar): Instead of outputting the hard coded
values of $$, $n and so forth, output invocation to b4_lhs_value,
b4_lhs_location, b4_rhs_value, and b4_rhs_location.
* data/bison.simple, data/bison.c++ (b4_lhs_value)
(b4_lhs_location, b4_rhs_value, and b4_rhs_location: New.
2002-05-02 Akim Demaille <akim@epita.fr>
* configure.in (AC_INIT): Bump to 1.49b.

1
TODO
View File

@@ -1,6 +1,5 @@
-*- outline -*-
* Several %unions
I think this is a pleasant (but useless currently) feature, but in the
future, I want a means to %include other bits of grammars, and _then_

30
data/bison.c++
View File

@@ -20,6 +20,36 @@ m4_define([b4_uint_type],
[m4_fatal([no unsigned int type for $1])])])
# b4_lhs_value([TYPE])
# --------------------
# Expansion of $<TYPE>$.
m4_define([b4_lhs_value],
[yyval[]m4_ifval([$1], [.$1])])
# b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
# --------------------------------------
# Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
# symbols on RHS.
m4_define([b4_rhs_value],
[yyvsp@<:@m4_eval([$2 - $1])@:>@m4_ifval([$3], [.$3])])
# b4_lhs_location()
# -----------------
# Expansion of @$.
m4_define([b4_lhs_location],
[yyloc])
# b4_rhs_location(RULE-LENGTH, NUM)
# ---------------------------------
# Expansion of @NUM, where the current rule has RULE-LENGTH symbols
# on RHS.
m4_define([b4_rhs_location],
[yylsp@<:@m4_eval([$2 - $1])@:>@])
# b4_token_defines(TOKEN-NAME, TOKEN-NUMBER)
# ------------------------------------------
# Output the definition of this token as #define.

30
data/bison.simple
View File

@@ -20,6 +20,36 @@ m4_define([b4_uint_type],
[m4_fatal([no unsigned int type for $1])])])
# b4_lhs_value([TYPE])
# --------------------
# Expansion of $<TYPE>$.
m4_define([b4_lhs_value],
[yyval[]m4_ifval([$1], [.$1])])
# b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
# --------------------------------------
# Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
# symbols on RHS.
m4_define([b4_rhs_value],
[yyvsp@<:@m4_eval([$2 - $1])@:>@m4_ifval([$3], [.$3])])
# b4_lhs_location()
# -----------------
# Expansion of @$.
m4_define([b4_lhs_location],
[yyloc])
# b4_rhs_location(RULE-LENGTH, NUM)
# ---------------------------------
# Expansion of @NUM, where the current rule has RULE-LENGTH symbols
# on RHS.
m4_define([b4_rhs_location],
[yylsp@<:@m4_eval([$2 - $1])@:>@])
m4_define_default([b4_input_suffix], [.y])
m4_define_default([b4_output_parser_suffix],

110
src/reader.c
View File

@@ -492,23 +492,22 @@ copy_comment (FILE *fin, struct obstack *oout)
}
/*-----------------------------------------------------------------.
| FIN is pointing to a location (i.e., a `@'). Output to OOUT a |
| reference to this location. STACK_OFFSET is the number of values |
| in the current rule so far, which says where to find `$0' with |
| respect to the top of the stack. |
`-----------------------------------------------------------------*/
/*-------------------------------------------------------------------.
| FIN is pointing to a location (i.e., a `@'). Output to OOUT a |
| reference to this location. RULE_LENGTH is the number of values in |
| the current rule so far, which says where to find `$0' with |
| respect to the top of the stack. |
`-------------------------------------------------------------------*/
static inline void
copy_at (FILE *fin, struct obstack *oout, int stack_offset)
copy_at (FILE *fin, struct obstack *oout, int rule_length)
{
int c;
int c = getc (fin);
locations_flag = 1;
c = getc (fin);
if (c == '$')
{
obstack_sgrow (oout, "yyloc");
locations_flag = 1;
obstack_sgrow (oout, "]b4_lhs_location[");
}
else if (isdigit (c) || c == '-')
{
@@ -516,16 +515,11 @@ copy_at (FILE *fin, struct obstack *oout, int stack_offset)
ungetc (c, fin);
n = read_signed_integer (fin);
if (n > stack_offset)
if (n > rule_length)
complain (_("invalid value: %s%d"), "@", n);
else
{
/* Offset is always 0 if parser has already popped the stack
pointer. */
obstack_fgrow1 (oout, "yylsp[%d]",
n - (semantic_parser ? 0 : stack_offset));
locations_flag = 1;
}
obstack_fgrow2 (oout, "]b4_rhs_location([%d], [%d])[",
rule_length, n);
}
else
{
@@ -536,19 +530,19 @@ copy_at (FILE *fin, struct obstack *oout, int stack_offset)
}
/*-------------------------------------------------------------------.
| FIN is pointing to a wannabee semantic value (i.e., a `$'). |
| |
| Possible inputs: $[<TYPENAME>]($|integer) |
| |
| Output to OOUT a reference to this semantic value. STACK_OFFSET is |
| the number of values in the current rule so far, which says where |
| to find `$0' with respect to the top of the stack. |
`-------------------------------------------------------------------*/
/*------------------------------------------------------------------.
| FIN is pointing to a wannabee semantic value (i.e., a `$'). |
| |
| Possible inputs: $[<TYPENAME>]($|integer) |
| |
| Output to OOUT a reference to this semantic value. RULE_LENGTH is |
| the number of values in the current rule so far, which says where |
| to find `$0' with respect to the top of the stack. |
`------------------------------------------------------------------*/
static inline void
copy_dollar (FILE *fin, struct obstack *oout,
symbol_list *rule, int stack_offset)
symbol_list *rule, int rule_length)
{
int c = getc (fin);
const char *type_name = NULL;
@@ -564,15 +558,15 @@ copy_dollar (FILE *fin, struct obstack *oout,
if (c == '$')
{
obstack_sgrow (oout, "yyval");
if (!type_name)
type_name = get_type_name (0, rule);
if (type_name)
obstack_fgrow1 (oout, ".%s", type_name);
if (!type_name && typed)
complain (_("$$ of `%s' has no declared type"),
rule->sym->tag);
if (!type_name)
type_name = "";
obstack_fgrow1 (oout,
"]b4_lhs_value([%s])[", type_name);
}
else if (isdigit (c) || c == '-')
{
@@ -580,23 +574,19 @@ copy_dollar (FILE *fin, struct obstack *oout,
ungetc (c, fin);
n = read_signed_integer (fin);
if (n > stack_offset)
if (n > rule_length)
complain (_("invalid value: %s%d"), "$", n);
else
{
if (!type_name && n > 0)
type_name = get_type_name (n, rule);
/* Offset is always 0 if parser has already popped the stack
pointer. */
obstack_fgrow1 (oout, "yyvsp[%d]",
n - (semantic_parser ? 0 : stack_offset));
if (type_name)
obstack_fgrow1 (oout, ".%s", type_name);
if (!type_name && typed)
complain (_("$%d of `%s' has no declared type"),
n, rule->sym->tag);
if (!type_name)
type_name = "";
obstack_fgrow3 (oout, "]b4_rhs_value([%d], [%d], [%s])[",
rule_length, n, type_name);
}
}
else
@@ -1277,19 +1267,19 @@ read_declarations (void)
}
}
/*-------------------------------------------------------------------.
| Assuming that a `{' has just been seen, copy everything up to the |
| matching `}' into the actions file. STACK_OFFSET is the number of |
| values in the current rule so far, which says where to find `$0' |
| with respect to the top of the stack. |
| |
| This routine is used both for actions and guards. Only |
| ACTION_OBSTACK is used, but this is fine, since we use only |
| pointers to relevant portions inside this obstack. |
`-------------------------------------------------------------------*/
/*------------------------------------------------------------------.
| Assuming that a `{' has just been seen, copy everything up to the |
| matching `}' into the actions file. RULE_LENGTH is the number of |
| values in the current rule so far, which says where to find `$0' |
| with respect to the top of the stack. |
| |
| This routine is used both for actions and guards. Only |
| ACTION_OBSTACK is used, but this is fine, since we use only |
| pointers to relevant portions inside this obstack. |
`------------------------------------------------------------------*/
static void
parse_braces (symbol_list *rule, int stack_offset)
parse_braces (symbol_list *rule, int rule_length)
{
int c;
int count;
@@ -1320,13 +1310,11 @@ parse_braces (symbol_list *rule, int stack_offset)
break;
case '$':
copy_dollar (finput, &action_obstack,
rule, stack_offset);
copy_dollar (finput, &action_obstack, rule, rule_length);
break;
case '@':
copy_at (finput, &action_obstack,
stack_offset);
copy_at (finput, &action_obstack, rule_length);
break;
case EOF:
@@ -1346,22 +1334,22 @@ parse_braces (symbol_list *rule, int stack_offset)
static void
parse_action (symbol_list *rule, int stack_offset)
parse_action (symbol_list *rule, int rule_length)
{
rule->action_line = lineno;
parse_braces (rule, stack_offset);
parse_braces (rule, rule_length);
rule->action = obstack_finish (&action_obstack);
}
static void
parse_guard (symbol_list *rule, int stack_offset)
parse_guard (symbol_list *rule, int rule_length)
{
token_t t = lex ();
if (t != tok_left_curly)
complain (_("invalid %s declaration"), "%guard");
rule->guard_line = lineno;
parse_braces (rule, stack_offset);
parse_braces (rule, rule_length);
rule->guard = obstack_finish (&action_obstack);
}