package core:encoding/json

Source

Array :: distinct [dynamic]Value

Boolean :: bool

Error :: enum int {
	None, 
	EOF,                            // Not necessarily an error
	// Tokenizing Errors
	Illegal_Character, 
	Invalid_Number, 
	String_Not_Terminated, 
	Invalid_String, 
	// Parsing Errors
	Unexpected_Token, 
	Expected_String_For_Object_Key, 
	Duplicate_Object_Key, 
	Expected_Colon_After_Key, 
	// Allocating Errors
	Invalid_Allocator, 
	Out_Of_Memory, 
}

Float :: f64

Integer :: i64

Marshal_Data_Error :: enum int {
	None, 
	Unsupported_Type, 
}

Marshal_Error :: union {
	Marshal_Data_Error, 
	io.Error, 
}

Marshal_Options :: struct {
	// output based on spec
	spec:                             Specification,
	// use line breaks & tab|spaces
	pretty:                           bool,
	// spacing
	use_spaces:                       bool,
	spaces:                           int,
	// state
	indentation:                      int,
	// option to output uint in JSON5 & MJSON
	write_uint_as_hex:                bool,
	// mjson output options
	mjson_keys_use_quotes:            bool,
	mjson_keys_use_equal_sign:        bool,
	// mjson state
	mjson_skipped_first_braces_start: bool,
	mjson_skipped_first_braces_end:   bool,
}

Null :: distinct rawptr

Object :: distinct map[string]Value

Parser :: struct {
	tok:            Tokenizer,
	prev_token:     Token,
	curr_token:     Token,
	spec:           Specification,
	allocator:      runtime.Allocator,
	parse_integers: bool,
}

Pos :: struct {
	offset: int,
	line:   int,
	column: int,
}

Specification :: enum int {
	JSON, 
	JSON5,        // https://json5.org/
	SJSON,        // https://bitsquid.blogspot.com/2009/10/simplified-json-notation.html
	Bitsquid = 2, 
	MJSON    = 2, 
}

String :: string

Token :: struct {
	pos:  Pos,
	kind: Token_Kind,
	text: string,
}

Token_Kind :: enum int {
	Invalid, 
	EOF, 
	Null, 
	False, 
	True, 
	Infinity, 
	NaN, 
	Ident, 
	Integer, 
	Float, 
	String, 
	Colon, 
	Comma, 
	Open_Brace, 
	Close_Brace, 
	Open_Bracket, 
	Close_Bracket, 
}

Tokenizer :: struct {
	pos:              Pos,
	data:             string,
	r:                rune,
	// current rune
	w:                int,
	// current rune width in bytes
	curr_line_offset: int,
	spec:             Specification,
	parse_integers:   bool,
	insert_comma:     bool,
}

Unmarshal_Data_Error :: enum int {
	Invalid_Data, 
	Invalid_Parameter, 
	Non_Pointer_Parameter, 
	Multiple_Use_Field, 
}

Unmarshal_Error :: union {
	Error, 
	Unmarshal_Data_Error, 
	Unsupported_Type_Error, 
}

Unsupported_Type_Error :: struct {
	id:    typeid,
	token: Token,
}

Value :: union {
	Null, 
	i64, 
	f64, 
	bool, 
	string, 
	Array, 
	Object, 
}

DEFAULT_SPECIFICATION :: Specification.JSON5

advance_token :: proc "odin" (p: ^Parser) -> (Token, Error) {…}

allow_token :: proc "odin" (p: ^Parser, kind: Token_Kind) -> bool {…}

clone_string :: proc "odin" (s: string, allocator: runtime.Allocator) -> (str: string, err: Error) {…}

destroy_value :: proc "odin" (value: Value, allocator := context.allocator) {…}

expect_token :: proc "odin" (p: ^Parser, kind: Token_Kind) -> Error {…}

get_token :: proc "odin" (t: ^Tokenizer) -> (token: Token, err: Error) {…}

is_valid :: proc "odin" (data: []u8, spec: Specification = DEFAULT_SPECIFICATION, parse_integers: bool = false) -> bool {…}

is_valid_number :: proc "odin" (str: string, spec: Specification) -> bool {…}

