core/encoding/xml

encoding_xml

Types

Attribute :: struct {
	key: string,
	val: string,
}

Source

Attributes :: [dynamic]AttributeSource

Document :: struct {
	elements:        [dynamic]Element,
	element_count:   Element_ID,
	prologue:        Attributes,
	encoding:        Encoding,
	doctype:         struct {
		// We only scan the <!DOCTYPE IDENT part and skip the rest.
		ident: string,
		rest:  string,
	},
	// If we encounter comments before the root node, and the option to intern comments is given, this is where they'll live.
	// Otherwise they'll be in the element tree.
	comments:        [dynamic]string,
	// Internal
	tokenizer:       ^Tokenizer,
	allocator:       mem.Allocator,
	// Input. Either the original buffer, or a copy if `.Input_May_Be_Modified` isn't specified.
	input:           []u8,
	strings_to_free: [dynamic]string,
}

Source

Element :: struct {
	ident:   string,
	value:   [dynamic]Value,
	attribs: Attributes,
	kind:    enum,
	parent:  Element_ID,
}

Source

Element_ID :: u32Source

Encoding :: enum int {
	Unknown    = 0,
	UTF_8      = 1,
	ISO_8859_1 = 2,
	// Aliases
	LATIN_1    = ISO_8859_1,
}

Source

Error :: enum int {
	// General return values.
	None                          = 0,
	General_Error                 = 1,
	Unexpected_Token              = 2,
	Invalid_Token                 = 3,
	// Couldn't find, open or read file.
	File_Error                    = 4,
	// File too short.
	Premature_EOF                 = 5,
	// XML-specific errors.
	No_Prolog                     = 6,
	Invalid_Prolog                = 7,
	Too_Many_Prologs              = 8,
	No_DocType                    = 9,
	Too_Many_DocTypes             = 10,
	DocType_Must_Preceed_Elements = 11,
	// If a DOCTYPE is present _or_ the caller
	// asked for a specific DOCTYPE and the DOCTYPE
	// and root tag don't match, we return `.Invalid_DocType`.
	Invalid_DocType               = 12,
	Invalid_Tag_Value             = 13,
	Mismatched_Closing_Tag        = 14,
	Unclosed_Comment              = 15,
	Comment_Before_Root_Element   = 16,
	Invalid_Sequence_In_Comment   = 17,
	Unsupported_Version           = 18,
	Unsupported_Encoding          = 19,
	// <!FOO are usually skipped.
	Unhandled_Bang                = 20,
	Duplicate_Attribute           = 21,
	Conflicting_Options           = 22,
}

Source

Error_Handler :: proc(pos: Pos, fmt: string, args)Source

Option_Flag :: enum int {
	// If the caller says that input may be modified, we can perform in-situ parsing.
	// If this flag isn't provided, the XML parser first duplicates the input so that it can.
	Input_May_Be_Modified  = 0,
	// Document MUST start with `<?xml` prologue.
	Must_Have_Prolog       = 1,
	// Document MUST have a `<!DOCTYPE`.
	Must_Have_DocType      = 2,
	// By default we skip comments. Use this option to intern a comment on a parented Element.
	Intern_Comments        = 3,
	// How to handle unsupported parts of the specification, like <! other than <!DOCTYPE and <![CDATA[
	Error_on_Unsupported   = 4,
	Ignore_Unsupported     = 5,
	// By default CDATA tags are passed-through as-is.
	// This option unwraps them when encountered.
	Unbox_CDATA            = 6,
	// By default SGML entities like `&gt;`, `&#32;` and `&#x20;` are passed-through as-is.
	// This option decodes them when encountered.
	Decode_SGML_Entities   = 7,
	// If a tag body has a comment, it will be stripped unless this option is given.
	Keep_Tag_Body_Comments = 8,
}

Source

Option_Flags :: bit_set[Option_Flag; u16]Source

Options :: struct {
	flags:            Option_Flags,
	expected_doctype: string,
}

Source

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

Source

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

Source

Token_Kind :: enum int {
	Invalid       = 0,
	Ident         = 1,
	Literal       = 2,
	Rune          = 3,
	String        = 4,
	Double_Quote  = 5, // "
	Single_Quote  = 6, // '
	Colon         = 7, // :
	Eq            = 8, // =
	Lt            = 9, // <
	Gt            = 10, // >
	Exclaim       = 11, // !
	Question      = 12, // ?
	Hash          = 13, // #
	Slash         = 14, // /
	Dash          = 15, // -
	Open_Bracket  = 16, // [
	Close_Bracket = 17, // ]
	EOF           = 18,
}

Source

Tokenizer :: struct {
	// Immutable data
	path:        string,
	src:         string,
	err:         Error_Handler,
	// Tokenizing state
	ch:          rune,
	offset:      int,
	read_offset: int,
	line_offset: int,
	line_count:  int,
	// Mutable data
	error_count: int,
}

