Subversion Repositories openrisc

@c Copyright (C) 1988, 1989, 1992, 1993, 1994, 1996, 1998, 1999, 2000,

@c Copyright (C) 1988, 1989, 1992, 1993, 1994, 1996, 1998, 1999, 2000,

@c 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.

@c 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.

@c This is part of the GCC manual.

@c This is part of the GCC manual.

@c For copying conditions, see the file gcc.texi.

@c For copying conditions, see the file gcc.texi.

@node C Extensions

@node C Extensions

@chapter Extensions to the C Language Family

@chapter Extensions to the C Language Family

@cindex extensions, C language

@cindex extensions, C language

@cindex C language extensions

@cindex C language extensions

@opindex pedantic

@opindex pedantic

GNU C provides several language features not found in ISO standard C@.

GNU C provides several language features not found in ISO standard C@.

(The @option{-pedantic} option directs GCC to print a warning message if

(The @option{-pedantic} option directs GCC to print a warning message if

any of these features is used.)  To test for the availability of these

any of these features is used.)  To test for the availability of these

features in conditional compilation, check for a predefined macro

features in conditional compilation, check for a predefined macro

@code{__GNUC__}, which is always defined under GCC@.

@code{__GNUC__}, which is always defined under GCC@.

These extensions are available in C and Objective-C@.  Most of them are

These extensions are available in C and Objective-C@.  Most of them are

also available in C++.  @xref{C++ Extensions,,Extensions to the

also available in C++.  @xref{C++ Extensions,,Extensions to the

C++ Language}, for extensions that apply @emph{only} to C++.

C++ Language}, for extensions that apply @emph{only} to C++.

Some features that are in ISO C99 but not C89 or C++ are also, as

Some features that are in ISO C99 but not C89 or C++ are also, as

extensions, accepted by GCC in C89 mode and in C++.

extensions, accepted by GCC in C89 mode and in C++.

@menu

@menu

* Statement Exprs::     Putting statements and declarations inside expressions.

* Statement Exprs::     Putting statements and declarations inside expressions.

* Local Labels::        Labels local to a block.

* Local Labels::        Labels local to a block.

* Labels as Values::    Getting pointers to labels, and computed gotos.

* Labels as Values::    Getting pointers to labels, and computed gotos.

* Nested Functions::    As in Algol and Pascal, lexical scoping of functions.

* Nested Functions::    As in Algol and Pascal, lexical scoping of functions.

* Constructing Calls::  Dispatching a call to another function.

* Constructing Calls::  Dispatching a call to another function.

* Typeof::              @code{typeof}: referring to the type of an expression.

* Typeof::              @code{typeof}: referring to the type of an expression.

* Conditionals::        Omitting the middle operand of a @samp{?:} expression.

* Conditionals::        Omitting the middle operand of a @samp{?:} expression.

* Long Long::           Double-word integers---@code{long long int}.

* Long Long::           Double-word integers---@code{long long int}.

* Complex::             Data types for complex numbers.

* Complex::             Data types for complex numbers.

* Decimal Float::       Decimal Floating Types.

* Decimal Float::       Decimal Floating Types.

* Hex Floats::          Hexadecimal floating-point constants.

* Hex Floats::          Hexadecimal floating-point constants.

* Zero Length::         Zero-length arrays.

* Zero Length::         Zero-length arrays.

* Variable Length::     Arrays whose length is computed at run time.

* Variable Length::     Arrays whose length is computed at run time.

* Empty Structures::    Structures with no members.

* Empty Structures::    Structures with no members.

* Variadic Macros::     Macros with a variable number of arguments.

* Variadic Macros::     Macros with a variable number of arguments.

* Escaped Newlines::    Slightly looser rules for escaped newlines.

* Escaped Newlines::    Slightly looser rules for escaped newlines.

* Subscripting::        Any array can be subscripted, even if not an lvalue.

* Subscripting::        Any array can be subscripted, even if not an lvalue.

* Pointer Arith::       Arithmetic on @code{void}-pointers and function pointers.

* Pointer Arith::       Arithmetic on @code{void}-pointers and function pointers.

* Initializers::        Non-constant initializers.

* Initializers::        Non-constant initializers.

* Compound Literals::   Compound literals give structures, unions

* Compound Literals::   Compound literals give structures, unions

                         or arrays as values.

                         or arrays as values.

* Designated Inits::    Labeling elements of initializers.

* Designated Inits::    Labeling elements of initializers.

* Cast to Union::       Casting to union type from any member of the union.

* Cast to Union::       Casting to union type from any member of the union.

* Case Ranges::         `case 1 ... 9' and such.

* Case Ranges::         `case 1 ... 9' and such.

* Mixed Declarations::  Mixing declarations and code.

* Mixed Declarations::  Mixing declarations and code.

* Function Attributes:: Declaring that functions have no side effects,

* Function Attributes:: Declaring that functions have no side effects,

                         or that they can never return.

                         or that they can never return.

* Attribute Syntax::    Formal syntax for attributes.

* Attribute Syntax::    Formal syntax for attributes.

* Function Prototypes:: Prototype declarations and old-style definitions.

* Function Prototypes:: Prototype declarations and old-style definitions.

* C++ Comments::        C++ comments are recognized.

* C++ Comments::        C++ comments are recognized.

* Dollar Signs::        Dollar sign is allowed in identifiers.

* Dollar Signs::        Dollar sign is allowed in identifiers.

* Character Escapes::   @samp{\e} stands for the character @key{ESC}.

* Character Escapes::   @samp{\e} stands for the character @key{ESC}.

* Variable Attributes:: Specifying attributes of variables.

* Variable Attributes:: Specifying attributes of variables.

* Type Attributes::     Specifying attributes of types.

* Type Attributes::     Specifying attributes of types.

* Alignment::           Inquiring about the alignment of a type or variable.

* Alignment::           Inquiring about the alignment of a type or variable.

* Inline::              Defining inline functions (as fast as macros).

* Inline::              Defining inline functions (as fast as macros).

* Extended Asm::        Assembler instructions with C expressions as operands.

* Extended Asm::        Assembler instructions with C expressions as operands.

                         (With them you can define ``built-in'' functions.)

                         (With them you can define ``built-in'' functions.)

* Constraints::         Constraints for asm operands

* Constraints::         Constraints for asm operands

* Asm Labels::          Specifying the assembler name to use for a C symbol.

* Asm Labels::          Specifying the assembler name to use for a C symbol.

* Explicit Reg Vars::   Defining variables residing in specified registers.

* Explicit Reg Vars::   Defining variables residing in specified registers.

* Alternate Keywords::  @code{__const__}, @code{__asm__}, etc., for header files.

* Alternate Keywords::  @code{__const__}, @code{__asm__}, etc., for header files.

* Incomplete Enums::    @code{enum foo;}, with details to follow.

* Incomplete Enums::    @code{enum foo;}, with details to follow.

* Function Names::      Printable strings which are the name of the current

* Function Names::      Printable strings which are the name of the current

                         function.

                         function.

* Return Address::      Getting the return or frame address of a function.

* Return Address::      Getting the return or frame address of a function.

* Vector Extensions::   Using vector instructions through built-in functions.

* Vector Extensions::   Using vector instructions through built-in functions.

* Offsetof::            Special syntax for implementing @code{offsetof}.

* Offsetof::            Special syntax for implementing @code{offsetof}.

* Atomic Builtins::     Built-in functions for atomic memory access.

* Atomic Builtins::     Built-in functions for atomic memory access.

* Object Size Checking:: Built-in functions for limited buffer overflow

