diff options
Diffstat (limited to 'include/hoxml.h')
| -rw-r--r-- | include/hoxml.h | 1497 |
1 files changed, 1497 insertions, 0 deletions
diff --git a/include/hoxml.h b/include/hoxml.h new file mode 100644 index 0000000..d7addec --- /dev/null +++ b/include/hoxml.h @@ -0,0 +1,1497 @@ +/* +Copyright (c) 2024-2025 Luke Philipsen + +Permission to use, copy, modify, and/or distribute this software for +any purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL +WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES +OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE +FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY +DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN +AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT +OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +/* Usage + + Do this: + #define HOXML_IMPLEMENTATION + before you include this file in *one* C or C++ file to create the implementation. + + You can define HOXML_DECL with + #define HOXML_DECL static + or + #define HOXML_DECL extern + to specify hoxml function declarations as static or extern, respectively. + The default specifier is extern. +*/ + +#ifndef HOXML_H + #define HOXML_H + +#include <stdlib.h> /* strtoul() */ +#include <string.h> /* memcpy(), memset(), NULL, size_t */ + +#ifndef HOXML_DECL + #define HOXML_DECL +#endif /* HOXML_DECL */ + +#ifdef __cplusplus + extern "C" { +#endif /* __cpluspus */ + +/***************/ +/* Definitions */ + +/** + * Error and token codes returned after parsing. + */ +typedef enum { + HOXML_ERROR_INVALID_INPUT = -9, /**< One or more parameter passed to hoxml was unacceptable. */ + HOXML_ERROR_INTERNAL = -8, /**< There's a bug in hoxml and parsing must halt. */ + HOXML_ERROR_INSUFFICIENT_MEMORY = -7, /**< Initialization or continued parsing require more memory. */ + HOXML_ERROR_UNEXPECTED_EOF = -6, /**< Reached the end of the XML content before the end of the document. */ + HOXML_ERROR_SYNTAX = -5, /**< Syntax error (e.g. "<element<"). */ + HOXML_ERROR_ENCODING = -4, /**< Character encoding error or contradiction. */ + HOXML_ERROR_TAG_MISMATCH = -3, /**< Close tag does not match the open tag (e.g. "<tag>" followed by "</tga>"). */ + HOXML_ERROR_INVALID_DOCUMENT_TYPE_DECLARATION = -2, /**< <!DOCTYPE> declaration not before the root element. */ + HOXML_ERROR_INVALID_DOCUMENT_DECLARATION = -1, /**< <?xml?> declaration not before the root element. */ + HOXML_END_OF_DOCUMENT = 0, /**< The root element has been closed, parsing is done. */ + HOXML_ELEMENT_BEGIN, /**< A new element/tag began and its name is available. */ + HOXML_ELEMENT_END, /**< An element was closed, </tag> or <tag/>, and its name and content are available. */ + HOXML_ATTRIBUTE, /**< An attribute's value, its name, and its element are available. */ + HOXML_PROCESSING_INSTRUCTION_BEGIN, /**< A processing instruction began and its target is available. */ + HOXML_PROCESSING_INSTRUCTION_END /**< A processing instruction ended and its content is available. */ +} hoxml_code_t; + +/** + * Holds context and state information needed by hoxml. Some of this information is public and holds the data parsed + * from XML content (element names, attribute names and values, etc.) but some is private and only makes sense to hoxml. + */ +typedef struct { + /* Public */ + char* tag; /**< Holds the name of the open or just-closed tag, or processing instruction target. */ + char* attribute; /**< Holds the current attribute's name. */ + char* value; /**< Holds the current attribute's value. */ + char* content; /**< Holds the current element's content. This means all character data found, including spaces. */ + int line; /**< The line currently being parsed. Lines are determined by line feeds and carriage returns. */ + int column; /**< The column, on the current line, of the character last parsed. */ + int depth; /**< The nested level of elements. Assigned with the level in which the element was found. */ + + /* Private (for internal use) */ + int is_initialized; /* Set to 1, or true, by hoxml_init() and indicates this context is safe to use */ + const char* xml; /* XML content to be parsed */ + size_t xml_length; /* Length of the XML content to parse */ + int encoding; /* Character encoding of the XML content */ + const char* iterator; /* Pointer to the character in the XML content being parsed */ + char* buffer; /* Memory allocated for hoxml to use */ + size_t buffer_length; /* Amount of memory allocated for hoxml */ + char* reference_start; /* Pointer to a location on the stack where a reference entity string (e.g "<") began */ + char* stack; /* Pointer to the current node in the stack-like structure of elements */ + int state; /* Current parsing state, determines which characters are acceptable and when to return */ + int post_state; /* When not "none" this indicates a post-state that has a cleanup step */ + int return_state; /* State to return to after the processing of a comment or reference has finished */ + int error_return_state; /* State to return to after recovering from an error */ + unsigned long stream; /* Holds the current character, whole or partial. May contain bytes from different strings. */ + size_t stream_length; /* Length of the 'stream' variable in bytes */ + unsigned newline_character; /* The character used to increment the 'line' variable, \r or \n */ +} hoxml_context_t; + +/** + * Sets up the hoxml context object to begin parsing. Following this, call hoxml_parse() until + * HOXML_END_OF_DOCUMENT or one of the error values is returned. + * + * @param context Pointer to an allocated hoxml context object. This instance will be modified. + * @param buffer A pointer to some contiguous block of memory for hoxml to use. This will also be modified, frequently. + * @param buffer_length The length, in bytes, of the buffer handed to hoxml as the 'buffer' parameter. + */ +HOXML_DECL void hoxml_init(hoxml_context_t* context, void* buffer, size_t buffer_length); + +/** + * Instruct hoxml to use a new buffer. This maintains the current state of parsing meaning that the next call to + * hoxml_parse() will continue none the wiser. + * The buffer must have a length greater than the current buffer and both buffers must be allocated at the time this + * function is called. Once it returns, the original buffer may and should be freed. + * + * @param context An initialized hoxml context object. + * @param buffer A pointer to a new, contiguous block of memory for hoxml to use. + * @param buffer_length The length, in bytes, of the buffer handed to hoxml as the 'buffer' parameter. + */ +HOXML_DECL void hoxml_realloc(hoxml_context_t* context, void* buffer, size_t buffer_length); + +/** + * Begin or continue parsing the given XML content string. + * The XML content string does not need to contain the content in its entirety. If hoxml finds a null terminator or + * parses up to the indicated length of the content, HOXML_ERROR_UNEXPECTED_EOF is returned and parsing will cease. + * However, this error is recoverable and parsing will continue if the next call to hoxml_parse() passes a new XML + * content string, using the same pointer or not. + * + * @param context An initialized hoxml context object. This should be treated as read-only until parsing is done. + * @param xml XML content as an encoded string. Supported character encodings include ASCII, UTF-8, and UTF-16(BE|LE). + * @param xml_length Length of the XML content in bytes. + * @return A code indicating what information from the XML content is available or an error. + */ +HOXML_DECL hoxml_code_t hoxml_parse(hoxml_context_t* context, const char* xml, size_t xml_length); + +#ifdef __cplusplus + } +#endif /* __cplusplus */ + +#ifdef HOXML_IMPLEMENTATION + +/******************/ +/* Implementation */ + +enum { + /* Current parser states */ + HOXML_STATE_ERROR_INTERNAL = -8, + HOXML_STATE_ERROR_INSUFFICIENT_MEMORY = -7, + HOXML_STATE_ERROR_UNEXPECTED_EOF = -6, + HOXML_STATE_ERROR_SYNTAX = -5, + HOXML_STATE_ERROR_ENCODING = -4, + HOXML_STATE_ERROR_TAG_MISMATCH = -3, + HOXML_STATE_ERROR_INVALID_DOCUMENT_TYPE_DECLARATION = -2, + HOXML_STATE_ERROR_INVALID_DOCUMENT_DECLARATION = -1, + HOXML_STATE_NONE = 0, + HOXML_STATE_UTF8_BOM1, + HOXML_STATE_UTF8_BOM2, + HOXML_STATE_UTF16BE_BOM, + HOXML_STATE_UTF16LE_BOM, + HOXML_STATE_TAG_BEGIN, + HOXML_STATE_TAG_END, + HOXML_STATE_ELEMENT_NAME1, + HOXML_STATE_ELEMENT_NAME2, + HOXML_STATE_ATTRIBUTE_NAME1, + HOXML_STATE_ATTRIBUTE_NAME2, + HOXML_STATE_ATTRIBUTE_ASSIGNMENT, + HOXML_STATE_ATTRIBUTE_VALUE, + HOXML_STATE_OPEN_TAG, + HOXML_STATE_COMMENT_CDATA_OR_DTD_BEGIN, + HOXML_STATE_COMMENT_BEGIN, + HOXML_STATE_COMMENT, + HOXML_STATE_COMMENT_END1, + HOXML_STATE_COMMENT_END2, + HOXML_STATE_CDATA_BEGIN1, + HOXML_STATE_CDATA_BEGIN2, + HOXML_STATE_CDATA_BEGIN3, + HOXML_STATE_CDATA_BEGIN4, + HOXML_STATE_CDATA_BEGIN5, + HOXML_STATE_CDATA_BEGIN6, + HOXML_STATE_CDATA_CONTENT, + HOXML_STATE_CDATA_END1, + HOXML_STATE_CDATA_END2, + HOXML_STATE_REFERENCE_BEGIN, + HOXML_STATE_REFERENCE_ENTITY, + HOXML_STATE_REFERENCE_NUMERIC, + HOXML_STATE_REFERENCE_HEX, + HOXML_STATE_PROCESSING_INSTRUCTION_BEGIN, + HOXML_STATE_PROCESSING_INSTRUCTION_TARGET1, + HOXML_STATE_PROCESSING_INSTRUCTION_TARGET2, + HOXML_STATE_PROCESSING_INSTRUCTION_CONTENT, + HOXML_STATE_PROCESSING_INSTRUCTION_END, + HOXML_STATE_DTD_BEGIN1, + HOXML_STATE_DTD_BEGIN2, + HOXML_STATE_DTD_BEGIN3, + HOXML_STATE_DTD_BEGIN4, + HOXML_STATE_DTD_BEGIN5, + HOXML_STATE_DTD_BEGIN6, + HOXML_STATE_DTD_BEGIN7, + HOXML_STATE_DTD_BEGIN8, + HOXML_STATE_DTD_NAME, + HOXML_STATE_DTD_CONTENT, + HOXML_STATE_DTD_OPEN_BRACKET, + HOXML_STATE_DONE, + /* Post (i.e. after) parser states indicating actions to take on the next call to hoxml_parse() */ + HOXML_POST_STATE_TAG_END, + HOXML_POST_STATE_ATTRIBUTE_END, +}; + +enum { + HOXML_FLAG_END_TAG = 1, /* The node is a dedicated end tag (not an empty element) */ + HOXML_FLAG_EMPTY_ELEMENT = 2, /* The node is an empty element */ + HOXML_FLAG_PROCESSING_INSTRUCTION = 4, /* The node is a processing instruction */ + HOXML_FLAG_DOUBLE_QUOTE = 8, /* The value string being parsed was opened with a double quote (") */ + HOXML_FLAG_TERMINATED = 16, /* The node's current string (tag, attribute, etc.) is null terminated */ + HOXML_FLAG_BEGUN = 32, /* The "element begun" code was already returned for this node */ + HOXML_FLAG_INCREMENT_DEPTH = 64, /* Context object's depth value should increase by one next hoxml_parse() */ + HOXML_FLAG_DECREMENT_DEPTH = 128 /* Context object's depth value should decrease by one next hoxml_parse() */ +}; + +enum { + HOXML_ENC_UNKNOWN = 0, /* The character encoding is unknown. UTF-8 is assumed. */ + HOXML_ENC_UTF_8, /* Variable-length encoding (8, 16, 24, or 32 bits) compatible with ASCII */ + HOXML_ENC_UTF_16_LE, /* Variable-length encoding (16 or 32 bits), little-endian variant */ + HOXML_ENC_UTF_16_BE /* Variable-lenght encoding (16 or 32 bits), big-endian variant */ +}; + +enum { + HOXML_CASE_SENSITIVE = 0, /* Cases must match. 'A' == 'a' -> false. */ + HOXML_CASE_INSENSITIVE /* Cases need not match. 'A' == 'a' -> true. */ +}; + +enum { + HOXML_REF_TYPE_ENTITY = 0, /* Predefined strings representing known, problematic characters (e.g. '<') */ + HOXML_REF_TYPE_NUMERIC, /* A value of a character given as a decimal number */ + HOXML_REF_TYPE_HEX /* A value of a character given as a hexadecimal number */ +}; + +struct _hoxml_node_t; +typedef struct _hoxml_node_t { + struct _hoxml_node_t* parent; /* Points to the parent node, or NULL if this is the root */ + char* end; /* Points to the last byte of this node's data */ + int flags; /* May contain any number of the flags defined in hoxml_node_flags */ + char tag; /* Where the tag string will be stored in the buffer, must be defined last */ +} hoxml_node_t; + +typedef struct { + unsigned encoded; /* Character as it appeared in the content. In other words, the original, encoded character. */ + unsigned codepoint; /* Unicode codepoint of the character. In other words, the decoded character. */ + size_t bytes; /* Number of eight-bit bytes of the encoded character, in the [1, 4] range */ +} hoxml_character_t; + +#ifndef UINT32_MAX /* Defined in stdint.h with later revisions of C and C++ but not for some earlier ones */ + #define UINT32_MAX (0xffffffff) +#endif +#define HOXML_STACK ((hoxml_node_t*)context->stack) +#define HOXML_TO_LOWER(c) (c >= 'A' && c <= 'Z' ? c + 32 : c) +#define HOXML_IS_NEW_LINE(c) (c == 0x0A || c == 0x0D) +#define HOXML_IS_WHITESPACE(c) (c == 0x20 || c == 0x09 || HOXML_IS_NEW_LINE(c)) +#define HOXML_IS_ASCII_CHAR(c) (c >= 0x21 && c <= 0x7F) +#define HOXML_IS_CHAR_DATA(c) (c != '<' && c != '&') +#define HOXML_IS_ALPHA(c) ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) +#define HOXML_IS_NUMERIC(c) (c >= '0' && c <= '9') +#define HOXML_IS_NAME_START_CHAR(c) (HOXML_IS_ALPHA(c) || c == ':' || c == '_' || (c >= 0xC0 && c <= 0xD6) || \ + (c >= 0xD8 && c <= 0xF6) || c >= 0xF8) +#define HOXML_IS_NAME_CHAR(c) (HOXML_IS_NAME_START_CHAR(c) || c == '-' || c == '.'|| HOXML_IS_NUMERIC(c)) +#define HOXML_IS_HEX_CHAR(c) (HOXML_IS_NUMERIC(c) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')) +#define HOXML_IS_VALUE_CHAR_DATA(f, c) (HOXML_IS_CHAR_DATA(c) && ((f & HOXML_FLAG_DOUBLE_QUOTE && c != '"') || \ + c != '\'')) + +void hoxml_push_stack(hoxml_context_t* context); +void hoxml_pop_stack(hoxml_context_t* context); +void hoxml_append_character(hoxml_context_t* context, hoxml_character_t c); +void hoxml_append_terminator(hoxml_context_t* context); +void hoxml_end_reference(hoxml_context_t* context, int type); +void hoxml_begin_tag(hoxml_context_t* context); +hoxml_code_t hoxml_end_tag(hoxml_context_t* context); +int hoxml_post_state_cleanup(hoxml_context_t* context); +hoxml_character_t hoxml_decode_character(const char* str, size_t str_length, int encoding); +hoxml_character_t hoxml_encode_character(unsigned codepoint, int encoding); +char* hoxml_to_ascii(const char* str, int encoding); +size_t hoxml_strlen(const char* str, int encoding); +int hoxml_strcmp(const char* str1, int encoding1, const char* str2, int encoding2, int sensitivity); +const char* hoxml_strstr(const char* haystack, int haystack_encoding, const char* needle, int needle_encoding, + int sensitivity); +#ifdef HOXML_DEBUG + #include <stdio.h> /* printf() */ + #define HOXML_LOG_STATE(s) printf("%s\n", s); +#else + #define HOXML_LOG_STATE(s) +#endif + +HOXML_DECL void hoxml_init(hoxml_context_t* context, void* buffer, size_t buffer_length) { + if (context == NULL || buffer == NULL || buffer_length <= 0) + return; + + memset(context, 0, sizeof(hoxml_context_t)); /* Assign all values of the context to zero */ + context->buffer = (char*)buffer; /* Use the provided buffer */ + context->buffer_length = buffer_length; /* Remember the length of the provided buffer */ + context->line = 1; /* This is meant to be human-readable and humans begin counting at one */ + context->is_initialized = 1; + memset(buffer, 0, buffer_length); /* Fill the buffer with zeroes */ +} + +HOXML_DECL void hoxml_realloc(hoxml_context_t* context, void* buffer, size_t buffer_length) { + if (context == NULL || context->is_initialized == 0 || buffer == NULL || buffer_length <= context->buffer_length) + return; + + /* Reassign the end and parent pointers of each node, beginning at the tail and iterate to the head */ + hoxml_node_t* node = HOXML_STACK; + while (node != NULL) { + hoxml_node_t* parent = node->parent; + node->end = (char*)buffer + (node->end - context->buffer); + if (node->parent != NULL) + node->parent = (hoxml_node_t*)((char*)buffer + ((char*)node->parent - context->buffer)); + node = parent; + } + + /* Use offsets from the original buffer pointer to reassign pointers such that they now point to the new buffer */ + if (context->tag != NULL) + context->tag = (char*)buffer + (context->tag - context->buffer); + if (context->attribute != NULL) + context->attribute = (char*)buffer + (context->attribute - context->buffer); + if (context->value != NULL) + context->value = (char*)buffer + (context->value - context->buffer); + if (context->content != NULL) + context->content = (char*)buffer + (context->content - context->buffer); + if (context->reference_start != NULL) + context->reference_start = (char*)buffer + (context->reference_start - context->buffer); + if (context->stack != NULL) + context->stack = (char*)buffer + (context->stack - context->buffer); + + memset(buffer, 0, buffer_length); /* Fill the new buffer with zeroes */ + memcpy(buffer, context->buffer, context->buffer_length); /* Copy the entire, current buffer to the new buffer */ + context->buffer = (char*)buffer; + context->buffer_length = buffer_length; + + if (context->state == HOXML_STATE_ERROR_INSUFFICIENT_MEMORY) { + context->state = context->error_return_state; + context->error_return_state = HOXML_STATE_NONE; + } +} + +HOXML_DECL hoxml_code_t hoxml_parse(hoxml_context_t* context, const char* xml, const size_t xml_length) { + if (context == NULL || context->is_initialized == 0 || xml == NULL || xml_length == 0) + return HOXML_ERROR_INVALID_INPUT; + + if (HOXML_STACK != NULL) { + if (HOXML_STACK->flags & HOXML_FLAG_INCREMENT_DEPTH) { /* If an element began, increasing nesting */ + context->depth += 1; + HOXML_STACK->flags &= ~HOXML_FLAG_INCREMENT_DEPTH; /* Clear the flag */ + } + + if (HOXML_STACK->flags & HOXML_FLAG_DECREMENT_DEPTH) { /* If an element ended, decreasing nesting */ + context->depth -= 1; + HOXML_STACK->flags &= ~HOXML_FLAG_DECREMENT_DEPTH; /* Clear the flag */ + } + } + + switch (context->state) { + /* Two errors are recoverable: HOXML_ERROR_INSUFFICIENT_MEMORY and HOXML_ERROR_UNEXPECTED_EOF. The former can */ + /* be recovered by assigning a new buffer with hoxml_realloc(). The latter can be recovered by passing a new */ + /* XML content string to hoxml_parse() so we'll check for one before concluding we're still in error. */ + case HOXML_STATE_ERROR_UNEXPECTED_EOF: { + /* Try to decode a character, or remainder of a character, at the beginning of this hopefully-new string */ + unsigned long stream = context->stream; + /* Calculate the number of bytes to copy into the 'stream' variable from the hopefully-new string. We */ + /* want 4 bytes, or whatever is available. */ + size_t bytes_to_copy = 4; + if (bytes_to_copy > xml_length) + bytes_to_copy = xml_length; + if (context->stream_length > 0) { + /* Adjust the number of bytes to copy to account for possible bytes from a previous string */ + bytes_to_copy -= context->stream_length; + /* Append the new bytes to the previous one(s) */ + memcpy((char*)&stream + context->stream_length, xml, bytes_to_copy); + } + else { + /* Copy to the 'stream' under the assumption that all of it can be overwritten */ + memcpy(&stream, xml, bytes_to_copy); + } + hoxml_character_t c = hoxml_decode_character((const char*)&stream, xml_length, context->encoding); + /* If the character is the equivalent of a null terminator or there was not enough data */ + if (c.codepoint == 0 || c.codepoint == UINT32_MAX) + return HOXML_ERROR_UNEXPECTED_EOF; + context->state = context->error_return_state; + context->error_return_state = HOXML_STATE_NONE; + /* Note: there is a check for a change in the input pointer a little further down */ + } break; + case HOXML_STATE_DONE: return HOXML_END_OF_DOCUMENT; + case HOXML_STATE_ERROR_INTERNAL: return HOXML_ERROR_INTERNAL; + case HOXML_STATE_ERROR_INSUFFICIENT_MEMORY: return HOXML_ERROR_INSUFFICIENT_MEMORY; + case HOXML_STATE_ERROR_SYNTAX: return HOXML_ERROR_SYNTAX; + case HOXML_STATE_ERROR_ENCODING: return HOXML_ERROR_ENCODING; + case HOXML_STATE_ERROR_TAG_MISMATCH: return HOXML_ERROR_TAG_MISMATCH; + case HOXML_STATE_ERROR_INVALID_DOCUMENT_DECLARATION: return HOXML_ERROR_INVALID_DOCUMENT_DECLARATION; + } + + /* A handful of cases leave the context in an intermediary state. This allows the caller to have access to things */ + /* like the tag's name, an attribute's value, etc. but that old data may now need to be cleaned up. */ + if (hoxml_post_state_cleanup(context)) /* If the cleanup process found the document ended */ + return HOXML_END_OF_DOCUMENT; + + /* If the pointer to the XML content string has changed */ + if (context->xml != xml) { + /* A few variables are now invalid: the pointer to the content, its length, and the iterator */ + context->xml = xml; + context->xml_length = xml_length; + context->iterator = xml; + } + + /* Remember some context variables in case we hit an unexpected EoF and need to undo an iteration */ + const char* previous_iterator = context->iterator; + size_t previous_stream_length = context->stream_length; + while (context->state >= HOXML_STATE_NONE && context->state <= HOXML_STATE_DONE) { + /* About half of the parsing states assume the stack is non-null. */ + /* If parsing is currently in one of those states and the stack (head) pointer is null. */ + if (((context->state >= HOXML_STATE_TAG_BEGIN && context->state <= HOXML_STATE_OPEN_TAG) || + (context->state >= HOXML_STATE_REFERENCE_BEGIN && context->state <= HOXML_STATE_REFERENCE_HEX)) && + context->stack == NULL) { + /* Some unforseen bug has led us to a state in which continuing would cause an illegal memory access. */ + /* Parsing must halt. There is no way to recover. */ + context->state = HOXML_STATE_ERROR_INTERNAL; + return HOXML_ERROR_INTERNAL; + } + + /* Calculate the number of bytes remaining in the current XML content string */ + size_t bytes_remaining = (size_t)(context->xml_length - (context->iterator - context->xml)); + /* Calculate the number of bytes to copy into the 'stream' variable. We want 4 bytes, or whatever is left. */ + size_t bytes_to_copy = 4; + if (bytes_to_copy > bytes_remaining) + bytes_to_copy = bytes_remaining; + if (context->stream_length > 0) { + /* Adjust the number of bytes to copy to account for possible bytes from a previous XML content string. */ + /* This will be non-zero in the rare case where content is being given in parts. */ + bytes_to_copy -= context->stream_length; + /* Append the new bytes to the previous one(s) */ + memcpy((char*)&(context->stream) + context->stream_length, context->iterator, bytes_to_copy); + } + else { + /* Copy to the 'stream' under the assumption that all of it can be overwritten */ + memcpy(&(context->stream), context->iterator, bytes_to_copy); + } + hoxml_character_t c = hoxml_decode_character((const char*)&(context->stream), bytes_remaining, + context->encoding); + + /* If the character is the equivalent of a null terminator or there was not enough data to decode the value */ + if (c.codepoint == 0 || c.codepoint == UINT32_MAX) { + context->stream_length = bytes_to_copy; + context->error_return_state = context->state; + context->state = HOXML_STATE_ERROR_UNEXPECTED_EOF; + return HOXML_ERROR_UNEXPECTED_EOF; + } else if (HOXML_IS_NEW_LINE(c.codepoint)) { + if (context->newline_character == 0) /* If this is the first newline */ + context->newline_character = c.codepoint; /* Remember this as the character to use for increments */ + if (c.codepoint == context->newline_character) /* Avoid incrementing twice for files with \r\n endings */ + context->line++; + context->column = 0; + } else + context->column++; + + /* Iterate up to four bytes into the XML content string. The idea is to jump forward by the number of bytes */ + /* that were just decoded as a single character. The number of bytes varies from one to four bytes depending */ + /* on the character encoding and character's codepoint. We also need to consider the case in which some of */ + /* this character's bytes were carried over from a previous XML content string. Those bytes would have been */ + /* stashed in the context's 'stream' variable where 'stream_length' tells us the number of said bytes. */ + previous_iterator = context->iterator; + previous_stream_length = context->stream_length; + context->iterator += c.bytes - context->stream_length; + context->stream_length = 0; + + #ifdef HOXML_DEBUG + char debugCodepoint = HOXML_IS_NEW_LINE(c.codepoint) ? ' ' : c.codepoint; + printf(" %c [%08X] [L%02dC%02d] -> ", debugCodepoint, c.codepoint, context->line, context->column); + #endif + + switch(context->state) { + case HOXML_STATE_NONE: /* The first state immediately following initialization, or a document declaration */ + HOXML_LOG_STATE("HOXML_STATE_NONE") + if (c.codepoint == '<') + hoxml_begin_tag(context); + else if (c.encoded == 0xEF) { /* UTF-8 Byte Order Marker (BOM) is [EF] BB BF, as hex bytes */ + context->state = HOXML_STATE_UTF8_BOM1; + context->column--; /* Don't count this as a column */ + } else if (c.encoded == 0xFE) { /* UTF-16BE BOM is [FE] FF, as hex bytes */ + context->state = HOXML_STATE_UTF16BE_BOM; + context->column--; /* Don't count this as a column */ + } else if (c.encoded == 0xFF) { /* UTF-16LE BOM is [FF] FE, as hex bytes */ + context->state = HOXML_STATE_UTF16LE_BOM; + context->column--; /* Don't count this as a column */ + } else if (!HOXML_IS_WHITESPACE(c.codepoint)) + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_UTF8_BOM1: /* The first byte of a UTF-8 byte order marker was found */ + HOXML_LOG_STATE("HOXML_STATE_UTF8_BOM1") + context->column--; /* Don't count this as a column */ + if (c.encoded == 0xBB) /* UTF-8 BOM is EF [BB] BF, as hex bytes */ + context->state = HOXML_STATE_UTF8_BOM2; + else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_UTF8_BOM2: /* The second byte of a UTF-8 byte order marker was found */ + HOXML_LOG_STATE("HOXML_STATE_UTF8_BOM2") + context->column--; /* Don't count this as a column */ + if (c.encoded == 0xBF) { /* UTF-8 BOM is EF BB [BF], as hex bytes */ + context->state = HOXML_STATE_NONE; + context->encoding = HOXML_ENC_UTF_8; + } else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_UTF16BE_BOM: /* The first byte of a UTF-16BE byte order marker was found */ + HOXML_LOG_STATE("HOXML_STATE_UTF16BE_BOM") + context->column--; /* Don't count this as a column */ + if (c.encoded == 0xFF) { /* UTF-16BE BOM is FE [FF], as hex bytes */ + context->state = HOXML_STATE_NONE; + context->encoding = HOXML_ENC_UTF_16_BE; + } else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_UTF16LE_BOM: /* The first byte of a UTF-16LE byte order marker was found */ + HOXML_LOG_STATE("HOXML_STATE_UTF16LE_BOM") + context->column--; /* Don't count this as a column */ + if (c.encoded == 0xFE) { /* UTF-16LE BOM is FF [FE], as hex bytes */ + context->state = HOXML_STATE_NONE; + context->encoding = HOXML_ENC_UTF_16_LE; + } else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_TAG_BEGIN: /* A new tag was started (a '<' was found) and a new node has been pushed */ + HOXML_LOG_STATE("HOXML_STATE_TAG_BEGIN") + if (c.codepoint == '?') { /* "<?" begins a processing instruction */ + context->state = HOXML_STATE_PROCESSING_INSTRUCTION_BEGIN; + HOXML_STACK->flags |= HOXML_FLAG_PROCESSING_INSTRUCTION; /* Apply the PI flag to this node */ + } else if (c.codepoint == '/') /* "</" begins an end tag */ + HOXML_STACK->flags |= HOXML_FLAG_END_TAG; /* Apply the end tag flag to this node */ + else if (c.codepoint == '!') /* "<!--" = comment, "<![CDATA[" = CDATA, and "<!DOCTYPE" = DTD */ + context->state = HOXML_STATE_COMMENT_CDATA_OR_DTD_BEGIN; + else if (HOXML_IS_NAME_START_CHAR(c.codepoint)) { + hoxml_append_character(context, c); + if (context->state >= HOXML_STATE_NONE) { /* If appending the character was successful */ + context->state = HOXML_STATE_ELEMENT_NAME1; + context->tag = &(HOXML_STACK->tag); /* The tag's name string will begin here */ + } + } else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_ELEMENT_NAME1: /* A name start character was found after '<' (e.g. the 't' in "<tag>") */ + HOXML_LOG_STATE("HOXML_STATE_ELEMENT_NAME1") + if (c.codepoint == '>') { + hoxml_append_terminator(context); + if (context->state >= HOXML_STATE_NONE) /* If appending the terminator was successful */ + return hoxml_end_tag(context); + } else if (c.codepoint == '/') { /* The tag is an empty element, AKA self-closed tag (e.g. "<tag/>") */ + if (HOXML_STACK->flags & HOXML_FLAG_END_TAG) /* If it's also a regular close tag (e.g. "</tag/>") */ + context->state = HOXML_STATE_ERROR_SYNTAX; + else { + hoxml_append_terminator(context); + if (context->state >= HOXML_STATE_NONE) { /* If appending the terminator was successful */ + HOXML_STACK->flags |= HOXML_FLAG_EMPTY_ELEMENT; /* Apply the empty element flag */ + return HOXML_ELEMENT_BEGIN; + } + } + } else if (HOXML_IS_WHITESPACE(c.codepoint)) { /* If whitespace ended the element name (e.g. "<tag ") */ + hoxml_append_terminator(context); + if (context->state >= HOXML_STATE_NONE) { /* If appending the terminator was successful */ + context->state = HOXML_STATE_ELEMENT_NAME2; + HOXML_STACK->flags |= HOXML_FLAG_BEGUN; /* Indicate "element begun" has already been returned */ + return HOXML_ELEMENT_BEGIN; + } + } else if (HOXML_IS_NAME_CHAR(c.codepoint)) + hoxml_append_character(context, c); + else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_ELEMENT_NAME2: /* Whitespace was found after a tag name (e.g. "<tag >") */ + HOXML_LOG_STATE("HOXML_STATE_ELEMENT_NAME2") + if (c.codepoint == '>') { + hoxml_append_terminator(context); + if (context->state >= HOXML_STATE_NONE) { /* If appending the terminator was successful */ + /* If "element begun" has already been returned for this element and this element is not */ + /* self-closing (i.e. the element has the form "<tag ... />" where "..." may be attributes) */ + if (HOXML_STACK->flags & HOXML_FLAG_BEGUN && + !(HOXML_STACK->flags & HOXML_FLAG_EMPTY_ELEMENT)) { + hoxml_end_tag(context); /* Do not return, "element begun" was returned when the name ended */ + hoxml_post_state_cleanup(context); /* Because hoxml_parse() won't be called, clean up now */ + } else + return hoxml_end_tag(context); + } + } else if (c.codepoint == '/') { /* The tag is an empty element, AKA self-closed tag (e.g. "<tag/>") */ + if (HOXML_STACK->flags & HOXML_FLAG_END_TAG) /* If it's also a regular close tag (e.g. "</tag/>") */ + context->state = HOXML_STATE_ERROR_SYNTAX; + else + HOXML_STACK->flags |= HOXML_FLAG_EMPTY_ELEMENT; /* Apply the empty element flag to this node */ + } else if (HOXML_IS_NAME_START_CHAR(c.codepoint)) { /* First letter of an attribute name */ + hoxml_append_character(context, c); + if (context->state >= HOXML_STATE_NONE) { /* If appending the character was successful */ + context->state = HOXML_STATE_ATTRIBUTE_NAME1; + context->attribute = HOXML_STACK->end; /* The attribute's name string began here */ + } + } else if (!HOXML_IS_WHITESPACE(c.codepoint)) + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_ATTRIBUTE_NAME1: /* A name start character was found inside a tag after whitespace */ + HOXML_LOG_STATE("HOXML_STATE_ATTRIBUTE_NAME1") + if (c.codepoint == '=') { /* The name was immediately followed by '=' */ + hoxml_append_terminator(context); + if (context->state >= HOXML_STATE_NONE) /* If appending the terminator was successful */ + context->state = HOXML_STATE_ATTRIBUTE_ASSIGNMENT; + } else if (HOXML_IS_NAME_CHAR(c.codepoint)) + hoxml_append_character(context, c); + else if (HOXML_IS_WHITESPACE(c.codepoint)) { /* Whitespace after the name, only '=' is allowed next */ + hoxml_append_terminator(context); + if (context->state >= HOXML_STATE_NONE) /* If appending the terminator was successful */ + context->state = HOXML_STATE_ATTRIBUTE_NAME2; + } else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_ATTRIBUTE_NAME2: /* Whitespace was found after an attribute name, look for '=' */ + HOXML_LOG_STATE("HOXML_STATE_ATTRIBUTE_NAME2") + if (c.codepoint == '=') + context->state = HOXML_STATE_ATTRIBUTE_ASSIGNMENT; + else if (!HOXML_IS_WHITESPACE(c.codepoint)) /* Only '=' and whitespace are allowed after an attribute name */ + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_ATTRIBUTE_ASSIGNMENT: /* Found a ' =' after an attribute name, look for quotes or whitespace */ + HOXML_LOG_STATE("HOXML_STATE_ATTRIBUTE_ASSIGNMENT") + if (c.codepoint == '"' || c.codepoint == '\'') { + context->state = HOXML_STATE_ATTRIBUTE_VALUE; + if (c.codepoint == '"') + HOXML_STACK->flags |= HOXML_FLAG_DOUBLE_QUOTE; /* Apply the double quote flag to this node */ + else + HOXML_STACK->flags &= ~HOXML_FLAG_DOUBLE_QUOTE; /* Remove the double quote flag from this node */ + context->value = HOXML_STACK->end + 1; /* The attribute's value string will begin here */ + } + else if (!HOXML_IS_WHITESPACE(c.codepoint)) + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_ATTRIBUTE_VALUE: /* A quotation, single or double, was found after an attribute name and '=' */ + HOXML_LOG_STATE("HOXML_STATE_ATTRIBUTE_VALUE") + if ((HOXML_STACK->flags & HOXML_FLAG_DOUBLE_QUOTE && c.codepoint == '"') || (!(HOXML_STACK->flags & + HOXML_FLAG_DOUBLE_QUOTE) && c.codepoint == '\'')) { /* The quotation marks match, value is done */ + hoxml_append_terminator(context); + if (context->state >= HOXML_STATE_NONE) { /* If appending the terminator was successful */ + context->state = HOXML_STATE_ELEMENT_NAME2; + context->post_state = HOXML_POST_STATE_ATTRIBUTE_END; /* Clean up some attribute things next call */ + return HOXML_ATTRIBUTE; + } + } else if (c.codepoint == '&') { + context->state = HOXML_STATE_REFERENCE_BEGIN; + context->return_state = HOXML_STATE_ATTRIBUTE_VALUE; /* Return to this attribute value state later */ + } else if (HOXML_IS_VALUE_CHAR_DATA(HOXML_STACK->flags, c.codepoint)) + hoxml_append_character(context, c); + else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_OPEN_TAG: /* Found a '>' and now inside an open tag, looking for multiple things */ + HOXML_LOG_STATE("HOXML_STATE_OPEN_TAG") + if (c.codepoint == '<') + hoxml_begin_tag(context); + else if (c.codepoint == '&') { + context->state = HOXML_STATE_REFERENCE_BEGIN; + context->return_state = HOXML_STATE_OPEN_TAG; /* Return to this open tag state later */ + } else if (HOXML_IS_CHAR_DATA(c.codepoint)) + hoxml_append_character(context, c); + else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_COMMENT_CDATA_OR_DTD_BEGIN: /* Found "<!", looking for a '-', '[', or 'D' */ + HOXML_LOG_STATE("HOXML_STATE_COMMENT_CDATA_OR_DTD_BEGIN") + if (c.codepoint == '-') /* Possible beginning of a comment (i.e. "<!--") */ + context->state = HOXML_STATE_COMMENT_BEGIN; + else if (c.codepoint == '[') /* Possible beginning of a CDATA section (i.e. "<![CDATA[") */ + context->state = HOXML_STATE_CDATA_BEGIN1; + else if (c.codepoint == 'D') { /* Possible beginning of a DTD (i.e. "<!DOCTYPE") */ + if (context->return_state != HOXML_STATE_NONE) { /* If this DTD was found after a root element */ + context->state = HOXML_STATE_ERROR_INVALID_DOCUMENT_TYPE_DECLARATION; + return HOXML_ERROR_INVALID_DOCUMENT_TYPE_DECLARATION; + } else + context->state = HOXML_STATE_DTD_BEGIN1; + } else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_COMMENT_BEGIN: /* Found a '-' was found after "<!", looking for a '-' beginning a comment */ + HOXML_LOG_STATE("HOXML_STATE_COMMENT_BEGIN") + hoxml_pop_stack(context); /* The preceeding '<' triggered a new node. Undo it. */ + if (c.codepoint == '-') + context->state = HOXML_STATE_COMMENT; + else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_COMMENT: /* Found a second '-' and now in a comment, looking for '-' */ + HOXML_LOG_STATE("HOXML_STATE_COMMENT") + if (c.codepoint == '-') + context->state = HOXML_STATE_COMMENT_END1; + else + context->state = HOXML_STATE_COMMENT; + break; + case HOXML_STATE_COMMENT_END1: /* Found a '-' while in a comment, looking for a second '-' */ + HOXML_LOG_STATE("HOXML_STATE_COMMENT_END1") + if (c.codepoint == '-') + context->state = HOXML_STATE_COMMENT_END2; + else + context->state = HOXML_STATE_COMMENT; + break; + case HOXML_STATE_COMMENT_END2: /* Found a second '-' while in a comment, looking for '>' to end the comment */ + HOXML_LOG_STATE("HOXML_STATE_COMMENT_END2") + if (c.codepoint == '>') + context->state = context->return_state; /* Return to the original state at the time '<' was found */ + else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_CDATA_BEGIN1: /* Found a '[' after "<!", looking for 'C' */ + HOXML_LOG_STATE("HOXML_STATE_CDATA_BEGIN1") + hoxml_pop_stack(context); /* The preceeding '<' triggered a new node. Undo it. */ + if (c.codepoint == 'C') + context->state = HOXML_STATE_CDATA_BEGIN2; + else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_CDATA_BEGIN2: /* Found a 'C' after "<![", looking for 'D' */ + HOXML_LOG_STATE("HOXML_STATE_CDATA_BEGIN2") + if (c.codepoint == 'D') + context->state = HOXML_STATE_CDATA_BEGIN3; + else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_CDATA_BEGIN3: /* Found a 'D' after "<![C", looking for 'A' */ + HOXML_LOG_STATE("HOXML_STATE_CDATA_BEGIN3") + if (c.codepoint == 'A') + context->state = HOXML_STATE_CDATA_BEGIN4; + else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_CDATA_BEGIN4: /* Found an 'A' after "<![CD", looking for 'T' */ + HOXML_LOG_STATE("HOXML_STATE_CDATA_BEGIN4") + if (c.codepoint == 'T') + context->state = HOXML_STATE_CDATA_BEGIN5; + else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_CDATA_BEGIN5: /* Found a 'T' after "<![CDA", looking for 'A' */ + HOXML_LOG_STATE("HOXML_STATE_CDATA_BEGIN5") + if (c.codepoint == 'A') + context->state = HOXML_STATE_CDATA_BEGIN6; + else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_CDATA_BEGIN6: /* Found an 'A' after "<![CDAT", looking for '[' */ + HOXML_LOG_STATE("HOXML_STATE_CDATA_BEGIN6") + if (c.codepoint == '[') + context->state = HOXML_STATE_CDATA_CONTENT; + else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_CDATA_CONTENT: /* Found a '[' after "<![CDATA" and now in a CDATA section, looking for ']' */ + HOXML_LOG_STATE("HOXML_STATE_CDATA_CONTENT") + hoxml_append_character(context, c); + if (context->state >= HOXML_STATE_NONE) { /* If appending the character was successful */ + if (c.codepoint == ']') + context->state = HOXML_STATE_CDATA_END1; + } break; + case HOXML_STATE_CDATA_END1: /* Found a ']' while in a CDATA section, looking for a second ']' */ + HOXML_LOG_STATE("HOXML_STATE_CDATA_END1") + hoxml_append_character(context, c); + if (context->state >= HOXML_STATE_NONE) { /* If appending the character was successful */ + if (c.codepoint == ']') + context->state = HOXML_STATE_CDATA_END2; + else + context->state = HOXML_STATE_CDATA_CONTENT; + } break; + case HOXML_STATE_CDATA_END2: /* Found a second ']' while in a CDATA section, looking for '>' */ + HOXML_LOG_STATE("HOXML_STATE_CDATA_END2") + if (c.codepoint == '>') { + context->state = HOXML_STATE_OPEN_TAG; + /* We couldn't be sure the CDATA section had ended until now so two ']' characters were appended. */ + /* If the document is encoded with UTF-16, four bytes need to be removed. Two bytes otherwise. */ + size_t bytes = context->encoding >= HOXML_ENC_UTF_16_BE ? 4 : 2; + /* The 'end' pointer is currently pointing at the last byte, the second ']' or its latter half if */ + /* using UTF-16. To remove the "]]" we replace them with zeroes. */ + memset(HOXML_STACK->end - bytes + 1, 0, bytes); + HOXML_STACK->end -= bytes; + } else { + hoxml_append_character(context, c); + if (context->state >= HOXML_STATE_NONE) /* If appending the character was successful */ + context->state = HOXML_STATE_CDATA_CONTENT; + } break; + case HOXML_STATE_REFERENCE_BEGIN: /* Found an '&' in content or a value, looking for '#', ';', or characters */ + HOXML_LOG_STATE("HOXML_STATE_REFERENCE_BEGIN") + context->reference_start = HOXML_STACK->end + 1; /* Point to the first byte for comparisons later */ + if (c.codepoint == '#') + context->state = HOXML_STATE_REFERENCE_NUMERIC; + /* The predefined entities are "amp", "lt", "gt", "quot", and "apos". Check for just their first letters. */ + else if (c.codepoint == 'a' || c.codepoint == 'g' || c.codepoint == 'l' || c.codepoint == 'q') { + hoxml_append_character(context, c); + if (context->state >= HOXML_STATE_NONE) /* If appending the character was successful */ + context->state = HOXML_STATE_REFERENCE_ENTITY; + } else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_REFERENCE_ENTITY: /* Looking for "[a]mp", "[l]t", "[g]t", "[q]uot", or "apos" */ + HOXML_LOG_STATE("HOXML_STATE_REFERENCE_ENTITY") + if (c.codepoint == ';') + hoxml_end_reference(context, HOXML_REF_TYPE_ENTITY); + /* Predefined escapes only use a subset of lower case English characters. For now, we'll check for ASCII. */ + else if (HOXML_IS_ASCII_CHAR(c.codepoint)) + hoxml_append_character(context, c); + else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_REFERENCE_NUMERIC: /* Found a '#' in a reference, looking for 'x', ';', or chars */ + HOXML_LOG_STATE("HOXML_STATE_REFERENCE_NUMERIC") + if (c.codepoint == 'x') + context->state = HOXML_STATE_REFERENCE_HEX; + else if (c.codepoint == ';') + hoxml_end_reference(context, HOXML_REF_TYPE_NUMERIC); + else if (HOXML_IS_NUMERIC(c.codepoint)) + hoxml_append_character(context, c); + else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_REFERENCE_HEX: /* Found an 'x' in a reference after '#', looking for chars or ';' */ + HOXML_LOG_STATE("HOXML_STATE_REFERENCE_HEX") + if (c.codepoint == ';') + hoxml_end_reference(context, HOXML_REF_TYPE_HEX); + else if (HOXML_IS_HEX_CHAR(c.codepoint)) + hoxml_append_character(context, c); + else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_PROCESSING_INSTRUCTION_BEGIN: /* Found a '?' after a '<' and now in a processing instruction */ + HOXML_LOG_STATE("HOXML_STATE_PROCESSING_INSTRUCTION_BEGIN") + if (HOXML_IS_NAME_START_CHAR(c.codepoint)) { + hoxml_append_character(context, c); + if (context->state >= HOXML_STATE_NONE) { /* If appending the character was successful */ + context->state = HOXML_STATE_PROCESSING_INSTRUCTION_TARGET1; + context->tag = &(HOXML_STACK->tag); /* The processing instruction's target string began here */ + } + } else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_PROCESSING_INSTRUCTION_TARGET1: /* Found a name char after "<?", looking for more name chars */ + HOXML_LOG_STATE("HOXML_STATE_PROCESSING_INSTRUCTION_TARGET1") + if (HOXML_IS_WHITESPACE(c.codepoint)) { /* A whitespace marks an end of a target and beginning of content */ + if (hoxml_strcmp(&(HOXML_STACK->tag), context->encoding, "xml", HOXML_ENC_UNKNOWN, + HOXML_CASE_INSENSITIVE) && HOXML_STACK->parent != NULL) { + /* The document declaration (e.g. <?xml encoding="UTF-8"?>) must come before the first element */ + context->state = HOXML_STATE_ERROR_INVALID_DOCUMENT_DECLARATION; + return HOXML_ERROR_INVALID_DOCUMENT_DECLARATION; + } + hoxml_append_terminator(context); + if (context->state >= HOXML_STATE_NONE) { /* If appending the terminator was successful */ + context->state = HOXML_STATE_PROCESSING_INSTRUCTION_CONTENT; + return HOXML_PROCESSING_INSTRUCTION_BEGIN; + } + } else if (c.codepoint == '?') { /* A '?' (or "?>") marks the end of the target and PI */ + hoxml_append_terminator(context); + if (context->state >= HOXML_STATE_NONE) /* If appending the terminator was successful */ + context->state = HOXML_STATE_PROCESSING_INSTRUCTION_END; + } else if (HOXML_IS_NAME_CHAR(c.codepoint)) + hoxml_append_character(context, c); + else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_PROCESSING_INSTRUCTION_CONTENT: /* Found space after a PI name, looking for '?' or chars */ + HOXML_LOG_STATE("HOXML_STATE_PROCESSING_INSTRUCTION_CONTENT") + if (c.codepoint == '?') { /* "?>" marks the end of a processing instruction */ + const char* declaration; + if ((declaration = hoxml_strstr(context->content, context->encoding, "encoding=", HOXML_ENC_UNKNOWN, + HOXML_CASE_SENSITIVE)) != NULL) { + const char* encoding; + if ((encoding = hoxml_strstr(declaration, context->encoding, "\"", HOXML_ENC_UNKNOWN, + HOXML_CASE_SENSITIVE)) != NULL || (encoding = hoxml_strstr(declaration, context->encoding, + "'", HOXML_ENC_UNKNOWN, HOXML_CASE_SENSITIVE)) != NULL) { + switch (context->encoding) { + case HOXML_ENC_UNKNOWN: /* The document did not begin with a byte order marker (BOM) */ + if (hoxml_strcmp(encoding, context->encoding, "\"UTF-8\"", HOXML_ENC_UNKNOWN, + HOXML_CASE_INSENSITIVE) != 0 || hoxml_strcmp(encoding, context->encoding, + "'UTF-8'", HOXML_ENC_UNKNOWN, HOXML_CASE_INSENSITIVE) != 0) { + context->encoding = HOXML_ENC_UTF_8; + } else if (hoxml_strcmp(encoding, context->encoding, "\"UTF-16\"", HOXML_ENC_UNKNOWN, + HOXML_CASE_INSENSITIVE) != 0 || hoxml_strcmp(encoding, context->encoding, + "'UTF-16'", HOXML_ENC_UNKNOWN, HOXML_CASE_INSENSITIVE) != 0) { + /* UTF-16 encoded documents require one of the UTF-16 BOMs so this is an error */ + context->state = HOXML_STATE_ERROR_ENCODING; + return HOXML_ERROR_ENCODING; + } break; + case HOXML_ENC_UTF_8: /* The UTF-8 BOM was found at the beginning of the document */ + if (hoxml_strcmp(encoding, context->encoding, "\"UTF-8\"", HOXML_ENC_UNKNOWN, + HOXML_CASE_INSENSITIVE) == 0 && hoxml_strcmp(encoding, context->encoding, + "'UTF-8'", HOXML_ENC_UNKNOWN, HOXML_CASE_INSENSITIVE) == 0) { + /* If the UTF-8 BOM was found but the encoding declaration was not "UTF-8" then we */ + /* have a contradiction and, therefore, an error */ + context->state = HOXML_STATE_ERROR_ENCODING; + return HOXML_ERROR_ENCODING; + } break; + case HOXML_ENC_UTF_16_LE: /* The UTF-16LE BOM was found at the beginning of the document */ + case HOXML_ENC_UTF_16_BE: /* The UTF-16BE BOM was found at the beginning of the document */ + if (hoxml_strcmp(encoding, context->encoding, "\"UTF-16\"", HOXML_ENC_UNKNOWN, + HOXML_CASE_INSENSITIVE) == 0 && hoxml_strcmp(encoding, context->encoding, + "'UTF-16'", HOXML_ENC_UNKNOWN, HOXML_CASE_INSENSITIVE) == 0) + return HOXML_ERROR_ENCODING; + break; + } + } + } + hoxml_append_terminator(context); + if (context->state >= HOXML_STATE_NONE) /* If appending the terminator was successful */ + context->state = HOXML_STATE_PROCESSING_INSTRUCTION_END; + } else { + if (context->content == NULL) /* If this is the first character of the PI's content */ + context->content = HOXML_STACK->end + 1; /* The PI's content string will begin here */ + hoxml_append_character(context, c); + } break; + case HOXML_STATE_DTD_BEGIN1: /* Found a 'D' after "<!", looking for 'O' */ + HOXML_LOG_STATE("HOXML_STATE_DTD_BEGIN1") + hoxml_pop_stack(context); /* The preceeding '<' triggered a new node. Undo it. */ + if (c.codepoint == 'O') + context->state = HOXML_STATE_DTD_BEGIN2; + else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_DTD_BEGIN2: /* Found an 'O' after "<!D", looking for 'C' */ + HOXML_LOG_STATE("HOXML_STATE_DTD_BEGIN2") + if (c.codepoint == 'C') + context->state = HOXML_STATE_DTD_BEGIN3; + else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_DTD_BEGIN3: /* Found a 'C' after "<!DO", looking for 'T' */ + HOXML_LOG_STATE("HOXML_STATE_DTD_BEGIN3") + if (c.codepoint == 'T') + context->state = HOXML_STATE_DTD_BEGIN4; + else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_DTD_BEGIN4: /* Found a 'T' after "<!DOC", looking for 'Y' */ + HOXML_LOG_STATE("HOXML_STATE_DTD_BEGIN4") + if (c.codepoint == 'Y') + context->state = HOXML_STATE_DTD_BEGIN5; + else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_DTD_BEGIN5: /* Found a 'Y' after "<!DOCT", looking for 'P' */ + HOXML_LOG_STATE("HOXML_STATE_DTD_BEGIN5") + if (c.codepoint == 'P') + context->state = HOXML_STATE_DTD_BEGIN6; + else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_DTD_BEGIN6: /* Found a 'P' after "<!DOCTY", looking for 'E' */ + HOXML_LOG_STATE("HOXML_STATE_DTD_BEGIN6") + if (c.codepoint == 'E') + context->state = HOXML_STATE_DTD_BEGIN7; + else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_DTD_BEGIN7: /* Found an 'E' after "<!DOCTYP", looking for whitespace */ + HOXML_LOG_STATE("HOXML_STATE_DTD_BEGIN7") + if (HOXML_IS_WHITESPACE(c.codepoint)) + context->state = HOXML_STATE_DTD_BEGIN8; + else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_DTD_BEGIN8: /* Found space after "<!DOCTYPE", looking for more or a name start character */ + HOXML_LOG_STATE("HOXML_STATE_DTD_BEGIN8") + if (HOXML_IS_NAME_START_CHAR(c.codepoint)) + context->state = HOXML_STATE_DTD_NAME; + else if (!HOXML_IS_WHITESPACE(c.codepoint)) + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_DTD_NAME: /* Found a name start character, looking for whitespace or name characters */ + HOXML_LOG_STATE("HOXML_STATE_DTD_NAME") + if (HOXML_IS_WHITESPACE(c.codepoint)) + context->state = HOXML_STATE_DTD_CONTENT; + else if (!HOXML_IS_NAME_CHAR(c.codepoint)) + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_DTD_CONTENT: /* Found a DTD name and now looking for mostly anything but mainly '[' or '>' */ + HOXML_LOG_STATE("HOXML_STATE_DTD_CONTENT") + /* We support Document Type Declarations (DTDs) insofar as they do not cause problems and DTD names may */ + /* be recognized as invalid. Beyond that, the content is ignored just as comments are. That said, some */ + /* checks are done here and the "open bracket" state because they're easy. */ + if (c.codepoint == '[') + context->state = HOXML_STATE_DTD_OPEN_BRACKET; + else if (c.codepoint == '>') + context->state = HOXML_STATE_NONE; /* Return to the "before root element" state, the only one allowed */ + else if (!HOXML_IS_CHAR_DATA(c.codepoint)) + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_STATE_DTD_OPEN_BRACKET: /* Found a '[' within DTD content, looking for a closing ']' */ + HOXML_LOG_STATE("HOXML_STATE_DTD_OPEN_BRACKET") + /* Some additional characters are allowed between '[' and ']' brackets, namely markup declaration */ + /* characters like '<' and '>'. We'll just allow anything to keep things simple. */ + if (c.codepoint == ']') + context->state = HOXML_STATE_DTD_CONTENT; + break; + case HOXML_STATE_PROCESSING_INSTRUCTION_END: /* Found a '?' after PI content, looking for '>' */ + HOXML_LOG_STATE("HOXML_STATE_PROCESSING_INSTRUCTION_END") + if (c.codepoint == '>') + return hoxml_end_tag(context); + else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + } + } /* while (context->state >= HOXML_STATE_NONE && context->state <= HOXML_STATE_DONE) */ + + /* A dozen or so states may try to add data to the buffer, new nodes, characters, or terminators. It's possible */ + /* there was not enough space left in the buffer for this putting us into an error state where parsing cannot */ + /* continue. In these cases, the state will have been set appropriately. */ + if (context->state == HOXML_STATE_ERROR_INSUFFICIENT_MEMORY) { + /* Because the character leading to this error state could not be used, we'll undo the iteration in the hopes */ + /* that we recover from this error (one of two errors that can be recovered, by hoxml_realloc() in this case) */ + /* and parsing can continue on the next call to hoxml_parse() */ + context->iterator = previous_iterator; + context->stream_length = previous_stream_length; + context->column--; /* If recovered, parsing will continue with the same character so don't count this one */ + return HOXML_ERROR_INSUFFICIENT_MEMORY; + } + + /* Any other error case not yet covered by previous checks is due to incorrect syntax in the document */ + return HOXML_ERROR_SYNTAX; +} + +/* Attempt to push a new node to the stack as a child of the current head node */ +void hoxml_push_stack(hoxml_context_t* context) { + /* If "allocating" a new node would overflow the buffer */ + if ((context->stack == NULL && sizeof(hoxml_node_t) >= context->buffer_length) || (context->stack != NULL && + HOXML_STACK->end + 1 + sizeof(hoxml_node_t) >= context->buffer + context->buffer_length)) { + context->error_return_state = context->state; + context->state = HOXML_STATE_ERROR_INSUFFICIENT_MEMORY; + return; + } + + hoxml_node_t* node; + if (context->stack == NULL)/* If pushing the root node */ + node = (hoxml_node_t*) context->buffer; /* Place the new node at the beginning of the buffer */ + else + node = (hoxml_node_t*)(HOXML_STACK->end + 1); + if (node != NULL) { + /* Assign initial values to the node */ + node->parent = HOXML_STACK; /* This new node's parent is the previous stack node */ + node->end = &(node->tag) - 1; /* Point to the last byte of the node, -1 because no tag has been copied yet */ + } + context->stack = (char*)node; +} + +/* Pop the head node from the stack */ +void hoxml_pop_stack(hoxml_context_t* context) { + if (context->stack == NULL) + return; + + /* Reassign the stack (head) pointer so that it now points to the parent of the node about to be popped */ + hoxml_node_t* popped_node = HOXML_STACK; + context->stack = (char*)popped_node->parent; + + /* Overwrite the memory used by this node with zeroes */ + context->tag = context->attribute = context->value = context->content = NULL; /* TODO: move somewhere else */ + memset(popped_node, 0, popped_node->end - (char*)popped_node + 1); +} + +/* Attempt to add the given character to the end of the stack's current head node */ +void hoxml_append_character(hoxml_context_t* context, hoxml_character_t c) { + HOXML_STACK->flags &= ~HOXML_FLAG_TERMINATED; + + if (HOXML_STACK->end + c.bytes >= context->buffer + context->buffer_length) { + context->error_return_state = context->state; + context->state = HOXML_STATE_ERROR_INSUFFICIENT_MEMORY; + return; + } + + memcpy(HOXML_STACK->end + 1, &(c.encoded), c.bytes); /* Copy the character to the stack */ + HOXML_STACK->end += c.bytes; /* Redirect the end pointer to the new end just after the appended character */ +} + +/* Attempt to add a null terminator to the end of the stack's current head node */ +void hoxml_append_terminator(hoxml_context_t* context) { + if (HOXML_STACK->flags & HOXML_FLAG_TERMINATED) /* If the node's current string is already terminated */ + return; /* To avoid adding additional terminators and using more bytes than expected, do nothing */ + HOXML_STACK->flags |= HOXML_FLAG_TERMINATED; + + /* If the document is encoded with UTF-16, two bytes will be appended. One byte otherwise. */ + size_t bytes = context->encoding >= HOXML_ENC_UTF_16_BE ? 2 : 1; + if (HOXML_STACK->end + bytes >= context->buffer + context->buffer_length) { + context->error_return_state = context->state; + context->state = HOXML_STATE_ERROR_INSUFFICIENT_MEMORY; + return; + } + + memset(HOXML_STACK->end + 1, '\0', bytes); /* Copy the terminator to the stack */ + HOXML_STACK->end += bytes; /* Redirect the end pointer to the new end just after the appended terminator */ +} + +/* Perform the steps needed to decode and clean up after a character or entity reference given the context obect and */ +/* the type of reference. There are three types defined in an enumeration. */ +void hoxml_end_reference(hoxml_context_t* context, int type) { + hoxml_character_t c; + c.codepoint = c.encoded = 0; + c.bytes = 0; + unsigned long value; /* Integer value of numeric or hexadecimal reference */ + + switch (type) { + case HOXML_REF_TYPE_ENTITY: + if (hoxml_strcmp(context->reference_start, context->encoding, "lt", + HOXML_ENC_UNKNOWN, HOXML_CASE_SENSITIVE) != 0) { + c = hoxml_encode_character('<', context->encoding); + } else if (hoxml_strcmp(context->reference_start, context->encoding, "gt", + HOXML_ENC_UNKNOWN, HOXML_CASE_SENSITIVE) != 0) { + c = hoxml_encode_character('>', context->encoding); + } else if (hoxml_strcmp(context->reference_start, context->encoding, "amp", HOXML_ENC_UNKNOWN, + HOXML_CASE_SENSITIVE) != 0) { + c = hoxml_encode_character('&', context->encoding); + } else if (hoxml_strcmp(context->reference_start, context->encoding, "apos", HOXML_ENC_UNKNOWN, + HOXML_CASE_SENSITIVE) != 0) { + c = hoxml_encode_character('\'', context->encoding); + } else if (hoxml_strcmp(context->reference_start, context->encoding, "quot", HOXML_ENC_UNKNOWN, + HOXML_CASE_SENSITIVE) != 0) { + c = hoxml_encode_character('"', context->encoding); + } else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_REF_TYPE_NUMERIC: + value = strtoul(hoxml_to_ascii(context->reference_start, context->encoding), NULL, 10); + if (value != 0) /* If the reference string could be converted as a base-ten integer */ + c = hoxml_encode_character(value, context->encoding); + else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + case HOXML_REF_TYPE_HEX: + value = strtoul(hoxml_to_ascii(context->reference_start, context->encoding), NULL, 16); + if (value != 0) /* If the reference string could be converted as a base-16 integer */ + c = hoxml_encode_character(value, context->encoding); + else + context->state = HOXML_STATE_ERROR_SYNTAX; + break; + } + + /* If the reference could not be turned into a character */ + if (c.bytes == 0) + return; + + /* Remove the reference's string from the buffer. For example, "<" would result in "lt" being stored so it */ + /* could be parsed here. It should now be removed from the buffer. */ + memset(context->reference_start, 0, HOXML_STACK->end - context->reference_start + 1); + HOXML_STACK->end = context->reference_start - 1; + context->reference_start = NULL; + hoxml_append_character(context, c); /* Append the character being referenced */ + /* No need for any checks against the buffer length. In all cases, more bytes were removed just now than added. */ + context->state = context->return_state; /* Either HOXML_STATE_OPEN_TAG or HOXML_STATE_ATTRIBUTE_VALUE */ + context->return_state = HOXML_STATE_NONE; +} + +void hoxml_begin_tag(hoxml_context_t* context) { + hoxml_push_stack(context); + if (context->state >= HOXML_STATE_NONE) { /* If pushing a new node was successful */ + context->return_state = context->state; /* For comments and references, so we know which state to return to */ + context->state = HOXML_STATE_TAG_BEGIN; + } +} + +hoxml_code_t hoxml_end_tag(hoxml_context_t* context) { + context->state = HOXML_STATE_OPEN_TAG; + context->post_state = HOXML_POST_STATE_TAG_END; /* Common to three of the four possible cases */ + hoxml_node_t* node = HOXML_STACK; + hoxml_node_t* parent = node->parent; + if (node->flags & HOXML_FLAG_END_TAG) { /* True for e.g. </tag> but not <tag/> */ + if (parent == NULL || hoxml_strcmp(&(node->tag), context->encoding, &(parent->tag), context->encoding, + HOXML_CASE_SENSITIVE) == 0) { /* If there was preceeding open tag or there is but it doesn't match */ + context->state = HOXML_STATE_ERROR_TAG_MISMATCH; + return HOXML_ERROR_TAG_MISMATCH; + } else { /* If an element successfully closed a matching open tag */ + hoxml_pop_stack(context); /* Pop the end tag (e.g. "</tag>") */ + context->tag = &(parent->tag); + /* Element content is placed, in memory, after the tag and its terminator... */ + context->content = context->tag + hoxml_strlen(context->tag, context->encoding); + /* ...which may be either one or two bytes, depending on encoding */ + context->content += (context->encoding >= HOXML_ENC_UTF_16_BE ? 2 : 1); + /* Closing an element means one less level of nesting so decrement the depth after returning */ + HOXML_STACK->flags |= HOXML_FLAG_DECREMENT_DEPTH; + return HOXML_ELEMENT_END; + } + } else if (node->flags & HOXML_FLAG_EMPTY_ELEMENT) /* Self-closing/empty element (e.g. "<tag/>") */ + return HOXML_ELEMENT_END; + else if (node->flags & HOXML_FLAG_PROCESSING_INSTRUCTION) /* Processing instruction (e.g. "<?xml?>") */ + return HOXML_PROCESSING_INSTRUCTION_END; + /* The only remaining case is an open tag (e.g. "<tag>") and we expect a matching close tag later */ + context->post_state = HOXML_STATE_NONE; /* For this fourth case, of four possible, there is no clean up */ + /* Opening an element means one more level of nesting so increment the depth after returning */ + HOXML_STACK->flags |= HOXML_FLAG_INCREMENT_DEPTH; + return HOXML_ELEMENT_BEGIN; +} + +int hoxml_post_state_cleanup(hoxml_context_t* context) { + if (context->post_state != HOXML_STATE_NONE) { + switch (context->post_state) { + case HOXML_POST_STATE_TAG_END: { /* Clean up after a close tag, empty element, or processing instruction */ + int was_document_or_document_type_declaration = 0; + /* If the processing instruction flag is applied (i.e. this is a PI) and the PI's target is the reserved */ + /* "xml" target, or some other case variant of it */ + if (HOXML_STACK->flags & HOXML_FLAG_PROCESSING_INSTRUCTION && hoxml_strcmp(&(HOXML_STACK->tag), + context->encoding, "xml", HOXML_ENC_UNKNOWN, HOXML_CASE_INSENSITIVE)) { + context->state = HOXML_STATE_NONE; /* Return to the initial state as if nothing happened */ + was_document_or_document_type_declaration = 1; + } + hoxml_pop_stack(context); /* Pop a start or self-closed tag (<tag> or <tag/> or <?pi?>)*/ + if (context->stack == NULL && was_document_or_document_type_declaration == 0) + return 1; /* hoxml_parse() should return HOXML_END_OF_DOCUMENT */ + break; + } case HOXML_POST_STATE_ATTRIBUTE_END: /* Remove the most recent attribute and value strings from the buffer */ + /* Zero the memory from the end pointer to the byte at which the attribute's name begins */ + memset(context->attribute, 0, HOXML_STACK->end - (char*)context->attribute + 1); + HOXML_STACK->end = context->attribute - 1; + /* With these public properties now pointing to zeroes, nullify them so there's no confusion */ + context->attribute = context->value = NULL; + break; + } + context->post_state = HOXML_STATE_NONE; + } + + return 0; /* hoxml_parse() should not return */ +} + +/* Decode the given character with the given encoding to the its equivalent value */ +hoxml_character_t hoxml_decode_character(const char* str, size_t str_length, int encoding) { + hoxml_character_t c; + c.encoded = c.codepoint = 0; /* These default values are not valid so pausing will cease if returned */ + c.bytes = 0; + + switch (encoding) { + case HOXML_ENC_UNKNOWN: + c.bytes = 1; + break; + case HOXML_ENC_UTF_8: + /* The first byte of a UTF-8 character can can begin with one of four bit patterns, each indicating the */ + /* number of remaining bytes: 0XXXXXXX = 1 byte, 110XXXXX = 2 bytes, 1110XXXX = 3 bytes, 11110XXX = 4 bytes. */ + /* NOTE: UTF-8 is *big* endian. */ + if (((str[0] >> 7) & 0x01) == 0x00) + c.bytes = 1; + else if (((str[0] >> 5) & 0x07) == 0x06) + c.bytes = 2; + else if (((str[0] >> 4) & 0x0F) == 0x0E) + c.bytes = 3; + else if (((str[0] >> 3) & 0x1F) == 0x1E) + c.bytes = 4; + break; + case HOXML_ENC_UTF_16_BE: + /* UTF-16 characters are either two bytes or four bytes where the four-byte characters are encoded such that */ + /* the first two bytes begin with 110110XX and the second with 110111XX. The rest are two-byte characters. */ + if (((str[0] >> 2) & 0x3F) == 0x36 && ((str[2] >> 2) & 0x3F) == 0x37) + c.bytes = 4; + else + c.bytes = 2; + break; + case HOXML_ENC_UTF_16_LE: + /* UTF-16LE (Little Endian) is just like UTF-16BE (Big Endian) but the most and least significant bytes in */ + /* any 16-bit sequence are swapped. (Technically, a byte isn't defined as eight bits but it is in practice.) */ + if (((str[1] >> 2) & 0x3F) == 0x36 && ((str[3] >> 2) & 0x3F) == 0x37) + c.bytes = 4; + else + c.bytes = 2; + break; + } + + /* If the string doesn't have enough bytes in it to decode this character */ + if (c.bytes > str_length) { + /* Set the decoded value to the maximum possible to indicate a failure, zero the rest, and return early */ + c.codepoint = UINT32_MAX; + c.encoded = 0; + c.bytes = 0; + return c; + } + + switch (encoding) { + case HOXML_ENC_UNKNOWN: + c.codepoint = str[0]; + break; + case HOXML_ENC_UTF_8: + if (c.bytes == 1) { + /* One-byte UTF-8 characters are encoded as 0XXXXXXX where the Xs represent the bits of the character's */ + /* value. For all decoding, we want to grab only those bits and transform them into an integer. */ + /* The method here takes one byte from the string, uses a mask to zero out any bit that is not part of */ + /* resulting value, casts the masked byte to an unsigned 32-bit integer, shifts those bits to the left to */ + /* place them at the indexes they're expected in the value, and then bitwise ORs these components into a */ + /* single unsigned 32-bit integer. This one-byte case does not need any shift but the remaining cases do. */ + c.codepoint = (unsigned)(str[0] & 0x7F); + } else if (c.bytes == 2) { + /* Two-byte UTF-8 characters are encoded as 110XXXXX 10XXXXXX */ + c.codepoint = ((unsigned)(str[0] & 0x1F) << 6) | (unsigned)(str[1] & 0x3F); + } else if (c.bytes == 3) { + /* Three-byte UTF-8 characters are encoded as 1110XXXX 10XXXXXX 10XXXXXX */ + c.codepoint = ((unsigned)(str[0] & 0x0F) << 12) | ((unsigned)(str[1] & 0x3F) << 6) | + ((unsigned)(str[2] & 0x3F) << 0); + } else if (c.bytes == 4) { + /* Four-byte UTF-8 characters are encoded as 11110XXX 10XXXXXX 10XXXXXX 10XXXXXX */ + c.codepoint = ((unsigned)(str[0] & 0x07) << 18) | ((unsigned)(str[1] & 0x3F) << 12) | + ((unsigned)(str[2] & 0x3F) << 6) | (unsigned)(str[3] & 0x3F); + } break; + case HOXML_ENC_UTF_16_BE: + if (c.bytes == 2) { + /* Concatenate the two bytes together to retrieve the original value */ + c.codepoint = ((unsigned)str[0] << 8) | ((unsigned)str[1] << 0); + } else if (c.bytes == 4) { + /* Four-byte UTF-16 characters are encoded as 110110XX XXXXXXXX 110111XX XXXXXXXX after first subtracting */ + /* 0x00010000 from the value. Here, that subtracted value is reconstructed and 0x00010000 is added back. */ + c.codepoint = (((unsigned)(str[0] & 0x03) << 18) | ((unsigned)str[1] << 16) | + ((unsigned)(str[2] & 0x03) << 8) | ((unsigned)str[3] << 0)) + 0x00010000; + } + break; + case HOXML_ENC_UTF_16_LE: + if (c.bytes == 2) + c.codepoint = ((unsigned)str[1] << 8) | ((unsigned)str[0] << 0); + else if (c.bytes == 4) { + c.codepoint = (((unsigned)(str[1] & 0x03) << 18) | ((unsigned)str[0] << 16) | + ((unsigned)(str[3] & 0x03) << 8) | ((unsigned)str[2] << 0)) + 0x00010000; + } + break; + } + + memcpy(&(c.encoded), str, c.bytes); /* Copy the bytes of the character from the pointed-to string into c.encoded */ + + return c; +} + +/* Encode the given character codepoint to the given character encoding */ +hoxml_character_t hoxml_encode_character(unsigned codepoint, int encoding) { + hoxml_character_t c; + c.codepoint = codepoint; + c.encoded = 0; + c.bytes = 0; + + /* This variable will make it easier to assign values to 'c.endoded' without difficult-to-read casts */ + char* str = (char*)&(c.encoded); + + switch (encoding) { + case HOXML_ENC_UNKNOWN: /* If the encoding is somehow not specified, assume UTF-8 */ + case HOXML_ENC_UTF_8: + if (codepoint <= 0x0000007F) { /* If the codepoint will fit into one byte */ + c.encoded = codepoint; + c.bytes = 1; + } else if (codepoint >= 0x000080 && codepoint <= 0x000007FF) { /* If the codepoint will fit into two bytes */ + /* For codepoints with bits XXXXXAAA AABBBBBB, we want to transform them to the form 110AAAAA 10BBBBBB. */ + /* The method here treats c.encoded as an array of unsigned, eight-bit integers. This is done to assign */ + /* bytes individually for the sake of endianness where UTF-8 is big endian. The codepoint is masked in */ + /* order to zero any bits that are not used in the byte being assigned, then shifted all the way to the */ + /* right. The prefixed "0xC0" and "0x80" bitwise ORs prepend the UTF-8 markers 110 and 10, respectively. */ + str[0] = 0xC0 | (char)((codepoint & 0x0000007C0) >> 6); /* 110AAAAAA */ + str[1] = 0x80 | (char)((codepoint & 0x0000000FF) >> 0); /* 10BBBBBB */ + c.bytes = 2; + } else if ((codepoint >= 0x00000800 && codepoint <= 0x0000D7FF) || + (codepoint >= 0x0000E000 && codepoint <= 0x0000FFFF)) { + /* For a codepoint with bits AAAABBBB BBCCCCCC we want 1110AAAA 10BBBBBB 10CCCCCC */ + str[0] = 0xE0 | (char)((codepoint & 0x0000F000) >> 12); /* 1110AAAA */ + str[1] = 0x80 | (char)((codepoint & 0x00000FC0) >> 6); /* 10BBBBBB */ + str[2] = 0x80 | (char)((codepoint & 0x0000003F) >> 0); /* 10CCCCCC */ + c.bytes = 3; + } else if (codepoint >= 0x00010000 && codepoint <= 0x0010FFFF) { + /* For a codepoint with bits XXXAAABB BBBBCCCC CCDDDDDD we want 11110AAA 10BBBBBB 10CCCCCC 10DDDDDD */ + str[0] = 0xF0 | (char)((codepoint & 0x001C0000) >> 18); /* 11110AAA */ + str[1] = 0x80 | (char)((codepoint & 0x0003F000) >> 12); /* 10BBBBBB */ + str[2] = 0x80 | (char)((codepoint & 0x00000FC0) >> 6); /* 10CCCCCC */ + str[3] = 0x80 | (char)((codepoint & 0x0000003F) >> 0); /* 10DDDDDD */ + c.bytes = 4; + } else /* If the codepoint is not valid */ + c.bytes = 0; /* Don't even try */ + break; + case HOXML_ENC_UTF_16_BE: + if (codepoint <= 0x0000D7FF || (codepoint >= 0x0000E000 && codepoint <= 0x0000FFFF)) { /* Fits in two bytes */ + str[0] = (char)((codepoint & 0x0000FF00) >> 8); + str[1] = (char) (codepoint & 0x000000FF); + c.bytes = 2; + } else if (codepoint >= 0x00010000 && codepoint <= 0x0010FFFF) { /* If the codepoint fits in four bytes */ + /* For codepoint - 0x00010000 with bits XXXXXXXX XXXXAABB BBBBBBCC DDDDDDDD we want to transform the bits */ + /* to the form 110110AA BBBBBBBB 110111CC DDDDDDDD. When decoded, as per UTF-16, 0x00010000 is added. */ + /* The prefixed "0xD8" and "0xDC" bitwise ORs prepend the UTF-16 markers 110110 and 110111, respectively. */ + codepoint -= 0x00010000; + str[0] = 0xD8 | (char)((codepoint & 0x000C0000) >> 20); /* 110110AA */ + str[1] = (char)((codepoint & 0x0003FC00) >> 18); /* BBBBBBBB */ + str[2] = 0xDC | (char)((codepoint & 0x00000300) >> 8); /* 110111CC */ + str[3] = (char)((codepoint & 0x000000FF) >> 0); /* DDDDDDDD */ + c.bytes = 4; + } else /* If the codepoint is not valid */ + c.bytes = 0; /* Don't even try */ + break; + case HOXML_ENC_UTF_16_LE: + /* UTF-16LE (Little Endian) is just like UTF-16BE (Big Endian) with the reverse endianness meaning that the */ + /* operations here are identical to those above but the indexes have been changed to reflect endianness */ + if (codepoint <= 0x0000D7FF || (codepoint >= 0x0000E000 && codepoint <= 0x0000FFFF)) { + str[1] = (char)((codepoint & 0x0000FF00) >> 8); + str[0] = (char)((codepoint & 0x000000FF) >> 0); + c.bytes = 2; + } else if (codepoint >= 0x00010000 && codepoint <= 0x0010FFFF) { + codepoint -= 0x00010000; + str[3] = 0xD8 | (char)((codepoint & 0x000C0000) >> 20); /* 110110AA */ + str[2] = (char)((codepoint & 0x0003FC00) >> 18); /* BBBBBBBB */ + str[1] = 0xDC | (char)((codepoint & 0x00000300) >> 8); /* 110111CC */ + str[0] = (char)((codepoint & 0x000000FF) >> 0); /* DDDDDDDD */ + c.bytes = 4; + } else + c.bytes = 0; + break; + } + + return c; +} + +/* Given a reference string with the given encoding, return an equivalent string encoding using ASCII */ +char* hoxml_to_ascii(const char* str, int encoding) { + /* This is only for references which have a maximum length so this static array will always be large enough */ + static char ascii[16]; + memset(ascii, 0, sizeof(ascii)); + + size_t ascii_index = 0; /* Current index in the ASCII string */ + const char* it = str; + hoxml_character_t c = hoxml_decode_character(it, 65535, encoding); + + /* While we haven't iterated up to a null terminator AND not beyond the size of the result array */ + while (c.codepoint != '\0' && ascii_index < sizeof(ascii)) { + /* Assign the decoded value of the source to the equivalent index in the result array. In practice, this is */ + /* effectively only necessary for UTF-16 content where the encoded values differ from decoded ones for */ + /* characters also included in ASCII. For UTF-8, this whole function call could be skipped. */ + ascii[ascii_index++] = c.codepoint; + + /* Iterate to the next character in the string */ + it += c.bytes; + c = hoxml_decode_character(it, 65535, encoding); + } + + return ascii; +} + +/* Get the length, in bytes not characters, of the given string with the given encoding */ +size_t hoxml_strlen(const char* str, int encoding) { + size_t length = 0; + const char* it = str; + hoxml_character_t c = hoxml_decode_character(it++, 65535, encoding); + + while (c.codepoint != '\0') { /* While we haven't iterated to a null terminator */ + length++; + c = hoxml_decode_character(it++, 65535, encoding); + } + + return length; +} + +/* Compare the given strings with the given encodings for equality with an additional parameter for case sensitivity. */ +/* The return value is 0 if the strings are not equal. All other return values mean the strings are equal. */ +int hoxml_strcmp(const char* str1, int encoding1, const char* str2, const int encoding2, int sensitivity) { + const char* it1 = str1; + const char* it2 = str2; + hoxml_character_t c1 = hoxml_decode_character(it1, 65535, encoding1); + hoxml_character_t c2 = hoxml_decode_character(it2, 65535, encoding2); + + while (c1.codepoint != '\0' && c2.codepoint != '\0') { /* While neither iterator has reached a null terminator */ + /* If, accounting for sensitivity, the charcters are not equal */ + if ((sensitivity == HOXML_CASE_INSENSITIVE && HOXML_TO_LOWER(c1.codepoint) != HOXML_TO_LOWER(c2.codepoint)) || + (sensitivity == HOXML_CASE_SENSITIVE && c1.codepoint != c2.codepoint)) { + return 0; + } + + /* Continue iterating through both strings one character at a time */ + it1 += c1.bytes; + c1 = hoxml_decode_character(it1, 65535, encoding1); + it2 += c2.bytes; + c2 = hoxml_decode_character(it2, 65535, encoding2); + } + + return c2.codepoint == '\0'; +} + +/* Search for a given string, needle, within another string, haystack. The return value is a pointer to the byte at */ +/* which the string, needle, first appears or NULL if it cannot be found. */ +const char* hoxml_strstr(const char* haystack, int haystack_encoding, const char* needle, int needle_encoding, + int sensitivity) { + const char* it_haystack = haystack; + const char* it_needle = needle; + hoxml_character_t c_haystack = hoxml_decode_character(it_haystack, 65535, haystack_encoding); + hoxml_character_t c_needle = hoxml_decode_character(it_needle, 65535, needle_encoding); + + while (c_haystack.codepoint != '\0') { /* While we haven't iterated to a null terminator */ + /* If the current character in the haystack equals the first character in the needle AND the whole needle */ + /* string follows this character */ + if (c_haystack.codepoint == c_needle.codepoint && + hoxml_strcmp(it_haystack, haystack_encoding, it_needle, needle_encoding, sensitivity) != 0) { + /* Return a pointer to the location the needle (first) appeared at */ + return it_haystack; + } + + /* Continue iterating through characters in the haystack string */ + it_haystack += c_haystack.bytes; + c_haystack = hoxml_decode_character(it_haystack, 65535, haystack_encoding); + } + + return NULL; /* The needle was not found in the haystack */ +} + +#endif /* HOXML_IMPLEMENTATION */ + +#endif /* HOXML_H */ |