编译器之简单的类C文法

<constant-expression> ::= <conditional-expression>

 

<conditional-expression> ::=<logical-or-expression> { ? <expression> : <conditional-expression> }*

 

<logical-or-expression> ::= <logical-and-expression> { || <logical-and-expression> }*

 

<logical-and-expression> ::= <inclusive-or-expression> { && <inclusive-or-expression> }*

 

<inclusive-or-expression> ::= <exclusive-or-expression> { | <exclusive-or-expression> }*

 

<exclusive-or-expression> ::= <and-expression> { ^ <and-expression> }*

 

<and-expression> ::= <equality-expression>{ & <equality-expression> }*

 

<equality-expression> ::= <relational-expression>{ w0 <relational-expression> }*

            w0 ::=  == | !=

 

<relational-expression> ::= <additive-expression> { w1 <additive-expression> }*

            w1 ::=  > | < | <= | >=

 

<additive-expression> ::= <multiplicative-expression>{ w2 <multiplicative-expression> }*

            w2 ::= + | -

 

<multiplicative-expression> ::= <unary-expression> { w3 <unary-expression> }*

            w3 ::= * | / | %

 

<unary-expression> ::= <unary-operator> <unary-expression>

                       | <constant>

                       | ( <constant-expression> )

                       | <primary-expression>

                       | <function-call-expression>

 

<primary-expression> ::= <identifier> { [ <constant-expression> ] }*

 

<constant> ::= <integer-constant>

             | <real-constant>

 

<expression> ::= <assignment-expression> { , <assignment-expression> }*

 

<assignment-expression> ::= <primary-expression> <assignment-operator> <constant-expression>

 

<assignment-operator> ::= =

 

<unary-operator> ::= - | ~ | !

 

<type-name> ::= { const }? <type-specifier>

 

 

<type-specifier> ::= char

                   | int

                   | real

 

<declarator>  ::= <identifier>  { [ {<constant-expression>}? ] }*

 

<declaration> ::=  <type-name> <init-declarator> { <init-declarator> }*

 

<init-declarator> ::= <declarator>

                    | <declarator> = <initializer>

 

<initializer> ::= <constant-expression>

                | { <initializer-list> }

                | { <initializer-list> , }

 

<initializer-list> ::= <initializer>

                     | <initializer> , <initializer-list>

 

<original-statements> ::= <type-specifier><identifier>()<compound_statements>

 

<compound-statement> ::= { {<declaration>}* {<statement>}* }

 

<statement> ::=<expression-statement>

              | <area-statement>

              | <selection-statement>

              | <iteration-statement>

              | <return-statement>

 

<area-statement> ::= { { <statement> }* }

 

<expression-statement> ::= {<expression>}? ;

 

<selection-statement> ::= if ( <constant-expression> ) <area-statement>

                        | if ( <constant-expression> ) <statement> else <area-statement>

 

<iteration-statement> ::= while ( <constant-expression> ) <area-jump-statement>

               | for ( {<expression>}? ; {<constant-expression>}? ; {<expression>}? ) <area-jump-statement>

 

<jump-statement> ::= continue ;

                  | break ;

                  | <expression-statement>

                  | <area-jump-statement>

                  | <selection-jump-statement>

                  | <iteration-statement>

                  | <return-statement>

 

<area-jump-statement> ::= { { <jump-statement }* }

 

<selection-statement> ::= if ( <constant-expression> ) <area-jump-statement>

                        | if ( <constant-expression> ) <statement> else <area-jump-statement>

 

几点限制：

const只能声明变量，后面必须跟立即数，数组只声明不初始化