Subversion Repositories c16

%{

#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);                                 }

        ;

%%