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 * @description repeating matching function `f`
 191 * zero or more times, like the asterisk `*` in regex `f*` .
 192 * @param f : the function to be repeated 0+ times.
 193 * @returns:the combined function
 194 */
 195 function OnceOrMoreDo(f) {
 196     return (x) => {
 197         var wrappedOldX = { _tag: "Some", value: x };
 198         var wrappedNewX = wrappedOldX;
 199         var counter = -1;
 200         while (wrappedNewX._tag != "None") {
 201             wrappedOldX = wrappedNewX;
 202             wrappedNewX = thenDo(wrappedOldX, f);
 203             counter += 1;
 204         }
 205         ;
 206         if (counter <= 0) {
 207             return { _tag: "None" };
 208         }
 209         let ast = wrappedOldX.value.ast;
 210         wrappedOldX.value.ast = ast.slice(ast.length - counter);
 211         console.log(repr(wrappedOldX.value.ast));
 212         return wrappedOldX;
 213     };
 214 }
 215 exports.OnceOrMoreDo = OnceOrMoreDo;
 216 /**
 217  * aux function for midfix operator
 218  * @param f function
 219  * @param signal the rule name
 220  * @returns
 221  */
 222 let midfix = (f, signal) => (x) => {
 223     var a = f(x);
 224     if (a._tag == "Some") {
 225         let ast_tail = slice(a.value.ast, a.value.ast.length - 3);
 226         let new_ast = [ast_tail];
 227         a.value.ast = new_ast;
 228         // console.log("+"+signal+"+"+repr(a));
 229     }
 230     return a;
 231 };
 232 let circumfix = (f, signal) => (x) => {
 233     var a = f(x);
 234     if (a._tag == "Some") {
 235         let inner = a.value.ast[a.value.ast.length - 2];
 236         let ast_middle = [inner];
 237         let new_ast = [ast_middle];
 238         a.value.ast = new_ast;
 239     }
 240     return a;
 241 };
 242 /**
 243  * TODO: 12(13)(14) only parsed with only 12(13)
 244  */
 245 /** single1 = tInt | "(" expr ")"*/
 246 let single1 = circumfix((x) => thenDo(thenDo(thenDo(tk.toSome(x), tLParen), expr), tRParen), "fac1");
 247 let single2 = tInt;
 248 let single = orDo(single1, single2);
 249 /** func = single | single "(" single ")"
 250  * i.e.
 251  *
 252  * func = single |  func_aux ( int )
 253  *
 254 */
 255 /** fac = single ["(" single ")"]?  | single */
 256 let fac1Appliee = circumfix((x) => thenDo(thenDo(thenDo(tk.toSome(x), tLParen), tInt), tRParen), "fac1");
 257 let fac1 = (x) => {
 258     let raw = thenDo(thenDo(toSome(x), single), OnceOrMoreDo(fac1Appliee));
 259     if (raw._tag == "Some") {
 260         var result = raw.value.ast[0];
 261         let applyToken = { text: '%apply', ln: 0, col: 0 };
 262         for (var i = 1; i < raw.value.ast.length; i++) {
 263             result = [applyToken, result, raw.value.ast[i]];
 264         }
 265         if (!Array.isArray(result)) {
 266             raw.value.ast = [result];
 267         }
 268         else {
 269             raw.value.ast = result;
 270         }
 271     }
 272     return raw;
 273 };
 274 let fac2 = single;
 275 let fac = orDo(fac1, fac2);
 276 /**
 277  *
 278  * term1 = fac (MUL | DIV) fac
 279  */
 280 let term1 = midfix((x) => thenDo(thenDo(thenDo(tk.toSome(x), fac), orDo(tMul, tDiv)), fac), "term1");
 281 /**
 282  *
 283  * term2 = int MUL int
 284  */
 285 let term2 = fac;
 286 /**
 287  * term = term1 | term2
 288  */
 289 let term = orDo(term1, term2);
 290 /**
 291  *
 292  * expr1 = term ADD term
 293  */
 294 let expr1 = midfix((x) => thenDo(thenDo(thenDo(tk.toSome(x), term), orDo(tAdd, tSub)), term), "expr1");
 295 /**
 296  * expr2 = term
 297  */
 298 let expr2 = term;
 299 /**
 300  * expr = expr1 | expr2
 301  */
 302 let expr = orDo(expr1, expr2);
 303 let tokens = tk.tokenize("1");
 304 let tokens2 = tk.tokenize("1(2)");
 305 let tokens3 = tk.tokenize("1(2)(3)");
 306 let tokens4 = tk.tokenize("(3(2))*2+1");
 307 //let tokens = tk.tokenize("(4-(3/4))");
 308 //tk.tokenize(argv[2]);
 309 let tokensFiltered = tokens4.filter((x) => {
 310     return (x.type != tk.TokenType.NL
 311         && x.type != tk.TokenType.SP);
 312 });
 313 let beta = expr({
 314     matched: [],
 315     remained: tokensFiltered,
 316     ast: []
 317 });
 318 if (beta._tag == "Some") {
 319     console.log(tkTreeToSExp(beta.value.ast));
 320 }
 321 console.log("RESULT=" + repr(beta));