转载地址：http://lists.canonical.org/pipermail/kragen-hacks/1999-October/000201.html
The C grammar in K&R 2nd Ed is fairly simple, only about 5 pages.
Here it is, translated to BNF. Here ( ) groups, ? means optional, |
is alternation, + means one or more, * means zero or more, space means
sequence, and "x" means literal x. As a special abbreviation, x% means
x ("," x)* -- that is, a non-null comma-separated list of x's.
I did this with the idea of writing a bare-bones recursive-descent parser
for the language. Accordingly, I have eschewed left recursion, and in
general have eschewed recursion as a method of iteration, preferring
explicit iteration. I think the only recursion remaining is where
recursion is really necessary. This resulted in the elimination of
many nonterminals.
I don't know if I will actually carry the implementation as code through,
though.
Discarded nonterminals: external-declaration struct-or-union
struct-declaration-list specifier-qualifier-list struct-declarator-list
enumerator-list init-declarator-list direct-declarator type-qualifier-list
parameter-list identifier-list initializer-list direct-abstract-declarator
labeled-statement expression-statement declaration-list statement-list
primary-expression typedef-name selection-statement
iteration-statement jump-statement argument-expression-list
unary-operator asssignment-operator
Renamed symbols: compound-statement -> block
40 nonterminals; I discarded 25. Also, I turned typedef-name into a terminal.
Original grammar has a total of 65 nonterminals.
C grammar begins here:
Terminals:
typedef-name integer-constant character-constant floating-constant
enumeration-constant identifier
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
C grammar ends here.
Notes:
Empty struct declarations (struct foo { }) are not legal in the grammar.
Neither are empty enum declarations (enum foo { }) or empty declaration
lists (int;).
Some comments in the book indicate that the book's expression grammar
captures both precedence and associativity. This was a matter of
some concern to me; making iteration happen with Kleene stars instead
of recursion eliminates the information on associativity. But the
book appears to be incorrect; its grammar captures precedence, but
none of the *-expression nonterminals are right-recursive, and most
of them are left-recursive. So if you parse according to the grammar,
all your operators will associate from left to right.
The split between cast-expression and unary-expression exists mainly to
try to keep you from incrementing or decrementing the results of casts,
I think, but it is ineffective, because an extra set of parens is all
you need. In other words, --(int)x doesn't parse with this grammar,
but --((int)x) does.
There are obviously many constraints on the language that the grammar
cannot express. In particular, constant-expression is subject to some
constraints, and many operators require modifiable lvalues for one of
their operands. It appears that some attempt to capture this has been
made in this grammar, but it would require a much larger grammar to
be successful.
There are also obviously many pieces of semantic information that the
original grammar conveyed by the name of the nonterminal that this
grammar does not convey.
I suspect this grammar still needs some work before I can use it for a
recursive-descent parser. I'm worried about how to tell labels from
variable names starting C statements (they are in separate namespaces,
so the typedef-name trick won't work) and how to tell casts from
parenthesized expressions.
For fun, I wrote the following, in the same language as the C grammar.
Grammar grammar begins here:
Terminals: identifier quoted-string blank-line
grammar:
blank-line*
terminals-decl
blank-line+
(definition blank-line+)*
definition?
terminals-decl: "Terminals" ":" identifier*
definition: identifier ":" alternation-regex
alternation-regex: simple-regex ("|" simple-regex)*
simple-regex:
(
(identifier | quoted-string | "(" alternation-regex ")")
("+" | "*" | "?" | "%")*
)*
Grammar grammar ends here.