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

Skip parameter names in procedure type expressions

Browse Source
This commit is contained in:
Eugen Wissner 2025-03-18 11:37:10 +01:00
parent 6eb4e91b2c
commit 5e8555b4f4
Signed by: belka
GPG Key ID: A27FDC1E8EE902C0
20 changed files with 469 additions and 490 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

231
boot/ast.cc
View File

@ -17,175 +17,8 @@ along with GCC; see the file COPYING3. If not see
#include "elna/boot/ast.h" #include "elna/boot/ast.h"
namespace elna namespace elna::boot
{ {
namespace boot
{
void empty_visitor::visit(variable_declaration *)
{
__builtin_unreachable();
}
void empty_visitor::visit(constant_definition *)
{
__builtin_unreachable();
}
void empty_visitor::visit(procedure_definition *)
{
__builtin_unreachable();
}
void empty_visitor::visit(type_definition *)
{
__builtin_unreachable();
}
void empty_visitor::visit(procedure_call *)
{
__builtin_unreachable();
}
void empty_visitor::visit(traits_expression *)
{
__builtin_unreachable();
}
void empty_visitor::visit(cast_expression *)
{
__builtin_unreachable();
}
void empty_visitor::visit(assign_statement *)
{
__builtin_unreachable();
}
void empty_visitor::visit(if_statement *)
{
__builtin_unreachable();
}
void empty_visitor::visit(while_statement *)
{
__builtin_unreachable();
}
void empty_visitor::visit(return_statement *)
{
__builtin_unreachable();
}
void empty_visitor::visit(defer_statement *)
{
__builtin_unreachable();
}
void empty_visitor::visit(block *)
{
__builtin_unreachable();
}
void empty_visitor::visit(program *)
{
__builtin_unreachable();
}
void empty_visitor::visit(binary_expression *)
{
__builtin_unreachable();
}
void empty_visitor::visit(unary_expression *)
{
__builtin_unreachable();
}
void empty_visitor::visit(primitive_type_expression *)
{
__builtin_unreachable();
}
void empty_visitor::visit(array_type_expression *)
{
__builtin_unreachable();
}
void empty_visitor::visit(pointer_type_expression *)
{
__builtin_unreachable();
}
void empty_visitor::visit(record_type_expression *)
{
__builtin_unreachable();
}
void empty_visitor::visit(union_type_expression *)
{
__builtin_unreachable();
}
void empty_visitor::visit(procedure_type_expression *)
{
__builtin_unreachable();
}
void empty_visitor::visit(variable_expression *)
{
__builtin_unreachable();
}
void empty_visitor::visit(array_access_expression *)
{
__builtin_unreachable();
}
void empty_visitor::visit(field_access_expression *)
{
__builtin_unreachable();
}
void empty_visitor::visit(dereference_expression *)
{
__builtin_unreachable();
}
void empty_visitor::visit(number_literal<std::int32_t> *)
{
__builtin_unreachable();
}
void empty_visitor::visit(number_literal<std::uint32_t> *)
{
__builtin_unreachable();
}
void empty_visitor::visit(number_literal<double> *)
{
__builtin_unreachable();
}
void empty_visitor::visit(number_literal<bool> *)
{
__builtin_unreachable();
}
void empty_visitor::visit(number_literal<unsigned char> *)
{
__builtin_unreachable();
}
void empty_visitor::visit(number_literal<std::nullptr_t> *)
{
__builtin_unreachable();
}
void empty_visitor::visit(number_literal<std::string> *)
{
__builtin_unreachable();
}
node::node(const struct position position) node::node(const struct position position)
: source_position(position) : source_position(position)
{ {
@ -305,7 +138,7 @@ namespace boot
return nullptr; return nullptr;
} }
literal *expression::is_literal() literal_expression *expression::is_literal()
{ {
return nullptr; return nullptr;
} }
@ -336,7 +169,7 @@ namespace boot
{ {
return node->accept(visitor); return node->accept(visitor);
} }
else if (literal *node = is_literal()) else if (literal_expression *node = is_literal())
{ {
return node->accept(visitor); return node->accept(visitor);
} }
@ -518,7 +351,7 @@ namespace boot
} }
constant_definition::constant_definition(const struct position position, const std::string& identifier, constant_definition::constant_definition(const struct position position, const std::string& identifier,
const bool exported, literal *body) const bool exported, literal_expression *body)
: definition(position, identifier, exported), m_body(body) : definition(position, identifier, exported), m_body(body)
{ {
} }
@ -528,7 +361,7 @@ namespace boot
visitor->visit(this); visitor->visit(this);
} }
literal& constant_definition::body() literal_expression& constant_definition::body()
{ {
return *m_body; return *m_body;
} }
@ -538,14 +371,19 @@ namespace boot
delete m_body; delete m_body;
} }
procedure_type_expression::procedure_type_expression(const struct position position, return_declaration::return_declaration(std::shared_ptr<type_expression> type)
std::shared_ptr<type_expression> return_type) : type(type)
: type_expression(position), return_type(return_type), no_return(false)
{ {
} }
procedure_type_expression::procedure_type_expression(const struct position position, no_return_t) return_declaration::return_declaration(std::monostate)
: type_expression(position), return_type(nullptr), no_return(true) : no_return(true)
{
}
procedure_type_expression::procedure_type_expression(const struct position position,
return_declaration return_type)
: type_expression(position), return_type(return_type)
{ {
} }
@ -554,14 +392,6 @@ namespace boot
visitor->visit(this); visitor->visit(this);
} }
procedure_type_expression::~procedure_type_expression()
{
for (auto parameter : this->parameters)
{
delete parameter;
}
}
procedure_definition::procedure_definition(const struct position position, const std::string& identifier, procedure_definition::procedure_definition(const struct position position, const std::string& identifier,
const bool exported, std::shared_ptr<procedure_type_expression> heading, block *body) const bool exported, std::shared_ptr<procedure_type_expression> heading, block *body)
: definition(position, identifier, exported), m_heading(heading), body(body) : definition(position, identifier, exported), m_heading(heading), body(body)
@ -652,42 +482,42 @@ namespace boot
} }
} }
literal::literal() literal_expression::literal_expression()
{ {
} }
literal *literal::is_literal() literal_expression *literal_expression::is_literal()
{ {
return this; return this;
} }
void literal::accept(parser_visitor *visitor) void literal_expression::accept(parser_visitor *visitor)
{ {
if (number_literal<std::int32_t> *node = is_int()) if (literal<std::int32_t> *node = is_int())
{ {
return node->accept(visitor); return node->accept(visitor);
} }
else if (number_literal<std::uint32_t> *node = is_word()) else if (literal<std::uint32_t> *node = is_word())
{ {
return node->accept(visitor); return node->accept(visitor);
} }
else if (number_literal<double> *node = is_float()) else if (literal<double> *node = is_float())
{ {
return node->accept(visitor); return node->accept(visitor);
} }
else if (number_literal<bool> *node = is_bool()) else if (literal<bool> *node = is_bool())
{ {
return node->accept(visitor); return node->accept(visitor);
} }
else if (number_literal<unsigned char> *node = is_char()) else if (literal<unsigned char> *node = is_char())
{ {
return node->accept(visitor); return node->accept(visitor);
} }
else if (number_literal<std::nullptr_t> *node = is_nil()) else if (literal<std::nullptr_t> *node = is_nil())
{ {
return node->accept(visitor); return node->accept(visitor);
} }
else if (number_literal<std::string> *node = is_string()) else if (literal<std::string> *node = is_string())
{ {
return node->accept(visitor); return node->accept(visitor);
} }
@ -991,9 +821,8 @@ namespace boot
delete m_value; delete m_value;
} }
traits_expression::traits_expression(const struct position position, traits_expression::traits_expression(const struct position position, const std::string& name)
const std::string& name, std::shared_ptr<type_expression> type) : node(position), name(name)
: node(position), m_type(type), name(name)
{ {
} }
@ -1007,11 +836,6 @@ namespace boot
return this; return this;
} }
type_expression& traits_expression::type()
{
return *m_type;
}
conditional_statements::conditional_statements(expression *prerequisite) conditional_statements::conditional_statements(expression *prerequisite)
: m_prerequisite(prerequisite) : m_prerequisite(prerequisite)
{ {
@ -1212,4 +1036,3 @@ namespace boot
__builtin_unreachable(); __builtin_unreachable();
}; };
} }
}

