123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629 |
- \." $Id$
- .\" eqn crefman.doc | troff -ms
- .EQ
- delim $$
- .EN
- .RP
- .TL
- ACK/CEM Compiler
- .br
- Reference Manual
- .AU
- Erik H. Baalbergen
- .AI
- Department of Mathematics and Computer Science
- Vrije Universiteit
- Amsterdam
- The Netherlands
- .AB no
- .AE
- .NH
- C Language
- .PP
- This section discusses the extensions to and deviations from the C language,
- as described in [1].
- The issues are numbered according to the reference manual.
- .SH
- 2.2 Identifiers
- .PP
- Upper and lower case letters are different.
- The number of significant letters
- is 32 by default, but may be set to another value using the \fB\-M\fP option.
- The identifier length should be set according to the rest of the compilation
- programs.
- .SH
- 2.3 Keywords
- .SH
- \f(CWasm\fP
- .PP
- The keyword \f(CWasm\fP
- is recognized.
- However, the statement
- .DS
- .ft CW
- asm(string);
- .ft R
- .DE
- is skipped, while a warning is given.
- .SH
- \f(CWenum\fP
- .PP
- The \f(CWenum\fP keyword is recognized and interpreted.
- .SH
- \f(CWentry\fP, \f(CWfortran\fP
- .PP
- The words \f(CWentry\fP and \f(CWfortran\fP
- are reserved under the restricted option.
- The words are not interpreted by the compiler.
- .SH
- 2.4.1 Integer Constants
- .PP
- The type of an integer constant is the first of the corresponding list
- in which its value can be represented. Decimal: \f(CWint, long, unsigned long\fP;
- octal or hexadecimal: \f(CWint, unsigned, long, unsigned long\fP; suffixed by
- the letter L or l: \f(CWlong, unsigned long\fP.
- .SH
- 2.4.3 Character Constants
- .PP
- A character constant is a sequence of 1 up to \f(CWsizeof(int)\fP characters
- enclosed in single quotes.
- The value of a character constant '$c sub 1 c sub 2 ... c sub n$'
- is $d sub n + M \(mu d sub {n - 1} + ... + M sup {n - 1} \(mu d sub 2 + M sup n \(mu d sub 1$,
- where M is 1 + maximum unsigned number representable in an \f(CWunsigned char\fP,
- and $d sub i$ is the signed value (ASCII)
- of character $c sub i$.
- .SH
- 2.4.4 Floating Constants
- .PP
- The compiler does not support compile-time floating point arithmetic.
- .SH
- 2.6 Hardware characteristics
- .PP
- The compiler is capable of producing EM code for machines with the following
- properties
- .IP \(bu
- a \f(CWchar\fP is 8 bits
- .IP \(bu
- the size of \f(CWint\fP is equal to the word size
- .IP \(bu
- the size of \f(CWshort\fP may not exceed the size of \f(CWint\fP
- .IP \(bu
- the size of \f(CWint\fP may not exceed the size of \f(CWlong\fP
- .IP \(bu
- the size of pointers is equal to the size of either \f(CWshort\fP, \f(CWint\fP
- or \f(CWlong\fP
- .LP
- .SH
- 4 What's in a name?
- .SH
- \f(CWchar\fP
- .PP
- Objects of type \f(CWchar\fP are taken to be signed.
- The combination \f(CWunsigned char\fP is legal.
- .SH
- \f(CWunsigned\fP
- .PP
- The type combinations \f(CWunsigned char\fP, \f(CWunsigned short\fP and
- \f(CWunsigned long\fP are supported.
- .SH
- \f(CWenum\fP
- .PP
- The data type \f(CWenum\fP is implemented as described
- in \fIRecent Changes to C\fP (see appendix A).
- .I Cem
- treats enumeration variables as if they were \f(CWint\fP.
- .SH
- \f(CWvoid\fP
- .PP
- Type \f(CWvoid\fP is implemented.
- The type specifies an empty set of values, which takes no storage space.
- .SH
- \fRFundamental types\fP
- .PP
- The names of the fundamental types can be redefined by the user, using
- \f(CWtypedef\fP.
- .SH
- 7 Expressions
- .PP
- The order of evaluation of expressions depends on the complexity of the
- subexpressions.
- In case of commutative operations, the most complex subexpression is
- evaluated first.
- Parameter lists are evaluated from right to left.
- .SH
- 7.2 Unary operators
- .PP
- The type of a \f(CWsizeof\fP expression is \f(CWunsigned int\fP.
- .SH
- 7.13 Conditional operator
- .PP
- Both the second and the third expression in a conditional expression may
- include assignment operators.
- They may be structs or unions.
- .SH
- 7.14 Assignment operators
- .PP
- Structures may be assigned, passed as arguments to functions, and returned
- by functions.
- The types of operands taking part must be the same.
- .SH
- 8.2 Type specifiers
- .PP
- The combinations \f(CWunsigned char\fP, \f(CWunsigned short\fP
- and \f(CWunsigned long\fP are implemented.
- .SH
- 8.5 Structure and union declarations
- .PP
- Fields of any integral type, either signed or unsigned,
- are supported, as long as the type fits in a word on the target machine.
- .PP
- Fields are left adjusted by default; the first field is put into the left
- part of a word, the next one on the right side of the first one, etc.
- The \f(CW-Vr\fP option in the call of the compiler
- causes fields to be right adjusted within a machine word.
- .PP
- The tags of structs and unions occupy a different name space from that of
- variables and that of member names.
- .SH
- 9.7 Switch statement
- .PP
- The type of \fIexpression\fP in
- .DS
- .ft CW
- \f(CWswitch (\fP\fIexpression\fP\f(CW)\fP \fIstatement\fP
- .ft
- .DE
- must be integral.
- A warning is given under the restricted option if the type is \f(CWlong\fP.
- .SH
- 10 External definitions
- .PP
- See [4] for a discussion on this complicated issue.
- .SH
- 10.1 External function definitions
- .PP
- Structures may be passed as arguments to functions, and returned
- by functions.
- .SH
- 11.1 Lexical scope
- .PP
- Typedef names may be redeclared like any other variable name; the ice mentioned
- in \(sc11.1 is walked correctly.
- .SH
- 12 Compiler control lines
- .PP
- Lines which do not occur within comment, and with \f(CW#\fP as first
- character, are interpreted as compiler control line.
- There may be an arbitrary number of spaces, tabs and comments (collectively
- referred as \fIwhite space\fP) following the \f(CW#\fP.
- Comments may contain newline characters.
- Control lines with only white space between the \f(CW#\fP and the line separator
- are skipped.
- .PP
- The #\f(CWinclude\fP, #\f(CWifdef\fP, #\f(CWifndef\fP, #\f(CWundef\fP, #\f(CWelse\fP and
- #\f(CWendif\fP control lines and line directives consist of a fixed number of
- arguments.
- The list of arguments may be followed an arbitrary sequence of characters,
- in which comment is interpreted as such.
- (I.e., the text between \f(CW/*\fP and \f(CW*/\fP is skipped, regardless of
- newlines; note that commented-out lines beginning with \f(CW#\fP are not
- considered to be control lines.)
- .SH
- 12.1 Token replacement
- .PP
- The replacement text of macros is taken to be a string of characters, in which
- an identifier may stand for a formal parameter, and in which comment is
- interpreted as such.
- Comments and newline characters, preceeded by a backslash, in the replacement
- text are replaced by a space character.
- .PP
- The actual parameters of a macro are considered tokens and are
- balanced with regard to \f(CW()\fP, \f(CW{}\fP and \f(CW[]\fP.
- This prevents the use of macros like
- .DS
- .ft CW
- CTL([)
- .ft
- .DE
- .PP
- Formal parameters of a macro must have unique names within the formal-parameter
- list of that macro.
- .PP
- A message is given at the definition of a macro if the macro has
- already been #\f(CWdefined\fP, while the number of formal parameters differ or
- the replacement texts are not equal (apart from leading and trailing
- white space).
- .PP
- Recursive use of macros is detected by the compiler.
- .PP
- Standard #\f(CWdefined\fP macros are
- .DS
- \f(CW__FILE__\fP name of current input file as string constant
- \f(CW__DATE__\fP curent date as string constant; e.g. \f(CW"Tue Wed 2 14:45:23 1986"\fP
- \f(CW__LINE__\fP current line number as an integer
- .DE
- .PP
- No message is given if \fIidentifier\fP is not known in
- .DS
- .ft CW
- #undef \fIidentifier\fP
- .ft
- .DE
- .SH
- 12.2 File inclusion
- .PP
- A newline character is appended to each file which is included.
- .SH
- 12.3 Conditional compilation
- .PP
- The #\f(CWif\fP, #\f(CWifdef\fP and #\f(CWifndef\fP control lines may be followed
- by an arbitrary number of
- .DS
- .ft CW
- #elif \fIconstant-expression\fP
- .ft
- .DE
- control lines, before the corresponding #\f(CWelse\fP or #\f(CWendif\fP
- is encountered.
- The construct
- .DS
- .ft CW
- #elif \fIconstant-expression\fP
- some text
- #endif /* corresponding to #elif */
- .ft
- .DE
- is equivalent to
- .DS
- .ft CW
- #else
- #if \fIconstant-expression\fP
- some text
- #endif /* corresponding to #if */
- #endif /* corresponding to #else */
- .ft
- .DE
- .PP
- The \fIconstant-expression\fP in #\f(CWif\fP and #\f(CWelif\fP control lines
- may contain the construction
- .DS
- .ft CW
- defined(\fIidentifier\fP)
- .ft
- .DE
- which is replaced by \f(CW1\fP, if \fIidentifier\fP has been #\f(CWdefined\fP,
- and by \f(CW0\fP, if not.
- .PP
- Comments in skipped lines are interpreted as such.
- .SH
- 12.4 Line control
- .PP
- Line directives may occur in the following forms:
- .DS
- .ft CW
- #line \fIconstant\fP
- #line \fIconstant\fP "\fIfilename\fP"
- #\fIconstant\fP
- #\fIconstant\fP "\fIfilename\fP"
- .ft
- .DE
- Note that \fIfilename\fP is enclosed in double quotes.
- .SH
- 14.2 Functions
- .PP
- If a pointer to a function is called, the function the pointer points to
- is called instead.
- .SH
- 15 Constant expressions
- .PP
- The compiler distinguishes the following types of integral constant expressions
- .IP \(bu
- field-width specifier
- .IP \(bu
- case-entry specifier
- .IP \(bu
- array-size specifier
- .IP \(bu
- global variable initialization value
- .IP \(bu
- enum-value specifier
- .IP \(bu
- truth value in \f(CW#if\fP control line
- .LP
- .PP
- Constant integral expressions are compile-time evaluated while an effort
- is made to report overflow.
- Constant floating expressions are not compile-time evaluated.
- .NH
- Compiler flags
- .IP \fB\-C\fR
- Run the preprocessor stand-alone while maintaining the comments.
- Line directives are produced whenever needed.
- .IP \fB\-D\fP\fIname\fP=\fIstring-of-characters\fP
- .br
- Define \fIname\fR as macro with \fIstring-of-characters\fR as
- replacement text.
- .IP \fB\-D\fP\fIname\fP
- .br
- Equal to \fB\-D\fP\fIname\fP\fB=1\fP.
- .IP \fB\-E\fP
- Run the preprocessor stand alone, i.e.,
- list the sequence of input tokens and delete any comments.
- Line directives are produced whenever needed.
- .IP \fB\-I\fIpath\fR
- .br
- Prepend \fIpath\fR to the list of include directories.
- To put the directories "include", "sys/h" and "util/h" into the
- include directory list in that order, the user has to specify
- .DS
- .ft CW
- -Iinclude -Isys/h -Iutil/h
- .ft R
- .DE
- An empty \fIpath\fP causes the standard include
- directory (usually \f(CW/usr/include\fP) to be forgotten.
- .IP \fB\-M\fP\fIn\fP
- .br
- Set maximum significant identifier length to \fIn\fP.
- .IP \fB\-n\fP
- Suppress EM register messages.
- The user-declared variables are not stored into registers on the target
- machine.
- .IP \fB\-p\fP
- Generate the EM \fBfil\fP and \fBlin\fP instructions in order to enable
- an interpreter to keep track of the current location in the source code.
- .IP \fB\-P\fP
- Equivalent with \fB\-E\fP, but without line directives.
- .IP \fB\-R\fP
- Interpret the input as restricted C (according to the language as
- described in [1]).
- .IP \fB\-T\fP\fIpath\fP
- .br
- Create temporary files, if necessary, in directory \fIpath\fP.
- .IP \fB\-U\fP\fIname\fP
- .br
- Get rid of the compiler-predefined macro \fIname\fP, i.e.,
- consider
- .DS
- .ft CW
- #undef \fIname\fP
- .ft R
- .DE
- to appear in the beginning of the file.
- .IP \fB\-V\fIcm\fR.\fIn\fR,\ \fB\-V\fIcm\fR.\fIncm\fR.\fIn\fR\ ...
- .br
- Set the size and alignment requirements.
- The letter \fIc\fR indicates the simple type, which is one of
- \fBs\fR(short), \fBi\fR(int), \fBl\fR(long), \fBf\fR(float), \fBd\fR(double)
- or \fBp\fR(pointer).
- If \fIc\fR is \fBS\fP or \fBU\fP, then \fIn\fP is taken to be the initial
- alignment of structs or unions, respectively.
- The effective alignment of a struct or union is the least common multiple
- of the initial struct/union alignment and the alignments of its members.
- The \fIm\fR parameter can be used to specify the length of the type (in bytes)
- and the \fIn\fR parameter for the alignment of that type.
- Absence of \fIm\fR or \fIn\fR causes the default value to be retained.
- To specify that the bitfields should be right adjusted instead of the
- default left adjustment, specify \fBr\fR as \fIc\fR parameter.
- .IP \fB\-w\fR
- Suppress warning messages
- .IP \fB\-\-\fIcharacter\fR
- .br
- Set debug-flag \fIcharacter\fP.
- This enables some special features offered by a debug and develop version of
- the compiler.
- Some particular flags may be recognized, others may have surprising effects.
- .RS
- .IP \fBd\fP
- Generate a dependency graph, reflecting the calling structure of functions.
- Lines of the form
- .DS
- .ft CW
- DFA: \fIcalling-function\fP: \fIcalled-function\fP
- .ft
- .DE
- are generated whenever a function call is encountered.
- .IP \fBf\fP
- Dump whole identifier table, including macros and reserved words.
- .IP \fBh\fP
- Supply hash-table statistics.
- .IP \fBi\fP
- Print names of included files.
- .IP \fBm\fP
- Supply statistics concerning the memory allocation.
- .IP \fBt\fP
- Dump table of identifiers.
- .IP \fBu\fP
- Generate extra statistics concerning the predefined types and identifiers.
- Works in combination with \fBf\fP or \fBt\fP.
- .IP \fBx\fP
- Print expression trees in human-readable format.
- .RE
- .LP
- .SH
- References
- .IP [1]
- Brian W. Kernighan, Dennis M. Ritchie,
- .I
- The C Programming Language
- .R
- .IP [2]
- L. Rosler,
- .I
- Draft Proposed Standard - Programming Language C,
- .R
- ANSI X3J11 Language Subcommittee
- .IP [3]
- Erik H. Baalbergen, Dick Grune, Maarten Waage,
- .I
- The CEM Compiler,
- .R
- Informatica Manual IM-4, Dept. of Mathematics and Computer Science, Vrije
- Universiteit, Amsterdam, The Netherlands
- .IP [4]
- Erik H. Baalbergen,
- .I
- Modeling global declarations in C,
- .R
- internal paper
- .LP
- .bp
- .SH
- Appendix A - Enumeration Type
- .PP
- The syntax is
- .sp
- .RS
- .I enum-specifier :
- .RS
- \&\f(CWenum\fP { \fIenum-list\fP }
- .br
- \&\f(CWenum\fP \fIidentifier\fP { \fIenum-list\fP }
- .br
- \&\f(CWenum\fP \fIidentifier\fP
- .RE
- .sp
- \&\fIenum-list\fP :
- .RS
- \&\fIenumerator\fP
- .br
- \&\fIenum-list\fP , \fIenumerator\fP
- .RE
- .sp
- \&\fIenumerator\fP :
- .RS
- \&\fIidentifier\fP
- .br
- \&\fIidentifier\fP = \fIconstant-expression\fP
- .RE
- .sp
- .RE
- The identifier has the same role as the structure tag in a struct specification.
- It names a particular enumeration type.
- .PP
- The identifiers in the enum-list are declared as constants, and may appear
- whenever constants are required.
- If no enumerators with
- .B =
- appear, then the values of the constants begin at 0 and increase by 1 as the
- declaration is read from left to right.
- An enumerator with
- .B =
- gives the associated identifier the value indicated; subsequent identifiers
- continue the progression from the assigned value.
- .PP
- Enumeration tags and constants must all be distinct, and, unlike structure
- tags and members, are drawn from the same set as ordinary identifiers.
- .PP
- Objects of a given enumeration type are regarded as having a type distinct
- from objects of all other types.
- .bp
- .SH
- Appendix B: C grammar in LL(1) form
- .PP
- The \fBbold-faced\fP and \fIitalicized\fP tokens represent terminal symbols.
- .vs 16
- .nf
- \fBexternal definitions\fP
- program: external-definition*
- external-definition: ext-decl-specifiers [declarator [function | non-function] | '\fB;\fP'] | asm-statement
- ext-decl-specifiers: decl-specifiers?
- non-function: initializer? ['\fB,\fP' init-declarator]* '\fB;\fP'
- function: declaration* compound-statement
- .sp 1
- \fBdeclarations\fP
- declaration: decl-specifiers init-declarator-list? '\fB;\fP'
- decl-specifiers: other-specifier+ [single-type-specifier other-specifier*]? | single-type-specifier other-specifier*
- other-specifier: \fBauto\fP | \fBstatic\fP | \fBextern\fP | \fBtypedef\fP | \fBregister\fP | \fBshort\fP | \fBlong\fP | \fBunsigned\fP
- type-specifier: decl-specifiers
- single-type-specifier: \fItype-identifier\fP | struct-or-union-specifier | enum-specifier
- init-declarator-list: init-declarator ['\fB,\fP' init-declarator]*
- init-declarator: declarator initializer?
- declarator: primary-declarator ['\fB(\fP' formal-list ? '\fB)\fP' | arrayer]* | '\fB*\fP' declarator
- primary-declarator: identifier | '\fB(\fP' declarator '\fB)\fP'
- arrayer: '\fB[\fP' constant-expression? '\fB]\fP'
- formal-list: formal ['\fB,\fP' formal]*
- formal: identifier
- enum-specifier: \fBenum\fP [enumerator-pack | identifier enumerator-pack?]
- enumerator-pack: '\fB{\fP' enumerator ['\fB,\fP' enumerator]* '\fB,\fP'? '\fB}\fP'
- enumerator: identifier ['\fB=\fP' constant-expression]?
- struct-or-union-specifier: [ \fBstruct\fP | \fBunion\fP] [ struct-declaration-pack | identifier struct-declaration-pack?]
- struct-declaration-pack: '\fB{\fP' struct-declaration+ '\fB}\fP'
- struct-declaration: type-specifier struct-declarator-list '\fB;\fP'?
- struct-declarator-list: struct-declarator ['\fB,\fP' struct-declarator]*
- struct-declarator: declarator bit-expression? | bit-expression
- bit-expression: '\fB:\fP' constant-expression
- initializer: '\fB=\fP'? initial-value
- cast: '\fB(\fP' type-specifier abstract-declarator '\fB)\fP'
- abstract-declarator: primary-abstract-declarator ['\fB(\fP' '\fB)\fP' | arrayer]* | '\fB*\fP' abstract-declarator
- primary-abstract-declarator: ['\fB(\fP' abstract-declarator '\fB)\fP']?
- .sp 1
- \fBstatements\fP
- statement:
- expression-statement
- | label '\fB:\fP' statement
- | compound-statement
- | if-statement
- | while-statement
- | do-statement
- | for-statement
- | switch-statement
- | case-statement
- | default-statement
- | break-statement
- | continue-statement
- | return-statement
- | jump
- | '\fB;\fP'
- | asm-statement
- ;
- expression-statement: expression '\fB;\fP'
- label: identifier
- if-statement: \fBif\fP '\fB(\fP' expression '\fB)\fP' statement [\fBelse\fP statement]?
- while-statement: \fBwhile\fP '\fB(\fP' expression '\fB)\fP' statement
- do-statement: \fBdo\fP statement \fBwhile\fP '\fB(\fP' expression '\fB)\fP' '\fB;\fP'
- for-statement: \fBfor\fP '\fB(\fP' expression? '\fB;\fP' expression? '\fB;\fP' expression? '\fB)\fP' statement
- switch-statement: \fBswitch\fP '\fB(\fP' expression '\fB)\fP' statement
- case-statement: \fBcase\fP constant-expression '\fB:\fP' statement
- default-statement: \fBdefault\fP '\fB:\fP' statement
- break-statement: \fBbreak\fP '\fB;\fP'
- continue-statement: \fBcontinue\fP '\fB;\fP'
- return-statement: \fBreturn\fP expression? '\fB;\fP'
- jump: \fBgoto\fP identifier '\fB;\fP'
- compound-statement: '\fB{\fP' declaration* statement* '\fB}\fP'
- asm-statement: \fBasm\fP '\fB(\fP' \fIstring\fP '\fB)\fP' '\fB;\fP'
- .sp 1
- \fBexpressions\fP
- initial-value: assignment-expression | initial-value-pack
- initial-value-pack: '\fB{\fP' initial-value-list '\fB}\fP'
- initial-value-list: initial-value ['\fB,\fP' initial-value]* '\fB,\fP'?
- primary: \fIidentifier\fP | constant | \fIstring\fP | '\fB(\fP' expression '\fB)\fP'
- secundary: primary [index-pack | parameter-pack | selection]*
- index-pack: '\fB[\fP' expression '\fB]\fP'
- parameter-pack: '\fB(\fP' parameter-list? '\fB)\fP'
- selection: ['\fB.\fP' | '\fB\->\fP'] identifier
- parameter-list: assignment-expression ['\fB,\fP' assignment-expression]*
- postfixed: secundary postop?
- unary: cast unary | postfixed | unop unary | size-of
- size-of: \fBsizeof\fP [cast | unary]
- binary-expression: unary [binop binary-expression]*
- conditional-expression: binary-expression ['\fB?\fP' expression '\fB:\fP' assignment-expression]?
- assignment-expression: conditional-expression [asgnop assignment-expression]?
- expression: assignment-expression ['\fB,\fP' assignment-expression]*
- unop: '\fB*\fP' | '\fB&\fP' | '\fB\-\fP' | '\fB!\fP' | '\fB~ \fP' | '\fB++\fP' | '\fB\-\-\fP'
- postop: '\fB++\fP' | '\fB\-\-\fP'
- multop: '\fB*\fP' | '\fB/\fP' | '\fB%\fP'
- addop: '\fB+\fP' | '\fB\-\fP'
- shiftop: '\fB<<\fP' | '\fB>>\fP'
- relop: '\fB<\fP' | '\fB>\fP' | '\fB<=\fP' | '\fB>=\fP'
- eqop: '\fB==\fP' | '\fB!=\fP'
- arithop: multop | addop | shiftop | '\fB&\fP' | '\fB^ \fP' | '\fB|\fP'
- binop: arithop | relop | eqop | '\fB&&\fP' | '\fB||\fP'
- asgnop: '\fB=\fP' | '\fB+\fP' '\fB=\fP' | '\fB\-\fP' '\fB=\fP' | '\fB*\fP' '\fB=\fP' | '\fB/\fP' '\fB=\fP' | '\fB%\fP' '\fB=\fP'
- | '\fB<<\fP' '\fB=\fP' | '\fB>>\fP' '\fB=\fP' | '\fB&\fP' '\fB=\fP' | '\fB^ \fP' '\fB=\fP' | '\fB|\fP' '\fB=\fP'
- | '\fB+=\fP' | '\fB\-=\fP' | '\fB*=\fP' | '\fB/=\fP' | '\fB%=\fP'
- | '\fB<<=\fP' | '\fB>>=\fP' | '\fB&=\fP' | '\fB^=\fP' | '\fB|=\fP'
- constant: \fIinteger\fP | \fIfloating\fP
- constant-expression: assignment-expression
- identifier: \fIidentifier\fP | \fItype-identifier\fP
- .fi
|