Initial revision
This commit is contained in:
ceriel
parent
4f0cb4abe1
commit
a18b0fbcff
627
doc/crefman.doc
Normal file
627
doc/crefman.doc
Normal file
|
|
@ -0,0 +1,627 @@
|
|||
.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
|
||||
\f5asm\fP
|
||||
.PP
|
||||
The keyword \f5asm\fP
|
||||
is recognized.
|
||||
However, the statement
|
||||
.DS
|
||||
.ft 5
|
||||
asm(string);
|
||||
.ft R
|
||||
.DE
|
||||
is skipped, while a warning is given.
|
||||
.SH
|
||||
\f5enum\fP
|
||||
.PP
|
||||
The \f5enum\fP keyword is recognized and interpreted.
|
||||
.SH
|
||||
\f5entry\fP, \f5fortran\fP
|
||||
.PP
|
||||
The words \f5entry\fP and \f5fortran\fP
|
||||
are reserved under the restricted option.
|
||||
The words are not interpreted by the compiler.
|
||||
.SH
|
||||
2.4.1 Integer Constants
|
||||
.PP
|
||||
An octal or hex constant which is less than or equal to the largest unsigned
|
||||
(target) machine integer is taken to be \f5unsigned\fP.
|
||||
An octal or hex constant which exceeds the largest unsigned (target) machine
|
||||
integer is taken to be \f5long\fP.
|
||||
.SH
|
||||
2.4.3 Character Constants
|
||||
.PP
|
||||
A character constant is a sequence of 1 up to \f5sizeof(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 \f5unsigned 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 \f5char\fP is 8 bits
|
||||
.IP \(bu
|
||||
the size of \f5int\fP is equal to the word size
|
||||
.IP \(bu
|
||||
the size of \f5short\fP may not exceed the size of \f5int\fP
|
||||
.IP \(bu
|
||||
the size of \f5int\fP may not exceed the size of \f5long\fP
|
||||
.IP \(bu
|
||||
the size of pointers is equal to the size of either \f5short\fP, \f5int\fP
|
||||
or \f5long\fP
|
||||
.LP
|
||||
.SH
|
||||
4 What's in a name?
|
||||
.SH
|
||||
\f5char\fP
|
||||
.PP
|
||||
Objects of type \f5char\fP are taken to be signed.
|
||||
The combination \f5unsigned char\fP is legal.
|
||||
.SH
|
||||
\f5unsigned\fP
|
||||
.PP
|
||||
The type combinations \f5unsigned char\fP, \f5unsigned short\fP and
|
||||
\f5unsigned long\fP are supported.
|
||||
.SH
|
||||
\f5enum\fP
|
||||
.PP
|
||||
The data type \f5enum\fP is implemented as described
|
||||
in \fIRecent Changes to C\fP (see appendix A).
|
||||
.I Cem
|
||||
treats enumeration variables as if they were \f5int\fP.
|
||||
.SH
|
||||
\f5void\fP
|
||||
.PP
|
||||
Type \f5void\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
|
||||
\f5typedef\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 \f5sizeof\fP expression is \f5unsigned 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 \f5unsigned char\fP, \f5unsigned short\fP
|
||||
and \f5unsigned 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 \f5-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 5
|
||||
\f5switch (\fP\fIexpression\fP\f5)\fP \fIstatement\fP
|
||||
.ft
|
||||
.DE
|
||||
must be integral.
|
||||
A warning is given under the restricted option if the type is \f5long\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 \f5#\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 \f5#\fP.
|
||||
Comments may contain newline characters.
|
||||
Control lines with only white space between the \f5#\fP and the line separator
|
||||
are skipped.
|
||||
.PP
|
||||
The #\f5include\fP, #\f5ifdef\fP, #\f5ifndef\fP, #\f5undef\fP, #\f5else\fP and
|
||||
#\f5endif\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 \f5/*\fP and \f5*/\fP is skipped, regardless of
|
||||
newlines; note that commented-out lines beginning with \f5#\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 \f5()\fP, \f5{}\fP and \f5[]\fP.
|
||||
This prevents the use of macros like
|
||||
.DS
|
||||
.ft 5
|
||||
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 #\f5defined\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 #\f5defined\fP macros are
|
||||
.DS
|
||||
\f5__FILE__\fP name of current input file as string constant
|
||||
\f5__DATE__\fP curent date as string constant; e.g. \f5"Tue Wed 2 14:45:23 1986"\fP
|
||||
\f5__LINE__\fP current line number as an integer
|
||||
.DE
|
||||
.PP
|
||||
No message is given if \fIidentifier\fP is not known in
|
||||
.DS
|
||||
.ft 5
|
||||
#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 #\f5if\fP, #\f5ifdef\fP and #\f5ifndef\fP control lines may be followed
|
||||
by an arbitrary number of
|
||||
.DS
|
||||
.ft 5
|
||||
#elif \fIconstant-expression\fP
|
||||
.ft
|
||||
.DE
|
||||
control lines, before the corresponding #\f5else\fP or #\f5endif\fP
|
||||
is encountered.
|
||||
The construct
|
||||
.DS
|
||||
.ft 5
|
||||
#elif \fIconstant-expression\fP
|
||||
some text
|
||||
#endif /* corresponding to #elif */
|
||||
.ft
|
||||
.DE
|
||||
is equivalent to
|
||||
.DS
|
||||
.ft 5
|
||||
#else
|
||||
#if \fIconstant-expression\fP
|
||||
some text
|
||||
#endif /* corresponding to #if */
|
||||
#endif /* corresponding to #else */
|
||||
.ft
|
||||
.DE
|
||||
.PP
|
||||
The \fIconstant-expression\fP in #\f5if\fP and #\f5elif\fP control lines
|
||||
may contain the construction
|
||||
.DS
|
||||
.ft 5
|
||||
defined(\fIidentifier\fP)
|
||||
.ft
|
||||
.DE
|
||||
which is replaced by \f51\fP, if \fIidentifier\fP has been #\f5defined\fP,
|
||||
and by \f50\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 5
|
||||
#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 \f5#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 5
|
||||
-Iinclude -Isys/h -Iutil/h
|
||||
.ft R
|
||||
.DE
|
||||
An empty \fIpath\fP causes the standard include
|
||||
directory (usually \f5/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 5
|
||||
#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 5
|
||||
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
|
||||
\&\f5enum\fP { \fIenum-list\fP }
|
||||
.br
|
||||
\&\f5enum\fP \fIidentifier\fP { \fIenum-list\fP }
|
||||
.br
|
||||
\&\f5enum\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
|
||||
Loading…
Reference in a new issue