Encapsulate code properties and related functionality for the various

destructors, printers, and actions into a code_props structure and
interface.
* src/location.h (EMPTY_LOCATION_INIT): Define so that it's easier to
consistently initialize const structs that have an empty location field.
* src/location.c (empty_location): Initialize with EMPTY_LOCATION_INIT
to ensure consistency.
* src/output.c (symbol_destructors_output, symbol_printers_output):
Replace with...
(symbol_code_props_output): ... this to eliminate duplicate code.
(output_skeleton): Update to use symbol_code_props_output.
* src/parse-gram.y (prologue_declaration, braceless, epilogue.opt):
Update all uses of translate_* functions to use the new code_props
interface and to use gram_scanner_last_string_free and
code_scanner_last_string_free where possible.
(grammar_declaration): symbol_list_destructor_set and
symbol_list_printer_set now perform the translation, so don't do it
here.  Use gram_scanner_last_string_free where possible.
* src/reader.c: Update to use code_props interface for destructors and
rule actions.
* src/scan-code.h (code_props): New structure.
(code_props_none_init, CODE_PROPS_NONE_INIT, code_props_none): New
function, macro, and const global variable for initializing a
code_props with no code.
(code_props_plain_init, code_props_symbol_action_init,
code_props_rule_action_init, code_props_translate_code,
code_props_code_get, code_props_location_get,
code_props_is_value_used): The rest of the new code_props interface.
(translate_rule_action, translate_symbol_action, translate_code):
Remove as these are now just special cases within
code_props_translate_code, which is switched on the code_props kind.
(code_scanner_last_string_free): New function similar to
gram_scanner_last_string_free.
* src/scan-code.l: Implement the new interface.
(last_string): New static global similar to the one in scan-gram.l.
(SC_SYMBOL_ACTION): For $$, set the is_value_used member of the
code_props since Bison will one day use this information for
destructors and printers.
(<*><<EOF>>): Use STRING_FINISH so that last_string is set.
(handle_action_dollar): Update to use the code_props interface of rule
actions.  Use symbol_list_n_get and set is_value_used directly since
symbol_list_n_used_set is removed.
* src/symlist.h, src/symlist.c (symbol_list): Replace action,
action_location, and used members with a code_props member, and update
all uses.
(symbol_list_n_used_set): Remove since it would need to break the
encapsulation of code_props.
(symbol_list_destructor_set, symbol_list_printer_set): Perform code
translation here rather than depending on the caller to do so.
* src/symtab.h (symbol, semantic_type): Remove destructor_location and
printer_location members and change the type of the destructor and
printer members to code_props.
(symbol_destructor_location_get, symbol_printer_location_get): Remove
unneeded.
(symbol_destructor_set, symbol_destructor_get, symbol_printer_set,
symbol_printer_get, semantic_type_destructor_set,
semantic_type_printer_set, default_tagged_destructor_set,
default_tagless_destructor_set, default_tagged_printer_set,
default_tagless_printer_set): Use code_props in arguments and return
types in place of const char * and location.
* src/symtab.c: Update implementation for interface and struct changes.
(default_tagged_destructor_location,
default_tagless_destructor_location, default_tagged_printer_location,
default_tagless_printer_location): Remove since we...
(default_tagged_destructor, default_tagless_destructor,
default_tagged_printer, default_tagless_printer): ... change the type
of these to code_props.
(SYMBOL_CODE_PRINT): New similar to SYMBOL_ATTR_PRINT but for
code_props members.
(symbol_print): Use SYMBOL_CODE_PRINT.

* src/scan-gram.h (gram_last_string): Remove declaration.
* src/scan-gram.l (last_string): Declare it static.

src/scan-code.h

