@graffiticode/basis 1.1.0 → 1.3.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@graffiticode/basis",
   "type": "module",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "The basis library for creating Graffiticode languages",
   "main": "index.js",
   "scripts": {

package/src/#compiler.js#

@@ -0,0 +1,739 @@
+/* Copyright (c) 2021, ARTCOMPILER INC */
+import {assert, message, messages, reserveCodeRange} from "./share.js";
+reserveCodeRange(1000, 1999, "compile");
+messages[1001] = "Node ID %1 not found in pool.";
+messages[1002] = "Invalid tag in node with Node ID %1.";
+messages[1003] = "No async callback provided.";
+messages[1004] = "No visitor method defined for '%1'.";
+
+function error(msg, arg) {
+  return msg + arg;
+}
+
+function newNode(tag, elts) {
+  return {
+    tag: tag,
+    elts: elts,
+  };
+}
+
+const ASYNC = true;
+
+class Visitor {
+  constructor(code) {
+    this.nodePool = code;
+    this.root = code.root;
+  }
+  visit(nid, options, resume) {
+    assert(nid);
+    let node;
+    if (typeof nid === "object") {
+      node = nid;
+    } else {
+      node = this.nodePool[nid];
+    }
+    assert(node && node.tag && node.elts, "2000: Visitor.visit() tag=" + node.tag + " elts= " + JSON.stringify(node.elts));
+    assert(this[node.tag], "2000: Visitor function not defined for: " + node.tag);
+    assert(typeof resume === "function", message(1003));
+    if (!options.SYNC && ASYNC) {
+      setTimeout(() => this[node.tag](node, options, resume), 0);
+    } else {
+      this[node.tag](node, options, resume);
+    }
+  }
+  node(nid) {
+    var n = this.nodePool[nid];
+    if (!nid) {
+      return null;
+    } else if (!n) {
+      return {};
+    }
+    var elts = [];
+    switch (n.tag) {
+    case "NULL":
+      break;
+    case "NUM":
+    case "STR":
+    case "IDENT":
+    case "BOOL":
+      elts[0] = n.elts[0];
+      break;
+    default:
+      for (var i=0; i < n.elts.length; i++) {
+        elts[i] = this.node(n.elts[i]);
+      }
+      break;
+    }
+    return {
+      tag: n.tag,
+      elts: elts,
+    };
+  }
+}
+
+export class Checker extends Visitor {
+  constructor(nodePool) {
+    super(nodePool);
+  }
+  check(options, resume) {
+    const nid = this.root;
+    this.visit(nid, options, (err, data) => {
+      resume(err, data);
+    });
+  }
+  PROG(node, options, resume) {
+    this.visit(node.elts[0], options, (e0, v0) => {
+      const err = [];
+      const val = node;
+      resume(err, val);
+    });
+  }
+  EXPRS(node, options, resume) {
+    let err = [];
+    let val = [];
+    for (let elt of node.elts) {
+      this.visit(elt, options, (e0, v0) => {
+        err = err.concat(e0);
+        val = val.concat(v0);
+        if (val.length === node.elts.length) {
+          resume(err, val);
+        }
+      });
+    }
+    if (node.elts.length === 0) {
+      resume(err, val);
+    }
+  }
+  NUM(node, options, resume) {
+    const err = [];
+    const val = node;
+    resume(err, val);
+  }
+  LAMBDA(node, options, resume) {
+    const err = [];
+    const val = node;
+    this.visit(node.elts[0], options, (e0, v0) => {
+      resume(err, val);
+    });
+  }
+  LIST(node, options, resume) {
+    const err = [];
+    const val = node;
+    if (node.elts.length === 0) {
+      resume(err, val);
+    } else {
+      this.visit(node.elts[0], options, (e0, v0) => {
+        resume(err, val);
+      });
+    }
+  }
+  IDENT(node, options, resume) {
+    const err = [];
+    const val = node;
+    resume(err, val);
+  }
+  STR(node, options, resume) {
+    const err = [];
+    const val = node;
+    resume(err, val);
+  }
+  CONCAT(node, options, resume) {
+    this.visit(node.elts[0], options, (e0, v0) => {
+      const err = [];
+      const val = node;
+      resume(err, val);
+    });
+  }
+  ADD(node, options, resume) {
+    this.visit(node.elts[0], options, (err1, val1) => {
+      this.visit(node.elts[1], options, (err2, val2) => {
+        if (isNaN(+val1)) {
+          err1 = err1.concat(error("Argument must be a number.", node.elts[0]));
+        }
+        if (isNaN(+val2)) {
+          err2 = err2.concat(error("Argument must be a number.", node.elts[1]));
+        }
+        const err = [].concat(err1).concat(err2);
+        const val = node;
+        resume(err, val);
+      });
+    });
+  }
+  BOOL(node, options, resume) {
+    const err = [];
+    const val = node;
+    resume(err, val);
+  }
+  NULL(node, options, resume) {
+    const err = [];
+    const val = node;
+    resume(err, val);
+  }
+  RECORD(node, options, resume) {
+    const err = [];
+    const val = node;
+    resume(err, val);
+  }
+  BINDING(node, options, resume) {
+    const err = [];
+    const val = node;
+    resume(err, val);
+  }
+  MUL(node, options, resume) {
+    this.visit(node.elts[0], options, (err1, val1) => {
+      this.visit(node.elts[1], options, (err2, val2) => {
+        if (isNaN(+val1)) {
+          err1 = err1.concat(error("Argument must be a number.", node.elts[0]));
+        }
+        if (isNaN(+val2)) {
+          err2 = err2.concat(error("Argument must be a number.", node.elts[1]));
+        }
+        const err = [].concat(err1).concat(err2);
+        const val = node;
+        resume(err, val);
+      });
+    });
+  }
+  POW(node, options, resume) {
+    this.visit(node.elts[0], options, (err1, val1) => {
+      this.visit(node.elts[1], options, (err2, val2) => {
+        if (isNaN(+val1)) {
+          err1 = err1.concat(error("Argument must be a number.", node.elts[0]));
+        }
+        if (isNaN(+val2)) {
+          err2 = err2.concat(error("Argument must be a number.", node.elts[1]));
+        }
+        const err = [].concat(err1).concat(err2);
+        const val = node;
+        resume(err, val);
+      });
+    });
+  }
+  VAL(node, options, resume) {
+    const err = [];
+    const val = node;
+    resume(err, val);
+  }
+  KEY(node, options, resume) {
+    const err = [];
+    const val = node;
+    resume(err, val);
+  }
+  LEN(node, options, resume) {
+    const err = [];
+    const val = node;
+    resume(err, val);
+  }
+  ARG(node, options, resume) {
+    const err = [];
+    const val = node;
+    resume(err, val);
+  }
+  DATA(node, options, resume) {
+    const err = [];
+    const val = node;
+    resume(err, val);
+  }
+  PAREN(node, options, resume) {
+    const err = [];
+    const val = node;
+    resume(err, val);
+  }
+  APPLY(node, options, resume) {
+    const err = [];
+    const val = node;
+    resume(err, val);
+  }
+  MAP(node, options, resume) {
+    const err = [];
+    const val = node;
+    resume(err, val);
+  }
+  STYLE(node, options, resume) {
+    const err = [];
+    const val = node;
+    resume(err, val);
+  }
+  CASE(node, options, resume) {
+    const err = [];
+    const val = node;
+    resume(err, val);
+  }
+  OF(node, options, resume) {
+    const err = [];
+    const val = node;
+    resume(err, val);
+  }
+}
+
+function enterEnv(ctx, name, paramc) {
+  if (!ctx.env) {
+    ctx.env = [];
+  }
+  // recursion guard
+  if (ctx.env.length > 380) {
+    //return;  // just stop recursing
+    throw new Error("runaway recursion");
+  }
+  ctx.env.push({
+    name: name,
+    paramc: paramc,
+    lexicon: {},
+    pattern: [],
+  });
+}
+function exitEnv(ctx) {
+  ctx.env.pop();
+}
+function findWord(ctx, lexeme) {
+  let env = ctx.env;
+  if (!env) {
+    return null;
+  }
+  for (var i = env.length-1; i >= 0; i--) {
+    var word = env[i].lexicon[lexeme];
+    if (word) {
+      return word;
+    }
+  }
+  return null;
+}
+function addWord(ctx, lexeme, entry) {
+  topEnv(ctx).lexicon[lexeme] = entry;
+  return null;
+}
+function topEnv(ctx) {
+  return ctx.env[ctx.env.length-1]
+}
+export class Transformer extends Visitor {
+  constructor(nodePool) {
+    super(nodePool);
+    this.patternNodePool = ['unused'];
+    this.patternNodeMap = {};
+  }
+  transform(options, resume) {
+    const nid = this.root;
+    this.visit(nid, options, (err, data) => {
+      resume(err, data);
+    });
+  }
+  internPattern(n) {
+    if (!n) {
+      return 0;
+    }
+    const nodeMap = this.patternNodeMap;
+    const nodePool = this.patternNodePool;
+    const tag = n.tag;
+    const elts_nids = [];
+    const count = n.elts.length;
+    let elts = "";
+    for (let i = 0; i < count; i++) {
+      if (typeof n.elts[i] === "object") {
+        n.elts[i] = this.internPattern(n.elts[i]);
+      }
+      elts += n.elts[i];
+    }
+    const key = tag+count+elts;
+    let nid = nodeMap[key];
+    if (nid === void 0) {
+      nodePool.push({tag: tag, elts: n.elts});
+      nid = nodePool.length - 1;
+      nodeMap[key] = nid;
+      if (n.coord) {
+        ctx.state.coords[nid] = n.coord;
+      }
+    }
+    return nid;
+  }
+  match(options, patterns, node) {
+    if (patterns.size === 0 || node === undefined) {
+      return false;
+    }
+    let matches = patterns.filter((pattern) => {
+      if (pattern.tag === undefined || node.tag === undefined) {
+        return false;
+      }
+      const patternNid = this.internPattern(pattern); 
+      if (patternNid === this.internPattern(node) ||
+          patternNid === this.internPattern(newNode('IDENT', ['_']))) {
+        return true;
+      }
+      if (pattern.tag === node.tag) {
+        if (pattern.elts.length === node.elts.length) {
+          // Same number of args, so see if each matches.
+          return pattern.elts.every((arg, i) => {
+            if (pattern.tag === 'VAR') {
+              if (arg === node.elts[i]) {
+                return true;
+              }
+              return false;
+            }
+            let result = this.match(options, [arg], node.elts[i]);
+            return result.length === 1;
+          });
+        } else if (pattern.elts.length < node.elts.length) {
+          // Different number of args, then see if there is a wildcard match.
+          let nargs = node.elts.slice(1);
+          if (pattern.elts.length === 2) {
+            // Binary node pattern
+            let result = (
+              this.match(options, [pattern.elts[0]], node.elts[0]).length > 0 &&
+              this.match(options, [pattern.elts[1]], newNode(node.tag, nargs)).length > 0
+              // Match rest of the node against the second pattern argument.
+            );
+            return result;
+          }
+        }
+      }
+      return false;
+    });
+    // if (true || matches.length > 0) {
+    //   console.log("match() node: " + JSON.stringify(node, null, 2));
+    //   console.log("match() matches: " + JSON.stringify(matches, null, 2));
+    // }
+    return matches;
+  }
+
+
+  PROG(node, options, resume) {
+    if (!options) {
+      options = {};
+    }
+    this.visit(node.elts[0], options, (e0, v0) => {
+      const err = e0;
+      const val = v0.pop();  // Return the value of the last expression.
+      resume(err, val);
+    });
+  }
+  EXPRS(node, options, resume) {
+    let err = [];
+    let val = [];
+    for (let elt of node.elts) {
+      this.visit(elt, options, (e0, v0) => {
+        err = err.concat(e0);
+        val.push(v0);
+        if (val.length === node.elts.length) {
+          resume(err, val);
+        }
+      });
+    }
+    if (node.elts.length === 0) {
+      val.push("");
+      resume(err, val);
+    }
+  }
+  NUM(node, options, resume) {
+    const err = [];
+    const val = +node.elts[0];
+    resume(err, val);
+  }
+  LAMBDA(node, options, resume) {
+    // Return a function value.
+    this.visit(node.elts[0], options, (err0, params) => {
+      let args = [].concat(options.args);
+      enterEnv(options, "lambda", params.length);
+      params.forEach((param, i) => {
+        // let inits = this.nodePool[node.elts[3]].elts;
+        if (args[i]) {
+          // Got an arg so use it.
+          addWord(options, param, {
+            name: param,
+            val: args[i],
+          });
+        // } else {
+        //   // Don't got an arg so use the init.
+        //   this.visit(inits[i], options, (err, val) => {
+        //     addWord(options, param, {
+        //       name: param,
+        //       val: val,
+        //     });
+        //   });
+        }
+      });
+      this.visit(node.elts[1], options, (err, val) => {
+        exitEnv(options);
+        resume([].concat(err0).concat(err).concat(err), val)
+      });
+    });
+  }
+  LIST(node, options, resume) {
+    let err = [];
+    let val = [];
+    if (node.elts.length === 0) {
+      resume(err, val);
+    } else {
+      for (let elt of node.elts) {
+        this.visit(elt, options, (e0, v0) => {
+          err = err.concat(e0);
+          val.push(v0);
+          if (val.length === node.elts.length) {
+            resume(err, val);
+          }
+        });
+      }
+    }
+  }
+  IDENT(node, options, resume) {
+    let word = findWord(options, node.elts[0]);
+    const err = [];
+    const val = word && word.val || node.elts[0];
+    resume(err, val);
+  }
+  STR(node, options, resume) {
+    const err = [];
+    const val = node.elts[0];
+    resume(err, val);
+  }
+  CONCAT(node, options, resume) {
+    this.visit(node.elts[0], options, (e0, v0) => {
+      const err = [];
+      const val = ([].concat(v0)).join('');
+      resume(err, val);
+    });
+  }
+  ADD(node, options, resume) {
+    this.visit(node.elts[0], options, (e0, v0) => {
+      this.visit(node.elts[1], options, (e1, v1) => {
+        const err = [].concat(e0).concat(e1);
+        const val = +v0 + +v1;
+        resume(err, val);
+      });
+    });
+  }
+  BOOL(node, options, resume) {
+    const err = [];
+    const val = node;
+    resume(err, val);
+  }
+  NULL(node, options, resume) {
+    const err = [];
+    const val = null;
+    resume(err, val);
+  }
+  BINDING(node, options, resume) {
+    const err = [];
+    const val = node;
+    this.visit(node.elts[0], options, (err1, val1) => {
+      this.visit(node.elts[1], options, (err2, val2) => {
+        resume([].concat(err1).concat(err2), {key: val1, val: val2});
+      });
+    });
+  }
+  RECORD(node, options, resume) {
+    let err = [];
+    let val = {};
+    let len = 0;
+    if (node.elts.length === 0) {
+      resume(err, val);
+    } else {
+      for (let elt of node.elts.reverse()) {
+        // For historical reasons, the bindings are reversed in the AST.
+        this.visit(elt, options, (e0, v0) => {
+          err = err.concat(e0);
+          val[v0.key] = v0.val;
+          if (++len === node.elts.length) {
+            resume(err, val);
+          }
+        });
+      }
+    }
+  }
+  MUL(node, options, resume) {
+    this.visit(node.elts[0], options, (err1, val1) => {
+      this.visit(node.elts[1], options, (err2, val2) => {
+        if (isNaN(+val1)) {
+          err1 = err1.concat(error("Argument must be a number.", node.elts[0]));
+        }
+        if (isNaN(+val2)) {
+          err2 = err2.concat(error("Argument must be a number.", node.elts[1]));
+        }
+        const err = [].concat(err1).concat(err2);
+        const val = +val1 * +val2;
+        resume(err, val);
+      });
+    });
+  }
+  POW(node, options, resume) {
+    this.visit(node.elts[0], options, (err1, val1) => {
+      this.visit(node.elts[1], options, (err2, val2) => {
+        if (isNaN(+val1)) {
+          err1 = err1.concat(error("Argument must be a number.", node.elts[0]));
+        }
+        if (isNaN(+val2)) {
+          err2 = err2.concat(error("Argument must be a number.", node.elts[1]));
+        }
+        const err = [].concat(err1).concat(err2);
+        const val = node;
+        resume(err, val);
+      });
+    });
+  }
+  VAL(node, options, resume) {
+    this.visit(node.elts[0], options, (e0, v0) => {
+      this.visit(node.elts[1], options, (e1, v1) => {
+        const err = [].concat(e0).concat(e1);
+        const val = v1[v0];
+        resume(err, val);
+      });
+    });
+  }
+  KEY(node, options, resume) {
+    const err = [];
+    const val = node;
+    resume(err, val);
+  }
+  LEN(node, options, resume) {
+    const err = [];
+    const val = node;
+    resume(err, val);
+  }
+  ARG(node, options, resume) {
+    const err = [];
+    const val = node;
+    resume(err, val);
+  }
+  DATA(node, options, resume) {
+    if (options.data && Object.keys(options.data).length !== 0) {
+      // Got external data, so use it.
+      const err = [];
+      const val = options.data;
+      resume(err, val);
+    } else {
+      // Otherwise, use the default data.
+      this.visit(node.elts[0], options, (e0, v0) => {
+        const err = e0;
+        const val = v0;
+        resume(err, val);
+      });
+    }
+  }
+  PAREN(node, options, resume) {
+    this.visit(node.elts[0], options, (e0, v0) => {
+      const err = [].concat(e0);
+      const val = v0;
+      resume(err, val);
+    });
+  }
+  APPLY(node, options, resume) {
+    // Apply a function to arguments.
+    this.visit(node.elts[1], options, (e1, v1) => {
+      options.args = v1;
+      this.visit(node.elts[0], options, (e0, v0) => {
+        //exitEnv(options);
+        const err = [].concat(e1).concat(e0);
+        const val = v0;
+        resume(err, val);
+      });
+    });
+  }
+  MAP(node, options, resume) {
+    this.visit(node.elts[1], options, (e1, v1) => {
+      let err = [];
+      let val = [];
+      v1.forEach(args => {
+        options.args = args;
+        options = JSON.parse(JSON.stringify(options));  // Copy option arg support async.
+        this.visit(node.elts[0], options, (e0, v0) => {
+          val.push(v0);
+          err = err.concat(e0);
+          if (val.length === v1.length) {
+            resume(err, val);
+          }
+        });
+      });
+    });
+  }
+  STYLE(node, options, resume) {
+    const err = [];
+    const val = node;
+    resume(err, val);
+  }
+  CASE(node, options, resume) {
+    // FIXME this isn't ASYNC compatible
+    options.SYNC = true;
+    this.visit(node.elts[0], options, (err, e0) => {
+      const e0Node = this.node(node.elts[0]);
+      const expr = (e0Node.tag === 'NUM' || e0Node.tag === 'NUM') && e0Node || {tag: 'STR', elts: [`${e0}`]};
+      let foundMatch = false;
+      const patterns = [];
+      for (var i = 1; i < node.elts.length; i++) {
+        this.visit(node.elts[i], options, (err, val) => {
+          if (this.match(options, [this.node(node.elts[i]).elts[0]], expr).length) {
+            this.visit(val.exprElt, options, resume);
+            foundMatch = true;
+          }
+        });
+        if (foundMatch) {
+          return;
+        }
+      }
+      if (!foundMatch) {
+        resume([], {})
+      }
+    });
+    options.SYNC = false;
+  }
+  OF(node, options, resume) {
+    this.visit(node.elts[0], options, (err0, pattern) => {
+      resume([].concat(err0), {
+        pattern: pattern,
+        exprElt: node.elts[1],
+      });
+    });
+  }
+}
+
+export class Renderer {
+  constructor(data) {
+    this.data = data;
+  }
+  render(options, resume) {
+    // Do some rendering here.
+    const err = [];
+    const val = this.data;
+    resume(err, val);
+  }
+}
+
+export class Compiler {
+  constructor(config) {
+    this.langID = config.langID;
+    this.version = config.version;
+    this.Checker = config.Checker || Checker;
+    this.Transformer = config.Transformer || Transformer;
+    this.Renderer = config.Renderer || Renderer;
+  }
+  compile(code, data, config, resume) {
+    // Compiler takes an AST in the form of a node pool (code) and transforms it
+    // into an object to be rendered on the client by the viewer for this
+    // language.
+    try {
+      let options = {
+        data: data,
+        config: config,
+        result: '',
+      };
+      const checker = new this.Checker(code);
+      checker.check(options, (err, val) => {
+        const transformer = new this.Transformer(code);
+        transformer.transform(options, (err, val) => {
+          if (err && err.length) {
+            resume(err, val);
+          } else {
+            const renderer = new this.Renderer(val);
+            renderer.render(options, (err, val) => {
+              resume(err, val);
+            });
+          }
+        });
+      });
+    } catch (x) {
+      console.log("ERROR with code");
+      console.log(x.stack);
+      resume([{
+        statusCode: 500,
+        error: "Compiler error"
+      }]);
+    }
+  }
+}

package/src/compiler.js

@@ -100,6 +100,9 @@ export class Checker extends Visitor {
         }
       });
     }
+    if (node.elts.length === 0) {
+      resume(err, val);
+    }
   }
   NUM(node, options, resume) {
     const err = [];
@@ -414,6 +417,10 @@ export class Transformer extends Visitor {
         }
       });
     }
+    if (node.elts.length === 0) {
+      val.push("");
+      resume(err, val);
+    }
   }
   NUM(node, options, resume) {
     const err = [];
@@ -495,7 +502,7 @@ export class Transformer extends Visitor {
   }
   BOOL(node, options, resume) {
     const err = [];
-    const val = node;
+    const val = node.elts[0];
     resume(err, val);
   }
   NULL(node, options, resume) {
@@ -586,7 +593,7 @@ export class Transformer extends Visitor {
     resume(err, val);
   }
   DATA(node, options, resume) {
-    if (options.data && Object.keys(options.data).length != 0) {
+    if (options.data && Object.keys(options.data).length !== 0) {
       // Got external data, so use it.
       const err = [];
       const val = options.data;