com.fasterxml.jackson.core.io.CharTypes Java Examples

/**
 * Overridden to provide developer readable "JsonPath" representation
 * of the context.
 */
@Override
public String toString() {
    StringBuilder sb = new StringBuilder(64);
    switch (_type) {
    case TYPE_ROOT:
        sb.append("/");
        break;
    case TYPE_ARRAY:
        sb.append('[');
        sb.append(getCurrentIndex());
        sb.append(']');
        break;
    case TYPE_OBJECT:
        sb.append('{');
        if (_currentName != null) {
            sb.append('"');
            CharTypes.appendQuoted(sb, _currentName);
            sb.append('"');
        } else {
            sb.append('?');
        }
        sb.append('}');
        break;
    }
    return sb.toString();
}
 

/**
 * Method for skipping contents of an input line; usually for CPP
 * and YAML style comments.
 */
private final void _skipLine() throws IOException
{
    // Ok: need to find EOF or linefeed
    final int[] codes = CharTypes.getInputCodeComment();
    while ((_inputPtr < _inputEnd) || _loadMore()) {
        int i = (int) _inputBuffer[_inputPtr++] & 0xFF;
        int code = codes[i];
        if (code != 0) {
            switch (code) {
            case INT_LF:
                ++_currInputRow;
                _currInputRowStart = _inputPtr;
                return;
            case INT_CR:
                _skipCR();
                return;
            case '*': // nop for these comments
                break;
            case 2: // 2-byte UTF
                _skipUtf8_2();
                break;
            case 3: // 3-byte UTF
                _skipUtf8_3();
                break;
            case 4: // 4-byte UTF
                _skipUtf8_4(i);
                break;
            default: // e.g. -1
                if (code < 0) {
                    // Is this good enough error message?
                    _reportInvalidChar(i);
                }
            }
        }
    }
}
 

/**
 * Method for skipping contents of an input line; usually for CPP
 * and YAML style comments.
 */
private final void _skipLine() throws IOException
{
    // Ok: need to find EOF or linefeed
    final int[] codes = CharTypes.getInputCodeComment();
    while ((_inputPtr < _inputEnd) || loadMore()) {
        int i = (int) _inputBuffer[_inputPtr++] & 0xFF;
        int code = codes[i];
        if (code != 0) {
            switch (code) {
            case INT_LF:
                ++_currInputRow;
                _currInputRowStart = _inputPtr;
                return;
            case INT_CR:
                _skipCR();
                return;
            case '*': // nop for these comments
                break;
            case 2: // 2-byte UTF
                _skipUtf8_2(i);
                break;
            case 3: // 3-byte UTF
                _skipUtf8_3(i);
                break;
            case 4: // 4-byte UTF
                _skipUtf8_4(i);
                break;
            default: // e.g. -1
                if (code < 0) {
                    // Is this good enough error message?
                    _reportInvalidChar(i);
                }
            }
        }
    }
}
 

private final void _skipCComment() throws IOException
{
    // Need to be UTF-8 aware here to decode content (for skipping)
    final int[] codes = CharTypes.getInputCodeComment();
    int i = _inputData.readUnsignedByte();

    // Ok: need the matching '*/'
    main_loop:
    while (true) {
        int code = codes[i];
        if (code != 0) {
            switch (code) {
            case '*':
                i = _inputData.readUnsignedByte();
                if (i == INT_SLASH) {
                    return;
                }
                continue main_loop;
            case INT_LF:
            case INT_CR:
                ++_currInputRow;
                break;
            case 2: // 2-byte UTF
                _skipUtf8_2();
                break;
            case 3: // 3-byte UTF
                _skipUtf8_3();
                break;
            case 4: // 4-byte UTF
                _skipUtf8_4();
                break;
            default: // e.g. -1
                // Is this good enough error message?
                _reportInvalidChar(i);
            }
        }
        i = _inputData.readUnsignedByte();
    }
}
 

