odin-lang.Odin/core/encoding/json/validator.odin

package json

import "core:mem"

// NOTE(bill): is_valid will not check for duplicate keys
is_valid :: proc(data: []byte, spec := Specification.JSON) -> bool {
	p := make_parser(data, spec, mem.nil_allocator());
	if p.spec == Specification.JSON5 {
		return validate_value(&p);
	}
	return validate_object(&p);
}

validate_object_key :: proc(p: ^Parser) -> bool {
	tok := p.curr_token;
	if p.spec == Specification.JSON5 {
		if tok.kind == .String {
			expect_token(p, .String);
			return true;
		} else if tok.kind == .Ident {
			expect_token(p, .Ident);
			return true;
		}
	}
	err := expect_token(p, .String);
	return err == Error.None;
}
validate_object :: proc(p: ^Parser) -> bool {
	if err := expect_token(p, .Open_Brace); err != Error.None {
		return false;
	}

	for p.curr_token.kind != .Close_Brace {
		if !validate_object_key(p) {
			return false;
		}
		if colon_err := expect_token(p, .Colon); colon_err != Error.None {
			return false;
		}

		if !validate_value(p) {
			return false;
		}

		if p.spec == Specification.JSON5 {
			// Allow trailing commas
			if allow_token(p, .Comma) {
				continue;
			}
		} else {
			// Disallow trailing commas
			if allow_token(p, .Comma) {
				continue;
			} else {
				break;
			}
		}
	}

	if err := expect_token(p, .Close_Brace); err != Error.None {
		return false;
	}
	return true;
}

validate_array :: proc(p: ^Parser) -> bool {
	if err := expect_token(p, .Open_Bracket); err != Error.None {
		return false;
	}

	for p.curr_token.kind != .Close_Bracket {
		if !validate_value(p) {
			return false;
		}

		// Disallow trailing commas for the time being
		if allow_token(p, .Comma) {
			continue;
		} else {
			break;
		}
	}

	if err := expect_token(p, .Close_Bracket); err != Error.None {
		return false;
	}

	return true;
}

validate_value :: proc(p: ^Parser) -> bool {
	token := p.curr_token;

	#partial switch token.kind {
	case .Null, .False, .True:
		advance_token(p);
		return true;
	case .Integer, .Float:
		advance_token(p);
		return true;
	case .String:
		advance_token(p);
		return is_valid_string_literal(token.text, p.spec);

	case .Open_Brace:
		return validate_object(p);

	case .Open_Bracket:
		return validate_array(p);

	case:
		if p.spec == Specification.JSON5 {
			#partial switch token.kind {
			case .Infinity, .NaN:
				advance_token(p);
				return true;
			}
		}
	}

	return false;
}