# This improved version of the C grammar was provided by Joe Buehler

use Parse::RecDescent;

local $/;
my $grammar = <DATA>;
my $parser = Parse::RecDescent->new($grammar);

my $text = <>;

my $parse_tree = $parser->translation_unit($text) or die "bad C code";

use Data::Dumper 'Dumper';
warn Dumper [ $parse_tree ];

__DATA__
<autotree>

primary_expression:
	IDENTIFIER
	| CONSTANT
	| STRING_LITERAL
	| '(' expression ')'

postfix_expression_post:
	'[' expression ']'
	| '(' argument_expression_list(?) ')'
	| '.' IDENTIFIER
	| '->' IDENTIFIER
	| '++'
	| '--'

postfix_expression:
	primary_expression postfix_expression_post(s?)

argument_expression_list:
	assignment_expression (',' assignment_expression)(s?)

unary_expression:
	postfix_expression
	| '++' unary_expression
	| '--' unary_expression
	| unary_operator cast_expression
	| SIZEOF unary_expression
	| SIZEOF '(' type_name ')'

unary_operator:
	/[-&*+!~]/

cast_expression:
	'(' type_name ')' cast_expression
	| unary_expression

multiplicative_expression_op:
	/[*\/%]/

multiplicative_expression:
	cast_expression (multiplicative_expression_op cast_expression)(s?)

additive_expression_op:
	/[-+]/

additive_expression:
	multiplicative_expression (additive_expression_op multiplicative_expression)(s?)

shift_expression_pre_op:
	/(<<|>>)(?!=)/

shift_expression:
	additive_expression (shift_expression_pre_op additive_expression)(s?)

relational_expression_op:
	/(<=|>=|<|>)/

relational_expression:
	shift_expression (relational_expression_op shift_expression)(s?)

equality_expression_pre_op:
	/==|!=/

equality_expression:
	relational_expression (equality_expression_pre_op relational_expression)(s?)

and_expression:
	equality_expression ('&' equality_expression)(s?)

exclusive_or_expression:
	and_expression ('^' and_expression)(s?)

inclusive_or_expression:
	exclusive_or_expression ('|' exclusive_or_expression)(s?)

logical_and_expression:
	inclusive_or_expression ('&&' inclusive_or_expression)(s?)

logical_or_expression:
	logical_and_expression ('||' logical_and_expression)(s?)

conditional_expression:
	logical_or_expression ('?' expression ':' conditional_expression)(?)

assignment_expression:
	conditional_expression
	| unary_expression assignment_operator assignment_expression

assignment_operator:
	/=(?!=)|\+=|\&=|\/=|<<=|\%=|\*=|\|=|>>=|-=|\^=/

expression:
	assignment_expression (',' assignment_expression)(s?)

constant_expression:
	conditional_expression

declaration:
	declaration_specifiers init_declarator_list ';'
	| declaration_specifiers ';'

declaration_specifiers:
	( storage_class_specifier | type_specifier | type_qualifier )(s)

init_declarator_list:
	init_declarator (',' init_declarator)(s?)

init_declarator:
	declarator '=' initializer
	| declarator

storage_class_specifier:
	/(typedef|extern|static|auto|register)(?![a-zA-Z0-9_])/

type_specifier:
	/(void|char|short|int|long|float|double|signed|unsigned)(?![a-zA-Z0-9_])/
	| struct_or_union_specifier
	| enum_specifier
	| TYPE_NAME

struct_or_union_specifier:
	struct_or_union IDENTIFIER '{' struct_declaration_list '}'
	| struct_or_union '{' struct_declaration_list '}'
	| struct_or_union IDENTIFIER

struct_or_union:
	/(struct|union)(?![a-zA-Z0-9_])/

struct_declaration_list:
	struct_declaration(s)

struct_declaration:
	specifier_qualifier_list struct_declarator_list ';'

specifier_qualifier_list:
	( type_specifier | type_qualifier )(s)

struct_declarator_list:
	struct_declarator (',' struct_declarator)(s?)

struct_declarator:
	declarator ':' constant_expression
	| declarator
	| ':' constant_expression

enum_specifier:
	ENUM '{' enumerator_list '}'
	| ENUM IDENTIFIER '{' enumerator_list '}'
	| ENUM IDENTIFIER

enumerator_list:
	enumerator (',' enumerator)(s?)

enumerator:
	IDENTIFIER '=' constant_expression
	| IDENTIFIER

