Merge pull request #10 from TopchetoEU/TopchetoEU/mapping

Add support for source mappings

.github/workflows/tagged-release.yml

@@ -15,7 +15,7 @@ jobs:
         uses: actions/setup-java@v3
         with:
           distribution: 'adopt'
-          java-version: '17'
+          java-version: '11'
       - name: Clone repository
         uses: GuillaumeFalourd/clone-github-repo-action@main
         with:

README.md

@@ -4,31 +4,42 @@
 
 **WARNING: Currently, this code is mostly undocumented. Proceed with caution and a psychiatrist.**
 
-JScript is an engine, capable of running EcmaScript 5, written entirely in Java. This engine has been developed with the goal of being easy to integrate with your preexisting codebase, **THE GOAL OF THIS ENGINE IS NOT PERFORMANCE**. My crude experiments show that this engine is 50x-100x slower than V8, which, although bad, is acceptable for most simple scripting purposes.
+JScript is an engine, capable of running EcmaScript 5, written entirely in Java. This engine has been developed with the goal of being easy to integrate with your preexisting codebase, **THE GOAL OF THIS ENGINE IS NOT PERFORMANCE**. My crude experiments show that this engine is 50x-100x slower than V8, which, although bad, is acceptable for most simple scripting purposes. Note that although the codebase has a Main class, this isn't meant to be a standalone program, but instead a library for running JavaScript code.
 
 ## Example
 
 The following will create a REPL using the engine as a backend. Not that this won't properly log errors. I recommend checking out the implementation in `Main.main`:
 
 ```java
-var engine = new PolyfillEngine(new File("."));
+var engine = new Engine(true /* false if you dont want debugging */);
-var in = new BufferedReader(new InputStreamReader(System.in));
+var env = new Environment(null, null, null);
+var debugger = new DebugServer();
+
+// Create one target for the engine and start debugging server
+debugger.targets.put("target", (socket, req) -> new SimpleDebugger(socket, engine));
+debugger.start(new InetSocketAddress("127.0.0.1", 9229), true);
+
+// Queue code to load internal libraries and start engine
+engine.pushMsg(false, null, new Internals().getApplier(env));
 engine.start();
 
 while (true) {
     try {
-        var raw = in.readLine();
+        var raw = Reading.read();
+        if (raw == null) break;
 
-        var res = engine.pushMsg(false, engine.global(), Map.of(), "<stdio>", raw, null).await();
+        // Push a message to the engine with the raw REPL code
-        Values.printValue(engine.context(), res);
+        var res = engine.pushMsg(
-        System.out.println();
+            false, new Context(engine).pushEnv(env),
+            new Filename("jscript", "repl.js"), raw, null
+        ).await();
+
+        Values.printValue(null, res);
     }
-    catch (EngineException e) {
+    catch (EngineException e) { Values.printError(e, ""); }
-        try {
+    catch (SyntaxException ex) {
-            System.out.println("Uncaught " + e.toString(engine.context()));
+        System.out.println("Syntax error:" + ex.msg);
-        }
-        catch (InterruptedException _e) {  return; }
     }
-    catch (IOException | InterruptedException e) { return; }
+    catch (IOException e) { }
 }
 ```

build.js

@@ -1,7 +1,7 @@
 const { spawn } = require('child_process');
 const fs = require('fs/promises');
 const pt = require('path');
-const { argv } = require('process');
+const { argv, exit } = require('process');
 
 const conf = {
     name: "java-jscript",
@@ -74,6 +74,7 @@ async function compileJava() {
     }
     catch (e) {
         if (argv[2] === 'debug') throw e;
-        else console.log(e.toString());
+        console.log(e.toString());
+        exit(-1);
     }
 })();

src/assets/js/bootstrap.js

@@ -0,0 +1,113 @@
+(function (ts, env, libs) {
+    var src = '', version = 0;
+    var lib = libs.concat([
+        'declare function exit(): never;',
+        'declare function go(): any;',
+        'declare function getTsDeclarations(): string[];'
+    ]).join('');
+    var libSnapshot = ts.ScriptSnapshot.fromString(lib);
+    var environments = {};
+    var declSnapshots = [];
+
+    var settings = {
+        outDir: "/out",
+        declarationDir: "/out",
+        target: ts.ScriptTarget.ES5,
+        lib: [ ],
+        module: ts.ModuleKind.None,
+        declaration: true,
+        stripInternal: true,
+        downlevelIteration: true,
+        forceConsistentCasingInFileNames: true,
+        experimentalDecorators: true,
+        strict: true,
+        sourceMap: true,
+    };
+
+    var reg = ts.createDocumentRegistry();
+    var service = ts.createLanguageService({
+        getCurrentDirectory: function() { return "/"; },
+        getDefaultLibFileName: function() { return "/lib.d.ts"; },
+        getScriptFileNames: function() {
+            var res = [ "/src.ts", "/lib.d.ts" ];
+            for (var i = 0; i < declSnapshots.length; i++) res.push("/glob." + (i + 1) + ".d.ts");
+            return res;
+        },
+        getCompilationSettings: function () { return settings; },
+        fileExists: function(filename) { return filename === "/lib.d.ts" || filename === "/src.ts" || filename === "/glob.d.ts"; },
+
+        getScriptSnapshot: function(filename) {
+            if (filename === "/lib.d.ts") return libSnapshot;
+            if (filename === "/src.ts") return ts.ScriptSnapshot.fromString(src);
+
+            var index = /\/glob\.(\d+)\.d\.ts/g.exec(filename);
+            if (index && index[1] && (index = Number(index[1])) && index > 0 && index <= declSnapshots.length) {
+                return declSnapshots[index - 1];
+            }
+
+            throw new Error("File '" + filename + "' doesn't exist.");
+        },
+        getScriptVersion: function (filename) {
+            if (filename === "/lib.d.ts" || filename.startsWith("/glob.")) return 0;
+            else return version;
+        },
+    }, reg);
+
+    service.getEmitOutput("/lib.d.ts");
+    log("Loaded libraries!");
+
+    var oldCompile = env.compile;
+
+    function compile(code, filename, env) {
+        src = code;
+        version++;
+
+        if (!environments[env.id]) environments[env.id] = []
+        declSnapshots = environments[env.id];
+        var emit = service.getEmitOutput("/src.ts");
+
+        var diagnostics = []
+            .concat(service.getCompilerOptionsDiagnostics())
+            .concat(service.getSyntacticDiagnostics("/src.ts"))
+            .concat(service.getSemanticDiagnostics("/src.ts"))
+            .map(function (diagnostic) {
+                var message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+                if (diagnostic.file) {
+                    var pos = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+                    var file = diagnostic.file.fileName.substring(1);
+                    if (file === "src.ts") file = filename;
+                    return file + ":" + (pos.line + 1) + ":" + (pos.character + 1) + ": " + message;
+                }
+                else return message;
+            });
+
+        if (diagnostics.length > 0) {
+            throw new SyntaxError(diagnostics.join("\n"));
+        }
+
+        var map = JSON.parse(emit.outputFiles[0].text);
+        var result = emit.outputFiles[1].text;
+        var declaration = emit.outputFiles[2].text;
+
+        var compiled = oldCompile(result, filename, env);
+
+        return {
+            function: function () {
+                var val = compiled.function.apply(this, arguments);
+                if (declaration !== '') declSnapshots.push(ts.ScriptSnapshot.fromString(declaration));
+                return val;
+            },
+            breakpoints: compiled.breakpoints,
+            mapChain: compiled.mapChain.concat(map.mappings),
+        };
+    }
+
+    function apply(env) {
+        env.compile = compile;
+        env.global.getTsDeclarations = function() {
+            return environments[env.id];
+        }
+    }
+
+    apply(env);
+})(arguments[0], arguments[1], arguments[2]);

src/me/topchetoeu/jscript/Buffer.java

@@ -0,0 +1,53 @@
+package me.topchetoeu.jscript;
+
+public class Buffer {
+    private byte[] data;
+    private int length;
+
+    public void write(int i, byte[] val) {
+        if (i + val.length > data.length) {
+            var newCap = i + val.length + 1;
+            if (newCap < data.length * 2) newCap = data.length * 2;
+
+            var tmp = new byte[newCap];
+            System.arraycopy(this.data, 0, tmp, 0, length);
+            this.data = tmp;
+        }
+
+        System.arraycopy(val, 0, data, i, val.length);
+        if (i + val.length > length) length = i + val.length;
+    }
+    public int read(int i, byte[] buff) {
+        int n = buff.length;
+        if (i + n > length) n = length - i;
+        System.arraycopy(data, i, buff, 0, n);
+        return n;
+    }
+
+    public void append(byte b) {
+        write(length, new byte[] { b });
+    }
+
+    public byte[] data() {
+        var res = new byte[length];
+        System.arraycopy(this.data, 0, res, 0, length);
+        return res;
+    }
+    public int length() {
+        return length;
+    }
+
+    public Buffer(byte[] data) {
+        this.data = new byte[data.length];
+        this.length = data.length;
+        System.arraycopy(data, 0, this.data, 0, data.length);
+    }
+    public Buffer(int capacity) {
+        this.data = new byte[capacity];
+        this.length = 0;
+    }
+    public Buffer() {
+        this.data = new byte[128];
+        this.length = 0;
+    }
+}

src/me/topchetoeu/jscript/Filename.java

@@ -51,4 +51,10 @@ public class Filename {
         this.protocol = protocol;
         this.path = path;
     }
+
+    public static Filename parse(String val) {
+        var i = val.indexOf("://");
+        if (i >= 0) return new Filename(val.substring(0, i).trim(), val.substring(i + 3).trim());
+        else return new Filename("file", val.trim());
+    }
 }

src/me/topchetoeu/jscript/Location.java

@@ -71,4 +71,23 @@ public class Location implements Comparable<Location> {
         this.start = start;
         this.filename = filename;
     }
+
+    public static Location parse(String raw) {
+        int i0 = -1, i1 = -1;
+        for (var i = raw.length() - 1; i >= 0; i--) {
+            if (raw.charAt(i) == ':') {
+                if (i1 == -1) i1 = i;
+                else if (i0 == -1) {
+                    i0 = i;
+                    break;
+                }
+            }
+        }
+
+        return new Location(
+            Integer.parseInt(raw.substring(i0 + 1, i1)),
+            Integer.parseInt(raw.substring(i1 + 1)),
+            Filename.parse(raw.substring(0, i0))
+        );
+    }
 }

src/me/topchetoeu/jscript/Main.java

@@ -1,153 +1,170 @@
-package me.topchetoeu.jscript;
+package me.topchetoeu.jscript;
-
+
-import java.io.IOException;
+import java.io.IOException;
-import java.net.InetSocketAddress;
+import java.net.InetSocketAddress;
-import java.nio.file.Files;
+import java.nio.file.Files;
-import java.nio.file.Path;
+import java.nio.file.Path;
-
+
-import me.topchetoeu.jscript.engine.Context;
+import me.topchetoeu.jscript.engine.Context;
-import me.topchetoeu.jscript.engine.Engine;
+import me.topchetoeu.jscript.engine.Engine;
-import me.topchetoeu.jscript.engine.Environment;
+import me.topchetoeu.jscript.engine.Environment;
-import me.topchetoeu.jscript.engine.StackData;
+import me.topchetoeu.jscript.engine.debug.DebugServer;
-import me.topchetoeu.jscript.engine.debug.DebugServer;
+import me.topchetoeu.jscript.engine.debug.SimpleDebugger;
-import me.topchetoeu.jscript.engine.debug.SimpleDebugger;
+import me.topchetoeu.jscript.engine.values.ArrayValue;
-import me.topchetoeu.jscript.engine.values.ArrayValue;
+import me.topchetoeu.jscript.engine.values.NativeFunction;
-import me.topchetoeu.jscript.engine.values.NativeFunction;
+import me.topchetoeu.jscript.engine.values.ObjectValue;
-import me.topchetoeu.jscript.engine.values.ObjectValue;
+import me.topchetoeu.jscript.engine.values.Values;
-import me.topchetoeu.jscript.engine.values.Values;
+import me.topchetoeu.jscript.events.Observer;
-import me.topchetoeu.jscript.events.Observer;
+import me.topchetoeu.jscript.exceptions.EngineException;
-import me.topchetoeu.jscript.exceptions.EngineException;
+import me.topchetoeu.jscript.exceptions.InterruptException;
-import me.topchetoeu.jscript.exceptions.InterruptException;
+import me.topchetoeu.jscript.exceptions.SyntaxException;
-import me.topchetoeu.jscript.exceptions.SyntaxException;
+import me.topchetoeu.jscript.filesystem.MemoryFilesystem;
-import me.topchetoeu.jscript.lib.Internals;
+import me.topchetoeu.jscript.filesystem.Mode;
-
+import me.topchetoeu.jscript.filesystem.PhysicalFilesystem;
-public class Main {
+import me.topchetoeu.jscript.lib.Internals;
-    static Thread engineTask, debugTask;
+
-    static Engine engine;
+public class Main {   
-    static Environment env;
+    public static class Printer implements Observer<Object> {
-    static int j = 0;
+        public void next(Object data) {
-
+            Values.printValue(null, data);
-    private static Observer<Object> valuePrinter = new Observer<Object>() {
+            System.out.println();
-        public void next(Object data) {
+        }
-            Values.printValue(null, data);
+
-            System.out.println();
+        public void error(RuntimeException err) {
-        }
+            Values.printError(err, null);
-
+        }
-        public void error(RuntimeException err) {
+
-            Values.printError(err, null);
+        public void finish() {
-        }
+            engineTask.interrupt();
-
+        }
-        @Override
+    }
-        public void finish() {
+
-            engineTask.interrupt();
+    static Thread engineTask, debugTask;
-        }
+    static Engine engine = new Engine(true);
-    };
+    static DebugServer debugServer = new DebugServer();
-
+    static Environment environment = new Environment(null, null, null);
-    public static void main(String args[]) {
+
-        System.out.println(String.format("Running %s v%s by %s", Metadata.NAME, Metadata.VERSION, Metadata.AUTHOR));
+    static int j = 0;
-        engine = new Engine(true);
+    static boolean exited = false;
-
+    static String[] args;
-        env = new Environment(null, null, null);
+
-        var exited = new boolean[1];
+    private static void reader() {
-        var server = new DebugServer();
+        try {
-        server.targets.put("target", (ws, req) -> new SimpleDebugger(ws, engine));
+            for (var arg : args) {
-
+                try {
-        engineTask = engine.start();
+                    if (arg.equals("--ts")) initTypescript();
-        debugTask = server.start(new InetSocketAddress("127.0.0.1", 9229), true);
+                    else {
-
+                        var file = Path.of(arg);
-        engine.pushMsg(false, null, new NativeFunction((ctx, thisArg, _a) -> {
+                        var raw = Files.readString(file);
-            new Internals().apply(env);
+                        var res = engine.pushMsg(
-
+                            false, new Context(engine, environment),
-            env.global.define("exit", _ctx -> {
+                            Filename.fromFile(file.toFile()),
-                exited[0] = true;
+                            raw, null
-                throw new InterruptException();
+                        ).await();
-            });
+                        Values.printValue(null, res);
-            env.global.define("go", _ctx -> {
+                        System.out.println();
-                try {
+                    }
-                    var f = Path.of("do.js");
+                }
-                    var func = _ctx.compile(new Filename("do", "do/" + j++ + ".js"), new String(Files.readAllBytes(f)));
+                catch (EngineException e) { Values.printError(e, null); }
-                    return func.call(_ctx);
+            }
-                }
+            for (var i = 0; ; i++) {
-                catch (IOException e) {
+                try {
-                    throw new EngineException("Couldn't open do.js");
+                    var raw = Reading.read();
-                }
+
-            });
+                    if (raw == null) break;
-            // TODO: make better API
+                    var res = engine.pushMsg(
-            env.global.define(true, new NativeFunction("include", (_ctx, th, __args) -> {
+                        false, new Context(engine, environment),
-                try {
+                        new Filename("jscript", "repl/" + i + ".js"),
-                    var currFilename = StackData.peekFrame(_ctx).function.loc().filename();
+                        raw, null
-                    var loc = Path.of("").toAbsolutePath();
+                    ).await();
-                    if (currFilename.protocol.equals("file")) loc = Path.of(currFilename.path).getParent();
+                    Values.printValue(null, res);
-                    var path = loc.resolve(Path.of(__args.length >= 1 ? Values.toString(_ctx, __args[0]) : ""));
+                    System.out.println();
-                    var src = Files.readString(path);
+                }
-                    var func = _ctx.compile(Filename.fromFile(path.toFile()), src);
+                catch (EngineException e) { Values.printError(e, null); }
-                    var callArgs = new ArrayValue();
+                catch (SyntaxException e) { Values.printError(e, null); }
-                    if (__args.length >= 2 && __args[1] instanceof ArrayValue) callArgs = (ArrayValue)__args[1];
+            }
-                    return func.call(_ctx, null, callArgs);
+        }
-                }
+        catch (IOException e) {
-                catch (IOException e) { throw EngineException.ofError("IOError", "Couldn't open file."); }
+            System.out.println(e.toString());
-            }));
+            exited = true;
-
+        }
-            return null;
+        catch (RuntimeException ex) {
-        }), null).await();
+            if (!exited) {
-
+                System.out.println("Internal error ocurred:");
-        try {
+                ex.printStackTrace();
-            var tsEnv = env.child();
+            }
-            tsEnv.global.define(null, "module", false, new ObjectValue());
+        }
-            engine.pushMsg(
+        if (exited) {
-                false, new Context(engine).pushEnv(tsEnv),
+            debugTask.interrupt();
-                new Filename("jscript", "ts.js"),
+            engineTask.interrupt();
-                Reading.resourceToString("js/ts.js"), null
+        }
-            ).await();
+    }
-            System.out.println("Loaded typescript!");
+
-
+    private static void initEnv() {
-            var ctx = new Context(engine).pushEnv(env.child());
+        environment = Internals.apply(environment);
-
+
-            engine.pushMsg(
+        environment.global.define(false, new NativeFunction("exit", (_ctx, th, args) -> {
-                false, ctx,
+            exited = true;
-                new Filename("jscript", "internals/bootstrap.js"), Reading.resourceToString("js/bootstrap.js"), null,
+            throw new InterruptException();
-                tsEnv.global.get(ctx, "ts"), env, new ArrayValue(null, Reading.resourceToString("js/lib.d.ts"))
+        }));
-            ).await();
+        environment.global.define(false, new NativeFunction("go", (_ctx, th, args) -> {
-        }
+            try {
-        catch (EngineException e) {
+                var f = Path.of("do.js");
-            Values.printError(e, "(while initializing TS)");
+                var func = _ctx.compile(new Filename("do", "do/" + j++ + ".js"), new String(Files.readAllBytes(f)));
-        }
+                return func.call(_ctx);
-
+            }
-        var reader = new Thread(() -> {
+            catch (IOException e) {
-            try {
+                throw new EngineException("Couldn't open do.js");
-                for (var arg : args) {
+            }
-                    try {
+        }));
-                        var file = Path.of(arg);
+
-                        var raw = Files.readString(file);
+        environment.filesystem.protocols.put("temp", new MemoryFilesystem(Mode.READ_WRITE));
-                        valuePrinter.next(engine.pushMsg(false, new Context(engine).pushEnv(env), Filename.fromFile(file.toFile()), raw, null).await());
+        environment.filesystem.protocols.put("file", new PhysicalFilesystem(Path.of(".").toAbsolutePath()));
-                    }
+    }
-                    catch (EngineException e) { Values.printError(e, ""); }
+    private static void initEngine() {
-                }
+        debugServer.targets.put("target", (ws, req) -> new SimpleDebugger(ws, engine));
-                for (var i = 0; ; i++) {
+        engineTask = engine.start();
-                    try {
+        debugTask = debugServer.start(new InetSocketAddress("127.0.0.1", 9229), true);
-                        var raw = Reading.read();
+    }
-
+    private static void initTypescript() {
-                        if (raw == null) break;
+        try {
-                        valuePrinter.next(engine.pushMsg(false, new Context(engine).pushEnv(env), new Filename("jscript", "repl/" + i + ".js"), raw, null).await());
+            var tsEnv = Internals.apply(new Environment(null, null, null));
-                    }
+            tsEnv.stackVisible = false;
-                    catch (EngineException e) { Values.printError(e, ""); }
+            tsEnv.global.define(null, "module", false, new ObjectValue());
-                }
+            var bsEnv = Internals.apply(new Environment(null, null, null));
-            }
+            bsEnv.stackVisible = false;
-            catch (IOException e) { exited[0] = true; }
+
-            catch (SyntaxException ex) {
+            engine.pushMsg(
-                if (exited[0]) return;
+                false, new Context(engine, tsEnv),
-                System.out.println("Syntax error:" + ex.msg);
+                new Filename("jscript", "ts.js"),
-            }
+                Reading.resourceToString("js/ts.js"), null
-            catch (RuntimeException ex) {
+            ).await();
-                if (!exited[0]) {
+            System.out.println("Loaded typescript!");
-                    System.out.println("Internal error ocurred:");
+
-                    ex.printStackTrace();
+            var ctx = new Context(engine, bsEnv);
-                }
+
-            }
+            engine.pushMsg(
-            if (exited[0]) debugTask.interrupt();
+                false, ctx,
-        });
+                new Filename("jscript", "bootstrap.js"), Reading.resourceToString("js/bootstrap.js"), null,
-        reader.setDaemon(true);
+                tsEnv.global.get(ctx, "ts"), environment, new ArrayValue(null, Reading.resourceToString("js/lib.d.ts"))
-        reader.setName("STD Reader");
+            ).await();
-        reader.start();
+        }
-    }
+        catch (EngineException e) {
-}
+            Values.printError(e, "(while initializing TS)");
+        }
+    }
+
+    public static void main(String args[]) {
+        System.out.println(String.format("Running %s v%s by %s", Metadata.name(), Metadata.version(), Metadata.author()));
+
+        Main.args = args;
+        var reader = new Thread(Main::reader);
+
+        initEnv();
+        initEngine();
+
+        reader.setDaemon(true);
+        reader.setName("STD Reader");
+        reader.start();
+    }
+}

src/me/topchetoeu/jscript/Metadata.java

@@ -1,7 +1,20 @@
 package me.topchetoeu.jscript;
 
 public class Metadata {
-    public static final String VERSION = "${VERSION}";
+    private static final String VERSION = "${VERSION}";
-    public static final String AUTHOR = "${AUTHOR}";
+    private static final String AUTHOR = "${AUTHOR}";
-    public static final String NAME = "${NAME}";
+    private static final String NAME = "${NAME}";
+
+    public static String version() {
+        if (VERSION.equals("$" + "{VERSION}")) return "1337-devel";
+        else return VERSION;
+    }
+    public static String author() {
+        if (AUTHOR.equals("$" + "{AUTHOR}")) return "anonymous";
+        else return AUTHOR;
+    }
+    public static String name() {
+        if (NAME.equals("$" + "{NAME}")) return "some-product";
+        else return NAME;
+    }
 }

src/me/topchetoeu/jscript/Reading.java

@@ -15,22 +15,13 @@ public class Reading {
     }
 
     public static String streamToString(InputStream in) {
-        try {
+        try { return new String(in.readAllBytes()); }
-            StringBuilder out = new StringBuilder();
-            BufferedReader br = new BufferedReader(new InputStreamReader(in));
-
-            for(var line = br.readLine(); line != null; line = br.readLine()) {
-                out.append(line).append('\n');
-            }
-
-            br.close();
-            return out.toString();
-        }
         catch (Throwable e) { throw new UncheckedException(e); }
     }
+    public static InputStream resourceToStream(String name) {
+        return Reading.class.getResourceAsStream("/assets/" + name);
+    }
     public static String resourceToString(String name) {
-        var str = Main.class.getResourceAsStream("/me/topchetoeu/jscript/" + name);
+        return streamToString(resourceToStream(name));
-        if (str == null) return null;
-        return streamToString(str);
     }
 }

src/me/topchetoeu/jscript/compilation/CalculateResult.java

@@ -0,0 +1,21 @@
+package me.topchetoeu.jscript.compilation;
+
+import me.topchetoeu.jscript.engine.values.Values;
+
+public final class CalculateResult {
+    public final boolean exists;
+    public final Object value;
+
+    public final boolean isTruthy() {
+        return exists && Values.toBoolean(value);
+    }
+
+    public CalculateResult(Object value) {
+        this.exists = true;
+        this.value = value;
+    }
+    public CalculateResult() {
+        this.exists = false;
+        this.value = null;
+    }
+}

src/me/topchetoeu/jscript/compilation/CompileTarget.java

@@ -1,38 +1,66 @@
-package me.topchetoeu.jscript.compilation;
+package me.topchetoeu.jscript.compilation;
-
+
-import java.util.Map;
+import java.util.HashMap;
-import java.util.TreeSet;
+import java.util.Map;
-import java.util.Vector;
+import java.util.TreeSet;
-
+import java.util.Vector;
-import me.topchetoeu.jscript.Location;
+
-
+import me.topchetoeu.jscript.Location;
-public class CompileTarget {
+import me.topchetoeu.jscript.compilation.Instruction.BreakpointType;
-    public final Vector<Instruction> target = new Vector<>();
+import me.topchetoeu.jscript.engine.Environment;
-    public final Map<Long, FunctionBody> functions;
+import me.topchetoeu.jscript.engine.values.CodeFunction;
-    public final TreeSet<Location> breakpoints;
+
-
+public class CompileTarget {
-    public Instruction add(Instruction instr) {
+    public final Vector<Instruction> target = new Vector<>();
-        target.add(instr);
+    public final Map<Long, FunctionBody> functions;
-        return instr;
+    public final TreeSet<Location> breakpoints;
-    }
+    private final HashMap<Location, Instruction> bpToInstr = new HashMap<>();
-    public Instruction set(int i, Instruction instr) {
+
-        return target.set(i, instr);
+    public Instruction add(Instruction instr) {
-    }
+        target.add(instr);
-    public void setDebug(int i) {
+        return instr;
-        breakpoints.add(target.get(i).location);
+    }
-    }
+    public Instruction set(int i, Instruction instr) {
-    public void setDebug() {
+        return target.set(i, instr);
-        setDebug(target.size() - 1);
+    }
-    }
+    public void setDebug(int i, BreakpointType type) {
-    public Instruction get(int i) {
+        var instr = target.get(i);
-        return target.get(i);
+        instr.breakpoint = type;
-    }
+
-    public int size() { return target.size(); }
+        if (type == BreakpointType.NONE) {
-
+            breakpoints.remove(target.get(i).location);
-    public Instruction[] array() { return target.toArray(Instruction[]::new); }
+            bpToInstr.remove(instr.location, instr);
-
+        }
-    public CompileTarget(Map<Long, FunctionBody> functions, TreeSet<Location> breakpoints) {
+        else {
-        this.functions = functions;
+            breakpoints.add(target.get(i).location);
-        this.breakpoints = breakpoints;
+
-    }
+            var old = bpToInstr.put(instr.location, instr);
-}
+            if (old != null) old.breakpoint = BreakpointType.NONE;
+        }
+    }
+    public void setDebug(BreakpointType type) {
+        setDebug(target.size() - 1, type);
+    }
+    public Instruction get(int i) {
+        return target.get(i);
+    }
+    public int size() { return target.size(); }
+    public Location lastLoc(Location fallback) {
+        if (target.size() == 0) return fallback;
+        else return target.get(target.size() - 1).location;
+    }
+
+    public Instruction[] array() { return target.toArray(Instruction[]::new); }
+
+    public FunctionBody body() {
+        return functions.get(0l);
+    }
+    public CodeFunction func(Environment env) {
+        return new CodeFunction(env, "", body());
+    }
+
+    public CompileTarget(Map<Long, FunctionBody> functions, TreeSet<Location> breakpoints) {
+        this.functions = functions;
+        this.breakpoints = breakpoints;
+    }
+}

src/me/topchetoeu/jscript/compilation/CompoundStatement.java

@@ -1,68 +1,54 @@
 package me.topchetoeu.jscript.compilation;
 
+import java.util.List;
 import java.util.Vector;
 
 import me.topchetoeu.jscript.Location;