/**
 * Method for skipping contents of an input line; usually for CPP
 * and YAML style comments.
 */
private final void _skipLine() throws IOException
{
    // Ok: need to find EOF or linefeed
    final int[] codes = CharTypes.getInputCodeComment();
    while (true) {
        int i = _inputData.readUnsignedByte();
        int code = codes[i];
        if (code != 0) {
            switch (code) {
            case INT_LF:
            case INT_CR:
                ++_currInputRow;
                return;
            case '*': // nop for these comments
                break;
            case 2: // 2-byte UTF
                _skipUtf8_2();
                break;
            case 3: // 3-byte UTF
                _skipUtf8_3();
                break;
            case 4: // 4-byte UTF
                _skipUtf8_4();
                break;
            default: // e.g. -1
                if (code < 0) {
                    // Is this good enough error message?
                    _reportInvalidChar(i);
                }
            }
        }
    }
}
 

/**
     * Method called when we see non-white space character other
     * than double quote, when expecting a field name.
     * In standard mode will just throw an exception; but
     * in non-standard modes may be able to parse name.
     */
    private JsonToken _handleOddName(int ch) throws IOException
    {
        // First: may allow single quotes
        switch (ch) {
        case '#':
            // Careful, since this may alternatively be leading char of
            // unquoted name...
            if (JsonParser.Feature.ALLOW_YAML_COMMENTS.enabledIn(_features)) {
                return _finishHashComment(MINOR_FIELD_LEADING_WS);
            }
            break;
        case '/':
            return _startSlashComment(MINOR_FIELD_LEADING_WS);
        case '\'':
            if (isEnabled(Feature.ALLOW_SINGLE_QUOTES)) {
                return _finishAposName(0, 0, 0);
            }
            break;
        case ']': // for better error reporting...
            return _closeArrayScope();
        }
        // allow unquoted names if feature enabled:
        if (!isEnabled(Feature.ALLOW_UNQUOTED_FIELD_NAMES)) {
         // !!! TODO: Decode UTF-8 characters properly...
//            char c = (char) _decodeCharForError(ch);
            char c = (char) ch;
            _reportUnexpectedChar(c, "was expecting double-quote to start field name");
        }
        // Also: note that although we use a different table here, it does NOT handle UTF-8
        // decoding. It'll just pass those high-bit codes as acceptable for later decoding.
        final int[] codes = CharTypes.getInputCodeUtf8JsNames();
        // Also: must start with a valid character...
        if (codes[ch] != 0) {
            _reportUnexpectedChar(ch, "was expecting either valid name character (for unquoted name) or double-quote (for quoted) to start field name");
        }

        return _finishUnquotedName(0, ch, 1);
    }
 

/**
 * Overridden to provide developer readable "JsonPath" representation
 * of the context.
 * 
 * @since 2.9
 */
@Override
public String toString() {
    StringBuilder sb = new StringBuilder(64);
    switch (_type) {
    case TYPE_ROOT:
        sb.append("/");
        break;
    case TYPE_ARRAY:
        sb.append('[');
        sb.append(getCurrentIndex());
        sb.append(']');
        break;
    case TYPE_OBJECT:
    default:
        sb.append('{');
        String currentName = getCurrentName();
        if (currentName != null) {
            sb.append('"');
            CharTypes.appendQuoted(sb, currentName);
            sb.append('"');
        } else {
            sb.append('?');
        }
        sb.append('}');
        break;
    }
    return sb.toString();
}
 

