extend.texi

早期freebsd实现

@cindex underscores in variables in macros
@cindex @samp{_} in variables in macros
@cindex local variables in macros
@cindex variables, local, in macros
@cindex macros, local variables in

The reason for using names that start with underscores for the local
variables is to avoid conflicts with variable names that occur within the
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
variables whose scopes start only after their initializers; this will be a
more reliable way to prevent such conflicts.

@node Typeof
@section Referring to a Type with @code{typeof}
@findex typeof
@findex sizeof
@cindex macros, types of arguments

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
construct acts semantically like a type name defined with @code{typedef}.

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:

@example
typeof (x[0](1))
@end example

@noindent
This assumes that @code{x} is an array of functions; the type described
is that of the values of the functions.

Here is an example with a typename as the argument:

@example
typeof (int *)
@end example

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

If you are writing a header file that must work when included in ANSI C
programs, write @code{__typeof__} instead of @code{typeof}.
@xref{Alternate Keywords}.

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
of @code{sizeof} or @code{typeof}.

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

@example
typeof (*x) y;
@end example

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

@example
typeof (*x) y[4];
@end example

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

@example
typeof (typeof (char *)[4]) y;
@end example

@noindent
It is equivalent to the following traditional C declaration:

@example
char *y[4];
@end example

To see the meaning of the declaration using @code{typeof}, and why it
might be a useful way to write, let's rewrite it with these macros:

@example
#define pointer(T)  typeof(T *)
#define array(T, N) typeof(T [N])
@end example

@noindent
Now the declaration can be rewritten this way:

@example
array (pointer (char), 4) y;
@end example

@noindent
Thus, @code{array (pointer (char), 4)} is the type of arrays of 4
pointers to @code{char}.
@end itemize

@node Lvalues
@section Generalized Lvalues
@cindex compound expressions as lvalues
@cindex expressions, compound, as lvalues
@cindex conditional expressions as lvalues
@cindex expressions, conditional, as lvalues
@cindex casts as lvalues
@cindex generalized lvalues
@cindex lvalues, generalized
@cindex extensions, @code{?:}
@cindex @code{?:} extensions
Compound expressions, conditional expressions and casts are allowed as
lvalues provided their operands are lvalues.  This means that you can take
their addresses or store values into them.

For example, a compound expression can be assigned, provided the last
expression in the sequence is an lvalue.  These two expressions are
equivalent:

@example
(a, b) += 5
a, (b += 5)
@end example

Similarly, the address of the compound expression can be taken.  These two
expressions are equivalent:

@example
&(a, b)
a, &b
@end example

A conditional expression is a valid lvalue if its type is not void and the
true and false branches are both valid lvalues.  For example, these two
expressions are equivalent:

@example
(a ? b : c) = 5
(a ? b = 5 : (c = 5))
@end example

A cast is a valid lvalue if its operand is an lvalue.  A simple
assignment whose left-hand side is a cast works by converting the
right-hand side first to the specified type, then to the type of the
inner left-hand side expression.  After this is stored, the value is
converted back to the specified type to become the value of the
assignment.  Thus, if @code{a} has type @code{char *}, the following two
expressions are equivalent:

@example
(int)a = 5
(int)(a = (char *)(int)5)
@end example

An assignment-with-arithmetic operation such as @samp{+=} applied to a cast
performs the arithmetic using the type resulting from the cast, and then
continues as in the previous case.  Therefore, these two expressions are
equivalent:

@example
(int)a += 5
(int)(a = (char *)(int) ((int)a + 5))
@end example

You cannot take the address of an lvalue cast, because the use of its
address would not work out coherently.  Suppose that @code{&(int)f} were
permitted, where @code{f} has type @code{float}.  Then the following
statement would try to store an integer bit-pattern where a floating
point number belongs:

@example
*&(int)f = 1;
@end example

This is quite different from what @code{(int)f = 1} would do---that
would convert 1 to floating point and store it.  Rather than cause this
inconsistency, we think it is better to prohibit use of @samp{&} on a cast.

If you really do want an @code{int *} pointer with the address of
@code{f}, you can simply write @code{(int *)&f}.

@node Conditionals
@section Conditional Expressions with Omitted Operands
@cindex conditional expressions, extensions
@cindex omitted middle-operands
@cindex middle-operands, omitted
@cindex extensions, @code{?:}
@cindex @code{?:} extensions

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
expression.

Therefore, the expression

@example
x ? : y
@end example

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

This example is perfectly equivalent to

