[deliverable/binutils-gdb.git] / include / ansidecl.h

/* ANSI and traditional C compatability macros
   Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
   2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010
   Free Software Foundation, Inc.
   This file is part of the GNU C Library.

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 2 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, write to the Free Software
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */

/* ANSI and traditional C compatibility macros

   ANSI C is assumed if __STDC__ is #defined.

   Macro		ANSI C definition	Traditional C definition
   -----		---- - ----------	----------- - ----------
   ANSI_PROTOTYPES	1			not defined
   PTR			`void *'		`char *'
   PTRCONST		`void *const'		`char *'
   LONG_DOUBLE		`long double'		`double'
   const		not defined		`'
   volatile		not defined		`'
   signed		not defined		`'
   VA_START(ap, var)	va_start(ap, var)	va_start(ap)

   Note that it is safe to write "void foo();" indicating a function
   with no return value, in all K+R compilers we have been able to test.

   For declaring functions with prototypes, we also provide these:

   PARAMS ((prototype))
   -- for functions which take a fixed number of arguments.  Use this
   when declaring the function.  When defining the function, write a
   K+R style argument list.  For example:

	char *strcpy PARAMS ((char *dest, char *source));
	...
	char *
	strcpy (dest, source)
	     char *dest;
	     char *source;
	{ ... }


   VPARAMS ((prototype, ...))
   -- for functions which take a variable number of arguments.  Use
   PARAMS to declare the function, VPARAMS to define it.  For example:

	int printf PARAMS ((const char *format, ...));
	...
	int
	printf VPARAMS ((const char *format, ...))
	{
	   ...
	}

   For writing functions which take variable numbers of arguments, we
   also provide the VA_OPEN, VA_CLOSE, and VA_FIXEDARG macros.  These
   hide the differences between K+R <varargs.h> and C89 <stdarg.h> more
   thoroughly than the simple VA_START() macro mentioned above.

   VA_OPEN and VA_CLOSE are used *instead of* va_start and va_end.
   Immediately after VA_OPEN, put a sequence of VA_FIXEDARG calls
   corresponding to the list of fixed arguments.  Then use va_arg
   normally to get the variable arguments, or pass your va_list object
   around.  You do not declare the va_list yourself; VA_OPEN does it
   for you.

   Here is a complete example:

	int
	printf VPARAMS ((const char *format, ...))
	{
	   int result;

	   VA_OPEN (ap, format);
	   VA_FIXEDARG (ap, const char *, format);

	   result = vfprintf (stdout, format, ap);
	   VA_CLOSE (ap);

	   return result;
	}


   You can declare variables either before or after the VA_OPEN,
   VA_FIXEDARG sequence.  Also, VA_OPEN and VA_CLOSE are the beginning
   and end of a block.  They must appear at the same nesting level,
   and any variables declared after VA_OPEN go out of scope at
   VA_CLOSE.  Unfortunately, with a K+R compiler, that includes the
   argument list.  You can have multiple instances of VA_OPEN/VA_CLOSE
   pairs in a single function in case you need to traverse the
   argument list more than once.

   For ease of writing code which uses GCC extensions but needs to be
   portable to other compilers, we provide the GCC_VERSION macro that
   simplifies testing __GNUC__ and __GNUC_MINOR__ together, and various
   wrappers around __attribute__.  Also, __extension__ will be #defined
   to nothing if it doesn't work.  See below.

   This header also defines a lot of obsolete macros:
   CONST, VOLATILE, SIGNED, PROTO, EXFUN, DEFUN, DEFUN_VOID,
   AND, DOTS, NOARGS.  Don't use them.  */

#ifndef	_ANSIDECL_H
#define _ANSIDECL_H	1

