X-Git-Url: https://git.kianting.info/?a=blobdiff_plain;f=src%2Findex.js;h=15e18628b9bd679b10e00ed1215069f029b1dfe2;hb=d4dfd2e99f564ca880d40172687986ea3ce757f0;hp=a1ef267b5eb062cd6765a25f3be82e86485efecd;hpb=a722e739575012ebad8cd0a7d2c12df478a54eb8;p=clo diff --git a/src/index.js b/src/index.js index a1ef267..15e1862 100644 --- a/src/index.js +++ b/src/index.js @@ -1,229 +1,206 @@ "use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; Object.defineProperty(exports, "__esModule", { value: true }); -exports.tokenize = exports.zeroOrOnceDo = exports.notDo = exports.zeroOrMoreDo = exports.orDo = exports.thenDo = exports.charToCodepoint = exports.matchRange = exports.matchAny = exports.match1Char = void 0; +exports.tkTreeToSExp = void 0; var fs = require('fs'); +const util = __importStar(require("util")); +const p = __importStar(require("typescript-parsec")); /** - * wrap a x in a `Some(T)` - * @param x : variable to be wrapped. - * @returns wrapped `x`. + * + * # REPRESENTATION */ -function toSome(x) { - return { _tag: "Some", value: x }; -} /** - * @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`. + * convert a `tkTree` AST to S-expr string + * @param t the `tkTree` + * @returns S-expr String */ -function match1Char(c) { - return (m) => { - if (m.remained.length == 0) { - return { _tag: "None" }; - } - const charToBeMatched = m.remained[0]; - if (charToBeMatched === c) { - return { _tag: "Some", value: { - matched: m.matched + charToBeMatched, - remained: m.remained.substring(1) - } }; +function tkTreeToSExp(t) { + var str = ""; + if (Array.isArray(t)) { + let strArray = t.map((x) => tkTreeToSExp(x)); + str = "(" + strArray.join(" ") + ")"; + } + else { + if (t === undefined) { + str = "%undefined"; } else { - return { _tag: "None" }; + str = t; } - }; + } + return str; } -exports.match1Char = match1Char; -; +exports.tkTreeToSExp = tkTreeToSExp; +/**inspect the inner of the representation. */ +let repr = (x) => { return util.inspect(x, { depth: null }); }; +var TokenKind; +(function (TokenKind) { + TokenKind[TokenKind["Seperator"] = 0] = "Seperator"; + TokenKind[TokenKind["Semicolon"] = 1] = "Semicolon"; + TokenKind[TokenKind["Number"] = 2] = "Number"; + TokenKind[TokenKind["Op"] = 3] = "Op"; + TokenKind[TokenKind["ExprMark"] = 4] = "ExprMark"; + TokenKind[TokenKind["ExcapeAt"] = 5] = "ExcapeAt"; + TokenKind[TokenKind["Paren"] = 6] = "Paren"; + TokenKind[TokenKind["SpaceNL"] = 7] = "SpaceNL"; + TokenKind[TokenKind["Id"] = 8] = "Id"; + TokenKind[TokenKind["Str"] = 9] = "Str"; + TokenKind[TokenKind["Comment"] = 10] = "Comment"; +})(TokenKind || (TokenKind = {})); +/** + * 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], +]); /** * - * @param m : the `MatcheePair` to be consumed. - * @returns if the length of `m.remained` >= 1; consumes the matchee by 1 char and wraps it in `Some`, - * otherwise, returns `None`. + * # TEST */ -function matchAny(m) { - if (m.remained.length >= 1) { - return { _tag: "Some", value: { - matched: m.matched + m.remained[0], - remained: m.remained.substring(1) - } }; +const inputTxt = `import a as b; /*bacourt*/ +/* ba choir +ipsum lorem*/ + +import you as john; +--- + +臺中市\\\@ + +公園 +@1+2==3; + +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) { + let unpackedInnerExprs = input[1].map((x) => { return x.text; }); + return ["%exprs", unpackedInnerExprs]; +} +function applySemiColon(value) { + return value.text; +} +function applyParts(first, second) { + return ["%clo", first, second[1]]; +} +function applyComment(value) { + return [value.text]; +} +function applyImport(input) { + 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) { + let resultBody = [input[0]].concat(input[1]); + let resultWrapper = ["%import", resultBody]; + return resultWrapper; +} +; +function applyNotAtText(value) { + if (value.text == "\\\@") { + return '@'; } else { - return { _tag: "None" }; + return value.text; } } -exports.matchAny = matchAny; -/** - * @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`. - */ -function matchRange(l, u) { - 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) => { - if (m.remained.length < 1) { - return { _tag: "None" }; - } - 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" }; - } - }; +; +function applyText(input) { + return ["%text", input]; +} +; +function applyContent(input) { + return ["%content", input]; } -exports.matchRange = matchRange; ; +function applySpaceNL(value) { + return value.text; +} /** - * 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`. + * IMPORTEE: Number, Op, Paren, Id, Str, Comment, */ -function charToCodepoint(s) { - 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); - } -} -exports.charToCodepoint = charToCodepoint; +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)); /** - * @description thendo(input, f, ...) like - * a ==> f - * @param input: the wrapped input. - * @param f: the function to be applied. - * - * @returns:the applied wrapped result `MatcheePair`. + * PROG : IMPORTS '---' CONTENT; */ -function thenDo(input, f) { - if (input._tag == "None") { - return input; - } - else { - let inner = input.value; - return f(inner); - } -} -exports.thenDo = thenDo; +PROG.setPattern(p.lrec_sc(IMPORTS, p.seq(p.str('---'), CONTENT), applyParts)); /** - * @description "or", like the regex `( f1 | f2 )` . - * It returns a function `f` of which the argument is`x`. - * if `f1(x)` is None, then `f` returns `f2(x)`. Otherwise, - * `F` returns `f1(x)`. - * @param f1 : 1st function to be compared - * @param f2 : 2nd function to be compared - * @returns:the combined function + * NOT_AT_TEXT : NOT_AT */ -function orDo(f1, f2) { - return (x) => { - let f1x = (f1(x)); - { - if (f1x._tag == "None") { - return f2(x); - } - else { - return f1x; - } - } - }; -} -exports.orDo = orDo; +NOT_AT_TEXT.setPattern(p.apply(NOT_AT, applyNotAtText)); +IMPORTS.setPattern(p.apply(p.seq(IMPORT, p.rep(IMPORT)), applyImports)); /** -* @description repeating matching function `f` -* zero or more times, like the asterisk `*` in regex `f*` . -* @param f : the function to be repeated 0+ times. -* @returns:the combined function -*/ -function zeroOrMoreDo(f) { - return (x) => { - var wrapped_old_x = { _tag: "Some", value: x }; - var wrapped_new_x = wrapped_old_x; - while (wrapped_new_x._tag != "None") { - wrapped_old_x = wrapped_new_x; - wrapped_new_x = thenDo(wrapped_old_x, f); - } - ; - return wrapped_old_x; - }; -} -exports.zeroOrMoreDo = zeroOrMoreDo; + * IMPORT : + * 'import' IMPORTEE* SEMICOLON | + * COMMENT | + */ +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))); /** -* @description Not. like the `^` inside regex of [^f]. -* returns a function `F(x)` such that if `f(x)` is `None`, -* returns the x consuming a char; if `f(x)` is not None, F(x) -* returns `None`. -* @param f: the function forbidden to be matched. -* @returns: combined function `F`. -*/ -function notDo(f) { - return (x) => { - let wrapped_x = { - _tag: "Some", - value: x - }; - let f_x = thenDo(wrapped_x, f); - if (f_x._tag != "None") { - return { _tag: "None" }; - } - else { - return thenDo(wrapped_x, matchAny); - } - }; -} -exports.notDo = notDo; + * SEMICOLON : ';'; + */ +SEMICOLON.setPattern(p.apply(p.tok(TokenKind.Semicolon), applySemiColon)); /** - * if `x` is matched by `f` once, returns `f(x)`. Otherwise, - * returns x - * similar to `?` in regex `f?`. - * @param f : the function to be matched - * @returns return wrapped f(x) + * SEGMENT : '@' NOT_AT* '@' | + * (NOT_AT_TEXT | EXCAPE_AT)* */ -function zeroOrOnceDo(f) { - return (x) => { - var wrapped_old_x = { _tag: "Some", value: x }; - var wrapped_new_x = thenDo(wrapped_old_x, f); - if (wrapped_new_x._tag != "None") { - return wrapped_new_x; - } - else { - return wrapped_old_x; - } - }; -} -exports.zeroOrOnceDo = zeroOrOnceDo; -function tokenize(input) { - var input_matchee_pair = toSome({ matched: "", - remained: input }); - // integer = ([+]|[-])\d\d? - let integer = (x) => { - let wrapped_x = toSome(x); - let plusMinus = orDo(match1Char('+'), match1Char('-')); // ([+]|[-]) - let d = matchRange('0', '9'); // \d - return thenDo(thenDo(thenDo(wrapped_x, zeroOrOnceDo(plusMinus)), d), zeroOrMoreDo(d)); - }; - console.log(input + ", result: "); - console.log(thenDo(input_matchee_pair, integer)); -} -exports.tokenize = tokenize; -tokenize("+123"); -tokenize("123"); -tokenize("-123"); -tokenize(" 123"); -tokenize("c123"); +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))); +/** + * CONTENT : SEGMENT* + */ +CONTENT.setPattern(p.apply(p.rep(SEGMENT), applyContent)); +let tree = p.expectSingleResult(p.expectEOF(PROG.parse(lexer.parse(inputTxt)))); +console.log("RESULT=" + tkTreeToSExp(tree));