X-Git-Url: https://git.kianting.info/?a=blobdiff_plain;f=src%2Findex.ts;h=157b1607348020eac4b7e8648093eb77ff8059c6;hb=8d03cc503c747bb974c75d39f8b9c0678a9cc91f;hp=26cd10df0e081ec2ce445b72c26aeef17bdde0bb;hpb=13c9e7026b3a5ba274ef046db3311b76aaaac244;p=clo diff --git a/src/index.ts b/src/index.ts index 26cd10d..157b160 100644 --- a/src/index.ts +++ b/src/index.ts @@ -1,104 +1,145 @@ var fs = require('fs'); +import jsTokens from "js-tokens"; +import * as util from 'util'; +import * as p from 'typescript-parsec'; +import { Token } from 'typescript-parsec'; +/** + * + * # REPRESENTATION + */ +/** + * 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; + } + } -type Some = { _tag: "Some"; value: T }; -type None = {_tag: "None"}; + return str; +} +/**inspect the inner of the representation. */ +let repr = (x : any)=>{return util.inspect(x, {depth: null})}; /** - * @description Like the `Some(a)` and `None` in Rust. - * - * @example - * ```ts - * let exam1 : Maybe = { _tag: "Some", value: 12 }; - * let exam2 : Maybe = None; - * ``` + * + * # TYPES */ -export type Maybe = Some | None; +type tkTree = string | tkTree[]; + +enum TokenKind { + Seperator, + Semicolon, + Number, + Op, + ExprMark, + Paren, + SpaceNL, + Id, + Str, +} + /** - * @description - * the pair of the string to be matched later and the string that have been matched - * @param matched : string have been matched - * @param remained : string will be tested whether it'll be matched. + * Parsing */ -export type MatcheePair = {matched : string; remained : string}; +const lexer = p.buildLexer([ + [true, /^\d+(\.\d+)?/g, TokenKind.Number], + [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], + [false, /^(\s|\n|\r|\t)+/g, TokenKind.SpaceNL] +]); /** - * @description - * it returns a function which test if the first char of the `remained` part of - * the argument of the function is `c`, if it's true, update the `MatchedPair` wrapped - * in `Some`. Otherwise, it returns `None`. - * * @param c : the char to be test. - * @returns the updated `MatchedPair` wrapped in `Some(x)` or `None`. + * + * # TEST */ -export function match1Char(c : string) : (m: MatcheePair) => Maybe { - return (m : MatcheePair)=>{ - const charToBeMatched = m.remained[0]; - if (charToBeMatched === c){ - return {_tag: "Some", value :{ - matched : m.matched + charToBeMatched, - remained : m.remained.substring(1)}}; - } - else{ - return {_tag: "None"}; - } - } +const inputTxt= +`import ast; +--- +122`; + + +const PROG = p.rule(); +const UNIT = p.rule(); +const IMPORTS = p.rule(); +const SEMICOLON = p.rule(); + + +let doubleMinus = { type: 'Punctuator', value: '--' }; +let doubleMinus2 = p.str('--'); +const TERM = p.rule(); + +function applyUnit(value: Token): tkTree{ + return value.text; +} + +function applySemiColon(value: Token): tkTree{ + return value.text; +} + +function applyParts(first: tkTree, + second: [Token, tkTree]):tkTree { + return ["%clo", first , second[1]]; +} + + + + +function applyImports(input: [Token,Token[], tkTree]):tkTree{ + let importTail = input[1].map(x=>x.text); + return ["import"].concat(importTail); }; /** - * @description - * it returns a function which test if the first char of the `remained` part of - * the argument of the function is between `l` and `u`, if it's true, update the `MatchedPair` wrapped - * in `Some`. Otherwise, it returns `None`. - * * @param l : lower bound char, 1-char string - * * @param u : upper bound char, 1-char string - * @returns the updated `MatchedPair` wrapped in `Some(x)` or `None`. + * PROG : IMPORTS '---' UNIT; */ -export function matchRange(l : string, u : string) : (m: MatcheePair) => Maybe { - let lCodepoint = charToCodepoint(l); - let uCodepoint = charToCodepoint(u); - if (l > u){ - throw new Error("Error: the codepoint of `"+l+"` is not smaller than `"+u+"`)"); - } - return (m : MatcheePair)=>{ - - const charToBeMatched = m.remained[0]; - const codePointToBeMatched = charToCodepoint(charToBeMatched); - if (codePointToBeMatched >= lCodepoint && codePointToBeMatched <= uCodepoint){ - return {_tag: "Some", value :{ - matched : m.matched + charToBeMatched, - remained : m.remained.substring(1)}}; - } - else{ - return {_tag: "None"}; - } - } -}; +PROG.setPattern( + p.lrec_sc(IMPORTS, p.seq(p.str('---'), UNIT), applyParts) + +) /** - * convert the one-char string to codepoint. - * @param s : the string to code point. - * @returns if `s.length > 1` return error; otherwise, return the codepoint of `s`. + * PROG : 'import' Id* SEMICOLON; */ -export function charToCodepoint(s : string): number{ - if (s.length > 1){ - throw new Error("Error: the length of input string for "+s+ "is "+s.length+`, - however, it should be 1.`); - }else{ - return s.charCodeAt(0); - } -} +IMPORTS.setPattern( + p.apply(p.seq(p.str('import'), p.rep_sc(p.tok(TokenKind.Id)), SEMICOLON) , applyImports) +); /** - * @description thendo(input, f, ...) like - * a ==> f + * SEMICOLON : ';'; */ -export function thenDo(input : Maybe, f : Function) : Maybe{ - if (input._tag == "None"){ - return input; - } - else{ - let inner = input.value; - return f(inner); - } -} +SEMICOLON.setPattern( + p.apply(p.tok(TokenKind.Semicolon), applySemiColon) +); + +/** + * UNIT : Number; + */ +UNIT.setPattern( + p.apply(p.tok(TokenKind.Number), applyUnit) +); + +let tree = p.expectSingleResult(p.expectEOF(PROG.parse(lexer.parse(inputTxt)))); + + + +console.log("RESULT="+tkTreeToSExp(tree));