5
boot/driver.cc
View File

@ -17,9 +17,7 @@ along with GCC; see the file COPYING3. If not see
#include "elna/boot/driver.h" #include "elna/boot/driver.h"
namespace elna namespace elna::boot
{
namespace boot
{ {
position make_position(const yy::location& location) position make_position(const yy::location& location)
{ {
@ -79,4 +77,3 @@ namespace boot
} }
} }
} }
}

118
boot/parser.yy
View File

@ -87,7 +87,7 @@ along with GCC; see the file COPYING3. If not see
ARROW "->" EXCLAMATION "!" ARROW "->" EXCLAMATION "!"
AT "@" HAT "^" AT "@" HAT "^"
COLON ":" SEMICOLON ";" DOT "." COMMA "," COLON ":" SEMICOLON ";" DOT "." COMMA ","
%token NOT "not" %token NOT "~"
CAST "cast" CAST "cast"
NIL "nil" NIL "nil"
CONST "const" CONST "const"
@ -107,27 +107,26 @@ along with GCC; see the file COPYING3. If not see
BEGIN_BLOCK "begin" BEGIN_BLOCK "begin"
END_BLOCK "end" END_BLOCK "end"
DEFER "defer" DEFER "defer"
%token OR "or" AND "and" XOR "xor" %token OR "|" AND "&" XOR "xor"
EQUALS "=" NOT_EQUAL "<>" LESS_THAN "<" GREATER_THAN ">" LESS_EQUAL "<=" GREATER_EQUAL ">=" EQUALS "=" NOT_EQUAL "<>" LESS_THAN "<" GREATER_THAN ">" LESS_EQUAL "<=" GREATER_EQUAL ">="
SHIFT_LEFT "<<" SHIFT_RIGHT ">>" SHIFT_LEFT "<<" SHIFT_RIGHT ">>"
PLUS "+" MINUS "-" PLUS "+" MINUS "-"
MULTIPLICATION "*" DIVISION "/" REMAINDER "%" MULTIPLICATION "*" DIVISION "/" REMAINDER "%"
%left "or" "and" "xor" %left "|" "&" "xor"
%left "=" "<>" "<" ">" "<=" ">=" %left "=" "<>" "<" ">" "<=" ">="
%left "<<" ">>" %left "<<" ">>"
%left "+" "-" %left "+" "-"
%left "*" "/" "%" %left "*" "/" "%"
%type <elna::boot::literal *> literal; %type <elna::boot::literal_expression *> literal;
%type <elna::boot::constant_definition *> constant_definition; %type <elna::boot::constant_definition *> constant_definition;
%type <std::vector<elna::boot::constant_definition *>> constant_part constant_definitions; %type <std::vector<elna::boot::constant_definition *>> constant_part constant_definitions;
%type <std::vector<elna::boot::variable_declaration *>> variable_declarations variable_part variable_declaration %type <std::vector<elna::boot::variable_declaration *>> variable_declarations variable_part variable_declaration;
formal_parameters formal_parameter_list;
%type <elna::boot::variable_declaration *> formal_parameter
%type <std::shared_ptr<elna::boot::type_expression>> type_expression; %type <std::shared_ptr<elna::boot::type_expression>> type_expression;
%type <std::vector<std::shared_ptr<elna::boot::type_expression>>> type_expressions;
%type <elna::boot::traits_expression *> traits_expression; %type <elna::boot::traits_expression *> traits_expression;
%type <elna::boot::expression *> expression operand; %type <elna::boot::expression *> expression operand qualident;
%type <elna::boot::unary_expression *> unary_expression; %type <elna::boot::unary_expression *> unary_expression;
%type <elna::boot::binary_expression *> binary_expression; %type <elna::boot::binary_expression *> binary_expression;
%type <std::vector<elna::boot::expression *>> expressions actual_parameter_list; %type <std::vector<elna::boot::expression *>> expressions actual_parameter_list;
@ -140,14 +139,15 @@ along with GCC; see the file COPYING3. If not see
%type <elna::boot::statement *> statement; %type <elna::boot::statement *> statement;
%type <std::vector<elna::boot::statement *>> statements; %type <std::vector<elna::boot::statement *>> statements;
%type <elna::boot::procedure_definition *> procedure_definition; %type <elna::boot::procedure_definition *> procedure_definition;
%type <std::shared_ptr<elna::boot::procedure_type_expression>> procedure_heading; %type <std::pair<std::vector<std::string>, std::shared_ptr<elna::boot::procedure_type_expression>>> procedure_heading;
%type <elna::boot::return_declaration> return_declaration;
%type <std::vector<elna::boot::procedure_definition *>> procedure_definitions procedure_part; %type <std::vector<elna::boot::procedure_definition *>> procedure_definitions procedure_part;
%type <elna::boot::type_definition *> type_definition; %type <elna::boot::type_definition *> type_definition;
%type <std::vector<elna::boot::type_definition *>> type_definitions type_part; %type <std::vector<elna::boot::type_definition *>> type_definitions type_part;
%type <elna::boot::block *> block; %type <elna::boot::block *> block;
%type <elna::boot::field_declaration> field_declaration; %type <elna::boot::field_declaration> field_declaration formal_parameter;
%type <std::vector<std::pair<std::string, std::shared_ptr<elna::boot::type_expression>>>> %type <std::vector<std::pair<std::string, std::shared_ptr<elna::boot::type_expression>>>>
optional_fields required_fields; optional_fields required_fields formal_parameters;
%type <std::vector<elna::boot::conditional_statements *>> elsif_then_statements elsif_do_statements; %type <std::vector<elna::boot::conditional_statements *>> elsif_then_statements elsif_do_statements;
%type <elna::boot::cast_expression *> cast_expression; %type <elna::boot::cast_expression *> cast_expression;
%type <elna::boot::defer_statement *> defer_statement; %type <elna::boot::defer_statement *> defer_statement;
@ -191,31 +191,32 @@ identifier_definitions:
$$.emplace($$.cbegin(), $1); $$.emplace($$.cbegin(), $1);
} }
| identifier_definition { $$.emplace_back(std::move($1)); } | identifier_definition { $$.emplace_back(std::move($1)); }
return_declaration:
/* proper procedure */ {}
| "->" "!" { $$ = elna::boot::return_declaration(std::monostate{}); }
| "->" type_expression { $$ = elna::boot::return_declaration($2); }
procedure_heading: procedure_heading:
formal_parameter_list "(" formal_parameters ")" return_declaration
{ {
$$ = std::make_shared<elna::boot::procedure_type_expression>(elna::boot::make_position(@1)); $$.second = std::make_shared<elna::boot::procedure_type_expression>(elna::boot::make_position(@1),
std::swap($1, $$->parameters); std::move($4));
} for (auto& [name, type] : $2)
| formal_parameter_list "->" "!" {
{ $$.first.emplace_back(std::move(name));
$$ = std::make_shared<elna::boot::procedure_type_expression>(elna::boot::make_position(@1), $$.second->parameters.push_back(type);
elna::boot::no_return); }
std::swap($1, $$->parameters);
}
| formal_parameter_list "->" type_expression
{
$$ = std::make_shared<elna::boot::procedure_type_expression>(elna::boot::make_position(@1), $3);
std::swap($1, $$->parameters);
} }
procedure_definition: procedure_definition:
"proc" identifier_definition procedure_heading ";" block "proc" identifier_definition procedure_heading ";" block
{ {
$$ = new elna::boot::procedure_definition(elna::boot::make_position(@1), $2.first, $2.second, $3, $5); $$ = new elna::boot::procedure_definition(elna::boot::make_position(@1),
$2.first, $2.second, $3.second, $5);
std::swap($3.first, $$->parameter_names);
} }
| "proc" identifier_definition procedure_heading ";" "extern" | "proc" identifier_definition procedure_heading ";" "extern"
{ {
$$ = new elna::boot::procedure_definition(elna::boot::make_position(@1), $2.first, $2.second, $3); $$ = new elna::boot::procedure_definition(elna::boot::make_position(@1), $2.first, $2.second, $3.second);
std::swap($3.first, $$->parameter_names);
} }
procedure_definitions: procedure_definitions:
procedure_definition procedure_definitions procedure_definition procedure_definitions
@ -293,47 +294,50 @@ defer_statement: DEFER statements "end"
literal: literal:
INTEGER INTEGER
{ {
$$ = new elna::boot::number_literal<std::int32_t>(elna::boot::make_position(@1), $1); $$ = new elna::boot::literal<std::int32_t>(elna::boot::make_position(@1), $1);
} }
| WORD | WORD
{ {
$$ = new elna::boot::number_literal<std::uint32_t>(elna::boot::make_position(@1), $1); $$ = new elna::boot::literal<std::uint32_t>(elna::boot::make_position(@1), $1);
} }
| FLOAT | FLOAT
{ {
$$ = new elna::boot::number_literal<double>(elna::boot::make_position(@1), $1); $$ = new elna::boot::literal<double>(elna::boot::make_position(@1), $1);
} }
| BOOLEAN | BOOLEAN
{ {
$$ = new elna::boot::number_literal<bool>(elna::boot::make_position(@1), $1); $$ = new elna::boot::literal<bool>(elna::boot::make_position(@1), $1);
} }
| CHARACTER | CHARACTER
{ {
$$ = new elna::boot::number_literal<unsigned char>(elna::boot::make_position(@1), $1.at(0)); $$ = new elna::boot::literal<unsigned char>(elna::boot::make_position(@1), $1.at(0));
} }
| "nil" | "nil"
{ {
$$ = new elna::boot::number_literal<std::nullptr_t>(elna::boot::make_position(@1), nullptr); $$ = new elna::boot::literal<std::nullptr_t>(elna::boot::make_position(@1), nullptr);
} }
| STRING | STRING
{ {
$$ = new elna::boot::number_literal<std::string>(elna::boot::make_position(@1), $1); $$ = new elna::boot::literal<std::string>(elna::boot::make_position(@1), $1);
} }
traits_expression: traits_expression:
TRAIT "(" type_expression ")" TRAIT "(" type_expressions ")"
{ {
$$ = new elna::boot::traits_expression(elna::boot::make_position(@1), $1, $3); $$ = new elna::boot::traits_expression(elna::boot::make_position(@1), $1);
std::swap($3, $$->parameters);
} }
operand: qualident:
literal { $$ = $1; } literal { $$ = $1; }
| designator_expression { $$ = $1; } | designator_expression { $$ = $1; }
| traits_expression { $$ = $1; } | traits_expression { $$ = $1; }
| cast_expression { $$ = $1; } | cast_expression { $$ = $1; }
| call_expression { $$ = $1; } | call_expression { $$ = $1; }
| "(" expression ")" { $$ = $2; } | "(" expression ")" { $$ = $2; }
expression: operand:
unary_expression { $$ = $1; } unary_expression { $$ = $1; }
| binary_expression { $$ = $1; } | qualident { $$ = $1; }
expression:
binary_expression { $$ = $1; }
| operand { $$ = $1; } | operand { $$ = $1; }
binary_expression: binary_expression:
expression "*" expression expression "*" expression
@ -391,12 +395,12 @@ binary_expression:
$$ = new elna::boot::binary_expression(elna::boot::make_position(@2), $1, $3, $$ = new elna::boot::binary_expression(elna::boot::make_position(@2), $1, $3,
elna::boot::binary_operator::greater_equal); elna::boot::binary_operator::greater_equal);
} }
| expression "and" expression | expression "&" expression
{ {
$$ = new elna::boot::binary_expression(elna::boot::make_position(@2), $1, $3, $$ = new elna::boot::binary_expression(elna::boot::make_position(@2), $1, $3,
elna::boot::binary_operator::conjunction); elna::boot::binary_operator::conjunction);
} }
| expression "or" expression | expression "|" expression
{ {
$$ = new elna::boot::binary_expression(elna::boot::make_position(@2), $1, $3, $$ = new elna::boot::binary_expression(elna::boot::make_position(@2), $1, $3,
elna::boot::binary_operator::disjunction); elna::boot::binary_operator::disjunction);
@ -422,7 +426,7 @@ unary_expression:
$$ = new elna::boot::unary_expression(elna::boot::make_position(@1), $2, $$ = new elna::boot::unary_expression(elna::boot::make_position(@1), $2,
elna::boot::unary_operator::reference); elna::boot::unary_operator::reference);
} }
| "not" operand | "~" operand
{ {
$$ = new elna::boot::unary_expression(elna::boot::make_position(@1), $2, $$ = new elna::boot::unary_expression(elna::boot::make_position(@1), $2,
elna::boot::unary_operator::negation); elna::boot::unary_operator::negation);
@ -438,17 +442,24 @@ expressions:
std::swap($$, $3); std::swap($$, $3);
$$.emplace($$.cbegin(), $1); $$.emplace($$.cbegin(), $1);
} }
| expression { $$.emplace_back(std::move($1)); } | expression { $$.push_back($1); }
type_expressions:
type_expression "," type_expressions
{
std::swap($$, $3);
$$.emplace($$.cbegin(), $1);
}
| type_expression { $$.push_back($1); }
designator_expression: designator_expression:
operand "[" expression "]" qualident "[" expression "]"
{ {
$$ = new elna::boot::array_access_expression(elna::boot::make_position(@2), $1, $3); $$ = new elna::boot::array_access_expression(elna::boot::make_position(@2), $1, $3);
} }
| operand "." IDENTIFIER | qualident "." IDENTIFIER
{ {
$$ = new elna::boot::field_access_expression(elna::boot::make_position(@2), $1, $3); $$ = new elna::boot::field_access_expression(elna::boot::make_position(@2), $1, $3);
} }
| operand "^" | qualident "^"
{ {
$$ = new elna::boot::dereference_expression(elna::boot::make_position(@1), $1); $$ = new elna::boot::dereference_expression(elna::boot::make_position(@1), $1);
} }
@ -500,9 +511,12 @@ type_expression:
{ {
$$ = std::make_shared<elna::boot::union_type_expression>(elna::boot::make_position(@1), std::move($2)); $$ = std::make_shared<elna::boot::union_type_expression>(elna::boot::make_position(@1), std::move($2));
} }
| "proc" procedure_heading | "proc" "(" type_expressions ")" return_declaration
{ {
$$ = $2; auto result = std::make_shared<elna::boot::procedure_type_expression>(elna::boot::make_position(@1),
std::move($5));
std::swap(result->parameters, $3);
$$ = result;
} }
| IDENTIFIER | IDENTIFIER
{ {
@ -559,18 +573,16 @@ type_part:
| "type" type_definitions { std::swap($$, $2); } | "type" type_definitions { std::swap($$, $2); }
formal_parameter: IDENTIFIER ":" type_expression formal_parameter: IDENTIFIER ":" type_expression
{ {
$$ = new elna::boot::variable_declaration(elna::boot::make_position(@2), $1, $3); $$ = std::make_pair($1, $3);
} }
formal_parameters: formal_parameters:
formal_parameter "," formal_parameters /* no formal parameters */ {}
| formal_parameter "," formal_parameters
{ {
std::swap($$, $3); std::swap($$, $3);
$$.emplace($$.cbegin(), $1); $$.emplace($$.cbegin(), $1);
} }
| formal_parameter { $$.emplace_back(std::move($1)); } | formal_parameter { $$.emplace_back(std::move($1)); }
formal_parameter_list:
"(" ")" {}
| "(" formal_parameters ")" { std::swap($$, $2); }
actual_parameter_list: actual_parameter_list:
"(" ")" {} "(" ")" {}
| "(" expressions ")" { std::swap($$, $2); } | "(" expressions ")" { std::swap($$, $2); }

5
boot/result.cc
View File

@ -17,9 +17,7 @@ along with GCC; see the file COPYING3. If not see
#include "elna/boot/result.h" #include "elna/boot/result.h"
namespace elna namespace elna::boot
{
namespace boot
{ {
error::error(const char *path, const struct position position) error::error(const char *path, const struct position position)
: position(position), path(path) : position(position), path(path)
@ -46,4 +44,3 @@ namespace boot
return m_errors; return m_errors;
} }
} }
}

