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

/* Muscle table manager for Bison,
   Copyright (C) 2001-2003, 2006-2007, 2009-2010 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)

#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)

#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);

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

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