hclang 0.1.0 → 0.5.4

package/README.md

@@ -1,12 +1,30 @@
 # Homiconic C
+version: 0.5.4
 
-[ ![Codeship Status for HC](https://app.codeship.com/projects/aaeb71c0-b7d8-0134-5ab7-22c228ba91d5/status?branch=master)](https://app.codeship.com/projects/194564)
+[![Codeship Status for TheSwanFactory/hclang](https://app.codeship.com/projects/b1198f30-aee9-0137-5fdc-4a1003a17a1c/status?branch=master)](https://app.codeship.com/projects/362584)
 
 ## Introduction
 
-[Homoiconic C](https://theswanfactory.com/2016/12/20/homoiconic-c-a-universal-language-for-code-and-data/) (HC) is a single universal language for code and data.  This repository contains the first implementation of HC as an interpreter written in TypeScript running on `nodejs`.  It also contains a sample application called MAML, the [*Multipurpose Abstract Markup Language*](https://theswanfactory.com/2016/11/08/introducing-maml-a-draft-proposal-for-html6/).  MAML is a radically simple proposal for replacing all the existing web technologies (HMTL, CSS, JavaScript, SVG, etc.) with a single format based on HC.
+[Homoiconic C](https://theswanfactory.wordpress.com/2016/12/20/homoiconic-c-a-universal-language-for-code-and-data/) (HC) is a single universal language for code and data.  This repository contains the first implementation of HC as an interpreter written in TypeScript running on `nodejs`.  It also contains a sample application called MAML, the [*Multipurpose Abstract Markup Language*](https://theswanfactory.wordpress.com/2016/11/08/introducing-maml-a-draft-proposal-for-html6/).  MAML is a radically simple proposal for replacing all the existing web technologies (HMTL, CSS, JavaScript, SVG, etc.) with a single format based on HC. It can also be used to define easily-parseable variants of other common file formats (e.g., HCSV, HCSON). 
 
-## Getting Started
+## Usage
+
+```
+$ npm install
+$ export DEBUG=true # optional
+$ npm run hc
+```
+This will launch the interpreter.
+
+## BitScheme
+
+To generate and run the BitScheme documentation, type:
+```
+$ npm run bs:all
+```
+This will open the BitScheme.html file, and also run the documentation through the testdoc evaluator which will generate pass/fail messages.
+
+## Development
 
 1. Install the [Atom editor](http://flight-manual.atom.io/getting-started/sections/installing-atom/).
 
@@ -18,3 +36,7 @@
   * e.g., `brew install node` on macOS.
 
 5. Run `npm test`.
+
+## Debugging
+0. $ npm run inspect
+5. # In Chrome: chrome://inspect

package/lib/src/cli/hc.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+import { HCEval } from '../execute/hc-eval.js';
+import { HCLog } from '../execute/hc-log.js';
+import { HCTest } from '../execute/hc-test.js';
+import minimist from 'minimist';
+import { runfile } from './runfile.js';
+const aliases = {
+    e: 'evaluate',
+    h: 'help',
+    i: 'interactive',
+    t: 'testdoc',
+    v: 'verbose',
+    V: 'version'
+};
+const options = minimist(process.argv.slice(2), { alias: aliases });
+if (options.verbose) {
+    console.error('options', options);
+}
+const context = HCEval.make_context(process.env);
+const out = new HCLog(context);
+let hc_eval = new HCEval(out);
+let evaluated = false;
+let test;
+if (options.testdoc) {
+    test = new HCTest(out);
+    hc_eval = new HCEval(test);
+    evaluated = true;
+}
+if (options.evaluate) {
+    hc_eval.call(options.evaluate.toString());
+    evaluated = true;
+}
+options._.forEach((file) => {
+    evaluated = runfile(hc_eval, file);
+});
+if (options.interactive || !evaluated) {
+    out.prompt = true;
+    hc_eval.repl();
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY2xpL2hjLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFHQSxPQUFPLEVBQUUsTUFBTSxFQUFFLE1BQU0sdUJBQXVCLENBQUE7QUFDOUMsT0FBTyxFQUFFLEtBQUssRUFBRSxNQUFNLHNCQUFzQixDQUFBO0FBQzVDLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQTtBQUM5QyxPQUFPLFFBQVEsTUFBTSxVQUFVLENBQUE7QUFDL0IsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLGNBQWMsQ0FBQTtBQUV0QyxNQUFNLE9BQU8sR0FBRztJQUNkLENBQUMsRUFBRSxVQUFVO0lBQ2IsQ0FBQyxFQUFFLE1BQU07SUFDVCxDQUFDLEVBQUUsYUFBYTtJQUNoQixDQUFDLEVBQUUsU0FBUztJQUNaLENBQUMsRUFBRSxTQUFTO0lBQ1osQ0FBQyxFQUFFLFNBQVM7Q0FDYixDQUFBO0FBQ0QsTUFBTSxPQUFPLEdBQUcsUUFBUSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsS0FBSyxFQUFFLE9BQU8sRUFBRSxDQUFDLENBQUE7QUFDbkUsSUFBSSxPQUFPLENBQUMsT0FBTyxFQUFFO0lBQ25CLE9BQU8sQ0FBQyxLQUFLLENBQUMsU0FBUyxFQUFFLE9BQU8sQ0FBQyxDQUFBO0NBQ2xDO0FBRUQsTUFBTSxPQUFPLEdBQUcsTUFBTSxDQUFDLFlBQVksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLENBQUE7QUFDaEQsTUFBTSxHQUFHLEdBQUcsSUFBSSxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUE7QUFDOUIsSUFBSSxPQUFPLEdBQUcsSUFBSSxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUE7QUFDN0IsSUFBSSxTQUFTLEdBQUcsS0FBSyxDQUFBO0FBQ3JCLElBQUksSUFBWSxDQUFBO0FBRWhCLElBQUksT0FBTyxDQUFDLE9BQU8sRUFBRTtJQUNuQixJQUFJLEdBQUcsSUFBSSxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUE7SUFDdEIsT0FBTyxHQUFHLElBQUksTUFBTSxDQUFDLElBQUksQ0FBQyxDQUFBO0lBQzFCLFNBQVMsR0FBRyxJQUFJLENBQUE7Q0FDakI7QUFFRCxJQUFJLE9BQU8sQ0FBQyxRQUFRLEVBQUU7SUFDcEIsT0FBTyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUE7SUFDekMsU0FBUyxHQUFHLElBQUksQ0FBQTtDQUNqQjtBQUVELE9BQU8sQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsSUFBUyxFQUFFLEVBQUU7SUFDOUIsU0FBUyxHQUFHLE9BQU8sQ0FBQyxPQUFPLEVBQUUsSUFBSSxDQUFDLENBQUE7QUFDcEMsQ0FBQyxDQUFDLENBQUE7QUFFRixJQUFJLE9BQU8sQ0FBQyxXQUFXLElBQUksQ0FBQyxTQUFTLEVBQUU7SUFDckMsR0FBRyxDQUFDLE1BQU0sR0FBRyxJQUFJLENBQUE7SUFDakIsT0FBTyxDQUFDLElBQUksRUFBRSxDQUFBO0NBQ2YifQ==

package/lib/src/cli/runfile.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import readline from 'readline';
+const RUNDOC = '#!/usr/bin/env hc \n```\n';
+const ENDDOC = '```\n';
+function is_doc(file) {
+    const file_ext = file.split('.').pop();
+    return file_ext === 'adoc' || file_ext === 'md';
+}
+function runfile(hc_eval, file) {
+    const file_ext = file.split('.').pop();
+    const is_doc_file = is_doc(file);
+    if (is_doc_file) {
+        hc_eval.call(RUNDOC);
+    }
+    const rl = readline.createInterface(fs.createReadStream(file), undefined);
+    rl.on('line', (line) => {
+        hc_eval.call(line);
+    });
+    rl.on('close', () => {
+        if (is_doc_file) {
+            hc_eval.call(ENDDOC);
+        }
+    });
+    return true;
+}
+export { runfile };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVuZmlsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jbGkvcnVuZmlsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQ0EsT0FBTyxFQUFFLE1BQU0sSUFBSSxDQUFBO0FBQ25CLE9BQU8sUUFBUSxNQUFNLFVBQVUsQ0FBQTtBQUcvQixNQUFNLE1BQU0sR0FBRywyQkFBMkIsQ0FBQTtBQUMxQyxNQUFNLE1BQU0sR0FBRyxPQUFPLENBQUE7QUFFdEIsU0FBUyxNQUFNLENBQUUsSUFBWTtJQUMzQixNQUFNLFFBQVEsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDLEdBQUcsRUFBRSxDQUFBO0lBQ3RDLE9BQU8sUUFBUSxLQUFLLE1BQU0sSUFBSSxRQUFRLEtBQUssSUFBSSxDQUFBO0FBQ2pELENBQUM7QUFFRCxTQUFTLE9BQU8sQ0FBRSxPQUFlLEVBQUUsSUFBUztJQUMxQyxNQUFNLFFBQVEsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDLEdBQUcsRUFBRSxDQUFBO0lBQ3RDLE1BQU0sV0FBVyxHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQTtJQUNoQyxJQUFJLFdBQVcsRUFBRTtRQUNmLE9BQU8sQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUE7S0FDckI7SUFDRCxNQUFNLEVBQUUsR0FBRyxRQUFRLENBQUMsZUFBZSxDQUFDLEVBQUUsQ0FBQyxnQkFBZ0IsQ0FBQyxJQUFJLENBQUMsRUFBRSxTQUFTLENBQUMsQ0FBQTtJQUN6RSxFQUFFLENBQUMsRUFBRSxDQUFDLE1BQU0sRUFBRSxDQUFDLElBQUksRUFBRSxFQUFFO1FBQ3JCLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUE7SUFDcEIsQ0FBQyxDQUFDLENBQUE7SUFDRixFQUFFLENBQUMsRUFBRSxDQUFDLE9BQU8sRUFBRSxHQUFHLEVBQUU7UUFDbEIsSUFBSSxXQUFXLEVBQUU7WUFDZixPQUFPLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFBO1NBQ3JCO0lBQ0gsQ0FBQyxDQUFDLENBQUE7SUFDRixPQUFPLElBQUksQ0FBQTtBQUNiLENBQUM7QUFFRCxPQUFPLEVBQUUsT0FBTyxFQUFFLENBQUEifQ==

package/lib/src/execute/eval-pipe.js

@@ -0,0 +1,15 @@
+import { Frame, NilContext } from '../frames.js';
+export class EvalPipe extends Frame {
+    constructor(out, meta = NilContext) {
+        super(meta);
+        this.set(Frame.kOUT, out);
+        this.up = out;
+    }
+    apply(expr, context) {
+        const out = this.get(Frame.kOUT);
+        const result = expr.in([out, context]);
+        out.apply(result, context);
+        return result;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZhbC1waXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2V4ZWN1dGUvZXZhbC1waXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBVyxLQUFLLEVBQUUsVUFBVSxFQUFFLE1BQU0sY0FBYyxDQUFBO0FBRXpELE1BQU0sT0FBTyxRQUFTLFNBQVEsS0FBSztJQUNqQyxZQUFhLEdBQVUsRUFBRSxPQUFnQixVQUFVO1FBQ2pELEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQTtRQUNYLElBQUksQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLElBQUksRUFBRSxHQUFHLENBQUMsQ0FBQTtRQUN6QixJQUFJLENBQUMsRUFBRSxHQUFHLEdBQUcsQ0FBQTtJQUNmLENBQUM7SUFFTSxLQUFLLENBQUUsSUFBVyxFQUFFLE9BQWM7UUFDdkMsTUFBTSxHQUFHLEdBQUcsSUFBSSxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUE7UUFDaEMsTUFBTSxNQUFNLEdBQUcsSUFBSSxDQUFDLEVBQUUsQ0FBQyxDQUFDLEdBQUcsRUFBRSxPQUFPLENBQUMsQ0FBQyxDQUFBO1FBQ3RDLEdBQUcsQ0FBQyxLQUFLLENBQUMsTUFBTSxFQUFFLE9BQU8sQ0FBQyxDQUFBO1FBQzFCLE9BQU8sTUFBTSxDQUFBO0lBQ2YsQ0FBQztDQUNGIn0=

package/lib/src/execute/evaluate.js

@@ -0,0 +1,10 @@
+import { FrameArray } from '../frames.js';
+import { HCEval } from './hc-eval.js';
+export const evaluate = (input, ...args) => {
+    const out = new FrameArray([]);
+    const hc_eval = new HCEval(out);
+    hc_eval.call(input);
+    return out;
+};
+// https://stackoverflow.com/questions/63524054/typescript-optional-arguments-spreading-crashing-in-v4
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZhbHVhdGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZXhlY3V0ZS9ldmFsdWF0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQVMsVUFBVSxFQUFFLE1BQU0sY0FBYyxDQUFBO0FBQ2hELE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxjQUFjLENBQUE7QUFFckMsTUFBTSxDQUFDLE1BQU0sUUFBUSxHQUFHLENBQUMsS0FBYSxFQUFFLEdBQUcsSUFBUyxFQUFTLEVBQUU7SUFDN0QsTUFBTSxHQUFHLEdBQUcsSUFBSSxVQUFVLENBQUMsRUFBRSxDQUFDLENBQUE7SUFDOUIsTUFBTSxPQUFPLEdBQUcsSUFBSSxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUE7SUFDL0IsT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQTtJQUNuQixPQUFPLEdBQUcsQ0FBQTtBQUNaLENBQUMsQ0FBQTtBQUNELHNHQUFzRyJ9

package/lib/src/execute/execute.js

@@ -0,0 +1,18 @@
+import { evaluate } from './evaluate.js';
+const stripLastCommas = (array) => {
+    const result = array.map((item) => {
+        const n = item.length - 1;
+        if (item[n] === ',') {
+            return item.substring(0, n);
+        }
+        return item;
+    });
+    return result;
+};
+export const execute = (input) => {
+    const result = evaluate(input);
+    const array = result.toStringArray();
+    const stripped = stripLastCommas(array);
+    return stripped.join('\n');
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXhlY3V0ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9leGVjdXRlL2V4ZWN1dGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQTtBQUd4QyxNQUFNLGVBQWUsR0FBRyxDQUFDLEtBQW9CLEVBQUUsRUFBRTtJQUMvQyxNQUFNLE1BQU0sR0FBRyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUMsSUFBSSxFQUFFLEVBQUU7UUFDaEMsTUFBTSxDQUFDLEdBQUcsSUFBSSxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUE7UUFDekIsSUFBSSxJQUFJLENBQUMsQ0FBQyxDQUFDLEtBQUssR0FBRyxFQUFFO1lBQ25CLE9BQU8sSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUE7U0FDNUI7UUFDRCxPQUFPLElBQUksQ0FBQTtJQUNiLENBQUMsQ0FBQyxDQUFBO0lBQ0YsT0FBTyxNQUFNLENBQUE7QUFDZixDQUFDLENBQUE7QUFFRCxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsQ0FBQyxLQUFhLEVBQUUsRUFBRTtJQUN2QyxNQUFNLE1BQU0sR0FBRyxRQUFRLENBQUMsS0FBSyxDQUFlLENBQUE7SUFDNUMsTUFBTSxLQUFLLEdBQUcsTUFBTSxDQUFDLGFBQWEsRUFBRSxDQUFBO0lBQ3BDLE1BQU0sUUFBUSxHQUFHLGVBQWUsQ0FBQyxLQUFLLENBQUMsQ0FBQTtJQUN2QyxPQUFPLFFBQVEsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUE7QUFDNUIsQ0FBQyxDQUFBIn0=

package/lib/src/execute/frame-space.js

@@ -0,0 +1,17 @@
+import * as frame from '../frames.js';
+export class FrameSpace extends frame.FrameAtom {
+    constructor(meta = frame.NilContext) {
+        super(meta);
+        this.is.void = true;
+    }
+    string_start() {
+        return FrameSpace.SPACE_CHAR;
+    }
+    ;
+    canInclude(char) {
+        return char === FrameSpace.SPACE_CHAR;
+    }
+}
+FrameSpace.SPACE_CHAR = ' ';
+;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnJhbWUtc3BhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZXhlY3V0ZS9mcmFtZS1zcGFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssS0FBSyxNQUFNLGNBQWMsQ0FBQTtBQUVyQyxNQUFNLE9BQU8sVUFBVyxTQUFRLEtBQUssQ0FBQyxTQUFTO0lBRzdDLFlBQWEsSUFBSSxHQUFHLEtBQUssQ0FBQyxVQUFVO1FBQ2xDLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQTtRQUNYLElBQUksQ0FBQyxFQUFFLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQTtJQUNyQixDQUFDO0lBRU0sWUFBWTtRQUNqQixPQUFPLFVBQVUsQ0FBQyxVQUFVLENBQUE7SUFDOUIsQ0FBQztJQUFBLENBQUM7SUFFSyxVQUFVLENBQUUsSUFBWTtRQUM3QixPQUFPLElBQUksS0FBSyxVQUFVLENBQUMsVUFBVSxDQUFBO0lBQ3ZDLENBQUM7O0FBYnNCLHFCQUFVLEdBQUcsR0FBRyxDQUFBO0FBY3hDLENBQUMifQ==

package/lib/src/execute/hc-eval.js

@@ -0,0 +1,105 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import chalk from 'chalk';
+import { FrameGroup, FrameString } from '../frames.js';
+import { version } from '../version.js';
+import { EvalPipe } from './eval-pipe.js';
+import { Lex } from './lex.js';
+import { LexPipe } from './lex-pipe.js';
+import { ParsePipe } from './parse-pipe.js';
+import { stdin as input, stdout as output } from 'node:process';
+import readline from 'node:readline/promises';
+export class HCEval {
+    static make_context(env) {
+        const context = {};
+        Object.entries(env).forEach(([key, value]) => {
+            if (key[0] !== 'n') {
+                context[key] = new FrameString(value || 'undefined');
+            }
+        });
+        if (context.DEBUG_ENV) {
+            console.debug('DEBUG_ENV', context);
+        }
+        return context;
+    }
+    static make_pipe(out) {
+        const evaluator = new EvalPipe(out); // evaluate groups into results
+        const parser = new ParsePipe(evaluator, FrameGroup); // parse tokens into groups of expressions
+        const lexer = new LexPipe(parser); // lex characters into tokens
+        return lexer;
+    }
+    static make_prompt(level) {
+        const indent = 2 * (level - 1);
+        const middle = ' '.repeat(indent);
+        return HCEval.EXPECT + middle + HCEval.EXPECT;
+    }
+    constructor(out) {
+        this.out = out;
+        this.pipe = HCEval.make_pipe(this.out);
+        this.lex = this.pipe;
+    }
+    call(input) {
+        if (!input) {
+            return null;
+        }
+        // console.error("HCEval.input", input);
+        const source = new FrameString(input);
+        this.checkInput(input);
+        const result = source.reduce(this.lex);
+        // console.error("HCEval.result", result);
+        this.lex = (result instanceof Lex) ? result : this.pipe;
+        return result;
+    }
+    repl() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log(chalk.green('.hc ' + version + ';'));
+            let status = true;
+            while (status) {
+                const input = yield this.getInput();
+                if (!input) {
+                    status = false;
+                    break;
+                }
+                this.call(input);
+            }
+            return status;
+        });
+    }
+    getInput() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let prefix = HCEval.SOURCE;
+            if (this.pipe.level > 0) {
+                prefix = HCEval.make_prompt(this.pipe.level);
+            }
+            const rlp = readline.createInterface({ input, output });
+            const answer = yield rlp.question(chalk.grey(prefix));
+            rlp.close();
+            return answer;
+        });
+    }
+    checkInput(input) {
+        const head = input.substr(0, 2);
+        const tail = input.substr(2);
+        const value = new FrameString(tail);
+        switch (head) {
+            case HCEval.SOURCE: {
+                this.out.set(HCEval.SOURCE, value);
+                break;
+            }
+            case HCEval.EXPECT: {
+                this.out.set(HCEval.EXPECT, value);
+                break;
+            }
+        }
+    }
+}
+HCEval.SOURCE = '; ';
+HCEval.EXPECT = '# ';
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/execute/hc-log.js

@@ -0,0 +1,39 @@
+import chalk from 'chalk';
+import { Frame } from '../frames.js';
+import { HCEval } from './hc-eval.js';
+export class HCLog extends Frame {
+    constructor(context, prompt = false) {
+        super(context);
+        this.prompt = prompt;
+    }
+    apply(argument, _parameter = Frame.nil) {
+        const debug = this.get('DEBUG');
+        if (debug !== Frame.missing) {
+            console.log(argument.id, argument);
+        }
+        if (argument !== Frame.nil && !argument.is.void && !argument.is.statement) {
+            const output = argument.toString();
+            if (this.prompt) {
+                console.log(chalk.grey(HCEval.EXPECT + output));
+            }
+            else {
+                const colorized = this.color(output);
+                console.log(colorized);
+            }
+        }
+        return argument;
+    }
+    color(output) {
+        if (output[0] !== '$') {
+            return output;
+        }
+        const flag = output[1];
+        const part = output.split(' .n ');
+        switch (flag) {
+            case '+': return chalk.green(part[0]) + chalk.grey.italic(part[1]);
+            case '-': return chalk.red(part[0]) + chalk.grey.italic(part[1]);
+            default: return chalk.yellow(output);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/execute/hc-test.js

@@ -0,0 +1,43 @@
+import { Frame, FrameNote, FrameString, NilContext } from '../frames.js';
+import { HCEval } from './hc-eval.js';
+export class HCTest extends Frame {
+    constructor(out) {
+        super(NilContext);
+        this.out = out;
+        this.actual = Frame.missing;
+        this.n = { total: 0, pass: 0, fail: 0 };
+    }
+    apply(argument, parameter = Frame.nil) {
+        const source = this.get(HCEval.SOURCE);
+        const expected = this.get(HCEval.EXPECT);
+        if (!this.actual.is.missing || !expected.is.missing) {
+            const result = this.performTest(expected, this.actual, source);
+            return this.out.call(result, parameter);
+        }
+        if (!source.is.missing) {
+            const actual = argument.toString();
+            this.actual = new FrameString(actual);
+        }
+        return argument;
+    }
+    performTest(expected, actual, source) {
+        const result = this.assertEqual(expected.toString(), actual.toString(), source.toString());
+        this.set(HCEval.SOURCE, Frame.missing);
+        this.set(HCEval.EXPECT, Frame.missing);
+        this.actual = Frame.missing;
+        return result;
+    }
+    assertEqual(expected, actual, source) {
+        const base = source + ' +' + expected;
+        this.n.total += 1;
+        if (expected === actual) {
+            this.n.pass += 1;
+            return FrameNote.pass(base, JSON.stringify(this.n));
+        }
+        else {
+            this.n.fail += 1;
+            return FrameNote.fail(base + ' -' + actual, JSON.stringify(this.n));
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/execute/lex-bytes.js

@@ -0,0 +1,42 @@
+import { Frame, FrameBytes, FrameSymbol } from '../frames.js';
+import { Token } from './lex.js';
+export class LexBytes extends Frame {
+    constructor(count, up) {
+        super();
+        this.count = count;
+        this.source = '';
+        this.body = [];
+        this.is.void = true;
+        this.up = up;
+    }
+    call(argument, _parameter = Frame.nil) {
+        if (argument === FrameSymbol.end()) {
+            return this.finish(argument, false);
+        }
+        const char = argument.toString();
+        const code = char.charCodeAt(0);
+        this.body.push(code);
+        if (this.body.length === this.count) {
+            this.finish(argument, false);
+        }
+        return this;
+    }
+    finish(_argument, _passAlong) {
+        this.exportFrame();
+        return this.up;
+    }
+    exportFrame() {
+        const output = this.makeFrame();
+        const out = this.get(Frame.kOUT);
+        return out.call(output);
+    }
+    makeFrame() {
+        if (this.body.length === 0) {
+            return FrameSymbol.end();
+        }
+        const frame = new FrameBytes(this.body);
+        this.body = [];
+        return new Token(frame);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGV4LWJ5dGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2V4ZWN1dGUvbGV4LWJ5dGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLEVBQUUsVUFBVSxFQUFFLFdBQVcsRUFBWSxNQUFNLGNBQWMsQ0FBQTtBQUN2RSxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sVUFBVSxDQUFBO0FBRWhDLE1BQU0sT0FBTyxRQUFTLFNBQVEsS0FBSztJQUlqQyxZQUE4QixLQUFhLEVBQUUsRUFBUztRQUNwRCxLQUFLLEVBQUUsQ0FBQTtRQURxQixVQUFLLEdBQUwsS0FBSyxDQUFRO1FBSHBDLFdBQU0sR0FBVyxFQUFFLENBQUE7UUFLeEIsSUFBSSxDQUFDLElBQUksR0FBRyxFQUFFLENBQUE7UUFDZCxJQUFJLENBQUMsRUFBRSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUE7UUFDbkIsSUFBSSxDQUFDLEVBQUUsR0FBRyxFQUFFLENBQUE7SUFDZCxDQUFDO0lBRU0sSUFBSSxDQUFFLFFBQWUsRUFBRSxVQUFVLEdBQUcsS0FBSyxDQUFDLEdBQUc7UUFDbEQsSUFBSSxRQUFRLEtBQUssV0FBVyxDQUFDLEdBQUcsRUFBRSxFQUFFO1lBQ2xDLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxRQUFRLEVBQUUsS0FBSyxDQUFDLENBQUE7U0FDcEM7UUFDRCxNQUFNLElBQUksR0FBRyxRQUFRLENBQUMsUUFBUSxFQUFFLENBQUE7UUFDaEMsTUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUMsQ0FBQTtRQUMvQixJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQTtRQUNwQixJQUFJLElBQUksQ0FBQyxJQUFJLENBQUMsTUFBTSxLQUFLLElBQUksQ0FBQyxLQUFLLEVBQUU7WUFDbkMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxRQUFRLEVBQUUsS0FBSyxDQUFDLENBQUE7U0FDN0I7UUFDRCxPQUFPLElBQUksQ0FBQTtJQUNiLENBQUM7SUFFUyxNQUFNLENBQUUsU0FBZ0IsRUFBRSxVQUFtQjtRQUNyRCxJQUFJLENBQUMsV0FBVyxFQUFFLENBQUE7UUFDbEIsT0FBTyxJQUFJLENBQUMsRUFBRSxDQUFBO0lBQ2hCLENBQUM7SUFFUyxXQUFXO1FBQ25CLE1BQU0sTUFBTSxHQUFHLElBQUksQ0FBQyxTQUFTLEVBQUUsQ0FBQTtRQUMvQixNQUFNLEdBQUcsR0FBRyxJQUFJLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQTtRQUNoQyxPQUFPLEdBQUcsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUE7SUFDekIsQ0FBQztJQUVTLFNBQVM7UUFDakIsSUFBSSxJQUFJLENBQUMsSUFBSSxDQUFDLE1BQU0sS0FBSyxDQUFDLEVBQUU7WUFDMUIsT0FBTyxXQUFXLENBQUMsR0FBRyxFQUFFLENBQUE7U0FDekI7UUFDRCxNQUFNLEtBQUssR0FBRyxJQUFJLFVBQVUsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUE7UUFDdkMsSUFBSSxDQUFDLElBQUksR0FBRyxFQUFFLENBQUE7UUFDZCxPQUFPLElBQUksS0FBSyxDQUFDLEtBQUssQ0FBQyxDQUFBO0lBQ3pCLENBQUM7Q0FDRiJ9

package/lib/src/execute/lex-pipe.js

@@ -0,0 +1,56 @@
+import { Frame, FrameString, FrameSymbol } from '../frames.js';
+import { getSyntax } from './syntax.js';
+export class LexPipe extends Frame {
+    constructor(out) {
+        const syntax = getSyntax();
+        syntax[Frame.kOUT] = out;
+        super(syntax);
+        this.level = 0;
+    }
+    lex_string(input) {
+        const source = new FrameString(input);
+        return this.lex(source);
+    }
+    lex(source) {
+        return source.reduce(this);
+    }
+    finish(_parameter) {
+        const output = FrameSymbol.end();
+        const out = this.get(Frame.kOUT);
+        out.call(output);
+        return this;
+    }
+    perform(action) {
+        const parser = this.get(Frame.kOUT);
+        for (const [key, value] of Object.entries(action)) {
+            switch (key) {
+                case 'semi-next': {
+                    parser.next(true);
+                    break;
+                }
+                case 'next': {
+                    parser.next(false);
+                    break;
+                }
+                case 'end': {
+                    parser.finish(value);
+                    break;
+                }
+                case 'push': {
+                    const next_parser = parser.push(value);
+                    this.set(Frame.kOUT, next_parser);
+                    this.level += 1;
+                    break;
+                }
+                case 'pop': {
+                    const next_parser = parser.pop(value);
+                    this.set(Frame.kOUT, next_parser);
+                    this.level -= 1;
+                    break;
+                }
+            }
+        }
+        return this;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/execute/lex.js

@@ -0,0 +1,110 @@
+import { Frame, FrameAtom, FrameBytes, FrameComment, FrameQuote, NilContext } from '../frames.js';
+import { LexBytes } from './lex-bytes.js';
+import { LexPipe } from './lex-pipe.js';
+import { terminals } from './terminals.js';
+export class Token extends FrameAtom {
+    constructor(data) {
+        super(NilContext);
+        this.data = data;
+    }
+    called_by(callee, parameter) {
+        return callee.apply(this.data, parameter);
+    }
+    toData() {
+        return this.data;
+    }
+    inspect() {
+        return `Token[${this.data.inspect()}]`;
+    }
+}
+export class Lex extends Frame {
+    static isTerminal(char) {
+        const terms = Object.keys(terminals);
+        return terms.includes(char);
+    }
+    constructor(Factory) {
+        super();
+        this.Factory = Factory;
+        this.pipe = new LexPipe(this);
+        this.body = '';
+        this.sample = new Factory('');
+        this.source = '';
+        this.is.void = true;
+        const name = this.sample.className();
+        this.id = this.id + '.' + name;
+    }
+    // TODO: use terminal to determine next parsing class
+    // Right now, FrameSpace/FrameNumber consume the initial '#' of a comment
+    // That should only happen at the end of a Quote
+    call(argument, _parameter = Frame.nil) {
+        const char = argument.toString();
+        const end = this.isEnd(char);
+        const terminal = Lex.isTerminal(char);
+        const not_quote = !this.isQuote();
+        if (end && terminal) { // ends token on a terminal
+            return this.finish(argument, true);
+        }
+        if (end) { // ends token, but not on a terminal
+            const use_arg_for_next_token = not_quote && !this.isComment();
+            const result = this.finish(argument, use_arg_for_next_token);
+            return result;
+        }
+        if (terminal && not_quote) { // unquoted terminal implicitly ends token
+            return this.finish(argument, true);
+        }
+        // otherwise, add to body since still in interior
+        // including quoted terminals
+        if (this.body === '') {
+            this.body = this.source;
+        }
+        this.body = this.body + argument.toString();
+        return this;
+    }
+    toString() {
+        return this.id + `[${this.body}]`;
+    }
+    isEnd(char) {
+        return !this.sample.canInclude(char);
+    }
+    isComment() {
+        return (this.sample instanceof FrameComment);
+    }
+    isQuote() {
+        return (this.sample instanceof FrameQuote);
+    }
+    finish(argument, passAlong) {
+        const recurse = this.checkRecursive(argument);
+        if (recurse !== null) {
+            return recurse;
+        }
+        this.exportFrame();
+        if (passAlong) {
+            const result = this.up.call(argument);
+            return result;
+        }
+        return this.up;
+    }
+    checkRecursive(_argument) {
+        if (!(this.sample instanceof FrameBytes)) {
+            return null;
+        }
+        const n = parseInt(this.body, 10);
+        const lex = new LexBytes(n, this.up);
+        return lex;
+    }
+    exportFrame() {
+        const output = this.makeFrame();
+        const out = this.get(Frame.kOUT);
+        const result = out.call(output);
+        return result;
+    }
+    makeFrame() {
+        if (this.body === '') {
+            this.body = this.source;
+        }
+        const frame = new this.Factory(this.body);
+        this.body = '';
+        return new Token(frame);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/execute/lexer.js

@@ -0,0 +1,24 @@
+import { Frame, FrameString } from '../frames.js';
+import { getSyntax } from './syntax.js';
+export class Lexer extends Frame {
+    constructor(out) {
+        const syntax = getSyntax();
+        syntax[Lexer.kOUT] = out;
+        super(syntax);
+    }
+    lex_string(input) {
+        const source = new FrameString(input);
+        return this.lex(source);
+    }
+    lex(source) {
+        return source.reduce(this);
+    }
+    fold(argument) {
+        const out = this.get(Frame.kOUT);
+        this.set(Frame.kOUT, out.call(argument));
+    }
+    finish(_options) {
+        return Frame.nil;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGV4ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZXhlY3V0ZS9sZXhlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLGNBQWMsQ0FBQTtBQUNqRCxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sYUFBYSxDQUFBO0FBSXZDLE1BQU0sT0FBTyxLQUFNLFNBQVEsS0FBSztJQUM5QixZQUFhLEdBQVU7UUFDckIsTUFBTSxNQUFNLEdBQUcsU0FBUyxFQUFFLENBQUE7UUFDMUIsTUFBTSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsR0FBRyxHQUFHLENBQUE7UUFDeEIsS0FBSyxDQUFDLE1BQU0sQ0FBQyxDQUFBO0lBQ2YsQ0FBQztJQUVNLFVBQVUsQ0FBRSxLQUFhO1FBQzlCLE1BQU0sTUFBTSxHQUFHLElBQUksV0FBVyxDQUFDLEtBQUssQ0FBQyxDQUFBO1FBQ3JDLE9BQU8sSUFBSSxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsQ0FBQTtJQUN6QixDQUFDO0lBRU0sR0FBRyxDQUFFLE1BQW1CO1FBQzdCLE9BQU8sTUFBTSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQTtJQUM1QixDQUFDO0lBRU0sSUFBSSxDQUFFLFFBQWU7UUFDMUIsTUFBTSxHQUFHLEdBQUcsSUFBSSxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUE7UUFDaEMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsSUFBSSxFQUFFLEdBQUcsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQTtJQUMxQyxDQUFDO0lBRU0sTUFBTSxDQUFFLFFBQW9CO1FBQ2pDLE9BQU8sS0FBSyxDQUFDLEdBQUcsQ0FBQTtJQUNsQixDQUFDO0NBQ0YifQ==