Subversion Repositories bacoAlunos

package com.owlike.genson.stream;

import java.io.IOException;

import java.io.Reader;

import java.io.StringReader;

import java.util.ArrayDeque;

import java.util.Arrays;

import java.util.Deque;

import java.util.HashMap;

import java.util.Map;

import static com.owlike.genson.stream.ValueType.*;

public class JsonReader implements ObjectReader {

  protected final static int[] SKIPPED_TOKENS;

  static {

    SKIPPED_TOKENS = new int[128];

    SKIPPED_TOKENS['\t'] = 1;

    SKIPPED_TOKENS['\b'] = 1;

    SKIPPED_TOKENS['\n'] = 1;

    SKIPPED_TOKENS['\r'] = 1;

    SKIPPED_TOKENS['\f'] = 1;

    SKIPPED_TOKENS[' '] = 1;

  }

  private final static boolean[] _NEXT_TOKEN = new boolean[128];

  static {

    _NEXT_TOKEN[','] = true;

    _NEXT_TOKEN['"'] = true;

    _NEXT_TOKEN['{'] = true;

    _NEXT_TOKEN['['] = true;

    _NEXT_TOKEN['n'] = true;

    _NEXT_TOKEN['N'] = true;

    _NEXT_TOKEN['-'] = true;

    _NEXT_TOKEN['t'] = true;

    _NEXT_TOKEN['f'] = true;

    _NEXT_TOKEN['T'] = true;

    _NEXT_TOKEN['F'] = true;

    for (int i = 48; i < 58; i++)

      _NEXT_TOKEN[i] = true;

  }

  private final static char[] _END_OF_LINE = new char[]{'\n'};

  private final static char[] _END_OF_BLOCK_COMMENT = new char[]{'*', '/'};

  /*

   * Recupere dans Jackson

   */

  private final static int[] sHexValues = new int[128];

  static {

    1.5.0/docs/api/java/util/Arrays.html">Arrays.fill(sHexValues, -1);

    for (int i = 0; i < 10; ++i) {

      sHexValues['0' + i] = i;

    }

    for (int i = 0; i < 6; ++i) {

      sHexValues['a' + i] = 10 + i;

      sHexValues['A' + i] = 10 + i;

    }

  }

  private final static double[] _POWS = new double[309];

  static {

    for (int i = 0; i < _POWS.length; i++)

      _POWS[i] = 1.5.0/docs/api/java/lang/Math.html">Math.pow(10, i);

  }

  private final 1.5.0/docs/api/java/io/Reader.html">Reader reader;

  private final boolean strictDoubleParse;

  private final boolean readMetadata;

  private final char[] _buffer = new char[2048];

  private int _col;

  private int _row;

  private int _cursor;

  private int _buflen;

  private char[] _stringBuffer = new char[16];

  private int _stringBufferTail = 0;

  private int _stringBufferLength = _stringBuffer.length;

  private 1.5.0/docs/api/java/lang/String.html">String currentName;

  private 1.5.0/docs/api/java/lang/String.html">String _stringValue;

  protected long _intValue;

  protected double _doubleValue;

  private int _numberLen = 0;

  private 1.5.0/docs/api/java/lang/Boolean.html">Boolean _booleanValue;

  private ValueType valueType;

  private boolean _first = true;

  private boolean _metadata_readen = false;

  private Map<String, String> _metadata = new HashMap<String, String>(5);

  private final Deque<JsonType> _ctx = new ArrayDeque<JsonType>(10);

  {

    _ctx.push(JsonType.EMPTY);

  }

