From 07ed40cc2481cda92df58d5c7f7b57cc8b3b1361 Mon Sep 17 00:00:00 2001 From: Eugen Wissner Date: Fri, 21 Mar 2025 10:24:57 +0100 Subject: [PATCH] Restrict cast types --- boot/driver.cc | 45 +++++++++++ boot/lexer.ll | 50 ++---------- boot/parser.yy | 153 ++++++++++++++++------------------- gcc/elna-generic.cc | 42 ++++++++-- gcc/elna-tree.cc | 10 ++- include/elna/boot/driver.h | 1 + include/elna/gcc/elna-tree.h | 1 + 7 files changed, 168 insertions(+), 134 deletions(-) diff --git a/boot/driver.cc b/boot/driver.cc index eb1ad1d..2443dbc 100644 --- a/boot/driver.cc +++ b/boot/driver.cc @@ -76,4 +76,49 @@ namespace elna::boot return escape_invalid_char; } } + + std::optional escape_string(const char *escape) + { + std::string result; + const char *current_position = escape + 1; + + while (*current_position != '\0') + { + if (*current_position == '\\' && *(current_position + 1) == 'x') + { + current_position += 2; + + std::size_t processed; + char character = static_cast(std::stoi(current_position, &processed, 16)); + if (processed == 0) + { + return std::nullopt; + } + else + { + current_position += processed - 1; + result.push_back(character); + } + } + else if (*current_position == '\\') + { + ++current_position; + + char escape = escape_char(*current_position); + if (escape == escape_invalid_char) + { + return std::nullopt; + } + result.push_back(escape); + } + else + { + result.push_back(*current_position); + } + ++current_position; + } + result.pop_back(); + + return result; + } } diff --git a/boot/lexer.ll b/boot/lexer.ll index 2ad3ffd..5029bf5 100644 --- a/boot/lexer.ll +++ b/boot/lexer.ll @@ -23,12 +23,12 @@ along with GCC; see the file COPYING3. If not see #include "parser.hh" #undef YY_DECL -#define YY_DECL yy::parser::symbol_type elna::boot::lexer::lex(elna::boot::driver& driver) +#define YY_DECL yy::parser::symbol_type elna::boot::lexer::lex(driver& driver) #define yyterminate() return yy::parser::make_YYEOF(this->location) %} %option c++ noyywrap never-interactive -%option yyclass="elna::boot::lexer" +%option yyclass="lexer" %x IN_COMMENT @@ -159,7 +159,7 @@ defer { return yy::parser::make_CHARACTER(std::string(&character, 1), this->location); } '\\[0nabtfrv\\'"?]' { - char escape = elna::boot::escape_char(yytext[2]); + char escape = escape_char(yytext[2]); if (escape == escape_invalid_char) { REJECT; @@ -167,46 +167,12 @@ defer { return yy::parser::make_CHARACTER(std::string(&escape, 1), this->location); } \"[[:print:]]*\" { - std::string result; - const char *current_position = yytext + 1; - - while (*current_position != '\0') + std::optional result = escape_string(yytext); + if (!result.has_value()) { - if (*current_position == '\\' && *(current_position + 1) == 'x') - { - current_position += 2; - - std::size_t processed; - char character = static_cast(std::stoi(current_position, &processed, 16)); - if (processed == 0) - { - REJECT; - } - else - { - current_position += processed - 1; - result.push_back(character); - } - } - else if (*current_position == '\\') - { - ++current_position; - - char escape = elna::boot::escape_char(*current_position); - if (escape == elna::boot::escape_invalid_char) - { - REJECT; - } - result.push_back(escape); - } - else - { - result.push_back(*current_position); - } - ++current_position; + REJECT; } - result.pop_back(); - return yy::parser::make_STRING(result, this->location); + return yy::parser::make_STRING(result.value(), this->location); } \( { return yy::parser::make_LEFT_PAREN(this->location); @@ -290,6 +256,6 @@ defer { std::stringstream ss; ss << "Illegal character 0x" << std::hex << static_cast(yytext[0]); - driver.add_error(ss.str(), driver.input_file, this->location); + driver.add_error(ss.str(), driver.input_file, this->location); } %% diff --git a/boot/parser.yy b/boot/parser.yy index e146db4..e0dbfaf 100644 --- a/boot/parser.yy +++ b/boot/parser.yy @@ -18,6 +18,10 @@ along with GCC; see the file COPYING3. If not see %require "3.4" %language "c++" +%code { + using namespace elna; +} + %code requires { #include #include @@ -52,7 +56,7 @@ along with GCC; see the file COPYING3. If not see { } - yy::parser::symbol_type lex(elna::boot::driver& driver); + yy::parser::symbol_type lex(driver& driver); }; } @@ -157,7 +161,7 @@ along with GCC; see the file COPYING3. If not see program: constant_part type_part variable_part procedure_part "begin" statements "end" "." { - auto tree = new elna::boot::program(elna::boot::make_position(@5)); + auto tree = new boot::program(boot::make_position(@5)); std::swap(tree->constants, $1); std::swap(tree->types , $2); @@ -169,7 +173,7 @@ program: } block: constant_part variable_part "begin" statements "end" { - $$ = new elna::boot::block(elna::boot::make_position(@3)); + $$ = new boot::block(boot::make_position(@3)); std::swap($$->constants, $1); std::swap($$->variables, $2); @@ -193,12 +197,12 @@ identifier_definitions: | identifier_definition { $$.emplace_back(std::move($1)); } return_declaration: /* proper procedure */ {} - | "->" "!" { $$ = elna::boot::return_declaration(std::monostate{}); } - | "->" type_expression { $$ = elna::boot::return_declaration($2); } + | "->" "!" { $$ = boot::return_declaration(std::monostate{}); } + | "->" type_expression { $$ = boot::return_declaration($2); } procedure_heading: "(" formal_parameters ")" return_declaration { - $$.second = std::make_shared(elna::boot::make_position(@1), + $$.second = std::make_shared(boot::make_position(@1), std::move($4)); for (auto& [name, type] : $2) { @@ -209,13 +213,13 @@ procedure_heading: procedure_definition: "proc" identifier_definition procedure_heading ";" block { - $$ = new elna::boot::procedure_definition(elna::boot::make_position(@1), + $$ = new boot::procedure_definition(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.second); + $$ = new boot::procedure_definition(boot::make_position(@1), $2.first, $2.second, $3.second); std::swap($3.first, $$->parameter_names); } procedure_definitions: @@ -230,21 +234,21 @@ procedure_part: | procedure_definitions { std::swap($$, $1); } assign_statement: designator_expression ":=" expression { - $$ = new elna::boot::assign_statement(elna::boot::make_position(@1), $1, $3); + $$ = new boot::assign_statement(boot::make_position(@1), $1, $3); } call_expression: designator_expression actual_parameter_list { - $$ = new elna::boot::procedure_call(elna::boot::make_position(@1), $1); + $$ = new boot::procedure_call(boot::make_position(@1), $1); std::swap($$->arguments, $2); } cast_expression: "cast" "(" expression ":" type_expression ")" { - $$ = new elna::boot::cast_expression(elna::boot::make_position(@1), $5, $3); + $$ = new boot::cast_expression(boot::make_position(@1), $5, $3); } elsif_do_statements: "elsif" expression "do" statements elsif_do_statements { - elna::boot::conditional_statements *branch = new elna::boot::conditional_statements($2); + boot::conditional_statements *branch = new boot::conditional_statements($2); std::swap(branch->statements, $4); std::swap($5, $$); $$.emplace($$.begin(), branch); @@ -252,15 +256,15 @@ elsif_do_statements: | {} while_statement: "while" expression "do" statements elsif_do_statements "end" { - auto body = new elna::boot::conditional_statements($2); + auto body = new boot::conditional_statements($2); std::swap($4, body->statements); - $$ = new elna::boot::while_statement(elna::boot::make_position(@1), body); + $$ = new boot::while_statement(boot::make_position(@1), body); std::swap($5, $$->branches); } elsif_then_statements: "elsif" expression "then" statements elsif_then_statements { - elna::boot::conditional_statements *branch = new elna::boot::conditional_statements($2); + boot::conditional_statements *branch = new boot::conditional_statements($2); std::swap(branch->statements, $4); std::swap($5, $$); $$.emplace($$.begin(), branch); @@ -269,61 +273,61 @@ elsif_then_statements: if_statement: "if" expression "then" statements elsif_then_statements "end" { - auto then = new elna::boot::conditional_statements($2); + auto then = new boot::conditional_statements($2); std::swap($4, then->statements); - $$ = new elna::boot::if_statement(elna::boot::make_position(@1), then); + $$ = new boot::if_statement(boot::make_position(@1), then); std::swap($5, $$->branches); } | "if" expression "then" statements elsif_then_statements "else" statements "end" { - auto then = new elna::boot::conditional_statements($2); + auto then = new boot::conditional_statements($2); std::swap($4, then->statements); - auto _else = new std::vector(std::move($7)); - $$ = new elna::boot::if_statement(elna::boot::make_position(@1), then, _else); + auto _else = new std::vector(std::move($7)); + $$ = new boot::if_statement(boot::make_position(@1), then, _else); std::swap($5, $$->branches); } return_statement: "return" expression { - $$ = new elna::boot::return_statement(elna::boot::make_position(@1), $2); + $$ = new boot::return_statement(boot::make_position(@1), $2); } defer_statement: DEFER statements "end" { - $$ = new elna::boot::defer_statement(elna::boot::make_position(@1)); + $$ = new boot::defer_statement(boot::make_position(@1)); std::swap($2, $$->statements); } literal: INTEGER { - $$ = new elna::boot::literal(elna::boot::make_position(@1), $1); + $$ = new boot::literal(boot::make_position(@1), $1); } | WORD { - $$ = new elna::boot::literal(elna::boot::make_position(@1), $1); + $$ = new boot::literal(boot::make_position(@1), $1); } | FLOAT { - $$ = new elna::boot::literal(elna::boot::make_position(@1), $1); + $$ = new boot::literal(boot::make_position(@1), $1); } | BOOLEAN { - $$ = new elna::boot::literal(elna::boot::make_position(@1), $1); + $$ = new boot::literal(boot::make_position(@1), $1); } | CHARACTER { - $$ = new elna::boot::literal(elna::boot::make_position(@1), $1.at(0)); + $$ = new boot::literal(boot::make_position(@1), $1.at(0)); } | "nil" { - $$ = new elna::boot::literal(elna::boot::make_position(@1), nullptr); + $$ = new boot::literal(boot::make_position(@1), nullptr); } | STRING { - $$ = new elna::boot::literal(elna::boot::make_position(@1), $1); + $$ = new boot::literal(boot::make_position(@1), $1); } traits_expression: TRAIT "(" type_expressions ")" { - $$ = new elna::boot::traits_expression(elna::boot::make_position(@1), $1); + $$ = new boot::traits_expression(boot::make_position(@1), $1); std::swap($3, $$->parameters); } qualident: @@ -342,99 +346,82 @@ expression: binary_expression: expression "*" expression { - $$ = new elna::boot::binary_expression(elna::boot::make_position(@2), $1, $3, - elna::boot::binary_operator::multiplication); + $$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::multiplication); } | expression "/" expression { - $$ = new elna::boot::binary_expression(elna::boot::make_position(@2), $1, $3, - elna::boot::binary_operator::division); + $$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::division); } | expression "%" expression { - $$ = new elna::boot::binary_expression(elna::boot::make_position(@2), $1, $3, - elna::boot::binary_operator::remainder); + $$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::remainder); } | expression "+" expression { - $$ = new elna::boot::binary_expression(elna::boot::make_position(@2), $1, $3, - elna::boot::binary_operator::sum); + $$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::sum); } | expression "-" expression { - $$ = new elna::boot::binary_expression(elna::boot::make_position(@2), $1, $3, - elna::boot::binary_operator::subtraction); + $$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::subtraction); } | expression "=" expression { - $$ = new elna::boot::binary_expression(elna::boot::make_position(@2), $1, $3, - elna::boot::binary_operator::equals); + $$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::equals); } | expression "<>" expression { - $$ = new elna::boot::binary_expression(elna::boot::make_position(@2), $1, $3, - elna::boot::binary_operator::not_equals); + $$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::not_equals); } | expression "<" expression { - $$ = new elna::boot::binary_expression(elna::boot::make_position(@2), $1, $3, - elna::boot::binary_operator::less); + $$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::less); } | expression ">" expression { - $$ = new elna::boot::binary_expression(elna::boot::make_position(@2), $1, $3, - elna::boot::binary_operator::greater); + $$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::greater); } | expression "<=" expression { - $$ = new elna::boot::binary_expression(elna::boot::make_position(@2), $1, $3, - elna::boot::binary_operator::less_equal); + $$ = new boot::binary_expression(boot::make_position(@2), $1, $3, + boot::binary_operator::less_equal); } | expression ">=" expression { - $$ = new elna::boot::binary_expression(elna::boot::make_position(@2), $1, $3, - elna::boot::binary_operator::greater_equal); + $$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::greater_equal); } | expression "&" expression { - $$ = new elna::boot::binary_expression(elna::boot::make_position(@2), $1, $3, - elna::boot::binary_operator::conjunction); + $$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::conjunction); } | expression "|" expression { - $$ = new elna::boot::binary_expression(elna::boot::make_position(@2), $1, $3, - elna::boot::binary_operator::disjunction); + $$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::disjunction); } | expression "xor" expression { - $$ = new elna::boot::binary_expression(elna::boot::make_position(@2), $1, $3, - elna::boot::binary_operator::exclusive_disjunction); + $$ = new boot::binary_expression(boot::make_position(@2), $1, $3, + boot::binary_operator::exclusive_disjunction); } | expression "<<" expression { - $$ = new elna::boot::binary_expression(elna::boot::make_position(@2), $1, $3, - elna::boot::binary_operator::shift_left); + $$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::shift_left); } | expression ">>" expression { - $$ = new elna::boot::binary_expression(elna::boot::make_position(@2), $1, $3, - elna::boot::binary_operator::shift_right); + $$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::shift_right); } unary_expression: "@" operand { - $$ = new elna::boot::unary_expression(elna::boot::make_position(@1), $2, - elna::boot::unary_operator::reference); + $$ = new boot::unary_expression(boot::make_position(@1), $2, boot::unary_operator::reference); } | "~" operand { - $$ = new elna::boot::unary_expression(elna::boot::make_position(@1), $2, - elna::boot::unary_operator::negation); + $$ = new boot::unary_expression(boot::make_position(@1), $2, boot::unary_operator::negation); } | "-" operand { - $$ = new elna::boot::unary_expression(elna::boot::make_position(@1), $2, - elna::boot::unary_operator::minus); + $$ = new boot::unary_expression(boot::make_position(@1), $2, boot::unary_operator::minus); } expressions: expression "," expressions @@ -453,19 +440,19 @@ type_expressions: designator_expression: qualident "[" expression "]" { - $$ = new elna::boot::array_access_expression(elna::boot::make_position(@2), $1, $3); + $$ = new boot::array_access_expression(boot::make_position(@2), $1, $3); } | qualident "." IDENTIFIER { - $$ = new elna::boot::field_access_expression(elna::boot::make_position(@2), $1, $3); + $$ = new boot::field_access_expression(boot::make_position(@2), $1, $3); } | qualident "^" { - $$ = new elna::boot::dereference_expression(elna::boot::make_position(@1), $1); + $$ = new boot::dereference_expression(boot::make_position(@1), $1); } | IDENTIFIER { - $$ = new elna::boot::variable_expression(elna::boot::make_position(@1), $1); + $$ = new boot::variable_expression(boot::make_position(@1), $1); } statement: assign_statement { $$ = $1; } @@ -497,37 +484,37 @@ optional_fields: type_expression: "[" INTEGER "]" type_expression { - $$ = std::make_shared(elna::boot::make_position(@1), $4, $2); + $$ = std::make_shared(boot::make_position(@1), $4, $2); } | "^" type_expression { - $$ = std::make_shared(elna::boot::make_position(@1), $2); + $$ = std::make_shared(boot::make_position(@1), $2); } | "record" optional_fields "end" { - $$ = std::make_shared(elna::boot::make_position(@1), std::move($2)); + $$ = std::make_shared(boot::make_position(@1), std::move($2)); } | "union" required_fields "end" { - $$ = std::make_shared(elna::boot::make_position(@1), std::move($2)); + $$ = std::make_shared(boot::make_position(@1), std::move($2)); } | "proc" "(" type_expressions ")" return_declaration { - auto result = std::make_shared(elna::boot::make_position(@1), + auto result = std::make_shared(boot::make_position(@1), std::move($5)); std::swap(result->parameters, $3); $$ = result; } | IDENTIFIER { - $$ = std::make_shared(elna::boot::make_position(@1), $1); + $$ = std::make_shared(boot::make_position(@1), $1); } variable_declaration: identifier_definitions ":" type_expression { for (const std::pair& identifier : $1) { - elna::boot::variable_declaration *declaration = new elna::boot::variable_declaration( - elna::boot::make_position(@2), identifier.first, $3, identifier.second); + boot::variable_declaration *declaration = new boot::variable_declaration( + boot::make_position(@2), identifier.first, $3, identifier.second); $$.push_back(declaration); } } @@ -544,7 +531,7 @@ variable_part: | "var" variable_declarations { std::swap($$, $2); } constant_definition: identifier_definition "=" literal { - $$ = new elna::boot::constant_definition(elna::boot::make_position(@1), $1.first, $1.second, $3); + $$ = new boot::constant_definition(boot::make_position(@1), $1.first, $1.second, $3); } constant_definitions: constant_definition constant_definitions @@ -558,7 +545,7 @@ constant_part: | "const" constant_definitions { std::swap($$, $2); } type_definition: identifier_definition "=" type_expression { - $$ = new elna::boot::type_definition(elna::boot::make_position(@1), $1.first, $1.second, $3); + $$ = new boot::type_definition(boot::make_position(@1), $1.first, $1.second, $3); } type_definitions: type_definition type_definitions @@ -590,5 +577,5 @@ actual_parameter_list: void yy::parser::error(const location_type& loc, const std::string& message) { - driver.add_error(message, driver.input_file, loc); + driver.add_error(message, driver.input_file, loc); } diff --git a/gcc/elna-generic.cc b/gcc/elna-generic.cc index 084a1fb..0779da6 100644 --- a/gcc/elna-generic.cc +++ b/gcc/elna-generic.cc @@ -229,9 +229,20 @@ namespace elna::gcc tree cast_target = this->current_expression; expression->value().accept(this); + tree cast_source = TREE_TYPE(this->current_expression); - this->current_expression = build1_loc(get_location(&expression->position()), CONVERT_EXPR, - cast_target, this->current_expression); + if ((is_primitive_type(cast_target) || is_pointer_type(cast_target)) + && (is_primitive_type(cast_source) || is_pointer_type(cast_source))) + { + this->current_expression = build1_loc(get_location(&expression->position()), CONVERT_EXPR, + cast_target, this->current_expression); + } + else + { + error_at(get_location(&expression->position()), "Type '%s' cannot be converted to '%s'", + print_type(cast_source).c_str(), print_type(cast_target).c_str()); + this->current_expression = error_mark_node; + } } void generic_visitor::visit(boot::program *program) @@ -1031,14 +1042,29 @@ namespace elna::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()); + tree aggregate_type = TREE_TYPE(this->current_expression); - if (field_declaration != error_mark_node) + if (is_array_type(aggregate_type) && expression->field() == "length") { - this->current_expression = build3_loc(expression_location, COMPONENT_REF, - TREE_TYPE(field_declaration), this->current_expression, - field_declaration, NULL_TREE); + this->current_expression = fold_convert(elna_word_type_node, + TYPE_MAX_VALUE(TYPE_DOMAIN(aggregate_type))); + } + else if (is_array_type(aggregate_type) && expression->field() == "ptr") + { + tree ptr_type = build_pointer_type_for_mode(TREE_TYPE(aggregate_type), VOIDmode, true); + this->current_expression = build1(ADDR_EXPR, ptr_type, this->current_expression); + } + else + { + tree field_declaration = find_field_by_name(expression_location, + TREE_TYPE(this->current_expression), expression->field()); + + 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); + } } } diff --git a/gcc/elna-tree.cc b/gcc/elna-tree.cc index b35e260..d5a655a 100644 --- a/gcc/elna-tree.cc +++ b/gcc/elna-tree.cc @@ -35,7 +35,7 @@ namespace elna::gcc bool is_integral_type(tree type) { gcc_assert(TYPE_P(type)); - return TREE_CODE(type) == INTEGER_TYPE; + return TREE_CODE(type) == INTEGER_TYPE && type != elna_char_type_node; } bool is_numeric_type(tree type) @@ -43,6 +43,14 @@ namespace elna::gcc return is_integral_type(type) || type == elna_float_type_node; } + bool is_primitive_type(tree type) + { + gcc_assert(TYPE_P(type)); + return TREE_CODE(type) == INTEGER_TYPE + || type == elna_float_type_node + || type == elna_bool_type_node; + } + bool is_array_type(tree type) { gcc_assert(TYPE_P(type)); diff --git a/include/elna/boot/driver.h b/include/elna/boot/driver.h index 0f3a37f..c9706bd 100644 --- a/include/elna/boot/driver.h +++ b/include/elna/boot/driver.h @@ -47,4 +47,5 @@ namespace elna::boot constexpr char escape_invalid_char = '\xff'; char escape_char(char escape); + std::optional escape_string(const char *escape); } diff --git a/include/elna/gcc/elna-tree.h b/include/elna/gcc/elna-tree.h index 027cdba..6a8e324 100644 --- a/include/elna/gcc/elna-tree.h +++ b/include/elna/gcc/elna-tree.h @@ -36,6 +36,7 @@ namespace elna::gcc bool is_pointer_type(tree type); bool is_integral_type(tree type); bool is_numeric_type(tree type); + bool is_primitive_type(tree type); bool is_array_type(tree type); bool is_void_type(tree type);