407 lines
15 KiB
Plaintext
407 lines
15 KiB
Plaintext
|
%require "3.2"
|
||
|
|
%language "c++"
|
||
|
|
|
||
|
|
%code requires {
|
||
|
|
#include <cstdint>
|
||
|
|
#include "elna/source/parser.hpp"
|
||
|
|
|
||
|
|
|
||
|
|
#if ! defined(yyFlexLexerOnce)
|
||
|
|
#include <FlexLexer.h>
|
||
|
|
#endif
|
||
|
|
|
||
|
|
namespace elna::syntax
|
||
|
|
{
|
||
|
|
class FooLexer;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
%code provides {
|
||
|
|
namespace elna::syntax
|
||
|
|
{
|
||
|
|
|
||
|
|
class FooLexer : public yyFlexLexer
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
yy::location location;
|
||
|
|
|
||
|
|
FooLexer(std::istream& arg_yyin)
|
||
|
|
: yyFlexLexer(&arg_yyin)
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
yy::parser::symbol_type lex();
|
||
|
|
};
|
||
|
|
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
%define api.token.raw
|
||
|
|
%define api.token.constructor
|
||
|
|
%define api.value.type variant
|
||
|
|
%define parse.assert
|
||
|
|
|
||
|
|
%parse-param {elna::syntax::FooLexer& lexer}
|
||
|
|
%parse-param {std::unique_ptr<elna::source::program>& program}
|
||
|
|
%locations
|
||
|
|
|
||
|
|
%header
|
||
|
|
|
||
|
|
%code {
|
||
|
|
#define yylex lexer.lex
|
||
|
|
}
|
||
|
|
%start program;
|
||
|
|
|
||
|
|
%token <std::string> IDENTIFIER "identifier"
|
||
|
|
%token <std::int32_t> NUMBER "number"
|
||
|
|
%token <bool> BOOLEAN
|
||
|
|
%token IF THEN WHILE DO
|
||
|
|
%token CONST VAR PROCEDURE
|
||
|
|
%token BEGIN_BLOCK END_BLOCK
|
||
|
|
%token TRUE FALSE
|
||
|
|
%token LEFT_PAREN RIGHT_PAREN SEMICOLON DOT COMMA
|
||
|
|
%token GREATER_EQUAL LESS_EQUAL LESS_THAN GREATER_THAN NOT_EQUAL EQUALS
|
||
|
|
%token PLUS MINUS MULTIPLICATION DIVISION
|
||
|
|
%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::variable_expression>> variable_expression;
|
||
|
|
%type <std::unique_ptr<elna::source::constant_definition>> constant_definition;
|
||
|
|
%type <std::unique_ptr<elna::source::unary_expression>> reference_expression dereference_expression;
|
||
|
|
%type <std::vector<std::unique_ptr<elna::source::constant_definition>>> constant_definition_part constant_definitions;
|
||
|
|
%type <std::unique_ptr<elna::source::type_expression>> type_expression;
|
||
|
|
%type <std::unique_ptr<elna::source::declaration>> variable_declaration;
|
||
|
|
%type <std::vector<std::unique_ptr<elna::source::declaration>>> variable_declaration_part variable_declarations;
|
||
|
|
%type <std::unique_ptr<elna::source::assign_statement>> assign_statement;
|
||
|
|
%type <std::unique_ptr<elna::source::expression>> expression factor term comparand;
|
||
|
|
%type <std::unique_ptr<elna::source::statement>> statement;
|
||
|
|
%type <std::vector<std::unique_ptr<elna::source::expression>>> arguments;
|
||
|
|
%type <std::unique_ptr<elna::source::call_statement>> call_statement;
|
||
|
|
%type <std::unique_ptr<elna::source::compound_statement>> compound_statement;
|
||
|
|
%type <std::vector<std::unique_ptr<elna::source::statement>>> statements;
|
||
|
|
%type <std::unique_ptr<elna::source::if_statement>> if_statement;
|
||
|
|
%type <std::unique_ptr<elna::source::while_statement>> while_statement;
|
||
|
|
%type <std::unique_ptr<elna::source::procedure_definition>> procedure_definition;
|
||
|
|
%type <std::vector<std::unique_ptr<elna::source::procedure_definition>>> procedure_definition_part procedure_definitions;
|
||
|
|
%%
|
||
|
|
program: constant_definition_part variable_declaration_part procedure_definition_part statement DOT
|
||
|
|
{
|
||
|
|
elna::source::position position;
|
||
|
|
std::vector<std::unique_ptr<elna::source::definition>> definitions($1.size());
|
||
|
|
std::vector<std::unique_ptr<elna::source::declaration>> declarations($2.size());
|
||
|
|
std::vector<std::unique_ptr<elna::source::definition>>::iterator definition = definitions.begin();
|
||
|
|
std::vector<std::unique_ptr<elna::source::declaration>>::iterator declaration = declarations.begin();
|
||
|
|
|
||
|
|
for (auto& constant : $1)
|
||
|
|
{
|
||
|
|
*definition++ = std::move(constant);
|
||
|
|
}
|
||
|
|
for (auto& variable : $2)
|
||
|
|
{
|
||
|
|
*declaration++ = std::move(variable);
|
||
|
|
}
|
||
|
|
program = std::make_unique<elna::source::program>(position,
|
||
|
|
std::move(definitions), std::move(declarations), std::move($4));
|
||
|
|
}
|
||
|
|
procedure_definition:
|
||
|
|
PROCEDURE IDENTIFIER SEMICOLON constant_definition_part variable_declaration_part statement SEMICOLON
|
||
|
|
{
|
||
|
|
elna::source::position position;
|
||
|
|
std::vector<std::unique_ptr<elna::source::definition>> definitions($4.size());
|
||
|
|
std::vector<std::unique_ptr<elna::source::declaration>> declarations($5.size());
|
||
|
|
std::vector<std::unique_ptr<elna::source::definition>>::iterator definition = definitions.begin();
|
||
|
|
std::vector<std::unique_ptr<elna::source::declaration>>::iterator declaration = declarations.begin();
|
||
|
|
|
||
|
|
for (auto& constant : $4)
|
||
|
|
{
|
||
|
|
*definition++ = std::move(constant);
|
||
|
|
}
|
||
|
|
for (auto& variable : $5)
|
||
|
|
{
|
||
|
|
*declaration++ = std::move(variable);
|
||
|
|
}
|
||
|
|
auto block = std::make_unique<elna::source::block>(position,
|
||
|
|
std::move(definitions), std::move(declarations), std::move($6));
|
||
|
|
$$ = std::make_unique<elna::source::procedure_definition>(position,
|
||
|
|
$2, std::move(block));
|
||
|
|
}
|
||
|
|
procedure_definition_part:
|
||
|
|
/* no procedure definitions. */ {}
|
||
|
|
| procedure_definitions { std::swap($1, $$); }
|
||
|
|
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);
|
||
|
|
}
|
||
|
|
boolean_literal: BOOLEAN
|
||
|
|
{
|
||
|
|
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::boolean_literal>(position, $1);
|
||
|
|
}
|
||
|
|
variable_expression: 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::variable_expression>(position, $1);
|
||
|
|
}
|
||
|
|
reference_expression: AT variable_expression
|
||
|
|
{
|
||
|
|
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::unary_expression>(position, std::move($2), '@');
|
||
|
|
}
|
||
|
|
dereference_expression: factor HAT
|
||
|
|
{
|
||
|
|
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::unary_expression>(position, std::move($1), '^');
|
||
|
|
}
|
||
|
|
expression:
|
||
|
|
comparand EQUALS comparand
|
||
|
|
{
|
||
|
|
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::binary_expression>(position,
|
||
|
|
std::move($1), std::move($3), '=');
|
||
|
|
}
|
||
|
|
| comparand NOT_EQUAL comparand
|
||
|
|
{
|
||
|
|
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::binary_expression>(position,
|
||
|
|
std::move($1), std::move($3), 'n');
|
||
|
|
}
|
||
|
|
| comparand GREATER_THAN comparand
|
||
|
|
{
|
||
|
|
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::binary_expression>(position,
|
||
|
|
std::move($1), std::move($3), '>');
|
||
|
|
}
|
||
|
|
| comparand LESS_THAN comparand
|
||
|
|
{
|
||
|
|
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::binary_expression>(position,
|
||
|
|
std::move($1), std::move($3), '<');
|
||
|
|
}
|
||
|
|
| comparand GREATER_EQUAL comparand
|
||
|
|
{
|
||
|
|
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::binary_expression>(position,
|
||
|
|
std::move($1), std::move($3), 'g');
|
||
|
|
}
|
||
|
|
| comparand LESS_EQUAL comparand
|
||
|
|
{
|
||
|
|
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::binary_expression>(position,
|
||
|
|
std::move($1), std::move($3), 'l');
|
||
|
|
}
|
||
|
|
comparand:
|
||
|
|
term PLUS term
|
||
|
|
{
|
||
|
|
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::binary_expression>(position,
|
||
|
|
std::move($1), std::move($3), '+');
|
||
|
|
}
|
||
|
|
| term MINUS term
|
||
|
|
{
|
||
|
|
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::binary_expression>(position,
|
||
|
|
std::move($1), std::move($3), '-');
|
||
|
|
}
|
||
|
|
| term { $$ = std::move($1); }
|
||
|
|
factor:
|
||
|
|
integer_literal { $$ = std::move($1); }
|
||
|
|
| boolean_literal { $$ = std::move($1); }
|
||
|
|
| variable_expression { $$ = std::move($1); }
|
||
|
|
| reference_expression { $$ = std::move($1); }
|
||
|
|
| dereference_expression { $$ = std::move($1); }
|
||
|
|
| LEFT_PAREN expression RIGHT_PAREN { $$ = std::move($2); }
|
||
|
|
term:
|
||
|
|
factor MULTIPLICATION factor
|
||
|
|
{
|
||
|
|
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::binary_expression>(position,
|
||
|
|
std::move($1), std::move($3), '*');
|
||
|
|
}
|
||
|
|
| factor DIVISION factor
|
||
|
|
{
|
||
|
|
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::binary_expression>(position,
|
||
|
|
std::move($1), std::move($3), '/');
|
||
|
|
}
|
||
|
|
| factor { $$ = std::move($1); }
|
||
|
|
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);
|
||
|
|
}
|
||
|
|
assign_statement: IDENTIFIER ASSIGNMENT expression
|
||
|
|
{
|
||
|
|
elna::source::position position{
|
||
|
|
static_cast<std::size_t>(@1.begin.line),
|
||
|
|
static_cast<std::size_t>(@2.begin.column)
|
||
|
|
};
|
||
|
|
$$ = std::make_unique<elna::source::assign_statement>(position, $1, std::move($3));
|
||
|
|
}
|
||
|
|
call_statement: IDENTIFIER LEFT_PAREN arguments RIGHT_PAREN
|
||
|
|
{
|
||
|
|
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::call_statement>(position, $1);
|
||
|
|
std::swap($3, $$->arguments());
|
||
|
|
}
|
||
|
|
compound_statement: BEGIN_BLOCK statements END_BLOCK
|
||
|
|
{
|
||
|
|
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::compound_statement>(position);
|
||
|
|
std::swap($2, $$->statements());
|
||
|
|
}
|
||
|
|
if_statement: IF expression THEN statement
|
||
|
|
{
|
||
|
|
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::if_statement>(position,
|
||
|
|
std::move($2), std::move($4));
|
||
|
|
}
|
||
|
|
while_statement: WHILE expression DO statement
|
||
|
|
{
|
||
|
|
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::while_statement>(position,
|
||
|
|
std::move($2), std::move($4));
|
||
|
|
}
|
||
|
|
statement:
|
||
|
|
assign_statement { $$ = std::move($1); }
|
||
|
|
| call_statement { $$ = std::move($1); }
|
||
|
|
| compound_statement { $$ = std::move($1); }
|
||
|
|
| if_statement { $$ = std::move($1); }
|
||
|
|
| while_statement { $$ = std::move($1); }
|
||
|
|
variable_declaration: IDENTIFIER COLON type_expression
|
||
|
|
{
|
||
|
|
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::declaration>(position, $1, std::move($3));
|
||
|
|
}
|
||
|
|
variable_declarations:
|
||
|
|
variable_declaration COMMA variable_declarations
|
||
|
|
{
|
||
|
|
std::swap($$, $3);
|
||
|
|
$$.emplace($$.cbegin(), std::move($1));
|
||
|
|
}
|
||
|
|
| variable_declaration { $$.emplace_back(std::move($1)); }
|
||
|
|
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,
|
||
|
|
$1, std::move($3));
|
||
|
|
};
|
||
|
|
constant_definitions:
|
||
|
|
constant_definition COMMA constant_definitions
|
||
|
|
{
|
||
|
|
std::swap($$, $3);
|
||
|
|
$$.emplace($$.cbegin(), std::move($1));
|
||
|
|
}
|
||
|
|
| constant_definition { $$.emplace_back(std::move($1)); }
|
||
|
|
constant_definition_part:
|
||
|
|
/* no constant definitions */ {}
|
||
|
|
| CONST constant_definitions SEMICOLON { std::swap($$, $2); };
|
||
|
|
variable_declaration_part:
|
||
|
|
/* no constant declarations */ {}
|
||
|
|
| VAR variable_declarations SEMICOLON { std::swap($$, $2); };
|
||
|
|
arguments:
|
||
|
|
/* no arguments */ {}
|
||
|
|
| expression COMMA arguments
|
||
|
|
{
|
||
|
|
std::swap($$, $3);
|
||
|
|
$$.emplace($$.cbegin(), std::move($1));
|
||
|
|
}
|
||
|
|
| expression { $$.emplace_back(std::move($1)); }
|
||
|
|
statements:
|
||
|
|
/* no statements */ {}
|
||
|
|
| statement SEMICOLON statements
|
||
|
|
{
|
||
|
|
std::swap($$, $3);
|
||
|
|
$$.emplace($$.cbegin(), std::move($1));
|
||
|
|
}
|
||
|
|
| statement { $$.emplace_back(std::move($1)); }
|
||
|
|
%%
|
||
|
|
|
||
|
|
void yy::parser::error(const location_type& loc, const std::string &message)
|
||
|
|
{
|
||
|
|
throw yy::parser::syntax_error(loc, message);
|
||
|
|
}
|