* 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.

diff --git a/ChangeLog b/ChangeLog
index 88ff17b..07e43df 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,17 @@
 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.
        (AM_INIT_AUTOMAKE): Short invocation.
 

diff --git a/TODO b/TODO
index a6b677f..9f10420 100644 (file)
--- a/TODO
+++ b/TODO
@@ -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_

diff --git a/data/bison.c++ b/data/bison.c++
index 463e136..41f3dec 100644 (file)
--- a/data/bison.c++
+++ b/data/bison.c++
@@ -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.

diff --git a/data/bison.simple b/data/bison.simple
index 803d1a4..14615bf 100644 (file)
--- a/data/bison.simple
+++ b/data/bison.simple
@@ -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],

diff --git a/src/reader.c b/src/reader.c
index 3375fa2..0e1fc2b 100644 (file)
--- a/src/reader.c
+++ b/src/reader.c
@@ -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)
     }
 }
 \f
-/*-------------------------------------------------------------------.
-| 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);
 }