* Object Size Checking:: Built-in functions for limited buffer overflow

                        checking.

                        checking.

* Other Builtins::      Other built-in functions.

* Other Builtins::      Other built-in functions.

* Target Builtins::     Built-in functions specific to particular targets.

* Target Builtins::     Built-in functions specific to particular targets.

* Target Format Checks:: Format checks specific to particular targets.

* Target Format Checks:: Format checks specific to particular targets.

* Pragmas::             Pragmas accepted by GCC.

* Pragmas::             Pragmas accepted by GCC.

* Unnamed Fields::      Unnamed struct/union fields within structs/unions.

* Unnamed Fields::      Unnamed struct/union fields within structs/unions.

* Thread-Local::        Per-thread variables.

* Thread-Local::        Per-thread variables.

@end menu

@end menu

@node Statement Exprs

@node Statement Exprs

@section Statements and Declarations in Expressions

@section Statements and Declarations in Expressions

@cindex statements inside expressions

@cindex statements inside expressions

@cindex declarations inside expressions

@cindex declarations inside expressions

@cindex expressions containing statements

@cindex expressions containing statements

@cindex macros, statements in expressions

@cindex macros, statements in expressions

@c the above section title wrapped and causes an underfull hbox.. i

@c the above section title wrapped and causes an underfull hbox.. i

@c changed it from "within" to "in". --mew 4feb93

@c changed it from "within" to "in". --mew 4feb93

A compound statement enclosed in parentheses may appear as an expression

A compound statement enclosed in parentheses may appear as an expression

in GNU C@.  This allows you to use loops, switches, and local variables

in GNU C@.  This allows you to use loops, switches, and local variables

within an expression.

within an expression.

Recall that a compound statement is a sequence of statements surrounded

Recall that a compound statement is a sequence of statements surrounded

by braces; in this construct, parentheses go around the braces.  For

by braces; in this construct, parentheses go around the braces.  For

example:

example:

@smallexample

@smallexample

(@{ int y = foo (); int z;

(@{ int y = foo (); int z;

   if (y > 0) z = y;

   if (y > 0) z = y;

   else z = - y;

   else z = - y;

   z; @})

   z; @})

@end smallexample

@end smallexample

@noindent

@noindent

is a valid (though slightly more complex than necessary) expression

is a valid (though slightly more complex than necessary) expression

for the absolute value of @code{foo ()}.

for the absolute value of @code{foo ()}.

The last thing in the compound statement should be an expression

The last thing in the compound statement should be an expression

followed by a semicolon; the value of this subexpression serves as the

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

value of the entire construct.  (If you use some other kind of statement

last within the braces, the construct has type @code{void}, and thus

last within the braces, the construct has type @code{void}, and thus

effectively no value.)

effectively no value.)

This feature is especially useful in making macro definitions ``safe'' (so

This feature is especially useful in making macro definitions ``safe'' (so

that they evaluate each operand exactly once).  For example, the

that they evaluate each operand exactly once).  For example, the

``maximum'' function is commonly defined as a macro in standard C as

``maximum'' function is commonly defined as a macro in standard C as

follows:

follows:

@smallexample

@smallexample

#define max(a,b) ((a) > (b) ? (a) : (b))

#define max(a,b) ((a) > (b) ? (a) : (b))

@end smallexample

@end smallexample

@noindent

@noindent

@cindex side effects, macro argument

@cindex side effects, macro argument

But this definition computes either @var{a} or @var{b} twice, with bad

But this definition computes either @var{a} or @var{b} twice, with bad

results if the operand has side effects.  In GNU C, if you know the

results if the operand has side effects.  In GNU C, if you know the

type of the operands (here taken as @code{int}), you can define

type of the operands (here taken as @code{int}), you can define

the macro safely as follows:

the macro safely as follows:

@smallexample

@smallexample

#define maxint(a,b) \

#define maxint(a,b) \

  (@{int _a = (a), _b = (b); _a > _b ? _a : _b; @})

  (@{int _a = (a), _b = (b); _a > _b ? _a : _b; @})

@end smallexample

@end smallexample

Embedded statements are not allowed in constant expressions, such as

Embedded statements are not allowed in constant expressions, such as

the value of an enumeration constant, the width of a bit-field, or

the value of an enumeration constant, the width of a bit-field, or

the initial value of a static variable.

the initial value of a static variable.

If you don't know the type of the operand, you can still do this, but you

If you don't know the type of the operand, you can still do this, but you

must use @code{typeof} (@pxref{Typeof}).

must use @code{typeof} (@pxref{Typeof}).

In G++, the result value of a statement expression undergoes array and

In G++, the result value of a statement expression undergoes array and

function pointer decay, and is returned by value to the enclosing

function pointer decay, and is returned by value to the enclosing

expression.  For instance, if @code{A} is a class, then

expression.  For instance, if @code{A} is a class, then

@smallexample

@smallexample

        A a;

        A a;

        (@{a;@}).Foo ()

        (@{a;@}).Foo ()

@end smallexample

@end smallexample

@noindent

@noindent

will construct a temporary @code{A} object to hold the result of the

will construct a temporary @code{A} object to hold the result of the

statement expression, and that will be used to invoke @code{Foo}.

statement expression, and that will be used to invoke @code{Foo}.

Therefore the @code{this} pointer observed by @code{Foo} will not be the

Therefore the @code{this} pointer observed by @code{Foo} will not be the

address of @code{a}.

address of @code{a}.

Any temporaries created within a statement within a statement expression

Any temporaries created within a statement within a statement expression

will be destroyed at the statement's end.  This makes statement

will be destroyed at the statement's end.  This makes statement

expressions inside macros slightly different from function calls.  In

expressions inside macros slightly different from function calls.  In

the latter case temporaries introduced during argument evaluation will

the latter case temporaries introduced during argument evaluation will

be destroyed at the end of the statement that includes the function

be destroyed at the end of the statement that includes the function

call.  In the statement expression case they will be destroyed during

call.  In the statement expression case they will be destroyed during

the statement expression.  For instance,

the statement expression.  For instance,

@smallexample

@smallexample

#define macro(a)  (@{__typeof__(a) b = (a); b + 3; @})

#define macro(a)  (@{__typeof__(a) b = (a); b + 3; @})

template<typename T> T function(T a) @{ T b = a; return b + 3; @}

template<typename T> T function(T a) @{ T b = a; return b + 3; @}

void foo ()

void foo ()

@{

@{

  macro (X ());

  macro (X ());

  function (X ());

  function (X ());

@}

@}

@end smallexample

@end smallexample

@noindent

@noindent

will have different places where temporaries are destroyed.  For the

will have different places where temporaries are destroyed.  For the

@code{macro} case, the temporary @code{X} will be destroyed just after

@code{macro} case, the temporary @code{X} will be destroyed just after

the initialization of @code{b}.  In the @code{function} case that

the initialization of @code{b}.  In the @code{function} case that

temporary will be destroyed when the function returns.

temporary will be destroyed when the function returns.

These considerations mean that it is probably a bad idea to use

These considerations mean that it is probably a bad idea to use

statement-expressions of this form in header files that are designed to

statement-expressions of this form in header files that are designed to

work with C++.  (Note that some versions of the GNU C Library contained

work with C++.  (Note that some versions of the GNU C Library contained

header files using statement-expression that lead to precisely this

header files using statement-expression that lead to precisely this

bug.)

bug.)

Jumping into a statement expression with @code{goto} or using a

Jumping into a statement expression with @code{goto} or using a

@code{switch} statement outside the statement expression with a

@code{switch} statement outside the statement expression with a

@code{case} or @code{default} label inside the statement expression is

