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  * @description
  33  * match one token type.
  34  *
  35  * it returns a function which test if the type of first token of the `remained` part of
  36  *  the argument of the function is `typ` , if it's true, update the `TokenMatcheePair` wrapped
  37  * in `Some`. Otherwise, it returns `None`.
  38  *  * @param typ : the type to be test.
  39  * @returns the updated `TokenMatcheePair` wrapped in `Some(x)` or `None`.
  40  */
  41 function m1TType(typ) {
  42     return (m) => {
  43         if (m.remained.length == 0) {
  44             return { _tag: "None" };
  45         }
  46         /**
  47          * token to be matched
  48          * */
  49         const ttbm = m.remained[0];
  50         if (ttbm.type == typ) {
  51             let new_matched = m.matched.concat(ttbm);
  52             let result = {
  53                 _tag: "Some", value: {
  54                     matched: new_matched,
  55                     remained: m.remained.slice(1)
  56                 }
  57             };
  58             return result;
  59         }
  60         else {
  61             return { _tag: "None" };
  62         }
  63     };
  64 }
  65 exports.m1TType = m1TType;
  66 ;
  67 let toSome = tk.toSome;
  68 let thenDo = tk.thenDo;
  69 let zeroOrOnceDo = tk.zeroOrOnceDo;
  70 let orDo = tk.orDo;
  71 let zeroOrMoreDo = tk.zeroOrMoreDo;
  72 node_process_1.argv.forEach((val, index) => {
  73     console.log(`${index}=${val}`);
  74 });
  75 let commandInput = "int a str b"; //argv[2];
  76 let commandInputTokenized = tk.tokenize(commandInput);
  77 let commandInputTokenizedFiltered = commandInputTokenized.filter((x) => {
  78     return x.type != tk.TokenType.SP &&
  79         x.type != tk.TokenType.NL;
  80 });
  81 console.log("aaa: " + util.inspect(commandInputTokenizedFiltered, { showHidden: true, depth: null }));
  82 /**
  83  * matchee pair of commandInputTokenized
  84  */
  85 let commandTPair = { matched: [],
  86     remained: commandInputTokenizedFiltered };
  87 let tInt = m1TType(tk.TokenType.INT);
  88 let tFlo = m1TType(tk.TokenType.FLO);
  89 let tStr = m1TType(tk.TokenType.STR);
  90 let tId = m1TType(tk.TokenType.ID);
  91 let tApos = m1TType(tk.TokenType.APOS);
  92 function tBool(x) {
  93     let text = x.remained[0].text;
  94     if (text == "true" || text == "false") {
  95         return thenDo(toSome(x), m1TType(tk.TokenType.ID));
  96     }
  97     else {
  98         return { _tag: "None" };
  99     }
 100 }
 101 /**
 102  * define the right hand side of a grammar
 103  * eg. `LHS ::= a + b`
 104  * @param process  the right hand side processing : eg. `a + b` in `LHS`
 105  * @param arrange define the order (0 starting) of the elements of the result.
 106  * ast. : eg. `a + c` is `1 0 2` `(+ a c)`
 107  * @returns the processed ast.
 108  */
 109 function gramRHS(process, arrange) {
 110     return (m) => {
 111         let middle = process(m);
 112         console.log("Middle" + util.inspect(middle, { showHidden: true, depth: null }));
 113         if (middle._tag == "None") {
 114             return middle;
 115         }
 116         else {
 117             let matched = middle.value.matched;
 118             let arrLength = arrange.length;
 119             let returnRrray = Array(arrange.length);
 120             arrange.forEach((val, index) => {
 121                 returnRrray[arrange[index]] = matched[index];
 122             });
 123             let matchedTmp1Length = matched.length - arrLength;
 124             console.log(matchedTmp1Length);
 125             var matchedTmp1 = matched
 126                 .slice(0, matchedTmp1Length);
 127             console.log("matchedTmp1" + util.inspect(matchedTmp1, { showHidden: true, depth: null }));
 128             console.log("returnRrray" + util.inspect(returnRrray, { showHidden: true, depth: null }));
 129             matchedTmp1.push(returnRrray);
 130             let result = { _tag: "Some",
 131                 value: { matched: matchedTmp1,
 132                     remained: middle.value.remained } };
 133             return result;
 134         }
 135     };
 136 }
 137 /**
 138  * typeABS ::= "'" ID
 139  */
 140 var typeABS = (x) => {
 141     var result = thenDo(thenDo(toSome(x), tApos), tId);
 142     if (result._tag == "Some" && "text" in result.value.matched[1]) {
 143         var realToken = result.value.matched[1];
 144         realToken.text = "'" + realToken.text;
 145         result.value.matched = [realToken];
 146     }
 147     return result;
 148 };
 149 /**
 150  * TypeId ::=  typeABS | ID
 151  */
 152 var typeName = (x) => {
 153     return thenDo(toSome(x), orDo(typeABS, tId));
 154 };
 155 /**
 156  *  CONST ::= INT | STR | FLO | BOOL
 157  */
 158 /**
 159  * TODO: 要用 debugger 檢查分析問題
 160  */
 161 var constParser = gramRHS((x) => { return thenDo(toSome(x), orDo(orDo(orDo(tInt, tFlo), tStr), tBool)); }, [0]);
 162 /**
 163  * storing the tree
 164  */
 165 var astTree = [];
 166 /**
 167  * TYPE_PAIR ::= TYP_ID ID
 168  */
 169 var typePair = (x) => {
 170     let a = thenDo(thenDo(x.maybeTokens, typeName), tId);
 171     if (a._tag == "Some") {
 172         let matched = a.value.matched;
 173         let slice = matched.slice(matched.length - 2);
 174         console.log("slice" + slice);
 175         let b = { maybeTokens: a, ast: slice };
 176         return b;
 177     }
 178     else {
 179         let b = { maybeTokens: a, ast: [] };
 180         return b;
 181     }
 182 };
 183 /**
 184  * function's arguments
 185  * FN_ARGS = TYPE_PAIR ("," TYPE_PAIR)+
 186  */
 187 var fnArgs = (x) => {
 188     let wrapper = { maybeTokens: toSome(x), ast: [] };
 189     let a = typePair(wrapper);
 190     console.log("AAAAA" + util.inspect(a, { showHidden: true, depth: null }));
 191     let abanibi = typePair(a);
 192     console.log("ABNB" + util.inspect(abanibi, { showHidden: true, depth: null }));
 193     return { maybeTokens: abanibi.maybeTokens, ast: [a.ast, abanibi.ast] };
 194 };
 195 let tree = fnArgs(commandTPair);
 196 console.log("CHRANN" + util.inspect(tree, { showHidden: true, depth: null }));