1 .\" Copyright (C) Caldera International Inc. 2001-2002. All rights reserved.
3 .\" Redistribution and use in source and binary forms, with or without
4 .\" modification, are permitted provided that the following conditions are
7 .\" Redistributions of source code and documentation must retain the above
8 .\" copyright notice, this list of conditions and the following
11 .\" Redistributions in binary form must reproduce the above copyright
12 .\" notice, this list of conditions and the following disclaimer in the
13 .\" documentation and/or other materials provided with the distribution.
15 .\" All advertising materials mentioning features or use of this software
16 .\" must display the following acknowledgement:
18 .\" This product includes software developed or owned by Caldera
19 .\" International, Inc. Neither the name of Caldera International, Inc.
20 .\" nor the names of other contributors may be used to endorse or promote
21 .\" products derived from this software without specific prior written
24 .\" USE OF THE SOFTWARE PROVIDED FOR UNDER THIS LICENSE BY CALDERA
25 .\" INTERNATIONAL, INC. AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR
26 .\" IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
27 .\" WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
28 .\" DISCLAIMED. IN NO EVENT SHALL CALDERA INTERNATIONAL, INC. BE LIABLE
29 .\" FOR ANY DIRECT, INDIRECT INCIDENTAL, SPECIAL, EXEMPLARY, OR
30 .\" CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
31 .\" SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
32 .\" BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
33 .\" WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
34 .\" OR OTHERWISE) RISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
35 .\" IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
37 .\" @(#)Clang.ms 8.1 (Berkeley) 6/8/93
42 The C Programming Language - Reference Manual
46 AT&T Bell Laboratories
49 This manual is a reprint, with updates to the current C standard, from
50 \fIThe C Programming Language\fR,
51 by Brian W. Kernighan and Dennis M. Ritchie, Prentice-Hall, Inc., 1978.
53 \fBThis document is of historical interest only. Do not use it as a reference
54 for modern implementations of C.\fP
55 .EH 'PSD:6-%''The C Programming Language - Reference Manual'
56 .OH 'The C Programming Language - Reference Manual''PSD:6-%'
60 This manual describes the C language on the DEC PDP-11\(dg, the DEC VAX-11,
63 \(dg DEC PDP-11, and DEC VAX-11 are trademarks of Digital Equipment Corporation.
65 \(dd 3B 20 is a trademark of AT&T.
67 and the AT&T 3B 20\(dd.
68 Where differences exist, it concentrates on the VAX, but tries to point
69 out implementation-dependent details. With few exceptions, these dependencies
70 follow directly from the underlying properties of the hardware; the various
71 compilers are generally quite compatible.
75 There are six classes of tokens\ -\
76 identifiers, keywords, constants, strings, operators, and other separators.
77 Blanks, tabs, new\(hylines,
78 and comments (collectively, ``white space'') as described below
79 are ignored except as they serve to separate
81 Some white space is required to separate
82 otherwise adjacent identifiers,
83 keywords, and constants.
85 If the input stream has been parsed into tokens
86 up to a given character, the next token is taken
87 to include the longest string of characters
88 which could possibly constitute a token.
96 introduce a comment which terminates
103 An identifier is a sequence of letters and digits.
104 The first character must be a letter.
108 Uppercase and lowercase letters
110 Although there is no limit on the length of a name,
111 only initial characters are significant: at least
112 eight characters of a non-external name, and perhaps
113 fewer for external names.
114 Moreover, some implementations may collapse case
115 distinctions for external names.
116 The external name sizes include:
120 PDP-11 7 characters, 2 cases
121 VAX-11 >100 characters, 2 cases
122 AT&T 3B 20 >100 characters, 2 cases
129 The following identifiers are reserved for use
130 as keywords and may not be used otherwise:
132 .ta 0.8i 1.6i 2.4i 3.2i 4.0i
133 \fBauto do for return typedef
134 break double goto short union
135 case else if sizeof unsigned
136 char enum int static void
137 continue external long struct while
138 default float register switch\fR
142 Some implementations also reserve the words
144 fortran, asm, gfloat, hfloat
152 There are several kinds
154 Each has a type; an introduction to types is given in ``NAMES.''
155 Hardware characteristics that affect sizes are summarized in
156 ``Hardware Characteristics'' under ``LEXICAL CONVENTIONS.''
161 An integer constant consisting of a sequence of digits
163 to be octal if it begins with
168 An octal constant consists of the digits \fB0\fR through \fB7\fR only.
169 A sequence of digits preceded by
177 (digit zero) is taken to be a hexadecimal integer.
178 The hexadecimal digits include
194 with values 10 through 15.
195 Otherwise, the integer constant is taken to be decimal.
196 A decimal constant whose value exceeds the largest
197 signed machine integer is taken to be
199 an octal or hex constant which exceeds the largest unsigned machine integer
200 is likewise taken to be
204 Otherwise, integer constants are \fBint\fR.
206 Explicit Long Constants
209 A decimal, octal, or hexadecimal integer constant immediately followed
222 integer and long values may be considered identical.
227 A character constant is a character enclosed in single quotes,
229 The value of a character constant is the numerical value of the
230 character in the machine's character set.
232 Certain nongraphic characters,
237 may be represented according to the following table
242 new\(hyline NL (LF) \en
243 horizontal tab HT \et
246 carriage return CR \er
250 bit pattern \fIddd\fR\^ \e\fIddd\fR\^
256 consists of the backslash followed by 1, 2, or 3 octal digits
257 which are taken to specify the value of the
259 A special case of this construction is
264 by a digit), which indicates the character
268 If the character following a backslash is not one
269 of those specified, the
270 behavior is undefined.
271 A new-line character is illegal in a character constant.
272 The type of a character constant is \fBint\fR.
277 A floating constant consists of
278 an integer part, a decimal point, a fraction part,
285 and an optionally signed integer exponent.
286 The integer and fraction parts both consist of a sequence
288 Either the integer part or the fraction
289 part (not both) may be missing.
290 Either the decimal point or
295 and the exponent (not both) may be missing.
296 Every floating constant has type \fBdouble\fR.
298 Enumeration Constants
301 Names declared as enumerators
302 (see ``Structure, Union, and Enumeration Declarations'' under
308 A string is a sequence of characters surrounded by
313 ``array of \fBchar\fR'' and storage class
316 and is initialized with
317 the given characters.
321 at the end of each string so that programs
322 which scan the string can
324 In a string, the double quote character
329 in addition, the same escapes as described for character
330 constants may be used.
337 the immediately following new\(hyline are ignored.
338 All strings, even when written identically, are distinct.
340 Hardware Characteristics
342 The following figure summarize
343 certain hardware properties that vary from machine to machine.
349 l | l1 lp8 | l1 lp8 | l1 lp8.
350 DEC PDP\-11 DEC VAX-11 AT&T 3B
351 (ASCII) (ASCII) (ASCII)
354 char 8 bits 8 bits 8bits
360 float range \(+-10 \(+-38 \(+-10 \(+-38 \(+-10 \(+-38
362 double range \(+-10 \(+-38 \(+-10 \(+-38 \(+-10 \(+-308
365 .\" .FG 4 4 1 "DEC PDP-11 HARDWARE CHARACTERISTICS"
371 Syntactic categories are indicated by
376 and literal words and characters
380 Alternative categories are listed on separate lines.
381 An optional terminal or nonterminal symbol is
382 indicated by the subscript ``opt,'' so that
384 { \fIexpression\v'0.5'\s-2opt\s0\v'-0.5'\fR }
387 indicates an optional expression enclosed in braces.
388 The syntax is summarized in ``SYNTAX SUMMARY''.
392 The C language bases the interpretation of an
393 identifier upon two attributes of the identifier \(mi its
400 The storage class determines the location and lifetime
401 of the storage associated with an identifier;
403 the meaning of the values
404 found in the identifier's storage.
408 .\" The original text had borrowed BL, LI and LE from the mm macros.
409 .\" That way madness lies.
410 There are four declarable storage classes:
422 Automatic variables are local to each invocation of
423 a block (see ``Compound Statement or Block'' in
424 ``STATEMENTS'') and are discarded upon exit from the block.
425 Static variables are local to a block but retain
426 their values upon reentry to a block even after control
428 External variables exist and retain their values throughout
429 the execution of the entire program and
430 may be used for communication between
431 functions, even separately compiled functions.
432 Register variables are (if possible) stored in the fast registers
433 of the machine; like automatic
434 variables, they are local to each block and disappear on exit from the block.
438 The C language supports several
441 Objects declared as characters
443 are large enough to store any member of the implementation's
445 If a genuine character from that character set is
446 stored in a \fBchar\fR variable,
447 its value is equivalent to the integer code for that character.
448 Other quantities may be stored into character variables, but
449 the implementation is machine dependent.
450 In particular, \fBchar\fR may be signed or unsigned by default.
452 Up to three sizes of integer, declared
464 Longer integers provide no less storage than shorter ones,
465 but the implementation may make either short integers or long integers,
466 or both, equivalent to plain integers.
467 ``Plain'' integers have the natural size suggested
468 by the host machine architecture.
469 The other sizes are provided to meet special needs.
471 The properties of \fBenum\fR types (see ``Structure, Union, and Enumeration Declarations''
472 under ``DECLARATIONS'')
473 are identical to those of
475 The implementation may use the range of values to
476 determine how to allocate storage.
483 obey the laws of arithmetic modulo
484 2\v'-0.5'\fIn\fR\v'0.5'
485 where \fIn\fR is the number of bits in the representation.
488 unsigned long quantities are not supported.)
490 Single-precision floating point
492 and double precision floating point
494 may be synonymous in some implementations.
496 Because objects of the foregoing types can usefully be interpreted
497 as numbers, they will be referred to as
506 of all sizes whether \fBunsigned\fR or not, and
510 will collectively be called
523 types will collectively be called
534 specifies an empty set of values.
535 It is used as the type returned by functions that
538 Besides the fundamental arithmetic types, there is a
539 conceptually infinite class of derived types constructed
540 from the fundamental types in the following ways:
542 of objects of most types
544 which return objects of a given type
546 to objects of a given type
548 containing a sequence of objects of various types
550 capable of containing any one of several objects of various types.
552 In general these methods
553 of constructing objects can
554 be applied recursively.
562 is a manipulatable region of storage.
567 is an expression referring to an object.
568 An obvious example of an lvalue
569 expression is an identifier.
570 There are operators which yield lvalues:
576 is an expression of pointer type, then
581 expression referring to the object to which
586 The name ``lvalue'' comes from the assignment expression
590 in which the left operand
595 an lvalue expression.
596 The discussion of each operator
597 below indicates whether it expects lvalue operands and whether it
602 A number of operators may, depending on their operands,
603 cause conversion of the value of an operand from one type to another.
604 This part explains the result to be expected from such
606 The conversions demanded by most ordinary operators are summarized under
607 ``Arithmetic Conversions.''
608 The summary will be supplemented
609 as required by the discussion
612 Characters and Integers
614 A character or a short integer may be used wherever an
617 the value is converted to an integer.
618 Conversion of a shorter integer
619 to a longer preserves sign.
620 Whether or not sign-extension occurs for characters is machine
621 dependent, but it is guaranteed that a member of the
622 standard character set is non-negative.
623 Of the machines treated here,
633 variables range in value from
635 The more explicit type
642 forces the values to range from 0 to 255.
644 On machines that treat characters as signed,
645 the characters of the
647 set are all non-negative.
648 However, a character constant specified
649 with an octal escape suffers sign extension
650 and may appear negative;
657 When a longer integer is converted to a shorter
663 it is truncated on the left.
664 Excess bits are simply discarded.
668 All floating arithmetic in C is carried out in double precision.
673 appears in an expression it is lengthened to
677 by zero padding its fraction.
685 for example by an assignment,
696 This result is undefined if it cannot be represented as a float.
697 On the VAX, the compiler can be directed to use single precision for expressions
698 containing only float and integer operands.
700 Floating and Integral
702 Conversions of floating values to integral type
703 are rather machine dependent.
704 In particular, the direction of truncation of negative numbers
706 The result is undefined if
707 it will not fit in the space provided.
709 Conversions of integral values to floating type
711 Some loss of accuracy occurs
712 if the destination lacks sufficient bits.
714 Pointers and Integers
716 An expression of integral type may be added to or subtracted from
717 a pointer; in such a case,
718 the first is converted as
719 specified in the discussion of the addition operator.
720 Two pointers to objects of the same type may be subtracted;
721 in this case, the result is converted to an integer
722 as specified in the discussion of the subtraction
727 Whenever an unsigned integer and a plain integer
728 are combined, the plain integer is converted to unsigned
729 and the result is unsigned.
731 is the least unsigned integer congruent to the signed
732 integer (modulo 2\v'-0.3'\s-2wordsize\s+2\v'0.3').
733 In a 2's complement representation,
734 this conversion is conceptual; and there is no actual change in the
737 When an unsigned \fBshort\fR integer is converted to
739 the value of the result is the same numerically as that of the
741 Thus the conversion amounts to padding with zeros on the left.
743 Arithmetic Conversions
745 A great many operators cause conversions
746 and yield result types in a similar way.
747 This pattern will be called the ``usual arithmetic conversions.''
749 First, any operands of type
759 and any operands of type \fBunsigned char\fR
760 or \fBunsigned short\fR are converted
761 to \fBunsigned int\fR.
763 Then, if either operand is
767 the other is converted to
771 and that is the type of the result.
773 Otherwise, if either operand is \fBunsigned long\fR,
774 the other is converted to \fBunsigned long\fR and that
775 is the type of the result.
777 Otherwise, if either operand is
779 the other is converted to
783 and that is the type of the result.
785 Otherwise, if one operand is \fBlong\fR, and
786 the other is \fBunsigned int\fR, they are both
787 converted to \fBunsigned long\fR and that is
788 the type of the result.
790 Otherwise, if either operand is
794 the other is converted to
798 and that is the type of the result.
800 Otherwise, both operands must be
802 and that is the type of the result.
807 The (nonexistent) value of a
811 object may not be used in any way,
812 and neither explicit nor implicit conversion may be applied.
813 Because a void expression denotes a nonexistent value,
814 such an expression may be used only
815 as an expression statement
816 (see ``Expression Statement'' under ``STATEMENTS'')
817 or as the left operand
818 of a comma expression (see ``Comma Operator'' under ``EXPRESSIONS'').
820 An expression may be converted to
826 For example, this makes explicit the discarding of the value
827 of a function call used as an expression statement.
831 The precedence of expression operators is the same
832 as the order of the major
833 subsections of this section, highest precedence first.
834 Thus, for example, the expressions referred to as the operands of
838 (see ``Additive Operators'')
839 are those expressions defined under ``Primary Expressions'',
840 ``Unary Operators'', and ``Multiplicative Operators''.
841 Within each subpart, the operators have the same
843 Left- or right-associativity is specified
844 in each subsection for the operators
846 The precedence and associativity of all the expression
847 operators are summarized in the
848 grammar of ``SYNTAX SUMMARY''.
850 Otherwise, the order of evaluation of expressions
851 is undefined. In particular, the compiler
852 considers itself free to
853 compute subexpressions in the order it believes
855 even if the subexpressions
856 involve side effects.
857 The order in which subexpression evaluation takes place is unspecified.
858 Expressions involving a commutative and associative
865 may be rearranged arbitrarily even in the presence
867 to force a particular order of evaluation,
868 an explicit temporary must be used.
870 The handling of overflow and divide check
871 in expression evaluation
873 Most existing implementations of C ignore integer overflows;
875 division by 0 and all floating-point exceptions
876 varies between machines and is usually
877 adjustable by a library function.
884 subscripting, and function calls
887 \fIprimary-expression:
892 primary-expression [ expression ]
893 primary-expression ( expression-list\v'0.5'\s-2opt\s0\v'-0.5' )
894 primary-expression . identifier
895 primary-expression \(mi> identifier\fR
900 expression-list , expression\fR
903 An identifier is a primary expression provided it has been
904 suitably declared as discussed below.
905 Its type is specified by its declaration.
906 If the type of the identifier is ``array of .\|.\|.'',
907 then the value of the identifier expression
909 to the first object in the array; and the
910 type of the expression is
911 ``pointer to .\|.\|.''.
912 Moreover, an array identifier is not an lvalue
914 Likewise, an identifier which is declared
915 ``function returning .\|.\|.'',
916 when used except in the function-name position
917 of a call, is converted to ``pointer to function returning .\|.\|.''.
920 constant is a primary expression.
928 depending on its form.
929 Character constants have type
933 and floating constants have type
938 A string is a primary expression.
939 Its type is originally ``array of
942 the same rule given above for identifiers,
943 this is modified to ``pointer to
946 result is a pointer to the first character
948 (There is an exception in certain initializers;
949 see ``Initialization'' under ``DECLARATIONS.'')
951 A parenthesized expression is a primary expression
952 whose type and value are identical
953 to those of the unadorned expression.
954 The presence of parentheses does
955 not affect whether the expression is an
958 A primary expression followed by an expression in square
959 brackets is a primary expression.
960 The intuitive meaning is that of a subscript.
961 Usually, the primary expression has type ``pointer to .\|.\|.'',
962 the subscript expression is
964 and the type of the result is ``\|.\|.\|.\|''.
970 identical (by definition) to
972 \(**((E1)\(plE2))\fR.
975 this notation are contained in this subpart together
977 in ``Unary Operators'' and ``Additive Operators'' on identifiers,
986 The implications are summarized under ``Arrays, Pointers, and Subscripting''
987 under ``TYPES REVISITED.''
989 A function call is a primary expression followed by parentheses
990 containing a possibly
991 empty, comma-separated list of expressions
992 which constitute the actual arguments to the
994 The primary expression must be of type ``function returning .\|.\|.,''
995 and the result of the function call is of type ``\|.\|.\|.\|''.
997 below, a hitherto unseen identifier followed
998 immediately by a left parenthesis
999 is contextually declared
1000 to represent a function returning
1002 thus in the most common case, integer-valued functions
1003 need not be declared.
1005 Any actual arguments of type
1027 Array names are converted to pointers.
1028 No other conversions are performed automatically;
1029 in particular, the compiler does not compare
1030 the types of actual arguments with those of formal
1032 If conversion is needed, use a cast;
1033 see ``Unary Operators'' and ``Type Names'' under
1036 In preparing for the call to a function,
1037 a copy is made of each actual parameter.
1038 Thus, all argument passing in C is strictly by value.
1040 change the values of its formal parameters, but
1041 these changes cannot affect the values
1042 of the actual parameters.
1044 to pass a pointer on the understanding
1045 that the function may change the value
1046 of the object to which the pointer points.
1047 An array name is a pointer expression.
1048 The order of evaluation of arguments is undefined by the language;
1049 take note that the various compilers differ.
1050 Recursive calls to any
1051 function are permitted.
1053 A primary expression followed by a dot followed by an identifier
1055 The first expression must be a structure or a union, and the identifier
1056 must name a member of the structure or union.
1057 The value is the named member of the structure or union, and it is
1058 an lvalue if the first expression is an lvalue.
1060 A primary expression followed by an arrow (built from
1069 followed by an identifier
1071 The first expression must be a pointer to a structure or a union
1072 and the identifier must name a member of that structure or union.
1073 The result is an lvalue referring to the named member
1074 of the structure or union
1075 to which the pointer expression points.
1084 Structures and unions are discussed in
1085 ``Structure, Union, and Enumeration Declarations'' under
1090 Expressions with unary operators
1091 group right to left.
1094 \fIunary-expression:
1104 ( type-name ) expression\fR
1105 sizeof\fI expression\fR
1106 sizeof\fI ( type-name )\fR
1119 the expression must be a pointer, and the result
1120 is an lvalue referring to the object to
1121 which the expression points.
1122 If the type of the expression is ``pointer to .\|.\|.,''
1123 the type of the result is ``\|.\|.\|.\|''.
1125 The result of the unary
1129 operator is a pointer
1130 to the object referred to by the
1132 If the type of the lvalue is ``\|.\|.\|.\|'',
1133 the type of the result is ``pointer to .\|.\|.''.
1141 is the negative of its operand.
1142 The usual arithmetic conversions are performed.
1143 The negative of an unsigned quantity is computed by
1144 subtracting its value from
1145 2\v'-0.5'\fIn\fR\^\v'0.5' where \fIn\fR\^ is the number of bits in
1146 the corresponding signed type.
1155 The result of the logical negation operator
1159 is one if the value of its operand is zero, zero if the value of its
1161 The type of the result is
1165 It is applicable to any arithmetic type
1172 operator yields the one's complement of its operand.
1173 The usual arithmetic conversions are performed.
1174 The type of the operand must be integral.
1176 The object referred to by the lvalue operand of prefix
1181 The value is the new value of the operand
1182 but is not an lvalue.
1189 See the discussions ``Additive Operators'' and ``Assignment
1190 Operators'' for information on conversions.
1192 The lvalue operand of prefix
1208 is applied to an lvalue,
1209 the result is the value of the object referred to by the lvalue.
1210 After the result is noted, the object
1211 is incremented in the same
1212 manner as for the prefix
1217 The type of the result is the same as the type of the lvalue expression.
1223 is applied to an lvalue,
1224 the result is the value of the object referred to by the lvalue.
1225 After the result is noted, the object
1226 is decremented in the manner as for the prefix
1231 The type of the result is the same as the type of the lvalue
1234 An expression preceded by the parenthesized name of a data type
1235 causes conversion of the value of the expression to the named type.
1236 This construction is called a
1240 Type names are described in ``Type Names'' under ``Declarations.''
1246 operator yields the size
1247 in bytes of its operand.
1252 is undefined by the language
1253 except in terms of the value of
1257 However, in all existing implementations,
1258 a byte is the space required to hold a
1260 When applied to an array, the result is the total
1261 number of bytes in the array.
1262 The size is determined from
1264 the objects in the expression.
1265 This expression is semantically an
1270 be used anywhere a constant is required.
1271 Its major use is in communication with routines
1272 like storage allocators and I/O systems.
1279 may also be applied to a parenthesized type name.
1280 In that case it yields the size in bytes of an object
1281 of the indicated type.
1284 \fBsizeof(\fItype\|\fR\^)\fR\^
1285 is taken to be a unit,
1287 \fBsizeof(\fItype\|\fB)-2\fR
1289 \fB(sizeof(\fItype\|\fB))-2\fR.
1291 Multiplicative Operators
1293 The multiplicative operators
1300 group left to right.
1301 The usual arithmetic conversions are performed.
1303 \fImultiplicative expression:
1304 expression \(** expression
1305 expression / expression
1306 expression % expression\fR
1313 operator indicates multiplication.
1318 operator is associative,
1319 and expressions with several multiplications at the same
1320 level may be rearranged by the compiler.
1325 operator indicates division.
1331 operator yields the remainder
1332 from the division of the first expression by the second.
1333 The operands must be integral.
1335 When positive integers are divided, truncation is toward 0;
1336 but the form of truncation is machine-dependent
1337 if either operand is negative.
1338 On all machines covered by this manual,
1339 the remainder has the same sign as the dividend.
1340 It is always true that
1342 (a/b)\(**b\ \(pl a%b
1356 The additive operators
1364 group left to right.
1365 The usual arithmetic conversions are performed.
1366 There are some additional type possibilities for each operator.
1368 \fIadditive-expression:
1369 expression \(pl expression
1370 expression \(mi expression\fR
1377 operator is the sum of the operands.
1378 A pointer to an object in an array and
1379 a value of any integral type
1381 The latter is in all cases converted to
1384 by the length of the object to which the
1386 The result is a pointer
1387 of the same type as the original pointer
1388 which points to another object in the same array,
1389 appropriately offset from the original object.
1395 to an object in an array, the expression
1400 to the next object in the array.
1401 No further type combinations are allowed for pointers.
1407 operator is associative,
1408 and expressions with several additions at the same level may
1409 be rearranged by the compiler.
1415 operator is the difference of the operands.
1416 The usual arithmetic conversions are performed.
1418 a value of any integral type
1419 may be subtracted from a pointer,
1420 and then the same conversions for addition apply.
1422 If two pointers to objects of the same type are subtracted,
1423 the result is converted
1424 (by division by the length of the object)
1429 representing the number of
1431 the pointed-to objects.
1432 This conversion will in general give unexpected
1433 results unless the pointers point
1434 to objects in the same array, since pointers, even
1435 to objects of the same type, do not necessarily differ
1436 by a multiple of the object length.
1448 group left to right.
1449 Both perform the usual arithmetic conversions on their operands,
1450 each of which must be integral.
1451 Then the right operand is converted to
1453 the type of the result is that of the left operand.
1454 The result is undefined if the right operand is negative
1455 or greater than or equal to the length of the object in bits.
1456 On the VAX a negative right operand is interpreted as reversing
1457 the direction of the shift.
1459 \fIshift-expression:
1460 expression << expression
1461 expression >> expression\fR
1472 (interpreted as a bit
1473 pattern) left-shifted
1478 Vacated bits are 0 filled.
1492 The right shift is guaranteed to be logical
1500 otherwise, it may be
1503 Relational Operators
1505 The relational operators group left to right.
1507 \fIrelational-expression:
1508 expression < expression
1509 expression > expression
1510 expression <= expression
1511 expression >= expression\fR
1522 (greater than), \fB<=\fR
1528 (greater than or equal to)
1529 all yield 0 if the specified relation is false
1530 and 1 if it is true.
1531 The type of the result is
1534 The usual arithmetic conversions are performed.
1535 Two pointers may be compared;
1536 the result depends on the relative locations in the address space
1537 of the pointed-to objects.
1538 Pointer comparison is portable only when the pointers point to objects
1544 \fIequality-expression:
1545 expression == expression
1546 expression != expression\fR
1557 (not equal to) operators
1558 are exactly analogous to the relational
1559 operators except for their lower
1573 have the same truth value).
1575 A pointer may be compared to an integer
1577 integer is the constant 0.
1578 A pointer to which 0 has been assigned is guaranteed
1579 not to point to any object
1580 and will appear to be equal to 0.
1581 In conventional usage, such a pointer is considered to be null.
1583 Bitwise \s-1AND\s0 Operator
1587 expression & expression\fR
1594 operator is associative,
1595 and expressions involving
1600 The usual arithmetic conversions are performed.
1601 The result is the bitwise
1603 function of the operands.
1604 The operator applies only to integral
1607 Bitwise Exclusive \s-1OR\s0 Operator
1609 \fIexclusive-or-expression:
1610 expression ^ expression\fR
1617 operator is associative,
1618 and expressions involving
1623 The usual arithmetic conversions are performed;
1625 the bitwise exclusive
1629 The operator applies only to integral
1632 Bitwise Inclusive \s-1OR\s0 Operator
1634 \fIinclusive-or-expression:
1635 expression | expression\fR
1642 operator is associative,
1643 and expressions involving
1648 The usual arithmetic conversions are performed;
1649 the result is the bitwise inclusive
1651 function of its operands.
1652 The operator applies only to integral
1655 Logical \s-1AND\s0 Operator
1657 \fIlogical-and-expression:
1658 expression && expression\fR
1665 operator groups left to right.
1666 It returns 1 if both its operands
1667 evaluate to nonzero, 0 otherwise.
1673 guarantees left to right
1674 evaluation; moreover, the second operand is not evaluated
1675 if the first operand is 0.
1677 The operands need not have the same type, but each
1678 must have one of the fundamental
1679 types or be a pointer.
1680 The result is always
1685 Logical \s-1OR\s0 Operator
1687 \fIlogical-or-expression:
1688 expression || expression\fR
1695 operator groups left to right.
1696 It returns 1 if either of its operands
1697 evaluates to nonzero, 0 otherwise.
1703 guarantees left to right evaluation; moreover,
1704 the second operand is not evaluated
1705 if the value of the first operand is nonzero.
1707 The operands need not have the same type, but each
1709 have one of the fundamental types
1711 The result is always
1716 Conditional Operator
1718 \fIconditional-expression:
1719 expression ? expression : expression\fR
1722 Conditional expressions group right to left.
1723 The first expression is evaluated;
1724 and if it is nonzero, the result is the value of the
1725 second expression, otherwise that of third expression.
1726 If possible, the usual arithmetic conversions are performed
1727 to bring the second and third expressions to a common type.
1728 If both are structures or unions of the same type,
1729 the result has the type of the structure or union.
1730 If both pointers are of the same type,
1731 the result has the common type.
1732 Otherwise, one must be a pointer and the other the constant 0,
1733 and the result has the type of the pointer.
1734 Only one of the second and third
1735 expressions is evaluated.
1737 Assignment Operators
1739 There are a number of assignment operators,
1740 all of which group right to left.
1741 All require an lvalue as their left operand,
1742 and the type of an assignment expression is that
1743 of its left operand.
1744 The value is the value stored in the
1745 left operand after the assignment has taken place.
1746 The two parts of a compound assignment operator are separate
1749 \fIassignment-expression:
1751 lvalue \(pl= expression
1752 lvalue \(mi= expression
1753 lvalue \(**= expression
1754 lvalue /= expression
1755 lvalue %= expression
1756 lvalue >>= expression
1757 lvalue <<= expression
1758 lvalue &= expression
1759 lvalue ^= expression
1760 lvalue |= expression\fR
1763 In the simple assignment with
1765 the value of the expression replaces that of the object
1768 If both operands have arithmetic type,
1769 the right operand is converted to the type of the left
1770 preparatory to the assignment.
1771 Second, both operands may be structures or unions of the same type.
1772 Finally, if the left operand is a pointer, the right operand must in general be a pointer
1774 However, the constant 0 may be assigned to a pointer;
1775 it is guaranteed that this value will produce a null
1776 pointer distinguishable from a pointer to any object.
1778 The behavior of an expression
1780 \fBE1\fR\^ \fIop\fR\^ = \fBE2\fR\^
1782 taking it as equivalent to
1783 \fBE1 = E1 \fIop\fR\^ (\fBE2\fR\^);
1788 is evaluated only once.
1795 the left operand may be a pointer; in which case, the (integral) right
1796 operand is converted as explained
1797 in ``Additive Operators.''
1798 All right operands and all nonpointer left operands must
1799 have arithmetic type.
1803 \fIcomma-expression:
1804 expression , expression\fR
1807 A pair of expressions separated by a comma is evaluated
1808 left to right, and the value of the left expression is
1810 The type and value of the result are the
1811 type and value of the right operand.
1812 This operator groups left to right.
1813 In contexts where comma is given a special meaning,
1814 e.g., in lists of actual arguments
1815 to functions (see ``Primary Expressions'') and lists
1816 of initializers (see ``Initialization'' under ``DECLARATIONS''),
1817 the comma operator as described in this subpart
1818 can only appear in parentheses. For example,
1820 \fBf(a, (t=3, t\(pl2), c)\fR
1823 has three arguments, the second of which has the value 5.
1827 Declarations are used to specify the interpretation
1828 which C gives to each identifier; they do not necessarily
1829 reserve storage associated with the identifier.
1830 Declarations have the form
1833 decl-specifiers declarator-list\v'0.5'\s-2opt\s0\v'-0.5' ;\fR
1836 The declarators in the declarator-list
1837 contain the identifiers being declared.
1839 consist of a sequence of type and storage class specifiers.
1842 type-specifier decl-specifiers\v'0.5'\s-2opt\s0\v'-0.5'
1843 sc-specifier decl-specifiers\v'0.5'\s-2opt\s0\v'-0.5'\fR
1846 The list must be self-consistent in a way described below.
1848 Storage Class Specifiers
1850 The sc-specifiers are:
1864 specifier does not reserve storage
1865 and is called a ``storage class specifier'' only for syntactic convenience.
1866 See ``Typedef'' for more information.
1867 The meanings of the various storage classes were discussed in ``Names.''
1876 declarations also serve as definitions
1877 in that they cause an appropriate amount of storage to be reserved.
1883 there must be an external definition (see ``External Definitions'')
1884 for the given identifiers
1885 somewhere outside the function in which they are declared.
1891 declaration is best thought of as an
1895 declaration, together with a hint to the compiler
1896 that the variables declared will be heavily used.
1898 such declarations in each function are effective.
1899 Moreover, only variables of certain types will be stored in registers;
1907 One other restriction applies to register variables:
1908 the address-of operator
1912 cannot be applied to them.
1913 Smaller, faster programs can be expected if register declarations
1914 are used appropriately,
1915 but future improvements in code generation
1916 may render them unnecessary.
1918 At most, one sc-specifier may be given in a declaration.
1919 If the sc-specifier is missing from a declaration, it
1935 The type-specifiers are
1938 struct-or-union-specifier
1941 basic-type-specifier:
1943 basic-type basic-type-specifiers
1955 At most one of the words \fBlong\fR or \fBshort\fR
1956 may be specified in conjunction with \fBint\fR;
1957 the meaning is the same as if \fBint\fR were not mentioned.
1958 The word \fBlong\fR may be specified in conjunction with
1960 the meaning is the same as \fBdouble\fR.
1961 The word \fBunsigned\fR may be specified alone, or
1962 in conjunction with \fBint\fR or any of its short
1963 or long varieties, or with \fBchar\fR.
1965 Otherwise, at most on type-specifier may be
1966 given in a declaration.
1967 In particular, adjectival use of \fBlong\fR,
1968 \fBshort\fR, or \fBunsigned\fR is not permitted
1969 with \fBtypedef\fR names.
1970 If the type-specifier is missing from a declaration,
1971 it is taken to be \fBint\fR.
1973 Specifiers for structures, unions, and enumerations are discussed in
1974 ``Structure, Union, and Enumeration Declarations.''
1979 names are discussed in ``Typedef.''
1983 The declarator-list appearing in a declaration
1984 is a comma-separated sequence of declarators,
1985 each of which may have an initializer.
1989 init-declarator , declarator-list
1993 declarator initializer\v'0.5'\s-2opt\s0\v'-0.5'\fR
1996 Initializers are discussed in ``Initialization''.
1997 The specifiers in the declaration
1998 indicate the type and storage class of the objects to which the
2000 Declarators have the syntax:
2007 declarator [ constant-expression\v'0.5'\s-2opt\s0\v'-0.5' ]\fR
2011 the same as in expressions.
2013 Meaning of Declarators
2015 Each declarator is taken to be
2016 an assertion that when a construction of
2017 the same form as the declarator appears in an expression,
2018 it yields an object of the indicated
2019 type and storage class.
2021 Each declarator contains exactly one identifier; it is this identifier that
2023 If an unadorned identifier appears
2024 as a declarator, then it has the type
2025 indicated by the specifier heading the declaration.
2027 A declarator in parentheses is identical to the unadorned declarator,
2028 but the binding of complex declarators may be altered by parentheses.
2029 See the examples below.
2031 Now imagine a declaration
2040 is a type-specifier (like
2048 Suppose this declaration makes the identifier have type
2054 where the ``\|.\|.\|.\|'' is empty if
2058 is just a plain identifier
2059 (so that the type of
2076 the type of the contained identifier is
2077 ``\|.\|.\|.\| pointer to
2092 then the contained identifier has the type
2093 ``\|.\|.\|. function returning
2102 \fBD\|[\|\fIconstant-expression\fB\|]\fR
2110 then the contained identifier has type
2111 ``\|.\|.\|.\| array of
2113 In the first case, the constant
2116 whose value is determinable at compile time
2120 and whose value is positive.
2121 (Constant expressions are defined precisely in ``Constant Expressions.'')
2122 When several ``array of'' specifications are adjacent, a multidimensional
2124 the constant expressions which specify the bounds
2125 of the arrays may be missing only for the first member of the sequence.
2126 This elision is useful when the array is external
2127 and the actual definition, which allocates storage,
2129 The first constant expression may also be omitted
2130 when the declarator is followed by initialization.
2131 In this case the size is calculated from the number
2132 of initial elements supplied.
2134 An array may be constructed from one of the basic types, from a pointer,
2135 from a structure or union,
2136 or from another array (to generate a multidimensional array).
2138 Not all the possibilities
2139 allowed by the syntax above are actually
2141 The restrictions are as follows:
2142 functions may not return
2144 although they may return pointers;
2145 there are no arrays of functions although
2146 there may be arrays of pointers to functions.
2147 Likewise, a structure or union may not contain a function;
2148 but it may contain a pointer to a function.
2150 As an example, the declaration
2152 \fBint i, \(**ip, f(), \(**fip(), (\(**pfi)();\fR
2166 returning an integer,
2171 returning a pointer to an integer,
2178 It is especially useful to compare the last two.
2187 The declaration suggests,
2188 and the same construction in an expression
2189 requires, the calling of a function
2193 Using indirection through the (pointer) result
2194 to yield an integer.
2197 the extra parentheses are necessary, as they are also
2198 in an expression, to indicate that indirection through
2199 a pointer to a function yields a function, which is then called;
2200 it returns an integer.
2204 \fBfloat fa[17], \(**afp[17];\fR
2207 declares an array of
2211 numbers and an array of
2219 \fBstatic int x3d[3][5][7];\fR
2222 declares a static 3-dimensional array of integers,
2223 with rank 3\(mu5\(mu7.
2228 is an array of three items;
2229 each item is an array of five arrays;
2230 each of the latter arrays is an array of seven
2232 Any of the expressions
2239 may reasonably appear in an expression.
2240 The first three have type ``array''
2241 and the last has type
2246 Structure and Union Declarations
2249 is an object consisting of a sequence of named members.
2250 Each member may have any type.
2251 A union is an object which may, at a given time, contain any one
2253 Structure and union specifiers have the same form.
2255 \fIstruct-or-union-specifier:
2256 struct-or-union { struct-decl-list }
2257 struct-or-union identifier { struct-decl-list }
2258 struct-or-union identifier
2261 \fIstruct-or-union:\fB
2269 is a sequence of declarations for the members of the structure or union:
2271 \fIstruct-decl-list:
2273 struct-declaration struct-decl-list
2276 \fIstruct-declaration:
2277 type-specifier struct-declarator-list ;
2280 \fIstruct-declarator-list:
2282 struct-declarator , struct-declarator-list\fR
2285 In the usual case, a struct-declarator is just a declarator
2286 for a member of a structure or union.
2287 A structure member may also consist of a specified number of bits.
2288 Such a member is also called a
2293 a non-negative constant expression,
2294 is set off from the field name by a colon.
2296 \fIstruct-declarator:
2298 declarator : constant-expression
2299 : constant-expression\fR
2302 Within a structure, the objects declared
2303 have addresses which increase as the declarations
2304 are read left to right.
2305 Each nonfield member of a structure
2306 begins on an addressing boundary appropriate
2308 therefore, there may
2309 be unnamed holes in a structure.
2310 Field members are packed into machine integers;
2311 they do not straddle words.
2312 A field which does not fit into the space remaining in a word
2313 is put into the next word.
2314 No field may be wider than a word.
2316 Fields are assigned right to left
2321 left to right on the 3B 20.
2323 A struct-declarator with no declarator, only a colon and a width,
2324 indicates an unnamed field useful for padding to conform
2325 to externally-imposed layouts.
2326 As a special case, a field with a width of 0
2327 specifies alignment of the next field at an implementation dependent boundary.
2329 The language does not restrict the types of things that
2330 are declared as fields,
2331 but implementations are not required to support any but
2338 fields may be considered to be unsigned.
2341 fields are not signed and have only integer values;
2344 fields declared with
2348 are treated as containing a sign.
2350 it is strongly recommended that fields be declared as
2354 In all implementations,
2355 there are no arrays of fields,
2356 and the address-of operator
2360 may not be applied to them, so that there are no pointers to
2363 A union may be thought of as a structure all of whose members
2364 begin at offset 0 and whose size is sufficient to contain
2366 At most, one of the members can be stored in a union
2369 A structure or union specifier of the second form, that is, one of
2371 \fBstruct \fIidentifier { struct-decl-list \fR}
2372 \fBunion \fIidentifier { struct-decl-list \fR}
2375 declares the identifier to be the
2380 of the structure specified by the list.
2381 A subsequent declaration may then use
2382 the third form of specifier, one of
2384 \fBstruct \fIidentifier\fR
2385 \fBunion \fIidentifier\fR
2388 Structure tags allow definition of self-referential
2389 structures. Structure tags also
2390 permit the long part of the declaration to be
2391 given once and used several times.
2392 It is illegal to declare a structure or union
2393 which contains an instance of
2394 itself, but a structure or union may contain a pointer to an instance of itself.
2396 The third form of a structure or union specifier may be
2397 used prior to a declaration which gives the complete specification
2398 of the structure or union in situations in which the size
2399 of the structure or union is unnecessary.
2400 The size is unnecessary in two situations: when a
2401 pointer to a structure or union is being declared and
2402 when a \fBtypedef\fR name is declared to be a synonym
2403 for a structure or union.
2404 This, for example, allows the declaration of a pair
2405 of structures which contain pointers to each other.
2407 The names of members and tags do not conflict
2408 with each other or with ordinary variables.
2409 A particular name may not be used twice
2410 in the same structure,
2411 but the same name may be used in several different structures in the same scope.
2413 A simple but important example of a structure declaration is
2414 the following binary tree structure:
2420 struct tnode \(**left;
2421 struct tnode \(**right;
2425 which contains an array of 20 characters, an integer, and two pointers
2426 to similar structures.
2427 Once this declaration has been given, the
2430 \fBstruct tnode s, \(**sp;\fR
2437 to be a structure of the given sort
2442 to be a pointer to a structure
2444 With these declarations, the expression
2453 field of the structure to which
2462 refers to the left subtree pointer
2467 \fBs.right->tword[0]\fR
2470 refers to the first character of the
2474 member of the right subtree of
2480 Enumeration Declarations
2482 Enumeration variables and constants have integral type.
2484 \fIenum-specifier:\fB
2485 enum\fI { enum-list \fR}\fB
2486 enum \fIidentifier { enum-list \fR}\fB
2491 enum-list , enumerator
2495 identifier = constant-expression\fR
2498 The identifiers in an enum-list are declared as constants
2499 and may appear wherever constants are required.
2500 If no enumerators with
2504 appear, then the values of the
2505 corresponding constants begin at 0 and increase by 1 as the declaration is
2506 read from left to right.
2511 gives the associated identifier the value
2512 indicated; subsequent identifiers continue the progression from the assigned value.
2514 The names of enumerators in the same scope must all be distinct
2515 from each other and from those of ordinary variables.
2517 The role of the identifier in the enum-specifier
2518 is entirely analogous to that of the structure tag
2519 in a struct-specifier; it names a particular enumeration.
2522 \fBenum color { chartreuse, burgundy, claret=20, winedark };
2524 enum color *cp, col;
2529 if (*cp == burgundy) ...\fR
2536 the enumeration-tag of a type describing various colors,
2541 as a pointer to an object of that type,
2546 as an object of that type.
2547 The possible values are drawn from the set {0,1,20,21}.
2551 A declarator may specify an initial value for the
2552 identifier being declared.
2553 The initializer is preceded by
2558 consists of an expression or a list of values nested in braces.
2562 = { initializer-list }
2563 = { initializer-list , }
2566 \fIinitializer-list:
2568 initializer-list , initializer-list\fR
2569 { \fIinitializer-list \fR}
2570 { \fIinitializer-list\fR , }
2573 All the expressions in an initializer
2574 for a static or external variable must be constant
2575 expressions, which are described in ``CONSTANT EXPRESSIONS'',
2576 or expressions which reduce to the address of a previously
2577 declared variable, possibly offset by a constant expression.
2578 Automatic or register variables may be initialized by arbitrary
2579 expressions involving constants and previously declared variables and functions.
2581 Static and external variables that are not initialized are
2582 guaranteed to start off as zero.
2583 Automatic and register variables that are not initialized
2584 are guaranteed to start off as garbage.
2586 When an initializer applies to a
2590 (a pointer or an object of arithmetic type),
2591 it consists of a single expression, perhaps in braces.
2592 The initial value of the object is taken from
2593 the expression; the same conversions as for assignment are performed.
2595 When the declared variable is an
2599 (a structure or array),
2600 the initializer consists of a brace-enclosed, comma-separated list of
2601 initializers for the members of the aggregate
2602 written in increasing subscript or member order.
2603 If the aggregate contains subaggregates, this rule
2604 applies recursively to the members of the aggregate.
2605 If there are fewer initializers in the list than there are members of the aggregate,
2606 then the aggregate is padded with zeros.
2607 It is not permitted to initialize unions or automatic aggregates.
2609 Braces may in some cases be omitted.
2610 If the initializer begins with a left brace, then
2611 the succeeding comma-separated list of initializers initializes
2612 the members of the aggregate;
2613 it is erroneous for there to be more initializers than members.
2614 If, however, the initializer does not begin with a left brace,
2615 then only enough elements from the list are taken to account
2616 for the members of the aggregate; any remaining members
2617 are left to initialize the next member of the aggregate of which
2618 the current aggregate is a part.
2620 A final abbreviation allows a
2624 array to be initialized by a string.
2625 In this case successive characters of the string
2626 initialize the members of the array.
2630 \fBint x[] = { 1, 3, 5 };\fR
2633 declares and initializes
2637 as a one-dimensional array which has three members, since no size was specified
2638 and there are three initializers.
2648 is a completely-bracketed initialization:
2649 1, 3, and 5 initialize the first row of
2659 Likewise, the next two lines initialize
2667 The initializer ends early and therefore
2671 is initialized with 0.
2672 Precisely, the same effect could have been achieved by
2676 1, 3, 5, 2, 4, 6, 3, 5, 7
2684 begins with a left brace but that for
2689 therefore, three elements from the list are used.
2690 Likewise, the next three are taken successively for
2702 { 1 }, { 2 }, { 3 }, { 4 }
2706 initializes the first column of
2710 (regarded as a two-dimensional array)
2711 and leaves the rest 0.
2715 \fBchar msg[] = "Syntax error on line %s\en";\fR
2718 shows a character array whose members are initialized
2723 In two contexts (to specify type conversions explicitly
2725 and as an argument of
2727 it is desired to supply the name of a data type.
2728 This is accomplished using a ``type name'', which in essence
2729 is a declaration for an object of that type which omits the name of
2733 type-specifier abstract-declarator
2736 \fIabstract-declarator:
2738 ( abstract-declarator )
2739 \(** abstract-declarator
2740 abstract-declarator ()
2741 abstract-declarator\fR\^ [ \fIconstant-expression\v'0.5'\s-2opt\s0\v'-0.5' \fR\^]
2747 \fI( abstract-declarator \fR)
2752 is required to be nonempty.
2753 Under this restriction,
2754 it is possible to identify uniquely the location in the abstract-declarator
2755 where the identifier would appear if the construction were a declarator
2757 The named type is then the same as the type of the
2758 hypothetical identifier.
2770 name respectively the types ``integer,'' ``pointer to integer,''
2771 ``array of three pointers to integers,''
2772 ``pointer to an array of three integers,''
2773 ``function returning pointer to integer,''
2774 ``pointer to function returning an integer,''
2775 and ``array of three pointers to functions returning an integer.''
2779 Declarations whose ``storage class'' is
2783 do not define storage but instead
2784 define identifiers which can be used later
2785 as if they were type keywords naming fundamental
2792 Within the scope of a declaration involving
2794 each identifier appearing as part of
2795 any declarator therein becomes syntactically
2796 equivalent to the type keyword
2798 associated with the identifier
2799 in the way described in ``Meaning of Declarators.''
2803 \fBtypedef int MILES, \(**KLICKSP;
2804 typedef struct { double re, im; } complex;\fR
2810 extern KLICKSP metricp;
2811 complex z, \(**zp;\fR
2814 are all legal declarations; the type of
2824 is ``pointer to \fBint\fR, ''
2829 is the specified structure.
2834 is a pointer to such a structure.
2840 does not introduce brand-new types, only synonyms for
2841 types which could be specified in another way.
2843 in the example above
2847 is considered to have exactly the same type as
2856 Except as indicated, statements are executed in sequence.
2858 Expression Statement
2860 Most statements are expression statements, which have
2866 Usually expression statements are assignments or function
2869 Compound Statement or Block
2871 So that several statements can be used where one is expected,
2872 the compound statement (also, and equivalently, called ``block'') is provided:
2874 \fIcompound-statement:
2875 { declaration-list\v'0.5'\s-2opt\s0\v'-0.5' statement-list\v'0.5'\s-2opt\s0\v'-0.5' }
2878 \fIdeclaration-list:
2880 declaration declaration-list
2885 statement statement-list\fR
2888 If any of the identifiers
2889 in the declaration-list were previously declared,
2890 the outer declaration is pushed down for the duration of the block,
2891 after which it resumes its force.
2893 Any initializations of
2901 variables are performed each time the block is entered at the top.
2902 It is currently possible
2903 (but a bad practice)
2904 to transfer into a block;
2905 in that case the initializations are not performed.
2910 variables are performed only once when the program
2916 declarations do not reserve storage
2917 so initialization is not permitted.
2919 Conditional Statement
2921 The two forms of the conditional statement are
2923 \fBif\fR\^ ( \fIexpression\fR\^ ) \fIstatement\fR\^
2924 \fBif\fR\^ ( \fIexpression\fR\^ ) \fIstatement \fBelse \fIstatement\fR\^
2927 In both cases, the expression is evaluated;
2928 and if it is nonzero, the first substatement
2930 In the second case, the second substatement is executed
2931 if the expression is 0.
2932 The ``else'' ambiguity is resolved by connecting
2937 with the last encountered
2949 statement has the form
2951 \fBwhile\fR\^ ( \fIexpression\fR\^ ) \fIstatement\fR\^
2954 The substatement is executed repeatedly
2955 so long as the value of the
2956 expression remains nonzero.
2957 The test takes place before each execution of the
2966 statement has the form
2968 \fBdo \fIstatement \fBwhile\fR\^ ( \fIexpression \fR\^) ;
2971 The substatement is executed repeatedly until
2972 the value of the expression becomes 0.
2973 The test takes place after each execution of the
2982 statement has the form:
2984 \fBfor\fI ( exp-1\v'0.5'\s-2opt\s0\v'-0.5' ; exp-2\v'0.5'\s-2opt\s0\v'-0.5' ; exp-3\v'0.5'\s-2opt\s0\v'-0.5' ) statement\fR
2988 Except for the behavior of \fBcontinue\fR,
2989 this statement is equivalent to
2992 \fBwhile\fR\^ ( \fIexp-2\ ) \fR\^
2999 Thus the first expression specifies initialization
3000 for the loop; the second specifies
3001 a test, made before each iteration, such
3002 that the loop is exited when the expression becomes
3004 The third expression often specifies an incrementing
3005 that is performed after each iteration.
3007 Any or all of the expressions may be dropped.
3017 clause equivalent to
3019 other missing expressions are simply
3020 dropped from the expansion above.
3028 statement causes control to be transferred
3029 to one of several statements depending on
3030 the value of an expression.
3033 \fBswitch\fR\^ ( \fIexpression\fR\^ ) \fIstatement\fR\^
3036 The usual arithmetic conversion is performed on the
3037 expression, but the result must be
3041 The statement is typically compound.
3042 Any statement within the statement
3043 may be labeled with one or more case prefixes
3046 \fBcase \fIconstant-expression \fR:
3055 No two of the case constants in the same switch
3056 may have the same value.
3057 Constant expressions are precisely defined in ``CONSTANT EXPRESSIONS.''
3059 There may also be at most one statement prefix of the
3069 statement is executed, its expression
3070 is evaluated and compared with each case constant.
3071 If one of the case constants is
3072 equal to the value of the expression,
3073 control is passed to the statement
3074 following the matched case prefix.
3075 If no case constant matches the expression
3079 passes to the prefixed
3081 If no case matches and if there is no
3084 none of the statements in the
3095 do not alter the flow of control,
3096 which continues unimpeded across such prefixes.
3097 To exit from a switch, see
3098 ``Break Statement.''
3100 Usually, the statement that is the subject of a switch is compound.
3101 Declarations may appear at the head of this
3104 initializations of automatic or register variables
3114 causes termination of the smallest enclosing
3121 control passes to the
3122 statement following the terminated statement.
3131 causes control to pass to the loop-continuation portion of the
3137 statement; that is to the end of the loop.
3138 More precisely, in each of the statements
3141 lw(2i) lw(2i) lw(2i).
3142 \fBwhile (\|.\|.\|.\|) { do { for (\|.\|.\|.\|) {\fR
3143 \fIstatement ; statement ; statement ;\fR
3144 \fBcontin: ; contin: ; contin: ;
3145 } } while (...); }\fR
3161 is a null statement, see ``Null Statement''.)
3165 A function returns to its caller by means of
3170 statement which has one of the
3174 return \fIexpression \fR;
3177 In the first case, the returned value is undefined.
3178 In the second case, the value of the expression
3179 is returned to the caller
3181 If required, the expression is converted,
3182 as if by assignment, to the type of
3183 function in which it appears.
3184 Flowing off the end of a function is
3185 equivalent to a return with no returned value.
3186 The expression may be parenthesized.
3190 Control may be transferred unconditionally by means of
3193 \fBgoto \fIidentifier \fR;
3196 The identifier must be a label
3197 (see ``Labeled Statement'')
3198 located in the current function.
3202 Any statement may be preceded by
3203 label prefixes of the form
3208 which serve to declare the identifier
3210 The only use of a label is as a target of a
3214 The scope of a label is the current function,
3215 excluding any subblocks in which the same identifier has been redeclared.
3216 See ``SCOPE RULES.''
3220 The null statement has the form
3225 A null statement is useful to carry a label just before the
3229 of a compound statement or to supply a null
3230 body to a looping statement such as
3235 External Definitions
3237 A C program consists of a sequence of external definitions.
3238 An external definition declares an identifier to
3248 The type-specifier (see ``Type Specifiers'' in
3249 ``DECLARATIONS'') may also be empty, in which
3250 case the type is taken to be
3254 The scope of external definitions persists to the end
3255 of the file in which they are declared just as the effect
3256 of declarations persists to the end of a block.
3257 The syntax of external definitions is the same
3258 as that of all declarations except that
3259 only at this level may the code for functions be given.
3261 External Function Definitions
3263 Function definitions have the form
3265 \fIfunction-definition:
3266 decl-specifiers\v'0.5'\s-2opt\s0\v'-0.5' function-declarator function-body\fR
3269 The only sc-specifiers
3271 among the decl-specifiers
3278 see ``Scope of Externals'' in
3279 ``SCOPE RULES'' for the distinction between them.
3280 A function declarator is similar to a declarator
3281 for a ``function returning .\|.\|.\|'' except that
3282 it lists the formal parameters of
3283 the function being defined.
3285 \fIfunction-declarator:
3286 declarator ( parameter-list\v'0.5'\s-2opt\s0\v'-0.5' )
3291 identifier , parameter-list\fR
3298 declaration-list\v'0.5'\s-2opt\s0\v'-0.5' compound-statement\fR
3301 The identifiers in the parameter list, and only those identifiers,
3302 may be declared in the declaration list.
3303 Any identifiers whose type is not given are taken to be
3307 The only storage class which may be specified is
3309 if it is specified, the corresponding actual parameter
3310 will be copied, if possible, into a register
3311 at the outset of the function.
3313 A simple example of a complete function definition is
3320 m = (a > b) ? a : b;
3321 return((m > c) ? m : c);
3329 is the type-specifier;
3333 is the function-declarator;
3337 is the declaration-list for
3342 block giving the code for the statement.
3344 The C program converts all
3351 so formal parameters declared
3355 have their declaration adjusted to read
3359 All \fBchar\fR and \fBshort\fR formal parameter
3360 declarations are similarly adjusted
3362 Also, since a reference to an array in any context
3363 (in particular as an actual parameter)
3365 a pointer to the first element of the array,
3366 declarations of formal parameters declared ``array of .\|.\|.\|''
3367 are adjusted to read ``pointer to .\|.\|.\|.''
3369 External Data Definitions
3371 An external data definition has the form
3377 The storage class of such data may be
3381 (which is the default)
3395 A C program need not all
3396 be compiled at the same time. The source text of the
3398 may be kept in several files, and precompiled
3399 routines may be loaded from
3401 Communication among the functions of a program
3402 may be carried out both through explicit calls
3403 and through manipulation of external data.
3405 Therefore, there are two kinds of scopes to consider:
3406 first, what may be called the
3409 of an identifier, which is essentially the
3410 region of a program during which it may
3411 be used without drawing ``undefined identifier''
3413 and second, the scope
3414 associated with external identifiers,
3415 which is characterized by the rule
3416 that references to the same external
3417 identifier are references to the same object.
3421 The lexical scope of identifiers declared in external definitions
3422 persists from the definition through
3423 the end of the source file
3424 in which they appear.
3425 The lexical scope of identifiers which are formal parameters
3426 persists through the function with which they are
3428 The lexical scope of identifiers declared at the head of a block
3429 persists until the end of the block.
3430 The lexical scope of labels is the whole of the
3431 function in which they appear.
3433 In all cases, however,
3434 if an identifier is explicitly declared at the head of a block,
3435 including the block constituting a function,
3436 any declaration of that identifier outside the block
3437 is suspended until the end of the block.
3439 Remember also (see ``Structure, Union, and Enumeration Declarations'' in
3440 ``DECLARATIONS'') that tags, identifiers associated with
3442 and identities associated with structure and union members
3443 form three disjoint classes
3444 which do not conflict.
3445 Members and tags follow the same scope rules
3446 as other identifiers.
3447 The \fBenum\fR constants are in the same
3448 class as ordinary variables and follow the same scope rules.
3453 names are in the same class as ordinary identifiers.
3454 They may be redeclared in inner blocks, but an explicit
3455 type must be given in the inner declaration:
3457 \fBtypedef float distance;
3469 must be present in the second declaration,
3470 or it would be taken to be
3471 a declaration with no declarators and type
3478 If a function refers to an identifier declared to be
3480 then somewhere among the files or libraries
3481 constituting the complete program
3482 there must be at least one external definition
3484 All functions in a given program which refer to the same
3485 external identifier refer to the same object,
3486 so care must be taken that the type and size
3487 specified in the definition
3488 are compatible with those specified
3489 by each function which references the data.
3491 It is illegal to explicitly initialize any external
3492 identifier more than once in the set of files and libraries
3493 comprising a multi-file program.
3494 It is legal to have more than one data definition
3495 for any external non-function identifier;
3496 explicit use of \fBextern\fR does not
3497 change the meaning of an external declaration.
3499 In restricted environments, the use of the \fBextern\fR
3500 storage class takes on an additional meaning.
3501 In these environments, the explicit appearance of the
3502 \fBextern\fR keyword in external data declarations of
3503 identities without initialization indicates that
3504 the storage for the identifiers is allocated elsewhere,
3505 either in this file or another file.
3506 It is required that there be exactly one definition of
3507 each external identifier (without \fBextern\fR)
3508 in the set of files and libraries
3509 comprising a mult-file program.
3511 Identifiers declared
3515 at the top level in external definitions
3516 are not visible in other files.
3517 Functions may be declared
3523 Compiler Control Lines
3525 The C compiler contains a preprocessor capable
3526 of macro substitution, conditional compilation,
3527 and inclusion of named files.
3528 Lines beginning with
3533 with this preprocessor.
3534 There may be any number of blanks and horizontal tabs
3535 between the \fB#\fR and the directive.
3536 These lines have syntax independent of the rest of the language;
3537 they may appear anywhere and have effect which lasts (independent of
3538 scope) until the end of the source program file.
3543 A compiler-control line of the form
3545 \fB#define \fIidentifier token-string\v'0.5'\s-2opt\s0\v'-0.5'\fR
3548 causes the preprocessor to replace subsequent instances
3549 of the identifier with the given string of tokens.
3550 Semicolons in or at the end of the token-string are part of that string.
3553 \fB#define \fIidentifier(identifier, ... )token-string\v'0.5'\s-2opt\s0\v'-0.5'\fR
3556 where there is no space between the first identifier
3559 is a macro definition with arguments.
3560 There may be zero or more formal parameters.
3561 Subsequent instances of the first identifier followed
3564 a sequence of tokens delimited by commas, and a
3567 by the token string in the definition.
3568 Each occurrence of an identifier mentioned in the formal parameter list
3569 of the definition is replaced by the corresponding token string from the call.
3570 The actual arguments in the call are token strings separated by commas;
3571 however, commas in quoted strings or protected by
3572 parentheses do not separate arguments.
3573 The number of formal and actual parameters must be the same.
3574 Strings and character constants in the token-string are scanned
3575 for formal parameters, but
3576 strings and character constants in the rest of the program are
3577 not scanned for defined identifiers
3580 In both forms the replacement string is rescanned for more
3581 defined identifiers.
3583 a long definition may be continued on another line
3588 at the end of the line to be continued.
3590 This facility is most valuable for definition of ``manifest constants,''
3593 \fB#define TABSIZE 100
3595 int table\|[\|TABSIZE\|]\|;\fR
3598 A control line of the form
3600 \fB#undef \fIidentifier\fR
3604 identifier's preprocessor definition (if any) to be forgotten.
3606 If a \fB#define\fRd identifier is the subject of a subsequent
3607 \fB#define\fR with no intervening \fB#undef\fR, then
3608 the two token-strings are compared textually.
3609 If the two token-strings are not identical
3610 (all white space is considered as equivalent), then
3611 the identifier is considered to be redefined.
3616 A compiler control line of
3619 \fB#include\fI "filename\|\fR"
3622 causes the replacement of that
3623 line by the entire contents of the file
3627 The named file is searched for first in the directory
3628 of the file containing the \fB#include\fR,
3629 and then in a sequence of specified or standard places.
3630 Alternatively, a control line of the form
3632 \fB#include\fI <filename\|\fR>
3635 searches only the specified or standard places
3636 and not the directory of the \fB#include\fR.
3637 (How the places are specified is not part of the language.)
3643 Conditional Compilation
3645 A compiler control line of the form
3647 \fB#if \fIrestricted-constant-expression\fR
3650 checks whether the restricted-constant expression evaluates to nonzero.
3651 (Constant expressions are discussed in ``CONSTANT EXPRESSIONS'';
3652 the following additional restrictions apply here:
3653 the constant expression may not contain
3657 casts, or an enumeration constant.)
3659 A restricted constant expression may also contain the
3660 additional unary expression
3662 \fBdefined \fIidentifier\fR
3666 \fBdefined( \fIidentifier )\fR
3668 which evaluates to one if the identifier is currently
3669 defined in the preprocessor and zero if it is not.
3671 All currently defined identifiers in restricted-constant-expressions
3672 are replaced by their token-strings (except those identifiers
3673 modified by \fBdefined\fR) just as in normal text.
3674 The restricted constant expression will be evaluated only
3675 after all expressions have finished.
3676 During this evaluation, all undefined (to the procedure)
3677 identifiers evaluate to zero.
3679 A control line of the form
3681 \fB#ifdef \fIidentifier\fR
3684 checks whether the identifier is currently defined
3685 in the preprocessor; i.e., whether it has been the
3691 It is equivalent to \fB#ifdef(\fIidentifier\fB)\fR.
3692 A control line of the form
3694 \fB#ifndef \fIidentifier\fR
3697 checks whether the identifier is currently undefined
3698 in the preprocessor.
3701 \fB#if !\|defined(\fIidentifier\fB)\fR.
3704 All three forms are followed by an arbitrary number of lines,
3705 possibly containing a control line
3710 and then by a control line
3715 If the checked condition is true,
3726 If the checked condition is false, then any lines between
3739 These constructions may be nested.
3744 For the benefit of other preprocessors which generate C programs,
3747 \fB#line \fIconstant "filename\fR"
3750 causes the compiler to believe, for purposes of error
3752 that the line number of the next source line is given by the constant and the current input
3753 file is named by "\fIfilename\fR".
3754 If "\fIfilename\fR" is absent, the remembered file name does not change.
3757 Implicit Declarations
3759 It is not always necessary to specify
3760 both the storage class and the type
3761 of identifiers in a declaration.
3762 The storage class is supplied by
3763 the context in external definitions
3764 and in declarations of formal parameters
3765 and structure members.
3766 In a declaration inside a function,
3767 if a storage class but no type
3768 is given, the identifier is assumed
3771 if a type but no storage class is indicated,
3772 the identifier is assumed to
3777 An exception to the latter rule is made for
3782 functions do not exist.
3783 If the type of an identifier is ``function returning .\|.\|.\|,''
3784 it is implicitly declared to be
3789 In an expression, an identifier
3794 and not already declared
3796 declared to be ``function returning
3803 This part summarizes the operations
3804 which can be performed on objects of certain types.
3807 Structures and Unions
3809 Structures and unions may be assigned, passed as arguments to functions,
3810 and returned by functions.
3811 Other plausible operators, such as equality comparison
3812 and structure casts,
3813 are not implemented.
3816 to a structure or union member, the
3818 of the \fB->\fR or the \fB.\fR
3819 must specify a member of the aggregate
3820 named or pointed to by the expression
3822 In general, a member of a union may not be inspected
3823 unless the value of the union has been assigned using that same member.
3824 However, one special guarantee is made by the language in order
3825 to simplify the use of unions:
3826 if a union contains several structures that share a common initial sequence
3827 and if the union currently contains one of these structures,
3828 it is permitted to inspect the common initial part of any of
3829 the contained structures.
3830 For example, the following is a legal fragment:
3851 u.nf.floatnode = 3.14;
3853 if (u.n.type == FLOAT)
3854 ... sin(u.nf.floatnode) ...\fR
3861 There are only two things that
3862 can be done with a function \fBm\fR,
3863 call it or take its address.
3864 If the name of a function appears in an
3865 expression not in the function-name position of a call,
3866 a pointer to the function is generated.
3867 Thus, to pass one function to another, one
3876 Then the definition of
3896 explicitly in the calling routine since its appearance
3907 Arrays, Pointers, and Subscripting
3909 Every time an identifier of array type appears
3910 in an expression, it is converted into a pointer
3911 to the first member of the array.
3912 Because of this conversion, arrays are not
3914 By definition, the subscript operator
3925 \(**((E1)\(plE2))\fR.
3927 Because of the conversion rules
3952 despite its asymmetric
3953 appearance, subscripting is a commutative operation.
3955 A consistent rule is followed in the case of
3956 multidimensional arrays.
3970 appearing in an expression is converted to
3971 a pointer to an (n-1)-dimensional
3978 operator, either explicitly
3979 or implicitly as a result of subscripting,
3980 is applied to this pointer,
3981 the result is the pointed-to (n-1)-dimensional array,
3982 which itself is immediately converted into a pointer.
3984 For example, consider
3993 is a 3\(mu5 array of integers.
3998 appears in an expression, it is converted
3999 to a pointer to (the first of three) 5-membered arrays of integers.
4002 which is equivalent to
4007 is first converted to a pointer as described;
4012 is converted to the type of
4014 which involves multiplying
4019 length the object to which the pointer points,
4020 namely 5-integer objects.
4021 The results are added and indirection applied to
4022 yield an array (of five integers) which in turn is converted to
4023 a pointer to the first of the integers.
4024 If there is another subscript, the same argument applies
4025 again; this time the result is an integer.
4027 Arrays in C are stored
4028 row-wise (last subscript varies fastest)
4029 and the first subscript in the declaration helps determine
4030 the amount of storage consumed by an array.
4031 Arrays play no other part in subscript calculations.
4034 Explicit Pointer Conversions
4036 Certain conversions involving pointers are permitted
4037 but have implementation-dependent aspects.
4038 They are all specified by means of an explicit type-conversion
4039 operator, see ``Unary Operators'' under``EXPRESSIONS'' and
4040 ``Type Names''under ``DECLARATIONS.''
4042 A pointer may be converted to any of the integral types large
4052 is required is machine dependent.
4053 The mapping function is also machine dependent but is intended
4054 to be unsurprising to those who know the addressing structure
4056 Details for some particular machines are given below.
4058 An object of integral type may be explicitly converted to a pointer.
4059 The mapping always carries an integer converted from a pointer back to the same pointer
4060 but is otherwise machine dependent.
4062 A pointer to one type may be converted to a pointer to another type.
4063 The resulting pointer may cause addressing exceptions
4065 the subject pointer does not refer to an object suitably aligned in storage.
4066 It is guaranteed that
4067 a pointer to an object of a given size may be converted to a pointer to an object
4069 and back again without change.
4072 a storage-allocation routine
4073 might accept a size (in bytes)
4074 of an object to allocate, and return a
4079 it might be used in this way.
4081 \fBextern char \(**malloc();
4084 dp = (double \(**) malloc(sizeof(double));
4085 \(**dp = 22.0 / 7.0;\fR
4092 must ensure (in a machine-dependent way)
4093 that its return value is suitable for conversion to a pointer to
4099 of the function is portable.
4102 representation on the
4104 corresponds to a 16-bit integer and
4109 have no alignment requirements; everything else must have an even address.
4113 pointers are 32 bits long and measure bytes.
4114 Elementary objects are aligned on a boundary equal to their
4119 quantities need be aligned only on even 4-byte boundaries.
4120 Aggregates are aligned on the strictest boundary required by
4121 any of their constituents.
4123 The 3B 20 computer has 24-bit pointers placed into 32-bit quantities.
4125 aligned on 4-byte boundaries. \fBShort\fRs are aligned in all cases on
4126 2-byte boundaries. Arrays of characters, all structures,
4127 \fBint\fR\^s, \fBlong\fR\^s, \fBfloat\fR\^s, and \fBdouble\fR\^s are aligned on 4-byte
4128 boundaries; but structure members may be packed tighter.
4131 CONSTANT EXPRESSIONS
4133 In several places C requires expressions that evaluate to
4137 as array bounds, and in initializers.
4138 In the first two cases, the expression can
4139 involve only integer constants, character constants,
4140 casts to integral types,
4141 enumeration constants,
4146 expressions, possibly
4147 connected by the binary operators
4150 \(pl \(mi \(** / % & | ^ << >> == != < > <= >= && ||
4153 or by the unary operators
4158 or by the ternary operator
4163 Parentheses can be used for grouping
4164 but not for function calls.
4166 More latitude is permitted for initializers;
4167 besides constant expressions as discussed above,
4168 one can also use floating constants
4169 and arbitrary casts and
4170 can also apply the unary
4174 operator to external or static objects
4175 and to external or static arrays subscripted
4176 with a constant expression.
4182 be applied implicitly
4183 by appearance of unsubscripted arrays and functions.
4184 The basic rule is that initializers must
4185 evaluate either to a constant or to the address
4186 of a previously declared external or static object plus or minus a constant.
4189 Portability Considerations
4191 Certain parts of C are inherently machine dependent.
4192 The following list of potential trouble spots
4193 is not meant to be all-inclusive
4194 but to point out the main ones.
4196 Purely hardware issues like
4197 word size and the properties of floating point arithmetic and integer division
4198 have proven in practice to be not much of a problem.
4199 Other facets of the hardware are reflected
4200 in differing implementations.
4202 particularly sign extension
4203 (converting a negative character into a negative integer)
4204 and the order in which bytes are placed in a word,
4205 are nuisances that must be carefully watched.
4206 Most of the others are only minor problems.
4212 variables that can actually be placed in registers
4213 varies from machine to machine
4214 as does the set of valid types.
4215 Nonetheless, the compilers all do things properly for their own machine;
4220 declarations are ignored.
4222 Some difficulties arise only when
4223 dubious coding practices are used.
4224 It is exceedingly unwise to write programs
4226 on any of these properties.
4228 The order of evaluation of function arguments
4229 is not specified by the language.
4230 The order in which side effects take place
4231 is also unspecified.
4233 Since character constants are really objects of type
4235 multicharacter character constants may be permitted.
4236 The specific implementation
4237 is very machine dependent
4238 because the order in which characters
4239 are assigned to a word
4240 varies from one machine to another.
4242 Fields are assigned to words and characters to integers right to left
4244 and left to right on other machines.
4245 These differences are invisible to isolated programs
4246 that do not indulge in type punning (e.g.,
4255 pointer and inspecting the pointed-to storage)
4256 but must be accounted for when conforming to externally-imposed
4262 This summary of C syntax is intended more for aiding comprehension
4263 than as an exact statement of the language.
4269 The basic expressions are:
4283 \fBsizeof\fI expression
4284 \fBsizeof (\fItype-name\fB)\fI
4285 ( type-name ) expression
4286 expression binop expression
4287 expression ? expression : expression
4288 lvalue asgnop expression
4289 expression , expression
4297 primary ( expression-list\v'0.5'\s-2opt\s0\v'-0.5' )
4298 primary [ expression ]
4299 primary . identifier
4300 primary \(mi identifier
4305 primary [ expression ]
4307 primary \(mi identifier
4313 The primary-expression operators
4319 have highest priority and group left to right.
4322 \(** & \(mi ! \s+2~\s0 \(pl\(pl \(mi\(mi \fBsizeof\fI ( type-name \fR)
4325 have priority below the primary operators
4326 but higher than any binary operator
4327 and group right to left.
4329 group left to right; they have priority
4345 The conditional operator groups right to left.
4347 Assignment operators all have the same
4348 priority and all group right to left.
4351 = \(pl= \(mi= \(**= /= %= >>= <<= &= ^= |=
4354 The comma operator has the lowest priority and groups left to right.
4361 decl-specifiers init-declarator-list\v'0.5'\s-2opt\s0\v'-0.5' ;
4365 type-specifier decl-specifiers\v'0.5'\s-2opt\s0\v'-0.5'
4366 sc-specifier decl-specifiers\v'0.5'\s-2opt\s0\v'-0.5'
4378 struct-or-union-specifier
4381 basic-type-specifier:
4383 basic-type basic-type-specifiers
4395 \fIenum-specifier:\fB
4396 enum\fI { enum-list }\fB
4397 enum \fIidentifier { enum-list }\fB
4403 enum-list , enumerator
4408 identifier = constant-expression
4411 \fIinit-declarator-list:
4413 init-declarator , init-declarator-list
4417 declarator initializer\v'0.5'\s-2opt\s0\v'-0.5'
4425 declarator [ constant-expression\v'0.5'\s-2opt\s0\v'-0.5' ]
4428 \fIstruct-or-union-specifier:\fB
4429 struct\fI { struct-decl-list }\fB
4430 struct \fIidentifier { struct-decl-list }\fB
4431 struct \fIidentifier\fB
4432 union { \fIstruct-decl-list }\fB
4433 union \fIidentifier { struct-decl-list }\fB
4437 \fIstruct-decl-list:
4439 struct-declaration struct-decl-list
4442 \fIstruct-declaration:
4443 type-specifier struct-declarator-list ;
4446 \fIstruct-declarator-list:
4448 struct-declarator , struct-declarator-list
4451 \fIstruct-declarator:
4453 declarator : constant-expression
4454 : constant-expression
4459 = { initializer-list }
4460 = { initializer-list , }
4463 \fIinitializer-list:
4465 initializer-list , initializer-list
4466 { initializer-list }
4467 { initializer-list , }
4471 type-specifier abstract-declarator
4474 \fIabstract-declarator:
4476 ( abstract-declarator )
4477 \(** abstract-declarator
4478 abstract-declarator ()
4479 abstract-declarator [ constant-expression\v'0.5'\s-2opt\s0\v'-0.5' ]
4490 \fIcompound-statement:
4491 { declaration-list\v'0.5'\s-2opt\s0\v'-0.5' statement-list\v'0.5'\s-2opt\s0\v'-0.5' }
4494 \fIdeclaration-list:
4496 declaration declaration-list
4501 statement statement-list
4507 \fBif\fI ( expression ) statement
4508 \fBif\fI ( expression ) statement \fBelse\fI statement
4509 \fBwhile\fI ( expression ) statement
4510 \fBdo\fI statement \fBwhile\fI ( expression ) ;
4511 \fBfor\fI (exp\v'0.3'\s-2opt\s0\v'-0.3'\fB;\fIexp\v'0.3'\s-2opt\s0\v'-0.3'\fB;\fIexp\v'0.3'\s-2opt\s0\v'-0.3'\fI) statement
4512 \fBswitch\fI ( expression ) statement
4513 \fBcase\fI constant-expression : statement
4514 \fBdefault\fI : statement
4518 return\fI expression ;
4519 \fBgoto\fI identifier ;
4520 identifier : statement
4525 External definitions
4530 external-definition program
4533 \fIexternal-definition:
4538 \fIfunction-definition:
4539 decl-specifier\v'0.5'\s-2opt\s0\v'-0.5' function-declarator function-body
4542 \fIfunction-declarator:
4543 declarator ( parameter-list\v'0.5'\s-2opt\s0\v'-0.5' )
4548 identifier , parameter-list
4552 declaration-list\v'0.5'\s-2opt\s0\v'-0.5' compound-statement
4556 \fBextern\fI declaration\fB ;
4557 \fBstatic\fI declaration\fB ;
4562 \fB#define\fI identifier token-string\v'0.3'\s-2opt\s0\v'-0.3'\fB
4563 \fB#define\fI identifier\fB(\fIidentifier\fB,...)\fItoken-string\v'0.5'\s-2opt\s0\v'-0.5'\fB
4564 \fB#undef\fI identifier\fB
4565 \fB#include "\fIfilename\|\fB"
4566 #include <\fIfilename\|\fB>
4567 \fB#if\fI restricted-constant-expression\fB
4568 \fB#ifdef\fI identifier\fB
4569 \fB#ifndef\fI identifier\fB
4572 \fB#line\fI constant \fB"\fIfilename\|\fB"
projects / FreeBSD / releng / 10.0.git / blob