#### 26.5.7 Predefined Macros ¶

Several object-like macros are predefined; you use them without supplying their definitions. Here we explain the ones user programs often need to use. Many other macro names starting with ‘`__`’ are predefined; in general, you should not define such macro names yourself.

`__FILE__`

  This macro expands to the name of the current input file, in the form of a C string constant. This is the full name by which the GCC opened the file, not the short name specified in `#include` or as the input file name argument. For example, `"/usr/local/include/myheader.h"` is a possible expansion of this macro.

`__LINE__`

  This macro expands to the current input line number, in the form of a decimal integer constant. While we call it a predefined macro, it’s a pretty strange macro, since its “definition” changes with each new line of source code.

`__func__`
`__FUNCTION__`

  These names are like variables that have as value a string containing the name of the current function definition. They are not really macros, but this is the best place to mention them.

  `__FUNCTION__` is the name that has been defined in GNU C since time immemorial; `__func__` is defined by the C standard. With the following conditionals, you can use whichever one is defined.

      #if __STDC_VERSION__ < 199901L
      # if __GNUC__ >= 2
      #  define __func__ __FUNCTION__
      # else
      #  define __func__ "<unknown>"
      # endif
      #endif

`__PRETTY_FUNCTION__`

  This is equivalent to `__FUNCTION__` in C, but in C`++` the string includes argument type information as well. It is a GNU C extension.

Those features are useful in generating an error message to report an inconsistency detected by the program; the message can state the source line where the inconsistency was detected. For example,

    fprintf (stderr, "Internal error: "
                     "negative string length "
                     "in function %s "
                     "%d at %s, line %d.",
             __func__, length, __FILE__, __LINE__);

A `#line` directive changes `__LINE__`, and may change `__FILE__` as well. See Line Control.

`__DATE__`

  This macro expands to a string constant that describes the date of compilation. The string constant contains eleven characters and looks like `"Feb 12 1996"`. If the day of the month is just one digit, an extra space precedes it so that the date is always eleven characters.

  If the compiler cannot determine the current date, it emits a warning messages (once per compilation) and `__DATE__` expands to `"??? ?? ????"`.

  We deprecate the use of `__DATE__` for the sake of reproducible compilation.

`__TIME__`

  This macro expands to a string constant that describes the time of compilation. The string constant contains eight characters and looks like `"23:59:01"`.

  If the compiler cannot determine the current time, it emits a warning message (once per compilation) and `__TIME__` expands to `"??:??:??"`.

  We deprecate the use of `__TIME__` for the sake of reproducible compilation.

`__STDC__`

  In normal operation, this macro expands to the constant 1, to signify that this compiler implements ISO Standard C.

`__STDC_VERSION__`

  This macro expands to the C Standard’s version number, a long integer constant of the form `yyyymmL` where yyyy and mm are the year and month of the Standard version. This states which version of the C Standard the compiler implements.

  The current default value is `201112L`, which signifies the C 2011 standard.

`__STDC_HOSTED__`

  This macro is defined, with value 1, if the compiler’s target is a hosted environment. A hosted environment provides the full facilities of the standard C library.

The rest of the predefined macros are GNU C extensions.

`__COUNTER__`

  This macro expands to sequential integral values starting from 0. In other words, each time the program uses this macro, it generates the next successive integer. This, with the `##` preprocessing operator, provides a convenient means for macros to generate unique identifiers.

`__GNUC__`
`__GNUC_MINOR__`
`__GNUC_PATCHLEVEL__`

  These macros expand to the major version, minor version, and patch level of the compiler, as integer constants. For example, GCC 3.2.1 expands `__GNUC__` to 3, `__GNUC_MINOR__` to 2, and `__GNUC_PATCHLEVEL__` to 1.

  If all you need to know is whether or not your program is being compiled by GCC, or a non-GCC compiler that claims to accept the GNU C extensions, you can simply test `__GNUC__`. If you need to write code that depends on a specific version, you must check more carefully. Each change in the minor version resets the patch level to zero; each change in the major version (which happens rarely) resets the minor version and the patch level to zero. To use the predefined macros directly in the conditional, write it like this:

      /* Test for version 3.2.0 or later. */
      #if __GNUC__ > 3 || \
          (__GNUC__ == 3 && (__GNUC_MINOR__ > 2 || \
                             (__GNUC_MINOR__ == 2 && \
                              __GNUC_PATCHLEVEL__ > 0))

  Another approach is to use the predefined macros to calculate a single number, then compare that against a threshold:

      #define GCC_VERSION (__GNUC__ * 10000 \
                           + __GNUC_MINOR__ * 100 \
                           + __GNUC_PATCHLEVEL__)
      /* ... */
      /* Test for GCC > 3.2.0 */
      #if GCC_VERSION > 30200

  Many people find this form easier to understand.

`__VERSION__`

  This macro expands to a string constant that describes the version of the compiler in use. You should not rely on its contents’ having any particular form, but you can count on it to contain at least the release number.

`__TIMESTAMP__`

  This macro expands to a string constant that describes the date and time of the last modification of the current source file. The string constant contains abbreviated day of the week, month, day of the month, time in hh:mm:ss form, and the year, in the format `"Sun Sep 16 01:03:52 1973"`. If the day of the month is less than 10, it is padded with a space on the left.

  If GCC cannot determine that information date, it emits a warning message (once per compilation) and `__TIMESTAMP__` expands to `"??? ??? ?? ??:??:?? ????"`.

  We deprecate the use of this macro for the sake of reproducible compilation.