X-Git-Url: https://git.kianting.info/?a=blobdiff_plain;f=src%2Findex.js;h=4163e92ef817fdc17ff1d4deda28ceedc56fadba;hb=1a7598fd6e01515661591a41320a63451cb82d5f;hp=fb887701725ab7261a7bda6b47b78fa15babc3a5;hpb=cda463d89022d09a5273b59bcd3e776f1127697a;p=clo diff --git a/src/index.js b/src/index.js index fb88770..4163e92 100644 --- a/src/index.js +++ b/src/index.js @@ -23,39 +23,208 @@ var __importStar = (this && this.__importStar) || function (mod) { return result; }; Object.defineProperty(exports, "__esModule", { value: true }); -exports.match1token = void 0; +exports.m1TType = void 0; var fs = require('fs'); +const node_process_1 = require("node:process"); const tk = __importStar(require("./tokenize.js")); -let b = tk.tokenize("2+2"); +const util = __importStar(require("util")); +/** + * debug reprensenting + */ +let repr = (x) => { return util.inspect(x, { depth: null }); }; +/** + * concated 2 `tkTree`s + * @param x the array to be concated + * @param y the item or array to ve concated + * @returns concated tkTree array, or thrown error if can't be concated. + */ +function concat(x, y) { + if (Array.isArray(x)) { + return x.concat(y); + } + else { + throw new Error("the tkTree can't be concated, because it's not an array."); + } +} +function slice(x, index, end) { + if (Array.isArray(x)) { + return x.slice(index, end); + } + else { + throw new Error("the tkTree can't be concated, because it's not an array."); + } +} /** * @description - * it returns a function which test if the first char of the `remained` part of - * the argument of the function is `c`, if it's true, update the `MatchedPair` wrapped + * match one token type. + * + * it returns a function which test if the type of first token of the `remained` part of + * the argument of the function is `typ` , if it's true, update the `TokenMatcheePair` wrapped * in `Some`. Otherwise, it returns `None`. - * * @param t : the char to be test. - * @returns the updated `MatchedPair` wrapped in `Some(x)` or `None`. + * * @param typ : the type to be test. + * @returns the updated `TokenMatcheePair` wrapped in `Some(x)` or `None`. */ -function match1token(t) { +function m1TType(typ) { return (m) => { if (m.remained.length == 0) { return { _tag: "None" }; } - const tokenToBeMatched = m.remained[0]; - if (tokenToBeMatched === t) { - m.matched.push(tokenToBeMatched); - return { + /** + * token to be matched + * */ + const ttbm = m.remained[0]; + if (ttbm.type == typ) { + let new_matched = m.matched.concat(ttbm); + let result = { _tag: "Some", value: { - matched: m.matched, - remained: m.remained.slice(1) + matched: new_matched, + remained: m.remained.slice(1), + ast: ([ttbm]), } }; + return result; } else { return { _tag: "None" }; } }; } -exports.match1token = match1token; +exports.m1TType = m1TType; ; -let c = tk.toSome(b); -console.log(thenDo(c, match1token(tk.tokenize("+")[0]))); +/** + * type int + */ +let tInt = m1TType(tk.TokenType.INT); +let tAdd = m1TType(tk.TokenType.I_ADD); +let tSub = m1TType(tk.TokenType.I_SUB); +let tMul = m1TType(tk.TokenType.I_MUL); +let tDiv = m1TType(tk.TokenType.I_DIV); +let tLParen = m1TType(tk.TokenType.L_PAREN); +let tRParen = m1TType(tk.TokenType.R_PAREN); +let toSome = tk.toSome; +node_process_1.argv.forEach((val, index) => { + console.log(`${index}=${val}`); +}); +/** + * like `m ==> f` in ocaml + * @param m matchee wrapped + * @param f matching function + * @returns wrapped result + */ +function thenDo(m, f) { + if (m._tag == "None") { + return m; + } + else { + var a = f(m.value); + if (a._tag == "Some") { + a.value.ast = concat(m.value.ast, a.value.ast); + } + return a; + } +} +/** + * like `f1 | f2` in regex + * @param f1 the first tried function + * @param f2 the second tried function + * @returns wrapped result + */ +function orDo(f1, f2) { + return (x) => { + let res1 = f1(x); + if (res1._tag == "Some") { + return res1; + } + else { + let res2 = f2(x); + return res2; + } + }; +} +/** + * aux function for midfix operator + * @param f function + * @param signal the rule name + * @returns + */ +let midfix = (f, signal) => (x) => { + var a = f(x); + if (a._tag == "Some") { + let ast_tail = slice(a.value.ast, a.value.ast.length - 3); + let new_ast = [ast_tail]; + a.value.ast = new_ast; + console.log("+" + signal + "+" + repr(a)); + } + return a; +}; +let circumfix = (f, signal) => (x) => { + var a = f(x); + if (a._tag == "Some") { + let inner = a.value.ast[a.value.ast.length - 2]; + let ast_middle = [inner]; + let new_ast = [ast_middle]; + a.value.ast = new_ast; + } + return a; +}; +/** + * TODO: 12(13)(14) only parsed with only 12(13) + */ +/** single1 = tInt | "(" expr ")"*/ +let single1 = circumfix((x) => thenDo(thenDo(thenDo(tk.toSome(x), tLParen), expr), tRParen), "fac1"); +let single2 = tInt; +let single = orDo(single1, single2); +/** fac1 = single "(" int ")" | single */ +let fac1Appliee = circumfix((x) => thenDo(thenDo(thenDo(tk.toSome(x), tLParen), tInt), tRParen), "fac1"); +let fac1 = (x) => { + let n = thenDo(thenDo(toSome(x), single), fac1Appliee); + console.log("+" + "bocchitherock" + "+" + repr(n)); + return n; +}; +let fac2 = single; +let fac = orDo(fac1, fac2); +/** + * + * term1 = fac (MUL | DIV) fac + */ +let term1 = midfix((x) => thenDo(thenDo(thenDo(tk.toSome(x), fac), orDo(tMul, tDiv)), fac), "term1"); +/** + * + * term2 = int MUL int + */ +let term2 = fac; +/** + * term = term1 | term2 + */ +let term = orDo(term1, term2); +/** + * + * expr1 = term ADD term + */ +let expr1 = midfix((x) => thenDo(thenDo(thenDo(tk.toSome(x), term), orDo(tAdd, tSub)), term), "expr1"); +/** + * expr2 = term + */ +let expr2 = term; +/** + * expr = expr1 | expr2 + */ +let expr = orDo(expr1, expr2); +let tokens = tk.tokenize("12(13)(14)"); +//let tokens = tk.tokenize("(4-(3/4))"); +//tk.tokenize(argv[2]); +let tokensFiltered = tokens.filter((x) => { + return (x.type != tk.TokenType.NL + && x.type != tk.TokenType.SP); +}); +let wrappedTokens = tk.toSome({ + matched: [], + remained: tokensFiltered, + ast: [] +}); +let beta = expr({ + matched: [], + remained: tokensFiltered, + ast: [] +}); +console.log("RESULT=" + repr(beta));