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"
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)
: source_position(position)
{
@ -305,7 +138,7 @@ namespace boot
return nullptr;
}
literal *expression::is_literal()
literal_expression *expression::is_literal()
{
return nullptr;
}
@ -336,7 +169,7 @@ namespace boot
{
return node->accept(visitor);
}
else if (literal *node = is_literal())
else if (literal_expression *node = is_literal())
{
return node->accept(visitor);
}
@ -518,7 +351,7 @@ namespace boot
}
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)
{
}
@ -528,7 +361,7 @@ namespace boot
visitor->visit(this);
}
literal& constant_definition::body()
literal_expression& constant_definition::body()
{
return *m_body;
}
@ -538,14 +371,19 @@ namespace boot
delete m_body;
}
procedure_type_expression::procedure_type_expression(const struct position position,
std::shared_ptr<type_expression> return_type)
: type_expression(position), return_type(return_type), no_return(false)
return_declaration::return_declaration(std::shared_ptr<type_expression> type)
: type(type)
{
}
procedure_type_expression::procedure_type_expression(const struct position position, no_return_t)
: type_expression(position), return_type(nullptr), no_return(true)
return_declaration::return_declaration(std::monostate)
: 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);
}
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,
const bool exported, std::shared_ptr<procedure_type_expression> heading, block *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;
}
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);
}
else if (number_literal<std::uint32_t> *node = is_word())
else if (literal<std::uint32_t> *node = is_word())
{
return node->accept(visitor);
}
else if (number_literal<double> *node = is_float())
else if (literal<double> *node = is_float())
{
return node->accept(visitor);
}
else if (number_literal<bool> *node = is_bool())
else if (literal<bool> *node = is_bool())
{
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);
}
else if (number_literal<std::nullptr_t> *node = is_nil())
else if (literal<std::nullptr_t> *node = is_nil())
{
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);
}
@ -991,9 +821,8 @@ namespace boot
delete m_value;
}
traits_expression::traits_expression(const struct position position,
const std::string& name, std::shared_ptr<type_expression> type)
: node(position), m_type(type), name(name)
traits_expression::traits_expression(const struct position position, const std::string& name)
: node(position), name(name)
{
}
@ -1007,11 +836,6 @@ namespace boot
return this;
}
type_expression& traits_expression::type()
{
return *m_type;
}
conditional_statements::conditional_statements(expression *prerequisite)
: m_prerequisite(prerequisite)
{
@ -1212,4 +1036,3 @@ namespace boot
__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"
namespace elna
{
namespace boot
namespace elna::boot
{
position make_position(const yy::location& location)
{
@ -79,4 +77,3 @@ namespace boot
}
}
}
}

116
boot/parser.yy
View File

