src/muscle-tab.h

   1 /* Muscle table manager for Bison,
   2
   3    Copyright (C) 2001-2003, 2006-2012 Free Software Foundation, Inc.
   4
   5    This file is part of Bison, the GNU Compiler Compiler.
   6
   7    This program 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 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program 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.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #ifndef MUSCLE_TAB_H_
  21 # define MUSCLE_TAB_H_
  22
  23 # include <quotearg.h>
  24
  25 # include "location.h"
  26
  27 void muscle_init (void);
  28 void muscle_insert (char const *key, char const *value);
  29 char const *muscle_find_const (char const *key);
  30 char *muscle_find (char const *key);
  31 void muscle_free (void);
  32
  33
  34 /* An obstack dedicated to receive muscle keys and values.  */
  35 extern struct obstack muscle_obstack;
  36
  37 #define MUSCLE_INSERT_BOOL(Key, Value)                          \
  38 do {                                                            \
  39   int v__ = Value;                                              \
  40   MUSCLE_INSERT_INT (Key, v__);                                 \
  41 } while(0)
  42
  43 #define MUSCLE_INSERT_INT(Key, Value)                           \
  44 do {                                                            \
  45   obstack_fgrow1 (&muscle_obstack, "%d", Value);                \
  46   obstack_1grow (&muscle_obstack, 0);                           \
  47   muscle_insert (Key, obstack_finish (&muscle_obstack));        \
  48 } while(0)
  49
  50 #define MUSCLE_INSERT_LONG_INT(Key, Value)                      \
  51 do {                                                            \
  52   obstack_fgrow1 (&muscle_obstack, "%ld", Value);               \
  53   obstack_1grow (&muscle_obstack, 0);                           \
  54   muscle_insert (Key, obstack_finish (&muscle_obstack));        \
  55 } while(0)
  56
  57 /* Key -> Value, but don't apply escaping to Value. */
  58 #define MUSCLE_INSERT_STRING_RAW(Key, Value)                    \
  59 do {                                                            \
  60   obstack_sgrow (&muscle_obstack, Value);                       \
  61   obstack_1grow (&muscle_obstack, 0);                           \
  62   muscle_insert (Key, obstack_finish (&muscle_obstack));        \
  63 } while(0)
  64
  65 /* Key -> Value, applying M4 escaping to Value. */
  66 #define MUSCLE_INSERT_STRING(Key, Value)                        \
  67 do {                                                            \
  68   MUSCLE_OBSTACK_SGROW (&muscle_obstack, Value);                \
  69   obstack_1grow (&muscle_obstack, 0);                           \
  70   muscle_insert (Key, obstack_finish (&muscle_obstack));        \
  71 } while(0)
  72
  73 #define MUSCLE_OBSTACK_SGROW(Obstack, Value)            \
  74 do {                                                    \
  75   char const *p__;                                      \
  76   for (p__ = Value; *p__; p__++)                        \
  77     switch (*p__)                                       \
  78       {                                                 \
  79       case '$': obstack_sgrow (Obstack, "$]["); break;  \
  80       case '@': obstack_sgrow (Obstack, "@@" ); break;  \
  81       case '[': obstack_sgrow (Obstack, "@{" ); break;  \
  82       case ']': obstack_sgrow (Obstack, "@}" ); break;  \
  83       default: obstack_1grow (Obstack, *p__); break;    \
  84       }                                                 \
  85 } while(0)
  86
  87 #define MUSCLE_INSERT_C_STRING(Key, Value)                      \
  88 do {                                                            \
  89   MUSCLE_OBSTACK_SGROW (&muscle_obstack,                        \
  90                         quotearg_style (c_quoting_style,        \
  91                                         Value));                \
  92   obstack_1grow (&muscle_obstack, 0);                           \
  93   muscle_insert (Key, obstack_finish (&muscle_obstack));        \
  94 } while(0)
  95
  96 /* Append VALUE to the current value of KEY.  If KEY did not already
  97    exist, create it.  Use MUSCLE_OBSTACK.  De-allocate the previously
  98    associated value.  Copy VALUE and SEPARATOR.  */
  99
 100 void muscle_grow (const char *key, const char *value, const char *separator);
 101
 102
 103 /* Append VALUE to the current value of KEY, using muscle_grow.  But
 104    in addition, issue a synchronization line for the location LOC.  */
 105
 106 void muscle_code_grow (const char *key, const char *value, location loc);
 107
 108
 109 /* MUSCLE is an M4 list of pairs.  Create or extend it with the pair
 110    (A1, A2) after escaping both values with digraphs.  Note that because the
 111    muscle values are output *double* quoted, one needs to strip the first level
 112    of quotes to reach the list itself.  */
 113 void muscle_pair_list_grow (const char *muscle,
 114                             const char *a1, const char *a2);
 115
 116 /* In the format `[[file_name:line.column]], [[file_name:line.column]]', append
 117    LOC to MUSCLE.  Use digraphs for special characters in each file name.  */
 118 void muscle_location_grow (char const *key, location loc);
 119
 120 /* In the format `file_name:line.column', append BOUND to MUSCLE.  Use digraphs
 121    for special characters in the file name.  */
 122 void muscle_boundary_grow (char const *key, boundary bound);
 123
 124 /* Grow KEY for the occurrence of the name USER_NAME at LOC appropriately for
 125    use with b4_check_user_names in ../data/bison.m4.  USER_NAME is not escaped
 126    with digraphs, so it must not contain `[' or `]'.  */
 127 void muscle_user_name_list_grow (char const *key, char const *user_name,
 128                                  location loc);
 129
 130 /* Indicates whether a variable's value was specified with -D/--define, with
 131    -F/--force-define, or in the grammar file.  */
 132 typedef enum {
 133   MUSCLE_PERCENT_DEFINE_D = 0, MUSCLE_PERCENT_DEFINE_F,
 134   MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE
 135 } muscle_percent_define_how;
 136
 137 /* Define the muscles for %define variable VARIABLE with VALUE specified
 138    at VARIABLE_LOC in the manner HOW unless it was specified in the
 139    grammar file while the previous definition for VARIABLE was specified
 140    with -F/--force-define.  Complain if a previous definition is being
 141    overridden and the new definition is specified in the grammar file.
 142    (These rules support the documented behavior as long as command-line
 143    definitions are processed before grammar file definitions.)  Record
 144    this as a user occurrence of VARIABLE by invoking
 145    muscle_user_name_list_grow.  */
 146 void muscle_percent_define_insert (char const *variable, location variable_loc,
 147                                    char const *value,
 148                                    muscle_percent_define_how how);
 149
 150 /* Make sure that VARIABLE is set to the boolean VALUE.  Warn on mismatches
 151    only, but accept repeated declaration.  Used for backward compatibility
 152    between old directives such as %pure-parser, and the recommended use of
 153    variables (%define api.pure).   */
 154 void muscle_percent_define_ensure (char const *variable, location variable_loc,
 155                                    bool value);
 156
 157 /* Mimic b4_percent_define_get in ../data/bison.m4 exactly.  That is, if the
 158    %define variable VARIABLE is defined, return its value.  Otherwise, return
 159    the empty string.  Also, record Bison's usage of VARIABLE by defining
 160    b4_percent_define_bison_variables(VARIABLE).  The caller is responsible for
 161    freeing the memory of the returned string.  */
 162 char *muscle_percent_define_get (char const *variable);
 163
 164 /* Mimic muscle_percent_define_get_loc in ../data/bison.m4 exactly.  That is,
 165    if the %define variable VARIABLE is undefined, complain fatally since that's
 166    a Bison error.  Otherwise, return its definition location in a form
 167    approriate for the first argument of warn_at, complain_at, or fatal_at.
 168    Don't record this as a Bison usage of VARIABLE as there's no reason to
 169    suspect that the user-supplied value has yet influenced the output.  */
 170 location muscle_percent_define_get_loc (char const *variable);
 171
 172 /* Mimic muscle_percent_define_get_syncline in ../data/bison.m4 exactly.  That
 173    is, if the %define variable VARIABLE is undefined, complain fatally since
 174    that's a Bison error.  Otherwise, return its definition location as a
 175    b4_syncline invocation.  Don't record this as a Bison usage of VARIABLE as
 176    there's no reason to suspect that the user-supplied value has yet influenced
 177    the output.  */
 178 char const *muscle_percent_define_get_syncline (char const *variable);
 179
 180 /* Mimic b4_percent_define_ifdef in ../data/bison.m4 exactly.  That is, if the
 181    %define variable VARIABLE is defined, return true.  Otherwise, return false.
 182    Also, record Bison's usage of VARIABLE by defining
 183    b4_percent_define_bison_variables(VARIABLE).  */
 184 bool muscle_percent_define_ifdef (char const *variable);
 185
 186 /* Mimic b4_percent_define_flag_if in ../data/bison.m4 exactly.  That is, if
 187    the %define variable VARIABLE is defined to "" or "true", return true.  If
 188    it is defined to "false", return false.  Complain if it is undefined (a
 189    Bison error since the default value should have been set already) or defined
 190    to any other value (possibly a user error).  Also, record Bison's usage of
 191    VARIABLE by defining b4_percent_define_bison_variables(VARIABLE).  */
 192 bool muscle_percent_define_flag_if (char const *variable);
 193
 194 /* Mimic b4_percent_define_default in ../data/bison.m4 exactly.  That is, if
 195    the %define variable VARIABLE is undefined, set its value to VALUE.
 196    Don't record this as a Bison usage of VARIABLE as there's no reason to
 197    suspect that the value has yet influenced the output.  */
 198 void muscle_percent_define_default (char const *variable, char const *value);
 199
 200 /* Mimic b4_percent_define_check_values in ../data/bison.m4 exactly except that
 201    the VALUES structure is more appropriate for C.  That is, VALUES points to a
 202    list of strings that is partitioned into sublists by NULL's, one terminating
 203    each sublist.  The last sublist is followed by a second NULL.  For each
 204    sublist, the first string is the name of a %define variable, and all
 205    remaining strings in that sublist are the valid values for that variable.
 206    Complain if such a variable is undefined (a Bison error since the default
 207    value should have been set already) or defined to any other value (possibly
 208    a user error).  Don't record this as a Bison usage of the variable as
 209    there's no reason to suspect that the value has yet influenced the
 210    output.  */
 211 void muscle_percent_define_check_values (char const * const *values);
 212
 213 /* Grow the muscle for the %code qualifier QUALIFIER appearing at
 214    QUALIFIER_LOC with code CODE appearing at CODE_LOC.  Record this as a
 215    user occurrence of QUALIFIER by invoking
 216    muscle_user_name_list_grow.  */
 217 void muscle_percent_code_grow (char const *qualifier, location qualifier_loc,
 218                                char const *code, location code_loc);
 219
 220 void muscles_m4_output (FILE *out);
 221
 222 #endif /* not MUSCLE_TAB_H_ */