rewrite parser

[clo] / src / index.ts

diff --git a/src/index.ts b/src/index.ts
index 55e3d65db7b9894c9aead54e69cfa73e657a1520..157b1607348020eac4b7e8648093eb77ff8059c6 100644 (file)
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,46 +1,145 @@
 var fs = require('fs');
+import jsTokens from "js-tokens";
+import * as util from 'util';
+import * as p from 'typescript-parsec';
+import { Token } from 'typescript-parsec';
+/**
+ * 
+ * # REPRESENTATION
+ */
+/**
+ * convert a `tkTree` AST to S-expr string
+ * @param t the `tkTree`
+ * @returns S-expr String
+ */
+export function tkTreeToSExp(t: tkTree): string{
+    var str = "";
+
+    if (Array.isArray(t)){
+        let strArray = t.map((x)=>tkTreeToSExp(x));
+        str = "(" + strArray.join(" ") + ")";
+    }else{
+        if (t=== undefined){
+            str = "%undefined"
+        }else{
+            str = t;
+        }
+    }
 
-import * as tk from './tokenize.js';
+    return str;
+}
 
+/**inspect the inner of the representation. */
+let repr = (x : any)=>{return util.inspect(x, {depth: null})};
+/**
+ * 
+ * # TYPES
+ */
 
 
-let b : Array<tk.Token> = tk.tokenize("2+2");
+type tkTree = string | tkTree[];
 
-export interface TokenMatcheePair {
-    matched: tk.Token[]
-    remained: tk.Token[]
+enum TokenKind {
+    Seperator,
+    Semicolon,
+    Number,
+    Op,
+    ExprMark,
+    Paren,
+    SpaceNL,
+    Id,
+    Str,
 }
 
 /**
- * @description
- * it returns a function which test if the first char of the `remained` part of
- *  the argument of the function is `c`, if it's true, update the `MatchedPair` wrapped
- * in `Some`. Otherwise, it returns `None`.
- *  * @param t : the char to be test.
- * @returns the updated `MatchedPair` wrapped in `Some(x)` or `None`.
+ * Parsing
  */
-export function match1token(t: tk.Token): (m: TokenMatcheePair) => tk.Maybe<TokenMatcheePair> {
-    return (m: TokenMatcheePair) => {
-        if (m.remained.length == 0) {
-            return { _tag: "None" };
-        }
-        const tokenToBeMatched = m.remained[0];
-        if (tokenToBeMatched === t) {
-            m.matched.push(tokenToBeMatched);
-            return {
-                _tag: "Some", value: {
-                    matched: m.matched,
-                    remained: m.remained.slice(1)
-                }
-            };
-        }
-        else {
-            return { _tag: "None" };
-        }
-    }
+const lexer = p.buildLexer([
+    [true, /^\d+(\.\d+)?/g, TokenKind.Number],
+    [true, /^\;/g, TokenKind.Semicolon],
+    [true, /^[-][-][-]/g, TokenKind.Seperator],
+    [true, /^[\+\-\*\/\&\|\!\^\<\>\~\=\?]+/g, TokenKind.Op],
+    [true, /^\@+/g, TokenKind.ExprMark],
+    [true, /^[()\[\]{}]/g, TokenKind.Paren],
+    [true, /^["]([\"]|[\\].)*["]/g, TokenKind.Str],
+    [true, /^[']([\']|[\\].)*[']/g, TokenKind.Str],
+    [true, /^[()\[\]{}]/g, TokenKind.Paren],
+    [true, /^[^\s\n\t\r;]+/g, TokenKind.Id],
+    [false, /^(\s|\n|\r|\t)+/g, TokenKind.SpaceNL]
+]);
+
+/**
+ * 
+ * # TEST
+ */
+const inputTxt=
+`import ast;
+---
+122`;
+
+
+const PROG = p.rule<TokenKind, tkTree>();
+const UNIT = p.rule<TokenKind, tkTree>();
+const IMPORTS = p.rule<TokenKind, tkTree>();
+const SEMICOLON = p.rule<TokenKind, tkTree>();
+
+
+let doubleMinus = { type: 'Punctuator', value: '--' };
+let doubleMinus2 = p.str('--');
+const TERM = p.rule<TokenKind, tkTree>();
+
+function applyUnit(value: Token<TokenKind.Number>): tkTree{
+    return value.text;
+}
+
+function applySemiColon(value: Token<TokenKind.Semicolon>): tkTree{
+    return value.text;
+}
+
+function applyParts(first: tkTree,
+                    second: [Token<TokenKind>, tkTree]):tkTree {
+    return ["%clo", first , second[1]];
+}
+
+
+
+
+function applyImports(input: [Token<TokenKind>,Token<TokenKind>[], tkTree]):tkTree{
+    let importTail = input[1].map(x=>x.text);
+    return ["import"].concat(importTail);
 };
 
+/**
+ * PROG : IMPORTS '---' UNIT;
+ */
+PROG.setPattern(
+    p.lrec_sc(IMPORTS, p.seq(p.str('---'), UNIT), applyParts)
+
+)
+
+/**
+ * PROG : 'import' Id* SEMICOLON;
+ */
+IMPORTS.setPattern(
+    p.apply(p.seq(p.str('import'), p.rep_sc(p.tok(TokenKind.Id)), SEMICOLON) , applyImports)
+);
+
+/**
+ * SEMICOLON : ';';
+ */
+SEMICOLON.setPattern(
+    p.apply(p.tok(TokenKind.Semicolon), applySemiColon)
+);
+
+/**
+ * UNIT : Number;
+ */
+UNIT.setPattern(
+    p.apply(p.tok(TokenKind.Number), applyUnit)
+);
+
+let tree = p.expectSingleResult(p.expectEOF(PROG.parse(lexer.parse(inputTxt))));
+
 
 
-let c = tk.toSome(b);
-console.log(thenDo(c,match1token(tk.tokenize("+")[0])));
\ No newline at end of file
+console.log("RESULT="+tkTreeToSExp(tree));