finish function node.

Parser.y: rename 'context' to 'ctx' to avoid conflict in new version bison.

1 files changed, 73 insertions, 51 deletions

diff --git a/Parser.y b/Parser.y
index 24b0424..c322dd3 100644
--- a/Parser.y
+++ b/Parser.y
@@ -17,11 +17,11 @@ namespace pcc{
 %locations
 
 %param {pcc::Driver& driver}
-%param {pcc::Context* context}
+%param {pcc::Context* ctx}
 
 %code{
 #define YY_DECL                                                                \
-    pcc::Parser::symbol_type yylex(pcc::Driver& driver, pcc::Context* context)
+    pcc::Parser::symbol_type yylex(pcc::Driver& driver, pcc::Context* ctx)
 
 YY_DECL;
 }
@@ -43,31 +43,47 @@ YY_DECL;
 %token INTEGER_LITERAL REAL_LITERAL STRING_LITERAL BOOLEAN_LITERAL CHAR_LITERAL
 
 %type <std::string> IDENTIFIER
+%type <std::shared_ptr<pcc::Type>> type
+%type <std::list<Declaration>> var_decls
+%type <std::pair<std::list<std::string>, std::shared_ptr<pcc::Type>>> var_decl
+%type <std::list<std::string>> vars
+
 %type <std::shared_ptr<pcc::BooleanLiteralNode>> BOOLEAN_LITERAL
 %type <std::shared_ptr<pcc::CharLiteralNode>> CHAR_LITERAL
 %type <std::shared_ptr<pcc::IntegerLiteralNode>> INTEGER_LITERAL
 %type <std::shared_ptr<pcc::RealLiteralNode>> REAL_LITERAL
 %type <std::shared_ptr<pcc::StringLiteralNode>> STRING_LITERAL
+%type <std::shared_ptr<pcc::ExprNode>> literal 
+
+%type <std::shared_ptr<pcc::ExprNode>> expression l1_expression l2_expression l3_expression
+%type <pcc::BinaryOperator> l1_operator l2_operator l3_operator
+%type <pcc::UnaryOperator> l4_operator
+
+%type <std::shared_ptr<pcc::StatementListNode>> statements statement_block
+
+%type <std::shared_ptr<pcc::FunctionNode>> function
+%type <std::list<std::shared_ptr<pcc::BaseNode>>> local_decls
+%type <std::shared_ptr<pcc::BaseNode>> local_decl
 
 %%
 
 /* ==================[global part]================== */
 
 program
-    : program_header decls functions
+    : program_header global_decls functions
     ;
 
 program_header
     : PROGRAM IDENTIFIER SEMICOLON
     ;
 
-decls 
-    : decls decl SEMICOLON
+global_decls
+    : global_decls global_decl SEMICOLON
     |
     ;
 
-decl
-    : VAR var_decls SEMICOLON
+global_decl
+    : VAR var_decls
     ;
 
 functions
@@ -78,34 +94,41 @@ functions
 /* ==================[var part]================== */
 
 var_decls
-    : var_decls SEMICOLON var_decl
-    | var_decl
+    : var_decls SEMICOLON var_decl  {$$=$1; auto NewChilds=std::get<0>($3); for(auto& name: NewChilds){$$.push_back({name, std::get<1>($3)});}}
+    | var_decl                      {auto NewChilds=std::get<0>($1); for(auto& name: NewChilds){$$.push_back({name, std::get<1>($1)});}}
     ;
 
 var_decl
-    : vars COLON type
+    : vars COLON type       {$$={$1,$3};}
     ;
 
 vars
-    : vars COMMA IDENTIFIER
-    | IDENTIFIER
+    : vars COMMA IDENTIFIER {$$=$1; $$.push_back($3);}
+    | IDENTIFIER            {$$.push_back($1);}
+    ;
 
 type
-    : INTEGER
-    | REAL
-    | BOOLEAN
-    | CHAR
-    | STRING
+    : BOOLEAN   {$$=ctx->GetTypeManager()->GetBuiltinType(pcc::BuiltinType::BOOLEAN);}
+    | CHAR      {$$=ctx->GetTypeManager()->GetBuiltinType(pcc::BuiltinType::CHAR);}
+    | INTEGER   {$$=ctx->GetTypeManager()->GetBuiltinType(pcc::BuiltinType::INTEGER);}
+    | REAL      {$$=ctx->GetTypeManager()->GetBuiltinType(pcc::BuiltinType::REAL);}
+    | STRING    {$$=ctx->GetTypeManager()->GetBuiltinType(pcc::BuiltinType::STRING);}
     ;
 
 /* ==================[function part]================== */
 
 function
-    : function_header decls statement_block
+    : FUNCTION IDENTIFIER LPARENTHESIS var_decls RPARENTHESIS COLON type SEMICOLON
+      local_decls statement_block
     ;
 
-function_header
-    : FUNCTION IDENTIFIER LPARENTHESIS var_decls RPARENTHESIS COLON type SEMICOLON
+local_decls 
+    : local_decls local_decl    {$$=$1; $$.push_back($2);}
+    |
+    ;
+
+local_decl
+    : VAR var_decls {$$=std::make_shared<pcc::VarDeclNode>(ctx, nullptr, $2);}
     ;
 
 /* ==================[statements part]================== */
@@ -154,56 +177,55 @@ assign_statement
 /* ==================[expression part]================== */
 
 expression
-    : l1_expression l1_operator expression
-    | l1_expression
+    : l1_expression l1_operator expression      {$$=std::make_shared<pcc::BinaryExprNode>(ctx,$2,$1,$3);}
+    | l1_expression                             {$$=$1;}
     ;
 
 l1_expression
-    : l1_expression l2_operator l2_expression
-    | l2_expression
+    : l1_expression l2_operator l2_expression   {$$=std::make_shared<pcc::BinaryExprNode>(ctx,$2,$1,$3);}
+    | l2_expression                             {$$=$1;}
     ;
 
 l2_expression
-    : l2_expression l3_operator l3_expression
-    | l3_expression
+    : l2_expression l3_operator l3_expression   {$$=std::make_shared<pcc::BinaryExprNode>(ctx,$2,$1,$3);}
+    | l3_expression                             {$$=$1;}
     ;
 
 l3_expression
     : lvalue
     | function_call
-    | literal
-    | LPARENTHESIS expression RPARENTHESIS
-    | l4_operator l3_expression
+    | literal                               {$$=$1;}
+    | LPARENTHESIS expression RPARENTHESIS  {$$=$2;}
+    | l4_operator l3_expression             {$$=std::make_shared<pcc::UnaryExprNode>(ctx,$1,$2);}
     ;
 
 l1_operator
-    : LT
-    | LE
-    | GT
-    | GE
-    | EQ
-    | NE
+    : LT        {$$=pcc::BinaryOperator::LT;}
+    | LE        {$$=pcc::BinaryOperator::LE;}
+    | GT        {$$=pcc::BinaryOperator::GT;}
+    | GE        {$$=pcc::BinaryOperator::GE;}
+    | EQ        {$$=pcc::BinaryOperator::EQ;}
+    | NE        {$$=pcc::BinaryOperator::NE;}
     ;
 
 l2_operator
-    : ADD
-    | SUB
-    | OR
-    | XOR
+    : ADD       {$$=pcc::BinaryOperator::ADD;}
+    | SUB       {$$=pcc::BinaryOperator::SUB;}
+    | OR        {$$=pcc::BinaryOperator::OR;}
+    | XOR       {$$=pcc::BinaryOperator::XOR;}
     ;
 
 l3_operator
-    : MUL
-    | REAL_DIV
-    | DIV
-    | MOD
-    | AND
+    : MUL       {$$=pcc::BinaryOperator::MUL;}
+    | DIV       {$$=pcc::BinaryOperator::DIV;}
+    | MOD       {$$=pcc::BinaryOperator::MOD;}
+    | AND       {$$=pcc::BinaryOperator::AND;}
     ;
 
 l4_operator
-    : NOT
-    | ADD
-    | SUB
+    : NOT   {$$=pcc::UnaryOperator::NOT;}
+    | ADD   {$$=pcc::UnaryOperator::POS;}
+    | SUB   {$$=pcc::UnaryOperator::NEG;}
     ;
 
 lvalue
@@ -223,10 +245,10 @@ arguments
     ;
 
 literal
-    : BOOLEAN_LITERAL
-    | INTEGER_LITERAL
-    | REAL_LITERAL
-    | STRING_LITERAL
+    : BOOLEAN_LITERAL   {$$=$1;}
+    | INTEGER_LITERAL   {$$=$1;}
+    | REAL_LITERAL      {$$=$1;}
+    | STRING_LITERAL    {$$=$1;}
     ;
 
 %%