130
boot/semantic.cc
View File

@ -17,9 +17,7 @@ along with GCC; see the file COPYING3. If not see
#include "elna/boot/semantic.h" #include "elna/boot/semantic.h"
namespace elna namespace elna::boot
{
namespace boot
{ {
undeclared_error::undeclared_error(const std::string& identifier, const char *path, const struct position position) undeclared_error::undeclared_error(const std::string& identifier, const char *path, const struct position position)
: error(path, position), identifier(identifier) : error(path, position), identifier(identifier)
@ -121,5 +119,129 @@ namespace boot
void declaration_visitor::visit(procedure_type_expression *) void declaration_visitor::visit(procedure_type_expression *)
{ {
} }
}
void declaration_visitor::visit(variable_declaration *)
{
__builtin_unreachable();
}
void declaration_visitor::visit(constant_definition *)
{
__builtin_unreachable();
}
void declaration_visitor::visit(procedure_definition *)
{
__builtin_unreachable();
}
void declaration_visitor::visit(assign_statement *)
{
__builtin_unreachable();
}
void declaration_visitor::visit(if_statement *)
{
__builtin_unreachable();
}
void declaration_visitor::visit(while_statement *)
{
__builtin_unreachable();
}
void declaration_visitor::visit(return_statement *)
{
__builtin_unreachable();
}
void declaration_visitor::visit(defer_statement *)
{
__builtin_unreachable();
}
void declaration_visitor::visit(procedure_call *)
{
__builtin_unreachable();
}
void declaration_visitor::visit(block *)
{
__builtin_unreachable();
}
void declaration_visitor::visit(traits_expression *)
{
__builtin_unreachable();
}
void declaration_visitor::visit(cast_expression *)
{
__builtin_unreachable();
}
void declaration_visitor::visit(binary_expression *)
{
__builtin_unreachable();
}
void declaration_visitor::visit(unary_expression *)
{
__builtin_unreachable();
}
void declaration_visitor::visit(variable_expression *)
{
__builtin_unreachable();
}
void declaration_visitor::visit(array_access_expression *)
{
__builtin_unreachable();
}
void declaration_visitor::visit(field_access_expression *)
{
__builtin_unreachable();
}
void declaration_visitor::visit(dereference_expression *)
{
__builtin_unreachable();
}
void declaration_visitor::visit(literal<std::int32_t> *)
{
__builtin_unreachable();
}
void declaration_visitor::visit(literal<std::uint32_t> *)
{
__builtin_unreachable();
}
void declaration_visitor::visit(literal<double> *)
{
__builtin_unreachable();
}
void declaration_visitor::visit(literal<bool> *)
{
__builtin_unreachable();
}
void declaration_visitor::visit(literal<unsigned char> *)
{
__builtin_unreachable();
}
void declaration_visitor::visit(literal<std::nullptr_t> *)
{
__builtin_unreachable();
}
void declaration_visitor::visit(literal<std::string> *)
{
__builtin_unreachable();
}
} }