@Override
protected char _decodeEscaped() throws IOException
{
    if (_inputPtr >= _inputEnd) {
        if (!loadMore()) {
            _reportInvalidEOF(" in character escape sequence");
        }
    }
    char c = _inputBuffer[_inputPtr++];

    switch ((int) c) {
        // First, ones that are mapped
    case 'b':
        return '\b';
    case 't':
        return '\t';
    case 'n':
        return '\n';
    case 'f':
        return '\f';
    case 'r':
        return '\r';

        // And these are to be returned as they are
    case '"':
    case '/':
    case '\\':
        return c;

    case 'u': // and finally hex-escaped
        break;

    default:
        return _handleUnrecognizedCharacterEscape(c);
    }

    // Ok, a hex escape. Need 4 characters
    int value = 0;
    for (int i = 0; i < 4; ++i) {
        if (_inputPtr >= _inputEnd) {
            if (!loadMore()) {
                _reportInvalidEOF(" in character escape sequence");
            }
        }
        int ch = (int) _inputBuffer[_inputPtr++];
        int digit = CharTypes.charToHex(ch);
        if (digit < 0) {
            _reportUnexpectedChar(ch, "expected a hex-digit for character escape sequence");
        }
        value = (value << 4) | digit;
    }
    return (char) value;
}
 

protected static void appendQuoted(StringBuilder sb, String content)
{
    sb.append('"');
    CharTypes.appendQuoted(sb, content);
    sb.append('"');
}
 

@Override
protected char _decodeEscaped() throws IOException
{
    if (_inputPtr >= _inputEnd) {
        if (!loadMore()) {
            _reportInvalidEOF(" in character escape sequence");
        }
    }
    int c = (int) _inputBuffer[_inputPtr++];

    switch (c) {
        // First, ones that are mapped
    case 'b':
        return '\b';
    case 't':
        return '\t';
    case 'n':
        return '\n';
    case 'f':
        return '\f';
    case 'r':
        return '\r';

        // And these are to be returned as they are
    case '"':
    case '/':
    case '\\':
        return (char) c;

    case 'u': // and finally hex-escaped
        break;

    default:
        return _handleUnrecognizedCharacterEscape((char) _decodeCharForError(c));
    }

    // Ok, a hex escape. Need 4 characters
    int value = 0;
    for (int i = 0; i < 4; ++i) {
        if (_inputPtr >= _inputEnd) {
            if (!loadMore()) {
                _reportInvalidEOF(" in character escape sequence");
            }
        }
        int ch = (int) _inputBuffer[_inputPtr++];
        int digit = CharTypes.charToHex(ch);
        if (digit < 0) {
            _reportUnexpectedChar(ch, "expected a hex-digit for character escape sequence");
        }
        value = (value << 4) | digit;
    }
    return (char) value;
}
 

private final void _skipCComment() throws IOException
{
    // Need to be UTF-8 aware here to decode content (for skipping)
    final int[] codes = CharTypes.getInputCodeComment();

    // Ok: need the matching '*/'
    main_loop:
    while ((_inputPtr < _inputEnd) || loadMore()) {
        int i = (int) _inputBuffer[_inputPtr++] & 0xFF;
        int code = codes[i];
        if (code != 0) {
            switch (code) {
            case '*':
                if (_inputPtr >= _inputEnd && !loadMore()) {
                    break main_loop;
                }
                if (_inputBuffer[_inputPtr] == INT_SLASH) {
                    ++_inputPtr;
                    return;
                }
                break;
            case INT_LF:
                ++_currInputRow;
                _currInputRowStart = _inputPtr;
                break;
            case INT_CR:
                _skipCR();
                break;
            case 2: // 2-byte UTF
                _skipUtf8_2(i);
                break;
            case 3: // 3-byte UTF
                _skipUtf8_3(i);
                break;
            case 4: // 4-byte UTF
                _skipUtf8_4(i);
                break;
            default: // e.g. -1
                // Is this good enough error message?
                _reportInvalidChar(i);
            }
        }
    }
    _reportInvalidEOF(" in a comment");
}
 

/**
 * Method called when we see non-white space character other
 * than double quote, when expecting a field name.
 * In standard mode will just throw an expection; but
 * in non-standard modes may be able to parse name.
 */
