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         // the list should not be (%list) (%apply) (%lambda) etc.
 241         if (Array.isArray(inner)) {
 242             if ('text' in inner[0] && (inner[0].text.slice(0, 1) != "%")) {
 243                 ast_middle = inner;
 244             }
 245             else {
 246                 ast_middle = [inner];
 247             }
 248         }
 249         else {
 250             ast_middle = [inner];
 251         }
 252         let new_ast = [ast_middle];
 253         a.value.ast = new_ast;
 254     }
 255     return a;
 256 };
 257 /** single1 = tInt | "(" expr ")"*/
 258 let single1 = circumfix((x) => thenDo(thenDo(thenDo(toSome(x), tLParen), expr), tRParen), "fac1");
 259 let single2 = tInt;
 260 let single = orDo(single1, single2);
 261 /** args = single "," args | single */
 262 let args1 = (x) => {
 263     var ret = thenDo(thenDo(thenDo(toSome(x), single), tComma), args);
 264     if (ret._tag == "Some") {
 265         let retLength = ret.value.ast.length;
 266         ret.value.ast = [[ret.value.ast[retLength - 3]].concat(ret.value.ast[retLength - 1])];
 267         console.log("$$" + repr(ret.value.ast));
 268     }
 269     return ret;
 270 };
 271 let args2 = single;
 272 let args = orDo(args1, args2);
 273 /** callees = "(" args ")" | "(" ")" */
 274 let callees1 = circumfix((x) => thenDo(thenDo(thenDo(toSome(x), tLParen), args), tRParen), "callees1");
 275 let callees2 = (x) => {
 276     let ret = thenDo(thenDo(toSome(x), tLParen), tRParen);
 277     if (ret._tag == "Some") {
 278         let new_ast = [[]];
 279         ret.value.ast = new_ast;
 280     }
 281     return ret;
 282 };
 283 let callees = orDo(callees1, callees2);
 284 /** %apply R combinating token */
 285 let applyToken = {
 286     text: "%apply",
 287     type: tk.TokenType.ID,
 288     col: 0,
 289     ln: 0,
 290 };
 291 /** facAux = callees facAux |  callees */
 292 let facAux1 = (x) => {
 293     var ret = thenDo(thenDo(toSome(x), callees), facAux);
 294     if (ret._tag == "Some") {
 295         console.log("1232345" + repr(tkTreeToSExp(ret.value.ast[ret.value.ast.length - 1])));
 296         let last1 = ret.value.ast[ret.value.ast.length - 1];
 297         let last2 = ret.value.ast[ret.value.ast.length - 2];
 298         let b = [applyToken];
 299         ret.value.ast = [b.concat([last2, last1])];
 300         console.log("11111" + repr(tkTreeToSExp(ret.value.ast)));
 301     }
 302     ;
 303     return ret;
 304 };
 305 let facAux2 = callees;
 306 let facAux = orDo(facAux1, facAux2);
 307 /** fac = single facAux | single
 308  * Issue1 to be fixed.
 309  */
 310 let fac1 = (x) => {
 311     var ret = thenDo(thenDo(toSome(x), single), facAux);
 312     if (ret._tag == "Some") {
 313         console.log("777" + repr(tkTreeToSExp(ret.value.ast)));
 314         ret.value.ast = [applyToken, ret.value.ast[ret.value.ast.length - 2],
 315             ret.value.ast[ret.value.ast.length - 1]];
 316         ret.value.ast;
 317         rearrangeTree(ret.value.ast);
 318         console.log("888" + repr(tkTreeToSExp(ret.value.ast)));
 319     }
 320     return ret;
 321 };
 322 let fac2 = single;
 323 let fac = orDo(fac1, fac2);
 324 /**
 325  * rearrangeTree : for applyToken subtree from right-combination to
 326  * left-combination
 327  * @input x a ast
 328  * @return another ast
 329  */
 330 function rearrangeTree(x) {
 331     if (x !== undefined) {
 332         for (var i = 1; i < x.length; i++) {
 333             rearrangeTree(x[i]);
 334         }
 335         console.log("@@" + repr(x[0]));
 336         if (x[0] == applyToken) {
 337             if (Array.isArray(x[2]) && x[2][0] == applyToken) {
 338                 let rl = rearrangeTree(x[2][1]);
 339                 let rr = rearrangeTree(x[2][2]);
 340                 let l = rearrangeTree(x[1]);
 341                 x[0] = applyToken;
 342                 x[1] = [applyToken, l, rl];
 343                 x[2] = rr;
 344                 console.log("@@==" + repr(x));
 345                 return x;
 346             }
 347             else {
 348                 x[0] = applyToken;
 349                 x[1] = rearrangeTree(x[1]);
 350                 x[2] = rearrangeTree(x[2]);
 351                 console.log("@@==" + repr(x));
 352                 return x;
 353             }
 354         }
 355         return x;
 356     }
 357 }
 358 /**
 359  *
 360  * term1 = fac (MUL | DIV) fac
 361  */
 362 let term1 = midfix((x) => thenDo(thenDo(thenDo(toSome(x), fac), orDo(tMul, tDiv)), fac), "term1");
 363 /**
 364  *
 365  * term2 = int MUL int
 366  */
 367 let term2 = fac;
 368 /**
 369  * term = term1 | term2
 370  */
 371 let term = orDo(term1, term2);
 372 /**
 373  *
 374  * expr1 = term ADD term
 375  */
 376 let expr1 = midfix((x) => thenDo(thenDo(thenDo(toSome(x), term), orDo(tAdd, tSub)), term), "expr1");
 377 /**
 378  * expr2 = term
 379  */
 380 let expr2 = term;
 381 /**
 382  * expr = expr1 | expr2
 383  */
 384 let expr = orDo(expr1, expr2);
 385 let tokens = tk.tokenize("1");
 386 let tokens2 = tk.tokenize("1(2)");
 387 let tokens3 = tk.tokenize("1(2)(3)");
 388 let tokens4 = tk.tokenize("2()(4)(5,6)(7,8,9,10)");
 389 //let tokens = tk.tokenize("(4-(3/4))");
 390 //tk.tokenize(argv[2]);
 391 let tokensFiltered = tokens4.filter((x) => {
 392     return (x.type != tk.TokenType.NL
 393         && x.type != tk.TokenType.SP);
 394 });
 395 let beta = expr({
 396     matched: [],
 397     remained: tokensFiltered,
 398     ast: []
 399 });
 400 if (beta._tag == "Some") {
 401     beta.value.ast = rearrangeTree(beta.value.ast);
 402     console.log(tkTreeToSExp(beta.value.ast));
 403 }
 404 console.log("RESULT=" + repr(beta));