X-Git-Url: https://git.kianting.info/?a=blobdiff_plain;f=src%2Findex.ts;h=4c1ce91924e0cfe689858d9ee19fc43e8890e0e2;hb=2167e24090ec8e7f4a43e85de7c8bb2146163804;hp=a8d103b5d550e29e63fe0e707a9b36b3b10bd090;hpb=6f2e788329da7702ea96dc28ae04499917ec8152;p=clo diff --git a/src/index.ts b/src/index.ts index a8d103b..4c1ce91 100644 --- a/src/index.ts +++ b/src/index.ts @@ -1,16 +1,55 @@ var fs = require('fs'); -import { argv } from 'node:process'; +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 { error } from 'node:console'; + +/** + * debug reprensenting + */ +let repr = (x : any)=>{return util.inspect(x, {depth: null})}; /** * token tree type. */ -type tkTree = tk.Token[] | tk.Token +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[] } /** @@ -35,13 +74,15 @@ export function m1TType(typ: tk.TokenType): const ttbm = m.remained[0]; if (ttbm.type == typ) { - m.matched.push(ttbm); - return { + let new_matched = m.matched.concat(ttbm); + let result : tk.Some = { _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" }; @@ -49,72 +90,135 @@ export function m1TType(typ: tk.TokenType): } }; -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 tMul = m1TType(tk.TokenType.I_MUL); argv.forEach((val, index) => { console.log(`${index}=${val}`); }); -let commandInput = 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 : TokenMatcheePair = {matched:[], - remained: commandInputTokenized}; - - -let tInt = m1TType(tk.TokenType.INT); -let tFlo = m1TType(tk.TokenType.FLO); -let tStr = m1TType(tk.TokenType.STR); -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 result : tk.Maybe = process(m); - console.log(`result ${result}`) - if (result._tag == "None"){ - return result; +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; + } } - else{ - let matched = result.value.matched; - let return_array : tkTree[] = Array(arrange.length); + +} - arrange.forEach((val, index) => { - return_array[arrange[index]] = matched[index]; - }); +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; - return return_array; - } + console.log("+"+signal+"+"+repr(a)); + + } + return a; } /** - * CONST ::= INT | STR | FLO | BOOL + * + * fac1 = int MUL int + */ +//let fac1 = midfix((x : TokenMatcheePair)=> +// thenDo(thenDo(thenDo(tk.toSome(x), tInt), tMul), tInt)); + +let fac1 = (x : TokenMatcheePair) => { + let a = midfix((x : TokenMatcheePair)=> + thenDo(thenDo(thenDo(tk.toSome(x), tInt), tMul), tInt), "fac1")(x); + + return a; +} + + +/** + * + * fac2 = int MUL int + */ +let fac2 = tInt; + +/** + * fac = fac1 | fac2 + */ +let fac = orDo(fac1, fac2); + + +/** + * + * expr1 = fac ADD fac + */ +let expr1 = midfix((x : TokenMatcheePair)=> + thenDo(thenDo(thenDo(tk.toSome(x), fac), tAdd), fac), "expr1"); +/** + * expr2 = fac */ -var constParser = gramRHS((x : TokenMatcheePair)=> - {return thenDo(toSome(x),orDo(orDo(orDo(tInt,tFlo),tStr),tBool))}, [0]); +let expr2 = fac; + +/** + * expr = expr1 | expr2 + */ +let expr = orDo(expr1, expr2); + + + + +let tokens = tk.tokenize("2+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.Maybe = + tk.toSome({ + matched : [] , + remained : tokensFiltered, + ast : []}); + +let beta = expr({ + matched : [] , + remained : tokensFiltered, + ast : []}); + +console.log(repr(wrappedTokens)); + +console.log(repr(beta)); -let tree = constParser(commandTPair); -console.log(util.inspect(tree, { showHidden: true, depth: null }));