ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/cebix/mon/src/disass/ansidecl.h

Comparing mon/src/disass/ansidecl.h (file contents):
Revision 1.1 by cebix, 2000-09-25T12:44:36Z vs.
Revision 1.2 by gbeauche, 2002-09-07T12:48:15Z

#	Line 1 | Line 1
1		/* ANSI and traditional C compatability macros
2	<	Copyright 1991, 1992, 1996 Free Software Foundation, Inc.
2	>	Copyright 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001
3	>	Free Software Foundation, Inc.
4		This file is part of the GNU C Library.
5
6		This program is free software; you can redistribute it and/or modify
#	Line 20 | Line 21 | Foundation, Inc., 59 Temple Place - Suit
21
22		ANSI C is assumed if __STDC__ is #defined.
23
24	<	Macro        ANSI C definition       Traditional C definition
25	<	-----        ---- - ----------       ----------- - ----------
26	<	PTR          `void *'                `char *'
27	<	LONG_DOUBLE  `long double'           `double'
28	<	VOLATILE     `volatile'              `'
29	<	SIGNED       `signed'                `'
30	<	PTRCONST     `void *const'           `char *'
31	<	ANSI_PROTOTYPES  1                   not defined
32	<
33	<	CONST is also defined, but is obsolete.  Just use const.
34	<
35	<	obsolete --     DEFUN (name, arglist, args)
36	<
37	<	Defines function NAME.
38	<
39	<	ARGLIST lists the arguments, separated by commas and enclosed in
40	<	parentheses.  ARGLIST becomes the argument list in traditional C.
41	<
42	<	ARGS list the arguments with their types.  It becomes a prototype in
43	<	ANSI C, and the type declarations in traditional C.  Arguments should
44	<	be separated with `AND'.  For functions with a variable number of
45	<	arguments, the last thing listed should be `DOTS'.
46	<
47	<	obsolete --     DEFUN_VOID (name)
48	<
49	<	Defines a function NAME, which takes no arguments.
50	<
51	<	obsolete --     EXFUN (name, (prototype))    -- obsolete.
52	<
53	<	Replaced by PARAMS.  Do not use; will disappear someday soon.
54	<	Was used in external function declarations.
55	<	In ANSI C it is `NAME PROTOTYPE' (so PROTOTYPE should be enclosed in
56	<	parentheses).  In traditional C it is `NAME()'.
57	<	For a function that takes no arguments, PROTOTYPE should be `(void)'.
58	<
59	<	obsolete --     PROTO (type, name, (prototype)    -- obsolete.
60	<
61	<	This one has also been replaced by PARAMS.  Do not use.
62	<
63	<	PARAMS ((args))
64	<
65	<	We could use the EXFUN macro to handle prototype declarations, but
66	<	the name is misleading and the result is ugly.  So we just define a
67	<	simple macro to handle the parameter lists, as in:
68	<
69	<	static int foo PARAMS ((int, char));
70	<
71	<	This produces:  `static int foo();' or `static int foo (int, char);'
72	<
73	<	EXFUN would have done it like this:
74	<
75	<	static int EXFUN (foo, (int, char));
76	<
77	<	but the function is not external...and it's hard to visually parse
78	<	the function name out of the mess.   EXFUN should be considered
79	<	obsolete; new code should be written to use PARAMS.
80	<
81	<	DOTS is also obsolete.
82	<
83	<	Examples:
84	<
85	<	extern int printf PARAMS ((const char *format, ...));
86	<	*/
24	>	Macro                ANSI C definition       Traditional C definition
25	>	-----                ---- - ----------       ----------- - ----------
26	>	ANSI_PROTOTYPES      1                       not defined
27	>	PTR                  `void *'                `char *'
28	>	PTRCONST             `void *const'           `char *'
29	>	LONG_DOUBLE          `long double'           `double'
30	>	const                not defined             `'
31	>	volatile             not defined             `'
32	>	signed               not defined             `'
33	>	VA_START(ap, var)    va_start(ap, var)       va_start(ap)
34	>
35	>	Note that it is safe to write "void foo();" indicating a function
36	>	with no return value, in all K+R compilers we have been able to test.
37	>
38	>	For declaring functions with prototypes, we also provide these:
39	>
40	>	PARAMS ((prototype))
41	>	-- for functions which take a fixed number of arguments.  Use this
42	>	when declaring the function.  When defining the function, write a
43	>	K+R style argument list.  For example:
44	>
45	>	char *strcpy PARAMS ((char *dest, char *source));
46	>	...
47	>	char *
48	>	strcpy (dest, source)
49	>	char *dest;
50	>	char *source;
51	>	{ ... }
52	>
53	>
54	>	VPARAMS ((prototype, ...))
55	>	-- for functions which take a variable number of arguments.  Use
56	>	PARAMS to declare the function, VPARAMS to define it.  For example:
57	>
58	>	int printf PARAMS ((const char *format, ...));
59	>	...
60	>	int
61	>	printf VPARAMS ((const char *format, ...))
62	>	{
63	>	...
64	>	}
65	>
66	>	For writing functions which take variable numbers of arguments, we
67	>	also provide the VA_OPEN, VA_CLOSE, and VA_FIXEDARG macros.  These
68	>	hide the differences between K+R <varargs.h> and C89 <stdarg.h> more
69	>	thoroughly than the simple VA_START() macro mentioned above.
70	>
71	>	VA_OPEN and VA_CLOSE are used *instead of* va_start and va_end.
72	>	Immediately after VA_OPEN, put a sequence of VA_FIXEDARG calls
73	>	corresponding to the list of fixed arguments.  Then use va_arg
74	>	normally to get the variable arguments, or pass your va_list object
75	>	around.  You do not declare the va_list yourself; VA_OPEN does it
76	>	for you.
77	>
78	>	Here is a complete example:
79	>
80	>	int
81	>	printf VPARAMS ((const char *format, ...))
82	>	{
83	>	int result;
84	>
85	>	VA_OPEN (ap, format);
86	>	VA_FIXEDARG (ap, const char *, format);
87	>
88	>	result = vfprintf (stdout, format, ap);
89	>	VA_CLOSE (ap);
90	>
91	>	return result;
92	>	}
93	>
94	>
95	>	You can declare variables either before or after the VA_OPEN,
96	>	VA_FIXEDARG sequence.  Also, VA_OPEN and VA_CLOSE are the beginning
97	>	and end of a block.  They must appear at the same nesting level,
98	>	and any variables declared after VA_OPEN go out of scope at
99	>	VA_CLOSE.  Unfortunately, with a K+R compiler, that includes the
100	>	argument list.  You can have multiple instances of VA_OPEN/VA_CLOSE
101	>	pairs in a single function in case you need to traverse the
102	>	argument list more than once.
103	>
104	>	For ease of writing code which uses GCC extensions but needs to be
105	>	portable to other compilers, we provide the GCC_VERSION macro that
106	>	simplifies testing __GNUC__ and __GNUC_MINOR__ together, and various
107	>	wrappers around __attribute__.  Also, __extension__ will be #defined
108	>	to nothing if it doesn't work.  See below.
109	>
110	>	This header also defines a lot of obsolete macros:
111	>	CONST, VOLATILE, SIGNED, PROTO, EXFUN, DEFUN, DEFUN_VOID,
112	>	AND, DOTS, NOARGS.  Don't use them.  */
113
114		#ifndef _ANSIDECL_H
115	<
89	<	#define _ANSIDECL_H     1
90	<
115	>	#define _ANSIDECL_H     1
116
117		/* Every source file includes this file,
118		so they will all get the switch for lint.  */
119		/* LINTLIBRARY */
120
121	+	/* Using MACRO(x,y) in cpp #if conditionals does not work with some
122	+	older preprocessors.  Thus we can't define something like this:
123	+
124	+	#define HAVE_GCC_VERSION(MAJOR, MINOR) \
125	+	(__GNUC__ > (MAJOR) || (__GNUC__ == (MAJOR) && __GNUC_MINOR__ >= (MINOR)))
126	+
127	+	and then test "#if HAVE_GCC_VERSION(2,7)".
128	+
129	+	So instead we use the macro below and test it against specific values.  */
130	+
131	+	/* This macro simplifies testing whether we are using gcc, and if it
132	+	is of a particular minimum version. (Both major & minor numbers are
133	+	significant.)  This macro will evaluate to 0 if we are not using
134	+	gcc at all.  */
135	+	#ifndef GCC_VERSION
136	+	#define GCC_VERSION (__GNUC__ * 1000 + __GNUC_MINOR__)
137	+	#endif /* GCC_VERSION */
138
139		#if defined (__STDC__) || defined (_AIX) || (defined (__mips) && defined (_SYSTYPE_SVR4)) || defined(_WIN32)
140		/* All known AIX compilers implement these things (but don't always
141		define __STDC__).  The RISC/OS MIPS compiler defines these things
142		in SVR4 mode, but does not define __STDC__.  */
143
144	<	#define PTR             void *
145	<	#define PTRCONST        void *CONST
146	<	#define LONG_DOUBLE     long double
147	<
148	<	#define AND             ,
149	<	#define NOARGS          void
150	<	#define VOLATILE        volatile
151	<	#define SIGNED          signed
152	<
153	<	#define PARAMS(paramlist)               paramlist
154	<	#define ANSI_PROTOTYPES                 1
155	<
156	<	#define VPARAMS(ARGS)                   ARGS
157	<	#define VA_START(va_list,var)           va_start(va_list,var)
144	>	#define ANSI_PROTOTYPES 1
145	>	#define PTR             void *
146	>	#define PTRCONST        void *const
147	>	#define LONG_DOUBLE     long double
148	>
149	>	#define PARAMS(ARGS)            ARGS
150	>	#define VPARAMS(ARGS)           ARGS
151	>	#define VA_START(VA_LIST, VAR)  va_start(VA_LIST, VAR)
152	>
153	>	/* variadic function helper macros */
154	>	/* "struct Qdmy" swallows the semicolon after VA_OPEN/VA_FIXEDARG's
155	>	use without inhibiting further decls and without declaring an
156	>	actual variable.  */
157	>	#define VA_OPEN(AP, VAR)        { va_list AP; va_start(AP, VAR); { struct Qdmy
158	>	#define VA_CLOSE(AP)            } va_end(AP); }
159	>	#define VA_FIXEDARG(AP, T, N)   struct Qdmy
160	>
161	>	#undef const
162	>	#undef volatile
163	>	#undef signed
164	>
165	>	/* inline requires special treatment; it's in C99, and GCC >=2.7 supports
166	>	it too, but it's not in C89.  */
167	>	#undef inline
168	>	#if __STDC_VERSION__ > 199901L
169	>	/* it's a keyword */
170	>	#else
171	>	# if GCC_VERSION >= 2007
172	>	#  define inline __inline__   /* __inline__ prevents -pedantic warnings */
173	>	# else
174	>	#  define inline  /* nothing */
175	>	# endif
176	>	#endif
177
178		/* These are obsolete.  Do not use.  */
179	<	#define CONST                           const
180	<	#define DOTS                            , ...
179	>	#ifndef IN_GCC
180	>	#define CONST           const
181	>	#define VOLATILE        volatile
182	>	#define SIGNED          signed
183	>
184		#define PROTO(type, name, arglist)      type name arglist
185		#define EXFUN(name, proto)              name proto
186		#define DEFUN(name, arglist, args)      name(args)
187		#define DEFUN_VOID(name)                name(void)
188	+	#define AND             ,
189	+	#define DOTS            , ...
190	+	#define NOARGS          void
191	+	#endif /* ! IN_GCC */
192
193		#else   /* Not ANSI C.  */
194
195	<	#define PTR             char *
196	<	#define PTRCONST        PTR
197	<	#define LONG_DOUBLE     double
198	<
199	<	#define AND             ;
200	<	#define NOARGS
201	<	#ifndef const /* some systems define it in header files for non-ansi mode */
202	<	#define const
203	<	#endif
204	<	#define VOLATILE
205	<	#define SIGNED
206	<
207	<	#define PARAMS(paramlist)               ()
208	<
209	<	#define VPARAMS(ARGS)                   (va_alist) va_dcl
210	<	#define VA_START(va_list,var)           va_start(va_list)
195	>	#undef  ANSI_PROTOTYPES
196	>	#define PTR             char *
197	>	#define PTRCONST        PTR
198	>	#define LONG_DOUBLE     double
199	>
200	>	#define PARAMS(args)            ()
201	>	#define VPARAMS(args)           (va_alist) va_dcl
202	>	#define VA_START(va_list, var)  va_start(va_list)
203	>
204	>	#define VA_OPEN(AP, VAR)                { va_list AP; va_start(AP); { struct Qdmy
205	>	#define VA_CLOSE(AP)                    } va_end(AP); }
206	>	#define VA_FIXEDARG(AP, TYPE, NAME)     TYPE NAME = va_arg(AP, TYPE)
207	>
208	>	/* some systems define these in header files for non-ansi mode */
209	>	#undef const
210	>	#undef volatile
211	>	#undef signed
212	>	#undef inline
213	>	#define const
214	>	#define volatile
215	>	#define signed
216	>	#define inline
217
218	<	/* These are obsolete.  Do not use.  */
218	>	#ifndef IN_GCC
219		#define CONST
220	<	#define DOTS
220	>	#define VOLATILE
221	>	#define SIGNED
222	>
223		#define PROTO(type, name, arglist)      type name ()
224		#define EXFUN(name, proto)              name()
225		#define DEFUN(name, arglist, args)      name arglist args;
226		#define DEFUN_VOID(name)                name()
227	+	#define AND             ;
228	+	#define DOTS
229	+	#define NOARGS
230	+	#endif /* ! IN_GCC */
231
232		#endif  /* ANSI C.  */
233
234	+	/* Define macros for some gcc attributes.  This permits us to use the
235	+	macros freely, and know that they will come into play for the
236	+	version of gcc in which they are supported.  */
237	+
238	+	#if (GCC_VERSION < 2007)
239	+	# define __attribute__(x)
240	+	#endif
241	+
242	+	/* Attribute __malloc__ on functions was valid as of gcc 2.96. */
243	+	#ifndef ATTRIBUTE_MALLOC
244	+	# if (GCC_VERSION >= 2096)
245	+	#  define ATTRIBUTE_MALLOC __attribute__ ((__malloc__))
246	+	# else
247	+	#  define ATTRIBUTE_MALLOC
248	+	# endif /* GNUC >= 2.96 */
249	+	#endif /* ATTRIBUTE_MALLOC */
250	+
251	+	/* Attributes on labels were valid as of gcc 2.93. */
252	+	#ifndef ATTRIBUTE_UNUSED_LABEL
253	+	# if (GCC_VERSION >= 2093)
254	+	#  define ATTRIBUTE_UNUSED_LABEL ATTRIBUTE_UNUSED
255	+	# else
256	+	#  define ATTRIBUTE_UNUSED_LABEL
257	+	# endif /* GNUC >= 2.93 */
258	+	#endif /* ATTRIBUTE_UNUSED_LABEL */
259	+
260	+	#ifndef ATTRIBUTE_UNUSED
261	+	#define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
262	+	#endif /* ATTRIBUTE_UNUSED */
263	+
264	+	#ifndef ATTRIBUTE_NORETURN
265	+	#define ATTRIBUTE_NORETURN __attribute__ ((__noreturn__))
266	+	#endif /* ATTRIBUTE_NORETURN */
267	+
268	+	#ifndef ATTRIBUTE_PRINTF
269	+	#define ATTRIBUTE_PRINTF(m, n) __attribute__ ((__format__ (__printf__, m, n)))
270	+	#define ATTRIBUTE_PRINTF_1 ATTRIBUTE_PRINTF(1, 2)
271	+	#define ATTRIBUTE_PRINTF_2 ATTRIBUTE_PRINTF(2, 3)
272	+	#define ATTRIBUTE_PRINTF_3 ATTRIBUTE_PRINTF(3, 4)
273	+	#define ATTRIBUTE_PRINTF_4 ATTRIBUTE_PRINTF(4, 5)
274	+	#define ATTRIBUTE_PRINTF_5 ATTRIBUTE_PRINTF(5, 6)
275	+	#endif /* ATTRIBUTE_PRINTF */
276	+
277	+	/* We use __extension__ in some places to suppress -pedantic warnings
278	+	about GCC extensions.  This feature didn't work properly before
279	+	gcc 2.8.  */
280	+	#if GCC_VERSION < 2008
281	+	#define __extension__
282	+	#endif
283	+
284	+	/* Bootstrap support:  Adjust certain macros defined by Autoconf,
285	+	which are only valid for the stage1 compiler.  If we detect
286	+	a modern version of GCC, we are probably in stage2 or beyond,
287	+	so unconditionally reset the values.  Note that const, inline,
288	+	etc. have been dealt with above.  */
289	+	#if (GCC_VERSION >= 2007)
290	+	# ifndef HAVE_LONG_DOUBLE
291	+	#  define HAVE_LONG_DOUBLE 1
292	+	# endif
293	+	#endif /* GCC >= 2.7 */
294	+
295		#endif  /* ansidecl.h   */

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines