Go to the previous, next section.
GNU C provides several language features not found in ANSI standard C.
(The `-pedantic' option directs GNU CC to print a warning message if
any of these features is used.) To test for the availability of these
features in conditional compilation, check for a predefined macro
__GNUC__, which is always defined under GNU CC.
These extensions are available in C and in the languages derived from it, C++ and Objective C. @xref{ C++ Language}, for extensions that apply only to C++.
A compound statement enclosed in parentheses may appear as an expression in GNU C. This allows you to use loops, switches, and local variables within an expression.
Recall that a compound statement is a sequence of statements surrounded by braces; in this construct, parentheses go around the braces. For example:
({ int y = foo (); int z;
if (y > 0) z = y;
else z = - y;
z; })
is a valid (though slightly more complex than necessary) expression
for the absolute value of foo ().
The last thing in the compound statement should be an expression
followed by a semicolon; the value of this subexpression serves as the
value of the entire construct. (If you use some other kind of statement
last within the braces, the construct has type void, and thus
effectively no value.)
This feature is especially useful in making macro definitions "safe" (so that they evaluate each operand exactly once). For example, the "maximum" function is commonly defined as a macro in standard C as follows:
#define max(a,b) ((a) > (b) ? (a) : (b))
But this definition computes either a or b twice, with bad
results if the operand has side effects. In GNU C, if you know the
type of the operands (here let's assume int), you can define
the macro safely as follows:
#define maxint(a,b) \
({int _a = (a), _b = (b); _a > _b ? _a : _b; 2)
Embedded statements are not allowed in constant expressions, such as the value of an enumeration constant, the width of a bit field, or the initial value of a static variable.
If you don't know the type of the operand, you can still do this, but you
must use typeof (see section Referring to a Type with typeof) or type naming (see section Naming an Expression's Type).
Each statement expression is a scope in which local labels can be
declared. A local label is simply an identifier; you can jump to it
with an ordinary goto statement, but only from within the
statement expression it belongs to.
A local label declaration looks like this:
__label__ label;
or
__label__ label1, label2, ...;
Local label declarations must come at the beginning of the statement expression, right after the `({', before any ordinary declarations.
The label declaration defines the label name, but does not define
the label itself. You must do this in the usual way, with
label:, within the statements of the statement expression.
The local label feature is useful because statement expressions are
often used in macros. If the macro contains nested loops, a goto
can be useful for breaking out of them. However, an ordinary label
whose scope is the whole function cannot be used: if the macro can be
expanded several times in one function, the label will be multiply
defined in that function. A local label avoids this problem. For
example:
#define SEARCH(array, target) \
({ \
__label__ found; \
typeof (target) _SEARCH_target = (target); \
typeof (*(array)) *_SEARCH_array = (array); \
int i, j; \
int value; \
for (i = 0; i < max; i++) \
for (j = 0; j < max; j++) \
if (_SEARCH_array[i][j] == _SEARCH_target) \
{ value = i; goto found; 2 \
value = -1; \
found: \
value; \
})
You can get the address of a label defined in the current function
(or a containing function) with the unary operator `&&'. The
value has type void *. This value is a constant and can be used
wherever a constant of that type is valid. For example:
void *ptr; ... ptr = &&foo;
To use these values, you need to be able to jump to one. This is done
with the computed goto statement(2), goto *exp;. For example,
goto *ptr;
Any expression of type void * is allowed.
One way of using these constants is in initializing a static array that will serve as a jump table:
static void *array[] = { &&foo, &&bar, &&hack 2;
Then you can select a label with indexing, like this:
goto *array[i];
Note that this does not check whether the subscript is in bounds--array indexing in C never does that.
Such an array of label values serves a purpose much like that of the
switch statement. The switch statement is cleaner, so
use that rather than an array unless the problem does not fit a
switch statement very well.
Another use of label values is in an interpreter for threaded code. The labels within the interpreter function can be stored in the threaded code for super-fast dispatching.
You can use this mechanism to jump to code in a different function. If you do that, totally unpredictable things will happen. The best way to avoid this is to store the label address only in automatic variables and never pass it as an argument.
A nested function is a function defined inside another function.
(Nested functions are not supported for GNU C++.) The nested function's
name is local to the block where it is defined. For example, here we
define a nested function named square, and call it twice:
foo (double a, double b)
{
double square (double z) { return z * z; 2
return square (a) + square (b);
}
The nested function can access all the variables of the containing
function that are visible at the point of its definition. This is
called lexical scoping. For example, here we show a nested
function which uses an inherited variable named offset:
bar (int *array, int offset, int size)
{
int access (int *array, int index)
{ return array[index + offset]; 2
int i;
...
for (i = 0; i < size; i++)
... access (array, i) ...
}
Nested function definitions are permitted within functions in the places where variable definitions are allowed; that is, in any block, before the first statement in the block.
It is possible to call the nested function from outside the scope of its name by storing its address or passing the address to another function:
hack (int *array, int size)
{
void store (int index, int value)
{ array[index] = value; 2
intermediate (store, size);
}
Here, the function intermediate receives the address of
store as an argument. If intermediate calls store,
the arguments given to store are used to store into array.
But this technique works only so long as the containing function
(hack, in this example) does not exit.
If you try to call the nested function through its address after the containing function has exited, all hell will break loose. If you try to call it after a containing scope level has exited, and if it refers to some of the variables that are no longer in scope, you may be lucky, but it's not wise to take the risk. If, however, the nested function does not refer to anything that has gone out of scope, you should be safe.
GNU CC implements taking the address of a nested function using a technique called trampolines. A paper describing them is available from `maya.idiap.ch' in directory `pub/tmb', file `usenix88-lexic.ps.Z'.
A nested function can jump to a label inherited from a containing
function, provided the label was explicitly declared in the containing
function (see section Locally Declared Labels). Such a jump returns instantly to the
containing function, exiting the nested function which did the
goto and any intermediate functions as well. Here is an example:
bar (int *array, int offset, int size)
{
__label__ failure;
int access (int *array, int index)
{
if (index > size)
goto failure;
return array[index + offset];
}
int i;
...
for (i = 0; i < size; i++)
... access (array, i) ...
...
return 0;
/* Control comes here from access
if it detects an error. */
failure:
return -1;
}
A nested function always has internal linkage. Declaring one with
extern is erroneous. If you need to declare the nested function
before its definition, use auto (which is otherwise meaningless
for function declarations).
bar (int *array, int offset, int size)
{
__label__ failure;
auto int access (int *, int);
...
int access (int *array, int index)
{
if (index > size)
goto failure;
return array[index + offset];
}
...
}
Using the built-in functions described below, you can record