src/system.h

/* System-dependent definitions for Bison.

   Copyright (C) 2000-2007, 2009-2012 Free Software Foundation, Inc.

   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 BISON_SYSTEM_H
#define BISON_SYSTEM_H

/* flex 2.5.31 gratutiously defines macros like INT8_MIN.  But this
   runs afoul of pre-C99 compilers that have <inttypes.h> or
   <stdint.h>, which are included below if available.  It also runs
   afoul of pre-C99 compilers that define these macros in <limits.h>.  */
#if ! defined __STDC_VERSION__ || __STDC_VERSION__ < 199901
# undef INT8_MIN
# undef INT16_MIN
# undef INT32_MIN
# undef INT8_MAX
# undef INT16_MAX
# undef UINT8_MAX
# undef INT32_MAX
# undef UINT16_MAX
# undef UINT32_MAX
#endif

#include <limits.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>

#define ARRAY_CARDINALITY(Array) (sizeof (Array) / sizeof *(Array))
#define STREQ(L, R)  (strcmp(L, R) == 0)
#define STRNEQ(L, R) (!STREQ(L, R))

/* Just like strncmp, but the second argument must be a literal string
   and you don't specify the length.  */
#define STRNCMP_LIT(S, Literal)                         \
  strncmp (S, "" Literal "", sizeof (Literal) - 1)

/* Whether Literal is a prefix of S.  */
#define STRPREFIX_LIT(Literal, S)               \
  (STRNCMP_LIT (S, Literal) == 0)

#include <unistd.h>
#include <inttypes.h>

#define ARRAY_CARDINALITY(Array) (sizeof (Array) / sizeof *(Array))
#define STREQ(L, R)  (strcmp(L, R) == 0)
#define STRNEQ(L, R) (!STREQ(L, R))

#ifndef UINTPTR_MAX
/* This isn't perfect, but it's good enough for Bison, which needs
   only to hash pointers.  */
typedef size_t uintptr_t;
#endif

// Version mismatch.
#define EX_MISMATCH 63

/*---------.
| Gnulib.  |
`---------*/

#include <unlocked-io.h>
#include <verify.h>
#include <xalloc.h>


/*-----------------.
| GCC extensions.  |
`-----------------*/

/* Use PACIFY_CC to indicate that Code is unimportant to the logic of Bison
   but that it is necessary for suppressing compiler warnings.  For example,
   Code might be a variable initializer that's always overwritten before the
   variable is used.

   PACIFY_CC is intended to be useful only as a comment as it does not alter
   Code.  It is tempting to redefine PACIFY_CC so that it will suppress Code
   when configuring without --enable-gcc-warnings.  However, that would mean
   that, for maintainers, Bison would compile with potentially less warnings
   and safer logic than it would for users.  Due to the overhead of M4,
   suppressing Code is unlikely to offer any significant improvement in
   Bison's performance anyway.  */
#define PACIFY_CC(Code) Code

#ifndef __attribute__
/* This feature is available in gcc versions 2.5 and later.  */
# if (! defined __GNUC__ || __GNUC__ < 2 \
       || (__GNUC__ == 2 && __GNUC_MINOR__ < 5))
#  define __attribute__(Spec) /* empty */
# endif
#endif

/* The __-protected variants of `format' and `printf' attributes
   are accepted by gcc versions 2.6.4 (effectively 2.7) and later.  */
#if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 7)
# define __format__ format
# define __printf__ printf
#endif

#ifndef ATTRIBUTE_NORETURN
# define ATTRIBUTE_NORETURN __attribute__ ((__noreturn__))
#endif

#ifndef ATTRIBUTE_UNUSED
# define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
#endif


/*------.
| NLS.  |
`------*/

#include <locale.h>

#include <gettext.h>
#define _(Msgid)  gettext (Msgid)
#define N_(Msgid) (Msgid)


/*-----------.
| Booleans.  |
`-----------*/

#include <stdbool.h>


/*-------------.
| Assertions.  |
`-------------*/

