head 1.1; branch 1.1.1; access ; symbols start:1.1.1.1 initial:1.1.1; locks ; strict; comment @# @; expand @b@; 1.1 date 2007.08.10.02.40.53; author arish.alreja; state Exp; branches 1.1.1.1; next ; commitid 25f846bbd0344567; 1.1.1.1 date 2007.08.10.02.40.53; author arish.alreja; state Exp; branches ; next ; commitid 25f846bbd0344567; desc @@ 1.1 log @Initial revision @ text @ %{ #include #include "Node.hh" #include "Name.hh" extern int yylex(); extern int yyparse(); extern int yyerror(const char *); extern FILE * out; %} %token EOFILE ERROR %token IDENTIFIER CONSTANT STRING_LITERAL SIZEOF ASM %token PTR_OP INC_OP DEC_OP LEFT_OP RIGHT_OP LE_OP GE_OP EQ_OP NE_OP %token AND_OP OR_OP MUL_ASSIGN DIV_ASSIGN MOD_ASSIGN ADD_ASSIGN %token SUB_ASSIGN LEFT_ASSIGN RIGHT_ASSIGN AND_ASSIGN %token XOR_ASSIGN OR_ASSIGN TYPE_NAME %token TYPEDEF EXTERN STATIC AUTO REGISTER %token CHAR SHORT INT LONG SIGNED UNSIGNED FLOAT DOUBLE CONST VOLATILE VOID %token STRUCT UNION ENUM ELLIPSIS %token CASE DEFAULT IF ELSE SWITCH WHILE DO FOR GOTO CONTINUE BREAK RETURN %expect 1 %start all %union { NumericConstant * _num; const char *_name; StringConstant *_string_constant; BinExprType _bin_expr_type; UnaExprType _una_expr_type; Specifier _specifier; Expression *_expr; Pointer *_pointer; IdentifierList *_identifier_list; Initializer *_initializer; InitializerList *_initializer_list; ParameterDeclaration *_parameter_declaration; ParameterDeclarationList *_parameter_declaration_list; Declarator *_declarator; Enumerator *_enumerator; EnumeratorList *_enumerator_list; StructDeclarator *_struct_declarator; StructDeclaratorList *_struct_declarator_list; StructDeclaration *_struct_declaration; StructDeclarationList *_struct_declaration_list; TypeSpecifier *_type_specifier; InitDeclarator *_init_declarator; InitDeclaratorList *_init_declarator_list; Declaration *_declaration; DeclarationList *_declaration_list; TypeName *_type_name; Statement *_statement; ExpressionStatement *_expression_statement; CompoundStatement *_compound_statement; StatementList *_statement_list; FunctionDefinition *_function_definition; } %type <_function_definition> function_definition function_head %type <_statement_list> statement_list %type <_statement> statement labeled_statement selection_statement iteration_statement jump_statement %type <_expression_statement> expression_statement %type <_compound_statement> compound_statement %type <_type_name> type_name %type <_declaration_list> declaration_list %type <_declaration> declaration %type <_init_declarator> init_declarator %type <_init_declarator_list> init_declarator_list %type <_type_specifier> struct_or_union_specifier type_specifier enum_specifier declaration_specifiers type_qualifier_list specifier_qualifier_list type_qualifier %type <_struct_declaration_list> struct_declaration_list %type <_struct_declaration> struct_declaration %type <_struct_declarator_list> struct_declarator_list %type <_struct_declarator> struct_declarator %type <_enumerator> enumerator %type <_enumerator_list> enumerator_list %type <_declarator> declarator direct_declarator abstract_declarator direct_abstract_declarator %type <_parameter_declaration> parameter_declaration %type <_parameter_declaration_list> parameter_list %type <_initializer> initializer %type <_initializer_list> initializer_list %type <_identifier_list> identifier_list %type <_pointer> pointer %type <_specifier> struct_or_union %type <_una_expr_type> unary_operator %type <_bin_expr_type> assignment_operator %type <_name> IDENTIFIER TYPE_NAME %type <_string_constant> STRING_LITERAL string_sequence %type <_num> CONSTANT %type <_expr> expression primary_expression postfix_expression argument_expression_list unary_expression cast_expression multiplicative_expression additive_expression shift_expression relational_expression equality_expression and_expression exclusive_or_expression inclusive_or_expression logical_and_expression logical_or_expression conditional_expression assignment_expression constant_expression %% all : translation_unit EOFILE { StringConstant::EmitAll(out); return 0; } ; primary_expression : IDENTIFIER { $$ = IdentifierExpression::New($1); } | CONSTANT { $$ = new NumericExpression($1); } | string_sequence { $$ = new StringExpression($1); } | '(' expression ')' { $$ = $2; } | ASM '(' string_sequence ')' { $$ = new AsmExpression($3); } ; string_sequence : STRING_LITERAL { $$ = $1; } | string_sequence STRING_LITERAL { $$ = *$1 & $2; } ; postfix_expression : primary_expression { $$ = $1; } | postfix_expression '[' expression ']' { $$ = BinaryExpression::New(ET_ELEMENT, $1, $3); } | postfix_expression '(' ')' { $$ = BinaryExpression::New(ET_FUNCALL, $1, 0); } | postfix_expression '(' argument_expression_list ')' { $$ = BinaryExpression::New(ET_FUNCALL, $1, $3); } | postfix_expression '.' IDENTIFIER { $$ = new MemberExpression(false, $1, $3); } | postfix_expression PTR_OP IDENTIFIER { $$ = new MemberExpression(true, $1, $3); } | postfix_expression INC_OP { $$ = UnaryExpression::New(ET_POSTINC, $1); } | postfix_expression DEC_OP { $$ = UnaryExpression::New(ET_POSTDEC, $1); } ; argument_expression_list : assignment_expression { $$ = $1; } | argument_expression_list ',' assignment_expression { $$ = new ArgListExpression($1, $3); } ; unary_expression : postfix_expression { $$ = $1; } | INC_OP unary_expression { $$ = UnaryExpression::New(ET_PREINC, $2); } | DEC_OP unary_expression { $$ = UnaryExpression::New(ET_PREDEC, $2); } | unary_operator cast_expression { $$ = UnaryExpression::New($1, $2); } | SIZEOF unary_expression { $$ = new NumericExpression($2); } | SIZEOF '(' type_name ')' { $$ = new NumericExpression($3); } ; unary_operator : '&' { $$ = ET_ADDRESS; } | '*' { $$ = ET_CONTENT; } | '+' { $$ = ET_CONJUGATE; } | '-' { $$ = ET_NEGATE; } | '~' { $$ = ET_COMPLEMENT; } | '!' { $$ = ET_LOG_NOT; } ; cast_expression : unary_expression { $$ = $1; } | '(' type_name ')' cast_expression { $$ = new UnaryExpression($2, $4); } ; multiplicative_expression : cast_expression { $$ = $1; } | multiplicative_expression '*' cast_expression { $$ = BinaryExpression::New(ET_MULT, $1, $3); } | multiplicative_expression '/' cast_expression { $$ = BinaryExpression::New(ET_DIV, $1, $3); } | multiplicative_expression '%' cast_expression { $$ = BinaryExpression::New(ET_MOD, $1, $3); } ; additive_expression : multiplicative_expression { $$ = $1; } | additive_expression '+' multiplicative_expression { $$ = AdditionExpression::New($1, $3); } | additive_expression '-' multiplicative_expression { $$ = SubtractionExpression::New($1, $3); } ; shift_expression : additive_expression { $$ = $1; } | shift_expression LEFT_OP additive_expression { $$ = BinaryExpression::New(ET_LEFT, $1, $3); } | shift_expression RIGHT_OP additive_expression { $$ = BinaryExpression::New(ET_RIGHT, $1, $3); } ; relational_expression : shift_expression { $$ = $1; } | relational_expression '<' shift_expression { $$ = BinaryExpression::New(ET_LESS, $1, $3); } | relational_expression '>' shift_expression { $$ = BinaryExpression::New(ET_GREATER, $1, $3); } | relational_expression LE_OP shift_expression { $$ = BinaryExpression::New(ET_LESS_EQUAL, $1, $3); } | relational_expression GE_OP shift_expression { $$ = BinaryExpression::New(ET_GREATER_EQUAL, $1, $3); } ; equality_expression : relational_expression { $$ = $1; } | equality_expression EQ_OP relational_expression { $$ = BinaryExpression::New(ET_EQUAL, $1, $3); } | equality_expression NE_OP relational_expression { $$ = BinaryExpression::New(ET_NOT_EQUAL, $1, $3); } ; and_expression : equality_expression { $$ = $1; } | and_expression '&' equality_expression { $$ = BinaryExpression::New(ET_BIT_AND, $1, $3); } ; exclusive_or_expression : and_expression { $$ = $1; } | exclusive_or_expression '^' and_expression { $$ = BinaryExpression::New(ET_BIT_XOR, $1, $3); } ; inclusive_or_expression : exclusive_or_expression { $$ = $1; } | inclusive_or_expression '|' exclusive_or_expression { $$ = BinaryExpression::New(ET_BIT_OR, $1, $3); } ; logical_and_expression : inclusive_or_expression { $$ = $1; } | logical_and_expression AND_OP inclusive_or_expression { $$ = BinaryExpression::New(ET_LOG_AND, $1, $3); } ; logical_or_expression : logical_and_expression { $$ = $1; } | logical_or_expression OR_OP logical_and_expression { $$ = BinaryExpression::New(ET_LOG_OR, $1, $3); } ; conditional_expression : logical_or_expression { $$ = $1; } | logical_or_expression '?' expression ':' conditional_expression { $$ = new CondExpression($1, $3, $5); } ; assignment_expression : conditional_expression { $$ = $1; } | unary_expression assignment_operator assignment_expression { $$ = BinaryExpression::New($2, $1, $3); } ; assignment_operator : '=' { $$ = ET_ASSIGN; } | MUL_ASSIGN { $$ = ET_MULT_ASSIGN; } | DIV_ASSIGN { $$ = ET_DIV_ASSIGN; } | MOD_ASSIGN { $$ = ET_MOD_ASSIGN; } | ADD_ASSIGN { $$ = ET_ADD_ASSIGN; } | SUB_ASSIGN { $$ = ET_SUB_ASSIGN; } | LEFT_ASSIGN { $$ = ET_LEFT_ASSIGN; } | RIGHT_ASSIGN { $$ = ET_RIGHT_ASSIGN; } | AND_ASSIGN { $$ = ET_AND_ASSIGN; } | XOR_ASSIGN { $$ = ET_XOR_ASSIGN; } | OR_ASSIGN { $$ = ET_OR_ASSIGN; } ; expression : assignment_expression { $$ = $1; } | expression ',' assignment_expression { $$ = BinaryExpression::New(ET_LIST, $1, $3); } ; constant_expression : conditional_expression { $$ = $1; } ; declaration : declaration_specifiers ';' { $$ = new Declaration($1, 0); } | declaration_specifiers init_declarator_list ';' { $$ = new Declaration($1, $2); } ; declaration_specifiers : type_specifier { $$ = $1; } | type_qualifier { $$ = $1; } | type_specifier declaration_specifiers { $$ = *$2 + *$1; } | type_qualifier declaration_specifiers { $$ = *$2 + *$1; } ; init_declarator_list : init_declarator { $$ = new InitDeclaratorList($1, 0); } | init_declarator ',' init_declarator_list { $$ = new InitDeclaratorList($1, $3); } ; init_declarator : declarator { $$ = new InitDeclarator($1, 0); } | declarator '=' initializer { $$ = new InitDeclarator($1, $3); } ; type_specifier // storage class : TYPEDEF { $$ = new TypeSpecifier(SC_TYPEDEF); } | EXTERN { $$ = new TypeSpecifier(SC_EXTERN); } | STATIC { $$ = new TypeSpecifier(SC_STATIC); } | AUTO { $$ = new TypeSpecifier(SC_AUTO); } | REGISTER { $$ = new TypeSpecifier(SC_REGISTER); } // type | VOID { $$ = new TypeSpecifier(TS_VOID); } | CHAR { $$ = new TypeSpecifier(TS_CHAR); } | SHORT { $$ = new TypeSpecifier(TS_SHORT); } | INT { $$ = new TypeSpecifier(TS_INT); } | LONG { $$ = new TypeSpecifier(TS_LONG); } | FLOAT { $$ = new TypeSpecifier(TS_FLOAT); } | DOUBLE { $$ = new TypeSpecifier(TS_DOUBLE); } | SIGNED { $$ = new TypeSpecifier(TS_SIGNED); } | UNSIGNED { $$ = new TypeSpecifier(TS_UNSIGNED); } | struct_or_union_specifier { $$ = $1; } | enum_specifier { $$ = $1; } | TYPE_NAME { $$ = new TypeSpecifier(TS_TYPE_NAME, $1, 0); } ; struct_or_union_specifier : struct_or_union IDENTIFIER '{' struct_declaration_list '}' { $$ = new TypeSpecifier($1, $2, $4); } | struct_or_union '{' struct_declaration_list '}' { $$ = new TypeSpecifier($1, 0, $3); } | struct_or_union IDENTIFIER { $$ = new TypeSpecifier($1, $2, 0); } ; struct_or_union : STRUCT { $$ = TS_STRUCT; } | UNION { $$ = TS_UNION; } ; struct_declaration_list : struct_declaration { $$ = new StructDeclarationList($1, 0); } | struct_declaration struct_declaration_list { $$ = new StructDeclarationList($1, $2); } ; struct_declaration : specifier_qualifier_list struct_declarator_list ';' { $$ = new StructDeclaration($1, $2); } ; specifier_qualifier_list : type_specifier { $$ = $1; } | type_qualifier { $$ = $1; } | type_specifier specifier_qualifier_list { $$=*$1 + *$2; } | type_qualifier specifier_qualifier_list { $$=*$1 + *$2; } ; struct_declarator_list : struct_declarator { $$ = new StructDeclaratorList($1, 0); } | struct_declarator ',' struct_declarator_list { $$ = new StructDeclaratorList($1, $3); } ; struct_declarator : declarator { $$ = new StructDeclarator($1, 0); } | ':' constant_expression { $$ = new StructDeclarator( 0, $2); } | declarator ':' constant_expression { $$ = new StructDeclarator($1, $3); } ; enum_specifier : ENUM '{' enumerator_list '}' { $$ = new TypeSpecifier( 0, $3); } | ENUM IDENTIFIER '{' enumerator_list '}' { $$ = new TypeSpecifier($2, $4); } | ENUM IDENTIFIER { $$ = new TypeSpecifier(TS_ENUM); } ; enumerator_list : enumerator { $$ = new EnumeratorList($1, 0); } | enumerator ',' enumerator_list { $$ = new EnumeratorList($1, $3); } ; enumerator : IDENTIFIER { $$ = new Enumerator($1, 0); } | IDENTIFIER '=' constant_expression { $$ = new Enumerator($1, $3); } ; type_qualifier : CONST { $$ = new TypeSpecifier(TQ_CONST); } | VOLATILE { $$ = new TypeSpecifier(TQ_VOLATILE); } ; declarator : pointer direct_declarator { $$ = new Declarator(new DeclItem($1), $2->Reverse()); } | direct_declarator { $$ = $1->Reverse(); } ; direct_declarator : IDENTIFIER { $$ = new Declarator(new DeclItem($1), 0); } | '(' declarator ')' { $$ = new Declarator(new DeclItem($2), 0); } | direct_declarator '[' constant_expression ']' { $$ = new Declarator(new DeclItem($3), $1); } | direct_declarator '[' ']' { $$ = new Declarator(new DeclItem(DECL_ARRAY), $1); } | direct_declarator '(' parameter_list ')' { $$ = new Declarator(new DeclItem($3), $1); } | direct_declarator '(' identifier_list ')' { $$ = new Declarator(new DeclItem($3), $1); } | direct_declarator '(' ')' { $$ = new Declarator(new DeclItem(DECL_FUN), $1); } ; pointer : '*' { $$ = new Pointer(new Ptr(0), 0); } | '*' type_qualifier_list { $$ = new Pointer(new Ptr($2), 0); } | '*' pointer { $$ = new Pointer(new Ptr(0), $2); } | '*' type_qualifier_list pointer { $$ = new Pointer(new Ptr($2), $3); } ; type_qualifier_list : type_qualifier { $$ = $1 } | type_qualifier type_qualifier_list { $$ = *$1 + *$2; } ; parameter_list : parameter_declaration { $$ = new ParameterDeclarationList($1, 0); } | ELLIPSIS { $$ = new ParameterDeclarationList( 0, 0); } | parameter_declaration ',' parameter_list { if ($3->Head()) $$ = new ParameterDeclarationList($1, $3); else $$ = $3->SetHead($1->SetEllipsis()); } ; parameter_declaration : declaration_specifiers declarator { $$ = new ParameterDeclaration($1, $2); } | declaration_specifiers abstract_declarator { $$ = new ParameterDeclaration($1, $2); } | declaration_specifiers { $$ = new ParameterDeclaration($1, 0); } ; identifier_list : IDENTIFIER { $$ = new IdentifierList(new Identifier($1), 0); } | IDENTIFIER ',' identifier_list { $$ = new IdentifierList(new Identifier($1), $3); } ; type_name : specifier_qualifier_list { assert($1); $$ = new TypeName($1, 0); } | specifier_qualifier_list abstract_declarator { assert($1); $$ = new TypeName($1, $2); } ; abstract_declarator : pointer { $$ = new Declarator(new DeclItem($1), 0); } | direct_abstract_declarator { $$ = $1->Reverse(); } | pointer direct_abstract_declarator { $$ = new Declarator(new DeclItem($1), $2->Reverse()); } ; direct_abstract_declarator : '(' abstract_declarator ')' { $$ = new Declarator(new DeclItem($2), 0); } | '[' ']' { $$ = new Declarator(new DeclItem(DECL_ARRAY), 0); } | '[' constant_expression ']' { $$ = new Declarator(new DeclItem($2), 0); } | '(' ')' { $$ = new Declarator(new DeclItem(DECL_FUN), 0); } | '(' parameter_list ')' { $$ = new Declarator(new DeclItem($2), 0); } | direct_abstract_declarator '[' ']' { $$ = new Declarator(new DeclItem(DECL_ARRAY), $1); } | direct_abstract_declarator '[' constant_expression ']' { $$ = new Declarator(new DeclItem($3), $1); } | direct_abstract_declarator '(' ')' { $$ = new Declarator(new DeclItem(DECL_FUN), $1); } | direct_abstract_declarator '(' parameter_list ')' { $$ = new Declarator(new DeclItem($3), $1); } ; initializer : assignment_expression { $$ = new Initializer($1); } | '{' initializer_list '}' { $$ = new Initializer($2->Reverse()); } | '{' initializer_list ',' '}' { $$ = new Initializer($2->Reverse()); } ; initializer_list : initializer { $$ = new InitializerList($1, 0); } | initializer_list ',' initializer { $$ = new InitializerList($3, $1); } ; statement : labeled_statement { $$ = $1; } | compound_statement { $$ = $1; } | expression_statement { $$ = $1; } | selection_statement { $$ = $1; } | iteration_statement { $$ = $1; } | jump_statement { $$ = $1; } ; labeled_statement : IDENTIFIER ':' statement { $$ = new LabelStatement($1, $3); } | CASE constant_expression ':' statement { $$ = new CaseStatement($2, $4); } | DEFAULT ':' statement { $$ = new CaseStatement(0, $3); } ; compound_statement : '{' '}' { $$ = new CompoundStatement( 0, 0); } | '{' statement_list '}' { $$ = new CompoundStatement( 0, $2); } | '{' declaration_list '}' { $$ = new CompoundStatement($2, 0); } | '{' declaration_list statement_list '}' { $$ = new CompoundStatement($2, $3); } ; declaration_list : declaration { $$ = new DeclarationList($1, 0); } | declaration declaration_list { $$ = new DeclarationList($1, $2); } ; statement_list : statement { $$ = new StatementList($1, 0); } | statement statement_list { $$ = new StatementList($1, $2); } ; expression_statement : ';' { $$ = new ExpressionStatement(0); } | expression ';' { $$ = new ExpressionStatement($1); } | error ';' { $$ = new ExpressionStatement(0); Node::Error(); } ; selection_statement : IF '(' expression ')' statement { $$ = new IfElseStatement($3, $5, 0); } | IF '(' expression ')' statement ELSE statement { $$ = new IfElseStatement($3, $5, $7); } | SWITCH '(' expression ')' compound_statement { $$ = new SwitchStatement($3, $5); } ; iteration_statement : WHILE '(' expression ')' statement { $$ = new WhileStatement($3, $5); } | DO statement WHILE '(' expression ')' ';' { $$ = new DoWhileStatement($2, $5); } | FOR '(' expression_statement expression_statement ')' statement { $$ = new ForStatement($3, $4, 0, $6); } | FOR '(' expression_statement expression_statement expression ')' statement { $$ = new ForStatement($3, $4, $5, $7); } ; jump_statement : GOTO IDENTIFIER ';' { $$ = new GotoStatement($2); } | CONTINUE ';' { $$ = new ContStatement(false); } | BREAK ';' { $$ = new ContStatement(true); } | RETURN ';' { $$ = new ReturnStatement(0); } | RETURN expression ';' { $$ = new ReturnStatement($2); } ; translation_unit : external_declaration { } | external_declaration translation_unit { } ; external_declaration : function_definition { $1->Emit(out); fprintf(out, ";;; ------------------------------------;\n"); } | declaration { if ($1) $1->Emit(out); fprintf(out, ";;; ------------------------------------;\n"); } | error { Node::Error(); fprintf(out, ";;; SYNTAX ERROR\n" ";;; ------------------------------------;\n"); } ; function_head : declaration_specifiers declarator declaration_list { $$ = new FunctionDefinition($1, $2, $3); } | declaration_specifiers declarator { $$ = new FunctionDefinition($1, $2, 0); } | declarator declaration_list { $$ = new FunctionDefinition( 0, $1, $2); } | declarator { $$ = new FunctionDefinition( 0, $1, 0); } ; function_definition : function_head compound_statement { $$ = $1->SetBody($2); } ; %% @ 1.1.1.1 log @Initial Commit @ text @@