[thirdparty/gcc.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
   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)
/* 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. */
#ifndef ATTRIBUTE_UNUSED_LABEL
# if (!defined (__cplusplus) && GCC_VERSION >= 2093)
#  define ATTRIBUTE_UNUSED_LABEL ATTRIBUTE_UNUSED
# else
#  define ATTRIBUTE_UNUSED_LABEL
# endif /* !__cplusplus && GNUC >= 2.93 */
#endif /* ATTRIBUTE_UNUSED_LABEL */

#ifndef ATTRIBUTE_UNUSED
#define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
#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 `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

#ifdef __cplusplus
}
#endif

#endif	/* ansidecl.h	*/
Commit	Line	Data
28e9041c	1	/* ANSI and traditional C compatability macros
74b36562	2	Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
74b36562	3	2002, 2003, 2004, 2005, 2006, 2007, 2009
24a928fa	4	Free Software Foundation, Inc.
28e9041c	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
2f8ebb8e	19	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
28e9041c	20
	21	/* ANSI and traditional C compatibility macros
	22
	23	ANSI C is assumed if __STDC__ is #defined.
	24
8b562dac	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,
cdf83f50	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.
8b562dac	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. */
28e9041c	114
28e9041c	115	#ifndef _ANSIDECL_H
8b562dac	116	#define _ANSIDECL_H 1
28e9041c	117
74b36562	118	#ifdef __cplusplus
	119	extern "C" {
	120	#endif
	121
28e9041c	122	/* Every source file includes this file,
	123	so they will all get the switch for lint. */
	124	/* LINTLIBRARY */
	125
8b562dac	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 */
28e9041c	143
74b36562	144	#if defined (__STDC__) \|\| defined(__cplusplus) \|\| defined (_AIX) \|\| (defined (__mips) && defined (_SYSTYPE_SVR4)) \|\| defined(_WIN32)
28e9041c	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__. */
cf114fce	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) */
28e9041c	151
8b562dac	152	#define ANSI_PROTOTYPES 1
	153	#define PTR void *
	154	#define PTRCONST void *const
	155	#define LONG_DOUBLE long double
	156
bb30d1f4	157	/* PARAMS is often defined elsewhere (e.g. by libintl.h), so wrap it in
	158	a #ifndef. */
	159	#ifndef PARAMS
8b562dac	160	#define PARAMS(ARGS) ARGS
bb30d1f4	161	#endif
bb30d1f4	162
8b562dac	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. */
68036f05	170	#define VA_OPEN(AP, VAR) { va_list AP; va_start(AP, VAR); { struct Qdmy
68036f05	171	#define VA_CLOSE(AP) } va_end(AP); }
8b562dac	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
74b36562	181	#if __STDC_VERSION__ > 199901L \|\| defined(__cplusplus)
8b562dac	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
28e9041c	190
28e9041c	191	/* These are obsolete. Do not use. */
e4ac85d2	192	#ifndef IN_GCC
8b562dac	193	#define CONST const
	194	#define VOLATILE volatile
	195	#define SIGNED signed
	196
28e9041c	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)
8b562dac	201	#define AND ,
	202	#define DOTS , ...
	203	#define NOARGS void
e4ac85d2	204	#endif /* ! IN_GCC */
28e9041c	205
	206	#else /* Not ANSI C. */
	207
8b562dac	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
68036f05	217	#define VA_OPEN(AP, VAR) { va_list AP; va_start(AP); { struct Qdmy
68036f05	218	#define VA_CLOSE(AP) } va_end(AP); }
8b562dac	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
28e9041c	230
e4ac85d2	231	#ifndef IN_GCC
28e9041c	232	#define CONST
8b562dac	233	#define VOLATILE
	234	#define SIGNED
	235
28e9041c	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()
8b562dac	240	#define AND ;
	241	#define DOTS
	242	#define NOARGS
e4ac85d2	243	#endif /* ! IN_GCC */
28e9041c	244
	245	#endif /* ANSI C. */
	246
00826d78	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
e6e27f6e	251	#if (GCC_VERSION < 2007)
00826d78	252	# define __attribute__(x)
	253	#endif
	254
a481083c	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__))
	259	# else
	260	# define ATTRIBUTE_MALLOC
	261	# endif /* GNUC >= 2.96 */
	262	#endif /* ATTRIBUTE_MALLOC */
	263