/* In the past, Bison defined aver to simply invoke abort in the case of
   a failed assertion.  The rationale was that <assert.h>'s assertions
   were too heavyweight and could be disabled too easily.  See
   discussions at
   <http://lists.gnu.org/archive/html/bison-patches/2006-01/msg00080.html>
   <http://lists.gnu.org/archive/html/bison-patches/2006-09/msg00111.html>.

   However, normal assert output can be helpful during development and
   in bug reports from users.  Moreover, it's not clear now that
   <assert.h>'s assertions are significantly heavyweight.  Finally, if
   users want to experiment with disabling assertions, it's debatable
   whether it's our responsibility to stop them.  See discussion
   starting at
   <http://lists.gnu.org/archive/html/bison-patches/2009-09/msg00013.html>.

   For now, we use assert but we call it aver throughout Bison in case
   we later wish to try another scheme.
*/
#include <assert.h>
#define aver assert


/*-----------.
| Obstacks.  |
`-----------*/

#define obstack_chunk_alloc xmalloc
#define obstack_chunk_free  free
#include <obstack.h>

/* String-grow: append Str to Obs.  */

#define obstack_sgrow(Obs, Str) \
  obstack_grow (Obs, Str, strlen (Str))

/* Output Str escaped for our postprocessing (i.e., escape M4 special
   characters).

   For instance "[foo]" -> "@{foo@}", "$$" -> "$][$][". */

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


/* Output Str both quoted for M4 (i.e., embed in [[...]]), and escaped
   for our postprocessing (i.e., escape M4 special characters).  If
   Str is empty (or NULL), output "[]" instead of "[[]]" as it make M4
   programming easier (m4_ifval can be used).

   For instance "[foo]" -> "[[@{foo@}]]", "$$" -> "[[$][$][]]". */

# define obstack_quote(Obs, Str)                \
  do {                                          \
    char const* obstack_quote_p = Str;          \
    if (obstack_quote_p && obstack_quote_p[0])  \
      {                                         \
        obstack_sgrow (Obs, "[[");              \
        obstack_escape (Obs, obstack_quote_p);  \
        obstack_sgrow (Obs, "]]");              \
      }                                         \
    else                                        \
      obstack_sgrow (Obs, "[]");                \
  } while (0)


/* Append the ending 0, finish Obs, and return the string.  */

# define obstack_finish0(Obs)                           \
  (obstack_1grow (Obs, '\0'), (char *) obstack_finish (Obs))


/*-----------------------------------------.
| Extensions to use for the output files.  |
`-----------------------------------------*/

#ifndef OUTPUT_EXT
# define OUTPUT_EXT ".output"
#endif

#ifndef TAB_EXT
# define TAB_EXT ".tab"
#endif


/*---------------------.
| Free a linked list.  |
`---------------------*/

#define LIST_FREE(Type, List)                   \
do {                                            \
  Type *_node, *_next;                          \
  for (_node = List; _node; _node = _next)      \
    {                                           \
      _next = _node->next;                      \
      free (_node);                             \
    }                                           \
} while (0)


/*---------------------------------------------.
| Debugging memory allocation (must be last).  |
`---------------------------------------------*/

# if WITH_DMALLOC
#  define DMALLOC_FUNC_CHECK
#  include <dmalloc.h>
# endif /* WITH_DMALLOC */

