Function buildExprTree

src/lib/libc_preprocessor.js:177–238

(tokens)

    // Given a token list e.g. ['2', '>', '1'], returns a function that evaluates that token list.
    function buildExprTree(tokens) {
      // Consume tokens array into a function tree until the tokens array is exhausted
      // to a single root node that evaluates it.
      while (tokens.length > 1 || typeof tokens[0] != 'function') {
        tokens = ((tokens) => {
          // Find the index 'i' of the operator we should evaluate next:
          var i, j, p, operatorAndPriority = -2;
          for (j = 0; j < tokens.length; ++j) {
            if ((p = ['*', '/', '+', '-', '!', '<', '<=', '>', '>=', '==', '!=', '&&', '||', '('].indexOf(tokens[j])) > operatorAndPriority) {
              i = j;
              operatorAndPriority = p;
            }
          }

          if (operatorAndPriority == 13 /* parens '(' */) {
            // Find the closing parens position
            j = find_closing_parens_index(tokens, i);
            if (j) {
              tokens.splice(i, j+1-i, buildExprTree(tokens.slice(i+1, j)));
              return tokens;
            }
          }

          if (operatorAndPriority == 4 /* unary ! */) {
            // Special case: the unary operator ! needs to evaluate right-to-left.
            i = tokens.lastIndexOf('!');
            var innerExpr = buildExprTree(tokens.slice(i+1, i+2));
            tokens.splice(i, 2, function() { return !innerExpr(); })
            return tokens;
          }

          // A binary operator:
          if (operatorAndPriority >= 0) {
            var left = buildExprTree(tokens.slice(0, i));
            var right = buildExprTree(tokens.slice(i+1));
            var opers = {
              '&&': () => left() && right(),
              '||': () => left() || right(),
              '==': () => left() == right(),
              '!=': () => left() != right(),
              '<' : () => left() <  right(),
              '<=': () => left() <= right(),
              '>' : () => left() >  right(),
              '>=': () => left() >= right(),
               '+': () => left()  + right(),
               '-': () => left()  - right(),
               '*': () => left()  * right(),
               '/': () => Math.floor(left() / right())
            };
            return [opers[tokens[i]]];
          }
          // else a number:
#if ASSERTIONS
          assert(tokens[i] !== ')', 'parse failure, mismatched parentheses in parsing' + tokens.toString());
          assert(operatorAndPriority == -1);
#endif
          var num = Number(tokens[i]);
          return [function() { return num; }]