add index-or-create opcode, indexed function statements will now create table chains if required.

Author: vddCore

Core/EVIL.Grammar/AST/Expressions/IndexerExpression.cs

@@ -12,18 +12,21 @@ public sealed class IndexerExpression : Expression
 
     public bool IsConditional { get; }
     public bool WillBeAssigned { get; }
+    public bool CreateTableIfNonExistent { get; }
 
     public IndexerExpression(
         Expression indexable, 
         Expression keyExpression, 
         bool isConditional, 
-        bool willBeAssigned)
+        bool willBeAssigned,
+        bool createTableIfNonExistent)
     {
         Indexable = indexable;
         KeyExpression = keyExpression;
 
         IsConditional = isConditional;
         WillBeAssigned = willBeAssigned;
+        CreateTableIfNonExistent = createTableIfNonExistent;
 
         Reparent(Indexable, KeyExpression);
     }

Core/EVIL.Grammar/EVIL.Grammar.csproj

@@ -3,7 +3,7 @@
     <TargetFramework>net9.0</TargetFramework>
     <Nullable>enable</Nullable>
 
-    <Version>8.1.0</Version>
+    <Version>8.2.0</Version>
 
     <IsPackable>false</IsPackable>
   </PropertyGroup>

Core/EVIL.Grammar/Parser.Expression.Indexer.cs

@@ -7,7 +7,7 @@
 
 public partial class Parser
 {
-    private IndexerExpression IndexerExpression(Expression indexable)
+    private IndexerExpression IndexerExpression(Expression indexable, bool createTableIfNonExistent)
     {
         int line, col;
         Expression indexer;
@@ -80,7 +80,8 @@ private IndexerExpression IndexerExpression(Expression indexable)
                 indexable, 
                 indexer, 
                 isConditional,
-                CurrentToken.Type == TokenType.Assign)
+                CurrentToken.Type == TokenType.Assign,
+                createTableIfNonExistent)
             { Line = line, Column = col };
     }
 }

Core/EVIL.Grammar/Parser.Expression.Postfix.cs

@@ -63,7 +63,7 @@ private Expression PostfixExpression()
                 case TokenType.Elvis:
                 case TokenType.ElvisArray:
                 {
-                    node = IndexerExpression(node);
+                    node = IndexerExpression(node, false);
                     break;
                 }
 

Core/EVIL.Grammar/Parser.Statement.Fn.cs

@@ -59,7 +59,7 @@ private Statement FnStatement()
 
                 while (CurrentToken.Type == TokenType.Dot)
                 {
-                    expression = IndexerExpression(expression);
+                    expression = IndexerExpression(expression, true);
                 }
 
                 primaryTarget = expression;

VirtualMachine/EVIL.Ceres/EVIL.Ceres.csproj

@@ -8,7 +8,7 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <EnableUnsafeBinaryFormatterSerialization>true</EnableUnsafeBinaryFormatterSerialization>
 
-    <Version>9.1.0</Version>
+    <Version>9.2.0</Version>
 
     <IsPackable>false</IsPackable>
   </PropertyGroup>

VirtualMachine/EVIL.Ceres/ExecutionEngine/Diagnostics/OpCode.cs

@@ -66,6 +66,7 @@ public enum OpCode : byte
     ELINIT,
     ELSET,
     INDEX,
+    INOCT,
     TABCLN,
     YIELD,
     YRET,

VirtualMachine/EVIL.Ceres/ExecutionEngine/ExecutionUnit.cs

@@ -1433,6 +1433,30 @@ public void Step()
                 break;
             }
 
+            case OpCode.INOCT:
+            {
+                a = PopValue(); // Key
+                c = PopValue(); // Table
+
+                if (c.Type != DynamicValueType.Table)
+                {
+                    throw new UnsupportedDynamicValueOperationException(
+                        $"Attempt to index or create a table on an unsupported type '{c.Type}'"
+                    );
+                }
+
+                var value = c.Index(a);
+                
+                if (value == DynamicValue.Nil)
+                {
+                    value = new Table();
+                    c.SetEntry(a, value);
+                }
+
+                PushValue(value);
+                break;
+            }
+
             case OpCode.TABCLN:
             {
                 var isDeepClone = frame.FetchByte() > 0;

VirtualMachine/EVIL.Ceres/TranslationEngine/Compiler.Expression.Indexer.cs

@@ -32,14 +32,25 @@ protected override void Visit(IndexerExpression indexerExpression)
             Chunk.CodeGenerator.Emit(OpCode.JUMP, endIndexerLabel);
             Chunk.UpdateLabel(indexLabel, Chunk.CodeGenerator.IP);
             Visit(indexerExpression.KeyExpression);
-            Chunk.CodeGenerator.Emit(OpCode.INDEX);
+            
+            Chunk.CodeGenerator.Emit(
+                indexerExpression.CreateTableIfNonExistent 
+                    ? OpCode.INOCT 
+                    : OpCode.INDEX
+            );
+            
             Chunk.UpdateLabel(endIndexerLabel, Chunk.CodeGenerator.IP);
         }
         else
         {
             Visit(indexerExpression.Indexable);
             Visit(indexerExpression.KeyExpression);
-            Chunk.CodeGenerator.Emit(OpCode.INDEX);
+            
+            Chunk.CodeGenerator.Emit(
+                indexerExpression.CreateTableIfNonExistent 
+                    ? OpCode.INOCT 
+                    : OpCode.INDEX
+            );
         }
     }
 }

VirtualMachine/Tests/EVIL.Ceres.LanguageTests/tests/027_fn_indexed.vil

@@ -27,4 +27,33 @@ fn fn_indexed_byref {
 
   assert.is_of_type(t.func, Function);
   assert.equal(t.func(10, 2), 20);    
+}
+
+#[test]
+fn fn_indexed_inoct_create_one {
+  val a = { };
+  
+  loc fn a.b.c(d) -> d * 2;
+  
+  assert.is_of_type(a, Table);
+  assert.is_of_type(a.b, Table);
+  assert.is_of_type(a.b.c, Function);
+  assert.equal(a.b.c(2), 4);
+}
+
+#[test]
+fn fn_indexed_inoct_create_many {
+  val a = { };
+  
+  loc fn a.b.c.d.e.f.g.h(i, j, k) -> i + j + k;
+  
+  assert.is_of_type(a, Table);
+  assert.is_of_type(a.b, Table);
+  assert.is_of_type(a.b.c, Table);
+  assert.is_of_type(a.b.c.d, Table);
+  assert.is_of_type(a.b.c.d.e, Table);
+  assert.is_of_type(a.b.c.d.e.f, Table);
+  assert.is_of_type(a.b.c.d.e.f.g, Table);
+  assert.is_of_type(a.b.c.d.e.f.g.h, Function);
+  assert.equal(a.b.c.d.e.f.g.h(1, 2, 3), 6);
 }