is_valid_string_literal :: proc "odin" (str: string, spec: Specification) -> bool {…}

make_parser :: proc "odin" (data: []u8, spec: Specification = DEFAULT_SPECIFICATION, parse_integers: bool = false, allocator := context.allocator) -> Parser {…}

make_parser_from_string :: proc "odin" (data: string, spec: Specification = DEFAULT_SPECIFICATION, parse_integers: bool = false, allocator := context.allocator) -> Parser {…}

make_tokenizer :: proc "odin" (data: string, spec: Specification = DEFAULT_SPECIFICATION, parse_integers: bool = false) -> Tokenizer {…}

marshal :: proc "odin" (v: any, opt: Marshal_Options = {}, allocator := context.allocator) -> (data: []u8, err: Marshal_Error) {…}

marshal_to_builder :: proc "odin" (b: ^strings.Builder, v: any, opt: ^Marshal_Options) -> Marshal_Error {…}

marshal_to_writer :: proc "odin" (w: io.Writer, v: any, opt: ^Marshal_Options) -> (err: Marshal_Error) {…}

next_rune :: proc "odin" (t: ^Tokenizer) -> rune {…}

opt_write_end :: proc "odin" (w: io.Writer, opt: ^Marshal_Options, c: u8) -> (err: io.Error) {…}

opt_write_indentation :: proc "odin" (w: io.Writer, opt: ^Marshal_Options) -> (err: io.Error) {…}

opt_write_iteration :: proc "odin" (w: io.Writer, opt: ^Marshal_Options, iteration: int) -> (err: io.Error) {…}

opt_write_key :: proc "odin" (w: io.Writer, opt: ^Marshal_Options, name: string) -> (err: io.Error) {…}

opt_write_start :: proc "odin" (w: io.Writer, opt: ^Marshal_Options, c: u8) -> (err: io.Error) {…}

parse :: proc "odin" (data: []u8, spec: Specification = DEFAULT_SPECIFICATION, parse_integers: bool = false, allocator := context.allocator) -> (Value, Error) {…}

parse_array :: proc "odin" (p: ^Parser) -> (value: Value, err: Error) {…}

parse_colon :: proc "odin" (p: ^Parser) -> (err: Error) {…}

parse_comma :: proc "odin" (p: ^Parser) -> (do_break: bool) {…}

parse_object :: proc "odin" (p: ^Parser) -> (value: Value, err: Error) {…}

parse_object_body :: proc "odin" (p: ^Parser, end_token: Token_Kind) -> (obj: Object, err: Error) {…}

parse_object_key :: proc "odin" (p: ^Parser, key_allocator: runtime.Allocator) -> (key: string, err: Error) {…}

parse_string :: proc "odin" (data: string, spec: Specification = DEFAULT_SPECIFICATION, parse_integers: bool = false, allocator := context.allocator) -> (Value, Error) {…}

parse_value :: proc "odin" (p: ^Parser) -> (value: Value, err: Error) {…}

token_end_pos :: proc "odin" (tok: Token) -> Pos {…}

unmarshal :: proc "odin" (data: []u8, ptr: ^$T, spec: Specification = DEFAULT_SPECIFICATION, allocator := context.allocator) -> Unmarshal_Error {…}

unmarshal_any :: proc "odin" (data: []u8, v: any, spec: Specification = DEFAULT_SPECIFICATION, allocator := context.allocator) -> Unmarshal_Error {…}

unmarshal_string :: proc "odin" (data: string, ptr: ^$T, spec: Specification = DEFAULT_SPECIFICATION, allocator := context.allocator) -> Unmarshal_Error {…}

unquote_string :: proc "odin" (token: Token, spec: Specification, allocator := context.allocator) -> (value: string, err: Error) {…}

validate_array :: proc "odin" (p: ^Parser) -> bool {…}

validate_object :: proc "odin" (p: ^Parser) -> bool {…}

validate_object_body :: proc "odin" (p: ^Parser, end_token: Token_Kind) -> bool {…}

validate_object_key :: proc "odin" (p: ^Parser) -> bool {…}

validate_value :: proc "odin" (p: ^Parser) -> bool {…}