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 toSome = tk.toSome;
 128 node_process_1.argv.forEach((val, index) => {
 129     console.log(`${index}=${val}`);
 130 });
 131 /**
 132  * like `m ==> f` in ocaml
 133  * @param m matchee wrapped
 134  * @param f matching function
 135  * @returns wrapped result
 136  */
 137 function thenDo(m, f) {
 138     if (m._tag == "None") {
 139         return m;
 140     }
 141     else {
 142         var a = f(m.value);
 143         if (a._tag == "Some") {
 144             a.value.ast = concat(m.value.ast, a.value.ast);
 145         }
 146         return a;
 147     }
 148 }
 149 /**
 150  * like `f1 | f2` in regex
 151  * @param f1 the first tried function
 152  * @param f2 the second tried function
 153  * @returns wrapped result
 154  */
 155 function orDo(f1, f2) {
 156     return (x) => {
 157         let res1 = f1(x);
 158         if (res1._tag == "Some") {
 159             return res1;
 160         }
 161         else {
 162             let res2 = f2(x);
 163             return res2;
 164         }
 165     };
 166 }
 167 /**
 168  *
 169  * @param m : the `MatcheePair` to be consumed.
 170  * @returns if the length of `m.remained` >= 1; consumes the matchee by 1 token
 171  *  and wraps it in `Some`,
 172  * otherwise, returns `None`.
 173  */
 174 function matchAny(m) {
 175     if (m.remained.length >= 1) {
 176         return {
 177             _tag: "Some", value: {
 178                 matched: m.matched.concat(m.remained[0]),
 179                 remained: m.remained.slice(1),
 180                 ast: [m.remained[0]],
 181             }
 182         };
 183     }
 184     else {
 185         return { _tag: "None" };
 186     }
 187 }
 188 exports.matchAny = matchAny;
 189 /**
 190  * Danger : Maybe it's not enough to work.
 191 * @description repeating matching function `f`
 192 * zero or more times, like the asterisk `*` in regex `f*` .
 193 * @param f : the function to be repeated 0+ times.
 194 * @returns:the combined function
 195 */
 196 function OnceOrMoreDo(f) {
 197     return (x) => {
 198         var wrappedOldX = { _tag: "Some", value: x };
 199         var wrappedNewX = wrappedOldX;
 200         var counter = -1;
 201         while (wrappedNewX._tag != "None") {
 202             wrappedOldX = wrappedNewX;
 203             wrappedNewX = thenDo(wrappedOldX, f);
 204             counter += 1;
 205         }
 206         ;
 207         if (counter <= 0) {
 208             return { _tag: "None" };
 209         }
 210         let ast = wrappedOldX.value.ast;
 211         wrappedOldX.value.ast = ast.slice(ast.length - counter);
 212         console.log(repr(wrappedOldX.value.ast));
 213         return wrappedOldX;
 214     };
 215 }
 216 exports.OnceOrMoreDo = OnceOrMoreDo;
 217 /**
 218  * aux function for midfix operator
 219  * @param f function
 220  * @param signal the rule name
 221  * @returns
 222  */
 223 let midfix = (f, signal) => (x) => {
 224     var a = f(x);
 225     if (a._tag == "Some") {
 226         let ast_tail = slice(a.value.ast, a.value.ast.length - 3);
 227         let new_ast = [ast_tail];
 228         a.value.ast = new_ast;
 229         // console.log("+"+signal+"+"+repr(a));
 230     }
 231     return a;
 232 };
 233 let circumfix = (f, signal) => (x) => {
 234     var a = f(x);
 235     if (a._tag == "Some") {
 236         let inner = a.value.ast[a.value.ast.length - 2];
 237         let ast_middle = [inner];
 238         let new_ast = [ast_middle];
 239         a.value.ast = new_ast;
 240     }
 241     return a;
 242 };
 243 /** single1 = tInt | "(" expr ")"*/
 244 let single1 = circumfix((x) => thenDo(thenDo(thenDo(tk.toSome(x), tLParen), expr), tRParen), "fac1");
 245 let single2 = tInt;
 246 let single = orDo(single1, single2);
 247 /** func = single | single "(" single ")"
 248  * i.e.
 249  *
 250  * func = single |  func_aux ( int )
 251  *
 252 */
 253 /** callees = "(" args ")" | "(" ")" */
 254 let callees1 = circumfix((x) => thenDo(thenDo(thenDo(tk.toSome(x), tLParen), tInt), tRParen), "callees1");
 255 let callees2 = (x) => {
 256     let ret = thenDo(thenDo(tk.toSome(x), tLParen), tRParen);
 257     if (ret._tag == "Some") {
 258         let new_ast = [[]];
 259         ret.value.ast = new_ast;
 260     }
 261     return ret;
 262 };
 263 let callees = orDo(callees1, callees2);
 264 /** %apply R combinating token */
 265 let applyToken = {
 266     text: "%apply",
 267     type: tk.TokenType.ID,
 268     col: 0,
 269     ln: 0,
 270 };
 271 /** facAux = callees facAux |  callees */
 272 let facAux1 = (x) => {
 273     var ret = thenDo(thenDo(tk.toSome(x), callees), facAux);
 274     if (ret._tag == "Some") {
 275         console.log("1232345" + repr(tkTreeToSExp(ret.value.ast[ret.value.ast.length - 1])));
 276         let last1 = ret.value.ast[ret.value.ast.length - 1];
 277         let last2 = ret.value.ast[ret.value.ast.length - 2];
 278         let b = [applyToken];
 279         ret.value.ast = [b.concat([last2, last1])];
 280         console.log("11111" + repr(tkTreeToSExp(ret.value.ast)));
 281     }
 282     ;
 283     return ret;
 284 };
 285 let facAux2 = callees;
 286 let facAux = orDo(facAux1, facAux2);
 287 /** fac = single facAux | single
 288  * Issue1 to be fixed.
 289  */
 290 let fac1 = (x) => {
 291     var ret = thenDo(thenDo(tk.toSome(x), single), facAux);
 292     if (ret._tag == "Some") {
 293         console.log("777" + repr(tkTreeToSExp(ret.value.ast)));
 294         ret.value.ast = [applyToken, ret.value.ast[ret.value.ast.length - 2],
 295             ret.value.ast[ret.value.ast.length - 1]];
 296         ret.value.ast;
 297         rearrangeTree(ret.value.ast);
 298         console.log("888" + repr(tkTreeToSExp(ret.value.ast)));
 299     }
 300     return ret;
 301 };
 302 let fac2 = single;
 303 let fac = orDo(fac1, fac2);
 304 /**
 305  * rearrangeTree : for applyToken subtree from right-combination to
 306  * left-combination
 307  * @input x a ast
 308  * @return another ast
 309  */
 310 function rearrangeTree(x) {
 311     if (x !== undefined) {
 312         for (var i = 1; i < x.length; i++) {
 313             rearrangeTree(x[i]);
 314         }
 315         console.log("@@" + repr(x[0]));
 316         if (x[0] == applyToken) {
 317             if (Array.isArray(x[2]) && x[2][0] == applyToken) {
 318                 let rl = rearrangeTree(x[2][1]);
 319                 let rr = rearrangeTree(x[2][2]);
 320                 let l = rearrangeTree(x[1]);
 321                 x[0] = applyToken;
 322                 x[1] = [applyToken, l, rl];
 323                 x[2] = rr;
 324                 console.log("@@==" + repr(x));
 325                 return x;
 326             }
 327             else {
 328                 x[0] = applyToken;
 329                 x[1] = rearrangeTree(x[1]);
 330                 x[2] = rearrangeTree(x[2]);
 331                 console.log("@@==" + repr(x));
 332                 return x;
 333             }
 334         }
 335         return x;
 336     }
 337 }
 338 /**
 339  *
 340  * term1 = fac (MUL | DIV) fac
 341  */
 342 let term1 = midfix((x) => thenDo(thenDo(thenDo(tk.toSome(x), fac), orDo(tMul, tDiv)), fac), "term1");
 343 /**
 344  *
 345  * term2 = int MUL int
 346  */
 347 let term2 = fac;
 348 /**
 349  * term = term1 | term2
 350  */
 351 let term = orDo(term1, term2);
 352 /**
 353  *
 354  * expr1 = term ADD term
 355  */
 356 let expr1 = midfix((x) => thenDo(thenDo(thenDo(tk.toSome(x), term), orDo(tAdd, tSub)), term), "expr1");
 357 /**
 358  * expr2 = term
 359  */
 360 let expr2 = term;
 361 /**
 362  * expr = expr1 | expr2
 363  */
 364 let expr = orDo(expr1, expr2);
 365 let tokens = tk.tokenize("1");
 366 let tokens2 = tk.tokenize("1(2)");
 367 let tokens3 = tk.tokenize("1(2)(3)");
 368 let tokens4 = tk.tokenize("2()");
 369 //let tokens = tk.tokenize("(4-(3/4))");
 370 //tk.tokenize(argv[2]);
 371 let tokensFiltered = tokens4.filter((x) => {
 372     return (x.type != tk.TokenType.NL
 373         && x.type != tk.TokenType.SP);
 374 });
 375 let beta = expr({
 376     matched: [],
 377     remained: tokensFiltered,
 378     ast: []
 379 });
 380 if (beta._tag == "Some") {
 381     beta.value.ast = rearrangeTree(beta.value.ast);
 382     console.log(tkTreeToSExp(beta.value.ast));
 383 }
 384 console.log("RESULT=" + repr(beta));