X-Git-Url: https://git.kianting.info/?a=blobdiff_plain;f=src%2Findex.ts;h=26a690eb3b71659a119668c7e4c5f202faf04a39;hb=d4dfd2e99f564ca880d40172687986ea3ce757f0;hp=acaa74ef15043c42b2b90d34d8ea5cf56964bc79;hpb=5f0943539e27b3e0d08e70559ea39017e6df330e;p=clo diff --git a/src/index.ts b/src/index.ts index acaa74e..26a690e 100644 --- a/src/index.ts +++ b/src/index.ts @@ -1,253 +1,265 @@ var fs = require('fs'); -import { argv, resourceUsage } from 'node:process'; -import * as tk from './tokenize.js'; +import jsTokens from "js-tokens"; import * as util from 'util'; -import { drawEllipsePath, reduceRotation } from 'pdf-lib'; -import { isTypedArray } from 'node:util/types'; -import { error } from 'node:console'; - +import * as p from 'typescript-parsec'; +import { Token } from 'typescript-parsec'; +import { TokenType } from "./tokenize"; /** - * debug reprensenting + * + * # REPRESENTATION */ -let repr = (x : any)=>{return util.inspect(x, {depth: null})}; - /** - * token tree type. + * convert a `tkTree` AST to S-expr string + * @param t the `tkTree` + * @returns S-expr String */ -type tkTree = tkTree[] | tk.Token +export function tkTreeToSExp(t: tkTree): string{ + var str = ""; -/** - * 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); + if (Array.isArray(t)){ + let strArray = t.map((x)=>tkTreeToSExp(x)); + str = "(" + strArray.join(" ") + ")"; }else{ - throw new Error("the tkTree can't be concated, because it's not an array."); - + if (t=== undefined){ + str = "%undefined" + }else{ + str = t; + } } -} -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."); - - } + return str; } +/**inspect the inner of the representation. */ +let repr = (x : any)=>{return util.inspect(x, {depth: null})}; /** - * TokenMatcheePair for tokens' parser combinator - * matched: the matched (now and before) tokens - * remained: tokens to be matched - * ast: abstract syntax tree + * + * # TYPES */ -export interface TokenMatcheePair { - matched: tk.Token[] - remained: tk.Token[] - ast : tkTree[] + + +type tkTree = string | tkTree[]; + +enum TokenKind { + Seperator, // --- + Semicolon, // ; + Number, + Op, + ExprMark, // @ + ExcapeAt, // \@ + Paren, + SpaceNL, // \s\t\n\r + Id, + Str, + Comment, // /* ooo */ } /** - * @description - * match one token type. - * - * it returns a function which test if the type of first token of the `remained` part of - * the argument of the function is `typ` , if it's true, update the `TokenMatcheePair` wrapped - * in `Some`. Otherwise, it returns `None`. - * * @param typ : the type to be test. - * @returns the updated `TokenMatcheePair` wrapped in `Some(x)` or `None`. + * Parsing */ -export function m1TType(typ: tk.TokenType): - (m: TokenMatcheePair) => tk.Maybe { - return (m: TokenMatcheePair) => { - if (m.remained.length == 0) { - return { _tag: "None" }; - } - /** - * token to be matched - * */ - const ttbm = m.remained[0]; - - if (ttbm.type == typ) { - let new_matched = m.matched.concat(ttbm); - let result : tk.Some = { - _tag: "Some", value: { - matched: new_matched, - remained: m.remained.slice(1), - ast: ([ttbm]), - } - }; - return result; - } - else { - return { _tag: "None" }; - } - } -}; +const lexer = p.buildLexer([ + [true, /^\d+(\.\d+)?/g, TokenKind.Number], + [true, /^\\\@/g, TokenKind.ExcapeAt], + [true, /^\/\*([^/]|\/[^*])*\*\//g, TokenKind.Comment], + [true, /^\;/g, TokenKind.Semicolon], + [true, /^[-][-][-]/g, TokenKind.Seperator], + [true, /^[\+\-\*\/\&\|\!\^\<\>\~\=\?]+/g, TokenKind.Op], + [true, /^\@/g, TokenKind.ExprMark], + [true, /^[()\[\]{}]/g, TokenKind.Paren], + [true, /^["]([\"]|[\\].)*["]/g, TokenKind.Str], + [true, /^[']([\']|[\\].)*[']/g, TokenKind.Str], + [true, /^[()\[\]{}]/g, TokenKind.Paren], + [true, /^[^\/\\\@\s\n\t\r;]+/g, TokenKind.Id], + [true, /^(\s|\n|\r|\t)+/g, TokenKind.SpaceNL], + +]); /** - * type int + * + * # TEST */ -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); +const inputTxt= +`import a as b; /*bacourt*/ +/* ba choir +ipsum lorem*/ +import you as john; +--- +臺中市\\\@ -argv.forEach((val, index) => { - console.log(`${index}=${val}`); -}); +公園 +@1+2==3; +console.log("122");@ -/** - * like `m ==> f` in ocaml - * @param m matchee wrapped - * @param f matching function - * @returns wrapped result - */ -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; - } + +const PROG = p.rule(); +const SEGMENT = p.rule(); +const IMPORT = p.rule(); +const IMPORTS = p.rule(); +const SEMICOLON = p.rule(); +const EXCAPE_AT = p.rule(); +const NOT_AT_TEXT = p.rule(); +const CONTENT = p.rule(); + +let doubleMinus = { type: 'Punctuator', value: '--' }; +let doubleMinus2 = p.str('--'); +const TERM = p.rule(); + +function applySegment(input: [Token, Token[], + Token]): tkTree[]{ + let unpackedInnerExprs = input[1].map((x)=>{return x.text}); + return ["%exprs", unpackedInnerExprs]; } -/** - * 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; - } - } - +function applySemiColon(value: Token): tkTree{ + return value.text; } -/** - * 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_tail : tkTree[] = slice(a.value.ast,a.value.ast.length-3); - let new_ast = [ast_tail]; - a.value.ast = new_ast; +function applyParts(first: tkTree, + second: [Token, tkTree]):tkTree { + return ["%clo", first , second[1]]; +} - console.log("+"+signal+"+"+repr(a)); - - } - return a; +function applyComment(value: Token): tkTree[]{ + return [value.text]; } -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; - console.log("+"+signal+"+"+repr(a)); +function applyImport(input: [Token,Token[], tkTree]) : tkTree{ + let importTail = input[1].map(x=>x.text); + return ["import"].concat(importTail); +}; - - } - return a; -} -/** fac1 = "(" expr ")" */ -let fac1 = circumfix((x : TokenMatcheePair)=> -thenDo(thenDo(thenDo(tk.toSome(x), tLParen), expr), tRParen), "fac1"); +/* +function applyImportComment(input: [Token,Token[], + tkTree, Token]) : tkTree{ + let importTail = input[1].map(x=>x.text); + let comment = [input[3].text]; + return ["import"].concat(importTail).concat(comment); +};*/ -let fac2 = tInt; +function applyImports(input : [tkTree, tkTree[]]): tkTree{ + let resultBody = [input[0]].concat(input[1]); + let resultWrapper = ["%import", resultBody]; + return resultWrapper; +}; -let fac = orDo(fac1, fac2); -/** - * - * term1 = fac (MUL | DIV) fac - */ +function applyNotAtText(value : Token): tkTree{ + if (value.text == "\\\@"){ + return '@'; + } + else{return value.text;} +}; -let term1 = midfix((x : TokenMatcheePair)=> - thenDo(thenDo(thenDo(tk.toSome(x), fac), orDo(tMul,tDiv)), fac), "term1"); +function applyText (input : tkTree): tkTree[]{ + return ["%text", input]; +}; + +function applyContent(input : tkTree[]): tkTree[]{ + return ["%content", input]; +}; + +function applySpaceNL(value : Token): tkTree{ + return value.text; +} - /** - * - * term2 = int MUL int + * IMPORTEE: Number, Op, Paren, Id, Str, Comment, */ -let term2 = fac; +let IMPORTEE = p.alt(p.tok(TokenKind.Number), + p.tok(TokenKind.Op), + p.tok(TokenKind.Paren), + p.tok(TokenKind.Id), + p.tok(TokenKind.Str), + p.tok(TokenKind.SpaceNL), + p.tok(TokenKind.Comment)); + +let NOT_AT = p.alt(p.tok(TokenKind.Seperator), + p.tok(TokenKind.Semicolon), + p.tok(TokenKind.Number), + p.tok(TokenKind.ExcapeAt), + p.tok(TokenKind.Op), + p.tok(TokenKind.Paren), + p.tok(TokenKind.SpaceNL), + p.tok(TokenKind.Id), + p.tok(TokenKind.Str), + p.tok(TokenKind.Comment), + ); /** - * term = term1 | term2 + * PROG : IMPORTS '---' CONTENT; */ -let term = orDo(term1, term2); - +PROG.setPattern( + p.lrec_sc(IMPORTS, p.seq(p.str('---'), CONTENT), applyParts) + +) /** - * - * expr1 = term ADD term + * NOT_AT_TEXT : NOT_AT */ -let expr1 = midfix((x : TokenMatcheePair)=> - thenDo(thenDo(thenDo(tk.toSome(x), term), orDo(tAdd,tSub)), term), "expr1"); +NOT_AT_TEXT.setPattern( + p.apply(NOT_AT, applyNotAtText) +); + +IMPORTS.setPattern( + p.apply( p.seq(IMPORT, p.rep(IMPORT)), applyImports) +); + /** - * expr2 = term + * IMPORT : + * 'import' IMPORTEE* SEMICOLON | + * COMMENT | */ -let expr2 = term; +IMPORT.setPattern( + p.alt( + p.apply(p.seq(p.str('import'), p.rep_sc(IMPORTEE), SEMICOLON), + applyImport), + p.apply(p.tok(TokenKind.Comment), applyComment), + p.apply(p.tok(TokenKind.SpaceNL), applySpaceNL) + + ) +); /** - * expr = expr1 | expr2 + * SEMICOLON : ';'; */ -let expr = orDo(expr1, expr2); +SEMICOLON.setPattern( + p.apply(p.tok(TokenKind.Semicolon), applySemiColon) +); +/** + * SEGMENT : '@' NOT_AT* '@' | + * (NOT_AT_TEXT | EXCAPE_AT)* + */ +SEGMENT.setPattern( + p.alt( + p.apply(p.rep_sc(NOT_AT_TEXT), applyText), + p.apply(p.seq(p.str('@'), p.rep(NOT_AT), p.str('@')), applySegment), + ) +); -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)}); +/** + * CONTENT : SEGMENT* + */ +CONTENT.setPattern( + p.apply(p.rep(SEGMENT), applyContent) +); -let wrappedTokens : tk.Maybe = - tk.toSome({ - matched : [] , - remained : tokensFiltered, - ast : []}); -let beta = expr({ - matched : [] , - remained : tokensFiltered, - ast : []}); +let tree = p.expectSingleResult(p.expectEOF(PROG.parse(lexer.parse(inputTxt)))); -console.log(repr(beta)); +console.log("RESULT="+tkTreeToSExp(tree));