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 & tabs/spaces
	pretty:                           bool,
	// Use spaces for indentation instead of tabs
	use_spaces:                       bool,
	// Given use_spaces true, use this many spaces per indent level. 0 means 4 spaces.
	spaces:                           int,
	// Output uint as hex in JSON5 & MJSON
	write_uint_as_hex:                bool,
	// If spec is MJSON and this is true, then keys will be quoted.
	// 
	// WARNING: If your keys contain whitespace and this is false, then the
	// output will be bad.
	mjson_keys_use_quotes:            bool,
	// If spec is MJSON and this is true, then use '=' as delimiter between
	// keys and values, otherwise ':' is used.
	mjson_keys_use_equal_sign:        bool,
	// When outputting a map, sort the output by key.
	// 
	// NOTE: This will temp allocate and sort a list for each map.
	sort_maps_by_key:                 bool,
	// Output enum value's name instead of its underlying value.
	// 
	// NOTE: If a name isn't found it'll use the underlying value.
	use_enum_names:                   bool,
	// Internal state
	indentation:                      int,
	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 {
	using 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 {
	using 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(p: ^Parser) -> (Token, Error) {…}

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

clone_string :: proc(s: string, allocator: runtime.Allocator, loc := #caller_location) -> (str: string, err: Error) {…}

clone_value :: proc(value: Value, allocator := context.allocator) -> Value {…}

destroy_value :: proc(value: Value, allocator := context.allocator, loc := #caller_location) {…}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

opt_write_iteration :: proc(w: io.Stream, opt: ^Marshal_Options, first_iteration: bool) -> (err: io.Error) {…}

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

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

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

parse_array :: proc(p: ^Parser, loc := #caller_location) -> (value: Value, err: Error) {…}

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

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

parse_object :: proc(p: ^Parser, loc := #caller_location) -> (value: Value, err: Error) {…}

parse_object_body :: proc(p: ^Parser, end_token: Token_Kind, loc := #caller_location) -> (obj: Object, err: Error) {…}

parse_object_key :: proc(p: ^Parser, key_allocator: runtime.Allocator, loc := #caller_location) -> (key: string, err: Error) {…}

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

parse_value :: proc(p: ^Parser, loc := #caller_location) -> (value: Value, err: Error) {…}

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

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

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

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

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

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

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

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

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

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