@example
x ? x : y
@end example

@cindex side effect in ?:
@cindex ?: side effect
@noindent
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,
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 middle operand uses the value already computed without the undesirable
effects of recomputing it.

@node Long Long
@section Double-Word Integers
@cindex @code{long long} data types
@cindex double-word arithmetic
@cindex multiprecision arithmetic

GNU C supports data types for integers that are twice as long as
@code{long int}.  Simply write @code{long long int} for a signed
integer, or @code{unsigned long long int} for an unsigned integer.

You can use these types in arithmetic like any other integer types.
Addition, subtraction, and bitwise boolean operations on these types
are open-coded on all types of machines.  Multiplication is open-coded
if the machine supports fullword-to-doubleword a widening multiply
instruction.  Division and shifts are open-coded only on machines that
provide special support.  The operations that are not open-coded use
special library routines that come with GNU CC.

There may be pitfalls when you use @code{long long} types for function
arguments, unless you declare function prototypes.  If a function
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
subroutine will disagree about the number of bytes for the argument.
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.

@node Zero Length
@section Arrays of Length Zero
@cindex arrays of length zero
@cindex zero-length arrays
@cindex length-zero arrays

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
object:

@example
struct line @{
  int length;
  char contents[0];
@};

@{
  struct line *thisline = (struct line *)
    malloc (sizeof (struct line) + this_length);
  thisline->length = this_length;
@}
@end example

In standard C, you would have to give @code{contents} a length of 1, which
means either you waste space or complicate the argument to @code{malloc}.

@node Variable Length
@section Arrays of Variable Length
@cindex variable-length arrays
@cindex arrays of variable length

Variable-length automatic arrays are allowed in GNU C.  These arrays are
declared like any other automatic arrays, but with a length that is not
a constant expression.  The storage is allocated at the point of
declaration and deallocated when the brace-level is exited.  For
example:

@example
FILE *
concat_fopen (char *s1, char *s2, char *mode)
@{
  char str[strlen (s1) + strlen (s2) + 1];
  strcpy (str, s1);
  strcat (str, s2);
  return fopen (str, mode);
@}
@end example

@cindex scope of a variable length array
@cindex variable-length array scope
@cindex deallocating variable length arrays
Jumping or breaking out of the scope of the array name deallocates the
storage.  Jumping into the scope is not allowed; you get an error
message for it.

@cindex @code{alloca} vs variable-length arrays
You can use the function @code{alloca} to get an effect much like
variable-length arrays.  The function @code{alloca} is available in
many other C implementations (but not in all).  On the other hand,
variable-length arrays are more elegant.

There are other differences between these two methods.  Space allocated
with @code{alloca} exists until the containing @emph{function} returns.
The space for a variable-length array is deallocated as soon as the array
name's scope ends.  (If you use both variable-length arrays and
@code{alloca} in the same function, deallocation of a variable-length array
will also deallocate anything more recently allocated with @code{alloca}.)

You can also use variable-length arrays as arguments to functions:

@example
struct entry
tester (int len, char data[len][len])
@{
  @dots{}
@}
@end example

The length of an array is computed once when the storage is allocated
and is remembered for the scope of the array in case you access it with
@code{sizeof}.

If you want to pass the array first and the length afterward, you can
use a forward declaration in the parameter list---another GNU extension.

@example
struct entry
tester (int len; char data[len][len], int len)
@{
  @dots{}
@}
@end example

@cindex parameter forward declaration
The @samp{int len} before the semicolon is a @dfn{parameter forward
declaration}, and it serves the purpose of making the name @code{len}
known when the declaration of @code{data} is parsed.

You can write any number of such parameter forward declarations in the
parameter list.  They can be separated by commas or semicolons, but the
last one must end with a semicolon, which is followed by the ``real''
parameter declarations.  Each forward declaration must match a ``real''
declaration in parameter name and data type.

@node Macro Varargs
@section Macros with Variable Numbers of Arguments
@cindex variable number of arguments
@cindex macro with variable arguments
@cindex rest argument (in macro)

In GNU C, a macro can accept a variable number of arguments, much as a
function can.  The syntax for defining the macro looks much like that
used for a function.  Here is an example:

@example
#define eprintf(format, args...)  \
 fprintf (stderr, format, ## args)
@end example

Here @code{args} is a @dfn{rest argument}: it takes in zero or more
arguments, as many as the call contains.  All of them plus the commas
between them form the value of @code{args}, which is substituted into
the macro body where @code{args} is used.  Thus, we have these
expansions: