Merge pull request #16 from comroid-git/dev-stmt

Implement try-catch statements

Author: burdoto

examples/PrintNumbers.kscr

@@ -69,14 +69,20 @@ public class PrintNumbers implements Throwable {
         stdio <<- "look at my cool object: " + obj.toString(0) + endl;
         stdio <<- "and of course i can access it this way too: " + obj.StackValue + endl;
 
-        stdio <<- "let's test for-loop recursion with an 8x8 matrix:" + endl;
+        try {
+            obj.callThroingMethod();
+        } catch (Throwable t) {
+            stdio <<- "no this time yet, tho! we caught it" + t + endl;
+        } finally {
+            stdio <<- "and another time, finalization blocks" + endl;
+        }
+        
+        stdio <<- "now we're doing some recursion shit with a 8x8 table:" + endl;
         for (int y = 1; y < 9; y++) {
             for (int x = 1; x < 9; x++)
-                //throw x + (y * 9);
                 stdio <<- " " + x + y + " -";
             stdio <<- endl;
-        }// finally stdio <<- "finally, we finish throwing:";
-        
+        } finally stdio <<- "finally, we finish throwing:" + endl;
         obj.callThroingMethod();
     }
 

kscr-bytecode/Adapter/BytecodeAdapterV0_10.cs

@@ -137,6 +137,7 @@ void WriteArray<T>(T[] arr) where T : IBytecode
             WriteByte((byte)comp.VariableContext);
             WriteULong(comp.ByteArg);
             WriteString(comp.Arg ?? string.Empty);
+            WriteArray(comp.Args.Select(IBytecode.String).ToArray());
             Write(strings, stream, comp.SourcefilePosition);
             var memberState = comp.GetComponentMember();
             WriteByte((byte)memberState);
@@ -343,6 +344,7 @@ T2[] ReadArray<T2>()
                 var varctx = (VariableContext)ReadByte();
                 var byteArg = ReadULong();
                 sArg = ReadString();
+                var sArgs = ReadArray<string>();
                 srcPos = Load<SourcefilePosition>(vm, strings, stream, pkg, cls);
                 var memberState = (ComponentMember)ReadByte();
                 Statement? subStmt, altStmt = subStmt = null;
@@ -367,6 +369,7 @@ T2[] ReadArray<T2>()
                     VariableContext = varctx,
                     ByteArg = byteArg,
                     Arg = sArg,
+                    Args = sArgs.ToList(),
                     SubStatement = subStmt,
                     AltStatement = altStmt,
                     SubComponent = subComp,

kscr-compiler/KScr/Compiler/AbstractVisitor.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using Antlr4.Runtime;
 using Antlr4.Runtime.Tree;
@@ -166,20 +167,24 @@ protected Statement VisitPipeListen(KScrParser.ExprContext pipe, KScrParser.Expr
             {
                 Type = StatementComponentType.Code,
                 CodeType = BytecodeType.StmtCatch,
-                Arg = katchow.type() == null
-                    ? string.Empty
-                    : string.Join(";", katchow.type()
-                        .Select(x => VisitTypeInfo(x).FullDetailedName)
-                        .Append(katchow.idPart().GetText())),
-                InnerCode = VisitCode(katchow.codeBlock())
+                Arg = katchow.idPart().GetText(),
+                Args = katchow.type() == null
+                    ? new List<string>()
+                    : katchow.type()
+                        .Select(x => VisitTypeInfo(x).CanonicalName)
+                        .Append(katchow.idPart().GetText())
+                        .ToList(),
+                InnerCode = VisitCode(katchow.codeBlock()),
+                SourcefilePosition = ToSrcPos(katchow)
             });
+        // finally
         if (context.finallyBlock() is { } finalli)
             comp.AltComponent = new StatementComponent()
             {
                 Type = StatementComponentType.Code,
                 CodeType = BytecodeType.StmtFinally,
-                InnerCode = VisitCode(finalli.codeBlock())
-
+                InnerCode = VisitCode(finalli.codeBlock()),
+                SourcefilePosition = ToSrcPos(finalli)
             };
         return comp;
     }

kscr-compiler/KScr/Compiler/Code/StatementVisitor.cs

@@ -151,14 +151,18 @@ public override Statement VisitStmtTryCatch(KScrParser.StmtTryCatchContext conte
         {
             Type = StatementComponentType.Code,
             CodeType = BytecodeType.StmtTry,
-            CatchFinally = context.catchBlocks() == null ? null : VisitCatchBlocks(context.catchBlocks())
+            CatchFinally = context.catchBlocks() == null ? null : VisitCatchBlocks(context.catchBlocks()),
+            Main =
+            {
+                new StatementComponent()
+                {
+                    Type = StatementComponentType.Code,
+                    CodeType = BytecodeType.StmtTry,
+                    ByteArg = 0,
+                    InnerCode = VisitCode(context.tryCatchStatement().codeBlock())
+                }
+            }
         };
-        stmt.Main.Add(new StatementComponent()
-        {
-            Type = StatementComponentType.Code,
-            CodeType = BytecodeType.StmtTry,
-            InnerCode = VisitCode(context.tryCatchStatement().codeBlock())
-        });
         return stmt;
     }
 
@@ -182,14 +186,15 @@ public override Statement VisitStmtTryWithRes(KScrParser.StmtTryWithResContext c
             {
                 Type = StatementComponentType.Code,
                 CodeType = BytecodeType.StmtTry,
-                Arg = decl.type().GetText() + ';' + decl.idPart().GetText(),
+                Args = { ctx.FindType(vm, decl.type().GetText())!.FullDetailedName, decl.idPart().GetText() },
                 SubComponent = VisitExpression(decl.expr())
             });
         }
         stmt.Main.Add(new StatementComponent()
         {
             Type = StatementComponentType.Code,
             CodeType = BytecodeType.StmtTry,
+            ByteArg = 1,
             SubStatement = defs,
             InnerCode = VisitCode(context.tryWithResourcesStatement().codeBlock())
         });

kscr-compiler/KScr/Compiler/Utils.cs

@@ -1,4 +1,5 @@
 using Antlr4.Runtime;
+using KScr.Antlr;
 using KScr.Core.Model;
 
 namespace KScr.Compiler;

kscr-core/Bytecode/Statement.cs