@code{case} or @code{default} label inside the statement expression is

not permitted.  Jumping into a statement expression with a computed

not permitted.  Jumping into a statement expression with a computed

@code{goto} (@pxref{Labels as Values}) yields undefined behavior.

@code{goto} (@pxref{Labels as Values}) yields undefined behavior.

Jumping out of a statement expression is permitted, but if the

Jumping out of a statement expression is permitted, but if the

statement expression is part of a larger expression then it is

statement expression is part of a larger expression then it is

unspecified which other subexpressions of that expression have been

unspecified which other subexpressions of that expression have been

evaluated except where the language definition requires certain

evaluated except where the language definition requires certain

subexpressions to be evaluated before or after the statement

subexpressions to be evaluated before or after the statement

expression.  In any case, as with a function call the evaluation of a

expression.  In any case, as with a function call the evaluation of a

statement expression is not interleaved with the evaluation of other

statement expression is not interleaved with the evaluation of other

parts of the containing expression.  For example,

parts of the containing expression.  For example,

@smallexample

@smallexample

  foo (), ((@{ bar1 (); goto a; 0; @}) + bar2 ()), baz();

  foo (), ((@{ bar1 (); goto a; 0; @}) + bar2 ()), baz();

@end smallexample

@end smallexample

@noindent

@noindent

will call @code{foo} and @code{bar1} and will not call @code{baz} but

will call @code{foo} and @code{bar1} and will not call @code{baz} but

may or may not call @code{bar2}.  If @code{bar2} is called, it will be

may or may not call @code{bar2}.  If @code{bar2} is called, it will be

called after @code{foo} and before @code{bar1}

called after @code{foo} and before @code{bar1}

@node Local Labels

@node Local Labels

@section Locally Declared Labels

@section Locally Declared Labels

@cindex local labels

@cindex local labels

@cindex macros, local labels

@cindex macros, local labels

GCC allows you to declare @dfn{local labels} in any nested block

GCC allows you to declare @dfn{local labels} in any nested block

scope.  A local label is just like an ordinary label, but you can

scope.  A local label is just like an ordinary label, but you can

only reference it (with a @code{goto} statement, or by taking its

only reference it (with a @code{goto} statement, or by taking its

address) within the block in which it was declared.

address) within the block in which it was declared.

A local label declaration looks like this:

A local label declaration looks like this:

@smallexample

@smallexample

__label__ @var{label};

__label__ @var{label};

@end smallexample

@end smallexample

@noindent

@noindent

or

or

@smallexample

@smallexample

__label__ @var{label1}, @var{label2}, /* @r{@dots{}} */;

__label__ @var{label1}, @var{label2}, /* @r{@dots{}} */;

@end smallexample

@end smallexample

Local label declarations must come at the beginning of the block,

Local label declarations must come at the beginning of the block,

before any ordinary declarations or statements.

before any ordinary declarations or statements.

The label declaration defines the label @emph{name}, but does not define

The label declaration defines the label @emph{name}, but does not define

the label itself.  You must do this in the usual way, with

the label itself.  You must do this in the usual way, with

@code{@var{label}:}, within the statements of the statement expression.

@code{@var{label}:}, within the statements of the statement expression.

The local label feature is useful for complex macros.  If a macro

The local label feature is useful for complex macros.  If a macro

contains nested loops, a @code{goto} can be useful for breaking out of

contains nested loops, a @code{goto} can be useful for breaking out of

them.  However, an ordinary label whose scope is the whole function

them.  However, an ordinary label whose scope is the whole function

cannot be used: if the macro can be expanded several times in one

cannot be used: if the macro can be expanded several times in one

function, the label will be multiply defined in that function.  A

function, the label will be multiply defined in that function.  A

local label avoids this problem.  For example:

local label avoids this problem.  For example:

@smallexample

@smallexample

#define SEARCH(value, array, target)              \

#define SEARCH(value, array, target)              \

do @{                                              \

do @{                                              \

  __label__ found;                                \

  __label__ found;                                \

  typeof (target) _SEARCH_target = (target);      \

  typeof (target) _SEARCH_target = (target);      \

  typeof (*(array)) *_SEARCH_array = (array);     \

  typeof (*(array)) *_SEARCH_array = (array);     \

  int i, j;                                       \

  int i, j;                                       \

  int value;                                      \

  int value;                                      \

  for (i = 0; i < max; i++)                       \

  for (i = 0; i < max; i++)                       \

    for (j = 0; j < max; j++)                     \

    for (j = 0; j < max; j++)                     \

      if (_SEARCH_array[i][j] == _SEARCH_target)  \

      if (_SEARCH_array[i][j] == _SEARCH_target)  \

        @{ (value) = i; goto found; @}              \

        @{ (value) = i; goto found; @}              \

  (value) = -1;                                   \

  (value) = -1;                                   \

 found:;                                          \

 found:;                                          \

@} while (0)

@} while (0)

@end smallexample

@end smallexample

This could also be written using a statement-expression:

This could also be written using a statement-expression:

@smallexample

@smallexample

#define SEARCH(array, target)                     \

#define SEARCH(array, target)                     \

(@{                                                \

(@{                                                \

  __label__ found;                                \

  __label__ found;                                \

  typeof (target) _SEARCH_target = (target);      \

  typeof (target) _SEARCH_target = (target);      \

  typeof (*(array)) *_SEARCH_array = (array);     \

  typeof (*(array)) *_SEARCH_array = (array);     \

  int i, j;                                       \

  int i, j;                                       \

  int value;                                      \

  int value;                                      \

  for (i = 0; i < max; i++)                       \

  for (i = 0; i < max; i++)                       \

    for (j = 0; j < max; j++)                     \

    for (j = 0; j < max; j++)                     \

      if (_SEARCH_array[i][j] == _SEARCH_target)  \

      if (_SEARCH_array[i][j] == _SEARCH_target)  \

        @{ value = i; goto found; @}                \

        @{ value = i; goto found; @}                \

  value = -1;                                     \

  value = -1;                                     \

 found:                                           \

 found:                                           \

  value;                                          \

  value;                                          \

@})

@})

@end smallexample

@end smallexample

Local label declarations also make the labels they declare visible to

Local label declarations also make the labels they declare visible to

nested functions, if there are any.  @xref{Nested Functions}, for details.

nested functions, if there are any.  @xref{Nested Functions}, for details.

@node Labels as Values

@node Labels as Values

@section Labels as Values

@section Labels as Values

@cindex labels as values

@cindex labels as values

@cindex computed gotos

@cindex computed gotos

@cindex goto with computed label

@cindex goto with computed label

@cindex address of a label

@cindex address of a label

You can get the address of a label defined in the current function

You can get the address of a label defined in the current function

(or a containing function) with the unary operator @samp{&&}.  The

(or a containing function) with the unary operator @samp{&&}.  The

value has type @code{void *}.  This value is a constant and can be used

value has type @code{void *}.  This value is a constant and can be used

wherever a constant of that type is valid.  For example:

wherever a constant of that type is valid.  For example:

@smallexample

@smallexample

void *ptr;

void *ptr;

/* @r{@dots{}} */

/* @r{@dots{}} */

ptr = &&foo;

ptr = &&foo;

@end smallexample

@end smallexample

To use these values, you need to be able to jump to one.  This is done

To use these values, you need to be able to jump to one.  This is done

with the computed goto statement@footnote{The analogous feature in

with the computed goto statement@footnote{The analogous feature in

Fortran is called an assigned goto, but that name seems inappropriate in

Fortran is called an assigned goto, but that name seems inappropriate in

C, where one can do more than simply store label addresses in label

C, where one can do more than simply store label addresses in label

variables.}, @code{goto *@var{exp};}.  For example,

variables.}, @code{goto *@var{exp};}.  For example,