  public JsonReader(1.5.0/docs/api/java/lang/String.html">String source) {

    this(new 1.5.0/docs/api/java/io/StringReader.html">StringReader(source), false, false);

  }

  public JsonReader(1.5.0/docs/api/java/io/Reader.html">Reader reader, boolean strictDoubleParse, boolean readMetadata) {

    this.reader = reader;

    this.strictDoubleParse = strictDoubleParse;

    this.readMetadata = readMetadata;

    char token = (char) readNextToken(false);

    if ('[' == token) valueType = ARRAY;

    else if ('{' == token) valueType = OBJECT;

    else {

      // ok lets try to read next

      if (_buflen > 0) {

        try {

          valueType = consumeValue();

        } catch (JsonStreamException jse) {

          try {

            // we must cheat because consumeString attends the current token to be "

            // and will increment the cursor

            _cursor = -1;

            _col = -1;

            _stringValue = consumeString('"');

            valueType = STRING;

          } catch (1.5.0/docs/api/java/lang/RuntimeException.html">RuntimeException re) {

            throw re;

          }

        }

        if (valueOf(valueType.name()) == null)

          throw new JsonStreamException(

            "Failed to instanciate reader, first character was " + (char) token

              + " when possible characters are [ and {");

      } else valueType = NULL;

    }

  }

  public void close() {

    try {

      reader.close();

    } catch (1.5.0/docs/api/java/io/IOException.html">IOException e) {

      throw new JsonStreamException(e);

    }

  }

  public ObjectReader beginArray() {

    begin('[', JsonType.ARRAY);

    valueType = ARRAY;

    if (_metadata_readen) _metadata.clear();

    return this;

  }

  public ObjectReader beginObject() {

    if (!_metadata_readen) {

      begin('{', JsonType.OBJECT);

      valueType = OBJECT;

      if (readMetadata) {

        _metadata.clear();

        readMetadata();

      }

    }

    return this;

  }

  public ObjectReader nextObjectMetadata() {

    return beginObject();

  }

  public ObjectReader endArray() {

    end(']', JsonType.ARRAY);

    return this;

  }

  public ObjectReader endObject() {

    end('}', JsonType.OBJECT);

    _metadata.clear();

    _metadata_readen = false;

    return this;

  }

  public 1.5.0/docs/api/java/lang/String.html">String name() {

    if (enclosingType() != JsonType.OBJECT)

      throw new JsonStreamException("Only json objects have names, actual type is "

        + valueType);

    return currentName;

  }

  public 1.5.0/docs/api/java/lang/String.html">String valueAsString() {

    if (STRING == valueType) return _stringValue;

    if (INTEGER == valueType) return "" + _intValue;

    if (DOUBLE == valueType) return "" + _doubleValue;

    if (NULL == valueType) return null;

    if (BOOLEAN == valueType) {

      return _booleanValue.toString();

    }

