jsonpath.lua

local utf8 = require('utf8')
local utf8_next = utf8.next
local utf8_isalpha = utf8.isalpha
local utf8_isdigit = utf8.isdigit
local string_byte = string.byte
local string_sub = string.sub

local JSON_TOKEN_NUM = 1
local JSON_TOKEN_STR = 2
local JSON_TOKEN_ANY = 3
local JSON_TOKEN_END = 4

local JSON_TOKEN_TYPE = {
    JSON_TOKEN_NUM = JSON_TOKEN_NUM,
    JSON_TOKEN_STR = JSON_TOKEN_STR,
    JSON_TOKEN_ANY = JSON_TOKEN_ANY,
    JSON_TOKEN_END = JSON_TOKEN_END,
}

local ZERO_BYTE = string_byte('0')
local NINE_BYTE = string_byte('9')
local UNDERSCORE_BYTE = string_byte('_')
local OPEN_BRACKET_BYTE = string_byte('[')
local CLOSE_BRACKET_BYTE = string_byte(']')
local SINGLE_QUOTE_BYTE = string_byte("'")
local DOUBLE_QUOTE_BYTE = string_byte('"')
local STAR_BYTE = string_byte('*')
local DOT_BYTE = string_byte('.')

local function is_ascii_digit(codepoint)
    return codepoint ~= nil
        and ZERO_BYTE <= codepoint
        and codepoint <= NINE_BYTE
end

local function json_lexer_is_eof(offset, src_len)
    return offset > src_len
end

-- Read one UTF-8 symbol.
-- Error positions are 1-based character positions, as in Tarantool json.c.
local function json_read_symbol(src, src_len, offset, symbol_count)
    if json_lexer_is_eof(offset, src_len) then
        return offset, symbol_count, nil, symbol_count + 1
    end

    local next_offset, codepoint = utf8_next(src, offset)
    if codepoint == nil then
        return offset, symbol_count, nil, symbol_count + 1
    end

    return next_offset, symbol_count + 1, codepoint
end

local function json_parse_string(
    src,
    src_len,
    offset,
    symbol_count,
    quote_type,
    capture_value)
    -- Opening quote is always one-byte ASCII.
    offset = offset + 1
    symbol_count = symbol_count + 1
    local str_offset = offset

    while true do
        local char, err
        offset, symbol_count, char, err =
            json_read_symbol(src, src_len, offset, symbol_count)

        if err ~= nil then
            return offset, symbol_count, nil, nil, err
        end

        if char == quote_type then
            local len = offset - str_offset - 1
            if len == 0 then
                return offset, symbol_count, nil, nil, symbol_count
            end

            local value
            if capture_value then
                value = string_sub(
                    src,
                    str_offset,
                    str_offset + len - 1
                )
            end

            return offset, symbol_count, JSON_TOKEN_STR, value
        end
    end
end

local function json_parse_integer(
    src,
    offset,
    symbol_count,
    index_base
)
    local pos = offset
    local byte = string_byte(src, pos)

    if not is_ascii_digit(byte) then
        return offset, symbol_count, nil, nil, symbol_count + 1
    end

    local value = 0
    local len = 0

    repeat
        value = value * 10 + byte - ZERO_BYTE
        len = len + 1
        pos = pos + 1
        byte = string_byte(src, pos)
    until not is_ascii_digit(byte)

    if value < index_base then
        return offset, symbol_count, nil, nil, symbol_count + 1
    end

    --
    -- This is the important off-by-one fix.
    --
    -- Tarantool json_parse_integer() advances both offsets by
    -- exactly the number of consumed ASCII digits.
    --
    offset = offset + len
    symbol_count = symbol_count + len

    return offset, symbol_count, JSON_TOKEN_NUM, value - index_base
end

local function json_is_valid_identifier_symbol(char)
    return utf8_isalpha(char)
        or char == UNDERSCORE_BYTE
        or utf8_isdigit(char)
end

local function json_parse_identifier(
    src,
    src_len,
    offset,
    symbol_count,
    capture_value
)
    local str_offset = offset
    local char, err

    offset, symbol_count, char, err =
        json_read_symbol(src, src_len, offset, symbol_count)

    if err ~= nil then
        return offset, symbol_count, nil, nil, err
    end

    -- First symbol cannot be a digit.
    if not utf8_isalpha(char) and char ~= UNDERSCORE_BYTE then
        return offset, symbol_count, nil, nil, symbol_count
    end

    local last_offset = offset

    while true do
        offset, symbol_count, char, err =
            json_read_symbol(src, src_len, offset, symbol_count)

        if err ~= nil then
            break
        end

        if not json_is_valid_identifier_symbol(char) then
            offset = last_offset
            symbol_count = symbol_count - 1
            break
        end

        last_offset = offset
    end

    local value
    if capture_value then
        value = string_sub(src, str_offset, offset - 1)
    end

    return offset, symbol_count, JSON_TOKEN_STR, value
