src/muscle-tab.h

/* Muscle table manager for Bison,

   Copyright (C) 2001-2003, 2006-2012 Free Software Foundation, Inc.

   This file is part of Bison, the GNU Compiler Compiler.

   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#ifndef MUSCLE_TAB_H_
# define MUSCLE_TAB_H_

# include <quotearg.h>

# include "location.h"

void muscle_init (void);
void muscle_insert (char const *key, char const *value);
char const *muscle_find_const (char const *key);
char *muscle_find (char const *key);
void muscle_free (void);


/* An obstack dedicated to receive muscle keys and values.  */
extern struct obstack muscle_obstack;

#define MUSCLE_INSERT_BOOL(Key, Value)                          \
  do {                                                          \
    int v__ = Value;                                            \
    MUSCLE_INSERT_INT (Key, v__);                               \
  } while (0)

#define MUSCLE_INSERTF(Key, Format, Value)                      \
  do {                                                          \
    obstack_printf (&muscle_obstack, Format, Value);            \
    muscle_insert (Key, obstack_finish0 (&muscle_obstack));     \
  } while (0)

#define MUSCLE_INSERT_INT(Key, Value)                           \
  MUSCLE_INSERTF(Key, "%d", Value)

#define MUSCLE_INSERT_LONG_INT(Key, Value)                      \
  MUSCLE_INSERTF(Key, "%ld", Value)

/* Key -> Value, but don't apply escaping to Value. */
#define MUSCLE_INSERT_STRING_RAW(Key, Value)                    \
  MUSCLE_INSERTF(Key, "%s", Value)

/* Key -> Value, applying M4 escaping to Value. */
#define MUSCLE_INSERT_STRING(Key, Value)                        \
  do {                                                          \
    obstack_escape (&muscle_obstack, Value);                    \
    muscle_insert (Key, obstack_finish0 (&muscle_obstack));     \
  } while (0)

#define MUSCLE_INSERT_C_STRING(Key, Value)                      \
  do {                                                          \
    obstack_escape (&muscle_obstack,                            \
                    quotearg_style (c_quoting_style, Value));   \
    muscle_insert (Key, obstack_finish0 (&muscle_obstack));     \
  } while (0)

/* Append VALUE to the current value of KEY.  If KEY did not already
   exist, create it.  Use MUSCLE_OBSTACK.  De-allocate the previously
   associated value.  Copy VALUE and SEPARATOR.  */

void muscle_grow (const char *key, const char *value, const char *separator);


/* Append VALUE to the current value of KEY, using muscle_grow.  But
   in addition, issue a synchronization line for the location LOC.  */

void muscle_code_grow (const char *key, const char *value, location loc);


/* MUSCLE is an M4 list of pairs.  Create or extend it with the pair
   (A1, A2) after escaping both values with digraphs.  Note that because the
   muscle values are output *double* quoted, one needs to strip the first level
   of quotes to reach the list itself.  */
void muscle_pair_list_grow (const char *muscle,
                            const char *a1, const char *a2);

/* Grow KEY for the occurrence of the name USER_NAME at LOC appropriately for
   use with b4_check_user_names in ../data/bison.m4.  USER_NAME is not escaped
   with digraphs, so it must not contain `[' or `]'.  */
void muscle_user_name_list_grow (char const *key, char const *user_name,
                                 location loc);

/* Indicates whether a variable's value was specified with -D/--define, with
   -F/--force-define, or in the grammar file.  */
typedef enum {
  MUSCLE_PERCENT_DEFINE_D = 0, MUSCLE_PERCENT_DEFINE_F,
  MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE
} muscle_percent_define_how;

/* Define the muscles for %define variable VARIABLE with VALUE specified
   at VARIABLE_LOC in the manner HOW unless it was specified in the
   grammar file while the previous definition for VARIABLE was specified
   with -F/--force-define.  Complain if a previous definition is being
   overridden and the new definition is specified in the grammar file.
   (These rules support the documented behavior as long as command-line
   definitions are processed before grammar file definitions.)  Record
   this as a user occurrence of VARIABLE by invoking
   muscle_user_name_list_grow.  */