protected String _handleOddName(int ch) throws IOException
{
    // [JACKSON-173]: allow single quotes
    if (ch == '\'' && isEnabled(Feature.ALLOW_SINGLE_QUOTES)) {
        return _parseAposName();
    }
    // [JACKSON-69]: allow unquoted names if feature enabled:
    if (!isEnabled(Feature.ALLOW_UNQUOTED_FIELD_NAMES)) {
        char c = (char) _decodeCharForError(ch);
        _reportUnexpectedChar(c, "was expecting double-quote to start field name");
    }
    /* Also: note that although we use a different table here,
     * it does NOT handle UTF-8 decoding. It'll just pass those
     * high-bit codes as acceptable for later decoding.
     */
    final int[] codes = CharTypes.getInputCodeUtf8JsNames();
    // Also: must start with a valid character...
    if (codes[ch] != 0) {
        _reportUnexpectedChar(ch, "was expecting either valid name character (for unquoted name) or double-quote (for quoted) to start field name");
    }

    /* Ok, now; instead of ultra-optimizing parsing here (as with
     * regular JSON names), let's just use the generic "slow"
     * variant. Can measure its impact later on if need be
     */
    int[] quads = _quadBuffer;
    int qlen = 0;
    int currQuad = 0;
    int currQuadBytes = 0;

    while (true) {
        // Ok, we have one more byte to add at any rate:
        if (currQuadBytes < 4) {
            ++currQuadBytes;
            currQuad = (currQuad << 8) | ch;
        } else {
            if (qlen >= quads.length) {
                _quadBuffer = quads = growArrayBy(quads, quads.length);
            }
            quads[qlen++] = currQuad;
            currQuad = ch;
            currQuadBytes = 1;
        }
        if (_inputPtr >= _inputEnd) {
            if (!loadMore()) {
                _reportInvalidEOF(" in field name");
            }
        }
        ch = _inputBuffer[_inputPtr] & 0xFF;
        if (codes[ch] != 0) {
            break;
        }
        ++_inputPtr;
    }

    if (currQuadBytes > 0) {
        if (qlen >= quads.length) {
            _quadBuffer = quads = growArrayBy(quads, quads.length);
        }
        quads[qlen++] = currQuad;
    }
    String name = _symbols.findName(quads, qlen);
    if (name == null) {
        name = addName(quads, qlen, currQuadBytes);
    }
    return name;
}
 

private int _decodeSplitEscaped(int value, int bytesRead) throws IOException
{
    if (_inputPtr >= _inputEnd) {
        _quoted32 = value;
        _quotedDigits = bytesRead;
        return -1;
    }
    int c = _inputBuffer[_inputPtr++];
    if (bytesRead == -1) { // expecting first char after backslash
        switch (c) {
            // First, ones that are mapped
        case 'b':
            return '\b';
        case 't':
            return '\t';
        case 'n':
            return '\n';
        case 'f':
            return '\f';
        case 'r':
            return '\r';

            // And these are to be returned as they are
        case '"':
        case '/':
        case '\\':
            return c;

        case 'u': // and finally hex-escaped
            break;

        default:
            {
             // !!! TODO: Decode UTF-8 characters properly...
//              char ch = (char) _decodeCharForError(c);
                char ch = (char) c;
                return _handleUnrecognizedCharacterEscape(ch);
            }
        }
        if (_inputPtr >= _inputEnd) {
            _quotedDigits = 0;
            _quoted32 = 0;
            return -1;
        }
        c = _inputBuffer[_inputPtr++];
        bytesRead = 0;
    }
    c &= 0xFF;
    while (true) {
        int digit = CharTypes.charToHex(c);
        if (digit < 0) {
            _reportUnexpectedChar(c, "expected a hex-digit for character escape sequence");
        }
        value = (value << 4) | digit;
        if (++bytesRead == 4) {
            return value;
        }
        if (_inputPtr >= _inputEnd) {
            _quotedDigits = bytesRead;
            _quoted32 = value;
            return -1;
        }
        c = _inputBuffer[_inputPtr++] & 0xFF;
    }
}
 