@smallexample

@smallexample

goto *ptr;

goto *ptr;

@end smallexample

@end smallexample

@noindent

@noindent

Any expression of type @code{void *} is allowed.

Any expression of type @code{void *} is allowed.

One way of using these constants is in initializing a static array that

One way of using these constants is in initializing a static array that

will serve as a jump table:

will serve as a jump table:

@smallexample

@smallexample

static void *array[] = @{ &&foo, &&bar, &&hack @};

static void *array[] = @{ &&foo, &&bar, &&hack @};

@end smallexample

@end smallexample

Then you can select a label with indexing, like this:

Then you can select a label with indexing, like this:

@smallexample

@smallexample

goto *array[i];

goto *array[i];

@end smallexample

@end smallexample

@noindent

@noindent

Note that this does not check whether the subscript is in bounds---array

Note that this does not check whether the subscript is in bounds---array

indexing in C never does that.

indexing in C never does that.

Such an array of label values serves a purpose much like that of the

Such an array of label values serves a purpose much like that of the

@code{switch} statement.  The @code{switch} statement is cleaner, so

@code{switch} statement.  The @code{switch} statement is cleaner, so

use that rather than an array unless the problem does not fit a

use that rather than an array unless the problem does not fit a

@code{switch} statement very well.

@code{switch} statement very well.

Another use of label values is in an interpreter for threaded code.

Another use of label values is in an interpreter for threaded code.

The labels within the interpreter function can be stored in the

The labels within the interpreter function can be stored in the

threaded code for super-fast dispatching.

threaded code for super-fast dispatching.

You may not use this mechanism to jump to code in a different function.

You may not use this mechanism to jump to code in a different function.

If you do that, totally unpredictable things will happen.  The best way to

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

avoid this is to store the label address only in automatic variables and

never pass it as an argument.

never pass it as an argument.

An alternate way to write the above example is

An alternate way to write the above example is

@smallexample

@smallexample

static const int array[] = @{ &&foo - &&foo, &&bar - &&foo,

static const int array[] = @{ &&foo - &&foo, &&bar - &&foo,

                             &&hack - &&foo @};

                             &&hack - &&foo @};

goto *(&&foo + array[i]);

goto *(&&foo + array[i]);

@end smallexample

@end smallexample

@noindent

@noindent

This is more friendly to code living in shared libraries, as it reduces

This is more friendly to code living in shared libraries, as it reduces

the number of dynamic relocations that are needed, and by consequence,

the number of dynamic relocations that are needed, and by consequence,

allows the data to be read-only.

allows the data to be read-only.

@node Nested Functions

@node Nested Functions

@section Nested Functions

@section Nested Functions

@cindex nested functions

@cindex nested functions

@cindex downward funargs

@cindex downward funargs

@cindex thunks

@cindex thunks

A @dfn{nested function} is a function defined inside another function.

A @dfn{nested function} is a function defined inside another function.

(Nested functions are not supported for GNU C++.)  The nested function's

