belka/elna
1
0
Fork 0
Code Issues 5 Pull Requests Releases Activity

Parse variable declarations

Browse Source
This commit is contained in:
Eugen Wissner
2024-12-21 14:05:27 +01:00
parent 72681e349a
commit 40a28059ca
6 changed files with 140 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
source/driver.cpp Normal file
View File

@ -0,0 +1,38 @@
#include "elna/source/driver.hpp"
namespace elna::source
{
position make_position(const yy::location& location)
{
return position{
static_cast<std::size_t>(location.begin.line),
static_cast<std::size_t>(location.begin.column)
};
}
syntax_error::syntax_error(const std::string& message,
const std::filesystem::path& input_file, const yy::location& location)
: error(input_file, make_position(location)), message(message)
{
}
std::string syntax_error::what() const
{
return message;
}
driver::driver(const std::filesystem::path& input_file)
: input_file(input_file)
{
}
void driver::error(const yy::location& loc, const std::string& message)
{
m_errors.emplace_back(std::make_unique<elna::source::syntax_error>(message, input_file, loc));
}
const std::list<std::unique_ptr<struct error>>& driver::errors() const noexcept
{
return m_errors;
}
}

6
source/lexer.ll
View File

@ -6,12 +6,12 @@
#include "parser.hpp"
#undef YY_DECL
#define YY_DECL yy::parser::symbol_type elna::syntax::FooLexer::lex()
#define YY_DECL yy::parser::symbol_type elna::source::lexer::lex()
#define yyterminate() return yy::parser::make_YYEOF(this->location)
%}
%option c++ noyywrap never-interactive
%option yyclass="elna::syntax::FooLexer"
%option yyclass="elna::source::lexer"
%%
%{
@ -125,7 +125,7 @@ False {
. {
std::stringstream ss;
ss << "Illegal character 0x" << std::hex << static_cast<unsigned char>(yytext[0]);
ss << "Illegal character 0x" << std::hex << static_cast<unsigned int>(yytext[0]);
throw yy::parser::syntax_error(this->location, ss.str());
}
%%

79
source/parser.yy
View File

@ -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
@ -68,12 +67,13 @@
%type <std::unique_ptr<elna::source::integer_literal>> integer_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;
%type <std::unique_ptr<elna::source::type_expression>> type_expression;
%type <std::unique_ptr<elna::source::statement>> statement;
%%
program: constant_definition_part
program: constant_definition_part variable_declaration_part statement DOT
{
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 +81,45 @@ 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));
driver.tree = std::make_unique<elna::source::program>(elna::source::position{},
std::move(definitions), std::move($2),
std::move($3));
}
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);
};
statement: BEGIN_BLOCK END_BLOCK
{
$$ = std::make_unique<elna::source::compound_statement>(elna::source::make_position(@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);
$$ = std::make_unique<elna::source::type_expression>(elna::source::make_position(@1), $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);
$$ = 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:
@ -135,7 +134,7 @@ constant_definition_part:
| CONST constant_definitions SEMICOLON { 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);
}