#ifdef __cplusplus
extern "C" {
#endif

/* Every source file includes this file,
   so they will all get the switch for lint.  */
/* LINTLIBRARY */

/* Using MACRO(x,y) in cpp #if conditionals does not work with some
   older preprocessors.  Thus we can't define something like this:

#define HAVE_GCC_VERSION(MAJOR, MINOR) \
  (__GNUC__ > (MAJOR) || (__GNUC__ == (MAJOR) && __GNUC_MINOR__ >= (MINOR)))

and then test "#if HAVE_GCC_VERSION(2,7)".

So instead we use the macro below and test it against specific values.  */

/* This macro simplifies testing whether we are using gcc, and if it
   is of a particular minimum version. (Both major & minor numbers are
   significant.)  This macro will evaluate to 0 if we are not using
   gcc at all.  */
#ifndef GCC_VERSION
#define GCC_VERSION (__GNUC__ * 1000 + __GNUC_MINOR__)
#endif /* GCC_VERSION */

#if defined (__STDC__) || defined(__cplusplus) || defined (_AIX) || (defined (__mips) && defined (_SYSTYPE_SVR4)) || defined(_WIN32)
/* All known AIX compilers implement these things (but don't always
   define __STDC__).  The RISC/OS MIPS compiler defines these things
   in SVR4 mode, but does not define __STDC__.  */
/* eraxxon@alumni.rice.edu: The Compaq C++ compiler, unlike many other
   C++ compilers, does not define __STDC__, though it acts as if this
   was so. (Verified versions: 5.7, 6.2, 6.3, 6.5) */

#define ANSI_PROTOTYPES	1
#define PTR		void *
#define PTRCONST	void *const
#define LONG_DOUBLE	long double

/* PARAMS is often defined elsewhere (e.g. by libintl.h), so wrap it in
   a #ifndef.  */
#ifndef PARAMS
#define PARAMS(ARGS)		ARGS
#endif

#define VPARAMS(ARGS)		ARGS
#define VA_START(VA_LIST, VAR)	va_start(VA_LIST, VAR)

/* variadic function helper macros */
/* "struct Qdmy" swallows the semicolon after VA_OPEN/VA_FIXEDARG's
   use without inhibiting further decls and without declaring an
   actual variable.  */
#define VA_OPEN(AP, VAR)	{ va_list AP; va_start(AP, VAR); { struct Qdmy
#define VA_CLOSE(AP)		} va_end(AP); }
#define VA_FIXEDARG(AP, T, N)	struct Qdmy
 
#undef const
#undef volatile
#undef signed

/* inline requires special treatment; it's in C99, and GCC >=2.7 supports
   it too, but it's not in C89.  */
#undef inline
#if __STDC_VERSION__ >= 199901L || defined(__cplusplus) || (defined(__SUNPRO_C) && defined(__C99FEATURES__))
/* it's a keyword */
#else
# if GCC_VERSION >= 2007
#  define inline __inline__   /* __inline__ prevents -pedantic warnings */
# else
#  define inline  /* nothing */
# endif
#endif

/* These are obsolete.  Do not use.  */
#ifndef IN_GCC
#define CONST		const
#define VOLATILE	volatile
#define SIGNED		signed

#define PROTO(type, name, arglist)	type name arglist
#define EXFUN(name, proto)		name proto
#define DEFUN(name, arglist, args)	name(args)
#define DEFUN_VOID(name)		name(void)
#define AND		,
#define DOTS		, ...
#define NOARGS		void
#endif /* ! IN_GCC */

#else	/* Not ANSI C.  */

#undef  ANSI_PROTOTYPES
#define PTR		char *
#define PTRCONST	PTR
#define LONG_DOUBLE	double

#define PARAMS(args)		()
#define VPARAMS(args)		(va_alist) va_dcl
#define VA_START(va_list, var)	va_start(va_list)

#define VA_OPEN(AP, VAR)		{ va_list AP; va_start(AP); { struct Qdmy
#define VA_CLOSE(AP)			} va_end(AP); }
#define VA_FIXEDARG(AP, TYPE, NAME)	TYPE NAME = va_arg(AP, TYPE)

/* some systems define these in header files for non-ansi mode */
#undef const
#undef volatile
#undef signed
#undef inline
#define const
#define volatile
#define signed
#define inline

#ifndef IN_GCC
#define CONST
#define VOLATILE
#define SIGNED

#define PROTO(type, name, arglist)	type name ()
#define EXFUN(name, proto)		name()
#define DEFUN(name, arglist, args)	name arglist args;
#define DEFUN_VOID(name)		name()
#define AND		;
#define DOTS
#define NOARGS
#endif /* ! IN_GCC */

#endif	/* ANSI C.  */

/* Define macros for some gcc attributes.  This permits us to use the
   macros freely, and know that they will come into play for the
   version of gcc in which they are supported.  */

#if (GCC_VERSION < 2007)
# define __attribute__(x)
#endif

/* Attribute __malloc__ on functions was valid as of gcc 2.96. */
#ifndef ATTRIBUTE_MALLOC
# if (GCC_VERSION >= 2096)
#  define ATTRIBUTE_MALLOC __attribute__ ((__malloc__))
# else
#  define ATTRIBUTE_MALLOC
# endif /* GNUC >= 2.96 */
#endif /* ATTRIBUTE_MALLOC */

/* Attributes on labels were valid as of gcc 2.93 and g++ 4.5.  For
   g++ an attribute on a label must be followed by a semicolon.  */
#ifndef ATTRIBUTE_UNUSED_LABEL
# ifndef __cplusplus
#  if GCC_VERSION >= 2093
#   define ATTRIBUTE_UNUSED_LABEL ATTRIBUTE_UNUSED
#  else
#   define ATTRIBUTE_UNUSED_LABEL
#  endif
# else
#  if GCC_VERSION >= 4005
#   define ATTRIBUTE_UNUSED_LABEL ATTRIBUTE_UNUSED ;
#  else
#   define ATTRIBUTE_UNUSED_LABEL
#  endif
# endif
#endif

/* Similarly to ARG_UNUSED below.  Prior to GCC 3.4, the C++ frontend
   couldn't parse attributes placed after the identifier name, and now
   the entire compiler is built with C++.  */
#ifndef ATTRIBUTE_UNUSED
#if GCC_VERSION >= 3004
#  define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
#else
#define ATTRIBUTE_UNUSED
#endif
#endif /* ATTRIBUTE_UNUSED */

/* Before GCC 3.4, the C++ frontend couldn't parse attributes placed after the
   identifier name.  */
#if ! defined(__cplusplus) || (GCC_VERSION >= 3004)
# define ARG_UNUSED(NAME) NAME ATTRIBUTE_UNUSED
#else /* !__cplusplus || GNUC >= 3.4 */
# define ARG_UNUSED(NAME) NAME
#endif /* !__cplusplus || GNUC >= 3.4 */

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

/* Attribute `nonnull' was valid as of gcc 3.3.  */
#ifndef ATTRIBUTE_NONNULL
# if (GCC_VERSION >= 3003)
#  define ATTRIBUTE_NONNULL(m) __attribute__ ((__nonnull__ (m)))
# else
#  define ATTRIBUTE_NONNULL(m)
# endif /* GNUC >= 3.3 */
#endif /* ATTRIBUTE_NONNULL */

/* Attribute `returns_nonnull' was valid as of gcc 4.9.  */
#ifndef ATTRIBUTE_RETURNS_NONNULL
# if (GCC_VERSION >= 4009)
#  define ATTRIBUTE_RETURNS_NONNULL __attribute__ ((__returns_nonnull__))
# else
#  define ATTRIBUTE_RETURNS_NONNULL
# endif /* GNUC >= 4.9 */
#endif /* ATTRIBUTE_RETURNS_NONNULL */

/* Attribute `pure' was valid as of gcc 3.0.  */
#ifndef ATTRIBUTE_PURE
# if (GCC_VERSION >= 3000)
#  define ATTRIBUTE_PURE __attribute__ ((__pure__))
# else
#  define ATTRIBUTE_PURE
# endif /* GNUC >= 3.0 */
#endif /* ATTRIBUTE_PURE */

/* Use ATTRIBUTE_PRINTF when the format specifier must not be NULL.
   This was the case for the `printf' format attribute by itself
   before GCC 3.3, but as of 3.3 we need to add the `nonnull'
   attribute to retain this behavior.  */
#ifndef ATTRIBUTE_PRINTF
#define ATTRIBUTE_PRINTF(m, n) __attribute__ ((__format__ (__printf__, m, n))) ATTRIBUTE_NONNULL(m)
#define ATTRIBUTE_PRINTF_1 ATTRIBUTE_PRINTF(1, 2)
#define ATTRIBUTE_PRINTF_2 ATTRIBUTE_PRINTF(2, 3)
#define ATTRIBUTE_PRINTF_3 ATTRIBUTE_PRINTF(3, 4)
#define ATTRIBUTE_PRINTF_4 ATTRIBUTE_PRINTF(4, 5)
#define ATTRIBUTE_PRINTF_5 ATTRIBUTE_PRINTF(5, 6)
#endif /* ATTRIBUTE_PRINTF */

/* Use ATTRIBUTE_FPTR_PRINTF when the format attribute is to be set on
   a function pointer.  Format attributes were allowed on function
   pointers as of gcc 3.1.  */
#ifndef ATTRIBUTE_FPTR_PRINTF
# if (GCC_VERSION >= 3001)
#  define ATTRIBUTE_FPTR_PRINTF(m, n) ATTRIBUTE_PRINTF(m, n)
# else
#  define ATTRIBUTE_FPTR_PRINTF(m, n)
# endif /* GNUC >= 3.1 */
# define ATTRIBUTE_FPTR_PRINTF_1 ATTRIBUTE_FPTR_PRINTF(1, 2)
# define ATTRIBUTE_FPTR_PRINTF_2 ATTRIBUTE_FPTR_PRINTF(2, 3)
# define ATTRIBUTE_FPTR_PRINTF_3 ATTRIBUTE_FPTR_PRINTF(3, 4)
# define ATTRIBUTE_FPTR_PRINTF_4 ATTRIBUTE_FPTR_PRINTF(4, 5)
# define ATTRIBUTE_FPTR_PRINTF_5 ATTRIBUTE_FPTR_PRINTF(5, 6)
#endif /* ATTRIBUTE_FPTR_PRINTF */

/* Use ATTRIBUTE_NULL_PRINTF when the format specifier may be NULL.  A
   NULL format specifier was allowed as of gcc 3.3.  */
#ifndef ATTRIBUTE_NULL_PRINTF
# if (GCC_VERSION >= 3003)
#  define ATTRIBUTE_NULL_PRINTF(m, n) __attribute__ ((__format__ (__printf__, m, n)))
# else
#  define ATTRIBUTE_NULL_PRINTF(m, n)
# endif /* GNUC >= 3.3 */
# define ATTRIBUTE_NULL_PRINTF_1 ATTRIBUTE_NULL_PRINTF(1, 2)
# define ATTRIBUTE_NULL_PRINTF_2 ATTRIBUTE_NULL_PRINTF(2, 3)
# define ATTRIBUTE_NULL_PRINTF_3 ATTRIBUTE_NULL_PRINTF(3, 4)
# define ATTRIBUTE_NULL_PRINTF_4 ATTRIBUTE_NULL_PRINTF(4, 5)
# define ATTRIBUTE_NULL_PRINTF_5 ATTRIBUTE_NULL_PRINTF(5, 6)
#endif /* ATTRIBUTE_NULL_PRINTF */

/* Attribute `sentinel' was valid as of gcc 3.5.  */
#ifndef ATTRIBUTE_SENTINEL
# if (GCC_VERSION >= 3005)
#  define ATTRIBUTE_SENTINEL __attribute__ ((__sentinel__))
# else
#  define ATTRIBUTE_SENTINEL
# endif /* GNUC >= 3.5 */
#endif /* ATTRIBUTE_SENTINEL */


#ifndef ATTRIBUTE_ALIGNED_ALIGNOF
# if (GCC_VERSION >= 3000)
#  define ATTRIBUTE_ALIGNED_ALIGNOF(m) __attribute__ ((__aligned__ (__alignof__ (m))))
# else
#  define ATTRIBUTE_ALIGNED_ALIGNOF(m)
# endif /* GNUC >= 3.0 */
#endif /* ATTRIBUTE_ALIGNED_ALIGNOF */

/* Useful for structures whose layout must much some binary specification
   regardless of the alignment and padding qualities of the compiler.  */
#ifndef ATTRIBUTE_PACKED
# define ATTRIBUTE_PACKED __attribute__ ((packed))
#endif

/* Attribute `hot' and `cold' was valid as of gcc 4.3.  */
#ifndef ATTRIBUTE_COLD
# if (GCC_VERSION >= 4003)
#  define ATTRIBUTE_COLD __attribute__ ((__cold__))
# else
#  define ATTRIBUTE_COLD
# endif /* GNUC >= 4.3 */
#endif /* ATTRIBUTE_COLD */
#ifndef ATTRIBUTE_HOT
# if (GCC_VERSION >= 4003)
#  define ATTRIBUTE_HOT __attribute__ ((__hot__))
# else
#  define ATTRIBUTE_HOT
# endif /* GNUC >= 4.3 */
#endif /* ATTRIBUTE_HOT */

/* We use __extension__ in some places to suppress -pedantic warnings
   about GCC extensions.  This feature didn't work properly before
   gcc 2.8.  */
#if GCC_VERSION < 2008
#define __extension__
#endif

/* This is used to declare a const variable which should be visible
   outside of the current compilation unit.  Use it as
     EXPORTED_CONST int i = 1;
   This is because the semantics of const are different in C and C++.
   "extern const" is permitted in C but it looks strange, and gcc
   warns about it when -Wc++-compat is not used.  */
#ifdef __cplusplus
#define EXPORTED_CONST extern const
#else
#define EXPORTED_CONST const
#endif

/* Be conservative and only use enum bitfields with C++ or GCC.
   FIXME: provide a complete autoconf test for buggy enum bitfields.  */

#ifdef __cplusplus
#define ENUM_BITFIELD(TYPE) enum TYPE
#elif (GCC_VERSION > 2000)
#define ENUM_BITFIELD(TYPE) __extension__ enum TYPE
#else
#define ENUM_BITFIELD(TYPE) unsigned int
#endif

#ifdef __cplusplus
}
#endif