(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

name is local to the block where it is defined.  For example, here we

define a nested function named @code{square}, and call it twice:

define a nested function named @code{square}, and call it twice:

@smallexample

@smallexample

@group

@group

foo (double a, double b)

foo (double a, double b)

@{

@{

  double square (double z) @{ return z * z; @}

  double square (double z) @{ return z * z; @}

  return square (a) + square (b);

  return square (a) + square (b);

@}

@}

@end group

@end group

@end smallexample

@end smallexample

The nested function can access all the variables of the containing

The nested function can access all the variables of the containing

function that are visible at the point of its definition.  This is

function that are visible at the point of its definition.  This is

called @dfn{lexical scoping}.  For example, here we show a nested

called @dfn{lexical scoping}.  For example, here we show a nested

function which uses an inherited variable named @code{offset}:

function which uses an inherited variable named @code{offset}:

@smallexample

@smallexample

@group

@group

bar (int *array, int offset, int size)

bar (int *array, int offset, int size)

@{

@{

  int access (int *array, int index)

  int access (int *array, int index)

    @{ return array[index + offset]; @}

    @{ return array[index + offset]; @}

  int i;

  int i;

  /* @r{@dots{}} */

  /* @r{@dots{}} */

  for (i = 0; i < size; i++)

  for (i = 0; i < size; i++)

    /* @r{@dots{}} */ access (array, i) /* @r{@dots{}} */

    /* @r{@dots{}} */ access (array, i) /* @r{@dots{}} */

@}

@}

@end group

@end group

@end smallexample

@end smallexample

Nested function definitions are permitted within functions in the places

Nested function definitions are permitted within functions in the places

where variable definitions are allowed; that is, in any block, mixed

where variable definitions are allowed; that is, in any block, mixed

with the other declarations and statements in the block.

with the other declarations and statements in the block.

It is possible to call the nested function from outside the scope of its

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:

name by storing its address or passing the address to another function:

@smallexample

@smallexample

hack (int *array, int size)

hack (int *array, int size)

@{

@{

  void store (int index, int value)

  void store (int index, int value)

    @{ array[index] = value; @}

    @{ array[index] = value; @}

  intermediate (store, size);

  intermediate (store, size);

@}

@}

@end smallexample

@end smallexample

Here, the function @code{intermediate} receives the address of

Here, the function @code{intermediate} receives the address of

@code{store} as an argument.  If @code{intermediate} calls @code{store},

@code{store} as an argument.  If @code{intermediate} calls @code{store},

the arguments given to @code{store} are used to store into @code{array}.

the arguments given to @code{store} are used to store into @code{array}.

But this technique works only so long as the containing function

But this technique works only so long as the containing function

(@code{hack}, in this example) does not exit.

(@code{hack}, in this example) does not exit.

If you try to call the nested function through its address after the

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

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 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,

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

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

does not refer to anything that has gone out of scope, you should be

safe.

safe.

GCC implements taking the address of a nested function using a technique

GCC implements taking the address of a nested function using a technique

called @dfn{trampolines}.  A paper describing them is available as

called @dfn{trampolines}.  A paper describing them is available as

@noindent

@noindent

@uref{http://people.debian.org/~aaronl/Usenix88-lexic.pdf}.

@uref{http://people.debian.org/~aaronl/Usenix88-lexic.pdf}.

A nested function can jump to a label inherited from a containing

A nested function can jump to a label inherited from a containing

function, provided the label was explicitly declared in the containing

function, provided the label was explicitly declared in the containing

function (@pxref{Local Labels}).  Such a jump returns instantly to the

function (@pxref{Local Labels}).  Such a jump returns instantly to the

containing function, exiting the nested function which did the

containing function, exiting the nested function which did the

@code{goto} and any intermediate functions as well.  Here is an example:

@code{goto} and any intermediate functions as well.  Here is an example:

@smallexample

@smallexample

@group

@group

bar (int *array, int offset, int size)

bar (int *array, int offset, int size)

@{

@{

  __label__ failure;

  __label__ failure;

  int access (int *array, int index)

  int access (int *array, int index)

    @{

    @{

      if (index > size)

      if (index > size)

        goto failure;

        goto failure;

      return array[index + offset];

      return array[index + offset];

    @}

    @}

  int i;

  int i;

  /* @r{@dots{}} */

  /* @r{@dots{}} */

  for (i = 0; i < size; i++)

  for (i = 0; i < size; i++)

    /* @r{@dots{}} */ access (array, i) /* @r{@dots{}} */

    /* @r{@dots{}} */ access (array, i) /* @r{@dots{}} */

  /* @r{@dots{}} */

  /* @r{@dots{}} */

  return 0;

  return 0;

 /* @r{Control comes here from @code{access}

 /* @r{Control comes here from @code{access}

    if it detects an error.}  */

    if it detects an error.}  */

 failure:

 failure:

  return -1;

  return -1;

@}

@}

@end group

@end group

@end smallexample

@end smallexample

A nested function always has no linkage.  Declaring one with

A nested function always has no linkage.  Declaring one with

@code{extern} or @code{static} is erroneous.  If you need to declare the nested function

@code{extern} or @code{static} is erroneous.  If you need to declare the nested function

before its definition, use @code{auto} (which is otherwise meaningless

before its definition, use @code{auto} (which is otherwise meaningless

for function declarations).

for function declarations).

@smallexample

@smallexample

bar (int *array, int offset, int size)

bar (int *array, int offset, int size)

@{

@{

  __label__ failure;

  __label__ failure;

  auto int access (int *, int);

  auto int access (int *, int);

  /* @r{@dots{}} */

  /* @r{@dots{}} */

  int access (int *array, int index)

  int access (int *array, int index)

    @{

    @{

      if (index > size)

      if (index > size)

        goto failure;

        goto failure;

      return array[index + offset];

      return array[index + offset];

    @}

    @}

  /* @r{@dots{}} */

  /* @r{@dots{}} */

@}

@}

@end smallexample

@end smallexample

@node Constructing Calls

@node Constructing Calls

@section Constructing Function Calls

@section Constructing Function Calls

@cindex constructing calls

@cindex constructing calls

@cindex forwarding calls

@cindex forwarding calls

Using the built-in functions described below, you can record

Using the built-in functions described below, you can record

the arguments a function received, and call another function

the arguments a function received, and call another function

with the same arguments, without knowing the number or types

with the same arguments, without knowing the number or types

of the arguments.

of the arguments.

You can also record the return value of that function call,

You can also record the return value of that function call,

and later return that value, without knowing what data type

and later return that value, without knowing what data type

the function tried to return (as long as your caller expects

the function tried to return (as long as your caller expects

that data type).

that data type).

However, these built-in functions may interact badly with some

However, these built-in functions may interact badly with some

sophisticated features or other extensions of the language.  It

sophisticated features or other extensions of the language.  It

is, therefore, not recommended to use them outside very simple

is, therefore, not recommended to use them outside very simple

functions acting as mere forwarders for their arguments.

functions acting as mere forwarders for their arguments.

@deftypefn {Built-in Function} {void *} __builtin_apply_args ()

@deftypefn {Built-in Function} {void *} __builtin_apply_args ()

This built-in function returns a pointer to data

This built-in function returns a pointer to data

describing how to perform a call with the same arguments as were passed

describing how to perform a call with the same arguments as were passed

to the current function.

to the current function.

The function saves the arg pointer register, structure value address,

The function saves the arg pointer register, structure value address,

and all registers that might be used to pass arguments to a function

and all registers that might be used to pass arguments to a function

into a block of memory allocated on the stack.  Then it returns the

into a block of memory allocated on the stack.  Then it returns the

address of that block.

address of that block.

@end deftypefn

@end deftypefn

@deftypefn {Built-in Function} {void *} __builtin_apply (void (*@var{function})(), void *@var{arguments}, size_t @var{size})

@deftypefn {Built-in Function} {void *} __builtin_apply (void (*@var{function})(), void *@var{arguments}, size_t @var{size})

This built-in function invokes @var{function}

This built-in function invokes @var{function}

with a copy of the parameters described by @var{arguments}

with a copy of the parameters described by @var{arguments}

and @var{size}.

and @var{size}.

The value of @var{arguments} should be the value returned by

The value of @var{arguments} should be the value returned by

@code{__builtin_apply_args}.  The argument @var{size} specifies the size

@code{__builtin_apply_args}.  The argument @var{size} specifies the size

of the stack argument data, in bytes.

of the stack argument data, in bytes.

This function returns a pointer to data describing

This function returns a pointer to data describing

how to return whatever value was returned by @var{function}.  The data

how to return whatever value was returned by @var{function}.  The data

is saved in a block of memory allocated on the stack.

is saved in a block of memory allocated on the stack.

It is not always simple to compute the proper value for @var{size}.  The

It is not always simple to compute the proper value for @var{size}.  The

value is used by @code{__builtin_apply} to compute the amount of data

value is used by @code{__builtin_apply} to compute the amount of data

that should be pushed on the stack and copied from the incoming argument

that should be pushed on the stack and copied from the incoming argument

area.

area.

@end deftypefn

@end deftypefn

@deftypefn {Built-in Function} {void} __builtin_return (void *@var{result})

@deftypefn {Built-in Function} {void} __builtin_return (void *@var{result})

This built-in function returns the value described by @var{result} from

This built-in function returns the value described by @var{result} from

the containing function.  You should specify, for @var{result}, a value

the containing function.  You should specify, for @var{result}, a value

returned by @code{__builtin_apply}.

returned by @code{__builtin_apply}.

@end deftypefn

@end deftypefn

@node Typeof

@node Typeof

@section Referring to a Type with @code{typeof}

@section Referring to a Type with @code{typeof}

@findex typeof

@findex typeof

@findex sizeof

@findex sizeof

@cindex macros, types of arguments

@cindex macros, types of arguments

Another way to refer to the type of an expression is with @code{typeof}.

Another way to refer to the type of an expression is with @code{typeof}.

The syntax of using of this keyword looks like @code{sizeof}, but the

The syntax of using of this keyword looks like @code{sizeof}, but the

construct acts semantically like a type name defined with @code{typedef}.

construct acts semantically like a type name defined with @code{typedef}.

There are two ways of writing the argument to @code{typeof}: with an

There are two ways of writing the argument to @code{typeof}: with an

expression or with a type.  Here is an example with an expression:

expression or with a type.  Here is an example with an expression:

@smallexample

@smallexample

typeof (x[0](1))

typeof (x[0](1))

@end smallexample

@end smallexample

@noindent

@noindent

This assumes that @code{x} is an array of pointers to functions;

This assumes that @code{x} is an array of pointers to functions;

the type described is that of the values of the functions.

the type described is that of the values of the functions.

Here is an example with a typename as the argument:

Here is an example with a typename as the argument:

@smallexample

@smallexample

typeof (int *)

typeof (int *)

@end smallexample

@end smallexample

@noindent

@noindent

Here the type described is that of pointers to @code{int}.

Here the type described is that of pointers to @code{int}.

If you are writing a header file that must work when included in ISO C

If you are writing a header file that must work when included in ISO C

programs, write @code{__typeof__} instead of @code{typeof}.

programs, write @code{__typeof__} instead of @code{typeof}.

@xref{Alternate Keywords}.

@xref{Alternate Keywords}.

A @code{typeof}-construct can be used anywhere a typedef name could be

A @code{typeof}-construct can be used anywhere a typedef name could be

used.  For example, you can use it in a declaration, in a cast, or inside

used.  For example, you can use it in a declaration, in a cast, or inside

of @code{sizeof} or @code{typeof}.

of @code{sizeof} or @code{typeof}.

@code{typeof} is often useful in conjunction with the

@code{typeof} is often useful in conjunction with the

statements-within-expressions feature.  Here is how the two together can

statements-within-expressions feature.  Here is how the two together can

be used to define a safe ``maximum'' macro that operates on any

be used to define a safe ``maximum'' macro that operates on any

arithmetic type and evaluates each of its arguments exactly once:

arithmetic type and evaluates each of its arguments exactly once:

@smallexample

@smallexample

#define max(a,b) \

#define max(a,b) \

  (@{ typeof (a) _a = (a); \

  (@{ typeof (a) _a = (a); \

      typeof (b) _b = (b); \

      typeof (b) _b = (b); \

    _a > _b ? _a : _b; @})

    _a > _b ? _a : _b; @})

@end smallexample

@end smallexample

@cindex underscores in variables in macros

@cindex underscores in variables in macros

@cindex @samp{_} in variables in macros

@cindex @samp{_} in variables in macros

@cindex local variables in macros

@cindex local variables in macros

@cindex variables, local, in macros

@cindex variables, local, in macros

@cindex macros, local variables in

@cindex macros, local variables in

The reason for using names that start with underscores for the local

The reason for using names that start with underscores for the local

variables is to avoid conflicts with variable names that occur within the

variables is to avoid conflicts with variable names that occur within the

expressions that are substituted for @code{a} and @code{b}.  Eventually we

expressions that are substituted for @code{a} and @code{b}.  Eventually we

hope to design a new form of declaration syntax that allows you to declare

hope to design a new form of declaration syntax that allows you to declare

variables whose scopes start only after their initializers; this will be a

variables whose scopes start only after their initializers; this will be a

more reliable way to prevent such conflicts.

more reliable way to prevent such conflicts.

@noindent

@noindent

Some more examples of the use of @code{typeof}:

Some more examples of the use of @code{typeof}:

@itemize @bullet

@itemize @bullet

@item

@item

This declares @code{y} with the type of what @code{x} points to.

This declares @code{y} with the type of what @code{x} points to.

@smallexample

@smallexample

typeof (*x) y;

typeof (*x) y;

@end smallexample

@end smallexample

@item

@item

This declares @code{y} as an array of such values.

This declares @code{y} as an array of such values.

@smallexample

@smallexample

typeof (*x) y[4];

typeof (*x) y[4];

@end smallexample

@end smallexample

@item

@item

This declares @code{y} as an array of pointers to characters:

This declares @code{y} as an array of pointers to characters:

@smallexample

@smallexample

typeof (typeof (char *)[4]) y;

typeof (typeof (char *)[4]) y;

@end smallexample

@end smallexample

@noindent

@noindent

It is equivalent to the following traditional C declaration:

It is equivalent to the following traditional C declaration:

@smallexample

@smallexample

char *y[4];

char *y[4];

@end smallexample

@end smallexample

To see the meaning of the declaration using @code{typeof}, and why it

To see the meaning of the declaration using @code{typeof}, and why it

might be a useful way to write, rewrite it with these macros:

might be a useful way to write, rewrite it with these macros:

@smallexample

@smallexample

#define pointer(T)  typeof(T *)

#define pointer(T)  typeof(T *)

#define array(T, N) typeof(T [N])

#define array(T, N) typeof(T [N])

@end smallexample

@end smallexample

@noindent

@noindent

Now the declaration can be rewritten this way:

Now the declaration can be rewritten this way:

@smallexample

@smallexample

array (pointer (char), 4) y;

array (pointer (char), 4) y;

@end smallexample

@end smallexample

@noindent

@noindent

Thus, @code{array (pointer (char), 4)} is the type of arrays of 4

Thus, @code{array (pointer (char), 4)} is the type of arrays of 4

pointers to @code{char}.

pointers to @code{char}.

@end itemize

@end itemize

@emph{Compatibility Note:} In addition to @code{typeof}, GCC 2 supported

@emph{Compatibility Note:} In addition to @code{typeof}, GCC 2 supported

a more limited extension which permitted one to write

a more limited extension which permitted one to write

@smallexample

@smallexample

typedef @var{T} = @var{expr};

typedef @var{T} = @var{expr};

@end smallexample

@end smallexample

@noindent

@noindent

with the effect of declaring @var{T} to have the type of the expression

with the effect of declaring @var{T} to have the type of the expression

@var{expr}.  This extension does not work with GCC 3 (versions between

@var{expr}.  This extension does not work with GCC 3 (versions between

3.0 and 3.2 will crash; 3.2.1 and later give an error).  Code which

3.0 and 3.2 will crash; 3.2.1 and later give an error).  Code which

relies on it should be rewritten to use @code{typeof}:

relies on it should be rewritten to use @code{typeof}:

@smallexample

@smallexample

typedef typeof(@var{expr}) @var{T};

typedef typeof(@var{expr}) @var{T};

@end smallexample

@end smallexample

@noindent

@noindent

This will work with all versions of GCC@.

This will work with all versions of GCC@.

@node Conditionals

@node Conditionals

@section Conditionals with Omitted Operands

@section Conditionals with Omitted Operands

@cindex conditional expressions, extensions

@cindex conditional expressions, extensions

@cindex omitted middle-operands

@cindex omitted middle-operands

@cindex middle-operands, omitted

@cindex middle-operands, omitted

@cindex extensions, @code{?:}

@cindex extensions, @code{?:}

@cindex @code{?:} extensions

@cindex @code{?:} extensions

The middle operand in a conditional expression may be omitted.  Then

The middle operand in a conditional expression may be omitted.  Then

if the first operand is nonzero, its value is the value of the conditional

if the first operand is nonzero, its value is the value of the conditional

expression.

expression.

Therefore, the expression

Therefore, the expression

@smallexample

@smallexample

x ? : y

x ? : y

@end smallexample

@end smallexample

@noindent

@noindent

has the value of @code{x} if that is nonzero; otherwise, the value of

has the value of @code{x} if that is nonzero; otherwise, the value of

@code{y}.

@code{y}.

This example is perfectly equivalent to

This example is perfectly equivalent to

@smallexample

@smallexample

x ? x : y

x ? x : y

@end smallexample

@end smallexample

@cindex side effect in ?:

@cindex side effect in ?:

@cindex ?: side effect

@cindex ?: side effect

@noindent

@noindent

In this simple case, the ability to omit the middle operand is not

In this simple case, the ability to omit the middle operand is not

especially useful.  When it becomes useful is when the first operand does,

especially useful.  When it becomes useful is when the first operand does,

or may (if it is a macro argument), contain a side effect.  Then repeating

or may (if it is a macro argument), contain a side effect.  Then repeating

the operand in the middle would perform the side effect twice.  Omitting

the operand in the middle would perform the side effect twice.  Omitting

the middle operand uses the value already computed without the undesirable

the middle operand uses the value already computed without the undesirable

effects of recomputing it.

effects of recomputing it.

@node Long Long

@node Long Long

@section Double-Word Integers

@section Double-Word Integers

@cindex @code{long long} data types

@cindex @code{long long} data types

@cindex double-word arithmetic

@cindex double-word arithmetic

@cindex multiprecision arithmetic

@cindex multiprecision arithmetic

@cindex @code{LL} integer suffix

@cindex @code{LL} integer suffix

@cindex @code{ULL} integer suffix

@cindex @code{ULL} integer suffix

ISO C99 supports data types for integers that are at least 64 bits wide,

ISO C99 supports data types for integers that are at least 64 bits wide,

and as an extension GCC supports them in C89 mode and in C++.

and as an extension GCC supports them in C89 mode and in C++.

Simply write @code{long long int} for a signed integer, or

Simply write @code{long long int} for a signed integer, or

@code{unsigned long long int} for an unsigned integer.  To make an

@code{unsigned long long int} for an unsigned integer.  To make an

integer constant of type @code{long long int}, add the suffix @samp{LL}

integer constant of type @code{long long int}, add the suffix @samp{LL}

to the integer.  To make an integer constant of type @code{unsigned long

to the integer.  To make an integer constant of type @code{unsigned long

long int}, add the suffix @samp{ULL} to the integer.

long int}, add the suffix @samp{ULL} to the integer.

You can use these types in arithmetic like any other integer types.

You can use these types in arithmetic like any other integer types.

Addition, subtraction, and bitwise boolean operations on these types

Addition, subtraction, and bitwise boolean operations on these types

are open-coded on all types of machines.  Multiplication is open-coded

are open-coded on all types of machines.  Multiplication is open-coded

if the machine supports fullword-to-doubleword a widening multiply

if the machine supports fullword-to-doubleword a widening multiply

instruction.  Division and shifts are open-coded only on machines that

instruction.  Division and shifts are open-coded only on machines that

provide special support.  The operations that are not open-coded use

provide special support.  The operations that are not open-coded use

special library routines that come with GCC@.

special library routines that come with GCC@.

There may be pitfalls when you use @code{long long} types for function

There may be pitfalls when you use @code{long long} types for function

arguments, unless you declare function prototypes.  If a function

arguments, unless you declare function prototypes.  If a function

expects type @code{int} for its argument, and you pass a value of type

expects type @code{int} for its argument, and you pass a value of type

@code{long long int}, confusion will result because the caller and the

@code{long long int}, confusion will result because the caller and the

subroutine will disagree about the number of bytes for the argument.

subroutine will disagree about the number of bytes for the argument.

Likewise, if the function expects @code{long long int} and you pass

Likewise, if the function expects @code{long long int} and you pass

@code{int}.  The best way to avoid such problems is to use prototypes.

@code{int}.  The best way to avoid such problems is to use prototypes.

@node Complex

@node Complex

@section Complex Numbers

@section Complex Numbers

@cindex complex numbers

@cindex complex numbers

@cindex @code{_Complex} keyword

@cindex @code{_Complex} keyword

@cindex @code{__complex__} keyword

@cindex @code{__complex__} keyword

ISO C99 supports complex floating data types, and as an extension GCC

ISO C99 supports complex floating data types, and as an extension GCC

supports them in C89 mode and in C++, and supports complex integer data

supports them in C89 mode and in C++, and supports complex integer data

types which are not part of ISO C99.  You can declare complex types

types which are not part of ISO C99.  You can declare complex types

using the keyword @code{_Complex}.  As an extension, the older GNU

using the keyword @code{_Complex}.  As an extension, the older GNU

keyword @code{__complex__} is also supported.

keyword @code{__complex__} is also supported.

For example, @samp{_Complex double x;} declares @code{x} as a

For example, @samp{_Complex double x;} declares @code{x} as a

variable whose real part and imaginary part are both of type

variable whose real part and imaginary part are both of type

@code{double}.  @samp{_Complex short int y;} declares @code{y} to

@code{double}.  @samp{_Complex short int y;} declares @code{y} to

have real and imaginary parts of type @code{short int}; this is not

have real and imaginary parts of type @code{short int}; this is not

likely to be useful, but it shows that the set of complex types is

likely to be useful, but it shows that the set of complex types is

complete.

complete.

To write a constant with a complex data type, use the suffix @samp{i} or

To write a constant with a complex data type, use the suffix @samp{i} or

@samp{j} (either one; they are equivalent).  For example, @code{2.5fi}

@samp{j} (either one; they are equivalent).  For example, @code{2.5fi}

has type @code{_Complex float} and @code{3i} has type

has type @code{_Complex float} and @code{3i} has type

@code{_Complex int}.  Such a constant always has a pure imaginary

@code{_Complex int}.  Such a constant always has a pure imaginary

value, but you can form any complex value you like by adding one to a

value, but you can form any complex value you like by adding one to a

real constant.  This is a GNU extension; if you have an ISO C99

real constant.  This is a GNU extension; if you have an ISO C99

conforming C library (such as GNU libc), and want to construct complex

conforming C library (such as GNU libc), and want to construct complex

constants of floating type, you should include @code{<complex.h>} and

constants of floating type, you should include @code{<complex.h>} and

use the macros @code{I} or @code{_Complex_I} instead.

use the macros @code{I} or @code{_Complex_I} instead.

@cindex @code{__real__} keyword

@cindex @code{__real__} keyword

@cindex @code{__imag__} keyword

@cindex @code{__imag__} keyword

To extract the real part of a complex-valued expression @var{exp}, write

To extract the real part of a complex-valued expression @var{exp}, write

@code{__real__ @var{exp}}.  Likewise, use @code{__imag__} to

@code{__real__ @var{exp}}.  Likewise, use @code{__imag__} to

extract the imaginary part.  This is a GNU extension; for values of

extract the imaginary part.  This is a GNU extension; for values of

floating type, you should use the ISO C99 functions @code{crealf},

floating type, you should use the ISO C99 functions @code{crealf},

@code{creal}, @code{creall}, @code{cimagf}, @code{cimag} and

@code{creal}, @code{creall}, @code{cimagf}, @code{cimag} and

@code{cimagl}, declared in @code{<complex.h>} and also provided as

@code{cimagl}, declared in @code{<complex.h>} and also provided as

built-in functions by GCC@.

built-in functions by GCC@.

@cindex complex conjugation

@cindex complex conjugation

The operator @samp{~} performs complex conjugation when used on a value

The operator @samp{~} performs complex conjugation when used on a value

with a complex type.  This is a GNU extension; for values of

with a complex type.  This is a GNU extension; for values of

floating type, you should use the ISO C99 functions @code{conjf},

floating type, you should use the ISO C99 functions @code{conjf},

@code{conj} and @code{conjl}, declared in @code{<complex.h>} and also

@code{conj} and @code{conjl}, declared in @code{<complex.h>} and also

provided as built-in functions by GCC@.

provided as built-in functions by GCC@.

GCC can allocate complex automatic variables in a noncontiguous

GCC can allocate complex automatic variables in a noncontiguous

fashion; it's even possible for the real part to be in a register while

fashion; it's even possible for the real part to be in a register while

the imaginary part is on the stack (or vice-versa).  Only the DWARF2

the imaginary part is on the stack (or vice-versa).  Only the DWARF2

debug info format can represent this, so use of DWARF2 is recommended.

debug info format can represent this, so use of DWARF2 is recommended.

If you are using the stabs debug info format, GCC describes a noncontiguous

If you are using the stabs debug info format, GCC describes a noncontiguous

complex variable as if it were two separate variables of noncomplex type.

complex variable as if it were two separate variables of noncomplex type.

If the variable's actual name is @code{foo}, the two fictitious

If the variable's actual name is @code{foo}, the two fictitious

variables are named @code{foo$real} and @code{foo$imag}.  You can

variables are named @code{foo$real} and @code{foo$imag}.  You can

examine and set these two fictitious variables with your debugger.

examine and set these two fictitious variables with your debugger.

@node Decimal Float

@node Decimal Float

@section Decimal Floating Types

@section Decimal Floating Types

@cindex decimal floating types

@cindex decimal floating types

@cindex @code{_Decimal32} data type

@cindex @code{_Decimal32} data type

@cindex @code{_Decimal64} data type

@cindex @code{_Decimal64} data type

@cindex @code{_Decimal128} data type

@cindex @code{_Decimal128} data type

@cindex @code{df} integer suffix

@cindex @code{df} integer suffix

@cindex @code{dd} integer suffix

@cindex @code{dd} integer suffix

@cindex @code{dl} integer suffix

@cindex @code{dl} integer suffix

@cindex @code{DF} integer suffix

@cindex @code{DF} integer suffix

@cindex @code{DD} integer suffix

@cindex @code{DD} integer suffix

@cindex @code{DL} integer suffix

@cindex @code{DL} integer suffix

As an extension, the GNU C compiler supports decimal floating types as

As an extension, the GNU C compiler supports decimal floating types as

defined in the N1176 draft of ISO/IEC WDTR24732.  Support for decimal

defined in the N1176 draft of ISO/IEC WDTR24732.  Support for decimal

floating types in GCC will evolve as the draft technical report changes.

floating types in GCC will evolve as the draft technical report changes.

Calling conventions for any target might also change.  Not all targets

Calling conventions for any target might also change.  Not all targets

support decimal floating types.

support decimal floating types.

The decimal floating types are @code{_Decimal32}, @code{_Decimal64}, and

The decimal floating types are @code{_Decimal32}, @code{_Decimal64}, and

@code{_Decimal128}.  They use a radix of ten, unlike the floating types

@code{_Decimal128}.  They use a radix of ten, unlike the floating types

@code{float}, @code{double}, and @code{long double} whose radix is not

@code{float}, @code{double}, and @code{long double} whose radix is not

specified by the C standard but is usually two.

specified by the C standard but is usually two.

Support for decimal floating types includes the arithmetic operators

Support for decimal floating types includes the arithmetic operators

add, subtract, multiply, divide; unary arithmetic operators;

add, subtract, multiply, divide; unary arithmetic operators;

relational operators; equality operators; and conversions to and from

relational operators; equality operators; and conversions to and from

integer and other floating types.  Use a suffix @samp{df} or

integer and other floating types.  Use a suffix @samp{df} or

@samp{DF} in a literal constant of type @code{_Decimal32}, @samp{dd}

@samp{DF} in a literal constant of type @code{_Decimal32}, @samp{dd}

or @samp{DD} for @code{_Decimal64}, and @samp{dl} or @samp{DL} for

or @samp{DD} for @code{_Decimal64}, and @samp{dl} or @samp{DL} for

@code{_Decimal128}.

@code{_Decimal128}.

GCC support of decimal float as specified by the draft technical report

GCC support of decimal float as specified by the draft technical report

is incomplete:

is incomplete:

@itemize @bullet

@itemize @bullet

@item

@item

Translation time data type (TTDT) is not supported.

Translation time data type (TTDT) is not supported.

@item

@item

Characteristics of decimal floating types are defined in header file

Characteristics of decimal floating types are defined in header file

@file{decfloat.h} rather than @file{float.h}.

@file{decfloat.h} rather than @file{float.h}.

@item

@item

When the value of a decimal floating type cannot be represented in the

When the value of a decimal floating type cannot be represented in the

integer type to which it is being converted, the result is undefined

integer type to which it is being converted, the result is undefined

rather than the result value specified by the draft technical report.

rather than the result value specified by the draft technical report.

@end itemize

@end itemize

Types @code{_Decimal32}, @code{_Decimal64}, and @code{_Decimal128}

Types @code{_Decimal32}, @code{_Decimal64}, and @code{_Decimal128}

are supported by the DWARF2 debug information format.

are supported by the DWARF2 debug information format.

@node Hex Floats

@node Hex Floats

@section Hex Floats

@section Hex Floats

@cindex hex floats

@cindex hex floats

ISO C99 supports floating-point numbers written not only in the usual

ISO C99 supports floating-point numbers written not only in the usual

decimal notation, such as @code{1.55e1}, but also numbers such as

decimal notation, such as @code{1.55e1}, but also numbers such as

@code{0x1.fp3} written in hexadecimal format.  As a GNU extension, GCC

@code{0x1.fp3} written in hexadecimal format.  As a GNU extension, GCC

supports this in C89 mode (except in some cases when strictly

supports this in C89 mode (except in some cases when strictly

conforming) and in C++.  In that format the

conforming) and in C++.  In that format the

@samp{0x} hex introducer and the @samp{p} or @samp{P} exponent field are

@samp{0x} hex introducer and the @samp{p} or @samp{P} exponent field are

mandatory.  The exponent is a decimal number that indicates the power of

mandatory.  The exponent is a decimal number that indicates the power of

2 by which the significant part will be multiplied.  Thus @samp{0x1.f} is

2 by which the significant part will be multiplied.  Thus @samp{0x1.f} is

@tex

@tex

$1 {15\over16}$,

$1 {15\over16}$,

@end tex

@end tex

@ifnottex

@ifnottex

1 15/16,

1 15/16,

@end ifnottex

@end ifnottex

@samp{p3} multiplies it by 8, and the value of @code{0x1.fp3}

@samp{p3} multiplies it by 8, and the value of @code{0x1.fp3}

is the same as @code{1.55e1}.

is the same as @code{1.55e1}.

Unlike for floating-point numbers in the decimal notation the exponent

Unlike for floating-point numbers in the decimal notation the exponent

is always required in the hexadecimal notation.  Otherwise the compiler

is always required in the hexadecimal notation.  Otherwise the compiler

would not be able to resolve the ambiguity of, e.g., @code{0x1.f}.  This

would not be able to resolve the ambiguity of, e.g., @code{0x1.f}.  This

could mean @code{1.0f} or @code{1.9375} since @samp{f} is also the

could mean @code{1.0f} or @code{1.9375} since @samp{f} is also the

extension for floating-point constants of type @code{float}.

extension for floating-point constants of type @code{float}.

@node Zero Length

@node Zero Length

@section Arrays of Length Zero

@section Arrays of Length Zero

@cindex arrays of length zero

@cindex arrays of length zero

@cindex zero-length arrays

@cindex zero-length arrays

@cindex length-zero arrays

@cindex length-zero arrays

@cindex flexible array members

@cindex flexible array members

Zero-length arrays are allowed in GNU C@.  They are very useful as the

Zero-length arrays are allowed in GNU C@.  They are very useful as the

last element of a structure which is really a header for a variable-length

last element of a structure which is really a header for a variable-length

object:

object:

@smallexample

@smallexample

struct line @{

struct line @{

  int length;

  int length;

  char contents[0];

  char contents[0];

@};

@};

struct line *thisline = (struct line *)

struct line *thisline = (struct line *)

  malloc (sizeof (struct line) + this_length);

  malloc (sizeof (struct line) + this_length);

thisline->length = this_length;

thisline->length = this_length;

@end smallexample

@end smallexample

In ISO C90, you would have to give @code{contents} a length of 1, which

In ISO C90, you would have to give @code{contents} a length of 1, which

means either you waste space or complicate the argument to @code{malloc}.

means either you waste space or complicate the argument to @code{malloc}.

In ISO C99, you would use a @dfn{flexible array member}, which is

In ISO C99, you would use a @dfn{flexible array member}, which is

slightly different in syntax and semantics:

slightly different in syntax and semantics:

@itemize @bullet

@itemize @bullet

@item

@item

Flexible array members are written as @code{contents[]} without

Flexible array members are written as @code{contents[]} without

the @code{0}.

the @code{0}.

@item

@item

Flexible array members have incomplete type, and so the @code{sizeof}

Flexible array members have incomplete type, and so the @code{sizeof}

operator may not be applied.  As a quirk of the original implementation

operator may not be applied.  As a quirk of the original implementation

of zero-length arrays, @code{sizeof} evaluates to zero.

of zero-length arrays, @code{sizeof} evaluates to zero.

@item

@item

Flexible array members may only appear as the last member of a

Flexible array members may only appear as the last member of a

@code{struct} that is otherwise non-empty.

@code{struct} that is otherwise non-empty.

@item

@item

A structure containing a flexible array member, or a union containing