array value access & assignment OK?

Author: CHiPs44

examples/030-array.pas

@@ -0,0 +1,29 @@
+(*
+    This file is part of the PascalScript Pascal interpreter.
+    SPDX-FileCopyrightText: 2026 Christophe 'CHiPs' Petit <chips44@gmail.com>
+    SPDX-License-Identifier: LGPL-3.0-or-later
+*)
+Program Arrays;
+
+Type
+    // NumberArray = Array[1..10] Of Integer;
+    NumberArray = Array['A'..'F'] Of Integer;
+
+Var
+    Numbers: NumberArray;
+    // I: Integer;
+    I: Char;
+    N: Integer;
+
+Begin
+    // For I := 1 To 10 Do
+    N := 10;
+    For I := 'A' To 'F' Do
+    Begin
+        Numbers[I] := N;
+        N := N + 1;
+    End;
+    // For I := 1 To 10 Do
+    For I := 'A' To 'F' Do
+        WriteLn(I:2, ' * ', I:2, ' = ', Numbers[I]:3);
+End.

examples/030-array0.pas

@@ -0,0 +1,26 @@
+(*
+    This file is part of the PascalScript Pascal interpreter.
+    SPDX-FileCopyrightText: 2026 Christophe 'CHiPs' Petit <chips44@gmail.com>
+    SPDX-License-Identifier: LGPL-3.0-or-later
+*)
+Program Arrays;
+
+Type
+    NumberArray = Array['A'..'F'] Of Integer;
+
+Var
+    Numbers: NumberArray;
+    C: Char;
+    N: Integer;
+
+Begin
+    Numbers['C'] := 42;
+    N := 10;
+    For C := 'A' To 'F' Do
+    Begin
+        Numbers[C] := N;
+        N := N + 1;
+    End;
+    For C := 'A' To 'F' Do
+        WriteLn(C:2, ' = ', Numbers[C]:3);
+End.

examples/031-array1.pas

@@ -0,0 +1,73 @@
+(*
+    This file is part of the PascalScript Pascal interpreter.
+    SPDX-FileCopyrightText: 2026 Christophe 'CHiPs' Petit <chips44@gmail.com>
+    SPDX-License-Identifier: LGPL-3.0-or-later
+*)
+Program Arrays;
+
+Type
+    TIndex1 = 1..10;
+    NumberArray = Array[1..10] Of Integer;
+    StringArray = Array[1..10] Of String;
+
+{ Same as Free Pascal SysUtils }
+Function IntToStr(N: Integer): String;
+Var S: String;
+    Digit: Integer;
+Begin
+    { Convert an Integer to a string }
+    { This is a simplified version of the SysUtils.IntToStr function }
+    { It does not handle all edge cases, but is sufficient for this example }
+    If N = 0 Then
+        S := '0'
+    Else
+    Begin
+        S := '';
+        If N < 0 Then
+        Begin
+            N := -N;
+            S := '-';
+        End;
+        While N > 0 Do
+        Begin
+            Digit := N Mod 10;
+            S := Chr(Ord('0') + Digit) + S;
+            N := N Div 10;
+        End;
+    End;
+    IntToStr := S;
+End;
+
+function Pad(N: Integer, w: Integer): String;
+Var S: String;
+Begin
+    S := IntToStr(N);
+    while Length(S) < w do
+    Begin
+        S := '0' + S;
+    End;
+    Pad := S;
+End;
+
+Var
+    Numbers: NumberArray;
+    Strings: StringArray;
+    I, N: Integer;
+    S: String;
+
+Begin
+    N := 1;
+    For I := 1 To 10 Do
+    Begin
+        Numbers[I] := N;
+        Strings[I] := {'#' + Pad(I, 2) + ' ' + }IntToStr(N);
+        N := N * 2;
+    End;
+    WriteLn('#  | Number | String ');
+    WriteLn('---|--------|--------');
+    For I := 1 To 10 Do
+    Begin
+        S := Strings[I];
+        WriteLn(I:2, ' | ', Numbers[I]:6, ' | ', S);
+    End;
+End.

examples/032-array2.pas

@@ -20,7 +20,7 @@
 #include "ps_symbol_table.h"
 #include "ps_version.h"
 