@@ -37,6 +37,7 @@ public class Statement : IBytecode, IStatement<StatementComponent>
 
     public Stack Evaluate(RuntimeBase vm, Stack stack)
     {
+        bool caught = false;
         try
         {
             foreach (var component in Main)
@@ -51,6 +52,57 @@ public Stack Evaluate(RuntimeBase vm, Stack stack)
                             stack[Default]![vm, stack, i] = stack.Bet?[vm, stack, 0] ?? IObject.Null;
                         }
 
+                        break;
+                    case (StatementComponentType.Code, BytecodeType.StmtTry):
+                        (string name, IObject value)[]? resources = null;
+                        var comp = Main[0];
+                        try
+                        {
+                            if (comp.ByteArg == 1) // try-with-resources
+                                resources = comp.SubStatement!.Main.Select(x => (x.Args[1],
+                                    x.SubComponent!.Evaluate(vm, stack.Output()).Copy()![vm, stack, 0])).ToArray();
+
+                            var resourcesF = resources;
+                            var compF = comp;
+                            stack.StepInside(vm, comp.SourcefilePosition, "try", stack =>
+                            {
+                                foreach (var resource in resourcesF ?? Array.Empty<(string, IObject)>())
+                                    vm.PutLocal(stack, resource.name, resource.value);
+                                compF.InnerCode!.Evaluate(vm, stack);
+                            });
+                        }
+                        catch (StackTraceException trace)
+                        {
+                            var innerCause = trace.InnerCause.Obj;
+                            foreach (var catchBlock in CatchFinally!.SubStatement!.Main
+                                         .Where(x => x.Args.Select(t => vm.FindType(t))
+                                             .Any(x => x!.CanHold(innerCause.Type)))
+                                         .Select(x => (x.Arg, x.InnerCode)))
+                            {
+                                stack.StepInside(vm, CatchFinally.SourcefilePosition, "catch", stack =>
+                                {
+                                    vm.PutLocal(stack, catchBlock.Arg, innerCause);
+                                    catchBlock.InnerCode!.Evaluate(vm, stack);
+                                });
+                            }
+                            caught = true;
+                        }
+                        finally
+                        {
+                            try
+                            {
+                                if (resources != null)
+                                    foreach (var resource in resources.Select(x => x.value))
+                                        Class.CloseableType.DeclaredMembers["close"].Invoke(vm, stack, resource);
+                                CatchFinally!.AltComponent!.InnerCode!.Evaluate(vm, stack);
+                                caught = true;
+                            }
+                            catch (StackTraceException fatal)
+                            {
+                                throw new FatalException("Inner exception during finalization", fatal);
+                            }
+                        }
+
                         break;
                     default:
                         component.Evaluate(vm, stack);
@@ -63,16 +115,23 @@ public Stack Evaluate(RuntimeBase vm, Stack stack)
         }
         catch (InternalException codeEx)
         {
-            if (CatchFinally != null)
-                CatchFinally.Evaluate(vm, stack);
+            stack[Tau] = new ObjectRef(Class.ThrowableType.DefaultInstance, codeEx.Obj);
+            CatchFinally?.Evaluate(vm, stack);
+            caught = true;
             throw codeEx;
         }
         catch (StackTraceException codeEx)
         {
-            if (CatchFinally != null)
-                CatchFinally.Evaluate(vm, stack);
+            stack[Tau] = new ObjectRef(Class.ThrowableType.DefaultInstance, codeEx.InnerCause.Obj);
+            CatchFinally?.Evaluate(vm, stack);
+            caught = true;
             throw codeEx;
         }
+        finally
+        {
+            if (!caught)
+                CatchFinally?.AltComponent?.InnerCode!.Evaluate(vm, stack);
+        }
 
         return stack;
     }
@@ -88,6 +147,7 @@ public class StatementComponent : IBytecode, IStatementComponent
     public Statement Statement { get; set; } = null!;
     public VariableContext VariableContext { get; set; }
     public string Arg { get; set; } = string.Empty;
+    public List<string> Args { get; set; } = new();
     public ulong ByteArg { get; set; }
     public SourcefilePosition SourcefilePosition { get; set; }
     public Statement? SubStatement { get; set; }
@@ -223,6 +283,7 @@ public virtual Stack Evaluate(RuntimeBase vm, Stack stack)
                 SubComponent.Evaluate(vm, stack.Output()).Copy(output: Alp | Omg);
                 //Console.WriteLine(stack[Alp]);
                 stack.State = State.Throw;
+                Stack.StackTrace.Clear();
                 break;
             case (StatementComponentType.Code, BytecodeType.StmtIf):
                 stack.StepInside(vm, SourcefilePosition, "if", stack =>
@@ -283,6 +344,20 @@ public virtual Stack Evaluate(RuntimeBase vm, Stack stack)
                     } while (SubComponent.Evaluate(vm, stack.Output(Phi)).Copy(Phi).ToBool());
                 });
                 break;
+            case (StatementComponentType.Code, BytecodeType.StmtCatch):
+                IObject ex = stack[Tau]![vm, stack, 0];
+                IClassInfo exType = ex.Type;
+                try
+                {
+                    SubStatement!.Main
+                        .FirstOrDefault(comp => comp.Args.Any(exClsName => exClsName == exType.CanonicalName))
+                        ?.InnerCode!.Evaluate(vm, stack);
+                }
+                finally
+                {
+                    AltComponent?.InnerCode!.Evaluate(vm, stack);
+                }
+                break;
             case (StatementComponentType.Operator, _):
                 var op = (Operator)ByteArg;
                 var compound = (op & Operator.Compound) == Operator.Compound;