#endif	/* ansidecl.h	*/
Commit	Line	Data
252b5132	1	/* ANSI and traditional C compatability macros
52d6785f	2	Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
43e85a8f	3	2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010
4f1d9bd8	4	Free Software Foundation, Inc.
252b5132 RH	5	This file is part of the GNU C Library.
	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 2 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, write to the Free Software
e172dbf8	19	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
252b5132 RH	20
	21	/* ANSI and traditional C compatibility macros
	22
	23	ANSI C is assumed if __STDC__ is #defined.
	24
562c4c36 DD	25	Macro ANSI C definition Traditional C definition
	26	----- ---- - ---------- ----------- - ----------
	27	ANSI_PROTOTYPES 1 not defined
	28	PTR `void ' `char '
	29	PTRCONST `void const' `char '
	30	LONG_DOUBLE `long double' `double'
	31	const not defined `'
	32	volatile not defined `'
	33	signed not defined `'
	34	VA_START(ap, var) va_start(ap, var) va_start(ap)
	35
	36	Note that it is safe to write "void foo();" indicating a function
	37	with no return value, in all K+R compilers we have been able to test.
	38
	39	For declaring functions with prototypes, we also provide these:
	40
	41	PARAMS ((prototype))
	42	-- for functions which take a fixed number of arguments. Use this
	43	when declaring the function. When defining the function, write a
	44	K+R style argument list. For example:
	45
	46	char strcpy PARAMS ((char dest, char *source));
	47	...
	48	char *
	49	strcpy (dest, source)
	50	char *dest;
	51	char *source;
	52	{ ... }
	53
	54
	55	VPARAMS ((prototype, ...))
	56	-- for functions which take a variable number of arguments. Use
	57	PARAMS to declare the function, VPARAMS to define it. For example:
	58
	59	int printf PARAMS ((const char *format, ...));
	60	...
	61	int
	62	printf VPARAMS ((const char *format, ...))
	63	{
	64	...
	65	}
	66
	67	For writing functions which take variable numbers of arguments, we
	68	also provide the VA_OPEN, VA_CLOSE, and VA_FIXEDARG macros. These
	69	hide the differences between K+R <varargs.h> and C89 <stdarg.h> more
	70	thoroughly than the simple VA_START() macro mentioned above.
	71
	72	VA_OPEN and VA_CLOSE are used instead of va_start and va_end.
	73	Immediately after VA_OPEN, put a sequence of VA_FIXEDARG calls
	74	corresponding to the list of fixed arguments. Then use va_arg
	75	normally to get the variable arguments, or pass your va_list object
	76	around. You do not declare the va_list yourself; VA_OPEN does it
	77	for you.
	78
	79	Here is a complete example:
	80
	81	int
	82	printf VPARAMS ((const char *format, ...))
	83	{
	84	int result;
	85
	86	VA_OPEN (ap, format);
	87	VA_FIXEDARG (ap, const char *, format);
	88
89	result = vfprintf (stdout, format, ap);
90	VA_CLOSE (ap);
91
92	return result;
93	}
94
95
96	You can declare variables either before or after the VA_OPEN,
f2e55dc2 DD	97	VA_FIXEDARG sequence. Also, VA_OPEN and VA_CLOSE are the beginning
	98	and end of a block. They must appear at the same nesting level,
	99	and any variables declared after VA_OPEN go out of scope at
	100	VA_CLOSE. Unfortunately, with a K+R compiler, that includes the
	101	argument list. You can have multiple instances of VA_OPEN/VA_CLOSE
	102	pairs in a single function in case you need to traverse the
	103	argument list more than once.
562c4c36 DD	104
	105	For ease of writing code which uses GCC extensions but needs to be
	106	portable to other compilers, we provide the GCC_VERSION macro that
	107	simplifies testing __GNUC__ and __GNUC_MINOR__ together, and various
	108	wrappers around __attribute__. Also, __extension__ will be #defined
	109	to nothing if it doesn't work. See below.
	110
	111	This header also defines a lot of obsolete macros:
	112	CONST, VOLATILE, SIGNED, PROTO, EXFUN, DEFUN, DEFUN_VOID,
	113	AND, DOTS, NOARGS. Don't use them. */
