X-Git-Url: https://git.kianting.info/?a=blobdiff_plain;f=src%2Findex.js;h=0e3686ca2732f5843159c62a956aa15071329fda;hb=5f0943539e27b3e0d08e70559ea39017e6df330e;hp=e18ebd5a1c4ff82a83542e067c0c39c7c233d41c;hpb=6f2e788329da7702ea96dc28ae04499917ec8152;p=clo diff --git a/src/index.js b/src/index.js index e18ebd5..0e3686c 100644 --- a/src/index.js +++ b/src/index.js @@ -28,6 +28,32 @@ var fs = require('fs'); const node_process_1 = require("node:process"); const tk = __importStar(require("./tokenize.js")); 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 * match one token type. @@ -48,13 +74,15 @@ function m1TType(typ) { * */ const ttbm = m.remained[0]; if (ttbm.type == typ) { - m.matched.push(ttbm); - return { + 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" }; @@ -63,57 +91,127 @@ function m1TType(typ) { } exports.m1TType = m1TType; ; -let toSome = tk.toSome; -let thenDo = tk.thenDo; -let orDo = tk.orDo; +/** + * 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); node_process_1.argv.forEach((val, index) => { console.log(`${index}=${val}`); }); -let commandInput = node_process_1.argv[2]; -let commandInputTokenized = tk.tokenize(commandInput); -console.log(commandInputTokenized); /** - * matchee pair of commandInputTokenized + * like `m ==> f` in ocaml + * @param m matchee wrapped + * @param f matching function + * @returns wrapped result */ -let commandTPair = { matched: [], - remained: commandInputTokenized }; -let tInt = m1TType(tk.TokenType.INT); -let tFlo = m1TType(tk.TokenType.FLO); -let tStr = m1TType(tk.TokenType.STR); -function tBool(x) { - let text = x.remained[0].text; - if (text == "true" || text == "false") { - return thenDo(toSome(x), m1TType(tk.TokenType.ID)); +function thenDo(m, f) { + if (m._tag == "None") { + return m; } else { - return { _tag: "None" }; + var a = f(m.value); + if (a._tag == "Some") { + a.value.ast = concat(m.value.ast, a.value.ast); + } + return a; } } /** - * define the right hand side of a grammar - * eg. `LHS ::= a + b` - * @param process the right hand side processing : eg. `a + b` in `LHS` - * @param arrange define the order (0 starting) of the elements of the result. - * ast. : eg. `a + c` is `1 0 2` `(+ a c)` - * @returns the processed ast. + * like `f1 | f2` in regex + * @param f1 the first tried function + * @param f2 the second tried function + * @returns wrapped result */ -function gramRHS(process, arrange) { - return (m) => { - let result = process(m); - console.log(`result ${result}`); - if (result._tag == "None") { - return result; +function orDo(f1, f2) { + return (x) => { + let res1 = f1(x); + if (res1._tag == "Some") { + return res1; } else { - let matched = result.value.matched; - let return_array = Array(arrange.length); - arrange.forEach((val, index) => { - return_array[arrange[index]] = matched[index]; - }); - return return_array; + let res2 = f2(x); + return res2; } }; } -var constParser = gramRHS((x) => { return thenDo(toSome(x), orDo(orDo(orDo(tInt, tFlo), tStr), tBool)); }, [0]); -let tree = constParser(commandTPair); -console.log(util.inspect(tree, { showHidden: true, depth: null })); +/** + * 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]; + console.log("AST====" + repr(a.value.ast)); + let ast_middle = [inner]; + let new_ast = [ast_middle]; + a.value.ast = new_ast; + console.log("+" + signal + "+" + repr(a)); + } + return a; +}; +/** fac1 = "(" expr ")" */ +let fac1 = circumfix((x) => thenDo(thenDo(thenDo(tk.toSome(x), tLParen), expr), tRParen), "fac1"); +let fac2 = tInt; +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("(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(repr(beta));