    throw new JsonStreamException("Readen value can not be converted to String");

  }

  public int valueAsInt() {

    if (INTEGER == valueType) {

      int value = (int) _intValue;

      if (value != _intValue) throwNumberFormatException("an int", "overflowing long value " + _intValue);

      return value;

    } else if (DOUBLE == valueType) {

      int value = (int) _doubleValue;

      long longValue = (long) _doubleValue;

      // lets accept only if the integer part is the same and ignore the decimals

      if (value != longValue) {

        throwNumberFormatException("an int", "overflowing double value " + _doubleValue);

      }

      return value;

    } else if (STRING == valueType) return 1.5.0/docs/api/java/lang/Integer.html">Integer.parseInt(_stringValue);

    throw new JsonStreamException("Expected a int but value is of type " + valueType);

  }

  public long valueAsLong() {

    if (INTEGER == valueType) {

      return _intValue;

    } else if (DOUBLE == valueType) {

      if (1.5.0/docs/api/java/lang/Long.html">Long.MIN_VALUE > _doubleValue || _doubleValue > 1.5.0/docs/api/java/lang/Long.html">Long.MAX_VALUE) {

        throwNumberFormatException("a long", "overflowing double value " + _doubleValue);

      }

      return (long) _doubleValue;

    } else if (STRING == valueType) return 1.5.0/docs/api/java/lang/Long.html">Long.parseLong(_stringValue);

    throw new JsonStreamException("Expected a long but value is of type " + valueType);

  }

  public double valueAsDouble() {

    if (DOUBLE == valueType) {

      return _doubleValue;

    } else if (INTEGER == valueType) {

      // for the moment lets do that even if there is some precision loss...

      return 1.5.0/docs/api/java/lang/Long.html">Long.valueOf(_intValue).doubleValue();

    } else if (STRING == valueType) return 1.5.0/docs/api/java/lang/Double.html">Double.parseDouble(_stringValue);

    throw new JsonStreamException("Expected a double but value is of type " + valueType);

  }

  public short valueAsShort() {

    if (INTEGER == valueType) {

      short value = (short) _intValue;

      if (value != _intValue) throwNumberFormatException("a short", "overflowing long value " + _intValue);

      return value;

    } else if (DOUBLE == valueType) {

      short value = (short) _doubleValue;

      long longValue = (long) _doubleValue;

      // lets accept only if the integer part is the same and ignore the decimals

      if (value != longValue) {

        throwNumberFormatException("a short", "overflowing double value " + _doubleValue);

      }

      return value;

    } else if (STRING == valueType) return 1.5.0/docs/api/java/lang/Short.html">Short.parseShort(_stringValue);

    throw new JsonStreamException("Expected a short but value is of type " + valueType);

  }

  public float valueAsFloat() {

    if (DOUBLE == valueType) {

      return (float) _doubleValue;

    } else if (INTEGER == valueType) {

      // same as for doubles, for the moment lets do that even if there is some precision

      // loss...

      return 1.5.0/docs/api/java/lang/Long.html">Long.valueOf(_intValue).floatValue();

    } else if (STRING == valueType) return 1.5.0/docs/api/java/lang/Float.html">Float.parseFloat(_stringValue);

    throw new JsonStreamException("Expected a float but value is of type " + valueType);

  }

  public boolean valueAsBoolean() {

    if (BOOLEAN == valueType) {

      return _booleanValue;

    }

    if (STRING == valueType) return 1.5.0/docs/api/java/lang/Boolean.html">Boolean.parseBoolean(_stringValue);

    throw new JsonStreamException("Readen value is not of type boolean");

  }

  public byte[] valueAsByteArray() {

    if (STRING == valueType) return Base64.decodeFast(_stringValue);

    if (NULL == valueType) return null;

    throw new JsonStreamException("Expected a String to convert to byte array found "

      + valueType);

  }

  public 1.5.0/docs/api/java/lang/String.html">String metadata(1.5.0/docs/api/java/lang/String.html">String name) {

    if (!_metadata_readen) nextObjectMetadata();

    return _metadata.get(name);

  }

  public ValueType getValueType() {

    return valueType;

  }

  public ObjectReader skipValue() {

    if (ARRAY == valueType || OBJECT == valueType) {

      int balance = 0;

      do {

        if (ARRAY == valueType) {

          beginArray();

          balance++;

        } else if (OBJECT == valueType) {

          beginObject();

          balance++;

        }

        while (hasNext()) {

          next();

          skipValue();

        }

        JsonType type = _ctx.peek();

        if (JsonType.ARRAY == type) {

          endArray();

          balance--;

        } else if (JsonType.OBJECT == type) {

          endObject();

          balance--;

        }

      } while (balance > 0);

    }

    return this;

  }

  public boolean hasNext() {

    int token = readNextToken(false);

    if (token == -1) return false;

    if (token < 128) {

      if (_first || _ctx.size() == 1) return _NEXT_TOKEN[token];

      else if (token == ',') return true;

    }

    return false;

  }

  public ValueType next() {

    _metadata_readen = false;

    _first = false;

    char ctoken = (char) readNextToken(false);

    if (ctoken == ',') {

      _cursor++;

      ctoken = (char) readNextToken(false);

    } else if (JsonType.ARRAY == _ctx.peek()) {

      if (ctoken == '[') {

        valueType = ARRAY;

        return valueType;

      }

      if (ctoken == '{') {

        valueType = OBJECT;

        return valueType;

      }

    }

    if (JsonType.OBJECT == _ctx.peek()) {

      currentName = consumeString(ctoken);

      if (readNextToken(true) != ':') newWrongTokenException(":", _cursor - 1);

    }

    valueType = consumeValue();

    return valueType;

  }

  @1.5.0/docs/api/java/lang/Override.html">Override

  public JsonType enclosingType() {

    return _ctx.peek();

  }

  protected final ValueType consumeValue() {

    char ctoken = (char) readNextToken(false);

    if (ctoken == '"') {

      _stringValue = consumeString(ctoken);

      return STRING;

    } else if (ctoken == '[') return ARRAY;

    else if (ctoken == '{') return OBJECT;

    else return consumeLiteral();

  }

  protected final void readMetadata() {

    _metadata_readen = true;

    while (true) {

      char ctoken = (char) readNextToken(false);

      if ('"' != ctoken) return;

      ensureBufferHas(2, true);

      if ('@' == _buffer[_cursor + 1]) {

        _cursor++;

        // we cheat here...

        1.5.0/docs/api/java/lang/String.html">String key = consumeString(ctoken);

        if (readNextToken(true) != ':') newWrongTokenException(":", _cursor - 1);

        1.5.0/docs/api/java/lang/String.html">String value = consumeString((char) readNextToken(false));

        _metadata.put(key, value);

        if (readNextToken(false) == ',') {

          _cursor++;

        }

      } else return;

    }

  }

  protected final void begin(int character, JsonType type) {

    int token = readNextToken(true);

    // seems unecessary as it is done in readNextToken

    // checkIllegalEnd(token);

    if (character == token) {

      _ctx.push(type);

    } else newWrongTokenException("" + (char) character, _cursor - 1);

    _first = true;

  }

  protected final void end(int character, JsonType type) {

    int token = readNextToken(true);

    // seems unecessary as it is done in readNextToken

    // checkIllegalEnd(token);

    if (character == token && type == _ctx.peek()) {

      _ctx.pop();

    } else newWrongTokenException("" + (char) character, _cursor - 1);

    _first = false;

  }

  protected final 1.5.0/docs/api/java/lang/String.html">String consumeString(int token) {

    if (token != '"') newMisplacedTokenException(_cursor);

    _cursor++;

    boolean buffered = false;

    while (true) {

      if (fillBuffer(true) < 0) {

        // TODO ugly to copy, by the way ensure we don't have the same problem elsewhere

        1.5.0/docs/api/java/lang/String.html">String name = new 1.5.0/docs/api/java/lang/String.html">String(_stringBuffer, 0, _stringBufferTail);

        _stringBufferTail = 0;

        return name;

      }

      int i = _cursor;

      for (; i < _buflen; ) {

        if (_buffer[i] == '"') {

          if (buffered) {

            writeToStringBuffer(_buffer, _cursor, i - _cursor);

            _cursor = i + 1;

            1.5.0/docs/api/java/lang/String.html">String name = new 1.5.0/docs/api/java/lang/String.html">String(_stringBuffer, 0, _stringBufferTail);

            _stringBufferTail = 0;

            return name;

          } else {

            1.5.0/docs/api/java/lang/String.html">String name = new 1.5.0/docs/api/java/lang/String.html">String(_buffer, _cursor, i - _cursor);

            _cursor = i + 1;

            return name;

          }

        } else if (_buffer[i] == '\\') {

          buffered = true;

          writeToStringBuffer(_buffer, _cursor, i - _cursor);

          _cursor = i + 1;

          if (_stringBufferLength <= (_stringBufferTail + 1)) expandStringBuffer(16);

          _stringBuffer[_stringBufferTail++] = readEscaped();

          i = _cursor;

        } else i++;

      }

      buffered = true;

      writeToStringBuffer(_buffer, _cursor, i - _cursor);

      _cursor = i + 1;

    }

  }

  /**

   * Reads the next literal value into _booleanValue, _doubleValue or _intValue and returns the

   * type of the readed literal, possible values are : INTEGER, DOUBLE, BOOLEAN, NULL. When

   * calling this method the _cursor must be positioned on the first character of the value in the

   * _buffer, you can ensure that by calling {@link #readNextToken(boolean)}.

   */

  protected final ValueType consumeLiteral() {

    int token = _buffer[_cursor];

    if ((token > 47 && token < 58) || token == 45) {

      return consumeNumber();

    } else {

      ensureBufferHas(4, true);

      if ((_buffer[_cursor] == 'N' || _buffer[_cursor] == 'n')

        && (_buffer[_cursor + 1] == 'U' || _buffer[_cursor + 1] == 'u')

        && (_buffer[_cursor + 2] == 'L' || _buffer[_cursor + 2] == 'l')

        && (_buffer[_cursor + 3] == 'L' || _buffer[_cursor + 3] == 'l')) {

        _cursor += 4;

        return NULL;

      }

      if ((_buffer[_cursor] == 'T' || _buffer[_cursor] == 't')

        && (_buffer[_cursor + 1] == 'R' || _buffer[_cursor + 1] == 'r')

        && (_buffer[_cursor + 2] == 'U' || _buffer[_cursor + 2] == 'u')

        && (_buffer[_cursor + 3] == 'E' || _buffer[_cursor + 3] == 'e')) {

        _booleanValue = true;

        _cursor += 4;

        return BOOLEAN;

      }

      ensureBufferHas(5, true);

      if ((_buffer[_cursor] == 'F' || _buffer[_cursor] == 'f')

        && (_buffer[_cursor + 1] == 'A' || _buffer[_cursor + 1] == 'a')

        && (_buffer[_cursor + 2] == 'L' || _buffer[_cursor + 2] == 'l')

        && (_buffer[_cursor + 3] == 'S' || _buffer[_cursor + 3] == 's')

        && (_buffer[_cursor + 4] == 'E' || _buffer[_cursor + 4] == 'e')) {

        _booleanValue = false;

        _cursor += 5;

        return BOOLEAN;

      } else {

        throw new JsonStreamException.Builder().message(

          "Illegal character around row " + _row + " and column " + (_cursor - _col)

            + " awaited for literal (number, boolean or null) but read '"

            + _buffer[_cursor] + "'!").create();

      }

    }

  }

  private ValueType consumeNumber() {

    // lets fill the buffer and handle differently overflowing values

    if ((_buflen - _cursor) < 378) ensureBufferHas(_buflen, false);

    int begin = _cursor;

    int cur;

    boolean negative;

    // check the sign

    if (_buffer[_cursor] == 45) {

      negative = true;

      _cursor++;

      cur = _cursor;

    } else {

      negative = false;

      cur = _cursor;

    }

    // just to handle invalid leading 0000

    for (; cur < _buflen && _buffer[cur] == 48; cur++) ;

    // Careful we consume the '-' here, but also all the leading 0, even if it is of form 0.xxx

    _cursor = cur;

    int len = 1.5.0/docs/api/java/lang/Math.html">Math.min(_buflen, cur + 18);

    int token;

    long longValue = 0;

    for (; cur < len; cur++) {

      token = _buffer[cur];

      if (token < 48 || token > 57) {

        break;

      }

      longValue = 10L * longValue + (token - 48);

    }

    if (cur < _buflen) {

      // read the maximum we can to fill the long capacity, at max we can read 1 additional

      // digit

      token = _buffer[cur];

      if (token > 47 && token < 58) {

        long newLongValue = 10L * longValue + (token - 48);

        if (newLongValue > longValue) {

          longValue = newLongValue;

          cur++;

        }

        /* TODO we parse here Long.MIN_VALUE as a double, we had also pb in the writer

        * the solution => instead of doing operations on positive numbers, do the inverse, use negative numbers

        * as the min negative long holds the - max positive long.

        */

        // else we exceed long capacity, just continue and parse it as a double

      }

      if (cur < _buflen

        && ((token = _buffer[cur]) == 46 || token == 101 || token == 69 || (token > 47 && token < 58))) {

        if (strictDoubleParse) {

          _cursor = begin;

          return consumeStrictNumber(cur);

        } else return consumeDouble(cur, longValue, negative);

      }

    }

    _intValue = negative ? -longValue : longValue;

    _numberLen = cur - _cursor;

    _cursor = cur;

    return INTEGER;

  }

  // a custom implementation based on fast path principles

  private ValueType consumeDouble(int cur, long longValue, boolean negative) {

    int token;

    // TODO a verifier : on ne veut compter dans les intDigit que ce qui n'est pas pris dans le

    // longValue, idem pour les decimales??

    int intDigits = cur - _cursor;

    int valueDigits = longValue > 0 ? cur - _cursor : 0;

    // ok we have readen as many characters as a long can contain

    // the next readen characters will serve for the digit count for large integer numbers

    if (intDigits > 17) {

      for (; cur < _buflen; cur++) {

        if (_buffer[cur] < 48 || _buffer[cur] > 57) {

          break;

        }

      }

      // only if we advanced

      if (intDigits != (cur - _cursor)) intDigits = (cur - _cursor) - intDigits;

    } else

      // TODO check ça m'a l'air bizarre comme cas...

      intDigits = 0;

    int decimalDigits = 0;

    // next possible case is a dot

    if (cur < _buflen && _buffer[cur] == 46) {

      cur++;

      int start = cur;

      // if integer part value is zero we could use scientific notation and win in precision

      if (longValue == 0) {

        // reset the counter as we don't care of the leading zeros

        intDigits = 0;

        // now lets try to read as many consecutive zeros as available

        for (; cur < _buflen && _buffer[cur] == 48; cur++) ;

      }

      // ok now we must read again into the longValue

      int len = 1.5.0/docs/api/java/lang/Math.html">Math.min(_buflen, cur + (18 - valueDigits));

      for (; cur < len; cur++) {

        token = _buffer[cur];

        if (token < 48 || token > 57) {

          break;

        }

        longValue = 10L * longValue + (token - 48);

      }

      decimalDigits = cur - start;

      start = cur;

      // no need to count digits after the precision we support for decimals

      // continue reading digits and just ignore the values, we will truncate

      for (; cur < _buflen; cur++) {

        if (_buffer[cur] < 48 || _buffer[cur] > 57) {

          break;

        }

      }

    }

    // now try to read exponent E/e

    if ((cur + 1) < _buflen && (_buffer[cur] == 101 || _buffer[cur] == 69)) {

      token = _buffer[++cur];

      boolean negativeExp;

      // check the sign

      if (token == 45) {

        negativeExp = true;

        cur++;

      } else {

        if (token == 43) cur++;

        negativeExp = false;

      }

      // read the power of ten

      int powValue = 0;

      for (; cur < _buflen; cur++) {

        token = _buffer[cur];

        if (token < 48 || token > 57) {

          break;

        }

        powValue = 10 * powValue + (token - 48);

      }

      // depending on the sign put it in the decimal digit counter or integer digit counter

      if (negativeExp) decimalDigits += powValue;

      else intDigits += powValue;

    }

    // and now make the difference so it balances well

    decimalDigits = intDigits - decimalDigits;

    if (decimalDigits < 0) {

            /*

             * This allows to handle also Double.MIN_VALUE and Double.MIN_NORMAL as

             * Double.MIN_NORMAL has 16 decimal digits, 308+16=324, but 10^324 overflows the double

             * capacity, its Infinity. So we use this little trick.

             */

      if (decimalDigits < -308) {

        if (decimalDigits < -325) {

          _doubleValue = 0;

        } else {

          _doubleValue = longValue / _POWS[-decimalDigits - 308];

          _doubleValue = _doubleValue / _POWS[308];

        }

      } else {

        // better precision than multiplication

        _doubleValue = longValue / _POWS[-decimalDigits];

      }

    } else {

      if (decimalDigits > 308) {

        _doubleValue = 1.5.0/docs/api/java/lang/Double.html">Double.POSITIVE_INFINITY;

      } else {

        // we don't need to apply same technique as before as

        // 308-16=292 so it's okay :)

        _doubleValue = longValue * _POWS[decimalDigits];

      }

    }

    _doubleValue = negative ? -_doubleValue : _doubleValue;

    _numberLen = cur - _cursor;

    _cursor = cur;

    return DOUBLE;

  }

  private final ValueType consumeStrictNumber(int localCursor) {

    if (localCursor < _buflen) {

      // consider all the remaining integer values as part of the double

      for (; localCursor < _buflen; localCursor++) {

        if (_buffer[localCursor] < 48 || _buffer[localCursor] > 57) {

          break;

        }

      }

    }

    if (localCursor < _buflen) {

      if (_buffer[localCursor] == '.') {

        localCursor = advanceWhileNumeric(++localCursor);

      }

    }

    if (localCursor + 1 < _buflen) {

      char ctoken = _buffer[localCursor];

      if (ctoken == 'e' || ctoken == 'E') {

        ctoken = _buffer[++localCursor];

        if (ctoken == '-' || ctoken == '+' || (ctoken > 47 && ctoken < 58)) {

          localCursor = advanceWhileNumeric(++localCursor);

        } else newWrongTokenException("'-' or '+' or '' (same as +)");

      }

    }

    // it may overflow of the max numeric value we accept to read, it should

    if (localCursor >= _buflen) {

    }

    _numberLen = localCursor - _cursor;

    _stringValue = new 1.5.0/docs/api/java/lang/String.html">String(_buffer, _cursor, _numberLen);

    _doubleValue = 1.5.0/docs/api/java/lang/Double.html">Double.parseDouble(_stringValue);

    _cursor = localCursor;

    return DOUBLE;

  }

  private int advanceWhileNumeric(int cursor) {

    for (; cursor < _buflen; cursor++) {

      if ((_buffer[cursor] < 48 || _buffer[cursor] > 57)) {

        return cursor;

      }

    }

    return cursor;

  }

  protected final int readNextToken(boolean consume) {

    while (true) {

      if (_cursor >= _buflen) fillBuffer(true);

      for (; _cursor < _buflen; _cursor++) {

        int token = _buffer[_cursor];

        if (token < 128 && SKIPPED_TOKENS[token] == 0) {