e6e27f6e	264	/* Attributes on labels were valid as of gcc 2.93. */
00826d78	265	#ifndef ATTRIBUTE_UNUSED_LABEL
f2d737fc	266	# if (!defined (__cplusplus) && GCC_VERSION >= 2093)
00826d78	267	# define ATTRIBUTE_UNUSED_LABEL ATTRIBUTE_UNUSED
e6e27f6e	268	# else
e6e27f6e	269	# define ATTRIBUTE_UNUSED_LABEL
f2d737fc	270	# endif /* !__cplusplus && GNUC >= 2.93 */
00826d78	271	#endif /* ATTRIBUTE_UNUSED_LABEL */
	272
	273	#ifndef ATTRIBUTE_UNUSED
	274	#define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
	275	#endif /* ATTRIBUTE_UNUSED */
	276
001ad2d4	277	/* Before GCC 3.4, the C++ frontend couldn't parse attributes placed after the
	278	identifier name. */
	279	#if ! defined(__cplusplus) \|\| (GCC_VERSION >= 3004)
	280	# define ARG_UNUSED(NAME) NAME ATTRIBUTE_UNUSED
	281	#else /* !__cplusplus \|\| GNUC >= 3.4 */
	282	# define ARG_UNUSED(NAME) NAME
	283	#endif /* !__cplusplus \|\| GNUC >= 3.4 */
	284
00826d78	285	#ifndef ATTRIBUTE_NORETURN
	286	#define ATTRIBUTE_NORETURN __attribute__ ((__noreturn__))
	287	#endif /* ATTRIBUTE_NORETURN */
	288
06df7294	289	/* Attribute `nonnull' was valid as of gcc 3.3. */
	290	#ifndef ATTRIBUTE_NONNULL
	291	# if (GCC_VERSION >= 3003)
	292	# define ATTRIBUTE_NONNULL(m) __attribute__ ((__nonnull__ (m)))
	293	# else
	294	# define ATTRIBUTE_NONNULL(m)
	295	# endif /* GNUC >= 3.3 */
	296	#endif /* ATTRIBUTE_NONNULL */
	297
6ca10ffb	298	/* Attribute `pure' was valid as of gcc 3.0. */
	299	#ifndef ATTRIBUTE_PURE
	300	# if (GCC_VERSION >= 3000)
	301	# define ATTRIBUTE_PURE __attribute__ ((__pure__))
	302	# else
	303	# define ATTRIBUTE_PURE
	304	# endif /* GNUC >= 3.0 */
	305	#endif /* ATTRIBUTE_PURE */
	306
06df7294	307	/* Use ATTRIBUTE_PRINTF when the format specifier must not be NULL.
	308	This was the case for the `printf' format attribute by itself
	309	before GCC 3.3, but as of 3.3 we need to add the `nonnull'
	310	attribute to retain this behavior. */
00826d78	311	#ifndef ATTRIBUTE_PRINTF
06df7294	312	#define ATTRIBUTE_PRINTF(m, n) __attribute__ ((__format__ (__printf__, m, n))) ATTRIBUTE_NONNULL(m)
00826d78	313	#define ATTRIBUTE_PRINTF_1 ATTRIBUTE_PRINTF(1, 2)
	314	#define ATTRIBUTE_PRINTF_2 ATTRIBUTE_PRINTF(2, 3)
	315	#define ATTRIBUTE_PRINTF_3 ATTRIBUTE_PRINTF(3, 4)
	316	#define ATTRIBUTE_PRINTF_4 ATTRIBUTE_PRINTF(4, 5)
	317	#define ATTRIBUTE_PRINTF_5 ATTRIBUTE_PRINTF(5, 6)
	318	#endif /* ATTRIBUTE_PRINTF */
	319
1b52004c	320	/* Use ATTRIBUTE_FPTR_PRINTF when the format attribute is to be set on
	321	a function pointer. Format attributes were allowed on function
	322	pointers as of gcc 3.1. */
	323	#ifndef ATTRIBUTE_FPTR_PRINTF
	324	# if (GCC_VERSION >= 3001)
	325	# define ATTRIBUTE_FPTR_PRINTF(m, n) ATTRIBUTE_PRINTF(m, n)
	326	# else
	327	# define ATTRIBUTE_FPTR_PRINTF(m, n)
	328	# endif /* GNUC >= 3.1 */
	329	# define ATTRIBUTE_FPTR_PRINTF_1 ATTRIBUTE_FPTR_PRINTF(1, 2)
	330	# define ATTRIBUTE_FPTR_PRINTF_2 ATTRIBUTE_FPTR_PRINTF(2, 3)
	331	# define ATTRIBUTE_FPTR_PRINTF_3 ATTRIBUTE_FPTR_PRINTF(3, 4)
	332	# define ATTRIBUTE_FPTR_PRINTF_4 ATTRIBUTE_FPTR_PRINTF(4, 5)
	333	# define ATTRIBUTE_FPTR_PRINTF_5 ATTRIBUTE_FPTR_PRINTF(5, 6)
	334	#endif /* ATTRIBUTE_FPTR_PRINTF */
	335
