![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Clang.ms CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / share / doc / ps1 / 01.Clang|
Return to Clang.ms CVS log | Up to [CSRG BSD Unix] / 43BSDReno / share / doc / ps1 / 01.Clang |
1.1 root 1: .\" @(#)Clang.ms 6.2 (Berkeley) 5/27/86
2: .\"
3: .nr Cl 2
4: .TL
5: The C Programming Language - Reference Manual
6: .AU
7: Dennis M. Ritchie
8: .AI
9: .MH
10: .PP
11: This manual is a reprint, with updates to the current C standard, from
12: \fIThe C Programming Language\fR,
13: by Brian W. Kernighan and Dennis M. Richie, Prentice-Hall, Inc., 1978.
14: .EH 'PS1:1-%''The C Programming Language - Reference Manual'
15: .OH 'The C Programming Language - Reference Manual''PS1:1-%'
16: .NH 1
17: Introduction
18: .PP
19: This manual describes the C language on the DEC PDP-11\(dg, the DEC VAX-11,
20: .FS
21: .LP
22: \(dg DEC PDP-11, and DEC VAX-11 are trademarks of Digital Equipment Corporation.
23: .LP
24: \(dd 3B 20 is a trademark of AT&T.
25: .FE
26: and the AT&T 3B 20\(dd.
27: Where differences exist, it concentrates on the VAX, but tries to point
28: out implementation-dependent details. With few execptions, these dependencies
29: follow directly from the underlying properties of the hardware; the various
30: compilers are generally quite compatible.
31: .NH 1
32: Lexical Conventions
33: .PP
34: There are six classes of tokens\ -\
35: identifiers, keywords, constants, strings, operators, and other separators.
36: Blanks, tabs, new\(hylines,
37: and comments (collectively, ``white space'') as described below
38: are ignored except as they serve to separate
39: tokens.
40: Some white space is required to separate
41: otherwise adjacent identifiers,
42: keywords, and constants.
43: .PP
44: If the input stream has been parsed into tokens
45: up to a given character, the next token is taken
46: to include the longest string of characters
47: which could possibly constitute a token.
48: .NH 2
49: Comments
50: .PP
51: The characters
52: .B
53: /*
54: .R
55: introduce a comment which terminates
56: with the characters
57: \fB\(**/\fR.
58: Comments do not nest.
59: .NH 2
60: Identifiers (Names)
61: .PP
62: An identifier is a sequence of letters and digits.
63: The first character must be a letter.
64: The underscore
65: (\fB_\fR)
66: counts as a letter.
67: Uppercase and lowercase letters
68: are different.
69: Although there is no limit on the length of a name,
70: only initial characters are significant: at least
71: eight characters of a non-external name, and perhaps
72: fewer for external names.
73: Moreover, some implementations may collapse case
74: distinctions for external names.
75: The external name sizes include:
76: .DS
77: .TS
78: l l.
79: PDP-11 7 characters, 2 cases
80: VAX-11 >100 characters, 2 cases
81: AT&T 3B 20 >100 characters, 2 cases
82: .TE
83: .fi
84: .DE
85: .NH 2
86: Keywords
87: .PP
88: The following identifiers are reserved for use
89: as keywords and may not be used otherwise:
90: .DS
91: .ta 0.8i 1.6i 2.4i 3.2i 4.0i
92: \fBauto do for return typedef
93: break double goto short union
94: case else if sizeof unsigned
95: char enum int static void
96: continue external long struct while
97: default float register switch\fR
98: .ta 0.5i
99: .DE
100: .PP
101: Some implementations also reserve the words
102: .B
103: fortran, asm, gfloat, hfloat
104: .R
105: and
106: .B quad
107: .R
108: .NH 2
109: Constants
110: .PP
111: There are several kinds
112: of constants.
113: Each has a type; an introduction to types is given in ``NAMES.''
114: Hardware characteristics that affect sizes are summarized in
115: ``Hardware Characteristics'' under ``LEXICAL CONVENTIONS.''
116: .NH 3
117: Integer Constants
118: .br
119: .PP
120: An integer constant consisting of a sequence of digits
121: is taken
122: to be octal if it begins with
123: .B
124: 0
125: .R
126: (digit zero).
127: An octal constant consists of the digits \fB0\fR through \fB7\fR only.
128: A sequence of digits preceded by
129: .B
130: 0x
131: .R
132: or
133: .B
134: 0X
135: .R
136: (digit zero) is taken to be a hexadecimal integer.
137: The hexadecimal digits include
138: .B
139: a
140: .R
141: or
142: .B
143: A
144: .R
145: through
146: .B
147: f
148: .R
149: or
150: .B
151: F
152: .R
153: with values 10 through 15.
154: Otherwise, the integer constant is taken to be decimal.
155: A decimal constant whose value exceeds the largest
156: signed machine integer is taken to be
157: \fBlong\fR;
158: an octal or hex constant which exceeds the largest unsigned machine integer
159: is likewise taken to be
160: .B
161: long\fR.
162: .R
163: Otherwise, integer constants are \fBint\fR.
164: .NH 3
165: Explicit Long Constants
166: .br
167: .PP
168: A decimal, octal, or hexadecimal integer constant immediately followed
169: by
170: .B
171: l
172: .R
173: (letter ell)
174: or
175: .B
176: L
177: .R
178: is a long constant.
179: As discussed below,
180: on some machines
181: integer and long values may be considered identical.
182: .NH 3
183: Character Constants
184: .br
185: .PP
186: A character constant is a character enclosed in single quotes,
187: as in '\fBx\fR'.
188: The value of a character constant is the numerical value of the
189: character in the machine's character set.
190: .PP
191: Certain nongraphic characters,
192: the single quote
193: (\fB'\fR)
194: and the backslash
195: (\fB\e\fR),
196: may be represented according to the following table
197: of escape sequences:
198: .DS
199: .TS
200: l l l.
201: new\(hyline NL (LF) \en
202: horizontal tab HT \et
203: vertical tab VT \ev
204: backspace BS \eb
205: carriage return CR \er
206: form feed FF \ef
207: backslash \e \e\e
208: single quote ' \e'
209: bit pattern \fIddd\fR\^ \e\fIddd\fR\^
210: .TE
211: .DE
212: .PP
213: The escape
214: \e\fIddd\fR
215: consists of the backslash followed by 1, 2, or 3 octal digits
216: which are taken to specify the value of the
217: desired character.
218: A special case of this construction is
219: .B
220: \e0
221: .R
222: (not followed
223: by a digit), which indicates the character
224: .B
225: NUL\fR.
226: .R
227: If the character following a backslash is not one
228: of those specified, the
229: behavior is undefined.
230: A new-line character is illegal in a character constant.
231: The type of a character constant is \fBint\fR.
232: .NH 3
233: Floating Constants
234: .br
235: .PP
236: A floating constant consists of
237: an integer part, a decimal point, a fraction part,
238: an
239: .B
240: e
241: .R
242: or
243: \fBE\fR,
244: and an optionally signed integer exponent.
245: The integer and fraction parts both consist of a sequence
246: of digits.
247: Either the integer part or the fraction
248: part (not both) may be missing.
249: Either the decimal point or
250: the
251: .B
252: e
253: .R
254: and the exponent (not both) may be missing.
255: Every floating constant has type \fBdouble\fR.
256: .NH 3
257: Enumeration Constants
258: .br
259: .PP
260: Names declared as enumerators
261: (see ``Structure, Union, and Enumeration Declarations'' under
262: ``DECLARATIONS'')
263: have type \fBint\fR.
264: .NH 2
265: Strings
266: .PP
267: A string is a sequence of characters surrounded by
268: double quotes,
269: as in
270: \fB"..."\fR.
271: A string has type
272: ``array of \fBchar\fR'' and storage class
273: \fBstatic\fR
274: (see ``NAMES'')
275: and is initialized with
276: the given characters.
277: The compiler places
278: a null byte
279: (\fB\e0\fR)
280: at the end of each string so that programs
281: which scan the string can
282: find its end.
283: In a string, the double quote character
284: (\fB"\fR)
285: must be preceded by
286: a
287: \fB\e\fR;
288: in addition, the same escapes as described for character
289: constants may be used.
290: .PP
291: A
292: .B
293: \e
294: .R
295: and
296: the immediately following new\(hyline are ignored.
297: All strings, even when written identically, are distinct.
298: .NH 2
299: Hardware Characteristics
300: .PP
301: The following figure summarize
302: certain hardware properties that vary from machine to machine.
303: .DS
304: .TS
305: center box;
306: c cfB s cfB s cfB s
307: c c s c s c s
308: l | l1 lp8 | l1 lp8 | l1 lp8.
309: DEC PDP\-11 DEC VAX-11 AT&T 3B
310: (ASCII) (ASCII) (ASCII)
311: .sp
312: _
313: char 8 bits 8 bits 8bits
314: int 16 32 32
315: short 16 16 16
316: long 32 32 32
317: float 32 32 32
318: double 64 64 64
319: float range \(+-10 \(+-38 \(+-10 \(+-38 \(+-10 \(+-38
320: \^ \^ \^ \^
321: double range \(+-10 \(+-38 \(+-10 \(+-38 \(+-10 \(+-308
322: \^ \^ \^ \^
323: .TE
324: .FG 4 4 1 "DEC PDP-11 HARDWARE CHARACTERISTICS"
325: .DE
326: .PP
327: .NH 1
328: Syntax Notation
329: .PP
330: Syntactic categories are indicated by
331: .I
332: italic
333: .R
334: type
335: and literal words and characters
336: in
337: \fBbold\fR
338: type.
339: Alternative categories are listed on separate lines.
340: An optional terminal or nonterminal symbol is
341: indicated by the subscript ``opt,'' so that
342: .DS
343: { \fIexpression\v'0.5'\s-2opt\s0\v'-0.5'\fR }
344: .DE
345: .LP
346: indicates an optional expression enclosed in braces.
347: The syntax is summarized in ``SYNTAX SUMMARY''.
348: .NH 1
349: Names
350: .PP
351: The C language bases the interpretation of an
352: identifier upon two attributes of the identifier \(mi its
353: .I
354: storage class
355: .R
356: and its
357: .I
358: type\fR.
359: The storage class determines the location and lifetime
360: of the storage associated with an identifier;
361: the type determines
362: the meaning of the values
363: found in the identifier's storage.
364: .NH 2
365: Storage Class
366: .PP
367: There are four declarable storage classes:
368: .BL 6 1
369: .LI
370: Automatic
371: .LI
372: Static
373: .LI
374: External
375: .LI
376: Register.
377: .LE
378: .PP
379: Automatic variables are local to each invocation of
380: a block (see ``Compound Statement or Block'' in
381: ``STATEMENTS'') and are discarded upon exit from the block.
382: Static variables are local to a block but retain
383: their values upon reentry to a block even after control
384: has left the block.
385: External variables exist and retain their values throughout
386: the execution of the entire program and
387: may be used for communication between
388: functions, even separately compiled functions.
389: Register variables are (if possible) stored in the fast registers
390: of the machine; like automatic
391: variables, they are local to each block and disappear on exit from the block.
392: .NH 2
393: Type
394: .PP
395: The C language supports several
396: fundamental
397: types of objects.
398: Objects declared as characters
399: (\fBchar\fR)
400: are large enough to store any member of the implementation's
401: character set.
402: If a genuine character from that character set is
403: stored in a \fBchar\fR variable,
404: its value is equivalent to the integer code for that character.
405: Other quantities may be stored into character variables, but
406: the implementation is machine dependent.
407: In particular, \fBchar\fR may be signed or unsigned by default.
408: .PP
409: Up to three sizes of integer, declared
410: .B
411: short
412: .R
413: \fBint\fR,
414: \fBint\fR,
415: and
416: .B
417: long
418: .R
419: \fBint\fR,
420: are available.
421: Longer integers provide no less storage than shorter ones,
422: but the implementation may make either short integers or long integers,
423: or both, equivalent to plain integers.
424: ``Plain'' integers have the natural size suggested
425: by the host machine architecture.
426: The other sizes are provided to meet special needs.
427: .PP
428: The properties of \fBenum\fR types (see ``Structure, Union, and Enumeration Declarations''
429: under ``DECLARATIONS'')
430: are identical to those of
431: some integer types.
432: The implementation may use the range of values to
433: determine how to allocate storage.
434: .PP
435: Unsigned
436: integers, declared
437: .B
438: unsigned,
439: .R
440: obey the laws of arithmetic modulo
441: 2\v'-0.5'\fIn\fR\v'0.5'
442: where \fIn\fR is the number of bits in the representation.
443: (On the
444: PDP-11,
445: unsigned long quantities are not supported.)
446: .PP
447: Single-precision floating point
448: (\fBfloat\fR)
449: and double precision floating point
450: (\fBdouble\fR)
451: may be synonymous in some implementations.
452: .PP
453: Because objects of the foregoing types can usefully be interpreted
454: as numbers, they will be referred to as
455: .I
456: arithmetic
457: .R
458: types.
459: \fBChar\fR,
460: .B
461: int
462: .R
463: of all sizes whether \fBunsigned\fR or not, and
464: .B
465: enum
466: .R
467: will collectively be called
468: .I
469: integral
470: .R
471: types.
472: The
473: .B
474: float
475: .R
476: and
477: .B
478: double
479: .R
480: types will collectively be called
481: .I
482: floating
483: .R
484: types.
485: .PP
486: The
487: .B
488: void
489: .R
490: type
491: specifies an empty set of values.
492: It is used as the type returned by functions that
493: generate no value.
494: .PP
495: Besides the fundamental arithmetic types, there is a
496: conceptually infinite class of derived types constructed
497: from the fundamental types in the following ways:
498: .BL 6 1
499: .LI
500: \fIArrays\fR
501: of objects of most types
502: .LI
503: \fIFunctions\fR
504: which return objects of a given type
505: .LI
506: \fIPointers\fR
507: to objects of a given type
508: .LI
509: \fIStructures\fR
510: containing a sequence of objects of various types
511: .LI
512: \fIUnions\fR
513: capable of containing any one of several objects of various types.
514: .LE
515: .PP
516: In general these methods
517: of constructing objects can
518: be applied recursively.
519: .NH 1
520: Objects and Lvalues
521: .PP
522: An
523: .I
524: object
525: .R
526: is a manipulatable region of storage.
527: An
528: .I
529: lvalue
530: .R
531: is an expression referring to an object.
532: An obvious example of an lvalue
533: expression is an identifier.
534: There are operators which yield lvalues:
535: for example,
536: if
537: .B
538: E
539: .R
540: is an expression of pointer type, then
541: .B
542: \(**E
543: .R
544: is an lvalue
545: expression referring to the object to which
546: .B
547: E
548: .R
549: points.
550: The name ``lvalue'' comes from the assignment expression
551: .B
552: E1\ =\ E2
553: .R
554: in which the left operand
555: .B
556: E1
557: .R
558: must be
559: an lvalue expression.
560: The discussion of each operator
561: below indicates whether it expects lvalue operands and whether it
562: yields an lvalue.
563: .NH 1
564: Conversions
565: .PP
566: A number of operators may, depending on their operands,
567: cause conversion of the value of an operand from one type to another.
568: This part explains the result to be expected from such
569: conversions.
570: The conversions demanded by most ordinary operators are summarized under
571: ``Arithmetic Conversions.''
572: The summary will be supplemented
573: as required by the discussion
574: of each operator.
575: .NH 2
576: Characters and Integers
577: .PP
578: A character or a short integer may be used wherever an
579: integer may be used.
580: In all cases
581: the value is converted to an integer.
582: Conversion of a shorter integer
583: to a longer preserves sign.
584: Whether or not sign-extension occurs for characters is machine
585: dependent, but it is guaranteed that a member of the
586: standard character set is non-negative.
587: Of the machines treated here,
588: only the
589: PDP-11
590: and
591: VAX-11
592: sign-extend.
593: On these machines,
594: .B
595: char
596: .R
597: variables range in value from
598: \(mi128 to 127.
599: The more explicit type
600: .B
601: unsigned
602: .R
603: .B
604: char
605: .R
606: forces the values to range from 0 to 255.
607: .PP
608: On machines that treat characters as signed,
609: the characters of the
610: ASCII
611: set are all non-negative.
612: However, a character constant specified
613: with an octal escape suffers sign extension
614: and may appear negative;
615: for example,
616: \fB\'\e377\'\fR
617: \fRhas the value
618: .B
619: \(mi1\fR.
620: .PP
621: When a longer integer is converted to a shorter
622: integer
623: or to a
624: .B
625: char,
626: .R
627: it is truncated on the left.
628: Excess bits are simply discarded.
629: .NH 2
630: Float and Double
631: .PP
632: All floating arithmetic in C is carried out in double precision.
633: Whenever a
634: .B
635: float
636: .R
637: appears in an expression it is lengthened to
638: .B
639: double
640: .R
641: by zero padding its fraction.
642: When a
643: .B
644: double
645: .R
646: must be
647: converted to
648: \fBfloat\fR,
649: for example by an assignment,
650: the
651: .B
652: double
653: .R
654: is rounded before
655: truncation to
656: .B
657: float
658: .R
659: length.
660: This result is undefined if it cannot be represented as a float.
661: On the VAX, the compiler can be directed to use single percision for expressions
662: containing only float and interger operands.
663: .NH 2
664: Floating and Integral
665: .PP
666: Conversions of floating values to integral type
667: are rather machine dependent.
668: In particular, the direction of truncation of negative numbers
669: varies.
670: The result is undefined if
671: it will not fit in the space provided.
672: .PP
673: Conversions of integral values to floating type
674: are well behaved.
675: Some loss of accuracy occurs
676: if the destination lacks sufficient bits.
677: .NH 2
678: Pointers and Integers
679: .PP
680: An expression of integral type may be added to or subtracted from
681: a pointer; in such a case,
682: the first is converted as
683: specified in the discussion of the addition operator.
684: Two pointers to objects of the same type may be subtracted;
685: in this case, the result is converted to an integer
686: as specified in the discussion of the subtraction
687: operator.
688: .NH 2
689: Unsigned
690: .PP
691: Whenever an unsigned integer and a plain integer
692: are combined, the plain integer is converted to unsigned
693: and the result is unsigned.
694: The value
695: is the least unsigned integer congruent to the signed
696: integer (modulo 2\v'-0.3'\s-2wordsize\s+2\v'0.3').
697: In a 2's complement representation,
698: this conversion is conceptual; and there is no actual change in the
699: bit pattern.
700: .PP
701: When an unsigned \fBshort\fR integer is converted to
702: \fBlong\fR,
703: the value of the result is the same numerically as that of the
704: unsigned integer.
705: Thus the conversion amounts to padding with zeros on the left.
706: .NH 2
707: Arithmetic Conversions
708: .PP
709: A great many operators cause conversions
710: and yield result types in a similar way.
711: This pattern will be called the ``usual arithmetic conversions.''
712: .AL 1 6
713: .LI
714: First, any operands of type
715: .B
716: char
717: .R
718: or
719: .B
720: short
721: .R
722: are converted to
723: \fBint\fR,
724: and any operands of type \fBunsigned char\fR
725: or \fBunsigned short\fR are converted
726: to \fBunsigned int\fR.
727: .LI
728: Then, if either operand is
729: .B
730: double,
731: .R
732: the other is converted to
733: .B
734: double
735: .R
736: and that is the type of the result.
737: .LI
738: Otherwise, if either operand is \fBunsigned long\fR,
739: the other is converted to \fBunsigned long\fR and that
740: is the type of the result.
741: .LI
742: Otherwise, if either operand is
743: \fBlong\fR,
744: the other is converted to
745: .B
746: long
747: .R
748: and that is the type of the result.
749: .LI
750: Otherwise, if one operand is \fBlong\fR, and
751: the other is \fBunsigned int\fR, they are both
752: converted to \fBunsigned long\fR and that is
753: the type of the result.
754: .LI
755: Otherwise, if either operand is
756: .B
757: unsigned,
758: .R
759: the other is converted to
760: .B
761: unsigned
762: .R
763: and that is the type of the result.
764: .LI
765: Otherwise, both operands must be
766: \fBint\fR,
767: and that is the type of the result.
768: .LE
769: .NH 2
770: Void
771: .PP
772: The (nonexistent) value of a
773: .B
774: void
775: .R
776: object may not be used in any way,
777: and neither explicit nor implicit conversion may be applied.
778: Because a void expression denotes a nonexistent value,
779: such an expression may be used only
780: as an expression statement
781: (see ``Expression Statement'' under ``STATEMENTS'')
782: or as the left operand
783: of a comma expression (see ``Comma Operator'' under ``EXPRESSIONS'').
784: .PP
785: An expression may be converted to
786: type
787: .B
788: void
789: .R
790: by use of a cast.
791: For example, this makes explicit the discarding of the value
792: of a function call used as an expression statement.
793: .NH 1
794: Expressions
795: .PP
796: The precedence of expression operators is the same
797: as the order of the major
798: subsections of this section, highest precedence first.
799: Thus, for example, the expressions referred to as the operands of
800: .B
801: \(pl
802: .R
803: (see ``Additive Operators'')
804: are those expressions defined under ``Primary Expressions'',
805: ``Unary Operators'', and ``Multiplicative Operators''.
806: Within each subpart, the operators have the same
807: precedence.
808: Left- or right-associativity is specified
809: in each subsection for the operators
810: discussed therein.
811: The precedence and associativity of all the expression
812: operators are summarized in the
813: grammar of ``SYNTAX SUMMARY''.
814: .PP
815: Otherwise, the order of evaluation of expressions
816: is undefined. In particular, the compiler
817: considers itself free to
818: compute subexpressions in the order it believes
819: most efficient
820: even if the subexpressions
821: involve side effects.
822: The order in which subexpression evaluation takes place is unspecified.
823: Expressions involving a commutative and associative
824: operator
825: (\fB\(**,\fR
826: \fB\(pl\fR,
827: \fB&\fR,
828: \fB|\fR,
829: \fB^\fR)
830: may be rearranged arbitrarily even in the presence
831: of parentheses;
832: to force a particular order of evaluation,
833: an explicit temporary must be used.
834: .PP
835: The handling of overflow and divide check
836: in expression evaluation
837: is undefined.
838: Most existing implementations of C ignore integer overflows;
839: treatment of
840: division by 0 and all floating-point exceptions
841: varies between machines and is usually
842: adjustable by a library function.
843: .NH 2
844: Primary Expressions
845: .PP
846: Primary expressions
847: involving \fB\.\fR,
848: \fB\(mi>\fR,
849: subscripting, and function calls
850: group left to right.
851: .DS
852: \fIprimary-expression:
853: identifier
854: constant
855: string
856: ( expression )
857: primary-expression [ expression ]
858: primary-expression ( expression-list\v'0.5'\s-2opt\s0\v'-0.5' )
859: primary-expression . identifier
860: primary-expression \(mi> identifier\fR
861: .DE
862: .DS
863: \fIexpression-list:
864: expression
865: expression-list , expression\fR
866: .DE
867: .PP
868: An identifier is a primary expression provided it has been
869: suitably declared as discussed below.
870: Its type is specified by its declaration.
871: If the type of the identifier is ``array of .\|.\|.'',
872: then the value of the identifier expression
873: is a pointer
874: to the first object in the array; and the
875: type of the expression is
876: ``pointer to .\|.\|.''.
877: Moreover, an array identifier is not an lvalue
878: expression.
879: Likewise, an identifier which is declared
880: ``function returning .\|.\|.'',
881: when used except in the function-name position
882: of a call, is converted to ``pointer to function returning .\|.\|.''.
883: .PP
884: A
885: constant is a primary expression.
886: Its type may be
887: \fBint\fR,
888: \fBlong\fR,
889: or
890: .B
891: double
892: .R
893: depending on its form.
894: Character constants have type
895: .B
896: int
897: .R
898: and floating constants have type
899: .B
900: double\fR.
901: .R
902: .PP
903: A string is a primary expression.
904: Its type is originally ``array of
905: \fBchar\fR'',
906: but following
907: the same rule given above for identifiers,
908: this is modified to ``pointer to
909: \fBchar\fR'' and
910: the
911: result is a pointer to the first character
912: in the string.
913: (There is an exception in certain initializers;
914: see ``Initialization'' under ``DECLARATIONS.'')
915: .PP
916: A parenthesized expression is a primary expression
917: whose type and value are identical
918: to those of the unadorned expression.
919: The presence of parentheses does
920: not affect whether the expression is an
921: lvalue.
922: .PP
923: A primary expression followed by an expression in square
924: brackets is a primary expression.
925: The intuitive meaning is that of a subscript.
926: Usually, the primary expression has type ``pointer to .\|.\|.'',
927: the subscript expression is
928: \fBint\fR,
929: and the type of the result is ``\|.\|.\|.\|''.
930: The expression
931: .B
932: E1[E2]
933: .R
934: is
935: identical (by definition) to
936: .B
937: \(**((E1)\(plE2))\fR.
938: All the clues
939: needed to understand
940: this notation are contained in this subpart together
941: with the discussions
942: in ``Unary Operators'' and ``Additive Operators'' on identifiers,
943: .B
944: \(**
945: .R
946: and
947: .B
948: \(pl
949: .R
950: respectively.
951: The implications are summarized under ``Arrays, Pointers, and Subscripting''
952: under ``TYPES REVISITED.''
953: .PP
954: A function call is a primary expression followed by parentheses
955: containing a possibly
956: empty, comma-separated list of expressions
957: which constitute the actual arguments to the
958: function.
959: The primary expression must be of type ``function returning .\|.\|.,''
960: and the result of the function call is of type ``\|.\|.\|.\|''.
961: As indicated
962: below, a hitherto unseen identifier followed
963: immediately by a left parenthesis
964: is contextually declared
965: to represent a function returning
966: an integer;
967: thus in the most common case, integer-valued functions
968: need not be declared.
969: .PP
970: Any actual arguments of type
971: .B
972: float
973: .R
974: are
975: converted to
976: .B
977: double
978: .R
979: before the call.
980: Any of type
981: .B
982: char
983: .R
984: or
985: .B
986: short
987: .R
988: are converted to
989: .B
990: int\fR.
991: .R
992: Array names are converted to pointers.
993: No other conversions are performed automatically;
994: in particular, the compiler does not compare
995: the types of actual arguments with those of formal
996: arguments.
997: If conversion is needed, use a cast;
998: see ``Unary Operators'' and ``Type Names'' under
999: ``DECLARATIONS.''
1000: .PP
1001: In preparing for the call to a function,
1002: a copy is made of each actual parameter.
1003: Thus, all argument passing in C is strictly by value.
1004: A function may
1005: change the values of its formal parameters, but
1006: these changes cannot affect the values
1007: of the actual parameters.
1008: It is possible
1009: to pass a pointer on the understanding
1010: that the function may change the value
1011: of the object to which the pointer points.
1012: An array name is a pointer expression.
1013: The order of evaluation of arguments is undefined by the language;
1014: take note that the various compilers differ.
1015: Recursive calls to any
1016: function are permitted.
1017: .PP
1018: A primary expression followed by a dot followed by an identifier
1019: is an expression.
1020: The first expression must be a structure or a union, and the identifier
1021: must name a member of the structure or union.
1022: The value is the named member of the structure or union, and it is
1023: an lvalue if the first expression is an lvalue.
1024: .PP
1025: A primary expression followed by an arrow (built from
1026: .B
1027: \(mi
1028: .R
1029: and
1030: .B
1031: >
1032: .R
1033: )
1034: followed by an identifier
1035: is an expression.
1036: The first expression must be a pointer to a structure or a union
1037: and the identifier must name a member of that structure or union.
1038: The result is an lvalue referring to the named member
1039: of the structure or union
1040: to which the pointer expression points.
1041: Thus the expression
1042: .B
1043: E1\(mi>MOS
1044: .R
1045: is the same as
1046: .B
1047: (\(**E1).MOS\fR.
1048: .R
1049: Structures and unions are discussed in
1050: ``Structure, Union, and Enumeration Declarations'' under
1051: ``DECLARATIONS.''
1052: .NH 2
1053: Unary Operators
1054: .PP
1055: Expressions with unary operators
1056: group right to left.
1057: .tr ~~
1058: .DS
1059: \fIunary-expression:
1060: \(** expression
1061: & lvalue
1062: \(mi expression
1063: ! expression
1064: \s+2~\s0 expression
1065: \(pl\(pl lvalue
1066: \(mi\(milvalue
1067: lvalue \(pl\(pl
1068: lvalue \(mi\(mi
1069: ( type-name ) expression\fR
1070: sizeof\fI expression\fR
1071: sizeof\fI ( type-name )\fR
1072: .DE
1073: .PP
1074: The unary
1075: .B
1076: \(**
1077: .R
1078: operator
1079: means
1080: .I
1081: indirection
1082: .R
1083: ;
1084: the expression must be a pointer, and the result
1085: is an lvalue referring to the object to
1086: which the expression points.
1087: If the type of the expression is ``pointer to .\|.\|.,''
1088: the type of the result is ``\|.\|.\|.\|''.
1089: .PP
1090: The result of the unary
1091: .B
1092: &
1093: .R
1094: operator is a pointer
1095: to the object referred to by the
1096: lvalue.
1097: If the type of the lvalue is ``\|.\|.\|.\|'',
1098: the type of the result is ``pointer to .\|.\|.''.
1099: .PP
1100: The result
1101: of the unary
1102: .B
1103: \(mi
1104: .R
1105: operator
1106: is the negative of its operand.
1107: The usual arithmetic conversions are performed.
1108: The negative of an unsigned quantity is computed by
1109: subtracting its value from
1110: 2\v'-0.5'\fIn\fR\^\v'0.5' where \fIn\fR\^ is the number of bits in
1111: the corresponding signed type.
1112: .sp
1113: .tr ~~
1114: There is no unary
1115: .B
1116: \(pl
1117: .R
1118: operator.
1119: .PP
1120: The result of the logical negation operator
1121: .B
1122: !
1123: .R
1124: is one if the value of its operand is zero, zero if the value of its
1125: operand is nonzero.
1126: The type of the result is
1127: .B
1128: int\fR.
1129: .R
1130: It is applicable to any arithmetic type
1131: or to pointers.
1132: .PP
1133: The
1134: .B
1135: \s+2~\s0
1136: .R
1137: operator yields the one's complement of its operand.
1138: The usual arithmetic conversions are performed.
1139: The type of the operand must be integral.
1140: .PP
1141: The object referred to by the lvalue operand of prefix
1142: .B
1143: \(pl\(pl
1144: .R
1145: is incremented.
1146: The value is the new value of the operand
1147: but is not an lvalue.
1148: The expression
1149: .B
1150: \(pl\(plx
1151: .R
1152: is equivalent to
1153: \fBx=x\(pl1\fR.
1154: See the discussions ``Additive Operators'' and ``Assignment
1155: Operators'' for information on conversions.
1156: .PP
1157: The lvalue operand of prefix
1158: .B
1159: \(mi\(mi
1160: .R
1161: is decremented
1162: analogously to the
1163: prefix
1164: .B
1165: \(pl\(pl
1166: .R
1167: operator.
1168: .PP
1169: When postfix
1170: .B
1171: \(pl\(pl
1172: .R
1173: is applied to an lvalue,
1174: the result is the value of the object referred to by the lvalue.
1175: After the result is noted, the object
1176: is incremented in the same
1177: manner as for the prefix
1178: .B
1179: \(pl\(pl
1180: .R
1181: operator.
1182: The type of the result is the same as the type of the lvalue expression.
1183: .PP
1184: When postfix
1185: .B
1186: \(mi\(mi
1187: .R
1188: is applied to an lvalue,
1189: the result is the value of the object referred to by the lvalue.
1190: After the result is noted, the object
1191: is decremented in the manner as for the prefix
1192: .B
1193: \(mi\(mi
1194: .R
1195: operator.
1196: The type of the result is the same as the type of the lvalue
1197: expression.
1198: .PP
1199: An expression preceded by the parenthesized name of a data type
1200: causes conversion of the value of the expression to the named type.
1201: This construction is called a
1202: .I
1203: cast\fR.
1204: .R
1205: Type names are described in ``Type Names'' under ``Declarations.''
1206: .PP
1207: The
1208: .B
1209: sizeof
1210: .R
1211: operator yields the size
1212: in bytes of its operand.
1213: (A
1214: .I
1215: byte
1216: .R
1217: is undefined by the language
1218: except in terms of the value of
1219: .B
1220: sizeof\fR.
1221: .R
1222: However, in all existing implementations,
1223: a byte is the space required to hold a
1224: \fBchar.\fR)
1225: When applied to an array, the result is the total
1226: number of bytes in the array.
1227: The size is determined from
1228: the declarations of
1229: the objects in the expression.
1230: This expression is semantically an
1231: .B
1232: unsigned
1233: .R
1234: constant and may
1235: be used anywhere a constant is required.
1236: Its major use is in communication with routines
1237: like storage allocators and I/O systems.
1238: .PP
1239: The
1240: .B
1241: sizeof
1242: .R
1243: operator
1244: may also be applied to a parenthesized type name.
1245: In that case it yields the size in bytes of an object
1246: of the indicated type.
1247: .PP
1248: The construction
1249: \fBsizeof(\fItype\|\fR\^)\fR\^
1250: is taken to be a unit,
1251: so the expression
1252: \fBsizeof(\fItype\|\fB)-2\fR
1253: is the same as
1254: \fB(sizeof(\fItype\|\fB))-2\fR.
1255: .NH 2
1256: Multiplicative Operators
1257: .PP
1258: The multiplicative operators
1259: \fB\(**\fR,
1260: \fB/\fR,
1261: and
1262: .B
1263: %
1264: .R
1265: group left to right.
1266: The usual arithmetic conversions are performed.
1267: .DS
1268: \fImultiplicative expression:
1269: expression \(** expression
1270: expression / expression
1271: expression % expression\fR
1272: .DE
1273: .PP
1274: The binary
1275: .B
1276: \(**
1277: .R
1278: operator indicates multiplication.
1279: The
1280: .B
1281: \(**
1282: .R
1283: operator is associative,
1284: and expressions with several multiplications at the same
1285: level may be rearranged by the compiler.
1286: The binary
1287: .B
1288: /
1289: .R
1290: operator indicates division.
1291: .PP
1292: The binary
1293: .B
1294: %
1295: .R
1296: operator yields the remainder
1297: from the division of the first expression by the second.
1298: The operands must be integral.
1299: .PP
1300: When positive integers are divided, truncation is toward 0;
1301: but the form of truncation is machine-dependent
1302: if either operand is negative.
1303: On all machines covered by this manual,
1304: the remainder has the same sign as the dividend.
1305: It is always true that
1306: .B
1307: (a/b)\(**b\ \(pl a%b
1308: .R
1309: is equal to
1310: .B
1311: a
1312: .R
1313: (if
1314: .B
1315: b
1316: .R
1317: is not 0).
1318: .NH 2
1319: Additive Operators
1320: .PP
1321: The additive operators
1322: .B
1323: \(pl
1324: .R
1325: and
1326: .B
1327: \(mi
1328: .R
1329: group left to right.
1330: The usual arithmetic conversions are performed.
1331: There are some additional type possibilities for each operator.
1332: .DS
1333: \fIadditive-expression:
1334: expression \(pl expression
1335: expression \(mi expression\fR
1336: .DE
1337: .PP
1338: The result of the
1339: .B
1340: \(pl
1341: .R
1342: operator is the sum of the operands.
1343: A pointer to an object in an array and
1344: a value of any integral type
1345: may be added.
1346: The latter is in all cases converted to
1347: an address offset
1348: by multiplying it
1349: by the length of the object to which the
1350: pointer points.
1351: The result is a pointer
1352: of the same type as the original pointer
1353: which points to another object in the same array,
1354: appropriately offset from the original object.
1355: Thus if
1356: .B
1357: P
1358: .R
1359: is a pointer
1360: to an object in an array, the expression
1361: .B
1362: P\(pl1
1363: .R
1364: is a pointer
1365: to the next object in the array.
1366: No further type combinations are allowed for pointers.
1367: .PP
1368: The
1369: .B
1370: \(pl
1371: .R
1372: operator is associative,
1373: and expressions with several additions at the same level may
1374: be rearranged by the compiler.
1375: .PP
1376: The result of the
1377: .B
1378: \(mi
1379: .R
1380: operator is the difference of the operands.
1381: The usual arithmetic conversions are performed.
1382: Additionally,
1383: a value of any integral type
1384: may be subtracted from a pointer,
1385: and then the same conversions for addition apply.
1386: .PP
1387: If two pointers to objects of the same type are subtracted,
1388: the result is converted
1389: (by division by the length of the object)
1390: to an
1391: .B
1392: int
1393: .R
1394: representing the number of
1395: objects separating
1396: the pointed-to objects.
1397: This conversion will in general give unexpected
1398: results unless the pointers point
1399: to objects in the same array, since pointers, even
1400: to objects of the same type, do not necessarily differ
1401: by a multiple of the object length.
1402: .NH 2
1403: Shift Operators
1404: .PP
1405: The shift operators
1406: .B
1407: <<
1408: .R
1409: and
1410: .B
1411: >>
1412: .R
1413: group left to right.
1414: Both perform the usual arithmetic conversions on their operands,
1415: each of which must be integral.
1416: Then the right operand is converted to
1417: \fBint\fR;
1418: the type of the result is that of the left operand.
1419: The result is undefined if the right operand is negative
1420: or greater than or equal to the length of the object in bits.
1421: On the VAX a negative right operand is interpreted as reversing
1422: the direction of the shift.
1423: .DS
1424: \fIshift-expression:
1425: expression << expression
1426: expression >> expression\fR
1427: .DE
1428: .PP
1429: The value of
1430: .B
1431: E1<<E2
1432: .R
1433: is
1434: .B
1435: E1
1436: .R
1437: (interpreted as a bit
1438: pattern) left-shifted
1439: .B
1440: E2
1441: .R
1442: bits.
1443: Vacated bits are 0 filled.
1444: The value of
1445: .B
1446: E1>>E2
1447: .R
1448: is
1449: .B
1450: E1
1451: .R
1452: right-shifted
1453: .B
1454: E2
1455: .R
1456: bit positions.
1457: The right shift is guaranteed to be logical
1458: (0 fill)
1459: if
1460: .B
1461: E1
1462: .R
1463: is
1464: \fBunsigned\fR;
1465: otherwise, it may be
1466: arithmetic.
1467: .NH 2
1468: Relational Operators
1469: .PP
1470: The relational operators group left to right.
1471: .DS
1472: \fIrelational-expression:
1473: expression < expression
1474: expression > expression
1475: expression <= expression
1476: expression >= expression\fR
1477: .DE
1478: .PP
1479: The operators
1480: .B
1481: <
1482: .R
1483: (less than),
1484: .B
1485: >
1486: .R
1487: (greater than), \fB<=\fR
1488: (less than
1489: or equal to), and
1490: .B
1491: >=
1492: .R
1493: (greater than or equal to)
1494: all yield 0 if the specified relation is false
1495: and 1 if it is true.
1496: The type of the result is
1497: .B
1498: int\fR.
1499: The usual arithmetic conversions are performed.
1500: Two pointers may be compared;
1501: the result depends on the relative locations in the address space
1502: of the pointed-to objects.
1503: Pointer comparison is portable only when the pointers point to objects
1504: in the same array.
1505: .NH 2
1506: Equality Operators
1507: .PP
1508: .DS
1509: \fIequality-expression:
1510: expression == expression
1511: expression != expression\fR
1512: .DE
1513: .PP
1514: The
1515: .B
1516: ==
1517: .R
1518: (equal to) and the
1519: .B
1520: !=
1521: .R
1522: (not equal to) operators
1523: are exactly analogous to the relational
1524: operators except for their lower
1525: precedence.
1526: (Thus
1527: .B
1528: a<b\ ==\ c<d
1529: .R
1530: is 1 whenever
1531: .B
1532: a<b
1533: .R
1534: and
1535: .B
1536: c<d
1537: .R
1538: have the same truth value).
1539: .PP
1540: A pointer may be compared to an integer
1541: only if the
1542: integer is the constant 0.
1543: A pointer to which 0 has been assigned is guaranteed
1544: not to point to any object
1545: and will appear to be equal to 0.
1546: In conventional usage, such a pointer is considered to be null.
1547: .NH 2
1548: Bitwise \s-1AND\s0 Operator
1549: .PP
1550: .DS
1551: \fIand-expression:
1552: expression & expression\fR
1553: .DE
1554: .PP
1555: The
1556: .B
1557: &
1558: .R
1559: operator is associative,
1560: and expressions involving
1561: .B
1562: &
1563: .R
1564: may be rearranged.
1565: The usual arithmetic conversions are performed.
1566: The result is the bitwise
1567: AND
1568: function of the operands.
1569: The operator applies only to integral
1570: operands.
1571: .NH 2
1572: Bitwise Exclusive \s-1OR\s0 Operator
1573: .DS
1574: \fIexclusive-or-expression:
1575: expression ^ expression\fR
1576: .DE
1577: .PP
1578: The
1579: .B
1580: ^
1581: .R
1582: operator is associative,
1583: and expressions involving
1584: .B
1585: ^
1586: .R
1587: may be rearranged.
1588: The usual arithmetic conversions are performed;
1589: the result is
1590: the bitwise exclusive
1591: OR
1592: function of
1593: the operands.
1594: The operator applies only to integral
1595: operands.
1596: .NH 2
1597: Bitwise Inclusive \s-1OR\s0 Operator
1598: .DS
1599: \fIinclusive-or-expression:
1600: expression | expression\fR
1601: .DE
1602: .PP
1603: The
1604: .B
1605: |
1606: .R
1607: operator is associative,
1608: and expressions involving
1609: .B
1610: |
1611: .R
1612: may be rearranged.
1613: The usual arithmetic conversions are performed;
1614: the result is the bitwise inclusive
1615: OR
1616: function of its operands.
1617: The operator applies only to integral
1618: operands.
1619: .NH 2
1620: Logical \s-1AND\s0 Operator
1621: .DS
1622: \fIlogical-and-expression:
1623: expression && expression\fR
1624: .DE
1625: .PP
1626: The
1627: .B
1628: &&
1629: .R
1630: operator groups left to right.
1631: It returns 1 if both its operands
1632: evaluate to nonzero, 0 otherwise.
1633: Unlike
1634: \fB&\fR,
1635: .B
1636: &&
1637: .R
1638: guarantees left to right
1639: evaluation; moreover, the second operand is not evaluated
1640: if the first operand is 0.
1641: .PP
1642: The operands need not have the same type, but each
1643: must have one of the fundamental
1644: types or be a pointer.
1645: The result is always
1646: .B
1647: int\fR.
1648: .R
1649: .NH 2
1650: Logical \s-1OR\s0 Operator
1651: .DS
1652: \fIlogical-or-expression:
1653: expression || expression\fR
1654: .DE
1655: .PP
1656: The
1657: .B
1658: ||
1659: .R
1660: operator groups left to right.
1661: It returns 1 if either of its operands
1662: evaluates to nonzero, 0 otherwise.
1663: Unlike
1664: \fB|\fR,
1665: .B
1666: ||
1667: .R
1668: guarantees left to right evaluation; moreover,
1669: the second operand is not evaluated
1670: if the value of the first operand is nonzero.
1671: .PP
1672: The operands need not have the same type, but each
1673: must
1674: have one of the fundamental types
1675: or be a pointer.
1676: The result is always
1677: .B
1678: int\fR.
1679: .R
1680: .NH 2
1681: Conditional Operator
1682: .DS
1683: \fIconditional-expression:
1684: expression ? expression : expression\fR
1685: .DE
1686: .PP
1687: Conditional expressions group right to left.
1688: The first expression is evaluated;
1689: and if it is nonzero, the result is the value of the
1690: second expression, otherwise that of third expression.
1691: If possible, the usual arithmetic conversions are performed
1692: to bring the second and third expressions to a common type.
1693: If both are structures or unions of the same type,
1694: the result has the type of the structure or union.
1695: If both pointers are of the same type,
1696: the result has the common type.
1697: Otherwise, one must be a pointer and the other the constant 0,
1698: and the result has the type of the pointer.
1699: Only one of the second and third
1700: expressions is evaluated.
1701: .NH 2
1702: Assignment Operators
1703: .PP
1704: There are a number of assignment operators,
1705: all of which group right to left.
1706: All require an lvalue as their left operand,
1707: and the type of an assignment expression is that
1708: of its left operand.
1709: The value is the value stored in the
1710: left operand after the assignment has taken place.
1711: The two parts of a compound assignment operator are separate
1712: tokens.
1713: .DS
1714: \fIassignment-expression:
1715: lvalue = expression
1716: lvalue \(pl= expression
1717: lvalue \(mi= expression
1718: lvalue \(**= expression
1719: lvalue /= expression
1720: lvalue %= expression
1721: lvalue >>= expression
1722: lvalue <<= expression
1723: lvalue &= expression
1724: lvalue ^= expression
1725: lvalue |= expression\fR
1726: .DE
1727: .PP
1728: In the simple assignment with
1729: \fB=\fR,
1730: the value of the expression replaces that of the object
1731: referred
1732: to by the lvalue.
1733: If both operands have arithmetic type,
1734: the right operand is converted to the type of the left
1735: preparatory to the assignment.
1736: Second, both operands may be structures or unions of the same type.
1737: Finally, if the left operand is a pointer, the right operand must in general be a pointer
1738: of the same type.
1739: However, the constant 0 may be assigned to a pointer;
1740: it is guaranteed that this value will produce a null
1741: pointer distinguishable from a pointer to any object.
1742: .PP
1743: The behavior of an expression
1744: of the form
1745: \fBE1\fR\^ \fIop\fR\^ = \fBE2\fR\^
1746: may be inferred by
1747: taking it as equivalent to
1748: \fBE1 = E1 \fIop\fR\^ (\fBE2\fR\^);
1749: however,
1750: .B
1751: E1
1752: .R
1753: is evaluated only once.
1754: In
1755: .B
1756: \(pl=
1757: .R
1758: and
1759: \fB\(mi=\fR,
1760: the left operand may be a pointer; in which case, the (integral) right
1761: operand is converted as explained
1762: in ``Additive Operators.''
1763: All right operands and all nonpointer left operands must
1764: have arithmetic type.
1765: .NH 2
1766: Comma Operator
1767: .DS
1768: \fIcomma-expression:
1769: expression , expression\fR
1770: .DE
1771: .PP
1772: A pair of expressions separated by a comma is evaluated
1773: left to right, and the value of the left expression is
1774: discarded.
1775: The type and value of the result are the
1776: type and value of the right operand.
1777: This operator groups left to right.
1778: In contexts where comma is given a special meaning,
1779: e.g., in lists of actual arguments
1780: to functions (see ``Primary Expressions'') and lists
1781: of initializers (see ``Initialization'' under ``DECLARATIONS''),
1782: the comma operator as described in this subpart
1783: can only appear in parentheses. For example,
1784: .DS
1785: \fBf(a, (t=3, t\(pl2), c)\fR
1786: .DE
1787: .LP
1788: has three arguments, the second of which has the value 5.
1789: .NH 1
1790: Declarations
1791: .PP
1792: Declarations are used to specify the interpretation
1793: which C gives to each identifier; they do not necessarily
1794: reserve storage associated with the identifier.
1795: Declarations have the form
1796: .DS
1797: \fIdeclaration:
1798: decl-specifiers declarator-list\v'0.5'\s-2opt\s0\v'-0.5' ;\fR
1799: .DE
1800: .PP
1801: The declarators in the declarator-list
1802: contain the identifiers being declared.
1803: The decl-specifiers
1804: consist of a sequence of type and storage class specifiers.
1805: .DS
1806: \fIdecl-specifiers:
1807: type-specifier decl-specifiers\v'0.5'\s-2opt\s0\v'-0.5'
1808: sc-specifier decl-specifiers\v'0.5'\s-2opt\s0\v'-0.5'\fR
1809: .DE
1810: .PP
1811: The list must be self-consistent in a way described below.
1812: .NH 2
1813: Storage Class Specifiers
1814: .PP
1815: The sc-specifiers are:
1816: .DS
1817: \fIsc-specifier:\fB
1818: auto
1819: static
1820: extern
1821: register
1822: typedef\fR
1823: .DE
1824: .PP
1825: The
1826: .B
1827: typedef
1828: .R
1829: specifier does not reserve storage
1830: and is called a ``storage class specifier'' only for syntactic convenience.
1831: See ``Typedef'' for more information.
1832: The meanings of the various storage classes were discussed in ``Names.''
1833: .PP
1834: The
1835: \fBauto\fR,
1836: \fBstatic\fR,
1837: and
1838: .B
1839: register
1840: .R
1841: declarations also serve as definitions
1842: in that they cause an appropriate amount of storage to be reserved.
1843: In the
1844: .B
1845: extern
1846: .R
1847: case,
1848: there must be an external definition (see ``External Definitions'')
1849: for the given identifiers
1850: somewhere outside the function in which they are declared.
1851: .PP
1852: A
1853: .B
1854: register
1855: .R
1856: declaration is best thought of as an
1857: .B
1858: auto
1859: .R
1860: declaration, together with a hint to the compiler
1861: that the variables declared will be heavily used.
1862: Only the first few
1863: such declarations in each function are effective.
1864: Moreover, only variables of certain types will be stored in registers;
1865: on the
1866: PDP-11,
1867: they are
1868: .B
1869: int
1870: .R
1871: or pointer.
1872: One other restriction applies to register variables:
1873: the address-of operator
1874: .B
1875: &
1876: .R
1877: cannot be applied to them.
1878: Smaller, faster programs can be expected if register declarations
1879: are used appropriately,
1880: but future improvements in code generation
1881: may render them unnecessary.
1882: .PP
1883: At most, one sc-specifier may be given in a declaration.
1884: If the sc-specifier is missing from a declaration, it
1885: is taken to be
1886: .B
1887: auto
1888: .R
1889: inside a function,
1890: .B
1891: extern
1892: .R
1893: outside.
1894: Exception:
1895: functions are never
1896: automatic.
1897: .NH 2
1898: Type Specifiers
1899: .PP
1900: The type-specifiers are
1901: .DS
1902: \fItype-specifier:
1903: struct-or-union-specifier
1904: typedef-name
1905: enum-specifier
1906: basic-type-specifier:
1907: basic-type
1908: basic-type basic-type-specifiers
1909: basic-type:\fB
1910: char
1911: short
1912: int
1913: long
1914: unsigned
1915: float
1916: double
1917: void\fR
1918: .DE
1919: .PP
1920: At most one of the words \fBlong\fR or \fBshort\fR
1921: may be specified in conjunction with \fBint\fR;
1922: the meaning is the same as if \fBint\fR were not mentioned.
1923: The word \fBlong\fR may be specified in conjunction with
1924: \fBfloat\fR;
1925: the meaning is the same as \fBdouble\fR.
1926: The word \fBunsigned\fR may be specified alone, or
1927: in conjunction with \fBint\fR or any of its short
1928: or long varieties, or with \fBchar\fR.
1929: .PP
1930: Otherwise, at most on type-specifier may be
1931: given in a declaration.
1932: In particular, adjectival use of \fBlong\fR,
1933: \fBshort\fR, or \fBunsigned\fR is not permitted
1934: with \fBtypedef\fR names.
1935: If the type-specifier is missing from a declaration,
1936: it is taken to be \fBint\fR.
1937: .PP
1938: Specifiers for structures, unions, and enumerations are discussed in
1939: ``Structure, Union, and Enumeration Declarations.''
1940: Declarations with
1941: .B
1942: typedef
1943: .R
1944: names are discussed in ``Typedef.''
1945: .NH 2
1946: Declarators
1947: .PP
1948: The declarator-list appearing in a declaration
1949: is a comma-separated sequence of declarators,
1950: each of which may have an initializer.
1951: .DS
1952: \fIdeclarator-list:
1953: init-declarator
1954: init-declarator , declarator-list
1955: .DE
1956: .DS
1957: \fIinit-declarator:
1958: declarator initializer\v'0.5'\s-2opt\s0\v'-0.5'\fR
1959: .DE
1960: .PP
1961: Initializers are discussed in ``Initialization''.
1962: The specifiers in the declaration
1963: indicate the type and storage class of the objects to which the
1964: declarators refer.
1965: Declarators have the syntax:
1966: .DS
1967: \fIdeclarator:
1968: identifier
1969: ( declarator )
1970: \(** declarator
1971: declarator ()
1972: declarator [ constant-expression\v'0.5'\s-2opt\s0\v'-0.5' ]\fR
1973: .DE
1974: .PP
1975: The grouping is
1976: the same as in expressions.
1977: .NH 2
1978: Meaning of Declarators
1979: .PP
1980: Each declarator is taken to be
1981: an assertion that when a construction of
1982: the same form as the declarator appears in an expression,
1983: it yields an object of the indicated
1984: type and storage class.
1985: .PP
1986: Each declarator contains exactly one identifier; it is this identifier that
1987: is declared.
1988: If an unadorned identifier appears
1989: as a declarator, then it has the type
1990: indicated by the specifier heading the declaration.
1991: .PP
1992: A declarator in parentheses is identical to the unadorned declarator,
1993: but the binding of complex declarators may be altered by parentheses.
1994: See the examples below.
1995: .PP
1996: Now imagine a declaration
1997: .DS
1998: \fBT D1\fR
1999: .DE
2000: .LP
2001: where
2002: .B
2003: T
2004: .R
2005: is a type-specifier (like
2006: \fBint\fR,
2007: etc.)
2008: and
2009: .B
2010: D1
2011: .R
2012: is a declarator.
2013: Suppose this declaration makes the identifier have type
2014: ``\|.\|.\|.\|
2015: .B
2016: T
2017: .R
2018: ,''
2019: where the ``\|.\|.\|.\|'' is empty if
2020: .B
2021: D1
2022: .R
2023: is just a plain identifier
2024: (so that the type of
2025: .B
2026: x
2027: .R
2028: in
2029: \fB`int x''\fR
2030: is just
2031: \fBint\fR).
2032: Then if
2033: .B
2034: D1
2035: .R
2036: has the form
2037: .DS
2038: \fB\(**D\fR
2039: .DE
2040: .LP
2041: the type of the contained identifier is
2042: ``\|.\|.\|.\| pointer to
2043: .B
2044: T
2045: .R
2046: \&.''
2047: .PP
2048: If
2049: .B
2050: D1
2051: .R
2052: has the form
2053: .DS
2054: \fBD\|(\|\|)\|\fR
2055: .DE
2056: .LP
2057: then the contained identifier has the type
2058: ``\|.\|.\|. function returning
2059: \fBT\fR.''
2060: .LP
2061: If
2062: .B
2063: D1
2064: .R
2065: has the form
2066: .DS
2067: \fBD\|[\|\fIconstant-expression\fB\|]\fR
2068: .DE
2069: .LP
2070: or
2071: .DS
2072: \fBD\|[\|]\|\fR
2073: .DE
2074: .LP
2075: then the contained identifier has type
2076: ``\|.\|.\|.\| array of
2077: \fBT\fR.''
2078: In the first case, the constant
2079: expression
2080: is an expression
2081: whose value is determinable at compile time
2082: , whose type is
2083: .B
2084: int\fR,
2085: and whose value is positive.
2086: (Constant expressions are defined precisely in ``Constant Expressions.'')
2087: When several ``array of'' specifications are adjacent, a multidimensional
2088: array is created;
2089: the constant expressions which specify the bounds
2090: of the arrays may be missing only for the first member of the sequence.
2091: This elision is useful when the array is external
2092: and the actual definition, which allocates storage,
2093: is given elsewhere.
2094: The first constant expression may also be omitted
2095: when the declarator is followed by initialization.
2096: In this case the size is calculated from the number
2097: of initial elements supplied.
2098: .PP
2099: An array may be constructed from one of the basic types, from a pointer,
2100: from a structure or union,
2101: or from another array (to generate a multidimensional array).
2102: .PP
2103: Not all the possibilities
2104: allowed by the syntax above are actually
2105: permitted.
2106: The restrictions are as follows:
2107: functions may not return
2108: arrays or functions
2109: although they may return pointers;
2110: there are no arrays of functions although
2111: there may be arrays of pointers to functions.
2112: Likewise, a structure or union may not contain a function;
2113: but it may contain a pointer to a function.
2114: .PP
2115: As an example, the declaration
2116: .DS
2117: \fBint i, \(**ip, f(), \(**fip(), (\(**pfi)();\fR
2118: .DE
2119: .LP
2120: declares an integer
2121: \fBi\fR,
2122: a pointer
2123: .B
2124: ip
2125: .R
2126: to an integer,
2127: a function
2128: .B
2129: f
2130: .R
2131: returning an integer,
2132: a function
2133: .B
2134: fip
2135: .R
2136: returning a pointer to an integer,
2137: and a pointer
2138: .B
2139: pfi
2140: .R
2141: to a function which
2142: returns an integer.
2143: It is especially useful to compare the last two.
2144: The binding of
2145: .B
2146: \(**fip()
2147: .R
2148: is
2149: .B
2150: \(**(fip())\fR.
2151: .R
2152: The declaration suggests,
2153: and the same construction in an expression
2154: requires, the calling of a function
2155: .B
2156: fip\fR.
2157: .R
2158: Using indirection through the (pointer) result
2159: to yield an integer.
2160: In the declarator
2161: \fB(\(**pfi)()\fR,
2162: the extra parentheses are necessary, as they are also
2163: in an expression, to indicate that indirection through
2164: a pointer to a function yields a function, which is then called;
2165: it returns an integer.
2166: .PP
2167: As another example,
2168: .DS
2169: \fBfloat fa[17], \(**afp[17];\fR
2170: .DE
2171: .LP
2172: declares an array of
2173: .B
2174: float
2175: .R
2176: numbers and an array of
2177: pointers to
2178: .B
2179: float
2180: .R
2181: numbers.
2182: Finally,
2183: .DS
2184: \fBstatic int x3d[3][5][7];\fR
2185: .DE
2186: .LP
2187: declares a static 3-dimensional array of integers,
2188: with rank 3\(mu5\(mu7.
2189: In complete detail,
2190: .B
2191: x3d
2192: .R
2193: is an array of three items;
2194: each item is an array of five arrays;
2195: each of the latter arrays is an array of seven
2196: integers.
2197: Any of the expressions
2198: \fBx3d\fR,
2199: \fBx3d[i]\fR,
2200: \fBx3d[i][j]\fR,
2201: .B
2202: x3d[i][j][k]
2203: .R
2204: may reasonably appear in an expression.
2205: The first three have type ``array''
2206: and the last has type
2207: .B
2208: int\fR.
2209: .R
2210: .NH 2
2211: Structure and Union Declarations
2212: .PP
2213: A structure
2214: is an object consisting of a sequence of named members.
2215: Each member may have any type.
2216: A union is an object which may, at a given time, contain any one
2217: of several members.
2218: Structure and union specifiers have the same form.
2219: .DS
2220: \fIstruct-or-union-specifier:
2221: struct-or-union { struct-decl-list }
2222: struct-or-union identifier { struct-decl-list }
2223: struct-or-union identifier
2224: .DE
2225: .DS
2226: \fIstruct-or-union:\fB
2227: struct
2228: union\fR
2229: .DE
2230: .PP
2231: The
2232: struct-decl-list
2233: .ne 4
2234: is a sequence of declarations for the members of the structure or union:
2235: .DS
2236: \fIstruct-decl-list:
2237: struct-declaration
2238: struct-declaration struct-decl-list
2239: .DE
2240: .DS
2241: \fIstruct-declaration:
2242: type-specifier struct-declarator-list ;
2243: .DE
2244: .DS
2245: \fIstruct-declarator-list:
2246: struct-declarator
2247: struct-declarator , struct-declarator-list\fR
2248: .DE
2249: .PP
2250: In the usual case, a struct-declarator is just a declarator
2251: for a member of a structure or union.
2252: A structure member may also consist of a specified number of bits.
2253: Such a member is also called a
2254: .I
2255: field ;
2256: .R
2257: its length,
2258: a non-negative constant expression,
2259: is set off from the field name by a colon.
2260: .DS
2261: \fIstruct-declarator:
2262: declarator
2263: declarator : constant-expression
2264: : constant-expression\fR
2265: .DE
2266: .PP
2267: Within a structure, the objects declared
2268: have addresses which increase as the declarations
2269: are read left to right.
2270: Each nonfield member of a structure
2271: begins on an addressing boundary appropriate
2272: to its type;
2273: therefore, there may
2274: be unnamed holes in a structure.
2275: Field members are packed into machine integers;
2276: they do not straddle words.
2277: A field which does not fit into the space remaining in a word
2278: is put into the next word.
2279: No field may be wider than a word.
2280: .PP
2281: Fields are assigned right to left
2282: on the
2283: PDP-11
2284: and
2285: VAX-11,
2286: left to right on the 3B 20.
2287: .PP
2288: A struct-declarator with no declarator, only a colon and a width,
2289: indicates an unnamed field useful for padding to conform
2290: to externally-imposed layouts.
2291: As a special case, a field with a width of 0
2292: specifies alignment of the next field at an implementation dependant boundary.
2293: .PP
2294: The language does not restrict the types of things that
2295: are declared as fields,
2296: but implementations are not required to support any but
2297: integer fields.
2298: Moreover,
2299: even
2300: .B
2301: int
2302: .R
2303: fields may be considered to be unsigned.
2304: On the
2305: PDP-11,
2306: fields are not signed and have only integer values;
2307: on the
2308: VAX-11,
2309: fields declared with
2310: .B
2311: int
2312: .R
2313: are treated as containing a sign.
2314: For these reasons,
2315: it is strongly recommended that fields be declared as
2316: .B
2317: unsigned\fR.
2318: .R
2319: In all implementations,
2320: there are no arrays of fields,
2321: and the address-of operator
2322: .B
2323: &
2324: .R
2325: may not be applied to them, so that there are no pointers to
2326: fields.
2327: .PP
2328: A union may be thought of as a structure all of whose members
2329: begin at offset 0 and whose size is sufficient to contain
2330: any of its members.
2331: At most, one of the members can be stored in a union
2332: at any time.
2333: .PP
2334: A structure or union specifier of the second form, that is, one of
2335: .DS
2336: \fBstruct \fIidentifier { struct-decl-list \fR}
2337: \fBunion \fIidentifier { struct-decl-list \fR}
2338: .DE
2339: .LP
2340: declares the identifier to be the
2341: .I
2342: structure tag
2343: .R
2344: (or union tag)
2345: of the structure specified by the list.
2346: A subsequent declaration may then use
2347: the third form of specifier, one of
2348: .DS
2349: \fBstruct \fIidentifier\fR
2350: \fBunion \fIidentifier\fR
2351: .DE
2352: .PP
2353: Structure tags allow definition of self-referential
2354: structures. Structure tags also
2355: permit the long part of the declaration to be
2356: given once and used several times.
2357: It is illegal to declare a structure or union
2358: which contains an instance of
2359: itself, but a structure or union may contain a pointer to an instance of itself.
2360: .PP
2361: The third form of a structure or union specifier may be
2362: used prior to a declaration which gives the complete specification
2363: of the structure or union in situations in which the size
2364: of the structure or union is unnecessary.
2365: The size is unnecessary in two situations: when a
2366: pointer to a structure or union is being declared and
2367: when a \fBtypedef\fR name is declared to be a synonym
2368: for a structure or union.
2369: This, for example, allows the declaration of a pair
2370: of structures which contain pointers to each other.
2371: .PP
2372: The names of members and tags do not conflict
2373: with each other or with ordinary variables.
2374: A particular name may not be used twice
2375: in the same structure,
2376: but the same name may be used in several different structures in the same scope.
2377: .PP
2378: A simple but important example of a structure declaration is
2379: the following binary tree structure:
2380: .DS
2381: \fBstruct tnode
2382: {
2383: char tword[20];
2384: int count;
2385: struct tnode \(**left;
2386: struct tnode \(**right;
2387: };\fR
2388: .DE
2389: .LP
2390: which contains an array of 20 characters, an integer, and two pointers
2391: to similar structures.
2392: Once this declaration has been given, the
2393: declaration
2394: .DS
2395: \fBstruct tnode s, \(**sp;\fR
2396: .DE
2397: .LP
2398: declares
2399: .B
2400: s
2401: .R
2402: to be a structure of the given sort
2403: and
2404: .B
2405: sp
2406: .R
2407: to be a pointer to a structure
2408: of the given sort.
2409: With these declarations, the expression
2410: .DS
2411: \fBsp->count\fR
2412: .DE
2413: .LP
2414: refers to the
2415: .B
2416: count
2417: .R
2418: field of the structure to which
2419: .B
2420: sp
2421: .R
2422: points;
2423: .DS
2424: \fBs.left\fR
2425: .DE
2426: .LP
2427: refers to the left subtree pointer
2428: of the structure
2429: \fBs\fR;
2430: and
2431: .DS
2432: \fBs.right->tword[0]\fR
2433: .DE
2434: .LP
2435: refers to the first character of the
2436: .B
2437: tword
2438: .R
2439: member of the right subtree of
2440: .B
2441: s\fR.
2442: .R
2443: .PP
2444: .NH 2
2445: Enumeration Declarations
2446: .PP
2447: Enumeration variables and constants have integral type.
2448: .DS
2449: \fIenum-specifier:\fB
2450: enum\fI { enum-list \fR}\fB
2451: enum \fIidentifier { enum-list \fR}\fB
2452: enum \fIidentifier
2453: .sp
2454: enum-list:
2455: enumerator
2456: enum-list , enumerator
2457: .sp
2458: enumerator:
2459: identifier
2460: identifier = constant-expression\fR
2461: .DE
2462: .PP
2463: The identifiers in an enum-list are declared as constants
2464: and may appear wherever constants are required.
2465: If no enumerators with
2466: .B
2467: =
2468: .R
2469: appear, then the values of the
2470: corresponding constants begin at 0 and increase by 1 as the declaration is
2471: read from left to right.
2472: An enumerator with
2473: .B
2474: =
2475: .R
2476: gives the associated identifier the value
2477: indicated; subsequent identifiers continue the progression from the assigned value.
2478: .PP
2479: The names of enumerators in the same scope must all be distinct
2480: from each other and from those of ordinary variables.
2481: .PP
2482: The role of the identifier in the enum-specifier
2483: is entirely analogous to that of the structure tag
2484: in a struct-specifier; it names a particular enumeration.
2485: For example,
2486: .DS L
2487: \fBenum color { chartreuse, burgundy, claret=20, winedark };
2488: \&...
2489: enum color \(\(**\(**cp, col;
2490: \&...
2491: col = claret;
2492: cp = &col;
2493: \&...
2494: if (\(\(**\(**cp == burgundy) ...\fR
2495: .DE
2496: .LP
2497: makes
2498: .B
2499: color
2500: .R
2501: the enumeration-tag of a type describing various colors,
2502: and then declares
2503: .B
2504: cp
2505: .R
2506: as a pointer to an object of that type,
2507: and
2508: .B
2509: col
2510: .R
2511: as an object of that type.
2512: The possible values are drawn from the set {0,1,20,21}.
2513: .NH 2
2514: Initialization
2515: .PP
2516: A declarator may specify an initial value for the
2517: identifier being declared.
2518: The initializer is preceded by
2519: .B
2520: =
2521: .R
2522: and
2523: consists of an expression or a list of values nested in braces.
2524: .DS
2525: \fIinitializer:
2526: = expression
2527: = { initializer-list }
2528: = { initializer-list , }
2529: .DE
2530: .DS
2531: \fIinitializer-list:
2532: expression
2533: initializer-list , initializer-list\fR
2534: { \fIinitializer-list \fR}
2535: { \fIinitializer-list\fR , }
2536: .DE
2537: .PP
2538: All the expressions in an initializer
2539: for a static or external variable must be constant
2540: expressions, which are described in ``CONSTANT EXPRESSIONS'',
2541: or expressions which reduce to the address of a previously
2542: declared variable, possibly offset by a constant expression.
2543: Automatic or register variables may be initialized by arbitrary
2544: expressions involving constants and previously declared variables and functions.
2545: .PP
2546: Static and external variables that are not initialized are
2547: guaranteed to start off as zero.
2548: Automatic and register variables that are not initialized
2549: are guaranteed to start off as garbage.
2550: .PP
2551: When an initializer applies to a
2552: .I
2553: scalar
2554: .R
2555: (a pointer or an object of arithmetic type),
2556: it consists of a single expression, perhaps in braces.
2557: The initial value of the object is taken from
2558: the expression; the same conversions as for assignment are performed.
2559: .PP
2560: When the declared variable is an
2561: .I
2562: aggregate
2563: .R
2564: (a structure or array),
2565: the initializer consists of a brace-enclosed, comma-separated list of
2566: initializers for the members of the aggregate
2567: written in increasing subscript or member order.
2568: If the aggregate contains subaggregates, this rule
2569: applies recursively to the members of the aggregate.
2570: If there are fewer initializers in the list than there are members of the aggregate,
2571: then the aggregate is padded with zeros.
2572: It is not permitted to initialize unions or automatic aggregates.
2573: .PP
2574: Braces may in some cases be omitted.
2575: If the initializer begins with a left brace, then
2576: the succeeding comma-separated list of initializers initializes
2577: the members of the aggregate;
2578: it is erroneous for there to be more initializers than members.
2579: If, however, the initializer does not begin with a left brace,
2580: then only enough elements from the list are taken to account
2581: for the members of the aggregate; any remaining members
2582: are left to initialize the next member of the aggregate of which
2583: the current aggregate is a part.
2584: .PP
2585: A final abbreviation allows a
2586: .B
2587: char
2588: .R
2589: array to be initialized by a string.
2590: In this case successive characters of the string
2591: initialize the members of the array.
2592: .PP
2593: For example,
2594: .DS
2595: \fBint x[] = { 1, 3, 5 };\fR
2596: .DE
2597: .LP
2598: declares and initializes
2599: .B
2600: x
2601: .R
2602: as a one-dimensional array which has three members, since no size was specified
2603: and there are three initializers.
2604: .DS
2605: \fBfloat y[4][3] =
2606: {
2607: { 1, 3, 5 },
2608: { 2, 4, 6 },
2609: { 3, 5, 7 },
2610: };\fR
2611: .DE
2612: .LP
2613: is a completely-bracketed initialization:
2614: 1, 3, and 5 initialize the first row of
2615: the array
2616: \fBy[0]\fR,
2617: namely
2618: \fBy[0][0]\fR,
2619: \fBy[0][1]\fR,
2620: and
2621: .B
2622: y[0][2]\fR.
2623: .R
2624: Likewise, the next two lines initialize
2625: .B
2626: y[1]
2627: .R
2628: and
2629: .B
2630: y[2]\fR.
2631: .R
2632: The initializer ends early and therefore
2633: .B
2634: y[3]
2635: .R
2636: is initialized with 0.
2637: Precisely, the same effect could have been achieved by
2638: .DS
2639: \fBfloat y[4][3] =
2640: {
2641: 1, 3, 5, 2, 4, 6, 3, 5, 7
2642: };\fR
2643: .DE
2644: .PP
2645: The initializer for
2646: .B
2647: y
2648: .R
2649: begins with a left brace but that for
2650: .B
2651: y[0]
2652: .R
2653: does not;
2654: therefore, three elements from the list are used.
2655: Likewise, the next three are taken successively for
2656: .B
2657: y[1]
2658: .R
2659: and
2660: .B
2661: y[2]\fR.
2662: .R
2663: Also,
2664: .DS
2665: \fBfloat y[4][3] =
2666: {
2667: { 1 }, { 2 }, { 3 }, { 4 }
2668: };\fR
2669: .DE
2670: .LP
2671: initializes the first column of
2672: .B
2673: y
2674: .R
2675: (regarded as a two-dimensional array)
2676: and leaves the rest 0.
2677: .PP
2678: Finally,
2679: .DS
2680: \fBchar msg[] = "Syntax error on line %s\en";\fR
2681: .DE
2682: .LP
2683: shows a character array whose members are initialized
2684: with a string.
2685: .NH 2
2686: Type Names
2687: .PP
2688: In two contexts (to specify type conversions explicitly
2689: by means of a cast
2690: and as an argument of
2691: \fBsizeof\fR),
2692: it is desired to supply the name of a data type.
2693: This is accomplished using a ``type name'', which in essence
2694: is a declaration for an object of that type which omits the name of
2695: the object.
2696: .DS
2697: \fItype-name:
2698: type-specifier abstract-declarator
2699: .DE
2700: .DS
2701: \fIabstract-declarator:
2702: empty
2703: ( abstract-declarator )
2704: \(** abstract-declarator
2705: abstract-declarator ()
2706: abstract-declarator\fR\^ [ \fIconstant-expression\v'0.5'\s-2opt\s0\v'-0.5' \fR\^]
2707: .DE
2708: .PP
2709: To avoid ambiguity,
2710: in the construction
2711: .DS
2712: \fI( abstract-declarator \fR)
2713: .DE
2714: .LP
2715: the
2716: abstract-declarator
2717: is required to be nonempty.
2718: Under this restriction,
2719: it is possible to identify uniquely the location in the abstract-declarator
2720: where the identifier would appear if the construction were a declarator
2721: in a declaration.
2722: The named type is then the same as the type of the
2723: hypothetical identifier.
2724: For example,
2725: .DS
2726: \fBint
2727: int \(**
2728: int \(**[3]
2729: int (\(**)[3]
2730: int \(**()
2731: int (\(**)()
2732: int (\(**[3])()\fR
2733: .DE
2734: .LP
2735: name respectively the types ``integer,'' ``pointer to integer,''
2736: ``array of three pointers to integers,''
2737: ``pointer to an array of three integers,''
2738: ``function returning pointer to integer,''
2739: ``pointer to function returning an integer,''
2740: and ``array of three pointers to functions returning an integer.''
2741: .NH 2
2742: Typedef
2743: .PP
2744: Declarations whose ``storage class'' is
2745: .B
2746: typedef
2747: .R
2748: do not define storage but instead
2749: define identifiers which can be used later
2750: as if they were type keywords naming fundamental
2751: or derived types.
2752: .DS
2753: \fItypedef-name:\fR
2754: \fIidentifier\fR
2755: .DE
2756: .PP
2757: Within the scope of a declaration involving
2758: \fBtypedef\fR,
2759: each identifier appearing as part of
2760: any declarator therein becomes syntactically
2761: equivalent to the type keyword
2762: naming the type
2763: associated with the identifier
2764: in the way described in ``Meaning of Declarators.''
2765: For example,
2766: after
2767: .DS
2768: \fBtypedef int MILES, \(**KLICKSP;
2769: typedef struct { double re, im; } complex;\fR
2770: .DE
2771: .LP
2772: the constructions
2773: .DS
2774: \fBMILES distance;
2775: extern KLICKSP metricp;
2776: complex z, \(**zp;\fR
2777: .DE
2778: .LP
2779: are all legal declarations; the type of
2780: .B
2781: distance
2782: .R
2783: is
2784: \fBint\fR,
2785: that of
2786: .B
2787: metricp
2788: .R
2789: is ``pointer to \fBint\fR, ''
2790: and that of
2791: .B
2792: z
2793: .R
2794: is the specified structure.
2795: The
2796: .B
2797: zp
2798: .R
2799: is a pointer to such a structure.
2800: .PP
2801: The
2802: .B
2803: typedef
2804: .R
2805: does not introduce brand-new types, only synonyms for
2806: types which could be specified in another way.
2807: Thus
2808: in the example above
2809: .B
2810: distance
2811: .R
2812: is considered to have exactly the same type as
2813: any other
2814: .B
2815: int
2816: .R
2817: object.
2818: .NH 1
2819: Statements
2820: .PP
2821: Except as indicated, statements are executed in sequence.
2822: .NH 2
2823: Expression Statement
2824: .PP
2825: Most statements are expression statements, which have
2826: the form
2827: .DS
2828: \fIexpression \fR;
2829: .DE
2830: .PP
2831: Usually expression statements are assignments or function
2832: calls.
2833: .NH 2
2834: Compound Statement or Block
2835: .PP
2836: So that several statements can be used where one is expected,
2837: the compound statement (also, and equivalently, called ``block'') is provided:
2838: .DS
2839: \fIcompound-statement:
2840: { declaration-list\v'0.5'\s-2opt\s0\v'-0.5' statement-list\v'0.5'\s-2opt\s0\v'-0.5' }
2841: .DE
2842: .DS
2843: \fIdeclaration-list:
2844: declaration
2845: declaration declaration-list
2846: .DE
2847: .DS
2848: \fIstatement-list:
2849: statement
2850: statement statement-list\fR
2851: .DE
2852: .PP
2853: If any of the identifiers
2854: in the declaration-list were previously declared,
2855: the outer declaration is pushed down for the duration of the block,
2856: after which it resumes its force.
2857: .PP
2858: Any initializations of
2859: .B
2860: auto
2861: .R
2862: or
2863: .B
2864: register
2865: .R
2866: variables are performed each time the block is entered at the top.
2867: It is currently possible
2868: (but a bad practice)
2869: to transfer into a block;
2870: in that case the initializations are not performed.
2871: Initializations of
2872: .B
2873: static
2874: .R
2875: variables are performed only once when the program
2876: begins execution.
2877: Inside a block,
2878: .B
2879: extern
2880: .R
2881: declarations do not reserve storage
2882: so initialization is not permitted.
2883: .NH 2
2884: Conditional Statement
2885: .PP
2886: The two forms of the conditional statement are
2887: .DS
2888: \fBif\fR\^ ( \fIexpression\fR\^ ) \fIstatement\fR\^
2889: \fBif\fR\^ ( \fIexpression\fR\^ ) \fIstatement \fBelse \fIstatement\fR\^
2890: .DE
2891: .PP
2892: In both cases, the expression is evaluated;
2893: and if it is nonzero, the first substatement
2894: is executed.
2895: In the second case, the second substatement is executed
2896: if the expression is 0.
2897: The ``else'' ambiguity is resolved by connecting
2898: an
2899: .B
2900: else
2901: .R
2902: with the last encountered
2903: \fBelse\fR-less
2904: .B
2905: if\fR.
2906: .R
2907: .NH 2
2908: While Statement
2909: .PP
2910: The
2911: .B
2912: while
2913: .R
2914: statement has the form
2915: .DS
2916: \fBwhile\fR\^ ( \fIexpression\fR\^ ) \fIstatement\fR\^
2917: .DE
2918: .PP
2919: The substatement is executed repeatedly
2920: so long as the value of the
2921: expression remains nonzero.
2922: The test takes place before each execution of the
2923: statement.
2924: .NH 2
2925: Do Statement
2926: .PP
2927: The
2928: .B
2929: do
2930: .R
2931: statement has the form
2932: .DS
2933: \fBdo \fIstatement \fBwhile\fR\^ ( \fIexpression \fR\^) ;
2934: .DE
2935: .PP
2936: The substatement is executed repeatedly until
2937: the value of the expression becomes 0.
2938: The test takes place after each execution of the
2939: statement.
2940: .NH 2
2941: For Statement
2942: .PP
2943: The
2944: .B
2945: for
2946: .R
2947: statement has the form:
2948: .DS
2949: \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
2950: .DE
2951: .PP
2952: .sp
2953: Except for the behavior of \fBcontinue\fR,
2954: this statement is equivalent to
2955: .DS
2956: \fIexp-1 \fR;
2957: \fBwhile\fR\^ ( \fIexp-2\ ) \fR\^
2958: {
2959: \fIstatement
2960: exp-3 ;\fR
2961: }
2962: .DE
2963: .PP
2964: Thus the first expression specifies initialization
2965: for the loop; the second specifies
2966: a test, made before each iteration, such
2967: that the loop is exited when the expression becomes
2968: 0.
2969: The third expression often specifies an incrementing
2970: that is performed after each iteration.
2971: .PP
2972: Any or all of the expressions may be dropped.
2973: A missing
2974: .I
2975: exp-2
2976: .R
2977: makes the
2978: implied
2979: .B
2980: while
2981: .R
2982: clause equivalent to
2983: \fBwhile(1)\fR;
2984: other missing expressions are simply
2985: dropped from the expansion above.
2986: .NH 2
2987: Switch Statement
2988: .PP
2989: The
2990: .B
2991: switch
2992: .R
2993: statement causes control to be transferred
2994: to one of several statements depending on
2995: the value of an expression.
2996: It has the form
2997: .DS
2998: \fBswitch\fR\^ ( \fIexpression\fR\^ ) \fIstatement\fR\^
2999: .DE
3000: .PP
3001: The usual arithmetic conversion is performed on the
3002: expression, but the result must be
3003: .B
3004: int\fR.
3005: .R
3006: The statement is typically compound.
3007: Any statement within the statement
3008: may be labeled with one or more case prefixes
3009: as follows:
3010: .DS
3011: \fBcase \fIconstant-expression \fR:
3012: .DE
3013: .LP
3014: where the constant
3015: expression
3016: must be
3017: .B
3018: int\fR.
3019: .R
3020: No two of the case constants in the same switch
3021: may have the same value.
3022: Constant expressions are precisely defined in ``CONSTANT EXPRESSIONS.''
3023: .PP
3024: There may also be at most one statement prefix of the
3025: form
3026: .DS
3027: \fBdefault :\fR
3028: .DE
3029: .PP
3030: When the
3031: .B
3032: switch
3033: .R
3034: statement is executed, its expression
3035: is evaluated and compared with each case constant.
3036: If one of the case constants is
3037: equal to the value of the expression,
3038: control is passed to the statement
3039: following the matched case prefix.
3040: If no case constant matches the expression
3041: and if there is a
3042: \fBdefault\fR,
3043: prefix, control
3044: passes to the prefixed
3045: statement.
3046: If no case matches and if there is no
3047: \fBdefault\fR,
3048: then
3049: none of the statements in the
3050: switch is executed.
3051: .PP
3052: The prefixes
3053: .B
3054: case
3055: .R
3056: and
3057: .B
3058: default
3059: .R
3060: do not alter the flow of control,
3061: which continues unimpeded across such prefixes.
3062: To exit from a switch, see
3063: ``Break Statement.''
3064: .PP
3065: Usually, the statement that is the subject of a switch is compound.
3066: Declarations may appear at the head of this
3067: statement,
3068: but
3069: initializations of automatic or register variables
3070: are ineffective.
3071: .NH 2
3072: Break Statement
3073: .PP
3074: The statement
3075: .DS
3076: \fBbreak ;\fR
3077: .DE
3078: .LP
3079: causes termination of the smallest enclosing
3080: \fBwhile\fR,
3081: \fBdo\fR,
3082: \fBfor\fR,
3083: or
3084: \fBswitch\fR
3085: statement;
3086: control passes to the
3087: statement following the terminated statement.
3088: .NH 2
3089: Continue Statement
3090: .PP
3091: The statement
3092: .DS
3093: \fBcontinue ;\fR
3094: .DE
3095: .LP
3096: causes control to pass to the loop-continuation portion of the
3097: smallest enclosing
3098: \fBwhile\fR,
3099: \fBdo\fR,
3100: or
3101: \fBfor\fR
3102: statement; that is to the end of the loop.
3103: More precisely, in each of the statements
3104: .DS
3105: .TS
3106: lw(2i) lw(2i) lw(2i).
3107: \fBwhile (\|.\|.\|.\|) { do { for (\|.\|.\|.\|) {\fR
3108: \fIstatement ; statement ; statement ;\fR
3109: \fBcontin: ; contin: ; contin: ;
3110: } } while (...); }\fR
3111: .TE
3112: .DE
3113: .LP
3114: a
3115: .B
3116: continue
3117: .R
3118: is equivalent to
3119: .B
3120: goto\ contin\fR.
3121: .R
3122: (Following the
3123: .B
3124: contin:
3125: .R
3126: is a null statement, see ``Null Statement''.)
3127: .NH 2
3128: Return Statement
3129: .PP
3130: A function returns to its caller by means of
3131: the
3132: .B
3133: return
3134: .R
3135: statement which has one of the
3136: forms
3137: .DS
3138: \fBreturn ;
3139: return \fIexpression \fR;
3140: .DE
3141: .PP
3142: In the first case, the returned value is undefined.
3143: In the second case, the value of the expression
3144: is returned to the caller
3145: of the function.
3146: If required, the expression is converted,
3147: as if by assignment, to the type of
3148: function in which it appears.
3149: Flowing off the end of a function is
3150: equivalent to a return with no returned value.
3151: The expression may be parenthesized.
3152: .NH 2
3153: Goto Statement
3154: .PP
3155: Control may be transferred unconditionally by means of
3156: the statement
3157: .DS
3158: \fBgoto \fIidentifier \fR;
3159: .DE
3160: .PP
3161: The identifier must be a label
3162: (see ``Labeled Statement'')
3163: located in the current function.
3164: .NH 2
3165: Labeled Statement
3166: .PP
3167: Any statement may be preceded by
3168: label prefixes of the form
3169: .DS
3170: \fIidentifier \fR:
3171: .DE
3172: .LP
3173: which serve to declare the identifier
3174: as a label.
3175: The only use of a label is as a target of a
3176: .B
3177: goto\fR.
3178: .R
3179: The scope of a label is the current function,
3180: excluding any subblocks in which the same identifier has been redeclared.
3181: See ``SCOPE RULES.''
3182: .NH 2
3183: Null Statement
3184: .PP
3185: The null statement has the form
3186: .DS
3187: \fB;\fR
3188: .DE
3189: .PP
3190: A null statement is useful to carry a label just before the
3191: .B
3192: }
3193: .R
3194: of a compound statement or to supply a null
3195: body to a looping statement such as
3196: .B
3197: while\fR.
3198: .R
3199: .NH 1
3200: External Definitions
3201: .PP
3202: A C program consists of a sequence of external definitions.
3203: An external definition declares an identifier to
3204: have storage class
3205: .B
3206: extern
3207: .R
3208: (by default)
3209: or perhaps
3210: \fBstatic\fR,
3211: and
3212: a specified type.
3213: The type-specifier (see ``Type Specifiers'' in
3214: ``DECLARATIONS'') may also be empty, in which
3215: case the type is taken to be
3216: .B
3217: int\fR.
3218: .R
3219: The scope of external definitions persists to the end
3220: of the file in which they are declared just as the effect
3221: of declarations persists to the end of a block.
3222: The syntax of external definitions is the same
3223: as that of all declarations except that
3224: only at this level may the code for functions be given.
3225: .NH 2
3226: External Function Definitions
3227: .PP
3228: Function definitions have the form
3229: .DS
3230: \fIfunction-definition:
3231: decl-specifiers\v'0.5'\s-2opt\s0\v'-0.5' function-declarator function-body\fR
3232: .DE
3233: .PP
3234: The only sc-specifiers
3235: allowed
3236: among the decl-specifiers
3237: are
3238: .B
3239: extern
3240: .R
3241: or
3242: \fBstatic\fR;
3243: see ``Scope of Externals'' in
3244: ``SCOPE RULES'' for the distinction between them.
3245: A function declarator is similar to a declarator
3246: for a ``function returning .\|.\|.\|'' except that
3247: it lists the formal parameters of
3248: the function being defined.
3249: .DS
3250: \fIfunction-declarator:
3251: declarator ( parameter-list\v'0.5'\s-2opt\s0\v'-0.5' )
3252: .DE
3253: .DS
3254: \fIparameter-list:
3255: identifier
3256: identifier , parameter-list\fR
3257: .DE
3258: .PP
3259: The function-body
3260: has the form
3261: .DS
3262: \fIfunction-body:
3263: declaration-list\v'0.5'\s-2opt\s0\v'-0.5' compound-statement\fR
3264: .DE
3265: .PP
3266: The identifiers in the parameter list, and only those identifiers,
3267: may be declared in the declaration list.
3268: Any identifiers whose type is not given are taken to be
3269: .B
3270: int\fR.
3271: .R
3272: The only storage class which may be specified is
3273: \fBregister\fR;
3274: if it is specified, the corresponding actual parameter
3275: will be copied, if possible, into a register
3276: at the outset of the function.
3277: .PP
3278: A simple example of a complete function definition is
3279: .DS
3280: \fBint max(a, b, c)
3281: int a, b, c;
3282: {
3283: int m;
3284: .sp
3285: m = (a > b) ? a : b;
3286: return((m > c) ? m : c);
3287: }\fR
3288: .DE
3289: .PP
3290: Here
3291: .B
3292: int
3293: .R
3294: is the type-specifier;
3295: .B
3296: max(a,\ b,\ c)
3297: .R
3298: is the function-declarator;
3299: .B
3300: int\ a,\ b,\ c;
3301: .R
3302: is the declaration-list for
3303: the formal
3304: parameters;
3305: \fB{\ ...\ }\fR
3306: is the
3307: block giving the code for the statement.
3308: .PP
3309: The C program converts all
3310: .B
3311: float
3312: .R
3313: actual parameters
3314: to
3315: \fBdouble\fR,
3316: so formal parameters declared
3317: .B
3318: float
3319: .R
3320: have their declaration adjusted to read
3321: .B
3322: double\fR.
3323: .R
3324: All \fBchar\fR and \fBshort\fR formal parameter
3325: declarations are similarly adjusted
3326: to read \fBint\fR.
3327: Also, since a reference to an array in any context
3328: (in particular as an actual parameter)
3329: is taken to mean
3330: a pointer to the first element of the array,
3331: declarations of formal parameters declared ``array of .\|.\|.\|''
3332: are adjusted to read ``pointer to .\|.\|.\|.''
3333: .NH 2
3334: External Data Definitions
3335: .PP
3336: An external data definition has the form
3337: .DS
3338: \fIdata-definition:
3339: declaration\fR
3340: .DE
3341: .PP
3342: The storage class of such data may be
3343: .B
3344: extern
3345: .R
3346: (which is the default)
3347: or
3348: .B
3349: static
3350: .R
3351: but not
3352: .B
3353: auto
3354: .R
3355: or
3356: \fBregister\fR.
3357: .NH 1
3358: Scope Rules
3359: .PP
3360: A C program need not all
3361: be compiled at the same time. The source text of the
3362: program
3363: may be kept in several files, and precompiled
3364: routines may be loaded from
3365: libraries.
3366: Communication among the functions of a program
3367: may be carried out both through explicit calls
3368: and through manipulation of external data.
3369: .PP
3370: Therefore, there are two kinds of scopes to consider:
3371: first, what may be called the
3372: .UL lexical
3373: .UL scope
3374: of an identifier, which is essentially the
3375: region of a program during which it may
3376: be used without drawing ``undefined identifier''
3377: diagnostics;
3378: and second, the scope
3379: associated with external identifiers,
3380: which is characterized by the rule
3381: that references to the same external
3382: identifier are references to the same object.
3383: .NH 2
3384: Lexical Scope
3385: .PP
3386: The lexical scope of identifiers declared in external definitions
3387: persists from the definition through
3388: the end of the source file
3389: in which they appear.
3390: The lexical scope of identifiers which are formal parameters
3391: persists through the function with which they are
3392: associated.
3393: The lexical scope of identifiers declared at the head of a block
3394: persists until the end of the block.
3395: The lexical scope of labels is the whole of the
3396: function in which they appear.
3397: .PP
3398: In all cases, however,
3399: if an identifier is explicitly declared at the head of a block,
3400: including the block constituting a function,
3401: any declaration of that identifier outside the block
3402: is suspended until the end of the block.
3403: .PP
3404: Remember also (see ``Structure, Union, and Enumeration Declarations'' in
3405: ``DECLARATIONS'') that tags, identifiers associated with
3406: ordinary variables,
3407: and identities associated with structure and union members
3408: form three disjoint classes
3409: which do not conflict.
3410: Members and tags follow the same scope rules
3411: as other identifiers.
3412: The \fBenum\fR constants are in the same
3413: class as ordinary variables and follow the same scope rules.
3414: The
3415: .B
3416: typedef
3417: .R
3418: names are in the same class as ordinary identifiers.
3419: They may be redeclared in inner blocks, but an explicit
3420: type must be given in the inner declaration:
3421: .DS
3422: \fBtypedef float distance;
3423: \&...
3424: {
3425: auto int distance;
3426: ...\fR
3427: }
3428: .DE
3429: .PP
3430: The
3431: .B
3432: int
3433: .R
3434: must be present in the second declaration,
3435: or it would be taken to be
3436: a declaration with no declarators and type
3437: .B
3438: distance\fR.
3439: .R
3440: .NH 2
3441: Scope of Externals
3442: .PP
3443: If a function refers to an identifier declared to be
3444: \fBextern\fR,
3445: then somewhere among the files or libraries
3446: constituting the complete program
3447: there must be at least one external definition
3448: for the identifier.
3449: All functions in a given program which refer to the same
3450: external identifier refer to the same object,
3451: so care must be taken that the type and size
3452: specified in the definition
3453: are compatible with those specified
3454: by each function which references the data.
3455: .PP
3456: It is illegal to explicitly initialize any external
3457: identifier more than once in the set of files and libraries
3458: comprising a multi-file program.
3459: It is legal to have more than one data definition
3460: for any external non-function identifier;
3461: explicit use of \fBextern\fR does not
3462: change the meaning of an external declaration.
3463: .PP
3464: In restricted environments, the use of the \fBextern\fR
3465: storage class takes on an additional meaning.
3466: In these environments, the explicit appearance of the
3467: \fBextern\fR keyword in external data declarations of
3468: identities without initialization indicates that
3469: the storage for the identifiers is allocated elsewhere,
3470: either in this file or another file.
3471: It is required that there be exactly one definition of
3472: each external identifier (without \fBextern\fR)
3473: in the set of files and libraries
3474: comprising a mult-file program.
3475: .PP
3476: Identifiers declared
3477: .B
3478: static
3479: .R
3480: at the top level in external definitions
3481: are not visible in other files.
3482: Functions may be declared
3483: .B
3484: static\fR.
3485: .R
3486: .nr Hu 1
3487: .NH 1
3488: Compiler Control Lines
3489: .PP
3490: The C compiler contains a preprocessor capable
3491: of macro substitution, conditional compilation,
3492: and inclusion of named files.
3493: Lines beginning with
3494: .B
3495: #
3496: .R
3497: communicate
3498: with this preprocessor.
3499: There may be any number of blanks and horizontal tabs
3500: between the \fB#\fR and the directive.
3501: These lines have syntax independent of the rest of the language;
3502: they may appear anywhere and have effect which lasts (independent of
3503: scope) until the end of the source program file.
3504: .nr Hu 1
3505: .NH 2
3506: Token Replacement
3507: .PP
3508: A compiler-control line of the form
3509: .DS
3510: \fB#define \fIidentifier token-string\v'0.5'\s-2opt\s0\v'-0.5'\fR
3511: .DE
3512: .LP
3513: causes the preprocessor to replace subsequent instances
3514: of the identifier with the given string of tokens.
3515: Semicolons in or at the end of the token-string are part of that string.
3516: A line of the form
3517: .DS
3518: \fB#define \fIidentifier(identifier, ... )token-string\v'0.5'\s-2opt\s0\v'-0.5'\fR
3519: .DE
3520: .LP
3521: where there is no space between the first identifier
3522: and the
3523: \fB(\fR,
3524: is a macro definition with arguments.
3525: There may be zero or more formal parameters.
3526: Subsequent instances of the first identifier followed
3527: by a
3528: \fB(\fR,
3529: a sequence of tokens delimited by commas, and a
3530: \fB)\fR
3531: are replaced
3532: by the token string in the definition.
3533: Each occurrence of an identifier mentioned in the formal parameter list
3534: of the definition is replaced by the corresponding token string from the call.
3535: The actual arguments in the call are token strings separated by commas;
3536: however, commas in quoted strings or protected by
3537: parentheses do not separate arguments.
3538: The number of formal and actual parameters must be the same.
3539: Strings and character constants in the token-string are scanned
3540: for formal parameters, but
3541: strings and character constants in the rest of the program are
3542: not scanned for defined identifiers
3543: to replacement.
3544: .PP
3545: In both forms the replacement string is rescanned for more
3546: defined identifiers.
3547: In both forms
3548: a long definition may be continued on another line
3549: by writing
3550: .B
3551: \e
3552: .R
3553: at the end of the line to be continued.
3554: .PP
3555: This facility is most valuable for definition of ``manifest constants,''
3556: as in
3557: .DS
3558: \fB#define TABSIZE 100
3559: .sp
3560: int table\|[\|TABSIZE\|]\|;\fR
3561: .DE
3562: .PP
3563: A control line of the form
3564: .DS
3565: \fB#undef \fIidentifier\fR
3566: .DE
3567: .LP
3568: causes the
3569: identifier's preprocessor definition (if any) to be forgotten.
3570: .PP
3571: If a \fB#define\fRd identifier is the subject of a subsequent
3572: \fB#define\fR with no intervening \fB#undef\fR, then
3573: the two token-strings are compared textually.
3574: If the two token-strings are not identical
3575: (all white space is considered as equivalent), then
3576: the identifier is considered to be redefined.
3577: .nr Hu 1
3578: .NH 2
3579: File Inclusion
3580: .PP
3581: A compiler control line of
3582: the form
3583: .DS
3584: \fB#include\fI "filename\|\fR"
3585: .DE
3586: .LP
3587: causes the replacement of that
3588: line by the entire contents of the file
3589: .I
3590: filename\fR.
3591: .R
3592: The named file is searched for first in the directory
3593: of the file containing the \fB#include\fR,
3594: and then in a sequence of specified or standard places.
3595: Alternatively, a control line of the form
3596: .DS
3597: \fB#include\fI <filename\|\fR>
3598: .DE
3599: .LP
3600: searches only the specified or standard places
3601: and not the directory of the \fB#include\fR.
3602: (How the places are specified is not part of the language.)
3603: .PP
3604: \fB#include\fRs
3605: may be nested.
3606: .nr Hu 1
3607: .NH 2
3608: Conditional Compilation
3609: .PP
3610: A compiler control line of the form
3611: .DS
3612: \fB#if \fIrestricted-constant-expression\fR
3613: .DE
3614: .LP
3615: checks whether the restricted-constant expression evaluates to nonzero.
3616: (Constant expressions are discussed in ``CONSTANT EXPRESSIONS'';
3617: the following additional restrictions apply here:
3618: the constant expression may not contain
3619: .B
3620: sizeof
3621: .R
3622: casts, or an enumeration constant.)
3623: .PP
3624: A restricted constant expression may also contain the
3625: additional unary expression
3626: .PP
3627: \fBdefined \fIidentifier\fR
3628: .LP
3629: or
3630: .PP
3631: \fBdefined( \fIidentifier )\fR
3632: .LP
3633: which evaluates to one if the identifier is currently
3634: defined in the preprocessor and zero if it is not.
3635: .PP
3636: All currently defined identifiers in restricted-constant-expressions
3637: are replaced by their token-strings (except those identifiers
3638: modified by \fBdefined\fR) just as in normal text.
3639: The restricted constant expression will be evaluated only
3640: after all expressions have finished.
3641: During this evaluation, all undefined (to the procedure)
3642: identifiers evaluate to zero.
3643: .PP
3644: A control line of the form
3645: .DS
3646: \fB#ifdef \fIidentifier\fR
3647: .DE
3648: .LP
3649: checks whether the identifier is currently defined
3650: in the preprocessor; i.e., whether it has been the
3651: subject of a
3652: .B
3653: #define
3654: .R
3655: control line.
3656: It is equivalent to \fB#ifdef(\fIidentifier\fB)\fR.
3657: A control line of the form
3658: .DS
3659: \fB#ifndef \fIidentifier\fR
3660: .DE
3661: .LP
3662: checks whether the identifier is currently undefined
3663: in the preprocessor.
3664: It is equivalent to
3665: .DS
3666: \fB#if !\|defined(\fIidentifier\fB)\fR.
3667: .DE
3668: .PP
3669: All three forms are followed by an arbitrary number of lines,
3670: possibly containing a control line
3671: .DS
3672: \fB#else\fR
3673: .DE
3674: .LP
3675: and then by a control line
3676: .DS
3677: \fB#endif\fR
3678: .DE
3679: .PP
3680: If the checked condition is true,
3681: then any lines
3682: between
3683: .B
3684: #else
3685: .R
3686: and
3687: .B
3688: #endif
3689: .R
3690: are ignored.
3691: If the checked condition is false, then any lines between
3692: the test and a
3693: .B
3694: #else
3695: .R
3696: or, lacking a
3697: \fB#else\fR,
3698: the
3699: .B
3700: #endif
3701: .R
3702: are ignored.
3703: .PP
3704: These constructions may be nested.
3705: .nr Hu 1
3706: .NH 2
3707: Line Control
3708: .PP
3709: For the benefit of other preprocessors which generate C programs,
3710: a line of the form
3711: .DS
3712: \fB#line \fIconstant "filename\fR"
3713: .DE
3714: .LP
3715: causes the compiler to believe, for purposes of error
3716: diagnostics,
3717: that the line number of the next source line is given by the constant and the current input
3718: file is named by "\fIfilename\fR".
3719: If "\fIfilename\fR" is absent, the remembered file name does not change.
3720: .nr Hu 1
3721: .NH 1
3722: Implicit Declarations
3723: .PP
3724: It is not always necessary to specify
3725: both the storage class and the type
3726: of identifiers in a declaration.
3727: The storage class is supplied by
3728: the context in external definitions
3729: and in declarations of formal parameters
3730: and structure members.
3731: In a declaration inside a function,
3732: if a storage class but no type
3733: is given, the identifier is assumed
3734: to be
3735: \fBint\fR;
3736: if a type but no storage class is indicated,
3737: the identifier is assumed to
3738: be
3739: .B
3740: auto\fR.
3741: .R
3742: An exception to the latter rule is made for
3743: functions because
3744: .B
3745: auto
3746: .R
3747: functions do not exist.
3748: If the type of an identifier is ``function returning .\|.\|.\|,''
3749: it is implicitly declared to be
3750: .B
3751: extern\fR.
3752: .R
3753: .PP
3754: In an expression, an identifier
3755: followed by
3756: .B
3757: (
3758: .R
3759: and not already declared
3760: is contextually
3761: declared to be ``function returning
3762: .B
3763: int\fR.''
3764: .nr Hu 1
3765: .NH 1
3766: Types Revisited
3767: .PP
3768: This part summarizes the operations
3769: which can be performed on objects of certain types.
3770: .nr Hu 1
3771: .NH 2
3772: Structures and Unions
3773: .PP
3774: Structures and unions may be assigned, passed as arguments to functions,
3775: and returned by functions.
3776: Other plausible operators, such as equality comparison
3777: and structure casts,
3778: are not implemented.
3779: .PP
3780: In a reference
3781: to a structure or union member, the
3782: name on the right
3783: of the \fB->\fR or the \fB.\fR
3784: must specify a member of the aggregate
3785: named or pointed to by the expression
3786: on the left.
3787: In general, a member of a union may not be inspected
3788: unless the value of the union has been assigned using that same member.
3789: However, one special guarantee is made by the language in order
3790: to simplify the use of unions:
3791: if a union contains several structures that share a common initial sequence
3792: and if the union currently contains one of these structures,
3793: it is permitted to inspect the common initial part of any of
3794: the contained structures.
3795: For example, the following is a legal fragment:
3796: .DS
3797: \fBunion
3798: {
3799: struct
3800: {
3801: int type;
3802: } n;
3803: struct
3804: {
3805: int type;
3806: int intnode;
3807: } ni;
3808: struct
3809: {
3810: int type;
3811: float floatnode;
3812: } nf;
3813: } u;
3814: \&...
3815: u.nf.type = FLOAT;
3816: u.nf.floatnode = 3.14;
3817: \&...
3818: if (u.n.type == FLOAT)
3819: ... sin(u.nf.floatnode) ...\fR
3820: .DE
3821: .PP
3822: .nr Hu 1
3823: .NH 2
3824: Functions
3825: .PP
3826: There are only two things that
3827: can be done with a function \fBm\fR,
3828: call it or take its address.
3829: If the name of a function appears in an
3830: expression not in the function-name position of a call,
3831: a pointer to the function is generated.
3832: Thus, to pass one function to another, one
3833: might say
3834: .DS
3835: \fBint f();
3836: \&...
3837: g(f);\fR
3838: .DE
3839: .PP
3840: .ne 8
3841: Then the definition of
3842: .B
3843: g
3844: .R
3845: might read
3846: .DS
3847: \fBg(funcp)
3848: int (\(**funcp)();
3849: {
3850: ...
3851: (\(**funcp)();
3852: ...
3853: }\fR
3854: .DE
3855: .PP
3856: Notice that
3857: .B
3858: f
3859: .R
3860: must be declared
3861: explicitly in the calling routine since its appearance
3862: in
3863: .B
3864: g(f)
3865: .R
3866: was not followed by
3867: .B
3868: (.
3869: .R
3870: .nr Hu 1
3871: .NH 2
3872: Arrays, Pointers, and Subscripting
3873: .PP
3874: Every time an identifier of array type appears
3875: in an expression, it is converted into a pointer
3876: to the first member of the array.
3877: Because of this conversion, arrays are not
3878: lvalues.
3879: By definition, the subscript operator
3880: .B
3881: []
3882: .R
3883: is interpreted
3884: in such a way that
3885: .B
3886: E1[E2]
3887: .R
3888: is identical to
3889: .B
3890: \(**((E1)\(plE2))\fR.
3891: .R
3892: Because of the conversion rules
3893: which apply to
3894: \fB\(pl\fR,
3895: if
3896: .B
3897: E1
3898: .R
3899: is an array and
3900: .B
3901: E2
3902: .R
3903: an integer,
3904: then
3905: .B
3906: E1[E2]
3907: .R
3908: refers to the
3909: .B
3910: E2-th
3911: .R
3912: member of
3913: .B
3914: E1\fR.
3915: .R
3916: Therefore,
3917: despite its asymmetric
3918: appearance, subscripting is a commutative operation.
3919: .PP
3920: A consistent rule is followed in the case of
3921: multidimensional arrays.
3922: If
3923: .B
3924: E
3925: .R
3926: is an
3927: \fIn\fR-dimensional
3928: array
3929: of rank
3930: i\(muj\(mu...\(muk,
3931: then
3932: .B
3933: E
3934: .R
3935: appearing in an expression is converted to
3936: a pointer to an (n-1)-dimensional
3937: array with rank
3938: j\(mu...\(muk.
3939: If the
3940: .B
3941: \(**
3942: .R
3943: operator, either explicitly
3944: or implicitly as a result of subscripting,
3945: is applied to this pointer,
3946: the result is the pointed-to (n-1)-dimensional array,
3947: which itself is immediately converted into a pointer.
3948: .PP
3949: For example, consider
3950: .DS
3951: \fBint x[3][5];\fR
3952: .DE
3953: .PP
3954: Here
3955: .B
3956: x
3957: .R
3958: is a 3\(mu5 array of integers.
3959: When
3960: .B
3961: x
3962: .R
3963: appears in an expression, it is converted
3964: to a pointer to (the first of three) 5-membered arrays of integers.
3965: In the expression
3966: \fBx[i]\fR,
3967: which is equivalent to
3968: \fB\(**(x\(pli)\fR,
3969: .B
3970: x
3971: .R
3972: is first converted to a pointer as described;
3973: then
3974: .B
3975: i
3976: .R
3977: is converted to the type of
3978: \fBx\fR,
3979: which involves multiplying
3980: .B
3981: i
3982: .R
3983: by the
3984: length the object to which the pointer points,
3985: namely 5-integer objects.
3986: The results are added and indirection applied to
3987: yield an array (of five integers) which in turn is converted to
3988: a pointer to the first of the integers.
3989: If there is another subscript, the same argument applies
3990: again; this time the result is an integer.
3991: .PP
3992: Arrays in C are stored
3993: row-wise (last subscript varies fastest)
3994: and the first subscript in the declaration helps determine
3995: the amount of storage consumed by an array.
3996: Arrays play no other part in subscript calculations.
3997: .nr Hu 1
3998: .NH 2
3999: Explicit Pointer Conversions
4000: .PP
4001: Certain conversions involving pointers are permitted
4002: but have implementation-dependent aspects.
4003: They are all specified by means of an explicit type-conversion
4004: operator, see ``Unary Operators'' under``EXPRESSIONS'' and
4005: ``Type Names''under ``DECLARATIONS.''
4006: .PP
4007: A pointer may be converted to any of the integral types large
4008: enough to hold it.
4009: Whether an
4010: .B
4011: int
4012: .R
4013: or
4014: .B
4015: long
4016: .R
4017: is required is machine dependent.
4018: The mapping function is also machine dependent but is intended
4019: to be unsurprising to those who know the addressing structure
4020: of the machine.
4021: Details for some particular machines are given below.
4022: .PP
4023: An object of integral type may be explicitly converted to a pointer.
4024: The mapping always carries an integer converted from a pointer back to the same pointer
4025: but is otherwise machine dependent.
4026: .PP
4027: A pointer to one type may be converted to a pointer to another type.
4028: The resulting pointer may cause addressing exceptions
4029: upon use if
4030: the subject pointer does not refer to an object suitably aligned in storage.
4031: It is guaranteed that
4032: a pointer to an object of a given size may be converted to a pointer to an object
4033: of a smaller size
4034: and back again without change.
4035: .PP
4036: For example,
4037: a storage-allocation routine
4038: might accept a size (in bytes)
4039: of an object to allocate, and return a
4040: .B
4041: char
4042: .R
4043: pointer;
4044: it might be used in this way.
4045: .DS
4046: \fBextern char \(**malloc();
4047: double \(**dp;
4048: .sp
4049: dp = (double \(**) malloc(sizeof(double));
4050: \(**dp = 22.0 / 7.0;\fR
4051: .DE
4052: .PP
4053: The
4054: .B
4055: alloc
4056: .R
4057: must ensure (in a machine-dependent way)
4058: that its return value is suitable for conversion to a pointer to
4059: \fBdouble\fR;
4060: then the
4061: .I
4062: use
4063: .R
4064: of the function is portable.
4065: .PP
4066: The pointer
4067: representation on the
4068: PDP-11
4069: corresponds to a 16-bit integer and
4070: measures bytes.
4071: The
4072: .B
4073: char\fR's
4074: have no alignment requirements; everything else must have an even address.
4075: .PP
4076: On the
4077: VAX-11,
4078: pointers are 32 bits long and measure bytes.
4079: Elementary objects are aligned on a boundary equal to their
4080: length, except that
4081: .B
4082: double
4083: .R
4084: quantities need be aligned only on even 4-byte boundaries.
4085: Aggregates are aligned on the strictest boundary required by
4086: any of their constituents.
4087: .PP
4088: The 3B 20 computer has 24-bit pointers placed into 32-bit quantities.
4089: Most objects are
4090: aligned on 4-byte boundaries. \fBShort\fRs are aligned in all cases on
4091: 2-byte boundaries. Arrays of characters, all structures,
4092: \fBint\fR\^s, \fBlong\fR\^s, \fBfloat\fR\^s, and \fBdouble\fR\^s are aligned on 4-byte
4093: boundries; but structure members may be packed tighter.
4094: .nr Hu 1
4095: .NH 2
4096: CONSTANT EXPRESSIONS
4097: .PP
4098: In several places C requires expressions that evaluate to
4099: a constant:
4100: after
4101: \fBcase\fR,
4102: as array bounds, and in initializers.
4103: In the first two cases, the expression can
4104: involve only integer constants, character constants,
4105: casts to integral types,
4106: enumeration constants,
4107: and
4108: .B
4109: sizeof
4110: .R
4111: expressions, possibly
4112: connected by the binary operators
4113: .ne 10
4114: .DS
4115: \(pl \(mi \(** / % & | ^ << >> == != < > <= >= && ||
4116: .DE
4117: .LP
4118: or by the unary operators
4119: .DS
4120: \(mi \s+2~\s0
4121: .DE
4122: .LP
4123: or by the ternary operator
4124: .DS
4125: ?:
4126: .DE
4127: .PP
4128: Parentheses can be used for grouping
4129: but not for function calls.
4130: .PP
4131: More latitude is permitted for initializers;
4132: besides constant expressions as discussed above,
4133: one can also use floating constants
4134: and arbitrary casts and
4135: can also apply the unary
4136: .B
4137: &
4138: .R
4139: operator to external or static objects
4140: and to external or static arrays subscripted
4141: with a constant expression.
4142: The unary
4143: .B
4144: &
4145: .R
4146: can also
4147: be applied implicitly
4148: by appearance of unsubscripted arrays and functions.
4149: The basic rule is that initializers must
4150: evaluate either to a constant or to the address
4151: of a previously declared external or static object plus or minus a constant.
4152: .nr Hu 1
4153: .NH 1
4154: Portability Considerations
4155: .PP
4156: Certain parts of C are inherently machine dependent.
4157: The following list of potential trouble spots
4158: is not meant to be all-inclusive
4159: but to point out the main ones.
4160: .PP
4161: Purely hardware issues like
4162: word size and the properties of floating point arithmetic and integer division
4163: have proven in practice to be not much of a problem.
4164: Other facets of the hardware are reflected
4165: in differing implementations.
4166: Some of these,
4167: particularly sign extension
4168: (converting a negative character into a negative integer)
4169: and the order in which bytes are placed in a word,
4170: are nuisances that must be carefully watched.
4171: Most of the others are only minor problems.
4172: .PP
4173: The number of
4174: .B
4175: register
4176: .R
4177: variables that can actually be placed in registers
4178: varies from machine to machine
4179: as does the set of valid types.
4180: Nonetheless, the compilers all do things properly for their own machine;
4181: excess or invalid
4182: .B
4183: register
4184: .R
4185: declarations are ignored.
4186: .PP
4187: Some difficulties arise only when
4188: dubious coding practices are used.
4189: It is exceedingly unwise to write programs
4190: that depend
4191: on any of these properties.
4192: .PP
4193: The order of evaluation of function arguments
4194: is not specified by the language.
4195: The order in which side effects take place
4196: is also unspecified.
4197: .PP
4198: Since character constants are really objects of type
4199: \fBint\fR,
4200: multicharacter character constants may be permitted.
4201: The specific implementation
4202: is very machine dependent
4203: because the order in which characters
4204: are assigned to a word
4205: varies from one machine to another.
4206: .PP
4207: Fields are assigned to words and characters to integers right to left
4208: on some machines
4209: and left to right on other machines.
4210: These differences are invisible to isolated programs
4211: that do not indulge in type punning (e.g.,
4212: by converting an
4213: .B
4214: int
4215: .R
4216: pointer to a
4217: .B
4218: char
4219: .R
4220: pointer and inspecting the pointed-to storage)
4221: but must be accounted for when conforming to externally-imposed
4222: storage layouts.
4223: .nr Hu 1
4224: .NH 1
4225: Syntax Summary
4226: .PP
4227: This summary of C syntax is intended more for aiding comprehension
4228: than as an exact statement of the language.
4229: .nr Hu 1
4230: .ne 18
4231: .NH 2
4232: Expressions
4233: .PP
4234: The basic expressions are:
4235: .tr ~~
4236: .DS
4237: \fIexpression:
4238: primary
4239: \(** expression\fR
4240: &\fIlvalue
4241: \(mi expression
4242: ! expression
4243: \s+2~\s0 expression
4244: \(pl\(pl lvalue
4245: \(mi\(milvalue
4246: lvalue \(pl\(pl
4247: lvalue \(mi\(mi
4248: \fBsizeof\fI expression
4249: \fBsizeof (\fItype-name\fB)\fI
4250: ( type-name ) expression
4251: expression binop expression
4252: expression ? expression : expression
4253: lvalue asgnop expression
4254: expression , expression
4255: .DE
4256: .DS
4257: \fIprimary:
4258: identifier
4259: constant
4260: string
4261: ( expression )
4262: primary ( expression-list\v'0.5'\s-2opt\s0\v'-0.5' )
4263: primary [ expression ]
4264: primary . identifier
4265: primary \(mi identifier
4266: .DE
4267: .DS
4268: \fIlvalue:
4269: identifier
4270: primary [ expression ]
4271: lvalue . identifier
4272: primary \(mi identifier
4273: \(** expression
4274: ( lvalue )\fR
4275: .DE
4276: .PP
4277: .PP
4278: The primary-expression operators
4279: .DS
4280: () [] . \(mi
4281: .tr ~~
4282: .DE
4283: .LP
4284: have highest priority and group left to right.
4285: The unary operators
4286: .DS
4287: \(** & \(mi ! \s+2~\s0 \(pl\(pl \(mi\(mi \fBsizeof\fI ( type-name \fR)
4288: .DE
4289: .LP
4290: have priority below the primary operators
4291: but higher than any binary operator
4292: and group right to left.
4293: Binary operators
4294: group left to right; they have priority
4295: decreasing
4296: as indicated below.
4297: .DS
4298: \fIbinop:\fR
4299: \(** / %
4300: \(pl \(mi
4301: >> <<
4302: < > <= >=
4303: == !=
4304: &
4305: ^
4306: |
4307: &&
4308: ||
4309: .DE
4310: The conditional operator groups right to left.
4311: .PP
4312: Assignment operators all have the same
4313: priority and all group right to left.
4314: .DS
4315: \fIasgnop:\fR
4316: = \(pl= \(mi= \(**= /= %= >>= <<= &= ^= |=
4317: .DE
4318: .PP
4319: The comma operator has the lowest priority and groups left to right.
4320: .nr Hu 1
4321: .NH 2
4322: Declarations
4323: .PP
4324: .DS
4325: \fIdeclaration:
4326: decl-specifiers init-declarator-list\v'0.5'\s-2opt\s0\v'-0.5' ;
4327: .DE
4328: .DS
4329: \fIdecl-specifiers:
4330: type-specifier decl-specifiers\v'0.5'\s-2opt\s0\v'-0.5'
4331: sc-specifier decl-specifiers\v'0.5'\s-2opt\s0\v'-0.5'
4332: .DE
4333: .DS
4334: \fIsc-specifier:\fB
4335: auto
4336: static
4337: extern
4338: register
4339: typedef
4340: .DE
4341: .DS
4342: \fItype-specifier:
4343: struct-or-union-specifier
4344: typedef-name
4345: enum-specifier
4346: basic-type-specifier:
4347: basic-type
4348: basic-type basic-type-specifiers
4349: basic-type:\fB
4350: char
4351: short
4352: int
4353: long
4354: unsigned
4355: float
4356: double
4357: void\fR
4358: .DE
4359: .DS
4360: \fIenum-specifier:\fB
4361: enum\fI { enum-list }\fB
4362: enum \fIidentifier { enum-list }\fB
4363: enum \fIidentifier
4364: .DE
4365: .DS
4366: \fIenum-list:
4367: enumerator
4368: enum-list , enumerator
4369: .DE
4370: .DS
4371: \fIenumerator:
4372: identifier
4373: identifier = constant-expression
4374: .DE
4375: .DS
4376: \fIinit-declarator-list:
4377: init-declarator
4378: init-declarator , init-declarator-list
4379: .DE
4380: .DS
4381: \fIinit-declarator:
4382: declarator initializer\v'0.5'\s-2opt\s0\v'-0.5'
4383: .DE
4384: .DS
4385: \fIdeclarator:
4386: identifier
4387: ( declarator )
4388: \(** declarator
4389: declarator ()
4390: declarator [ constant-expression\v'0.5'\s-2opt\s0\v'-0.5' ]
4391: .DE
4392: .DS
4393: \fIstruct-or-union-specifier:\fB
4394: struct\fI { struct-decl-list }\fB
4395: struct \fIidentifier { struct-decl-list }\fB
4396: struct \fIidentifier\fB
4397: union { \fIstruct-decl-list }\fB
4398: union \fIidentifier { struct-decl-list }\fB
4399: union \fIidentifier
4400: .DE
4401: .DS
4402: \fIstruct-decl-list:
4403: struct-declaration
4404: struct-declaration struct-decl-list
4405: .DE
4406: .DS
4407: \fIstruct-declaration:
4408: type-specifier struct-declarator-list ;
4409: .DE
4410: .DS
4411: \fIstruct-declarator-list:
4412: struct-declarator
4413: struct-declarator , struct-declarator-list
4414: .DE
4415: .DS
4416: \fIstruct-declarator:
4417: declarator
4418: declarator : constant-expression
4419: : constant-expression
4420: .DE
4421: .DS
4422: \fIinitializer:
4423: = expression
4424: = { initializer-list }
4425: = { initializer-list , }
4426: .DE
4427: .DS
4428: \fIinitializer-list:
4429: expression
4430: initializer-list , initializer-list
4431: { initializer-list }
4432: { initializer-list , }
4433: .DE
4434: .DS
4435: \fItype-name:
4436: type-specifier abstract-declarator
4437: .DE
4438: .DS
4439: \fIabstract-declarator:
4440: empty
4441: ( abstract-declarator )
4442: \(** abstract-declarator
4443: abstract-declarator ()
4444: abstract-declarator [ constant-expression\v'0.5'\s-2opt\s0\v'-0.5' ]
4445: .DE
4446: .DS
4447: \fItypedef-name:
4448: identifier
4449: .nr Hu 1
4450: .DE
4451: .NH 2
4452: Statements
4453: .PP
4454: .DS
4455: \fIcompound-statement:
4456: { declaration-list\v'0.5'\s-2opt\s0\v'-0.5' statement-list\v'0.5'\s-2opt\s0\v'-0.5' }
4457: .DE
4458: .DS
4459: \fIdeclaration-list:
4460: declaration
4461: declaration declaration-list
4462: .DE
4463: .DS
4464: \fIstatement-list:
4465: statement
4466: statement statement-list
4467: .DE
4468: .DS
4469: \fIstatement:
4470: compound-statement
4471: expression ;
4472: \fBif\fI ( expression ) statement
4473: \fBif\fI ( expression ) statement \fBelse\fI statement
4474: \fBwhile\fI ( expression ) statement
4475: \fBdo\fI statement \fBwhile\fI ( expression ) ;
4476: \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
4477: \fBswitch\fI ( expression ) statement
4478: \fBcase\fI constant-expression : statement
4479: \fBdefault\fI : statement
4480: \fBbreak ;
4481: continue ;
4482: return ;
4483: return\fI expression ;
4484: \fBgoto\fI identifier ;
4485: identifier : statement
4486: ;\fR
4487: .nr Hu 1
4488: .DE
4489: .NH 2
4490: External definitions
4491: .PP
4492: .DS
4493: \fIprogram:
4494: external-definition
4495: external-definition program
4496: .DE
4497: .DS
4498: \fIexternal-definition:
4499: function-definition
4500: data-definition
4501: .DE
4502: .DS
4503: \fIfunction-definition:
4504: decl-specifier\v'0.5'\s-2opt\s0\v'-0.5' function-declarator function-body
4505: .DE
4506: .DS
4507: \fIfunction-declarator:
4508: declarator ( parameter-list\v'0.5'\s-2opt\s0\v'-0.5' )
4509: .DE
4510: .DS
4511: \fIparameter-list:
4512: identifier
4513: identifier , parameter-list
4514: .DE
4515: .DS
4516: \fIfunction-body:
4517: declaration-list\v'0.5'\s-2opt\s0\v'-0.5' compound-statement
4518: .DE
4519: .DS
4520: \fIdata-definition:
4521: \fBextern\fI declaration\fB ;
4522: \fBstatic\fI declaration\fB ;
4523: .DE
4524: .NH
4525: Preprocessor
4526: .DS
4527: \fB#define\fI identifier token-string\v'0.3'\s-2opt\s0\v'-0.3'\fB
4528: \fB#define\fI identifier\fB(\fIidentifier\fB,...)\fItoken-string\v'0.5'\s-2opt\s0\v'-0.5'\fB
4529: \fB#undef\fI identifier\fB
4530: \fB#include "\fIfilename\|\fB"
4531: #include <\fIfilename\|\fB>
4532: \fB#if\fI restricted-constant-expression\fB
4533: \fB#ifdef\fI identifier\fB
4534: \fB#ifndef\fI identifier\fB
4535: \fB#else
4536: \fB#endif
4537: \fB#line\fI constant \fB"\fIfilename\|\fB"
4538: .sp 5
4539: .DE
4540: .TC 2 1 3 0
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.