5
boot/symbol.cc
View File

@ -17,9 +17,7 @@ along with GCC; see the file COPYING3. If not see
#include "elna/boot/symbol.h" #include "elna/boot/symbol.h"
namespace elna namespace elna::boot
{
namespace boot
{ {
type::type() type::type()
{ {
@ -301,4 +299,3 @@ namespace boot
return result; return result;
} }
} }
}

5
gcc/elna-builtins.cc
View File

@ -21,9 +21,7 @@ along with GCC; see the file COPYING3. If not see
#include "stringpool.h" #include "stringpool.h"
#include "elna/gcc/elna-tree.h" #include "elna/gcc/elna-tree.h"
namespace elna namespace elna::gcc
{
namespace gcc
{ {
void init_ttree() void init_ttree()
{ {
@ -66,4 +64,3 @@ namespace gcc
return symbol_table; return symbol_table;
} }
} }
}

5
gcc/elna-diagnostic.cc
View File

@ -19,9 +19,7 @@ along with GCC; see the file COPYING3. If not see
#include "elna/gcc/elna-tree.h" #include "elna/gcc/elna-tree.h"
#include "elna/gcc/elna1.h" #include "elna/gcc/elna1.h"
namespace elna namespace elna::gcc
{
namespace gcc
{ {
location_t get_location(const boot::position *position) location_t get_location(const boot::position *position)
{ {
@ -144,4 +142,3 @@ namespace gcc
} }
} }
} }
}

171
gcc/elna-generic.cc
View File

