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;
+ }
+ }
-type Some<T> = { _tag: "Some"; value: T };
-type None = {_tag: "None"};
+ return str;
+}
+/**inspect the inner of the representation. */
+let repr = (x : any)=>{return util.inspect(x, {depth: null})};
/**
- * @description Like the `Some(a)` and `None` in Rust.
- *
- * @example
- * ```ts
- * let exam1 : Maybe<Number> = { _tag: "Some", value: 12 };
- * let exam2 : Maybe<Number> = None;
- * ```
+ *
+ * # TYPES
*/
-export type Maybe<T> = Some<T> | None;
+type tkTree = string | tkTree[];
+
+enum TokenKind {
+ Seperator,
+ Semicolon,
+ Number,
+ Op,
+ ExprMark,
+ Paren,
+ SpaceNL,
+ Id,
+ Str,
+}
+
/**
- * @description
- * the pair of the string to be matched later and the string that have been matched
- * @param matched : string have been matched
- * @param remained : string will be tested whether it'll be matched.
+ * Parsing
*/
-export type MatcheePair = {matched : string; remained : string};
+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]
+]);
/**
- * @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 c : the char to be test.
- * @returns the updated `MatchedPair` wrapped in `Some(x)` or `None`.
+ *
+ * # TEST
*/
-export function match1Char(c : string) : (m: MatcheePair) => Maybe<MatcheePair> {
- return (m : MatcheePair)=>{
- const charToBeMatched = m.remained[0];
- if (charToBeMatched === c){
- return {_tag: "Some", value :{
- matched : m.matched + charToBeMatched,
- remained : m.remained.substring(1)}};
- }
- else{
- return {_tag: "None"};
- }
- }
+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);
};
/**
- * @description
- * it returns a function which test if the first char of the `remained` part of
- * the argument of the function is between `l` and `u`, if it's true, update the `MatchedPair` wrapped
- * in `Some`. Otherwise, it returns `None`.
- * * @param l : lower bound char, 1-char string
- * * @param u : upper bound char, 1-char string
- * @returns the updated `MatchedPair` wrapped in `Some(x)` or `None`.
+ * PROG : IMPORTS '---' UNIT;
*/
-export function matchRange(l : string, u : string) : (m: MatcheePair) => Maybe<MatcheePair> {
- let lCodepoint = charToCodepoint(l);
- let uCodepoint = charToCodepoint(u);
- if (l > u){
- throw new Error("Error: the codepoint of `"+l+"` is not smaller than `"+u+"`)");
- }
- return (m : MatcheePair)=>{
-
- const charToBeMatched = m.remained[0];
- const codePointToBeMatched = charToCodepoint(charToBeMatched);
- if (codePointToBeMatched >= lCodepoint && codePointToBeMatched <= uCodepoint){
- return {_tag: "Some", value :{
- matched : m.matched + charToBeMatched,
- remained : m.remained.substring(1)}};
- }
- else{
- return {_tag: "None"};
- }
- }
-};
+PROG.setPattern(
+ p.lrec_sc(IMPORTS, p.seq(p.str('---'), UNIT), applyParts)
+
+)
/**
- * convert the one-char string to codepoint.
- * @param s : the string to code point.
- * @returns if `s.length > 1` return error; otherwise, return the codepoint of `s`.
+ * PROG : 'import' Id* SEMICOLON;
*/
-export function charToCodepoint(s : string): number{
- if (s.length > 1){
- throw new Error("Error: the length of input string for "+s+ "is "+s.length+`,
- however, it should be 1.`);
- }else{
- return s.charCodeAt(0);
- }
-}
+IMPORTS.setPattern(
+ p.apply(p.seq(p.str('import'), p.rep_sc(p.tok(TokenKind.Id)), SEMICOLON) , applyImports)
+);
/**
- * @description thendo(input, f, ...) like
- * a ==> f
+ * SEMICOLON : ';';
*/
-export function thenDo<T>(input : Maybe<T>, f : Function) : Maybe<T>{
- if (input._tag == "None"){
- return input;
- }
- else{
- let inner = input.value;
- return f(inner);
- }
-}
+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))));
+
+
+
+console.log("RESULT="+tkTreeToSExp(tree));