void muscle_percent_define_insert (char const *variable, location variable_loc,
                                   char const *value,
                                   muscle_percent_define_how how);

/* Make sure that VARIABLE is set to the boolean VALUE.  Warn on mismatches
   only, but accept repeated declaration.  Used for backward compatibility
   between old directives such as %pure-parser, and the recommended use of
   variables (%define api.pure).   */
void muscle_percent_define_ensure (char const *variable, location variable_loc,
                                   bool value);

/* Mimic b4_percent_define_get in ../data/bison.m4 exactly.  That is, if the
   %define variable VARIABLE is defined, return its value.  Otherwise, return
   the empty string.  Also, record Bison's usage of VARIABLE by defining
   b4_percent_define_bison_variables(VARIABLE).  The caller is responsible for
   freeing the memory of the returned string.  */
char *muscle_percent_define_get (char const *variable);

/* Mimic muscle_percent_define_get_loc in ../data/bison.m4 exactly.  That is,
   if the %define variable VARIABLE is undefined, complain fatally since that's
   a Bison error.  Otherwise, return its definition location in a form
   approriate for the first argument of warn_at, complain_at, or fatal_at.
   Don't record this as a Bison usage of VARIABLE as there's no reason to
   suspect that the user-supplied value has yet influenced the output.  */
location muscle_percent_define_get_loc (char const *variable);

/* Mimic muscle_percent_define_get_syncline in ../data/bison.m4 exactly.  That
   is, if the %define variable VARIABLE is undefined, complain fatally since
   that's a Bison error.  Otherwise, return its definition location as a
   b4_syncline invocation.  Don't record this as a Bison usage of VARIABLE as
   there's no reason to suspect that the user-supplied value has yet influenced
   the output.  */
char const *muscle_percent_define_get_syncline (char const *variable);

/* Mimic b4_percent_define_ifdef in ../data/bison.m4 exactly.  That is, if the
   %define variable VARIABLE is defined, return true.  Otherwise, return false.
   Also, record Bison's usage of VARIABLE by defining
   b4_percent_define_bison_variables(VARIABLE).  */
bool muscle_percent_define_ifdef (char const *variable);

/* Mimic b4_percent_define_flag_if in ../data/bison.m4 exactly.  That is, if
   the %define variable VARIABLE is defined to "" or "true", return true.  If
   it is defined to "false", return false.  Complain if it is undefined (a
   Bison error since the default value should have been set already) or defined
   to any other value (possibly a user error).  Also, record Bison's usage of
   VARIABLE by defining b4_percent_define_bison_variables(VARIABLE).  */
bool muscle_percent_define_flag_if (char const *variable);

/* Mimic b4_percent_define_default in ../data/bison.m4 exactly.  That is, if
   the %define variable VARIABLE is undefined, set its value to VALUE.
   Don't record this as a Bison usage of VARIABLE as there's no reason to
   suspect that the value has yet influenced the output.  */
void muscle_percent_define_default (char const *variable, char const *value);

/* Mimic b4_percent_define_check_values in ../data/bison.m4 exactly except that
   the VALUES structure is more appropriate for C.  That is, VALUES points to a
   list of strings that is partitioned into sublists by NULL's, one terminating
   each sublist.  The last sublist is followed by a second NULL.  For each
   sublist, the first string is the name of a %define variable, and all
   remaining strings in that sublist are the valid values for that variable.
   Complain if such a variable is undefined (a Bison error since the default
   value should have been set already) or defined to any other value (possibly
   a user error).  Don't record this as a Bison usage of the variable as
   there's no reason to suspect that the value has yet influenced the
   output.  */
void muscle_percent_define_check_values (char const * const *values);

/* Grow the muscle for the %code qualifier QUALIFIER appearing at
   QUALIFIER_LOC with code CODE appearing at CODE_LOC.  Record this as a
   user occurrence of QUALIFIER by invoking
   muscle_user_name_list_grow.  */
void muscle_percent_code_grow (char const *qualifier, location qualifier_loc,
                               char const *code, location code_loc);

void muscles_m4_output (FILE *out);