@ -34,9 +34,7 @@ along with GCC; see the file COPYING3. If not see
#include "fold-const.h" #include "fold-const.h"
#include "langhooks.h" #include "langhooks.h"
namespace elna namespace elna::gcc
{
namespace gcc
{ {
tree get_inner_alias(const boot::type& type, std::shared_ptr<symbol_table> symbols) tree get_inner_alias(const boot::type& type, std::shared_ptr<symbol_table> symbols)
{ {
@ -317,7 +315,7 @@ namespace gcc
tree fndecl = build_fn_decl(definition->identifier.c_str(), declaration_type); tree fndecl = build_fn_decl(definition->identifier.c_str(), declaration_type);
this->symbols->enter(definition->identifier, fndecl); this->symbols->enter(definition->identifier, fndecl);
if (definition->heading().no_return) if (definition->heading().return_type.no_return)
{ {
TREE_THIS_VOLATILE(fndecl) = 1; TREE_THIS_VOLATILE(fndecl) = 1;
} }
@ -336,19 +334,22 @@ namespace gcc
function_args_iterator parameter_type; function_args_iterator parameter_type;
function_args_iter_init(&parameter_type, declaration_type); function_args_iter_init(&parameter_type, declaration_type);
for (const boot::variable_declaration *parameter : definition->heading().parameters) std::vector<std::string>::const_iterator parameter_name = definition->parameter_names.cbegin();
for (std::shared_ptr<boot::type_expression> parameter : definition->heading().parameters)
{ {
tree declaration_tree = build_decl(get_location(&parameter->position()), PARM_DECL, tree declaration_tree = build_decl(get_location(&parameter->position()), PARM_DECL,
get_identifier(parameter->identifier.c_str()), function_args_iter_cond(&parameter_type)); get_identifier(parameter_name->c_str()), function_args_iter_cond(&parameter_type));
DECL_CONTEXT(declaration_tree) = fndecl; DECL_CONTEXT(declaration_tree) = fndecl;
DECL_ARG_TYPE(declaration_tree) = function_args_iter_cond(&parameter_type); DECL_ARG_TYPE(declaration_tree) = function_args_iter_cond(&parameter_type);
if (definition->body != nullptr) if (definition->body != nullptr)
{ {
this->symbols->enter(parameter->identifier, declaration_tree); this->symbols->enter(*parameter_name, declaration_tree);
} }
argument_chain = chainon(argument_chain, declaration_tree); argument_chain = chainon(argument_chain, declaration_tree);
function_args_iter_next(&parameter_type); function_args_iter_next(&parameter_type);
++parameter_name;
} }
DECL_ARGUMENTS(fndecl) = argument_chain; DECL_ARGUMENTS(fndecl) = argument_chain;
TREE_PUBLIC(fndecl) = definition->exported; TREE_PUBLIC(fndecl) = definition->exported;
@ -409,17 +410,17 @@ namespace gcc
return bind_expr; return bind_expr;
} }
void generic_visitor::visit(boot::number_literal<std::int32_t> *literal) void generic_visitor::visit(boot::literal<std::int32_t> *literal)
{ {
this->current_expression = build_int_cst(elna_int_type_node, literal->value); this->current_expression = build_int_cst(elna_int_type_node, literal->value);
} }
void generic_visitor::visit(boot::number_literal<std::uint32_t> *literal) void generic_visitor::visit(boot::literal<std::uint32_t> *literal)
{ {
this->current_expression = build_int_cstu(elna_word_type_node, literal->value); this->current_expression = build_int_cstu(elna_word_type_node, literal->value);
} }
void generic_visitor::visit(boot::number_literal<double> *literal) void generic_visitor::visit(boot::literal<double> *literal)
{ {
REAL_VALUE_TYPE real_value1; REAL_VALUE_TYPE real_value1;
@ -434,22 +435,22 @@ namespace gcc
mpfr_clear(number); mpfr_clear(number);
} }
void generic_visitor::visit(boot::number_literal<bool> *boolean) void generic_visitor::visit(boot::literal<bool> *boolean)
{ {
this->current_expression = boolean->value ? boolean_true_node : boolean_false_node; this->current_expression = boolean->value ? boolean_true_node : boolean_false_node;
} }
void generic_visitor::visit(boot::number_literal<unsigned char> *character) void generic_visitor::visit(boot::literal<unsigned char> *character)
{ {
this->current_expression = build_int_cstu(elna_char_type_node, character->value); this->current_expression = build_int_cstu(elna_char_type_node, character->value);
} }
void generic_visitor::visit(boot::number_literal<nullptr_t> *) void generic_visitor::visit(boot::literal<nullptr_t> *)
{ {
this->current_expression = elna_pointer_nil_node; this->current_expression = elna_pointer_nil_node;
} }
void generic_visitor::visit(boot::number_literal<std::string> *string) void generic_visitor::visit(boot::literal<std::string> *string)
{ {
tree index_constant = build_int_cstu(elna_word_type_node, string->value.size()); tree index_constant = build_int_cstu(elna_word_type_node, string->value.size());
tree string_type = build_array_type(elna_char_type_node, build_index_type(index_constant)); tree string_type = build_array_type(elna_char_type_node, build_index_type(index_constant));
@ -779,15 +780,14 @@ namespace gcc
for (std::size_t i = 0; i < type.parameters.size(); ++i) for (std::size_t i = 0; i < type.parameters.size(); ++i)
{ {
boot::type_expression& parameter_type = type.parameters.at(i)->variable_type(); type.parameters.at(i)->accept(this);
parameter_type.accept(this);
parameter_types[i] = this->current_expression; parameter_types[i] = this->current_expression;
} }
tree return_type = void_type_node; tree return_type = void_type_node;
if (type.return_type != nullptr) if (type.return_type.type != nullptr)
{ {
type.return_type->accept(this); type.return_type.type->accept(this);
return_type = this->current_expression; return_type = this->current_expression;
} }
this->current_expression = NULL_TREE; this->current_expression = NULL_TREE;
@ -924,32 +924,105 @@ namespace gcc
} }
} }
bool generic_visitor::expect_trait_type_only(boot::traits_expression *trait)
{
if (trait->parameters.size() != 1)
{
error_at(get_location(&trait->position()), "Trait '%s' expects 1 argument, got %lu",
trait->name.c_str(), trait->parameters.size());
this->current_expression = error_mark_node;
return false;
}
trait->parameters.front()->accept(this);
return this->current_expression != error_mark_node;
}
bool generic_visitor::expect_trait_for_integral_type(boot::traits_expression *trait)
{
if (!expect_trait_type_only(trait))
{
return false;
}
else if (!is_integral_type(this->current_expression))
{
error_at(get_location(&trait->position()), "Type '%s' does not support trait '%s'",
print_type(this->current_expression).c_str(), trait->name.c_str());
this->current_expression = error_mark_node;
return false;
}
return true;
}
void generic_visitor::visit(boot::traits_expression *trait) void generic_visitor::visit(boot::traits_expression *trait)
{ {
trait->type().accept(this); location_t trait_location = get_location(&trait->position());
if (trait->name == "size") if (trait->name == "size")
{ {
this->current_expression = build1(CONVERT_EXPR, elna_word_type_node, if (expect_trait_type_only(trait))
size_in_bytes(this->current_expression)); {
this->current_expression = build1_loc(trait_location, CONVERT_EXPR, elna_word_type_node,
size_in_bytes(this->current_expression));
}
} }
else if (trait->name == "alignment") else if (trait->name == "alignment")
{ {
this->current_expression = build_int_cstu(elna_word_type_node, if (expect_trait_type_only(trait))
TYPE_ALIGN_UNIT(this->current_expression)); {
this->current_expression = build_int_cstu(elna_word_type_node,
TYPE_ALIGN_UNIT(this->current_expression));
}
} }
else if (trait->name == "min" && is_integral_type(this->current_expression)) else if (trait->name == "min")
{ {
this->current_expression = TYPE_MIN_VALUE(this->current_expression); if (expect_trait_for_integral_type(trait))
{
this->current_expression = TYPE_MIN_VALUE(this->current_expression);
}
} }
else if (trait->name == "max" && is_integral_type(this->current_expression)) else if (trait->name == "max")
{ {
this->current_expression = TYPE_MAX_VALUE(this->current_expression); if (expect_trait_for_integral_type(trait))
{
this->current_expression = TYPE_MAX_VALUE(this->current_expression);
}
}
else if (trait->name == "offset")
{
if (trait->parameters.size() != 2)
{
error_at(trait_location, "Trait '%s' expects 2 arguments, got %lu",
trait->name.c_str(), trait->parameters.size());
this->current_expression = error_mark_node;
return;
}
trait->parameters.front()->accept(this);
auto field_type = trait->parameters.at(1)->is_primitive();
if (field_type == nullptr)
{
error_at(trait_location,
"The second argument to the offset trait is expected to be a field name,"
"got a type expression");
this->current_expression = error_mark_node;
return;
}
tree field_declaration = find_field_by_name(trait_location, this->current_expression, field_type->name);
if (field_declaration != error_mark_node)
{
this->current_expression = build1(CONVERT_EXPR, elna_word_type_node,
byte_position(field_declaration));
}
else
{
this->current_expression = error_mark_node;
}
} }
else else
{ {
error_at(get_location(&trait->position()), "type '%s' does not have property '%s'", error_at(get_location(&trait->position()), "Trait '%s' is unknown", trait->name.c_str());
print_type(this->current_expression).c_str(), trait->name.c_str());
this->current_expression = error_mark_node; this->current_expression = error_mark_node;
} }
} }
@ -958,41 +1031,14 @@ namespace gcc
{ {
expression->base().accept(this); expression->base().accept(this);
location_t expression_location = get_location(&expression->position()); location_t expression_location = get_location(&expression->position());
tree field_declaration = find_field_by_name(expression_location,
TREE_TYPE(this->current_expression), expression->field());
if (is_aggregate_type(TREE_TYPE(this->current_expression))) if (field_declaration != error_mark_node)
{ {
tree field_declaration = TYPE_FIELDS(TREE_TYPE(this->current_expression)); this->current_expression = build3_loc(expression_location, COMPONENT_REF,
TREE_TYPE(field_declaration), this->current_expression,
while (field_declaration != NULL_TREE) field_declaration, NULL_TREE);
{
tree declaration_name = DECL_NAME(field_declaration);
const char *identifier_pointer = IDENTIFIER_POINTER(declaration_name);
if (expression->field() == identifier_pointer)
{
break;
}
field_declaration = TREE_CHAIN(field_declaration);
}
if (field_declaration == NULL_TREE)
{
error_at(expression_location,
"record type does not have a field named '%s'",
expression->field().c_str());
this->current_expression = error_mark_node;
}
else
{
this->current_expression = build3_loc(expression_location, COMPONENT_REF,
TREE_TYPE(field_declaration), this->current_expression,
field_declaration, NULL_TREE);
}
}
else
{
error_at(expression_location, "type '%s' does not have a field named '%s'",
print_type(TREE_TYPE(this->current_expression)).c_str(), expression->field().c_str());
this->current_expression = error_mark_node;
} }
} }
@ -1226,4 +1272,3 @@ namespace gcc
defer(leave_scope()); defer(leave_scope());
} }
} }
}

