From 44d6e8a27294e5ca7300ab11900011b73d9336d4 Mon Sep 17 00:00:00 2001 From: Eugen Wissner Date: Tue, 21 Jul 2026 01:55:56 +0200 Subject: Implement slices --- include/elna/boot/ast.h | 47 +++++++++++++++++++++++++++++++++++++++ include/elna/boot/evaluator.h | 2 ++ include/elna/boot/name_analysis.h | 2 ++ include/elna/boot/symbol.h | 10 +++++++++ include/elna/boot/type_check.h | 1 + include/elna/gcc/elna-generic.h | 1 + 6 files changed, 63 insertions(+) (limited to 'include') diff --git a/include/elna/boot/ast.h b/include/elna/boot/ast.h index 4e35f02..9cc1419 100644 --- a/include/elna/boot/ast.h +++ b/include/elna/boot/ast.h @@ -62,6 +62,7 @@ namespace elna::boot class cast_expression; class record_constructor_expression; class array_constructor_expression; + class slicing_expression; class assign_statement; class if_statement; class import_declaration; @@ -73,6 +74,7 @@ namespace elna::boot class unary_expression; class type_expression; class array_type_expression; + class slice_type_expression; class pointer_type_expression; class constant_type_expression; class record_type_expression; @@ -101,6 +103,7 @@ namespace elna::boot virtual void visit(cast_expression *) = 0; virtual void visit(record_constructor_expression *) = 0; virtual void visit(array_constructor_expression *) = 0; + virtual void visit(slicing_expression *) = 0; virtual void visit(traits_expression *) = 0; virtual void visit(assign_statement *) = 0; virtual void visit(if_statement *) = 0; @@ -113,6 +116,7 @@ namespace elna::boot virtual void visit(binary_expression *) = 0; virtual void visit(unary_expression *) = 0; virtual void visit(array_type_expression *) = 0; + virtual void visit(slice_type_expression *) = 0; virtual void visit(pointer_type_expression *) = 0; virtual void visit(constant_type_expression *) = 0; virtual void visit(record_type_expression *) = 0; @@ -138,6 +142,7 @@ namespace elna::boot { public: [[noreturn]] void visit(array_type_expression *) override; + [[noreturn]] void visit(slice_type_expression *) override; [[noreturn]] void visit(pointer_type_expression *) override; [[noreturn]] void visit(constant_type_expression *) override; [[noreturn]] void visit(type_declaration *) override; @@ -159,6 +164,7 @@ namespace elna::boot [[noreturn]] void visit(cast_expression *) override; [[noreturn]] void visit(record_constructor_expression *) override; [[noreturn]] void visit(array_constructor_expression *) override; + [[noreturn]] void visit(slicing_expression *) override; [[noreturn]] void visit(traits_expression *) override; [[noreturn]] void visit(binary_expression *) override; [[noreturn]] void visit(unary_expression *) override; @@ -182,6 +188,7 @@ namespace elna::boot { public: void visit(array_type_expression *) override; + void visit(slice_type_expression *) override; void visit(pointer_type_expression *) override; void visit(constant_type_expression *) override; void visit(type_declaration *) override; @@ -203,6 +210,7 @@ namespace elna::boot void visit(cast_expression *expression) override; void visit(record_constructor_expression *expression) override; void visit(array_constructor_expression *expression) override; + void visit(slicing_expression *expression) override; void visit(traits_expression *trait) override; void visit(binary_expression *expression) override; void visit(unary_expression *expression) override; @@ -287,6 +295,7 @@ namespace elna::boot virtual record_type_expression *is_record(); virtual procedure_type_expression *is_procedure(); virtual enumeration_type_expression *is_enumeration(); + virtual slice_type_expression *is_slice(); }; class array_type_expression : public type_expression @@ -306,6 +315,21 @@ namespace elna::boot type_expression& base(); }; + class slice_type_expression : public type_expression + { + type_expression *m_base; + + public: + slice_type_expression(const source_position position, + type_expression *base); + ~slice_type_expression() override; + + void accept(parser_visitor *visitor) override; + slice_type_expression *is_slice() override; + + type_expression& base(); + }; + class pointer_type_expression : public type_expression { type_expression *m_base; @@ -601,12 +625,35 @@ namespace elna::boot virtual array_access_expression *is_array_access(); virtual field_access_expression *is_field_access(); virtual dereference_expression *is_dereference(); + virtual slicing_expression *is_slicing(); designator_expression *is_designator() override; void accept(parser_visitor *visitor) override; ~designator_expression() override = 0; }; + /** + * Slicing expression. + */ + class slicing_expression : public designator_expression + { + expression *m_base; + expression *m_offset; + expression *m_length; + + public: + slicing_expression(const source_position position, + expression *base, expression *offset, expression *length); + void accept(parser_visitor *visitor) override; + slicing_expression *is_slicing() override; + + expression& base(); + expression& offset(); + expression& length(); + + ~slicing_expression() override; + }; + /** * Expression refering to an entity by its name. */ diff --git a/include/elna/boot/evaluator.h b/include/elna/boot/evaluator.h index 08aec6b..b8a9956 100644 --- a/include/elna/boot/evaluator.h +++ b/include/elna/boot/evaluator.h @@ -43,6 +43,8 @@ namespace elna::boot std::size_t char_alignment{0}; std::size_t float_size{0}; std::size_t float_alignment{0}; + std::size_t bool_size{0}; + std::size_t bool_alignment{0}; }; /** diff --git a/include/elna/boot/name_analysis.h b/include/elna/boot/name_analysis.h index 6f40bec..bb66c7a 100644 --- a/include/elna/boot/name_analysis.h +++ b/include/elna/boot/name_analysis.h @@ -125,12 +125,14 @@ namespace elna::boot name_analysis_visitor(symbol_bag bag); void visit(array_type_expression *expression) override; + void visit(slice_type_expression *expression) override; void visit(pointer_type_expression *expression) override; void visit(constant_type_expression *expression) override; void visit(type_declaration *declaration) override; void visit(record_type_expression *expression) override; void visit(record_constructor_expression *expression) override; void visit(array_constructor_expression *expression) override; + void visit(slicing_expression *expression) override; void visit(procedure_type_expression *expression) override; void visit(enumeration_type_expression *expression) override; diff --git a/include/elna/boot/symbol.h b/include/elna/boot/symbol.h index 9505e5a..ea418b1 100644 --- a/include/elna/boot/symbol.h +++ b/include/elna/boot/symbol.h @@ -36,6 +36,7 @@ namespace elna::boot struct pointer_type; struct constant_type; struct array_type; + struct slice_type; struct procedure_type; struct enumeration_type; @@ -49,6 +50,7 @@ namespace elna::boot std::shared_ptr, std::shared_ptr, std::shared_ptr, + std::shared_ptr, std::shared_ptr, std::shared_ptr > payload; @@ -62,6 +64,7 @@ namespace elna::boot explicit type(std::shared_ptr pointer); explicit type(std::shared_ptr constant); explicit type(std::shared_ptr array); + explicit type(std::shared_ptr slice); explicit type(std::shared_ptr procedure); explicit type(std::shared_ptr enumeration); @@ -110,6 +113,13 @@ namespace elna::boot array_type(type base, std::uint64_t size); }; + struct slice_type + { + const type base; + + explicit slice_type(type base); + }; + struct primitive_type { const std::string identifier; diff --git a/include/elna/boot/type_check.h b/include/elna/boot/type_check.h index 51aa04d..32da10c 100644 --- a/include/elna/boot/type_check.h +++ b/include/elna/boot/type_check.h @@ -259,6 +259,7 @@ namespace elna::boot void visit(case_statement *statement) override; void visit(record_constructor_expression *expression) override; void visit(array_constructor_expression *expression) override; + void visit(slicing_expression *expression) override; void visit(unary_expression *expression) override; }; } diff --git a/include/elna/gcc/elna-generic.h b/include/elna/gcc/elna-generic.h index aa4bde1..1d98675 100644 --- a/include/elna/gcc/elna-generic.h +++ b/include/elna/gcc/elna-generic.h @@ -88,6 +88,7 @@ namespace elna::gcc void visit(boot::unit *unit) override; void visit(boot::record_constructor_expression *expression) override; void visit(boot::array_constructor_expression *expression) override; + void visit(boot::slicing_expression *expression) override; void visit(boot::assign_statement *statement) override; void visit(boot::if_statement *statement) override; void visit(boot::import_declaration *) override; -- cgit v1.2.3