[bison.git] / src / muscle-tab.h

/* Muscle table manager for Bison,

   Copyright (C) 2001, 2002, 2003, 2006, 2007, 2008, 2009
   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 "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_INSERT_INT(Key, Value)				\
do {								\
  obstack_fgrow1 (&muscle_obstack, "%d", Value);		\
  obstack_1grow (&muscle_obstack, 0);				\
  muscle_insert (Key, obstack_finish (&muscle_obstack));	\
} while(0)

#define MUSCLE_INSERT_LONG_INT(Key, Value)			\
do {								\
  obstack_fgrow1 (&muscle_obstack, "%ld", Value);		\
  obstack_1grow (&muscle_obstack, 0);				\
  muscle_insert (Key, obstack_finish (&muscle_obstack));	\
} while(0)

/* Key -> Value, but don't apply escaping to Value. */
#define MUSCLE_INSERT_STRING_RAW(Key, Value)			\
do {								\
  obstack_sgrow (&muscle_obstack, Value);			\
  obstack_1grow (&muscle_obstack, 0);				\
  muscle_insert (Key, obstack_finish (&muscle_obstack));	\
} while(0)

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

#define MUSCLE_OBSTACK_SGROW(Obstack, Value)            \
do {                                                    \
  char const *p__;                                      \
  for (p__ = Value; *p__; p__++)                        \
    switch (*p__)                                       \
      {                                                 \
      case '$':	obstack_sgrow (Obstack, "$]["); break;  \
      case '@':	obstack_sgrow (Obstack, "@@" ); break;  \
      case '[':	obstack_sgrow (Obstack, "@{" ); break;  \
      case ']':	obstack_sgrow (Obstack, "@}" ); break;  \
      default: obstack_1grow (Obstack, *p__); break;    \
      }                                                 \
} while(0)

#define MUSCLE_INSERT_C_STRING(Key, Value)			\
do {								\
  MUSCLE_OBSTACK_SGROW (&muscle_obstack,			\
			quotearg_style (c_quoting_style,	\
					Value));		\
  obstack_1grow (&muscle_obstack, 0);				\
  muscle_insert (Key, obstack_finish (&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);

/* In the format `[[file_name:line.column]], [[file_name:line.column]]', append
   LOC to MUSCLE.  Use digraphs for special characters in each file name.  */
void muscle_location_grow (char const *key, location loc);

/* In the format `file_name:line.column', append BOUND to MUSCLE.  Use digraphs
   for special characters in the file name.  */
void muscle_boundary_grow (char const *key, boundary bound);

/* 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);

/* Define the muscle for the %define variable VARIABLE appearing at
   VARIABLE_LOC in the grammar file with value VALUE.  Warn if VARIABLE is
   already defined.  Record this as a grammar occurrence of VARIABLE by
   invoking muscle_user_name_list_grow.  */
void muscle_percent_define_insert (char const *variable, location variable_loc,
                                   char const *value);

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