/**
 * Parsing of optionally supported non-standard "unquoted" names: names without
 * either double-quotes or apostrophes surrounding them.
 * Unlike other 
 */
private JsonToken _finishUnquotedName(int qlen, int currQuad, int currQuadBytes)
    throws IOException
{
    int[] quads = _quadBuffer;
    final int[] codes = CharTypes.getInputCodeUtf8JsNames();

    // Ok, now; instead of ultra-optimizing parsing here (as with regular JSON names),
    // let's just use the generic "slow" variant. Can measure its impact later on if need be.
    while (true) {
        if (_inputPtr >= _inputEnd) {
            _quadLength = qlen;
            _pending32 = currQuad;
            _pendingBytes = currQuadBytes;
            _minorState = MINOR_FIELD_UNQUOTED_NAME;
            return (_currToken = JsonToken.NOT_AVAILABLE);
        }
        int ch = _inputBuffer[_inputPtr] & 0xFF;
        if (codes[ch] != 0) {
            break;
        }
        ++_inputPtr;
        // Ok, we have one more byte to add at any rate:
        if (currQuadBytes < 4) {
            ++currQuadBytes;
            currQuad = (currQuad << 8) | ch;
        } else {
            if (qlen >= quads.length) {
                _quadBuffer = quads = growArrayBy(quads, quads.length);
            }
            quads[qlen++] = currQuad;
            currQuad = ch;
            currQuadBytes = 1;
        }
    }

    if (currQuadBytes > 0) {
        if (qlen >= quads.length) {
            _quadBuffer = quads = growArrayBy(quads, quads.length);
        }
        quads[qlen++] = currQuad;
    }
    String name = _symbols.findName(quads, qlen);
    if (name == null) {
        name = _addName(quads, qlen, currQuadBytes);
    }
    return _fieldComplete(name);
}
 

@Override
protected char _decodeEscaped() throws IOException
{
    if (_inputPtr >= _inputEnd) {
        if (!_loadMore()) {
            _reportInvalidEOF(" in character escape sequence", JsonToken.VALUE_STRING);
        }
    }
    char c = _inputBuffer[_inputPtr++];

    switch ((int) c) {
        // First, ones that are mapped
    case 'b':
        return '\b';
    case 't':
        return '\t';
    case 'n':
        return '\n';
    case 'f':
        return '\f';
    case 'r':
        return '\r';

        // And these are to be returned as they are
    case '"':
    case '/':
    case '\\':
        return c;

    case 'u': // and finally hex-escaped
        break;

    default:
        return _handleUnrecognizedCharacterEscape(c);
    }

    // Ok, a hex escape. Need 4 characters
    int value = 0;
    for (int i = 0; i < 4; ++i) {
        if (_inputPtr >= _inputEnd) {
            if (!_loadMore()) {
                _reportInvalidEOF(" in character escape sequence", JsonToken.VALUE_STRING);
            }
        }
        int ch = (int) _inputBuffer[_inputPtr++];
        int digit = CharTypes.charToHex(ch);
        if (digit < 0) {
            _reportUnexpectedChar(ch, "expected a hex-digit for character escape sequence");
        }
        value = (value << 4) | digit;
    }
    return (char) value;
}
 

@Override
protected char _decodeEscaped() throws IOException
{
    int c = _inputData.readUnsignedByte();

    switch (c) {
        // First, ones that are mapped
    case 'b':
        return '\b';
    case 't':
        return '\t';
    case 'n':
        return '\n';
    case 'f':
        return '\f';
    case 'r':
        return '\r';

        // And these are to be returned as they are
    case '"':
    case '/':
    case '\\':
        return (char) c;

    case 'u': // and finally hex-escaped
        break;

    default:
        return _handleUnrecognizedCharacterEscape((char) _decodeCharForError(c));
    }

    // Ok, a hex escape. Need 4 characters
    int value = 0;
    for (int i = 0; i < 4; ++i) {
        int ch = _inputData.readUnsignedByte();
        int digit = CharTypes.charToHex(ch);
        if (digit < 0) {
            _reportUnexpectedChar(ch, "expected a hex-digit for character escape sequence");
        }
        value = (value << 4) | digit;
    }
    return (char) value;
}
 