#endif /* not MUSCLE_TAB_H_ */
Commit	Line	Data
	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_INSERTF(Key, Format, Value) \
	44	do { \
	45	obstack_printf (&muscle_obstack, Format, Value); \
	46	muscle_insert (Key, obstack_finish0 (&muscle_obstack)); \
	47	} while (0)
	48
	49	#define MUSCLE_INSERT_INT(Key, Value) \
	50	MUSCLE_INSERTF(Key, "%d", Value)
	51
	52	#define MUSCLE_INSERT_LONG_INT(Key, Value) \
	53	MUSCLE_INSERTF(Key, "%ld", Value)
	54
	55	/* Key -> Value, but don't apply escaping to Value. */
	56	#define MUSCLE_INSERT_STRING_RAW(Key, Value) \
	57	MUSCLE_INSERTF(Key, "%s", Value)
	58
	59	/* Key -> Value, applying M4 escaping to Value. */
	60	#define MUSCLE_INSERT_STRING(Key, Value) \
	61	do { \
	62	obstack_escape (&muscle_obstack, Value); \
	63	muscle_insert (Key, obstack_finish0 (&muscle_obstack)); \
	64	} while (0)
	65
	66	#define MUSCLE_INSERT_C_STRING(Key, Value) \
	67	do { \
	68	obstack_escape (&muscle_obstack, \
	69	quotearg_style (c_quoting_style, Value)); \
	70	muscle_insert (Key, obstack_finish0 (&muscle_obstack)); \
	71	} while (0)
	72
	73	/* Append VALUE to the current value of KEY. If KEY did not already
	74	exist, create it. Use MUSCLE_OBSTACK. De-allocate the previously
	75	associated value. Copy VALUE and SEPARATOR. */
	76
	77	void muscle_grow (const char key, const char value, const char *separator);
	78
	79
	80	/* Append VALUE to the current value of KEY, using muscle_grow. But
	81	in addition, issue a synchronization line for the location LOC. */
	82
	83	void muscle_code_grow (const char key, const char value, location loc);
	84
	85
	86	/* MUSCLE is an M4 list of pairs. Create or extend it with the pair
	87	(A1, A2) after escaping both values with digraphs. Note that because the
	88	muscle values are output double quoted, one needs to strip the first level
	89	of quotes to reach the list itself. */
	90	void muscle_pair_list_grow (const char *muscle,
	91	const char a1, const char a2);
	92
	93	/* Grow KEY for the occurrence of the name USER_NAME at LOC appropriately for
	94	use with b4_check_user_names in ../data/bison.m4. USER_NAME is not escaped
	95	with digraphs, so it must not contain `[' or `]'. */
	96	void muscle_user_name_list_grow (char const key, char const user_name,
	97	location loc);
	98
	99	/* Indicates whether a variable's value was specified with -D/--define, with
	100	-F/--force-define, or in the grammar file. */
	101	typedef enum {
	102	MUSCLE_PERCENT_DEFINE_D = 0, MUSCLE_PERCENT_DEFINE_F,
	103	MUSCLE_PERCENT_DEFINE_GRAMMAR_FILE
	104	} muscle_percent_define_how;
	105
	106	/* Define the muscles for %define variable VARIABLE with VALUE specified
	107	at VARIABLE_LOC in the manner HOW unless it was specified in the
	108	grammar file while the previous definition for VARIABLE was specified
	109	with -F/--force-define. Complain if a previous definition is being
	110	overridden and the new definition is specified in the grammar file.
	111	(These rules support the documented behavior as long as command-line
	112	definitions are processed before grammar file definitions.) Record
	113	this as a user occurrence of VARIABLE by invoking
	114	muscle_user_name_list_grow. */
	115	void muscle_percent_define_insert (char const *variable, location variable_loc,
	116	char const *value,
	117	muscle_percent_define_how how);
	118
	119	/* Make sure that VARIABLE is set to the boolean VALUE. Warn on mismatches
	120	only, but accept repeated declaration. Used for backward compatibility
	121	between old directives such as %pure-parser, and the recommended use of
	122	variables (%define api.pure). */
	123	void muscle_percent_define_ensure (char const *variable, location variable_loc,
	124	bool value);
	125
	126	/* Mimic b4_percent_define_get in ../data/bison.m4 exactly. That is, if the
	127	%define variable VARIABLE is defined, return its value. Otherwise, return
	128	the empty string. Also, record Bison's usage of VARIABLE by defining
	129	b4_percent_define_bison_variables(VARIABLE). The caller is responsible for
	130	freeing the memory of the returned string. */
	131	char muscle_percent_define_get (char const variable);
	132
	133	/* Mimic muscle_percent_define_get_loc in ../data/bison.m4 exactly. That is,
	134	if the %define variable VARIABLE is undefined, complain fatally since that's
	135	a Bison error. Otherwise, return its definition location in a form
	136	approriate for the first argument of warn_at, complain_at, or fatal_at.
	137	Don't record this as a Bison usage of VARIABLE as there's no reason to
	138	suspect that the user-supplied value has yet influenced the output. */
	139	location muscle_percent_define_get_loc (char const *variable);
	140
	141	/* Mimic muscle_percent_define_get_syncline in ../data/bison.m4 exactly. That
	142	is, if the %define variable VARIABLE is undefined, complain fatally since
	143	that's a Bison error. Otherwise, return its definition location as a
	144	b4_syncline invocation. Don't record this as a Bison usage of VARIABLE as
	145	there's no reason to suspect that the user-supplied value has yet influenced
	146	the output. */
	147	char const muscle_percent_define_get_syncline (char const variable);
	148
	149	/* Mimic b4_percent_define_ifdef in ../data/bison.m4 exactly. That is, if the
	150	%define variable VARIABLE is defined, return true. Otherwise, return false.
	151	Also, record Bison's usage of VARIABLE by defining
	152	b4_percent_define_bison_variables(VARIABLE). */
	153	bool muscle_percent_define_ifdef (char const *variable);
	154
	155	/* Mimic b4_percent_define_flag_if in ../data/bison.m4 exactly. That is, if
	156	the %define variable VARIABLE is defined to "" or "true", return true. If
	157	it is defined to "false", return false. Complain if it is undefined (a
	158	Bison error since the default value should have been set already) or defined
	159	to any other value (possibly a user error). Also, record Bison's usage of
	160	VARIABLE by defining b4_percent_define_bison_variables(VARIABLE). */
	161	bool muscle_percent_define_flag_if (char const *variable);
	162
	163	/* Mimic b4_percent_define_default in ../data/bison.m4 exactly. That is, if
	164	the %define variable VARIABLE is undefined, set its value to VALUE.
	165	Don't record this as a Bison usage of VARIABLE as there's no reason to
	166	suspect that the value has yet influenced the output. */
	167	void muscle_percent_define_default (char const variable, char const value);
	168
	169	/* Mimic b4_percent_define_check_values in ../data/bison.m4 exactly except that
	170	the VALUES structure is more appropriate for C. That is, VALUES points to a
	171	list of strings that is partitioned into sublists by NULL's, one terminating
	172	each sublist. The last sublist is followed by a second NULL. For each
	173	sublist, the first string is the name of a %define variable, and all
	174	remaining strings in that sublist are the valid values for that variable.
	175	Complain if such a variable is undefined (a Bison error since the default
	176	value should have been set already) or defined to any other value (possibly
	177	a user error). Don't record this as a Bison usage of the variable as
	178	there's no reason to suspect that the value has yet influenced the
	179	output. */
	180	void muscle_percent_define_check_values (char const * const *values);
	181
	182	/* Grow the muscle for the %code qualifier QUALIFIER appearing at
	183	QUALIFIER_LOC with code CODE appearing at CODE_LOC. Record this as a
	184	user occurrence of QUALIFIER by invoking
	185	muscle_user_name_list_grow. */
	186	void muscle_percent_code_grow (char const *qualifier, location qualifier_loc,
	187	char const *code, location code_loc);
	188
	189	void muscles_m4_output (FILE *out);
	190
	191	#endif /* not MUSCLE_TAB_H_ */