pyret-npm 0.1.22 → 0.1.24

package/README.md

@@ -1,9 +1,5 @@
 NPM package for a command line interface of the Pyret programming language.
 
-The package ships a prebuilt compiler. `build.sh` builds `lang/` from this
-repository and stages `build/phaseA` into `pyret-lang/`, which is where
-`pyret.js` loads it from.
-
 After installing the package, you can run
 
 ```
@@ -12,19 +8,3 @@ $ pyret --help
 
 to get started.
 
-## Compiler backends
-
-The CLI can run on either the stock Pyret-hosted compiler (the default) or
-the TypeScript port of the compiler (`pyret-lang/src/ts-compiler`) — the CLI
-analogue of code.pyret.org's `?compiler=ts` flag:
-
-```
-$ pyret --backend ts my-program.arr      # or: PYRET_COMPILER=ts pyret my-program.arr
-```
-
-Each backend keeps its own Parley compile server (separate sockets), so both
-can be used side by side. An explicit `--compiler <path>` overrides
-`--backend`. The ts backend is available when the package was built with
-`PYRET_NPM_TS=1 npm run build` (which additionally runs `make ts-compiler`
-in `../lang` and packages its build output); the default build ships only
-the stock compiler, and default behavior is unchanged.

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "pyret-npm",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "description": "The CLI for the Pyret programming language",
   "files": [
     "pyret.js",
     "client-lib.js",
     "pyret-lang/build/phaseA/*",
-    "pyret-lang/build/ts-compiler/*"
+    "pyret-lang/build/ts-compiler/*",
+    "pyret-lang/src/js/base/*",
+    "pyret-lang/lib/jglr/*"
   ],
   "dependencies": {
     "ascii-table": "^0.0.9",
@@ -15,6 +17,7 @@
     "command-line-usage": "^5.0.5",
     "mkdirp": "^0.5.1",
     "resolve": "^1.22.10",
+    "source-map": "^0.5.7",
     "strip-ansi": "^4.0.0",
     "vega": "^6.1.2",
     "ws": "^5.2.1"

package/pyret-lang/lib/jglr/cyclicJSON.js

@@ -0,0 +1,174 @@
+define("jglr/cyclicJSON", [], function() {
+/*
+  cycle.js
+  2013-02-19
+
+  Public Domain.
+
+  NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
+
+  This code should be minified before deployment.
+  See http://javascript.crockford.com/jsmin.html
+
+  USE YOUR OWN COPY. IT IS EXTREMELY UNWISE TO LOAD CODE FROM SERVERS YOU DO
+  NOT CONTROL.
+*/
+
+/*jslint evil: true, regexp: true */
+
+/*members $ref, apply, call, decycle, hasOwnProperty, length, prototype, push,
+  retrocycle, stringify, test, toString
+*/
+//////////////////////////////////
+if (typeof JSON.decycle !== 'function') {
+  JSON.decycle = function decycle(object) {
+    'use strict';
+
+    // Make a deep copy of an object or array, assuring that there is at most
+    // one instance of each object or array in the resulting structure. The
+    // duplicate references (which might be forming cycles) are replaced with
+    // an object of the form
+    //      {$ref: PATH}
+    // where the PATH is a JSONPath string that locates the first occurance.
+    // So,
+    //      var a = [];
+    //      a[0] = a;
+    //      return JSON.stringify(JSON.decycle(a));
+    // produces the string '[{"$ref":"$"}]'.
+
+    // JSONPath is used to locate the unique object. $ indicates the top level of
+    // the object or array. [NUMBER] or [STRING] indicates a child member or
+    // property.
+    
+    var objects = [],   // Keep a reference to each unique object or array
+    paths = [];     // Keep the path to each unique object or array
+    
+    return (function derez(value, path) {
+      
+      // The derez recurses through the object, producing the deep copy.
+      
+      var i,          // The loop counter
+      name,       // Property name
+      nu;         // The new object or array
+      
+      // typeof null === 'object', so go on if this value is really an object but not
+      // one of the weird builtin objects.
+
+      if (typeof value === 'object' && value !== null &&
+          !(value instanceof Boolean) &&
+          !(value instanceof Date)    &&
+          !(value instanceof Number)  &&
+          !(value instanceof RegExp)  &&
+          !(value instanceof String)) {
+
+        // If the value is an object or array, look to see if we have already
+        // encountered it. If so, return a $ref/path object. This is a hard way,
+        // linear search that will get slower as the number of unique objects grows.
+
+        for (i = 0; i < objects.length; i += 1) {
+          if (objects[i] === value) {
+            return {$ref: paths[i]};
+          }
+        }
+
+        // Otherwise, accumulate the unique value and its path.
+
+        objects.push(value);
+        paths.push(path);
+
+        // If it is an array, replicate the array.
+
+        if (Object.prototype.toString.apply(value) === '[object Array]') {
+          nu = [];
+          for (i = 0; i < value.length; i += 1) {
+            nu[i] = derez(value[i], path + '[' + i + ']');
+          }
+        } else {
+
+          // If it is an object, replicate the object.
+
+          nu = {};
+          for (name in value) {
+            if (Object.prototype.hasOwnProperty.call(value, name)) {
+              nu[name] = derez(value[name],
+                               path + '[' + JSON.stringify(name) + ']');
+            }
+          }
+        }
+        return nu;
+      }
+      return value;
+    }(object, '$'));
+  };
+}
+
+
+if (typeof JSON.retrocycle !== 'function') {
+  JSON.retrocycle = function retrocycle($) {
+    'use strict';
+
+    // Restore an object that was reduced by decycle. Members whose values are
+    // objects of the form
+    //      {$ref: PATH}
+    // are replaced with references to the value found by the PATH. This will
+    // restore cycles. The object will be mutated.
+
+    // The eval function is used to locate the values described by a PATH. The
+    // root object is kept in a $ variable. A regular expression is used to
+    // assure that the PATH is extremely well formed. The regexp contains nested
+    // * quantifiers. That has been known to have extremely bad performance
+    // problems on some browsers for very long strings. A PATH is expected to be
+    // reasonably short. A PATH is allowed to belong to a very restricted subset of
+    // Goessner's JSONPath.
+
+    // So,
+    //      var s = '[{"$ref":"$"}]';
+    //      return JSON.retrocycle(JSON.parse(s));
+    // produces an array containing a single element which is the array itself.
+
+    var px =
+      /^\$(?:\[(?:\d+|\"(?:[^\\\"\u0000-\u001f]|\\([\\\"\/bfnrt]|u[0-9a-zA-Z]{4}))*\")\])*$/;
+
+    (function rez(value) {
+
+      // The rez function walks recursively through the object looking for $ref
+      // properties. When it finds one that has a value that is a path, then it
+      // replaces the $ref object with a reference to the value that is found by
+      // the path.
+
+      var i, item, name, path;
+
+      if (value && typeof value === 'object') {
+        if (Object.prototype.toString.apply(value) === '[object Array]') {
+          for (i = 0; i < value.length; i += 1) {
+            item = value[i];
+            if (item && typeof item === 'object') {
+              path = item.$ref;
+              if (typeof path === 'string' && px.test(path)) {
+                value[i] = eval(path);
+              } else {
+                rez(item);
+              }
+            }
+          }
+        } else {
+          for (name in value) {
+            if (typeof value[name] === 'object') {
+              item = value[name];
+              if (item) {
+                path = item.$ref;
+                if (typeof path === 'string' && px.test(path)) {
+                  value[name] = eval(path);
+                } else {
+                  rez(item);
+                }
+              }
+            }
+          }
+        }
+      }
+    }($));
+    return $;
+  };
+}
+});

package/pyret-lang/lib/jglr/jglr.js

@@ -0,0 +1,341 @@
+define("jglr/jglr", ["jglr/rnglr"], function(E) {
+  const SrcLoc = E.SrcLoc
+  const NS_PER_SEC = 1e9;
+  var start;
+  function startTimer() {
+    if (typeof window !== "undefined" && window.performance) {
+      start = window.performance.now();
+    } else if (typeof process !== "undefined" && process.hrtime) {
+      start = process.hrtime();
+    }
+  }
+  function endTimer() {
+    if (typeof window !== "undefined" && window.performance) {
+      return window.performance.now() - start;
+    } else if (typeof process !== "undefined" && process.hrtime) {
+      return process.hrtime(start);
+    }
+  }
+
+  /*! https://mths.be/startswith v0.2.0 by @mathias */
+  if (!String.prototype.startsWith) {
+    (function() {
+      'use strict'; // needed to support `apply`/`call` with `undefined`/`null`
+      var defineProperty = (function() {
+        // IE 8 only supports `Object.defineProperty` on DOM elements
+        try {
+	  var object = {};
+	  var $defineProperty = Object.defineProperty;
+	  var result = $defineProperty(object, object, object) && $defineProperty;
+        } catch(error) {}
+        return result;
+      }());
+      var toString = {}.toString;
+      var startsWith = function(search) {
+        if (this == null) {
+	  throw TypeError();
+        }
+        var string = String(this);
+        if (search && toString.call(search) == '[object RegExp]') {
+	  throw TypeError();
+        }
+        var stringLength = string.length;
+        var searchString = String(search);
+        var searchLength = searchString.length;
+        var position = arguments.length > 1 ? arguments[1] : undefined;
+        // `ToInteger`
+        var pos = position ? Number(position) : 0;
+        if (pos != pos) { // better `isNaN`
+	  pos = 0;
+        }
+        var start = Math.min(Math.max(pos, 0), stringLength);
+        // Avoid the `indexOf` call if no match is possible
+        if (searchLength + start > stringLength) {
+	  return false;
+        }
+        var index = -1;
+        while (++index < searchLength) {
+	  if (string.charCodeAt(start + index) != searchString.charCodeAt(index)) {
+	    return false;
+	  }
+        }
+        return true;
+      };
+      if (defineProperty) {
+        defineProperty(String.prototype, 'startsWith', {
+	  'value': startsWith,
+	  'configurable': true,
+	  'writable': true
+        });
+      } else {
+        String.prototype.startsWith = startsWith;
+      }
+    }());
+  }
+
+
+
+
+  //////////////////////////////////////////////////
+  ///////////////////////// Old Tokenizer
+  //////////////////////////////////////////////////
+
+  var Tokenizer = (function() {
+    function Tokenizer(ignore_ws, Tokens) {
+      this.ignore_ws = ignore_ws;
+      this.Tokens = Tokens;
+    }
+    Tokenizer.prototype.isEOF = function(tok) { return tok === E.EOF; }
+    Tokenizer.prototype.tokenizeFrom = function(str) {
+      this.str = str;
+      this.curLine = 1;
+      this.curCol = 0;
+      this.pos = 0;
+      this.len = str.length;
+      delete this.curTok;
+      delete E.EOF.pos;
+      SrcLoc.reset();
+      this.times = {};
+    }
+    const STICKY_REGEXP = ''; //(function() { try { new RegExp("", 'y'); return 'y' } catch(e) { return ''; }})();
+
+    Tokenizer.prototype.hasNext = function() { return this.pos <= this.len; }
+    Tokenizer.prototype.isEmpty = function() { return this.length == 0; }
+    if (STICKY_REGEXP === 'y') {
+      Tokenizer.prototype.positionTokenRegexp = function(tok) { tok.val.lastIndex = this.pos; };
+      Tokenizer.prototype.updateString = function(match) { };
+      Tokenizer.prototype.updatePosition = function(tok, match) { this.pos = tok.val.lastIndex; };
+    } else {
+      Tokenizer.prototype.positionTokenRegexp = function(tok) { };
+      Tokenizer.prototype.updateString = function(match) { this.str = this.str.slice(match[0].length); };
+      Tokenizer.prototype.updatePosition = function(tok, match) { this.pos += match[0].length; };
+    }
+    Tokenizer.prototype.makeToken = function (tok_type, s, pos) { 
+      var t = new E.Token(tok_type, s);
+      t.pos = pos;
+      return t;
+    }
+    Tokenizer.prototype.postProcessMatch = function(tok, match, str) { return tok.name; }
+    Tokenizer.prototype.unshiftToken = function(prev_tok) { this.curTok = prev_tok; }
+    Tokenizer.prototype.next = function() {
+      delete this.skippedWhitespace;
+      startTimer();
+      while (this.hasNext()) { // Surround the tokenizer loop...
+        if (this.pos == this.len) { 
+          this.pos++; 
+          E.EOF.pos = SrcLoc.make(this.curLine, this.curCol, this.pos, this.curLine, this.curCol, this.pos);
+          this.curTok = E.EOF;
+          return E.EOF; 
+        }
+        for (var i = 0; i < this.Tokens.length; i++) {
+          var tok = this.Tokens[i];
+          this.positionTokenRegexp(tok);
+          var match = tok.val.exec(this.str);
+          if (match !== null) {
+            var tok_type = this.postProcessMatch(tok, match, this.str);
+            this.updateString(match);
+            var p = this.pos;
+            var l = this.curLine;
+            var c = this.curCol;
+            var s = match[0];
+            var lines = s.split("\n").length - 1; // From jsPerf, this is UNBELIEVABLY much faster than the prior implementation
+            this.updatePosition(tok, match);
+            this.curLine += lines;
+            if (lines === 0)
+              this.curCol += s.length;
+            else
+              this.curCol = s.length - s.lastIndexOf("\n") - 1;
+            if (this.ignore_ws && (tok_type === "WS" || tok_type === "COMMENT")) {
+              // ... in case we're ignoring whitespace
+              var endT = endTimer();
+              if (this.times[tok_type] === undefined) this.times[tok_type] = [];
+              this.times[tok_type].push((endT[0] * NS_PER_SEC + endT[1]) / NS_PER_SEC);
+              var newWS = SrcLoc.make(l, c, p, this.curLine, this.curCol, this.pos);
+              if (this.skippedWhitespace === undefined)
+                this.skippedWhitespace = newWS;
+              else
+                this.skippedWhitespace = this.skippedWhitespace.combine(newWS);
+              break;
+            }
+            var t = this.makeToken(tok_type, s, SrcLoc.make(l, c, p, this.curLine, this.curCol, this.pos));
+            this.curTok = t;
+            var endT = endTimer();
+            if (this.times[this.curTok.name] === undefined) this.times[this.curTok.name] = [];
+            this.times[this.curTok.name].push((endT[0] * NS_PER_SEC + endT[1]) / NS_PER_SEC);
+            return t;
+          }
+        }
+      }
+    }
+
+    return Tokenizer;
+  })();
+
+  //////////////////////////////////////////////////
+  ///////////////////////// New Tokenizer
+  //////////////////////////////////////////////////
+  
+  var Tokenizer2 = (function() {
+    const ws = new RegExp("\\s+", "g");
+
+    function merge(dest, src) {
+      for (var first in src) {
+        var cur = dest[first];
+        if (cur === undefined)
+          cur = dest[first] = [];
+        var ext = src[first];
+        for (var i = 0; i < ext.length; i++) {
+          cur.push(ext[i]);
+        }
+      }
+    }
+    
+    function Tokenizer(spec) {
+      this.ignore = spec.ignore;
+
+      this.whitespace = spec.whitespace;
+      this.keywords = Object.create(null);
+      merge(this.keywords, spec.symbols);
+      merge(this.keywords, spec.comments);
+      merge(this.keywords, spec.keywords);
+      for (var first in this.keywords) {
+        this.keywords[first].sort(function(a, b) {
+          // sort in descending length, then by which needs priorWhitespace, then alphabetically
+          if (b.val.length === a.val.length) {
+            if (a.needsWs && !b.needsWs) return -1;
+            if (b.needsWs && !a.needsWs) return 1;
+            return (a < b) ? -1 : 0;
+          }
+          return b.val.length - a.val.length;
+        });
+      }
+    }
+    Tokenizer.prototype.tokenizeFrom = function(str) {
+      if (typeof str.normalize === "function")
+        this.str = str.normalize("NFC");
+      else
+        this.str = str;
+      
+      this.len = str.length; // XXX Not necessarily unicode-aware
+      this.curCol = 0;
+      this.curLine = 1;
+      this.pos = 0;
+      this.priorWhitespace = true;
+      delete this.curTok;
+      delete E.EOF.pos;
+      SrcLoc.reset();
+      this.times = {};
+    }
+    Tokenizer.prototype.isEOF = function(tok) { return tok === E.EOF; }
+    Tokenizer.prototype.isEmpty = function() { return this.length == 0; }
+    Tokenizer.prototype.hasNext = function() { return this.pos <= this.len; }
+    Tokenizer.prototype.unshiftToken = function(prev_tok) { this.curTok = prev_tok; }
+    Tokenizer.prototype.addWhitespace = function(ws_loc) {
+      if (this.skippedWhitespace === undefined)
+        this.skippedWhitespace = ws_loc;
+      else
+        this.skippedWhitespace = this.skippedWhitespace.combine(ws_loc);
+    }
+    Tokenizer.prototype.next = function() {
+      delete this.skippedWhitespace;
+      this.curTok = undefined;
+      var startT = startTimer();
+      while (this.curTok === undefined && this.hasNext()) {
+        if (this.pos == this.len) { 
+          this.pos++;
+          this.curCol++;
+          E.EOF.pos = SrcLoc.make(this.curLine, this.curCol, this.pos, this.curLine, this.curCol, this.pos);
+          this.curTok = E.EOF;
+          return E.EOF; 
+        }
+        var c = this.str[this.pos];  // XXX not unicode aware
+        var candidates = this.keywords[c];
+        var line = this.curLine, col = this.curCol, pos = this.pos;
+        if (candidates) {
+          for (var i = 0; i < candidates.length; i++) {
+            var candidate = candidates[i];
+            if (this.str.startsWith(candidate.val, this.pos)) {
+              if (candidate.process) {
+                this.curTok = candidate.process.call(this, candidate);
+                if (this.curTok) break;
+              } else {
+                var noFollow = candidate.noFollow;
+                var mustFollow = candidate.mustFollow;
+                var match = false;
+                if (candidate.needsWs && !this.priorWhitespace) {
+                  match = false;
+                } else if (!noFollow && !mustFollow) {
+                  match = true;
+                } else if (noFollow && !noFollow.has(this.str[this.pos + candidate.val.length])) {
+                  match = true;
+                } else if (mustFollow && mustFollow.has(this.str[this.pos + candidate.val.length])) {
+                  match = true;
+                }
+                if (match) {
+                  this.curCol += candidate.val.length;
+                  this.pos += candidate.val.length;
+                  var t = this.makeToken(candidate.name, candidate.val,
+                                         SrcLoc.make(line, col, pos, this.curLine, this.curCol, this.pos),
+                                         candidate);
+                  this.priorWhitespace = false;
+                  this.curTok = t;
+                  break;
+                }
+              }
+            }
+          }
+        }
+        // Handle whitespace
+        if (this.curTok === undefined && this.whitespace[c]) {
+          this.priorWhitespace = true;
+          while (this.whitespace[c]) {
+            this.pos++;
+            this.curCol++;
+            if (c === "\n") {
+              this.curLine++;
+              this.curCol = 0;
+            }
+            c = this.str[this.pos];  // XXX not unicode aware
+          }
+          this.curTok = this.makeWSToken(line, col, pos);
+        }
+        if (this.curTok === undefined) {
+          // FAILOVER
+          var t = this.makeToken("UNKNOWN", this.str[this.pos],
+                                 SrcLoc.make(line, col, pos, line, col + 1, pos + 1));
+          this.curCol++;
+          this.pos++;
+          this.curTok = t;
+        }
+
+        if (this.ignore.has(this.curTok.name)) {
+          var endT = endTimer();
+          if (this.times[this.curTok.name] === undefined) this.times[this.curTok.name] = [];
+          this.times[this.curTok.name].push((endT[0] * NS_PER_SEC + endT[1]) / NS_PER_SEC);
+          this.curTok = undefined;
+        }
+      }
+      var endT = endTimer();
+      if (this.times[this.curTok.name] === undefined) this.times[this.curTok.name] = [];
+      this.times[this.curTok.name].push((endT[0] * NS_PER_SEC + endT[1]) / NS_PER_SEC);
+      return this.curTok;
+    }
+
+    return Tokenizer;
+  })();
+
+  return {
+    'Tokenizer': Tokenizer,
+    'Tokenizer2': Tokenizer2,
+    'STICKY_REGEXP': '',
+    'Atom': E.Atom,
+    'Nonterm': E.Nonterm,
+    'Token': E.Token,
+    'Rule': E.Rule,
+    'Grammar': E.Grammar,
+    'SetOfSets': E.SetOfSets,
+    'EOF': E.EOF,
+    'EPSILON': E.EPSILON,
+    'SrcLoc': E.SrcLoc
+  };
+});