AST WIP

Author: CHiPs44

include/ps_ast.h

@@ -100,7 +100,7 @@ extern "C"
         ps_ast_statement_list *then_branch; /** @brief Statements to execute if condition is true, can be empty  */
         ps_ast_statement_list *else_branch; /** @brief Statements to execute if condition is false, can be empty */
     } ps_ast_if;
-    #define PS_AST_IF_SIZE sizeof(ps_ast_if)
+#define PS_AST_IF_SIZE sizeof(ps_ast_if)
 
     /** @brief WHILE statement */
     typedef struct s_ps_ast_while
@@ -123,16 +123,16 @@ extern "C"
     typedef struct s_ps_ast_variable_simple
     {
         PS_AST_NODE_COMMON
-        ps_symbol *variable; /** @brief Symbol being referenced */
+        ps_symbol *variable; /** @brief Variable being referenced */
     } ps_ast_variable_simple;
 
     /** @brief Lvalue: array value, like A[I], A[I, J, K], ... */
     typedef struct s_ps_ast_variable_array
     {
         PS_AST_NODE_COMMON
-        ps_symbol *variable;   /** @brief Array being referenced    */
-        size_t n_indexes;      /** @brief Number of dimensions      */
-        ps_ast_node **indexes; /** @brief Values for each dimension */
+        ps_symbol *variable;   /** @brief Array being referenced         */
+        size_t n_indexes;      /** @brief Number of dimensions           */
+        ps_ast_node **indexes; /** @brief Expressions for each dimension */
     } ps_ast_variable_array;
 
     /** @brief FOR statement */

include/ps_config.h

@@ -22,7 +22,7 @@ extern "C"
 // #define PS_BITNESS 64
 
 /*
-    NB: 32 bits by default, as our far target is RP2040 and RP2350 which have either ARM M0+ or M33 cores
+    NB: 32 bits by default, as our far target is RP2040 and RP2350 which have either 32bit ARM M0+ or M33 cores
         16 bits if someone tries to port PascalScript to an older architecture
         64 bits on actual computers
     cf. <https://en.wiktionary.org/wiki/bitness>
@@ -162,12 +162,8 @@ extern "C"
  */
 #endif
 
-#ifndef PS_STRING_REF_TYPE
-#define PS_STRING_REF_TYPE uint16_t
-#endif
-
-#if !defined(PS_STRING_LEN_TYPE) || !defined(PS_STRING_MAX_LEN) || !defined(PS_STRING_REF_TYPE)
-#error PS_STRING_LEN_TYPE / PS_STRING_MAX_LEN / PS_STRING_REF_TYPE must be defined.
+#if !defined(PS_STRING_LEN_TYPE) || !defined(PS_STRING_MAX_LEN)
+#error PS_STRING_LEN_TYPE and PS_STRING_MAX_LEN must be defined.
 #endif
 
 #ifndef PS_IDENTIFIER_LEN
@@ -176,6 +172,24 @@ extern "C"
 
 #define PS_IDENTIFIER_SIZE ((size_t)(PS_IDENTIFIER_LEN + 1u))
 
+#if PS_BITNESS == 16
+#define PS_HANDLE uint16_t
+#define PS_HANDLE_FMT_10 PRIu16
+#define PS_HANDLE_FMT_16 PRIx16
+#endif
+
+#if PS_BITNESS == 32
+#define PS_HANDLE uint32_t
+#define PS_HANDLE_FMT_10 PRIu32
+#define PS_HANDLE_FMT_16 PRIx32
+#endif
+
+#if PS_BITNESS == 64
+#define PS_HANDLE uint64_t
+#define PS_HANDLE_FMT_10 PRIu64
+#define PS_HANDLE_FMT_16 PRIx64
+#endif
+
     typedef char ps_identifier[PS_IDENTIFIER_SIZE];
 
     void ps_config_report(FILE *output);

include/ps_system_types.h

@@ -46,7 +46,9 @@ extern "C"
 
     typedef uint32_t ps_set[8]; /** @brief Set of 256 bits */
 
-    /** @brief  */
+    typedef PS_HANDLE ps_handle; /** @brief Handle: variable index in stack */
+
+    /** @brief pointer *FUTURE* */
     typedef void *ps_pointer;
 
     // clang-format off

include/ps_value_data.h

