@graffiticode/parser 0.1.0 → 0.1.2

package/src/parse.ts~

@@ -0,0 +1,1037 @@
+// Copyright 2021, ARTCOMPILER INC
+/*
+  Error handling
+  -- every range points to a node
+  -- multiple ranges can point to the same node
+  -- errors are associated with ranges
+  -- errors are determined by nodes in context
+
+  -- parser returns an ast which might compile to a list of errors of the form
+     {from, to, message, severity}
+  -- compiler checkers report these errors in the err callback arg
+*/
+
+import assert from "assert";
+import { folder } from "./fold.js";
+import { Node, ParserContext, StringStream, Env, Word } from "./types.js";
+
+// Global declarations for CodeMirror and window
+let CodeMirror: { Pos: () => Record<string, any> };
+if (typeof CodeMirror === "undefined") {
+  CodeMirror = {
+    Pos: function () {
+      return {};
+    }
+  };
+}
+
+let window: { 
+  gcexports: {
+    coords: Record<string, any>;
+    errors: any[];
+    topEnv?: (ctx: ParserContext) => Env;
+    scanTime?: () => number;
+    scanCount?: () => number;
+    parseTime?: () => number;
+    parseCount?: () => number;
+    program?: Function;
+    keywords?: Record<string, Word>;
+    firstTime?: boolean;
+  };
+  isSynthetic?: boolean;
+};
+
+if (typeof window === "undefined") {
+  window = {
+    gcexports: {
+      coords: {},
+      errors: []
+    },
+    isSynthetic: true
+  };
+}
+
+// ast module
+export const Ast = (function () {
+  const ASSERT = true;
+  const assert = function (val: any, str?: string): void {
+    if (!ASSERT) {
+      return;
+    }
+    if (str === undefined) {
+      str = "failed!";
+    }
+    if (!val) {
+      throw new Error(str);
+    }
+  };
+
+  class AstClass {
+    intern!: (ctx: ParserContext, n: any) => number;
+    node!: (ctx: ParserContext, nid: number) => Node | null;
+    dump!: (n: any) => string;
+    dumpAll!: (ctx: ParserContext) => string;
+    poolToJSON!: (ctx: ParserContext) => Record<string, any>;
+    number!: (ctx: ParserContext, num: string | number, coord?: any) => void;
+    string!: (ctx: ParserContext, str: string, coord?: any) => void;
+    name!: (ctx: ParserContext, name: string, coord?: any) => void;
+    apply!: (ctx: ParserContext, fnId: number, argc: number) => void;
+    fold!: (ctx: ParserContext, fn: any, args: any[]) => void;
+    expr!: (ctx: ParserContext, argc: number) => void;
+    binaryExpr!: (ctx: ParserContext, name: string) => void;
+    unaryExpr!: (ctx: ParserContext, name: string) => void;
+    parenExpr!: (ctx: ParserContext, coord?: any) => void;
+    prefixExpr!: (ctx: ParserContext, name: string) => void;
+    lambda!: (ctx: ParserContext, env: any, nid: number) => void;
+    applyLate!: (ctx: ParserContext, count: number) => void;
+    letDef!: (ctx: ParserContext) => void;
+    ifExpr!: (ctx: ParserContext) => void;
+    caseExpr!: (ctx: ParserContext, n: number) => void;
+    ofClause!: (ctx: ParserContext) => void;
+    record!: (ctx: ParserContext) => void;
+    binding!: (ctx: ParserContext) => void;
+    exprs!: (ctx: ParserContext, count: number, inReverse?: boolean) => void;
+    program!: (ctx: ParserContext) => void;
+    pop!: (ctx: ParserContext) => number;
+    topNode!: (ctx: ParserContext) => number;
+    peek!: (ctx: ParserContext, n?: number) => number;
+    push!: (ctx: ParserContext, node: any) => void;
+    mod!: (ctx: ParserContext) => void;
+    add!: (ctx: ParserContext, coord?: any) => void;
+    sub!: (ctx: ParserContext) => void;
+    div!: (ctx: ParserContext) => void;
+    pow!: (ctx: ParserContext) => void;
+    concat!: (ctx: ParserContext) => void;
+    eq!: (ctx: ParserContext) => void;
+    ne!: (ctx: ParserContext) => void;
+    lt!: (ctx: ParserContext) => void;
+    gt!: (ctx: ParserContext) => void;
+    le!: (ctx: ParserContext) => void;
+    ge!: (ctx: ParserContext) => void;
+    neg!: (ctx: ParserContext) => void;
+    list!: (ctx: ParserContext, count: number, coord?: any, reverse?: boolean) => void;
+    bool!: (ctx: ParserContext, val: any) => void;
+    nul!: (ctx: ParserContext) => void;
+    error!: (ctx: ParserContext, str: string, coord?: any) => void;
+  }
+
+  const astClass = new AstClass();
+
+  // Assign prototype methods to astClass
+  function push(ctx: ParserContext, node: any): void {
+    let nid: number;
+    if (typeof node === "number") { // if already interned
+      nid = node;
+    } else {
+      nid = intern(ctx, node);
+    }
+    ctx.state.nodeStack.push(nid);
+  }
+
+  function topNode(ctx: ParserContext): number {
+    const nodeStack = ctx.state.nodeStack;
+    return nodeStack[nodeStack.length - 1];
+  }
+
+  function pop(ctx: ParserContext): number {
+    const nodeStack = ctx.state.nodeStack;
+    return nodeStack.pop()!;
+  }
+
+  function peek(ctx: ParserContext, n?: number): number {
+    if (n === undefined) {
+      n = 0;
+    }
+    const nodeStack = ctx.state.nodeStack;
+    return nodeStack[nodeStack.length - 1 - n];
+  }
+
+  function intern(ctx: ParserContext, n: any): number {
+    if (!n) {
+      return 0;
+    }
+    const nodeMap = ctx.state.nodeMap;
+    const nodePool = ctx.state.nodePool;
+    const tag = n.tag;
+    let elts = "";
+    const count = n.elts.length;
+    for (let i = 0; i < count; i++) {
+      if (typeof n.elts[i] === "object") {
+        n.elts[i] = intern(ctx, n.elts[i]);
+      }
+      elts += n.elts[i];
+    }
+    const key = tag + count + elts;
+    let nid = nodeMap[key];
+    if (nid === undefined) {
+      nodePool.push({ tag, elts: n.elts });
+      nid = nodePool.length - 1;
+      nodeMap[key] = nid;
+      if (n.coord) {
+        ctx.state.coords[nid] = n.coord;
+      }
+    }
+    return nid;
+  }
+
+  function node(ctx: ParserContext, nid: number): Node | null {
+    const n = ctx.state.nodePool[nid];
+    if (!nid) {
+      return null;
+    } else if (!n) {
+      return {} as Node;
+    }
+    const elts: any[] = [];
+    switch (n.tag) {
+      case "NULL":
+        break;
+      case "NUM":
+      case "STR":
+      case "IDENT":
+      case "BOOL":
+        elts[0] = n.elts[0];
+        break;
+      default:
+        for (let i = 0; i < n.elts.length; i++) {
+          elts[i] = node(ctx, n.elts[i]);
+        }
+        break;
+    }
+    return {
+      tag: n.tag,
+      elts,
+      coord: getCoord(ctx)
+    };
+  }
+
+  function dumpAll(ctx: ParserContext): string {
+    const nodePool = ctx.state.nodePool;
+    let s = "\n{";
+    for (let i = 1; i < nodePool.length; i++) {
+      const n = nodePool[i];
+      s = s + "\n  " + i + ": " + dump(n) + ",";
+    }
+    s += "\n  root: " + (nodePool.length - 1);
+    s += "\n}\n";
+    return s;
+  }
+
+  function poolToJSON(ctx: ParserContext): Record<string, any> {
+    const nodePool = ctx.state.nodePool;
+    const obj: Record<string, any> = {};
+    for (let i = 1; i < nodePool.length; i++) {
+      const n = nodePool[i];
+      obj[i] = nodeToJSON(n);
+    }
+    obj.root = (nodePool.length - 1);
+    return obj;
+  }
+
+  function nodeToJSON(n: any): any {
+    let obj;
+    if (typeof n === "object") {
+      switch (n.tag) {
+        case "num":
+          obj = n.elts[0];
+          break;
+        case "str":
+          obj = n.elts[0];
+          break;
+        default:
+          obj = {};
+          obj.tag = n.tag;
+          obj.elts = [];
+          for (let i = 0; i < n.elts.length; i++) {
+            obj.elts[i] = nodeToJSON(n.elts[i]);
+          }
+          break;
+      }
+    } else if (typeof n === "string") {
+      obj = n;
+    } else {
+      obj = n;
+    }
+    return obj;
+  }
+
+  function dump(n: any): string {
+    let s = "";
+    if (typeof n === "object") {
+      switch (n.tag) {
+        case "num":
+          s = n.elts[0];
+          break;
+        case "str":
+          s = "\"" + n.elts[0] + "\"";
+          break;
+        default:
+          if (!n.elts) {
+            s += "<invalid>";
+          } else {
+            s = "{ tag: \"" + n.tag + "\", elts: [ ";
+            for (let i = 0; i < n.elts.length; i++) {
+              if (i > 0) {
+                s += " , ";
+              }
+              s += dump(n.elts[i]);
+            }
+            s += " ] }";
+          }
+          break;
+      }
+    } else if (typeof n === "string") {
+      s = "\"" + n + "\"";
+    } else {
+      s = String(n);
+    }
+    return s;
+  }
+
+  function fold(ctx: ParserContext, fn: any, args: any[]): void {
+    // Local defs:
+    // -- put bindings in env
+    // Three cases:
+    // -- full application, all args are available at parse time
+    // -- partial application, only some args are available at parse time
+    // -- late application, args are available at compile time (not parse time)
+    //        apply <[x y]: add x y> data..
+    //    x: val 0 data
+    //    y: val 1 data
+    env.enterEnv(ctx, fn.name);
+    if (fn.env) {
+      const lexicon = fn.env.lexicon;
+      const pattern = Ast.node(ctx, fn.env.pattern);
+      let outerEnv: Record<string, any> | null = null;
+      // let isListPattern;
+      // setup inner environment record (lexicon)
+      if (pattern && pattern.elts &&
+          pattern.elts.length === 1 &&
+          pattern.elts[0].tag === "LIST") {
+        // For now we only support one pattern per param list.
+        // isListPattern = true;
+      }
+      for (const id in lexicon) {
+        // For each parameter, get its definition assign the value of the argument
+        // used on the current function application.
+        if (!id) continue;
+        const word = JSON.parse(JSON.stringify(lexicon[id])); // poor man's copy.
+        const index = args.length - word.offset - 1;
+        // TODO we currently ignore list patterns
+        // if (isListPattern) {
+        //   // <[x y]: ...> foo..
+        //   word.nid = Ast.intern(ctx, {
+        //     tag: "VAL",
+        //     elts: [{
+        //       tag: "NUM",
+        //       elts: [
+        //         String(word.offset),
+        //       ]}, {
+        //         tag: "ARG",
+        //         elts: [{
+        //           tag: "NUM",
+        //           elts: ["0"]
+        //         }]
+        //       }]
+        //   });
+        // } else
+        if (index >= 0 && index < args.length) {
+          word.nid = args[index];
+        }
+        if (index < 0) {
+          // We've got an unbound variable or a variable with a default value,
+          // so add it to the new variable list.
+          // <x:x> => <x:x>
+          // (<x y: add x y> 10) => <y: add 10 y>
+          // (<y: let x = 10.. add x y>) => <y: add 10 y>
+          if (!outerEnv) {
+            outerEnv = {};
+          }
+          outerEnv[id] = word;
+        }
+        env.addWord(ctx, id, word);
+      }
+      folder.fold(ctx, fn.nid);
+      if (outerEnv) {
+        lambda(ctx, {
+          lexicon: outerEnv,
+          pattern // FIXME need to trim pattern if some args where applied.
+        }, pop(ctx));
+      }
+    }
+    env.exitEnv(ctx);
+  }
+
+  function applyLate(ctx: ParserContext, count: number): void {
+    // Ast.applyLate
+    const elts = [];
+    for (let i = count; i > 0; i--) {
+      elts.push(pop(ctx));
+    }
+    push(ctx, {
+      tag: "APPLY",
+      elts
+    });
+  }
+
+  function apply(ctx: ParserContext, fnId: number, argc: number): void {
+    // Construct function and apply available arguments.
+    const fn = node(ctx, fnId);
+    // if (fn.tag !== "LAMBDA") {
+    //   // Construct an APPLY node for compiling later.
+    //   return {
+    //     tag: "APPLY",
+    //     elts: [
+    //       fnId,
+    //     ]
+    //   };
+    // }
+    // Construct a lexicon
+    const lexicon: Record<string, any> = {};
+    let paramc = 0;
+    fn!.elts[0].elts.forEach(function (n, i) {
+      const name = n.elts[0];
+      const nid = Ast.intern(ctx, fn!.elts[3].elts[i]);
+      lexicon[name] = {
+        cls: "val",
+        name,
+        offset: i,
+        nid
+      };
+      if (!nid) {
+        // Parameters don't have nids.
+        // assert that there are parameters after a binding without a nid.
+        paramc++;
+      }
+    });
+    const def = {
+      name: "lambda",
+      nid: Ast.intern(ctx, fn!.elts[1]),
+      env: {
+        lexicon,
+        pattern: Ast.intern(ctx, fn!.elts[2])
+      }
+    };
+    const elts = [];
+    // While there are args on the stack, pop them.
+    while (argc-- > 0 && paramc-- > 0) {
+      const elt = pop(ctx);
+      elts.unshift(elt); // Get the order right.
+    }
+    fold(ctx, def, elts);
+  }
+
+  // Node constructors
+
+  function error(ctx: ParserContext, str: string, coord?: any): void {
+    console.log(
+      "error()",
+      "str=" + str,
+      "coord=" + JSON.stringify(coord),
+    );
+    const from = coord?.from !== undefined ? coord.from : -1;
+    const to = coord?.to !== undefined ? coord.to : -1;
+    number(ctx, to);
+    number(ctx, from);
+    string(ctx, str, coord);
+    push(ctx, {
+      tag: "ERROR",
+      elts: [
+        pop(ctx),
+        pop(ctx),
+        pop(ctx),
+      ],
+      coord
+    });
+  }
+
+  function bool(ctx: ParserContext, val: any): void {
+    let b;
+    if (val) {
+      b = true;
+    } else {
+      b = false;
+    }
+    push(ctx, {
+      tag: "BOOL",
+      elts: [b]
+    });
+  }
+
+  function nul(ctx: ParserContext): void {
+    push(ctx, {
+      tag: "NULL",
+      elts: []
+    });
+  }
+
+  function number(ctx: ParserContext, num: string | number, coord?: any): void {
+    assert(typeof num === "string" || typeof num === "number");
+    push(ctx, {
+      tag: "NUM",
+      elts: [String(num)],
+      coord
+    });
+  }
+
+  function string(ctx: ParserContext, str: string, coord?: any): void {
+    push(ctx, {
+      tag: "STR",
+      elts: [str],
+      coord
+    });
+  }
+
+  function name(ctx: ParserContext, name: string, coord?: any): void {
+    push(ctx, {
+      tag: "IDENT",
+      elts: [name],
+      coord
+    });
+  }
+
+  function expr(ctx: ParserContext, argc: number): void {
+    // Ast.expr -- construct a expr node for the compiler.
+    const elts = [];
+    const pos = getPos(ctx);
+    console.trace(
+      "expr()",
+      "argc=" + argc,
+      "nodeStack=" + JSON.stringify(ctx.state.nodeStack, null, 2),
+    );
+    assertErr(ctx, argc <= ctx.state.nodeStack.length - 1, `Too few arguments. Expected ${argc} got ${ctx.state.nodeStack.length - 1}.`, {
+      from: pos - 1, to: pos
+    });
+    while (argc--) {
+      const elt = pop(ctx);
+      elts.push(elt);
+    }
+    const nameId = pop(ctx);
+    console.log(
+      "expr()",
+      "nameId=" + nameId,
+    );
+    assertErr(ctx, nameId, "Ill formed node.");
+    const e = node(ctx, nameId)!.elts;
+    assertErr(ctx, e && e.length > 0, "Ill formed node.");
+    const nodeName = e[0];
+    push(ctx, {
+      tag: nodeName,
+      elts,
+      coord: getCoord(ctx)
+    });
+  }
+
+  function parenExpr(ctx: ParserContext, coord?: any): void {
+    // Ast.parenExpr
+    const elts = [];
+    const elt = pop(ctx);
+    elts.push(elt);
+    push(ctx, {
+      tag: "PAREN",
+      elts,
+      coord
+    });
+  }
+
+  function list(ctx: ParserContext, count: number, coord?: any, reverse?: boolean): void {
+    // Ast.list
+    const elts = [];
+    for (let i = count; i > 0; i--) {
+      const elt = pop(ctx);
+      if (elt !== undefined) {
+        elts.push(elt);
+      }
+    }
+    push(ctx, {
+      tag: "LIST",
+      elts: reverse ? elts : elts.reverse(),
+      coord
+    });
+  }
+
+  function binaryExpr(ctx: ParserContext, name: string): void {
+    const elts = [];
+    // args are in the order produced by the parser
+    elts.push(pop(ctx));
+    elts.push(pop(ctx));
+    push(ctx, {
+      tag: name,
+      elts: elts.reverse()
+    });
+  }
+
+  function unaryExpr(ctx: ParserContext, name: string): void {
+    const elts = [];
+    elts.push(pop(ctx));
+    push(ctx, {
+      tag: name,
+      elts
+    });
+  }
+
+  function prefixExpr(ctx: ParserContext, name: string): void {
+    const elts = [];
+    elts.push(pop(ctx));
+    push(ctx, {
+      tag: name,
+      elts
+    });
+  }
+
+  function neg(ctx: ParserContext): void {
+    const v1 = +node(ctx, pop(ctx))!.elts[0];
+    number(ctx, -1 * v1);
+  }
+
+  function add(ctx: ParserContext, coord?: any): void {
+    const n2 = node(ctx, pop(ctx))!;
+    const n1 = node(ctx, pop(ctx))!;
+    const v2 = n2.elts[0];
+    const v1 = n1.elts[0];
+    if (n1.tag !== "NUM" || n2.tag !== "NUM") {
+      push(ctx, {
+        tag: "ADD",
+        elts: [n1, n2],
+        coord
+      });
+    } else {
+      number(ctx, +v1 + +v2);
+    }
+  }
+
+  function sub(ctx: ParserContext): void {
+    const n2 = node(ctx, pop(ctx))!;
+    const n1 = node(ctx, pop(ctx))!;
+    const v2 = n2.elts[0];
+    const v1 = n1.elts[0];
+    if (n1.tag !== "NUM" || n2.tag !== "NUM") {
+      push(ctx, { tag: "SUB", elts: [n1, n2] });
+    } else {
+      number(ctx, +v1 - +v2);
+    }
+  }
+
+  // function mul(ctx: ParserContext): void {
+  //   let n2 = node(ctx, pop(ctx));
+  //   let n1 = node(ctx, pop(ctx));
+  //   const v2 = n2.elts[0];
+  //   const v1 = n1.elts[0];
+  //   if (n1.tag === undefined) {
+  //     n1 = n1.elts[0];
+  //   }
+  //   if (n2.tag === undefined) {
+  //     n2 = n2.elts[0];
+  //   }
+  //   if (n1.tag !== "NUM" || n2.tag !== "NUM") {
+  //     push(ctx, { tag: "MUL", elts: [n2, n1] });
+  //   } else {
+  //     number(ctx, +v1 * +v2);
+  //   }
+  // }
+
+  function div(ctx: ParserContext): void {
+    const n2 = node(ctx, pop(ctx))!;
+    const n1 = node(ctx, pop(ctx))!;
+    const v2 = n2.elts[0];
+    const v1 = n1.elts[0];
+    if (n1.tag !== "NUM" || n2.tag !== "NUM") {
+      push(ctx, { tag: "DIV", elts: [n1, n2] });
+    } else {
+      number(ctx, +v1 / +v2);
+    }
+  }
+
+  function mod(ctx: ParserContext): void {
+    const n2 = node(ctx, pop(ctx))!;
+    const n1 = node(ctx, pop(ctx))!;
+    const v1 = n1.elts[0];
+    const v2 = n2.elts[0];
+    if (n1.tag !== "NUM" || n2.tag !== "NUM") {
+      push(ctx, { tag: "MOD", elts: [n1, n2] });
+    } else {
+      number(ctx, +v1 % +v2);
+    }
+  }
+
+  function pow(ctx: ParserContext): void {
+    const n2 = node(ctx, pop(ctx))!;
+    const n1 = node(ctx, pop(ctx))!;
+    const v2 = n2.elts[0];
+    const v1 = n1.elts[0];
+    if (n1.tag !== "NUM" || n2.tag !== "NUM") {
+      push(ctx, { tag: "POW", elts: [n1, n2] });
+    } else {
+      number(ctx, Math.pow(+v1, +v2));
+    }
+  }
+
+  function concat(ctx: ParserContext): void {
+    const n1 = node(ctx, pop(ctx))!;
+    push(ctx, {
+      tag: "CONCAT",
+      elts: [n1]
+    });
+  }
+
+  function eq(ctx: ParserContext): void {
+    const v2 = node(ctx, pop(ctx))!.elts[0];
+    const v1 = node(ctx, pop(ctx))!.elts[0];
+    bool(ctx, v1 === v2);
+  }
+
+  function ne(ctx: ParserContext): void {
+    const v2 = +node(ctx, pop(ctx))!.elts[0];
+    const v1 = +node(ctx, pop(ctx))!.elts[0];
+    bool(ctx, v1 !== v2);
+  }
+
+  function lt(ctx: ParserContext): void {
+    const v2 = +node(ctx, pop(ctx))!.elts[0];
+    const v1 = +node(ctx, pop(ctx))!.elts[0];
+    bool(ctx, v1 < v2);
+  }
+
+  function gt(ctx: ParserContext): void {
+    const v2 = +node(ctx, pop(ctx))!.elts[0];
+    const v1 = +node(ctx, pop(ctx))!.elts[0];
+    bool(ctx, v1 > v2);
+  }
+
+  function le(ctx: ParserContext): void {
+    const v2 = +node(ctx, pop(ctx))!.elts[0];
+    const v1 = +node(ctx, pop(ctx))!.elts[0];
+    bool(ctx, v1 <= v2);
+  }
+
+  function ge(ctx: ParserContext): void {
+    const v2 = +node(ctx, pop(ctx))!.elts[0];
+    const v1 = +node(ctx, pop(ctx))!.elts[0];
+    bool(ctx, v1 >= v2);
+  }
+
+  function ifExpr(ctx: ParserContext): void {
+    const elts = [];
+    elts.push(pop(ctx)); // if
+    elts.push(pop(ctx)); // then
+    elts.push(pop(ctx)); // else
+    push(ctx, { tag: "IF", elts: elts.reverse() });
+  }
+
+  function caseExpr(ctx: ParserContext, n: number): void {
+    const elts = [];
+    elts.push(pop(ctx)); // val
+    for (let i = n; i > 0; i--) {
+      elts.push(pop(ctx)); // of
+    }
+    push(ctx, { tag: "CASE", elts: elts.reverse() });
+  }
+
+  function ofClause(ctx: ParserContext): void {
+    const elts = [];
+    elts.push(pop(ctx));
+    elts.push(pop(ctx));
+    push(ctx, { tag: "OF", elts: elts.reverse() });
+  }
+
+  function record(ctx: ParserContext): void {
+    // Ast.record
+    const count = ctx.state.exprc;
+    const elts = [];
+    for (let i = count; i > 0; i--) {
+      const elt = pop(ctx);
+      if (elt !== undefined) {
+        elts.push(elt);
+      }
+    }
+    push(ctx, {
+      tag: "RECORD",
+      elts
+    });
+  }
+
+  function binding(ctx: ParserContext): void {
+    // Ast.binding
+    const elts = [];
+    elts.push(pop(ctx));
+    elts.push(pop(ctx));
+    push(ctx, {
+      tag: "BINDING",
+      elts: elts.reverse()
+    });
+  }
+
+  function lambda(ctx: ParserContext, env: any, nid: number): void {
+    // Ast.lambda
+    const names = [];
+    const nids = [];
+    for (const id in env.lexicon) {
+      const word = env.lexicon[id];
+      names.push({
+        tag: "IDENT",
+        elts: [word.name],
+        coord: getCoord(ctx)
+      });
+      nids.push(word.nid || 0);
+    }
+    const pattern = env.pattern;
+    push(ctx, {
+      tag: "LAMBDA",
+      elts: [{
+        tag: "LIST",
+        elts: names
+      }, nid, {
+        tag: "LIST",
+        elts: pattern
+      }, {
+        tag: "LIST",
+        elts: nids
+      }]
+    });
+  }
+
+  function exprs(ctx: ParserContext, count: number, inReverse?: boolean): void {
+    // Ast.exprs
+    let elts = [];
+    assert(ctx.state.nodeStack.length >= count);
+    if (inReverse) {
+      for (let i = count; i > 0; i--) {
+        const elt = pop(ctx);
+        elts.push(elt); // Reverse order.
+      }
+    } else {
+      for (let i = count; i > 0; i--) {
+        const elt = pop(ctx);
+        elts.push(elt); // Reverse order.
+      }
+      elts = elts.reverse();
+    }
+    push(ctx, {
+      tag: "EXPRS",
+      elts
+    });
+  }
+
+  function letDef(ctx: ParserContext): void {
+    // Clean up stack and produce initializer.
+    pop(ctx); // body
+    pop(ctx); // name
+    for (let i = 0; i < ctx.state.paramc; i++) {
+      pop(ctx); // params
+    }
+    ctx.state.exprc--; // don't count as expr.
+  }
+
+  function program(ctx: ParserContext): void {
+    const elts = [];
+    elts.push(pop(ctx));
+    push(ctx, {
+      tag: "PROG",
+      elts
+    });
+  }
+
+  // Assign all the methods to astClass
+  astClass.intern = intern;
+  astClass.node = node;
+  astClass.dump = dump;
+  astClass.dumpAll = dumpAll;
+  astClass.poolToJSON = poolToJSON;
+  astClass.number = number;
+  astClass.string = string;
+  astClass.name = name;
+  astClass.apply = apply;
+  astClass.fold = fold;
+  astClass.expr = expr;
+  astClass.binaryExpr = binaryExpr;
+  astClass.unaryExpr = unaryExpr;
+  astClass.parenExpr = parenExpr;
+  astClass.prefixExpr = prefixExpr;
+  astClass.lambda = lambda;
+  astClass.applyLate = applyLate;
+  astClass.letDef = letDef;
+  astClass.ifExpr = ifExpr;
+  astClass.caseExpr = caseExpr;
+  astClass.ofClause = ofClause;
+  astClass.record = record;
+  astClass.binding = binding;
+  astClass.exprs = exprs;
+  astClass.program = program;
+  astClass.pop = pop;
+  astClass.topNode = topNode;
+  astClass.peek = peek;
+  astClass.push = push;
+  astClass.mod = mod;
+  astClass.add = add;
+  astClass.sub = sub;
+  astClass.div = div;
+  astClass.pow = pow;
+  astClass.concat = concat;
+  astClass.eq = eq;
+  astClass.ne = ne;
+  astClass.lt = lt;
+  astClass.gt = gt;
+  astClass.le = le;
+  astClass.ge = ge;
+  astClass.neg = neg;
+  astClass.list = list;
+  astClass.bool = bool;
+  astClass.nul = nul;
+  astClass.error = error;
+
+  return astClass;
+})();
+
+// The following code for StreamString was copied from CodeMirror.
+class StringStream implements StringStream {
+  pos: number;
+  start: number;
+  string: string;
+  tabSize: number;
+
+  constructor(string: string, tabSize?: number) {
+    this.pos = this.start = 0;
+    this.string = string;
+    this.tabSize = tabSize || 8;
+  }
+
+  eol(): boolean { 
+    return this.pos >= this.string.length; 
+  }
+  
+  sol(): boolean { 
+    return this.pos === 0; 
+  }
+  
+  peek(): string | undefined { 
+    return this.string.charAt(this.pos) || undefined; 
+  }
+  
+  next(): string | undefined {
+    if (this.pos < this.string.length) { 
+      return this.string.charAt(this.pos++); 
+    }
+    return undefined;
+  }
+  
+  eat(match: string | RegExp | ((ch: string) => boolean)): string | undefined {
+    const ch = this.string.charAt(this.pos);
+    let ok;
+    if (typeof match === "string") {
+      ok = ch === match;
+    } else {
+      ok = ch && (match instanceof RegExp ? match.test(ch) : match(ch));
+    }
+    if (ok) { 
+      ++this.pos; 
+      return ch; 
+    }
+    return undefined;
+  }
+  
+  eatWhile(match: string | RegExp | ((ch: string) => boolean)): boolean {
+    const start = this.pos;
+    while (this.eat(match) !== undefined) {}
+    return this.pos > start;
+  }
+  
+  eatSpace(): boolean {
+    const start = this.pos;
+    while (/[\s\u00a0]/.test(this.string.charAt(this.pos))) ++this.pos;
+    return this.pos > start;
+  }
+  
+  skipToEnd(): void { 
+    this.pos = this.string.length; 
+  }
+  
+  skipTo(ch: string): boolean | undefined {
+    const found = this.string.indexOf(ch, this.pos);
+    if (found > -1) { 
+      this.pos = found; 
+      return true; 
+    }
+    return undefined;
+  }
+  
+  backUp(n: number): void { 
+    this.pos -= n; 
+  }
+  
+  match(pattern: string | RegExp, consume?: boolean, caseInsensitive?: boolean): boolean | RegExpMatchArray | null {
+    assert(false, "Should not get here");
+    if (typeof pattern === "string") {
+      const cased = function (str: string) { 
+        return caseInsensitive ? str.toLowerCase() : str; 
+      };
+      if (cased(this.string).indexOf(cased(pattern), this.pos) === this.pos) {
+        if (consume !== false) this.pos += pattern.length;
+        return true;
+      }
+    } else {
+      const match = this.string.slice(this.pos).match(pattern);
+      if (match && match.index! > 0) return null;
+      if (match && consume !== false) this.pos += match[0].length;
+      return match;
+    }
+    return false;
+  }
+  
+  current(): string { 
+    return this.string.slice(this.start, this.pos); 
+  }
+}
+
+// env module
+export const env = (function () {
+  return {
+    findWord,
+    addWord,
+    enterEnv,
+    exitEnv,
+    addPattern
+  };
+
+  // private functions
+  function findWord(ctx: ParserContext, lexeme: string): any {
+    const env = ctx.state.env;
+    for (let i = env.length - 1; i >= 0; i--) {
+      const word = env[i].lexicon[lexeme];
+      if (word) {
+        return word;
+      }
+    }
+    return null;
+  }
+
+  function addWord(ctx: ParserContext, lexeme: string, entry: any): null {
+    window.gcexports.topEnv!(ctx).lexicon[lexeme] = entry;
+    return null;
+  }
+
+  function addPattern(ctx: ParserContext, pattern: any): void {
+    window.gcexports.topEnv!(ctx).pattern.push(pattern);
+  }
+
+  function enterEnv(ctx: ParserContext, name: string): void {
+    // recursion guard
+    if (ctx.state.env.length > 380) {
+      console.trace(
+        "enterEnv()",
+        "name=" + name,
+      );
+      // return;  // just stop recursing
+      throw new Error("runaway recursion");
+    }
+    window.gcexports.topEnv!(ctx).paramc = ctx.state.paramc;
+    ctx.state.env.push({
+      name,
+      lexicon: {},
+      pattern: []
+    });
+  }
+
+  function exitEnv(ctx: ParserContext): void {
+    ctx.state.env.pop();
+    ctx.state.paramc = window.gcexports.topEnv!(ctx).paramc!;
+  }
+})();