@ -87,7 +87,7 @@ along with GCC; see the file COPYING3. If not see
ARROW "->" EXCLAMATION "!"
AT "@" HAT "^"
COLON ":" SEMICOLON ";" DOT "." COMMA ","
%token NOT "not"
%token NOT "~"
CAST "cast"
NIL "nil"
CONST "const"
@ -107,27 +107,26 @@ along with GCC; see the file COPYING3. If not see
BEGIN_BLOCK "begin"
END_BLOCK "end"
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 ">="
SHIFT_LEFT "<<" SHIFT_RIGHT ">>"
PLUS "+" MINUS "-"
MULTIPLICATION "*" DIVISION "/" REMAINDER "%"
%left "or" "and" "xor"
%left "|" "&" "xor"
%left "=" "<>" "<" ">" "<=" ">="
%left "<<" ">>"
%left "+" "-"
%left "*" "/" "%"
%type <elna::boot::literal *> literal;
%type <elna::boot::literal_expression *> literal;
%type <elna::boot::constant_definition *> constant_definition;
%type <std::vector<elna::boot::constant_definition *>> constant_part constant_definitions;
%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::vector<elna::boot::variable_declaration *>> variable_declarations variable_part variable_declaration;
%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::expression *> expression operand;
%type <elna::boot::expression *> expression operand qualident;
%type <elna::boot::unary_expression *> unary_expression;
%type <elna::boot::binary_expression *> binary_expression;
%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 <std::vector<elna::boot::statement *>> statements;
%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 <elna::boot::type_definition *> type_definition;
%type <std::vector<elna::boot::type_definition *>> type_definitions type_part;
%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>>>>
optional_fields required_fields;
optional_fields required_fields formal_parameters;
%type <std::vector<elna::boot::conditional_statements *>> elsif_then_statements elsif_do_statements;
%type <elna::boot::cast_expression *> cast_expression;
%type <elna::boot::defer_statement *> defer_statement;
@ -191,31 +191,32 @@ identifier_definitions:
$$.emplace($$.cbegin(), $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:
formal_parameter_list
"(" formal_parameters ")" return_declaration
{
$$ = std::make_shared<elna::boot::procedure_type_expression>(elna::boot::make_position(@1));
std::swap($1, $$->parameters);
$$.second = std::make_shared<elna::boot::procedure_type_expression>(elna::boot::make_position(@1),
std::move($4));
for (auto& [name, type] : $2)
{
$$.first.emplace_back(std::move(name));
$$.second->parameters.push_back(type);
}
| formal_parameter_list "->" "!"
{
$$ = std::make_shared<elna::boot::procedure_type_expression>(elna::boot::make_position(@1),
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:
"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"
{
$$ = 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_definition procedure_definitions
@ -293,47 +294,50 @@ defer_statement: DEFER statements "end"
literal:
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
{
$$ = 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
{
$$ = new elna::boot::number_literal<double>(elna::boot::make_position(@1), $1);
$$ = new elna::boot::literal<double>(elna::boot::make_position(@1), $1);
}
| 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
{
$$ = 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"
{
$$ = 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
{
$$ = 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:
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; }
| designator_expression { $$ = $1; }
| traits_expression { $$ = $1; }
| cast_expression { $$ = $1; }
| call_expression { $$ = $1; }
| "(" expression ")" { $$ = $2; }
expression:
operand:
unary_expression { $$ = $1; }
| binary_expression { $$ = $1; }
| qualident { $$ = $1; }
expression:
binary_expression { $$ = $1; }
| operand { $$ = $1; }
binary_expression:
expression "*" expression
@ -391,12 +395,12 @@ binary_expression:
$$ = new elna::boot::binary_expression(elna::boot::make_position(@2), $1, $3,
elna::boot::binary_operator::greater_equal);
}
| expression "and" expression
| expression "&" expression
{
$$ = new elna::boot::binary_expression(elna::boot::make_position(@2), $1, $3,
elna::boot::binary_operator::conjunction);
}
| expression "or" expression
| expression "|" expression
{
$$ = new elna::boot::binary_expression(elna::boot::make_position(@2), $1, $3,
elna::boot::binary_operator::disjunction);
@ -422,7 +426,7 @@ unary_expression:
$$ = new elna::boot::unary_expression(elna::boot::make_position(@1), $2,
elna::boot::unary_operator::reference);
}
| "not" operand
| "~" operand
{
$$ = new elna::boot::unary_expression(elna::boot::make_position(@1), $2,
elna::boot::unary_operator::negation);
@ -438,17 +442,24 @@ expressions:
std::swap($$, $3);
$$.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:
operand "[" expression "]"
qualident "[" expression "]"
{
$$ = 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);
}
| operand "^"
| qualident "^"
{
$$ = 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));
}
| "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
{
@ -559,18 +573,16 @@ type_part:
| "type" type_definitions { std::swap($$, $2); }
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_parameter "," formal_parameters
/* no formal parameters */ {}
| formal_parameter "," formal_parameters
{
std::swap($$, $3);
$$.emplace($$.cbegin(), $1);
}
| formal_parameter { $$.emplace_back(std::move($1)); }
formal_parameter_list:
"(" ")" {}
| "(" formal_parameters ")" { std::swap($$, $2); }
actual_parameter_list:
"(" ")" {}
| "(" 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"
namespace elna
{
namespace boot
namespace elna::boot
{
error::error(const char *path, const struct position position)
: position(position), path(path)
@ -46,4 +44,3 @@ namespace boot
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"
namespace elna
{
namespace boot
namespace elna::boot
{
undeclared_error::undeclared_error(const std::string& identifier, const char *path, const struct position position)
: error(path, position), identifier(identifier)
@ -121,5 +119,129 @@ namespace boot
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"
namespace elna
{
namespace boot
namespace elna::boot
{
type::type()
{
@ -301,4 +299,3 @@ namespace boot
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 "elna/gcc/elna-tree.h"
namespace elna
{
namespace gcc
namespace elna::gcc
{
void init_ttree()
{
@ -66,4 +64,3 @@ namespace gcc
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/elna1.h"
namespace elna
{
namespace gcc
namespace elna::gcc
{
location_t get_location(const boot::position *position)
{
@ -144,4 +142,3 @@ namespace gcc
}
}
}
}

155
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 "langhooks.h"
namespace elna
{
namespace gcc
namespace elna::gcc
{
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);
this->symbols->enter(definition->identifier, fndecl);
if (definition->heading().no_return)
if (definition->heading().return_type.no_return)
{
TREE_THIS_VOLATILE(fndecl) = 1;
}
@ -336,19 +334,22 @@ namespace gcc
function_args_iterator parameter_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,
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_ARG_TYPE(declaration_tree) = function_args_iter_cond(&parameter_type);
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);
function_args_iter_next(&parameter_type);
++parameter_name;
}
DECL_ARGUMENTS(fndecl) = argument_chain;
TREE_PUBLIC(fndecl) = definition->exported;
@ -409,17 +410,17 @@ namespace gcc
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);
}
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);
}
void generic_visitor::visit(boot::number_literal<double> *literal)
void generic_visitor::visit(boot::literal<double> *literal)
{
REAL_VALUE_TYPE real_value1;
@ -434,22 +435,22 @@ namespace gcc
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;
}
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);
}
void generic_visitor::visit(boot::number_literal<nullptr_t> *)
void generic_visitor::visit(boot::literal<nullptr_t> *)
{
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 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)
{
boot::type_expression& parameter_type = type.parameters.at(i)->variable_type();
parameter_type.accept(this);
type.parameters.at(i)->accept(this);
parameter_types[i] = this->current_expression;
}
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;
}
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)
{
trait->type().accept(this);
location_t trait_location = get_location(&trait->position());
if (trait->name == "size")
{
this->current_expression = build1(CONVERT_EXPR, elna_word_type_node,
if (expect_trait_type_only(trait))
{
this->current_expression = build1_loc(trait_location, CONVERT_EXPR, elna_word_type_node,
size_in_bytes(this->current_expression));
}
}
else if (trait->name == "alignment")
{
if (expect_trait_type_only(trait))
{
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")
{
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")
{
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
{
error_at(get_location(&trait->position()), "type '%s' does not have property '%s'",
print_type(this->current_expression).c_str(), trait->name.c_str());
this->current_expression = error_mark_node;
}
}
else
{
error_at(get_location(&trait->position()), "Trait '%s' is unknown", trait->name.c_str());
this->current_expression = error_mark_node;
}
}
@ -958,43 +1031,16 @@ namespace gcc
{
expression->base().accept(this);
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)))
{
tree field_declaration = TYPE_FIELDS(TREE_TYPE(this->current_expression));
while (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
if (field_declaration != error_mark_node)
{
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;
}
}
void generic_visitor::visit(boot::dereference_expression *expression)
{
@ -1226,4 +1272,3 @@ namespace gcc
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 "diagnostic-core.h"
namespace elna
{
namespace gcc
namespace elna::gcc
{
bool is_pointer_type(tree type)
{
@ -209,5 +207,37 @@ namespace gcc
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 <string>
#include <vector>
#include <variant>
#include "elna/boot/result.h"
namespace elna
{
namespace boot
namespace elna::boot
{
enum class binary_operator
{
@ -80,9 +79,9 @@ namespace boot
class field_access_expression;
class dereference_expression;
class designator_expression;
class literal;
class literal_expression;
template<typename T>
class number_literal;
class literal;
class defer_statement;
/**
@ -116,53 +115,13 @@ namespace boot
virtual void visit(array_access_expression *) = 0;
virtual void visit(field_access_expression *) = 0;
virtual void visit(dereference_expression *) = 0;
virtual void visit(number_literal<std::int32_t> *) = 0;
virtual void visit(number_literal<std::uint32_t> *) = 0;
virtual void visit(number_literal<double> *) = 0;
virtual void visit(number_literal<bool> *) = 0;
virtual void visit(number_literal<unsigned char> *) = 0;
virtual void visit(number_literal<std::nullptr_t> *) = 0;
virtual void visit(number_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;
virtual void visit(literal<std::int32_t> *) = 0;
virtual void visit(literal<std::uint32_t> *) = 0;
virtual void visit(literal<double> *) = 0;
virtual void visit(literal<bool> *) = 0;
virtual void visit(literal<unsigned char> *) = 0;
virtual void visit(literal<std::nullptr_t> *) = 0;
virtual void visit(literal<std::string> *) = 0;
};
/**
@ -213,7 +172,7 @@ namespace boot
virtual unary_expression *is_unary();
virtual designator_expression *is_designator();
virtual procedure_call *is_call_expression();
virtual literal *is_literal();
virtual literal_expression *is_literal();
void accept(parser_visitor *visitor);
~expression() = 0;
@ -336,22 +295,22 @@ namespace boot
/**
* Literal expression.
*/
class literal : public expression
class literal_expression : public expression
{
public:
virtual number_literal<std::int32_t> *is_int() = 0;
virtual number_literal<std::uint32_t> *is_word() = 0;
virtual number_literal<double> *is_float() = 0;
virtual number_literal<bool> *is_bool() = 0;
virtual number_literal<unsigned char> *is_char() = 0;
virtual number_literal<std::nullptr_t> *is_nil() = 0;
virtual number_literal<std::string> *is_string() = 0;
virtual literal<std::int32_t> *is_int() = 0;
virtual literal<std::uint32_t> *is_word() = 0;
virtual literal<double> *is_float() = 0;
virtual literal<bool> *is_bool() = 0;
virtual literal<unsigned char> *is_char() = 0;
virtual literal<std::nullptr_t> *is_nil() = 0;
virtual literal<std::string> *is_string() = 0;
literal *is_literal() override;
literal_expression *is_literal() override;
void accept(parser_visitor *visitor);
protected:
literal();
literal_expression();
};
/**
@ -359,7 +318,7 @@ namespace boot
*/
class constant_definition : public definition
{
literal *m_body;
literal_expression *m_body;
public:
/**
@ -368,10 +327,10 @@ namespace boot
* \param body Constant value.
*/
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);
literal& body();
literal_expression& body();
virtual ~constant_definition() override;
};
@ -379,10 +338,15 @@ namespace boot
/**
* 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.
@ -390,18 +354,14 @@ namespace boot
class procedure_type_expression : public type_expression
{
public:
const std::shared_ptr<type_expression> return_type;
const bool no_return;
std::vector<variable_declaration *> parameters;
const return_declaration return_type;
std::vector<std::shared_ptr<type_expression>> parameters;
procedure_type_expression(const struct position position,
std::shared_ptr<type_expression> return_type = nullptr);
procedure_type_expression(const struct position position, no_return_t);
return_declaration return_type = return_declaration());
void accept(parser_visitor *visitor);
std::shared_ptr<procedure_type_expression> is_procedure() override;
virtual ~procedure_type_expression() override;
};
/**
@ -413,6 +373,7 @@ namespace boot
public:
block *const body;
std::vector<std::string> parameter_names;
procedure_definition(const struct position position, const std::string& identifier,
const bool exported, std::shared_ptr<procedure_type_expression> heading, block *body = nullptr);
@ -459,17 +420,13 @@ namespace boot
class traits_expression : public expression
{
std::shared_ptr<type_expression> m_type;
public:
std::vector<std::shared_ptr<type_expression>> parameters;
const std::string name;
traits_expression(const struct position position, const std::string& name,
std::shared_ptr<type_expression> type);
traits_expression(const struct position position, const std::string& name);
void accept(parser_visitor *visitor);
traits_expression *is_traits() override;
type_expression& type();
};
/**
@ -688,21 +645,21 @@ namespace boot
};
template<typename T>
class number_literal : public literal
class literal : public literal_expression
{
public:
T value;
number_literal(const struct position position, const T& value)
literal(const struct position position, const T& 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)
{
return reinterpret_cast<number_literal<std::int32_t> *>(this);
return reinterpret_cast<literal<std::int32_t> *>(this);
}
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)
{
return reinterpret_cast<number_literal<std::uint32_t> *>(this);
return reinterpret_cast<literal<std::uint32_t> *>(this);
}
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)
{
return reinterpret_cast<number_literal<double> *>(this);
return reinterpret_cast<literal<double> *>(this);
}
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)
{
return reinterpret_cast<number_literal<bool> *>(this);
return reinterpret_cast<literal<bool> *>(this);
}
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)
{
return reinterpret_cast<number_literal<unsigned char> *>(this);
return reinterpret_cast<literal<unsigned char> *>(this);
}
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)
{
return reinterpret_cast<number_literal<std::nullptr_t> *>(this);
return reinterpret_cast<literal<std::nullptr_t> *>(this);
}
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)
{
return reinterpret_cast<number_literal<std::string> *>(this);
return reinterpret_cast<literal<std::string> *>(this);
}
else
{
@ -840,4 +797,3 @@ namespace boot
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 "location.hh"
namespace elna
{
namespace boot
namespace elna::boot
{
position make_position(const yy::location& location);
@ -50,4 +48,3 @@ namespace boot
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 <memory>
namespace elna
{
namespace boot
namespace elna::boot
{
/**
* 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/symbol.h"
namespace elna
{
namespace boot
namespace elna::boot
{
class undeclared_error : public error
{
@ -48,7 +46,7 @@ namespace boot
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;
std::shared_ptr<symbol_table> symbols;
@ -66,6 +64,31 @@ namespace boot
void visit(record_type_expression *) override;
void visit(union_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 <vector>
namespace elna
{
namespace boot
namespace elna::boot
{
class alias_type;
class primitive_type;
@ -257,4 +255,3 @@ namespace boot
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"
namespace elna
{
namespace gcc
namespace elna::gcc
{
void init_ttree();
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"
namespace elna
{
namespace gcc
namespace elna::gcc
{
location_t get_location(const boot::position *position);
std::string print_type(tree type);
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>
namespace elna
{
namespace gcc
namespace elna::gcc
{
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::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 };
std::shared_ptr<symbol_table> symbols;
@ -64,6 +62,9 @@ namespace gcc
tree procedure_address, const std::vector<boot::expression *>& arguments);
void build_record_call(location_t call_location,
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);
public:
@ -74,13 +75,13 @@ namespace gcc
void visit(boot::procedure_call *call) override;
void visit(boot::cast_expression *expression) override;
void visit(boot::traits_expression *trait) override;
void visit(boot::number_literal<std::int32_t> *literal) override;
void visit(boot::number_literal<std::uint32_t> *literal) override;
void visit(boot::number_literal<double> *literal) override;
void visit(boot::number_literal<bool> *boolean) override;
void visit(boot::number_literal<unsigned char> *character) override;
void visit(boot::number_literal<std::nullptr_t> *) override;
void visit(boot::number_literal<std::string> *string) override;
void visit(boot::literal<std::int32_t> *literal) override;
void visit(boot::literal<std::uint32_t> *literal) override;
void visit(boot::literal<double> *literal) override;
void visit(boot::literal<bool> *boolean) override;
void visit(boot::literal<unsigned char> *character) override;
void visit(boot::literal<std::nullptr_t> *) override;
void visit(boot::literal<std::string> *string) override;
void visit(boot::binary_expression *expression) override;
void visit(boot::unary_expression *expression) override;
void visit(boot::constant_definition *definition) override;
@ -104,4 +105,3 @@ namespace gcc
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/symbol.h"
namespace elna
{
namespace gcc
namespace elna::gcc
{
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_code operator_code, tree left, tree right);
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
input: ^Byte
empty: proc(data: ^Byte) -> Bool
advance: proc(data: ^Byte)
head: proc(data: ^Byte) -> Char
empty: proc(^Byte) -> Bool
advance: proc(^Byte)
head: proc(^Byte) -> Char
end
Token* = record
kind: Int