json_parser.cpp

struct Json_object;
struct Json_array;

struct Json_value {
    enum Type: u8 {
        INVALID, OBJECT, ARRAY, STRING, INTEGER, NUMBER, BOOLEAN, UNDEFINED,
        TYPE_COUNT
    };
    
    Array<u8> data;
    u64 handle;
    
    u8 type() { return handle >> 56; }
    u64 offset() { return handle & ((1ull << 56) - 1); }
    
    static Json_value make(Array<u8> data, u8 type, u64 offset=0) {
        assert(0 < type and type < TYPE_COUNT);
        assert(offset >> 56 == 0);
        return {data, (u64)type << 56 | offset};
    }
    
    template <typename T>
        Array<T> get_array() { return {(T*)&data[offset()+8], *(s64*)&data[offset()]}; }
    
    Json_object* obj() { return type() == OBJECT ? (Json_object*)this : nullptr; }
    Json_array*  arr() { return type() == ARRAY  ? (Json_array*) this : nullptr; }
    Array<u8> str(bool* err=nullptr) {
        if (type() != STRING) {
            if (err) *err = true;
            return {};
        }
        return get_array<u8>();
    }
    s64 integer(bool* err=nullptr) {
        if (type() != INTEGER) {
            if (err) *err = true;
            return -1;
        }
        u64 val = offset();
        if (val >> 57) val |= 0xffull << 56ull;
        return (s64)val;
    }
    double number(bool* err=nullptr) {
        if (type() != NUMBER) {
            if (err) *err = true;
            return -1;
        }
        return *(double*)&data[offset()+8];
    }
    double boolean(bool* err=nullptr) {
        if (type() != BOOLEAN) {
            if (err) *err = true;
            return false;
        }
        return offset();
    }
    bool is_null() { return type() == UNDEFINED; }
};

struct Json_object_entry {
    Json_value key, val;
};
struct Json_object_iter {
    Array<u8> data;
    u64 offset;
    
    Json_object_entry operator* () { return {{data, *(u64*)&data[offset]}, {data, *(u64*)&data[offset+8]}}; }
    Json_object_iter& operator++ () { offset += 16; return *this; }
    bool operator!= (Json_object_iter o) { return data.data != o.data.data or offset != o.offset; }
};

struct Json_object: Json_value {
    struct Entry {
        u64 key, val;
    };
    
    Array<Entry> entries() { return get_array<Entry>(); }
    s64 size() { return *(s64*)&data[offset()]; }
    
    Json_object_iter begin() { return {data, offset()+8}; }
    Json_object_iter end()   { return {data, offset()+8 + 8*size()}; }
    
    Json_value operator[] (char const* str) { return (*this)[array_from_str(str)]; }
    Json_value operator[] (Array<u8> str) {
        for (auto i: entries()) {
            Json_value i_key {data, i.key};
            Json_value i_val {data, i.val};
            if (array_equal(i_key.str(), str)) return i_val;
        }
        return Json_value::make(data, Json_value::UNDEFINED);
    }
    bool contains(Array<u8> str) {
        for (auto i: entries()) {
            Json_value i_key {data, i.key};
            if (array_equal(i_key.str(), str)) return true;
        }
        return false;
    }
};

struct Json_array_iter {
    Array<u8> data;
    u64 offset;
    
    Json_value operator* () { return {data, *(u64*)&data[offset]}; }
    Json_array_iter& operator++ () { offset += 8; return *this; }
    bool operator!= (Json_array_iter o) { return data.data != o.data.data or offset != o.offset; }
};
struct Json_array: Json_value {
    s64 size() { return *(s64*)&data[offset()]; }
    
    Json_array_iter begin() { return {data, offset()+8}; }
    Json_array_iter end()   { return {data, offset()+8 + 8*size()}; }
    
    Json_value operator[] (s64 i) {
        return {data, get_array<u64>()[i]};
    }
};

struct Json_parser {
    Array_dyn<u64> stack;
    Array_dyn<u8> data;
    Array<u8> input;
    s64 index;
    Status* status;
};

u8 json_parser_peek(Json_parser* parser) {
    if (parser->status->bad()) return 0;
    
    while (parser->index < parser->input.size) {
        u8 c = parser->input[parser->index];
        if (c == ' ' or c == '\t' or c == '\n' or c == '\r') {
            ++parser->index;
            continue;
        }
        if (c == 0) break;
        return c;
    }
    os_error_print(parser->status, 20250609001, "unexpected eof\n");
    return 0;
}

void json_parser_match(Json_parser* parser, u8 str) {
    u8 c = json_parser_peek(parser);
    if (not c) return;
    if (c != str) {
        return os_error_print(parser->status, 20250609002, "unexpected character %C (expected %C)\n", c, str);
    }
    ++parser->index;
}
void json_parser_match(Json_parser* parser, Array<u8> str) {
    for (s64 i = 0; i < str.size; ++i) {
        json_parser_match(parser, str[i]);
    }
}

void json_parser_value(Json_parser* parser);

void json_parser_string(Json_parser* parser) {
    json_parser_match(parser, '"');
    if (parser->status->bad()) return;
    u8 state = 0;
    
    s64 offset = parser->data.size;
    array_append_zero(&parser->data, 8);
    
    while (true) {
        if (parser->index >= parser->input.size) {
            return os_error_print(parser->status, 20250609003, "unexpected eof while reading string literal\n");
        }
        u8 c = parser->input[parser->index++];
        if (state == 0) {
            if (c == '\\') {
                state = 1;
            } else if (c == '"') {
                break;
            } else {
                array_push(&parser->data, c);
            }
        } else if (state == 1) {
            if (c == '"' or c == '\\' or c == '/') {
                array_push(&parser->data, c);
            } else if (c == 'b') { array_push(&parser->data, '\b');
            } else if (c == 'f') { array_push(&parser->data, '\f');
            } else if (c == 'n') { array_push(&parser->data, '\n');
            } else if (c == 'r') { array_push(&parser->data, '\r');
            } else if (c == 't') { array_push(&parser->data, '\t');
            } else if (c == 'u') { 
                if (parser->index+4 >= parser->data.size) {
                    return os_error_print(parser->status, 20250609004, "unexpected eof while reading unicode escape sequence\n");
                }
                u32 cp = 0;
                for (s64 i = 0; i < 4; ++i) {
                    u8 cc = parser->input[parser->index++];
                    if ('0' <= cc and cc <= '9') {
                        cp = 16*cp + (cc - '0');
                    } else if ('a' <= cc and cc <= 'z') {
                        cp = 16*cp + (cc - 'a' + 10);
                    } else if ('A' <= cc and cc <= 'Z') {
                        cp = 16*cp + (cc - 'A' + 10);
                    } else {
                        return os_error_print(parser->status, 20250609005, "invalid character %C in unicode escape sequence\n", cc);
                    }
                }
                if (not utf8_encode(cp, &parser->data)) {
                    return os_error_print(parser->status, 20250609006, "invalid codepoint U+%x\n", cp);
                }
            } else {
                return os_error_print(parser->status, 20250609007, "invalid escape character %C\n", c);
            }
            state = 0;
        } else assert(false);
    }
    
    *(s64*)&parser->data[offset] = parser->data.size - (offset+8);
    
    array_push(&parser->stack, offset | (u64)Json_value::STRING << 56);
}

void json_parser_object(Json_parser* parser) {
    json_parser_match(parser, '{');
    s64 index = parser->stack.size;
    bool first = true;
    while (true) {
        u8 c = json_parser_peek(parser);
        if (c == '}') {
            ++parser->index;
            break;
        } else if (first) {
            first = false;
        } else {
            json_parser_match(parser, ',');
        }
        
        json_parser_string(parser);
        json_parser_match(parser, ':');
        json_parser_value(parser);
        if (parser->status->bad()) return;
    }
    
    u64 offset = parser->data.size;
    array_append(&parser->data, array_bytes_arr(array_subarray(parser->stack, index)));
    parser->stack.size = index;
    array_push(&parser->stack, offset | (u64)Json_value::OBJECT << 56);
}

