__setModuleDefault(result, mod);
return result;
};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+ return (mod && mod.__esModule) ? mod : { "default": mod };
+};
Object.defineProperty(exports, "__esModule", { value: true });
-exports.m1TType = void 0;
+exports.matchAny = exports.tkTreeToSExp = void 0;
var fs = require('fs');
-const node_process_1 = require("node:process");
-const tk = __importStar(require("./tokenize.js"));
+const js_tokens_1 = __importDefault(require("js-tokens"));
const util = __importStar(require("util"));
/**
- * debug reprensenting
+ *
+ * # REPRESENTATION
*/
-let repr = (x) => { return util.inspect(x, { depth: null }); };
/**
- * 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.
+ * convert a `tkTree` AST to S-expr string
+ * @param t the `tkTree`
+ * @returns S-expr String
*/
-function concat(x, y) {
- if (Array.isArray(x)) {
- return x.concat(y);
+function tkTreeToSExp(t) {
+ var str = "";
+ 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.");
- }
-}
-function slice(x, index, end) {
- 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.");
- }
-}
-/**
- * @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`.
- */
-function m1TType(typ) {
- return (m) => {
- 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 = {
- _tag: "Some", value: {
- matched: new_matched,
- remained: m.remained.slice(1),
- ast: ([ttbm]),
- }
- };
- return result;
+ if (t === undefined) {
+ str = "%undefined";
}
else {
- return { _tag: "None" };
+ str = t.value;
}
- };
+ }
+ return str;
}
-exports.m1TType = m1TType;
-;
+exports.tkTreeToSExp = tkTreeToSExp;
+/**inspect the inner of the representation. */
+let repr = (x) => { return util.inspect(x, { depth: null }); };
/**
- * type int
+ *
+ * # PARSER UNITS
*/
-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);
-node_process_1.argv.forEach((val, index) => {
- console.log(`${index}=${val}`);
-});
+function toSome(x) {
+ return { _tag: "Some", value: x };
+}
/**
* like `m ==> f` in ocaml
* @param m matchee wrapped
else {
var a = f(m.value);
if (a._tag == "Some") {
- a.value.ast = concat(m.value.ast, a.value.ast);
+ a.value.ast = m.value.ast.concat(a.value.ast);
}
return a;
}
}
+/**
+ *
+ * @param m : the `TokenPair` to be consumed.
+ * @returns if the length of `m.remained` >= 1; consumes the matchee by 1 token
+ * and wraps it in `Some`,
+ * otherwise, returns `None`.
+ */
+function matchAny(m) {
+ if (m.remained.length >= 1) {
+ return {
+ _tag: "Some", value: {
+ matched: m.matched.concat(m.remained[0]),
+ remained: m.remained.slice(1),
+ ast: [m.remained[0]],
+ }
+ };
+ }
+ else {
+ return { _tag: "None" };
+ }
+}
+exports.matchAny = matchAny;
/**
* like `f1 | f2` in regex
* @param f1 the first tried function
};
}
/**
- * aux function for midfix operator
- * @param f function
- * @param signal the rule name
- * @returns
- */
-let midfix = (f, signal) => (x) => {
- var a = f(x);
- if (a._tag == "Some") {
- let ast_tail = slice(a.value.ast, a.value.ast.length - 3);
- let new_ast = [ast_tail];
- a.value.ast = new_ast;
- console.log("+" + signal + "+" + repr(a));
- }
- return a;
-};
-let circumfix = (f, signal) => (x) => {
- 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 = [inner];
- let new_ast = [ast_middle];
- a.value.ast = new_ast;
- console.log("+" + signal + "+" + repr(a));
- }
- return a;
-};
-/** fac1 = "(" expr ")" */
-let fac1 = circumfix((x) => 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) => thenDo(thenDo(thenDo(tk.toSome(x), fac), orDo(tMul, tDiv)), fac), "term1");
-/**
- *
- * term2 = int MUL int
+ * like regex [^c]
+ * @param f input token function. one token only.
+ * @returns combined finction
*/
-let term2 = fac;
-/**
- * term = term1 | term2
- */
-let term = orDo(term1, term2);
+function notDo(f) {
+ return (x) => {
+ let res1 = f(x);
+ if (res1._tag == "Some") {
+ return { _tag: "None" };
+ }
+ else {
+ let res2 = matchAny(x);
+ return res2;
+ }
+ };
+}
+function matchToken(typeName, value) {
+ return (t) => {
+ let headToken = t.remained[0];
+ if (headToken.type != typeName) {
+ return { _tag: "None" };
+ }
+ else {
+ if (value === undefined || value == headToken.value) {
+ let newTokenPair = {
+ matched: t.matched.concat(headToken),
+ remained: t.remained.slice(1),
+ ast: [headToken]
+ };
+ return { _tag: "Some", value: newTokenPair };
+ }
+ else {
+ return { _tag: "None" };
+ }
+ }
+ ;
+ };
+}
+;
/**
*
- * expr1 = term ADD term
- */
-let expr1 = midfix((x) => thenDo(thenDo(thenDo(tk.toSome(x), term), orDo(tAdd, tSub)), term), "expr1");
-/**
- * expr2 = term
+ * # TEST
*/
-let expr2 = term;
-/**
- * expr = expr1 | expr2
- */
-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.toSome({
- matched: [],
- remained: tokensFiltered,
- ast: []
-});
-let beta = expr({
+const tokens = Array.from((0, js_tokens_1.default)(`import; foo from\t 'bar';
+import * as util from 'util';
+
+
+花非花，霧\\{非霧 。{{foo();}}下
+一句`));
+console.log("RESULT=" + repr(tokens));
+var mainTokenPair = {
matched: [],
- remained: tokensFiltered,
+ remained: tokens,
ast: []
-});
-console.log(repr(beta));
+};
+let a = thenDo(thenDo(toSome(mainTokenPair), matchToken('IdentifierName')), notDo(matchToken('Punctuator', ';')));
+console.log("RESULT=" + repr(a));
+if (a._tag == "Some") {
+ console.log("SEXP=" + tkTreeToSExp(a.value.ast));
+}
projects / clo / blobdiff