@@ -1,4 +1,4 @@
-/* Bison Action Scanner
+/* Bison Code Data Structure and Scanner.
 
    Copyright (C) 2006 Free Software Foundation, Inc.
 
@@ -24,24 +24,210 @@
 # define SCAN_CODE_H_
 
 # include "location.h"
-# include "symlist.h"
 
-/* Keeps track of the maximum number of semantic values to the left of
-   a handle (those referenced by $0, $-1, etc.) are required by the
-   semantic actions of this grammar. */
+struct symbol_list;
+
+/**
+ * \brief
+ *   Keeps track of the maximum number of semantic values to the left of a
+ *   handle (those referenced by \c $0, \c $-1, etc.) that are required by the
+ *   semantic actions of this grammar.
+ */
 extern int max_left_semantic_context;
 
+/**
+ * \brief
+ *   A code passage captured from the grammar file and possibly translated,
+ *   and/or properties associated with such a code passage.
+ * \note
+ *   - Don't break encapsulation by accessing the fields directly.  Use the
+ *     provided interface functions.
+ */
+typedef struct code_props {
+  /**
+   * \brief
+   *   What kind of \c code_props this is.
+   * \sa
+   *   - \c code_props_none_init
+   *   - \c code_props_plain_init
+   *   - \c code_props_symbol_action_init
+   *   - \c code_props_rule_action_init
+   */
+  enum {
+    CODE_PROPS_NONE, CODE_PROPS_PLAIN,
+    CODE_PROPS_SYMBOL_ACTION, CODE_PROPS_RULE_ACTION
+  } kind;
+
+  /**
+   * \brief
+   *   The code passage contained within this \c code_props.
+   * \invariant
+   *   - <tt>code_props::code = NULL</tt> iff
+   *     <tt>code_props::kind = CODE_PROPS_NONE</tt>.
+   */
+  char const *code;
+  /**
+   * \brief
+   *   The grammar file location of \c code_props::code.
+   * \invariant
+   *   - \c code_props::location is undefined iff
+   *     <tt>code_props::code = NULL</tt>.
+   */
+  location location;
+  /**
+   * \brief
+   *   The value returned by \c code_props_is_value_used for this
+   *   \c code_props.
+   */
+  bool is_value_used;
+
+  /**
+   * \brief
+   *   The \c symbol_list node associated with this code passage.
+   * \invariant
+   *   - <tt>code_props::rule != NULL</tt> iff \c code_props::kind is
+   *     \c CODE_PROPS_RULE_ACTION.
+   */
+  struct symbol_list *rule;
+} code_props;
+
+/**
+ * \pre
+ *   - <tt>self != NULL</tt>.
+ * \post
+ *   - \c self has been overwritten to contain no code.  (However, \c self may
+ *     still be conceptually associated with some passage of code contained
+ *     elsewhere.  Thus, a call on <tt>code_props_is_value_used (*self)</tt>,
+ *     for example, is still reasonable.)
+ */
+void code_props_none_init (code_props *self);
+
+/**
+ * \brief A \c code_props initializer equivalent to \c code_props_none_init.
+ */
+#define CODE_PROPS_NONE_INIT \
+  {CODE_PROPS_NONE, NULL, EMPTY_LOCATION_INIT, false, NULL}
+
+/**
+ * \brief
+ *   A \c code_props initialized by \c CODE_PROPS_NONE_INIT with no further
+ *   modification.
+ */
+extern code_props const code_props_none;
+
+/**
+ * \pre
+ *   - <tt>self != NULL</tt>.
+ *   - <tt>code != NULL</tt>.
+ *   - \c code is an untranslated code passage containing no Bison escapes.
+ *   - \c code was extracted from the grammar file at \c code_loc.
+ * \post
+ *   - \c self has been overwritten to represent the specified plain code
+ *     passage.
+ *   - \c self does not claim responsibility for the memory of \c code.
+ */
+void code_props_plain_init (code_props *self, char const *code,
+                            location code_loc);
+
+/**
+ * \pre
+ *   - <tt>self != NULL</tt>.
+ *   - <tt>code != NULL</tt>.
+ *   - \c code is an untranslated code passage.  The only Bison escapes it
+ *     might contain are \c $$ and \c \@$, referring to a single symbol.
+ *   - \c code was extracted from the grammar file at \c code_loc.
+ * \post
+ *   - \c self has been overwritten to represent the specified symbol action.
+ *   - \c self does not claim responsibility for the memory of \c code.
+ */
+void code_props_symbol_action_init (code_props *self, char const *code,
+                                    location code_loc);
+
+/**
+ * \pre
+ *   - <tt>self != NULL</tt>.
+ *   - <tt>code != NULL</tt>.
+ *   - <tt>rule != NULL</tt>.
+ *   - \c code is the untranslated action of the rule for which \c rule is the
+ *     LHS node.  Thus, \c code possibly contains Bison escapes such as \c $$,
+ *     \c $1, \c $2, etc referring to the values of the rule.
+ * \post
+ *   - \c self has been overwritten to represent the specified rule action.
+ *   - \c self does not claim responsibility for the memory of \c code or
+ *     \c rule.
+ */
+void code_props_rule_action_init (code_props *self, char const *code,
+                                  location code_loc, struct symbol_list *rule);
+
+/**
+ * \pre
+ *   - If there's a code passage contained in \c self and it contains Bison
+ *     escapes, all grammar declarations have already been parsed as they may
+ *     affect warnings and complaints issued here.
+ * \post
+ *   - All M4 special symbols and Bison escapes have been translated in
+ *     <tt>code_props_code_get (*self)</tt> iff
+ *     <tt>code_props_code_get (*self \@pre) != NULL</tt>.
+ */
+void code_props_translate_code (code_props *self);
+
+/**
+ * \pre
+ *   - None.
+ * \post
+ *   - \c result = either:
+ *     - The code passage contained with \c self.
+ *     - \c NULL if none.
+ */
+char const *code_props_code_get (code_props const self);
+
+/**
+ * \pre
+ *   - <tt>code_props_code_get (self) != NULL</tt>.
+ * \post
+ *   - \c result = the grammar file location of
+ *     <tt>code_props_code_get (self)</tt>.
+ */
+location code_props_location_get (code_props const self);
+
+/**
+ * \pre
+ *   - \c self was not previously initialized with \c code_props_plain_init.
+ * \post
+ *   - \c result = either:
+ *     - \c false if either:
+ *       - \c code_props_translate_code has never previously been invoked for
+ *         the \c code_props that would contain the code passage associated
+ *         with \c self.  (If \c self is for a RHS \c symbol_list node, that
+ *         \c code_props is not \c self.  Instead, it's the \c code_props for
+ *         the LHS symbol of the same rule.)
+ *       - \c code_props_translate_code has been invoked for that
+ *         \c code_props, but the symbol value associated with \c self was not
+ *         referenced in the code passage.
+ *     - \c true otherwise.
+ */
+bool code_props_is_value_used (code_props const self);
+
+/**
+ * \pre
+ *   - None.
+ * \post
+ *   - The dynamic memory allocated by the previous invocation of
+ *     \c code_props_translate_code (if any) was freed.  The \c code_props
+ *     instance for which that \c code_props_translate_code was invoked is now
+ *     invalid.
+ */
+void code_scanner_last_string_free (void);
+
+/**
+ * \pre
+ *   - None.
+ * \post
+ *   - All dynamic memory allocated during invocations of
+ *     \c code_props_translate_code (if any) has been freed.  All
+ *     \c code_props instances and all pointers returned by
+ *     \c code_props_code_get may now be invalid.
+ */
 void code_scanner_free (void);
 
-/* The action of the rule R contains $$, $1 etc. referring to the values
-   of the rule R. */
-char const *translate_rule_action (symbol_list *r);
-
-/* The action A refers to $$ and @$ only, referring to a symbol. */
-char const *translate_symbol_action (char const *a, location l);
-
-/* The action contains no special escapes, just protect M4 special
-   symbols.  */
-char const *translate_code (char const *a, location l);
-
 #endif /* !SCAN_CODE_H_ */