src/muscle-tab.h

   1 /* Muscle table manager for Bison,
   2
   3    Copyright (C) 2001-2003, 2006-2013 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 /* The kind of value associated to this muscle, depending on the
  28    syntax of the value: keyword (no delimiter, e.g., true), string
  29    (double quotes, e.g., "foo.h"), or code (braces, e.g., {int}).  */
  30 typedef enum
  31 {
  32   muscle_code,
  33   muscle_keyword,
  34   muscle_string
  35 } muscle_kind;
  36
  37 /* Conversion from string.  */
  38 muscle_kind muscle_kind_new (char const *k);
  39
  40 /* Conversion to string.  */
  41 char const *muscle_kind_string (muscle_kind k);
  42
  43
  44 /* Create the MUSCLE_TABLE, and initialize it with default values.
  45    Also set up the MUSCLE_OBSTACK.  */
  46 void muscle_init (void);
  47
  48 /* Insert (KEY, VALUE).  If KEY already existed, overwrite the
  49    previous value.  Otherwise create as a muscle_string type.  */
  50 void muscle_insert (char const *key, char const *value);
  51
  52 /* Find the value of muscle KEY.  Unlike MUSCLE_FIND, this is always
  53    reliable to determine whether KEY has a value.  */
  54 char const *muscle_find_const (char const *key);
  55
  56 /* Find the value of muscle KEY.  Abort if muscle_insert was invoked
  57    more recently than muscle_grow for KEY since muscle_find can't
  58    return a char const *.  */
  59 char *muscle_find (char const *key);
  60
  61 /* Free all the memory consumed by the muscle machinery only.  */
  62 void muscle_free (void);
  63
  64
  65 /* An obstack dedicated to receive muscle keys and values.  */
  66 extern struct obstack muscle_obstack;
  67
  68 # define MUSCLE_INSERT_BOOL(Key, Value)         \
  69   do {                                          \
  70     int v__ = Value;                            \
  71     MUSCLE_INSERT_INT (Key, v__);               \
  72   } while (0)
  73
  74 # define MUSCLE_INSERTF(Key, Format, Value)                     \
  75   do {                                                          \
  76     obstack_printf (&muscle_obstack, Format, Value);            \
  77     muscle_insert (Key, obstack_finish0 (&muscle_obstack));     \
  78   } while (0)
  79
  80 # define MUSCLE_INSERT_INT(Key, Value)          \
  81   MUSCLE_INSERTF(Key, "%d", Value)
  82
  83 # define MUSCLE_INSERT_LONG_INT(Key, Value)     \
  84   MUSCLE_INSERTF(Key, "%ld", Value)
  85
  86 /* Key -> Value, but don't apply escaping to Value. */
  87 # define MUSCLE_INSERT_STRING_RAW(Key, Value)   \
  88   MUSCLE_INSERTF(Key, "%s", Value)
  89
  90 /* Key -> Value, applying M4 escaping to Value. */
  91 # define MUSCLE_INSERT_STRING(Key, Value)                       \
  92   do {                                                          \
  93     obstack_escape (&muscle_obstack, Value);                    \
  94     muscle_insert (Key, obstack_finish0 (&muscle_obstack));     \
  95   } while (0)
  96
  97 /* Key -> Value, applying C escaping to Value (and then M4). */
  98 # define MUSCLE_INSERT_C_STRING(Key, Value)                     \
  99   MUSCLE_INSERT_STRING(Key, quotearg_style (c_quoting_style, Value))
 100
 101
 102 /* Append VALUE to the current value of KEY, using muscle_grow.  But
 103    in addition, issue a synchronization line for the location LOC.
 104    Be sure to append on a new line.  */
 105 void muscle_code_grow (const char *key, const char *value, location loc);
 106
 107
 108 /* MUSCLE is an M4 list of pairs.  Create or extend it with the pair
 109    (A1, A2) after escaping both values with digraphs.  Note that because the
 110    muscle values are output *double* quoted, one needs to strip the first level
 111    of quotes to reach the list itself.  */
 112 void muscle_pair_list_grow (const char *muscle,
 113                             const char *a1, const char *a2);
 114
 115 /* Grow KEY for the occurrence of the name USER_NAME at LOC appropriately for
 116    use with b4_check_user_names in ../data/bison.m4.  USER_NAME is not escaped
 117    with digraphs, so it must not contain '[' or ']'.  */
 118 void muscle_user_name_list_grow (char const *key, char const *user_name,
 119                                  location loc);
 120
 121 /* Indicates whether a variable's value was specified with -D/--define, with
 122    -F/--force-define, or in the grammar file.  */
 123 typedef enum {
 124   MUSCLE_PERCENT_DEFINE_D = 0,
 125   MUSCLE_PERCENT_DEFINE_F,
 126   MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE
 127 } muscle_percent_define_how;
 128
 129 /* Define the muscles for %define variable VARIABLE with VALUE specified
 130    at VARIABLE_LOC in the manner HOW unless it was specified in the
 131    grammar file while the previous definition for VARIABLE was specified
 132    with -F/--force-define.  Complain if a previous definition is being
 133    overridden and the new definition is specified in the grammar file.
 134    (These rules support the documented behavior as long as command-line
 135    definitions are processed before grammar file definitions.)  Record
 136    this as a user occurrence of VARIABLE by invoking
 137    muscle_user_name_list_grow.  */
 138 void muscle_percent_define_insert (char const *variable, location variable_loc,
 139                                    muscle_kind kind,
 140                                    char const *value,
 141                                    muscle_percent_define_how how);
 142
 143 /* Make sure that VARIABLE is set to the boolean VALUE.  Warn on mismatches
 144    only, but accept repeated declaration.  Used for backward compatibility
 145    between old directives such as %pure-parser, and the recommended use of
 146    variables (%define api.pure).   */
 147 void muscle_percent_define_ensure (char const *variable, location variable_loc,
 148                                    bool value);
 149
 150 /* Mimic b4_percent_define_get in ../data/bison.m4 exactly.  That is, if the
 151    %define variable VARIABLE is defined, return its value.  Otherwise, return
 152    the empty string.  Also, record Bison's usage of VARIABLE by defining
 153    b4_percent_define_bison_variables(VARIABLE).  The caller is responsible for
 154    freeing the memory of the returned string.  */
 155 char *muscle_percent_define_get (char const *variable);
 156
 157 /* Mimic muscle_percent_define_get_loc in ../data/bison.m4 exactly.  That is,
 158    if the %define variable VARIABLE is undefined, complain fatally since that's
 159    a Bison error.  Otherwise, return its definition location in a form
 160    approriate for the first argument of warn_at, complain_at, or fatal_at.
 161    Don't record this as a Bison usage of VARIABLE as there's no reason to
 162    suspect that the user-supplied value has yet influenced the output.  */
 163 location muscle_percent_define_get_loc (char const *variable);
 164
 165 /* Mimic muscle_percent_define_get_syncline in ../data/bison.m4 exactly.  That
 166    is, if the %define variable VARIABLE is undefined, complain fatally since
 167    that's a Bison error.  Otherwise, return its definition location as a
 168    b4_syncline invocation.  Don't record this as a Bison usage of VARIABLE as
 169    there's no reason to suspect that the user-supplied value has yet influenced
 170    the output.  */
 171 char const *muscle_percent_define_get_syncline (char const *variable);
 172
 173 /* Mimic b4_percent_define_ifdef in ../data/bison.m4 exactly.  That is, if the
 174    %define variable VARIABLE is defined, return true.  Otherwise, return false.
 175    Also, record Bison's usage of VARIABLE by defining
 176    b4_percent_define_bison_variables(VARIABLE).  */
 177 bool muscle_percent_define_ifdef (char const *variable);
 178
 179 /* Mimic b4_percent_define_flag_if in ../data/bison.m4 exactly.  That is, if
 180    the %define variable VARIABLE is defined to "" or "true", return true.  If
 181    it is defined to "false", return false.  Complain if it is undefined (a
 182    Bison error since the default value should have been set already) or defined
 183    to any other value (possibly a user error).  Also, record Bison's usage of
 184    VARIABLE by defining b4_percent_define_bison_variables(VARIABLE).  */
 185 bool muscle_percent_define_flag_if (char const *variable);
 186
 187 /* Mimic b4_percent_define_default in ../data/bison.m4 exactly.  That is, if
 188    the %define variable VARIABLE is undefined, set its value to VALUE.
 189    Don't record this as a Bison usage of VARIABLE as there's no reason to
 190    suspect that the value has yet influenced the output.  */
 191 void muscle_percent_define_default (char const *variable, char const *value);
 192
 193 /* Mimic b4_percent_define_check_values in ../data/bison.m4 exactly except that
 194    the VALUES structure is more appropriate for C.  That is, VALUES points to a
 195    list of strings that is partitioned into sublists by NULL's, one terminating
 196    each sublist.  The last sublist is followed by a second NULL.  For each
 197    sublist, the first string is the name of a %define variable, and all
 198    remaining strings in that sublist are the valid values for that variable.
 199    Complain if such a variable is undefined (a Bison error since the default
 200    value should have been set already) or defined to any other value (possibly
 201    a user error).  Don't record this as a Bison usage of the variable as
 202    there's no reason to suspect that the value has yet influenced the
 203    output.  */
 204 void muscle_percent_define_check_values (char const * const *values);
 205
 206 /* Grow the muscle for the %code qualifier QUALIFIER appearing at
 207    QUALIFIER_LOC with code CODE appearing at CODE_LOC.  Record this as a
 208    user occurrence of QUALIFIER by invoking
 209    muscle_user_name_list_grow.  */
 210 void muscle_percent_code_grow (char const *qualifier, location qualifier_loc,
 211                                char const *code, location code_loc);
 212
 213 /* Output the definition of all the current muscles into a list of
 214    m4_defines.  */
 215 void muscles_m4_output (FILE *out);
 216
 217 #endif /* not MUSCLE_TAB_H_ */