Miscellaneous Macros

## Miscellaneous Macros Miscellaneous Macros — specialized macros which are not used often |

## Synopsis

    #include <glib.h>

    #define             G_INLINE_FUNC

    #define             G_STMT_START
    #define             G_STMT_END

    #define             G_BEGIN_DECLS
    #define             G_END_DECLS

    #define             G_VA_COPY                           (ap1,
                                                             ap2)

    #define             G_STRINGIFY                         (macro_or_string)
    #define             G_PASTE                             (identifier1,
                                                             identifier2)
    #define             G_STATIC_ASSERT                     (expr)
    #define             G_STATIC_ASSERT_EXPR                (expr)

    #define             G_GNUC_EXTENSION
    #define             G_GNUC_CONST
    #define             G_GNUC_PURE
    #define             G_GNUC_MALLOC
    #define             G_GNUC_ALLOC_SIZE                   (x)
    #define             G_GNUC_ALLOC_SIZE2                  (x,
                                                             y)
    #define             G_GNUC_DEPRECATED
    #define             G_GNUC_DEPRECATED_FOR               (f)
    #define             G_GNUC_BEGIN_IGNORE_DEPRECATIONS
    #define             G_GNUC_END_IGNORE_DEPRECATIONS
    #define             G_GNUC_NORETURN
    #define             G_GNUC_UNUSED
    #define             G_GNUC_PRINTF                       (format_idx,
                                                             arg_idx)
    #define             G_GNUC_SCANF                        (format_idx,
                                                             arg_idx)
    #define             G_GNUC_FORMAT                       (arg_idx)
    #define             G_GNUC_NULL_TERMINATED
    #define             G_GNUC_WARN_UNUSED_RESULT
    #define             G_GNUC_FUNCTION
    #define             G_GNUC_PRETTY_FUNCTION
    #define             G_GNUC_NO_INSTRUMENT
    #define             G_HAVE_GNUC_VISIBILITY
    #define             G_GNUC_INTERNAL
    #define             G_GNUC_MAY_ALIAS

    #define             G_DEPRECATED
    #define             G_DEPRECATED_FOR                    (f)
    #define             G_UNAVAILABLE                       (maj,
                                                             min)

    #define             G_LIKELY                            (expr)
    #define             G_UNLIKELY                          (expr)

    #define             G_STRLOC
    #define             G_STRFUNC

## Description

These macros provide more specialized features which are not needed so often by application programmers.

## Details

### G_INLINE_FUNC

    #  define G_INLINE_FUNC _GLIB_EXTERN

This macro is used to export function prototypes so they can be linked with an external version when no inlining is performed. The file which implements the functions should define `G_IMPLEMENTS_INLINES` before including the headers which contain `G_INLINE_FUNC` declarations. Since inlining is very compiler-dependent using these macros correctly is very difficult. Their use is strongly discouraged.

This macro is often mistaken for a replacement for the inline keyword; inline is already declared in a portable manner in the GLib headers and can be used normally.

### G_STMT_START

    #  define G_STMT_START  do

Used within multi-statement macros so that they can be used in places where only one statement is expected by the compiler.

### G_STMT_END

    #  define G_STMT_END    while (0)

Used within multi-statement macros so that they can be used in places where only one statement is expected by the compiler.

### G_BEGIN_DECLS

    # define G_BEGIN_DECLS  extern "C" {

Used (along with G_END_DECLS) to bracket header files. If the compiler in use is a C++ compiler, adds `extern "C"` around the header.

### G_END_DECLS

    # define G_END_DECLS    }

Used (along with G_BEGIN_DECLS) to bracket header files. If the compiler in use is a C++ compiler, adds `extern "C"` around the header.

### G_VA_COPY()

    #define             G_VA_COPY(ap1,ap2)

Portable way to copy va_list variables.

In order to use this function, you must include `string.h` yourself, because this macro may use `memmove()` and GLib does not include `string.h` for you.

`ap1` : | the va_list variable to place a copy of `ap2` in
`ap2` : | a va_list

