X-Git-Url: https://git.kianting.info/?a=blobdiff_plain;f=src%2Findex.ts;h=599d32a9040ef78c4127eff01698f54b0aa95ab1;hb=9784854866f652eb2118c390425a6cbe7a702ab1;hp=48d2c866b1d5f622a965eb212194f267bb18722a;hpb=ec563ca30f683cf8dcfd825c697913128f2a5445;p=clo diff --git a/src/index.ts b/src/index.ts index 48d2c86..599d32a 100644 --- a/src/index.ts +++ b/src/index.ts @@ -2,21 +2,80 @@ var fs = require('fs'); import { argv, resourceUsage } from 'node:process'; import * as tk from './tokenize.js'; import * as util from 'util'; -import { reduceRotation } from 'pdf-lib'; +import { drawEllipsePath, reduceRotation } from 'pdf-lib'; +import { isAnyArrayBuffer, isTypedArray } from 'node:util/types'; +import { error } from 'node:console'; +import { isUndefined } from 'node:util'; + +/** + * debug reprensenting + */ +let repr = (x : any)=>{return util.inspect(x, {depth: null})}; /** * token tree type. */ type tkTree = tkTree[] | tk.Token +/** + * 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: tkTree, y:tkTree): tkTree[] { + 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: tkTree, index?:number, end?:number): tkTree[] { + 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."); + + } +} + +/** + * TokenMatcheePair for tokens' parser combinator + * + * matched: the matched (now and before) tokens + * + * remained: tokens to be matched + * + * ast: abstract syntax tree + */ export interface TokenMatcheePair { - matched: tkTree[] + matched: tk.Token[] remained: tk.Token[] + ast : tkTree[] } -export interface MaybeTokensAST{ - maybeTokens: tk.Maybe; - 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; } /** @@ -45,7 +104,8 @@ export function m1TType(typ: tk.TokenType): let result : tk.Some = { _tag: "Some", value: { matched: new_matched, - remained: m.remained.slice(1) + remained: m.remained.slice(1), + ast: ([ttbm]), } }; return result; @@ -56,168 +116,265 @@ 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; -let thenDo = tk.thenDo; -let zeroOrOnceDo = tk.zeroOrOnceDo; -let orDo = tk.orDo; -let zeroOrMoreDo = tk.zeroOrMoreDo; argv.forEach((val, index) => { console.log(`${index}=${val}`); }); -let commandInput = "int a str b"//argv[2]; -let commandInputTokenized = tk.tokenize(commandInput); -let commandInputTokenizedFiltered = commandInputTokenized.filter( - (x : tk.Token)=>{return x.type != tk.TokenType.SP && - x.type != tk.TokenType.NL}); -console.log("aaa: "+util.inspect(commandInputTokenizedFiltered, { showHidden: true, depth: null })); /** - * matchee pair of commandInputTokenized + * like `m ==> f` in ocaml + * @param m matchee wrapped + * @param f matching function + * @returns wrapped result */ -let commandTPair : TokenMatcheePair = {matched:[], - remained: commandInputTokenizedFiltered}; - - -let tInt = m1TType(tk.TokenType.INT); -let tFlo = m1TType(tk.TokenType.FLO); -let tStr = m1TType(tk.TokenType.STR); -let tId = m1TType(tk.TokenType.ID); -let tApos = m1TType(tk.TokenType.APOS); - - -function tBool (x : TokenMatcheePair) :tk.Maybe { - let text = x.remained[0].text - if (text == "true" || text == "false"){ - return thenDo(toSome(x), m1TType(tk.TokenType.ID)); +function thenDo(m : tk.Maybe, f : Function){ + if (m._tag == "None"){ + return m; }else{ - return {_tag : "None"}; + var a : tk.Maybe = 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: Function, arrange : number[]){ - return (m : TokenMatcheePair)=>{ - - let middle : tk.Maybe = process(m); +function orDo(f1 : Function, f2 : Function){ + return (x : TokenMatcheePair) =>{ + let res1 : tk.Maybe = f1(x); + if (res1._tag == "Some"){ + return res1; + }else{ + let res2 : tk.Maybe = f2(x); + return res2; + } + } +} - console.log("Middle"+util.inspect(middle, { showHidden: true, depth: null })); - if (middle._tag == "None"){ - return middle; +/** + * + * @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" }; } - else{ - let matched = middle.value.matched; - let arrLength = arrange.length; - let returnRrray : tkTree[] = Array(arrange.length); - - arrange.forEach((val, index) => { - returnRrray[arrange[index]] = matched[index]; - }); - - let matchedTmp1Length = matched.length-arrLength; - console.log(matchedTmp1Length); - var matchedTmp1 : tkTree[] = matched - .slice(0,matchedTmp1Length); - - console.log("matchedTmp1"+util.inspect(matchedTmp1, { showHidden: true, depth: null })); - console.log("returnRrray"+util.inspect(returnRrray, { showHidden: true, depth: null })); - matchedTmp1.push(returnRrray); +} +/** + * 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)); - let result : tk.Some = {_tag:"Some", - value : {matched : matchedTmp1, - remained : middle.value.remained}}; - return result; - } - } + return wrappedOldX; }; } /** - * typeABS ::= "'" ID + * aux function for midfix operator + * @param f function + * @param signal the rule name + * @returns */ -var typeABS = (x : TokenMatcheePair)=> -{ - var result = thenDo(thenDo(toSome(x),tApos),tId); - if (result._tag == "Some" && "text" in result.value.matched[1]){ - var realToken : tk.Token = result.value.matched[1]; - realToken.text = "'"+realToken.text; - result.value.matched = [realToken]; +let midfix = (f : Function, signal? : string) => (x : TokenMatcheePair)=>{ + var a = f(x); + if (a._tag == "Some"){ + 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)); + + } - return result; + return a; } -/** - * TypeId ::= typeABS | ID - */ -var typeName = (x : TokenMatcheePair)=> -{ - return thenDo(toSome(x), orDo(typeABS, tId)); +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; } /** - * CONST ::= INT | STR | FLO | BOOL + * 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 ) + * +*/ + + +/** fac = single ["(" single ")"]? | single + * Issue1 to be fixed. + */ +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)); + + + + 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 - {return thenDo(toSome(x),orDo(orDo(orDo(tInt,tFlo),tStr),tBool))}, [0]); +let term1 = midfix((x : TokenMatcheePair)=> + thenDo(thenDo(thenDo(tk.toSome(x), fac), orDo(tMul,tDiv)), fac), "term1"); + + /** - * storing the tree + * + * term2 = int MUL int */ -var astTree : tkTree = []; +let term2 = fac; /** - * TYPE_PAIR ::= TYP_ID ID + * term = term1 | term2 */ -var typePair = (x : MaybeTokensAST)=> -{ - - - let a = thenDo(thenDo(x.maybeTokens, typeName), tId); - if (a._tag == "Some"){ - let matched = a.value.matched; - let slice = matched.slice(matched.length-2); - console.log("slice"+slice); +let term = orDo(term1, term2); + - let b : MaybeTokensAST = {maybeTokens : a, ast : slice}; - return b; - } - else{ - let b : MaybeTokensAST= {maybeTokens : a, ast : []}; - return b; - } -} +/** + * + * expr1 = term ADD term + */ +let expr1 = midfix((x : TokenMatcheePair)=> + thenDo(thenDo(thenDo(tk.toSome(x), term), orDo(tAdd,tSub)), term), "expr1"); +/** + * expr2 = term + */ +let expr2 = term; /** - * function's arguments - * FN_ARGS = TYPE_PAIR ("," TYPE_PAIR)+ + * expr = expr1 | expr2 */ +let expr = orDo(expr1, expr2); -var fnArgs = (x : TokenMatcheePair)=> - { - let wrapper : MaybeTokensAST = {maybeTokens : toSome(x), ast : []}; - let a = typePair(wrapper); - console.log("AAAAA"+util.inspect(a, { showHidden: true, depth: null })); - let abanibi = typePair(a); - console.log("ABNB"+util.inspect(abanibi, { showHidden: true, depth: null })); - return {maybeTokens : abanibi.maybeTokens, ast : [a.ast, abanibi.ast]}; - - }; +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("(4-(3/4))"); +//tk.tokenize(argv[2]); + +let tokensFiltered = tokens4.filter( + (x)=>{return (x.type != tk.TokenType.NL + && x.type != tk.TokenType.SP)}); + + + +let beta = expr({ + matched : [] , + remained : tokensFiltered, + ast : []}); + +if (beta._tag == "Some"){ + console.log(tkTreeToSExp(beta.value.ast)); +} + +console.log("RESULT="+repr(beta)); -let tree = fnArgs(commandTPair); -console.log("CHRANN"+util.inspect(tree, { showHidden: true, depth: null }));