|
@@ -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
|