252b5132 RH	114
252b5132 RH	115	#ifndef _ANSIDECL_H
562c4c36	116	#define _ANSIDECL_H 1
252b5132	117
52d6785f DD	118	#ifdef __cplusplus
	119	extern "C" {
	120	#endif
	121
252b5132 RH	122	/* Every source file includes this file,
	123	so they will all get the switch for lint. */
	124	/* LINTLIBRARY */
	125
562c4c36 DD	126	/* Using MACRO(x,y) in cpp #if conditionals does not work with some
	127	older preprocessors. Thus we can't define something like this:
	128
	129	#define HAVE_GCC_VERSION(MAJOR, MINOR) \
	130	(__GNUC__ > (MAJOR) \|\| (__GNUC__ == (MAJOR) && __GNUC_MINOR__ >= (MINOR)))
	131
	132	and then test "#if HAVE_GCC_VERSION(2,7)".
	133
	134	So instead we use the macro below and test it against specific values. */
	135
	136	/* This macro simplifies testing whether we are using gcc, and if it
	137	is of a particular minimum version. (Both major & minor numbers are
	138	significant.) This macro will evaluate to 0 if we are not using
	139	gcc at all. */
	140	#ifndef GCC_VERSION
	141	#define GCC_VERSION (__GNUC__ * 1000 + __GNUC_MINOR__)
	142	#endif /* GCC_VERSION */
252b5132	143
52d6785f	144	#if defined (__STDC__) \|\| defined(__cplusplus) \|\| defined (_AIX) \|\| (defined (__mips) && defined (_SYSTYPE_SVR4)) \|\| defined(_WIN32)
252b5132 RH	145	/* All known AIX compilers implement these things (but don't always
	146	define __STDC__). The RISC/OS MIPS compiler defines these things
	147	in SVR4 mode, but does not define __STDC__. */
995a8435 DD	148	/* eraxxon@alumni.rice.edu: The Compaq C++ compiler, unlike many other
	149	C++ compilers, does not define __STDC__, though it acts as if this
	150	was so. (Verified versions: 5.7, 6.2, 6.3, 6.5) */
252b5132	151
562c4c36 DD	152	#define ANSI_PROTOTYPES 1
	153	#define PTR void *
	154	#define PTRCONST void *const
	155	#define LONG_DOUBLE long double
	156
8adce22d DD	157	/* PARAMS is often defined elsewhere (e.g. by libintl.h), so wrap it in
	158	a #ifndef. */
	159	#ifndef PARAMS
562c4c36	160	#define PARAMS(ARGS) ARGS
8adce22d DD	161	#endif
8adce22d DD	162
562c4c36 DD	163	#define VPARAMS(ARGS) ARGS
	164	#define VA_START(VA_LIST, VAR) va_start(VA_LIST, VAR)
	165
	166	/* variadic function helper macros */
	167	/* "struct Qdmy" swallows the semicolon after VA_OPEN/VA_FIXEDARG's
	168	use without inhibiting further decls and without declaring an
	169	actual variable. */
8a423cb3 DD	170	#define VA_OPEN(AP, VAR) { va_list AP; va_start(AP, VAR); { struct Qdmy
8a423cb3 DD	171	#define VA_CLOSE(AP) } va_end(AP); }
562c4c36 DD	172	#define VA_FIXEDARG(AP, T, N) struct Qdmy
	173
	174	#undef const
	175	#undef volatile
	176	#undef signed
	177
	178	/* inline requires special treatment; it's in C99, and GCC >=2.7 supports
	179	it too, but it's not in C89. */
	180	#undef inline
43e85a8f	181	#if __STDC_VERSION__ >= 199901L \|\| defined(__cplusplus) \|\| (defined(__SUNPRO_C) && defined(__C99FEATURES__))
562c4c36 DD	182	/* it's a keyword */
	183	#else
	184	# if GCC_VERSION >= 2007
	185	# define inline __inline__ /* __inline__ prevents -pedantic warnings */
	186	# else
	187	# define inline /* nothing */
	188	# endif
	189	#endif
252b5132 RH	190
	191	/* These are obsolete. Do not use. */
	192	#ifndef IN_GCC
562c4c36 DD	193	#define CONST const
	194	#define VOLATILE volatile
	195	#define SIGNED signed
	196
252b5132 RH	197	#define PROTO(type, name, arglist) type name arglist
	198	#define EXFUN(name, proto) name proto
	199	#define DEFUN(name, arglist, args) name(args)
	200	#define DEFUN_VOID(name) name(void)
562c4c36 DD	201	#define AND ,
	202	#define DOTS , ...
	203	#define NOARGS void
252b5132 RH	204	#endif /* ! IN_GCC */
	205
	206	#else /* Not ANSI C. */
	207
562c4c36 DD	208	#undef ANSI_PROTOTYPES
	209	#define PTR char *
	210	#define PTRCONST PTR
	211	#define LONG_DOUBLE double
	212
	213	#define PARAMS(args) ()
	214	#define VPARAMS(args) (va_alist) va_dcl
	215	#define VA_START(va_list, var) va_start(va_list)
	216
8a423cb3 DD	217	#define VA_OPEN(AP, VAR) { va_list AP; va_start(AP); { struct Qdmy
8a423cb3 DD	218	#define VA_CLOSE(AP) } va_end(AP); }
562c4c36 DD	219	#define VA_FIXEDARG(AP, TYPE, NAME) TYPE NAME = va_arg(AP, TYPE)
	220
	221	/* some systems define these in header files for non-ansi mode */
	222	#undef const
	223	#undef volatile
	224	#undef signed
	225	#undef inline
	226	#define const
	227	#define volatile
	228	#define signed
	229	#define inline
252b5132	230
252b5132 RH	231	#ifndef IN_GCC
252b5132 RH	232	#define CONST
562c4c36 DD	233	#define VOLATILE
	234	#define SIGNED
	235
252b5132 RH	236	#define PROTO(type, name, arglist) type name ()
	237	#define EXFUN(name, proto) name()
	238	#define DEFUN(name, arglist, args) name arglist args;
	239	#define DEFUN_VOID(name) name()
562c4c36 DD	240	#define AND ;
	241	#define DOTS
	242	#define NOARGS
252b5132 RH	243	#endif /* ! IN_GCC */
	244
	245	#endif /* ANSI C. */
	246
893e9593 ILT	247	/* Define macros for some gcc attributes. This permits us to use the
	248	macros freely, and know that they will come into play for the
	249	version of gcc in which they are supported. */
	250
4597ba0f	251	#if (GCC_VERSION < 2007)
893e9593 ILT	252	# define __attribute__(x)
	253	#endif
	254
4597ba0f ILT	255	/* Attribute __malloc__ on functions was valid as of gcc 2.96. */
	256	#ifndef ATTRIBUTE_MALLOC
	257	# if (GCC_VERSION >= 2096)
	258	# define ATTRIBUTE_MALLOC __attribute__ ((__malloc__))
893e9593	259	# else
4597ba0f ILT	260	# define ATTRIBUTE_MALLOC
	261	# endif /* GNUC >= 2.96 */
	262	#endif /* ATTRIBUTE_MALLOC */
	263
671f4ed1 DD	264	/* Attributes on labels were valid as of gcc 2.93 and g++ 4.5. For
671f4ed1 DD	265	g++ an attribute on a label must be followed by a semicolon. */
4597ba0f	266	#ifndef ATTRIBUTE_UNUSED_LABEL
671f4ed1 DD	267	# ifndef __cplusplus
	268	# if GCC_VERSION >= 2093
	269	# define ATTRIBUTE_UNUSED_LABEL ATTRIBUTE_UNUSED
	270	# else
	271	# define ATTRIBUTE_UNUSED_LABEL
	272	# endif
4597ba0f	273	# else
671f4ed1 DD	274	# if GCC_VERSION >= 4005
	275	# define ATTRIBUTE_UNUSED_LABEL ATTRIBUTE_UNUSED ;
	276	# else
	277	# define ATTRIBUTE_UNUSED_LABEL
	278	# endif
	279	# endif
	280	#endif
893e9593	281
ddd27bde DD	282	/* Similarly to ARG_UNUSED below. Prior to GCC 3.4, the C++ frontend
	283	couldn't parse attributes placed after the identifier name, and now
	284	the entire compiler is built with C++. */
893e9593	285	#ifndef ATTRIBUTE_UNUSED
ddd27bde DD	286	#if GCC_VERSION >= 3004
	287	# define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
	288	#else
	289	#define ATTRIBUTE_UNUSED
	290	#endif
893e9593 ILT	291	#endif /* ATTRIBUTE_UNUSED */
893e9593 ILT	292
d5b4094f DD	293	/* Before GCC 3.4, the C++ frontend couldn't parse attributes placed after the
	294	identifier name. */
	295	#if ! defined(__cplusplus) \|\| (GCC_VERSION >= 3004)
	296	# define ARG_UNUSED(NAME) NAME ATTRIBUTE_UNUSED
	297	#else /* !__cplusplus \|\| GNUC >= 3.4 */
	298	# define ARG_UNUSED(NAME) NAME
	299	#endif /* !__cplusplus \|\| GNUC >= 3.4 */
	300
893e9593 ILT	301	#ifndef ATTRIBUTE_NORETURN
	302	#define ATTRIBUTE_NORETURN __attribute__ ((__noreturn__))
	303	#endif /* ATTRIBUTE_NORETURN */
	304
bf8db3d4 DD	305	/* Attribute `nonnull' was valid as of gcc 3.3. */
	306	#ifndef ATTRIBUTE_NONNULL
	307	# if (GCC_VERSION >= 3003)
	308	# define ATTRIBUTE_NONNULL(m) __attribute__ ((__nonnull__ (m)))
	309	# else
	310	# define ATTRIBUTE_NONNULL(m)
	311	# endif /* GNUC >= 3.3 */
	312	#endif /* ATTRIBUTE_NONNULL */
	313
689a1abf	314	/* Attribute `returns_nonnull' was valid as of gcc 4.9. */
	315	#ifndef ATTRIBUTE_RETURNS_NONNULL
	316	# if (GCC_VERSION >= 4009)
	317	# define ATTRIBUTE_RETURNS_NONNULL __attribute__ ((__returns_nonnull__))
	318	# else
	319	# define ATTRIBUTE_RETURNS_NONNULL
	320	# endif /* GNUC >= 4.9 */
	321	#endif /* ATTRIBUTE_RETURNS_NONNULL */
	322
a35b6b04 DD	323	/* Attribute `pure' was valid as of gcc 3.0. */
	324	#ifndef ATTRIBUTE_PURE
	325	# if (GCC_VERSION >= 3000)
	326	# define ATTRIBUTE_PURE __attribute__ ((__pure__))
	327	# else
	328	# define ATTRIBUTE_PURE
	329	# endif /* GNUC >= 3.0 */
	330	#endif /* ATTRIBUTE_PURE */
	331
bf8db3d4 DD	332	/* Use ATTRIBUTE_PRINTF when the format specifier must not be NULL.
	333	This was the case for the `printf' format attribute by itself
	334	before GCC 3.3, but as of 3.3 we need to add the `nonnull'
	335	attribute to retain this behavior. */
893e9593	336	#ifndef ATTRIBUTE_PRINTF
bf8db3d4	337	#define ATTRIBUTE_PRINTF(m, n) __attribute__ ((__format__ (__printf__, m, n))) ATTRIBUTE_NONNULL(m)
893e9593 ILT	338	#define ATTRIBUTE_PRINTF_1 ATTRIBUTE_PRINTF(1, 2)
	339	#define ATTRIBUTE_PRINTF_2 ATTRIBUTE_PRINTF(2, 3)
	340	#define ATTRIBUTE_PRINTF_3 ATTRIBUTE_PRINTF(3, 4)
	341	#define ATTRIBUTE_PRINTF_4 ATTRIBUTE_PRINTF(4, 5)
	342	#define ATTRIBUTE_PRINTF_5 ATTRIBUTE_PRINTF(5, 6)
	343	#endif /* ATTRIBUTE_PRINTF */
	344
e9472921 DD	345	/* Use ATTRIBUTE_FPTR_PRINTF when the format attribute is to be set on
	346	a function pointer. Format attributes were allowed on function
	347	pointers as of gcc 3.1. */
	348	#ifndef ATTRIBUTE_FPTR_PRINTF
	349	# if (GCC_VERSION >= 3001)
	350	# define ATTRIBUTE_FPTR_PRINTF(m, n) ATTRIBUTE_PRINTF(m, n)
	351	# else
	352	# define ATTRIBUTE_FPTR_PRINTF(m, n)
	353	# endif /* GNUC >= 3.1 */
	354	# define ATTRIBUTE_FPTR_PRINTF_1 ATTRIBUTE_FPTR_PRINTF(1, 2)
	355	# define ATTRIBUTE_FPTR_PRINTF_2 ATTRIBUTE_FPTR_PRINTF(2, 3)
	356	# define ATTRIBUTE_FPTR_PRINTF_3 ATTRIBUTE_FPTR_PRINTF(3, 4)
	357	# define ATTRIBUTE_FPTR_PRINTF_4 ATTRIBUTE_FPTR_PRINTF(4, 5)
	358	# define ATTRIBUTE_FPTR_PRINTF_5 ATTRIBUTE_FPTR_PRINTF(5, 6)
	359	#endif /* ATTRIBUTE_FPTR_PRINTF */
	360
bf8db3d4 DD	361	/* Use ATTRIBUTE_NULL_PRINTF when the format specifier may be NULL. A
	362	NULL format specifier was allowed as of gcc 3.3. */
	363	#ifndef ATTRIBUTE_NULL_PRINTF
	364	# if (GCC_VERSION >= 3003)
	365	# define ATTRIBUTE_NULL_PRINTF(m, n) __attribute__ ((__format__ (__printf__, m, n)))
	366	# else
	367	# define ATTRIBUTE_NULL_PRINTF(m, n)
	368	# endif /* GNUC >= 3.3 */
	369	# define ATTRIBUTE_NULL_PRINTF_1 ATTRIBUTE_NULL_PRINTF(1, 2)
	370	# define ATTRIBUTE_NULL_PRINTF_2 ATTRIBUTE_NULL_PRINTF(2, 3)
	371	# define ATTRIBUTE_NULL_PRINTF_3 ATTRIBUTE_NULL_PRINTF(3, 4)
	372	# define ATTRIBUTE_NULL_PRINTF_4 ATTRIBUTE_NULL_PRINTF(4, 5)
	373	# define ATTRIBUTE_NULL_PRINTF_5 ATTRIBUTE_NULL_PRINTF(5, 6)
	374	#endif /* ATTRIBUTE_NULL_PRINTF */
	375
a5ecc6a5 DD	376	/* Attribute `sentinel' was valid as of gcc 3.5. */
	377	#ifndef ATTRIBUTE_SENTINEL
	378	# if (GCC_VERSION >= 3005)
	379	# define ATTRIBUTE_SENTINEL __attribute__ ((__sentinel__))
	380	# else
	381	# define ATTRIBUTE_SENTINEL
	382	# endif /* GNUC >= 3.5 */
	383	#endif /* ATTRIBUTE_SENTINEL */
	384
6ba85b8c DD	385
	386	#ifndef ATTRIBUTE_ALIGNED_ALIGNOF
	387	# if (GCC_VERSION >= 3000)
	388	# define ATTRIBUTE_ALIGNED_ALIGNOF(m) __attribute__ ((__aligned__ (__alignof__ (m))))
	389	# else
	390	# define ATTRIBUTE_ALIGNED_ALIGNOF(m)
	391	# endif /* GNUC >= 3.0 */
	392	#endif /* ATTRIBUTE_ALIGNED_ALIGNOF */
	393
ce493bd9	394	/* Useful for structures whose layout must much some binary specification
4fd454c8 NC	395	regardless of the alignment and padding qualities of the compiler. */
	396	#ifndef ATTRIBUTE_PACKED
	397	# define ATTRIBUTE_PACKED __attribute__ ((packed))
	398	#endif
	399
e04d7611 DD	400	/* Attribute `hot' and `cold' was valid as of gcc 4.3. */
	401	#ifndef ATTRIBUTE_COLD
	402	# if (GCC_VERSION >= 4003)
	403	# define ATTRIBUTE_COLD __attribute__ ((__cold__))
	404	# else
	405	# define ATTRIBUTE_COLD
	406	# endif /* GNUC >= 4.3 */
	407	#endif /* ATTRIBUTE_COLD */
	408	#ifndef ATTRIBUTE_HOT
	409	# if (GCC_VERSION >= 4003)
	410	# define ATTRIBUTE_HOT __attribute__ ((__hot__))
	411	# else
	412	# define ATTRIBUTE_HOT
	413	# endif /* GNUC >= 4.3 */
	414	#endif /* ATTRIBUTE_HOT */
	415
f1d95f4b L	416	/* We use __extension__ in some places to suppress -pedantic warnings
	417	about GCC extensions. This feature didn't work properly before
	418	gcc 2.8. */
	419	#if GCC_VERSION < 2008
	420	#define __extension__
	421	#endif
	422
8466c6d4 DD	423	/* This is used to declare a const variable which should be visible
	424	outside of the current compilation unit. Use it as
	425	EXPORTED_CONST int i = 1;
	426	This is because the semantics of const are different in C and C++.
	427	"extern const" is permitted in C but it looks strange, and gcc
	428	warns about it when -Wc++-compat is not used. */
	429	#ifdef __cplusplus
	430	#define EXPORTED_CONST extern const
	431	#else
	432	#define EXPORTED_CONST const
	433	#endif
	434
006d5c88	435	/* Be conservative and only use enum bitfields with C++ or GCC.
1ae0d051 JK	436	FIXME: provide a complete autoconf test for buggy enum bitfields. */
1ae0d051 JK	437
006d5c88 DD	438	#ifdef __cplusplus
	439	#define ENUM_BITFIELD(TYPE) enum TYPE
	440	#elif (GCC_VERSION > 2000)
1ae0d051 JK	441	#define ENUM_BITFIELD(TYPE) __extension__ enum TYPE
	442	#else
	443	#define ENUM_BITFIELD(TYPE) unsigned int
	444	#endif
	445
52d6785f DD	446	#ifdef __cplusplus
	447	}
	448	#endif
	449
252b5132	450	#endif /* ansidecl.h */