### G_STRINGIFY()

    #define G_STRINGIFY(macro_or_string) G_STRINGIFY_ARG (macro_or_string)

Accepts a macro or a string and converts it into a string after preprocessor argument expansion. For example, the following code:

    1
    2
    #define AGE 27
    const gchar *greeting = G_STRINGIFY (AGE) " today!";

is transformed by the preprocessor into (code equivalent to):

    1
    const gchar *greeting = "27 today!";

`macro_or_string` : | a macro or a string

### G_PASTE()

    #define G_PASTE(identifier1,identifier2)      G_PASTE_ARGS (identifier1, identifier2)

Yields a new preprocessor pasted identifier `identifier1identifier2` from its expanded arguments `identifier1` and `identifier2`. For example, the following code:

    1
    2
    3
    4
    #define GET(traveller,method) G_PASTE(traveller_get_, method) (traveller)
    const gchar *name = GET (traveller, name);
    const gchar *quest = GET (traveller, quest);
    GdkColor *favourite = GET (traveller, favourite_colour);

is transformed by the preprocessor into:

    1
    2
    3
    const gchar *name = traveller_get_name (traveller);
    const gchar *quest = traveller_get_quest (traveller);
    GdkColor *favourite = traveller_get_favourite_colour (traveller);

`identifier1` : | an identifier
`identifier2` : | an identifier

Since 2.20

### G_STATIC_ASSERT()

    #define G_STATIC_ASSERT(expr) typedef char G_PASTE (_GStaticAssertCompileTimeAssertion_, __COUNTER__)[(expr) ? 1 : -1] G_GNUC_UNUSED

The G_STATIC_ASSERT macro lets the programmer check a condition at compile time, the condition needs to be compile time computable. The macro can be used in any place where a `typedef` is valid.

### Note

A `typedef` is generally allowed in exactly the same places that a variable declaration is allowed. For this reason, you should not use `G_STATIC_ASSERT` in the middle of blocks of code.

The macro should only be used once per source code line.

`expr` : | a constant expression

Since 2.20

### G_STATIC_ASSERT_EXPR()

    #define G_STATIC_ASSERT_EXPR(expr) ((void) sizeof (char[(expr) ? 1 : -1]))

The G_STATIC_ASSERT_EXPR macro lets the programmer check a condition at compile time. The condition needs to be compile time computable.

Unlike `G_STATIC_ASSERT`, this macro evaluates to an expression and, as such, can be used in the middle of other expressions. Its value should be ignored. This can be accomplished by placing it as the first argument of a comma expression.

    1
    2
    #define ADD_ONE_TO_INT(x) \
      (G_STATIC_ASSERT_EXPR(sizeof (x) == sizeof (int)), ((x) + 1))

`expr` : | a constant expression

Since 2.30

### G_GNUC_EXTENSION

    #  define G_GNUC_EXTENSION __extension__

Expands to `__extension__` when gcc is used as the compiler. This simply tells gcc not to warn about the following non-standard code when compiling with the `-pedantic` option.

### G_GNUC_CONST

    #define             G_GNUC_CONST

Expands to the GNU C `const` function attribute if the compiler is gcc. Declaring a function as const enables better optimization of calls to the function. A const function doesn't examine any values except its parameters, and has no effects except its return value.

Place the attribute after the declaration, just before the semicolon.

See the GNU C documentation for more details.

### Note

A function that has pointer arguments and examines the data pointed to must not be declared const. Likewise, a function that calls a non-const function usually must not be const. It doesn't make sense for a const function to return void.

### G_GNUC_PURE

    #define             G_GNUC_PURE

Expands to the GNU C `pure` function attribute if the compiler is gcc. Declaring a function as pure enables better optimization of calls to the function. A pure function has no effects except its return value and the return value depends only on the parameters and/or global variables.

Place the attribute after the declaration, just before the semicolon.

See the GNU C documentation for more details.

### G_GNUC_MALLOC

    #define             G_GNUC_MALLOC

