X-Git-Url: https://git.kianting.info/?a=blobdiff_plain;f=src%2Findex.ts;h=26a690eb3b71659a119668c7e4c5f202faf04a39;hb=d4dfd2e99f564ca880d40172687986ea3ce757f0;hp=48d2c866b1d5f622a965eb212194f267bb18722a;hpb=ec563ca30f683cf8dcfd825c697913128f2a5445;p=clo diff --git a/src/index.ts b/src/index.ts index 48d2c86..26a690e 100644 --- a/src/index.ts +++ b/src/index.ts @@ -1,223 +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 { reduceRotation } from 'pdf-lib'; - +import * as p from 'typescript-parsec'; +import { Token } from 'typescript-parsec'; +import { TokenType } from "./tokenize"; +/** + * + * # REPRESENTATION + */ /** - * 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 = ""; -export interface TokenMatcheePair { - matched: tkTree[] - remained: tk.Token[] -} + if (Array.isArray(t)){ + let strArray = t.map((x)=>tkTreeToSExp(x)); + str = "(" + strArray.join(" ") + ")"; + }else{ + if (t=== undefined){ + str = "%undefined" + }else{ + str = t; + } + } -export interface MaybeTokensAST{ - maybeTokens: tk.Maybe; - ast: tkTree; + return str; } +/**inspect the inner of the representation. */ +let repr = (x : any)=>{return util.inspect(x, {depth: null})}; /** - * @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`. + * # TYPES */ -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) - } - }; - return result; - } - else { - return { _tag: "None" }; - } - } -}; - -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}`); -}); +type tkTree = string | tkTree[]; + +enum TokenKind { + Seperator, // --- + Semicolon, // ; + Number, + Op, + ExprMark, // @ + ExcapeAt, // \@ + Paren, + SpaceNL, // \s\t\n\r + Id, + Str, + Comment, // /* ooo */ +} -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 })); +/** + * Parsing + */ +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], + +]); /** - * matchee pair of commandInputTokenized + * + * # TEST */ -let commandTPair : TokenMatcheePair = {matched:[], - remained: commandInputTokenizedFiltered}; +const inputTxt= +`import a as b; /*bacourt*/ +/* ba choir +ipsum lorem*/ +import you as john; +--- -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); +臺中市\\\@ +公園 +@1+2==3; -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"}; - } +console.log("122");@ + +山頂 +`; + + +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]; } -/** - * 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. - */ -function gramRHS (process: Function, arrange : number[]){ - return (m : TokenMatcheePair)=>{ +function applySemiColon(value: Token): tkTree{ + return value.text; +} - let middle : tk.Maybe = process(m); +function applyParts(first: tkTree, + second: [Token, tkTree]):tkTree { + return ["%clo", first , second[1]]; +} - console.log("Middle"+util.inspect(middle, { showHidden: true, depth: null })); - if (middle._tag == "None"){ - return middle; - } - 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); - - - let result : tk.Some = {_tag:"Some", - value : {matched : matchedTmp1, - remained : middle.value.remained}}; - return result; - } +function applyComment(value: Token): tkTree[]{ + return [value.text]; +} + + +function applyImport(input: [Token,Token[], tkTree]) : tkTree{ + let importTail = input[1].map(x=>x.text); + return ["import"].concat(importTail); +}; + + +/* +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); +};*/ + +function applyImports(input : [tkTree, tkTree[]]): tkTree{ + let resultBody = [input[0]].concat(input[1]); + let resultWrapper = ["%import", resultBody]; + return resultWrapper; +}; + + + + +function applyNotAtText(value : Token): tkTree{ + if (value.text == "\\\@"){ + return '@'; } + else{return value.text;} +}; + +function applyText (input : tkTree): tkTree[]{ + return ["%text", input]; +}; + +function applyContent(input : tkTree[]): tkTree[]{ + return ["%content", input]; +}; + +function applySpaceNL(value : Token): tkTree{ + return value.text; } /** - * typeABS ::= "'" ID + * IMPORTEE: Number, Op, Paren, Id, Str, Comment, */ -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]; - } - return result; -} +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), + ); /** - * TypeId ::= typeABS | ID + * PROG : IMPORTS '---' CONTENT; */ -var typeName = (x : TokenMatcheePair)=> -{ - return thenDo(toSome(x), orDo(typeABS, tId)); -} +PROG.setPattern( + p.lrec_sc(IMPORTS, p.seq(p.str('---'), CONTENT), applyParts) + +) /** - * CONST ::= INT | STR | FLO | BOOL + * NOT_AT_TEXT : NOT_AT */ +NOT_AT_TEXT.setPattern( + p.apply(NOT_AT, applyNotAtText) +); + +IMPORTS.setPattern( + p.apply( p.seq(IMPORT, p.rep(IMPORT)), applyImports) +); /** - * TODO: 要用 debugger 檢查分析問題 + * IMPORT : + * 'import' IMPORTEE* SEMICOLON | + * COMMENT | */ -var constParser = gramRHS((x : TokenMatcheePair)=> - {return thenDo(toSome(x),orDo(orDo(orDo(tInt,tFlo),tStr),tBool))}, [0]); +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) + + ) +); /** - * storing the tree + * SEMICOLON : ';'; */ -var astTree : tkTree = []; +SEMICOLON.setPattern( + p.apply(p.tok(TokenKind.Semicolon), applySemiColon) +); + + /** - * TYPE_PAIR ::= TYP_ID ID + * SEGMENT : '@' NOT_AT* '@' | + * (NOT_AT_TEXT | EXCAPE_AT)* */ -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 b : MaybeTokensAST = {maybeTokens : a, ast : slice}; - return b; - } - else{ - let b : MaybeTokensAST= {maybeTokens : a, ast : []}; - return b; - } -} +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), + ) +); /** - * function's arguments - * FN_ARGS = TYPE_PAIR ("," TYPE_PAIR)+ + * CONTENT : SEGMENT* */ +CONTENT.setPattern( + p.apply(p.rep(SEGMENT), applyContent) +); + -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 })); +let tree = p.expectSingleResult(p.expectEOF(PROG.parse(lexer.parse(inputTxt)))); - return {maybeTokens : abanibi.maybeTokens, ast : [a.ast, abanibi.ast]}; - - }; -let tree = fnArgs(commandTPair); -console.log("CHRANN"+util.inspect(tree, { showHidden: true, depth: null })); +console.log("RESULT="+tkTreeToSExp(tree));