06df7294	336	/* Use ATTRIBUTE_NULL_PRINTF when the format specifier may be NULL. A
	337	NULL format specifier was allowed as of gcc 3.3. */
	338	#ifndef ATTRIBUTE_NULL_PRINTF
	339	# if (GCC_VERSION >= 3003)
	340	# define ATTRIBUTE_NULL_PRINTF(m, n) __attribute__ ((__format__ (__printf__, m, n)))
	341	# else
	342	# define ATTRIBUTE_NULL_PRINTF(m, n)
	343	# endif /* GNUC >= 3.3 */
	344	# define ATTRIBUTE_NULL_PRINTF_1 ATTRIBUTE_NULL_PRINTF(1, 2)
	345	# define ATTRIBUTE_NULL_PRINTF_2 ATTRIBUTE_NULL_PRINTF(2, 3)
	346	# define ATTRIBUTE_NULL_PRINTF_3 ATTRIBUTE_NULL_PRINTF(3, 4)
	347	# define ATTRIBUTE_NULL_PRINTF_4 ATTRIBUTE_NULL_PRINTF(4, 5)
	348	# define ATTRIBUTE_NULL_PRINTF_5 ATTRIBUTE_NULL_PRINTF(5, 6)
	349	#endif /* ATTRIBUTE_NULL_PRINTF */
	350
bf6c8de0	351	/* Attribute `sentinel' was valid as of gcc 3.5. */
	352	#ifndef ATTRIBUTE_SENTINEL
	353	# if (GCC_VERSION >= 3005)
	354	# define ATTRIBUTE_SENTINEL __attribute__ ((__sentinel__))
	355	# else
	356	# define ATTRIBUTE_SENTINEL
	357	# endif /* GNUC >= 3.5 */
	358	#endif /* ATTRIBUTE_SENTINEL */
	359
91fc5678	360
	361	#ifndef ATTRIBUTE_ALIGNED_ALIGNOF
	362	# if (GCC_VERSION >= 3000)
	363	# define ATTRIBUTE_ALIGNED_ALIGNOF(m) __attribute__ ((__aligned__ (__alignof__ (m))))
	364	# else
	365	# define ATTRIBUTE_ALIGNED_ALIGNOF(m)
	366	# endif /* GNUC >= 3.0 */
	367	#endif /* ATTRIBUTE_ALIGNED_ALIGNOF */
	368
9430e4a9	369	/* Useful for structures whose layout must much some binary specification
	370	regardless of the alignment and padding qualities of the compiler. */
	371	#ifndef ATTRIBUTE_PACKED
	372	# define ATTRIBUTE_PACKED __attribute__ ((packed))
	373	#endif
	374
5de92639	375	/* Attribute `hot' and `cold' was valid as of gcc 4.3. */
	376	#ifndef ATTRIBUTE_COLD
	377	# if (GCC_VERSION >= 4003)
	378	# define ATTRIBUTE_COLD __attribute__ ((__cold__))
	379	# else
	380	# define ATTRIBUTE_COLD
	381	# endif /* GNUC >= 4.3 */
	382	#endif /* ATTRIBUTE_COLD */
	383	#ifndef ATTRIBUTE_HOT
	384	# if (GCC_VERSION >= 4003)
	385	# define ATTRIBUTE_HOT __attribute__ ((__hot__))
	386	# else
	387	# define ATTRIBUTE_HOT
	388	# endif /* GNUC >= 4.3 */
	389	#endif /* ATTRIBUTE_HOT */
	390
db7e2f59	391	/* We use __extension__ in some places to suppress -pedantic warnings
	392	about GCC extensions. This feature didn't work properly before
	393	gcc 2.8. */
	394	#if GCC_VERSION < 2008
	395	#define __extension__
	396	#endif
	397
cd819d2f	398	/* This is used to declare a const variable which should be visible
	399	outside of the current compilation unit. Use it as
	400	EXPORTED_CONST int i = 1;
	401	This is because the semantics of const are different in C and C++.
	402	"extern const" is permitted in C but it looks strange, and gcc
	403	warns about it when -Wc++-compat is not used. */
	404	#ifdef __cplusplus
	405	#define EXPORTED_CONST extern const
	406	#else
	407	#define EXPORTED_CONST const
	408	#endif
	409
74b36562	410	#ifdef __cplusplus
	411	}
	412	#endif
	413
28e9041c	414	#endif /* ansidecl.h */