kscr-core/Exception/FatalException.cs

@@ -1,34 +1,37 @@
-using KScr.Core.Model;
+using System;
+using System.IO;
 using KScr.Core.Std;
 using KScr.Core.Store;
-using String = System.String;
 
 namespace KScr.Core.Exception;
 
 public class InternalException : System.Exception
 {
-    public IClass Type { get; init; } = Class.ThrowableType;
-    public InternalException(string? message) : base(message)
+    internal readonly IObject Obj;
+
+    public InternalException(string? message, IObject? obj = null) : base(message)
     {
+        Obj = obj ?? IObject.Null;
     }
 
-    public InternalException(string? message, System.Exception? innerException) : base(message, innerException)
+    public InternalException(string? message, System.Exception? innerException) : base(message ?? innerException?.Message, innerException)
     {
+        Obj = IObject.Null;
     }
-
-    public string BaseMessage => base.Message;
-    public override string Message => $"An internal {Type.DetailedName} occurred: {BaseMessage}";
-
-    public static InternalException npe(string? message = null!) => new(message ?? String.Empty) { Type = Class.NullPointerExceptionType };
 }
 
-public class FatalException : System.Exception
+public class FatalException :  
+        #if DEBUG
+System.Exception 
+        #else
+InternalException
+        #endif
 {
     public FatalException(string? message) : base(message)
     {
     }
 
-    public FatalException(string? message, System.Exception? innerException) : base(message, innerException)
+    public FatalException(string? message, System.Exception? innerException) : base(message ?? innerException?.Message, innerException)
     {
     }
 }
@@ -41,13 +44,13 @@ public interface IStackTrace
 
 public class StackTraceException : System.Exception, IStackTrace
 {
-    public StackTraceException(CallLocation srcPos, string local, System.Exception innerTrace,
+    public StackTraceException(CallLocation srcPos, string local, InternalException innerCause,
         string? message = null)
-        : base(message ?? "<...>", innerTrace)
+        : base(message ?? "<...>", innerCause)
     {
         CallLoc = srcPos;
         Local = local;
-        InnerTrace = innerTrace;
+        InnerCause = innerCause;
     }
 
     public StackTraceException(CallLocation srcPos, string local, StackTraceException innerTrace,
@@ -56,14 +59,23 @@ public StackTraceException(CallLocation srcPos, string local, StackTraceExceptio
     {
         CallLoc = srcPos;
         Local = local;
+        InnerCause = innerTrace.InnerCause;
     }
 
-    public System.Exception? InnerTrace { get; }
+    public InternalException InnerCause { get; }
     public string Local { get; }
     public string BaseMessage => base.Message;
     public CallLocation CallLoc { get; }
 
     public override string Message => $"{CallLoc.SourceName}" + (CallLoc.SourceLine == 0
         ? string.Empty
         : $" [line {CallLoc.SourceLine} pos {CallLoc.SourceCursor}]");// + BaseMessage;
+
+    public void PrintStackTrace() => WriteStackTrace(Console.Out);
+    public void WriteStackTrace(TextWriter @out)
+    {
+        @out.WriteLine($"An exception occurred:\t{InnerCause.Message}");
+        foreach (var stackTraceElement in Stack.StackTrace)
+            @out.WriteLine($"\tat\t{stackTraceElement.Message}");
+    }
 }

kscr-core/RuntimeBase.cs

@@ -253,9 +253,7 @@ public Stack Execute()
         }
         catch (StackTraceException stc)
         {
-            Console.WriteLine($"An exception occurred:\t{stc.InnerTrace.Message}");
-            foreach (var stackTraceElement in Stack.StackTrace)
-                Console.WriteLine($"\tat\t{stackTraceElement.Message}");
+            stc.PrintStackTrace();
         }
 
         return stack;