X-Git-Url: https://git.kianting.info/?a=blobdiff_plain;f=src%2Findex.ts;h=46c4a7205501d288c574df83980d0e910e4bfd63;hb=4fd4c8a4b69464bf1ac74af920175308656e6f6b;hp=0d94c74c6fb2434f783f1451c0b86f3824973a80;hpb=1a7598fd6e01515661591a41320a63451cb82d5f;p=clo diff --git a/src/index.ts b/src/index.ts index 0d94c74..46c4a72 100644 --- a/src/index.ts +++ b/src/index.ts @@ -3,8 +3,9 @@ import { argv, resourceUsage } from 'node:process'; import * as tk from './tokenize.js'; import * as util from 'util'; import { drawEllipsePath, reduceRotation } from 'pdf-lib'; -import { isTypedArray } from 'node:util/types'; +import { isAnyArrayBuffer, isTypedArray } from 'node:util/types'; import { error } from 'node:console'; +import { isUndefined } from 'node:util'; /** * debug reprensenting @@ -42,8 +43,11 @@ function slice(x: tkTree, index?:number, end?:number): tkTree[] { /** * TokenMatcheePair for tokens' parser combinator + * * matched: the matched (now and before) tokens + * * remained: tokens to be matched + * * ast: abstract syntax tree */ export interface TokenMatcheePair { @@ -52,6 +56,28 @@ export interface TokenMatcheePair { ast : tkTree[] } +/** + * convert a `tkTree` AST to S-expr string + * @param t the `tkTree` + * @returns S-expr String + */ +export function tkTreeToSExp(t: tkTree): string{ + var str = ""; + + if (Array.isArray(t)){ + let strArray = t.map((x)=>tkTreeToSExp(x)); + str = "(" + strArray.join(" ") + ")"; + }else{ + if (t=== undefined){ + str = "%undefined" + }else{ + str = t.text; + } + } + + return str; +} + /** * @description * match one token type. @@ -94,13 +120,16 @@ export function m1TType(typ: tk.TokenType): * type int */ let tInt = m1TType(tk.TokenType.INT); +let tId = m1TType(tk.TokenType.ID); + + 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 tComma = m1TType(tk.TokenType.COMMA); let toSome = tk.toSome; @@ -143,8 +172,61 @@ function orDo(f1 : Function, f2 : Function){ let res2 : tk.Maybe = f2(x); return res2; } + } +} + + +/** + * + * @param m : the `MatcheePair` to be consumed. + * @returns if the length of `m.remained` >= 1; consumes the matchee by 1 token + * and wraps it in `Some`, + * otherwise, returns `None`. + */ +export function matchAny(m: TokenMatcheePair): tk.Maybe { + if (m.remained.length >= 1) { + return { + _tag: "Some", value: { + matched: m.matched.concat(m.remained[0]), + remained: m.remained.slice(1), + ast : [m.remained[0]], + } + }; + } else { + return { _tag: "None" }; } - +} + +/** + * Danger : Maybe it's not enough to work. +* @description repeating matching function `f` +* zero or more times, like the asterisk `*` in regex `f*` . +* @param f : the function to be repeated 0+ times. +* @returns:the combined function +*/ +export function OnceOrMoreDo(f: Function): (x: TokenMatcheePair) => + tk.Maybe { + return (x) => { + var wrappedOldX: tk.Maybe = { _tag: "Some", value: x }; + var wrappedNewX: tk.Maybe = wrappedOldX; + + var counter = -1; + + while (wrappedNewX._tag != "None") { + wrappedOldX = wrappedNewX; + wrappedNewX = thenDo(wrappedOldX, f); + counter += 1; + + }; + + if (counter <= 0){ + return { _tag: "None"}; + } + let ast = wrappedOldX.value.ast ; + wrappedOldX.value.ast =ast.slice(ast.length-counter); + console.log(repr(wrappedOldX.value.ast)); + + return wrappedOldX; }; } /** @@ -160,7 +242,7 @@ let midfix = (f : Function, signal? : string) => (x : TokenMatcheePair)=>{ let new_ast = [ast_tail]; a.value.ast = new_ast; - console.log("+"+signal+"+"+repr(a)); + // console.log("+"+signal+"+"+repr(a)); } @@ -168,46 +250,169 @@ let midfix = (f : Function, signal? : string) => (x : TokenMatcheePair)=>{ } let circumfix = (f : Function, signal? : string) => (x : TokenMatcheePair)=>{ - var a = f(x); + var a : tk.Maybe = f(x); if (a._tag == "Some"){ + console.log("$$$"+repr(a.value.ast)); let inner = a.value.ast[a.value.ast.length-2]; - let ast_middle : tkTree[] = [inner]; + var ast_middle : tkTree[]; + // the list should not be (%list) (%apply) (%lambda) etc. + if (Array.isArray(inner)){ + if ('text' in inner[0] && (inner[0].text.slice(0,1) != "%")){ + ast_middle = inner; + } + else{ + ast_middle = [inner]; + } + } + else{ + 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 : TokenMatcheePair) => - thenDo(thenDo(thenDo(tk.toSome(x), tLParen), expr), tRParen), "fac1"); + thenDo(thenDo(thenDo(toSome(x), tLParen), expr), tRParen), "fac1"); let single2= tInt; let single = orDo(single1, single2); -/** fac1 = single "(" int ")" | single */ -let fac1Appliee = circumfix((x : TokenMatcheePair) => thenDo(thenDo(thenDo(tk.toSome(x), tLParen), tInt), tRParen), "fac1"); -let fac1 = (x : TokenMatcheePair) => - { - let n = thenDo(thenDo(toSome(x), single), fac1Appliee); +/** args = single "," args | single */ +let args1 = (x: TokenMatcheePair)=>{ + var ret = thenDo(thenDo(thenDo(toSome(x), single), tComma), args); + if (ret._tag == "Some"){ + let retLength = ret.value.ast.length; + ret.value.ast = [[ret.value.ast[retLength-3]].concat(ret.value.ast[retLength-1])]; + console.log("$$"+repr(ret.value.ast)); + } + return ret; +}; + +let args2 = single; + +let args = orDo(args1, args2); + + +/** callees = "(" args ")" | "(" ")" */ + + +let callees1 = circumfix((x : TokenMatcheePair) => + thenDo(thenDo(thenDo(toSome(x), tLParen), args), tRParen), "callees1"); +let callees2 = (x: TokenMatcheePair)=>{ + let ret = thenDo(thenDo(toSome(x), tLParen), tRParen); + if (ret._tag == "Some"){ + let new_ast : tkTree[] = [[]]; + ret.value.ast = new_ast; + } + + return ret}; + +let callees = orDo(callees1, callees2); + + + +/** %apply R combinating token */ +let applyToken = { + text: "%apply", + type: tk.TokenType.ID, + col: 0, + ln: 0, +} + +/** facAux = callees facAux | callees */ +let facAux1 = (x: TokenMatcheePair)=>{ + var ret = thenDo(thenDo(toSome(x), callees), facAux); + if (ret._tag == "Some"){ + console.log("1232345"+repr(tkTreeToSExp(ret.value.ast[ret.value.ast.length-1]))); + let last1 = ret.value.ast[ret.value.ast.length-1]; + let last2 = ret.value.ast[ret.value.ast.length-2]; - console.log("+"+"bocchitherock"+"+"+repr(n)); - return n + let b : tkTree[] = [applyToken]; + ret.value.ast = [b.concat([last2, last1])]; + console.log("11111"+repr(tkTreeToSExp(ret.value.ast))); + }; + +return ret;} +let facAux2 = callees; +let facAux = orDo(facAux1, facAux2); + + + +/** fac = single facAux | single + * Issue1 to be fixed. + */ +let fac1 = (x: TokenMatcheePair)=>{ + var ret = thenDo(thenDo(toSome(x), single),facAux); + if(ret._tag == "Some"){ + console.log("777"+repr(tkTreeToSExp(ret.value.ast))); + ret.value.ast = [applyToken, ret.value.ast[ret.value.ast.length-2], + ret.value.ast[ret.value.ast.length-1]]; + ret.value.ast; + rearrangeTree(ret.value.ast); + console.log("888"+repr(tkTreeToSExp(ret.value.ast))); + + } + + return ret;}; let fac2 = single; let fac = orDo(fac1, fac2); +/** + * rearrangeTree : for applyToken subtree from right-combination to + * left-combination + * @input x a ast + * @return another ast + */ +function rearrangeTree(x: any) : any { + + if (x !== undefined){ + for (var i=1;i - thenDo(thenDo(thenDo(tk.toSome(x), fac), orDo(tMul,tDiv)), fac), "term1"); + thenDo(thenDo(thenDo(toSome(x), fac), orDo(tMul,tDiv)), fac), "term1"); /** @@ -227,7 +432,7 @@ let term = orDo(term1, term2); * expr1 = term ADD term */ let expr1 = midfix((x : TokenMatcheePair)=> - thenDo(thenDo(thenDo(tk.toSome(x), term), orDo(tAdd,tSub)), term), "expr1"); + thenDo(thenDo(thenDo(toSome(x), term), orDo(tAdd,tSub)), term), "expr1"); /** * expr2 = term */ @@ -240,19 +445,19 @@ let expr = orDo(expr1, expr2); -let tokens = tk.tokenize("12(13)(14)"); +let tokens = tk.tokenize("1"); +let tokens2 = tk.tokenize("1(2)"); +let tokens3 = tk.tokenize("1(2)(3)"); +let tokens4 = tk.tokenize("2()(4)(5,6)(7,8,9,10)"); + //let tokens = tk.tokenize("(4-(3/4))"); //tk.tokenize(argv[2]); -let tokensFiltered = tokens.filter( +let tokensFiltered = tokens4.filter( (x)=>{return (x.type != tk.TokenType.NL && x.type != tk.TokenType.SP)}); -let wrappedTokens : tk.Maybe = - tk.toSome({ - matched : [] , - remained : tokensFiltered, - ast : []}); + let beta = expr({ matched : [] , @@ -260,5 +465,12 @@ let beta = expr({ ast : []}); + +if (beta._tag == "Some"){ + beta.value.ast = rearrangeTree(beta.value.ast); + console.log(tkTreeToSExp(beta.value.ast)); + +} + console.log("RESULT="+repr(beta));