Source

Value :: union {
	string,
	Element_ID,
}

Source

Constants

CDATA_END :: "]]>"Source

CDATA_START :: "<![CDATA["Source

COMMENT_END :: "-->"Source

COMMENT_START :: "<!--"Source

DEFAULT_OPTIONS :: Options = Options{
	flags = {.Ignore_Unsupported},
	expected_doctype = "",
}

Source

likely :: intrinsics.expectSource

Procedures

advance_rune :: proc(t: ^Tokenizer)Source

check_duplicate_attributes :: proc(t: ^Tokenizer, attribs: Attributes, attr: Attribute, offset: int) -> (err: Error)Source

default_error_handler :: proc(pos: Pos, msg: string, args)Source

destroy :: proc(doc: ^Document, allocator: mem.Allocator = context.allocator)Source

error :: proc(t: ^Tokenizer, offset: int, msg: string, args)Source

expect :: proc(t: ^Tokenizer, kind: Token_Kind, multiline_string: untyped boolean = false) -> (tok: Token, err: Error)Source

find_attribute_val_by_key :: proc(doc: ^Document, parent_id: Element_ID, key: string) -> (val: string, found: bool)Source

Find an attribute by key.

find_child_by_ident :: proc(doc: ^Document, parent_id: Element_ID, ident: string, nth: untyped integer = 0) -> (res: Element_ID, found: bool)

Source

Find parent's nth child with a given ident.

init :: proc(t: ^Tokenizer, src: string, path: string, err: Error_Handler)Source

is_letter :: proc(r: rune) -> (bool)Source

is_valid_identifier_rune :: proc(r: rune) -> (bool)Source

load_from_file :: proc(filename: string, options = DEFAULT_OPTIONS, error_handler = default_error_handler, allocator: mem.Allocator = context.allocator) -> (doc: ^Document, err: Error)

Source

Load an XML file

new_element :: proc(doc: ^Document) -> (id: Element_ID)Source

parse_attribute :: proc(doc: ^Document) -> (attr: Attribute, offset: int, err: Error)Source

parse_attributes :: proc(doc: ^Document, attribs: ^Attributes) -> (err: Error)Source

parse_body :: proc(doc: ^Document, element: Element_ID, opts: Options) -> (err: Error)Source

parse_bytes :: proc(data: []u8, options = DEFAULT_OPTIONS, path: untyped string = "", error_handler = default_error_handler, allocator: mem.Allocator = context.allocator) -> (doc: ^Document, err: Error)

Source

parse_doctype :: proc(doc: ^Document) -> (err: Error)Source

parse_prologue :: proc(doc: ^Document) -> (err: Error)Source

parse_string :: proc(data: string, options = DEFAULT_OPTIONS, path: untyped string = "", error_handler = default_error_handler, allocator: mem.Allocator = context.allocator) -> (doc: ^Document, err: Error)

Source

peek :: proc(t: ^Tokenizer) -> (token: Token)Source

peek_byte :: proc(t: ^Tokenizer, offset: untyped integer = 0) -> (u8)Source

print :: proc(writer: io.Writer, doc: ^Document) -> (written: int, err: io.Error)Source

Just for debug purposes.

print_element :: proc(writer: io.Writer, doc: ^Document, element_id: Element_ID, indent: untyped integer = 0) -> (written: int, err: io.Error)

Source

scan :: proc(t: ^Tokenizer, multiline_string: untyped boolean = false) -> (Token)Source

scan_comment :: proc(t: ^Tokenizer) -> (comment: string, err: Error)Source

A comment ends when we see -->, preceded by a character that's not a dash.

"For compatibility, the string "--" (double-hyphen) must not occur within comments."

	See: https://www.w3.org/TR/2006/REC-xml11-20060816/#dt-comment

	Thanks to the length (4) of the comment start, we also have enough lookback,
	and the peek at the next byte asserts that there's at least one more character
	that's a `>`.

scan_identifier :: proc(t: ^Tokenizer) -> (string)Source

scan_string :: proc(t: ^Tokenizer, offset: int, close: rune, consume_close: untyped boolean = false, multiline: untyped boolean = true) -> (value: string, err: Error)

Source

skip_cdata :: proc(t: ^Tokenizer) -> (err: Error)Source

Skip CDATA

skip_element :: proc(t: ^Tokenizer) -> (err: Error)Source

skip_whitespace :: proc(t: ^Tokenizer)Source

validate_options :: proc(options: Options) -> (validated: Options, err: Error)Source

Helpers.

Procedure Groups

parse :: proc{parse_string, parse_bytes}Source

encoding_xml

Types

Constants

Procedures

Procedure Groups

Find anything

Settings