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 df3282cd96
Signed by: belka
GPG Key ID: A27FDC1E8EE902C0
20 changed files with 181 additions and 224 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
boot/ast.cc
View File

@ -17,9 +17,7 @@ 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 *) void empty_visitor::visit(variable_declaration *)
{ {
@ -151,37 +149,37 @@ namespace boot
__builtin_unreachable(); __builtin_unreachable();
} }
void empty_visitor::visit(number_literal<std::int32_t> *) void empty_visitor::visit(literal<std::int32_t> *)
{ {
__builtin_unreachable(); __builtin_unreachable();
} }
void empty_visitor::visit(number_literal<std::uint32_t> *) void empty_visitor::visit(literal<std::uint32_t> *)
{ {
__builtin_unreachable(); __builtin_unreachable();
} }
void empty_visitor::visit(number_literal<double> *) void empty_visitor::visit(literal<double> *)
{ {
__builtin_unreachable(); __builtin_unreachable();
} }
void empty_visitor::visit(number_literal<bool> *) void empty_visitor::visit(literal<bool> *)
{ {
__builtin_unreachable(); __builtin_unreachable();
} }
void empty_visitor::visit(number_literal<unsigned char> *) void empty_visitor::visit(literal<unsigned char> *)
{ {
__builtin_unreachable(); __builtin_unreachable();
} }
void empty_visitor::visit(number_literal<std::nullptr_t> *) void empty_visitor::visit(literal<std::nullptr_t> *)
{ {
__builtin_unreachable(); __builtin_unreachable();
} }
void empty_visitor::visit(number_literal<std::string> *) void empty_visitor::visit(literal<std::string> *)
{ {
__builtin_unreachable(); __builtin_unreachable();
} }
@ -305,7 +303,7 @@ namespace boot
return nullptr; return nullptr;
} }
literal *expression::is_literal() literal_expression *expression::is_literal()
{ {
return nullptr; return nullptr;
} }
@ -336,7 +334,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 +516,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 +526,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 +536,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 +557,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 +647,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);
} }
@ -1212,4 +1207,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
} }
} }
} }
}

85
boot/parser.yy
View File

@ -119,13 +119,12 @@ along with GCC; see the file COPYING3. If not see
%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;
%type <elna::boot::unary_expression *> unary_expression; %type <elna::boot::unary_expression *> unary_expression;
@ -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,31 +294,31 @@ 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_expression ")"
@ -438,7 +439,14 @@ 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 "]" operand "[" expression "]"
{ {
@ -500,9 +508,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 +570,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;
} }
} }
}

5
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)
@ -122,4 +120,3 @@ namespace boot
{ {
} }
} }
}

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
} }
} }
} }
}

37
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;
@ -1226,4 +1226,3 @@ namespace gcc
defer(leave_scope()); defer(leave_scope());
} }
} }
}

5
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)
{ {
@ -210,4 +208,3 @@ namespace gcc
} }
} }
} }
}

118
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,13 +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;
}; };
/** /**
@ -156,13 +155,13 @@ namespace boot
virtual void visit(array_access_expression *) override; virtual void visit(array_access_expression *) override;
virtual void visit(field_access_expression *) override; virtual void visit(field_access_expression *) override;
virtual void visit(dereference_expression *) override; virtual void visit(dereference_expression *) override;
virtual void visit(number_literal<std::int32_t> *) override; virtual void visit(literal<std::int32_t> *) override;
virtual void visit(number_literal<std::uint32_t> *) override; virtual void visit(literal<std::uint32_t> *) override;
virtual void visit(number_literal<double> *) override; virtual void visit(literal<double> *) override;
virtual void visit(number_literal<bool> *) override; virtual void visit(literal<bool> *) override;
virtual void visit(number_literal<unsigned char> *) override; virtual void visit(literal<unsigned char> *) override;
virtual void visit(number_literal<std::nullptr_t> *) override; virtual void visit(literal<std::nullptr_t> *) override;
virtual void visit(number_literal<std::string> *) override; virtual void visit(literal<std::string> *) override;
}; };
/** /**
@ -213,7 +212,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 +335,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 +358,7 @@ namespace boot
*/ */
class constant_definition : public definition class constant_definition : public definition
{ {
literal *m_body; literal_expression *m_body;
public: public:
/** /**
@ -368,10 +367,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 +378,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 +394,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 +413,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);
@ -688,21 +689,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 +711,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 +723,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 +735,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 +747,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 +759,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 +771,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 +841,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
} }
}; };
} }
}

5
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
{ {
@ -68,4 +66,3 @@ namespace boot
void visit(procedure_type_expression *) override; void visit(procedure_type_expression *) 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);
} }
}

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

@ -30,9 +30,7 @@ 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,
@ -74,13 +72,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 +102,3 @@ namespace gcc
void visit(boot::defer_statement *statement) override; void visit(boot::defer_statement *statement) override;
}; };
} }
}

5
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>;
@ -82,4 +80,3 @@ namespace gcc
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);
} }
}

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