open-lisp 2026.306.224346

package/script/src/oml2ast.js

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.oml2ast = oml2ast;
+exports.ast2oml = ast2oml;
+exports.astequal = astequal;
+function tokenize(str) {
+    //console.debug("tokenize", str);
+    const re = /[\s,]*([()\[\]{}'`]|"(?:\\.|[^\\"])*"|[$]?@(?:@@|[^@])*@|;.*|#[!# ].*|#lang[ ]+.*|#[\|][\s\S]+?[\|]#|#[a-z]+|[^\s,()\[\]{}'"`;@]*)/g;
+    const result = [];
+    let token;
+    while ((token = re.exec(str)[1]) !== "") {
+        //console.debug(`token=${token}`);
+        if (token[0] === ";")
+            continue;
+        if (token.startsWith("#!"))
+            continue;
+        if (token.startsWith("##"))
+            continue;
+        if (token.startsWith("# "))
+            continue;
+        if (token.startsWith("#lang "))
+            continue;
+        if (token.startsWith("#|") && !token.startsWith("#|@"))
+            continue;
+        if (!token.startsWith("#@") && !token.startsWith("#|") &&
+            token.startsWith("#"))
+            token = token.substring(1);
+        if (isFinite(token))
+            token = parseFloat(token, 10);
+        result.push(token);
+    }
+    return result;
+}
+function read_token(code, exp) {
+    if (code.length === 0)
+        return undefined;
+    const token = code.shift();
+    exp.push(token);
+    return token;
+}
+function read_list(code, exp, ch) {
+    const result = [];
+    let ast;
+    while ((ast = read_sexp(code, exp, false)) !== undefined) {
+        if (ast === "]") {
+            if (ch !== "[")
+                code.unshift("]");
+            break;
+        }
+        else if (ast === ")") {
+            break;
+        }
+        result.push(ast);
+    }
+    return result;
+}
+function read_dict(code, exp) {
+    const result = [["#", "dict"]];
+    let ast1;
+    let ast2;
+    while ((ast1 = read_sexp(code, exp)) !== undefined) {
+        if (ast1 === "]")
+            continue;
+        if (ast1 === "}")
+            break;
+        ast2 = read_sexp(code, exp);
+        result.push(ast1);
+        result.push(ast2);
+    }
+    return result;
+}
+function read_sexp(code, exp) {
+    let token = read_token(code, exp);
+    if (token === undefined)
+        return undefined;
+    if ((typeof token) === "number")
+        return token;
+    switch (token) {
+        case "false":
+            return false;
+        case "true":
+            return true;
+        case "null":
+            return null;
+        case "undefined":
+            return ["@", "undefined"];
+    }
+    let ch = token[0];
+    if (ch == "#")
+        ch = token.slice(0, 2);
+    if (token.startsWith("$@")) {
+        ch = "$@";
+    }
+    switch (ch) {
+        case "(":
+        case "[": {
+            const lst = read_list(code, exp, ch);
+            return lst;
+        }
+        case ")":
+        case "]":
+            return ch;
+        case "{":
+            return read_dict(code, exp);
+        case "}":
+            return ch;
+        case '"':
+            token = token.replaceAll("\r\n", "\n");
+            token = token.replaceAll("\n", "\\n");
+            token = JSON.parse(token);
+            return token;
+        case "@":
+            token = token.replace(/(^@|@$)/g, "");
+            token = token.replace(/(@@)/g, "@");
+            token = token.trim();
+            return ["@", token];
+        case "#|": {
+            if (token.startsWith("#|@")) {
+                token = token.replace(/^#[\|]@/g, "");
+                token = token.replace(/[\|]#$/g, "");
+                token = token.trim();
+                return ["@", token];
+            }
+            // not a "#|@" quoted string – handle as in the default branch
+            if (token[0] === ":")
+                return token;
+            if (token[0] === "&")
+                return token;
+            const ids = token[0] === "." ? [token] : token.split(".");
+            return ["#", ...ids];
+        }
+        case "$@": // template literal string
+            token = token.replaceAll("\r\n", "\n");
+            token = token.replace(/(^[$]@|@$)/g, "");
+            token = token.replace(/(@@)/g, "@");
+            return ["$@", token];
+        default: {
+            //if (token[0] === ":") return token;
+            //if (token[0] === "&") return token;
+            if (!token.match(/^[_a-zA-Z][._a-zA-Z0-9]*$/)) {
+                //console.debug(`token=${token} does not match the identifier pattern`);
+                return ["#", token];
+            }
+            const ids = token[0] === "." ? [token] : token.split(".");
+            return ["#", ...ids];
+        }
+    }
+}
+function join_sexp(exp) {
+    if (exp.length === 0)
+        return "";
+    let last = exp.shift();
+    let result = "" + last;
+    while (exp.length > 0) {
+        let token = exp.shift();
+        if (token !== ")" &&
+            token !== "]" &&
+            (last !== "(") & (last !== "[") &&
+            last !== "'") {
+            result += " ";
+        }
+        if (token === "[")
+            token = "(";
+        if (token === "]")
+            token = ")";
+        result += token;
+        last = token;
+    }
+    return result;
+}
+function oml2ast(text) {
+    const code = tokenize(text);
+    const result = [];
+    while (true) {
+        const exp = [];
+        const ast = read_sexp(code, exp);
+        if (ast === undefined)
+            break;
+        if (ast === ")")
+            continue;
+        if (ast === "]")
+            continue;
+        result.push([join_sexp(exp), ast]);
+    }
+    return result;
+}
+function ast2oml(ast) {
+    if (ast === null)
+        return "null";
+    if (ast === undefined)
+        return "undefined";
+    if ((typeof ast) === "number")
+        return JSON.stringify(ast);
+    if ((typeof ast) === "string")
+        return JSON.stringify(ast);
+    if ((typeof ast) === "boolean")
+        return JSON.stringify(ast);
+    if (ast instanceof Array) {
+        let result = "( ";
+        for (let i = 0; i < ast.length; i++) {
+            if (i > 0)
+                result += " ";
+            result += ast2oml(ast[i]);
+        }
+        let keys = Object.keys(ast);
+        const re = /^[0-9]+/;
+        keys = keys.filter((key) => !re.test(key));
+        keys.sort();
+        if (keys.length > 0) {
+            if (ast.length > 0)
+                result += " ";
+            result += "?";
+            for (let i = 0; i < keys.length; i++) {
+                const key = keys[i];
+                result += " (";
+                result += JSON.stringify(key);
+                result += " ";
+                result += ast2oml(ast[key]);
+                result += ")";
+            }
+        }
+        result += " )";
+        return result;
+    }
+    else {
+        let result = "{ ";
+        const keys = Object.keys(ast);
+        keys.sort();
+        for (let i = 0; i < keys.length; i++) {
+            if (i > 0)
+                result += " ";
+            result += JSON.stringify(keys[i]);
+            result += " ";
+            result += ast2oml(ast[keys[i]]);
+        }
+        result += " }";
+        return result;
+    }
+}
+function astequal(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (a instanceof Function || b instanceof Function) {
+        return false;
+    }
+    else if (typeof a === "object" && typeof b === "object") {
+        const ak = Object.keys(a);
+        const bk = Object.keys(b);
+        if (ak.length !== bk.length) {
+            return false;
+        }
+        for (let i = 0; i < ak.length; ++i) {
+            const key = ak[i];
+            const ret = astequal(a[key], b[key]);
+            if (ret === false) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}

package/script/src/omlcommon.d.ts

@@ -0,0 +1,17 @@
+export class OMLCommon {
+    is_array(x: any): x is any[];
+    is_bool(x: any): x is boolean;
+    is_number(x: any): x is number;
+    is_string(x: any): x is string;
+    is_quoted(x: any): boolean;
+    is_id(ast: any, name?: undefined): boolean;
+    is_variable(ast: any): boolean;
+    is_script(ast: any): boolean;
+    is_template(ast: any): boolean;
+    is_callable(ast: any): boolean;
+    is_fn(ast: any): boolean;
+    to_id(ast: any): any;
+    id(x: any): any[];
+    to_def(ast: any): any;
+}
+//# sourceMappingURL=omlcommon.d.ts.map

package/script/src/omlcommon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omlcommon.d.ts","sourceRoot":"","sources":["../../src/src/omlcommon.js"],"names":[],"mappings":"AAAA;IACE,6BAEC;IAED,8BAEC;IAED,+BAEC;IAED,+BAEC;IAED,2BAIC;IAED,2CAKC;IAED,+BAIC;IAED,6BAIC;IAED,+BAIC;IAED,+BAMC;IAED,yBAIC;IAED,qBAQC;IAED,kBAEC;IAED,sBAuCC;CAEF"}

package/script/src/omlcommon.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OMLCommon = void 0;
+class OMLCommon {
+    is_array(x) {
+        return (x instanceof Array);
+    }
+    is_bool(x) {
+        return (typeof x) === "boolean";
+    }
+    is_number(x) {
+        return (typeof x) === "number";
+    }
+    is_string(x) {
+        return (typeof x) === "string";
+    }
+    is_quoted(x) {
+        if (!this.is_array(x))
+            return false;
+        if (x.length === 0)
+            return false;
+        return x[0] === "`";
+    }
+    is_id(ast, name = undefined) {
+        const ok = ast instanceof Array && ast[0] === "#";
+        if (!ok)
+            return false;
+        if (name !== undefined)
+            return ast.length > 1 && ast[1] === name;
+        return true;
+    }
+    is_variable(ast) {
+        if (!(ast instanceof Array))
+            return false;
+        if (ast.length === 0)
+            return false;
+        return ast[0] === "#";
+    }
+    is_script(ast) {
+        if (!(ast instanceof Array))
+            return false;
+        if (ast.length === 0)
+            return false;
+        return ast[0] === "@";
+    }
+    is_template(ast) {
+        if (!(ast instanceof Array))
+            return false;
+        if (ast.length === 0)
+            return false;
+        return ast[0] === "$@";
+    }
+    is_callable(ast) {
+        if (!(ast instanceof Array))
+            return false;
+        if (ast.length === 0)
+            return false;
+        if (ast[0] === "#")
+            return false;
+        if (ast[0] === "@")
+            return false;
+        return this.is_id(ast[0]) || this.is_script(ast[0]);
+    }
+    is_fn(ast) {
+        if (!(ast instanceof Array))
+            return false;
+        if (ast.length === 0)
+            return false;
+        return this.is_id(ast[0]) && this.to_id(ast[0]) === "fn";
+    }
+    to_id(ast) {
+        if (this.is_id(ast)) {
+            const ids = ast.slice(1);
+            return ids.join(".");
+        }
+        else if (this.is_script(ast)) {
+            return "<script>";
+        }
+        return ast;
+    }
+    id(x) {
+        return ["#", x];
+    }
+    to_def(ast) {
+        if (!this.is_array(ast))
+            return null;
+        if (ast.length === 0)
+            return null;
+        switch (this.to_id(ast[0])) {
+            case "def": {
+                if (ast.length < 2)
+                    throw new Error("syntax error");
+                const ast1 = ast[1];
+                const ast2 = ast.length === 2 ? null : ast[2];
+                return [this.id("def"), ast1, ast2];
+            }
+            case "defvar": {
+                if (ast.length < 2)
+                    throw new Error("syntax error");
+                const ast1 = ast[1];
+                const ast2 = ast.length === 2 ? null : ast[2];
+                return [this.id("def"), ast1, ast2];
+            }
+            case "defun": {
+                if (ast.length < 3)
+                    throw new Error("syntax error");
+                const new_ast = ast.slice(3);
+                new_ast.unshift(ast[2]);
+                new_ast.unshift(this.id("fn"));
+                return [this.id("def"), ast[1], new_ast];
+            }
+            case "define": {
+                const ast1 = this.to_id(ast[1]);
+                if (ast1 instanceof Array) {
+                    if (ast.length < 2)
+                        throw new Error("syntax error");
+                    const new_ast = ast.slice(2);
+                    return this.to_def([this.id("defun"), ast[1][0], ast[1].slice(1), ...new_ast]);
+                }
+                else {
+                    if (ast.length < 2)
+                        throw new Error("syntax error");
+                    const ast2 = ast.length === 2 ? null : ast[2];
+                    return this.to_def([this.id("defvar"), ast[1], ast2]);
+                }
+            }
+            default:
+                return null;
+        }
+    }
+}
+exports.OMLCommon = OMLCommon;