Miscellaneous Macros
specialized macros which are not used often.
These macros provide more specialized features which are not needed so often
by application programmers.
Used to declare inline functions. If inline functions are not supported on
the particular platform, the macro evaluates to the empty string.
Used within multi-statement macros so that they can be used in places where
only one statement is expected by the compiler.
Used within multi-statement macros so that they can be used in places where
only one statement is expected by the compiler.
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.
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.
Determines the number of elements in an array. The array must be
declared so the compiler knows its size at compile-time; this
macro will not work on an array allocated on the heap, only static
arrays or arrays on the stack.
@arr: the array
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.
Accepts a macro or a string and converts it into a string.
@macro_or_string: a macro or a string.
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 option.
Expands to the GNU C const function attribute if the compiler is gcc.
Declaring a function as const enables better optimization of the function.
A const function doesn't examine any values except its parameters,
and has no effects except its return value.
See the GNU C documentation for details.
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.
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 option, the compiler will
generate warnings when deprecated interfaces are used.
See the GNU C documentation for details.
@Since: 2.2
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. See the GNU C documentation for details.
Expands to the GNU C unused function attribute if the compiler is gcc.
It is used for declaring functions which may never be used.
It avoids possible compiler warnings. See the GNU C documentation for details.
Expands to the GNU C pure function attribute if the compiler is gcc.
Declaring a function as pure enables better optimization of 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.
See the GNU C documentation for details.
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.
See the GNU C documentation for details.
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.
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.
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).
See the GNU C documentation for details.
gchar *g_dgettext (gchar *domain_name, gchar *msgid) G_GNUC_FORMAT (2);
@arg_idx: the index of the argument.
Expands to the GNU C __FUNCTION__ variable if the
compiler is gcc, or "" if it isn't. The GNU C
__FUNCTION__ variable contains the name of the
current function. See the GNU C documentation for details.
Expands to the GNU C __PRETTY_FUNCTION__ variable
if the compiler is gcc, or "" if it isn't.
The GNU C __PRETTY_FUNCTION__ variable contains the
name of the current function. For a C program this is the same as the
__FUNCTION__ variable but for C++ it also includes
extra information such as the class and function prototype. See the
GNU C documentation for details.
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
option.
See the GNU C documentation for details.
Hints the compiler that the expression is likely to evaluate to a true
value. The compiler may use this information for optimizations.
if (G_LIKELY (random () != 1))
g_print ("not one");
@expr: the expression
@Since: 2.2
Hints the compiler that the expression is unlikely to evaluate to a true
value. The compiler may use this information for optimizations.
if (G_UNLIKELY (random () == 1))
g_print ("a random one");
@expr: the expression
@Since: 2.2
Expands to a string identifying the current code position.
The platform dependent length modifier for constructing printf() conversion
specifiers for values of type #gint16. It is a string literal, but doesn't
include the percent-sign, such that you can add precision and length
modifiers between percent-sign and conversion specifier and append a
conversion specifier.
The following example prints "0x7b";
gint16 value = 123;
g_print ("%#" G_GINT16_MODIFIER "x", value);
@Since: 2.4
This is the platform dependent conversion specifier for scanning and
printing values of type #gint16. It is a string literal, but doesn't
include the percent-sign, such that you can add precision and length
modifiers between percent-sign and conversion specifier.
gint16 in;
gint32 out;
sscanf ("42", "%" G_GINT16_FORMAT, &in)
out = in * 1000;
g_print ("%" G_GINT32_FORMAT, out);
This is the platform dependent conversion specifier for scanning and
printing values of type #guint16. See also #G_GINT16_FORMAT.
The platform dependent length modifier for constructing printf() conversion
specifiers for values of type #gint32. See also #G_GINT16_MODIFIER.
@Since: 2.4
This is the platform dependent conversion specifier for scanning and
printing values of type #gint32. See also #G_GINT16_FORMAT.
This is the platform dependent conversion specifier for scanning and
printing values of type #guint32. See also #G_GINT16_FORMAT.
The platform dependent length modifier for constructing printf() conversion
specifiers for values of type #gint64. See also #G_GINT16_MODIFIER.
Some platforms do not support printing 64 bit integers,
even though the types are supported. On such platforms #G_GINT64_MODIFIER
is not defined.
@Since: 2.4
This is the platform dependent conversion specifier for scanning and
printing values of type #gint64. See also #G_GINT16_FORMAT.
Some platforms do not support scanning and printing 64 bit integers,
even though the types are supported. On such platforms #G_GINT64_FORMAT
is not defined. Note that scanf() may not support 64 bit integers, even
if #G_GINT64_FORMAT is defined. Due to its weak error handling, scanf() is not
recommended for parsing anyway; consider using g_strtoull() instead.
This is the platform dependent conversion specifier for scanning and
printing values of type #guint64. See also #G_GINT16_FORMAT.
Some platforms do not support scanning and printing 64 bit integers,
even though the types are supported. On such platforms #G_GUINT64_FORMAT
is not defined. Note that scanf() may not support 64 bit integers, even
if #G_GINT64_FORMAT is defined. Due to its weak error handling, scanf() is not
recommended for parsing anyway; consider using g_strtoull() instead.