qjs_rtensor.js (117473e) - rtensor · DKL9 GitList

Refactor towards a working QuickJS version

dkl9 commited 117473e at 2023-196 12:46:40

qjs_rtensor.js

Blame History Raw

import {fts} from "./rtensor_common.js";
import {AST} from "./maths_ast.js";
import {TokenStream, NewParser} from "./maths_parser.js";
import {BUILTIN_FUNCS} from "./rtensor_lib.js";
import * as std from "std";
import * as os from "os";

const calcVars = Object.fromEntries(Object.entries(BUILTIN_FUNCS));
calcVars["_"] = [];
const pastInps = [];
var histPos = 0;

function evalInp(inpText) {
    let disp;
    let perr = false;
    const st = inpText.split(";");
    for (let i = 0; i < st.length; i++) {
        const wt = st[i];
        const lexer = new TokenStream(wt);
        const ast = NewParser.statement(lexer);
        if (ast === null) {
            disp = "syntax error";
            break;
        } else {
            perr = perr || (lexer.tind != lexer.toks.length - 1);
            try {
                const res = ast.evaluate(calcVars, false);
                if (res != null) { calcVars["_"] = res; }
                const svn = "_ans_" + pastInps.length.toString();
                calcVars[svn] = res;
                disp = (res == null) ? "evaluation error" : (svn + " = " + fts(res));
            } catch (err) {
                disp = err;
            }
        }
    }
    return disp + (perr ? "\npossible syntax error" : "");
}

function getEscSeq(fhs) {
    let r = "";
    while (/[A-H]$/.exec(r) == null) {
        r += String.fromCharCode(fhs.getByte());
    }
    return r;
}

// returns Array [newt, newwi]
function histFetch(oldt) {
    const t = pastInps[histPos] || oldt;
    const wi = t.length;
    std.out.puts("\r\x1b[" + PRLEN + "C\x1b[K" + t +
        "\r\x1b[" + (wi + PRLEN) + "C");
    return [t, wi];
}

function wf(t) {
    std.out.puts(t);
    std.out.flush();
}

if (os.isatty(std.in)) {
    os.ttySetRaw(std.in);
}

const PROMPT = "> ";
const PRLEN = PROMPT.length;

let t;
while (true) {
    if (os.isatty(std.in)) {
        wf(PROMPT);
        t = "";
        let wi = 0;
        let nmi = true;
        while (nmi) {
            const nc = std.in.getByte();
            switch (nc) {
                // ^D
                case 4:
                    t = "quit";
                    nmi = false;
                    break;
                // escape
                case 27:
                    const es = getEscSeq(std.in);
                    // up arrow
                    if (es == "[A") {
                        histPos--;
                        const ra = histFetch(t);
                        t = ra[0]; wi = ra[1];
                        wf("\r\x1b[" + PRLEN + "C" + t);
                    // down arrow
                    } else if (es == "[B") {
                        histPos++;
                        const ra = histFetch(t);
                        t = ra[0]; wi = ra[1];
                    // right arrow
                    } else if (es == "[C") {
                        wi = (wi == t.length) ? wi : (wi + 1);
                        wf("\x1b[C");
                    // left arrow
                    } else if (es == "[D") {
                        wi = (wi == 0) ? wi : (wi - 1);
                        wf("\x1b[D");
                    // ctrl-right arrow
                    } else if (es == "[1;5C") {
                        //
                    // ctrl-left arrow
                    } else if (es == "[1;5D") {
                        //
                    // home
                    } else if (es == "[H") {
                        wi = 0;
                        wf("\r\x1b[" + PRLEN + "C");
                    // end
                    } else if (es == "[F") {
                        wi = t.length;
                        wf("\r\x1b[" + (wi + PRLEN) + "C");
                    }
                    break;
                // backspace
                case 8:
                case 127:
                    if (wi > 0) {
                        wi--;
                        t = t.slice(0, wi) + t.slice(wi + 1);
                        wf("\x1b[D\x1b[K" +
                            (t.slice(wi) ? (t.slice(wi) + "\x1b[" + t.slice(wi).length + "D") : ""));
                    } else {
                        wf("\x07");
                    }
                    break;
                // newline
                case 13:
                    nmi = false;
                    wf("\n");
                    break;
                // printable?
                default:
                    wf(String.fromCharCode(nc));
                    t = t.slice(0, wi) + String.fromCharCode(nc) + t.slice(wi);
                    wi++;
            }
        }
    } else {
        t = std.in.getline();
    }
    pastInps.push(t);
    histPos = pastInps.length;
    if (t == "quit" || t == null) {
        break;
    }
    if (t == "") {
        continue;
    }
    console.log(evalInp(t));
}