38
gcc/elna-tree.cc
View File

@ -24,9 +24,7 @@ along with GCC; see the file COPYING3. If not see
#include "fold-const.h" #include "fold-const.h"
#include "diagnostic-core.h" #include "diagnostic-core.h"
namespace elna namespace elna::gcc
{
namespace gcc
{ {
bool is_pointer_type(tree type) bool is_pointer_type(tree type)
{ {
@ -209,5 +207,37 @@ namespace gcc
return error_mark_node; return error_mark_node;
} }
} }
}
tree find_field_by_name(location_t expression_location, tree type, const std::string& field_name)
{
if (type == error_mark_node)
{
return type;
}
tree field_declaration = TYPE_FIELDS(type);
if (!is_aggregate_type(type))
{
error_at(expression_location, "type '%s' does not have a field named '%s'",
print_type(type).c_str(), field_name.c_str());
return error_mark_node;
}
while (field_declaration != NULL_TREE)
{
tree declaration_name = DECL_NAME(field_declaration);
const char *identifier_pointer = IDENTIFIER_POINTER(declaration_name);
if (field_name == identifier_pointer)
{
break;
}
field_declaration = TREE_CHAIN(field_declaration);
}
if (field_declaration == NULL_TREE)
{
error_at(expression_location, "record type does not have a field named '%s'", field_name.c_str());
return error_mark_node;
}
return field_declaration;
}
} }

152
include/elna/boot/ast.h
View File