@@ -26,6 +26,7 @@ extern "C"
     /** @brief Value union */
     typedef union u_ps_value_data {
         // clang-format off
+        ps_handle           h; /** @brief "h" is for "_h_andle"     */
         ps_real             r; /** @brief "r" is for "_r_eal"       */
         ps_integer          i; /** @brief "i" is for "_i_nteger"    */
         ps_unsigned         u; /** @brief "u" is for "_u_nsigned"   */

src/ps_lexer.c

@@ -593,7 +593,6 @@ char *ps_lexer_get_debug_value(ps_lexer *lexer)
 {
     static char value[128] = {0};
     static char string[96] = {0};
-    size_t len;
 
     switch (lexer->current_token.type)
     {
@@ -617,17 +616,9 @@ char *ps_lexer_get_debug_value(ps_lexer *lexer)
         break;
     case PS_TOKEN_STRING_VALUE:
         // s t r l c p y(string, lexer->current_token.value.s, sizeof(string));
-        len = strlen(lexer->current_token.value.s);
-        if (len < sizeof(string))
-        {
-            snprintf(value, sizeof(value) - 1, "STRING \"%s\"", lexer->current_token.value.s);
-        }
-        else
-        {
-            strncpy(string, lexer->current_token.value.s, sizeof(string) - 1);
-            string[sizeof(string) - 1] = '\0';
-            snprintf(value, sizeof(value) - 1, "STRING \"%s\"", string);
-        }
+        strncpy(string, lexer->current_token.value.s, sizeof(string) - 1);
+        string[sizeof(string) - 1] = '\0';
+        snprintf(value, sizeof(value) - 1, "STRING \"%s\"", string);
         break;
     case PS_TOKEN_IDENTIFIER:
         snprintf(value, sizeof(value) - 1, "IDENTIFIER \"%s\"", lexer->current_token.value.identifier);

src/ps_parse_executable.c

@@ -15,6 +15,7 @@
 #include "ps_parse_declaration.h"
 #include "ps_parse_executable.h"
 #include "ps_parse_expression.h"
+#include "ps_parse_statement.h"
 #include "ps_parse_type.h"
 #include "ps_procedures.h"
 #include "ps_signature.h"
@@ -459,20 +460,25 @@ bool ps_parse_procedure_or_function_declaration(ps_compiler *compiler, ps_ast_bl
 }
 
 bool ps_parse_procedure_or_function_call_user(ps_compiler *compiler, ps_ast_block *block, ps_ast_call **call,
-                                              ps_symbol *executable, ps_value *result_value)
+                                              ps_symbol *executable)
 {
     PARSE_BEGIN("PROCEDURE_OR_FUNCTION_CALL", "")
+    (void)start_line;
+    (void)start_column;
 
     uint16_t line = 0;
     uint16_t column = 0;
-    bool has_environment = false;
     ps_symbol *result_symbol = NULL;
     ps_identifier result_identifier = "RESULT";
+    ps_value *result_value = NULL;
+
+    if (executable->kind != PS_SYMBOL_KIND_PROCEDURE && executable->kind != PS_SYMBOL_KIND_FUNCTION)
+        RETURN_ERROR(PS_ERROR_UNEXPECTED_TOKEN)
 
     // Enter environment for procedure or function
-    has_environment = ps_compiler_enter_environment(compiler, executable->name);
-    if (!has_environment)
-        TRACE_ERROR("ENTER_ENVIRONMENT")
+    // has_environment = ps_compiler_enter_environment(compiler, executable->name);
+    // if (!has_environment)
+    //     TRACE_ERROR("ENTER_ENVIRONMENT")
     // Parse actual parameters
     if (lexer->current_token.type == PS_TOKEN_LEFT_PARENTHESIS)
     {
@@ -502,16 +508,14 @@ bool ps_parse_procedure_or_function_call_user(ps_compiler *compiler, ps_ast_bloc
     else if (executable->kind == PS_SYMBOL_KIND_FUNCTION)
     {
         // Function have a return value
-        result_value->type = executable->value->data.x->block->signature->result_type;
-        result_value->data.v = NULL;
-        result_value->allocated = false;
+        result_value =
+            ps_value_alloc(executable->value->data.x->block->signature->result_type, (ps_value_data){.h = 0});
+        if (result_value == NULL)
+            GOTO_CLEANUP(PS_ERROR_OUT_OF_MEMORY)
         result_symbol = ps_symbol_alloc(PS_SYMBOL_KIND_VARIABLE, result_identifier, result_value);
         if (result_symbol == NULL)
-        {
-            compiler->error = PS_ERROR_OUT_OF_MEMORY;
-            goto cleanup;
-        }
-        if (!ps_environment_add_symbol(ps_compiler_get_environment(compiler), result_symbol))
+            GOTO_CLEANUP(PS_ERROR_OUT_OF_MEMORY)
+        if (!ps_compiler_add_symbol(compiler, block, result_symbol))
         {
             ps_symbol_free(result_symbol);
             compiler->error = PS_ERROR_OUT_OF_MEMORY;
@@ -520,6 +524,9 @@ bool ps_parse_procedure_or_function_call_user(ps_compiler *compiler, ps_ast_bloc
     }
 
     // TODO build AST node for CALL
+    *call = ps_ast_create_call(line, column,
+                               executable->kind == PS_SYMBOL_KIND_PROCEDURE ? PS_AST_PROCEDURE : PS_AST_FUNCTION,
+                               executable, 0, NULL, NULL, NULL);
 
 cleanup:
     if (compiler->error != PS_ERROR_NONE)
@@ -537,24 +544,26 @@ bool ps_parse_procedure_or_function_call(ps_compiler *compiler, ps_ast_block *bl
                                          ps_symbol *executable)
 {
     PARSE_BEGIN("PROCEDURE_OR_FUNCTION_CALL", "")
+    (void)start_line;
+    (void)start_column;
 
     if (executable == &ps_system_procedure_write || executable == &ps_system_procedure_writeln)
     {
         // Write or WriteLn
-        if (!ps_parse_write_or_writeln(compiler, block, executable == &ps_system_procedure_writeln))
+        if (!ps_parse_write_or_writeln(compiler, block, call, executable == &ps_system_procedure_writeln))
             TRACE_ERROR("WRITE[LN]");
     }
     else if (executable == &ps_system_procedure_read || executable == &ps_system_procedure_readln)
     {
         compiler->error = PS_ERROR_NOT_IMPLEMENTED;
-        if (!ps_parse_read_or_readln(compiler, block, executable == &ps_system_procedure_readln))
+        if (!ps_parse_read_or_readln(compiler, block, call, executable == &ps_system_procedure_readln))
             TRACE_ERROR("READ[LN]");
     }
     else if (executable == &ps_system_procedure_randomize)
     {
         // Randomize
-        if (!ps_procedure_randomize(compiler, NULL))
-            TRACE_ERROR("RANDOMIZE");
+        ps_compiler_set_message(compiler, "TODO: call RANDOMIZE", executable->name);
+        RETURN_ERROR(PS_ERROR_NOT_IMPLEMENTED)
     }
     else if (executable->system)
     {
@@ -563,7 +572,7 @@ bool ps_parse_procedure_or_function_call(ps_compiler *compiler, ps_ast_block *bl
         RETURN_ERROR(PS_ERROR_NOT_IMPLEMENTED)
     }
     // User defined procedure or function call
-    else if (!ps_parse_procedure_or_function_call_user(compiler, block, call, executable, result_value))
+    else if (!ps_parse_procedure_or_function_call_user(compiler, block, call, executable))
         TRACE_ERROR("USER");
 
     PARSE_END("OK")

src/ps_parse_expression.c

@@ -538,6 +538,8 @@ bool ps_parse_function_call_low_high(ps_compiler *compiler, ps_ast_block *block,
     *symbol = ps_compiler_find_symbol(compiler, block, identifier, false);
     if (*symbol == NULL)
         RETURN_ERROR(PS_ERROR_SYMBOL_NOT_FOUND)
+    if (!ps_value_is_ordinal((*symbol)->value) && !ps_value_is_array((*symbol)->value))
+        RETURN_ERROR(PS_ERROR_UNEXPECTED_TYPE)
     READ_NEXT_TOKEN
     EXPECT_TOKEN(PS_TOKEN_RIGHT_PARENTHESIS)
     READ_NEXT_TOKEN
@@ -605,7 +607,9 @@ bool ps_parse_function_call_system(ps_compiler *compiler, ps_ast_block *block, p
         n_args = -1;
         if (!ps_parse_function_call_low_high(compiler, block, &symbol))
             TRACE_ERROR("LOW_HIGH")
-        args[0] = symbol;
+        ps_ast_variable_simple *symbol_node =
+            ps_ast_create_variable_simple(start_line, start_column, PS_AST_LVALUE_SIMPLE, symbol);
+        args[0] = (ps_ast_node *)symbol_node;
     }
     else if (function == &ps_system_function_power)
     {
@@ -693,8 +697,10 @@ bool ps_parse_function_call(ps_compiler *compiler, ps_ast_block *block, ps_ast_c
 bool ps_parse_constant_expression(ps_compiler *compiler, ps_ast_block *block, ps_value *constant)
 {
     PARSE_BEGIN("CONSTANT_EXPRESSION", "");
-    bool negate = false;
+    (void)start_line;
+    (void)start_column;
 
+    bool negate = false;
     ps_identifier identifier = {0};
     ps_symbol *symbol = NULL;
 

src/ps_parse_statement.c

@@ -616,8 +616,6 @@ bool ps_parse_for_do(ps_compiler *compiler, ps_ast_block *block, ps_ast_for **fo
     bool downto = false;
     ps_ast_statement_list *body = NULL;
     ps_identifier identifier = {0};
-    uint16_t line = 0;
-    uint16_t column = 0;
 
     // FOR
     EXPECT_TOKEN(PS_TOKEN_FOR)
@@ -665,7 +663,11 @@ bool ps_parse_for_do(ps_compiler *compiler, ps_ast_block *block, ps_ast_for **fo
     if (!ps_parse_statement_or_compound_statement(compiler, block, &body))
         TRACE_ERROR("STATEMENT_OR_COMPOUND")
 
-    *for_statement = ps_ast_create_for(start_line, start_column, variable, start, finish, downto ? -1 : 1, body);
+    ps_ast_variable_simple *variable_node =
+        ps_ast_create_variable_simple(start_line, start_column, PS_AST_LVALUE_SIMPLE, variable);
+    if (variable_node == NULL)
+        RETURN_ERROR(PS_ERROR_OUT_OF_MEMORY)
+    *for_statement = ps_ast_create_for(start_line, start_column, variable_node, start, finish, downto ? -1 : 1, body);
     if (*for_statement == NULL)
         RETURN_ERROR(PS_ERROR_OUT_OF_MEMORY)
 
@@ -691,7 +693,7 @@ bool ps_parse_statement_list(ps_compiler *compiler, ps_ast_block *block, ps_ast_
     else
     {
         // Let's go!
-        ps_ast_node *statement = NULL;
+        ps_ast_node **statement = NULL;
         // Up to 256 statements for now
         size_t count = 0;
         ps_ast_node *statements[256];
@@ -703,7 +705,7 @@ bool ps_parse_statement_list(ps_compiler *compiler, ps_ast_block *block, ps_ast_
             count += 1;
             if (count > 255)
                 RETURN_ERROR(PS_ERROR_TOO_MANY_ARGUMENTS) // should be PS_ERROR_TOO_MANY_STATEMENTS
-            statements[count - 1] = statement;
+            statements[count - 1] = (ps_ast_node *)(*statement);
             // NB: semi-colon at statement list end is optional
             if (lexer->current_token.type == PS_TOKEN_SEMI_COLON)
             {
@@ -749,7 +751,7 @@ bool ps_parse_statement_or_compound_statement(ps_compiler *compiler, ps_ast_bloc
         *statement_list = ps_ast_create_statement_list(start_line, start_column, 1);
         if (*statement_list == NULL)
             RETURN_ERROR(PS_ERROR_OUT_OF_MEMORY)
-        (*statement_list)->statements[0] = statement;
+        (*statement_list)->statements[0] = *statement;
     }
 
     PARSE_END("OK")

src/ps_system.c

@@ -193,7 +193,7 @@ bool ps_system_init(ps_symbol_table *system)
 
 void ps_system_done(ps_symbol_table *system)
 {
-    ps_symbol_table_done(system->symbols);
+    ps_symbol_table_free(system);
 }
 
 bool ps_system_add_symbol(ps_symbol_table *system, ps_symbol *symbol)