-#define DEBUGGER_SOURCE "examples/030-array.pas"
+#define DEBUGGER_SOURCE "examples/031-array1.pas"
 // #define DEBUGGER_SOURCE "examples/005-first.pas"
 
 // Runtime options

src/pascalscript.c

@@ -52,7 +52,7 @@ ps_type_definition *ps_array_get_type_def(const ps_symbol *symbol)
         ps_symbol_debug(stderr, "PS_ARRAY_GET_TYPE_DEF, => array    : ", symbol);
     if (symbol == NULL || symbol->value == NULL || symbol->value->type == NULL)
         return NULL;
-    ps_symbol *symbol2;
+    const ps_symbol *symbol2;
     if (symbol->kind == PS_SYMBOL_KIND_TYPE_DEFINITION)
     {
         symbol2 = symbol;
@@ -83,17 +83,14 @@ ps_symbol *ps_array_get_subrange(const ps_symbol *array_type)
 {
     if (ps_array_debug)
         ps_symbol_debug(stderr, "ps_array_get_subrange, array_type: ", array_type);
-    // WORKS(?) => array->value->type->value->data.t->def.a.subrange
-    ps_symbol_debug(stderr, "GET_SUBRANGE\tARRAY\t\t", array_type);
-    ps_value_debug(stderr, "GET_SUBRANGE\tVALUE\t\t", array_type->value);
-    ps_symbol_debug(stderr, "GET_SUBRANGE\tTYPE\t\t", array_type->value->type);
-    ps_value_debug(stderr, "GET_SUBRANGE\tTYPE\t\t", array_type->value->type->value);
     const ps_type_definition *type_def = ps_array_get_type_def(array_type);
-    ps_type_definition_debug(stderr, "GET_SUBRANGE\tTYPE_DEF\t", type_def);
+    if (ps_array_debug)
+        ps_type_definition_debug(stderr, "GET_SUBRANGE\tTYPE_DEF\t", type_def);
     if (type_def == NULL)
         return NULL;
     ps_symbol *subrange = type_def->def.a.subrange;
-    ps_symbol_debug(stderr, "GET_SUBRANGE\tSUBRANGE\t", subrange);
+    if (ps_array_debug)
+        ps_symbol_debug(stderr, "GET_SUBRANGE\tSUBRANGE\t", subrange);
     return subrange;
 }
 
@@ -141,13 +138,9 @@ ps_error ps_array_set_value(ps_symbol *array_var, const ps_value *index, const p
         array_var->value->data.a->values == NULL)
         return PS_ERROR_INVALID_PARAMETERS;
     const ps_symbol *subrange = ps_array_get_subrange(array_var->value->type);
-    ps_symbol_debug(stderr, "SET_VALUE ", subrange);
-    ps_type_definition_debug(stderr, "SET_VALUE ", subrange->value->data.t);
     // Get offset from index
-    fprintf(stderr, "11111 OFFSET\n");
     ps_array_debug = true;
     ps_unsigned offset = ps_type_definition_get_subrange_offset(subrange->value->data.t, index);
-    fprintf(stderr, "22222 offset=%u, count=%u\n", offset, array_var->value->data.a->count);
     if (offset >= array_var->value->data.a->count)
         return PS_ERROR_INVALID_SUBRANGE;
     ps_array_debug = false;

src/ps_array.c

@@ -175,7 +175,7 @@ ps_unsigned ps_type_definition_get_subrange_count(const ps_type_definition *subr
 
 ps_unsigned ps_type_definition_get_subrange_offset(const ps_type_definition *subrange, const ps_value *index)
 {
-    bool debug = true;
+    bool debug = false;
     ps_unsigned offset = PS_UNSIGNED_MAX;
     if (subrange->type == PS_TYPE_SUBRANGE)
     {
@@ -192,7 +192,7 @@ ps_unsigned ps_type_definition_get_subrange_offset(const ps_type_definition *sub
         {
         case PS_TYPE_CHAR:
             // 'C' from 'A'..'Z' => Ord('C') - Ord('A') => 2
-            if (ps_value_get_type(index) == PS_TYPE_CHAR && index->data.c >= subrange->def.g.c.min &&
+            if (ps_value_get_base(index) == PS_TYPE_CHAR && index->data.c >= subrange->def.g.c.min &&
                 index->data.c <= subrange->def.g.c.max)
                 offset = index->data.c - subrange->def.g.c.min;
             break;
@@ -220,7 +220,7 @@ ps_unsigned ps_type_definition_get_subrange_offset(const ps_type_definition *sub
         case PS_TYPE_INTEGER:
             // 3 from -4..4 => 3 - -4 => 7
             //         0..8
-            if (ps_value_get_type(index) == PS_TYPE_INTEGER && index->data.i >= subrange->def.g.i.min &&
+            if (ps_value_get_base(index) == PS_TYPE_INTEGER && index->data.i >= subrange->def.g.i.min &&
                 index->data.i <= subrange->def.g.i.max)
                 offset = index->data.i - subrange->def.g.i.min;
             break;

src/ps_type_definition.c

@@ -276,37 +276,33 @@ bool ps_visit_term(ps_interpreter *interpreter, ps_interpreter_mode mode, ps_val
 bool ps_visit_factor_identifier_array(ps_interpreter *interpreter, ps_interpreter_mode mode, const ps_symbol *symbol,
                                       ps_value *result)
 {
-    // interpreter->debug = DEBUG_VERBOSE;
     VISIT_BEGIN("FACTOR", "ARRAY");
 
-    ps_type_definition *type_def = ps_array_get_type_def(symbol->value->type);
+    const ps_type_definition *type_def = ps_array_get_type_def(symbol->value->type);
     if (type_def == NULL)
         RETURN_ERROR(PS_ERROR_TYPE_MISMATCH)
     READ_NEXT_TOKEN
     if (lexer->current_token.type == PS_TOKEN_LEFT_BRACKET)
     {
-        ps_value index = {.type = type_def->def.a.item_type, .allocated = false, .data.v = NULL};
-        // clang-format off
-        ps_symbol_debug         (stderr, "ARRAY     ", symbol);
-        ps_value_debug          (stderr, "INDEX     ", &index);
-        ps_symbol_debug         (stderr, "ITEM_TYPE ", type_def->def.a.item_type);
-        ps_symbol_debug         (stderr, "SUBRANGE1 ", type_def->def.a.subrange);
-        ps_type_definition_debug(stderr, "SUBRANGE2 ", type_def->def.a.subrange->value->data.t);
-        // clang-format on
+        ps_value index = {.type = &ps_system_none/*type_def->def.a.item_type*/, .allocated = false, .data.v = NULL};
         READ_NEXT_TOKEN
         if (!ps_visit_expression(interpreter, mode, &index))
         {
             ps_interpreter_set_message(interpreter, "Index is invalid");
             TRACE_ERROR("INDEX")
         }
         EXPECT_TOKEN(PS_TOKEN_RIGHT_BRACKET)
-        ps_error error = ps_array_get_value(symbol, &index, result, interpreter->range_check);
-        if (error != PS_ERROR_NONE)
+        if (mode == MODE_EXEC)
         {
-            ps_interpreter_set_message(interpreter, "Can't get array value for index %s",
-                                       ps_value_get_debug_string(&index));
-            RETURN_ERROR(error)
+            ps_error error = ps_array_get_value(symbol, &index, result, interpreter->range_check);
+            if (error != PS_ERROR_NONE)
+            {
+                ps_interpreter_set_message(interpreter, "Can't get array value for index %s",
+                                           ps_value_get_debug_string(&index));
+                RETURN_ERROR(error)
+            }
         }
+        READ_NEXT_TOKEN
     }
 
     VISIT_END("OK")
@@ -342,7 +338,6 @@ bool ps_visit_factor_identifier(ps_interpreter *interpreter, ps_interpreter_mode
                     symbol->name, ps_symbol_get_kind_name(symbol->kind),
                     ps_type_definition_get_name(symbol->value->type->value->data.t));
         }
-        // fprintf(stderr, "ARRAY? %s\n", ps_value_is_array(symbol->value) ? "YES" : "NO");
         if (ps_value_is_array(symbol->value))
         {
             if (!ps_visit_factor_identifier_array(interpreter, mode, symbol, result))

src/ps_visit_expression.c

@@ -86,6 +86,38 @@ bool ps_visit_compound_statement(ps_interpreter *interpreter, ps_interpreter_mod
 //     VISIT_END("OK");
 // }
 
+bool ps_visit_assignment_array(ps_interpreter *interpreter, ps_interpreter_mode mode, ps_symbol *variable)
+{
+    VISIT_BEGIN("ASSIGNMENT", "ARRAY")
+
+    ps_value result = {.type = &ps_system_none, .data.v = NULL};
+    ps_value index = {.type = &ps_system_none, .data.v = NULL};
+
+    EXPECT_TOKEN(PS_TOKEN_LEFT_BRACKET)
+    READ_NEXT_TOKEN
+    index.type = variable->value->type->value->data.t->def.a.subrange;
+    if (!ps_visit_expression(interpreter, mode, &index))
+        TRACE_ERROR("INDEX")
+    EXPECT_TOKEN(PS_TOKEN_RIGHT_BRACKET)
+    READ_NEXT_TOKEN
+    EXPECT_TOKEN(PS_TOKEN_ASSIGN)
+    READ_NEXT_TOKEN
+    result.type = variable->value->type->value->data.t->def.a.item_type;
+    if (!ps_visit_expression(interpreter, mode, &result))
+        TRACE_ERROR("EXPRESSION1")
+    if (mode == MODE_EXEC)
+    {
+        ps_error error = ps_array_set_value(variable, &index, &result, interpreter->range_check);
+        if (error != PS_ERROR_NONE)
+        {
+            interpreter->error = error;
+            TRACE_ERROR("ARRAY_ASSIGN")
+        }
+    }
+
+    VISIT_END("OK")
+}
+
 /**
  * Visit assignment:
  *      IDENTIFIER := EXPRESSION
@@ -98,11 +130,9 @@ bool ps_visit_compound_statement(ps_interpreter *interpreter, ps_interpreter_mod
  */
 bool ps_visit_assignment(ps_interpreter *interpreter, ps_interpreter_mode mode, ps_symbol *variable)
 {
-    // interpreter->debug = DEBUG_TRACE;
     VISIT_BEGIN("ASSIGNMENT", "")
 
     ps_value result = {.type = &ps_system_none, .data.v = NULL};
-    ps_value index = {.type = &ps_system_none, .data.v = NULL};
 
     if (variable->kind == PS_SYMBOL_KIND_CONSTANT)
     {
@@ -122,28 +152,8 @@ bool ps_visit_assignment(ps_interpreter *interpreter, ps_interpreter_mode mode,
     if (ps_value_get_type(variable->value) == PS_TYPE_ARRAY)
     {
         // => array[index] := expression
-        EXPECT_TOKEN(PS_TOKEN_LEFT_BRACKET)
-        READ_NEXT_TOKEN
-        index.type = variable->value->type->value->data.t->def.a.subrange;
-        if (!ps_visit_expression(interpreter, mode, &index))
-            TRACE_ERROR("INDEX")
-        EXPECT_TOKEN(PS_TOKEN_RIGHT_BRACKET)
-        READ_NEXT_TOKEN
-        EXPECT_TOKEN(PS_TOKEN_ASSIGN)
-        READ_NEXT_TOKEN
-        result.type = variable->value->type->value->data.t->def.a.item_type;
-        if (!ps_visit_expression(interpreter, mode, &result))
-            TRACE_ERROR("EXPRESSION1")
-        ps_value_debug(stderr, "*** RESULT ", &result);
-        ps_value_debug(stderr, "*** INDEX  ", &index);
-        ps_error error = ps_array_set_value(variable, &index, &result, interpreter->range_check);
-        if (error != PS_ERROR_NONE)
-        {
-            interpreter->error = error;
-            TRACE_ERROR("ARRAY_ASSIGN")
-        }
-        fprintf(stderr, "\n\n*** HERE! ***\n\n");
-        ps_array_debug_values(stderr, variable);
+        if (!ps_visit_assignment_array(interpreter, mode, variable))
+            TRACE_ERROR("ARRAY")
     }
     else
     {