X-Git-Url: https://git.kianting.info/?a=blobdiff_plain;f=src%2Findex.ts;h=acaa74ef15043c42b2b90d34d8ea5cf56964bc79;hb=5f0943539e27b3e0d08e70559ea39017e6df330e;hp=a8d103b5d550e29e63fe0e707a9b36b3b10bd090;hpb=6f2e788329da7702ea96dc28ae04499917ec8152;p=clo diff --git a/src/index.ts b/src/index.ts index a8d103b..acaa74e 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,164 @@ 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 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); + 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}; +function thenDo(m : tk.Maybe, f : Function){ + if (m._tag == "None"){ + return m; + }else{ + var a : tk.Maybe = f(m.value); + if (a._tag == "Some"){ + a.value.ast = concat(m.value.ast, a.value.ast); + } + return a; + } +} -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)); - }else{ - return {_tag : "None"}; +/** + * like `f1 | f2` in regex + * @param f1 the first tried function + * @param f2 the second tried function + * @returns wrapped 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; + } } + } /** - * 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. + * aux function for midfix operator + * @param f function + * @param signal the rule name + * @returns */ -function gramRHS (process: Function, arrange : number[]){ - return (m : TokenMatcheePair)=>{ +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)); - let result : tk.Maybe = process(m); - console.log(`result ${result}`) - if (result._tag == "None"){ - return result; + } - else{ - let matched = result.value.matched; - let return_array : tkTree[] = Array(arrange.length); + return a; +} - arrange.forEach((val, index) => { - return_array[arrange[index]] = matched[index]; - }); +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]; + console.log("AST===="+repr(a.value.ast)); + let ast_middle : tkTree[] = [inner]; + let new_ast = [ast_middle]; + a.value.ast = new_ast; - return return_array; - } + console.log("+"+signal+"+"+repr(a)); + + } + return a; } +/** fac1 = "(" expr ")" */ +let fac1 = circumfix((x : TokenMatcheePair)=> +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 : TokenMatcheePair)=> + 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 : TokenMatcheePair)=> + thenDo(thenDo(thenDo(tk.toSome(x), term), orDo(tAdd,tSub)), term), "expr1"); +/** + * expr2 = term + */ +let expr2 = term; + /** - * CONST ::= INT | STR | FLO | BOOL + * expr = expr1 | expr2 */ -var constParser = gramRHS((x : TokenMatcheePair)=> - {return thenDo(toSome(x),orDo(orDo(orDo(tInt,tFlo),tStr),tBool))}, [0]); +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.Maybe = + tk.toSome({ + matched : [] , + remained : tokensFiltered, + ast : []}); + +let beta = expr({ + matched : [] , + remained : tokensFiltered, + ast : []}); + + +console.log(repr(beta)); -let tree = constParser(commandTPair); -console.log(util.inspect(tree, { showHidden: true, depth: null }));