git.kianting.info Git - clo/blob - src/index.js

   1 "use strict";
   2 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
   3     if (k2 === undefined) k2 = k;
   4     var desc = Object.getOwnPropertyDescriptor(m, k);
   5     if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
   6       desc = { enumerable: true, get: function() { return m[k]; } };
   7     }
   8     Object.defineProperty(o, k2, desc);
   9 }) : (function(o, m, k, k2) {
  10     if (k2 === undefined) k2 = k;
  11     o[k2] = m[k];
  12 }));
  13 var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
  14     Object.defineProperty(o, "default", { enumerable: true, value: v });
  15 }) : function(o, v) {
  16     o["default"] = v;
  17 });
  18 var __importStar = (this && this.__importStar) || function (mod) {
  19     if (mod && mod.__esModule) return mod;
  20     var result = {};
  21     if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
  22     __setModuleDefault(result, mod);
  23     return result;
  24 };
  25 Object.defineProperty(exports, "__esModule", { value: true });
  26 exports.OnceOrMoreDo = exports.matchAny = exports.m1TType = exports.tkTreeToSExp = void 0;
  27 var fs = require('fs');
  28 const node_process_1 = require("node:process");
  29 const tk = __importStar(require("./tokenize.js"));
  30 const util = __importStar(require("util"));
  31 /**
  32  * debug reprensenting
  33  */
  34 let repr = (x) => { return util.inspect(x, { depth: null }); };
  35 /**
  36  * concated 2 `tkTree`s
  37  * @param x the array to be concated
  38  * @param y the item or array to ve concated
  39  * @returns concated tkTree array, or thrown error if can't be concated.
  40  */
  41 function concat(x, y) {
  42     if (Array.isArray(x)) {
  43         return x.concat(y);
  44     }
  45     else {
  46         throw new Error("the tkTree can't be concated, because it's not an array.");
  47     }
  48 }
  49 function slice(x, index, end) {
  50     if (Array.isArray(x)) {
  51         return x.slice(index, end);
  52     }
  53     else {
  54         throw new Error("the tkTree can't be concated, because it's not an array.");
  55     }
  56 }
  57 /**
  58  * convert a `tkTree` AST to S-expr string
  59  * @param t the `tkTree`
  60  * @returns S-expr String
  61  */
  62 function tkTreeToSExp(t) {
  63     var str = "";
  64     if (Array.isArray(t)) {
  65         let strArray = t.map((x) => tkTreeToSExp(x));
  66         str = "(" + strArray.join(" ") + ")";
  67     }
  68     else {
  69         if (t === undefined) {
  70             str = "%undefined";
  71         }
  72         else {
  73             str = t.text;
  74         }
  75     }
  76     return str;
  77 }
  78 exports.tkTreeToSExp = tkTreeToSExp;
  79 /**
  80  * @description
  81  * match one token type.
  82  *
  83  * it returns a function which test if the type of first token of the `remained` part of
  84  *  the argument of the function is `typ` , if it's true, update the `TokenMatcheePair` wrapped
  85  * in `Some`. Otherwise, it returns `None`.
  86  *  * @param typ : the type to be test.
  87  * @returns the updated `TokenMatcheePair` wrapped in `Some(x)` or `None`.
  88  */
  89 function m1TType(typ) {
  90     return (m) => {
  91         if (m.remained.length == 0) {
  92             return { _tag: "None" };
  93         }
  94         /**
  95          * token to be matched
  96          * */
  97         const ttbm = m.remained[0];
  98         if (ttbm.type == typ) {
  99             let new_matched = m.matched.concat(ttbm);
 100             let result = {
 101                 _tag: "Some", value: {
 102                     matched: new_matched,
 103                     remained: m.remained.slice(1),
 104                     ast: ([ttbm]),
 105                 }
 106             };
 107             return result;
 108         }
 109         else {
 110             return { _tag: "None" };
 111         }
 112     };
 113 }
 114 exports.m1TType = m1TType;
 115 ;
 116 /**
 117  * type int
 118  */
 119 let tInt = m1TType(tk.TokenType.INT);
 120 let tId = m1TType(tk.TokenType.ID);
 121 let tAdd = m1TType(tk.TokenType.I_ADD);
 122 let tSub = m1TType(tk.TokenType.I_SUB);
 123 let tMul = m1TType(tk.TokenType.I_MUL);
 124 let tDiv = m1TType(tk.TokenType.I_DIV);
 125 let tLParen = m1TType(tk.TokenType.L_PAREN);
 126 let tRParen = m1TType(tk.TokenType.R_PAREN);
 127 let tComma = m1TType(tk.TokenType.COMMA);
 128 let toSome = tk.toSome;
 129 node_process_1.argv.forEach((val, index) => {
 130     console.log(`${index}=${val}`);
 131 });
 132 /**
 133  * like `m ==> f` in ocaml
 134  * @param m matchee wrapped
 135  * @param f matching function
 136  * @returns wrapped result
 137  */
 138 function thenDo(m, f) {
 139     if (m._tag == "None") {
 140         return m;
 141     }
 142     else {
 143         var a = f(m.value);
 144         if (a._tag == "Some") {
 145             a.value.ast = concat(m.value.ast, a.value.ast);
 146         }
 147         return a;
 148     }
 149 }
 150 /**
 151  * like `f1 | f2` in regex
 152  * @param f1 the first tried function
 153  * @param f2 the second tried function
 154  * @returns wrapped result
 155  */
 156 function orDo(f1, f2) {
 157     return (x) => {
 158         let res1 = f1(x);
 159         if (res1._tag == "Some") {
 160             return res1;
 161         }
 162         else {
 163             let res2 = f2(x);
 164             return res2;
 165         }
 166     };
 167 }
 168 /**
 169  *
 170  * @param m : the `MatcheePair` to be consumed.
 171  * @returns if the length of `m.remained` >= 1; consumes the matchee by 1 token
 172  *  and wraps it in `Some`,
 173  * otherwise, returns `None`.
 174  */
 175 function matchAny(m) {
 176     if (m.remained.length >= 1) {
 177         return {
 178             _tag: "Some", value: {
 179                 matched: m.matched.concat(m.remained[0]),
 180                 remained: m.remained.slice(1),
 181                 ast: [m.remained[0]],
 182             }
 183         };
 184     }
 185     else {
 186         return { _tag: "None" };
 187     }
 188 }
 189 exports.matchAny = matchAny;
 190 /**
 191  * Danger : Maybe it's not enough to work.
 192 * @description repeating matching function `f`
 193 * zero or more times, like the asterisk `*` in regex `f*` .
 194 * @param f : the function to be repeated 0+ times.
 195 * @returns:the combined function
 196 */
 197 function OnceOrMoreDo(f) {
 198     return (x) => {
 199         var wrappedOldX = { _tag: "Some", value: x };
 200         var wrappedNewX = wrappedOldX;
 201         var counter = -1;
 202         while (wrappedNewX._tag != "None") {
 203             wrappedOldX = wrappedNewX;
 204             wrappedNewX = thenDo(wrappedOldX, f);
 205             counter += 1;
 206         }
 207         ;
 208         if (counter <= 0) {
 209             return { _tag: "None" };
 210         }
 211         let ast = wrappedOldX.value.ast;
 212         wrappedOldX.value.ast = ast.slice(ast.length - counter);
 213         console.log(repr(wrappedOldX.value.ast));
 214         return wrappedOldX;
 215     };
 216 }
 217 exports.OnceOrMoreDo = OnceOrMoreDo;
 218 /**
 219  * aux function for midfix operator
 220  * @param f function
 221  * @param signal the rule name
 222  * @returns
 223  */
 224 let midfix = (f, signal) => (x) => {
 225     var a = f(x);
 226     if (a._tag == "Some") {
 227         let ast_tail = slice(a.value.ast, a.value.ast.length - 3);
 228         let new_ast = [ast_tail];
 229         a.value.ast = new_ast;
 230         // console.log("+"+signal+"+"+repr(a));
 231     }
 232     return a;
 233 };
 234 let circumfix = (f, signal) => (x) => {
 235     var a = f(x);
 236     if (a._tag == "Some") {
 237         console.log("$$$" + repr(a.value.ast));
 238         let inner = a.value.ast[a.value.ast.length - 2];
 239         var ast_middle;
 240         if (Array.isArray(inner)) {
 241             ast_middle = inner;
 242         }
 243         else {
 244             ast_middle = [inner];
 245         }
 246         let new_ast = [ast_middle];
 247         a.value.ast = new_ast;
 248     }
 249     return a;
 250 };
 251 /** single1 = tInt | "(" expr ")"*/
 252 let single1 = circumfix((x) => thenDo(thenDo(thenDo(toSome(x), tLParen), expr), tRParen), "fac1");
 253 let single2 = tInt;
 254 let single = orDo(single1, single2);
 255 /** args = single "," args | single */
 256 let args1 = (x) => {
 257     var ret = thenDo(thenDo(thenDo(toSome(x), single), tComma), args);
 258     if (ret._tag == "Some") {
 259         let retLength = ret.value.ast.length;
 260         ret.value.ast = [[ret.value.ast[retLength - 3]].concat(ret.value.ast[retLength - 1])];
 261         console.log("$$" + repr(ret.value.ast));
 262     }
 263     return ret;
 264 };
 265 let args2 = single;
 266 let args = orDo(args1, args2);
 267 /** callees = "(" args ")" | "(" ")" */
 268 let callees1 = circumfix((x) => thenDo(thenDo(thenDo(toSome(x), tLParen), args), tRParen), "callees1");
 269 let callees2 = (x) => {
 270     let ret = thenDo(thenDo(toSome(x), tLParen), tRParen);
 271     if (ret._tag == "Some") {
 272         let new_ast = [[]];
 273         ret.value.ast = new_ast;
 274     }
 275     return ret;
 276 };
 277 let callees = orDo(callees1, callees2);
 278 /** %apply R combinating token */
 279 let applyToken = {
 280     text: "%apply",
 281     type: tk.TokenType.ID,
 282     col: 0,
 283     ln: 0,
 284 };
 285 /** facAux = callees facAux |  callees */
 286 let facAux1 = (x) => {
 287     var ret = thenDo(thenDo(toSome(x), callees), facAux);
 288     if (ret._tag == "Some") {
 289         console.log("1232345" + repr(tkTreeToSExp(ret.value.ast[ret.value.ast.length - 1])));
 290         let last1 = ret.value.ast[ret.value.ast.length - 1];
 291         let last2 = ret.value.ast[ret.value.ast.length - 2];
 292         let b = [applyToken];
 293         ret.value.ast = [b.concat([last2, last1])];
 294         console.log("11111" + repr(tkTreeToSExp(ret.value.ast)));
 295     }
 296     ;
 297     return ret;
 298 };
 299 let facAux2 = callees;
 300 let facAux = orDo(facAux1, facAux2);
 301 /** fac = single facAux | single
 302  * Issue1 to be fixed.
 303  */
 304 let fac1 = (x) => {
 305     var ret = thenDo(thenDo(toSome(x), single), facAux);
 306     if (ret._tag == "Some") {
 307         console.log("777" + repr(tkTreeToSExp(ret.value.ast)));
 308         ret.value.ast = [applyToken, ret.value.ast[ret.value.ast.length - 2],
 309             ret.value.ast[ret.value.ast.length - 1]];
 310         ret.value.ast;
 311         rearrangeTree(ret.value.ast);
 312         console.log("888" + repr(tkTreeToSExp(ret.value.ast)));
 313     }
 314     return ret;
 315 };
 316 let fac2 = single;
 317 let fac = orDo(fac1, fac2);
 318 /**
 319  * rearrangeTree : for applyToken subtree from right-combination to
 320  * left-combination
 321  * @input x a ast
 322  * @return another ast
 323  */
 324 function rearrangeTree(x) {
 325     if (x !== undefined) {
 326         for (var i = 1; i < x.length; i++) {
 327             rearrangeTree(x[i]);
 328         }
 329         console.log("@@" + repr(x[0]));
 330         if (x[0] == applyToken) {
 331             if (Array.isArray(x[2]) && x[2][0] == applyToken) {
 332                 let rl = rearrangeTree(x[2][1]);
 333                 let rr = rearrangeTree(x[2][2]);
 334                 let l = rearrangeTree(x[1]);
 335                 x[0] = applyToken;
 336                 x[1] = [applyToken, l, rl];
 337                 x[2] = rr;
 338                 console.log("@@==" + repr(x));
 339                 return x;
 340             }
 341             else {
 342                 x[0] = applyToken;
 343                 x[1] = rearrangeTree(x[1]);
 344                 x[2] = rearrangeTree(x[2]);
 345                 console.log("@@==" + repr(x));
 346                 return x;
 347             }
 348         }
 349         return x;
 350     }
 351 }
 352 /**
 353  *
 354  * term1 = fac (MUL | DIV) fac
 355  */
 356 let term1 = midfix((x) => thenDo(thenDo(thenDo(toSome(x), fac), orDo(tMul, tDiv)), fac), "term1");
 357 /**
 358  *
 359  * term2 = int MUL int
 360  */
 361 let term2 = fac;
 362 /**
 363  * term = term1 | term2
 364  */
 365 let term = orDo(term1, term2);
 366 /**
 367  *
 368  * expr1 = term ADD term
 369  */
 370 let expr1 = midfix((x) => thenDo(thenDo(thenDo(toSome(x), term), orDo(tAdd, tSub)), term), "expr1");
 371 /**
 372  * expr2 = term
 373  */
 374 let expr2 = term;
 375 /**
 376  * expr = expr1 | expr2
 377  */
 378 let expr = orDo(expr1, expr2);
 379 let tokens = tk.tokenize("1");
 380 let tokens2 = tk.tokenize("1(2)");
 381 let tokens3 = tk.tokenize("1(2)(3)");
 382 let tokens4 = tk.tokenize("2()(4)");
 383 //let tokens = tk.tokenize("(4-(3/4))");
 384 //tk.tokenize(argv[2]);
 385 let tokensFiltered = tokens4.filter((x) => {
 386     return (x.type != tk.TokenType.NL
 387         && x.type != tk.TokenType.SP);
 388 });
 389 let beta = expr({
 390     matched: [],
 391     remained: tokensFiltered,
 392     ast: []
 393 });
 394 if (beta._tag == "Some") {
 395     beta.value.ast = rearrangeTree(beta.value.ast);
 396     console.log(tkTreeToSExp(beta.value.ast));
 397 }
 398 console.log("RESULT=" + repr(beta));