/**
 * Method called when we see non-white space character other
 * than double quote, when expecting a field name.
 * In standard mode will just throw an exception; but
 * in non-standard modes may be able to parse name.
 */
protected String _handleOddName(int ch) throws IOException
{
    if (ch == '\'' && isEnabled(Feature.ALLOW_SINGLE_QUOTES)) {
        return _parseAposName();
    }
    if (!isEnabled(Feature.ALLOW_UNQUOTED_FIELD_NAMES)) {
        char c = (char) _decodeCharForError(ch);
        _reportUnexpectedChar(c, "was expecting double-quote to start field name");
    }
    /* Also: note that although we use a different table here,
     * it does NOT handle UTF-8 decoding. It'll just pass those
     * high-bit codes as acceptable for later decoding.
     */
    final int[] codes = CharTypes.getInputCodeUtf8JsNames();
    // Also: must start with a valid character...
    if (codes[ch] != 0) {
        _reportUnexpectedChar(ch, "was expecting either valid name character (for unquoted name) or double-quote (for quoted) to start field name");
    }

    /* Ok, now; instead of ultra-optimizing parsing here (as with
     * regular JSON names), let's just use the generic "slow"
     * variant. Can measure its impact later on if need be
     */
    int[] quads = _quadBuffer;
    int qlen = 0;
    int currQuad = 0;
    int currQuadBytes = 0;

    while (true) {
        // Ok, we have one more byte to add at any rate:
        if (currQuadBytes < 4) {
            ++currQuadBytes;
            currQuad = (currQuad << 8) | ch;
        } else {
            if (qlen >= quads.length) {
                _quadBuffer = quads = _growArrayBy(quads, quads.length);
            }
            quads[qlen++] = currQuad;
            currQuad = ch;
            currQuadBytes = 1;
        }
        ch = _inputData.readUnsignedByte();
        if (codes[ch] != 0) {
            break;
        }
    }
    // Note: we must "push back" character read here for future consumption
    _nextByte = ch;
    if (currQuadBytes > 0) {
        if (qlen >= quads.length) {
            _quadBuffer = quads = _growArrayBy(quads, quads.length);
        }
        quads[qlen++] = currQuad;
    }
    String name = _symbols.findName(quads, qlen);
    if (name == null) {
        name = addName(quads, qlen, currQuadBytes);
    }
    return name;
}
 

@Override
protected char _decodeEscaped() throws IOException
{
    if (_inputPtr >= _inputEnd) {
        if (!_loadMore()) {
            _reportInvalidEOF(" in character escape sequence", JsonToken.VALUE_STRING);
        }
    }
    int c = (int) _inputBuffer[_inputPtr++];

    switch (c) {
        // First, ones that are mapped
    case 'b':
        return '\b';
    case 't':
        return '\t';
    case 'n':
        return '\n';
    case 'f':
        return '\f';
    case 'r':
        return '\r';

        // And these are to be returned as they are
    case '"':
    case '/':
    case '\\':
        return (char) c;

    case 'u': // and finally hex-escaped
        break;

    default:
        return _handleUnrecognizedCharacterEscape((char) _decodeCharForError(c));
    }

    // Ok, a hex escape. Need 4 characters
    int value = 0;
    for (int i = 0; i < 4; ++i) {
        if (_inputPtr >= _inputEnd) {
            if (!_loadMore()) {
                _reportInvalidEOF(" in character escape sequence", JsonToken.VALUE_STRING);
            }
        }
        int ch = (int) _inputBuffer[_inputPtr++];
        int digit = CharTypes.charToHex(ch);
        if (digit < 0) {
            _reportUnexpectedChar(ch, "expected a hex-digit for character escape sequence");
        }
        value = (value << 4) | digit;
    }
    return (char) value;
}
 