Expands to the GNU C `malloc` function attribute if the compiler is gcc. Declaring a function as malloc enables better optimization of the function. A function can have the malloc attribute if it returns a pointer which is guaranteed to not alias with any other pointer when the function returns (in practice, this means newly allocated memory).

Place the attribute after the declaration, just before the semicolon.

See the GNU C documentation for more details.

Since 2.6

### G_GNUC_ALLOC_SIZE()

    #define G_GNUC_ALLOC_SIZE(x) __attribute__((__alloc_size__(x)))

Expands to the GNU C `alloc_size` function attribute if the compiler is a new enough gcc. This attribute tells the compiler that the function returns a pointer to memory of a size that is specified by the `x`th function parameter.

Place the attribute after the function declaration, just before the semicolon.

See the GNU C documentation for more details.

`x` : | the index of the argument specifying the allocation size

Since 2.18

### G_GNUC_ALLOC_SIZE2()

    #define G_GNUC_ALLOC_SIZE2(x,y) __attribute__((__alloc_size__(x,y)))

Expands to the GNU C `alloc_size` function attribute if the compiler is a new enough gcc. This attribute tells the compiler that the function returns a pointer to memory of a size that is specified by the product of two function parameters.

Place the attribute after the function declaration, just before the semicolon.

See the GNU C documentation for more details.

`x` : | the index of the argument specifying one factor of the allocation size
`y` : | the index of the argument specifying the second factor of the allocation size

Since 2.18

### G_GNUC_DEPRECATED

    #define             G_GNUC_DEPRECATED

Expands to the GNU C `deprecated` attribute if the compiler is gcc. It can be used to mark typedefs, variables and functions as deprecated. When called with the `-Wdeprecated-declarations` option, the compiler will generate warnings when deprecated interfaces are used.

Place the attribute after the declaration, just before the semicolon.

See the GNU C documentation for more details.

Since 2.2

### G_GNUC_DEPRECATED_FOR()

    #define             G_GNUC_DEPRECATED_FOR(f)

Like `G_GNUC_DEPRECATED`, but names the intended replacement for the deprecated symbol if the version of gcc in use is new enough to support custom deprecation messages.

Place the attribute after the declaration, just before the semicolon.

See the GNU C documentation for more details.