@ -21,11 +21,10 @@ along with GCC; see the file COPYING3. If not see
#include <memory> #include <memory>
#include <string> #include <string>
#include <vector> #include <vector>
#include <variant>
#include "elna/boot/result.h" #include "elna/boot/result.h"
namespace elna namespace elna::boot
{
namespace boot
{ {
enum class binary_operator enum class binary_operator
{ {
@ -80,9 +79,9 @@ namespace boot
class field_access_expression; class field_access_expression;
class dereference_expression; class dereference_expression;
class designator_expression; class designator_expression;
class literal; class literal_expression;
template<typename T> template<typename T>
class number_literal; class literal;
class defer_statement; class defer_statement;
/** /**
@ -116,53 +115,13 @@ namespace boot
virtual void visit(array_access_expression *) = 0; virtual void visit(array_access_expression *) = 0;
virtual void visit(field_access_expression *) = 0; virtual void visit(field_access_expression *) = 0;
virtual void visit(dereference_expression *) = 0; virtual void visit(dereference_expression *) = 0;
virtual void visit(number_literal<std::int32_t> *) = 0; virtual void visit(literal<std::int32_t> *) = 0;
virtual void visit(number_literal<std::uint32_t> *) = 0; virtual void visit(literal<std::uint32_t> *) = 0;
virtual void visit(number_literal<double> *) = 0; virtual void visit(literal<double> *) = 0;
virtual void visit(number_literal<bool> *) = 0; virtual void visit(literal<bool> *) = 0;
virtual void visit(number_literal<unsigned char> *) = 0; virtual void visit(literal<unsigned char> *) = 0;
virtual void visit(number_literal<std::nullptr_t> *) = 0; virtual void visit(literal<std::nullptr_t> *) = 0;
virtual void visit(number_literal<std::string> *) = 0; virtual void visit(literal<std::string> *) = 0;
};
/**
* A visitor which visits all nodes but does nothing.
*/
struct empty_visitor : parser_visitor
{
virtual void visit(variable_declaration *) override;
virtual void visit(constant_definition *) override;
virtual void visit(procedure_definition *) override;
virtual void visit(type_definition *) override;
virtual void visit(procedure_call *) override;
virtual void visit(cast_expression *) override;
virtual void visit(traits_expression *) override;
virtual void visit(assign_statement *) override;
virtual void visit(if_statement *) override;
virtual void visit(while_statement *) override;
virtual void visit(return_statement *) override;
virtual void visit(defer_statement *) override;
virtual void visit(block *) override;
virtual void visit(program *) override;
virtual void visit(binary_expression *) override;
virtual void visit(unary_expression *) override;
virtual void visit(primitive_type_expression *) override;
virtual void visit(array_type_expression *) override;
virtual void visit(pointer_type_expression *) override;
virtual void visit(record_type_expression *) override;
virtual void visit(union_type_expression *) override;
virtual void visit(procedure_type_expression *) override;
virtual void visit(variable_expression *) override;
virtual void visit(array_access_expression *) override;
virtual void visit(field_access_expression *) override;
virtual void visit(dereference_expression *) override;
virtual void visit(number_literal<std::int32_t> *) override;
virtual void visit(number_literal<std::uint32_t> *) override;
virtual void visit(number_literal<double> *) override;
virtual void visit(number_literal<bool> *) override;
virtual void visit(number_literal<unsigned char> *) override;
virtual void visit(number_literal<std::nullptr_t> *) override;
virtual void visit(number_literal<std::string> *) override;
}; };
/** /**
@ -213,7 +172,7 @@ namespace boot
virtual unary_expression *is_unary(); virtual unary_expression *is_unary();
virtual designator_expression *is_designator(); virtual designator_expression *is_designator();
virtual procedure_call *is_call_expression(); virtual procedure_call *is_call_expression();
virtual literal *is_literal(); virtual literal_expression *is_literal();
void accept(parser_visitor *visitor); void accept(parser_visitor *visitor);
~expression() = 0; ~expression() = 0;
@ -336,22 +295,22 @@ namespace boot
/** /**
* Literal expression. * Literal expression.
*/ */
class literal : public expression class literal_expression : public expression
{ {
public: public:
virtual number_literal<std::int32_t> *is_int() = 0; virtual literal<std::int32_t> *is_int() = 0;
virtual number_literal<std::uint32_t> *is_word() = 0; virtual literal<std::uint32_t> *is_word() = 0;
virtual number_literal<double> *is_float() = 0; virtual literal<double> *is_float() = 0;
virtual number_literal<bool> *is_bool() = 0; virtual literal<bool> *is_bool() = 0;
virtual number_literal<unsigned char> *is_char() = 0; virtual literal<unsigned char> *is_char() = 0;
virtual number_literal<std::nullptr_t> *is_nil() = 0; virtual literal<std::nullptr_t> *is_nil() = 0;
virtual number_literal<std::string> *is_string() = 0; virtual literal<std::string> *is_string() = 0;
literal *is_literal() override; literal_expression *is_literal() override;
void accept(parser_visitor *visitor); void accept(parser_visitor *visitor);
protected: protected:
literal(); literal_expression();
}; };
/** /**
@ -359,7 +318,7 @@ namespace boot
*/ */
class constant_definition : public definition class constant_definition : public definition
{ {
literal *m_body; literal_expression *m_body;
public: public:
/** /**
@ -368,10 +327,10 @@ namespace boot
* \param body Constant value. * \param body Constant value.
*/ */
constant_definition(const struct position position, const std::string& identifier, constant_definition(const struct position position, const std::string& identifier,
const bool exported, literal *body); const bool exported, literal_expression *body);
void accept(parser_visitor *visitor); void accept(parser_visitor *visitor);
literal& body(); literal_expression& body();
virtual ~constant_definition() override; virtual ~constant_definition() override;
}; };
@ -379,10 +338,15 @@ namespace boot
/** /**
* Tags a procedure type as never returning. * Tags a procedure type as never returning.
*/ */
struct no_return_t struct return_declaration
{ {
return_declaration() = default;
explicit return_declaration(std::shared_ptr<type_expression> type);
explicit return_declaration(std::monostate);
std::shared_ptr<type_expression> type{ nullptr };
bool no_return{ false };
}; };
constexpr no_return_t no_return{};
/** /**
* Procedure type. * Procedure type.
@ -390,18 +354,14 @@ namespace boot
class procedure_type_expression : public type_expression class procedure_type_expression : public type_expression
{ {
public: public:
const std::shared_ptr<type_expression> return_type; const return_declaration return_type;
const bool no_return; std::vector<std::shared_ptr<type_expression>> parameters;
std::vector<variable_declaration *> parameters;
procedure_type_expression(const struct position position, procedure_type_expression(const struct position position,
std::shared_ptr<type_expression> return_type = nullptr); return_declaration return_type = return_declaration());
procedure_type_expression(const struct position position, no_return_t);
void accept(parser_visitor *visitor); void accept(parser_visitor *visitor);
std::shared_ptr<procedure_type_expression> is_procedure() override; std::shared_ptr<procedure_type_expression> is_procedure() override;
virtual ~procedure_type_expression() override;
}; };
/** /**
@ -413,6 +373,7 @@ namespace boot
public: public:
block *const body; block *const body;
std::vector<std::string> parameter_names;
procedure_definition(const struct position position, const std::string& identifier, procedure_definition(const struct position position, const std::string& identifier,
const bool exported, std::shared_ptr<procedure_type_expression> heading, block *body = nullptr); const bool exported, std::shared_ptr<procedure_type_expression> heading, block *body = nullptr);
@ -459,17 +420,13 @@ namespace boot
class traits_expression : public expression class traits_expression : public expression
{ {
std::shared_ptr<type_expression> m_type;
public: public:
std::vector<std::shared_ptr<type_expression>> parameters;
const std::string name; const std::string name;
traits_expression(const struct position position, const std::string& name, traits_expression(const struct position position, const std::string& name);
std::shared_ptr<type_expression> type);
void accept(parser_visitor *visitor); void accept(parser_visitor *visitor);
traits_expression *is_traits() override; traits_expression *is_traits() override;
type_expression& type();
}; };
/** /**
@ -688,21 +645,21 @@ namespace boot
}; };
template<typename T> template<typename T>
class number_literal : public literal class literal : public literal_expression
{ {
public: public:
T value; T value;
number_literal(const struct position position, const T& value) literal(const struct position position, const T& value)
: node(position), value(value) : node(position), value(value)
{ {
} }
number_literal<std::int32_t> *is_int() override literal<std::int32_t> *is_int() override
{ {
if (std::is_same<T, std::int32_t>::value) if (std::is_same<T, std::int32_t>::value)
{ {
return reinterpret_cast<number_literal<std::int32_t> *>(this); return reinterpret_cast<literal<std::int32_t> *>(this);
} }
else else
{ {
@ -710,11 +667,11 @@ namespace boot
} }
} }
number_literal<std::uint32_t> *is_word() override literal<std::uint32_t> *is_word() override
{ {
if (std::is_same<T, std::uint32_t>::value) if (std::is_same<T, std::uint32_t>::value)
{ {
return reinterpret_cast<number_literal<std::uint32_t> *>(this); return reinterpret_cast<literal<std::uint32_t> *>(this);
} }
else else
{ {
@ -722,11 +679,11 @@ namespace boot
} }
} }
number_literal<double> *is_float() override literal<double> *is_float() override
{ {
if (std::is_same<T, double>::value) if (std::is_same<T, double>::value)
{ {
return reinterpret_cast<number_literal<double> *>(this); return reinterpret_cast<literal<double> *>(this);
} }
else else
{ {
@ -734,11 +691,11 @@ namespace boot
} }
} }
number_literal<bool> *is_bool() override literal<bool> *is_bool() override
{ {
if (std::is_same<T, bool>::value) if (std::is_same<T, bool>::value)
{ {
return reinterpret_cast<number_literal<bool> *>(this); return reinterpret_cast<literal<bool> *>(this);
} }
else else
{ {
@ -746,11 +703,11 @@ namespace boot
} }
} }
number_literal<unsigned char> *is_char() override literal<unsigned char> *is_char() override
{ {
if (std::is_same<T, unsigned char>::value) if (std::is_same<T, unsigned char>::value)
{ {
return reinterpret_cast<number_literal<unsigned char> *>(this); return reinterpret_cast<literal<unsigned char> *>(this);
} }
else else
{ {
@ -758,11 +715,11 @@ namespace boot
} }
} }
number_literal<std::nullptr_t> *is_nil() override literal<std::nullptr_t> *is_nil() override
{ {
if (std::is_same<T, std::nullptr_t>::value) if (std::is_same<T, std::nullptr_t>::value)
{ {
return reinterpret_cast<number_literal<std::nullptr_t> *>(this); return reinterpret_cast<literal<std::nullptr_t> *>(this);
} }
else else
{ {
@ -770,11 +727,11 @@ namespace boot
} }
} }
number_literal<std::string> *is_string() override literal<std::string> *is_string() override
{ {
if (std::is_same<T, std::string>::value) if (std::is_same<T, std::string>::value)
{ {
return reinterpret_cast<number_literal<std::string> *>(this); return reinterpret_cast<literal<std::string> *>(this);
} }
else else
{ {
@ -840,4 +797,3 @@ namespace boot
const char *print_binary_operator(const binary_operator operation); const char *print_binary_operator(const binary_operator operation);
} }
}

5
include/elna/boot/driver.h
View File

@ -21,9 +21,7 @@ along with GCC; see the file COPYING3. If not see
#include "elna/boot/ast.h" #include "elna/boot/ast.h"
#include "location.hh" #include "location.hh"
namespace elna namespace elna::boot
{
namespace boot
{ {
position make_position(const yy::location& location); position make_position(const yy::location& location);
@ -50,4 +48,3 @@ namespace boot
char escape_char(char escape); char escape_char(char escape);
} }
}

5
include/elna/boot/result.h
View File

@ -22,9 +22,7 @@ along with GCC; see the file COPYING3. If not see
#include <deque> #include <deque>
#include <memory> #include <memory>
namespace elna namespace elna::boot
{
namespace boot
{ {
/** /**
* Position in the source text. * Position in the source text.
@ -82,4 +80,3 @@ namespace boot
} }
}; };
} }
}

33
include/elna/boot/semantic.h
View File

@ -24,9 +24,7 @@ along with GCC; see the file COPYING3. If not see
#include "elna/boot/result.h" #include "elna/boot/result.h"
#include "elna/boot/symbol.h" #include "elna/boot/symbol.h"
namespace elna namespace elna::boot
{
namespace boot
{ {
class undeclared_error : public error class undeclared_error : public error
{ {
@ -48,7 +46,7 @@ namespace boot
std::string what() const override; std::string what() const override;
}; };
class declaration_visitor final : public empty_visitor, public error_container class declaration_visitor final : public parser_visitor, public error_container
{ {
type current_type; type current_type;
std::shared_ptr<symbol_table> symbols; std::shared_ptr<symbol_table> symbols;
@ -66,6 +64,31 @@ namespace boot
void visit(record_type_expression *) override; void visit(record_type_expression *) override;
void visit(union_type_expression *) override; void visit(union_type_expression *) override;
void visit(procedure_type_expression *) override; void visit(procedure_type_expression *) override;
void visit(variable_declaration *) override;
void visit(constant_definition *) override;
void visit(procedure_definition *) override;
void visit(assign_statement *) override;
void visit(if_statement *) override;
void visit(while_statement *) override;
void visit(return_statement *) override;
void visit(defer_statement *) override;
void visit(procedure_call *) override;
void visit(block *) override;
void visit(cast_expression *) override;
void visit(traits_expression *) override;
void visit(binary_expression *) override;
void visit(unary_expression *) override;
void visit(variable_expression *) override;
void visit(array_access_expression *) override;
void visit(field_access_expression *) override;
void visit(dereference_expression *) override;
void visit(literal<std::int32_t> *) override;
void visit(literal<std::uint32_t> *) override;
void visit(literal<double> *) override;
void visit(literal<bool> *) override;
void visit(literal<unsigned char> *) override;
void visit(literal<std::nullptr_t> *) override;
void visit(literal<std::string> *) override;
}; };
} }
}

5
include/elna/boot/symbol.h
View File

@ -23,9 +23,7 @@ along with GCC; see the file COPYING3. If not see
#include <memory> #include <memory>
#include <vector> #include <vector>
namespace elna namespace elna::boot
{
namespace boot
{ {
class alias_type; class alias_type;
class primitive_type; class primitive_type;
@ -257,4 +255,3 @@ namespace boot
std::shared_ptr<symbol_table> builtin_symbol_table(); std::shared_ptr<symbol_table> builtin_symbol_table();
} }
}

5
include/elna/gcc/elna-builtins.h
View File

@ -25,11 +25,8 @@ along with GCC; see the file COPYING3. If not see
#include "elna/gcc/elna-tree.h" #include "elna/gcc/elna-tree.h"
namespace elna namespace elna::gcc
{
namespace gcc
{ {
void init_ttree(); void init_ttree();
std::shared_ptr<symbol_table> builtin_symbol_table(); std::shared_ptr<symbol_table> builtin_symbol_table();
} }
}

5
include/elna/gcc/elna-diagnostic.h
View File

@ -29,12 +29,9 @@ along with GCC; see the file COPYING3. If not see
#include "elna/boot/result.h" #include "elna/boot/result.h"
namespace elna namespace elna::gcc
{
namespace gcc
{ {
location_t get_location(const boot::position *position); location_t get_location(const boot::position *position);
std::string print_type(tree type); std::string print_type(tree type);
void report_errors(const std::deque<std::unique_ptr<boot::error>>& errors); void report_errors(const std::deque<std::unique_ptr<boot::error>>& errors);
} }
}

24
include/elna/gcc/elna-generic.h
View File

@ -30,16 +30,14 @@ along with GCC; see the file COPYING3. If not see
#include <string> #include <string>
namespace elna namespace elna::gcc
{
namespace gcc
{ {
std::deque<std::unique_ptr<boot::error>> do_semantic_analysis(const char *path, std::deque<std::unique_ptr<boot::error>> do_semantic_analysis(const char *path,
std::unique_ptr<boot::program>& ast, std::shared_ptr<boot::symbol_table> info_table, std::unique_ptr<boot::program>& ast, std::shared_ptr<boot::symbol_table> info_table,
std::shared_ptr<symbol_table> symbols); std::shared_ptr<symbol_table> symbols);
tree handle_symbol(const std::string& symbol_name, const boot::type& type, std::shared_ptr<symbol_table> symbols); tree handle_symbol(const std::string& symbol_name, const boot::type& type, std::shared_ptr<symbol_table> symbols);
class generic_visitor final : public boot::empty_visitor class generic_visitor final : public boot::parser_visitor
{ {
tree current_expression{ NULL_TREE }; tree current_expression{ NULL_TREE };
std::shared_ptr<symbol_table> symbols; std::shared_ptr<symbol_table> symbols;
@ -64,6 +62,9 @@ namespace gcc
tree procedure_address, const std::vector<boot::expression *>& arguments); tree procedure_address, const std::vector<boot::expression *>& arguments);
void build_record_call(location_t call_location, void build_record_call(location_t call_location,
tree symbol, const std::vector<boot::expression *>& arguments); tree symbol, const std::vector<boot::expression *>& arguments);
bool expect_trait_type_only(boot::traits_expression *trait);
bool expect_trait_for_integral_type(boot::traits_expression *trait);
void visit_statements(const std::vector<boot::statement *>& statements); void visit_statements(const std::vector<boot::statement *>& statements);
public: public:
@ -74,13 +75,13 @@ namespace gcc
void visit(boot::procedure_call *call) override; void visit(boot::procedure_call *call) override;
void visit(boot::cast_expression *expression) override; void visit(boot::cast_expression *expression) override;
void visit(boot::traits_expression *trait) override; void visit(boot::traits_expression *trait) override;
void visit(boot::number_literal<std::int32_t> *literal) override; void visit(boot::literal<std::int32_t> *literal) override;
void visit(boot::number_literal<std::uint32_t> *literal) override; void visit(boot::literal<std::uint32_t> *literal) override;
void visit(boot::number_literal<double> *literal) override; void visit(boot::literal<double> *literal) override;
void visit(boot::number_literal<bool> *boolean) override; void visit(boot::literal<bool> *boolean) override;
void visit(boot::number_literal<unsigned char> *character) override; void visit(boot::literal<unsigned char> *character) override;
void visit(boot::number_literal<std::nullptr_t> *) override; void visit(boot::literal<std::nullptr_t> *) override;
void visit(boot::number_literal<std::string> *string) override; void visit(boot::literal<std::string> *string) override;
void visit(boot::binary_expression *expression) override; void visit(boot::binary_expression *expression) override;
void visit(boot::unary_expression *expression) override; void visit(boot::unary_expression *expression) override;
void visit(boot::constant_definition *definition) override; void visit(boot::constant_definition *definition) override;
@ -104,4 +105,3 @@ namespace gcc
void visit(boot::defer_statement *statement) override; void visit(boot::defer_statement *statement) override;
}; };
} }
}

6
include/elna/gcc/elna-tree.h
View File

@ -29,9 +29,7 @@ along with GCC; see the file COPYING3. If not see
#include "elna/boot/ast.h" #include "elna/boot/ast.h"
#include "elna/boot/symbol.h" #include "elna/boot/symbol.h"
namespace elna namespace elna::gcc
{
namespace gcc
{ {
using symbol_table = boot::symbol_map<tree, tree, NULL_TREE>; using symbol_table = boot::symbol_map<tree, tree, NULL_TREE>;
@ -81,5 +79,5 @@ namespace gcc
tree build_arithmetic_operation(boot::binary_expression *expression, tree build_arithmetic_operation(boot::binary_expression *expression,
tree_code operator_code, tree left, tree right); tree_code operator_code, tree left, tree right);
tree build_field(location_t location, tree record_type, const std::string name, tree type); tree build_field(location_t location, tree record_type, const std::string name, tree type);
} tree find_field_by_name(location_t expression_location, tree type, const std::string& field_name);
} }

6
source.elna
View File

@ -88,9 +88,9 @@ type
position: Position position: Position
input: ^Byte input: ^Byte
empty: proc(data: ^Byte) -> Bool empty: proc(^Byte) -> Bool
advance: proc(data: ^Byte) advance: proc(^Byte)
head: proc(data: ^Byte) -> Char head: proc(^Byte) -> Char
end end
Token* = record Token* = record
kind: Int kind: Int