X-Git-Url: https://git.kianting.info/?a=blobdiff_plain;f=src%2Findex.ts;h=599d32a9040ef78c4127eff01698f54b0aa95ab1;hb=9784854866f652eb2118c390425a6cbe7a702ab1;hp=4c1ce91924e0cfe689858d9ee19fc43e8890e0e2;hpb=f801ef14fc25ae122aaef4aede639ddb9b37006a;p=clo diff --git a/src/index.ts b/src/index.ts index 4c1ce91..599d32a 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,8 +120,17 @@ 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 toSome = tk.toSome; argv.forEach((val, index) => { @@ -137,62 +172,179 @@ 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; }; +} + +/** + * aux function for midfix operator + * @param f function + * @param signal the rule name + * @returns + */ let midfix = (f : Function, signal? : string) => (x : TokenMatcheePair)=>{ var a = f(x); if (a._tag == "Some"){ - let ast_head : tkTree[] = slice(a.value.ast,0,a.value.ast.length-3); let ast_tail : tkTree[] = slice(a.value.ast,a.value.ast.length-3); let new_ast = [ast_tail]; a.value.ast = new_ast; - console.log("+"+signal+"+"+repr(a)); + // console.log("+"+signal+"+"+repr(a)); } return a; } +let circumfix = (f : Function, signal? : string) => (x : TokenMatcheePair)=>{ + var a = f(x); + if (a._tag == "Some"){ + let inner = a.value.ast[a.value.ast.length-2]; + let ast_middle : tkTree[] = [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"); +let single2= tInt; +let single = orDo(single1, single2); + +/** func = single | single "(" single ")" + * i.e. + * + * func = single | func_aux ( int ) * - * fac1 = int MUL int +*/ + + +/** fac = single ["(" single ")"]? | single + * Issue1 to be fixed. */ -//let fac1 = midfix((x : TokenMatcheePair)=> -// thenDo(thenDo(thenDo(tk.toSome(x), tInt), tMul), tInt)); +let fac1Appliee = circumfix((x : TokenMatcheePair) => thenDo(thenDo(thenDo(tk.toSome(x), tLParen), tInt), tRParen), "fac1"); +let fac1 = (x : TokenMatcheePair) => + { + let raw = thenDo(thenDo(toSome(x), single), OnceOrMoreDo(fac1Appliee)); -let fac1 = (x : TokenMatcheePair) => { - let a = midfix((x : TokenMatcheePair)=> - thenDo(thenDo(thenDo(tk.toSome(x), tInt), tMul), tInt), "fac1")(x); + + + if (raw._tag == "Some"){ + + + var result : tkTree = raw.value.ast[0]; + let applyToken : tk.Token = {text: '%apply', ln:0, col:0}; + for (var i=1; i + thenDo(thenDo(thenDo(tk.toSome(x), fac), orDo(tMul,tDiv)), fac), "term1"); /** * - * fac2 = int MUL int + * term2 = int MUL int */ -let fac2 = tInt; +let term2 = fac; /** - * fac = fac1 | fac2 + * term = term1 | term2 */ -let fac = orDo(fac1, fac2); +let term = orDo(term1, term2); /** * - * expr1 = fac ADD fac + * expr1 = term ADD term */ let expr1 = midfix((x : TokenMatcheePair)=> - thenDo(thenDo(thenDo(tk.toSome(x), fac), tAdd), fac), "expr1"); + thenDo(thenDo(thenDo(tk.toSome(x), term), orDo(tAdd,tSub)), term), "expr1"); /** - * expr2 = fac + * expr2 = term */ -let expr2 = fac; +let expr2 = term; /** * expr = expr1 | expr2 @@ -201,24 +353,28 @@ let expr = orDo(expr1, expr2); +let tokens = tk.tokenize("1"); +let tokens2 = tk.tokenize("1(2)"); +let tokens3 = tk.tokenize("1(2)(3)"); +let tokens4 = tk.tokenize("(3(2))*2+1"); -let tokens = tk.tokenize("2+3*4");//tk.tokenize(argv[2]); -let tokensFiltered = tokens.filter( +//let tokens = tk.tokenize("(4-(3/4))"); +//tk.tokenize(argv[2]); + +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 : [] , remained : tokensFiltered, ast : []}); -console.log(repr(wrappedTokens)); +if (beta._tag == "Some"){ + console.log(tkTreeToSExp(beta.value.ast)); +} -console.log(repr(beta)); +console.log("RESULT="+repr(beta));