Note that if `f` is a macro, it will be expanded in the warning message. You can enclose it in quotes to prevent this. (The quotes will show up in the warning, but it's better than showing the macro expansion.)

`f` : | the intended replacement for the deprecated symbol, such as the name of a function

Since 2.26

### G_GNUC_BEGIN_IGNORE_DEPRECATIONS

    #define             G_GNUC_BEGIN_IGNORE_DEPRECATIONS

Tells gcc (if it is a new enough version) to temporarily stop emitting warnings when functions marked with `G_GNUC_DEPRECATED` or `G_GNUC_DEPRECATED_FOR` are called. This is useful for when you have one deprecated function calling another one, or when you still have regression tests for deprecated functions.

Use `G_GNUC_END_IGNORE_DEPRECATIONS` to begin warning again. (If you are not compiling with `-Wdeprecated-declarations` then neither macro has any effect.)

This macro can be used either inside or outside of a function body, but must appear on a line by itself.

Since 2.32

### G_GNUC_END_IGNORE_DEPRECATIONS

    #define             G_GNUC_END_IGNORE_DEPRECATIONS

Undoes the effect of `G_GNUC_BEGIN_IGNORE_DEPRECATIONS`, telling gcc to begin outputting warnings again (assuming those warnings had been enabled to begin with).

This macro can be used either inside or outside of a function body, but must appear on a line by itself.

Since 2.32

### G_GNUC_NORETURN

    #define             G_GNUC_NORETURN

Expands to the GNU C `noreturn` function attribute if the compiler is gcc. It is used for declaring functions which never return. It enables optimization of the function, and avoids possible compiler warnings.

Place the attribute after the declaration, just before the semicolon.

See the GNU C documentation for more details.

### G_GNUC_UNUSED

    #define             G_GNUC_UNUSED

Expands to the GNU C `unused` function attribute if the compiler is gcc. It is used for declaring functions and arguments which may never be used. It avoids possible compiler warnings.

For functions, place the attribute after the declaration, just before the semicolon. For arguments, place the attribute at the beginning of the argument declaration.

    1
    2
    void my_unused_function (G_GNUC_UNUSED gint unused_argument,
                             gint other_argument) G_GNUC_UNUSED;

See the GNU C documentation for more details.

### G_GNUC_PRINTF()

    #define             G_GNUC_PRINTF( format_idx, arg_idx )

Expands to the GNU C `format` function attribute if the compiler is gcc. This is used for declaring functions which take a variable number of arguments, with the same syntax as `printf()`. It allows the compiler to type-check the arguments passed to the function.

Place the attribute after the function declaration, just before the semicolon.

See the GNU C documentation for more details.

    1
    2
    3
    4
    gint g_snprintf (gchar  *string,
                     gulong       n,
                     gchar const *format,
                     ...) G_GNUC_PRINTF (3, 4);

`format_idx` : | the index of the argument corresponding to the format string (The arguments are numbered from 1)
`arg_idx` : | the index of the first of the format arguments

### G_GNUC_SCANF()

    #define             G_GNUC_SCANF( format_idx, arg_idx )

Expands to the GNU C `format` function attribute if the compiler is gcc. This is used for declaring functions which take a variable number of arguments, with the same syntax as `scanf()`. It allows the compiler to type-check the arguments passed to the function. See the GNU C documentation for details.

`format_idx` : | the index of the argument corresponding to the format string (The arguments are numbered from 1)
`arg_idx` : | the index of the first of the format arguments

### G_GNUC_FORMAT()

    #define             G_GNUC_FORMAT( arg_idx )

Expands to the GNU C `format_arg` function attribute if the compiler is gcc. This function attribute specifies that a function takes a format string for a `printf()`, `scanf()`, `strftime()` or `strfmon()` style function and modifies it, so that the result can be passed to a `printf()`, `scanf()`, `strftime()` or `strfmon()` style function (with the remaining arguments to the format function the same as they would have been for the unmodified string).

Place the attribute after the function declaration, just before the semicolon.

See the GNU C documentation for more details.

    1
    gchar *g_dgettext (gchar *domain_name, gchar *msgid) G_GNUC_FORMAT (2);

`arg_idx` : | the index of the argument

### G_GNUC_NULL_TERMINATED

    #define G_GNUC_NULL_TERMINATED __attribute__((__sentinel__))

Expands to the GNU C `sentinel` function attribute if the compiler is gcc, or "" if it isn't. This function attribute only applies to variadic functions and instructs the compiler to check that the argument list is terminated with an explicit `NULL`.

Place the attribute after the declaration, just before the semicolon.

See the GNU C documentation for more details.

Since 2.8

### G_GNUC_WARN_UNUSED_RESULT

    #define             G_GNUC_WARN_UNUSED_RESULT

Expands to the GNU C `warn_unused_result` function attribute if the compiler is gcc, or "" if it isn't. This function attribute makes the compiler emit a warning if the result of a function call is ignored.

Place the attribute after the declaration, just before the semicolon.

See the GNU C documentation for more details.

Since 2.10

### G_GNUC_FUNCTION

    #define G_GNUC_FUNCTION         __FUNCTION__

### Warning

`G_GNUC_FUNCTION` has been deprecated since version 2.16 and should not be used in newly-written code. Use G_STRFUNC instead

Expands to "" on all modern compilers, and to `__FUNCTION__` on gcc version 2.x. Don't use it.

### G_GNUC_PRETTY_FUNCTION

    #define G_GNUC_PRETTY_FUNCTION  __PRETTY_FUNCTION__

### Warning

`G_GNUC_PRETTY_FUNCTION` has been deprecated since version 2.16 and should not be used in newly-written code. Use G_STRFUNC instead

Expands to "" on all modern compilers, and to `__PRETTY_FUNCTION__` on gcc version 2.x. Don't use it.

### G_GNUC_NO_INSTRUMENT

    #define             G_GNUC_NO_INSTRUMENT

Expands to the GNU C `no_instrument_function` function attribute if the compiler is gcc. Functions with this attribute will not be instrumented for profiling, when the compiler is called with the `-finstrument-functions` option.

Place the attribute after the declaration, just before the semicolon.

See the GNU C documentation for more details.

### G_HAVE_GNUC_VISIBILITY

    #define G_HAVE_GNUC_VISIBILITY 1

### G_GNUC_INTERNAL

    #define G_GNUC_INTERNAL __attribute__((visibility("hidden")))

This attribute can be used for marking library functions as being used internally to the library only, which may allow the compiler to handle function calls more efficiently. Note that static functions do not need to be marked as internal in this way. See the GNU C documentation for details.

When using a compiler that supports the GNU C hidden visibility attribute, this macro expands to `__attribute__((visibility("hidden")))`. When using the Sun Studio compiler, it expands to `__hidden`.

Note that for portability, the attribute should be placed before the function declaration. While GCC allows the macro after the declaration, Sun Studio does not.

    1
    2
    3
    4
    5
    G_GNUC_INTERNAL
    void _g_log_fallback_handler (const gchar    *log_domain,
                                  GLogLevelFlags  log_level,
                                  const gchar    *message,
                                  gpointer        unused_data);

Since 2.6

### G_GNUC_MAY_ALIAS

    #  define G_GNUC_MAY_ALIAS __attribute__((may_alias))

Expands to the GNU C `may_alias` type attribute if the compiler is gcc. Types with this attribute will not be subjected to type-based alias analysis, but are assumed to alias with any other type, just like char. See the GNU C documentation for details.

Since 2.14

### G_DEPRECATED

    #define G_DEPRECATED __attribute__((__deprecated__))

This macro is similar to `G_GNUC_DEPRECATED`, and can be used to mark functions declarations as deprecated. Unlike `G_GNUC_DEPRECATED`, it is meant to be portable across different compilers and must be placed before the function declaration.

Since 2.32

### G_DEPRECATED_FOR()

    #define G_DEPRECATED_FOR(f) __attribute__((__deprecated__("Use '" #f "' instead")))

This macro is similar to `G_GNUC_DEPRECATED_FOR`, and can be used to mark functions declarations as deprecated. Unlike `G_GNUC_DEPRECATED_FOR`, it is meant to be portable across different compilers and must be placed before the function declaration.

`f` : | the name of the function that this function was deprecated for

Since 2.32

### G_UNAVAILABLE()

    #define G_UNAVAILABLE(maj,min) __attribute__((deprecated("Not available before " #maj "." #min)))

This macro can be used to mark a function declaration as unavailable. It must be placed before the function declaration. Use of a function that has been annotated with this macros will produce a compiler warning.

`maj` : | the major version that introduced the symbol
`min` : | the minor version that introduced the symbol

Since 2.32

### G_LIKELY()

    #define G_LIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 1))

Hints the compiler that the expression is likely to evaluate to a true value. The compiler may use this information for optimizations.

    1
    2
    if (G_LIKELY (random () != 1))
      g_print ("not one");

`expr` : | the expression
Returns : | the value of `expr`

Since 2.2

### G_UNLIKELY()

    #define G_UNLIKELY(expr) (__builtin_expect (_G_BOOLEAN_EXPR(expr), 0))

Hints the compiler that the expression is unlikely to evaluate to a true value. The compiler may use this information for optimizations.

    1
    2
    if (G_UNLIKELY (random () == 1))
      g_print ("a random one");

`expr` : | the expression
Returns : | the value of `expr`

Since 2.2

### G_STRLOC

    #  define G_STRLOC __FILE__ ":" G_STRINGIFY (__LINE__) ":" __PRETTY_FUNCTION__ "()"

Expands to a string identifying the current code position.

### G_STRFUNC

    #  define G_STRFUNC     ((const char*) (__PRETTY_FUNCTION__))

Expands to a string identifying the current function.

Since 2.4