Add cy.eval.

docs/docs.md

@@ -2975,7 +2975,14 @@ Builtin types are used internally by the compiler to define it's own primitive t
 >Evaluates to the module's URI as a string. See [Module URI](#module-uri).
 
 ## Runtime execution.
-> _Planned Feature_
+`cy.eval` evaluates source code in an isolated VM.
+If the last statement is an expression, a primitive or String can be returned to the caller:
+```cy
+use cy
+
+var res = cy.eval('1 + 2')
+print res        --> 3
+```
 
 # libcyber.
 

src/builtins/bindings.zig

@@ -57,10 +57,12 @@ pub const Symbol = enum {
     bytes,
 
     AssertError,
+    EvalError,
     FileNotFound,
     MissingSymbol,
     EndOfStream,
     OutOfBounds,
+    InvalidResult,
     InvalidArgument,
     InvalidSignature,
     InvalidRune,

src/builtins/builtins.zig

@@ -379,7 +379,9 @@ pub fn prepThrowZError2(ctx: cy.Context, err: anyerror, optTrace: ?*std.builtin.
 fn errorSymbol(err: anyerror) Symbol {
     switch (err) {
         error.AssertError           => return .AssertError,
+        error.EvalError             => return .EvalError,
         error.Unicode               => return .Unicode,
+        error.InvalidResult         => return .InvalidResult,
         error.InvalidArgument       => return .InvalidArgument,
         error.InvalidEnumTag        => return .InvalidArgument,
         error.FileNotFound          => return .FileNotFound,

src/builtins/cy.cy

@@ -1,3 +1,7 @@
+--| Evaluates source code in an isolated VM.
+--| If the last statement is an expression, a primitive or a String can be returned.
+#host func eval(src String) any
+
 --| Parses Cyber source string into a structured map object.
 --| Currently, only metadata about static declarations is made available but this will be extended to include an AST.
 #host func parse(src String) Map

src/builtins/cy.zig

@@ -10,6 +10,7 @@ const zErrFunc = cy.builtins.zErrFunc;
 
 const NameFunc = struct { []const u8, cy.ZHostFuncFn };
 const funcs = [_]NameFunc{
+    .{"eval",           zErrFunc(eval)},
     .{"parse",          zErrFunc(parse)},
     .{"parseCyon",      zErrFunc(parseCyon)},
     .{"repl",           zErrFunc(repl)},
@@ -305,7 +306,7 @@ fn fromCyonValue(vm: *cy.VM, val: cy.DecodeValueIR) !cy.Value {
             while (iter.next()) |entry| {
                 const child = try fromCyonValue(vm, dmap.getValue(entry.key_ptr.*));
                 const key = try vm.allocString(entry.key_ptr.*);
-                try map.map.set(vm, key, child);
+                try map.map.setConsume(vm, key, child);
             }
             return mapVal;
         },
@@ -549,6 +550,61 @@ pub fn repl2(vm: *cy.VM, config: c.EvalConfig, read_line: IReplReadLine) !void {
     }
 }
 
+fn eval(vm: *cy.VM, args: [*]const cy.Value, _: u8) anyerror!cy.Value {
+    // Create an isolated VM.
+    const ivm: *cy.VM = @ptrCast(@alignCast(c.create()));
+    defer c.destroy(@ptrCast(ivm));
+
+    // Use the same printers as the parent VM.
+    c.setPrinter(@ptrCast(ivm), c.getPrinter(@ptrCast(vm)));
+    c.setErrorPrinter(@ptrCast(ivm), c.getErrorPrinter(@ptrCast(vm)));
+
+    var config = c.defaultEvalConfig();
+    config.single_run = false;
+    config.file_modules = false;
+    config.reload = false;
+    config.backend = c.BackendVM;
+    config.spawn_exe = false;
+
+    const src = args[0].asString();
+    var val: cy.Value = undefined;
+    const res = c.evalExt(@ptrCast(ivm), c.toStr("eval"), c.toStr(src), config, @ptrCast(&val));
+    if (res != c.Success) {
+        switch (res) {
+            c.ErrorCompile => {
+                const report = c.newErrorReportSummary(@ptrCast(ivm));
+                defer c.freeStr(@ptrCast(ivm), report);
+                rt.err(vm, c.fromStr(report));
+            },
+            c.ErrorPanic => {
+                const report = c.newPanicSummary(@ptrCast(ivm));
+                defer c.freeStr(@ptrCast(ivm), report);
+                rt.err(vm, c.fromStr(report));
+            },
+            else => {
+                rt.err(vm, "unknown error\n");
+            },
+        }
+        return error.EvalError;
+    }
+
+    switch (val.getTypeId()) {
+        bt.Boolean,
+        bt.Integer,
+        bt.Float => {
+            return val;
+        },
+        bt.String => {
+            defer ivm.release(val);
+            return vm.allocString(val.asString());
+        },
+        else => {
+            defer ivm.release(val);
+            return error.InvalidResult;
+        }
+    }
+}
+
 const VmReadLine = struct {
     vm: *cy.VM,
     read_line: cy.Value,

test/behavior_test.zig

@@ -224,6 +224,7 @@ if (!aot) {
         run.case2(Config.initFileModules("./test/modules/import_sym_alias.cy"), "modules/import_sym_alias.cy");
     }
     run.case("modules/core.cy");
+    run.case("modules/cy.cy");
     run.case("modules/math.cy");
     run.case("modules/test_eq_panic.cy");
     run.case("modules/test.cy");

test/modules/cy.cy

@@ -1,6 +1,20 @@
 use t 'test'
 use cy
 
+-- eval()
+let res = cy.eval('1')
+t.eq(res, 1)
+res = cy.eval('1 + 2')
+t.eq(res, 3)
+res = cy.eval('''
+func mul(a int, b int) int:
+    return a * b
+mul(10, 5)''')
+t.eq(res, 50)
+res = cy.eval('"hello $(123)"')
+t.eq(res, 'hello 123')
+t.throws(() => cy.eval('a'), error.EvalError)
+
 -- parse()
 res = cy.parse('var .foo = 123')
 t.eq(res['decls'][0]['type'], 'variable')
@@ -73,4 +87,6 @@ t.eq(cyon, '{}')
 cyon = cy.toCyon({ a: 123 })
 t.eq(cyon, '''{
     a: 123,
-}''')
+}''')
+
+--cytest: pass

test/setup.zig

@@ -243,9 +243,10 @@ pub const VMrunner = struct {
         }
 
         if (config.checkGlobalRc) {
-            if (c.getGlobalRC(vm) != 0) {
+            const grc = c.getGlobalRC(vm);
+            if (grc != 0) {
                 c.traceDumpLiveObjects(vm);
-                cy.panic("unreleased refcount");
+                cy.panicFmt("unreleased refcount {}", .{grc});
             }
         }
     }