docs: private HsqlException readExpression(HsqlArrayList exprList, short[] parseList, int start,
                                            int count, boolean isOption, boolean preferToThrow) {
      /* disable 2 lines ...
      void readExpression(HsqlArrayList exprList, short[] parseList, int start,
                          int count, boolean isOption) {
      ... disabled 2 lines */
      // End of VoltDB extension
  
          for (int i = start; i < start + count; i++) {
              int exprType = parseList[i];
  
              switch (exprType) {
  
                  case Tokens.QUESTION : {
                      Expression e = null;
  
                      e = XreadAllTypesCommonValueExpression(false);
  
                      exprList.add(e);
  
                      continue;
                  }
                  case Tokens.X_POS_INTEGER : {
                      Expression e       = null;
                      int        integer = readInteger();
  
                      if (integer < 0) {
                          throw Error.error(ErrorCode.X_42592);
                      }
  
                      e = new ExpressionValue(ValuePool.getInt(integer),
                                              Type.SQL_INTEGER);
  
                      exprList.add(e);
  
                      continue;
                  }
                  case Tokens.X_OPTION : {
                      i++;
  
                      int expressionCount  = exprList.size();
                      int position         = getPosition();
                      int elementCount     = parseList[i++];
                      int initialExprIndex = exprList.size();
  
                      // A VoltDB extension to avoid using exceptions for flow control.
                      HsqlException ex = null;
                      try {
                          ex = readExpression(exprList, parseList, i, elementCount, true, false);
                      } catch (HsqlException caught) {
                          ex = caught;
                      }
                      if (ex != null) {
                      /* disable 4 lines ...
                      try {
                          readExpression(exprList, parseList, i, elementCount,
                                         true);
                      } catch (HsqlException ex) {
                      ... disabled 4 lines */
                      // End of VoltDB extension
                          ex.setLevel(compileContext.subQueryDepth);
  
                          if (lastError == null
                                  || lastError.getLevel() < ex.getLevel()) {
                              lastError = ex;
                          }
  
                          rewind(position);
                          exprList.setSize(expressionCount);
  
                          for (int j = i; j < i + elementCount; j++) {
                              if (parseList[j] == Tokens.QUESTION
                                      || parseList[j] == Tokens.X_KEYSET
                                      || parseList[j] == Tokens.X_POS_INTEGER) {
                                  exprList.add(null);
                              }
                          }
  
                          i += elementCount - 1;
  
                          continue;
                      }
  
                      if (initialExprIndex == exprList.size()) {
                          exprList.add(null);
                      }
  
                      i += elementCount - 1;
  
                      continue;
                  }
                  case Tokens.X_REPEAT : {
                      i++;
  
                      int elementCount = parseList[i++];
                      int parseIndex   = i;
  
                      while (true) {
                          int initialExprIndex = exprList.size();
  
                          // A VoltDB extension to avoid using exceptions for flow control.
                          if (preferToThrow) {
                              readExpression(exprList, parseList, parseIndex,
                                             elementCount, true, true);
                          } else {
                              HsqlException ex = null;
                              try {
                                  ex = readExpression(exprList, parseList, parseIndex,
                                                             elementCount, true, false);
                              } catch (HsqlException caught) {
                                  ex = caught;
                              }
                              if (ex != null) {
                                  // TODO: There is likely a more elegant pre-emptive way of handling
                                  // the inevitable close paren that properly terminates a repeating group.
                                  // This filtering probably masks/ignores some syntax errors such as
                                  // a trailing comma right before the paren.
                                  if (ex.getMessage().equalsIgnoreCase("unexpected token: )")) {
                                      break;
                                  }
                                  return ex;
                              }
                          }
                          /* disable 2 lines ...
                          readExpression(exprList, parseList, parseIndex,
                                         elementCount, true);
                          ... disabled 2 lines */
                          // End of VoltDB extension
  
                          if (exprList.size() == initialExprIndex) {
                              break;
                          }
                      }
  
                      i += elementCount - 1;
  
                      continue;
                  }
                  case Tokens.X_KEYSET : {
                      int        elementCount = parseList[++i];
                      Expression e            = null;
  
                      if (ArrayUtil.find(parseList, token.tokenType, i
                                         + 1, elementCount) == -1) {
                          if (!isOption) {
                              // A VoltDB extension to avoid using exceptions for flow control.
                              if ( ! preferToThrow) {
                                  return unexpectedToken();
                              }
                              // End of VoltDB extension
                              throw unexpectedToken();
                          }
                      } else {
                          e = new ExpressionValue(
                              ValuePool.getInt(token.tokenType),
                              Type.SQL_INTEGER);
  
                          read();
                      }
  
                      exprList.add(e);
  
                      i += elementCount;
  
                      continue;
                  }
                  case Tokens.OPENBRACKET :
                  case Tokens.CLOSEBRACKET :
                  case Tokens.COMMA :
                  default :
                      if (token.tokenType != exprType) {
                          // A VoltDB extension to avoid using exceptions for flow control.
                          if ( ! preferToThrow) {
                              return unexpectedToken();
                          }
                          // End of VoltDB extension
                          throw unexpectedToken();
                      }
  
                      read();
  
                      continue;
              }
          }
          // A VoltDB extension to avoid using exceptions for flow control.
          return null; // Successful return -- no exception to pass back.
          // End of VoltDB extension
      }