Owl Hotfixes and proxy defaults fix (#107)

* fix: proxy defaults for modules without properties

* fix for token run size

* fix for end of string tokization again

* Update parser.h

typo fix

* code review

---------

Co-authored-by: Falko Schindler <[email protected]>

Author: JensOgorek

gen_parser.sh

@@ -1,5 +1,8 @@
 #!/bin/bash
 
+echo "This generator is does not include changes from PR #107 and should not be used."
+exit 1
+
 echo "Generating parser..."
 if [[ "language.owl" -nt main/parser.h ]]
 then

main/modules/bluetooth.cpp

@@ -1,6 +1,11 @@
 #include "bluetooth.h"
 #include "uart.h"
 
+const std::map<std::string, Variable_ptr> &Bluetooth::get_defaults() {
+    static std::map<std::string, Variable_ptr> defaults = {};
+    return defaults;
+}
+
 Bluetooth::Bluetooth(const std::string name, const std::string device_name, MessageHandler message_handler)
     : Module(bluetooth, name), device_name(device_name) {
     ZZ::BleCommand::init(device_name, [message_handler](const std::string_view &message) {
@@ -11,6 +16,7 @@ Bluetooth::Bluetooth(const std::string name, const std::string device_name, Mess
             echo("error in bluetooth message handler: %s", e.what());
         }
     });
+    this->properties = Bluetooth::get_defaults();
 }
 
 void Bluetooth::call(const std::string method_name, const std::vector<ConstExpression_ptr> arguments) {

main/modules/bluetooth.h

@@ -16,4 +16,5 @@ class Bluetooth : public Module {
     Bluetooth(const std::string name, const std::string device_name, MessageHandler message_handler);
 
     void call(const std::string method_name, const std::vector<ConstExpression_ptr> arguments) override;
+    static const std::map<std::string, Variable_ptr> &get_defaults();
 };

main/modules/module.cpp

@@ -465,6 +465,13 @@ const std::map<std::string, Variable_ptr> &Module::get_module_defaults(const std
         return Analog::get_defaults();
     } else if (type_name == "LinearMotor") {
         return LinearMotor::get_defaults();
+    } else if (type_name == "Serial") {
+        return Serial::get_defaults();
+    } else if (type_name == "Bluetooth") {
+        return Bluetooth::get_defaults();
+    } else if (type_name == "MotorAxis") {
+        return MotorAxis::get_defaults();
+    } else {
+        throw std::runtime_error("module type \"" + type_name + "\" not found in defaults list");
     }
-    throw std::runtime_error("module type \"" + type_name + "\" not found in defaults list");
 }

main/modules/motor_axis.cpp

@@ -2,8 +2,14 @@
 #include "utils/uart.h"
 #include <stdexcept>
 
+const std::map<std::string, Variable_ptr> &MotorAxis::get_defaults() {
+    static std::map<std::string, Variable_ptr> defaults = {};
+    return defaults;
+}
+
 MotorAxis::MotorAxis(const std::string name, const Motor_ptr motor, const Input_ptr input1, const Input_ptr input2)
     : Module(motor_axis, name), motor(motor), input1(input1), input2(input2) {
+    this->properties = MotorAxis::get_defaults();
 }
 
 bool MotorAxis::can_move(const float speed) const {

main/modules/motor_axis.h

@@ -15,4 +15,5 @@ class MotorAxis : public Module {
     MotorAxis(const std::string name, const Motor_ptr motor, const Input_ptr input1, const Input_ptr input2);
     void step() override;
     void call(const std::string method_name, const std::vector<ConstExpression_ptr> arguments) override;
+    static const std::map<std::string, Variable_ptr> &get_defaults();
 };

main/modules/serial.cpp

@@ -8,9 +8,16 @@
 #define TX_BUF_SIZE 2048
 #define UART_PATTERN_QUEUE_SIZE 100
 
+const std::map<std::string, Variable_ptr> &Serial::get_defaults() {
+    static const std::map<std::string, Variable_ptr> defaults = {};
+    return defaults;
+}
+
 Serial::Serial(const std::string name,
                const gpio_num_t rx_pin, const gpio_num_t tx_pin, const long baud_rate, const uart_port_t uart_num)
     : Module(serial, name), rx_pin(rx_pin), tx_pin(tx_pin), baud_rate(baud_rate), uart_num(uart_num) {
+    this->properties = Serial::get_defaults();
+
     if (uart_is_driver_installed(uart_num)) {
         throw std::runtime_error("serial interface is already in use");
     }

main/modules/serial.h

@@ -32,4 +32,5 @@ class Serial : public Module {
     void clear() const;
     std::string get_output() const override;
     void call(const std::string method_name, const std::vector<ConstExpression_ptr> arguments) override;
+    static const std::map<std::string, Variable_ptr> &get_defaults();
 };

main/parser.h

@@ -1701,6 +1701,7 @@ struct parsed_statements owl_tree_get_parsed_statements(struct owl_tree *tree) {
     check_for_error(tree);
     return parsed_statements_get(owl_tree_root_ref(tree));
 }
+#define HOTFIX_TOKENIZER_ADVANCE_SIZE 256
 #define ESCAPE_CHAR(c, info) ((c) == 'b' ? '\b' : (c) == 'f' ? '\f' : (c) == 'n' ? '\n' : (c) == 'r' ? '\r' : (c) == 't' ? '\t' : (c))
 #define IGNORE_TOKEN_WRITE(...)
 #define IGNORE_TOKEN_READ(...) (0)
@@ -1766,9 +1767,9 @@ struct owl_token_run {
     struct owl_token_run *prev;
     uint16_t number_of_tokens;
     uint16_t lengths_size;
-    uint8_t lengths[4096 * 2];
-    uint32_t tokens[4096];
-    uint32_t states[4096];
+    uint8_t lengths[HOTFIX_TOKENIZER_ADVANCE_SIZE * 2];
+    uint32_t tokens[HOTFIX_TOKENIZER_ADVANCE_SIZE];
+    uint32_t states[HOTFIX_TOKENIZER_ADVANCE_SIZE];
 };
 struct owl_default_tokenizer {
     const char *text;
@@ -1843,14 +1844,17 @@ static size_t decode_token_length(struct owl_token_run *run, uint16_t *length_of
     return length;
 }
 static bool OWL_DONT_INLINE owl_default_tokenizer_advance(struct owl_default_tokenizer *tokenizer, struct owl_token_run **previous_run) {
+    if (tokenizer->text[tokenizer->offset] == '\0') {
+        return false;
+    }
     struct owl_token_run *run = malloc(sizeof(struct owl_token_run));
     if (!run) return false;
     uint16_t number_of_tokens = 0;
     uint16_t lengths_size = 0;
     const char *text = tokenizer->text;
     size_t whitespace = tokenizer->whitespace;
     size_t offset = tokenizer->offset;
-    while (number_of_tokens < 4096) {
+    while (number_of_tokens < HOTFIX_TOKENIZER_ADVANCE_SIZE) {
         char c = text[offset];
         if (c == '\0') break;
         size_t whitespace_length = read_whitespace(text + offset, tokenizer->info);
@@ -1975,7 +1979,7 @@ static bool OWL_DONT_INLINE owl_default_tokenizer_advance(struct owl_default_tok
             free(run);
             return false;
         }
-        if (end_token && number_of_tokens + 1 >= 4096) break;
+        if (end_token && number_of_tokens + 1 >= HOTFIX_TOKENIZER_ADVANCE_SIZE) break;
         if (!encode_token_length(run, &lengths_size, token_length, whitespace)) break;
         if (token == 43) {
             write_identifier_token(offset, token_length, tokenizer->info);
@@ -2020,7 +2024,7 @@ static bool OWL_DONT_INLINE owl_default_tokenizer_advance(struct owl_default_tok
         number_of_tokens++;
         offset += token_length;
         if (end_token) {
-            assert(number_of_tokens < 4096);
+            assert(number_of_tokens < HOTFIX_TOKENIZER_ADVANCE_SIZE);
             run->tokens[number_of_tokens] = 4294967295U;
             number_of_tokens++;
         }