FYI: M4 handling of $$ etc.

[Akim Demaille]

This patch will help freeing the skeletons from the original names.
For instance, the C++ parsers had to use dirty tricks to handle yylsp
as the C parser does :(

I believe Robert A. will be able to clean the C++ parser now.

Index: ChangeLog
from  Akim Demaille  <address@hidden>

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

Index: TODO
===================================================================
RCS file: /cvsroot/bison/bison/TODO,v
retrieving revision 1.52
diff -u -u -r1.52 TODO
--- TODO 2 May 2002 09:25:54 -0000 1.52
+++ TODO 2 May 2002 14:30:00 -0000
@@ -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_
Index: data/bison.c++
===================================================================
RCS file: /cvsroot/bison/bison/data/bison.c++,v
retrieving revision 1.24
diff -u -u -r1.24 bison.c++
--- data/bison.c++ 24 Apr 2002 16:22:56 -0000 1.24
+++ data/bison.c++ 2 May 2002 14:30:00 -0000
@@ -20,6 +20,36 @@
        [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.
Index: data/bison.simple
===================================================================
RCS file: /cvsroot/bison/bison/data/bison.simple,v
retrieving revision 1.16
diff -u -u -r1.16 bison.simple
--- data/bison.simple 27 Apr 2002 01:20:51 -0000 1.16
+++ data/bison.simple 2 May 2002 14:30:00 -0000
@@ -20,6 +20,36 @@
        [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],
Index: src/reader.c
===================================================================
RCS file: /cvsroot/bison/bison/src/reader.c,v
retrieving revision 1.170
diff -u -u -r1.170 reader.c
--- src/reader.c 25 Apr 2002 14:36:38 -0000 1.170
+++ src/reader.c 2 May 2002 14:30:00 -0000
@@ -492,23 +492,22 @@
 }
 
 
-/*-----------------------------------------------------------------.
-| 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 @@
 
       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 @@
 }
 
 
-/*-------------------------------------------------------------------.
-| 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 @@
 
   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 @@
       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 @@
     }
 }
 
-/*-------------------------------------------------------------------.
-| 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 @@
            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 @@
 
 
 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);
 }