private final void _skipCComment() throws IOException
{
    // Need to be UTF-8 aware here to decode content (for skipping)
    final int[] codes = CharTypes.getInputCodeComment();

    // Ok: need the matching '*/'
    main_loop:
    while ((_inputPtr < _inputEnd) || _loadMore()) {
        int i = (int) _inputBuffer[_inputPtr++] & 0xFF;
        int code = codes[i];
        if (code != 0) {
            switch (code) {
            case '*':
                if (_inputPtr >= _inputEnd && !_loadMore()) {
                    break main_loop;
                }
                if (_inputBuffer[_inputPtr] == INT_SLASH) {
                    ++_inputPtr;
                    return;
                }
                break;
            case INT_LF:
                ++_currInputRow;
                _currInputRowStart = _inputPtr;
                break;
            case INT_CR:
                _skipCR();
                break;
            case 2: // 2-byte UTF
                _skipUtf8_2();
                break;
            case 3: // 3-byte UTF
                _skipUtf8_3();
                break;
            case 4: // 4-byte UTF
                _skipUtf8_4(i);
                break;
            default: // e.g. -1
                // Is this good enough error message?
                _reportInvalidChar(i);
            }
        }
    }
    _reportInvalidEOF(" in a comment", null);
}
 

/**
 * Method called when we see non-white space character other
 * than double quote, when expecting a field name.
 * In standard mode will just throw an exception; but
 * in non-standard modes may be able to parse name.
 */
protected String _handleOddName(int ch) throws IOException
{
    // First: may allow single quotes
    if (ch == INT_APOS && isEnabled(Feature.ALLOW_SINGLE_QUOTES)) {
        return _parseAposName();
    }
    // Allow unquoted names if feature enabled:
    if (!isEnabled(Feature.ALLOW_UNQUOTED_FIELD_NAMES)) {
        char c = (char) _decodeCharForError(ch);
        _reportUnexpectedChar(c, "was expecting double-quote to start field name");
    }
    /* Also: note that although we use a different table here,
     * it does NOT handle UTF-8 decoding. It'll just pass those
     * high-bit codes as acceptable for later decoding.
     */
    final int[] codes = CharTypes.getInputCodeUtf8JsNames();
    // Also: must start with a valid character...
    if (codes[ch] != 0) {
        _reportUnexpectedChar(ch, "was expecting either valid name character (for unquoted name) or double-quote (for quoted) to start field name");
    }

    // Ok, now; instead of ultra-optimizing parsing here (as with regular
    // JSON names), let's just use the generic "slow" variant.
    // Can measure its impact later on if need be.
    int[] quads = _quadBuffer;
    int qlen = 0;
    int currQuad = 0;
    int currQuadBytes = 0;

    while (true) {
        // Ok, we have one more byte to add at any rate:
        if (currQuadBytes < 4) {
            ++currQuadBytes;
            currQuad = (currQuad << 8) | ch;
        } else {
            if (qlen >= quads.length) {
                _quadBuffer = quads = growArrayBy(quads, quads.length);
            }
            quads[qlen++] = currQuad;
            currQuad = ch;
            currQuadBytes = 1;
        }
        if (_inputPtr >= _inputEnd) {
            if (!_loadMore()) {
                _reportInvalidEOF(" in field name", JsonToken.FIELD_NAME);
            }
        }
        ch = _inputBuffer[_inputPtr] & 0xFF;
        if (codes[ch] != 0) {
            break;
        }
        ++_inputPtr;
    }

    if (currQuadBytes > 0) {
        if (qlen >= quads.length) {
            _quadBuffer = quads = growArrayBy(quads, quads.length);
        }
        quads[qlen++] = currQuad;
    }
    String name = _symbols.findName(quads, qlen);
    if (name == null) {
        name = addName(quads, qlen, currQuadBytes);
    }
    return name;
}