#endif  /* ! BISON_SYSTEM_H */
Commit	Line	Data
	1	/* System-dependent definitions for Bison.
	2
	3	Copyright (C) 2000-2007, 2009-2012 Free Software Foundation, Inc.
	4
	5	This program is free software: you can redistribute it and/or modify
	6	it under the terms of the GNU General Public License as published by
	7	the Free Software Foundation, either version 3 of the License, or
	8	(at your option) any later version.
	9
	10	This program is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	GNU General Public License for more details.
	14
	15	You should have received a copy of the GNU General Public License
	16	along with this program. If not, see <http://www.gnu.org/licenses/>. */
	17
	18	#ifndef BISON_SYSTEM_H
	19	#define BISON_SYSTEM_H
	20
	21	/* flex 2.5.31 gratutiously defines macros like INT8_MIN. But this
	22	runs afoul of pre-C99 compilers that have <inttypes.h> or
	23	<stdint.h>, which are included below if available. It also runs
	24	afoul of pre-C99 compilers that define these macros in <limits.h>. */
	25	#if ! defined __STDC_VERSION__ \|\| __STDC_VERSION__ < 199901
	26	# undef INT8_MIN
	27	# undef INT16_MIN
	28	# undef INT32_MIN
	29	# undef INT8_MAX
	30	# undef INT16_MAX
	31	# undef UINT8_MAX
	32	# undef INT32_MAX
	33	# undef UINT16_MAX
	34	# undef UINT32_MAX
	35	#endif
	36
	37	#include <limits.h>
	38	#include <stddef.h>
	39	#include <stdlib.h>
	40	#include <string.h>
	41
	42	#define ARRAY_CARDINALITY(Array) (sizeof (Array) / sizeof *(Array))
	43	#define STREQ(L, R) (strcmp(L, R) == 0)
	44	#define STRNEQ(L, R) (!STREQ(L, R))
	45
	46	/* Just like strncmp, but the second argument must be a literal string
	47	and you don't specify the length. */
	48	#define STRNCMP_LIT(S, Literal) \
	49	strncmp (S, "" Literal "", sizeof (Literal) - 1)
	50
	51	/* Whether Literal is a prefix of S. */
	52	#define STRPREFIX_LIT(Literal, S) \
	53	(STRNCMP_LIT (S, Literal) == 0)
	54
	55	#include <unistd.h>
	56	#include <inttypes.h>
	57
	58	#define ARRAY_CARDINALITY(Array) (sizeof (Array) / sizeof *(Array))
	59	#define STREQ(L, R) (strcmp(L, R) == 0)
	60	#define STRNEQ(L, R) (!STREQ(L, R))
	61
	62	#ifndef UINTPTR_MAX
	63	/* This isn't perfect, but it's good enough for Bison, which needs
	64	only to hash pointers. */
	65	typedef size_t uintptr_t;
	66	#endif
	67
	68	// Version mismatch.
	69	#define EX_MISMATCH 63
	70
	71	/*---------.
	72	\| Gnulib. \|
	73	`---------*/
	74
	75	#include <unlocked-io.h>
	76	#include <verify.h>
	77	#include <xalloc.h>
	78
	79
	80	/*-----------------.
	81	\| GCC extensions. \|
	82	`-----------------*/
	83
	84	/* Use PACIFY_CC to indicate that Code is unimportant to the logic of Bison
	85	but that it is necessary for suppressing compiler warnings. For example,
	86	Code might be a variable initializer that's always overwritten before the
	87	variable is used.
	88
	89	PACIFY_CC is intended to be useful only as a comment as it does not alter
	90	Code. It is tempting to redefine PACIFY_CC so that it will suppress Code
	91	when configuring without --enable-gcc-warnings. However, that would mean
	92	that, for maintainers, Bison would compile with potentially less warnings
	93	and safer logic than it would for users. Due to the overhead of M4,
	94	suppressing Code is unlikely to offer any significant improvement in
	95	Bison's performance anyway. */
	96	#define PACIFY_CC(Code) Code
	97
	98	#ifndef __attribute__
	99	/* This feature is available in gcc versions 2.5 and later. */
	100	# if (! defined __GNUC__ \|\| __GNUC__ < 2 \
	101	\|\| (__GNUC__ == 2 && __GNUC_MINOR__ < 5))
	102	# define __attribute__(Spec) /* empty */
	103	# endif
	104	#endif
	105
	106	/* The __-protected variants of `format' and `printf' attributes
	107	are accepted by gcc versions 2.6.4 (effectively 2.7) and later. */
	108	#if __GNUC__ < 2 \|\| (__GNUC__ == 2 && __GNUC_MINOR__ < 7)
	109	# define __format__ format
	110	# define __printf__ printf
	111	#endif
	112
	113	#ifndef ATTRIBUTE_NORETURN
	114	# define ATTRIBUTE_NORETURN __attribute__ ((__noreturn__))
	115	#endif
	116
	117	#ifndef ATTRIBUTE_UNUSED
	118	# define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
	119	#endif
	120
	121
	122	/*------.
	123	\| NLS. \|
	124	`------*/
	125
	126	#include <locale.h>
	127
	128	#include <gettext.h>
	129	#define _(Msgid) gettext (Msgid)
	130	#define N_(Msgid) (Msgid)
	131
	132
	133	/*-----------.
	134	\| Booleans. \|
	135	`-----------*/
	136
	137	#include <stdbool.h>
	138
	139
	140
	141	/*-------------.
	142	\| Assertions. \|
	143	`-------------*/
	144
	145	/* In the past, Bison defined aver to simply invoke abort in the case of
	146	a failed assertion. The rationale was that <assert.h>'s assertions
	147	were too heavyweight and could be disabled too easily. See
	148	discussions at
	149	<http://lists.gnu.org/archive/html/bison-patches/2006-01/msg00080.html>
	150	<http://lists.gnu.org/archive/html/bison-patches/2006-09/msg00111.html>.
	151
	152	However, normal assert output can be helpful during development and
	153	in bug reports from users. Moreover, it's not clear now that
	154	<assert.h>'s assertions are significantly heavyweight. Finally, if
	155	users want to experiment with disabling assertions, it's debatable
	156	whether it's our responsibility to stop them. See discussion
	157	starting at
	158	<http://lists.gnu.org/archive/html/bison-patches/2009-09/msg00013.html>.
	159
	160	For now, we use assert but we call it aver throughout Bison in case
	161	we later wish to try another scheme.
	162	*/
	163	#include <assert.h>
	164	#define aver assert
	165
	166
	167	/*-----------.
	168	\| Obstacks. \|
	169	`-----------*/
	170
	171	#define obstack_chunk_alloc xmalloc
	172	#define obstack_chunk_free free
	173	#include <obstack.h>
	174
	175	/* String-grow: append Str to Obs. */
	176
	177	#define obstack_sgrow(Obs, Str) \
	178	obstack_grow (Obs, Str, strlen (Str))
	179
	180	/* Output Str escaped for our postprocessing (i.e., escape M4 special
	181	characters).
	182
	183	For instance "[foo]" -> "@{foo@}", "$$" -> "$][$][". */
	184
	185	# define obstack_escape(Obs, Str) \
	186	do { \
	187	char const *p__; \
	188	for (p__ = Str; *p__; p__++) \
	189	switch (*p__) \
	190	{ \
	191	case '$': obstack_sgrow (Obs, "$]["); break; \
	192	case '@': obstack_sgrow (Obs, "@@" ); break; \
	193	case '[': obstack_sgrow (Obs, "@{" ); break; \
	194	case ']': obstack_sgrow (Obs, "@}" ); break; \
	195	default: obstack_1grow (Obs, *p__ ); break; \
	196	} \
	197	} while (0)
	198
	199
	200	/* Output Str both quoted for M4 (i.e., embed in [[...]]), and escaped
	201	for our postprocessing (i.e., escape M4 special characters). If
	202	Str is empty (or NULL), output "[]" instead of "[[]]" as it make M4
	203	programming easier (m4_ifval can be used).
	204
	205	For instance "[foo]" -> "[[@{foo@}]]", "$$" -> "[[$][$][]]". */
	206
	207	# define obstack_quote(Obs, Str) \
	208	do { \
	209	char const* obstack_quote_p = Str; \
	210	if (obstack_quote_p && obstack_quote_p[0]) \
	211	{ \
	212	obstack_sgrow (Obs, "[["); \
	213	obstack_escape (Obs, obstack_quote_p); \
	214	obstack_sgrow (Obs, "]]"); \
	215	} \
	216	else \
	217	obstack_sgrow (Obs, "[]"); \
	218	} while (0)
	219
	220
	221	/* Append the ending 0, finish Obs, and return the string. */
	222
	223	# define obstack_finish0(Obs) \
	224	(obstack_1grow (Obs, '\0'), (char *) obstack_finish (Obs))
	225
	226
	227	/*-----------------------------------------.
	228	\| Extensions to use for the output files. \|
	229	`-----------------------------------------*/
	230
	231	#ifndef OUTPUT_EXT
	232	# define OUTPUT_EXT ".output"
	233	#endif
	234
	235	#ifndef TAB_EXT
	236	# define TAB_EXT ".tab"
	237	#endif
	238
	239
	240
	241	/*---------------------.
	242	\| Free a linked list. \|
	243	`---------------------*/
	244
	245	#define LIST_FREE(Type, List) \
	246	do { \
	247	Type _node, _next; \
	248	for (_node = List; _node; _node = _next) \
	249	{ \
	250	_next = _node->next; \
	251	free (_node); \
	252	} \
	253	} while (0)
	254
	255
	256	/*---------------------------------------------.
	257	\| Debugging memory allocation (must be last). \|
	258	`---------------------------------------------*/
	259
	260	# if WITH_DMALLOC
	261	# define DMALLOC_FUNC_CHECK
	262	# include <dmalloc.h>
	263	# endif /* WITH_DMALLOC */
	264
	265	#endif /* ! BISON_SYSTEM_H */