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    Bison 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 2, or (at your option)
   9    any later version.
  10
  11    Bison 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 Bison; see the file COPYING.  If not, write to
  18    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19    Boston, MA 02110-1301, USA.  */
  20
  21 #ifndef MUSCLE_TAB_H_
  22 # define MUSCLE_TAB_H_
  23
  24 # include "location.h"
  25
  26 void muscle_init (void);
  27 void muscle_insert (char const *key, char const *value);
  28 char const *muscle_find_const (char const *key);
  29 char *muscle_find (char const *key);
  30 void muscle_free (void);
  31
  32
  33 /* An obstack dedicated to receive muscle keys and values.  */
  34 extern struct obstack muscle_obstack;
  35
  36 #define MUSCLE_INSERT_BOOL(Key, Value)                          \
  37 do {                                                            \
  38   int v = Value;                                                \
  39   MUSCLE_INSERT_INT (Key, v);                                   \
  40 } while(0)
  41
  42 #define MUSCLE_INSERT_INT(Key, Value)                           \
  43 do {                                                            \
  44   obstack_fgrow1 (&muscle_obstack, "%d", Value);                \
  45   obstack_1grow (&muscle_obstack, 0);                           \
  46   muscle_insert (Key, obstack_finish (&muscle_obstack));        \
  47 } while(0)
  48
  49 #define MUSCLE_INSERT_LONG_INT(Key, Value)                      \
  50 do {                                                            \
  51   obstack_fgrow1 (&muscle_obstack, "%ld", Value);               \
  52   obstack_1grow (&muscle_obstack, 0);                           \
  53   muscle_insert (Key, obstack_finish (&muscle_obstack));        \
  54 } while(0)
  55
  56 #define MUSCLE_INSERT_STRING_RAW(Key, Value)                    \
  57 do {                                                            \
  58   obstack_sgrow (&muscle_obstack, Value);                       \
  59   obstack_1grow (&muscle_obstack, 0);                           \
  60   muscle_insert (Key, obstack_finish (&muscle_obstack));        \
  61 } while(0)
  62
  63 #define MUSCLE_INSERT_STRING(Key, Value)                        \
  64 do {                                                            \
  65   MUSCLE_OBSTACK_SGROW (&muscle_obstack, Value);                \
  66   obstack_1grow (&muscle_obstack, 0);                           \
  67   muscle_insert (Key, obstack_finish (&muscle_obstack));        \
  68 } while(0)
  69
  70 #define MUSCLE_OBSTACK_SGROW(Obstack, Value)                    \
  71 do {                                                            \
  72   char const *p;                                                \
  73   for (p = Value; *p; p++)                                      \
  74     switch (*p)                                                 \
  75       {                                                         \
  76       case '$': obstack_sgrow (Obstack, "$]["); break;          \
  77       case '@': obstack_sgrow (Obstack, "@@" ); break;          \
  78       case '[': obstack_sgrow (Obstack, "@{" ); break;          \
  79       case ']': obstack_sgrow (Obstack, "@}" ); break;          \
  80       default: obstack_1grow (Obstack, *p); break;              \
  81       }                                                         \
  82 } while(0)
  83
  84 #define MUSCLE_INSERT_C_STRING(Key, Value)                      \
  85 do {                                                            \
  86   MUSCLE_OBSTACK_SGROW (&muscle_obstack,                        \
  87                         quotearg_style (c_quoting_style,        \
  88                                         Value));                \
  89   obstack_1grow (&muscle_obstack, 0);                           \
  90   muscle_insert (Key, obstack_finish (&muscle_obstack));        \
  91 } while(0)
  92
  93 /* Append VALUE to the current value of KEY.  If KEY did not already
  94    exist, create it.  Use MUSCLE_OBSTACK.  De-allocate the previously
  95    associated value.  Copy VALUE and SEPARATOR.  */
  96
  97 void muscle_grow (const char *key, const char *value, const char *separator);
  98
  99
 100 /* Append VALUE to the current value of KEY, using muscle_grow.  But
 101    in addition, issue a synchronization line for the location LOC.  */
 102
 103 void muscle_code_grow (const char *key, const char *value, location loc);
 104
 105
 106 /* MUSCLE is an M4 list of pairs.  Create or extend it with the pair
 107    (A1, A2) after escaping both values with digraphs.  Note that because the
 108    muscle values are output *double* quoted, one needs to strip the first level
 109    of quotes to reach the list itself.  */
 110 void muscle_pair_list_grow (const char *muscle,
 111                             const char *a1, const char *a2);
 112
 113 /* In the format `[[file_name:line.column]], [[file_name:line.column]]', append
 114    LOC to MUSCLE.  Use digraphs for special characters in each file name.  */
 115 void muscle_location_grow (char const *key, location loc);
 116
 117 /* In the format `file_name:line.column', append BOUND to MUSCLE.  Use digraphs
 118    for special characters in the file name.  */
 119 void muscle_boundary_grow (char const *key, boundary bound);
 120
 121 /* Grow KEY for the occurrence of the name USER_NAME at LOC appropriately for
 122    use with b4_check_user_names in ../data/bison.m4.  USER_NAME is not escaped
 123    with digraphs, so it must not contain `[' or `]'.  */
 124 void muscle_user_name_list_grow (char const *key, char const *user_name,
 125                                  location loc);
 126
 127 /* Define the muscle for the %define variable VARIABLE appearing at
 128    VARIABLE_LOC in the grammar file with value VALUE.  Warn if VARIABLE is
 129    already defined.  Record this as a grammar occurrence of VARIABLE by
 130    invoking muscle_user_name_list_grow.  */
 131 void muscle_percent_define_insert (char const *variable, location variable_loc,
 132                                    char const *value);
 133
 134 /* Mimic b4_percent_define_get in ../data/bison.m4 exactly.  That is, if the
 135    %define variable VARIABLE is defined, return its value.  Otherwise, return
 136    the empty string.  Also, record Bison's usage of VARIABLE by defining
 137    b4_percent_define_bison_variables(VARIABLE).  The caller is responsible for
 138    freeing the memory of the returned string.  */
 139 char *muscle_percent_define_get (char const *variable);
 140
 141 /* Mimic b4_percent_define_ifdef in ../data/bison.m4 exactly.  That is, if the
 142    %define variable VARIABLE is defined, return true.  Otherwise, return false.
 143    Also, record Bison's usage of VARIABLE by defining
 144    b4_percent_define_bison_variables(VARIABLE).  */
 145 bool muscle_percent_define_ifdef (char const *variable);
 146
 147 /* Mimic b4_percent_define_flag_if in ../data/bison.m4 exactly.  That is, if
 148    the %define variable VARIABLE is defined to "" or "true", return true.  If
 149    it is defined to "false", return false.  Complain if it is undefined (a
 150    Bison error since the default value should have been set already) or defined
 151    to any other value (possibly a user error).  Also, record Bison's usage of
 152    VARIABLE by defining b4_percent_define_bison_variables(VARIABLE).  */
 153 bool muscle_percent_define_flag_if (char const *variable);
 154
 155 /* Mimic b4_percent_define_default in ../data/bison.m4 exactly.  That is, if
 156    the %define variable VARIABLE is undefined, set its value to VALUE.
 157    Don't record this as a Bison usage of VARIABLE as there's no reason to
 158    suspect that the value has yet influenced the output.  */
 159 void muscle_percent_define_default (char const *variable, char const *value);
 160
 161 /* VALUES points to a sequence of strings that is partitioned into
 162    subsequences by NULL's, one terminating each subsequence.  The last
 163    subsequence is followed by a second NULL.  For each subsequence, the first
 164    string is the name of a %define variable, and all remaining strings in that
 165    subsequence are the valid values for that variable.  Complain if such a
 166    variable is undefined (a Bison error since the default value should have
 167    been set already) or defined to any other value (possibly a user error).
 168    Don't record this as a Bison usage of the variable as there's no reason to
 169    suspect that the value has yet influenced the output.  */
 170 void muscle_percent_define_check_values (char const * const *values);
 171
 172 /* Grow the muscle for the %code qualifier QUALIFIER appearing at QUALIFIER_LOC
 173    in the grammar file with code CODE appearing at CODE_LOC.  Record this as a
 174    grammar occurrence of VARIABLE by invoking muscle_user_name_list_grow.  */
 175 void muscle_percent_code_grow (char const *qualifier, location qualifier_loc,
 176                                char const *code, location code_loc);
 177
 178 void muscles_m4_output (FILE *out);
 179
 180 #endif /* not MUSCLE_TAB_H_ */