C 語言的 BNF 語法
primary_exp : id
| const
| string
| '(' exp ')'
;
postfix_exp : primary_exp 基本算式
| postfix_exp '[' exp ']' 陣列存取
| postfix_exp '(' argument_exp_list ')' 函數呼叫
| postfix_exp '(' ')' 函數呼叫
| postfix_exp '.' id 結構成員
| postfix_exp '->' id 結構成員
| postfix_exp '++' x++
| postfix_exp '--' x--
;
argument_exp_list : assignment_exp
| argument_exp_list ',' assignment_exp
;
function_definition : decl_specs declarator decl_list compound_stat
EXAMPLE 1 In the following:
extern int max(int a, int b)
{
return a > b ? a : b;
}
extern is the storage-class specifier and int is the type specifier; max(int a, int b) is the
function declarator; and
{ return a > b ? a : b; }
is the function body. The following similar definition uses the identifier-list form for the parameter
declarations:
資料來源:http://c.comsci.us/syntax/expression/ebnf.html
語法
- <expression>
- ::= <sequence-expression>
- <sequence-expression>
- ::= <assignment-expression> ( <sequence-operator> <assignment-expression> ) *
- <assignment-expression>
- ::= ( <variable-reference> <assignment-operator> ) * <conditional-expression>
- <variable-reference>
- ::= <unary-expression>
- <conditional-expression>
- ::= <logical-or-expression> ( '?' <expression> ':' <logical-or-expression> ) *
- <logical-or-expression>
- ::= <logical-and-expression> ( <logical-or-operator> <logical-and-expression> ) *
- <logical-and-expression>
- ::= <bitwise-or-expression> ( <logical-and-operator> <bitwise-or-expression> ) *
- <bitwise-or-expression>
- ::= <bitwise-xor-expression> ( <bitwise-or-operator> <bitwise-xor-expression> ) *
- <bitwise-xor-expression>
- ::= <bitwise-and-expression> ( <bitwise-xor-operator> <bitwise-and-expression> ) *
- <bitwise-and-expression>
- ::= <equality-expression> ( <bitwise-and-operator> <equality-expression> ) *
- <equality-expression>
- ::= <relational-expression> ( <equality-operator> <relational-expression> ) *
- <relational-expression>
- ::= <shift-expression> ( <relational-operator> <shift-expression> ) *
- <shift-expression>
- ::= <additive-expression> ( <shift-operator> <additive-expression> ) *
- <additive-expression>
- ::= <multiplicative-expression> ( <additive-operator> <multiplicative-expression> ) *
- <multiplicative-expression>
- ::= <cast-expression> ( <multiplicative-operator> <cast-expression> ) *
- <cast-expression>
- ::= ( '(' <type-name> ')' ) * <unary-expression>
- <unary-expression>
- ::= <unary-operator> <cast-expression>| ( <prefix-operator> ) * <postfix-expression> | 'sizeof' '(' <type> ')'
- <postfix-expression>
- ::= <primary-expression> <postfix-phrase>
- <postfix-phrase>
- ::= <postfix-operator>| <member-selector>| <element-selector>| <argument-specifier>
- <member-selector>
- ::= '.' <identifier>| '->' <identifier>
- <element-selector>
- ::= '[' <expression> ']'
- <argument-specifier>
- ::= '(' <argument> ( ',' <argument> ')' ')'
- <argument>
- ::= <expression>
- <primary-expression>
- ::= <identifier>| <literal-constant>| '(' <expression> ')'
http://lists.canonical.org/pipermail/kragen-hacks/1999-October/000201.html
translation-unit: (function-definition | declaration)+
function-definition:
declaration-specifiers? declarator declaration* block
declaration: declaration-specifiers init-declarator% ";"
declaration-specifiers:
(storage-class-specifier | type-specifier | type-qualifier)+
storage-class-specifier:
("auto" | "register" | "static" | "extern" | "typedef")
type-specifier: ("void" | "char" | "short" | "int" | "long" | "float" |
"double" | "signed" | "unsigned" | struct-or-union-specifier |
enum-specifier | typedef-name)
type-qualifier: ("const" | "volatile")
struct-or-union-specifier:
("struct" | "union") (
identifier? "{" struct-declaration+ "}" |
identifier
)
init-declarator: declarator ("=" initializer)?
struct-declaration:
(type-specifier | type-qualifier)+ struct-declarator%
struct-declarator: declarator | declarator? ":" constant-expression
enum-specifier: "enum" (identifier | identifier? "{" enumerator% "}")
enumerator: identifier ("=" constant-expression)?
declarator:
pointer? (identifier | "(" declarator ")") (
"[" constant-expression? "]" |
"(" parameter-type-list ")" |
"(" identifier%? ")"
)*
pointer:
("*" type-qualifier*)*
parameter-type-list: parameter-declaration% ("," "...")?
parameter-declaration:
declaration-specifiers (declarator | abstract-declarator)?
initializer: assignment-expression | "{" initializer% ","? "}"
type-name: (type-specifier | type-qualifier)+ abstract-declarator?
abstract-declarator:
pointer ("(" abstract-declarator ")")? (
"[" constant-expression? "]" |
"(" parameter-type-list? ")"
)*
statement:
((identifier | "case" constant-expression | "default") ":")*
(expression? ";" |
block |
"if" "(" expression ")" statement |
"if" "(" expression ")" statement "else" statement |
"switch" "(" expression ")" statement |
"while" "(" expression ")" statement |
"do" statement "while" "(" expression ")" ";" |
"for" "(" expression? ";" expression? ";" expression? ")" statement |
"goto" identifier ";" |
"continue" ";" |
"break" ";" |
"return" expression? ";"
)
block: "{" declaration* statement* "}"
expression:
assignment-expression%
assignment-expression: (
unary-expression (
"=" | "*=" | "/=" | "%=" | "+=" | "-=" | "<<=" | ">>=" | "&=" |
"^=" | "|="
)
)* conditional-expression
conditional-expression:
logical-OR-expression ( "?" expression ":" conditional-expression )?
constant-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 ( ("==" | "!=") relational-expression )*
relational-expression:
shift-expression ( ("<" | ">" | "<=" | ">=") shift-expression )*
shift-expression:
additive-expression ( ("<<" | ">>") additive-expression )*
additive-expression:
multiplicative-expression ( ("+" | "-") multiplicative-expression )*
multiplicative-expression:
cast-expression ( ("*" | "/" | "%") cast-expression )*
cast-expression:
( "(" type-name ")" )* unary-expression
unary-expression:
("++" | "--" | "sizeof" ) * (
"sizeof" "(" type-name ")" |
("&" | "*" | "+" | "-" | "~" | "!" ) cast-expression |
postfix-expression
)
postfix-expression:
(identifier | constant | string | "(" expression ")") (
"[" expression "]" |
"(" assignment-expression% ")" |
"." identifier |
"->" identifier |
"++" |
"--"
)*
constant:
integer-constant |
character-constant |
floating-constant |
enumeration-constant
http://shell.sh.cvut.cz/~wilx/repos/c2pas/_darcs/current/docs/c_syntax.bnf
%token int_const char_const float_const id string enumeration_const
%%
translation_unit : external_decl
| translation_unit external_decl
;
external_decl : function_definition
| decl
;
function_definition : decl_specs declarator decl_list compound_stat
| declarator decl_list compound_stat
| decl_specs declarator compound_stat
| declarator compound_stat
;
decl : decl_specs init_declarator_list ';'
| decl_specs ';'
;
decl_list : decl
| decl_list decl
;
decl_specs : storage_class_spec decl_specs
| storage_class_spec
| type_spec decl_specs
| type_spec
| type_qualifier decl_specs
| type_qualifier
;
storage_class_spec : 'auto' | 'register' | 'static' | 'extern' | 'typedef'
;
type_spec : 'void' | 'char' | 'short' | 'int' | 'long' | 'float'
| 'double' | 'signed' | 'unsigned'
| struct_or_union_spec
| enum_spec
| typedef_name
;
type_qualifier : 'const' | 'volatile'
;
struct_or_union_spec : struct_or_union id '{' struct_decl_list '}'
| struct_or_union '{' struct_decl_list '}'
| struct_or_union id
;
struct_or_union : 'struct' | 'union'
;
struct_decl_list : struct_decl
| struct_decl_list struct_decl
;
init_declarator_list : init_declarator
| init_declarator_list ',' init_declarator
;
init_declarator : declarator
| declarator '=' initializer
;
struct_decl : spec_qualifier_list struct_declarator_list ';'
;
spec_qualifier_list : type_spec spec_qualifier_list
| type_spec
| type_qualifier spec_qualifier_list
| type_qualifier
;
struct_declarator_list : struct_declarator
| struct_declarator_list ',' struct_declarator
;
struct_declarator : declarator
| declarator ':' const_exp
| ':' const_exp
;
enum_spec : 'enum' id '{' enumerator_list '}'
| 'enum' '{' enumerator_list '}'
| 'enum' id
;
enumerator_list : enumerator
| enumerator_list ',' enumerator
;
enumerator : id
| id '=' const_exp
;
declarator : pointer direct_declarator
| direct_declarator
;
direct_declarator : id
| '(' declarator ')'
| direct_declarator '[' const_exp ']'
| direct_declarator '[' ']'
| direct_declarator '(' param_type_list ')'
| direct_declarator '(' id_list ')'
| direct_declarator '(' ')'
;
pointer : '*' type_qualifier_list
| '*'
| '*' type_qualifier_list pointer
| '*' pointer
;
type_qualifier_list : type_qualifier
| type_qualifier_list type_qualifier
;
param_type_list : param_list
| param_list ',' '...'
;
param_list : param_decl
| param_list ',' param_decl
;
param_decl : decl_specs declarator
| decl_specs abstract_declarator
| decl_specs
;
id_list : id
| id_list ',' id
;
initializer : assignment_exp
| '{' initializer_list '}'
| '{' initializer_list ',' '}'
;
initializer_list : initializer
| initializer_list ',' initializer
;
type_name : spec_qualifier_list abstract_declarator
| spec_qualifier_list
;
abstract_declarator : pointer
| pointer direct_abstract_declarator
| direct_abstract_declarator
;
direct_abstract_declarator: '(' abstract_declarator ')'
| direct_abstract_declarator '[' const_exp ']'
| '[' const_exp ']'
| direct_abstract_declarator '[' ']'
| '[' ']'
| direct_abstract_declarator '(' param_type_list ')'
| '(' param_type_list ')'
| direct_abstract_declarator '(' ')'
| '(' ')'
;
typedef_name : id
;
stat : labeled_stat
| exp_stat
| compound_stat
| selection_stat
| iteration_stat
| jump_stat
;
labeled_stat : id ':' stat
| 'case' const_exp ':' stat
| 'default' ':' stat
;
exp_stat : exp ';'
| ';'
;
compound_stat : '{' decl_list stat_list '}'
| '{' stat_list '}'
| '{' decl_list '}'
| '{' '}'
;
stat_list : stat
| stat_list stat
;
selection_stat : 'if' '(' exp ')' stat
| 'if' '(' exp ')' stat 'else' stat
| 'switch' '(' exp ')' stat
;
iteration_stat : 'while' '(' exp ')' stat
| 'do' stat 'while' '(' exp ')' ';'
| 'for' '(' exp ';' exp ';' exp ')' stat
| 'for' '(' exp ';' exp ';' ')' stat
| 'for' '(' exp ';' ';' exp ')' stat
| 'for' '(' exp ';' ';' ')' stat
| 'for' '(' ';' exp ';' exp ')' stat
| 'for' '(' ';' exp ';' ')' stat
| 'for' '(' ';' ';' exp ')' stat
| 'for' '(' ';' ';' ')' stat
;
jump_stat : 'goto' id ';'
| 'continue' ';'
| 'break' ';'
| 'return' exp ';'
| 'return' ';'
;
exp : assignment_exp
| exp ',' assignment_exp
;
assignment_exp : conditional_exp
| unary_exp assignment_operator assignment_exp
;
assignment_operator : '=' | '*=' | '/=' | '%=' | '+=' | '-=' | '<<='
| '>>=' | '&=' | '^=' | '|='
;
conditional_exp : logical_or_exp
| logical_or_exp '?' exp ':' conditional_exp
;
const_exp : conditional_exp
;
logical_or_exp : logical_and_exp
| logical_or_exp '||' logical_and_exp
;
logical_and_exp : inclusive_or_exp
| logical_and_exp '&&' inclusive_or_exp
;
inclusive_or_exp : exclusive_or_exp
| inclusive_or_exp '|' exclusive_or_exp
;
exclusive_or_exp : and_exp
| exclusive_or_exp '^' and_exp
;
and_exp : equality_exp
| and_exp '&' equality_exp
;
equality_exp : relational_exp
| equality_exp '==' relational_exp
| equality_exp '!=' relational_exp
;
relational_exp : shift_expression
| relational_exp '<' shift_expression
| relational_exp '>' shift_expression
| relational_exp '<=' shift_expression
| relational_exp '>=' shift_expression
;
shift_expression : additive_exp
| shift_expression '<<' additive_exp
| shift_expression '>>' additive_exp
;
additive_exp : mult_exp
| additive_exp '+' mult_exp
| additive_exp '-' mult_exp
;
mult_exp : cast_exp
| mult_exp '*' cast_exp
| mult_exp '/' cast_exp
| mult_exp '%' cast_exp
;
cast_exp : unary_exp
| '(' type_name ')' cast_exp
;
unary_exp : postfix_exp
| '++' unary_exp
| '--' unary_exp
| unary_operator cast_exp
| 'sizeof' unary_exp
| 'sizeof' '(' type_name ')'
;
unary_operator : '&' | '*' | '+' | '-' | '~' | '!'
;
postfix_exp : primary_exp
| postfix_exp '[' exp ']'
| postfix_exp '(' argument_exp_list ')'
| postfix_exp '(' ')'
| postfix_exp '.' id
| postfix_exp '->' id
| postfix_exp '++'
| postfix_exp '--'
;
primary_exp : id
| const
| string
| '(' exp ')'
;
argument_exp_list : assignment_exp
| argument_exp_list ',' assignment_exp
;
const : int_const
| char_const
| float_const
| enumeration_const
;
page revision: 0, last edited: 05 Apr 2010 13:16
Post preview:
Close preview