Parse variable declarations
This commit is contained in:
254
source/parser.yy
254
source/parser.yy
@@ -4,29 +4,28 @@
|
||||
%code requires {
|
||||
#include <cstdint>
|
||||
#include <iostream>
|
||||
#include "elna/source/ast.hpp"
|
||||
#include "elna/source/driver.hpp"
|
||||
|
||||
|
||||
#if ! defined(yyFlexLexerOnce)
|
||||
#if !defined(yyFlexLexerOnce)
|
||||
#include <FlexLexer.h>
|
||||
#endif
|
||||
|
||||
namespace elna::syntax
|
||||
namespace elna::source
|
||||
{
|
||||
class FooLexer;
|
||||
class lexer;
|
||||
}
|
||||
}
|
||||
|
||||
%code provides {
|
||||
namespace elna::syntax
|
||||
namespace elna::source
|
||||
{
|
||||
|
||||
class FooLexer : public yyFlexLexer
|
||||
class lexer: public yyFlexLexer
|
||||
{
|
||||
public:
|
||||
yy::location location;
|
||||
|
||||
FooLexer(std::istream& arg_yyin)
|
||||
lexer(std::istream& arg_yyin)
|
||||
: yyFlexLexer(&arg_yyin)
|
||||
{
|
||||
}
|
||||
@@ -42,8 +41,8 @@
|
||||
%define api.value.type variant
|
||||
%define parse.assert
|
||||
|
||||
%parse-param {elna::syntax::FooLexer& lexer}
|
||||
%parse-param {std::unique_ptr<elna::source::program>& program}
|
||||
%parse-param {elna::source::lexer& lexer}
|
||||
%parse-param {elna::source::driver& driver}
|
||||
%locations
|
||||
|
||||
%header
|
||||
@@ -66,14 +65,46 @@
|
||||
%token ASSIGNMENT COLON HAT AT
|
||||
|
||||
%type <std::unique_ptr<elna::source::integer_literal>> integer_literal;
|
||||
%type <std::unique_ptr<elna::source::boolean_literal>> boolean_literal;
|
||||
%type <std::unique_ptr<elna::source::constant_definition>> constant_definition;
|
||||
%type <std::vector<std::unique_ptr<elna::source::constant_definition>>> constant_definition_part constant_definitions;
|
||||
%type <std::unique_ptr<elna::source::declaration>> variable_declaration;
|
||||
%type <std::vector<std::unique_ptr<elna::source::declaration>>> variable_declarations variable_declaration_part
|
||||
formal_parameter_list;
|
||||
%type <std::unique_ptr<elna::source::type_expression>> type_expression;
|
||||
%type <std::unique_ptr<elna::source::expression>> expression pointer summand factor address;
|
||||
%type <std::vector<std::unique_ptr<elna::source::expression>>> expressions actual_parameter_list;
|
||||
%type <std::unique_ptr<elna::source::variable_expression>> variable_expression;
|
||||
%type <std::unique_ptr<elna::source::compound_statement>> compound_statement;
|
||||
%type <std::unique_ptr<elna::source::assign_statement>> assign_statement;
|
||||
%type <std::unique_ptr<elna::source::call_statement>> call_statement;
|
||||
%type <std::unique_ptr<elna::source::while_statement>> while_statement;
|
||||
%type <std::unique_ptr<elna::source::if_statement>> if_statement;
|
||||
%type <std::unique_ptr<elna::source::statement>> statement;
|
||||
%type <std::vector<std::unique_ptr<elna::source::statement>>> statements optional_statements;
|
||||
%type <std::unique_ptr<elna::source::procedure_definition>> procedure_definition;
|
||||
%type <std::vector<std::unique_ptr<elna::source::procedure_definition>>> procedure_definitions;
|
||||
%type <std::unique_ptr<elna::source::block>> block;
|
||||
%%
|
||||
program: constant_definition_part
|
||||
program: constant_definition_part variable_declaration_part procedure_definitions statement DOT
|
||||
{
|
||||
std::vector<std::unique_ptr<elna::source::definition>> definitions($1.size() + $3.size());
|
||||
std::vector<std::unique_ptr<elna::source::definition>>::iterator definition = definitions.begin();
|
||||
|
||||
for (auto& constant : $1)
|
||||
{
|
||||
*definition++ = std::move(constant);
|
||||
}
|
||||
for (auto& constant : $3)
|
||||
{
|
||||
*definition++ = std::move(constant);
|
||||
}
|
||||
driver.tree = std::make_unique<elna::source::program>(elna::source::position{},
|
||||
std::move(definitions), std::move($2),
|
||||
std::move($4));
|
||||
}
|
||||
block: constant_definition_part variable_declaration_part statement
|
||||
{
|
||||
elna::source::position position;
|
||||
std::vector<std::unique_ptr<elna::source::declaration>> declarations;
|
||||
std::vector<std::unique_ptr<elna::source::definition>> definitions($1.size());
|
||||
std::vector<std::unique_ptr<elna::source::definition>>::iterator definition = definitions.begin();
|
||||
|
||||
@@ -81,46 +112,171 @@ program: constant_definition_part
|
||||
{
|
||||
*definition++ = std::move(constant);
|
||||
}
|
||||
program = std::make_unique<elna::source::program>(position,
|
||||
std::move(definitions), std::move(declarations),
|
||||
std::make_unique<elna::source::compound_statement>(position));
|
||||
$$ = std::make_unique<elna::source::block>(elna::source::position{},
|
||||
std::move(definitions), std::move($2), std::move($3));
|
||||
};
|
||||
procedure_definition:
|
||||
PROCEDURE IDENTIFIER formal_parameter_list SEMICOLON block SEMICOLON
|
||||
{
|
||||
$$ = std::make_unique<elna::source::procedure_definition>(elna::source::position{},
|
||||
std::move($2), std::move($5));
|
||||
std::swap($$->parameters(), $3);
|
||||
};
|
||||
procedure_definitions:
|
||||
procedure_definition procedure_definitions
|
||||
{
|
||||
std::swap($$, $2);
|
||||
$$.emplace($$.cbegin(), std::move($1));
|
||||
}
|
||||
| procedure_definition { $$.emplace_back(std::move($1)); }
|
||||
integer_literal: NUMBER
|
||||
{
|
||||
elna::source::position position{
|
||||
static_cast<std::size_t>(@1.begin.line),
|
||||
static_cast<std::size_t>(@1.begin.column)
|
||||
};
|
||||
$$ = std::make_unique<elna::source::integer_literal>(position, $1);
|
||||
$$ = std::make_unique<elna::source::integer_literal>(elna::source::make_position(@1), $1);
|
||||
};
|
||||
boolean_literal: BOOLEAN
|
||||
{
|
||||
$$ = std::make_unique<elna::source::boolean_literal>(elna::source::make_position(@1), $1);
|
||||
};
|
||||
compound_statement: BEGIN_BLOCK optional_statements END_BLOCK
|
||||
{
|
||||
$$ = std::make_unique<elna::source::compound_statement>(elna::source::make_position(@1));
|
||||
std::swap($$->statements(), $2);
|
||||
}
|
||||
assign_statement: IDENTIFIER ASSIGNMENT expression
|
||||
{
|
||||
$$ = std::make_unique<elna::source::assign_statement>(elna::source::make_position(@1), $1, std::move($3));
|
||||
}
|
||||
call_statement: IDENTIFIER actual_parameter_list
|
||||
{
|
||||
$$ = std::make_unique<elna::source::call_statement>(elna::source::make_position(@1), $1);
|
||||
std::swap($$->arguments(), $2);
|
||||
}
|
||||
while_statement: WHILE expression DO statement
|
||||
{
|
||||
$$ = std::make_unique<elna::source::while_statement>(elna::source::make_position(@1),
|
||||
std::move($2), std::move($4));
|
||||
}
|
||||
if_statement:
|
||||
IF expression THEN statement
|
||||
{
|
||||
$$ = std::make_unique<elna::source::if_statement>(elna::source::make_position(@1),
|
||||
std::move($2), std::move($4));
|
||||
}
|
||||
pointer:
|
||||
integer_literal { $$ = std::move($1); }
|
||||
| boolean_literal { $$ = std::move($1); }
|
||||
| variable_expression { $$ = std::move($1); }
|
||||
| LEFT_PAREN expression RIGHT_PAREN { $$ = std::move($2); }
|
||||
summand:
|
||||
factor { $$ = std::move($1); }
|
||||
| factor MULTIPLICATION factor
|
||||
{
|
||||
$$ = std::make_unique<elna::source::binary_expression>(elna::source::make_position(@1),
|
||||
std::move($1), std::move($3), '*');
|
||||
}
|
||||
| factor DIVISION factor
|
||||
{
|
||||
$$ = std::make_unique<elna::source::binary_expression>(elna::source::make_position(@1),
|
||||
std::move($1), std::move($3), '/');
|
||||
}
|
||||
address:
|
||||
pointer HAT
|
||||
{
|
||||
$$ = std::make_unique<elna::source::unary_expression>(elna::source::make_position(@1),
|
||||
std::move($1), '^');
|
||||
}
|
||||
| pointer { $$ = std::move($1); }
|
||||
factor:
|
||||
AT address
|
||||
{
|
||||
$$ = std::make_unique<elna::source::unary_expression>(elna::source::make_position(@1),
|
||||
std::move($2), '@');
|
||||
}
|
||||
| address { $$ = std::move($1); }
|
||||
expression:
|
||||
summand EQUALS summand
|
||||
{
|
||||
$$ = std::make_unique<elna::source::binary_expression>(elna::source::make_position(@1),
|
||||
std::move($1), std::move($3), '=');
|
||||
}
|
||||
| summand NOT_EQUAL summand
|
||||
{
|
||||
$$ = std::make_unique<elna::source::binary_expression>(elna::source::make_position(@1),
|
||||
std::move($1), std::move($3), 'n');
|
||||
}
|
||||
| summand LESS_THAN summand
|
||||
{
|
||||
$$ = std::make_unique<elna::source::binary_expression>(elna::source::make_position(@1),
|
||||
std::move($1), std::move($3), '<');
|
||||
}
|
||||
| summand GREATER_THAN summand
|
||||
{
|
||||
$$ = std::make_unique<elna::source::binary_expression>(elna::source::make_position(@1),
|
||||
std::move($1), std::move($3), '>');
|
||||
}
|
||||
| summand LESS_EQUAL summand
|
||||
{
|
||||
$$ = std::make_unique<elna::source::binary_expression>(elna::source::make_position(@1),
|
||||
std::move($1), std::move($3), '<');
|
||||
}
|
||||
| summand GREATER_EQUAL summand
|
||||
{
|
||||
$$ = std::make_unique<elna::source::binary_expression>(elna::source::make_position(@1),
|
||||
std::move($1), std::move($3), '>');
|
||||
}
|
||||
| summand { $$ = std::move($1); }
|
||||
expressions:
|
||||
expression COMMA expressions
|
||||
{
|
||||
std::swap($$, $3);
|
||||
$$.emplace($$.cbegin(), std::move($1));
|
||||
}
|
||||
| expression { $$.emplace_back(std::move($1)); }
|
||||
variable_expression: IDENTIFIER
|
||||
{ $$ = std::make_unique<elna::source::variable_expression>(elna::source::make_position(@1), $1); }
|
||||
statement:
|
||||
compound_statement { $$ = std::move($1); }
|
||||
| assign_statement { $$ = std::move($1); }
|
||||
| call_statement { $$ = std::move($1); }
|
||||
| while_statement { $$ = std::move($1); }
|
||||
| if_statement { $$ = std::move($1); }
|
||||
statements:
|
||||
statement SEMICOLON statements
|
||||
{
|
||||
std::swap($$, $3);
|
||||
$$.emplace($$.cbegin(), std::move($1));
|
||||
}
|
||||
| statement { $$.emplace_back(std::move($1)); }
|
||||
optional_statements:
|
||||
statements { std::swap($$, $1); }
|
||||
| /* no statements */ {}
|
||||
type_expression:
|
||||
HAT IDENTIFIER
|
||||
{
|
||||
elna::source::position position{
|
||||
static_cast<std::size_t>(@1.begin.line),
|
||||
static_cast<std::size_t>(@1.begin.column)
|
||||
};
|
||||
$$ = std::make_unique<elna::source::type_expression>(position, $2, true);
|
||||
}
|
||||
| IDENTIFIER
|
||||
{
|
||||
elna::source::position position{
|
||||
static_cast<std::size_t>(@1.begin.line),
|
||||
static_cast<std::size_t>(@1.begin.column)
|
||||
};
|
||||
$$ = std::make_unique<elna::source::type_expression>(position, $1, false);
|
||||
}
|
||||
HAT IDENTIFIER
|
||||
{
|
||||
$$ = std::make_unique<elna::source::type_expression>(elna::source::make_position(@1), $2, true);
|
||||
}
|
||||
| IDENTIFIER
|
||||
{
|
||||
$$ = std::make_unique<elna::source::type_expression>(elna::source::make_position(@1), $1, false);
|
||||
}
|
||||
variable_declaration: IDENTIFIER COLON type_expression
|
||||
{
|
||||
$$ = std::make_unique<elna::source::declaration>(elna::source::make_position(@1),
|
||||
$1, std::move($3));
|
||||
};
|
||||
variable_declarations:
|
||||
variable_declaration COMMA variable_declarations
|
||||
| variable_declaration
|
||||
variable_declaration COMMA variable_declarations
|
||||
{
|
||||
std::swap($$, $3);
|
||||
$$.emplace($$.cbegin(), std::move($1));
|
||||
}
|
||||
| variable_declaration { $$.emplace_back(std::move($1)); }
|
||||
variable_declaration_part:
|
||||
/* no variable declarations */ {}
|
||||
| VAR variable_declarations SEMICOLON { std::swap($$, $2); }
|
||||
constant_definition: IDENTIFIER EQUALS integer_literal
|
||||
{
|
||||
elna::source::position position{
|
||||
static_cast<std::size_t>(@1.begin.line),
|
||||
static_cast<std::size_t>(@1.begin.column)
|
||||
};
|
||||
$$ = std::make_unique<elna::source::constant_definition>(position,
|
||||
$$ = std::make_unique<elna::source::constant_definition>(elna::source::make_position(@1),
|
||||
$1, std::move($3));
|
||||
};
|
||||
constant_definitions:
|
||||
@@ -133,9 +289,15 @@ constant_definitions:
|
||||
constant_definition_part:
|
||||
/* no constant definitions */ {}
|
||||
| CONST constant_definitions SEMICOLON { std::swap($$, $2); };
|
||||
formal_parameter_list:
|
||||
LEFT_PAREN RIGHT_PAREN {}
|
||||
| LEFT_PAREN variable_declarations RIGHT_PAREN { std::swap($$, $2); }
|
||||
actual_parameter_list:
|
||||
LEFT_PAREN RIGHT_PAREN {}
|
||||
| LEFT_PAREN expressions RIGHT_PAREN { std::swap($$, $2); }
|
||||
%%
|
||||
|
||||
void yy::parser::error(const location_type& loc, const std::string &message)
|
||||
void yy::parser::error(const location_type& loc, const std::string& message)
|
||||
{
|
||||
std::cerr << "Error: " << message << std::endl;
|
||||
driver.error(loc, message);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user