-import me.topchetoeu.jscript.compilation.control.ContinueStatement;
+import me.topchetoeu.jscript.compilation.Instruction.BreakpointType;
-import me.topchetoeu.jscript.compilation.control.ReturnStatement;
-import me.topchetoeu.jscript.compilation.control.ThrowStatement;
 import me.topchetoeu.jscript.compilation.values.FunctionStatement;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
 
 public class CompoundStatement extends Statement {
     public final Statement[] statements;
+    public final boolean separateFuncs;
     public Location end;
 
+    @Override public boolean pure() {
+        for (var stm : statements) {
+            if (!stm.pure()) return false;
+        }
+
+        return true;
+    }
+
     @Override
     public void declare(ScopeRecord varsScope) {
-        for (var stm : statements) {
+        for (var stm : statements) stm.declare(varsScope);
-            stm.declare(varsScope);
-        }
     }
 
     @Override
-    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute, BreakpointType type) {
-        for (var stm : statements) {
+        List<Statement> statements = new Vector<Statement>();
-            if (stm instanceof FunctionStatement) {
+        if (separateFuncs) for (var stm : this.statements) {
-                int start = target.size();
+            if (stm instanceof FunctionStatement && ((FunctionStatement)stm).statement) {
-                ((FunctionStatement)stm).compile(target, scope, null, true);
+                stm.compile(target, scope, false);
-                target.setDebug(start);
-                target.add(Instruction.discard());
             }
+            else statements.add(stm);
+        }
+        else statements = List.of(this.statements);
+
+        var polluted = false;
+
+        for (var i = 0; i < statements.size(); i++) {
+            var stm = statements.get(i);
+
+            if (i != statements.size() - 1) stm.compile(target, scope, false, BreakpointType.STEP_OVER);
+            else stm.compile(target, scope, polluted = pollute, BreakpointType.STEP_OVER);
         }
 
-        for (var i = 0; i < statements.length; i++) {
+        if (!polluted && pollute) {
-            var stm = statements[i];
+            target.add(Instruction.loadValue(loc(), null));
-
-            if (stm instanceof FunctionStatement) continue;
-            if (i != statements.length - 1) stm.compileWithDebug(target, scope, false);
-            else stm.compileWithDebug(target, scope, pollute);
         }
-
-        if (end != null) {
-            target.add(Instruction.nop().locate(end));
-            target.setDebug();
-        }
-    }
-
-    @Override
-    public Statement optimize() {
-        var res = new Vector<Statement>(statements.length);
-
-        for (var i = 0; i < statements.length; i++) {
-            var stm = statements[i].optimize();
-            if (i < statements.length - 1 && stm.pure()) continue;
-            res.add(stm);
-            if (
-                stm instanceof ContinueStatement ||
-                stm instanceof ReturnStatement ||
-                stm instanceof ThrowStatement ||
-                stm instanceof ContinueStatement
-            ) break;
-        }
-
-        if (res.size() == 1) return res.get(0);
-        else return new CompoundStatement(loc(), res.toArray(Statement[]::new));
     }
 
     public CompoundStatement setEnd(Location loc) {
@@ -70,8 +56,9 @@ public class CompoundStatement extends Statement {
         return this;
     }
 
-    public CompoundStatement(Location loc, Statement ...statements) {
+    public CompoundStatement(Location loc, boolean separateFuncs, Statement ...statements) {
         super(loc);
+        this.separateFuncs = separateFuncs;
         this.statements = statements;
     }
 }

src/me/topchetoeu/jscript/compilation/FunctionBody.java

@@ -3,13 +3,25 @@ package me.topchetoeu.jscript.compilation;
 public class FunctionBody {
     public final Instruction[] instructions;
     public final String[] captureNames, localNames;
+    public final int localsN, argsN;
 
-    public FunctionBody(Instruction[] instructions, String[] captureNames, String[] localNames) {
+    public FunctionBody(int localsN, int argsN, Instruction[] instructions, String[] captureNames, String[] localNames) {
+        this.argsN = argsN;
+        this.localsN = localsN;
         this.instructions = instructions;
         this.captureNames = captureNames;
         this.localNames = localNames;
     }
-    public FunctionBody(Instruction[] instructions) {
+    public FunctionBody(int localsN, int argsN, Instruction[] instructions) {
+        this.argsN = argsN;
+        this.localsN = localsN;
+        this.instructions = instructions;
+        this.captureNames = new String[0];
+        this.localNames = new String[0];
+    }
+    public FunctionBody(Instruction... instructions) {
+        this.argsN = 0;
+        this.localsN = 2;
         this.instructions = instructions;
         this.captureNames = new String[0];
         this.localNames = new String[0];

src/me/topchetoeu/jscript/compilation/Instruction.java

@@ -10,7 +10,8 @@ public class Instruction {
         THROW,
         THROW_SYNTAX,
         DELETE,
-        TRY,
+        TRY_START,
+        TRY_END,
         NOP,
 
         CALL,
@@ -33,7 +34,6 @@ public class Instruction {
         LOAD_REGEX,
 
         DUP,
-        MOVE,
 
         STORE_VAR,
         STORE_MEMBER,
@@ -45,51 +45,30 @@ public class Instruction {
 
         TYPEOF,
         OPERATION;
-        // TYPEOF,
+    }
-        // INSTANCEOF(true),
+    public static enum BreakpointType {
-        // IN(true),
+        NONE,
+        STEP_OVER,
+        STEP_IN;
 
-        // MULTIPLY(true),
+        public boolean shouldStepIn() {
-        // DIVIDE(true),
+            return this != NONE;
-        // MODULO(true),
+        }
-        // ADD(true),
+        public boolean shouldStepOver() {
-        // SUBTRACT(true),
+            return this == STEP_OVER;
-
+        }
-        // USHIFT_RIGHT(true),
-        // SHIFT_RIGHT(true),
-        // SHIFT_LEFT(true),
-
-        // GREATER(true),
-        // LESS(true),
-        // GREATER_EQUALS(true),
-        // LESS_EQUALS(true),
-        // LOOSE_EQUALS(true),
-        // LOOSE_NOT_EQUALS(true),
-        // EQUALS(true),
-        // NOT_EQUALS(true),
-
-        // AND(true),
-        // OR(true),
-        // XOR(true),
-
-        // NEG(true),
-        // POS(true),
-        // NOT(true),
-        // INVERSE(true);
-
-        // final boolean isOperation;
-
-        // private Type(boolean isOperation) {
-        //     this.isOperation = isOperation;
-        // }
-        // private Type() {
-        //     this(false);
-        // }
     }
 
     public final Type type;
     public final Object[] params;
     public Location location;
+    public BreakpointType breakpoint = BreakpointType.NONE;
+
+    public Instruction setDbgData(Instruction other) {
+        this.location = other.location;
+        this.breakpoint = other.breakpoint;
+        return this;
+    }
 
     public Instruction locate(Location loc) {
         this.location = loc;
@@ -129,26 +108,32 @@ public class Instruction {
         this.params = params;
     }
 
-    public static Instruction tryInstr(int n, int catchN, int finallyN) {
+    public static Instruction tryStart(Location loc, int catchStart, int finallyStart, int end) {
-        return new Instruction(null, Type.TRY, n, catchN, finallyN);
+        return new Instruction(loc, Type.TRY_START, catchStart, finallyStart, end);
     }
-    public static Instruction throwInstr() {
+    public static Instruction tryEnd(Location loc) {
-        return new Instruction(null, Type.THROW);
+        return new Instruction(loc, Type.TRY_END);
     }
-    public static Instruction throwSyntax(SyntaxException err) {
+    public static Instruction throwInstr(Location loc) {
-        return new Instruction(null, Type.THROW_SYNTAX, err.getMessage());
+        return new Instruction(loc, Type.THROW);
     }
-    public static Instruction delete() {
+    public static Instruction throwSyntax(Location loc, SyntaxException err) {
-        return new Instruction(null, Type.DELETE);
+        return new Instruction(loc, Type.THROW_SYNTAX, err.getMessage());
     }
-    public static Instruction ret() {
+    public static Instruction throwSyntax(Location loc, String err) {
-        return new Instruction(null, Type.RETURN);
+        return new Instruction(loc, Type.THROW_SYNTAX, err);
     }
-    public static Instruction debug() {
+    public static Instruction delete(Location loc) {
-        return new Instruction(null, Type.NOP, "debug");
+        return new Instruction(loc, Type.DELETE);
+    }
+    public static Instruction ret(Location loc) {
+        return new Instruction(loc, Type.RETURN);
+    }
+    public static Instruction debug(Location loc) {
+        return new Instruction(loc, Type.NOP, "debug");
     }
 
-    public static Instruction nop(Object ...params) {
+    public static Instruction nop(Location loc, Object ...params) {
         for (var param : params) {
             if (param instanceof String) continue;
             if (param instanceof Boolean) continue;
@@ -158,109 +143,104 @@ public class Instruction {
 
             throw new RuntimeException("NOP params may contain only strings, booleans, doubles, integers and nulls.");
         }
-        return new Instruction(null, Type.NOP, params);
+        return new Instruction(loc, Type.NOP, params);
     }
 
-    public static Instruction call(int argn) {
+    public static Instruction call(Location loc, int argn) {
-        return new Instruction(null, Type.CALL, argn);
+        return new Instruction(loc, Type.CALL, argn);
     }
-    public static Instruction callNew(int argn) {
+    public static Instruction callNew(Location loc, int argn) {
-        return new Instruction(null, Type.CALL_NEW, argn);
+        return new Instruction(loc, Type.CALL_NEW, argn);
     }
-    public static Instruction jmp(int offset) {
+    public static Instruction jmp(Location loc, int offset) {
-        return new Instruction(null, Type.JMP, offset);
+        return new Instruction(loc, Type.JMP, offset);
     }
-    public static Instruction jmpIf(int offset) {
+    public static Instruction jmpIf(Location loc, int offset) {
-        return new Instruction(null, Type.JMP_IF, offset);
+        return new Instruction(loc, Type.JMP_IF, offset);
     }
-    public static Instruction jmpIfNot(int offset) {
+    public static Instruction jmpIfNot(Location loc, int offset) {
-        return new Instruction(null, Type.JMP_IFN, offset);
+        return new Instruction(loc, Type.JMP_IFN, offset);
     }
 
-    public static Instruction loadValue(Object val) {
+    public static Instruction loadValue(Location loc, Object val) {
-        return new Instruction(null, Type.LOAD_VALUE, val);
+        return new Instruction(loc, Type.LOAD_VALUE, val);
     }
 
-    public static Instruction makeVar(String name) {
+    public static Instruction makeVar(Location loc, String name) {
-        return new Instruction(null, Type.MAKE_VAR, name);
+        return new Instruction(loc, Type.MAKE_VAR, name);
     }
-    public static Instruction loadVar(Object i) {
+    public static Instruction loadVar(Location loc, Object i) {
-        return new Instruction(null, Type.LOAD_VAR, i);
+        return new Instruction(loc, Type.LOAD_VAR, i);
     }
-    public static Instruction loadGlob() {
+    public static Instruction loadGlob(Location loc) {
-        return new Instruction(null, Type.LOAD_GLOB);
+        return new Instruction(loc, Type.LOAD_GLOB);
     }
-    public static Instruction loadMember() {
+    public static Instruction loadMember(Location loc) {
-        return new Instruction(null, Type.LOAD_MEMBER);
+        return new Instruction(loc, Type.LOAD_MEMBER);
     }
-    public static Instruction loadMember(Object key) {
+    public static Instruction loadMember(Location loc, Object key) {
         if (key instanceof Number) key = ((Number)key).doubleValue();
-        return new Instruction(null, Type.LOAD_VAL_MEMBER, key);
+        return new Instruction(loc, Type.LOAD_VAL_MEMBER, key);
     }
 
-    public static Instruction loadRegex(String pattern, String flags) {
+    public static Instruction loadRegex(Location loc, String pattern, String flags) {
-        return new Instruction(null, Type.LOAD_REGEX, pattern, flags);
+        return new Instruction(loc, Type.LOAD_REGEX, pattern, flags);
     }
-    public static Instruction loadFunc(long id, int varN, int len, int[] captures) {
+    public static Instruction loadFunc(Location loc, long id, int[] captures) {
-        var args = new Object[3 + captures.length];
+        var args = new Object[1 + captures.length];
         args[0] = id;
-        args[1] = varN;
+        for (var i = 0; i < captures.length; i++) args[i + 1] = captures[i];
-        args[2] = len;
+        return new Instruction(loc, Type.LOAD_FUNC, args);
-        for (var i = 0; i < captures.length; i++) args[i + 3] = captures[i];
-        return new Instruction(null, Type.LOAD_FUNC, args);
     }
-    public static Instruction loadObj() {
+    public static Instruction loadObj(Location loc) {
-        return new Instruction(null, Type.LOAD_OBJ);
+        return new Instruction(loc, Type.LOAD_OBJ);
     }
-    public static Instruction loadArr(int count) {
+    public static Instruction loadArr(Location loc, int count) {
-        return new Instruction(null, Type.LOAD_ARR, count);
+        return new Instruction(loc, Type.LOAD_ARR, count);
     }
-    public static Instruction dup() {
+    public static Instruction dup(Location loc) {
-        return new Instruction(null, Type.DUP, 0, 1);
+        return new Instruction(loc, Type.DUP, 1);
     }
-    public static Instruction dup(int count, int offset) {
+    public static Instruction dup(Location loc, int count) {
-        return new Instruction(null, Type.DUP, offset, count);
+        return new Instruction(loc, Type.DUP, count);
-    }
-    public static Instruction move(int count, int offset) {
-        return new Instruction(null, Type.MOVE, offset, count);
     }
 
-    public static Instruction storeSelfFunc(int i) {
+    public static Instruction storeSelfFunc(Location loc, int i) {
-        return new Instruction(null, Type.STORE_SELF_FUNC, i);
+        return new Instruction(loc, Type.STORE_SELF_FUNC, i);
     }
-    public static Instruction storeVar(Object i) {
+    public static Instruction storeVar(Location loc, Object i) {
-        return new Instruction(null, Type.STORE_VAR, i, false);
+        return new Instruction(loc, Type.STORE_VAR, i, false);
     }
-    public static Instruction storeVar(Object i, boolean keep) {
+    public static Instruction storeVar(Location loc, Object i, boolean keep) {
-        return new Instruction(null, Type.STORE_VAR, i, keep);
+        return new Instruction(loc, Type.STORE_VAR, i, keep);
     }
-    public static Instruction storeMember() {
+    public static Instruction storeMember(Location loc) {
-        return new Instruction(null, Type.STORE_MEMBER, false);
+        return new Instruction(loc, Type.STORE_MEMBER, false);
     }
-    public static Instruction storeMember(boolean keep) {
+    public static Instruction storeMember(Location loc, boolean keep) {
-        return new Instruction(null, Type.STORE_MEMBER, keep);
+        return new Instruction(loc, Type.STORE_MEMBER, keep);
     }
-    public static Instruction discard() {
+    public static Instruction discard(Location loc) {
-        return new Instruction(null, Type.DISCARD);
+        return new Instruction(loc, Type.DISCARD);
     }
 
-    public static Instruction typeof() {
+    public static Instruction typeof(Location loc) {
-        return new Instruction(null, Type.TYPEOF);
+        return new Instruction(loc, Type.TYPEOF);
     }
-    public static Instruction typeof(Object varName) {
+    public static Instruction typeof(Location loc, Object varName) {
-        return new Instruction(null, Type.TYPEOF, varName);
+        return new Instruction(loc, Type.TYPEOF, varName);
     }
 
-    public static Instruction keys(boolean forInFormat) {
+    public static Instruction keys(Location loc, boolean forInFormat) {
-        return new Instruction(null, Type.KEYS, forInFormat);
+        return new Instruction(loc, Type.KEYS, forInFormat);
     }
 
-    public static Instruction defProp() {
+    public static Instruction defProp(Location loc) {
-        return new Instruction(null, Type.DEF_PROP);
+        return new Instruction(loc, Type.DEF_PROP);
     }
 
-    public static Instruction operation(Operation op) {
+    public static Instruction operation(Location loc, Operation op) {
-        return new Instruction(null, Type.OPERATION, op);
+        return new Instruction(loc, Type.OPERATION, op);
     }
 
     @Override

src/me/topchetoeu/jscript/compilation/Statement.java

@@ -1,20 +1,26 @@
 package me.topchetoeu.jscript.compilation;
 
 import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.compilation.Instruction.BreakpointType;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
 
 public abstract class Statement {
     private Location _loc;
 
     public boolean pure() { return false; }
-    public abstract void compile(CompileTarget target, ScopeRecord scope, boolean pollute);
     public void declare(ScopeRecord varsScope) { }
-    public Statement optimize() { return this; }
 
-    public void compileWithDebug(CompileTarget target, ScopeRecord scope, boolean pollute) {
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute, BreakpointType type) {
         int start = target.size();
         compile(target, scope, pollute);
-        if (target.size() != start) target.setDebug(start);
+
+        if (target.size() != start) {
+            target.get(start).locate(loc());
+            target.setDebug(start, type);
+        }
+    }
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+        compile(target, scope, pollute, BreakpointType.NONE);
     }
 
     public Location loc() { return _loc; }

src/me/topchetoeu/jscript/compilation/ThrowSyntaxStatement.java

@@ -0,0 +1,18 @@
+package me.topchetoeu.jscript.compilation;
+
+import me.topchetoeu.jscript.engine.scope.ScopeRecord;
+import me.topchetoeu.jscript.exceptions.SyntaxException;
+
+public class ThrowSyntaxStatement extends Statement {
+    public final String name;
+
+    @Override
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+        target.add(Instruction.throwSyntax(loc(), name));
+    }
+
+    public ThrowSyntaxStatement(SyntaxException e) {
+        super(e.loc);
+        this.name = e.msg;
+    }
+}

src/me/topchetoeu/jscript/compilation/VariableDeclareStatement.java

@@ -3,6 +3,7 @@ package me.topchetoeu.jscript.compilation;
 import java.util.List;
 
 import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.compilation.Instruction.BreakpointType;
 import me.topchetoeu.jscript.compilation.values.FunctionStatement;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
 
@@ -32,23 +33,16 @@ public class VariableDeclareStatement extends Statement {
         for (var entry : values) {
             if (entry.name == null) continue;
             var key = scope.getKey(entry.name);
-            int start = target.size();
 
-            if (key instanceof String) target.add(Instruction.makeVar((String)key).locate(entry.location));
+            if (key instanceof String) target.add(Instruction.makeVar(entry.location, (String)key));
 
-            if (entry.value instanceof FunctionStatement) {
+            if (entry.value != null) {
-                ((FunctionStatement)entry.value).compile(target, scope, entry.name, false);
+                FunctionStatement.compileWithName(entry.value, target, scope, true, entry.name, BreakpointType.STEP_OVER);
-                target.add(Instruction.storeVar(key).locate(entry.location));
+                target.add(Instruction.storeVar(entry.location, key));
             }
-            else if (entry.value != null) {
-                entry.value.compile(target, scope, true);
-                target.add(Instruction.storeVar(key).locate(entry.location));
-            }
-
-            if (target.size() != start) target.setDebug(start);
         }
 
-        if (pollute) target.add(Instruction.loadValue(null).locate(loc()));
+        if (pollute) target.add(Instruction.loadValue(loc(), null));
     }
 
     public VariableDeclareStatement(Location loc, List<Pair> values) {

src/me/topchetoeu/jscript/compilation/control/BreakStatement.java

@@ -11,8 +11,8 @@ public class BreakStatement extends Statement {
 
     @Override
     public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
-        target.add(Instruction.nop("break", label).locate(loc()));
+        target.add(Instruction.nop(loc(), "break", label));
-        if (pollute) target.add(Instruction.loadValue(null).locate(loc()));
+        if (pollute) target.add(Instruction.loadValue(loc(), null));
     }
 
     public BreakStatement(Location loc, String label) {

src/me/topchetoeu/jscript/compilation/control/ContinueStatement.java

@@ -11,8 +11,8 @@ public class ContinueStatement extends Statement {
 
     @Override
     public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
-        target.add(Instruction.nop("cont", label).locate(loc()));
+        target.add(Instruction.nop(loc(), "cont", label));
-        if (pollute) target.add(Instruction.loadValue(null).locate(loc()));
+        if (pollute) target.add(Instruction.loadValue(loc(), null));
     }
 
     public ContinueStatement(Location loc, String label) {

src/me/topchetoeu/jscript/compilation/control/DebugStatement.java

@@ -9,8 +9,8 @@ import me.topchetoeu.jscript.engine.scope.ScopeRecord;
 public class DebugStatement extends Statement {
     @Override
     public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
-        target.add(Instruction.debug().locate(loc()));
+        target.add(Instruction.debug(loc()));
-        if (pollute) target.add(Instruction.loadValue(null).locate(loc()));
+        if (pollute) target.add(Instruction.loadValue(loc(), null));
     }
 
     public DebugStatement(Location loc) {

src/me/topchetoeu/jscript/compilation/control/DeleteStatement.java

@@ -15,8 +15,8 @@ public class DeleteStatement extends Statement {
         value.compile(target, scope, true);
         key.compile(target, scope, true);
 
-        target.add(Instruction.delete().locate(loc()));
+        target.add(Instruction.delete(loc()));
-        if (!pollute) target.add(Instruction.discard().locate(loc()));
+        if (pollute) target.add(Instruction.loadValue(loc(), true));
     }
 
     public DeleteStatement(Location loc, Statement key, Statement value) {

src/me/topchetoeu/jscript/compilation/control/DoWhileStatement.java

@@ -2,12 +2,10 @@ package me.topchetoeu.jscript.compilation.control;
 
 import me.topchetoeu.jscript.Location;
 import me.topchetoeu.jscript.compilation.CompileTarget;
-import me.topchetoeu.jscript.compilation.CompoundStatement;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
-import me.topchetoeu.jscript.compilation.values.ConstantStatement;
+import me.topchetoeu.jscript.compilation.Instruction.BreakpointType;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
-import me.topchetoeu.jscript.engine.values.Values;
 
 public class DoWhileStatement extends Statement {
     public final Statement condition, body;
@@ -20,54 +18,14 @@ public class DoWhileStatement extends Statement {
 
     @Override
     public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
-        if (condition instanceof ConstantStatement) {
-            int start = target.size();
-            body.compile(target, scope, false);
-            int end = target.size();
-            if (Values.toBoolean(((ConstantStatement)condition).value)) {
-                WhileStatement.replaceBreaks(target, label, start, end, end + 1, end + 1);
-            }
-            else {
-                target.add(Instruction.jmp(start - end).locate(loc()));
-                WhileStatement.replaceBreaks(target, label, start, end, start, end + 1);
-            }
-            if (pollute) target.add(Instruction.loadValue(null).locate(loc()));
-            return;
-        }
-
         int start = target.size();
-        body.compileWithDebug(target, scope, false);
+        body.compile(target, scope, false, BreakpointType.STEP_OVER);
         int mid = target.size();
-        condition.compile(target, scope, true);
+        condition.compile(target, scope, true, BreakpointType.STEP_OVER);
         int end = target.size();
 
         WhileStatement.replaceBreaks(target, label, start, mid - 1, mid, end + 1);
-        target.add(Instruction.jmpIf(start - end).locate(loc()));
+        target.add(Instruction.jmpIf(loc(), start - end));
-    }
-
-    @Override
-    public Statement optimize() {
-        var cond = condition.optimize();
-        var b = body.optimize();
-
-        if (b instanceof CompoundStatement) {
-            var comp = (CompoundStatement)b;
-            if (comp.statements.length > 0) {
-                var last = comp.statements[comp.statements.length - 1];
-                if (last instanceof ContinueStatement) comp.statements[comp.statements.length - 1] = new CompoundStatement(loc());
-                if (last instanceof BreakStatement) {
-                    comp.statements[comp.statements.length - 1] = new CompoundStatement(loc());
-                    return new CompoundStatement(loc());
-                }
-            }
-        }
-        else if (b instanceof ContinueStatement) {
-            b = new CompoundStatement(loc());
-        }
-        else if (b instanceof BreakStatement) return new CompoundStatement(loc());
-
-        if (b.pure()) return new DoWhileStatement(loc(), label, cond, new CompoundStatement(loc()));
-        else return new DoWhileStatement(loc(), label, cond, b);
     }
 
     public DoWhileStatement(Location loc, String label, Statement condition, Statement body) {

src/me/topchetoeu/jscript/compilation/control/ForInStatement.java

@@ -4,6 +4,7 @@ import me.topchetoeu.jscript.Location;
 import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
+import me.topchetoeu.jscript.compilation.Instruction.BreakpointType;
 import me.topchetoeu.jscript.engine.Operation;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
 
@@ -25,39 +26,38 @@ public class ForInStatement extends Statement {
         var key = scope.getKey(varName);
 
         int first = target.size();
-        if (key instanceof String) target.add(Instruction.makeVar((String)key));
+        if (key instanceof String) target.add(Instruction.makeVar(loc(), (String)key));
 
         if (varValue != null) {
             varValue.compile(target, scope, true);
-            target.add(Instruction.storeVar(scope.getKey(varName)));
+            target.add(Instruction.storeVar(loc(), scope.getKey(varName)));
         }
 
-        object.compileWithDebug(target, scope, true);
+        object.compile(target, scope, true, BreakpointType.STEP_OVER);
-        target.add(Instruction.keys(true));
+        target.add(Instruction.keys(loc(), true));
 
         int start = target.size();
-        target.add(Instruction.dup());
+        target.add(Instruction.dup(loc()));
-        target.add(Instruction.loadValue(null));
+        target.add(Instruction.loadValue(loc(), null));
-        target.add(Instruction.operation(Operation.EQUALS));
+        target.add(Instruction.operation(loc(), Operation.EQUALS));
         int mid = target.size();
-        target.add(Instruction.nop());
+        target.add(Instruction.nop(loc()));
 
-        target.add(Instruction.loadMember("value").locate(varLocation));
+        target.add(Instruction.loadMember(varLocation, "value"));
-        target.setDebug();
+        target.add(Instruction.storeVar(object.loc(), key));
-        target.add(Instruction.storeVar(key));
+        target.setDebug(BreakpointType.STEP_OVER);
 
-        body.compileWithDebug(target, scope, false);
+        body.compile(target, scope, false, BreakpointType.STEP_OVER);
 
         int end = target.size();
 
         WhileStatement.replaceBreaks(target, label, mid + 1, end, start, end + 1);
 
-        target.add(Instruction.jmp(start - end));
+        target.add(Instruction.jmp(loc(), start - end));
-        target.add(Instruction.discard());
+        target.add(Instruction.discard(loc()));
-        target.set(mid, Instruction.jmpIf(end - mid + 1));
+        target.set(mid, Instruction.jmpIf(loc(), end - mid + 1));
-        if (pollute) target.add(Instruction.loadValue(null));
+        if (pollute) target.add(Instruction.loadValue(loc(), null));
         target.get(first).locate(loc());
-        target.setDebug(first);
     }
 
     public ForInStatement(Location loc, Location varLocation, String label, boolean isDecl, String varName, Statement varValue, Statement object, Statement body) {

src/me/topchetoeu/jscript/compilation/control/ForStatement.java

@@ -2,12 +2,10 @@ package me.topchetoeu.jscript.compilation.control;
 
 import me.topchetoeu.jscript.Location;
 import me.topchetoeu.jscript.compilation.Statement;
+import me.topchetoeu.jscript.compilation.Instruction.BreakpointType;
 import me.topchetoeu.jscript.compilation.CompileTarget;
-import me.topchetoeu.jscript.compilation.CompoundStatement;
 import me.topchetoeu.jscript.compilation.Instruction;
-import me.topchetoeu.jscript.compilation.values.ConstantStatement;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
-import me.topchetoeu.jscript.engine.values.Values;
 
 public class ForStatement extends Statement {
     public final Statement declaration, assignment, condition, body;
@@ -20,58 +18,22 @@ public class ForStatement extends Statement {
     }
     @Override
     public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
-        declaration.compile(target, scope, false);
+        declaration.compile(target, scope, false, BreakpointType.STEP_OVER);
-
-        if (condition instanceof ConstantStatement) {
-            if (Values.toBoolean(((ConstantStatement)condition).value)) {
-                int start = target.size();
-                body.compile(target, scope, false);
-                int mid = target.size();
-                assignment.compileWithDebug(target, scope, false);
-                int end = target.size();
-                WhileStatement.replaceBreaks(target, label, start, mid, mid, end + 1);
-                target.add(Instruction.jmp(start - target.size()).locate(loc()));
-                if (pollute) target.add(Instruction.loadValue(null).locate(loc()));
-            }
-            return;
-        }
 
         int start = target.size();
-        condition.compile(target, scope, true);
+        condition.compile(target, scope, true, BreakpointType.STEP_OVER);
         int mid = target.size();
-        target.add(Instruction.nop());
+        target.add(Instruction.nop(null));
-        body.compile(target, scope, false);
+        body.compile(target, scope, false, BreakpointType.STEP_OVER);
         int beforeAssign = target.size();
-        assignment.compileWithDebug(target, scope, false);
+        assignment.compile(target, scope, false, BreakpointType.STEP_OVER);
         int end = target.size();
 
         WhileStatement.replaceBreaks(target, label, mid + 1, end, beforeAssign, end + 1);
 
-        target.add(Instruction.jmp(start - end).locate(loc()));
+        target.add(Instruction.jmp(loc(), start - end));
-        target.set(mid, Instruction.jmpIfNot(end - mid + 1).locate(loc()));
+        target.set(mid, Instruction.jmpIfNot(loc(), end - mid + 1));
-        if (pollute) target.add(Instruction.loadValue(null).locate(loc()));
+        if (pollute) target.add(Instruction.loadValue(loc(), null));
-    }
-    @Override
-    public Statement optimize() {
-        var decl = declaration.optimize();
-        var asgn = assignment.optimize();
-        var cond = condition.optimize();
-        var b = body.optimize();
-
-        if (asgn.pure()) {
-            if (decl.pure()) return new WhileStatement(loc(), label, cond, b).optimize();
-            else return new CompoundStatement(loc(),
-                decl, new WhileStatement(loc(), label, cond, b)
-            ).optimize();
-        }
-
-        else if (b instanceof ContinueStatement) return new CompoundStatement(loc(),
-            decl, new WhileStatement(loc(), label, cond, new CompoundStatement(loc(), b, asgn))
-        );
-        else if (b instanceof BreakStatement) return decl;
-
-        if (b.pure()) return new ForStatement(loc(), label, decl, cond, asgn, new CompoundStatement(null));
-        else return new ForStatement(loc(), label, decl, cond, asgn, b);
     }
 
     public ForStatement(Location loc, String label, Statement declaration, Statement condition, Statement assignment, Statement body) {
@@ -82,14 +44,4 @@ public class ForStatement extends Statement {
         this.assignment = assignment;
         this.body = body;
     }
-
-    public static CompoundStatement ofFor(Location loc, String label, Statement declaration, Statement condition, Statement increment, Statement body) {
-        return new CompoundStatement(loc,
-            declaration,
-            new WhileStatement(loc, label, condition, new CompoundStatement(loc,
-                body,
-                increment
-            ))
-        );
-    }
 }

src/me/topchetoeu/jscript/compilation/control/IfStatement.java

@@ -2,13 +2,10 @@ package me.topchetoeu.jscript.compilation.control;
 
 import me.topchetoeu.jscript.Location;
 import me.topchetoeu.jscript.compilation.CompileTarget;
-import me.topchetoeu.jscript.compilation.CompoundStatement;
-import me.topchetoeu.jscript.compilation.DiscardStatement;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
-import me.topchetoeu.jscript.compilation.values.ConstantStatement;
+import me.topchetoeu.jscript.compilation.Instruction.BreakpointType;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
-import me.topchetoeu.jscript.engine.values.Values;
 
 public class IfStatement extends Statement {
     public final Statement condition, body, elseBody;
@@ -19,53 +16,31 @@ public class IfStatement extends Statement {
         if (elseBody != null) elseBody.declare(globScope);
     }
 
-    @Override
+    @Override public void compile(CompileTarget target, ScopeRecord scope, boolean pollute, BreakpointType breakpoint) {
-    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+        condition.compile(target, scope, true, breakpoint);
-        if (condition instanceof ConstantStatement) {
-            if (Values.not(((ConstantStatement)condition).value)) {
-                if (elseBody != null) elseBody.compileWithDebug(target, scope, pollute);
-            }
-            else {
-                body.compileWithDebug(target, scope, pollute);
-            }
-
-            return;
-        }
-
-        condition.compile(target, scope, true);
 
         if (elseBody == null) {
             int i = target.size();
-            target.add(Instruction.nop());
+            target.add(Instruction.nop(null));
-            body.compileWithDebug(target, scope, pollute);
+            body.compile(target, scope, pollute, breakpoint);
             int endI = target.size();
-            target.set(i, Instruction.jmpIfNot(endI - i).locate(loc()));
+            target.set(i, Instruction.jmpIfNot(loc(), endI - i));
         }
         else {
             int start = target.size();
-            target.add(Instruction.nop());
+            target.add(Instruction.nop(null));
-            body.compileWithDebug(target, scope, pollute);
+            body.compile(target, scope, pollute, breakpoint);
-            target.add(Instruction.nop());
+            target.add(Instruction.nop(null));
             int mid = target.size();
-            elseBody.compileWithDebug(target, scope, pollute);
+            elseBody.compile(target, scope, pollute, breakpoint);
             int end = target.size();
 
-            target.set(start, Instruction.jmpIfNot(mid - start).locate(loc()));
+            target.set(start, Instruction.jmpIfNot(loc(), mid - start));
-            target.set(mid - 1, Instruction.jmp(end - mid + 1).locate(loc()));
+            target.set(mid - 1, Instruction.jmp(loc(), end - mid + 1));
         }
     }
-    
+    @Override public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
-    @Override
+        compile(target, scope, pollute, BreakpointType.STEP_IN);
-    public Statement optimize() {
-        var cond = condition.optimize();
-        var b = body.optimize();
-        var e = elseBody == null ? null : elseBody.optimize();
-
-        if (b.pure()) b = new CompoundStatement(null);
-        if (e != null && e.pure()) e = null;
-
-        if (b.pure() && e == null) return new DiscardStatement(loc(), cond).optimize();
-        else return new IfStatement(loc(), cond, b, e);
     }
 
     public IfStatement(Location loc, Statement condition, Statement body, Statement elseBody) {

src/me/topchetoeu/jscript/compilation/control/ReturnStatement.java

@@ -11,9 +11,9 @@ public class ReturnStatement extends Statement {
 
     @Override
     public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
-        if (value == null) target.add(Instruction.loadValue(null).locate(loc()));
+        if (value == null) target.add(Instruction.loadValue(loc(), null));
         else value.compile(target, scope, true);
-        target.add(Instruction.ret().locate(loc()));
+        target.add(Instruction.ret(loc()));
     }
 
     public ReturnStatement(Location loc, Statement value) {

src/me/topchetoeu/jscript/compilation/control/SwitchStatement.java

@@ -6,6 +6,7 @@ import me.topchetoeu.jscript.Location;
 import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
+import me.topchetoeu.jscript.compilation.Instruction.BreakpointType;
 import me.topchetoeu.jscript.compilation.Instruction.Type;
 import me.topchetoeu.jscript.engine.Operation;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
@@ -33,46 +34,47 @@ public class SwitchStatement extends Statement {
 
     @Override
     public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
-        var caseMap = new HashMap<Integer, Integer>();
+        var caseToStatement = new HashMap<Integer, Integer>();
-        var stmIndexMap = new HashMap<Integer, Integer>();
+        var statementToIndex = new HashMap<Integer, Integer>();
 
-        value.compile(target, scope, true);
+        value.compile(target, scope, true, BreakpointType.STEP_OVER);
 
         for (var ccase : cases) {
-            target.add(Instruction.dup().locate(loc()));
+            target.add(Instruction.dup(loc()));
             ccase.value.compile(target, scope, true);
-            target.add(Instruction.operation(Operation.EQUALS).locate(loc()));
+            target.add(Instruction.operation(loc(), Operation.EQUALS));
-            caseMap.put(target.size(), ccase.statementI);
+            caseToStatement.put(target.size(), ccase.statementI);
-            target.add(Instruction.nop().locate(ccase.value.loc()));
+            target.add(Instruction.nop(null));
         }
 
         int start = target.size();
 
-        target.add(Instruction.nop());
+        target.add(Instruction.nop(null));
 
         for (var stm : body) {
-            stmIndexMap.put(stmIndexMap.size(), target.size());
+            statementToIndex.put(statementToIndex.size(), target.size());
-            stm.compileWithDebug(target, scope, false);
+            stm.compile(target, scope, false, BreakpointType.STEP_OVER);
         }
 
-        if (defaultI < 0 || defaultI >= body.length) target.set(start, Instruction.jmp(target.size() - start).locate(loc()));
+        int end = target.size();
-        else target.set(start, Instruction.jmp(stmIndexMap.get(defaultI) - start)).locate(loc());
+        target.add(Instruction.discard(loc()));
+        if (pollute) target.add(Instruction.loadValue(loc(), null));
 
-        for (int i = start; i < target.size(); i++) {
+        if (defaultI < 0 || defaultI >= body.length) target.set(start, Instruction.jmp(loc(), end - start));
+        else target.set(start, Instruction.jmp(loc(), statementToIndex.get(defaultI) - start));
+
+        for (int i = start; i < end; i++) {
             var instr = target.get(i);
             if (instr.type == Type.NOP && instr.is(0, "break") && instr.get(1) == null) {
-                target.set(i, Instruction.jmp(target.size() - i).locate(instr.location));
+                target.set(i, Instruction.jmp(loc(), end - i).locate(instr.location));
             }
         }
-        for (var el : caseMap.entrySet()) {
+        for (var el : caseToStatement.entrySet()) {
-            var loc = target.get(el.getKey()).location;
+            var i = statementToIndex.get(el.getValue());
-            var i = stmIndexMap.get(el.getValue());
+            if (i == null) i = end;
-            if (i == null) i = target.size();
+            target.set(el.getKey(), Instruction.jmpIf(loc(), i - el.getKey()));
-            target.set(el.getKey(), Instruction.jmpIf(i - el.getKey()).locate(loc));
-            target.setDebug(el.getKey());
         }
 
-        target.add(Instruction.discard().locate(loc()));
     }
 
     public SwitchStatement(Location loc, Statement value, int defaultI, SwitchCase[] cases, Statement[] body) {

src/me/topchetoeu/jscript/compilation/control/ThrowStatement.java

@@ -12,7 +12,7 @@ public class ThrowStatement extends Statement {
     @Override
     public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
         value.compile(target, scope, true);
-        target.add(Instruction.throwInstr().locate(loc()));
+        target.add(Instruction.throwInstr(loc()));
     }
 
     public ThrowStatement(Location loc, Statement value) {

src/me/topchetoeu/jscript/compilation/control/TryStatement.java

@@ -4,6 +4,7 @@ import me.topchetoeu.jscript.Location;
 import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
+import me.topchetoeu.jscript.compilation.Instruction.BreakpointType;
 import me.topchetoeu.jscript.engine.scope.GlobalScope;
 import me.topchetoeu.jscript.engine.scope.LocalScopeRecord;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
@@ -22,31 +23,32 @@ public class TryStatement extends Statement {
     }
 
     @Override
-    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute, BreakpointType bpt) {
-        target.add(Instruction.nop());
+        target.add(Instruction.nop(null));
 
-        int start = target.size(), tryN, catchN = -1, finN = -1;
+        int start = target.size(), catchStart = -1, finallyStart = -1;
 
         tryBody.compile(target, scope, false);
-        tryN = target.size() - start;
+        target.add(Instruction.tryEnd(loc()));
 
         if (catchBody != null) {
-            int tmp = target.size();
+            catchStart = target.size() - start;
             var local = scope instanceof GlobalScope ? scope.child() : (LocalScopeRecord)scope;
             local.define(name, true);
             catchBody.compile(target, scope, false);
             local.undefine();
-            catchN = target.size() - tmp;
+            target.add(Instruction.tryEnd(loc()));
         }
 
         if (finallyBody != null) {
-            int tmp = target.size();
+            finallyStart = target.size() - start;
             finallyBody.compile(target, scope, false);
-            finN = target.size() - tmp;
+            target.add(Instruction.tryEnd(loc()));
         }
 
-        target.set(start - 1, Instruction.tryInstr(tryN, catchN, finN).locate(loc()));
+        target.set(start - 1, Instruction.tryStart(loc(), catchStart, finallyStart, target.size() - start));
-        if (pollute) target.add(Instruction.loadValue(null).locate(loc()));
+        target.setDebug(start - 1, BreakpointType.STEP_OVER);
+        if (pollute) target.add(Instruction.loadValue(loc(), null));
     }
 
     public TryStatement(Location loc, Statement tryBody, Statement catchBody, Statement finallyBody, String name) {

src/me/topchetoeu/jscript/compilation/control/WhileStatement.java

@@ -3,13 +3,10 @@ package me.topchetoeu.jscript.compilation.control;
 import me.topchetoeu.jscript.Location;
 import me.topchetoeu.jscript.compilation.Statement;
 import me.topchetoeu.jscript.compilation.CompileTarget;
-import me.topchetoeu.jscript.compilation.CompoundStatement;
-import me.topchetoeu.jscript.compilation.DiscardStatement;
 import me.topchetoeu.jscript.compilation.Instruction;
+import me.topchetoeu.jscript.compilation.Instruction.BreakpointType;
 import me.topchetoeu.jscript.compilation.Instruction.Type;
-import me.topchetoeu.jscript.compilation.values.ConstantStatement;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
-import me.topchetoeu.jscript.engine.values.Values;
 
 public class WhileStatement extends Statement {
     public final Statement condition, body;
@@ -21,43 +18,19 @@ public class WhileStatement extends Statement {
     }
     @Override
     public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
-        if (condition instanceof ConstantStatement) {
-            if (Values.toBoolean(((ConstantStatement)condition).value)) {
-                int start = target.size();
-                body.compile(target, scope, false);
-                int end = target.size();
-                replaceBreaks(target, label, start, end, start, end + 1);
-                target.add(Instruction.jmp(start - target.size()).locate(loc()));
-                return;
-            }
-        }
-
         int start = target.size();
         condition.compile(target, scope, true);
         int mid = target.size();
-        target.add(Instruction.nop());
+        target.add(Instruction.nop(null));
-        body.compile(target, scope, false);
+        body.compile(target, scope, false, BreakpointType.STEP_OVER);
 
         int end = target.size();
 
         replaceBreaks(target, label, mid + 1, end, start, end + 1);
 
-        target.add(Instruction.jmp(start - end).locate(loc()));
+        target.add(Instruction.jmp(loc(), start - end));
-        target.set(mid, Instruction.jmpIfNot(end - mid + 1).locate(loc()));
+        target.set(mid, Instruction.jmpIfNot(loc(), end - mid + 1));
-        if (pollute) target.add(Instruction.loadValue(null).locate(loc()));
+        if (pollute) target.add(Instruction.loadValue(loc(), null));
-    }
-    @Override
-    public Statement optimize() {
-        var cond = condition.optimize();
-        var b = body.optimize();
-
-        if (b instanceof ContinueStatement) {
-            b = new CompoundStatement(loc());
-        }
-        else if (b instanceof BreakStatement) return new DiscardStatement(loc(), cond).optimize();
-
-        if (b.pure()) return new WhileStatement(loc(), label, cond, new CompoundStatement(null));
-        else return new WhileStatement(loc(), label, cond, b);
     }
 
     public WhileStatement(Location loc, String label, Statement condition, Statement body) {
@@ -71,23 +44,11 @@ public class WhileStatement extends Statement {
         for (int i = start; i < end; i++) {
             var instr = target.get(i);
             if (instr.type == Type.NOP && instr.is(0, "cont") && (instr.get(1) == null || instr.is(1, label))) {
-                target.set(i, Instruction.jmp(continuePoint - i));
+                target.set(i, Instruction.jmp(instr.location, continuePoint - i).setDbgData(target.get(i)));
-                target.get(i).location = instr.location;
             }
             if (instr.type == Type.NOP && instr.is(0, "break") && (instr.get(1) == null || instr.is(1, label))) {
-                target.set(i, Instruction.jmp(breakPoint - i));
+                target.set(i, Instruction.jmp(instr.location, breakPoint - i).setDbgData(target.get(i)));
-                target.get(i).location = instr.location;
             }
         }
     }
-
-    // public static CompoundStatement ofFor(Location loc, String label, Statement declaration, Statement condition, Statement increment, Statement body) {
-    //     return new CompoundStatement(loc,
-    //         declaration,
-    //         new WhileStatement(loc, label, condition, new CompoundStatement(loc,
-    //             body,
-    //             increment
-    //         ))
-    //     );
-    // }
 }

src/me/topchetoeu/jscript/compilation/values/ArrayStatement.java

@@ -1,35 +1,41 @@
-package me.topchetoeu.jscript.compilation.control;
+package me.topchetoeu.jscript.compilation.values;
-
+
-import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.Location;
-import me.topchetoeu.jscript.compilation.CompileTarget;
+import me.topchetoeu.jscript.compilation.CompileTarget;
-import me.topchetoeu.jscript.compilation.Instruction;
+import me.topchetoeu.jscript.compilation.Instruction;
-import me.topchetoeu.jscript.compilation.Statement;
+import me.topchetoeu.jscript.compilation.Statement;
-import me.topchetoeu.jscript.engine.scope.ScopeRecord;
+import me.topchetoeu.jscript.engine.scope.ScopeRecord;
-
+
-public class ArrayStatement extends Statement {
+public class ArrayStatement extends Statement {
-    public final Statement[] statements;
+    public final Statement[] statements;
-
+
-    @Override
+    @Override public boolean pure() {
-    public boolean pure() { return true; }
+        for (var stm : statements) {
-
+            if (!stm.pure()) return false;
-    @Override
+        }
-    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+
-        target.add(Instruction.loadArr(statements.length).locate(loc()));
+        return true;
-        var i = 0;
+    }
-        for (var el : statements) {
+
-            if (el != null) {
+    @Override
-                target.add(Instruction.dup().locate(loc()));
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
-                target.add(Instruction.loadValue(i).locate(loc()));
+        target.add(Instruction.loadArr(loc(), statements.length));
-                el.compile(target, scope, true);
+
-                target.add(Instruction.storeMember().locate(loc()));
+        for (var i = 0; i < statements.length; i++) {
-            }
+            var el = statements[i];
-            i++;
+            if (el != null) {
-        }
+                target.add(Instruction.dup(loc()));
-        if (!pollute) target.add(Instruction.discard().locate(loc()));
+                target.add(Instruction.loadValue(loc(), i));
-    }
+                el.compile(target, scope, true);
-
+                target.add(Instruction.storeMember(loc()));
-    public ArrayStatement(Location loc, Statement[] statements) {
+            }
-        super(loc);
+        }
-        this.statements = statements;
+
-    }
+        if (!pollute) target.add(Instruction.discard(loc()));
-}
+    }
+
+    public ArrayStatement(Location loc, Statement[] statements) {
+        super(loc);
+        this.statements = statements;
+    }
+}

src/me/topchetoeu/jscript/compilation/values/CallStatement.java

@@ -4,36 +4,47 @@ import me.topchetoeu.jscript.Location;
 import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
+import me.topchetoeu.jscript.compilation.Instruction.BreakpointType;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
 
 public class CallStatement extends Statement {
     public final Statement func;
     public final Statement[] args;
+    public final boolean isNew;
 
     @Override
-    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute, BreakpointType type) {
-        if (func instanceof IndexStatement) {
+        if (isNew) func.compile(target, scope, true);
+        else if (func instanceof IndexStatement) {
             ((IndexStatement)func).compile(target, scope, true, true);
         }
         else {
-            target.add(Instruction.loadValue(null).locate(loc()));
+            target.add(Instruction.loadValue(loc(), null));
             func.compile(target, scope, true);
         }
 
         for (var arg : args) arg.compile(target, scope, true);
 
-        target.add(Instruction.call(args.length).locate(loc()));
+        if (isNew) target.add(Instruction.callNew(loc(), args.length));
-        target.setDebug();
+        else target.add(Instruction.call(loc(), args.length));
-        if (!pollute) target.add(Instruction.discard().locate(loc()));
+        target.setDebug(type);
+
+        if (!pollute) target.add(Instruction.discard(loc()));
+    }
+    @Override
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+        compile(target, scope, pollute, BreakpointType.STEP_IN);
     }
 
-    public CallStatement(Location loc, Statement func, Statement ...args) {
+    public CallStatement(Location loc, boolean isNew, Statement func, Statement ...args) {
         super(loc);
+        this.isNew = isNew;
         this.func = func;
         this.args = args;
     }
-    public CallStatement(Location loc, Statement obj, Object key, Statement ...args) {
+    public CallStatement(Location loc, boolean isNew, Statement obj, Object key, Statement ...args) {
         super(loc);
+        this.isNew = isNew;
         this.func = new IndexStatement(loc, obj, new ConstantStatement(loc, key));
         this.args = args;
     }

src/me/topchetoeu/jscript/compilation/values/ChangeStatement.java

@@ -16,10 +16,10 @@ public class ChangeStatement extends Statement {
     @Override
     public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
         value.toAssign(new ConstantStatement(loc(), -addAmount), Operation.SUBTRACT).compile(target, scope, true);
-        if (!pollute) target.add(Instruction.discard().locate(loc()));
+        if (!pollute) target.add(Instruction.discard(loc()));
         else if (postfix) {
-            target.add(Instruction.loadValue(addAmount));
+            target.add(Instruction.loadValue(loc(), addAmount));
-            target.add(Instruction.operation(Operation.SUBTRACT));
+            target.add(Instruction.operation(loc(), Operation.SUBTRACT));
         }
     }
 

src/me/topchetoeu/jscript/compilation/values/CommaStatement.java

@@ -1,38 +0,0 @@
-package me.topchetoeu.jscript.compilation.values;
-
-import java.util.Vector;
-
-import me.topchetoeu.jscript.Location;
-import me.topchetoeu.jscript.compilation.CompileTarget;
-import me.topchetoeu.jscript.compilation.Statement;
-import me.topchetoeu.jscript.engine.scope.ScopeRecord;
-
-public class CommaStatement extends Statement {
-    public final Statement[] values;
-
-    @Override
-    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
-        for (var i = 0; i < values.length; i++) {
-            values[i].compile(target, scope, i == values.length - 1 && pollute);
-        }
-    }
-    
-    @Override
-    public Statement optimize() {
-        var res = new Vector<Statement>(values.length);
-
-        for (var i = 0; i < values.length; i++) {
-            var stm = values[i].optimize();
-            if (i < values.length - 1 && stm.pure()) continue;
-            res.add(stm);
-        }
-
-        if (res.size() == 1) return res.get(0);
-        else return new CommaStatement(loc(), res.toArray(Statement[]::new));
-    }
-
-    public CommaStatement(Location loc, Statement ...args) {
-        super(loc);
-        this.values = args;
-    }
-}

src/me/topchetoeu/jscript/compilation/values/ConstantStatement.java

@@ -9,12 +9,11 @@ import me.topchetoeu.jscript.engine.scope.ScopeRecord;
 public class ConstantStatement extends Statement {
     public final Object value;
 
-    @Override
+    @Override public boolean pure() { return true; }
-    public boolean pure() { return true; }
 
     @Override
     public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
-        if (pollute) target.add(Instruction.loadValue(value).locate(loc()));
+        if (pollute) target.add(Instruction.loadValue(loc(), value));
     }
 
     public ConstantStatement(Location loc, Object val) {

src/me/topchetoeu/jscript/compilation/values/DiscardStatement.java

@@ -1,23 +1,20 @@
-package me.topchetoeu.jscript.compilation;
+package me.topchetoeu.jscript.compilation.values;
 
 import me.topchetoeu.jscript.Location;
-import me.topchetoeu.jscript.compilation.values.ConstantStatement;
+import me.topchetoeu.jscript.compilation.CompileTarget;
+import me.topchetoeu.jscript.compilation.Instruction;
+import me.topchetoeu.jscript.compilation.Statement;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
 
 public class DiscardStatement extends Statement {
     public final Statement value;
 
+    @Override public boolean pure() { return value.pure(); }
+
     @Override
     public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
         value.compile(target, scope, false);
-        
+        if (pollute) target.add(Instruction.loadValue(loc(), null));
-    }
-    @Override
-    public Statement optimize() {
-        if (value == null) return this;
-        var val = value.optimize();
-        if (val.pure()) return new ConstantStatement(loc(), null);
-        else return new DiscardStatement(loc(), val);
     }
 
     public DiscardStatement(Location loc, Statement val) {

src/me/topchetoeu/jscript/compilation/values/FunctionStatement.java

@@ -8,23 +8,25 @@ import me.topchetoeu.jscript.compilation.CompoundStatement;
 import me.topchetoeu.jscript.compilation.FunctionBody;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
+import me.topchetoeu.jscript.compilation.Instruction.BreakpointType;
 import me.topchetoeu.jscript.compilation.Instruction.Type;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
 import me.topchetoeu.jscript.exceptions.SyntaxException;
 
 public class FunctionStatement extends Statement {
     public final CompoundStatement body;
-    public final String name;
+    public final String varName;
     public final String[] args;
+    public final boolean statement;
+    public final Location end;
 
     private static Random rand = new Random();
 
-    @Override
+    @Override public boolean pure() { return varName == null && statement; }
-    public boolean pure() { return name == null; }
 
     @Override
     public void declare(ScopeRecord scope) {
-        if (name != null) scope.define(name);
+        if (varName != null && statement) scope.define(varName);
     }
 
     public static void checkBreakAndCont(CompileTarget target, int start) {
@@ -40,73 +42,98 @@ public class FunctionStatement extends Statement {
         }
     }
 
-    public void compile(CompileTarget target, ScopeRecord scope, String name, boolean isStatement) {
+    private long compileBody(CompileTarget target, ScopeRecord scope, boolean polute, BreakpointType bp) {
         for (var i = 0; i < args.length; i++) {
             for (var j = 0; j < i; j++) {
-                if (args[i].equals(args[j])){
+                if (args[i].equals(args[j])) {
-                    target.add(Instruction.throwSyntax(new SyntaxException(loc(), "Duplicate parameter '" + args[i] + "'.")));
+                    throw new SyntaxException(loc(), "Duplicate parameter '" + args[i] + "'.");
-                    return;
                 }
             }
         }
-        var subscope = scope.child();
 
-        int start = target.size();
+        var id = rand.nextLong();
-        var funcTarget = new CompileTarget(target.functions, target.breakpoints);
+        var subscope = scope.child();
+        var subtarget = new CompileTarget(target.functions, target.breakpoints);
 
         subscope.define("this");
         var argsVar = subscope.define("arguments");
 
         if (args.length > 0) {
             for (var i = 0; i < args.length; i++) {
-                funcTarget.add(Instruction.loadVar(argsVar).locate(loc()));
+                subtarget.add(Instruction.loadVar(loc(), argsVar));
-                funcTarget.add(Instruction.loadMember(i).locate(loc()));
+                subtarget.add(Instruction.loadMember(loc(), i));
-                funcTarget.add(Instruction.storeVar(subscope.define(args[i])).locate(loc()));
+                subtarget.add(Instruction.storeVar(loc(), subscope.define(args[i])));
             }
         }
 
-        if (!isStatement && this.name != null) {
+        if (!statement && this.varName != null) {
-            funcTarget.add(Instruction.storeSelfFunc((int)subscope.define(this.name)));
+            subtarget.add(Instruction.storeSelfFunc(loc(), (int)subscope.define(this.varName)));
+            subtarget.setDebug(bp);
         }
 
         body.declare(subscope);
-        body.compile(funcTarget, subscope, false);
+        body.compile(subtarget, subscope, false);
-        funcTarget.add(Instruction.ret().locate(loc()));
+        subtarget.add(Instruction.ret(end));
-        checkBreakAndCont(funcTarget, start);
+        checkBreakAndCont(subtarget, 0);
 
-        var id = rand.nextLong();
+        if (polute) target.add(Instruction.loadFunc(loc(), id, subscope.getCaptures()));
+        target.functions.put(id, new FunctionBody(
+            subscope.localsCount(), args.length,
+            subtarget.array(), subscope.captures(), subscope.locals()
+        ));
 
-        target.add(Instruction.loadFunc(id, subscope.localsCount(), args.length, subscope.getCaptures()).locate(loc()));
+        return id;
-        target.functions.put(id, new FunctionBody(funcTarget.array(), subscope.captures(), subscope.locals()));
-
-        if (name == null) name = this.name;
-
-        if (name != null) {
-            target.add(Instruction.dup().locate(loc()));
-            target.add(Instruction.loadValue("name").locate(loc()));
-            target.add(Instruction.loadValue(name).locate(loc()));
-            target.add(Instruction.storeMember().locate(loc()));
-        }
-
-        if (this.name != null && isStatement) {
-            var key = scope.getKey(this.name);
-
-            if (key instanceof String) target.add(Instruction.makeVar((String)key).locate(loc()));
-            target.add(Instruction.storeVar(scope.getKey(this.name), false).locate(loc()));
-        }
-
-    }
-    @Override
-    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
-        compile(target, scope, null, false);
-        if (!pollute) target.add(Instruction.discard().locate(loc()));
     }
 
-    public FunctionStatement(Location loc, String name, String[] args, CompoundStatement body) {
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute, String name, BreakpointType bp) {
+        if (this.varName != null) name = this.varName;
+
+        var hasVar = this.varName != null && statement;
+        var hasName = name != null;
+
+        compileBody(target, scope, pollute || hasVar || hasName, bp);
+
+        if (hasName) {
+            if (pollute || hasVar) target.add(Instruction.dup(loc()));
+            target.add(Instruction.loadValue(loc(), "name"));
+            target.add(Instruction.loadValue(loc(), name));
+            target.add(Instruction.storeMember(loc()));
+        }
+
+        if (hasVar) {
+            var key = scope.getKey(this.varName);
+
+            if (key instanceof String) target.add(Instruction.makeVar(loc(), (String)key));
+            target.add(Instruction.storeVar(loc(), scope.getKey(this.varName), false));
+        }
+    }
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute, String name) {
+        compile(target, scope, pollute, name, BreakpointType.NONE);
+    }
+    @Override public void compile(CompileTarget target, ScopeRecord scope, boolean pollute, BreakpointType bp) {
+        compile(target, scope, pollute, (String)null, bp);
+    }
+    @Override public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+        compile(target, scope, pollute, (String)null, BreakpointType.NONE);
+    }
+
+    public FunctionStatement(Location loc, Location end, String varName, String[] args, boolean statement, CompoundStatement body) {
         super(loc);
-        this.name = name;
+
+        this.end = end;
+        this.varName = varName;
+        this.statement = statement;
 
         this.args = args;
         this.body = body;
     }
+
+    public static void compileWithName(Statement stm, CompileTarget target, ScopeRecord scope, boolean pollute, String name) {
+        if (stm instanceof FunctionStatement) ((FunctionStatement)stm).compile(target, scope, pollute, name);
+        else stm.compile(target, scope, pollute);
+    }
+    public static void compileWithName(Statement stm, CompileTarget target, ScopeRecord scope, boolean pollute, String name, BreakpointType bp) {
+        if (stm instanceof FunctionStatement) ((FunctionStatement)stm).compile(target, scope, pollute, name, bp);
+        else stm.compile(target, scope, pollute, bp);
+    }
 }

src/me/topchetoeu/jscript/compilation/values/GlobalThisStatement.java

@@ -7,12 +7,11 @@ import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
 
 public class GlobalThisStatement extends Statement {
-    @Override
+    @Override public boolean pure() { return true; }
-    public boolean pure() { return true; }
 
     @Override
     public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
-        if (pollute) target.add(Instruction.loadGlob().locate(loc()));
+        if (pollute) target.add(Instruction.loadGlob(loc()));
     }
 
     public GlobalThisStatement(Location loc) {

src/me/topchetoeu/jscript/compilation/values/IndexAssignStatement.java

@@ -4,6 +4,7 @@ import me.topchetoeu.jscript.Location;
 import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
+import me.topchetoeu.jscript.compilation.Instruction.BreakpointType;
 import me.topchetoeu.jscript.engine.Operation;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
 
@@ -18,22 +19,22 @@ public class IndexAssignStatement extends Statement {
         if (operation != null) {
             object.compile(target, scope, true);
             index.compile(target, scope, true);
-            target.add(Instruction.dup(2, 0).locate(loc()));
+            target.add(Instruction.dup(loc(), 2));
 
-            target.add(Instruction.loadMember().locate(loc()));
+            target.add(Instruction.loadMember(loc()));
             value.compile(target, scope, true);
-            target.add(Instruction.operation(operation).locate(loc()));
+            target.add(Instruction.operation(loc(), operation));
 
-            target.add(Instruction.storeMember(pollute).locate(loc()));
+            target.add(Instruction.storeMember(loc(), pollute));
-            target.setDebug();
+            target.setDebug(BreakpointType.STEP_IN);
         }
         else {
             object.compile(target, scope, true);
             index.compile(target, scope, true);
             value.compile(target, scope, true);
 
-            target.add(Instruction.storeMember(pollute).locate(loc()));
+            target.add(Instruction.storeMember(loc(), pollute));
-            target.setDebug();
+            target.setDebug(BreakpointType.STEP_IN);
         }
     }
 

src/me/topchetoeu/jscript/compilation/values/IndexStatement.java

@@ -5,6 +5,7 @@ import me.topchetoeu.jscript.compilation.AssignableStatement;
 import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
+import me.topchetoeu.jscript.compilation.Instruction.BreakpointType;
 import me.topchetoeu.jscript.engine.Operation;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
 
@@ -12,26 +13,23 @@ public class IndexStatement extends AssignableStatement {
     public final Statement object;
     public final Statement index;
 
-    @Override
-    public boolean pure() { return true; }
-
     @Override
     public Statement toAssign(Statement val, Operation operation) {
         return new IndexAssignStatement(loc(), object, index, val, operation);
     }
     public void compile(CompileTarget target, ScopeRecord scope, boolean dupObj, boolean pollute) {
         object.compile(target, scope, true);
-        if (dupObj) target.add(Instruction.dup().locate(loc()));
+        if (dupObj) target.add(Instruction.dup(loc()));
         if (index instanceof ConstantStatement) {
-            target.add(Instruction.loadMember(((ConstantStatement)index).value).locate(loc()));
+            target.add(Instruction.loadMember(loc(), ((ConstantStatement)index).value));
-            target.setDebug();
+            target.setDebug(BreakpointType.STEP_IN);
             return;
         }
 
         index.compile(target, scope, true);
-        target.add(Instruction.loadMember().locate(loc()));
+        target.add(Instruction.loadMember(loc()));
-        target.setDebug();
+        target.setDebug(BreakpointType.STEP_IN);
-        if (!pollute) target.add(Instruction.discard().locate(loc()));
+        if (!pollute) target.add(Instruction.discard(loc()));
     }
     @Override
     public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {

src/me/topchetoeu/jscript/compilation/values/LazyAndStatement.java

@@ -10,10 +10,7 @@ import me.topchetoeu.jscript.engine.values.Values;
 public class LazyAndStatement extends Statement {
     public final Statement first, second;
 
-    @Override
+    @Override public boolean pure() { return first.pure() && second.pure(); }
-    public boolean pure() {
-        return first.pure() && second.pure();
-    }
 
     @Override
     public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
@@ -26,12 +23,12 @@ public class LazyAndStatement extends Statement {
         }
 
         first.compile(target, scope, true);
-        if (pollute) target.add(Instruction.dup().locate(loc()));
+        if (pollute) target.add(Instruction.dup(loc()));
         int start = target.size();
-        target.add(Instruction.nop());
+        target.add(Instruction.nop(null));
-        if (pollute) target.add(Instruction.discard().locate(loc()));
+        if (pollute) target.add(Instruction.discard(loc()));
         second.compile(target, scope, pollute);
-        target.set(start, Instruction.jmpIfNot(target.size() - start).locate(loc()));
+        target.set(start, Instruction.jmpIfNot(loc(), target.size() - start));
     }
 
     public LazyAndStatement(Location loc, Statement first, Statement second) {

src/me/topchetoeu/jscript/compilation/values/LazyOrStatement.java

@@ -10,10 +10,7 @@ import me.topchetoeu.jscript.engine.values.Values;
 public class LazyOrStatement extends Statement {
     public final Statement first, second;
 
-    @Override
+    @Override public boolean pure() { return first.pure() && second.pure(); }
-    public boolean pure() {
-        return first.pure() && second.pure();
-    }
 
     @Override
     public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
@@ -26,12 +23,12 @@ public class LazyOrStatement extends Statement {
         }
 
         first.compile(target, scope, true);
-        if (pollute) target.add(Instruction.dup().locate(loc()));
+        if (pollute) target.add(Instruction.dup(loc()));
         int start = target.size();
-        target.add(Instruction.nop());
+        target.add(Instruction.nop(null));
-        if (pollute) target.add(Instruction.discard().locate(loc()));
+        if (pollute) target.add(Instruction.discard(loc()));
         second.compile(target, scope, pollute);
-        target.set(start, Instruction.jmpIf(target.size() - start).locate(loc()));
+        target.set(start, Instruction.jmpIf(loc(), target.size() - start));
     }
 
     public LazyOrStatement(Location loc, Statement first, Statement second) {

src/me/topchetoeu/jscript/compilation/values/NewStatement.java

@@ -1,28 +0,0 @@
-package me.topchetoeu.jscript.compilation.values;
-
-import me.topchetoeu.jscript.Location;
-import me.topchetoeu.jscript.compilation.CompileTarget;
-import me.topchetoeu.jscript.compilation.Instruction;
-import me.topchetoeu.jscript.compilation.Statement;
-import me.topchetoeu.jscript.engine.scope.ScopeRecord;
-
-public class NewStatement extends Statement {
-    public final Statement func;
-    public final Statement[] args;
-
-    @Override
-    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
-        func.compile(target, scope, true);
-
-        for (var arg : args) arg.compile(target, scope, true);
-
-        target.add(Instruction.callNew(args.length).locate(loc()));
-        target.setDebug();
-    }
-
-    public NewStatement(Location loc, Statement func, Statement ...args) {
-        super(loc);
-        this.func = func;
-        this.args = args;
-    }
-}

src/me/topchetoeu/jscript/compilation/values/ObjectStatement.java

@@ -14,17 +14,24 @@ public class ObjectStatement extends Statement {
     public final Map<Object, FunctionStatement> getters;
     public final Map<Object, FunctionStatement> setters;
 
+    @Override public boolean pure() {
+        for (var el : map.values()) {
+            if (!el.pure()) return false;
+        }
+
+        return true;
+    }
+
     @Override
     public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
-        target.add(Instruction.loadObj().locate(loc()));
+        target.add(Instruction.loadObj(loc()));
 
         for (var el : map.entrySet()) {
-            target.add(Instruction.dup().locate(loc()));
+            target.add(Instruction.dup(loc()));
-            target.add(Instruction.loadValue(el.getKey()).locate(loc()));
+            target.add(Instruction.loadValue(loc(), el.getKey()));
             var val = el.getValue();
-            if (val instanceof FunctionStatement) ((FunctionStatement)val).compile(target, scope, el.getKey().toString(), false);
+            FunctionStatement.compileWithName(val, target, scope, true, el.getKey().toString());
-            else val.compile(target, scope, true);
+            target.add(Instruction.storeMember(loc()));
-            target.add(Instruction.storeMember().locate(loc()));
         }
 
         var keys = new ArrayList<Object>();
@@ -32,19 +39,19 @@ public class ObjectStatement extends Statement {
         keys.addAll(setters.keySet());
 
         for (var key : keys) {
-            if (key instanceof String) target.add(Instruction.loadValue((String)key).locate(loc()));
+            if (key instanceof String) target.add(Instruction.loadValue(loc(), (String)key));
-            else target.add(Instruction.loadValue((Double)key).locate(loc()));
+            else target.add(Instruction.loadValue(loc(), (Double)key));
 
             if (getters.containsKey(key)) getters.get(key).compile(target, scope, true);
-            else target.add(Instruction.loadValue(null).locate(loc()));
+            else target.add(Instruction.loadValue(loc(), null));
 
             if (setters.containsKey(key)) setters.get(key).compile(target, scope, true);
-            else target.add(Instruction.loadValue(null).locate(loc()));
+            else target.add(Instruction.loadValue(loc(), null));
 
-            target.add(Instruction.defProp().locate(loc()));
+            target.add(Instruction.defProp(loc()));
         }
 
-        if (!pollute) target.add(Instruction.discard().locate(loc()));
+        if (!pollute) target.add(Instruction.discard(loc()));
     }
 
     public ObjectStatement(Location loc, Map<Object, Statement> map, Map<Object, FunctionStatement> getters, Map<Object, FunctionStatement> setters) {

src/me/topchetoeu/jscript/compilation/values/OperationStatement.java

@@ -4,57 +4,29 @@ import me.topchetoeu.jscript.Location;
 import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
-import me.topchetoeu.jscript.compilation.control.ThrowStatement;
 import me.topchetoeu.jscript.engine.Operation;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
-import me.topchetoeu.jscript.engine.values.Values;
-import me.topchetoeu.jscript.exceptions.EngineException;
 
 public class OperationStatement extends Statement {
     public final Statement[] args;
     public final Operation operation;
 
+    @Override public boolean pure() {
+        for (var el : args) {
+            if (!el.pure()) return false;
+        }
+
+        return true;
+    }
+
     @Override
     public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
         for (var arg : args) {
             arg.compile(target, scope, true);
         }
 
-        if (pollute) target.add(Instruction.operation(operation).locate(loc()));
+        if (pollute) target.add(Instruction.operation(loc(), operation));
-        else target.add(Instruction.discard().locate(loc()));
+        else target.add(Instruction.discard(loc()));
-    }
-
-    @Override
-    public boolean pure() {
-        for (var arg : args) {
-            if (!arg.pure()) return false;
-        }
-        return true;
-    }
-
-    @Override
-    public Statement optimize() {
-        var args = new Statement[this.args.length];
-        var allConst = true;
-
-        for (var i = 0; i < this.args.length; i++) {
-            args[i] = this.args[i].optimize();
-            if (!(args[i] instanceof ConstantStatement)) allConst = false;
-        }
-
-        if (allConst) {
-            var vals = new Object[this.args.length];
-
-            for (var i = 0; i < args.length; i++) {
-                vals[i] = ((ConstantStatement)args[i]).value;
-            }
-
-            try { return new ConstantStatement(loc(), Values.operation(null, operation, vals)); }
-            catch (EngineException e) { return new ThrowStatement(loc(), new ConstantStatement(loc(), e.value)); }
-        }
-
-        return new OperationStatement(loc(), operation, args);
-
     }
 
     public OperationStatement(Location loc, Operation operation, Statement ...args) {

src/me/topchetoeu/jscript/compilation/values/RegexStatement.java

@@ -9,13 +9,13 @@ import me.topchetoeu.jscript.engine.scope.ScopeRecord;
 public class RegexStatement extends Statement {
     public final String pattern, flags;
 
-    @Override
+    // Not really pure, since a function is called, but can be ignored.
-    public boolean pure() { return true; }
+    @Override public boolean pure() { return true; }
 
     @Override
     public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
-        target.add(Instruction.loadRegex(pattern, flags).locate(loc()));
+        target.add(Instruction.loadRegex(loc(), pattern, flags));
-        if (!pollute) target.add(Instruction.discard().locate(loc()));
+        if (!pollute) target.add(Instruction.discard(loc()));
     }
 
     public RegexStatement(Location loc, String pattern, String flags) {

src/me/topchetoeu/jscript/compilation/values/TypeofStatement.java

@@ -4,44 +4,26 @@ import me.topchetoeu.jscript.Location;
 import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
-import me.topchetoeu.jscript.compilation.control.ArrayStatement;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
-import me.topchetoeu.jscript.engine.values.Values;
 
 public class TypeofStatement extends Statement {
     public final Statement value;
 
-    @Override
+    // Not really pure, since a variable from the global scope could be accessed,
-    public boolean pure() { return true; }
+    // which could lead to code execution, that would get omitted
+    @Override public boolean pure() { return true; }
 
     @Override
     public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
         if (value instanceof VariableStatement) {
             var i = scope.getKey(((VariableStatement)value).name);
             if (i instanceof String) {
-                target.add(Instruction.typeof((String)i).locate(loc()));
+                target.add(Instruction.typeof(loc(), (String)i));
                 return;
             }
         }
         value.compile(target, scope, pollute);
-        target.add(Instruction.typeof().locate(loc()));
+        target.add(Instruction.typeof(loc()));
-    }
-
-    @Override
-    public Statement optimize() {
-        var val = value.optimize();
-
-        if (val instanceof ConstantStatement) {
-            return new ConstantStatement(loc(), Values.type(((ConstantStatement)val).value));
-        }
-        else if (
-            val instanceof ObjectStatement ||
-            val instanceof ArrayStatement ||
-            val instanceof GlobalThisStatement
-        ) return new ConstantStatement(loc(), "object");
-        else if(val instanceof FunctionStatement) return new ConstantStatement(loc(), "function");
-
-        return new TypeofStatement(loc(), val);
     }
 
     public TypeofStatement(Location loc, Statement value) {

src/me/topchetoeu/jscript/compilation/values/VariableAssignStatement.java

@@ -12,20 +12,20 @@ public class VariableAssignStatement extends Statement {
     public final Statement value;
     public final Operation operation;
 
+    @Override public boolean pure() { return false; }
+
     @Override
     public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
         var i = scope.getKey(name);
         if (operation != null) {
-            target.add(Instruction.loadVar(i).locate(loc()));
+            target.add(Instruction.loadVar(loc(), i));
-            if (value instanceof FunctionStatement) ((FunctionStatement)value).compile(target, scope, name, false);
+            FunctionStatement.compileWithName(value, target, scope, true, name);
-            else value.compile(target, scope, true);
+            target.add(Instruction.operation(loc(), operation));
-            target.add(Instruction.operation(operation).locate(loc()));
+            target.add(Instruction.storeVar(loc(), i, pollute));
-            target.add(Instruction.storeVar(i, pollute).locate(loc()));
         }
         else {
-            if (value instanceof FunctionStatement) ((FunctionStatement)value).compile(target, scope, name, false);
+            FunctionStatement.compileWithName(value, target, scope, true, name);
-            else value.compile(target, scope, true);
+            target.add(Instruction.storeVar(loc(), i, pollute));
-            target.add(Instruction.storeVar(i, pollute).locate(loc()));
         }
     }
 

src/me/topchetoeu/jscript/compilation/values/VariableIndexStatement.java

@@ -9,12 +9,11 @@ import me.topchetoeu.jscript.engine.scope.ScopeRecord;
 public class VariableIndexStatement extends Statement {
     public final int index;
 
-    @Override
+    @Override public boolean pure() { return true; }
-    public boolean pure() { return true; }
 
     @Override
     public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
-        if (pollute) target.add(Instruction.loadVar(index).locate(loc()));
+        if (pollute) target.add(Instruction.loadVar(loc(), index));
     }
 
     public VariableIndexStatement(Location loc, int i) {

src/me/topchetoeu/jscript/compilation/values/VariableStatement.java

@@ -11,8 +11,7 @@ import me.topchetoeu.jscript.engine.scope.ScopeRecord;
 public class VariableStatement extends AssignableStatement {
     public final String name;
 
-    @Override
+    @Override public boolean pure() { return false; }
-    public boolean pure() { return true; }
 
     @Override
     public Statement toAssign(Statement val, Operation operation) {
@@ -22,8 +21,8 @@ public class VariableStatement extends AssignableStatement {
     @Override
     public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
         var i = scope.getKey(name);
-        target.add(Instruction.loadVar(i).locate(loc()));
+        target.add(Instruction.loadVar(loc(), i));
-        if (!pollute) target.add(Instruction.discard().locate(loc()));
+        if (!pollute) target.add(Instruction.discard(loc()));
     }
 
     public VariableStatement(Location loc, String name) {

src/me/topchetoeu/jscript/compilation/values/VoidStatement.java

@@ -1,30 +0,0 @@
-package me.topchetoeu.jscript.compilation.values;
-
-import me.topchetoeu.jscript.Location;
-import me.topchetoeu.jscript.compilation.Statement;
-import me.topchetoeu.jscript.engine.scope.ScopeRecord;
-import me.topchetoeu.jscript.compilation.CompileTarget;
-import me.topchetoeu.jscript.compilation.Instruction;
-
-public class VoidStatement extends Statement {
-    public final Statement value;
-
-    @Override
-    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
-        if (value != null) value.compile(target, scope, false);
-        if (pollute) target.add(Instruction.loadValue(null).locate(loc()));
-    }
-
-    @Override
-    public Statement optimize() {
-        if (value == null) return this;
-        var val = value.optimize();
-        if (val.pure()) return new ConstantStatement(loc(), null);
-        else return new VoidStatement(loc(), val);
-    }
-
-    public VoidStatement(Location loc, Statement value) {
-        super(loc);
-        this.value = value;
-    }
-}

src/me/topchetoeu/jscript/engine/Context.java

@@ -1,59 +1,125 @@
-package me.topchetoeu.jscript.engine;
+package me.topchetoeu.jscript.engine;
-
+
-import java.util.Stack;
+import java.util.ArrayList;
-import java.util.TreeSet;
+import java.util.Arrays;
-
+import java.util.Collections;
-import me.topchetoeu.jscript.Filename;
+import java.util.List;
-import me.topchetoeu.jscript.Location;
+import java.util.Stack;
-import me.topchetoeu.jscript.engine.values.FunctionValue;
+import java.util.TreeSet;
-import me.topchetoeu.jscript.engine.values.ObjectValue;
+import java.util.stream.Collectors;
-import me.topchetoeu.jscript.engine.values.Values;
+
-import me.topchetoeu.jscript.parsing.Parsing;
+import me.topchetoeu.jscript.Filename;
-
+import me.topchetoeu.jscript.Location;
-public class Context {
+import me.topchetoeu.jscript.engine.frame.CodeFrame;
-    private final Stack<Environment> env = new Stack<>();
+import me.topchetoeu.jscript.engine.values.ArrayValue;
-    public final Data data;
+import me.topchetoeu.jscript.engine.values.FunctionValue;
-    public final Engine engine;
+import me.topchetoeu.jscript.engine.values.Values;
-
+import me.topchetoeu.jscript.exceptions.EngineException;
-    public Environment environment() {
+import me.topchetoeu.jscript.mapping.SourceMap;
-        return env.empty() ? null : env.peek();
+
-    }
+public class Context {
-
+    private final Stack<Environment> env = new Stack<>();
-    public Context pushEnv(Environment env) {
+    private final ArrayList<CodeFrame> frames = new ArrayList<>();
-        this.env.push(env);
+    public final Engine engine;
-        return this;
+
-    }
+    public Environment environment() {
-    public void popEnv() {
+        return env.empty() ? null : env.peek();
-        if (!env.empty()) this.env.pop();
+    }
-    }
+
-
+    public Context pushEnv(Environment env) {
-    public FunctionValue compile(Filename filename, String raw) {
+        this.env.push(env);
-        var transpiled = environment().compile.call(this, null, raw, filename.toString());
+        return this;
-        String source = null;
+    }
-        FunctionValue runner = null;
+    public void popEnv() {
-
+        if (!env.empty()) this.env.pop();
-        if (transpiled instanceof ObjectValue) {
+    }
-            source = Values.toString(this, Values.getMember(this, transpiled, "source"));
+
-            var _runner = Values.getMember(this, transpiled, "runner");
+    public FunctionValue compile(Filename filename, String raw) {
-            if (_runner instanceof FunctionValue) runner = (FunctionValue)_runner;
+        var env = environment();
-        }
+        var result = env.compile.call(this, null, raw, filename.toString(), env);
-        else source = Values.toString(this, transpiled);
+
-
+        var function = (FunctionValue)Values.getMember(this, result, "function");
-        var breakpoints = new TreeSet<Location>();
+        if (!engine.debugging) return function;
-        FunctionValue res = Parsing.compile(Engine.functions, breakpoints, environment(), filename, source);
+
-        engine.onSource(filename, source, breakpoints);
+        var rawMapChain = ((ArrayValue)Values.getMember(this, result, "mapChain")).toArray();
-
+        var breakpoints = new TreeSet<>(
-        if (runner != null) res = (FunctionValue)runner.call(this, null, res);
+            Arrays.stream(((ArrayValue)Values.getMember(this, result, "breakpoints")).toArray())
-
+                .map(v -> Location.parse(Values.toString(this, v)))
-        return res;
+                .collect(Collectors.toList())
-    }
+        );
-
+        var maps = new SourceMap[rawMapChain.length];
-    public Context(Engine engine, Data data) {
+
-        this.data = new Data(engine.data);
+        for (var i = 0; i < maps.length; i++) maps[i] = SourceMap.parse(Values.toString(this, (String)rawMapChain[i]));
-        if (data != null) this.data.addAll(data);
+
-        this.engine = engine;
+        var map = SourceMap.chain(maps);
-    }
+
-    public Context(Engine engine) {
+        if (map != null) {
-        this(engine, null);
+            var newBreakpoints = new TreeSet<Location>();
-    }
+            for (var bp : breakpoints) {
-}
+                bp = map.toCompiled(bp);
+                if (bp != null) newBreakpoints.add(bp);
+            }
+            breakpoints = newBreakpoints;
+        }
+
+        engine.onSource(filename, raw, breakpoints, map);
+
+        return function;
+    }
+
+
+    public void pushFrame(CodeFrame frame) {
+        frames.add(frame);
+        if (frames.size() > engine.maxStackFrames) throw EngineException.ofRange("Stack overflow!");
+        pushEnv(frame.function.environment);
+        engine.onFramePush(this, frame);
+    }
+    public boolean popFrame(CodeFrame frame) {
+        if (frames.size() == 0) return false;
+        if (frames.get(frames.size() - 1) != frame) return false;
+        frames.remove(frames.size() - 1);
+        popEnv();
+        engine.onFramePop(this, frame);
+        return true;
+    }
+    public CodeFrame peekFrame() {
+        if (frames.size() == 0) return null;
+        return frames.get(frames.size() - 1);
+    }
+
+    public List<CodeFrame> frames() {
+        return Collections.unmodifiableList(frames);
+    }
+    public List<String> stackTrace() {
+        var res = new ArrayList<String>();
+
+        for (var i = frames.size() - 1; i >= 0; i--) {
+            var el = frames.get(i);
+            var name = el.function.name;
+            Location loc = null;
+
+            for (var j = el.codePtr; j >= 0 && loc == null; j--) loc = el.function.body[j].location;
+            if (loc == null) loc = el.function.loc();
+
+            var trace = "";
+
+            if (loc != null) trace += "at " + loc.toString() + " ";
+            if (name != null && !name.equals("")) trace += "in " + name + " ";
+
+            trace = trace.trim();
+
+            if (!trace.equals("")) res.add(trace);
+        }
+
+        return res;
+    }
+
+    public Context(Engine engine) {
+        this.engine = engine;
+    }
+    public Context(Engine engine, Environment env) {
+        this(engine);
+        this.pushEnv(env);
+        
+    }
+}

src/me/topchetoeu/jscript/engine/Data.java

@@ -5,7 +5,6 @@ import java.util.Map;
 
 @SuppressWarnings("unchecked")
 public class Data {
-    public final Data parent;
     private HashMap<DataKey<Object>, Object> data = new HashMap<>();
 
     public Data copy() {
@@ -33,19 +32,12 @@ public class Data {
         return this;
     }
     public <T> T get(DataKey<T> key, T val) {
-        for (var it = this; it != null; it = it.parent) {
+        if (data.containsKey(key)) return (T)data.get((DataKey<Object>)key);
-            if (it.data.containsKey(key)) {
-                return (T)it.data.get((DataKey<Object>)key);
-            }
-        }
-
         set(key, val);
         return val;
     }
     public <T> T get(DataKey<T> key) {
-        for (var it = this; it != null; it = it.parent) {
+        if (data.containsKey(key)) return (T)data.get((DataKey<Object>)key);
-            if (it.data.containsKey(key)) return (T)it.data.get((DataKey<Object>)key);
-        }
         return null;
     }
     public boolean has(DataKey<?> key) { return data.containsKey(key); }
@@ -61,11 +53,4 @@ public class Data {
     public int increase(DataKey<Integer> key) {
         return increase(key, 1, 0);
     }
-
-    public Data() {
-        this.parent = null;
-    }
-    public Data(Data parent) {
-        this.parent = parent;
-    }
 }

src/me/topchetoeu/jscript/engine/Engine.java

@@ -2,7 +2,7 @@ package me.topchetoeu.jscript.engine;
 
 import java.util.HashMap;
 import java.util.TreeSet;
-import java.util.concurrent.LinkedBlockingDeque;
+import java.util.concurrent.PriorityBlockingQueue;
 
 import me.topchetoeu.jscript.Filename;
 import me.topchetoeu.jscript.Location;
@@ -15,6 +15,7 @@ import me.topchetoeu.jscript.events.Awaitable;
 import me.topchetoeu.jscript.events.DataNotifier;
 import me.topchetoeu.jscript.exceptions.EngineException;
 import me.topchetoeu.jscript.exceptions.InterruptException;
+import me.topchetoeu.jscript.mapping.SourceMap;
 
 public class Engine implements DebugController {
     private class UncompiledFunction extends FunctionValue {
@@ -35,65 +36,72 @@ public class Engine implements DebugController {
         }
     }
 
-    private static class Task {
+    private static class Task implements Comparable<Task> {
         public final FunctionValue func;
         public final Object thisArg;
         public final Object[] args;
         public final DataNotifier<Object> notifier = new DataNotifier<>();
         public final Context ctx;
+        public final boolean micro;
 
-        public Task(Context ctx, FunctionValue func, Object thisArg, Object[] args) {
+        public Task(Context ctx, FunctionValue func, Object thisArg, Object[] args, boolean micro) {
             this.ctx = ctx;
             this.func = func;
             this.thisArg = thisArg;
             this.args = args;
+            this.micro = micro;
+        }
+
+        @Override
+        public int compareTo(Task other) {
+            return Integer.compare(this.micro ? 0 : 1, other.micro ? 0 : 1);
         }
     }
 
     private static int nextId = 0;
     public static final HashMap<Long, FunctionBody> functions = new HashMap<>();
 
-    private Thread thread;
-    private LinkedBlockingDeque<Task> macroTasks = new LinkedBlockingDeque<>();
-    private LinkedBlockingDeque<Task> microTasks = new LinkedBlockingDeque<>();
-
     public final int id = ++nextId;
-    public final Data data = new Data().set(StackData.MAX_FRAMES, 200);
     public final boolean debugging;
+    public int maxStackFrames = 10000;
+
     private final HashMap<Filename, String> sources = new HashMap<>();
     private final HashMap<Filename, TreeSet<Location>> bpts = new HashMap<>();
-    private DebugController debugger;
+    private final HashMap<Filename, SourceMap> maps = new HashMap<>();
 
-    public boolean attachDebugger(DebugController debugger) {
+    public Location mapToCompiled(Location location) {
+        var map = maps.get(location.filename());
+        if (map == null) return location;
+        return map.toCompiled(location);
+    }
+    public Location mapToOriginal(Location location) {
+        var map = maps.get(location.filename());
+        if (map == null) return location;
+        return map.toOriginal(location);
+    }
+
+    private DebugController debugger;
+    private Thread thread;
+    private PriorityBlockingQueue<Task> tasks = new PriorityBlockingQueue<>();
+
+    public synchronized boolean attachDebugger(DebugController debugger) {
         if (!debugging || this.debugger != null) return false;
 
-        for (var source : sources.entrySet()) {
+        for (var source : sources.entrySet()) debugger.onSource(
-            debugger.onSource(source.getKey(), source.getValue(), bpts.get(source.getKey()));
+            source.getKey(), source.getValue(),
-        }
+            bpts.get(source.getKey()),
+            maps.get(source.getKey())
+        );
 
         this.debugger = debugger;
         return true;
     }
-    public boolean detachDebugger() {
+    public synchronized boolean detachDebugger() {
         if (!debugging || this.debugger == null) return false;
         this.debugger = null;
         return true;
     }
 
-    @Override public void onFramePop(Context ctx, CodeFrame frame) {
-        if (debugging && debugger != null) debugger.onFramePop(ctx, frame);
-    }
-    @Override public boolean onInstruction(Context ctx, CodeFrame frame, Instruction instruction, Object returnVal, EngineException error, boolean caught) {
-        if (debugging && debugger != null) return debugger.onInstruction(ctx, frame, instruction, returnVal, error, caught);
-        else return false;
-    }
-    @Override public void onSource(Filename filename, String source, TreeSet<Location> breakpoints) {
-        if (!debugging) return;
-        if (debugger != null) debugger.onSource(filename, source, breakpoints);
-        sources.put(filename, source);
-        bpts.put(filename, breakpoints);
-    }
-
     private void runTask(Task task) {
         try {
             task.notifier.next(task.func.call(task.ctx, task.thisArg, task.args));
@@ -104,18 +112,12 @@ public class Engine implements DebugController {
         }
     }
     public void run(boolean untilEmpty) {
-        while (!untilEmpty || !macroTasks.isEmpty()) {
+        while (!untilEmpty || !tasks.isEmpty()) {
             try {
-                runTask(macroTasks.take());
+                runTask(tasks.take());
-
-                while (!microTasks.isEmpty()) {
-                    runTask(microTasks.take());
-                }
             }
             catch (InterruptedException | InterruptException e) {
-                for (var msg : macroTasks) {
+                for (var msg : tasks) msg.notifier.error(new InterruptException(e));
-                    msg.notifier.error(new InterruptException(e));
-                }
                 break;
             }
         }
@@ -135,20 +137,38 @@ public class Engine implements DebugController {
     public boolean inExecThread() {
         return Thread.currentThread() == thread;
     }
-    public boolean isRunning() {
+    public synchronized boolean isRunning() {
         return this.thread != null;
     }
 
     public Awaitable<Object> pushMsg(boolean micro, Context ctx, FunctionValue func, Object thisArg, Object ...args) {
-        var msg = new Task(ctx == null ? new Context(this) : ctx, func, thisArg, args);
+        var msg = new Task(ctx == null ? new Context(this) : ctx, func, thisArg, args, micro);
-        if (micro) microTasks.addLast(msg);
+        tasks.add(msg);
-        else macroTasks.addLast(msg);
         return msg.notifier;
     }
     public Awaitable<Object> pushMsg(boolean micro, Context ctx, Filename filename, String raw, Object thisArg, Object ...args) {
         return pushMsg(micro, ctx, new UncompiledFunction(filename, raw), thisArg, args);
     }
 
+    @Override
+    public void onFramePush(Context ctx, CodeFrame frame) {
+        if (debugging && debugger != null) debugger.onFramePush(ctx, frame);
+    }
+    @Override public void onFramePop(Context ctx, CodeFrame frame) {
+        if (debugging && debugger != null) debugger.onFramePop(ctx, frame);
+    }
+    @Override public boolean onInstruction(Context ctx, CodeFrame frame, Instruction instruction, Object returnVal, EngineException error, boolean caught) {
+        if (debugging && debugger != null) return debugger.onInstruction(ctx, frame, instruction, returnVal, error, caught);
+        else return false;
+    }
+    @Override public void onSource(Filename filename, String source, TreeSet<Location> breakpoints, SourceMap map) {
+        if (!debugging) return;
+        if (debugger != null) debugger.onSource(filename, source, breakpoints, map);
+        sources.put(filename, source);
+        bpts.put(filename, breakpoints);
+        maps.put(filename, map);
+    }
+
     public Engine(boolean debugging) {
         this.debugging = debugging;
     }

src/me/topchetoeu/jscript/engine/Environment.java

@@ -1,87 +1,131 @@
-package me.topchetoeu.jscript.engine;
+package me.topchetoeu.jscript.engine;
-
+
-import java.util.HashMap;
+import java.util.HashMap;
-
+import java.util.stream.Collectors;
-import me.topchetoeu.jscript.engine.scope.GlobalScope;
+
-import me.topchetoeu.jscript.engine.values.FunctionValue;
+import me.topchetoeu.jscript.Filename;
-import me.topchetoeu.jscript.engine.values.NativeFunction;
+import me.topchetoeu.jscript.Location;
-import me.topchetoeu.jscript.engine.values.ObjectValue;
+import me.topchetoeu.jscript.engine.scope.GlobalScope;
-import me.topchetoeu.jscript.engine.values.Symbol;
+import me.topchetoeu.jscript.engine.values.ArrayValue;
-import me.topchetoeu.jscript.exceptions.EngineException;
+import me.topchetoeu.jscript.engine.values.FunctionValue;
-import me.topchetoeu.jscript.interop.Native;
+import me.topchetoeu.jscript.engine.values.NativeFunction;
-import me.topchetoeu.jscript.interop.NativeGetter;
+import me.topchetoeu.jscript.engine.values.ObjectValue;
-import me.topchetoeu.jscript.interop.NativeSetter;
+import me.topchetoeu.jscript.engine.values.Symbol;
-import me.topchetoeu.jscript.interop.NativeWrapperProvider;
+import me.topchetoeu.jscript.engine.values.Values;
-
+import me.topchetoeu.jscript.exceptions.EngineException;
-public class Environment {
+import me.topchetoeu.jscript.filesystem.RootFilesystem;
-    private HashMap<String, ObjectValue> prototypes = new HashMap<>();
+import me.topchetoeu.jscript.interop.Native;
-
+import me.topchetoeu.jscript.interop.NativeGetter;
-    public final Data data = new Data();
+import me.topchetoeu.jscript.interop.NativeSetter;
-    public static final HashMap<String, Symbol> symbols = new HashMap<>();
+import me.topchetoeu.jscript.interop.NativeWrapperProvider;
-
+import me.topchetoeu.jscript.parsing.Parsing;
-    public GlobalScope global;
+import me.topchetoeu.jscript.permissions.Permission;
-    public WrappersProvider wrappers;
+import me.topchetoeu.jscript.permissions.PermissionsProvider;
-
+
-    @Native public FunctionValue compile;
+public class Environment implements PermissionsProvider {
-    @Native public FunctionValue regexConstructor = new NativeFunction("RegExp", (ctx, thisArg, args) -> {
+    private HashMap<String, ObjectValue> prototypes = new HashMap<>();
-        throw EngineException.ofError("Regular expressions not supported.").setCtx(ctx.environment(), ctx.engine);
+
-    });
+    public final Data data = new Data();
-
+    public static final HashMap<String, Symbol> symbols = new HashMap<>();
-    public Environment addData(Data data) {
+
-        this.data.addAll(data);
+    public GlobalScope global;
-        return this;
+    public WrappersProvider wrappers;
-    }
+    public PermissionsProvider permissions = null;
-
+    public final RootFilesystem filesystem = new RootFilesystem(this);
-    @Native public ObjectValue proto(String name) {
+
-        return prototypes.get(name);
+    private static int nextId = 0;
-    }
+
-    @Native public void setProto(String name, ObjectValue val) {
+    @Native public boolean stackVisible = true;
-        prototypes.put(name, val);
+    @Native public int id = ++nextId;
-    }
+
-
+    @Native public FunctionValue compile = new NativeFunction("compile", (ctx, thisArg, args) -> {
-    @Native public Symbol symbol(String name) {
+        var source = Values.toString(ctx, args[0]);
-        if (symbols.containsKey(name)) return symbols.get(name);
+        var filename = Values.toString(ctx, args[1]);
-        else {
+        var isDebug = Values.toBoolean(args[2]);
-            var res = new Symbol(name);
+
-            symbols.put(name, res);
+        var env = Values.wrapper(args[2], Environment.class);
-            return res;
+        var res = new ObjectValue();
-        }
+
-    }
+        var target = Parsing.compile(env, Filename.parse(filename), source);
-
+        Engine.functions.putAll(target.functions);
-    @NativeGetter("global") public ObjectValue getGlobal() {
+        Engine.functions.remove(0l);
-        return global.obj;
+
-    }
+        res.defineProperty(ctx, "function", target.func(env));
-    @NativeSetter("global") public void setGlobal(ObjectValue val) {
+        res.defineProperty(ctx, "mapChain", new ArrayValue());
-        global = new GlobalScope(val);
+
-    }
+
-
+        if (isDebug) {
-    @Native public Environment fork() {
+            res.defineProperty(ctx, "breakpoints", ArrayValue.of(ctx, target.breakpoints.stream().map(Location::toString).collect(Collectors.toList())));
-        var res = new Environment(compile, null, global);
+        }
-        res.wrappers = wrappers.fork(res);
+
-        res.regexConstructor = regexConstructor;
+        return res;
-        res.prototypes = new HashMap<>(prototypes);
+    });
-        return res;
+    @Native public FunctionValue regexConstructor = new NativeFunction("RegExp", (ctx, thisArg, args) -> {
-    }
+        throw EngineException.ofError("Regular expressions not supported.").setCtx(ctx.environment(), ctx.engine);
-    @Native public Environment child() {
+    });
-        var res = fork();
+
-        res.global = res.global.globalChild();
+    public Environment addData(Data data) {
-        return res;
+        this.data.addAll(data);
-    }
+        return this;
-
+    }
-    public Context context(Engine engine, Data data) {
+
-        return new Context(engine, data).pushEnv(this);
+    @Native public ObjectValue proto(String name) {
-    }
+        return prototypes.get(name);
-    public Context context(Engine engine) {
+    }
-        return new Context(engine).pushEnv(this);
+    @Native public void setProto(String name, ObjectValue val) {
-    }
+        prototypes.put(name, val);
-
+    }
-    public Environment(FunctionValue compile, WrappersProvider nativeConverter, GlobalScope global) {
+
-        if (compile == null) compile = new NativeFunction("compile", (ctx, thisArg, args) -> args.length == 0 ? "" : args[0]);
+    @Native public Symbol symbol(String name) {
-        if (nativeConverter == null) nativeConverter = new NativeWrapperProvider(this);
+        return getSymbol(name);
-        if (global == null) global = new GlobalScope();
+    }
-
+
-        this.wrappers = nativeConverter;
+    @NativeGetter("global") public ObjectValue getGlobal() {
-        this.compile = compile;
+        return global.obj;
-        this.global = global;
+    }
-    }
+    @NativeSetter("global") public void setGlobal(ObjectValue val) {
-}
+        global = new GlobalScope(val);
+    }
+
+    @Native public Environment fork() {
+        var res = new Environment(compile, null, global);
+        res.wrappers = wrappers.fork(res);
+        res.regexConstructor = regexConstructor;
+        res.prototypes = new HashMap<>(prototypes);
+        return res;
+    }
+    @Native public Environment child() {
+        var res = fork();
+        res.global = res.global.globalChild();
+        return res;
+    }
+
+    @Override public boolean hasPermission(Permission perm, char delim) {
+        return permissions == null || permissions.hasPermission(perm, delim);
+    }
+    @Override public boolean hasPermission(Permission perm) {
+        return permissions == null || permissions.hasPermission(perm);
+    }
+
+    public Context context(Engine engine) {
+        return new Context(engine).pushEnv(this);
+    }
+
+    public static Symbol getSymbol(String name) {
+        if (symbols.containsKey(name)) return symbols.get(name);
+        else {
+            var res = new Symbol(name);
+            symbols.put(name, res);
+            return res;
+        }
+    }
+
+    public Environment(FunctionValue compile, WrappersProvider nativeConverter, GlobalScope global) {
+        if (compile != null) this.compile = compile;
+        if (nativeConverter == null) nativeConverter = new NativeWrapperProvider(this);
+        if (global == null) global = new GlobalScope();
+
+        this.wrappers = nativeConverter;
+        this.global = global;
+    }
+}

src/me/topchetoeu/jscript/engine/StackData.java

@@ -1,65 +0,0 @@
-package me.topchetoeu.jscript.engine;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
-import me.topchetoeu.jscript.Location;
-import me.topchetoeu.jscript.engine.debug.Debugger;
-import me.topchetoeu.jscript.engine.frame.CodeFrame;
-import me.topchetoeu.jscript.exceptions.EngineException;
-
-public class StackData {
-    public static final DataKey<ArrayList<CodeFrame>> FRAMES = new DataKey<>();
-    public static final DataKey<Integer> MAX_FRAMES = new DataKey<>();
-    public static final DataKey<Debugger> DEBUGGER = new DataKey<>();
-
-    public static void pushFrame(Context ctx, CodeFrame frame) {
-        var frames = ctx.data.get(FRAMES, new ArrayList<>());
-        frames.add(frame);
-        if (frames.size() > ctx.data.get(MAX_FRAMES, 10000)) throw EngineException.ofRange("Stack overflow!");
-        ctx.pushEnv(frame.function.environment);
-    }
-    public static boolean popFrame(Context ctx, CodeFrame frame) {
-        var frames = ctx.data.get(FRAMES, new ArrayList<>());
-        if (frames.size() == 0) return false;
-        if (frames.get(frames.size() - 1) != frame) return false;
-        frames.remove(frames.size() - 1);
-        ctx.popEnv();
-        ctx.engine.onFramePop(ctx, frame);
-        return true;
-    }
-    public static CodeFrame peekFrame(Context ctx) {
-        var frames = ctx.data.get(FRAMES, new ArrayList<>());
-        if (frames.size() == 0) return null;
-        return frames.get(frames.size() - 1);
-    }
-
-    public static List<CodeFrame> frames(Context ctx) {
-        return Collections.unmodifiableList(ctx.data.get(FRAMES, new ArrayList<>()));
-    }
-    public static List<String> stackTrace(Context ctx) {
-        var res = new ArrayList<String>();
-        var frames = frames(ctx);
-
-        for (var i = frames.size() - 1; i >= 0; i--) {
-            var el = frames.get(i);
-            var name = el.function.name;
-            Location loc = null;
-
-            for (var j = el.codePtr; j >= 0 && loc == null; j--) loc = el.function.body[j].location;
-            if (loc == null) loc = el.function.loc();
-
-            var trace = "";
-
-            if (loc != null) trace += "at " + loc.toString() + " ";
-            if (name != null && !name.equals("")) trace += "in " + name + " ";
-
-            trace = trace.trim();
-
-            if (!trace.equals("")) res.add(trace);
-        }
-
-        return res;
-    }
-}

src/me/topchetoeu/jscript/engine/debug/DebugController.java

@@ -1,40 +1,51 @@
-package me.topchetoeu.jscript.engine.debug;
+package me.topchetoeu.jscript.engine.debug;
-
+
-import java.util.TreeSet;
+import java.util.TreeSet;
-
+
-import me.topchetoeu.jscript.Filename;
+import me.topchetoeu.jscript.Filename;
-import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.Location;
-import me.topchetoeu.jscript.compilation.Instruction;
+import me.topchetoeu.jscript.compilation.Instruction;
-import me.topchetoeu.jscript.engine.Context;
+import me.topchetoeu.jscript.engine.Context;
-import me.topchetoeu.jscript.engine.frame.CodeFrame;
+import me.topchetoeu.jscript.engine.frame.CodeFrame;
-import me.topchetoeu.jscript.exceptions.EngineException;
+import me.topchetoeu.jscript.exceptions.EngineException;
-
+import me.topchetoeu.jscript.mapping.SourceMap;
-public interface DebugController {
+
-    /**
+public interface DebugController {
-     * Called when a script has been loaded
+    /**
-     * @param breakpoints 
+     * Called when a script has been loaded
-     */
+     * @param filename The name of the source
-    void onSource(Filename filename, String source, TreeSet<Location> breakpoints);
+     * @param source The name of the source
-
+     * @param breakpoints A set of all the breakpointable locations in this source
-    /**
+     * @param map The source map associated with this file. null if this source map isn't mapped
-     * Called immediatly before an instruction is executed, as well as after an instruction, if it has threw or returned.
+     */
-     * This function might pause in order to await debugging commands.
+    void onSource(Filename filename, String source, TreeSet<Location> breakpoints, SourceMap map);
-     * @param ctx The context of execution
+
-     * @param frame The frame in which execution is occuring
+    /**
-     * @param instruction The instruction which was or will be executed
+     * Called immediatly before an instruction is executed, as well as after an instruction, if it has threw or returned.
-     * @param loc The most recent location the code frame has been at
+     * This function might pause in order to await debugging commands.
-     * @param returnVal The return value of the instruction, Runners.NO_RETURN if none
+     * @param ctx The context of execution
-     * @param error The error that the instruction threw, null if none
+     * @param frame The frame in which execution is occuring
-     * @param caught Whether or not the error has been caught
+     * @param instruction The instruction which was or will be executed
-     * @return Whether or not the frame should restart
+     * @param loc The most recent location the code frame has been at
-     */
+     * @param returnVal The return value of the instruction, Runners.NO_RETURN if none
-    boolean onInstruction(Context ctx, CodeFrame frame, Instruction instruction, Object returnVal, EngineException error, boolean caught);
+     * @param error The error that the instruction threw, null if none
-
+     * @param caught Whether or not the error has been caught
-    /**
+     * @return Whether or not the frame should restart
-     * Called immediatly after a frame has been popped out of the frame stack.
+     */
-     * This function might pause in order to await debugging commands.
+    boolean onInstruction(Context ctx, CodeFrame frame, Instruction instruction, Object returnVal, EngineException error, boolean caught);
-     * @param ctx The context of execution
+
-     * @param frame The code frame which was popped out
+    /**
-     */
+     * Called immediatly before a frame has been pushed on the frame stack.
-    void onFramePop(Context ctx, CodeFrame frame);
+     * This function might pause in order to await debugging commands.
-}
+     * @param ctx The context of execution
+     * @param frame The code frame which was pushed
+     */
+    void onFramePush(Context ctx, CodeFrame frame);
+    /**
+     * Called immediatly after a frame has been popped out of the frame stack.
+     * This function might pause in order to await debugging commands.
+     * @param ctx The context of execution
+     * @param frame The code frame which was popped out
+     */
+    void onFramePop(Context ctx, CodeFrame frame);
+}

src/me/topchetoeu/jscript/engine/debug/DebugHandler.java

@@ -1,35 +1,34 @@
-package me.topchetoeu.jscript.engine.debug;
+package me.topchetoeu.jscript.engine.debug;
-
+
-public interface DebugHandler {
+public interface DebugHandler {
-    void enable(V8Message msg);
+    void enable(V8Message msg);
-    void disable(V8Message msg);
+    void disable(V8Message msg);
-
+
-    void setBreakpoint(V8Message msg);
+    void setBreakpointByUrl(V8Message msg);
-    void setBreakpointByUrl(V8Message msg);
+    void removeBreakpoint(V8Message msg);
-    void removeBreakpoint(V8Message msg);
+    void continueToLocation(V8Message msg);
-    void continueToLocation(V8Message msg);
+
-
+    void getScriptSource(V8Message msg);
-    void getScriptSource(V8Message msg);
+    void getPossibleBreakpoints(V8Message msg);
-    void getPossibleBreakpoints(V8Message msg);
+
-
+    void resume(V8Message msg);
-    void resume(V8Message msg);
+    void pause(V8Message msg);
-    void pause(V8Message msg);
+
-
+    void stepInto(V8Message msg);
-    void stepInto(V8Message msg);
+    void stepOut(V8Message msg);
-    void stepOut(V8Message msg);
+    void stepOver(V8Message msg);
-    void stepOver(V8Message msg);
+
-
+    void setPauseOnExceptions(V8Message msg);
-    void setPauseOnExceptions(V8Message msg);
+
-
+    void evaluateOnCallFrame(V8Message msg);
-    void evaluateOnCallFrame(V8Message msg);
+
-
+    void getProperties(V8Message msg);
-    void getProperties(V8Message msg);
+    void releaseObjectGroup(V8Message msg);
-    void releaseObjectGroup(V8Message msg);
+    void releaseObject(V8Message msg);
-    void releaseObject(V8Message msg);
+    /**
-    /**
+     * This method might not execute the actual code for well-known requests
-     * This method might not execute the actual code for well-known requests
+     */
-     */
+    void callFunctionOn(V8Message msg);
-    void callFunctionOn(V8Message msg);
+
-
+    void runtimeEnable(V8Message msg);
-    void runtimeEnable(V8Message msg);
+}
-}

src/me/topchetoeu/jscript/engine/debug/DebugServer.java

@@ -1,246 +1,245 @@
-package me.topchetoeu.jscript.engine.debug;
+package me.topchetoeu.jscript.engine.debug;
-
+
-import java.io.IOException;
+import java.io.IOException;
-import java.net.InetSocketAddress;
+import java.net.InetSocketAddress;
-import java.net.ServerSocket;
+import java.net.ServerSocket;
-import java.net.Socket;
+import java.net.Socket;
-import java.security.MessageDigest;
+import java.security.MessageDigest;
-import java.util.Base64;
+import java.util.Base64;
-import java.util.HashMap;
+import java.util.HashMap;
-
+
-import me.topchetoeu.jscript.Metadata;
+import me.topchetoeu.jscript.Metadata;
-import me.topchetoeu.jscript.engine.debug.WebSocketMessage.Type;
+import me.topchetoeu.jscript.Reading;
-import me.topchetoeu.jscript.events.Notifier;
+import me.topchetoeu.jscript.engine.debug.WebSocketMessage.Type;
-import me.topchetoeu.jscript.exceptions.SyntaxException;
+import me.topchetoeu.jscript.events.Notifier;
-import me.topchetoeu.jscript.exceptions.UncheckedException;
+import me.topchetoeu.jscript.exceptions.SyntaxException;
-import me.topchetoeu.jscript.exceptions.UncheckedIOException;
+import me.topchetoeu.jscript.exceptions.UncheckedException;
-import me.topchetoeu.jscript.json.JSON;
+import me.topchetoeu.jscript.exceptions.UncheckedIOException;
-import me.topchetoeu.jscript.json.JSONList;
+import me.topchetoeu.jscript.json.JSON;
-import me.topchetoeu.jscript.json.JSONMap;
+import me.topchetoeu.jscript.json.JSONList;
-
+import me.topchetoeu.jscript.json.JSONMap;
-public class DebugServer {
+
-    public static String browserDisplayName = Metadata.NAME + "/" + Metadata.VERSION;
+public class DebugServer {
-
+    public static String browserDisplayName = Metadata.name() + "/" + Metadata.version();
-    public final HashMap<String, DebuggerProvider> targets = new HashMap<>();
+
-
+    public final HashMap<String, DebuggerProvider> targets = new HashMap<>();
-    private final byte[] favicon, index, protocol;
+
-    private final Notifier connNotifier = new Notifier();
+    private final byte[] favicon, index, protocol;
-
+    private final Notifier connNotifier = new Notifier();
-    private static void send(HttpRequest req, String val) throws IOException {
+
-        req.writeResponse(200, "OK", "application/json", val.getBytes());
+    private static void send(HttpRequest req, String val) throws IOException {
-    }
+        req.writeResponse(200, "OK", "application/json", val.getBytes());
-
+    }
-    // SILENCE JAVA
+
-    private MessageDigest getDigestInstance() {
+    // SILENCE JAVA
-        try {
+    private MessageDigest getDigestInstance() {
-            return MessageDigest.getInstance("sha1");
+        try {
-        }
+            return MessageDigest.getInstance("sha1");
-        catch (Throwable e) { throw new UncheckedException(e); }
+        }
-
+        catch (Throwable e) { throw new UncheckedException(e); }
-    }
+
-
+    }
-    private static Thread runAsync(Runnable func, String name) {
+
-        var res = new Thread(func);
+    private static Thread runAsync(Runnable func, String name) {
-        res.setName(name);
+        var res = new Thread(func);
-        res.start();
+        res.setName(name);
-        return res;
+        res.start();
-    }
+        return res;
-
+    }
-    private void handle(WebSocket ws, Debugger debugger) {
+
-        WebSocketMessage raw;
+    private void handle(WebSocket ws, Debugger debugger) {
-
+        WebSocketMessage raw;
-        debugger.connect();
+
-
+        debugger.connect();
-        while ((raw = ws.receive()) != null) {
+
-            if (raw.type != Type.Text) {
+        while ((raw = ws.receive()) != null) {
-                ws.send(new V8Error("Expected a text message."));
+            if (raw.type != Type.Text) {
-                continue;
+                ws.send(new V8Error("Expected a text message."));
-            }
+                continue;
-
+            }
-            V8Message msg;
+
-
+            V8Message msg;
-            try {
+
-                msg = new V8Message(raw.textData());
+            try {
-            }
+                msg = new V8Message(raw.textData());
-            catch (SyntaxException e) {
+            }
-                ws.send(new V8Error(e.getMessage()));
+            catch (SyntaxException e) {
-                return;
+                ws.send(new V8Error(e.getMessage()));
-            }
+                return;
-
+            }
-            try {
+
-                switch (msg.name) {
+            try {
-                    case "Debugger.enable":
+                switch (msg.name) {
-                        connNotifier.next();
+                    case "Debugger.enable":
-                        debugger.enable(msg); continue;
+                        connNotifier.next();
-                    case "Debugger.disable": debugger.disable(msg); continue;
+                        debugger.enable(msg); continue;
-
+                    case "Debugger.disable": debugger.disable(msg); continue;
-                    case "Debugger.setBreakpoint": debugger.setBreakpoint(msg); continue;
+
-                    case "Debugger.setBreakpointByUrl": debugger.setBreakpointByUrl(msg); continue;
+                    case "Debugger.setBreakpointByUrl": debugger.setBreakpointByUrl(msg); continue;
-                    case "Debugger.removeBreakpoint": debugger.removeBreakpoint(msg); continue;
+                    case "Debugger.removeBreakpoint": debugger.removeBreakpoint(msg); continue;
-                    case "Debugger.continueToLocation": debugger.continueToLocation(msg); continue;
+                    case "Debugger.continueToLocation": debugger.continueToLocation(msg); continue;
-
+
-                    case "Debugger.getScriptSource": debugger.getScriptSource(msg); continue;
+                    case "Debugger.getScriptSource": debugger.getScriptSource(msg); continue;
-                    case "Debugger.getPossibleBreakpoints": debugger.getPossibleBreakpoints(msg); continue;
+                    case "Debugger.getPossibleBreakpoints": debugger.getPossibleBreakpoints(msg); continue;
-
+
-                    case "Debugger.resume": debugger.resume(msg); continue;
+                    case "Debugger.resume": debugger.resume(msg); continue;
-                    case "Debugger.pause": debugger.pause(msg); continue;
+                    case "Debugger.pause": debugger.pause(msg); continue;
-
+
-                    case "Debugger.stepInto": debugger.stepInto(msg); continue;
+                    case "Debugger.stepInto": debugger.stepInto(msg); continue;
-                    case "Debugger.stepOut": debugger.stepOut(msg); continue;
+                    case "Debugger.stepOut": debugger.stepOut(msg); continue;
-                    case "Debugger.stepOver": debugger.stepOver(msg); continue;
+                    case "Debugger.stepOver": debugger.stepOver(msg); continue;
-
+
-                    case "Debugger.setPauseOnExceptions": debugger.setPauseOnExceptions(msg); continue;
+                    case "Debugger.setPauseOnExceptions": debugger.setPauseOnExceptions(msg); continue;
-                    case "Debugger.evaluateOnCallFrame": debugger.evaluateOnCallFrame(msg); continue;
+                    case "Debugger.evaluateOnCallFrame": debugger.evaluateOnCallFrame(msg); continue;
-
+
-                    case "Runtime.releaseObjectGroup": debugger.releaseObjectGroup(msg); continue;
+                    case "Runtime.releaseObjectGroup": debugger.releaseObjectGroup(msg); continue;
-                    case "Runtime.releaseObject": debugger.releaseObject(msg); continue;
+                    case "Runtime.releaseObject": debugger.releaseObject(msg); continue;
-                    case "Runtime.getProperties": debugger.getProperties(msg); continue;
+                    case "Runtime.getProperties": debugger.getProperties(msg); continue;
-                    case "Runtime.callFunctionOn": debugger.callFunctionOn(msg); continue;
+                    case "Runtime.callFunctionOn": debugger.callFunctionOn(msg); continue;
-                    // case "NodeWorker.enable": debugger.nodeWorkerEnable(msg); continue;
+                    // case "NodeWorker.enable": debugger.nodeWorkerEnable(msg); continue;
-                    case "Runtime.enable": debugger.runtimeEnable(msg); continue;
+                    case "Runtime.enable": debugger.runtimeEnable(msg); continue;
-                }
+                }
-
+
-                if (
+                if (
-                    msg.name.startsWith("DOM.") ||
+                    msg.name.startsWith("DOM.") ||
-                    msg.name.startsWith("DOMDebugger.") ||
+                    msg.name.startsWith("DOMDebugger.") ||
-                    msg.name.startsWith("Emulation.") ||
+                    msg.name.startsWith("Emulation.") ||
-                    msg.name.startsWith("Input.") ||
+                    msg.name.startsWith("Input.") ||
-                    msg.name.startsWith("Network.") ||
+                    msg.name.startsWith("Network.") ||
-                    msg.name.startsWith("Page.")
+                    msg.name.startsWith("Page.")
-                ) ws.send(new V8Error("This isn't a browser..."));
+                ) ws.send(new V8Error("This isn't a browser..."));
-                else ws.send(new V8Error("This API is not supported yet."));
+                else ws.send(new V8Error("This API is not supported yet."));
-            }
+            }
-            catch (Throwable e) {
+            catch (Throwable e) {
-                e.printStackTrace();
+                e.printStackTrace();
-                throw new UncheckedException(e);
+                throw new UncheckedException(e);
-            }
+            }
-        }
+        }
-
+
-        debugger.disconnect();
+        debugger.disconnect();
-    }
+    }
-    private void onWsConnect(HttpRequest req, Socket socket, DebuggerProvider debuggerProvider) {
+    private void onWsConnect(HttpRequest req, Socket socket, DebuggerProvider debuggerProvider) {
-        var key = req.headers.get("sec-websocket-key");
+        var key = req.headers.get("sec-websocket-key");
-
+
-        if (key == null) {
+        if (key == null) {
-            req.writeResponse(
+            req.writeResponse(
-                426, "Upgrade Required", "text/txt",
+                426, "Upgrade Required", "text/txt",
-                "Expected a WS upgrade".getBytes()
+                "Expected a WS upgrade".getBytes()
-            );
+            );
-            return;
+            return;
-        }
+        }
-
+
-        var resKey = Base64.getEncoder().encodeToString(getDigestInstance().digest(
+        var resKey = Base64.getEncoder().encodeToString(getDigestInstance().digest(
-            (key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11").getBytes()
+            (key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11").getBytes()
-        ));
+        ));
-
+
-        req.writeCode(101, "Switching Protocols");
+        req.writeCode(101, "Switching Protocols");
-        req.writeHeader("Connection", "Upgrade");
+        req.writeHeader("Connection", "Upgrade");
-        req.writeHeader("Sec-WebSocket-Accept", resKey);
+        req.writeHeader("Sec-WebSocket-Accept", resKey);
-        req.writeLastHeader("Upgrade", "WebSocket");
+        req.writeLastHeader("Upgrade", "WebSocket");
-
+
-        var ws = new WebSocket(socket);
+        var ws = new WebSocket(socket);
-        var debugger = debuggerProvider.getDebugger(ws, req);
+        var debugger = debuggerProvider.getDebugger(ws, req);
-
+
-        if (debugger == null) {
+        if (debugger == null) {
-            ws.close();
+            ws.close();
-            return;
+            return;
-        }
+        }
-
+
-        runAsync(() -> {
+        runAsync(() -> {
-            try { handle(ws, debugger); }
+            try { handle(ws, debugger); }
-            catch (RuntimeException e) {
+            catch (RuntimeException e) {
-                ws.send(new V8Error(e.getMessage()));
+                ws.send(new V8Error(e.getMessage()));
-            }
+            }
-            finally { ws.close(); debugger.disconnect(); }
+            finally { ws.close(); debugger.disconnect(); }
-        }, "Debug Handler");
+        }, "Debug Handler");
-    }
+    }
-
+
-    public void awaitConnection() {
+    public void awaitConnection() {
-        connNotifier.await();
+        connNotifier.await();
-    }
+    }
-
+
-    public void run(InetSocketAddress address) {
+    public void run(InetSocketAddress address) {
-        try {
+        try {
-            ServerSocket server = new ServerSocket();
+            ServerSocket server = new ServerSocket();
-            server.bind(address);
+            server.bind(address);
-
+
-            try {
+            try {
-                while (true) {
+                while (true) {
-                    var socket = server.accept();
+                    var socket = server.accept();
-                    var req = HttpRequest.read(socket);
+                    var req = HttpRequest.read(socket);
-
+
-                    if (req == null) continue;
+                    if (req == null) continue;
-    
+    
-                    switch (req.path) {
+                    switch (req.path) {
-                        case "/json/version":
+                        case "/json/version":
-                            send(req, "{\"Browser\":\"" + browserDisplayName + "\",\"Protocol-Version\":\"1.1\"}");
+                            send(req, "{\"Browser\":\"" + browserDisplayName + "\",\"Protocol-Version\":\"1.1\"}");
-                            break;
+                            break;
-                        case "/json/list":
+                        case "/json/list":
-                        case "/json": {
+                        case "/json": {
-                            var res = new JSONList();
+                            var res = new JSONList();
-
+
-                            for (var el : targets.entrySet()) {
+                            for (var el : targets.entrySet()) {
-                                res.add(new JSONMap()
+                                res.add(new JSONMap()
-                                    .set("description", "JScript debugger")
+                                    .set("description", "JScript debugger")
-                                    .set("favicon", "/favicon.ico")
+                                    .set("favicon", "/favicon.ico")
-                                    .set("id", el.getKey())
+                                    .set("id", el.getKey())
-                                    .set("type", "node")
+                                    .set("type", "node")
-                                    .set("webSocketDebuggerUrl", "ws://" + address.getHostString() + ":" + address.getPort() + "/" + el.getKey())
+                                    .set("webSocketDebuggerUrl", "ws://" + address.getHostString() + ":" + address.getPort() + "/" + el.getKey())
-                                );
+                                );
-                            }
+                            }
-                            send(req, JSON.stringify(res));
+                            send(req, JSON.stringify(res));
-                            break;
+                            break;
-                        }
+                        }
-                        case "/json/protocol":
+                        case "/json/protocol":
-                            req.writeResponse(200, "OK", "application/json", protocol);
+                            req.writeResponse(200, "OK", "application/json", protocol);
-                            break;
+                            break;
-                        case "/json/new":
+                        case "/json/new":
-                        case "/json/activate":
+                        case "/json/activate":
-                        case "/json/close":
+                        case "/json/close":
-                        case "/devtools/inspector.html":
+                        case "/devtools/inspector.html":
-                            req.writeResponse(
+                            req.writeResponse(
-                                501, "Not Implemented", "text/txt",
+                                501, "Not Implemented", "text/txt",
-                                "This feature isn't (and probably won't be) implemented.".getBytes()
+                                "This feature isn't (and probably won't be) implemented.".getBytes()
-                            );
+                            );
-                            break;
+                            break;
-                        case "/":
+                        case "/":
-                        case "/index.html":
+                        case "/index.html":
-                            req.writeResponse(200, "OK", "text/html", index);
+                            req.writeResponse(200, "OK", "text/html", index);
-                            break;
+                            break;
-                        case "/favicon.ico":
+                        case "/favicon.ico":
-                            req.writeResponse(200, "OK", "image/png", favicon);
+                            req.writeResponse(200, "OK", "image/png", favicon);
-                            break;
+                            break;
-                        default:
+                        default:
-                            if (req.path.length() > 1 && targets.containsKey(req.path.substring(1))) {
+                            if (req.path.length() > 1 && targets.containsKey(req.path.substring(1))) {
-                                onWsConnect(req, socket, targets.get(req.path.substring(1)));
+                                onWsConnect(req, socket, targets.get(req.path.substring(1)));
-                            }
+                            }
-                            break;
+                            break;
-                    }
+                    }
-                }
+                }
-            }
+            }
-            finally { server.close(); }
+            finally { server.close(); }
-        }
+        }
-        catch (IOException e) { throw new UncheckedIOException(e); }
+        catch (IOException e) { throw new UncheckedIOException(e); }
-    }
+    }
-
+
-    public Thread start(InetSocketAddress address, boolean daemon) {
+    public Thread start(InetSocketAddress address, boolean daemon) {
-        var res = new Thread(() -> run(address), "Debug Server");
+        var res = new Thread(() -> run(address), "Debug Server");
-        res.setDaemon(daemon);
+        res.setDaemon(daemon);
-        res.start();
+        res.start();
-        return res;
+        return res;
-    }
+    }
-
+
-    public DebugServer() {
+    public DebugServer() {
-        try {
+        try {
-            this.favicon = getClass().getClassLoader().getResourceAsStream("assets/favicon.png").readAllBytes();
+            this.favicon = Reading.resourceToStream("debugger/favicon.png").readAllBytes();
-            this.protocol = getClass().getClassLoader().getResourceAsStream("assets/protocol.json").readAllBytes();
+            this.protocol = Reading.resourceToStream("debugger/protocol.json").readAllBytes();
-            var index = new String(getClass().getClassLoader().getResourceAsStream("assets/index.html").readAllBytes());
+            this.index = Reading.resourceToString("debugger/index.html")
-            this.index = index
+                .replace("${NAME}", Metadata.name())
-                .replace("${NAME}", Metadata.NAME)
+                .replace("${VERSION}", Metadata.version())
-                .replace("${VERSION}", Metadata.VERSION)
+                .replace("${AUTHOR}", Metadata.author())
-                .replace("${AUTHOR}", Metadata.AUTHOR)
+                .getBytes();
-                .getBytes();
+        }
-        }
+        catch (IOException e) { throw new UncheckedIOException(e); }
-        catch (IOException e) { throw new UncheckedIOException(e); }
+    }
-    }
+}
-}

src/me/topchetoeu/jscript/engine/debug/WebSocket.java

@@ -118,8 +118,6 @@ public class WebSocket implements AutoCloseable {
         else send(msg.textData());
     }
     public void send(Object data) {
-        // TODO: Remove
-        // System.out.println("SEND: " + data);
         if (closed) throw new IllegalStateException("Object is closed.");
         write(1, data.toString().getBytes());
     }
@@ -201,10 +199,6 @@ public class WebSocket implements AutoCloseable {
                 if (!fin) continue;
                 var raw = data.toByteArray();
 
-                // TODO: Remove
-                // System.out.println("RECEIVED: " + new String(raw));
-
-
                 if (type == 1) return new WebSocketMessage(new String(raw));
                 else return new WebSocketMessage(raw);
             }

src/me/topchetoeu/jscript/engine/frame/CodeFrame.java

@@ -4,6 +4,7 @@ import java.util.List;
 import java.util.Stack;
 
 import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.engine.Context;
 import me.topchetoeu.jscript.engine.scope.LocalScope;
 import me.topchetoeu.jscript.engine.scope.ValueVariable;
@@ -16,32 +17,74 @@ import me.topchetoeu.jscript.exceptions.EngineException;
 import me.topchetoeu.jscript.exceptions.InterruptException;
 
 public class CodeFrame {
+    public static enum TryState {
+        TRY,
+        CATCH,
+        FINALLY,
+    }
+
     public static class TryCtx {
-        public static final int STATE_TRY = 0;
+        public final int start, end, catchStart, finallyStart;
-        public static final int STATE_CATCH = 1;
+        public final int restoreStackPtr;
-        public static final int STATE_FINALLY_THREW = 2;
+        public final TryState state;
-        public static final int STATE_FINALLY_RETURNED = 3;
+        public final EngineException error;
-        public static final int STATE_FINALLY_JUMPED = 4;
+        public final PendingResult result;
 
-        public final boolean hasCatch, hasFinally;
+        public boolean hasCatch() { return catchStart >= 0; }
-        public final int tryStart, catchStart, finallyStart, end;
+        public boolean hasFinally() { return finallyStart >= 0; }
-        public int state;
-        public Object retVal;
-        public EngineException err;
-        public int jumpPtr;
 
-        public TryCtx(int tryStart, int tryN, int catchN, int finallyN) {
+        public boolean inBounds(int ptr) {
-            hasCatch = catchN >= 0;
+            return ptr >= start && ptr < end;
-            hasFinally = finallyN >= 0;
+        }
 
-            if (catchN < 0) catchN = 0;
+        public TryCtx _catch(EngineException e) {
-            if (finallyN < 0) finallyN = 0;
+            if (error != null) e.setCause(error);
+            return new TryCtx(TryState.CATCH, e, result, restoreStackPtr, start, end, -1, finallyStart);
+        }
+        public TryCtx _finally(PendingResult res) {
+            return new TryCtx(TryState.FINALLY, error, res, restoreStackPtr, start, end, -1, -1);
+        }
 
-            this.tryStart = tryStart;
+        public TryCtx(TryState state, EngineException err, PendingResult res, int stackPtr, int start, int end, int catchStart, int finallyStart) {
-            this.catchStart = tryStart + tryN;
+            this.catchStart = catchStart;
-            this.finallyStart = catchStart + catchN;
+            this.finallyStart = finallyStart;
-            this.end = finallyStart + finallyN;
+            this.restoreStackPtr = stackPtr;
-            this.jumpPtr = end;
+            this.result = res == null ? PendingResult.ofNone() : res;
+            this.state = state;
+            this.start = start;
+            this.end = end;
+            this.error = err;
+        }
+    }
+
+    private static class PendingResult {
+        public final boolean isReturn, isJump, isThrow;
+        public final Object value;
+        public final EngineException error;
+        public final int ptr;
+        public final Instruction instruction;
+
+        private PendingResult(Instruction instr, boolean isReturn, boolean isJump, boolean isThrow, Object value, EngineException error, int ptr) {
+            this.instruction = instr;
+            this.isReturn = isReturn;
+            this.isJump = isJump;
+            this.isThrow = isThrow;
+            this.value = value;
+            this.error = error;
+            this.ptr = ptr;
+        }
+
+        public static PendingResult ofNone() {
+            return new PendingResult(null, false, false, false, null, null, 0);
+        }
+        public static PendingResult ofReturn(Object value, Instruction instr) {
+            return new PendingResult(instr, true, false, false, value, null, 0);
+        }
+        public static PendingResult ofThrow(EngineException error, Instruction instr) {
+            return new PendingResult(instr, false, false, true, null, error, 0);
+        }
+        public static PendingResult ofJump(int codePtr, Instruction instr) {
+            return new PendingResult(instr, false, true, false, null, null, codePtr);
         }
     }
 
@@ -50,11 +93,10 @@ public class CodeFrame {
     public final Object[] args;
     public final Stack<TryCtx> tryStack = new Stack<>();
     public final CodeFunction function;
-
     public Object[] stack = new Object[32];
     public int stackPtr = 0;
     public int codePtr = 0;
-    public boolean jumpFlag = false;
+    public boolean jumpFlag = false, popTryFlag = false;
     private Location prevLoc = null;
 
     public ObjectValue getLocalScope(Context ctx, boolean props) {
@@ -104,9 +146,9 @@ public class CodeFrame {
         };
     }
 
-    public void addTry(int n, int catchN, int finallyN) {
+    public void addTry(int start, int end, int catchStart, int finallyStart) {
-        var res = new TryCtx(codePtr + 1, n, catchN, finallyN);
+        var err = tryStack.empty() ? null : tryStack.peek().error;
-        if (!tryStack.empty()) res.err = tryStack.peek().err;
+        var res = new TryCtx(TryState.TRY, err, null, stackPtr, start, end, catchStart, finallyStart);
 
         tryStack.add(res);
     }
@@ -144,30 +186,29 @@ public class CodeFrame {
         stack[stackPtr++] = Values.normalize(ctx, val);
     }
 
-    private void setCause(Context ctx, EngineException err, EngineException cause) {
-        err.setCause(cause);
-    }
-
     public Object next(Context ctx, Object value, Object returnValue, EngineException error) {
         if (value != Runners.NO_RETURN) push(ctx, value);
 
+        Instruction instr = null;
+        if (codePtr >= 0 && codePtr < function.body.length) instr = function.body[codePtr];
+
         if (returnValue == Runners.NO_RETURN && error == null) {
             try {
                 if (Thread.currentThread().isInterrupted()) throw new InterruptException();
 
-                var instr = function.body[codePtr];
+                if (instr == null) returnValue = null;
-                ctx.engine.onInstruction(ctx, this, instr, Runners.NO_RETURN, null, false);
-
-                if (codePtr < 0 || codePtr >= function.body.length) returnValue = null;
                 else {
+                // System.out.println(instr + "@" + instr.location);
+                    ctx.engine.onInstruction(ctx, this, instr, Runners.NO_RETURN, null, false);
+
                     if (instr.location != null) prevLoc = instr.location;
 
                     try {
-                        this.jumpFlag = false;
+                        this.jumpFlag = this.popTryFlag = false;
                         returnValue = Runners.exec(ctx, instr, this);
                     }
                     catch (EngineException e) {
-                        error = e.add(function.name, prevLoc).setCtx(function.environment, ctx.engine);
+                        error = e.add(ctx, function.name, prevLoc);
                     }
                 }
             }
@@ -176,113 +217,84 @@ public class CodeFrame {
 
         while (!tryStack.empty()) {
             var tryCtx = tryStack.peek();
-            var newState = -1;
+            TryCtx newCtx = null;
 
-            switch (tryCtx.state) {
+            if (error != null) {
-                case TryCtx.STATE_TRY:
+                if (tryCtx.hasCatch()) newCtx = tryCtx._catch(error);
-                    if (error != null) {
+                else if (tryCtx.hasFinally()) newCtx = tryCtx._finally(PendingResult.ofThrow(error, instr));
-                        if (tryCtx.hasCatch) {
-                            tryCtx.err = error;
-                            newState = TryCtx.STATE_CATCH;
-                        }
-                        else if (tryCtx.hasFinally) {
-                            tryCtx.err = error;
-                            newState = TryCtx.STATE_FINALLY_THREW;
-                        }
-                        break;
-                    }
-                    else if (returnValue != Runners.NO_RETURN) {
-                        if (tryCtx.hasFinally) {
-                            tryCtx.retVal = returnValue;
-                            newState = TryCtx.STATE_FINALLY_RETURNED;
-                        }
-                        break;
-                    }
-                    else if (codePtr >= tryCtx.tryStart && codePtr < tryCtx.catchStart) return Runners.NO_RETURN;
-
-                    if (tryCtx.hasFinally) {
-                        if (jumpFlag) tryCtx.jumpPtr = codePtr;
-                        else tryCtx.jumpPtr = tryCtx.end;
-                        newState = TryCtx.STATE_FINALLY_JUMPED;
-                    }
-                    else codePtr = tryCtx.end;
-                    break;
-                case TryCtx.STATE_CATCH:
-                    if (error != null) {
-                        setCause(ctx, error, tryCtx.err);
-                        if (tryCtx.hasFinally) {
-                            tryCtx.err = error;
-                            newState = TryCtx.STATE_FINALLY_THREW;
-                        }
-                        break;
-                    }
-                    else if (returnValue != Runners.NO_RETURN) {
-                        if (tryCtx.hasFinally) {
-                            tryCtx.retVal = returnValue;
-                            newState = TryCtx.STATE_FINALLY_RETURNED;
-                        }
-                        break;
-                    }
-                    else if (codePtr >= tryCtx.catchStart && codePtr < tryCtx.finallyStart) return Runners.NO_RETURN;
-
-                    if (tryCtx.hasFinally) {
-                        if (jumpFlag) tryCtx.jumpPtr = codePtr;
-                        else tryCtx.jumpPtr = tryCtx.end;
-                        newState = TryCtx.STATE_FINALLY_JUMPED;
-                    }
-                    else codePtr = tryCtx.end;
-                    break;
-                case TryCtx.STATE_FINALLY_THREW:
-                    if (error != null) setCause(ctx, error, tryCtx.err);
-                    else if (codePtr < tryCtx.finallyStart || codePtr >= tryCtx.end) error = tryCtx.err;
-                    else if (returnValue == Runners.NO_RETURN) return Runners.NO_RETURN;
-                    break;
-                case TryCtx.STATE_FINALLY_RETURNED:
-                    if (error != null) setCause(ctx, error, tryCtx.err);
-                    if (returnValue == Runners.NO_RETURN) {
-                        if (codePtr < tryCtx.finallyStart || codePtr >= tryCtx.end) returnValue = tryCtx.retVal;
-                        else return Runners.NO_RETURN;
-                    }
-                    break;
-                case TryCtx.STATE_FINALLY_JUMPED:
-                    if (error != null) setCause(ctx, error, tryCtx.err);
-                    else if (codePtr < tryCtx.finallyStart || codePtr >= tryCtx.end) {
-                        if (!jumpFlag) codePtr = tryCtx.jumpPtr;
-                        else codePtr = tryCtx.end;
-                    }
-                    else if (returnValue == Runners.NO_RETURN) return Runners.NO_RETURN;
-                    break;
             }
-
+            else if (returnValue != Runners.NO_RETURN) {
-            if (tryCtx.state == TryCtx.STATE_CATCH) scope.catchVars.remove(scope.catchVars.size() - 1);
+                if (tryCtx.hasFinally()) newCtx = tryCtx._finally(PendingResult.ofReturn(returnValue, instr));
-
-            if (newState == -1) {
-                var err = tryCtx.err;
-                tryStack.pop();
-                if (!tryStack.isEmpty()) tryStack.peek().err = err;
-                continue;
             }
+            else if (jumpFlag && !tryCtx.inBounds(codePtr)) {
+                if (tryCtx.hasFinally()) newCtx = tryCtx._finally(PendingResult.ofJump(codePtr, instr));
+            }
+            else if (!this.popTryFlag) newCtx = tryCtx;
 
-            tryCtx.state = newState;
+            if (newCtx != null) {
-            switch (newState) {
+                if (newCtx != tryCtx) {
-                case TryCtx.STATE_CATCH:
+                    switch (newCtx.state) {
-                    scope.catchVars.add(new ValueVariable(false, tryCtx.err.value));
+                        case CATCH:
-                    codePtr = tryCtx.catchStart;
+                            if (tryCtx.state != TryState.CATCH) scope.catchVars.add(new ValueVariable(false, error.value));
-                    ctx.engine.onInstruction(ctx, this, function.body[codePtr], null, error, true);
+                            codePtr = tryCtx.catchStart;
-                    break;
+                            stackPtr = tryCtx.restoreStackPtr;
-                default:
+                            break;
+                        case FINALLY:
+                            if (tryCtx.state == TryState.CATCH) scope.catchVars.remove(scope.catchVars.size() - 1);
+                            codePtr = tryCtx.finallyStart;
+                            stackPtr = tryCtx.restoreStackPtr;
+                        default:
+                    }
+
+                    tryStack.pop();
+                    tryStack.push(newCtx);
+                }
+                error = null;
+                returnValue = Runners.NO_RETURN;
+                break;
+            }
+            else {
+                if (tryCtx.state == TryState.CATCH) scope.catchVars.remove(scope.catchVars.size() - 1);
+
+                if (tryCtx.state != TryState.FINALLY && tryCtx.hasFinally()) {
                     codePtr = tryCtx.finallyStart;
+                    stackPtr = tryCtx.restoreStackPtr;
+                    tryStack.pop();
+                    tryStack.push(tryCtx._finally(null));
+                    break;
+                }
+                else {
+                    tryStack.pop();
+                    codePtr = tryCtx.end;
+                    if (tryCtx.result.instruction != null) instr = tryCtx.result.instruction;
+                    if (tryCtx.result.isJump) {
+                        codePtr = tryCtx.result.ptr;
+                        jumpFlag = true;
+                    }
+                    if (tryCtx.result.isReturn) returnValue = tryCtx.result.value;
+                    if (tryCtx.result.isThrow) {
+                        error = tryCtx.result.error;
+                    }
+                    if (error != null) error.setCause(tryCtx.error);
+                    continue;
+                }
             }
-
-            return Runners.NO_RETURN;
         }
 
         if (error != null) {
-            ctx.engine.onInstruction(ctx, this, function.body[codePtr], null, error, false);
+            var caught = false;
+
+            for (var frame : ctx.frames()) {
+                for (var tryCtx : frame.tryStack) {
+                    if (tryCtx.state == TryState.TRY) caught = true;
+                }
+            }
+
+            ctx.engine.onInstruction(ctx, this, instr, null, error, caught);
             throw error;
         }
         if (returnValue != Runners.NO_RETURN) {
-            ctx.engine.onInstruction(ctx, this, function.body[codePtr], returnValue, null, false);
+            ctx.engine.onInstruction(ctx, this, instr, returnValue, null, false);
             return returnValue;
         }
 

src/me/topchetoeu/jscript/engine/frame/Runners.java

@@ -97,50 +97,37 @@ public class Runners {
             obj.defineProperty(ctx, "value", el);
             frame.push(ctx, obj);
         }
-        // var arr = new ObjectValue();
 
-        // var members = Values.getMembers(ctx, val, false, false);
-        // Collections.reverse(members);
-        // for (var el : members) {
-        //     if (el instanceof Symbol) continue;
-        //     arr.defineProperty(ctx, i++, el);
-        // }
-
-        // arr.defineProperty(ctx, "length", i);
-
-        // frame.push(ctx, arr);
         frame.codePtr++;
         return NO_RETURN;
     }
 
-    public static Object execTry(Context ctx, Instruction instr, CodeFrame frame) {
+    public static Object execTryStart(Context ctx, Instruction instr, CodeFrame frame) {
-        frame.addTry(instr.get(0), instr.get(1), instr.get(2));
+        int start = frame.codePtr + 1;
+        int catchStart = (int)instr.get(0);
+        int finallyStart = (int)instr.get(1);
+        if (finallyStart >= 0) finallyStart += start;
+        if (catchStart >= 0) catchStart += start;
+        int end = (int)instr.get(2) + start;
+        frame.addTry(start, end, catchStart, finallyStart);
         frame.codePtr++;
         return NO_RETURN;
     }
+    public static Object execTryEnd(Context ctx, Instruction instr, CodeFrame frame) {
+        frame.popTryFlag = true;
+        return NO_RETURN;
+    }
 
     public static Object execDup(Context ctx, Instruction instr, CodeFrame frame) {
-        int offset = instr.get(0), count = instr.get(1);
+        int count = instr.get(0);
 
         for (var i = 0; i < count; i++) {
-            frame.push(ctx, frame.peek(offset + count - 1));
+            frame.push(ctx, frame.peek(count - 1));
         }
 
         frame.codePtr++;
         return NO_RETURN;
     }
-    public static Object execMove(Context ctx, Instruction instr, CodeFrame frame) {
-        int offset = instr.get(0), count = instr.get(1);
-
-        var tmp = frame.take(offset);
-        var res = frame.take(count);
-
-        for (var i = 0; i < offset; i++) frame.push(ctx, tmp[i]);
-        for (var i = 0; i < count; i++) frame.push(ctx, res[i]);
-
-        frame.codePtr++;
-        return NO_RETURN;
-    }
     public static Object execLoadUndefined(Context ctx, Instruction instr, CodeFrame frame) {
         frame.push(ctx, null);
         frame.codePtr++;
@@ -179,16 +166,13 @@ public class Runners {
     }
     public static Object execLoadFunc(Context ctx, Instruction instr, CodeFrame frame) {
         long id = (Long)instr.get(0);
-        int localsN = (Integer)instr.get(1);
+        var captures = new ValueVariable[instr.params.length - 1];
-        int len = (Integer)instr.get(2);
-        var captures = new ValueVariable[instr.params.length - 3];
 
-        for (var i = 3; i < instr.params.length; i++) {
+        for (var i = 1; i < instr.params.length; i++) {
-            captures[i - 3] = frame.scope.get(instr.get(i));
+            captures[i - 1] = frame.scope.get(instr.get(i));
         }
 
-        var body = Engine.functions.get(id);
+        var func = new CodeFunction(ctx.environment(), "", Engine.functions.get(id), captures);
-        var func = new CodeFunction(ctx.environment(), "", localsN, len, captures, body);
 
         frame.push(ctx, func);
 
@@ -306,7 +290,6 @@ public class Runners {
         var val = frame.pop();
 
         if (!Values.deleteMember(ctx, val, key)) throw EngineException.ofSyntax("Can't delete member '" + key + "'.");
-        frame.push(ctx, true);
         frame.codePtr++;
         return NO_RETURN;
     }
@@ -330,10 +313,10 @@ public class Runners {
             case THROW_SYNTAX: return execThrowSyntax(ctx, instr, frame);
             case CALL: return execCall(ctx, instr, frame);
             case CALL_NEW: return execCallNew(ctx, instr, frame);
-            case TRY: return execTry(ctx, instr, frame);
+            case TRY_START: return execTryStart(ctx, instr, frame);
+            case TRY_END: return execTryEnd(ctx, instr, frame);
 
             case DUP: return execDup(ctx, instr, frame);
-            case MOVE: return execMove(ctx, instr, frame);
             case LOAD_VALUE: return execLoadValue(ctx, instr, frame);
             case LOAD_VAR: return execLoadVar(ctx, instr, frame);
             case LOAD_OBJ: return execLoadObj(ctx, instr, frame);

src/me/topchetoeu/jscript/engine/scope/GlobalScope.java

@@ -12,9 +12,6 @@ import me.topchetoeu.jscript.exceptions.EngineException;
 public class GlobalScope implements ScopeRecord {
     public final ObjectValue obj;
 
-    @Override
-    public GlobalScope parent() { return null; }
-
     public boolean has(Context ctx, String name) {
         return obj.hasMember(ctx, name, false);
     }
@@ -28,7 +25,7 @@ public class GlobalScope implements ScopeRecord {
         return new GlobalScope(obj);
     }
     public LocalScopeRecord child() {
-        return new LocalScopeRecord(this);
+        return new LocalScopeRecord();
     }
 
     public Object define(String name) {

src/me/topchetoeu/jscript/engine/scope/LocalScopeRecord.java

@@ -2,11 +2,8 @@ package me.topchetoeu.jscript.engine.scope;
 
 import java.util.ArrayList;
 
-import me.topchetoeu.jscript.engine.Context;
-
 public class LocalScopeRecord implements ScopeRecord {
     public final LocalScopeRecord parent;
-    public final GlobalScope global;
 
     private final ArrayList<String> captures = new ArrayList<>();
     private final ArrayList<String> locals = new ArrayList<>();
@@ -18,11 +15,8 @@ public class LocalScopeRecord implements ScopeRecord {
         return locals.toArray(String[]::new);
     }
 
-    @Override
-    public LocalScopeRecord parent() { return parent; }
-
     public LocalScopeRecord child() {
-        return new LocalScopeRecord(this, global);
+        return new LocalScopeRecord(this);
     }
 
     public int localsCount() {
@@ -62,12 +56,6 @@ public class LocalScopeRecord implements ScopeRecord {
 
         return name;
     }
-    public boolean has(Context ctx, String name) {
-        return
-            global.has(ctx, name) ||
-            locals.contains(name) ||
-            parent != null && parent.has(ctx, name);
-    }
     public Object define(String name, boolean force) {
         if (!force && locals.contains(name)) return locals.indexOf(name);
         locals.add(name);
@@ -80,12 +68,10 @@ public class LocalScopeRecord implements ScopeRecord {
         locals.remove(locals.size() - 1);
     }
 
-    public LocalScopeRecord(GlobalScope global) {
+    public LocalScopeRecord() {
         this.parent = null;
-        this.global = global;
     }
-    public LocalScopeRecord(LocalScopeRecord parent, GlobalScope global) {
+    public LocalScopeRecord(LocalScopeRecord parent) {
         this.parent = parent;
-        this.global = global;
     }
 }

src/me/topchetoeu/jscript/engine/scope/ScopeRecord.java

@@ -3,6 +3,5 @@ package me.topchetoeu.jscript.engine.scope;
 public interface ScopeRecord {
     public Object getKey(String name);
     public Object define(String name);
-    public ScopeRecord parent();
     public LocalScopeRecord child();
 }

src/me/topchetoeu/jscript/engine/values/CodeFunction.java

@@ -5,14 +5,12 @@ import me.topchetoeu.jscript.compilation.FunctionBody;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.engine.Context;
 import me.topchetoeu.jscript.engine.Environment;
-import me.topchetoeu.jscript.engine.StackData;
 import me.topchetoeu.jscript.engine.frame.CodeFrame;
 import me.topchetoeu.jscript.engine.frame.Runners;
 import me.topchetoeu.jscript.engine.scope.ValueVariable;
 
 public class CodeFunction extends FunctionValue {
     public final int localsN;
-    public final int length;
     public final Instruction[] body;
     public final String[] captureNames, localNames;
     public final ValueVariable[] captures;
@@ -35,7 +33,7 @@ public class CodeFunction extends FunctionValue {
     public Object call(Context ctx, Object thisArg, Object ...args) {
         var frame = new CodeFrame(ctx, thisArg, args, this);
         try {
-            StackData.pushFrame(ctx, frame);
+            ctx.pushFrame(frame);
 
             while (true) {
                 var res = frame.next(ctx, Runners.NO_RETURN, Runners.NO_RETURN, null);
@@ -43,18 +41,17 @@ public class CodeFunction extends FunctionValue {
             }
         }
         finally {
-            StackData.popFrame(ctx, frame);
+            ctx.popFrame(frame);
         }
     }
 
-    public CodeFunction(Environment environment, String name, int localsN, int length, ValueVariable[] captures, FunctionBody body) {
+    public CodeFunction(Environment environment, String name, FunctionBody body, ValueVariable... captures) {
-        super(name, length);
+        super(name, body.argsN);
         this.captures = captures;
         this.captureNames = body.captureNames;
         this.localNames = body.localNames;
         this.environment = environment;
-        this.localsN = localsN;
+        this.localsN = body.localsN;
-        this.length = length;
         this.body = body.instructions;
     }
 }

src/me/topchetoeu/jscript/engine/values/FunctionValue.java

@@ -11,7 +11,7 @@ public abstract class FunctionValue extends ObjectValue {
 
     @Override
     public String toString() {
-        return "function(...) {  ...}";
+        return String.format("function %s(...)", name);
     }
 
     public abstract Object call(Context ctx, Object thisArg, Object ...args);
@@ -21,21 +21,21 @@ public abstract class FunctionValue extends ObjectValue {
 
     @Override
     protected Object getField(Context ctx, Object key) {
-        if (key.equals("name")) return name;
+        if ("name".equals(key)) return name;
-        if (key.equals("length")) return length;
+        if ("length".equals(key)) return length;
         return super.getField(ctx, key);
     }
     @Override
     protected boolean setField(Context ctx, Object key, Object val) {
-        if (key.equals("name")) name = Values.toString(ctx, val);
+        if ("name".equals(key)) name = Values.toString(ctx, val);
-        else if (key.equals("length")) length = (int)Values.toNumber(ctx, val);
+        else if ("length".equals(key)) length = (int)Values.toNumber(ctx, val);
         else return super.setField(ctx, key, val);
         return true;
     }
     @Override
     protected boolean hasField(Context ctx, Object key) {
-        if (key.equals("name")) return true;
+        if ("name".equals(key)) return true;
-        if (key.equals("length")) return true;
+        if ("length".equals(key)) return true;
         return super.hasField(ctx, key);
     }
 

src/me/topchetoeu/jscript/engine/values/NativeWrapper.java

@@ -12,6 +12,19 @@ public class NativeWrapper extends ObjectValue {
         else return super.getPrototype(ctx);
     }
 
+    @Override
+    public String toString() {
+        return wrapped.toString();
+    }
+    @Override
+    public boolean equals(Object obj) {
+        return wrapped.equals(obj);
+    }
+    @Override
+    public int hashCode() {
+        return wrapped.hashCode();
+    }
+
     public NativeWrapper(Object wrapped) {
         this.wrapped = wrapped;
         prototype = NATIVE_PROTO;

src/me/topchetoeu/jscript/engine/values/ObjectValue.java

@@ -262,7 +262,7 @@ public class ObjectValue {
             values.put(key, val);
             return true;
         }
-        else if (key.equals("__proto__")) return setPrototype(ctx, val);
+        else if ("__proto__".equals(key)) return setPrototype(ctx, val);
         else if (nonWritableSet.contains(key)) return false;
         else return setField(ctx, key, val);
     }
@@ -273,7 +273,7 @@ public class ObjectValue {
     public final boolean hasMember(Context ctx, Object key, boolean own) {
         key = Values.normalize(ctx, key);
 
-        if (key != null && key.equals("__proto__")) return true;
+        if (key != null && "__proto__".equals(key)) return true;
         if (hasField(ctx, key)) return true;
         if (properties.containsKey(key)) return true;
         if (own) return false;

src/me/topchetoeu/jscript/engine/values/ScopeValue.java

@@ -1,51 +1,54 @@
-package me.topchetoeu.jscript.engine.values;
+package me.topchetoeu.jscript.engine.values;
-
+
-import java.util.HashMap;
+import java.util.HashMap;
-import java.util.List;
+import java.util.List;
-
+
-import me.topchetoeu.jscript.engine.Context;
+import me.topchetoeu.jscript.engine.Context;
-import me.topchetoeu.jscript.engine.scope.ValueVariable;
+import me.topchetoeu.jscript.engine.scope.ValueVariable;
-
+
-public class ScopeValue extends ObjectValue {
+public class ScopeValue extends ObjectValue {
-    public final ValueVariable[] variables;
+    public final ValueVariable[] variables;
-    public final HashMap<String, Integer> names = new HashMap<>();
+    public final HashMap<String, Integer> names = new HashMap<>();
-
+
-    @Override
+    @Override
-    protected Object getField(Context ctx, Object key) {
+    protected Object getField(Context ctx, Object key) {
-        if (names.containsKey(key)) return variables[names.get(key)].get(ctx);
+        if (names.containsKey(key)) return variables[names.get(key)].get(ctx);
-        return super.getField(ctx, key);
+        return super.getField(ctx, key);
-    }
+    }
-    @Override
+    @Override
-    protected boolean setField(Context ctx, Object key, Object val) {
+    protected boolean setField(Context ctx, Object key, Object val) {
-        if (names.containsKey(key)) {
+        if (names.containsKey(key)) {
-            variables[names.get(key)].set(ctx, val);
+            variables[names.get(key)].set(ctx, val);
-            return true;
+            return true;
-        }
+        }
-
+
-        return super.setField(ctx, key, val);
+        var proto = getPrototype(ctx);
-    }
+        if (proto != null && proto.hasField(ctx, key) && proto.setField(ctx, key, val)) return true;
-    @Override
+
-    protected void deleteField(Context ctx, Object key) {
+        return super.setField(ctx, key, val);
-        if (names.containsKey(key)) return;
+    }
-        super.deleteField(ctx, key);
+    @Override
-    }
+    protected void deleteField(Context ctx, Object key) {
-    @Override
+        if (names.containsKey(key)) return;
-    protected boolean hasField(Context ctx, Object key) {
+        super.deleteField(ctx, key);
-        if (names.containsKey(key)) return true;
+    }
-        return super.hasField(ctx, key);
+    @Override
-    }
+    protected boolean hasField(Context ctx, Object key) {
-    @Override
+        if (names.containsKey(key)) return true;
-    public List<Object> keys(boolean includeNonEnumerable) {
+        return super.hasField(ctx, key);
-        var res = super.keys(includeNonEnumerable);
+    }
-        res.addAll(names.keySet());
+    @Override
-        return res;
+    public List<Object> keys(boolean includeNonEnumerable) {
-    }
+        var res = super.keys(includeNonEnumerable);
-
+        res.addAll(names.keySet());
-    public ScopeValue(ValueVariable[] variables, String[] names) {
+        return res;
-        this.variables = variables;
+    }
-        for (var i = 0; i < names.length && i < variables.length; i++) {
+
-            this.names.put(names[i], i);
+    public ScopeValue(ValueVariable[] variables, String[] names) {
-            this.nonConfigurableSet.add(names[i]);
+        this.variables = variables;
-        }
+        for (var i = 0; i < names.length && i < variables.length; i++) {
-    }
+            this.names.put(names[i], i);
-}
+            this.nonConfigurableSet.add(names[i]);
+        }
+    }
+}

src/me/topchetoeu/jscript/engine/values/Values.java

@@ -17,8 +17,27 @@ import me.topchetoeu.jscript.exceptions.ConvertException;
 import me.topchetoeu.jscript.exceptions.EngineException;
 import me.topchetoeu.jscript.exceptions.SyntaxException;
 import me.topchetoeu.jscript.exceptions.UncheckedException;
+import me.topchetoeu.jscript.lib.PromiseLib;
 
 public class Values {
+    public static enum CompareResult {
+        NOT_EQUAL,
+        EQUAL,
+        LESS,
+        GREATER;
+
+        public boolean less() { return this == LESS; }
+        public boolean greater() { return this == GREATER; }
+        public boolean lessOrEqual() { return this == LESS || this == EQUAL; }
+        public boolean greaterOrEqual() { return this == GREATER || this == EQUAL; }
+
+        public static CompareResult from(int cmp) {
+            if (cmp < 0) return LESS;
+            if (cmp > 0) return GREATER;
+            return EQUAL;
+        }
+    }
+
     public static final Object NULL = new Object();
 
     public static boolean isObject(Object val) { return val instanceof ObjectValue; }
@@ -51,8 +70,7 @@ public class Values {
 
     @SuppressWarnings("unchecked")
     public static <T> T wrapper(Object val, Class<T> clazz) { 
-        if (!isWrapper(val)) return null;
+        if (!isWrapper(val)) val = new NativeWrapper(val);
-
         var res = (NativeWrapper)val;
         if (res != null && clazz.isInstance(res.wrapped)) return (T)res.wrapped;
         else return null;
@@ -105,7 +123,7 @@ public class Values {
     }
     public static boolean toBoolean(Object obj) {
         if (obj == NULL || obj == null) return false;
-        if (obj instanceof Number && number(obj) == 0) return false;
+        if (obj instanceof Number && (number(obj) == 0 || Double.isNaN(number(obj)))) return false;
         if (obj instanceof String && ((String)obj).equals("")) return false;
         if (obj instanceof Boolean) return (Boolean)obj;
         return true;
@@ -137,7 +155,7 @@ public class Values {
         }
         if (val instanceof Boolean) return (Boolean)val ? "true" : "false";
         if (val instanceof String) return (String)val;
-        if (val instanceof Symbol) return ((Symbol)val).toString();
+        if (val instanceof Symbol) return val.toString();
 
         return "Unknown value";
     }
@@ -191,12 +209,18 @@ public class Values {
         return _a >>> _b;
     }
 
-    public static int compare(Context ctx, Object a, Object b) {
+    public static CompareResult compare(Context ctx, Object a, Object b) {
         a = toPrimitive(ctx, a, ConvertHint.VALUEOF);
         b = toPrimitive(ctx, b, ConvertHint.VALUEOF);
 
-        if (a instanceof String && b instanceof String) return ((String)a).compareTo((String)b);
+        if (a instanceof String && b instanceof String) CompareResult.from(((String)a).compareTo((String)b));
-        else return Double.compare(toNumber(ctx, a), toNumber(ctx, b));
+
+        var _a = toNumber(ctx, a);
+        var _b = toNumber(ctx, b);
+
+        if (Double.isNaN(_a) || Double.isNaN(_b)) return CompareResult.NOT_EQUAL;
+
+        return CompareResult.from(Double.compare(_a, _b));
     }
 
     public static boolean not(Object obj) {
@@ -232,10 +256,10 @@ public class Values {
             case LOOSE_EQUALS: return looseEqual(ctx, args[0], args[1]);
             case LOOSE_NOT_EQUALS: return !looseEqual(ctx, args[0], args[1]);
 
-            case GREATER: return compare(ctx, args[0], args[1]) > 0;
+            case GREATER: return compare(ctx, args[0], args[1]).greater();
-            case GREATER_EQUALS: return compare(ctx, args[0], args[1]) >= 0;
+            case GREATER_EQUALS: return compare(ctx, args[0], args[1]).greaterOrEqual();
-            case LESS: return compare(ctx, args[0], args[1]) < 0;
+            case LESS: return compare(ctx, args[0], args[1]).less();
-            case LESS_EQUALS: return compare(ctx, args[0], args[1]) <= 0;
+            case LESS_EQUALS: return compare(ctx, args[0], args[1]).lessOrEqual();
 
             case INVERSE: return bitwiseNot(ctx, args[0]);
             case NOT: return not(args[0]);
@@ -272,15 +296,20 @@ public class Values {
 
         var proto = getPrototype(ctx, obj);
 
-        if (proto == null) return key.equals("__proto__") ? NULL : null;
+        if (proto == null) return "__proto__".equals(key) ? NULL : null;
-        else if (key != null && key.equals("__proto__")) return proto;
+        else if (key != null && "__proto__".equals(key)) return proto;
         else return proto.getMember(ctx, key, obj);
     }
+    public static Object getMemberPath(Context ctx, Object obj, Object ...path) {
+        var res = obj;
+        for (var key : path) res = getMember(ctx, res, key);
+        return res;
+    }
     public static boolean setMember(Context ctx, Object obj, Object key, Object val) {
         obj = normalize(ctx, obj); key = normalize(ctx, key); val = normalize(ctx, val);
         if (obj == null) throw EngineException.ofType("Tried to access member of undefined.");
         if (obj == NULL) throw EngineException.ofType("Tried to access member of null.");
-        if (key.equals("__proto__")) return setPrototype(ctx, obj, val);
+        if (key != null && "__proto__".equals(key)) return setPrototype(ctx, obj, val);
         if (isObject(obj)) return object(obj).setMember(ctx, key, val, false);
 
         var proto = getPrototype(ctx, obj);
@@ -290,7 +319,7 @@ public class Values {
         if (obj == null || obj == NULL) return false;
         obj = normalize(ctx, obj); key = normalize(ctx, key);
 
-        if (key.equals("__proto__")) return true;
+        if ("__proto__".equals(key)) return true;
         if (isObject(obj)) return object(obj).hasMember(ctx, key, own);
 
         if (obj instanceof String && key instanceof Number) {
@@ -518,7 +547,7 @@ public class Values {
         throw new ConvertException(type(obj), clazz.getSimpleName());
     }
 
-    public static Iterable<Object> toJavaIterable(Context ctx, Object obj) {
+    public static Iterable<Object> fromJSIterator(Context ctx, Object obj) {
         return () -> {
             try {
                 var symbol = ctx.environment().symbol("Symbol.iterator");
@@ -571,7 +600,7 @@ public class Values {
         };
     }
 
-    public static ObjectValue fromJavaIterator(Context ctx, Iterator<?> it) {
+    public static ObjectValue toJSIterator(Context ctx, Iterator<?> it) {
         var res = new ObjectValue();
 
         try {
@@ -592,10 +621,43 @@ public class Values {
         return res;
     }
 
-    public static ObjectValue fromJavaIterable(Context ctx, Iterable<?> it) {
+    public static ObjectValue toJSIterator(Context ctx, Iterable<?> it) {
-        return fromJavaIterator(ctx, it.iterator());
+        return toJSIterator(ctx, it.iterator());
     }
 
+    public static ObjectValue toJSAsyncIterator(Context ctx, Iterator<?> it) {
+        var res = new ObjectValue();
+
+        try {
+            var key = getMemberPath(ctx, ctx.environment().proto("symbol"), "constructor", "asyncIterator");
+            res.defineProperty(ctx, key, new NativeFunction("", (_ctx, thisArg, args) -> thisArg));
+        }
+        catch (IllegalArgumentException | NullPointerException e) { }
+
+        res.defineProperty(ctx, "next", new NativeFunction("", (_ctx, _th, _args) -> {
+            return PromiseLib.await(ctx, () -> {
+                if (!it.hasNext()) return new ObjectValue(ctx, Map.of("done", true));
+                else {
+                    var obj = new ObjectValue();
+                    obj.defineProperty(_ctx, "value", it.next());
+                    return obj;
+                }
+            });
+        }));
+
+        return res;
+    }
+
+    private static boolean isEmptyFunc(ObjectValue val) {
+        if (!(val instanceof FunctionValue)) return false;
+        if (!val.values.containsKey("prototype") || val.values.size() + val.properties.size() > 1) return false;
+        var proto = val.values.get("prototype");
+        if (!(proto instanceof ObjectValue)) return false;
+        var protoObj = (ObjectValue)proto;
+        if (protoObj.values.get("constructor") != val) return false;
+        if (protoObj.values.size() + protoObj.properties.size() != 1) return false;
+        return true;
+    }
     private static void printValue(Context ctx, Object val, HashSet<Object> passed, int tab) {
         if (tab == 0 && val instanceof String) {
             System.out.print(val);
@@ -610,10 +672,7 @@ public class Values {
         var printed = true;
 
         if (val instanceof FunctionValue) {
-            System.out.print("function ");
+            System.out.print(val.toString());
-            var name = Values.getMember(ctx, val, "name");
-            if (name != null) System.out.print(Values.toString(ctx, name));
-            System.out.print("(...)");
             var loc = val instanceof CodeFunction ? ((CodeFunction)val).loc() : null;
 
             if (loc != null) System.out.print(" @ " + loc);
@@ -643,7 +702,7 @@ public class Values {
             passed.add(val);
 
             var obj = (ObjectValue)val;
-            if (obj.values.size() + obj.properties.size() == 0) {
+            if (obj.values.size() + obj.properties.size() == 0 || isEmptyFunc(obj)) {
                 if (!printed) System.out.println("{}");
             }
             else {
@@ -661,12 +720,13 @@ public class Values {
                     printValue(ctx, el.getKey(), passed, tab + 1);
                     System.out.println(": [prop],");
                 }
-    
+
                 for (int i = 0; i < tab; i++) System.out.print("    ");
                 System.out.print("}");
-    
+
-                passed.remove(val);
             }
+
+            passed.remove(val);
         }
         else if (val == null) System.out.print("undefined");
         else if (val == Values.NULL) System.out.print("null");

src/me/topchetoeu/jscript/exceptions/EngineException.java

@@ -12,19 +12,48 @@ import me.topchetoeu.jscript.engine.values.Values;
 import me.topchetoeu.jscript.engine.values.ObjectValue.PlaceholderProto;
 
 public class EngineException extends RuntimeException {
+    public static class StackElement {
+        public final Location location;
+        public final String function;
+        public final Context ctx;
+
+        public boolean visible() {
+            return ctx == null || ctx.environment() == null || ctx.environment().stackVisible;
+        }
+        public String toString() {
+            var res = "";
+            var loc = location;
+
+            if (loc != null && ctx != null && ctx.engine != null) loc = ctx.engine.mapToCompiled(loc);
+
+            if (loc != null) res += "at " + loc.toString() + " ";
+            if (function != null && !function.equals("")) res += "in " + function + " ";
+
+            return res.trim();
+        }
+
+        public StackElement(Context ctx, Location location, String function) {
+            if (function != null) function = function.trim();
+            if (function.equals("")) function = null;
+
+            if (ctx == null) this.ctx = null;
+            else this.ctx = new Context(ctx.engine).pushEnv(ctx.environment());
+            this.location = location;
+            this.function = function;
+        }
+    }
+
     public final Object value;
     public EngineException cause;
     public Environment env = null;
     public Engine engine = null;
-    public final List<String> stackTrace = new ArrayList<>();
+    public final List<StackElement> stackTrace = new ArrayList<>();
 
-    public EngineException add(String name, Location location) {
+    public EngineException add(Context ctx, String name, Location location) {
-        var res = "";
+        var el = new StackElement(ctx, location, name);
-
+        if (el.function == null && el.location == null) return this;
-        if (location != null) res += "at " + location.toString() + " ";
+        setCtx(ctx.environment(), ctx.engine);
-        if (name != null && !name.equals("")) res += "in " + name + " ";
+        stackTrace.add(el);
-
-        this.stackTrace.add(res.trim());
         return this;
     }
     public EngineException setCause(EngineException cause) {
@@ -46,7 +75,7 @@ public class EngineException extends RuntimeException {
             ss.append("[Error while stringifying]\n");
         }
         for (var line : stackTrace) {
-            ss.append("    ").append(line).append('\n');
+            if (line.visible()) ss.append("    ").append(line.toString()).append("\n");
         }
         if (cause != null) ss.append("Caused by ").append(cause.toString(ctx)).append('\n');
         ss.deleteCharAt(ss.length() - 1);
@@ -74,7 +103,7 @@ public class EngineException extends RuntimeException {
         return new EngineException(err(null, msg, PlaceholderProto.ERROR));
     }
     public static EngineException ofSyntax(SyntaxException e) {
-        return new EngineException(err(null, e.msg, PlaceholderProto.SYNTAX_ERROR)).add(null, e.loc);
+        return new EngineException(err(null, e.msg, PlaceholderProto.SYNTAX_ERROR)).add(null, null, e.loc);
     }
     public static EngineException ofSyntax(String msg) {
         return new EngineException(err(null, msg, PlaceholderProto.SYNTAX_ERROR));

src/me/topchetoeu/jscript/filesystem/EntryType.java

@@ -1,7 +1,13 @@
 package me.topchetoeu.jscript.filesystem;
 
 public enum EntryType {
-    NONE,
+    NONE("none"),
-    FILE,
+    FILE("file"),
-    FOLDER,
+    FOLDER("folder");
+
+    public final String name;
+
+    private EntryType(String name) {
+        this.name = name;
+    }
 }

src/me/topchetoeu/jscript/filesystem/File.java

@@ -1,27 +1,41 @@
-package me.topchetoeu.jscript.filesystem;
+package me.topchetoeu.jscript.filesystem;
-
+
-import java.io.IOException;
+import me.topchetoeu.jscript.Buffer;
-
+
-public interface File {
+public interface File {
-    int read() throws IOException, InterruptedException;
+    int read(byte[] buff);
-    boolean write(byte val) throws IOException, InterruptedException;
+    void write(byte[] buff);
-    long tell() throws IOException, InterruptedException;
+    long getPtr();
-    void seek(long offset, int pos) throws IOException, InterruptedException;
+    void setPtr(long offset, int pos);
-    void close() throws IOException, InterruptedException;
+    void close();
-    Permissions perms();
+    Mode mode();
-
+
-    default String readToString() throws IOException, InterruptedException {
+    default String readToString() {
-        seek(0, 2);
+        setPtr(0, 2);
-        long len = tell();
+        long len = getPtr();
-        if (len < 0) return null;
+        if (len < 0) return null;
-
+
-        seek(0, 0);
+        setPtr(0, 0);
-        byte[] res = new byte[(int)len];
+
-
+        byte[] res = new byte[(int)len];
-        for (var i = 0; i < len; i++) {
+        read(res);
-            res[i] = (byte)read();
+
-        }
+        return new String(res);
-
+    }
-        return new String(res);
+    default String readLine() {
-    }
+        var res = new Buffer();
+        var buff = new byte[1];
+
+        while (true) {
+            if (read(buff) == 0) {
+                if (res.length() == 0) return null;
+                else break;
+            }
+
+            if (buff[0] == '\n') break;
+
+            res.write(res.length(), buff);
+        }
+        return new String(res.data());
+    }
 }

src/me/topchetoeu/jscript/filesystem/FileStat.java

@@ -0,0 +1,11 @@
+package me.topchetoeu.jscript.filesystem;
+
+public class FileStat {
+    public final Mode mode;
+    public final EntryType type;
+
+    public FileStat(Mode mode, EntryType type) {
+        this.mode = mode;
+        this.type = type;
+    }
+}

src/me/topchetoeu/jscript/filesystem/Filesystem.java

@@ -1,10 +1,7 @@
 package me.topchetoeu.jscript.filesystem;
 
-import java.io.IOException;
-
 public interface Filesystem {
-    File open(String path) throws IOException, InterruptedException;
+    File open(String path, Mode mode) throws FilesystemException;
-    boolean mkdir(String path) throws IOException, InterruptedException;
+    void create(String path, EntryType type) throws FilesystemException;
-    EntryType type(String path) throws IOException, InterruptedException;
+    FileStat stat(String path) throws FilesystemException;
-    boolean rm(String path) throws IOException, InterruptedException;
+}
-}

src/me/topchetoeu/jscript/filesystem/FilesystemException.java

@@ -0,0 +1,55 @@
+package me.topchetoeu.jscript.filesystem;
+
+import me.topchetoeu.jscript.engine.values.Values;
+import me.topchetoeu.jscript.exceptions.EngineException;
+
+public class FilesystemException extends RuntimeException {
+    public static enum FSCode {
+        DOESNT_EXIST(0x1),
+        NOT_FILE(0x2),
+        NOT_FOLDER(0x3),
+        NO_PERMISSIONS_R(0x4),
+        NO_PERMISSIONS_RW(0x5),
+        FOLDER_NOT_EMPTY(0x6),
+        ALREADY_EXISTS(0x7),
+        FOLDER_EXISTS(0x8);
+
+        public final int code;
+
+        private FSCode(int code) { this.code = code; }
+    }
+
+    public static final String[] MESSAGES = {
+        "How did we get here?",
+        "The file or folder '%s' doesn't exist or is inaccessible.",
+        "'%s' is not a file",
+        "'%s' is not a folder",
+        "No permissions to read '%s'",
+        "No permissions to write '%s'",
+        "Can't delete '%s', since it is a full folder.",
+        "'%s' already exists."
+    };
+
+    public final String message, filename;
+    public final FSCode code;
+
+    public FilesystemException(String message, String filename, FSCode code) {
+        super(code + ": " + String.format(message, filename));
+        this.message = message;
+        this.code = code;
+        this.filename = filename;
+    }
+    public FilesystemException(String filename, FSCode code) {
+        super(code + ": " + String.format(MESSAGES[code.code], filename));
+        this.message = MESSAGES[code.code];
+        this.code = code;
+        this.filename = filename;
+    }
+
+    public EngineException toEngineException() {
+        var res = EngineException.ofError("IOError", getMessage());
+        Values.setMember(null, res.value, "code", code);
+        Values.setMember(null, res.value, "filename", filename.toString());
+        return res;
+    }
+}

src/me/topchetoeu/jscript/filesystem/InaccessibleFile.java

@@ -1,35 +0,0 @@
-package me.topchetoeu.jscript.filesystem;
-
-import java.io.IOException;
-
-public class InaccessibleFile implements File {
-    public static final InaccessibleFile INSTANCE = new InaccessibleFile();
-
-    @Override
-    public int read() throws IOException, InterruptedException {
-        return -1;
-    }
-
-    @Override
-    public boolean write(byte val) throws IOException, InterruptedException {
-        return false;
-    }
-
-    @Override
-    public long tell() throws IOException, InterruptedException {
-        return 0;
-    }
-
-    @Override
-    public void seek(long offset, int pos) throws IOException, InterruptedException { }
-
-    @Override
-    public void close() throws IOException, InterruptedException { }
-
-    @Override
-    public Permissions perms() {
-        return Permissions.NONE;
-    }
-
-    private InaccessibleFile() { }
-}

src/me/topchetoeu/jscript/filesystem/MemoryFile.java

@@ -1,53 +1,67 @@
-package me.topchetoeu.jscript.filesystem;
+package me.topchetoeu.jscript.filesystem;
-
+
-import java.io.IOException;
+import me.topchetoeu.jscript.Buffer;
-
+import me.topchetoeu.jscript.filesystem.FilesystemException.FSCode;
-public class MemoryFile implements File {
+
-    private int ptr;
+public class MemoryFile implements File {
-    private Permissions mode;
+    private int ptr;
-    public final byte[] data;
+    private Mode mode;
-
+    private Buffer data;
-    @Override
+    private String filename;
-    public int read() throws IOException, InterruptedException {
+
-        if (data == null || !mode.readable || ptr >= data.length) return -1;
+    public Buffer data() { return data; }
-        return data[ptr++];
+
-    }
+    @Override
-
+    public int read(byte[] buff) {
-    @Override
+        if (data == null || !mode.readable) throw new FilesystemException(filename, FSCode.NO_PERMISSIONS_R);
-    public boolean write(byte val) throws IOException, InterruptedException {
+        var res = data.read(ptr, buff);
-        if (data == null || !mode.writable || ptr >= data.length) return false;
+        ptr += res;
-        data[ptr++] = val;
+        return res;
-        return true;
+    }
-    }
+    @Override
-
+    public void write(byte[] buff) {
-    @Override
+        if (data == null || !mode.writable) throw new FilesystemException(filename, FSCode.NO_PERMISSIONS_RW);
-    public long tell() throws IOException, InterruptedException {
+
-        return ptr;
+        data.write(ptr, buff);
-    }
+        ptr += buff.length;
-
+    }
-    @Override
+
-    public void seek(long offset, int pos) throws IOException, InterruptedException {
+    @Override
-        if (data == null) return;
+    public long getPtr() {
-
+        if (data == null || !mode.readable) throw new FilesystemException(filename, FSCode.NO_PERMISSIONS_R);
-        if (pos == 0) ptr = (int)offset;
+        return ptr;
-        else if (pos == 1) ptr += (int)offset;
+    }
-        else if (pos == 2) ptr = data.length - (int)offset;
+    @Override
-    }
+    public void setPtr(long offset, int pos) {
-
+        if (data == null || !mode.readable) throw new FilesystemException(filename, FSCode.NO_PERMISSIONS_R);
-    @Override
+
-    public void close() throws IOException, InterruptedException {
+        if (pos == 0) ptr = (int)offset;
-        mode = null;
+        else if (pos == 1) ptr += (int)offset;
-        ptr = 0;
+        else if (pos == 2) ptr = data.length() - (int)offset;
-    }
+    }
-
+
-    @Override
+    @Override
-    public Permissions perms() {
+    public void close() {
-        if (data == null) return Permissions.NONE;
+        mode = Mode.NONE;
-        return mode;
+        ptr = 0;
-    }
+    }
-
+    @Override
-    public MemoryFile(byte[] buff, Permissions mode) {
+    public Mode mode() {
-        this.data = buff;
+        if (data == null) return Mode.NONE;
-        this.mode = mode;
+        return mode;
-    }
+    }
-}
+
+    public MemoryFile(String filename, Buffer buff, Mode mode) {
+        this.filename = filename;
+        this.data = buff;
+        this.mode = mode;
+    }
+
+    public static MemoryFile fromFileList(String filename, java.io.File[] list) {
+        var res = new StringBuilder();
+
+        for (var el : list) res.append(el.getName()).append('\n');
+
+        return new MemoryFile(filename, new Buffer(res.toString().getBytes()), Mode.READ);
+    }
+}

src/me/topchetoeu/jscript/filesystem/MemoryFilesystem.java

@@ -0,0 +1,90 @@
+package me.topchetoeu.jscript.filesystem;
+
+import java.nio.file.Path;
+import java.util.HashMap;
+import java.util.HashSet;
+
+import me.topchetoeu.jscript.Buffer;
+import me.topchetoeu.jscript.filesystem.FilesystemException.FSCode;
+
+public class MemoryFilesystem implements Filesystem {
+    public final Mode mode;
+    private HashMap<Path, Buffer> files = new HashMap<>();
+    private HashSet<Path> folders = new HashSet<>();
+
+    private Path getPath(String name) {
+        return Path.of("/" + name.replace("\\", "/")).normalize();
+    }
+
+    @Override
+    public void create(String path, EntryType type) {
+        var _path = getPath(path);
+
+        switch (type) {
+            case FILE:
+                if (!folders.contains(_path.getParent())) throw new FilesystemException(path, FSCode.DOESNT_EXIST);
+                if (folders.contains(_path) || files.containsKey(_path)) throw new FilesystemException(path, FSCode.ALREADY_EXISTS);
+                if (folders.contains(_path)) throw new FilesystemException(path, FSCode.ALREADY_EXISTS);
+                files.put(_path, new Buffer());
+                break;
+            case FOLDER:
+                if (!folders.contains(_path.getParent())) throw new FilesystemException(path, FSCode.DOESNT_EXIST);
+                if (folders.contains(_path) || files.containsKey(_path)) throw new FilesystemException(path, FSCode.ALREADY_EXISTS);
+                folders.add(_path);
+                break;
+            default:
+            case NONE:
+                if (!folders.remove(_path) && files.remove(_path) == null) throw new FilesystemException(path, FSCode.DOESNT_EXIST);
+        }
+    }
+
+    @Override
+    public File open(String path, Mode perms) {
+        var _path = getPath(path);
+        var pcount = _path.getNameCount();
+
+        if (files.containsKey(_path)) return new MemoryFile(path, files.get(_path), perms);
+        else if (folders.contains(_path)) {
+            var res = new StringBuilder();
+            for (var folder : folders) {
+                if (pcount + 1 != folder.getNameCount()) continue;
+                if (!folder.startsWith(_path)) continue;
+                res.append(folder.toFile().getName()).append('\n');
+            }
+            for (var file : files.keySet()) {
+                if (pcount + 1 != file.getNameCount()) continue;
+                if (!file.startsWith(_path)) continue;
+                res.append(file.toFile().getName()).append('\n');
+            }
+            return new MemoryFile(path, new Buffer(res.toString().getBytes()), perms.intersect(Mode.READ));
+        }
+        else throw new FilesystemException(path, FSCode.DOESNT_EXIST);
+    }
+
+    @Override
+    public FileStat stat(String path) {
+        var _path = getPath(path);
+
+        if (files.containsKey(_path)) return new FileStat(mode, EntryType.FILE);
+        else if (folders.contains(_path)) return new FileStat(mode, EntryType.FOLDER);
+        else throw new FilesystemException(path, FSCode.DOESNT_EXIST);
+    }
+
+    public MemoryFilesystem put(String path, byte[] data) {
+        var _path = getPath(path);
+        var _curr = "/";
+
+        for (var seg : _path) {
+            create(_curr, EntryType.FOLDER);
+            _curr += seg + "/";
+        }
+
+        files.put(_path, new Buffer(data));
+        return this;
+    }
+
+    public MemoryFilesystem(Mode mode) {
+        this.mode = mode;
+        folders.add(Path.of("/"));
+    }
+}

src/me/topchetoeu/jscript/filesystem/Mode.java

@@ -0,0 +1,31 @@
+package me.topchetoeu.jscript.filesystem;
+
+public enum Mode {
+    NONE("", false, false),
+    READ("r", true, false),
+    READ_WRITE("rw", true, true);
+
+    public final String name;
+    public final boolean readable;
+    public final boolean writable;
+
+    public Mode intersect(Mode other) {
+        if (this == NONE || other == NONE) return NONE;
+        if (this == READ_WRITE && other == READ_WRITE) return READ_WRITE;
+        return READ;
+    }
+
+    private Mode(String mode, boolean r, boolean w) {
+        this.name = mode;
+        this.readable = r;
+        this.writable = w;
+    }
+
+    public static Mode parse(String mode) {
+        switch (mode) {
+            case "r": return READ;
+            case "rw": return READ_WRITE;
+            default: return NONE;
+        }
+    }
+}

src/me/topchetoeu/jscript/filesystem/Permissions.java

@@ -1,17 +0,0 @@
-package me.topchetoeu.jscript.filesystem;
-
-public enum Permissions {
-    NONE("", false, false),
-    READ("r", true, false),
-    READ_WRITE("rw", true, true);
-
-    public final String readMode;
-    public final boolean readable;
-    public final boolean writable;
-
-    private Permissions(String mode, boolean r, boolean w) {
-        this.readMode = mode;
-        this.readable = r;
-        this.writable = w;
-    }
-}

src/me/topchetoeu/jscript/filesystem/PhysicalFile.java

@@ -1,50 +1,62 @@
 package me.topchetoeu.jscript.filesystem;
 
+import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.RandomAccessFile;
 
+import me.topchetoeu.jscript.filesystem.FilesystemException.FSCode;
+
 public class PhysicalFile implements File {
+    private String filename;
     private RandomAccessFile file;
-    private Permissions perms;
+    private Mode perms;
 
     @Override
-    public int read() throws IOException, InterruptedException {
+    public int read(byte[] buff) {
-        if (file == null || !perms.readable) return -1;
+        if (file == null || !perms.readable) throw new FilesystemException(filename, FSCode.NO_PERMISSIONS_R);
-        else return file.read();
+        else try { return file.read(buff); }
+        catch (IOException e) { throw new FilesystemException(filename, FSCode.NO_PERMISSIONS_R); }
+    }
+    @Override
+    public void write(byte[] buff) {
+        if (file == null || !perms.writable) throw new FilesystemException(filename, FSCode.NO_PERMISSIONS_RW);
+        else try { file.write(buff); }
+        catch (IOException e) { throw new FilesystemException(filename, FSCode.NO_PERMISSIONS_RW); }
     }
 
     @Override
-    public boolean write(byte val) throws IOException, InterruptedException {
+    public long getPtr() {
-        if (file == null || !perms.writable) return false;
+        if (file == null || !perms.readable) throw new FilesystemException(filename, FSCode.NO_PERMISSIONS_R);
-        file.write(val);
+        else try { return file.getFilePointer(); }
-        return true;
+        catch (IOException e) { throw new FilesystemException(filename, FSCode.NO_PERMISSIONS_R); }
+    }
+    @Override
+    public void setPtr(long offset, int pos) {
+        if (file == null || !perms.readable) throw new FilesystemException(filename, FSCode.NO_PERMISSIONS_R);
+
+        try {
+            if (pos == 1) pos += file.getFilePointer();
+            else if (pos == 2) pos += file.length();
+            file.seek(pos);
+        }
+        catch (IOException e) { throw new FilesystemException(filename, FSCode.NO_PERMISSIONS_R); }
     }
 
     @Override
-    public long tell() throws IOException, InterruptedException {
+    public void close() {
-        if (file == null) return 0;
-        return file.getFilePointer();
-    }
-    @Override
-    public void seek(long offset, int pos) throws IOException, InterruptedException {
         if (file == null) return;
-        if (pos == 0) file.seek(pos);
+        try { file.close(); }
-        else if (pos == 1) file.seek(file.getFilePointer() + pos);
+        catch (IOException e) {} // SHUT
-        else if (pos == 2) file.seek(file.length() + pos);
+        file = null;
+        perms = Mode.NONE;
     }
-
     @Override
-    public void close() throws IOException, InterruptedException {
+    public Mode mode() { return perms; }
-        if (file == null) return;
-        file.close();
-    }
 
-    @Override
+    public PhysicalFile(String path, Mode mode) throws FileNotFoundException {
-    public Permissions perms() { return perms; }
+        if (mode == Mode.NONE) file = null;
-    
+        else try { file = new RandomAccessFile(path, mode.name); }
-    public PhysicalFile(String path, Permissions mode) throws IOException {
+        catch (FileNotFoundException e) { throw new FilesystemException(filename, FSCode.DOESNT_EXIST); }
-        if (mode == Permissions.NONE) file = null;
-        else file = new RandomAccessFile(path, mode.readMode);
 
         perms = mode;
     }

src/me/topchetoeu/jscript/filesystem/PhysicalFilesystem.java

@@ -1,74 +1,74 @@
 package me.topchetoeu.jscript.filesystem;
 
+import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.nio.file.Path;
 
+import me.topchetoeu.jscript.filesystem.FilesystemException.FSCode;
+
 public class PhysicalFilesystem implements Filesystem {
     public final Path root;
 
-    private Permissions getPerms(Path path) {
-        var file = path.toFile();
-        if (!path.startsWith(root)) return Permissions.NONE;
-        if (file.canRead() && file.canWrite()) return Permissions.READ_WRITE;
-        if (file.canRead()) return Permissions.READ;
-
-        return Permissions.NONE;
-    }
     private Path getPath(String name) {
-        return root.resolve(name);
+        return root.resolve(name.replace("\\", "/")).normalize();
+    }
+
+    private void checkMode(Path path, Mode mode) {
+        if (!path.startsWith(root)) throw new FilesystemException(path.toString(), FSCode.NO_PERMISSIONS_R);
+        if (mode.readable && !path.toFile().canRead()) throw new FilesystemException(path.toString(), FSCode.NO_PERMISSIONS_R);
+        if (mode.writable && !path.toFile().canWrite()) throw new FilesystemException(path.toString(), FSCode.NO_PERMISSIONS_RW);
     }
 
     @Override
-    public File open(String path) throws IOException, InterruptedException {
+    public File open(String path, Mode perms) {
-        var _path = root.resolve(path);
+        var _path = getPath(path);
-
-        var perms = getPerms(_path);
-        if (perms == Permissions.NONE) return InaccessibleFile.INSTANCE;
-
         var f = _path.toFile();
 
-        if (f.isDirectory()) {
+        checkMode(_path, perms);
-            var res = new StringBuilder();
 
-            for (var child : f.listFiles()) res.append(child.toString()).append('\n');
 
-            return new MemoryFile(res.toString().getBytes(), Permissions.READ);
+        if (f.isDirectory()) return MemoryFile.fromFileList(path, f.listFiles());
+        else try { return new PhysicalFile(path, perms); }
+        catch (FileNotFoundException e) { throw new FilesystemException(_path.toString(), FSCode.DOESNT_EXIST); }
+    }
+
+    @Override
+    public void create(String path, EntryType type) {
+        var _path = getPath(path);
+        var f = _path.toFile();
+
+        switch (type) {
+            case FILE:
+                try {
+                    if (!f.createNewFile()) throw new FilesystemException(_path.toString(), FSCode.ALREADY_EXISTS);
+                    else break;
+                } 
+                catch (IOException e) { throw new FilesystemException(_path.toString(), FSCode.NO_PERMISSIONS_RW); }
+            case FOLDER:
+                if (!f.mkdir()) throw new FilesystemException(_path.toString(), FSCode.ALREADY_EXISTS);
+                else break;
+            case NONE:
+            default:
+                if (!f.delete()) throw new FilesystemException(_path.toString(), FSCode.DOESNT_EXIST);
+                else break;
         }
-        else return new PhysicalFile(path, perms);
     }
 
     @Override
-    public boolean mkdir(String path) throws IOException, InterruptedException {
+    public FileStat stat(String path) {
         var _path = getPath(path);
-        var perms = getPerms(_path);
         var f = _path.toFile();
 
-        if (!perms.writable) return false;
+        if (!f.exists()) throw new FilesystemException(_path.toString(), FSCode.DOESNT_EXIST);
-        else return f.mkdir();
+        checkMode(_path, Mode.READ);
-    }
 
-    @Override
+        return new FileStat(
-    public EntryType type(String path) throws IOException, InterruptedException {
+            f.canWrite() ? Mode.READ_WRITE : Mode.READ,
-        var _path = getPath(path);
+            f.isFile() ? EntryType.FILE : EntryType.FOLDER
-        var perms = getPerms(_path);
+        );
-        var f = _path.toFile();
-
-        if (perms == Permissions.NONE) return EntryType.NONE;
-        else if (f.isFile()) return EntryType.FILE;
-        else return EntryType.FOLDER;
-    }
-
-    @Override
-    public boolean rm(String path) throws IOException, InterruptedException {
-        var _path = getPath(path);
-        var perms = getPerms(_path);
-        var f = _path.toFile();
-
-        if (!perms.writable) return false;
-        else return f.delete();
     }
 
     public PhysicalFilesystem(Path root) {
-        this.root = root;
+        this.root = root.toAbsolutePath().normalize();
     }
 }

src/me/topchetoeu/jscript/filesystem/RootFilesystem.java

@@ -0,0 +1,57 @@
+package me.topchetoeu.jscript.filesystem;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import me.topchetoeu.jscript.Filename;
+import me.topchetoeu.jscript.filesystem.FilesystemException.FSCode;
+import me.topchetoeu.jscript.permissions.PermissionsProvider;
+
+public class RootFilesystem implements Filesystem {
+    public final Map<String, Filesystem> protocols = new HashMap<>();
+    public final PermissionsProvider perms;
+
+    private boolean canRead(String _path) {
+        return perms.hasPermission("jscript.file.read:" + _path, '/');
+    }
+    private boolean canWrite(String _path) {
+        return perms.hasPermission("jscript.file.write:" + _path, '/');
+    }
+
+    private void modeAllowed(String _path, Mode mode) throws FilesystemException {
+        if (mode.readable && perms != null && !canRead(_path)) throw new FilesystemException(_path, FSCode.NO_PERMISSIONS_R);
+        if (mode.writable && perms != null && !canWrite(_path)) throw new FilesystemException(_path, FSCode.NO_PERMISSIONS_RW);
+    }
+
+    @Override public File open(String path, Mode perms) throws FilesystemException {
+        var filename = Filename.parse(path);
+        var protocol = protocols.get(filename.protocol);
+        if (protocol == null) throw new FilesystemException(filename.toString(), FSCode.DOESNT_EXIST);
+        modeAllowed(filename.toString(), perms);
+
+        try { return protocol.open(filename.path, perms); }
+        catch (FilesystemException e) { throw new FilesystemException(filename.toString(), e.code); }
+    }
+    @Override public void create(String path, EntryType type) throws FilesystemException {
+        var filename = Filename.parse(path);
+        var protocol = protocols.get(filename.protocol);
+        if (protocol == null) throw new FilesystemException(filename.toString(), FSCode.DOESNT_EXIST);
+        modeAllowed(filename.toString(), Mode.READ_WRITE);
+
+        try { protocol.create(filename.path, type); }
+        catch (FilesystemException e) { throw new FilesystemException(filename.toString(), e.code); }
+    }
+    @Override public FileStat stat(String path) throws FilesystemException {
+        var filename = Filename.parse(path);
+        var protocol = protocols.get(filename.protocol);
+        if (protocol == null) throw new FilesystemException(filename.toString(), FSCode.DOESNT_EXIST);
+        modeAllowed(filename.toString(), Mode.READ);
+
+        try { return protocol.stat(path); }
+        catch (FilesystemException e) { throw new FilesystemException(filename.toString(), e.code); }
+    }
+
+    public RootFilesystem(PermissionsProvider perms) {
+        this.perms = perms;
+    }
+}

src/me/topchetoeu/jscript/interop/NativeWrapperProvider.java

@@ -108,6 +108,12 @@ public class NativeWrapperProvider implements WrappersProvider {
         }
     }
 
+    public static String getName(Class<?> clazz) {
+        var classNat = clazz.getAnnotation(Native.class);
+        if (classNat != null && !classNat.value().trim().equals("")) return classNat.value().trim();
+        else return clazz.getSimpleName();
+    }
+
     /**
      * Generates a prototype for the given class.
      * The returned object will have appropriate wrappers for all instance members.
@@ -117,6 +123,8 @@ public class NativeWrapperProvider implements WrappersProvider {
     public static ObjectValue makeProto(Environment ctx, Class<?> clazz) {
         var res = new ObjectValue();
 
+        res.defineProperty(null, ctx.symbol("Symbol.typeName"), getName(clazz));
+
         for (var overload : clazz.getDeclaredMethods()) {
             var init = overload.getAnnotation(NativeInit.class);
             if (init == null || init.value() != InitType.PROTOTYPE) continue;
@@ -137,11 +145,7 @@ public class NativeWrapperProvider implements WrappersProvider {
      * @param clazz The class for which a constructor should be generated
      */
     public static FunctionValue makeConstructor(Environment ctx, Class<?> clazz) {
-        var name = clazz.getName();
+        FunctionValue func = new OverloadFunction(getName(clazz));
-        var classNat = clazz.getAnnotation(Native.class);
-        if (classNat != null && !classNat.value().trim().equals("")) name = classNat.value().trim();
-
-        FunctionValue func = new OverloadFunction(name);
 
         for (var overload : clazz.getDeclaredConstructors()) {
             var nat = overload.getAnnotation(Native.class);
@@ -161,7 +165,7 @@ public class NativeWrapperProvider implements WrappersProvider {
         }
 
         if (((OverloadFunction)func).overloads.size() == 0) {
-            func = new NativeFunction(clazz.getName(), (a, b, c) -> { throw EngineException.ofError("This constructor is not invokable."); });
+            func = new NativeFunction(getName(clazz), (a, b, c) -> { throw EngineException.ofError("This constructor is not invokable."); });
         }
 
         applyMethods(ctx, false, func, clazz);
@@ -256,7 +260,27 @@ public class NativeWrapperProvider implements WrappersProvider {
         constructors.put(clazz, value);
     }
 
+    private void initError() {
+        var proto = new ObjectValue();
+        proto.defineProperty(null, "message", new NativeFunction("message", (ctx, thisArg, args) -> {
+            if (thisArg instanceof Throwable) return ((Throwable)thisArg).getMessage();
+            else return null;
+        }));
+        proto.defineProperty(null, "name", new NativeFunction("name", (ctx, thisArg, args) -> getName(thisArg.getClass())));
+
+        var constr = makeConstructor(null, Throwable.class);
+        proto.defineProperty(null, "constructor", constr, true, false, false);
+        constr.defineProperty(null, "prototype", proto, true, false, false);
+
+        proto.setPrototype(null, getProto(Object.class));
+        constr.setPrototype(null, getConstr(Object.class));
+
+        setProto(Throwable.class, proto);
+        setConstr(Throwable.class, constr);
+    }
+
     public NativeWrapperProvider(Environment env) {
         this.env = env;
+        initError();
     }
 }

src/me/topchetoeu/jscript/interop/OverloadFunction.java

@@ -8,6 +8,7 @@ import java.util.List;
 import me.topchetoeu.jscript.Location;
 import me.topchetoeu.jscript.engine.Context;
 import me.topchetoeu.jscript.engine.values.FunctionValue;
+import me.topchetoeu.jscript.engine.values.NativeWrapper;
 import me.topchetoeu.jscript.engine.values.Values;
 import me.topchetoeu.jscript.exceptions.ConvertException;
 import me.topchetoeu.jscript.exceptions.EngineException;
@@ -82,21 +83,28 @@ public class OverloadFunction extends FunctionValue {
             catch (InvocationTargetException e) {
                 var loc = Location.INTERNAL;
                 if (e.getTargetException() instanceof EngineException) {
-                    throw ((EngineException)e.getTargetException()).add(name, loc);
+                    throw ((EngineException)e.getTargetException()).add(ctx, name, loc);
                 }
                 else if (e.getTargetException() instanceof NullPointerException) {
                     e.printStackTrace();
-                    throw EngineException.ofType("Unexpected value of 'undefined'.").add(name, loc);
+                    throw EngineException.ofType("Unexpected value of 'undefined'.").add(ctx, name, loc);
                 }
                 else if (e.getTargetException() instanceof InterruptException || e.getTargetException() instanceof InterruptedException) {
                     throw new InterruptException();
                 }
                 else {
-                    throw EngineException.ofError(e.getTargetException().getMessage()).add(name, loc);
+                    var target = e.getTargetException();
+                    var targetClass = target.getClass();
+                    var err = new NativeWrapper(e.getTargetException());
+
+                    err.defineProperty(ctx, "message", target.getMessage());
+                    err.defineProperty(ctx, "name", NativeWrapperProvider.getName(targetClass));
+
+                    throw new EngineException(err).add(ctx, name, loc);
                 }
             }
             catch (ReflectiveOperationException e) {
-                throw EngineException.ofError(e.getMessage()).add(name, Location.INTERNAL);
+                throw EngineException.ofError(e.getMessage()).add(ctx, name, Location.INTERNAL);
             }
         }
 

src/me/topchetoeu/jscript/js/bootstrap.js

@@ -1,87 +0,0 @@
-(function (_arguments) {
-    var ts = _arguments[0];
-    var src = '', lib = _arguments[2].concat([ 'declare const exit: never;' ]).join(''), decls = '', version = 0;
-    var libSnapshot = ts.ScriptSnapshot.fromString(lib);
-
-    var settings = {
-        outDir: "/out",
-        declarationDir: "/out",
-        target: ts.ScriptTarget.ES5,
-        lib: [ ],
-        module: ts.ModuleKind.None,
-        declaration: true,
-        stripInternal: true,
-        downlevelIteration: true,
-        forceConsistentCasingInFileNames: true,
-        experimentalDecorators: true,
-        strict: true,
-    };
-
-    var reg = ts.createDocumentRegistry();
-    var service = ts.createLanguageService({
-        getCurrentDirectory: function() { return "/"; },
-        getDefaultLibFileName: function() { return "/lib_.d.ts"; },
-        getScriptFileNames: function() { return [ "/src.ts", "/lib.d.ts", "/glob.d.ts" ]; },
-        getCompilationSettings: function () { return settings; },
-        fileExists: function(filename) { return filename === "/lib.d.ts" || filename === "/src.ts" || filename === "/glob.d.ts"; },
-    
-        getScriptSnapshot: function(filename) {
-            if (filename === "/lib.d.ts") return libSnapshot;
-            if (filename === "/src.ts") return ts.ScriptSnapshot.fromString(src);
-            if (filename === "/glob.d.ts") return ts.ScriptSnapshot.fromString(decls);
-            throw new Error("File '" + filename + "' doesn't exist.");
-        },
-        getScriptVersion: function (filename) {
-            if (filename === "/lib.d.ts") return 0;
-            else return version;
-        },
-    }, reg);
-
-    service.getEmitOutput('/lib.d.ts');
-    log('Loaded libraries!');
-
-    function compile(code, filename) {
-        src = code, version++;
-
-        var emit = service.getEmitOutput("/src.ts");
-
-        var diagnostics = []
-            .concat(service.getCompilerOptionsDiagnostics())
-            .concat(service.getSyntacticDiagnostics("/src.ts"))
-            .concat(service.getSemanticDiagnostics("/src.ts"))
-            .map(function (diagnostic) {
-                var message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
-                if (diagnostic.file) {
-                    var pos = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
-                    var file = diagnostic.file.fileName.substring(1);
-                    if (file === "src.ts") file = filename;
-                    return file + ":" + (pos.line + 1) + ":" + (pos.character + 1) + ": " + message;
-                }
-                else return "Error: " + message;
-            });
-
-        if (diagnostics.length > 0) {
-            throw new SyntaxError(diagnostics.join('\n'));
-        }
-
-        return {
-            result: emit.outputFiles[0].text,
-            declaration: emit.outputFiles[1].text
-        };
-    }
-
-    _arguments[1].compile = function (filename, code) {
-        var res = compile(filename, code);
-
-        return {
-            source: res.result,
-            runner: function(func) {
-                return function() {
-                    var val = func.apply(this, arguments);
-                    decls += res.declaration;
-                    return val;
-                }
-            }
-        }
-    }
-})(arguments);

src/me/topchetoeu/jscript/json/JSON.java

@@ -37,21 +37,6 @@ public class JSON {
         if (val instanceof Number) return JSONElement.number(((Number)val).doubleValue());
         if (val instanceof String) return JSONElement.string((String)val);
         if (val == Values.NULL) return JSONElement.NULL;
-        if (val instanceof ObjectValue) {
-            if (prev.contains(val)) throw new EngineException("Circular dependency in JSON.");
-            prev.add(val);
-
-            var res = new JSONMap();
-
-            for (var el : ((ObjectValue)val).keys(false)) {
-                var jsonEl = fromJs(ctx, ((ObjectValue)val).getMember(ctx, el), prev);
-                if (jsonEl == null) continue;
-                if (el instanceof String || el instanceof Number) res.put(el.toString(), jsonEl);
-            }
-
-            prev.remove(val);
-            return JSONElement.of(res);
-        }
         if (val instanceof ArrayValue) {
             if (prev.contains(val)) throw new EngineException("Circular dependency in JSON.");
             prev.add(val);
@@ -67,6 +52,21 @@ public class JSON {
             prev.remove(val);
             return JSONElement.of(res);
         }
+        if (val instanceof ObjectValue) {
+            if (prev.contains(val)) throw new EngineException("Circular dependency in JSON.");
+            prev.add(val);
+
+            var res = new JSONMap();
+
+            for (var el : ((ObjectValue)val).keys(false)) {
+                var jsonEl = fromJs(ctx, ((ObjectValue)val).getMember(ctx, el), prev);
+                if (jsonEl == null) continue;
+                if (el instanceof String || el instanceof Number) res.put(el.toString(), jsonEl);
+            }
+
+            prev.remove(val);
+            return JSONElement.of(res);
+        }
         if (val == null) return null;
         return null;
     }

src/me/topchetoeu/jscript/lib/ArrayLib.java

@@ -4,16 +4,14 @@ import java.util.Iterator;
 import java.util.Stack;
 
 import me.topchetoeu.jscript.engine.Context;
-import me.topchetoeu.jscript.engine.Environment;
 import me.topchetoeu.jscript.engine.values.ArrayValue;
 import me.topchetoeu.jscript.engine.values.FunctionValue;
+import me.topchetoeu.jscript.engine.values.NativeFunction;
 import me.topchetoeu.jscript.engine.values.ObjectValue;
 import me.topchetoeu.jscript.engine.values.Values;
-import me.topchetoeu.jscript.interop.InitType;
 import me.topchetoeu.jscript.interop.Native;
 import me.topchetoeu.jscript.interop.NativeConstructor;
 import me.topchetoeu.jscript.interop.NativeGetter;
-import me.topchetoeu.jscript.interop.NativeInit;
 import me.topchetoeu.jscript.interop.NativeSetter;
 
 @Native("Array") public class ArrayLib {
@@ -25,10 +23,10 @@ import me.topchetoeu.jscript.interop.NativeSetter;
     }
     
     @Native(thisArg = true) public static ObjectValue values(Context ctx, ArrayValue thisArg) {
-        return Values.fromJavaIterable(ctx, thisArg);
+        return Values.toJSIterator(ctx, thisArg);
     }
     @Native(thisArg = true) public static ObjectValue keys(Context ctx, ArrayValue thisArg) {
-        return Values.fromJavaIterable(ctx, () -> new Iterator<Object>() {
+        return Values.toJSIterator(ctx, () -> new Iterator<Object>() {
             private int i = 0;
 
             @Override
@@ -43,7 +41,7 @@ import me.topchetoeu.jscript.interop.NativeSetter;
         });
     }
     @Native(thisArg = true) public static ObjectValue entries(Context ctx, ArrayValue thisArg) {
-        return Values.fromJavaIterable(ctx, () -> new Iterator<Object>() {
+        return Values.toJSIterator(ctx, () -> new Iterator<Object>() {
             private int i = 0;
 
             @Override
@@ -94,8 +92,11 @@ import me.topchetoeu.jscript.interop.NativeSetter;
     }
 
     @Native(thisArg = true) public static ArrayValue sort(Context ctx, ArrayValue arr, FunctionValue cmp) {
+        var defaultCmp = new NativeFunction("", (_ctx, thisArg, args) -> {
+            return Values.toString(ctx, args[0]).compareTo(Values.toString(ctx, args[1]));
+        });
         arr.sort((a, b) -> {
-            var res = Values.toNumber(ctx, cmp.call(ctx, null, a, b));
+            var res = Values.toNumber(ctx, (cmp == null ? defaultCmp : cmp).call(ctx, null, a, b));
             if (res < 0) return -1;
             if (res > 0) return 1;
             return 0;
@@ -309,8 +310,9 @@ import me.topchetoeu.jscript.interop.NativeSetter;
         return res;
     }
 
-    @Native(thisArg = true) public static ArrayValue splice(Context ctx, ArrayValue arr, int start, int deleteCount, Object ...items) {
+    @Native(thisArg = true) public static ArrayValue splice(Context ctx, ArrayValue arr, int start, Object _deleteCount, Object ...items) {
         start = normalizeI(arr.size(), start, true);
+        int deleteCount = _deleteCount == null ? arr.size() - 1 : (int)Values.toNumber(ctx, _deleteCount);
         deleteCount = normalizeI(arr.size(), deleteCount, true);
         if (start + deleteCount >= arr.size()) deleteCount = arr.size() - start;
 
@@ -323,9 +325,6 @@ import me.topchetoeu.jscript.interop.NativeSetter;
 
         return res;
     }
-    @Native(thisArg = true) public static ArrayValue splice(Context ctx, ArrayValue arr, int start) {
-        return splice(ctx, arr, start, arr.size() - start);
-    }
     @Native(thisArg = true) public static String toString(Context ctx, ArrayValue arr) {
         return join(ctx, arr, ",");
     }
@@ -371,8 +370,4 @@ import me.topchetoeu.jscript.interop.NativeSetter;
 
         return res;
     }
-
-    @NativeInit(InitType.PROTOTYPE) public static void init(Environment env, ObjectValue target) {
-        target.defineProperty(null, env.symbol("Symbol.typeName"), "Array");
-    }
 }

src/me/topchetoeu/jscript/lib/AsyncFunctionLib.java

@@ -1,7 +1,6 @@
 package me.topchetoeu.jscript.lib;
 
 import me.topchetoeu.jscript.engine.Context;
-import me.topchetoeu.jscript.engine.StackData;
 import me.topchetoeu.jscript.engine.frame.CodeFrame;
 import me.topchetoeu.jscript.engine.frame.Runners;
 import me.topchetoeu.jscript.engine.values.CodeFunction;
@@ -21,7 +20,7 @@ import me.topchetoeu.jscript.interop.Native;
 
         private void next(Context ctx, Object inducedValue, Object inducedError) {
             Object res = null;
-            StackData.pushFrame(ctx, frame);
+            ctx.pushFrame(frame);
             ctx.pushEnv(frame.function.environment);
 
             awaiting = false;
@@ -40,7 +39,7 @@ import me.topchetoeu.jscript.interop.Native;
                 }
             }
 
-            StackData.popFrame(ctx, frame);
+            ctx.popFrame(frame);
 
             if (awaiting) {
                 PromiseLib.then(ctx, frame.pop(), new NativeFunction(this::fulfill), new NativeFunction(this::reject));

src/me/topchetoeu/jscript/lib/AsyncGeneratorLib.java

@@ -3,7 +3,6 @@ package me.topchetoeu.jscript.lib;
 import java.util.Map;
 
 import me.topchetoeu.jscript.engine.Context;
-import me.topchetoeu.jscript.engine.StackData;
 import me.topchetoeu.jscript.engine.frame.CodeFrame;
 import me.topchetoeu.jscript.engine.frame.Runners;
 import me.topchetoeu.jscript.engine.values.NativeFunction;
@@ -29,7 +28,7 @@ import me.topchetoeu.jscript.interop.Native;
         }
 
         Object res = null;
-        StackData.pushFrame(ctx, frame);
+        ctx.pushFrame(frame);
         state = 0;
 
         while (state == 0) {
@@ -50,7 +49,7 @@ import me.topchetoeu.jscript.interop.Native;
             }
         }
 
-        StackData.popFrame(ctx, frame);
+        ctx.popFrame(frame);
 
         if (state == 1) {
             PromiseLib.then(ctx, frame.pop(), new NativeFunction(this::fulfill), new NativeFunction(this::reject));