mathjs 5.0.0 → 5.0.4

package/lib/expression/parse.js

@@ -1,5 +1,7 @@
 'use strict';
 
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
 var ArgumentsError = require('../error/ArgumentsError');
 var deepMap = require('../utils/collection/deepMap');
 
@@ -59,19 +61,18 @@ function factory(type, config, load, typed) {
     }
 
     // pass extra nodes
-    extraNodes = options && options.nodes ? options.nodes : {};
+    var extraNodes = options && options.nodes ? options.nodes : {};
 
     if (typeof expr === 'string') {
       // parse a single expression
-      expression = expr;
-      return parseStart();
+
+      return parseStart(expr, extraNodes);
     } else if (Array.isArray(expr) || expr instanceof type.Matrix) {
       // parse an array or matrix with expressions
       return deepMap(expr, function (elem) {
         if (typeof elem !== 'string') throw new TypeError('String expected');
 
-        expression = elem;
-        return parseStart();
+        return parseStart(elem, extraNodes);
       });
     } else {
       // oops
@@ -149,101 +150,68 @@ function factory(type, config, load, typed) {
 
   var NUMERIC_CONSTANTS = ['NaN', 'Infinity'];
 
-  var extraNodes = {}; // current extra nodes
-  var expression = ''; // current expression
-  var comment = ''; // last parsed comment
-  var index = 0; // current index in expr
-  var c = ''; // current token character in expr
-  var token = ''; // current token
-  var tokenType = TOKENTYPE.NULL; // type of the token
-  var nestingLevel = 0; // level of nesting inside parameters, used to ignore newline characters
-  var conditionalLevel = null; // when a conditional is being parsed, the level of the conditional is stored here
-  var tokenStates = []; // holds saved token states
-
-  /**
-   * Get the first character from the expression.
-   * The character is stored into the char c. If the end of the expression is
-   * reached, the function puts an empty string in c.
-   * @private
-   */
-  function first() {
-    index = 0;
-    c = expression.charAt(0);
-    nestingLevel = 0;
-    conditionalLevel = null;
+  function initialState() {
+    return {
+      extraNodes: {}, // current extra nodes, must be careful not to mutate
+      expression: '', // current expression
+      comment: '', // last parsed comment
+      index: 0, // current index in expr
+      token: '', // current token
+      tokenType: TOKENTYPE.NULL, // type of the token
+      nestingLevel: 0, // level of nesting inside parameters, used to ignore newline characters
+      conditionalLevel: null // when a conditional is being parsed, the level of the conditional is stored here
+    };
   }
 
   /**
-   * Get the next character from the expression.
-   * The character is stored into the char c. If the end of the expression is
-   * reached, the function puts an empty string in c.
+   * View upto `length` characters of the expression starting at the current character.
+   *
+   * @param {State} state
+   * @param {number} [length=1] Number of characters to view
+   * @returns {string}
    * @private
    */
-  function next() {
-    index++;
-    c = expression.charAt(index);
+  function currentString(state, length) {
+    return state.expression.substr(state.index, length);
   }
 
   /**
-   * Preview the previous character from the expression.
-   * @return {string} cNext
+   * View the current character. Returns '' if end of expression is reached.
+   *
+   * @param {State} state
+   * @returns {string}
    * @private
    */
-  function prevPreview() {
-    return expression.charAt(index - 1);
+  function currentCharacter(state) {
+    return currentString(state, 1);
   }
 
   /**
-   * Preview the next character from the expression.
-   * @return {string} cNext
+   * Get the next character from the expression.
+   * The character is stored into the char c. If the end of the expression is
+   * reached, the function puts an empty string in c.
    * @private
    */
-  function nextPreview() {
-    return expression.charAt(index + 1);
+  function next(state) {
+    state.index++;
   }
 
   /**
-   * Preview the second next character from the expression.
+   * Preview the previous character from the expression.
    * @return {string} cNext
    * @private
    */
-  function nextNextPreview() {
-    return expression.charAt(index + 2);
-  }
-
-  /**
-   * Save the current token state so we can rewind later if necessary.
-   * @private
-   */
-  function pushTokenState() {
-    tokenStates.push({
-      tokenType: tokenType,
-      token: token,
-      comment: comment,
-      index: index,
-      c: c
-    });
-  }
-
-  /**
-   * Rewind the parser by one token by restoring the last saved token state
-   * @private
-   */
-  function popTokenState() {
-    var restoredState = tokenStates.pop();
-    tokenType = restoredState.tokenType;
-    token = restoredState.token;
-    comment = restoredState.comment;
-    index = restoredState.index;
-    c = restoredState.c;
+  function prevCharacter(state) {
+    return state.expression.charAt(state.index - 1);
   }
 
   /**
-   * Discard the most recent token state without restoring it
+   * Preview the next character from the expression.
+   * @return {string} cNext
    * @private
    */
-  function discardTokenState() {
-    tokenStates.pop();
+  function nextCharacter(state) {
+    return state.expression.charAt(state.index + 1);
   }
 
   /**
@@ -251,125 +219,123 @@ function factory(type, config, load, typed) {
    * The token and token type are available as token and tokenType
    * @private
    */
-  function getToken() {
-    tokenType = TOKENTYPE.NULL;
-    token = '';
-    comment = '';
+  function getToken(state) {
+    state.tokenType = TOKENTYPE.NULL;
+    state.token = '';
+    state.comment = '';
 
     // skip over whitespaces
     // space, tab, and newline when inside parameters
-    while (parse.isWhitespace(c, nestingLevel)) {
-      next();
+    while (parse.isWhitespace(currentCharacter(state), state.nestingLevel)) {
+      next(state);
     }
 
     // skip comment
-    if (c === '#') {
-      while (c !== '\n' && c !== '') {
-        comment += c;
-        next();
+    if (currentCharacter(state) === '#') {
+      while (currentCharacter(state) !== '\n' && currentCharacter(state) !== '') {
+        state.comment += currentCharacter(state);
+        next(state);
       }
     }
 
     // check for end of expression
-    if (c === '') {
+    if (currentCharacter(state) === '') {
       // token is still empty
-      tokenType = TOKENTYPE.DELIMITER;
+      state.tokenType = TOKENTYPE.DELIMITER;
       return;
     }
 
     // check for new line character
-    if (c === '\n' && !nestingLevel) {
-      tokenType = TOKENTYPE.DELIMITER;
-      token = c;
-      next();
+    if (currentCharacter(state) === '\n' && !state.nestingLevel) {
+      state.tokenType = TOKENTYPE.DELIMITER;
+      state.token = currentCharacter(state);
+      next(state);
       return;
     }
 
-    // check for delimiters consisting of 3 characters
-    var c2 = c + nextPreview();
-    var c3 = c2 + nextNextPreview();
+    var c1 = currentCharacter(state);
+    var c2 = currentString(state, 2);
+    var c3 = currentString(state, 3);
     if (c3.length === 3 && DELIMITERS[c3]) {
-      tokenType = TOKENTYPE.DELIMITER;
-      token = c3;
-      next();
-      next();
-      next();
+      state.tokenType = TOKENTYPE.DELIMITER;
+      state.token = c3;
+      next(state);
+      next(state);
+      next(state);
       return;
     }
 
     // check for delimiters consisting of 2 characters
     if (c2.length === 2 && DELIMITERS[c2]) {
-      tokenType = TOKENTYPE.DELIMITER;
-      token = c2;
-      next();
-      next();
+      state.tokenType = TOKENTYPE.DELIMITER;
+      state.token = c2;
+      next(state);
+      next(state);
       return;
     }
 
     // check for delimiters consisting of 1 character
-    if (DELIMITERS[c]) {
-      tokenType = TOKENTYPE.DELIMITER;
-      token = c;
-      next();
+    if (DELIMITERS[c1]) {
+      state.tokenType = TOKENTYPE.DELIMITER;
+      state.token = c1;
+      next(state);
       return;
     }
 
     // check for a number
-    if (parse.isDigitDot(c)) {
-      tokenType = TOKENTYPE.NUMBER;
+    if (parse.isDigitDot(c1)) {
+      state.tokenType = TOKENTYPE.NUMBER;
 
       // get number, can have a single dot
-      if (c === '.') {
-        token += c;
-        next();
+      if (currentCharacter(state) === '.') {
+        state.token += currentCharacter(state);
+        next(state);
 
-        if (!parse.isDigit(c)) {
+        if (!parse.isDigit(currentCharacter(state))) {
           // this is no number, it is just a dot (can be dot notation)
-          tokenType = TOKENTYPE.DELIMITER;
+          state.tokenType = TOKENTYPE.DELIMITER;
         }
       } else {
-        while (parse.isDigit(c)) {
-          token += c;
-          next();
+        while (parse.isDigit(currentCharacter(state))) {
+          state.token += currentCharacter(state);
+          next(state);
         }
-        if (parse.isDecimalMark(c, nextPreview())) {
-          token += c;
-          next();
+        if (parse.isDecimalMark(currentCharacter(state), nextCharacter(state))) {
+          state.token += currentCharacter(state);
+          next(state);
         }
       }
-      while (parse.isDigit(c)) {
-        token += c;
-        next();
-      }
 
+      while (parse.isDigit(currentCharacter(state))) {
+        state.token += currentCharacter(state);
+        next(state);
+      }
       // check for exponential notation like "2.3e-4", "1.23e50" or "2e+4"
-      c2 = nextPreview();
-      if (c === 'E' || c === 'e') {
-        if (parse.isDigit(c2) || c2 === '-' || c2 === '+') {
-          token += c;
-          next();
-
-          if (c === '+' || c === '-') {
-            token += c;
-            next();
+      if (currentCharacter(state) === 'E' || currentCharacter(state) === 'e') {
+        if (parse.isDigit(nextCharacter(state)) || nextCharacter(state) === '-' || nextCharacter(state) === '+') {
+          state.token += currentCharacter(state);
+          next(state);
+
+          if (currentCharacter(state) === '+' || currentCharacter(state) === '-') {
+            state.token += currentCharacter(state);
+            next(state);
           }
-
           // Scientific notation MUST be followed by an exponent
-          if (!parse.isDigit(c)) {
-            throw createSyntaxError('Digit expected, got "' + c + '"');
+          if (!parse.isDigit(currentCharacter(state))) {
+            throw createSyntaxError(state, 'Digit expected, got "' + currentCharacter(state) + '"');
           }
 
-          while (parse.isDigit(c)) {
-            token += c;
-            next();
+          while (parse.isDigit(currentCharacter(state))) {
+            state.token += currentCharacter(state);
+            next(state);
           }
 
-          if (parse.isDecimalMark(c, nextPreview())) {
-            throw createSyntaxError('Digit expected, got "' + c + '"');
+          if (parse.isDecimalMark(currentCharacter(state), nextCharacter(state))) {
+            throw createSyntaxError(state, 'Digit expected, got "' + currentCharacter(state) + '"');
           }
-        } else if (c2 === '.') {
-          next();
-          throw createSyntaxError('Digit expected, got "' + c + '"');
+        } else if (nextCharacter(state) === '.') {
+          next(state);
+          throw createSyntaxError(state, 'Digit expected, got "' + currentCharacter(state) + '"');
         }
       }
 
@@ -377,53 +343,53 @@ function factory(type, config, load, typed) {
     }
 
     // check for variables, functions, named operators
-    if (parse.isAlpha(c, prevPreview(), nextPreview())) {
-      while (parse.isAlpha(c, prevPreview(), nextPreview()) || parse.isDigit(c)) {
-        token += c;
-        next();
+    if (parse.isAlpha(currentCharacter(state), prevCharacter(state), nextCharacter(state))) {
+      while (parse.isAlpha(currentCharacter(state), prevCharacter(state), nextCharacter(state)) || parse.isDigit(currentCharacter(state))) {
+        state.token += currentCharacter(state);
+        next(state);
       }
 
-      if (NAMED_DELIMITERS.hasOwnProperty(token)) {
-        tokenType = TOKENTYPE.DELIMITER;
+      if (NAMED_DELIMITERS.hasOwnProperty(state.token)) {
+        state.tokenType = TOKENTYPE.DELIMITER;
       } else {
-        tokenType = TOKENTYPE.SYMBOL;
+        state.tokenType = TOKENTYPE.SYMBOL;
       }
 
       return;
     }
 
     // something unknown is found, wrong characters -> a syntax error
-    tokenType = TOKENTYPE.UNKNOWN;
-    while (c !== '') {
-      token += c;
-      next();
+    state.tokenType = TOKENTYPE.UNKNOWN;
+    while (currentCharacter(state) !== '') {
+      state.token += currentCharacter(state);
+      next(state);
     }
-    throw createSyntaxError('Syntax error in part "' + token + '"');
+    throw createSyntaxError(state, 'Syntax error in part "' + state.token + '"');
   }
 
   /**
    * Get next token and skip newline tokens
    */
-  function getTokenSkipNewline() {
+  function getTokenSkipNewline(state) {
     do {
-      getToken();
-    } while (token === '\n'); // eslint-disable-line no-unmodified-loop-condition
+      getToken(state);
+    } while (state.token === '\n'); // eslint-disable-line no-unmodified-loop-condition
   }
 
   /**
    * Open parameters.
-   * New line characters will be ignored until closeParams() is called
+   * New line characters will be ignored until closeParams(state) is called
    */
-  function openParams() {
-    nestingLevel++;
+  function openParams(state) {
+    state.nestingLevel++;
   }
 
   /**
    * Close parameters.
    * New line characters will no longer be ignored
    */
-  function closeParams() {
-    nestingLevel--;
+  function closeParams(state) {
+    state.nestingLevel--;
   }
 
   /**
@@ -523,24 +489,23 @@ function factory(type, config, load, typed) {
    * @return {Node} node
    * @private
    */
-  function parseStart() {
-    // get the first character in expression
-    first();
+  function parseStart(expression, extraNodes) {
+    var state = initialState();
+    _extends(state, { expression: expression, extraNodes: extraNodes });
+    getToken(state);
 
-    getToken();
-
-    var node = parseBlock();
+    var node = parseBlock(state);
 
     // check for garbage at the end of the expression
     // an expression ends with a empty character '' and tokenType DELIMITER
-    if (token !== '') {
-      if (tokenType === TOKENTYPE.DELIMITER) {
+    if (state.token !== '') {
+      if (state.tokenType === TOKENTYPE.DELIMITER) {
         // user entered a not existing operator like "//"
 
         // TODO: give hints for aliases, for example with "<>" give as hint " did you mean !== ?"
-        throw createError('Unexpected operator ' + token);
+        throw createError(state, 'Unexpected operator ' + state.token);
       } else {
-        throw createSyntaxError('Unexpected part "' + token + '"');
+        throw createSyntaxError(state, 'Unexpected part "' + state.token + '"');
       }
     }
 
@@ -554,33 +519,33 @@ function factory(type, config, load, typed) {
    * @return {Node} node
    * @private
    */
-  function parseBlock() {
+  function parseBlock(state) {
     var node = void 0;
     var blocks = [];
     var visible = void 0;
 
-    if (token !== '' && token !== '\n' && token !== ';') {
-      node = parseAssignment();
-      node.comment = comment;
+    if (state.token !== '' && state.token !== '\n' && state.token !== ';') {
+      node = parseAssignment(state);
+      node.comment = state.comment;
     }
 
     // TODO: simplify this loop
-    while (token === '\n' || token === ';') {
+    while (state.token === '\n' || state.token === ';') {
       // eslint-disable-line no-unmodified-loop-condition
       if (blocks.length === 0 && node) {
-        visible = token !== ';';
+        visible = state.token !== ';';
         blocks.push({
           node: node,
           visible: visible
         });
       }
 
-      getToken();
-      if (token !== '\n' && token !== ';' && token !== '') {
-        node = parseAssignment();
-        node.comment = comment;
+      getToken(state);
+      if (state.token !== '\n' && state.token !== ';' && state.token !== '') {
+        node = parseAssignment(state);
+        node.comment = state.comment;
 
-        visible = token !== ';';
+        visible = state.token !== ';';
         blocks.push({
           node: node,
           visible: visible
@@ -593,7 +558,7 @@ function factory(type, config, load, typed) {
     } else {
       if (!node) {
         node = new ConstantNode(undefined);
-        node.comment = comment;
+        node.comment = state.comment;
       }
 
       return node;
@@ -608,25 +573,25 @@ function factory(type, config, load, typed) {
    * @return {Node} node
    * @private
    */
-  function parseAssignment() {
+  function parseAssignment(state) {
     var name = void 0,
         args = void 0,
         value = void 0,
         valid = void 0;
 
-    var node = parseConditional();
+    var node = parseConditional(state);
 
-    if (token === '=') {
+    if (state.token === '=') {
       if (type.isSymbolNode(node)) {
         // parse a variable assignment like 'a = 2/3'
         name = node.name;
-        getTokenSkipNewline();
-        value = parseAssignment();
+        getTokenSkipNewline(state);
+        value = parseAssignment(state);
         return new AssignmentNode(new SymbolNode(name), value);
       } else if (type.isAccessorNode(node)) {
         // parse a matrix subset assignment like 'A[1,2] = 4'
-        getTokenSkipNewline();
-        value = parseAssignment();
+        getTokenSkipNewline(state);
+        value = parseAssignment(state);
         return new AssignmentNode(node.object, node.index, value);
       } else if (type.isFunctionNode(node) && type.isSymbolNode(node.fn)) {
         // parse function assignment like 'f(x) = x^2'
@@ -643,13 +608,13 @@ function factory(type, config, load, typed) {
         });
 
         if (valid) {
-          getTokenSkipNewline();
-          value = parseAssignment();
+          getTokenSkipNewline(state);
+          value = parseAssignment(state);
           return new FunctionAssignmentNode(name, args, value);
         }
       }
 
-      throw createSyntaxError('Invalid left hand side of assignment operator =');
+      throw createSyntaxError(state, 'Invalid left hand side of assignment operator =');
     }
 
     return node;
@@ -665,31 +630,31 @@ function factory(type, config, load, typed) {
    * @return {Node} node
    * @private
    */
-  function parseConditional() {
-    var node = parseLogicalOr();
+  function parseConditional(state) {
+    var node = parseLogicalOr(state);
 
-    while (token === '?') {
+    while (state.token === '?') {
       // eslint-disable-line no-unmodified-loop-condition
       // set a conditional level, the range operator will be ignored as long
-      // as conditionalLevel === nestingLevel.
-      var prev = conditionalLevel;
-      conditionalLevel = nestingLevel;
-      getTokenSkipNewline();
+      // as conditionalLevel === state.nestingLevel.
+      var prev = state.conditionalLevel;
+      state.conditionalLevel = state.nestingLevel;
+      getTokenSkipNewline(state);
 
       var condition = node;
-      var trueExpr = parseAssignment();
+      var trueExpr = parseAssignment(state);
 
-      if (token !== ':') throw createSyntaxError('False part of conditional expression expected');
+      if (state.token !== ':') throw createSyntaxError(state, 'False part of conditional expression expected');
 
-      conditionalLevel = null;
-      getTokenSkipNewline();
+      state.conditionalLevel = null;
+      getTokenSkipNewline(state);
 
-      var falseExpr = parseAssignment(); // Note: check for conditional operator again, right associativity
+      var falseExpr = parseAssignment(state); // Note: check for conditional operator again, right associativity
 
       node = new ConditionalNode(condition, trueExpr, falseExpr);
 
       // restore the previous conditional level
-      conditionalLevel = prev;
+      state.conditionalLevel = prev;
     }
 
     return node;
@@ -700,13 +665,13 @@ function factory(type, config, load, typed) {
    * @return {Node} node
    * @private
    */
-  function parseLogicalOr() {
-    var node = parseLogicalXor();
+  function parseLogicalOr(state) {
+    var node = parseLogicalXor(state);
 
-    while (token === 'or') {
+    while (state.token === 'or') {
       // eslint-disable-line no-unmodified-loop-condition
-      getTokenSkipNewline();
-      node = new OperatorNode('or', 'or', [node, parseLogicalXor()]);
+      getTokenSkipNewline(state);
+      node = new OperatorNode('or', 'or', [node, parseLogicalXor(state)]);
     }
 
     return node;
@@ -717,13 +682,13 @@ function factory(type, config, load, typed) {
    * @return {Node} node
    * @private
    */
-  function parseLogicalXor() {
-    var node = parseLogicalAnd();
+  function parseLogicalXor(state) {
+    var node = parseLogicalAnd(state);
 
-    while (token === 'xor') {
+    while (state.token === 'xor') {
       // eslint-disable-line no-unmodified-loop-condition
-      getTokenSkipNewline();
-      node = new OperatorNode('xor', 'xor', [node, parseLogicalAnd()]);
+      getTokenSkipNewline(state);
+      node = new OperatorNode('xor', 'xor', [node, parseLogicalAnd(state)]);
     }
 
     return node;
@@ -734,13 +699,13 @@ function factory(type, config, load, typed) {
    * @return {Node} node
    * @private
    */
-  function parseLogicalAnd() {
-    var node = parseBitwiseOr();
+  function parseLogicalAnd(state) {
+    var node = parseBitwiseOr(state);
 
-    while (token === 'and') {
+    while (state.token === 'and') {
       // eslint-disable-line no-unmodified-loop-condition
-      getTokenSkipNewline();
-      node = new OperatorNode('and', 'and', [node, parseBitwiseOr()]);
+      getTokenSkipNewline(state);
+      node = new OperatorNode('and', 'and', [node, parseBitwiseOr(state)]);
     }
 
     return node;
@@ -751,13 +716,13 @@ function factory(type, config, load, typed) {
    * @return {Node} node
    * @private
    */
-  function parseBitwiseOr() {
-    var node = parseBitwiseXor();
+  function parseBitwiseOr(state) {
+    var node = parseBitwiseXor(state);
 
-    while (token === '|') {
+    while (state.token === '|') {
       // eslint-disable-line no-unmodified-loop-condition
-      getTokenSkipNewline();
-      node = new OperatorNode('|', 'bitOr', [node, parseBitwiseXor()]);
+      getTokenSkipNewline(state);
+      node = new OperatorNode('|', 'bitOr', [node, parseBitwiseXor(state)]);
     }
 
     return node;
@@ -768,13 +733,13 @@ function factory(type, config, load, typed) {
    * @return {Node} node
    * @private
    */
-  function parseBitwiseXor() {
-    var node = parseBitwiseAnd();
+  function parseBitwiseXor(state) {
+    var node = parseBitwiseAnd(state);
 
-    while (token === '^|') {
+    while (state.token === '^|') {
       // eslint-disable-line no-unmodified-loop-condition
-      getTokenSkipNewline();
-      node = new OperatorNode('^|', 'bitXor', [node, parseBitwiseAnd()]);
+      getTokenSkipNewline(state);
+      node = new OperatorNode('^|', 'bitXor', [node, parseBitwiseAnd(state)]);
     }
 
     return node;
@@ -785,13 +750,13 @@ function factory(type, config, load, typed) {
    * @return {Node} node
    * @private
    */
-  function parseBitwiseAnd() {
-    var node = parseRelational();
+  function parseBitwiseAnd(state) {
+    var node = parseRelational(state);
 
-    while (token === '&') {
+    while (state.token === '&') {
       // eslint-disable-line no-unmodified-loop-condition
-      getTokenSkipNewline();
-      node = new OperatorNode('&', 'bitAnd', [node, parseRelational()]);
+      getTokenSkipNewline(state);
+      node = new OperatorNode('&', 'bitAnd', [node, parseRelational(state)]);
     }
 
     return node;
@@ -802,14 +767,14 @@ function factory(type, config, load, typed) {
    * @return {Node} node
    * @private
    */
-  function parseRelational() {
+  function parseRelational(state) {
     var node = void 0,
         operators = void 0,
         name = void 0,
         fn = void 0,
         params = void 0;
 
-    node = parseShift();
+    node = parseShift(state);
 
     operators = {
       '==': 'equal',
@@ -819,12 +784,12 @@ function factory(type, config, load, typed) {
       '<=': 'smallerEq',
       '>=': 'largerEq'
     };
-    while (operators.hasOwnProperty(token)) {
-      name = token;
+    while (operators.hasOwnProperty(state.token)) {
+      name = state.token;
       fn = operators[name];
 
-      getTokenSkipNewline();
-      params = [node, parseShift()];
+      getTokenSkipNewline(state);
+      params = [node, parseShift(state)];
       node = new OperatorNode(name, fn, params);
     }
 
@@ -836,14 +801,14 @@ function factory(type, config, load, typed) {
    * @return {Node} node
    * @private
    */
-  function parseShift() {
+  function parseShift(state) {
     var node = void 0,
         operators = void 0,
         name = void 0,
         fn = void 0,
         params = void 0;
 
-    node = parseConversion();
+    node = parseConversion(state);
 
     operators = {
       '<<': 'leftShift',
@@ -851,12 +816,12 @@ function factory(type, config, load, typed) {
       '>>>': 'rightLogShift'
     };
 
-    while (operators.hasOwnProperty(token)) {
-      name = token;
+    while (operators.hasOwnProperty(state.token)) {
+      name = state.token;
       fn = operators[name];
 
-      getTokenSkipNewline();
-      params = [node, parseConversion()];
+      getTokenSkipNewline(state);
+      params = [node, parseConversion(state)];
       node = new OperatorNode(name, fn, params);
     }
 
@@ -868,32 +833,32 @@ function factory(type, config, load, typed) {
    * @return {Node} node
    * @private
    */
-  function parseConversion() {
+  function parseConversion(state) {
     var node = void 0,
         operators = void 0,
         name = void 0,
         fn = void 0,
         params = void 0;
 
-    node = parseRange();
+    node = parseRange(state);
 
     operators = {
       'to': 'to',
       'in': 'to' // alias of 'to'
     };
 
-    while (operators.hasOwnProperty(token)) {
-      name = token;
+    while (operators.hasOwnProperty(state.token)) {
+      name = state.token;
       fn = operators[name];
 
-      getTokenSkipNewline();
+      getTokenSkipNewline(state);
 
-      if (name === 'in' && token === '') {
+      if (name === 'in' && state.token === '') {
         // end of expression -> this is the unit 'in' ('inch')
         node = new OperatorNode('*', 'multiply', [node, new SymbolNode('in')], true);
       } else {
         // operator 'a to b' or 'a in b'
-        params = [node, parseRange()];
+        params = [node, parseRange(state)];
         node = new OperatorNode(name, fn, params);
       }
     }
@@ -906,33 +871,33 @@ function factory(type, config, load, typed) {
    * @return {Node} node
    * @private
    */
-  function parseRange() {
+  function parseRange(state) {
     var node = void 0;
     var params = [];
 
-    if (token === ':') {
+    if (state.token === ':') {
       // implicit start=1 (one-based)
       node = new ConstantNode(1);
     } else {
       // explicit start
-      node = parseAddSubtract();
+      node = parseAddSubtract(state);
     }
 
-    if (token === ':' && conditionalLevel !== nestingLevel) {
+    if (state.token === ':' && state.conditionalLevel !== state.nestingLevel) {
       // we ignore the range operator when a conditional operator is being processed on the same level
       params.push(node);
 
       // parse step and end
-      while (token === ':' && params.length < 3) {
+      while (state.token === ':' && params.length < 3) {
         // eslint-disable-line no-unmodified-loop-condition
-        getTokenSkipNewline();
+        getTokenSkipNewline(state);
 
-        if (token === ')' || token === ']' || token === ',' || token === '') {
+        if (state.token === ')' || state.token === ']' || state.token === ',' || state.token === '') {
           // implicit end
           params.push(new SymbolNode('end'));
         } else {
           // explicit end
-          params.push(parseAddSubtract());
+          params.push(parseAddSubtract(state));
         }
       }
 
@@ -954,25 +919,25 @@ function factory(type, config, load, typed) {
    * @return {Node} node
    * @private
    */
-  function parseAddSubtract() {
+  function parseAddSubtract(state) {
     var node = void 0,
         operators = void 0,
         name = void 0,
         fn = void 0,
         params = void 0;
 
-    node = parseMultiplyDivide();
+    node = parseMultiplyDivide(state);
 
     operators = {
       '+': 'add',
       '-': 'subtract'
     };
-    while (operators.hasOwnProperty(token)) {
-      name = token;
+    while (operators.hasOwnProperty(state.token)) {
+      name = state.token;
       fn = operators[name];
 
-      getTokenSkipNewline();
-      params = [node, parseMultiplyDivide()];
+      getTokenSkipNewline(state);
+      params = [node, parseMultiplyDivide(state)];
       node = new OperatorNode(name, fn, params);
     }
 
@@ -984,14 +949,14 @@ function factory(type, config, load, typed) {
    * @return {Node} node
    * @private
    */
-  function parseMultiplyDivide() {
+  function parseMultiplyDivide(state) {
     var node = void 0,
         last = void 0,
         operators = void 0,
         name = void 0,
         fn = void 0;
 
-    node = parseImplicitMultiplication();
+    node = parseImplicitMultiplication(state);
     last = node;
 
     operators = {
@@ -1004,14 +969,14 @@ function factory(type, config, load, typed) {
     };
 
     while (true) {
-      if (operators.hasOwnProperty(token)) {
+      if (operators.hasOwnProperty(state.token)) {
         // explicit operators
-        name = token;
+        name = state.token;
         fn = operators[name];
 
-        getTokenSkipNewline();
+        getTokenSkipNewline(state);
 
-        last = parseImplicitMultiplication();
+        last = parseImplicitMultiplication(state);
         node = new OperatorNode(name, fn, [node, last]);
       } else {
         break;
@@ -1026,21 +991,21 @@ function factory(type, config, load, typed) {
    * @return {Node} node
    * @private
    */
-  function parseImplicitMultiplication() {
+  function parseImplicitMultiplication(state) {
     var node = void 0,
         last = void 0;
 
-    node = parseRule2();
+    node = parseRule2(state);
     last = node;
 
     while (true) {
-      if (tokenType === TOKENTYPE.SYMBOL || token === 'in' && type.isConstantNode(node) || tokenType === TOKENTYPE.NUMBER && !type.isConstantNode(last) && (!type.isOperatorNode(last) || last.op === '!') || token === '(') {
+      if (state.tokenType === TOKENTYPE.SYMBOL || state.token === 'in' && type.isConstantNode(node) || state.tokenType === TOKENTYPE.NUMBER && !type.isConstantNode(last) && (!type.isOperatorNode(last) || last.op === '!') || state.token === '(') {
         // parse implicit multiplication
         //
         // symbol:      implicit multiplication like '2a', '(2+3)a', 'a b'
         // number:      implicit multiplication like '(2+3)2'
         // parenthesis: implicit multiplication like '2(3+4)', '(3+4)(1+2)'
-        last = parseRule2();
+        last = parseRule2(state);
         node = new OperatorNode('*', 'multiply', [node, last], true /* implicit */);
       } else {
         break;
@@ -1057,43 +1022,41 @@ function factory(type, config, load, typed) {
    * @return {Node} node
    * @private
    */
-  function parseRule2() {
-    var node = void 0,
-        last = void 0;
-
-    node = parseUnary();
-    last = node;
+  function parseRule2(state) {
+    var node = parseUnary(state);
+    var last = node;
+    var tokenStates = [];
 
     while (true) {
       // Match the "number /" part of the pattern "number / number symbol"
-      if (token === '/' && type.isConstantNode(last)) {
+      if (state.token === '/' && type.isConstantNode(last)) {
         // Look ahead to see if the next token is a number
-        pushTokenState();
-        getTokenSkipNewline();
+        tokenStates.push(_extends({}, state));
+        getTokenSkipNewline(state);
 
         // Match the "number / number" part of the pattern
-        if (tokenType === TOKENTYPE.NUMBER) {
+        if (state.tokenType === TOKENTYPE.NUMBER) {
           // Look ahead again
-          pushTokenState();
-          getTokenSkipNewline();
+          tokenStates.push(_extends({}, state));
+          getTokenSkipNewline(state);
 
           // Match the "symbol" part of the pattern, or a left parenthesis
-          if (tokenType === TOKENTYPE.SYMBOL || token === '(') {
+          if (state.tokenType === TOKENTYPE.SYMBOL || state.token === '(') {
             // We've matched the pattern "number / number symbol".
             // Rewind once and build the "number / number" node; the symbol will be consumed later
-            popTokenState();
-            discardTokenState();
-            last = parseUnary();
+            _extends(state, tokenStates.pop());
+            tokenStates.pop();
+            last = parseUnary(state);
             node = new OperatorNode('/', 'divide', [node, last]);
           } else {
             // Not a match, so rewind
-            popTokenState();
-            popTokenState();
+            tokenStates.pop();
+            _extends(state, tokenStates.pop());
             break;
           }
         } else {
           // Not a match, so rewind
-          popTokenState();
+          _extends(state, tokenStates.pop());
           break;
         }
       } else {
@@ -1109,7 +1072,7 @@ function factory(type, config, load, typed) {
    * @return {Node} node
    * @private
    */
-  function parseUnary() {
+  function parseUnary(state) {
     var name = void 0,
         params = void 0,
         fn = void 0;
@@ -1120,17 +1083,17 @@ function factory(type, config, load, typed) {
       'not': 'not'
     };
 
-    if (operators.hasOwnProperty(token)) {
-      fn = operators[token];
-      name = token;
+    if (operators.hasOwnProperty(state.token)) {
+      fn = operators[state.token];
+      name = state.token;
 
-      getTokenSkipNewline();
-      params = [parseUnary()];
+      getTokenSkipNewline(state);
+      params = [parseUnary(state)];
 
       return new OperatorNode(name, fn, params);
     }
 
-    return parsePow();
+    return parsePow(state);
   }
 
   /**
@@ -1139,20 +1102,20 @@ function factory(type, config, load, typed) {
    * @return {Node} node
    * @private
    */
-  function parsePow() {
+  function parsePow(state) {
     var node = void 0,
         name = void 0,
         fn = void 0,
         params = void 0;
 
-    node = parseLeftHandOperators();
+    node = parseLeftHandOperators(state);
 
-    if (token === '^' || token === '.^') {
-      name = token;
+    if (state.token === '^' || state.token === '.^') {
+      name = state.token;
       fn = name === '^' ? 'pow' : 'dotPow';
 
-      getTokenSkipNewline();
-      params = [node, parseUnary()]; // Go back to unary, we can have '2^-3'
+      getTokenSkipNewline(state);
+      params = [node, parseUnary(state)]; // Go back to unary, we can have '2^-3'
       node = new OperatorNode(name, fn, params);
     }
 
@@ -1164,29 +1127,29 @@ function factory(type, config, load, typed) {
    * @return {Node} node
    * @private
    */
-  function parseLeftHandOperators() {
+  function parseLeftHandOperators(state) {
     var node = void 0,
         operators = void 0,
         name = void 0,
         fn = void 0,
         params = void 0;
 
-    node = parseCustomNodes();
+    node = parseCustomNodes(state);
 
     operators = {
       '!': 'factorial',
       '\'': 'ctranspose'
     };
 
-    while (operators.hasOwnProperty(token)) {
-      name = token;
+    while (operators.hasOwnProperty(state.token)) {
+      name = state.token;
       fn = operators[name];
 
-      getToken();
+      getToken(state);
       params = [node];
 
       node = new OperatorNode(name, fn, params);
-      node = parseAccessors(node);
+      node = parseAccessors(state, node);
     }
 
     return node;
@@ -1220,37 +1183,37 @@ function factory(type, config, load, typed) {
    * @return {Node} node
    * @private
    */
-  function parseCustomNodes() {
+  function parseCustomNodes(state) {
     var params = [];
 
-    if (tokenType === TOKENTYPE.SYMBOL && extraNodes.hasOwnProperty(token)) {
-      var CustomNode = extraNodes[token];
+    if (state.tokenType === TOKENTYPE.SYMBOL && state.extraNodes.hasOwnProperty(state.token)) {
+      var CustomNode = state.extraNodes[state.token];
 
-      getToken();
+      getToken(state);
 
       // parse parameters
-      if (token === '(') {
+      if (state.token === '(') {
         params = [];
 
-        openParams();
-        getToken();
+        openParams(state);
+        getToken(state);
 
-        if (token !== ')') {
-          params.push(parseAssignment());
+        if (state.token !== ')') {
+          params.push(parseAssignment(state));
 
           // parse a list with parameters
-          while (token === ',') {
+          while (state.token === ',') {
             // eslint-disable-line no-unmodified-loop-condition
-            getToken();
-            params.push(parseAssignment());
+            getToken(state);
+            params.push(parseAssignment(state));
           }
         }
 
-        if (token !== ')') {
-          throw createSyntaxError('Parenthesis ) expected');
+        if (state.token !== ')') {
+          throw createSyntaxError(state, 'Parenthesis ) expected');
         }
-        closeParams();
-        getToken();
+        closeParams(state);
+        getToken(state);
       }
 
       // create a new custom node
@@ -1258,7 +1221,7 @@ function factory(type, config, load, typed) {
       return new CustomNode(params);
     }
 
-    return parseSymbol();
+    return parseSymbol(state);
   }
 
   /**
@@ -1266,14 +1229,14 @@ function factory(type, config, load, typed) {
    * @return {Node} node
    * @private
    */
-  function parseSymbol() {
+  function parseSymbol(state) {
     var node = void 0,
         name = void 0;
 
-    if (tokenType === TOKENTYPE.SYMBOL || tokenType === TOKENTYPE.DELIMITER && token in NAMED_DELIMITERS) {
-      name = token;
+    if (state.tokenType === TOKENTYPE.SYMBOL || state.tokenType === TOKENTYPE.DELIMITER && state.token in NAMED_DELIMITERS) {
+      name = state.token;
 
-      getToken();
+      getToken(state);
 
       if (CONSTANTS.hasOwnProperty(name)) {
         // true, false, null, ...
@@ -1286,11 +1249,11 @@ function factory(type, config, load, typed) {
       }
 
       // parse function parameters and matrix index
-      node = parseAccessors(node);
+      node = parseAccessors(state, node);
       return node;
     }
 
-    return parseString();
+    return parseString(state);
   }
 
   /**
@@ -1306,35 +1269,35 @@ function factory(type, config, load, typed) {
    * @return {Node} node
    * @private
    */
-  function parseAccessors(node, types) {
+  function parseAccessors(state, node, types) {
     var params = void 0;
 
-    while ((token === '(' || token === '[' || token === '.') && (!types || types.indexOf(token) !== -1)) {
+    while ((state.token === '(' || state.token === '[' || state.token === '.') && (!types || types.indexOf(state.token) !== -1)) {
       // eslint-disable-line no-unmodified-loop-condition
       params = [];
 
-      if (token === '(') {
+      if (state.token === '(') {
         if (type.isSymbolNode(node) || type.isAccessorNode(node)) {
           // function invocation like fn(2, 3) or obj.fn(2, 3)
-          openParams();
-          getToken();
+          openParams(state);
+          getToken(state);
 
-          if (token !== ')') {
-            params.push(parseAssignment());
+          if (state.token !== ')') {
+            params.push(parseAssignment(state));
 
             // parse a list with parameters
-            while (token === ',') {
+            while (state.token === ',') {
               // eslint-disable-line no-unmodified-loop-condition
-              getToken();
-              params.push(parseAssignment());
+              getToken(state);
+              params.push(parseAssignment(state));
             }
           }
 
-          if (token !== ')') {
-            throw createSyntaxError('Parenthesis ) expected');
+          if (state.token !== ')') {
+            throw createSyntaxError(state, 'Parenthesis ) expected');
           }
-          closeParams();
-          getToken();
+          closeParams(state);
+          getToken(state);
 
           node = new FunctionNode(node, params);
         } else {
@@ -1343,38 +1306,38 @@ function factory(type, config, load, typed) {
           // with correct precedence
           return node;
         }
-      } else if (token === '[') {
+      } else if (state.token === '[') {
         // index notation like variable[2, 3]
-        openParams();
-        getToken();
+        openParams(state);
+        getToken(state);
 
-        if (token !== ']') {
-          params.push(parseAssignment());
+        if (state.token !== ']') {
+          params.push(parseAssignment(state));
 
           // parse a list with parameters
-          while (token === ',') {
+          while (state.token === ',') {
             // eslint-disable-line no-unmodified-loop-condition
-            getToken();
-            params.push(parseAssignment());
+            getToken(state);
+            params.push(parseAssignment(state));
           }
         }
 
-        if (token !== ']') {
-          throw createSyntaxError('Parenthesis ] expected');
+        if (state.token !== ']') {
+          throw createSyntaxError(state, 'Parenthesis ] expected');
         }
-        closeParams();
-        getToken();
+        closeParams(state);
+        getToken(state);
 
         node = new AccessorNode(node, new IndexNode(params));
       } else {
         // dot notation like variable.prop
-        getToken();
+        getToken(state);
 
-        if (tokenType !== TOKENTYPE.SYMBOL) {
-          throw createSyntaxError('Property name expected after dot');
+        if (state.tokenType !== TOKENTYPE.SYMBOL) {
+          throw createSyntaxError(state, 'Property name expected after dot');
         }
-        params.push(new ConstantNode(token));
-        getToken();
+        params.push(new ConstantNode(state.token));
+        getToken(state);
 
         var dotNotation = true;
         node = new AccessorNode(node, new IndexNode(params, dotNotation));
@@ -1390,49 +1353,49 @@ function factory(type, config, load, typed) {
    * @return {Node} node
    * @private
    */
-  function parseString() {
+  function parseString(state) {
     var node = void 0,
         str = void 0;
 
-    if (token === '"') {
-      str = parseStringToken();
+    if (state.token === '"') {
+      str = parseStringToken(state);
 
       // create constant
       node = new ConstantNode(str);
 
       // parse index parameters
-      node = parseAccessors(node);
+      node = parseAccessors(state, node);
 
       return node;
     }
 
-    return parseMatrix();
+    return parseMatrix(state);
   }
 
   /**
    * Parse a string surrounded by double quotes "..."
    * @return {string}
    */
-  function parseStringToken() {
+  function parseStringToken(state) {
     var str = '';
 
-    while (c !== '' && c !== '"') {
-      if (c === '\\') {
+    while (currentCharacter(state) !== '' && currentCharacter(state) !== '"') {
+      if (currentCharacter(state) === '\\') {
         // escape character, immediately process the next
         // character to prevent stopping at a next '\"'
-        str += c;
-        next();
+        str += currentCharacter(state);
+        next(state);
       }
 
-      str += c;
-      next();
+      str += currentCharacter(state);
+      next(state);
     }
 
-    getToken();
-    if (token !== '"') {
-      throw createSyntaxError('End of string " expected');
+    getToken(state);
+    if (state.token !== '"') {
+      throw createSyntaxError(state, 'End of string " expected');
     }
-    getToken();
+    getToken(state);
 
     return JSON.parse('"' + str + '"'); // unescape escaped characters
   }
@@ -1442,87 +1405,87 @@ function factory(type, config, load, typed) {
    * @return {Node} node
    * @private
    */
-  function parseMatrix() {
+  function parseMatrix(state) {
     var array = void 0,
         params = void 0,
         rows = void 0,
         cols = void 0;
 
-    if (token === '[') {
+    if (state.token === '[') {
       // matrix [...]
-      openParams();
-      getToken();
+      openParams(state);
+      getToken(state);
 
-      if (token !== ']') {
+      if (state.token !== ']') {
         // this is a non-empty matrix
-        var row = parseRow();
+        var row = parseRow(state);
 
-        if (token === ';') {
+        if (state.token === ';') {
           // 2 dimensional array
           rows = 1;
           params = [row];
 
           // the rows of the matrix are separated by dot-comma's
-          while (token === ';') {
+          while (state.token === ';') {
             // eslint-disable-line no-unmodified-loop-condition
-            getToken();
+            getToken(state);
 
-            params[rows] = parseRow();
+            params[rows] = parseRow(state);
             rows++;
           }
 
-          if (token !== ']') {
-            throw createSyntaxError('End of matrix ] expected');
+          if (state.token !== ']') {
+            throw createSyntaxError(state, 'End of matrix ] expected');
           }
-          closeParams();
-          getToken();
+          closeParams(state);
+          getToken(state);
 
           // check if the number of columns matches in all rows
           cols = params[0].items.length;
           for (var r = 1; r < rows; r++) {
             if (params[r].items.length !== cols) {
-              throw createError('Column dimensions mismatch ' + '(' + params[r].items.length + ' !== ' + cols + ')');
+              throw createError(state, 'Column dimensions mismatch ' + '(' + params[r].items.length + ' !== ' + cols + ')');
             }
           }
 
           array = new ArrayNode(params);
         } else {
           // 1 dimensional vector
-          if (token !== ']') {
-            throw createSyntaxError('End of matrix ] expected');
+          if (state.token !== ']') {
+            throw createSyntaxError(state, 'End of matrix ] expected');
           }
-          closeParams();
-          getToken();
+          closeParams(state);
+          getToken(state);
 
           array = row;
         }
       } else {
         // this is an empty matrix "[ ]"
-        closeParams();
-        getToken();
+        closeParams(state);
+        getToken(state);
         array = new ArrayNode([]);
       }
 
-      return parseAccessors(array);
+      return parseAccessors(state, array);
     }
 
-    return parseObject();
+    return parseObject(state);
   }
 
   /**
    * Parse a single comma-separated row from a matrix, like 'a, b, c'
    * @return {ArrayNode} node
    */
-  function parseRow() {
-    var params = [parseAssignment()];
+  function parseRow(state) {
+    var params = [parseAssignment(state)];
     var len = 1;
 
-    while (token === ',') {
+    while (state.token === ',') {
       // eslint-disable-line no-unmodified-loop-condition
-      getToken();
+      getToken(state);
 
       // parse expression
-      params[len] = parseAssignment();
+      params[len] = parseAssignment(state);
       len++;
     }
 
@@ -1534,50 +1497,50 @@ function factory(type, config, load, typed) {
    * @return {Node} node
    * @private
    */
-  function parseObject() {
-    if (token === '{') {
+  function parseObject(state) {
+    if (state.token === '{') {
       var key = void 0;
 
       var properties = {};
       do {
-        getToken();
+        getToken(state);
 
-        if (token !== '}') {
+        if (state.token !== '}') {
           // parse key
-          if (token === '"') {
-            key = parseStringToken();
-          } else if (tokenType === TOKENTYPE.SYMBOL) {
-            key = token;
-            getToken();
+          if (state.token === '"') {
+            key = parseStringToken(state);
+          } else if (state.tokenType === TOKENTYPE.SYMBOL) {
+            key = state.token;
+            getToken(state);
           } else {
-            throw createSyntaxError('Symbol or string expected as object key');
+            throw createSyntaxError(state, 'Symbol or string expected as object key');
           }
 
           // parse key/value separator
-          if (token !== ':') {
-            throw createSyntaxError('Colon : expected after object key');
+          if (state.token !== ':') {
+            throw createSyntaxError(state, 'Colon : expected after object key');
           }
-          getToken();
+          getToken(state);
 
           // parse key
-          properties[key] = parseAssignment();
+          properties[key] = parseAssignment(state);
         }
-      } while (token === ','); // eslint-disable-line no-unmodified-loop-condition
+      } while (state.token === ','); // eslint-disable-line no-unmodified-loop-condition
 
-      if (token !== '}') {
-        throw createSyntaxError('Comma , or bracket } expected after object value');
+      if (state.token !== '}') {
+        throw createSyntaxError(state, 'Comma , or bracket } expected after object value');
       }
-      getToken();
+      getToken(state);
 
       var node = new ObjectNode(properties);
 
       // parse index parameters
-      node = parseAccessors(node);
+      node = parseAccessors(state, node);
 
       return node;
     }
 
-    return parseNumber();
+    return parseNumber(state);
   }
 
   /**
@@ -1585,18 +1548,18 @@ function factory(type, config, load, typed) {
    * @return {Node} node
    * @private
    */
-  function parseNumber() {
+  function parseNumber(state) {
     var numberStr = void 0;
 
-    if (tokenType === TOKENTYPE.NUMBER) {
+    if (state.tokenType === TOKENTYPE.NUMBER) {
       // this is a number
-      numberStr = token;
-      getToken();
+      numberStr = state.token;
+      getToken(state);
 
       return new ConstantNode(numeric(numberStr, config.number));
     }
 
-    return parseParentheses();
+    return parseParentheses(state);
   }
 
   /**
@@ -1604,29 +1567,29 @@ function factory(type, config, load, typed) {
    * @return {Node} node
    * @private
    */
-  function parseParentheses() {
+  function parseParentheses(state) {
     var node = void 0;
 
     // check if it is a parenthesized expression
-    if (token === '(') {
+    if (state.token === '(') {
       // parentheses (...)
-      openParams();
-      getToken();
+      openParams(state);
+      getToken(state);
 
-      node = parseAssignment(); // start again
+      node = parseAssignment(state); // start again
 
-      if (token !== ')') {
-        throw createSyntaxError('Parenthesis ) expected');
+      if (state.token !== ')') {
+        throw createSyntaxError(state, 'Parenthesis ) expected');
       }
-      closeParams();
-      getToken();
+      closeParams(state);
+      getToken(state);
 
       node = new ParenthesisNode(node);
-      node = parseAccessors(node);
+      node = parseAccessors(state, node);
       return node;
     }
 
-    return parseEnd();
+    return parseEnd(state);
   }
 
   /**
@@ -1634,14 +1597,14 @@ function factory(type, config, load, typed) {
    * @return {Node} res
    * @private
    */
-  function parseEnd() {
-    if (token === '') {
+  function parseEnd(state) {
+    if (state.token === '') {
       // syntax error or unexpected end of expression
-      throw createSyntaxError('Unexpected end of expression');
-    } else if (token === "'") {
-      throw createSyntaxError('Value expected. Note: strings must be enclosed by double quotes');
+      throw createSyntaxError(state, 'Unexpected end of expression');
+    } else if (state.token === "'") {
+      throw createSyntaxError(state, 'Value expected. Note: strings must be enclosed by double quotes');
     } else {
-      throw createSyntaxError('Value expected');
+      throw createSyntaxError(state, 'Value expected');
     }
   }
 
@@ -1658,11 +1621,11 @@ function factory(type, config, load, typed) {
 
   /**
    * Shortcut for getting the current col value (one based)
-   * Returns the column (position) where the last token starts
+   * Returns the column (position) where the last state.token starts
    * @private
    */
-  function col() {
-    return index - token.length + 1;
+  function col(state) {
+    return state.index - state.token.length + 1;
   }
 
   /**
@@ -1671,8 +1634,8 @@ function factory(type, config, load, typed) {
    * @return {SyntaxError} instantiated error
    * @private
    */
-  function createSyntaxError(message) {
-    var c = col();
+  function createSyntaxError(state, message) {
+    var c = col(state);
     var error = new SyntaxError(message + ' (char ' + c + ')');
     error['char'] = c;
 
@@ -1685,8 +1648,8 @@ function factory(type, config, load, typed) {
    * @return {Error} instantiated error
    * @private
    */
-  function createError(message) {
-    var c = col();
+  function createError(state, message) {
+    var c = col(state);
     var error = new SyntaxError(message + ' (char ' + c + ')');
     error['char'] = c;