void json_parser_array(Json_parser* parser) {
    json_parser_match(parser, '[');
    s64 index = parser->stack.size;
    bool first = true;
    while (true) {
        u8 c = json_parser_peek(parser);
        if (c == ']') {
            ++parser->index;
            break;
        } else if (first) {
            first = false;
        } else {
            json_parser_match(parser, ',');
        }
        
        json_parser_value(parser);
        if (parser->status->bad()) return;
    }
    
    u64 offset = parser->data.size;
    array_append(&parser->data, array_bytes_arr(array_subarray(parser->stack, index)));
    parser->stack.size = index;
    array_push(&parser->stack, offset | (u64)Json_value::ARRAY << 56);
}

void json_parser_atom(Json_parser* parser, u8 c) {
    if (c == 't') {
        json_parser_match(parser, "true"_arr);
        array_push(&parser->stack, 1 | (u64)Json_value::BOOLEAN << 56);
    } else if (c == 'f') {
        json_parser_match(parser, "false"_arr);
        array_push(&parser->stack, 0 | (u64)Json_value::BOOLEAN << 56);
    } else if (c == 'n') {
        json_parser_match(parser, "null"_arr);
        array_push(&parser->stack, 0 | (u64)Json_value::UNDEFINED << 56);
    } else assert(false);
}

void json_parser_number(Json_parser* parser) {
    if (parser->status->bad()) return;
    
    s64 index = parser->index;
    u8 state = 0;
    s8 trans[9][6] = {
        {2,3,1,-1,-1,-1},{2,3,-1,-1,-1,-1},{-1,-1,-1,-1,6,4},
        {3,3,-1,-1,6,4},{5,5,-1,-1,-1,-1},{5,5,-1,-1,6,-1},
        {-1,-1,7,7,-1,-1},{8,8,-1,-1,-1,-1},{8,8,-1,-1,-1,-1}
    };
    
    while (true) {
        u8 c = parser->index < parser->input.size ? parser->input[parser->index] : 0;
        u8 cc = -1;
        if (c == '0') cc = 0;
        else if ('1' <= c and c <= '9') cc = 1;
        else if (c == '-') cc = 2;
        else if (c == '+') cc = 3;
        else if (c == 'e' or c == 'E') cc = 4;
        else if (c == '.') cc = 5;
        else break;
        ++parser->index;
        state = trans[state][cc];
    }
    
    if (not (state == 2 or state == 3 or state == 5 or state == 8)) {
        return os_error_print(parser->status, 20250609007, "invalid number format\n");
    }
    
    auto arr = array_subarray(parser->input, index, parser->index);
    if (state == 2 or state == 3) {
        s64 val = parse_int(arr);
        array_push(&parser->stack, (val & ((1ull << 56)-1)) | (u64)Json_value::INTEGER << 56);
    } else {
#ifdef PHILIB_NUMBER
        double val = number_parse<double>(arr, parser->status));
        if (parser->status->bad()) return;
        
        u64 offset = parser->data.size;
        array_append(&parser->data, array_bytes(&val));
        array_push(&parser->stack, offset | (u64)Json_value::NUMBER << 56);
#else
        assert(false);
#endif
    }
}

void json_parser_value(Json_parser* parser) {
    u8 c = json_parser_peek(parser);
    if (c == 0) return;
    
    if (c == '{') {
        json_parser_object(parser);
    } else if (c == '[') {
        json_parser_array(parser);
    } else if (c == '"') {
        json_parser_string(parser);
    } else if (c == 't' or c == 'f' or c == 'n') {
        json_parser_atom(parser, c);
    } else if ('0' <= c and c <= '9') {
        json_parser_number(parser);
    } else {
        return os_error_print(parser->status, 20250609008, "invalid value starting with %c\n", c);
    }
}

void json_parser_parse(Json_parser* parser, Array<u8> input, Status* status=nullptr) {
    if (os_status_initp(&status)) return;
    parser->input = input;
    parser->index = 0;
    parser->status = status;
    json_parser_value(parser);
    assert(parser->stack.size == 1);
}

Json_value json_parse(Array<u8> input, Status* status=nullptr) {
    if (os_status_initp(&status)) return Json_value::make({}, Json_value::UNDEFINED);;
    Json_parser parser;
    json_parser_parse(&parser, input, status);
    if (status->bad()) {
        array_free(&parser.stack);
        array_free(&parser.data);
        return Json_value::make({}, Json_value::UNDEFINED);
    }
    Json_value val {parser.data, parser.stack[0]};
    array_free(&parser.stack);
    return val;
}