src/muscle_tab.h

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