parser.js

/*!
 Based on ndef.parser, by Raphael Graf(r@undefined.ch)
 http://www.undefined.ch/mparser/index.html

 Ported to JavaScript and modified by Matthew Crumley (email@matthewcrumley.com, http://silentmatt.com/)

 You are free to use and modify this code in anyway you find useful. Please leave this comment in the code
 to acknowledge its original source. If you feel like it, I enjoy hearing about projects that use my code,
 but don't feel like you have to let me know or ask permission.
*/

var Parser = (function (scope) { // eslint-disable-line no-unused-vars
  //  Added by stlsmiths 6/13/2011
  //  re-define Array.indexOf, because IE doesn't know it ...
  function indexOf(array, obj, start) {
    for (var i = (start || 0); i < array.length; i++) {
      if (array[i] === obj) {
        return i;
      }
    }
    return -1;
  }

  function object(o) {
    function F() {}
    F.prototype = o;
    return new F();
  }

  var INUMBER = 'INUMBER';
  var IOP1 = 'IOP1';
  var IOP2 = 'IOP2';
  var IVAR = 'IVAR';
  var IFUNCALL = 'IFUNCALL';

  function Instruction(type, value) {
    this.type = type;
    this.value = (value !== undefined && value !== null) ? value : 0;
  }

  Instruction.prototype.toString = function () {
    switch (this.type) {
      case INUMBER:
      case IOP1:
      case IOP2:
      case IVAR:
        return this.value;
      case IFUNCALL:
        return 'CALL';
      default:
        return 'Invalid Instruction';
    }
  };

  function Expression(tokens, ops1, ops2, functions) {
    this.tokens = tokens;
    this.ops1 = ops1;
    this.ops2 = ops2;
    this.functions = functions;
  }

  // Based on http://www.json.org/json2.js
  var escapable = /[\\'\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g; // eslint-disable-line no-control-regex
  var meta = {    // table of character substitutions
    '\b': '\\b',
    '\t': '\\t',
    '\n': '\\n',
    '\f': '\\f',
    '\r': '\\r',
    '\'': '\\\'',
    '\\': '\\\\'
  };

  function escapeValue(v) {
    if (typeof v === 'string') {
      escapable.lastIndex = 0;
      if (escapable.test(v)) {
        return '\'' + v.replace(escapable, function (a) {
          var c = meta[a];
          return typeof c === 'string' ? c : '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
        }) + '\'';
      } else {
        return '\'' + v + '\'';
      }
    }
    return v;
  }

  function hasValue(values, index) {
    var parts = index.split(/\./);
    var value = values;
    var part;
    while ((part = parts.shift())) {
      if (!(part in value)) {
        return false;
      }
      value = value[part];
    }
    return true;
  }

  function getValue(values, index) {
    var parts = index.split(/\./);
    var value = values;
    var part;
    while ((part = parts.shift())) {
      value = value[part];
    }
    return value;
  }

  Expression.prototype = {
    simplify: function (values) {
      values = values || {};
      var nstack = [];
      var newexpression = [];
      var n1;
      var n2;
      var f;
      var L = this.tokens.length;
      var item;
      var i = 0;
      for (i = 0; i < L; i++) {
        item = this.tokens[i];
        var type = item.type;
        if (type === INUMBER) {
          nstack.push(item);
        } else if (type === IVAR && hasValue(values, item.value)) {
          item = new Instruction(INUMBER, getValue(values, item.value));
          nstack.push(item);
        } else if (type === IOP2 && nstack.length > 1) {
          n2 = nstack.pop();
          n1 = nstack.pop();
          f = this.ops2[item.value];
          item = new Instruction(INUMBER, f(n1.value, n2.value));
          nstack.push(item);
        } else if (type === IOP1 && nstack.length > 0) {
          n1 = nstack.pop();
          f = this.ops1[item.value];
          item = new Instruction(INUMBER, f(n1.value));
          nstack.push(item);
        } else {
          while (nstack.length > 0) {
            newexpression.push(nstack.shift());
          }
          newexpression.push(item);
        }
      }
      while (nstack.length > 0) {
        newexpression.push(nstack.shift());
      }

      return new Expression(newexpression, object(this.ops1), object(this.ops2), object(this.functions));
    },

    substitute: function (variable, expr) {
      if (!(expr instanceof Expression)) {
        expr = new Parser().parse(String(expr));
      }
      var newexpression = [];
      var L = this.tokens.length;
      var item;
      var i = 0;
      for (i = 0; i < L; i++) {
        item = this.tokens[i];
        var type = item.type;
        if (type === IVAR && item.value === variable) {
          for (var j = 0; j < expr.tokens.length; j++) {
            var expritem = expr.tokens[j];
            var replitem = new Instruction(expritem.type, expritem.value);
            newexpression.push(replitem);
          }
        } else {
          newexpression.push(item);
        }
      }

      var ret = new Expression(newexpression, object(this.ops1), object(this.ops2), object(this.functions));
      return ret;
    },

    evaluate: function (values) {
      values = values || {};
      var nstack = [];
      var n1;
      var n2;
      var f;
      var L = this.tokens.length;
      var item;
      var i = 0;
      for (i = 0; i < L; i++) {
        item = this.tokens[i];
        var type = item.type;
        if (type === INUMBER) {
          nstack.push(item.value);
        } else if (type === IOP2) {
          n2 = nstack.pop();
          n1 = nstack.pop();
          f = this.ops2[item.value];
          nstack.push(f(n1, n2));
        } else if (type === IVAR) {
          if (hasValue(values, item.value)) {
            nstack.push(getValue(values, item.value));
          } else if (hasValue(this.functions, item.value)) {
            nstack.push(getValue(this.functions, item.value));
          } else {
            throw new Error('undefined variable: ' + item.value);
          }
        } else if (type === IOP1) {
          n1 = nstack.pop();
          f = this.ops1[item.value];
          nstack.push(f(n1));
        } else if (type === IFUNCALL) {
          n1 = nstack.pop();
          f = nstack.pop();
          if (f.apply && f.call) {
            if (Object.prototype.toString.call(n1) === '[object Array]') {
              nstack.push(f.apply(undefined, n1));
            } else {
              nstack.push(f(n1));
            }
          } else {
            throw new Error(f + ' is not a function');
          }
        } else {
          throw new Error('invalid Expression');
        }
      }
      if (nstack.length > 1) {
        throw new Error('invalid Expression (parity)');
      }
      return nstack[0];
    },

    toString: function (toJS) {
      var nstack = [];
      var n1;
      var n2;
      var f;
      var L = this.tokens.length;
      var item;
      var i = 0;
      for (i = 0; i < L; i++) {
        item = this.tokens[i];
        var type = item.type;
        if (type === INUMBER) {
          nstack.push(escapeValue(item.value));
        } else if (type === IOP2) {
          n2 = nstack.pop();
          n1 = nstack.pop();
          f = item.value;
          if (toJS && f === '^') {
            nstack.push('Math.pow(' + n1 + ',' + n2 + ')');
          } else {
            nstack.push('(' + n1 + f + n2 + ')');
          }
        } else if (type === IVAR) {
          nstack.push(item.value);
        } else if (type === IOP1) {
          n1 = nstack.pop();
          f = item.value;
          if (f === '-') {
            nstack.push('(' + f + n1 + ')');
          } else {
            nstack.push(f + '(' + n1 + ')');
          }
        } else if (type === IFUNCALL) {
          n1 = nstack.pop();
          f = nstack.pop();
          nstack.push(f + '(' + n1 + ')');
        } else {
          throw new Error('invalid Expression');
        }
      }
      if (nstack.length > 1) {
        throw new Error('invalid Expression (parity)');
      }
      return nstack[0];
    },

    variables: function () {
      var L = this.tokens.length;
      var vars = [];
      for (var i = 0; i < L; i++) {
        var item = this.tokens[i];
        if (item.type === IVAR && (indexOf(vars, item.value) === -1)) {
          vars.push(item.value);
        }
      }

      return vars;
    },

    toJSFunction: function (param, variables) {
      var f = new Function(param, 'with(Parser.values) { return ' + this.simplify(variables).toString(true) + '; }'); // eslint-disable-line no-new-func
      return f;
    }
  };

  function add(a, b) {
    return Number(a) + Number(b);
  }
  function sub(a, b) {
    return a - b;
  }
  function mul(a, b) {
    return a * b;
  }
  function div(a, b) {
    return a / b;
  }
  function mod(a, b) {
    return a % b;
  }
  function concat(a, b) {
    return '' + a + b;
  }
  function equal(a, b) {
    return a === b;
  }
  function notEqual(a, b) {
    return a !== b;
  }
  function greaterThan(a, b) {
    return a > b;
  }
  function lessThan(a, b) {
    return a < b;
  }
  function greaterThanEqual(a, b) {
    return a >= b;
  }
  function lessThanEqual(a, b) {
    return a <= b;
  }
  function andOperator(a, b) {
    return Boolean(a && b);
  }
  function orOperator(a, b) {
    return Boolean(a || b);
  }
  function sinh(a) {
    return Math.sinh ? Math.sinh(a) : ((Math.exp(a) - Math.exp(-a)) / 2);
  }
  function cosh(a) {
    return Math.cosh ? Math.cosh(a) : ((Math.exp(a) + Math.exp(-a)) / 2);
  }
  function tanh(a) {
    if (Math.tanh) return Math.tanh(a);
    if (a === Infinity) return 1;
    if (a === -Infinity) return -1;
    return (Math.exp(a) - Math.exp(-a)) / (Math.exp(a) + Math.exp(-a));
  }
  function asinh(a) {
    if (Math.asinh) return Math.asinh(a);
    if (a === -Infinity) return a;
    return Math.log(a + Math.sqrt(a * a + 1));
  }
  function acosh(a) {
    return Math.acosh ? Math.acosh(a) : Math.log(a + Math.sqrt(a * a - 1));
  }
  function atanh(a) {
    return Math.atanh ? Math.atanh(a) : (Math.log((1 + a) / (1 - a)) / 2);
  }
  function log10(a) {
    return Math.log(a) * Math.LOG10E;
  }
  function neg(a) {
    return -a;
  }
  function not(a) {
    return !a;
  }
  function trunc(a) {
    if (Math.trunc) {
      return Math.trunc(a);
    } else {
      return a < 0 ? Math.ceil(a) : Math.floor(a);
    }
  }
  function random(a) {
    return Math.random() * (a || 1);
  }
  function fac(a) { // a!
    a = Math.floor(a);
    var b = a;
    while (a > 1) {
      b = b * (--a);
    }
    return b;
  }

  // TODO: use hypot that doesn't overflow
  function hypot() {
    if (Math.hypot) return Math.hypot.apply(this, arguments);
    var y = 0;
    var length = arguments.length;
    for (var i = 0; i < length; i++) {
      if (arguments[i] === Infinity || arguments[i] === -Infinity) {
        return Infinity;
      }
      y += arguments[i] * arguments[i];
    }
    return Math.sqrt(y);
  }

  function condition(cond, yep, nope) {
    return cond ? yep : nope;
  }

  function append(a, b) {
    if (Object.prototype.toString.call(a) !== '[object Array]') {
      return [a, b];
    }
    a = a.slice();
    a.push(b);
    return a;
  }

  var TEOF = 'TEOF';
  var TOP = 'TOP';
  var TNUMBER = 'TNUMBER';
  var TSTRING = 'TSTRING';
  var TPAREN = 'TPAREN';
  var TCOMMA = 'TCOMMA';
  var TNAME = 'TNAME';

  function Token(type, value, line, column) {
    this.type = type;
    this.value = value;
    this.line = line;
    this.column = column;
  }

  Token.prototype.toString = function () {
    return this.type + ': ' + this.value;
  };

  function TokenStream(expression, ops1, ops2, consts) {
    this.pos = 0;
    this.line = 0;
    this.column = 0;
    this.current = null;
    this.ops1 = ops1;
    this.ops2 = ops2;
    this.consts = consts;
    this.expression = expression;
  }

  TokenStream.prototype.newToken = function (type, value, line, column) {
    return new Token(type, value, line != null ? line : this.line, column != null ? column : this.column);
  };

  TokenStream.prototype.next = function () {
    if (this.pos >= this.expression.length) {
      return this.newToken(TEOF, 'EOF');
    }

    if (this.isWhitespace() || this.isComment()) {
      return this.next();
    } else if (this.isOperator() ||
        this.isNumber() ||
        this.isString() ||
        this.isParen() ||
        this.isComma() ||
        this.isNamedOp() ||
        this.isConst() ||
        this.isName()) {
      return this.current;
    } else {
      this.parseError('Unknown character "' + this.expression.charAt(this.pos) + '"');
    }
  };

  TokenStream.prototype.isString = function () {
    var r = false;
    var str = '';
    var startLine = this.line;
    var startColumn = this.column;

    if (this.pos < this.expression.length && this.expression.charAt(this.pos) === '\'') {
      this.pos++;
      this.column++;
      while (this.pos < this.expression.length) {
        var char = this.expression.charAt(this.pos);
        if (char !== '\'' || str.slice(-1) === '\\') {
          str += char;
          this.pos++;
          this.column++;
          if (char === '\n') {
            this.line++;
            this.column = 0;
          }
        } else {
          this.current = this.newToken(TSTRING, this.unescape(str), startLine, startColumn);
          this.pos++;
          this.column++;
          r = true;
          break;
        }
      }
    }
    return r;
  };

  TokenStream.prototype.isParen = function () {
    var char = this.expression.charAt(this.pos);
    if (char === '(' || char === ')') {
      this.current = this.newToken(TPAREN, char);
      this.pos++;
      this.column++;
      return true;
    }
    return false;
  };

  TokenStream.prototype.isComma = function () {
    var char = this.expression.charAt(this.pos);
    if (char === ',') {
      this.current = this.newToken(TCOMMA, ',');
      this.pos++;
      this.column++;
      return true;
    }
    return false;
  };

  TokenStream.prototype.isConst = function () {
    var str = '';
    for (var i = this.pos; i < this.expression.length; i++) {
      var c = this.expression.charAt(i);
      if (c.toUpperCase() === c.toLowerCase()) {
        if (i === this.pos || (c !== '_' && c !== '.' && (c < '0' || c > '9'))) {
          break;
        }
      }
      str += c;
    }
    if (str.length > 0 && (str in this.consts)) {
      this.current = this.newToken(TNUMBER, this.consts[str]);
      this.pos += str.length;
      this.column += str.length;
      return true;
    }
    return false;
  };

  TokenStream.prototype.isNamedOp = function () {
    var str = '';
    for (var i = this.pos; i < this.expression.length; i++) {
      var c = this.expression.charAt(i);
      if (c.toUpperCase() === c.toLowerCase()) {
        if (i === this.pos || (c !== '_' && (c < '0' || c > '9'))) {
          break;
        }
      }
      str += c;
    }
    if (str.length > 0 && (str in this.ops2 || str in this.ops1)) {
      this.current = this.newToken(TOP, str);
      this.pos += str.length;
      this.column += str.length;
      return true;
    }
    return false;
  };

  TokenStream.prototype.isName = function () {
    var str = '';
    for (var i = this.pos; i < this.expression.length; i++) {
      var c = this.expression.charAt(i);
      if (c.toUpperCase() === c.toLowerCase()) {
        if (i === this.pos || (c !== '_' && c !== '.' && (c < '0' || c > '9'))) {
          break;
        }
      }
      str += c;
    }
    if (str.length > 0) {
      this.current = this.newToken(TNAME, str);
      this.pos += str.length;
      this.column += str.length;
      return true;
    }
    return false;
  };

  TokenStream.prototype.isWhitespace = function () {
    var r = false;
    var char = this.expression.charAt(this.pos);
    while (char === ' ' || char === '\t' || char === '\n' || char === '\r') {
      r = true;
      this.pos++;
      this.column++;
      if (char === '\n') {
        this.line++;
        this.column = 0;
      }
      char = this.expression.charAt(this.pos);
    }
    return r;
  };

  TokenStream.prototype.unescape = function (v) {
    var buffer = [];
    var escaping = false;

    for (var i = 0; i < v.length; i++) {
      var c = v.charAt(i);

      if (escaping) {
        switch (c) {
          case '\'':
            buffer.push('\'');
            break;
          case '\\':
            buffer.push('\\');
            break;
          case '/':
            buffer.push('/');
            break;
          case 'b':
            buffer.push('\b');
            break;
          case 'f':
            buffer.push('\f');
            break;
          case 'n':
            buffer.push('\n');
            break;
          case 'r':
            buffer.push('\r');
            break;
          case 't':
            buffer.push('\t');
            break;
          case 'u':
            // interpret the following 4 characters as the hex of the unicode code point
            var codePoint = parseInt(v.substring(i + 1, i + 5), 16);
            buffer.push(String.fromCharCode(codePoint));
            i += 4;
            break;
          default:
            throw this.parseError('Illegal escape sequence: "\\' + c + '"');
        }
        escaping = false;
      } else {
        if (c === '\\') {
          escaping = true;
        } else {
          buffer.push(c);
        }
      }
    }

    return buffer.join('');
  };

  TokenStream.prototype.isComment = function () {
    var char = this.expression.charAt(this.pos);
    if (char === '/' && this.expression.charAt(this.pos + 1) === '*') {
      var startPos = this.pos;
      this.pos = this.expression.indexOf('*/', this.pos) + 2;
      if (this.pos === 1) {
        this.pos = this.expression.length;
      }
      var comment = this.expression.substring(startPos, this.pos);
      var newline = comment.indexOf('\n');
      while (newline >= 0) {
        this.line++;
        this.column = comment.length - newline;
        newline = comment.indexOf('\n', newline + 1);
      }
      return true;
    }
    return false;
  };

  TokenStream.prototype.isNumber = function () {
    var r = false;
    var str = '';
    while (this.pos < this.expression.length) {
      var char = this.expression.charAt(this.pos);
      if ((char >= '0' && char <= '9') || char === '.') {
        str += this.expression.charAt(this.pos);
        this.pos++;
        this.column++;
        r = true;
      } else {
        break;
      }
    }

    if (r) {
      this.current = this.newToken(TNUMBER, parseFloat(str));
    }
    return r;
  };

  TokenStream.prototype.isOperator = function () {
    var char = this.expression.charAt(this.pos);

    if (char === '+' || char === '-' || char === '*' || char === '/' || char === '%' || char === '^') {
      this.current = this.newToken(TOP, char);
    } else if (char === '∙' || char === '•') {
      this.current = this.newToken(TOP, '*');
    } else if (char === '>') {
      if (this.expression.charAt(this.pos + 1) === '=') {
        this.current = this.newToken(TOP, '>=');
        this.pos++;
        this.column++;
      } else {
        this.current = this.newToken(TOP, '>');
      }
    } else if (char === '<') {
      if (this.expression.charAt(this.pos + 1) === '=') {
        this.current = this.newToken(TOP, '<=');
        this.pos++;
        this.column++;
      } else {
        this.current = this.newToken(TOP, '<');
      }
    } else if (char === '|') {
      if (this.expression.charAt(this.pos + 1) === '|') {
        this.current = this.newToken(TOP, '||');
        this.pos++;
        this.column++;
      } else {
        return false;
      }
    } else if (char === '=') {
      if (this.expression.charAt(this.pos + 1) === '=') {
        this.current = this.newToken(TOP, '==');
        this.pos++;
        this.column++;
      } else {
        return false;
      }
    } else if (char === '!') {
      if (this.expression.charAt(this.pos + 1) === '=') {
        this.current = this.newToken(TOP, '!=');
        this.pos++;
        this.column++;
      } else {
        return false;
      }
    } else if (char === 'a') {
      if (this.expression.charAt(this.pos + 1) === 'n' && this.expression.charAt(this.pos + 2) === 'd') {
        this.current = this.newToken(TOP, 'and');
        this.pos += 2;
        this.column += 2;
      } else {
        return false;
      }
    } else if (char === 'o') {
      if (this.expression.charAt(this.pos + 1) === 'r') {
        this.current = this.newToken(TOP, 'or');
        this.pos++;
        this.column++;
      } else {
        return false;
      }
    } else {
      return false;
    }
    this.pos++;
    this.column++;
    return true;
  };

  TokenStream.prototype.parseError = function (msg) {
    throw new Error('parse error [' + (this.line + 1) + ':' + (this.column + 1) + ']: ' + msg);
  };

  function ParserState(parser, tokenStream) {
    this.parser = parser;
    this.tokens = tokenStream;
    this.current = null;
    this.nextToken = null;
    this.next();
  }

  ParserState.prototype.next = function () {
    this.current = this.nextToken;
    return (this.nextToken = this.tokens.next());
  };

  ParserState.prototype.tokenMatches = function (token, value) {
    if (typeof value === 'undefined') {
      return true;
    } else if (Object.prototype.toString.call(value) === '[object Array]') {
      return indexOf(value, token.value) >= 0;
    } else if (typeof value === 'function') {
      return value(token);
    } else {
      return token.value === value;
    }
  };

  ParserState.prototype.accept = function (type, value) {
    if (this.nextToken.type === type && this.tokenMatches(this.nextToken, value)) {
      this.next();
      return true;
    }
    return false;
  };

  ParserState.prototype.expect = function (type, value) {
    if (this.accept(type, value)) {
      return true;
    }
    throw new Error('parse error [' + this.tokens.line + ':' + this.tokens.column + ']: Expected ' + (value || type));
  };

  ParserState.prototype.parseAtom = function (instr) {
    if (this.accept(TNAME)) {
      instr.push(new Instruction(IVAR, this.current.value));
    } else if (this.accept(TNUMBER)) {
      instr.push(new Instruction(INUMBER, this.current.value));
    } else if (this.accept(TSTRING)) {
      instr.push(new Instruction(INUMBER, this.current.value));
    } else if (this.accept(TPAREN, '(')) {
      this.parseExpression(instr);
      this.expect(TPAREN, ')');
    } else {
      throw new Error('unexpected ' + this.nextToken);
    }
  };

  ParserState.prototype.parseExpression = function (instr) {
    this.parseOrExpression(instr);
  };

  ParserState.prototype.parseOrExpression = function (instr) {
    this.parseAndExpression(instr);
    while (this.accept(TOP, 'or')) {
      var op = this.current;
      this.parseAndExpression(instr);
      instr.push(new Instruction(IOP2, op.value));
    }
  };

  ParserState.prototype.parseAndExpression = function (instr) {
    this.parseComparison(instr);
    while (this.accept(TOP, 'and')) {
      var op = this.current;
      this.parseComparison(instr);
      instr.push(new Instruction(IOP2, op.value));
    }
  };

  ParserState.prototype.parseComparison = function (instr) {
    this.parseAddSub(instr);
    while (this.accept(TOP, ['==', '!=', '<', '<=', '>=', '>'])) {
      var op = this.current;
      this.parseAddSub(instr);
      instr.push(new Instruction(IOP2, op.value));
    }
  };

  ParserState.prototype.parseAddSub = function (instr) {
    this.parseTerm(instr);
    while (this.accept(TOP, ['+', '-', '||'])) {
      var op = this.current;
      this.parseTerm(instr);
      instr.push(new Instruction(IOP2, op.value));
    }
  };

  ParserState.prototype.parseTerm = function (instr) {
    this.parseFactor(instr);
    while (this.accept(TOP, ['*', '/', '%'])) {
      var op = this.current;
      this.parseFactor(instr);
      instr.push(new Instruction(IOP2, op.value));
    }
  };

  ParserState.prototype.parseFactor = function (instr) {
    var ops1 = this.tokens.ops1;
    function isPrefixOperator(token) {
      return token.value in ops1;
    }

    if (this.accept(TOP, isPrefixOperator)) {
      var op = this.current;
      this.parseFactor(instr);
      instr.push(new Instruction(IOP1, op.value));
    } else {
      this.parseExponential(instr);
    }
  };

  ParserState.prototype.parseExponential = function (instr) {
    this.parseFunctionCall(instr);
    while (this.accept(TOP, '^')) {
      this.parseFactor(instr);
      instr.push(new Instruction(IOP2, '^'));
    }
  };

  ParserState.prototype.parseFunctionCall = function (instr) {
    this.parseAtom(instr);
    while (this.accept(TPAREN, '(')) {
      instr.push(new Instruction(INUMBER, []));
      if (this.accept(TPAREN, ')')) {
        instr.push(new Instruction(IFUNCALL, 0));
      } else {
        this.parseArgumentList(instr);
        instr.push(new Instruction(IFUNCALL, 0));
      }
    }
  };

  ParserState.prototype.parseArgumentList = function (instr) {
    while (!this.accept(TPAREN, ')')) {
      this.parseOrExpression(instr);
      instr.push(new Instruction(IOP2, ','));
      while (this.accept(TCOMMA)) {
        this.parseOrExpression(instr);
        instr.push(new Instruction(IOP2, ','));
      }
    }
  };

  function Parser() {
    this.ops1 = {
      sin: Math.sin,
      cos: Math.cos,
      tan: Math.tan,
      asin: Math.asin,
      acos: Math.acos,
      atan: Math.atan,
      sinh: sinh,
      cosh: cosh,
      tanh: tanh,
      asinh: asinh,
      acosh: acosh,
      atanh: atanh,
      sqrt: Math.sqrt,
      log: Math.log,
      lg: log10,
      log10: log10,
      abs: Math.abs,
      ceil: Math.ceil,
      floor: Math.floor,
      round: Math.round,
      trunc: trunc,
      '-': neg,
      '+': Number,
      exp: Math.exp,
      not: not
    };

    this.ops2 = {
      '+': add,
      '-': sub,
      '*': mul,
      '/': div,
      '%': mod,
      '^': Math.pow,
      ',': append,
      '||': concat,
      '==': equal,
      '!=': notEqual,
      '>': greaterThan,
      '<': lessThan,
      '>=': greaterThanEqual,
      '<=': lessThanEqual,
      and: andOperator,
      or: orOperator
    };

    this.functions = {
      random: random,
      fac: fac,
      min: Math.min,
      max: Math.max,
      hypot: hypot,
      pyt: hypot, // backward compat
      pow: Math.pow,
      atan2: Math.atan2,
      'if': condition
    };

    this.consts = {
      E: Math.E,
      PI: Math.PI,
      'true': true,
      'false': false
    };
  }

  Parser.parse = function (expr) {
    return new Parser().parse(expr);
  };

  Parser.evaluate = function (expr, variables) {
    return Parser.parse(expr).evaluate(variables);
  };

  Parser.Expression = Expression;

  Parser.values = {
    sin: Math.sin,
    cos: Math.cos,
    tan: Math.tan,
    asin: Math.asin,
    acos: Math.acos,
    atan: Math.atan,
    sinh: sinh,
    cosh: cosh,
    tanh: tanh,
    asinh: asinh,
    acosh: acosh,
    atanh: atanh,
    sqrt: Math.sqrt,
    log: Math.log,
    lg: log10,
    log10: log10,
    abs: Math.abs,
    ceil: Math.ceil,
    floor: Math.floor,
    round: Math.round,
    trunc: trunc,
    random: random,
    fac: fac,
    exp: Math.exp,
    min: Math.min,
    max: Math.max,
    hypot: hypot,
    pyt: hypot, // backward compat
    pow: Math.pow,
    atan2: Math.atan2,
    'if': condition,
    E: Math.E,
    PI: Math.PI
  };

  Parser.prototype = {
    parse: function (expr) {
      var instr = [];
      var parserState = new ParserState(this, new TokenStream(expr, this.ops1, this.ops2, this.consts));
      parserState.parseExpression(instr);
      parserState.expect(TEOF, 'EOF');

      return new Expression(instr, object(this.ops1), object(this.ops2), object(this.functions));
    },

    evaluate: function (expr, variables) {
      return this.parse(expr).evaluate(variables);
    }
  };

  scope.Parser = Parser;
  return Parser;
}(typeof exports === 'undefined' ? {} : exports));