Standard
predefined macros
The standard
predefined macros are available with the same mean-ings regardless of the
machine or operating system on which you are using GNU C. Their names all
start and end with double underscores. Those preceding __GNUC__
in this table are standardized by ANSI C; the rest are GNU C extensions.
- __FILE__
- __LINE__
- This and __FILE__ are useful in generating an error message to report an inconsistency detected by the program; the message can state the source line at which the inconsistency was detected. Use the following output as an example.
- This macro expands to the
name of the current input file, in the form of a C string constant. The
precise name returned is the one that was specified in #include
or as the input file name argument.
- This macro expands to the
current input line number, in the form of a decimal integer constant. While
we call it a predefined macro, its a pretty strange macro, since its definition
changes with each new line of source code.
fprintf (stderr, "Internal error: " "negative string length " "%d at %s, line %d.", length, __FILE__, __LINE__);
- This macro expands to a
string constant that describes the date on which the preprocessor is being
run. The string constant contains eleven characters and looks like "Jan
29 1987" or "Apr
1 1905".
- This macro expands to a
string constant that describes the time at which the preprocessor is being
run. The string con-stant contains eight characters and looks like "23:59:01".
- This macro expands to the
constant 1,
to signify that this is ANSI Standard C. (Whether that is actually true
depends on what C compiler will operate on the output from the preprocessor.)
- This macro expands to the
C Standards version number, a long integer constant of the form yyyymmL
where yyyy
and mm
are the year and month of the Standard version. This signifies which version
of the C Standard the preprocessor conforms to. Like __STDC__,
whether this version number is accurate for the entire implementation depends
on what C compiler will operate on the output from the preprocessor.
- This macro is defined if
and only if this is GNU C. This macro is defined only when the entire GNU
C compiler is in use; if you invoke the preprocessor directly, __GNUC__
is undefined. The value identifies the major version number of GNU CC (1
for GNU CC version 1, which is now obsolete, and 2
for version 2).
- The macro contains the minor
version number of the compiler. This can be used to work around differences
between different releases of the compiler (for example, if gcc 2.6.3 is
known to support a feature, you can test for __GNUC__
> 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 6)).
The last number, 3,
denotes the bugfix level of the compiler; no macro contains this value.
- The GNU C compiler defines
this when the compilation language is C++; use __GNUG__
to distinguish between GNU C and GNU C++.
- The draft ANSI standard
for C++ used to require predefining this variable. Though it is
no longer required, GNU C++ continues to define it, as do other popular
C++ compilers. You can use __cplusplus
to test whether a header is compiled by a C compiler or a C++ compiler.
- GNU C defines this macro
if and only if the -ansi
switch was specified when GNU C was invoked. Its definition is the null
string. This macro exists primarily to direct certain GNU header files
not to define certain traditional Unix constructs which are incompatible
with ANSI C.
- This macro expands to the
name of the main input file, in the form of a C string constant. This is
the source file that was specified as an argument when the C compiler was
invoked.
- This macro expands to a
decimal integer constant that represents the depth of nesting in include
files. The value of this macro increments on every #include
directive and decremented at every end of file. For input files specified
by command line arguments, the nesting level is zero.
- This macro expands to a
string which describes the version number of GNU C. The string is normally
a sequence of decimal numbers separated by periods, such as "2.6.0".
- GNU CC defines this macro
in optimizing compilations. It causes certain GNU header files to define
alternative macro definitions for some system library
functions. You should not refer to or test the definition of this macro
unless you make very sure that programs will execute with the same effect
regardless.
- GNU C defines this macro
if and only if the data type char
is unsigned on the target machine. It exists to cause the standard header
file, limit.h,
to work correctly. You should not refer to this macro yourself; instead,
refer to the standard macros defined in limit.h.
The preprocessor uses this macro to determine whether or not to sign-extend
large character constants written in octal; see The
#if
directive.
- This macro expands to a
string (not a string constant) describing the prefix applied to CPU registers
in assembler code. You can use it to write assembler code that is usable
in multiple environments. For example, in the m68k-aout
environment, it expands to the null string, and in the m68k-coff
environment, it expands to the string, %.
- Similar
to __REGISTER_PREFIX__, this
macro describes the prefix applied to user generated labels in assembler
code. For example, in the m68k-aout
environment, it expands to the string, _,
but in the m68k-coff
environment, it expands to the null string. This does not work with the
-mno-underscores option that
the i386 OSF/rose and m88k targets provide, nor with the -mcall*
options of the rs6000 System V Release 4 target.
|
© 2004 Red Hat, Inc. All rights reserved. About Red Hat : Legal statement : Privacy statement : Contact Red Hat |