git.kianting.info Git - uann/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.m1TType = 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  * @description
  59  * match one token type.
  60  *
  61  * it returns a function which test if the type of first token of the `remained` part of
  62  *  the argument of the function is `typ` , if it's true, update the `TokenMatcheePair` wrapped
  63  * in `Some`. Otherwise, it returns `None`.
  64  *  * @param typ : the type to be test.
  65  * @returns the updated `TokenMatcheePair` wrapped in `Some(x)` or `None`.
  66  */
  67 function m1TType(typ) {
  68     return (m) => {
  69         if (m.remained.length == 0) {
  70             return { _tag: "None" };
  71         }
  72         /**
  73          * token to be matched
  74          * */
  75         const ttbm = m.remained[0];
  76         if (ttbm.type == typ) {
  77             let new_matched = m.matched.concat(ttbm);
  78             let result = {
  79                 _tag: "Some", value: {
  80                     matched: new_matched,
  81                     remained: m.remained.slice(1),
  82                     ast: ([ttbm]),
  83                 }
  84             };
  85             return result;
  86         }
  87         else {
  88             return { _tag: "None" };
  89         }
  90     };
  91 }
  92 exports.m1TType = m1TType;
  93 ;
  94 /**
  95  * type int
  96  */
  97 let tInt = m1TType(tk.TokenType.INT);
  98 let tAdd = m1TType(tk.TokenType.I_ADD);
  99 let tSub = m1TType(tk.TokenType.I_SUB);
 100 let tMul = m1TType(tk.TokenType.I_MUL);
 101 let tDiv = m1TType(tk.TokenType.I_DIV);
 102 let tLParen = m1TType(tk.TokenType.L_PAREN);
 103 let tRParen = m1TType(tk.TokenType.R_PAREN);
 104 let toSome = tk.toSome;
 105 node_process_1.argv.forEach((val, index) => {
 106     console.log(`${index}=${val}`);
 107 });
 108 /**
 109  * like `m ==> f` in ocaml
 110  * @param m matchee wrapped
 111  * @param f matching function
 112  * @returns wrapped result
 113  */
 114 function thenDo(m, f) {
 115     if (m._tag == "None") {
 116         return m;
 117     }
 118     else {
 119         var a = f(m.value);
 120         if (a._tag == "Some") {
 121             a.value.ast = concat(m.value.ast, a.value.ast);
 122         }
 123         return a;
 124     }
 125 }
 126 /**
 127  * like `f1 | f2` in regex
 128  * @param f1 the first tried function
 129  * @param f2 the second tried function
 130  * @returns wrapped result
 131  */
 132 function orDo(f1, f2) {
 133     return (x) => {
 134         let res1 = f1(x);
 135         if (res1._tag == "Some") {
 136             return res1;
 137         }
 138         else {
 139             let res2 = f2(x);
 140             return res2;
 141         }
 142     };
 143 }
 144 /**
 145  * aux function for midfix operator
 146  * @param f function
 147  * @param signal the rule name
 148  * @returns
 149  */
 150 let midfix = (f, signal) => (x) => {
 151     var a = f(x);
 152     if (a._tag == "Some") {
 153         let ast_tail = slice(a.value.ast, a.value.ast.length - 3);
 154         let new_ast = [ast_tail];
 155         a.value.ast = new_ast;
 156         console.log("+" + signal + "+" + repr(a));
 157     }
 158     return a;
 159 };
 160 let circumfix = (f, signal) => (x) => {
 161     var a = f(x);
 162     if (a._tag == "Some") {
 163         let inner = a.value.ast[a.value.ast.length - 2];
 164         let ast_middle = [inner];
 165         let new_ast = [ast_middle];
 166         a.value.ast = new_ast;
 167     }
 168     return a;
 169 };
 170 /**
 171  * TODO: 12(13)(14) only parsed with only 12(13)
 172  */
 173 /** single1 = tInt | "(" expr ")"*/
 174 let single1 = circumfix((x) => thenDo(thenDo(thenDo(tk.toSome(x), tLParen), expr), tRParen), "fac1");
 175 let single2 = tInt;
 176 let single = orDo(single1, single2);
 177 /** fac1 = single "(" int ")"  | single */
 178 let fac1Appliee = circumfix((x) => thenDo(thenDo(thenDo(tk.toSome(x), tLParen), tInt), tRParen), "fac1");
 179 let fac1 = (x) => {
 180     let n = thenDo(thenDo(toSome(x), single), fac1Appliee);
 181     console.log("+" + "bocchitherock" + "+" + repr(n));
 182     return n;
 183 };
 184 let fac2 = single;
 185 let fac = orDo(fac1, fac2);
 186 /**
 187  *
 188  * term1 = fac (MUL | DIV) fac
 189  */
 190 let term1 = midfix((x) => thenDo(thenDo(thenDo(tk.toSome(x), fac), orDo(tMul, tDiv)), fac), "term1");
 191 /**
 192  *
 193  * term2 = int MUL int
 194  */
 195 let term2 = fac;
 196 /**
 197  * term = term1 | term2
 198  */
 199 let term = orDo(term1, term2);
 200 /**
 201  *
 202  * expr1 = term ADD term
 203  */
 204 let expr1 = midfix((x) => thenDo(thenDo(thenDo(tk.toSome(x), term), orDo(tAdd, tSub)), term), "expr1");
 205 /**
 206  * expr2 = term
 207  */
 208 let expr2 = term;
 209 /**
 210  * expr = expr1 | expr2
 211  */
 212 let expr = orDo(expr1, expr2);
 213 let tokens = tk.tokenize("12(13)(14)");
 214 //let tokens = tk.tokenize("(4-(3/4))");
 215 //tk.tokenize(argv[2]);
 216 let tokensFiltered = tokens.filter((x) => {
 217     return (x.type != tk.TokenType.NL
 218         && x.type != tk.TokenType.SP);
 219 });
 220 let wrappedTokens = tk.toSome({
 221     matched: [],
 222     remained: tokensFiltered,
 223     ast: []
 224 });
 225 let beta = expr({
 226     matched: [],
 227     remained: tokensFiltered,
 228     ast: []
 229 });
 230 console.log("RESULT=" + repr(beta));