end

--
-- Returns:
--   updated byte offset,
--   updated symbol count,
--   token type,
--   token value (only when capture_value is true),
--   syntax error position.
--
local function json_lexer_next_token(
    src,
    src_len,
    offset,
    symbol_count,
    index_base,
    capture_value
)
    if json_lexer_is_eof(offset, src_len) then
        return offset, symbol_count, JSON_TOKEN_END
    end

    local last_offset = offset
    local char, err

    offset, symbol_count, char, err =
        json_read_symbol(src, src_len, offset, symbol_count)

    if err ~= nil then
        return offset, symbol_count, nil, nil, err
    end

    if char == OPEN_BRACKET_BYTE then
        -- Same special case as json.c for a trailing '['.
        if json_lexer_is_eof(offset, src_len) then
            return offset, symbol_count, nil, nil, symbol_count
        end

        local token_type
        local value

        -- Tarantool's json_current_char() reads a byte here.
        -- There is no reason to invoke utf8.next() for syntax bytes.
        char = string_byte(src, offset)

        if char == SINGLE_QUOTE_BYTE
            or char == DOUBLE_QUOTE_BYTE
        then
            offset, symbol_count, token_type, value, err =
                json_parse_string(
                    src,
                    src_len,
                    offset,
                    symbol_count,
                    char,
                    capture_value
                )
        elseif char == STAR_BYTE then
            -- '*' is one-byte ASCII.
            offset = offset + 1
            symbol_count = symbol_count + 1
            token_type = JSON_TOKEN_ANY
        else
            offset, symbol_count, token_type, value, err =
                json_parse_integer(
                    src,
                    offset,
                    symbol_count,
                    index_base
                )
        end

        if err ~= nil then
            return offset, symbol_count, nil, nil, err
        end

        if json_lexer_is_eof(offset, src_len)
            or string_byte(src, offset) ~= CLOSE_BRACKET_BYTE
        then
            return offset, symbol_count, nil, nil, symbol_count + 1
        end

        -- Closing ']' is one-byte ASCII.
        offset = offset + 1
        symbol_count = symbol_count + 1

        return offset, symbol_count, token_type, value
    end

    if char == DOT_BYTE then
        if json_lexer_is_eof(offset, src_len) then
            return offset, symbol_count, nil, nil, symbol_count + 1
        end

        return json_parse_identifier(
            src,
            src_len,
            offset,
            symbol_count,
            capture_value
        )
    end

    -- A bare identifier is allowed only as the first path component.
    if last_offset ~= 1 then
        return offset, symbol_count, nil, nil, symbol_count
    end

    -- Re-read the first symbol as part of the identifier.
    offset = last_offset
    symbol_count = symbol_count - 1

    return json_parse_identifier(
        src,
        src_len,
        offset,
        symbol_count,
        capture_value
    )
end

local function validate(path, base)
    local src_len = #path
    local offset = 1
    local symbol_count = 0
    local index_base = base or 0

    while true do
        local token_type, err
        local _

        offset, symbol_count, token_type, _, err =
            json_lexer_next_token(
                path,
                src_len,
                offset,
                symbol_count,
                index_base,
                false
            )

        if err ~= nil then
            return false, err
        end

        if token_type == JSON_TOKEN_END then
            return true
        end
    end
end

local function extract_tokens(path, base)
    local src_len = #path
    local offset = 1
    local symbol_count = 0
    local index_base = base or 0
    local result = {}
    local i = 1

    while true do
        local token_type, value, err

        offset, symbol_count, token_type, value, err =
            json_lexer_next_token(
                path,
                src_len,
                offset,
                symbol_count,
                index_base,
                true
            )

        if err ~= nil then
            return nil, err
        end

        if value == nil then
            result[i] = {
                type = token_type,
            }
        else
            result[i] = {
                type = token_type,
                value = value,
            }
        end

        if token_type == JSON_TOKEN_END then
            return result
        end
        i = i + 1
    end
end

return {
    JSON_TOKEN_TYPE = JSON_TOKEN_TYPE,
    validate = validate,
    extract_tokens = extract_tokens,
}