type_qualifier:
	/(const|volatile)(?![a-zA-Z0-9_])/

declarator:
	pointer(?) direct_declarator

direct_declarator_pre:
	IDENTIFIER
	| '(' declarator ')'

direct_declarator_post:
	'[' constant_expression ']'
	| '[' ']'
	| '(' parameter_type_list ')'
	| '(' identifier_list ')'
	| '(' ')'

direct_declarator:
	direct_declarator_pre direct_declarator_post(s?)

pointer:
	'*' type_qualifier_list(?) pointer(?)

type_qualifier_list:
	type_qualifier(s)

parameter_type_list:
	parameter_list ',' '...'
	| parameter_list

parameter_list:
	parameter_declaration (',' parameter_declaration)(s?)

parameter_declaration:
	declaration_specifiers declarator
	| declaration_specifiers abstract_declarator(?)

identifier_list:
	IDENTIFIER (',' IDENTIFIER)(s?)

type_name:
	specifier_qualifier_list abstract_declarator(?)

abstract_declarator:
	pointer direct_abstract_declarator(?)
	| direct_abstract_declarator

direct_abstract_declarator_pre:
	'(' abstract_declarator ')'
	| direct_abstract_declarator_post

direct_abstract_declarator_post:
	'[' ']'
	| '[' constant_expression ']'
	| '(' ')'
	| '(' parameter_type_list ')'

direct_abstract_declarator:
	direct_abstract_declarator_pre direct_abstract_declarator_post(s?)

initializer:
	assignment_expression
	| '{' initializer_list '}'
	| '{' initializer_list ',' '}'

initializer_list:
	initializer (',' initializer)(s?)

statement:
	labeled_statement
	| compound_statement
	| expression_statement
	| selection_statement
	| iteration_statement
	| jump_statement

labeled_statement:
	IDENTIFIER ':' statement
	| /case(?![a-zA-Z0-9_])/ constant_expression ':' statement
	| /default(?![a-zA-Z0-9_])/ ':' statement

compound_statement:
	'{' declaration_list statement_list(?) '}'
	| '{' statement_list(?) '}'

declaration_list:
	declaration(s)

statement_list:
	statement(s)

expression_statement:
	expression(?) ';'

selection_statement:
	IF '(' expression ')' statement ELSE statement
	| IF '(' expression ')' statement
	| SWITCH '(' expression ')' statement

iteration_statement:
	WHILE '(' expression ')' statement
	| DO statement WHILE '(' expression ')' ';'
	| FOR '(' expression_statement expression_statement expression(?) ')' statement

jump_statement:
	/goto(?![a-zA-Z0-9_])/ IDENTIFIER ';'
	| /continue(?![a-zA-Z0-9_])/ ';'
	| /break(?![a-zA-Z0-9_])/ ';'
	| /return(?![a-zA-Z0-9_])/ expression(?) ';'

translation_unit:
	external_declaration(s)

external_declaration:
	function_definition { print "*** function\n"; }
	| declaration { print "*** declaration\n"; }

function_definition:
	declaration_specifiers declarator(?) declaration_list(?) compound_statement

reserved_word:
	/(auto|break|case|char|const|continue|default|do|double|enum|extern|float|for|goto|if|int|long|register|return|short|signed|sizeof|static|struct|switch|typedef|union|unsigned|void|volatile|while)(?![a-zA-Z0-9_])/

CONSTANT:       /[+-]?(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?/
DO:             /do(?![a-zA-Z0-9_])/
ELSE:           /else(?![a-zA-Z0-9_])/
ENUM:           /enum(?![a-zA-Z0-9_])/
FOR:            /for(?![a-zA-Z0-9_])/
IDENTIFIER:     ...!reserved_word /[a-zA-Z_][a-zA-Z_0-9]*/
IF:             /if(?![a-zA-Z0-9_])/
SIZEOF:         /sizeof(?![a-zA-Z0-9_])/
STRING_LITERAL: { extract_delimited($text,'"') }
SWITCH:         /switch(?![a-zA-Z0-9_])/
TYPE_NAME:      ...!reserved_word /[a-zA-Z_][a-zA-Z_0-9]*/ ...IDENTIFIER
				| ...!reserved_word /[a-zA-Z_][a-zA-Z_0-9]*/ .../[:*)]/
WHILE:          /while(?![a-zA-Z0-9_])/