From fc5939dcff72e1bd5430e3c403ee0c1392503afb Mon Sep 17 00:00:00 2001
From: Gabor Kiss-Vamosi <kisvegabor@gmail.com>
Date: Fri, 22 Nov 2024 10:46:13 +0100
Subject: [PATCH] feat(xml): add the basics of declarative XML support

---
 Kconfig                                       |    5 +-
 docs/details/other-components/index.rst       |    1 +
 docs/details/other-components/xml.rst         |  301 +
 examples/others/lv_example_others.h           |    1 +
 examples/others/xml/index.rst                 |    5 +
 examples/others/xml/lv_example_xml.h          |   38 +
 examples/others/xml/lv_example_xml_1.c        |   37 +
 examples/others/xml/my_button.xml             |   15 +
 examples/others/xml/my_card.xml               |   23 +
 examples/others/xml/my_h3.xml                 |   12 +
 examples/others/xml/view.xml                  |   25 +
 lv_conf_template.h                            |    5 +-
 lvgl.h                                        |    2 +
 lvgl_private.h                                |    1 +
 scripts/code-format.cfg                       |    1 +
 src/libs/expat/add_lvgl_if.sh                 |   13 +
 src/libs/expat/ascii.h                        |  129 +
 src/libs/expat/asciitab.h                     |   72 +
 src/libs/expat/expat.h                        | 1081 +++
 src/libs/expat/expat_config.h                 |  151 +
 src/libs/expat/expat_external.h               |  171 +
 src/libs/expat/iasciitab.h                    |   73 +
 src/libs/expat/internal.h                     |  182 +
 src/libs/expat/latin1tab.h                    |   72 +
 src/libs/expat/nametab.h                      |  142 +
 src/libs/expat/siphash.h                      |  398 +
 src/libs/expat/utf8tab.h                      |   72 +
 src/libs/expat/winconfig.h                    |   54 +
 src/libs/expat/xmlparse.c                     | 8567 +++++++++++++++++
 src/libs/expat/xmlrole.c                      | 1261 +++
 src/libs/expat/xmlrole.h                      |  148 +
 src/libs/expat/xmltok.c                       | 1678 ++++
 src/libs/expat/xmltok.h                       |  327 +
 src/libs/expat/xmltok_impl.c                  | 1825 ++++
 src/libs/expat/xmltok_impl.h                  |   80 +
 src/libs/expat/xmltok_ns.c                    |  128 +
 src/lv_conf_internal.h                        |   11 +-
 src/lv_init.c                                 |    7 +-
 src/misc/lv_types.h                           |    5 +
 src/others/xml/lv_xml.c                       |  389 +
 src/others/xml/lv_xml.h                       |   57 +
 src/others/xml/lv_xml_base_types.c            |  111 +
 src/others/xml/lv_xml_base_types.h            |   76 +
 src/others/xml/lv_xml_component.c             |  306 +
 src/others/xml/lv_xml_component.h             |   78 +
 src/others/xml/lv_xml_component_private.h     |   58 +
 src/others/xml/lv_xml_parser.c                |   98 +
 src/others/xml/lv_xml_parser.h                |   84 +
 src/others/xml/lv_xml_private.h               |   58 +
 src/others/xml/lv_xml_style.c                 |  202 +
 src/others/xml/lv_xml_style.h                 |   91 +
 src/others/xml/lv_xml_utils.c                 |  237 +
 src/others/xml/lv_xml_utils.h                 |   50 +
 src/others/xml/lv_xml_widget.c                |   78 +
 src/others/xml/lv_xml_widget.h                |   57 +
 src/others/xml/parsers/lv_xml_button_parser.c |   59 +
 src/others/xml/parsers/lv_xml_button_parser.h |   41 +
 src/others/xml/parsers/lv_xml_chart_parser.c  |  145 +
 src/others/xml/parsers/lv_xml_chart_parser.h  |   43 +
 src/others/xml/parsers/lv_xml_image_parser.c  |  112 +
 src/others/xml/parsers/lv_xml_image_parser.h  |   43 +
 src/others/xml/parsers/lv_xml_label_parser.c  |   76 +
 src/others/xml/parsers/lv_xml_label_parser.h  |   41 +
 src/others/xml/parsers/lv_xml_obj_parser.c    |   89 +
 src/others/xml/parsers/lv_xml_obj_parser.h    |   41 +
 src/others/xml/parsers/lv_xml_slider_parser.c |   99 +
 src/others/xml/parsers/lv_xml_slider_parser.h |   40 +
 .../xml/parsers/lv_xml_tabview_parser.c       |  109 +
 .../xml/parsers/lv_xml_tabview_parser.h       |   44 +
 src/stdlib/lv_string.h                        |   11 +
 tests/ref_imgs/xml/complex_1.png              |  Bin 0 -> 11154 bytes
 tests/ref_imgs/xml/component_create_1.png     |  Bin 0 -> 3937 bytes
 tests/ref_imgs/xml/consts_1.png               |  Bin 0 -> 2808 bytes
 tests/ref_imgs/xml/image_and_font_1.png       |  Bin 0 -> 9693 bytes
 tests/ref_imgs/xml/lv_slider.png              |  Bin 0 -> 5010 bytes
 tests/ref_imgs/xml/nested_1.png               |  Bin 0 -> 10919 bytes
 tests/ref_imgs/xml/params_1.png               |  Bin 0 -> 5000 bytes
 tests/ref_imgs/xml/styles_1.png               |  Bin 0 -> 4701 bytes
 tests/ref_imgs/xml/widget_create_1.png        |  Bin 0 -> 3880 bytes
 tests/ref_imgs_vg_lite/xml/complex_1.png      |  Bin 0 -> 12155 bytes
 .../xml/component_create_1.png                |  Bin 0 -> 4481 bytes
 tests/ref_imgs_vg_lite/xml/consts_1.png       |  Bin 0 -> 2779 bytes
 .../ref_imgs_vg_lite/xml/image_and_font_1.png |  Bin 0 -> 5232 bytes
 tests/ref_imgs_vg_lite/xml/lv_slider.png      |  Bin 0 -> 5679 bytes
 tests/ref_imgs_vg_lite/xml/nested_1.png       |  Bin 0 -> 11209 bytes
 tests/ref_imgs_vg_lite/xml/params_1.png       |  Bin 0 -> 5027 bytes
 tests/ref_imgs_vg_lite/xml/styles_1.png       |  Bin 0 -> 5198 bytes
 .../ref_imgs_vg_lite/xml/widget_create_1.png  |  Bin 0 -> 4315 bytes
 tests/src/lv_test_conf_full.h                 |    1 +
 tests/src/test_assets/lv_example_xml.h        |   38 +
 tests/src/test_assets/xml/my_button.xml       |   15 +
 tests/src/test_assets/xml/my_card.xml         |   23 +
 tests/src/test_assets/xml/my_h3.xml           |   10 +
 tests/src/test_assets/xml/view.xml            |   25 +
 tests/src/test_cases/xml/test_xml_general.c   |  348 +
 tests/src/test_cases/xml/test_xml_slider.c    |   75 +
 xmls/globals.xml                              |   45 +
 xmls/lv_animimg.xml                           |   18 +
 xmls/lv_arc.xml                               |   32 +
 xmls/lv_bar.xml                               |   38 +
 xmls/lv_button.xml                            |   11 +
 xmls/lv_buttonmatrix.xml                      |   46 +
 xmls/lv_calendar.xml                          |   36 +
 xmls/lv_canvas.xml                            |   10 +
 xmls/lv_chart.xml                             |   66 +
 xmls/lv_checkbox.xml                          |   12 +
 xmls/lv_dropdown.xml                          |   24 +
 xmls/lv_label.xml                             |   27 +
 xmls/lv_obj.xml                               |   71 +
 xmls/lv_scale.xml                             |   61 +
 xmls/lv_slider.xml                            |   27 +
 xmls/lv_spangroup.xml                         |   46 +
 xmls/lv_table.xml                             |   50 +
 xmls/lv_tabview.xml                           |   24 +
 114 files changed, 21316 insertions(+), 5 deletions(-)
 create mode 100644 docs/details/other-components/xml.rst
 create mode 100644 examples/others/xml/index.rst
 create mode 100644 examples/others/xml/lv_example_xml.h
 create mode 100644 examples/others/xml/lv_example_xml_1.c
 create mode 100644 examples/others/xml/my_button.xml
 create mode 100644 examples/others/xml/my_card.xml
 create mode 100644 examples/others/xml/my_h3.xml
 create mode 100644 examples/others/xml/view.xml
 create mode 100755 src/libs/expat/add_lvgl_if.sh
 create mode 100644 src/libs/expat/ascii.h
 create mode 100644 src/libs/expat/asciitab.h
 create mode 100644 src/libs/expat/expat.h
 create mode 100644 src/libs/expat/expat_config.h
 create mode 100644 src/libs/expat/expat_external.h
 create mode 100644 src/libs/expat/iasciitab.h
 create mode 100644 src/libs/expat/internal.h
 create mode 100644 src/libs/expat/latin1tab.h
 create mode 100644 src/libs/expat/nametab.h
 create mode 100644 src/libs/expat/siphash.h
 create mode 100644 src/libs/expat/utf8tab.h
 create mode 100644 src/libs/expat/winconfig.h
 create mode 100644 src/libs/expat/xmlparse.c
 create mode 100644 src/libs/expat/xmlrole.c
 create mode 100644 src/libs/expat/xmlrole.h
 create mode 100644 src/libs/expat/xmltok.c
 create mode 100644 src/libs/expat/xmltok.h
 create mode 100644 src/libs/expat/xmltok_impl.c
 create mode 100644 src/libs/expat/xmltok_impl.h
 create mode 100644 src/libs/expat/xmltok_ns.c
 create mode 100644 src/others/xml/lv_xml.c
 create mode 100644 src/others/xml/lv_xml.h
 create mode 100644 src/others/xml/lv_xml_base_types.c
 create mode 100644 src/others/xml/lv_xml_base_types.h
 create mode 100644 src/others/xml/lv_xml_component.c
 create mode 100644 src/others/xml/lv_xml_component.h
 create mode 100644 src/others/xml/lv_xml_component_private.h
 create mode 100644 src/others/xml/lv_xml_parser.c
 create mode 100644 src/others/xml/lv_xml_parser.h
 create mode 100644 src/others/xml/lv_xml_private.h
 create mode 100644 src/others/xml/lv_xml_style.c
 create mode 100644 src/others/xml/lv_xml_style.h
 create mode 100644 src/others/xml/lv_xml_utils.c
 create mode 100644 src/others/xml/lv_xml_utils.h
 create mode 100644 src/others/xml/lv_xml_widget.c
 create mode 100644 src/others/xml/lv_xml_widget.h
 create mode 100644 src/others/xml/parsers/lv_xml_button_parser.c
 create mode 100644 src/others/xml/parsers/lv_xml_button_parser.h
 create mode 100644 src/others/xml/parsers/lv_xml_chart_parser.c
 create mode 100644 src/others/xml/parsers/lv_xml_chart_parser.h
 create mode 100644 src/others/xml/parsers/lv_xml_image_parser.c
 create mode 100644 src/others/xml/parsers/lv_xml_image_parser.h
 create mode 100644 src/others/xml/parsers/lv_xml_label_parser.c
 create mode 100644 src/others/xml/parsers/lv_xml_label_parser.h
 create mode 100644 src/others/xml/parsers/lv_xml_obj_parser.c
 create mode 100644 src/others/xml/parsers/lv_xml_obj_parser.h
 create mode 100644 src/others/xml/parsers/lv_xml_slider_parser.c
 create mode 100644 src/others/xml/parsers/lv_xml_slider_parser.h
 create mode 100644 src/others/xml/parsers/lv_xml_tabview_parser.c
 create mode 100644 src/others/xml/parsers/lv_xml_tabview_parser.h
 create mode 100644 tests/ref_imgs/xml/complex_1.png
 create mode 100644 tests/ref_imgs/xml/component_create_1.png
 create mode 100644 tests/ref_imgs/xml/consts_1.png
 create mode 100644 tests/ref_imgs/xml/image_and_font_1.png
 create mode 100644 tests/ref_imgs/xml/lv_slider.png
 create mode 100644 tests/ref_imgs/xml/nested_1.png
 create mode 100644 tests/ref_imgs/xml/params_1.png
 create mode 100644 tests/ref_imgs/xml/styles_1.png
 create mode 100644 tests/ref_imgs/xml/widget_create_1.png
 create mode 100644 tests/ref_imgs_vg_lite/xml/complex_1.png
 create mode 100644 tests/ref_imgs_vg_lite/xml/component_create_1.png
 create mode 100644 tests/ref_imgs_vg_lite/xml/consts_1.png
 create mode 100644 tests/ref_imgs_vg_lite/xml/image_and_font_1.png
 create mode 100644 tests/ref_imgs_vg_lite/xml/lv_slider.png
 create mode 100644 tests/ref_imgs_vg_lite/xml/nested_1.png
 create mode 100644 tests/ref_imgs_vg_lite/xml/params_1.png
 create mode 100644 tests/ref_imgs_vg_lite/xml/styles_1.png
 create mode 100644 tests/ref_imgs_vg_lite/xml/widget_create_1.png
 create mode 100644 tests/src/test_assets/lv_example_xml.h
 create mode 100644 tests/src/test_assets/xml/my_button.xml
 create mode 100644 tests/src/test_assets/xml/my_card.xml
 create mode 100644 tests/src/test_assets/xml/my_h3.xml
 create mode 100644 tests/src/test_assets/xml/view.xml
 create mode 100644 tests/src/test_cases/xml/test_xml_general.c
 create mode 100644 tests/src/test_cases/xml/test_xml_slider.c
 create mode 100644 xmls/globals.xml
 create mode 100644 xmls/lv_animimg.xml
 create mode 100644 xmls/lv_arc.xml
 create mode 100644 xmls/lv_bar.xml
 create mode 100644 xmls/lv_button.xml
 create mode 100644 xmls/lv_buttonmatrix.xml
 create mode 100644 xmls/lv_calendar.xml
 create mode 100644 xmls/lv_canvas.xml
 create mode 100644 xmls/lv_chart.xml
 create mode 100644 xmls/lv_checkbox.xml
 create mode 100644 xmls/lv_dropdown.xml
 create mode 100644 xmls/lv_label.xml
 create mode 100644 xmls/lv_obj.xml
 create mode 100644 xmls/lv_scale.xml
 create mode 100644 xmls/lv_slider.xml
 create mode 100644 xmls/lv_spangroup.xml
 create mode 100644 xmls/lv_table.xml
 create mode 100644 xmls/lv_tabview.xml

diff --git a/Kconfig b/Kconfig
index 903a2dce1..d274fcc97 100644
--- a/Kconfig
+++ b/Kconfig
@@ -1390,7 +1390,7 @@ menu "LVGL configuration"
 			default n
 			help
 				You won't be able to open URLs after enabling this feature.
-				Note that FFmpeg image decoder will always use lvgl file system. 
+				Note that FFmpeg image decoder will always use lvgl file system.
 	endmenu
 
 	menu "Others"
@@ -1591,7 +1591,8 @@ menu "LVGL configuration"
 			int "Font manager name max length"
 			depends on LV_USE_FONT_MANAGER
 			default 32
-
+		config LV_USE_XML
+			bool "Enable loading XML UIs runtime"
 		config LVGL_VERSION_MAJOR
 			int
 			default 9 # LVGL_VERSION_MAJOR
diff --git a/docs/details/other-components/index.rst b/docs/details/other-components/index.rst
index 769703559..45789cd15 100644
--- a/docs/details/other-components/index.rst
+++ b/docs/details/other-components/index.rst
@@ -18,3 +18,4 @@ Other Components
     obj_property
     observer
     snapshot
+    xml
diff --git a/docs/details/other-components/xml.rst b/docs/details/other-components/xml.rst
new file mode 100644
index 000000000..1937beb74
--- /dev/null
+++ b/docs/details/other-components/xml.rst
@@ -0,0 +1,301 @@
+.. _xml:
+
+====================
+XML - Declarative UI
+====================
+
+Introduction
+------------
+
+LVGL is capable of loading UI elements written in XML.
+Although still under development, the basics are already functional, serving as a preview.
+
+This declarative language serves as the backend for LVGL's UI editor (currently under development),
+which enables faster and more maintainable UI implementation.
+
+Note that, the UI editor is not required to utilize LVGL's XML loading capabilities.
+
+Describing the UI in XML in a declarative manner offers several advantages:
+
+- XML files can be loaded at runtime (e.g., from an SD card) to change the application build.
+- XML is simpler to write than C, enabling people with different skill sets to create LVGL UIs.
+- XML is textual data, making it easy to parse and manipulate with scripts.
+- XML can be used to generate LVGL code in any language.
+- XML helps to separate the view from the logic.
+
+Currently supported features:
+
+- Load XML components at runtime from file or data
+- Nest components and widgets any deep
+- Dynamically create instances of XML components in C
+- Register images and font that can be accessed by name later in the XMLs
+- Constants are working for widget and style properties
+- Parameters can be defined and passed and used for components
+- Basic built in widgets (label, slider, bar, button, etc)
+- Style sheets and local styles that can be assigned to parts and states support the basic style properties
+
+Limitations:
+
+- Only basic widgets are supported with limited functionality.
+- Only a few style properties are supported.
+- Events are not supported yet.
+- Animations are not supported yet.
+- Subjects are not supported yet.
+- The documentation is not complete yet.
+
+Main Concept
+~~~~~~~~~~~~
+
+It's important to distinguish between widgets and components:
+
+Widgets are the core building blocks of the UI and are not meant to be loaded at runtime
+but rather compiled into the application. The main characteristics of widgets are:
+
+- Similar to LVGL's built-in widgets.
+- Built from classes.
+- Have a large API with set/get/add/etc. functions.
+- Support "internal widgets" (e.g., tabview's tabs, dropdown's list).
+- Have custom and complex logic inside.
+- Cannot be loaded from XML at runtime because custom code cannot be loaded.
+
+Components are built from other components and widgets and can be loaded at runtime.
+The main characteristics of components are:
+
+- Built from widgets or other components.
+- Can be used for styling widgets.
+- Can contain widgets or other components.
+- Cannot have custom C code.
+- Can be loaded from XML at runtime as they describe only the visuals.
+
+Components
+----------
+
+Overview
+~~~~~~~~
+
+In light of the above, only components can be loaded from XML.
+An example of a ``my_button`` component looks like this:
+
+.. code-block:: xml
+
+    <component>
+        <consts>
+            <px name="size" value="100"/>
+            <color name="orange" value="0xffa020"/>
+        </consts>
+
+        <api>
+            <prop name="btn_text" default="Apply" type="string"/>
+        </api>
+
+        <styles>
+            <style name="blue" bg_color="0x0000ff" radius="2"/>
+            <style name="red" bg_color="0xff0000"/>
+        </styles>
+
+        <view extends="lv_button" width="#size" styles="blue red:pressed">
+            <my_h3 text="$btn_text" align="center" color="#orange" style_text_color:checked="0x00ff00"/>
+        </view>
+    </component>
+
+- ``<component>``: The root element.
+- ``<consts>``: Constants with ``int``, ``px``, ``string``, ``color``, or ``style`` types.
+Constants can later be referenced as ``#name``.
+- ``<params>``: Parameters with ``int``, ``px``, ``string``, ``color``, or ``style`` types.
+Parameters can later be referenced as ``$name``.
+- ``<styles>``: ``<style>`` properties can be defined with names and properties.
+- ``<view>``: Describes how the component looks. Can reference constants, parameters, and styles.
+
+Naming conventions:
+
+- A standard XML syntax is used.
+- Lowercase letters with ``_`` separation are used for attribute names.
+- The usual variable name rules apply for attribute and tag names: only letters, numbers, `'_'` and can't start with a number.
+- LVGL API is followed as much as possible, e.g., ``align="center"``, ``bg_color="0xff0000"``.
+- ``params`` can be referenced with ``$``
+- ``consts`` can be referenced with ``#``
+- ``styles`` can be attached to states and/or parts like ``styles="red blue:pressed green:focused:scrollbar"``
+- Local styles can be used like  ``<lv_label style_text_color="0xff0000" style_text_color:checked="0x00ff00" ``
+Usage
+~~~~~
+
+Once a component is created (e.g., ``my_button``), it can be registered by calling either:
+
+- ``lv_xml_component_register_from_file("A:lvgl/examples/others/xml/my_button.xml");``
+- ``lv_xml_component_register_from_data("my_button", xml_data_of_my_button);``
+
+These registration functions process the XML data and save some relevant data internally.
+This is required to make LVGL recognize the components by name.
+When loaded from a file, the file name is used as the component name.
+
+After this, a new instance of any of the registered components can be created with:
+``lv_obj_t * obj = lv_xml_create(lv_screen_active(), "my_button", NULL);``
+
+The created widget is a normal LVGL widget that can be used like any other manually created widget.
+
+The last parameter can be ``NULL`` or an attribute list, like this:
+
+.. code-block:: c
+
+    /* Can be local */
+    char * my_button_attrs[] = {
+        "x", "10",
+        "y", "-10",
+        "align", "bottom_left",
+        "btn_text", "New button",
+        NULL, NULL,
+    };
+
+    lv_obj_t * btn1 = lv_xml_create(lv_screen_active(), "my_button", my_button_attrs);
+
+Parameters
+~~~~~~~~~~
+
+It is possible to pass parameters to child components and widgets.
+These parameters can be set on a parent widget or provided by the user.
+
+Additionally, it's possible to use the extended widget's attributes
+(see ``<view extends="...">``) when a widget or component is created.
+This means that components and widgets inherit the API of the extended widget
+as well.
+
+The following example demonstrates parameter chaining and the use of the
+``text`` label property on a component:
+
+.. code-block:: xml
+
+    <!-- h3.xml -->
+    <component>
+        <view extends="lv_label"/>
+    </component>
+
+.. code-block:: xml
+
+    <!-- red_button.xml -->
+    <component>
+        <api>
+            <prop type="string" name="btn_text" default="None"/>
+        </api>
+        <view extends="lv_button" style_radius="0" style_bg_color="0xff0000">
+            <h3 text="$btn_text"/>
+        </view>
+    </component>
+
+.. code-block:: c
+
+    lv_xml_component_register_from_file("A:path/to/h3.xml");
+    lv_xml_component_register_from_file("A:path/to/red_button.xml");
+
+    /* Creates a button with "None" text */
+    lv_xml_create(lv_screen_active(), "red_button", NULL);
+
+    /* Use attributes to set the button text */
+    const char * attrs[] = {
+        "btn_text", "Click here",
+        NULL, NULL,
+    };
+    lv_xml_create(lv_screen_active(), "red_button", attrs);
+
+Widgets
+-------
+
+Overview
+~~~~~~~~
+
+Widgets are written in C and compiled into the application.
+They can be referenced from components, and their API can be used via the exposed attributes
+(e.g., label text or slider value).
+
+Usage
+~~~~~
+
+To make the widgets accessible from XML, an XML parser needs to be registered for each widget.
+The XML parser for the slider looks like this:
+
+.. code-block:: c
+
+    void * lv_xml_label_create(lv_xml_parser_state_t * state, const char ** attrs)
+    {
+        /* Create the label */
+        void * item = lv_label_create(lv_xml_state_get_parent(state));
+        return item;
+    }
+
+    void lv_xml_label_apply(lv_xml_parser_state_t * state, const char ** attrs)
+	{
+        void * item = lv_xml_state_get_item(state);
+
+	    /*Apply the common properties, e.g. width, height, styles flags etc*/
+	    lv_xml_obj_apply(state, attrs);
+
+        /* Apply the common properties, e.g., width, height, styles, flags, etc. */
+        lv_obj_xml_apply_attrs(state, item, attrs);
+
+        /* Process the label-specific attributes */
+        for(int i = 0; attrs[i]; i += 2) {
+            const char * name = attrs[i];
+            const char * value = attrs[i + 1];
+
+            if(lv_streq("text", name)) lv_label_set_text(item, value);
+            if(lv_streq("long_mode", name)) lv_label_set_long_mode(item, long_mode_text_to_enum_value(value));
+        }
+	}
+
+    /* Helper to convert the string to enum values */
+    static lv_label_long_mode_t long_mode_text_to_enum_value(const char * txt)
+    {
+        if(lv_streq("wrap", txt)) return LV_LABEL_LONG_WRAP;
+        if(lv_streq("scroll", txt)) return LV_LABEL_LONG_SCROLL;
+
+        LV_LOG_WARN("%s is an unknown value for label's long_mode", txt);
+        return 0; /* Return 0 in the absence of a better option. */
+    }
+
+A widget XML process can be registered like
+:cpp:expr:`lv_xml_widget_register("lv_label", lv_xml_label_create, lv_xml_label_apply);`
+
+After this, a widget can be created like this:
+
+.. code-block:: c
+
+    const char * attrs[] = {
+        "text", "Click here",
+        "align", "center",
+        NULL, NULL,
+    };
+
+    lv_xml_create(lv_screen_active(), "lv_label", attrs);
+
+LVGL automatically registers its built-in widgets,
+so only custom widgets need to be registered manually.
+
+Images and Fonts
+----------------
+
+In an XML file, images and fonts can be referenced via a name like this:
+``<lv_image src="image1" style_text_font="font1"/>``
+
+The font and image names must be mapped to the actual resources in the following way:
+
+.. code-block:: c
+
+    lv_xml_register_image("image1", "path/to/logo.png");
+    lv_xml_register_image("image2", &some_image_dsc);
+
+    lv_xml_register_font("font1", &arial_14);
+
+The built-in fonts are automatically registered with names like
+ ``"lv_montserrat_16"``.
+
+The registration functions should be called after
+:cpp:expr:`lv_init()` but before :cpp:expr:`lv_xml_create(...)`.
+
+Example
+-------
+
+.. include:: ../../examples/others/xml/index.rst
+
+.. _xml_api:
+
+API
+---
diff --git a/examples/others/lv_example_others.h b/examples/others/lv_example_others.h
index dc6886763..e4f25946c 100644
--- a/examples/others/lv_example_others.h
+++ b/examples/others/lv_example_others.h
@@ -23,6 +23,7 @@ extern "C" {
 #include "observer/lv_example_observer.h"
 #include "snapshot/lv_example_snapshot.h"
 #include "gestures/lv_example_gestures.h"
+#include "xml/lv_example_xml.h"
 
 /*********************
  *      DEFINES
diff --git a/examples/others/xml/index.rst b/examples/others/xml/index.rst
new file mode 100644
index 000000000..73e9e738a
--- /dev/null
+++ b/examples/others/xml/index.rst
@@ -0,0 +1,5 @@
+Load components at runtime
+--------------------------
+
+.. lv_example:: others/xml/lv_example_xml_1
+  :language: c
diff --git a/examples/others/xml/lv_example_xml.h b/examples/others/xml/lv_example_xml.h
new file mode 100644
index 000000000..341144881
--- /dev/null
+++ b/examples/others/xml/lv_example_xml.h
@@ -0,0 +1,38 @@
+/**
+ * @file lv_example_xml.h
+ *
+ */
+
+#ifndef LV_EXAMPLE_XML_H
+#define LV_EXAMPLE_XML_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+void lv_example_xml_1(void);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_EXAMPLE_XML_H*/
diff --git a/examples/others/xml/lv_example_xml_1.c b/examples/others/xml/lv_example_xml_1.c
new file mode 100644
index 000000000..6b1dcd894
--- /dev/null
+++ b/examples/others/xml/lv_example_xml_1.c
@@ -0,0 +1,37 @@
+#include "../../lv_examples.h"
+#if LV_BUILD_EXAMPLES && LV_USE_XML
+
+void lv_example_xml_1(void)
+{
+    lv_xml_component_register_from_file("A:lvgl/examples/others/xml/my_h3.xml");
+    lv_xml_component_register_from_file("A:lvgl/examples/others/xml/my_card.xml");
+    lv_xml_component_register_from_file("A:lvgl/examples/others/xml/my_button.xml");
+    lv_xml_component_register_from_file("A:lvgl/examples/others/xml/view.xml");
+
+    lv_obj_t * obj = lv_xml_create(lv_screen_active(), "view", NULL);
+    lv_obj_set_pos(obj, 10, 10);
+
+    const char * my_button_attrs[] = {
+        "x", "10",
+        "y", "-10",
+        "align", "bottom_left",
+        "btn_text", "New button",
+        NULL, NULL,
+    };
+
+    lv_xml_component_unregister("my_button");
+
+    lv_xml_create(lv_screen_active(), "my_button", my_button_attrs);
+
+    const char * slider_attrs[] = {
+        "x", "200",
+        "y", "-15",
+        "align", "bottom_left",
+        "value", "30",
+        NULL, NULL,
+    };
+
+    lv_obj_t * slider = lv_xml_create(lv_screen_active(), "lv_slider", slider_attrs);
+    lv_obj_set_width(slider, 100);
+}
+#endif
diff --git a/examples/others/xml/my_button.xml b/examples/others/xml/my_button.xml
new file mode 100644
index 000000000..bcfb69a39
--- /dev/null
+++ b/examples/others/xml/my_button.xml
@@ -0,0 +1,15 @@
+<component>
+	<consts>
+		<px name="size" value="100"/>
+		<color name="orange" value="0xffa020"/>
+	</consts>
+
+	<api>
+		<prop name="btn_text" type="string"/>
+	</api>
+
+	<view extends="lv_button" width="#size">
+		<my_h3 text="$btn_text" align="center" color="#orange"/>
+	</view>
+</component>
+
diff --git a/examples/others/xml/my_card.xml b/examples/others/xml/my_card.xml
new file mode 100644
index 000000000..7db0773b3
--- /dev/null
+++ b/examples/others/xml/my_card.xml
@@ -0,0 +1,23 @@
+<component>
+	<consts>
+		<px name="size" value="100%"/>
+	</consts>
+
+	<api>
+		<prop name="title" type="string" default="No title"/>
+		<prop name="action" type="string" default="No action"/>
+		<prop name="bg_color" type="color" default="0xcccccc"/>
+		<prop name="btn_rel_style" type="style" />
+		<prop name="btn_pr_style" type="style" />
+	</api>
+
+	<styles>
+		<style name="gray" bg_color="0x888888"/>
+		<style name="blue" bg_color="0x0000ff"/>
+	</styles>
+
+	<view extends="lv_obj" style_radius="3" width="#size" height="content" style_bg_color="$bg_color" >
+		<lv_label text="$title" align="left_mid"/>
+		<my_button styles="$btn_rel_style $btn_pr_style:pressed" btn_text="$action" align="right_mid"/>
+	</view>
+</component>
diff --git a/examples/others/xml/my_h3.xml b/examples/others/xml/my_h3.xml
new file mode 100644
index 000000000..979fc80c4
--- /dev/null
+++ b/examples/others/xml/my_h3.xml
@@ -0,0 +1,12 @@
+<component>
+	<api>
+		<prop name="color" type="color" default="0x000000"/>
+		<prop name="style"  type="style"/>
+	</api>
+
+	<view extends="lv_label"
+		  style_text_color="$color"
+		  styles="$style"
+		  style_text_font="lv_montserrat_18">
+	</view>
+</component>
diff --git a/examples/others/xml/view.xml b/examples/others/xml/view.xml
new file mode 100644
index 000000000..a59d948e0
--- /dev/null
+++ b/examples/others/xml/view.xml
@@ -0,0 +1,25 @@
+<component>
+	<consts>
+		<color name="light_blue" value="0xbbbbff"/>
+		<color name="dark_blue" value="0x000080"/>
+	</consts>
+
+	<styles>
+		<style name="btn_style" bg_color="#dark_blue" bg_opa="150"/>
+		<style name="btn_pr_style" bg_opa="255"/>
+	</styles>
+
+	<view extends="lv_obj" width="280" height="content" style_bg_color="#light_blue">
+		<lv_label text="Hello"/>
+		<my_card title="Card 1"
+				 y="0"
+				 btn_rel_style="btn_style"
+				 btn_pr_style="btn_pr_style"/>
+
+		<my_card y="85"
+				 bg_color="0xffaaaa"
+				 action="Apply"
+				 btn_rel_style="btn_style"
+				 btn_pr_style="btn_pr_style"/>
+	</view>
+</component>
diff --git a/lv_conf_template.h b/lv_conf_template.h
index 469cf5743..a4196cdf5 100644
--- a/lv_conf_template.h
+++ b/lv_conf_template.h
@@ -1076,11 +1076,14 @@
 #define LV_USE_FONT_MANAGER                     0
 #if LV_USE_FONT_MANAGER
 
-/*Font manager name max length*/
+/**Font manager name max length*/
 #define LV_FONT_MANAGER_NAME_MAX_LEN            32
 
 #endif
 
+/** Enable loading XML UIs runtime */
+#define LV_USE_XML	0
+
 /*==================
  * DEVICES
  *==================*/
diff --git a/lvgl.h b/lvgl.h
index 758e8be64..73051e1ad 100644
--- a/lvgl.h
+++ b/lvgl.h
@@ -94,6 +94,8 @@ extern "C" {
 #include "src/others/ime/lv_ime_pinyin.h"
 #include "src/others/file_explorer/lv_file_explorer.h"
 #include "src/others/font_manager/lv_font_manager.h"
+#include "src/others/xml/lv_xml.h"
+#include "src/others/xml/lv_xml_component.h"
 
 #include "src/libs/barcode/lv_barcode.h"
 #include "src/libs/bin_decoder/lv_bin_decoder.h"
diff --git a/lvgl_private.h b/lvgl_private.h
index b42a3260d..b4a958c83 100644
--- a/lvgl_private.h
+++ b/lvgl_private.h
@@ -28,6 +28,7 @@ extern "C" {
 #include "src/others/ime/lv_ime_pinyin_private.h"
 #include "src/others/fragment/lv_fragment_private.h"
 #include "src/others/observer/lv_observer_private.h"
+#include "src/others/xml/lv_xml_private.h"
 #include "src/libs/qrcode/lv_qrcode_private.h"
 #include "src/libs/barcode/lv_barcode_private.h"
 #include "src/libs/gif/lv_gif_private.h"
diff --git a/scripts/code-format.cfg b/scripts/code-format.cfg
index eb488758e..354d71c7b 100644
--- a/scripts/code-format.cfg
+++ b/scripts/code-format.cfg
@@ -47,6 +47,7 @@
 --exclude=../src/libs/tjpgd/tjpgd.h
 --exclude=../src/libs/tjpgd/tjpgdcnf.h
 --exclude=../src/libs/thorvg
+--exclude=../src/libs/expat
 --exclude=../src/libs/lz4
 --exclude=../src/others/vg_lite_tvg/vg_lite.h
 --exclude=../tests/unity/unity.c
diff --git a/src/libs/expat/add_lvgl_if.sh b/src/libs/expat/add_lvgl_if.sh
new file mode 100755
index 000000000..26752e868
--- /dev/null
+++ b/src/libs/expat/add_lvgl_if.sh
@@ -0,0 +1,13 @@
+#!/bin/bash
+
+#Add LVGL #if LV_USE_THORVG_INTERNAL guard
+#Usage
+#   find -name "*.cpp" | xargs ./add_lvgl_if.sh
+#   find -name "t*.h" | xargs ./add_lvgl_if.sh
+
+sed '0,/\*\/$/ {/\*\/$/ {n; s|^|\n#include "../../lv_conf_internal.h"\n#if LV_USE_XML\n|}}' $@ -i
+
+sed -i -e '$a\
+\
+#endif /* LV_USE_XML */\
+' $@ -i
diff --git a/src/libs/expat/ascii.h b/src/libs/expat/ascii.h
new file mode 100644
index 000000000..d4a868fe3
--- /dev/null
+++ b/src/libs/expat/ascii.h
@@ -0,0 +1,129 @@
+/*
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 1999-2000 Thai Open Source Software Center Ltd
+   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2002      Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
+   Copyright (c) 2007      Karl Waclawek <karl@waclawek.net>
+   Copyright (c) 2017      Sebastian Pipping <sebastian@pipping.org>
+   Licensed under the MIT license:
+
+   Permission is  hereby granted,  free of charge,  to any  person obtaining
+   a  copy  of  this  software   and  associated  documentation  files  (the
+   "Software"),  to  deal in  the  Software  without restriction,  including
+   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
+   distribute, sublicense, and/or sell copies of the Software, and to permit
+   persons  to whom  the Software  is  furnished to  do so,  subject to  the
+   following conditions:
+
+   The above copyright  notice and this permission notice  shall be included
+   in all copies or substantial portions of the Software.
+
+   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
+   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
+   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+   USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include "../../lv_conf_internal.h"
+#if LV_USE_XML
+
+#define ASCII_A 0x41
+#define ASCII_B 0x42
+#define ASCII_C 0x43
+#define ASCII_D 0x44
+#define ASCII_E 0x45
+#define ASCII_F 0x46
+#define ASCII_G 0x47
+#define ASCII_H 0x48
+#define ASCII_I 0x49
+#define ASCII_J 0x4A
+#define ASCII_K 0x4B
+#define ASCII_L 0x4C
+#define ASCII_M 0x4D
+#define ASCII_N 0x4E
+#define ASCII_O 0x4F
+#define ASCII_P 0x50
+#define ASCII_Q 0x51
+#define ASCII_R 0x52
+#define ASCII_S 0x53
+#define ASCII_T 0x54
+#define ASCII_U 0x55
+#define ASCII_V 0x56
+#define ASCII_W 0x57
+#define ASCII_X 0x58
+#define ASCII_Y 0x59
+#define ASCII_Z 0x5A
+
+#define ASCII_a 0x61
+#define ASCII_b 0x62
+#define ASCII_c 0x63
+#define ASCII_d 0x64
+#define ASCII_e 0x65
+#define ASCII_f 0x66
+#define ASCII_g 0x67
+#define ASCII_h 0x68
+#define ASCII_i 0x69
+#define ASCII_j 0x6A
+#define ASCII_k 0x6B
+#define ASCII_l 0x6C
+#define ASCII_m 0x6D
+#define ASCII_n 0x6E
+#define ASCII_o 0x6F
+#define ASCII_p 0x70
+#define ASCII_q 0x71
+#define ASCII_r 0x72
+#define ASCII_s 0x73
+#define ASCII_t 0x74
+#define ASCII_u 0x75
+#define ASCII_v 0x76
+#define ASCII_w 0x77
+#define ASCII_x 0x78
+#define ASCII_y 0x79
+#define ASCII_z 0x7A
+
+#define ASCII_0 0x30
+#define ASCII_1 0x31
+#define ASCII_2 0x32
+#define ASCII_3 0x33
+#define ASCII_4 0x34
+#define ASCII_5 0x35
+#define ASCII_6 0x36
+#define ASCII_7 0x37
+#define ASCII_8 0x38
+#define ASCII_9 0x39
+
+#define ASCII_TAB 0x09
+#define ASCII_SPACE 0x20
+#define ASCII_EXCL 0x21
+#define ASCII_QUOT 0x22
+#define ASCII_AMP 0x26
+#define ASCII_APOS 0x27
+#define ASCII_MINUS 0x2D
+#define ASCII_PERIOD 0x2E
+#define ASCII_COLON 0x3A
+#define ASCII_SEMI 0x3B
+#define ASCII_LT 0x3C
+#define ASCII_EQUALS 0x3D
+#define ASCII_GT 0x3E
+#define ASCII_LSQB 0x5B
+#define ASCII_RSQB 0x5D
+#define ASCII_UNDERSCORE 0x5F
+#define ASCII_LPAREN 0x28
+#define ASCII_RPAREN 0x29
+#define ASCII_FF 0x0C
+#define ASCII_SLASH 0x2F
+#define ASCII_HASH 0x23
+#define ASCII_PIPE 0x7C
+#define ASCII_COMMA 0x2C
+
+#endif /* LV_USE_XML */
+
diff --git a/src/libs/expat/asciitab.h b/src/libs/expat/asciitab.h
new file mode 100644
index 000000000..ed7942dfa
--- /dev/null
+++ b/src/libs/expat/asciitab.h
@@ -0,0 +1,72 @@
+/*
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2002      Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
+   Copyright (c) 2017      Sebastian Pipping <sebastian@pipping.org>
+   Licensed under the MIT license:
+
+   Permission is  hereby granted,  free of charge,  to any  person obtaining
+   a  copy  of  this  software   and  associated  documentation  files  (the
+   "Software"),  to  deal in  the  Software  without restriction,  including
+   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
+   distribute, sublicense, and/or sell copies of the Software, and to permit
+   persons  to whom  the Software  is  furnished to  do so,  subject to  the
+   following conditions:
+
+   The above copyright  notice and this permission notice  shall be included
+   in all copies or substantial portions of the Software.
+
+   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
+   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
+   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+   USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include "../../lv_conf_internal.h"
+#if LV_USE_XML
+
+/* 0x00 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+    /* 0x04 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+    /* 0x08 */ BT_NONXML, BT_S, BT_LF, BT_NONXML,
+    /* 0x0C */ BT_NONXML, BT_CR, BT_NONXML, BT_NONXML,
+    /* 0x10 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+    /* 0x14 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+    /* 0x18 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+    /* 0x1C */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+    /* 0x20 */ BT_S, BT_EXCL, BT_QUOT, BT_NUM,
+    /* 0x24 */ BT_OTHER, BT_PERCNT, BT_AMP, BT_APOS,
+    /* 0x28 */ BT_LPAR, BT_RPAR, BT_AST, BT_PLUS,
+    /* 0x2C */ BT_COMMA, BT_MINUS, BT_NAME, BT_SOL,
+    /* 0x30 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
+    /* 0x34 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
+    /* 0x38 */ BT_DIGIT, BT_DIGIT, BT_COLON, BT_SEMI,
+    /* 0x3C */ BT_LT, BT_EQUALS, BT_GT, BT_QUEST,
+    /* 0x40 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
+    /* 0x44 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
+    /* 0x48 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x4C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x50 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x54 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x58 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_LSQB,
+    /* 0x5C */ BT_OTHER, BT_RSQB, BT_OTHER, BT_NMSTRT,
+    /* 0x60 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
+    /* 0x64 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
+    /* 0x68 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x6C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x70 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x74 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x78 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
+    /* 0x7C */ BT_VERBAR, BT_OTHER, BT_OTHER, BT_OTHER,
+
+#endif /* LV_USE_XML */
+
diff --git a/src/libs/expat/expat.h b/src/libs/expat/expat.h
new file mode 100644
index 000000000..959e3b08b
--- /dev/null
+++ b/src/libs/expat/expat.h
@@ -0,0 +1,1081 @@
+/*
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2000-2005 Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
+   Copyright (c) 2001-2002 Greg Stein <gstein@users.sourceforge.net>
+   Copyright (c) 2002-2016 Karl Waclawek <karl@waclawek.net>
+   Copyright (c) 2016-2024 Sebastian Pipping <sebastian@pipping.org>
+   Copyright (c) 2016      Cristian Rodríguez <crrodriguez@opensuse.org>
+   Copyright (c) 2016      Thomas Beutlich <tc@tbeu.de>
+   Copyright (c) 2017      Rhodri James <rhodri@wildebeest.org.uk>
+   Copyright (c) 2022      Thijs Schreijer <thijs@thijsschreijer.nl>
+   Copyright (c) 2023      Hanno Böck <hanno@gentoo.org>
+   Copyright (c) 2023      Sony Corporation / Snild Dolkow <snild@sony.com>
+   Copyright (c) 2024      Taichi Haradaguchi <20001722@ymail.ne.jp>
+   Licensed under the MIT license:
+
+   Permission is  hereby granted,  free of charge,  to any  person obtaining
+   a  copy  of  this  software   and  associated  documentation  files  (the
+   "Software"),  to  deal in  the  Software  without restriction,  including
+   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
+   distribute, sublicense, and/or sell copies of the Software, and to permit
+   persons  to whom  the Software  is  furnished to  do so,  subject to  the
+   following conditions:
+
+   The above copyright  notice and this permission notice  shall be included
+   in all copies or substantial portions of the Software.
+
+   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
+   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
+   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+   USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include "../../lv_conf_internal.h"
+#if LV_USE_XML
+
+#ifndef Expat_INCLUDED
+#define Expat_INCLUDED 1
+
+#include <stdlib.h>
+#include "expat_external.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct XML_ParserStruct;
+typedef struct XML_ParserStruct *XML_Parser;
+
+typedef unsigned char XML_Bool;
+#define XML_TRUE ((XML_Bool)1)
+#define XML_FALSE ((XML_Bool)0)
+
+/* The XML_Status enum gives the possible return values for several
+   API functions.  The preprocessor #defines are included so this
+   stanza can be added to code that still needs to support older
+   versions of Expat 1.95.x:
+
+   #ifndef XML_STATUS_OK
+   #define XML_STATUS_OK    1
+   #define XML_STATUS_ERROR 0
+   #endif
+
+   Otherwise, the #define hackery is quite ugly and would have been
+   dropped.
+*/
+enum XML_Status {
+  XML_STATUS_ERROR = 0,
+#define XML_STATUS_ERROR XML_STATUS_ERROR
+  XML_STATUS_OK = 1,
+#define XML_STATUS_OK XML_STATUS_OK
+  XML_STATUS_SUSPENDED = 2
+#define XML_STATUS_SUSPENDED XML_STATUS_SUSPENDED
+};
+
+enum XML_Error {
+  XML_ERROR_NONE,
+  XML_ERROR_NO_MEMORY,
+  XML_ERROR_SYNTAX,
+  XML_ERROR_NO_ELEMENTS,
+  XML_ERROR_INVALID_TOKEN,
+  XML_ERROR_UNCLOSED_TOKEN,
+  XML_ERROR_PARTIAL_CHAR,
+  XML_ERROR_TAG_MISMATCH,
+  XML_ERROR_DUPLICATE_ATTRIBUTE,
+  XML_ERROR_JUNK_AFTER_DOC_ELEMENT,
+  XML_ERROR_PARAM_ENTITY_REF,
+  XML_ERROR_UNDEFINED_ENTITY,
+  XML_ERROR_RECURSIVE_ENTITY_REF,
+  XML_ERROR_ASYNC_ENTITY,
+  XML_ERROR_BAD_CHAR_REF,
+  XML_ERROR_BINARY_ENTITY_REF,
+  XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF,
+  XML_ERROR_MISPLACED_XML_PI,
+  XML_ERROR_UNKNOWN_ENCODING,
+  XML_ERROR_INCORRECT_ENCODING,
+  XML_ERROR_UNCLOSED_CDATA_SECTION,
+  XML_ERROR_EXTERNAL_ENTITY_HANDLING,
+  XML_ERROR_NOT_STANDALONE,
+  XML_ERROR_UNEXPECTED_STATE,
+  XML_ERROR_ENTITY_DECLARED_IN_PE,
+  XML_ERROR_FEATURE_REQUIRES_XML_DTD,
+  XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING,
+  /* Added in 1.95.7. */
+  XML_ERROR_UNBOUND_PREFIX,
+  /* Added in 1.95.8. */
+  XML_ERROR_UNDECLARING_PREFIX,
+  XML_ERROR_INCOMPLETE_PE,
+  XML_ERROR_XML_DECL,
+  XML_ERROR_TEXT_DECL,
+  XML_ERROR_PUBLICID,
+  XML_ERROR_SUSPENDED,
+  XML_ERROR_NOT_SUSPENDED,
+  XML_ERROR_ABORTED,
+  XML_ERROR_FINISHED,
+  XML_ERROR_SUSPEND_PE,
+  /* Added in 2.0. */
+  XML_ERROR_RESERVED_PREFIX_XML,
+  XML_ERROR_RESERVED_PREFIX_XMLNS,
+  XML_ERROR_RESERVED_NAMESPACE_URI,
+  /* Added in 2.2.1. */
+  XML_ERROR_INVALID_ARGUMENT,
+  /* Added in 2.3.0. */
+  XML_ERROR_NO_BUFFER,
+  /* Added in 2.4.0. */
+  XML_ERROR_AMPLIFICATION_LIMIT_BREACH
+};
+
+enum XML_Content_Type {
+  XML_CTYPE_EMPTY = 1,
+  XML_CTYPE_ANY,
+  XML_CTYPE_MIXED,
+  XML_CTYPE_NAME,
+  XML_CTYPE_CHOICE,
+  XML_CTYPE_SEQ
+};
+
+enum XML_Content_Quant {
+  XML_CQUANT_NONE,
+  XML_CQUANT_OPT,
+  XML_CQUANT_REP,
+  XML_CQUANT_PLUS
+};
+
+/* If type == XML_CTYPE_EMPTY or XML_CTYPE_ANY, then quant will be
+   XML_CQUANT_NONE, and the other fields will be zero or NULL.
+   If type == XML_CTYPE_MIXED, then quant will be NONE or REP and
+   numchildren will contain number of elements that may be mixed in
+   and children point to an array of XML_Content cells that will be
+   all of XML_CTYPE_NAME type with no quantification.
+
+   If type == XML_CTYPE_NAME, then the name points to the name, and
+   the numchildren field will be zero and children will be NULL. The
+   quant fields indicates any quantifiers placed on the name.
+
+   CHOICE and SEQ will have name NULL, the number of children in
+   numchildren and children will point, recursively, to an array
+   of XML_Content cells.
+
+   The EMPTY, ANY, and MIXED types will only occur at top level.
+*/
+
+typedef struct XML_cp XML_Content;
+
+struct XML_cp {
+  enum XML_Content_Type type;
+  enum XML_Content_Quant quant;
+  XML_Char *name;
+  unsigned int numchildren;
+  XML_Content *children;
+};
+
+/* This is called for an element declaration. See above for
+   description of the model argument. It's the user code's responsibility
+   to free model when finished with it. See XML_FreeContentModel.
+   There is no need to free the model from the handler, it can be kept
+   around and freed at a later stage.
+*/
+typedef void(XMLCALL *XML_ElementDeclHandler)(void *userData,
+                                              const XML_Char *name,
+                                              XML_Content *model);
+
+XMLPARSEAPI(void)
+XML_SetElementDeclHandler(XML_Parser parser, XML_ElementDeclHandler eldecl);
+
+/* The Attlist declaration handler is called for *each* attribute. So
+   a single Attlist declaration with multiple attributes declared will
+   generate multiple calls to this handler. The "default" parameter
+   may be NULL in the case of the "#IMPLIED" or "#REQUIRED"
+   keyword. The "isrequired" parameter will be true and the default
+   value will be NULL in the case of "#REQUIRED". If "isrequired" is
+   true and default is non-NULL, then this is a "#FIXED" default.
+*/
+typedef void(XMLCALL *XML_AttlistDeclHandler)(
+    void *userData, const XML_Char *elname, const XML_Char *attname,
+    const XML_Char *att_type, const XML_Char *dflt, int isrequired);
+
+XMLPARSEAPI(void)
+XML_SetAttlistDeclHandler(XML_Parser parser, XML_AttlistDeclHandler attdecl);
+
+/* The XML declaration handler is called for *both* XML declarations
+   and text declarations. The way to distinguish is that the version
+   parameter will be NULL for text declarations. The encoding
+   parameter may be NULL for XML declarations. The standalone
+   parameter will be -1, 0, or 1 indicating respectively that there
+   was no standalone parameter in the declaration, that it was given
+   as no, or that it was given as yes.
+*/
+typedef void(XMLCALL *XML_XmlDeclHandler)(void *userData,
+                                          const XML_Char *version,
+                                          const XML_Char *encoding,
+                                          int standalone);
+
+XMLPARSEAPI(void)
+XML_SetXmlDeclHandler(XML_Parser parser, XML_XmlDeclHandler xmldecl);
+
+typedef struct {
+  void *(*malloc_fcn)(size_t size);
+  void *(*realloc_fcn)(void *ptr, size_t size);
+  void (*free_fcn)(void *ptr);
+} XML_Memory_Handling_Suite;
+
+/* Constructs a new parser; encoding is the encoding specified by the
+   external protocol or NULL if there is none specified.
+*/
+XMLPARSEAPI(XML_Parser)
+XML_ParserCreate(const XML_Char *encoding);
+
+/* Constructs a new parser and namespace processor.  Element type
+   names and attribute names that belong to a namespace will be
+   expanded; unprefixed attribute names are never expanded; unprefixed
+   element type names are expanded only if there is a default
+   namespace. The expanded name is the concatenation of the namespace
+   URI, the namespace separator character, and the local part of the
+   name.  If the namespace separator is '\0' then the namespace URI
+   and the local part will be concatenated without any separator.
+   It is a programming error to use the separator '\0' with namespace
+   triplets (see XML_SetReturnNSTriplet).
+   If a namespace separator is chosen that can be part of a URI or
+   part of an XML name, splitting an expanded name back into its
+   1, 2 or 3 original parts on application level in the element handler
+   may end up vulnerable, so these are advised against;  sane choices for
+   a namespace separator are e.g. '\n' (line feed) and '|' (pipe).
+
+   Note that Expat does not validate namespace URIs (beyond encoding)
+   against RFC 3986 today (and is not required to do so with regard to
+   the XML 1.0 namespaces specification) but it may start doing that
+   in future releases.  Before that, an application using Expat must
+   be ready to receive namespace URIs containing non-URI characters.
+*/
+XMLPARSEAPI(XML_Parser)
+XML_ParserCreateNS(const XML_Char *encoding, XML_Char namespaceSeparator);
+
+/* Constructs a new parser using the memory management suite referred to
+   by memsuite. If memsuite is NULL, then use the standard library memory
+   suite. If namespaceSeparator is non-NULL it creates a parser with
+   namespace processing as described above. The character pointed at
+   will serve as the namespace separator.
+
+   All further memory operations used for the created parser will come from
+   the given suite.
+*/
+XMLPARSEAPI(XML_Parser)
+XML_ParserCreate_MM(const XML_Char *encoding,
+                    const XML_Memory_Handling_Suite *memsuite,
+                    const XML_Char *namespaceSeparator);
+
+/* Prepare a parser object to be reused.  This is particularly
+   valuable when memory allocation overhead is disproportionately high,
+   such as when a large number of small documnents need to be parsed.
+   All handlers are cleared from the parser, except for the
+   unknownEncodingHandler. The parser's external state is re-initialized
+   except for the values of ns and ns_triplets.
+
+   Added in Expat 1.95.3.
+*/
+XMLPARSEAPI(XML_Bool)
+XML_ParserReset(XML_Parser parser, const XML_Char *encoding);
+
+/* atts is array of name/value pairs, terminated by 0;
+   names and values are 0 terminated.
+*/
+typedef void(XMLCALL *XML_StartElementHandler)(void *userData,
+                                               const XML_Char *name,
+                                               const XML_Char **atts);
+
+typedef void(XMLCALL *XML_EndElementHandler)(void *userData,
+                                             const XML_Char *name);
+
+/* s is not 0 terminated. */
+typedef void(XMLCALL *XML_CharacterDataHandler)(void *userData,
+                                                const XML_Char *s, int len);
+
+/* target and data are 0 terminated */
+typedef void(XMLCALL *XML_ProcessingInstructionHandler)(void *userData,
+                                                        const XML_Char *target,
+                                                        const XML_Char *data);
+
+/* data is 0 terminated */
+typedef void(XMLCALL *XML_CommentHandler)(void *userData, const XML_Char *data);
+
+typedef void(XMLCALL *XML_StartCdataSectionHandler)(void *userData);
+typedef void(XMLCALL *XML_EndCdataSectionHandler)(void *userData);
+
+/* This is called for any characters in the XML document for which
+   there is no applicable handler.  This includes both characters that
+   are part of markup which is of a kind that is not reported
+   (comments, markup declarations), or characters that are part of a
+   construct which could be reported but for which no handler has been
+   supplied. The characters are passed exactly as they were in the XML
+   document except that they will be encoded in UTF-8 or UTF-16.
+   Line boundaries are not normalized. Note that a byte order mark
+   character is not passed to the default handler. There are no
+   guarantees about how characters are divided between calls to the
+   default handler: for example, a comment might be split between
+   multiple calls.
+*/
+typedef void(XMLCALL *XML_DefaultHandler)(void *userData, const XML_Char *s,
+                                          int len);
+
+/* This is called for the start of the DOCTYPE declaration, before
+   any DTD or internal subset is parsed.
+*/
+typedef void(XMLCALL *XML_StartDoctypeDeclHandler)(void *userData,
+                                                   const XML_Char *doctypeName,
+                                                   const XML_Char *sysid,
+                                                   const XML_Char *pubid,
+                                                   int has_internal_subset);
+
+/* This is called for the end of the DOCTYPE declaration when the
+   closing > is encountered, but after processing any external
+   subset.
+*/
+typedef void(XMLCALL *XML_EndDoctypeDeclHandler)(void *userData);
+
+/* This is called for entity declarations. The is_parameter_entity
+   argument will be non-zero if the entity is a parameter entity, zero
+   otherwise.
+
+   For internal entities (<!ENTITY foo "bar">), value will
+   be non-NULL and systemId, publicID, and notationName will be NULL.
+   The value string is NOT null-terminated; the length is provided in
+   the value_length argument. Since it is legal to have zero-length
+   values, do not use this argument to test for internal entities.
+
+   For external entities, value will be NULL and systemId will be
+   non-NULL. The publicId argument will be NULL unless a public
+   identifier was provided. The notationName argument will have a
+   non-NULL value only for unparsed entity declarations.
+
+   Note that is_parameter_entity can't be changed to XML_Bool, since
+   that would break binary compatibility.
+*/
+typedef void(XMLCALL *XML_EntityDeclHandler)(
+    void *userData, const XML_Char *entityName, int is_parameter_entity,
+    const XML_Char *value, int value_length, const XML_Char *base,
+    const XML_Char *systemId, const XML_Char *publicId,
+    const XML_Char *notationName);
+
+XMLPARSEAPI(void)
+XML_SetEntityDeclHandler(XML_Parser parser, XML_EntityDeclHandler handler);
+
+/* OBSOLETE -- OBSOLETE -- OBSOLETE
+   This handler has been superseded by the EntityDeclHandler above.
+   It is provided here for backward compatibility.
+
+   This is called for a declaration of an unparsed (NDATA) entity.
+   The base argument is whatever was set by XML_SetBase. The
+   entityName, systemId and notationName arguments will never be
+   NULL. The other arguments may be.
+*/
+typedef void(XMLCALL *XML_UnparsedEntityDeclHandler)(
+    void *userData, const XML_Char *entityName, const XML_Char *base,
+    const XML_Char *systemId, const XML_Char *publicId,
+    const XML_Char *notationName);
+
+/* This is called for a declaration of notation.  The base argument is
+   whatever was set by XML_SetBase. The notationName will never be
+   NULL.  The other arguments can be.
+*/
+typedef void(XMLCALL *XML_NotationDeclHandler)(void *userData,
+                                               const XML_Char *notationName,
+                                               const XML_Char *base,
+                                               const XML_Char *systemId,
+                                               const XML_Char *publicId);
+
+/* When namespace processing is enabled, these are called once for
+   each namespace declaration. The call to the start and end element
+   handlers occur between the calls to the start and end namespace
+   declaration handlers. For an xmlns attribute, prefix will be
+   NULL.  For an xmlns="" attribute, uri will be NULL.
+*/
+typedef void(XMLCALL *XML_StartNamespaceDeclHandler)(void *userData,
+                                                     const XML_Char *prefix,
+                                                     const XML_Char *uri);
+
+typedef void(XMLCALL *XML_EndNamespaceDeclHandler)(void *userData,
+                                                   const XML_Char *prefix);
+
+/* This is called if the document is not standalone, that is, it has an
+   external subset or a reference to a parameter entity, but does not
+   have standalone="yes". If this handler returns XML_STATUS_ERROR,
+   then processing will not continue, and the parser will return a
+   XML_ERROR_NOT_STANDALONE error.
+   If parameter entity parsing is enabled, then in addition to the
+   conditions above this handler will only be called if the referenced
+   entity was actually read.
+*/
+typedef int(XMLCALL *XML_NotStandaloneHandler)(void *userData);
+
+/* This is called for a reference to an external parsed general
+   entity.  The referenced entity is not automatically parsed.  The
+   application can parse it immediately or later using
+   XML_ExternalEntityParserCreate.
+
+   The parser argument is the parser parsing the entity containing the
+   reference; it can be passed as the parser argument to
+   XML_ExternalEntityParserCreate.  The systemId argument is the
+   system identifier as specified in the entity declaration; it will
+   not be NULL.
+
+   The base argument is the system identifier that should be used as
+   the base for resolving systemId if systemId was relative; this is
+   set by XML_SetBase; it may be NULL.
+
+   The publicId argument is the public identifier as specified in the
+   entity declaration, or NULL if none was specified; the whitespace
+   in the public identifier will have been normalized as required by
+   the XML spec.
+
+   The context argument specifies the parsing context in the format
+   expected by the context argument to XML_ExternalEntityParserCreate;
+   context is valid only until the handler returns, so if the
+   referenced entity is to be parsed later, it must be copied.
+   context is NULL only when the entity is a parameter entity.
+
+   The handler should return XML_STATUS_ERROR if processing should not
+   continue because of a fatal error in the handling of the external
+   entity.  In this case the calling parser will return an
+   XML_ERROR_EXTERNAL_ENTITY_HANDLING error.
+
+   Note that unlike other handlers the first argument is the parser,
+   not userData.
+*/
+typedef int(XMLCALL *XML_ExternalEntityRefHandler)(XML_Parser parser,
+                                                   const XML_Char *context,
+                                                   const XML_Char *base,
+                                                   const XML_Char *systemId,
+                                                   const XML_Char *publicId);
+
+/* This is called in two situations:
+   1) An entity reference is encountered for which no declaration
+      has been read *and* this is not an error.
+   2) An internal entity reference is read, but not expanded, because
+      XML_SetDefaultHandler has been called.
+   Note: skipped parameter entities in declarations and skipped general
+         entities in attribute values cannot be reported, because
+         the event would be out of sync with the reporting of the
+         declarations or attribute values
+*/
+typedef void(XMLCALL *XML_SkippedEntityHandler)(void *userData,
+                                                const XML_Char *entityName,
+                                                int is_parameter_entity);
+
+/* This structure is filled in by the XML_UnknownEncodingHandler to
+   provide information to the parser about encodings that are unknown
+   to the parser.
+
+   The map[b] member gives information about byte sequences whose
+   first byte is b.
+
+   If map[b] is c where c is >= 0, then b by itself encodes the
+   Unicode scalar value c.
+
+   If map[b] is -1, then the byte sequence is malformed.
+
+   If map[b] is -n, where n >= 2, then b is the first byte of an
+   n-byte sequence that encodes a single Unicode scalar value.
+
+   The data member will be passed as the first argument to the convert
+   function.
+
+   The convert function is used to convert multibyte sequences; s will
+   point to a n-byte sequence where map[(unsigned char)*s] == -n.  The
+   convert function must return the Unicode scalar value represented
+   by this byte sequence or -1 if the byte sequence is malformed.
+
+   The convert function may be NULL if the encoding is a single-byte
+   encoding, that is if map[b] >= -1 for all bytes b.
+
+   When the parser is finished with the encoding, then if release is
+   not NULL, it will call release passing it the data member; once
+   release has been called, the convert function will not be called
+   again.
+
+   Expat places certain restrictions on the encodings that are supported
+   using this mechanism.
+
+   1. Every ASCII character that can appear in a well-formed XML document,
+      other than the characters
+
+      $@\^`{}~
+
+      must be represented by a single byte, and that byte must be the
+      same byte that represents that character in ASCII.
+
+   2. No character may require more than 4 bytes to encode.
+
+   3. All characters encoded must have Unicode scalar values <=
+      0xFFFF, (i.e., characters that would be encoded by surrogates in
+      UTF-16 are  not allowed).  Note that this restriction doesn't
+      apply to the built-in support for UTF-8 and UTF-16.
+
+   4. No Unicode character may be encoded by more than one distinct
+      sequence of bytes.
+*/
+typedef struct {
+  int map[256];
+  void *data;
+  int(XMLCALL *convert)(void *data, const char *s);
+  void(XMLCALL *release)(void *data);
+} XML_Encoding;
+
+/* This is called for an encoding that is unknown to the parser.
+
+   The encodingHandlerData argument is that which was passed as the
+   second argument to XML_SetUnknownEncodingHandler.
+
+   The name argument gives the name of the encoding as specified in
+   the encoding declaration.
+
+   If the callback can provide information about the encoding, it must
+   fill in the XML_Encoding structure, and return XML_STATUS_OK.
+   Otherwise it must return XML_STATUS_ERROR.
+
+   If info does not describe a suitable encoding, then the parser will
+   return an XML_ERROR_UNKNOWN_ENCODING error.
+*/
+typedef int(XMLCALL *XML_UnknownEncodingHandler)(void *encodingHandlerData,
+                                                 const XML_Char *name,
+                                                 XML_Encoding *info);
+
+XMLPARSEAPI(void)
+XML_SetElementHandler(XML_Parser parser, XML_StartElementHandler start,
+                      XML_EndElementHandler end);
+
+XMLPARSEAPI(void)
+XML_SetStartElementHandler(XML_Parser parser, XML_StartElementHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetEndElementHandler(XML_Parser parser, XML_EndElementHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetCharacterDataHandler(XML_Parser parser,
+                            XML_CharacterDataHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetProcessingInstructionHandler(XML_Parser parser,
+                                    XML_ProcessingInstructionHandler handler);
+XMLPARSEAPI(void)
+XML_SetCommentHandler(XML_Parser parser, XML_CommentHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetCdataSectionHandler(XML_Parser parser,
+                           XML_StartCdataSectionHandler start,
+                           XML_EndCdataSectionHandler end);
+
+XMLPARSEAPI(void)
+XML_SetStartCdataSectionHandler(XML_Parser parser,
+                                XML_StartCdataSectionHandler start);
+
+XMLPARSEAPI(void)
+XML_SetEndCdataSectionHandler(XML_Parser parser,
+                              XML_EndCdataSectionHandler end);
+
+/* This sets the default handler and also inhibits expansion of
+   internal entities. These entity references will be passed to the
+   default handler, or to the skipped entity handler, if one is set.
+*/
+XMLPARSEAPI(void)
+XML_SetDefaultHandler(XML_Parser parser, XML_DefaultHandler handler);
+
+/* This sets the default handler but does not inhibit expansion of
+   internal entities.  The entity reference will not be passed to the
+   default handler.
+*/
+XMLPARSEAPI(void)
+XML_SetDefaultHandlerExpand(XML_Parser parser, XML_DefaultHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetDoctypeDeclHandler(XML_Parser parser, XML_StartDoctypeDeclHandler start,
+                          XML_EndDoctypeDeclHandler end);
+
+XMLPARSEAPI(void)
+XML_SetStartDoctypeDeclHandler(XML_Parser parser,
+                               XML_StartDoctypeDeclHandler start);
+
+XMLPARSEAPI(void)
+XML_SetEndDoctypeDeclHandler(XML_Parser parser, XML_EndDoctypeDeclHandler end);
+
+XMLPARSEAPI(void)
+XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
+                                 XML_UnparsedEntityDeclHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetNotationDeclHandler(XML_Parser parser, XML_NotationDeclHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetNamespaceDeclHandler(XML_Parser parser,
+                            XML_StartNamespaceDeclHandler start,
+                            XML_EndNamespaceDeclHandler end);
+
+XMLPARSEAPI(void)
+XML_SetStartNamespaceDeclHandler(XML_Parser parser,
+                                 XML_StartNamespaceDeclHandler start);
+
+XMLPARSEAPI(void)
+XML_SetEndNamespaceDeclHandler(XML_Parser parser,
+                               XML_EndNamespaceDeclHandler end);
+
+XMLPARSEAPI(void)
+XML_SetNotStandaloneHandler(XML_Parser parser,
+                            XML_NotStandaloneHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetExternalEntityRefHandler(XML_Parser parser,
+                                XML_ExternalEntityRefHandler handler);
+
+/* If a non-NULL value for arg is specified here, then it will be
+   passed as the first argument to the external entity ref handler
+   instead of the parser object.
+*/
+XMLPARSEAPI(void)
+XML_SetExternalEntityRefHandlerArg(XML_Parser parser, void *arg);
+
+XMLPARSEAPI(void)
+XML_SetSkippedEntityHandler(XML_Parser parser,
+                            XML_SkippedEntityHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetUnknownEncodingHandler(XML_Parser parser,
+                              XML_UnknownEncodingHandler handler,
+                              void *encodingHandlerData);
+
+/* This can be called within a handler for a start element, end
+   element, processing instruction or character data.  It causes the
+   corresponding markup to be passed to the default handler.
+*/
+XMLPARSEAPI(void)
+XML_DefaultCurrent(XML_Parser parser);
+
+/* If do_nst is non-zero, and namespace processing is in effect, and
+   a name has a prefix (i.e. an explicit namespace qualifier) then
+   that name is returned as a triplet in a single string separated by
+   the separator character specified when the parser was created: URI
+   + sep + local_name + sep + prefix.
+
+   If do_nst is zero, then namespace information is returned in the
+   default manner (URI + sep + local_name) whether or not the name
+   has a prefix.
+
+   Note: Calling XML_SetReturnNSTriplet after XML_Parse or
+     XML_ParseBuffer has no effect.
+*/
+
+XMLPARSEAPI(void)
+XML_SetReturnNSTriplet(XML_Parser parser, int do_nst);
+
+/* This value is passed as the userData argument to callbacks. */
+XMLPARSEAPI(void)
+XML_SetUserData(XML_Parser parser, void *userData);
+
+/* Returns the last value set by XML_SetUserData or NULL. */
+#define XML_GetUserData(parser) (*(void **)(parser))
+
+/* This is equivalent to supplying an encoding argument to
+   XML_ParserCreate. On success XML_SetEncoding returns non-zero,
+   zero otherwise.
+   Note: Calling XML_SetEncoding after XML_Parse or XML_ParseBuffer
+     has no effect and returns XML_STATUS_ERROR.
+*/
+XMLPARSEAPI(enum XML_Status)
+XML_SetEncoding(XML_Parser parser, const XML_Char *encoding);
+
+/* If this function is called, then the parser will be passed as the
+   first argument to callbacks instead of userData.  The userData will
+   still be accessible using XML_GetUserData.
+*/
+XMLPARSEAPI(void)
+XML_UseParserAsHandlerArg(XML_Parser parser);
+
+/* If useDTD == XML_TRUE is passed to this function, then the parser
+   will assume that there is an external subset, even if none is
+   specified in the document. In such a case the parser will call the
+   externalEntityRefHandler with a value of NULL for the systemId
+   argument (the publicId and context arguments will be NULL as well).
+   Note: For the purpose of checking WFC: Entity Declared, passing
+     useDTD == XML_TRUE will make the parser behave as if the document
+     had a DTD with an external subset.
+   Note: If this function is called, then this must be done before
+     the first call to XML_Parse or XML_ParseBuffer, since it will
+     have no effect after that.  Returns
+     XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING.
+   Note: If the document does not have a DOCTYPE declaration at all,
+     then startDoctypeDeclHandler and endDoctypeDeclHandler will not
+     be called, despite an external subset being parsed.
+   Note: If XML_DTD is not defined when Expat is compiled, returns
+     XML_ERROR_FEATURE_REQUIRES_XML_DTD.
+   Note: If parser == NULL, returns XML_ERROR_INVALID_ARGUMENT.
+*/
+XMLPARSEAPI(enum XML_Error)
+XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD);
+
+/* Sets the base to be used for resolving relative URIs in system
+   identifiers in declarations.  Resolving relative identifiers is
+   left to the application: this value will be passed through as the
+   base argument to the XML_ExternalEntityRefHandler,
+   XML_NotationDeclHandler and XML_UnparsedEntityDeclHandler. The base
+   argument will be copied.  Returns XML_STATUS_ERROR if out of memory,
+   XML_STATUS_OK otherwise.
+*/
+XMLPARSEAPI(enum XML_Status)
+XML_SetBase(XML_Parser parser, const XML_Char *base);
+
+XMLPARSEAPI(const XML_Char *)
+XML_GetBase(XML_Parser parser);
+
+/* Returns the number of the attribute/value pairs passed in last call
+   to the XML_StartElementHandler that were specified in the start-tag
+   rather than defaulted. Each attribute/value pair counts as 2; thus
+   this corresponds to an index into the atts array passed to the
+   XML_StartElementHandler.  Returns -1 if parser == NULL.
+*/
+XMLPARSEAPI(int)
+XML_GetSpecifiedAttributeCount(XML_Parser parser);
+
+/* Returns the index of the ID attribute passed in the last call to
+   XML_StartElementHandler, or -1 if there is no ID attribute or
+   parser == NULL.  Each attribute/value pair counts as 2; thus this
+   corresponds to an index into the atts array passed to the
+   XML_StartElementHandler.
+*/
+XMLPARSEAPI(int)
+XML_GetIdAttributeIndex(XML_Parser parser);
+
+#ifdef XML_ATTR_INFO
+/* Source file byte offsets for the start and end of attribute names and values.
+   The value indices are exclusive of surrounding quotes; thus in a UTF-8 source
+   file an attribute value of "blah" will yield:
+   info->valueEnd - info->valueStart = 4 bytes.
+*/
+typedef struct {
+  XML_Index nameStart;  /* Offset to beginning of the attribute name. */
+  XML_Index nameEnd;    /* Offset after the attribute name's last byte. */
+  XML_Index valueStart; /* Offset to beginning of the attribute value. */
+  XML_Index valueEnd;   /* Offset after the attribute value's last byte. */
+} XML_AttrInfo;
+
+/* Returns an array of XML_AttrInfo structures for the attribute/value pairs
+   passed in last call to the XML_StartElementHandler that were specified
+   in the start-tag rather than defaulted. Each attribute/value pair counts
+   as 1; thus the number of entries in the array is
+   XML_GetSpecifiedAttributeCount(parser) / 2.
+*/
+XMLPARSEAPI(const XML_AttrInfo *)
+XML_GetAttributeInfo(XML_Parser parser);
+#endif
+
+/* Parses some input. Returns XML_STATUS_ERROR if a fatal error is
+   detected.  The last call to XML_Parse must have isFinal true; len
+   may be zero for this call (or any other).
+
+   Though the return values for these functions has always been
+   described as a Boolean value, the implementation, at least for the
+   1.95.x series, has always returned exactly one of the XML_Status
+   values.
+*/
+XMLPARSEAPI(enum XML_Status)
+XML_Parse(XML_Parser parser, const char *s, int len, int isFinal);
+
+XMLPARSEAPI(void *)
+XML_GetBuffer(XML_Parser parser, int len);
+
+XMLPARSEAPI(enum XML_Status)
+XML_ParseBuffer(XML_Parser parser, int len, int isFinal);
+
+/* Stops parsing, causing XML_Parse() or XML_ParseBuffer() to return.
+   Must be called from within a call-back handler, except when aborting
+   (resumable = 0) an already suspended parser. Some call-backs may
+   still follow because they would otherwise get lost. Examples:
+   - endElementHandler() for empty elements when stopped in
+     startElementHandler(),
+   - endNameSpaceDeclHandler() when stopped in endElementHandler(),
+   and possibly others.
+
+   Can be called from most handlers, including DTD related call-backs,
+   except when parsing an external parameter entity and resumable != 0.
+   Returns XML_STATUS_OK when successful, XML_STATUS_ERROR otherwise.
+   Possible error codes:
+   - XML_ERROR_SUSPENDED: when suspending an already suspended parser.
+   - XML_ERROR_FINISHED: when the parser has already finished.
+   - XML_ERROR_SUSPEND_PE: when suspending while parsing an external PE.
+
+   When resumable != 0 (true) then parsing is suspended, that is,
+   XML_Parse() and XML_ParseBuffer() return XML_STATUS_SUSPENDED.
+   Otherwise, parsing is aborted, that is, XML_Parse() and XML_ParseBuffer()
+   return XML_STATUS_ERROR with error code XML_ERROR_ABORTED.
+
+   *Note*:
+   This will be applied to the current parser instance only, that is, if
+   there is a parent parser then it will continue parsing when the
+   externalEntityRefHandler() returns. It is up to the implementation of
+   the externalEntityRefHandler() to call XML_StopParser() on the parent
+   parser (recursively), if one wants to stop parsing altogether.
+
+   When suspended, parsing can be resumed by calling XML_ResumeParser().
+*/
+XMLPARSEAPI(enum XML_Status)
+XML_StopParser(XML_Parser parser, XML_Bool resumable);
+
+/* Resumes parsing after it has been suspended with XML_StopParser().
+   Must not be called from within a handler call-back. Returns same
+   status codes as XML_Parse() or XML_ParseBuffer().
+   Additional error code XML_ERROR_NOT_SUSPENDED possible.
+
+   *Note*:
+   This must be called on the most deeply nested child parser instance
+   first, and on its parent parser only after the child parser has finished,
+   to be applied recursively until the document entity's parser is restarted.
+   That is, the parent parser will not resume by itself and it is up to the
+   application to call XML_ResumeParser() on it at the appropriate moment.
+*/
+XMLPARSEAPI(enum XML_Status)
+XML_ResumeParser(XML_Parser parser);
+
+enum XML_Parsing { XML_INITIALIZED, XML_PARSING, XML_FINISHED, XML_SUSPENDED };
+
+typedef struct {
+  enum XML_Parsing parsing;
+  XML_Bool finalBuffer;
+} XML_ParsingStatus;
+
+/* Returns status of parser with respect to being initialized, parsing,
+   finished, or suspended and processing the final buffer.
+   XXX XML_Parse() and XML_ParseBuffer() should return XML_ParsingStatus,
+   XXX with XML_FINISHED_OK or XML_FINISHED_ERROR replacing XML_FINISHED
+*/
+XMLPARSEAPI(void)
+XML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status);
+
+/* Creates an XML_Parser object that can parse an external general
+   entity; context is a '\0'-terminated string specifying the parse
+   context; encoding is a '\0'-terminated string giving the name of
+   the externally specified encoding, or NULL if there is no
+   externally specified encoding.  The context string consists of a
+   sequence of tokens separated by formfeeds (\f); a token consisting
+   of a name specifies that the general entity of the name is open; a
+   token of the form prefix=uri specifies the namespace for a
+   particular prefix; a token of the form =uri specifies the default
+   namespace.  This can be called at any point after the first call to
+   an ExternalEntityRefHandler so longer as the parser has not yet
+   been freed.  The new parser is completely independent and may
+   safely be used in a separate thread.  The handlers and userData are
+   initialized from the parser argument.  Returns NULL if out of memory.
+   Otherwise returns a new XML_Parser object.
+*/
+XMLPARSEAPI(XML_Parser)
+XML_ExternalEntityParserCreate(XML_Parser parser, const XML_Char *context,
+                               const XML_Char *encoding);
+
+enum XML_ParamEntityParsing {
+  XML_PARAM_ENTITY_PARSING_NEVER,
+  XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE,
+  XML_PARAM_ENTITY_PARSING_ALWAYS
+};
+
+/* Controls parsing of parameter entities (including the external DTD
+   subset). If parsing of parameter entities is enabled, then
+   references to external parameter entities (including the external
+   DTD subset) will be passed to the handler set with
+   XML_SetExternalEntityRefHandler.  The context passed will be 0.
+
+   Unlike external general entities, external parameter entities can
+   only be parsed synchronously.  If the external parameter entity is
+   to be parsed, it must be parsed during the call to the external
+   entity ref handler: the complete sequence of
+   XML_ExternalEntityParserCreate, XML_Parse/XML_ParseBuffer and
+   XML_ParserFree calls must be made during this call.  After
+   XML_ExternalEntityParserCreate has been called to create the parser
+   for the external parameter entity (context must be 0 for this
+   call), it is illegal to make any calls on the old parser until
+   XML_ParserFree has been called on the newly created parser.
+   If the library has been compiled without support for parameter
+   entity parsing (ie without XML_DTD being defined), then
+   XML_SetParamEntityParsing will return 0 if parsing of parameter
+   entities is requested; otherwise it will return non-zero.
+   Note: If XML_SetParamEntityParsing is called after XML_Parse or
+      XML_ParseBuffer, then it has no effect and will always return 0.
+   Note: If parser == NULL, the function will do nothing and return 0.
+*/
+XMLPARSEAPI(int)
+XML_SetParamEntityParsing(XML_Parser parser,
+                          enum XML_ParamEntityParsing parsing);
+
+/* Sets the hash salt to use for internal hash calculations.
+   Helps in preventing DoS attacks based on predicting hash
+   function behavior. This must be called before parsing is started.
+   Returns 1 if successful, 0 when called after parsing has started.
+   Note: If parser == NULL, the function will do nothing and return 0.
+*/
+XMLPARSEAPI(int)
+XML_SetHashSalt(XML_Parser parser, unsigned long hash_salt);
+
+/* If XML_Parse or XML_ParseBuffer have returned XML_STATUS_ERROR, then
+   XML_GetErrorCode returns information about the error.
+*/
+XMLPARSEAPI(enum XML_Error)
+XML_GetErrorCode(XML_Parser parser);
+
+/* These functions return information about the current parse
+   location.  They may be called from any callback called to report
+   some parse event; in this case the location is the location of the
+   first of the sequence of characters that generated the event.  When
+   called from callbacks generated by declarations in the document
+   prologue, the location identified isn't as neatly defined, but will
+   be within the relevant markup.  When called outside of the callback
+   functions, the position indicated will be just past the last parse
+   event (regardless of whether there was an associated callback).
+
+   They may also be called after returning from a call to XML_Parse
+   or XML_ParseBuffer.  If the return value is XML_STATUS_ERROR then
+   the location is the location of the character at which the error
+   was detected; otherwise the location is the location of the last
+   parse event, as described above.
+
+   Note: XML_GetCurrentLineNumber and XML_GetCurrentColumnNumber
+   return 0 to indicate an error.
+   Note: XML_GetCurrentByteIndex returns -1 to indicate an error.
+*/
+XMLPARSEAPI(XML_Size) XML_GetCurrentLineNumber(XML_Parser parser);
+XMLPARSEAPI(XML_Size) XML_GetCurrentColumnNumber(XML_Parser parser);
+XMLPARSEAPI(XML_Index) XML_GetCurrentByteIndex(XML_Parser parser);
+
+/* Return the number of bytes in the current event.
+   Returns 0 if the event is in an internal entity.
+*/
+XMLPARSEAPI(int)
+XML_GetCurrentByteCount(XML_Parser parser);
+
+/* If XML_CONTEXT_BYTES is >=1, returns the input buffer, sets
+   the integer pointed to by offset to the offset within this buffer
+   of the current parse position, and sets the integer pointed to by size
+   to the size of this buffer (the number of input bytes). Otherwise
+   returns a NULL pointer. Also returns a NULL pointer if a parse isn't
+   active.
+
+   NOTE: The character pointer returned should not be used outside
+   the handler that makes the call.
+*/
+XMLPARSEAPI(const char *)
+XML_GetInputContext(XML_Parser parser, int *offset, int *size);
+
+/* For backwards compatibility with previous versions. */
+#define XML_GetErrorLineNumber XML_GetCurrentLineNumber
+#define XML_GetErrorColumnNumber XML_GetCurrentColumnNumber
+#define XML_GetErrorByteIndex XML_GetCurrentByteIndex
+
+/* Frees the content model passed to the element declaration handler */
+XMLPARSEAPI(void)
+XML_FreeContentModel(XML_Parser parser, XML_Content *model);
+
+/* Exposing the memory handling functions used in Expat */
+XMLPARSEAPI(void *)
+XML_ATTR_MALLOC
+XML_ATTR_ALLOC_SIZE(2)
+XML_MemMalloc(XML_Parser parser, size_t size);
+
+XMLPARSEAPI(void *)
+XML_ATTR_ALLOC_SIZE(3)
+XML_MemRealloc(XML_Parser parser, void *ptr, size_t size);
+
+XMLPARSEAPI(void)
+XML_MemFree(XML_Parser parser, void *ptr);
+
+/* Frees memory used by the parser. */
+XMLPARSEAPI(void)
+XML_ParserFree(XML_Parser parser);
+
+/* Returns a string describing the error. */
+XMLPARSEAPI(const XML_LChar *)
+XML_ErrorString(enum XML_Error code);
+
+/* Return a string containing the version number of this expat */
+XMLPARSEAPI(const XML_LChar *)
+XML_ExpatVersion(void);
+
+typedef struct {
+  int major;
+  int minor;
+  int micro;
+} XML_Expat_Version;
+
+/* Return an XML_Expat_Version structure containing numeric version
+   number information for this version of expat.
+*/
+XMLPARSEAPI(XML_Expat_Version)
+XML_ExpatVersionInfo(void);
+
+/* Added in Expat 1.95.5. */
+enum XML_FeatureEnum {
+  XML_FEATURE_END = 0,
+  XML_FEATURE_UNICODE,
+  XML_FEATURE_UNICODE_WCHAR_T,
+  XML_FEATURE_DTD,
+  XML_FEATURE_CONTEXT_BYTES,
+  XML_FEATURE_MIN_SIZE,
+  XML_FEATURE_SIZEOF_XML_CHAR,
+  XML_FEATURE_SIZEOF_XML_LCHAR,
+  XML_FEATURE_NS,
+  XML_FEATURE_LARGE_SIZE,
+  XML_FEATURE_ATTR_INFO,
+  /* Added in Expat 2.4.0. */
+  XML_FEATURE_BILLION_LAUGHS_ATTACK_PROTECTION_MAXIMUM_AMPLIFICATION_DEFAULT,
+  XML_FEATURE_BILLION_LAUGHS_ATTACK_PROTECTION_ACTIVATION_THRESHOLD_DEFAULT,
+  /* Added in Expat 2.6.0. */
+  XML_FEATURE_GE
+  /* Additional features must be added to the end of this enum. */
+};
+
+typedef struct {
+  enum XML_FeatureEnum feature;
+  const XML_LChar *name;
+  long int value;
+} XML_Feature;
+
+XMLPARSEAPI(const XML_Feature *)
+XML_GetFeatureList(void);
+
+#if defined(XML_DTD) || (defined(XML_GE) && XML_GE == 1)
+/* Added in Expat 2.4.0 for XML_DTD defined and
+ * added in Expat 2.6.0 for XML_GE == 1. */
+XMLPARSEAPI(XML_Bool)
+XML_SetBillionLaughsAttackProtectionMaximumAmplification(
+    XML_Parser parser, float maximumAmplificationFactor);
+
+/* Added in Expat 2.4.0 for XML_DTD defined and
+ * added in Expat 2.6.0 for XML_GE == 1. */
+XMLPARSEAPI(XML_Bool)
+XML_SetBillionLaughsAttackProtectionActivationThreshold(
+    XML_Parser parser, unsigned long long activationThresholdBytes);
+#endif
+
+/* Added in Expat 2.6.0. */
+XMLPARSEAPI(XML_Bool)
+XML_SetReparseDeferralEnabled(XML_Parser parser, XML_Bool enabled);
+
+/* Expat follows the semantic versioning convention.
+   See https://semver.org
+*/
+#define XML_MAJOR_VERSION 2
+#define XML_MINOR_VERSION 6
+#define XML_MICRO_VERSION 3
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* not Expat_INCLUDED */
+
+#endif /* LV_USE_XML */
+
diff --git a/src/libs/expat/expat_config.h b/src/libs/expat/expat_config.h
new file mode 100644
index 000000000..f368c9b9a
--- /dev/null
+++ b/src/libs/expat/expat_config.h
@@ -0,0 +1,151 @@
+/* expat_config.h.  Generated from expat_config.h.in by configure.  */
+
+#include "../../lv_conf_internal.h"
+#if LV_USE_XML
+/* expat_config.h.in.  Generated from configure.ac by autoheader.  */
+
+#ifndef EXPAT_CONFIG_H
+#define EXPAT_CONFIG_H 1
+
+/* Define if building universal (internal helper macro) */
+/* #undef AC_APPLE_UNIVERSAL_BUILD */
+
+/* 1234 = LILENDIAN, 4321 = BIGENDIAN */
+#define BYTEORDER 1234
+
+#define XML_POOR_ENTROPY 1
+
+/* Define to 1 if you have the `arc4random' function. */
+/* #undef HAVE_ARC4RANDOM */
+
+/* Define to 1 if you have the `arc4random_buf' function. */
+/* #undef HAVE_ARC4RANDOM_BUF */
+
+/* define if the compiler supports basic C++11 syntax */
+/*#define HAVE_CXX11 1*/
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+/*#define HAVE_DLFCN_H 1*/
+
+/* Define to 1 if you have the <fcntl.h> header file. */
+/*#define HAVE_FCNTL_H 1*/
+
+/* Define to 1 if you have the `getpagesize' function. */
+/*#define HAVE_GETPAGESIZE 1*/
+
+/* Define to 1 if you have the `getrandom' function. */
+/*#define HAVE_GETRANDOM 1*/
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#define HAVE_INTTYPES_H 1
+
+/* Define to 1 if you have the `bsd' library (-lbsd). */
+/* #undef HAVE_LIBBSD */
+
+/* Define to 1 if you have a working `mmap' system call. */
+/*#define HAVE_MMAP 1*/
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#define HAVE_STDINT_H 1
+
+/* Define to 1 if you have the <stdio.h> header file. */
+#define HAVE_STDIO_H 1
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#define HAVE_STDLIB_H 1
+
+/* Define to 1 if you have the <strings.h> header file. */
+/*#define HAVE_STRINGS_H 1*/
+
+/* Define to 1 if you have the <string.h> header file. */
+#define HAVE_STRING_H 1
+
+/* Define to 1 if you have `syscall' and `SYS_getrandom'. */
+//#define HAVE_SYSCALL_GETRANDOM 0
+
+/* Define to 1 if you have the <sys/param.h> header file. */
+/*#define HAVE_SYS_PARAM_H 1*/
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+/*#define HAVE_SYS_STAT_H 1*/
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+/*#define HAVE_SYS_TYPES_H 1*/
+
+/* Define to 1 if you have the <unistd.h> header file. */
+/*#define HAVE_UNISTD_H 1*/
+
+/* Define to the sub-directory where libtool stores uninstalled libraries. */
+#define LT_OBJDIR ".libs/"
+
+/* Name of package */
+#define PACKAGE "expat"
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT "https://github.com/libexpat/libexpat/issues"
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME "expat"
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING "expat 2.6.3"
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME "expat"
+
+/* Define to the home page for this package. */
+#define PACKAGE_URL ""
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION "2.6.3"
+
+/* Define to 1 if all of the C90 standard headers exist (not just the ones
+   required in a freestanding environment). This macro is provided for
+   backward compatibility; new code need not use it. */
+#define STDC_HEADERS 1
+
+/* Version number of package */
+#define VERSION "2.6.3"
+
+/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
+   significant byte first (like Motorola and SPARC, unlike Intel). */
+#if defined AC_APPLE_UNIVERSAL_BUILD
+# if defined __BIG_ENDIAN__
+#  define WORDS_BIGENDIAN 1
+# endif
+#else
+# ifndef WORDS_BIGENDIAN
+/* #  undef WORDS_BIGENDIAN */
+# endif
+#endif
+
+/* Define to allow retrieving the byte offsets for attribute names and values.
+   */
+/* #undef XML_ATTR_INFO */
+
+/* Define to specify how much context to retain around the current parse
+   point, 0 to disable. */
+#define XML_CONTEXT_BYTES 1024
+
+/* Define to include code reading entropy from `/dev/urandom'. */
+/*#define XML_DEV_URANDOM 1*/
+
+/* Define to make parameter entity parsing functionality available. */
+/*#define XML_DTD 1*/
+
+/* Define as 1/0 to enable/disable support for general entities. */
+#define XML_GE 0
+
+/* Define to make XML Namespaces functionality available. */
+/*#define XML_NS 1*/
+
+/* Define to empty if `const' does not conform to ANSI C. */
+/* #undef const */
+
+/* Define to `long int' if <sys/types.h> does not define. */
+/* #undef off_t */
+
+#endif // ndef EXPAT_CONFIG_H
+
+#endif /* LV_USE_XML */
+
diff --git a/src/libs/expat/expat_external.h b/src/libs/expat/expat_external.h
new file mode 100644
index 000000000..e4e2992e6
--- /dev/null
+++ b/src/libs/expat/expat_external.h
@@ -0,0 +1,171 @@
+/*
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2000-2004 Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
+   Copyright (c) 2001-2002 Greg Stein <gstein@users.sourceforge.net>
+   Copyright (c) 2002-2006 Karl Waclawek <karl@waclawek.net>
+   Copyright (c) 2016      Cristian Rodríguez <crrodriguez@opensuse.org>
+   Copyright (c) 2016-2019 Sebastian Pipping <sebastian@pipping.org>
+   Copyright (c) 2017      Rhodri James <rhodri@wildebeest.org.uk>
+   Copyright (c) 2018      Yury Gribov <tetra2005@gmail.com>
+   Licensed under the MIT license:
+
+   Permission is  hereby granted,  free of charge,  to any  person obtaining
+   a  copy  of  this  software   and  associated  documentation  files  (the
+   "Software"),  to  deal in  the  Software  without restriction,  including
+   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
+   distribute, sublicense, and/or sell copies of the Software, and to permit
+   persons  to whom  the Software  is  furnished to  do so,  subject to  the
+   following conditions:
+
+   The above copyright  notice and this permission notice  shall be included
+   in all copies or substantial portions of the Software.
+
+   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
+   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
+   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+   USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include "../../lv_conf_internal.h"
+#if LV_USE_XML
+
+#ifndef Expat_External_INCLUDED
+#define Expat_External_INCLUDED 1
+
+/* External API definitions */
+
+/* Expat tries very hard to make the API boundary very specifically
+   defined.  There are two macros defined to control this boundary;
+   each of these can be defined before including this header to
+   achieve some different behavior, but doing so it not recommended or
+   tested frequently.
+
+   XMLCALL    - The calling convention to use for all calls across the
+                "library boundary."  This will default to cdecl, and
+                try really hard to tell the compiler that's what we
+                want.
+
+   XMLIMPORT  - Whatever magic is needed to note that a function is
+                to be imported from a dynamically loaded library
+                (.dll, .so, or .sl, depending on your platform).
+
+   The XMLCALL macro was added in Expat 1.95.7.  The only one which is
+   expected to be directly useful in client code is XMLCALL.
+
+   Note that on at least some Unix versions, the Expat library must be
+   compiled with the cdecl calling convention as the default since
+   system headers may assume the cdecl convention.
+*/
+#ifndef XMLCALL
+#  if defined(_MSC_VER)
+#    define XMLCALL __cdecl
+#  elif defined(__GNUC__) && defined(__i386) && ! defined(__INTEL_COMPILER)
+#    define XMLCALL __attribute__((cdecl))
+#  else
+/* For any platform which uses this definition and supports more than
+   one calling convention, we need to extend this definition to
+   declare the convention used on that platform, if it's possible to
+   do so.
+
+   If this is the case for your platform, please file a bug report
+   with information on how to identify your platform via the C
+   pre-processor and how to specify the same calling convention as the
+   platform's malloc() implementation.
+*/
+#    define XMLCALL
+#  endif
+#endif /* not defined XMLCALL */
+
+#if ! defined(XML_STATIC) && ! defined(XMLIMPORT)
+#  ifndef XML_BUILDING_EXPAT
+/* using Expat from an application */
+
+#    if defined(_MSC_EXTENSIONS) && ! defined(__BEOS__) && ! defined(__CYGWIN__)
+#      define XMLIMPORT __declspec(dllimport)
+#    endif
+
+#  endif
+#endif /* not defined XML_STATIC */
+
+#ifndef XML_ENABLE_VISIBILITY
+#  define XML_ENABLE_VISIBILITY 0
+#endif
+
+#if ! defined(XMLIMPORT) && XML_ENABLE_VISIBILITY
+#  define XMLIMPORT __attribute__((visibility("default")))
+#endif
+
+/* If we didn't define it above, define it away: */
+#ifndef XMLIMPORT
+#  define XMLIMPORT
+#endif
+
+#if defined(__GNUC__)                                                          \
+    && (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96))
+#  define XML_ATTR_MALLOC __attribute__((__malloc__))
+#else
+#  define XML_ATTR_MALLOC
+#endif
+
+#if defined(__GNUC__)                                                          \
+    && ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
+#  define XML_ATTR_ALLOC_SIZE(x) __attribute__((__alloc_size__(x)))
+#else
+#  define XML_ATTR_ALLOC_SIZE(x)
+#endif
+
+#define XMLPARSEAPI(type) XMLIMPORT type XMLCALL
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef XML_UNICODE_WCHAR_T
+#  ifndef XML_UNICODE
+#    define XML_UNICODE
+#  endif
+#  if defined(__SIZEOF_WCHAR_T__) && (__SIZEOF_WCHAR_T__ != 2)
+#    error "sizeof(wchar_t) != 2; Need -fshort-wchar for both Expat and libc"
+#  endif
+#endif
+
+#ifdef XML_UNICODE /* Information is UTF-16 encoded. */
+#  ifdef XML_UNICODE_WCHAR_T
+typedef wchar_t XML_Char;
+typedef wchar_t XML_LChar;
+#  else
+typedef unsigned short XML_Char;
+typedef char XML_LChar;
+#  endif /* XML_UNICODE_WCHAR_T */
+#else    /* Information is UTF-8 encoded. */
+typedef char XML_Char;
+typedef char XML_LChar;
+#endif   /* XML_UNICODE */
+
+#ifdef XML_LARGE_SIZE /* Use large integers for file/stream positions. */
+typedef long long XML_Index;
+typedef unsigned long long XML_Size;
+#else
+typedef long XML_Index;
+typedef unsigned long XML_Size;
+#endif /* XML_LARGE_SIZE */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* not Expat_External_INCLUDED */
+
+#endif /* LV_USE_XML */
+
diff --git a/src/libs/expat/iasciitab.h b/src/libs/expat/iasciitab.h
new file mode 100644
index 000000000..9a2ba4eb9
--- /dev/null
+++ b/src/libs/expat/iasciitab.h
@@ -0,0 +1,73 @@
+/*
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2002      Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
+   Copyright (c) 2017      Sebastian Pipping <sebastian@pipping.org>
+   Licensed under the MIT license:
+
+   Permission is  hereby granted,  free of charge,  to any  person obtaining
+   a  copy  of  this  software   and  associated  documentation  files  (the
+   "Software"),  to  deal in  the  Software  without restriction,  including
+   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
+   distribute, sublicense, and/or sell copies of the Software, and to permit
+   persons  to whom  the Software  is  furnished to  do so,  subject to  the
+   following conditions:
+
+   The above copyright  notice and this permission notice  shall be included
+   in all copies or substantial portions of the Software.
+
+   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
+   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
+   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+   USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include "../../lv_conf_internal.h"
+#if LV_USE_XML
+
+/* Like asciitab.h, except that 0xD has code BT_S rather than BT_CR */
+/* 0x00 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+    /* 0x04 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+    /* 0x08 */ BT_NONXML, BT_S, BT_LF, BT_NONXML,
+    /* 0x0C */ BT_NONXML, BT_S, BT_NONXML, BT_NONXML,
+    /* 0x10 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+    /* 0x14 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+    /* 0x18 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+    /* 0x1C */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+    /* 0x20 */ BT_S, BT_EXCL, BT_QUOT, BT_NUM,
+    /* 0x24 */ BT_OTHER, BT_PERCNT, BT_AMP, BT_APOS,
+    /* 0x28 */ BT_LPAR, BT_RPAR, BT_AST, BT_PLUS,
+    /* 0x2C */ BT_COMMA, BT_MINUS, BT_NAME, BT_SOL,
+    /* 0x30 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
+    /* 0x34 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
+    /* 0x38 */ BT_DIGIT, BT_DIGIT, BT_COLON, BT_SEMI,
+    /* 0x3C */ BT_LT, BT_EQUALS, BT_GT, BT_QUEST,
+    /* 0x40 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
+    /* 0x44 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
+    /* 0x48 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x4C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x50 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x54 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x58 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_LSQB,
+    /* 0x5C */ BT_OTHER, BT_RSQB, BT_OTHER, BT_NMSTRT,
+    /* 0x60 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
+    /* 0x64 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
+    /* 0x68 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x6C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x70 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x74 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x78 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
+    /* 0x7C */ BT_VERBAR, BT_OTHER, BT_OTHER, BT_OTHER,
+
+#endif /* LV_USE_XML */
+
diff --git a/src/libs/expat/internal.h b/src/libs/expat/internal.h
new file mode 100644
index 000000000..07f1897f9
--- /dev/null
+++ b/src/libs/expat/internal.h
@@ -0,0 +1,182 @@
+/* internal.h
+
+   Internal definitions used by Expat.  This is not needed to compile
+   client code.
+
+   The following calling convention macros are defined for frequently
+   called functions:
+
+   FASTCALL    - Used for those internal functions that have a simple
+                 body and a low number of arguments and local variables.
+
+   PTRCALL     - Used for functions called though function pointers.
+
+   PTRFASTCALL - Like PTRCALL, but for low number of arguments.
+
+   inline      - Used for selected internal functions for which inlining
+                 may improve performance on some platforms.
+
+   Note: Use of these macros is based on judgement, not hard rules,
+         and therefore subject to change.
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 2002-2003 Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
+   Copyright (c) 2002-2006 Karl Waclawek <karl@waclawek.net>
+   Copyright (c) 2003      Greg Stein <gstein@users.sourceforge.net>
+   Copyright (c) 2016-2024 Sebastian Pipping <sebastian@pipping.org>
+   Copyright (c) 2018      Yury Gribov <tetra2005@gmail.com>
+   Copyright (c) 2019      David Loffredo <loffredo@steptools.com>
+   Copyright (c) 2023-2024 Sony Corporation / Snild Dolkow <snild@sony.com>
+   Copyright (c) 2024      Taichi Haradaguchi <20001722@ymail.ne.jp>
+   Licensed under the MIT license:
+
+   Permission is  hereby granted,  free of charge,  to any  person obtaining
+   a  copy  of  this  software   and  associated  documentation  files  (the
+   "Software"),  to  deal in  the  Software  without restriction,  including
+   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
+   distribute, sublicense, and/or sell copies of the Software, and to permit
+   persons  to whom  the Software  is  furnished to  do so,  subject to  the
+   following conditions:
+
+   The above copyright  notice and this permission notice  shall be included
+   in all copies or substantial portions of the Software.
+
+   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
+   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
+   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+   USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include "../../lv_conf_internal.h"
+#if LV_USE_XML
+
+#if defined(__GNUC__) && defined(__i386__) && ! defined(__MINGW32__)
+/* We'll use this version by default only where we know it helps.
+
+   regparm() generates warnings on Solaris boxes.   See SF bug #692878.
+
+   Instability reported with egcs on a RedHat Linux 7.3.
+   Let's comment out:
+   #define FASTCALL __attribute__((stdcall, regparm(3)))
+   and let's try this:
+*/
+#  define FASTCALL __attribute__((regparm(3)))
+#  define PTRFASTCALL __attribute__((regparm(3)))
+#endif
+
+/* Using __fastcall seems to have an unexpected negative effect under
+   MS VC++, especially for function pointers, so we won't use it for
+   now on that platform. It may be reconsidered for a future release
+   if it can be made more effective.
+   Likely reason: __fastcall on Windows is like stdcall, therefore
+   the compiler cannot perform stack optimizations for call clusters.
+*/
+
+/* Make sure all of these are defined if they aren't already. */
+
+#ifndef FASTCALL
+#  define FASTCALL
+#endif
+
+#ifndef PTRCALL
+#  define PTRCALL
+#endif
+
+#ifndef PTRFASTCALL
+#  define PTRFASTCALL
+#endif
+
+#ifndef XML_MIN_SIZE
+#  if ! defined(__cplusplus) && ! defined(inline)
+#    ifdef __GNUC__
+#      define inline __inline
+#    endif /* __GNUC__ */
+#  endif
+#endif /* XML_MIN_SIZE */
+
+#ifdef __cplusplus
+#  define inline inline
+#else
+#  ifndef inline
+#    define inline
+#  endif
+#endif
+
+#include <limits.h> // ULONG_MAX
+
+#if defined(_WIN32)                                                            \
+    && (! defined(__USE_MINGW_ANSI_STDIO)                                      \
+        || (1 - __USE_MINGW_ANSI_STDIO - 1 == 0))
+#  define EXPAT_FMT_ULL(midpart) "%" midpart "I64u"
+#  if defined(_WIN64) // Note: modifiers "td" and "zu" do not work for MinGW
+#    define EXPAT_FMT_PTRDIFF_T(midpart) "%" midpart "I64d"
+#    define EXPAT_FMT_SIZE_T(midpart) "%" midpart "I64u"
+#  else
+#    define EXPAT_FMT_PTRDIFF_T(midpart) "%" midpart "d"
+#    define EXPAT_FMT_SIZE_T(midpart) "%" midpart "u"
+#  endif
+#else
+#  define EXPAT_FMT_ULL(midpart) "%" midpart "llu"
+#  if ! defined(ULONG_MAX)
+#    error Compiler did not define ULONG_MAX for us
+#  elif ULONG_MAX == 18446744073709551615u // 2^64-1
+#    define EXPAT_FMT_PTRDIFF_T(midpart) "%" midpart "ld"
+#    define EXPAT_FMT_SIZE_T(midpart) "%" midpart "lu"
+#  else
+#    define EXPAT_FMT_PTRDIFF_T(midpart) "%" midpart "d"
+#    define EXPAT_FMT_SIZE_T(midpart) "%" midpart "u"
+#  endif
+#endif
+
+#ifndef UNUSED_P
+#  define UNUSED_P(p) (void)p
+#endif
+
+/* NOTE BEGIN If you ever patch these defaults to greater values
+              for non-attack XML payload in your environment,
+              please file a bug report with libexpat.  Thank you!
+*/
+#define EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_MAXIMUM_AMPLIFICATION_DEFAULT   \
+  100.0f
+#define EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_ACTIVATION_THRESHOLD_DEFAULT    \
+  8388608 // 8 MiB, 2^23
+/* NOTE END */
+
+#include "expat.h" // so we can use type XML_Parser below
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void _INTERNAL_trim_to_complete_utf8_characters(const char *from,
+                                                const char **fromLimRef);
+
+#if defined(XML_GE) && XML_GE == 1
+unsigned long long testingAccountingGetCountBytesDirect(XML_Parser parser);
+unsigned long long testingAccountingGetCountBytesIndirect(XML_Parser parser);
+const char *unsignedCharToPrintable(unsigned char c);
+#endif
+
+extern
+#if ! defined(XML_TESTING)
+    const
+#endif
+    XML_Bool g_reparseDeferralEnabledDefault; // written ONLY in runtests.c
+#if defined(XML_TESTING)
+extern unsigned int g_bytesScanned; // used for testing only
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LV_USE_XML */
+
diff --git a/src/libs/expat/latin1tab.h b/src/libs/expat/latin1tab.h
new file mode 100644
index 000000000..c3a9d5ad8
--- /dev/null
+++ b/src/libs/expat/latin1tab.h
@@ -0,0 +1,72 @@
+/*
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2002      Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
+   Copyright (c) 2017      Sebastian Pipping <sebastian@pipping.org>
+   Licensed under the MIT license:
+
+   Permission is  hereby granted,  free of charge,  to any  person obtaining
+   a  copy  of  this  software   and  associated  documentation  files  (the
+   "Software"),  to  deal in  the  Software  without restriction,  including
+   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
+   distribute, sublicense, and/or sell copies of the Software, and to permit
+   persons  to whom  the Software  is  furnished to  do so,  subject to  the
+   following conditions:
+
+   The above copyright  notice and this permission notice  shall be included
+   in all copies or substantial portions of the Software.
+
+   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
+   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
+   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+   USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include "../../lv_conf_internal.h"
+#if LV_USE_XML
+
+/* 0x80 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+    /* 0x84 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+    /* 0x88 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+    /* 0x8C */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+    /* 0x90 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+    /* 0x94 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+    /* 0x98 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+    /* 0x9C */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+    /* 0xA0 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+    /* 0xA4 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+    /* 0xA8 */ BT_OTHER, BT_OTHER, BT_NMSTRT, BT_OTHER,
+    /* 0xAC */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+    /* 0xB0 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+    /* 0xB4 */ BT_OTHER, BT_NMSTRT, BT_OTHER, BT_NAME,
+    /* 0xB8 */ BT_OTHER, BT_OTHER, BT_NMSTRT, BT_OTHER,
+    /* 0xBC */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+    /* 0xC0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0xC4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0xC8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0xCC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0xD0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0xD4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
+    /* 0xD8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0xDC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0xE0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0xE4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0xE8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0xEC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0xF0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0xF4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
+    /* 0xF8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0xFC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+
+#endif /* LV_USE_XML */
+
diff --git a/src/libs/expat/nametab.h b/src/libs/expat/nametab.h
new file mode 100644
index 000000000..f698c3c54
--- /dev/null
+++ b/src/libs/expat/nametab.h
@@ -0,0 +1,142 @@
+/*
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 2000 Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2017 Sebastian Pipping <sebastian@pipping.org>
+   Licensed under the MIT license:
+
+   Permission is  hereby granted,  free of charge,  to any  person obtaining
+   a  copy  of  this  software   and  associated  documentation  files  (the
+   "Software"),  to  deal in  the  Software  without restriction,  including
+   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
+   distribute, sublicense, and/or sell copies of the Software, and to permit
+   persons  to whom  the Software  is  furnished to  do so,  subject to  the
+   following conditions:
+
+   The above copyright  notice and this permission notice  shall be included
+   in all copies or substantial portions of the Software.
+
+   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
+   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
+   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+   USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include "../../lv_conf_internal.h"
+#if LV_USE_XML
+
+static const unsigned namingBitmap[] = {
+    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+    0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+    0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x04000000,
+    0x87FFFFFE, 0x07FFFFFE, 0x00000000, 0x00000000, 0xFF7FFFFF, 0xFF7FFFFF,
+    0xFFFFFFFF, 0x7FF3FFFF, 0xFFFFFDFE, 0x7FFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+    0xFFFFE00F, 0xFC31FFFF, 0x00FFFFFF, 0x00000000, 0xFFFF0000, 0xFFFFFFFF,
+    0xFFFFFFFF, 0xF80001FF, 0x00000003, 0x00000000, 0x00000000, 0x00000000,
+    0x00000000, 0x00000000, 0xFFFFD740, 0xFFFFFFFB, 0x547F7FFF, 0x000FFFFD,
+    0xFFFFDFFE, 0xFFFFFFFF, 0xDFFEFFFF, 0xFFFFFFFF, 0xFFFF0003, 0xFFFFFFFF,
+    0xFFFF199F, 0x033FCFFF, 0x00000000, 0xFFFE0000, 0x027FFFFF, 0xFFFFFFFE,
+    0x0000007F, 0x00000000, 0xFFFF0000, 0x000707FF, 0x00000000, 0x07FFFFFE,
+    0x000007FE, 0xFFFE0000, 0xFFFFFFFF, 0x7CFFFFFF, 0x002F7FFF, 0x00000060,
+    0xFFFFFFE0, 0x23FFFFFF, 0xFF000000, 0x00000003, 0xFFF99FE0, 0x03C5FDFF,
+    0xB0000000, 0x00030003, 0xFFF987E0, 0x036DFDFF, 0x5E000000, 0x001C0000,
+    0xFFFBAFE0, 0x23EDFDFF, 0x00000000, 0x00000001, 0xFFF99FE0, 0x23CDFDFF,
+    0xB0000000, 0x00000003, 0xD63DC7E0, 0x03BFC718, 0x00000000, 0x00000000,
+    0xFFFDDFE0, 0x03EFFDFF, 0x00000000, 0x00000003, 0xFFFDDFE0, 0x03EFFDFF,
+    0x40000000, 0x00000003, 0xFFFDDFE0, 0x03FFFDFF, 0x00000000, 0x00000003,
+    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFE, 0x000D7FFF,
+    0x0000003F, 0x00000000, 0xFEF02596, 0x200D6CAE, 0x0000001F, 0x00000000,
+    0x00000000, 0x00000000, 0xFFFFFEFF, 0x000003FF, 0x00000000, 0x00000000,
+    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+    0x00000000, 0xFFFFFFFF, 0xFFFF003F, 0x007FFFFF, 0x0007DAED, 0x50000000,
+    0x82315001, 0x002C62AB, 0x40000000, 0xF580C900, 0x00000007, 0x02010800,
+    0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0FFFFFFF, 0xFFFFFFFF,
+    0xFFFFFFFF, 0x03FFFFFF, 0x3F3FFFFF, 0xFFFFFFFF, 0xAAFF3F3F, 0x3FFFFFFF,
+    0xFFFFFFFF, 0x5FDFFFFF, 0x0FCF1FDC, 0x1FDC1FFF, 0x00000000, 0x00004C40,
+    0x00000000, 0x00000000, 0x00000007, 0x00000000, 0x00000000, 0x00000000,
+    0x00000080, 0x000003FE, 0xFFFFFFFE, 0xFFFFFFFF, 0x001FFFFF, 0xFFFFFFFE,
+    0xFFFFFFFF, 0x07FFFFFF, 0xFFFFFFE0, 0x00001FFF, 0x00000000, 0x00000000,
+    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF,
+    0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0000003F, 0x00000000, 0x00000000,
+    0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0000000F,
+    0x00000000, 0x00000000, 0x00000000, 0x07FF6000, 0x87FFFFFE, 0x07FFFFFE,
+    0x00000000, 0x00800000, 0xFF7FFFFF, 0xFF7FFFFF, 0x00FFFFFF, 0x00000000,
+    0xFFFF0000, 0xFFFFFFFF, 0xFFFFFFFF, 0xF80001FF, 0x00030003, 0x00000000,
+    0xFFFFFFFF, 0xFFFFFFFF, 0x0000003F, 0x00000003, 0xFFFFD7C0, 0xFFFFFFFB,
+    0x547F7FFF, 0x000FFFFD, 0xFFFFDFFE, 0xFFFFFFFF, 0xDFFEFFFF, 0xFFFFFFFF,
+    0xFFFF007B, 0xFFFFFFFF, 0xFFFF199F, 0x033FCFFF, 0x00000000, 0xFFFE0000,
+    0x027FFFFF, 0xFFFFFFFE, 0xFFFE007F, 0xBBFFFFFB, 0xFFFF0016, 0x000707FF,
+    0x00000000, 0x07FFFFFE, 0x0007FFFF, 0xFFFF03FF, 0xFFFFFFFF, 0x7CFFFFFF,
+    0xFFEF7FFF, 0x03FF3DFF, 0xFFFFFFEE, 0xF3FFFFFF, 0xFF1E3FFF, 0x0000FFCF,
+    0xFFF99FEE, 0xD3C5FDFF, 0xB080399F, 0x0003FFCF, 0xFFF987E4, 0xD36DFDFF,
+    0x5E003987, 0x001FFFC0, 0xFFFBAFEE, 0xF3EDFDFF, 0x00003BBF, 0x0000FFC1,
+    0xFFF99FEE, 0xF3CDFDFF, 0xB0C0398F, 0x0000FFC3, 0xD63DC7EC, 0xC3BFC718,
+    0x00803DC7, 0x0000FF80, 0xFFFDDFEE, 0xC3EFFDFF, 0x00603DDF, 0x0000FFC3,
+    0xFFFDDFEC, 0xC3EFFDFF, 0x40603DDF, 0x0000FFC3, 0xFFFDDFEC, 0xC3FFFDFF,
+    0x00803DCF, 0x0000FFC3, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+    0xFFFFFFFE, 0x07FF7FFF, 0x03FF7FFF, 0x00000000, 0xFEF02596, 0x3BFF6CAE,
+    0x03FF3F5F, 0x00000000, 0x03000000, 0xC2A003FF, 0xFFFFFEFF, 0xFFFE03FF,
+    0xFEBF0FDF, 0x02FE3FFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1FFF0000, 0x00000002,
+    0x000000A0, 0x003EFFFE, 0xFFFFFFFE, 0xFFFFFFFF, 0x661FFFFF, 0xFFFFFFFE,
+    0xFFFFFFFF, 0x77FFFFFF,
+};
+static const unsigned char nmstrtPages[] = {
+    0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00, 0x00, 0x09, 0x0A, 0x0B,
+    0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x13, 0x00, 0x14, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x15, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00,
+};
+static const unsigned char namePages[] = {
+    0x19, 0x03, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x00, 0x00, 0x1F, 0x20, 0x21,
+    0x22, 0x23, 0x24, 0x25, 0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x13, 0x26, 0x14, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x27, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00,
+};
+
+#endif /* LV_USE_XML */
+
diff --git a/src/libs/expat/siphash.h b/src/libs/expat/siphash.h
new file mode 100644
index 000000000..a4b2f0dfb
--- /dev/null
+++ b/src/libs/expat/siphash.h
@@ -0,0 +1,398 @@
+/* ==========================================================================
+ * siphash.h - SipHash-2-4 in a single header file
+ * --------------------------------------------------------------------------
+ * Derived by William Ahern from the reference implementation[1] published[2]
+ * by Jean-Philippe Aumasson and Daniel J. Berstein.
+ * Minimal changes by Sebastian Pipping and Victor Stinner on top, see below.
+ * Licensed under the CC0 Public Domain Dedication license.
+ *
+ * 1. https://www.131002.net/siphash/siphash24.c
+ * 2. https://www.131002.net/siphash/
+ * --------------------------------------------------------------------------
+ * HISTORY:
+ *
+ * 2020-10-03  (Sebastian Pipping)
+ *   - Drop support for Visual Studio 9.0/2008 and earlier
+ *
+ * 2019-08-03  (Sebastian Pipping)
+ *   - Mark part of sip24_valid as to be excluded from clang-format
+ *   - Re-format code using clang-format 9
+ *
+ * 2018-07-08  (Anton Maklakov)
+ *   - Add "fall through" markers for GCC's -Wimplicit-fallthrough
+ *
+ * 2017-11-03  (Sebastian Pipping)
+ *   - Hide sip_tobin and sip_binof unless SIPHASH_TOBIN macro is defined
+ *
+ * 2017-07-25  (Vadim Zeitlin)
+ *   - Fix use of SIPHASH_MAIN macro
+ *
+ * 2017-07-05  (Sebastian Pipping)
+ *   - Use _SIP_ULL macro to not require a C++11 compiler if compiled as C++
+ *   - Add const qualifiers at two places
+ *   - Ensure <=80 characters line length (assuming tab width 4)
+ *
+ * 2017-06-23  (Victor Stinner)
+ *   - Address Win64 compile warnings
+ *
+ * 2017-06-18  (Sebastian Pipping)
+ *   - Clarify license note in the header
+ *   - Address C89 issues:
+ *     - Stop using inline keyword (and let compiler decide)
+ *     - Replace _Bool by int
+ *     - Turn macro siphash24 into a function
+ *     - Address invalid conversion (void pointer) by explicit cast
+ *   - Address lack of stdint.h for Visual Studio 2003 to 2008
+ *   - Always expose sip24_valid (for self-tests)
+ *
+ * 2012-11-04 - Born.  (William Ahern)
+ * --------------------------------------------------------------------------
+ * USAGE:
+ *
+ * SipHash-2-4 takes as input two 64-bit words as the key, some number of
+ * message bytes, and outputs a 64-bit word as the message digest. This
+ * implementation employs two data structures: a struct sipkey for
+ * representing the key, and a struct siphash for representing the hash
+ * state.
+ *
+ * For converting a 16-byte unsigned char array to a key, use either the
+ * macro sip_keyof or the routine sip_tokey. The former instantiates a
+ * compound literal key, while the latter requires a key object as a
+ * parameter.
+ *
+ * 	unsigned char secret[16];
+ * 	arc4random_buf(secret, sizeof secret);
+ * 	struct sipkey *key = sip_keyof(secret);
+ *
+ * For hashing a message, use either the convenience macro siphash24 or the
+ * routines sip24_init, sip24_update, and sip24_final.
+ *
+ * 	struct siphash state;
+ * 	void *msg;
+ * 	size_t len;
+ * 	uint64_t hash;
+ *
+ * 	sip24_init(&state, key);
+ * 	sip24_update(&state, msg, len);
+ * 	hash = sip24_final(&state);
+ *
+ * or
+ *
+ * 	hash = siphash24(msg, len, key);
+ *
+ * To convert the 64-bit hash value to a canonical 8-byte little-endian
+ * binary representation, use either the macro sip_binof or the routine
+ * sip_tobin. The former instantiates and returns a compound literal array,
+ * while the latter requires an array object as a parameter.
+ * --------------------------------------------------------------------------
+ * NOTES:
+ *
+ * o Neither sip_keyof, sip_binof, nor siphash24 will work with compilers
+ *   lacking compound literal support. Instead, you must use the lower-level
+ *   interfaces which take as parameters the temporary state objects.
+ *
+ * o Uppercase macros may evaluate parameters more than once. Lowercase
+ *   macros should not exhibit any such side effects.
+ * ==========================================================================
+ */
+
+#include "../../lv_conf_internal.h"
+#if LV_USE_XML
+#ifndef SIPHASH_H
+#define SIPHASH_H
+
+#include <stddef.h> /* size_t */
+#include <stdint.h> /* uint64_t uint32_t uint8_t */
+
+/*
+ * Workaround to not require a C++11 compiler for using ULL suffix
+ * if this code is included and compiled as C++; related GCC warning is:
+ * warning: use of C++11 long long integer constant [-Wlong-long]
+ */
+#define SIP_ULL(high, low) ((((uint64_t)high) << 32) | (low))
+
+#define SIP_ROTL(x, b) (uint64_t)(((x) << (b)) | ((x) >> (64 - (b))))
+
+#define SIP_U32TO8_LE(p, v)                                                    \
+  (p)[0] = (uint8_t)((v) >> 0);                                                \
+  (p)[1] = (uint8_t)((v) >> 8);                                                \
+  (p)[2] = (uint8_t)((v) >> 16);                                               \
+  (p)[3] = (uint8_t)((v) >> 24);
+
+#define SIP_U64TO8_LE(p, v)                                                    \
+  SIP_U32TO8_LE((p) + 0, (uint32_t)((v) >> 0));                                \
+  SIP_U32TO8_LE((p) + 4, (uint32_t)((v) >> 32));
+
+#define SIP_U8TO64_LE(p)                                                       \
+  (((uint64_t)((p)[0]) << 0) | ((uint64_t)((p)[1]) << 8)                       \
+   | ((uint64_t)((p)[2]) << 16) | ((uint64_t)((p)[3]) << 24)                   \
+   | ((uint64_t)((p)[4]) << 32) | ((uint64_t)((p)[5]) << 40)                   \
+   | ((uint64_t)((p)[6]) << 48) | ((uint64_t)((p)[7]) << 56))
+
+#define SIPHASH_INITIALIZER {0, 0, 0, 0, {0}, 0, 0}
+
+struct siphash {
+  uint64_t v0, v1, v2, v3;
+
+  unsigned char buf[8], *p;
+  uint64_t c;
+}; /* struct siphash */
+
+#define SIP_KEYLEN 16
+
+struct sipkey {
+  uint64_t k[2];
+}; /* struct sipkey */
+
+#define sip_keyof(k) sip_tokey(&(struct sipkey){{0}}, (k))
+
+static struct sipkey *
+sip_tokey(struct sipkey *key, const void *src) {
+  key->k[0] = SIP_U8TO64_LE((const unsigned char *)src);
+  key->k[1] = SIP_U8TO64_LE((const unsigned char *)src + 8);
+  return key;
+} /* sip_tokey() */
+
+#ifdef SIPHASH_TOBIN
+
+#  define sip_binof(v) sip_tobin((unsigned char[8]){0}, (v))
+
+static void *
+sip_tobin(void *dst, uint64_t u64) {
+  SIP_U64TO8_LE((unsigned char *)dst, u64);
+  return dst;
+} /* sip_tobin() */
+
+#endif /* SIPHASH_TOBIN */
+
+static void
+sip_round(struct siphash *H, const int rounds) {
+  int i;
+
+  for (i = 0; i < rounds; i++) {
+    H->v0 += H->v1;
+    H->v1 = SIP_ROTL(H->v1, 13);
+    H->v1 ^= H->v0;
+    H->v0 = SIP_ROTL(H->v0, 32);
+
+    H->v2 += H->v3;
+    H->v3 = SIP_ROTL(H->v3, 16);
+    H->v3 ^= H->v2;
+
+    H->v0 += H->v3;
+    H->v3 = SIP_ROTL(H->v3, 21);
+    H->v3 ^= H->v0;
+
+    H->v2 += H->v1;
+    H->v1 = SIP_ROTL(H->v1, 17);
+    H->v1 ^= H->v2;
+    H->v2 = SIP_ROTL(H->v2, 32);
+  }
+} /* sip_round() */
+
+static struct siphash *
+sip24_init(struct siphash *H, const struct sipkey *key) {
+  H->v0 = SIP_ULL(0x736f6d65U, 0x70736575U) ^ key->k[0];
+  H->v1 = SIP_ULL(0x646f7261U, 0x6e646f6dU) ^ key->k[1];
+  H->v2 = SIP_ULL(0x6c796765U, 0x6e657261U) ^ key->k[0];
+  H->v3 = SIP_ULL(0x74656462U, 0x79746573U) ^ key->k[1];
+
+  H->p = H->buf;
+  H->c = 0;
+
+  return H;
+} /* sip24_init() */
+
+#define sip_endof(a) (&(a)[sizeof(a) / sizeof *(a)])
+
+static struct siphash *
+sip24_update(struct siphash *H, const void *src, size_t len) {
+  const unsigned char *p = (const unsigned char *)src, *pe = p + len;
+  uint64_t m;
+
+  do {
+    while (p < pe && H->p < sip_endof(H->buf))
+      *H->p++ = *p++;
+
+    if (H->p < sip_endof(H->buf))
+      break;
+
+    m = SIP_U8TO64_LE(H->buf);
+    H->v3 ^= m;
+    sip_round(H, 2);
+    H->v0 ^= m;
+
+    H->p = H->buf;
+    H->c += 8;
+  } while (p < pe);
+
+  return H;
+} /* sip24_update() */
+
+static uint64_t
+sip24_final(struct siphash *H) {
+  const char left = (char)(H->p - H->buf);
+  uint64_t b = (H->c + left) << 56;
+
+  switch (left) {
+  case 7:
+    b |= (uint64_t)H->buf[6] << 48;
+    /* fall through */
+  case 6:
+    b |= (uint64_t)H->buf[5] << 40;
+    /* fall through */
+  case 5:
+    b |= (uint64_t)H->buf[4] << 32;
+    /* fall through */
+  case 4:
+    b |= (uint64_t)H->buf[3] << 24;
+    /* fall through */
+  case 3:
+    b |= (uint64_t)H->buf[2] << 16;
+    /* fall through */
+  case 2:
+    b |= (uint64_t)H->buf[1] << 8;
+    /* fall through */
+  case 1:
+    b |= (uint64_t)H->buf[0] << 0;
+    /* fall through */
+  case 0:
+    break;
+  }
+
+  H->v3 ^= b;
+  sip_round(H, 2);
+  H->v0 ^= b;
+  H->v2 ^= 0xff;
+  sip_round(H, 4);
+
+  return H->v0 ^ H->v1 ^ H->v2 ^ H->v3;
+} /* sip24_final() */
+
+static uint64_t
+siphash24(const void *src, size_t len, const struct sipkey *key) {
+  struct siphash state = SIPHASH_INITIALIZER;
+  return sip24_final(sip24_update(sip24_init(&state, key), src, len));
+} /* siphash24() */
+
+/*
+ * SipHash-2-4 output with
+ * k = 00 01 02 ...
+ * and
+ * in = (empty string)
+ * in = 00 (1 byte)
+ * in = 00 01 (2 bytes)
+ * in = 00 01 02 (3 bytes)
+ * ...
+ * in = 00 01 02 ... 3e (63 bytes)
+ */
+static int
+sip24_valid(void) {
+  /* clang-format off */
+  static const unsigned char vectors[64][8] = {
+    { 0x31, 0x0e, 0x0e, 0xdd, 0x47, 0xdb, 0x6f, 0x72, },
+    { 0xfd, 0x67, 0xdc, 0x93, 0xc5, 0x39, 0xf8, 0x74, },
+    { 0x5a, 0x4f, 0xa9, 0xd9, 0x09, 0x80, 0x6c, 0x0d, },
+    { 0x2d, 0x7e, 0xfb, 0xd7, 0x96, 0x66, 0x67, 0x85, },
+    { 0xb7, 0x87, 0x71, 0x27, 0xe0, 0x94, 0x27, 0xcf, },
+    { 0x8d, 0xa6, 0x99, 0xcd, 0x64, 0x55, 0x76, 0x18, },
+    { 0xce, 0xe3, 0xfe, 0x58, 0x6e, 0x46, 0xc9, 0xcb, },
+    { 0x37, 0xd1, 0x01, 0x8b, 0xf5, 0x00, 0x02, 0xab, },
+    { 0x62, 0x24, 0x93, 0x9a, 0x79, 0xf5, 0xf5, 0x93, },
+    { 0xb0, 0xe4, 0xa9, 0x0b, 0xdf, 0x82, 0x00, 0x9e, },
+    { 0xf3, 0xb9, 0xdd, 0x94, 0xc5, 0xbb, 0x5d, 0x7a, },
+    { 0xa7, 0xad, 0x6b, 0x22, 0x46, 0x2f, 0xb3, 0xf4, },
+    { 0xfb, 0xe5, 0x0e, 0x86, 0xbc, 0x8f, 0x1e, 0x75, },
+    { 0x90, 0x3d, 0x84, 0xc0, 0x27, 0x56, 0xea, 0x14, },
+    { 0xee, 0xf2, 0x7a, 0x8e, 0x90, 0xca, 0x23, 0xf7, },
+    { 0xe5, 0x45, 0xbe, 0x49, 0x61, 0xca, 0x29, 0xa1, },
+    { 0xdb, 0x9b, 0xc2, 0x57, 0x7f, 0xcc, 0x2a, 0x3f, },
+    { 0x94, 0x47, 0xbe, 0x2c, 0xf5, 0xe9, 0x9a, 0x69, },
+    { 0x9c, 0xd3, 0x8d, 0x96, 0xf0, 0xb3, 0xc1, 0x4b, },
+    { 0xbd, 0x61, 0x79, 0xa7, 0x1d, 0xc9, 0x6d, 0xbb, },
+    { 0x98, 0xee, 0xa2, 0x1a, 0xf2, 0x5c, 0xd6, 0xbe, },
+    { 0xc7, 0x67, 0x3b, 0x2e, 0xb0, 0xcb, 0xf2, 0xd0, },
+    { 0x88, 0x3e, 0xa3, 0xe3, 0x95, 0x67, 0x53, 0x93, },
+    { 0xc8, 0xce, 0x5c, 0xcd, 0x8c, 0x03, 0x0c, 0xa8, },
+    { 0x94, 0xaf, 0x49, 0xf6, 0xc6, 0x50, 0xad, 0xb8, },
+    { 0xea, 0xb8, 0x85, 0x8a, 0xde, 0x92, 0xe1, 0xbc, },
+    { 0xf3, 0x15, 0xbb, 0x5b, 0xb8, 0x35, 0xd8, 0x17, },
+    { 0xad, 0xcf, 0x6b, 0x07, 0x63, 0x61, 0x2e, 0x2f, },
+    { 0xa5, 0xc9, 0x1d, 0xa7, 0xac, 0xaa, 0x4d, 0xde, },
+    { 0x71, 0x65, 0x95, 0x87, 0x66, 0x50, 0xa2, 0xa6, },
+    { 0x28, 0xef, 0x49, 0x5c, 0x53, 0xa3, 0x87, 0xad, },
+    { 0x42, 0xc3, 0x41, 0xd8, 0xfa, 0x92, 0xd8, 0x32, },
+    { 0xce, 0x7c, 0xf2, 0x72, 0x2f, 0x51, 0x27, 0x71, },
+    { 0xe3, 0x78, 0x59, 0xf9, 0x46, 0x23, 0xf3, 0xa7, },
+    { 0x38, 0x12, 0x05, 0xbb, 0x1a, 0xb0, 0xe0, 0x12, },
+    { 0xae, 0x97, 0xa1, 0x0f, 0xd4, 0x34, 0xe0, 0x15, },
+    { 0xb4, 0xa3, 0x15, 0x08, 0xbe, 0xff, 0x4d, 0x31, },
+    { 0x81, 0x39, 0x62, 0x29, 0xf0, 0x90, 0x79, 0x02, },
+    { 0x4d, 0x0c, 0xf4, 0x9e, 0xe5, 0xd4, 0xdc, 0xca, },
+    { 0x5c, 0x73, 0x33, 0x6a, 0x76, 0xd8, 0xbf, 0x9a, },
+    { 0xd0, 0xa7, 0x04, 0x53, 0x6b, 0xa9, 0x3e, 0x0e, },
+    { 0x92, 0x59, 0x58, 0xfc, 0xd6, 0x42, 0x0c, 0xad, },
+    { 0xa9, 0x15, 0xc2, 0x9b, 0xc8, 0x06, 0x73, 0x18, },
+    { 0x95, 0x2b, 0x79, 0xf3, 0xbc, 0x0a, 0xa6, 0xd4, },
+    { 0xf2, 0x1d, 0xf2, 0xe4, 0x1d, 0x45, 0x35, 0xf9, },
+    { 0x87, 0x57, 0x75, 0x19, 0x04, 0x8f, 0x53, 0xa9, },
+    { 0x10, 0xa5, 0x6c, 0xf5, 0xdf, 0xcd, 0x9a, 0xdb, },
+    { 0xeb, 0x75, 0x09, 0x5c, 0xcd, 0x98, 0x6c, 0xd0, },
+    { 0x51, 0xa9, 0xcb, 0x9e, 0xcb, 0xa3, 0x12, 0xe6, },
+    { 0x96, 0xaf, 0xad, 0xfc, 0x2c, 0xe6, 0x66, 0xc7, },
+    { 0x72, 0xfe, 0x52, 0x97, 0x5a, 0x43, 0x64, 0xee, },
+    { 0x5a, 0x16, 0x45, 0xb2, 0x76, 0xd5, 0x92, 0xa1, },
+    { 0xb2, 0x74, 0xcb, 0x8e, 0xbf, 0x87, 0x87, 0x0a, },
+    { 0x6f, 0x9b, 0xb4, 0x20, 0x3d, 0xe7, 0xb3, 0x81, },
+    { 0xea, 0xec, 0xb2, 0xa3, 0x0b, 0x22, 0xa8, 0x7f, },
+    { 0x99, 0x24, 0xa4, 0x3c, 0xc1, 0x31, 0x57, 0x24, },
+    { 0xbd, 0x83, 0x8d, 0x3a, 0xaf, 0xbf, 0x8d, 0xb7, },
+    { 0x0b, 0x1a, 0x2a, 0x32, 0x65, 0xd5, 0x1a, 0xea, },
+    { 0x13, 0x50, 0x79, 0xa3, 0x23, 0x1c, 0xe6, 0x60, },
+    { 0x93, 0x2b, 0x28, 0x46, 0xe4, 0xd7, 0x06, 0x66, },
+    { 0xe1, 0x91, 0x5f, 0x5c, 0xb1, 0xec, 0xa4, 0x6c, },
+    { 0xf3, 0x25, 0x96, 0x5c, 0xa1, 0x6d, 0x62, 0x9f, },
+    { 0x57, 0x5f, 0xf2, 0x8e, 0x60, 0x38, 0x1b, 0xe5, },
+    { 0x72, 0x45, 0x06, 0xeb, 0x4c, 0x32, 0x8a, 0x95, }
+  };
+  /* clang-format on */
+
+  unsigned char in[64];
+  struct sipkey k;
+  size_t i;
+
+  sip_tokey(&k, "\000\001\002\003\004\005\006\007\010\011"
+                "\012\013\014\015\016\017");
+
+  for (i = 0; i < sizeof in; ++i) {
+    in[i] = (unsigned char)i;
+
+    if (siphash24(in, i, &k) != SIP_U8TO64_LE(vectors[i]))
+      return 0;
+  }
+
+  return 1;
+} /* sip24_valid() */
+
+#ifdef SIPHASH_MAIN
+
+#  include <stdio.h>
+
+int
+main(void) {
+  const int ok = sip24_valid();
+
+  if (ok)
+    puts("OK");
+  else
+    puts("FAIL");
+
+  return ! ok;
+} /* main() */
+
+#endif /* SIPHASH_MAIN */
+
+#endif /* SIPHASH_H */
+
+#endif /* LV_USE_XML */
+
diff --git a/src/libs/expat/utf8tab.h b/src/libs/expat/utf8tab.h
new file mode 100644
index 000000000..c2548ef8c
--- /dev/null
+++ b/src/libs/expat/utf8tab.h
@@ -0,0 +1,72 @@
+/*
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2002      Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
+   Copyright (c) 2017      Sebastian Pipping <sebastian@pipping.org>
+   Licensed under the MIT license:
+
+   Permission is  hereby granted,  free of charge,  to any  person obtaining
+   a  copy  of  this  software   and  associated  documentation  files  (the
+   "Software"),  to  deal in  the  Software  without restriction,  including
+   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
+   distribute, sublicense, and/or sell copies of the Software, and to permit
+   persons  to whom  the Software  is  furnished to  do so,  subject to  the
+   following conditions:
+
+   The above copyright  notice and this permission notice  shall be included
+   in all copies or substantial portions of the Software.
+
+   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
+   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
+   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+   USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include "../../lv_conf_internal.h"
+#if LV_USE_XML
+
+/* 0x80 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+    /* 0x84 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+    /* 0x88 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+    /* 0x8C */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+    /* 0x90 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+    /* 0x94 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+    /* 0x98 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+    /* 0x9C */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+    /* 0xA0 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+    /* 0xA4 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+    /* 0xA8 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+    /* 0xAC */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+    /* 0xB0 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+    /* 0xB4 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+    /* 0xB8 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+    /* 0xBC */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+    /* 0xC0 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+    /* 0xC4 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+    /* 0xC8 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+    /* 0xCC */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+    /* 0xD0 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+    /* 0xD4 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+    /* 0xD8 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+    /* 0xDC */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+    /* 0xE0 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
+    /* 0xE4 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
+    /* 0xE8 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
+    /* 0xEC */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
+    /* 0xF0 */ BT_LEAD4, BT_LEAD4, BT_LEAD4, BT_LEAD4,
+    /* 0xF4 */ BT_LEAD4, BT_NONXML, BT_NONXML, BT_NONXML,
+    /* 0xF8 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+    /* 0xFC */ BT_NONXML, BT_NONXML, BT_MALFORM, BT_MALFORM,
+
+#endif /* LV_USE_XML */
+
diff --git a/src/libs/expat/winconfig.h b/src/libs/expat/winconfig.h
new file mode 100644
index 000000000..e45414cc4
--- /dev/null
+++ b/src/libs/expat/winconfig.h
@@ -0,0 +1,54 @@
+/*
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2002      Greg Stein <gstein@users.sourceforge.net>
+   Copyright (c) 2005      Karl Waclawek <karl@waclawek.net>
+   Copyright (c) 2017-2023 Sebastian Pipping <sebastian@pipping.org>
+   Copyright (c) 2023      Orgad Shaneh <orgad.shaneh@audiocodes.com>
+   Licensed under the MIT license:
+
+   Permission is  hereby granted,  free of charge,  to any  person obtaining
+   a  copy  of  this  software   and  associated  documentation  files  (the
+   "Software"),  to  deal in  the  Software  without restriction,  including
+   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
+   distribute, sublicense, and/or sell copies of the Software, and to permit
+   persons  to whom  the Software  is  furnished to  do so,  subject to  the
+   following conditions:
+
+   The above copyright  notice and this permission notice  shall be included
+   in all copies or substantial portions of the Software.
+
+   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
+   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
+   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+   USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include "../../lv_conf_internal.h"
+#if LV_USE_XML
+
+#ifndef WINCONFIG_H
+#define WINCONFIG_H
+
+#ifndef WIN32_LEAN_AND_MEAN
+#  define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#undef WIN32_LEAN_AND_MEAN
+
+#include <memory.h>
+#include <string.h>
+
+#endif /* ndef WINCONFIG_H */
+
+#endif /* LV_USE_XML */
+
diff --git a/src/libs/expat/xmlparse.c b/src/libs/expat/xmlparse.c
new file mode 100644
index 000000000..ccedc603b
--- /dev/null
+++ b/src/libs/expat/xmlparse.c
@@ -0,0 +1,8567 @@
+/* ba4cdf9bdb534f355a9def4c9e25d20ee8e72f95b0a4d930be52e563f5080196 (2.6.3+)
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2000-2006 Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
+   Copyright (c) 2001-2002 Greg Stein <gstein@users.sourceforge.net>
+   Copyright (c) 2002-2016 Karl Waclawek <karl@waclawek.net>
+   Copyright (c) 2005-2009 Steven Solie <steven@solie.ca>
+   Copyright (c) 2016      Eric Rahm <erahm@mozilla.com>
+   Copyright (c) 2016-2024 Sebastian Pipping <sebastian@pipping.org>
+   Copyright (c) 2016      Gaurav <g.gupta@samsung.com>
+   Copyright (c) 2016      Thomas Beutlich <tc@tbeu.de>
+   Copyright (c) 2016      Gustavo Grieco <gustavo.grieco@imag.fr>
+   Copyright (c) 2016      Pascal Cuoq <cuoq@trust-in-soft.com>
+   Copyright (c) 2016      Ed Schouten <ed@nuxi.nl>
+   Copyright (c) 2017-2022 Rhodri James <rhodri@wildebeest.org.uk>
+   Copyright (c) 2017      Václav Slavík <vaclav@slavik.io>
+   Copyright (c) 2017      Viktor Szakats <commit@vsz.me>
+   Copyright (c) 2017      Chanho Park <chanho61.park@samsung.com>
+   Copyright (c) 2017      Rolf Eike Beer <eike@sf-mail.de>
+   Copyright (c) 2017      Hans Wennborg <hans@chromium.org>
+   Copyright (c) 2018      Anton Maklakov <antmak.pub@gmail.com>
+   Copyright (c) 2018      Benjamin Peterson <benjamin@python.org>
+   Copyright (c) 2018      Marco Maggi <marco.maggi-ipsu@poste.it>
+   Copyright (c) 2018      Mariusz Zaborski <oshogbo@vexillium.org>
+   Copyright (c) 2019      David Loffredo <loffredo@steptools.com>
+   Copyright (c) 2019-2020 Ben Wagner <bungeman@chromium.org>
+   Copyright (c) 2019      Vadim Zeitlin <vadim@zeitlins.org>
+   Copyright (c) 2021      Donghee Na <donghee.na@python.org>
+   Copyright (c) 2022      Samanta Navarro <ferivoz@riseup.net>
+   Copyright (c) 2022      Jeffrey Walton <noloader@gmail.com>
+   Copyright (c) 2022      Jann Horn <jannh@google.com>
+   Copyright (c) 2022      Sean McBride <sean@rogue-research.com>
+   Copyright (c) 2023      Owain Davies <owaind@bath.edu>
+   Copyright (c) 2023-2024 Sony Corporation / Snild Dolkow <snild@sony.com>
+   Copyright (c) 2024      Berkay Eren Ürün <berkay.ueruen@siemens.com>
+   Licensed under the MIT license:
+
+   Permission is  hereby granted,  free of charge,  to any  person obtaining
+   a  copy  of  this  software   and  associated  documentation  files  (the
+   "Software"),  to  deal in  the  Software  without restriction,  including
+   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
+   distribute, sublicense, and/or sell copies of the Software, and to permit
+   persons  to whom  the Software  is  furnished to  do so,  subject to  the
+   following conditions:
+
+   The above copyright  notice and this permission notice  shall be included
+   in all copies or substantial portions of the Software.
+
+   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
+   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
+   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+   USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include "../../lv_conf_internal.h"
+#if LV_USE_XML
+
+#define XML_BUILDING_EXPAT 1
+
+#include "expat_config.h"
+
+#if ! defined(XML_GE) || (1 - XML_GE - 1 == 2) || (XML_GE < 0) || (XML_GE > 1)
+#  error XML_GE (for general entities) must be defined, non-empty, either 1 or 0 (0 to disable, 1 to enable; 1 is a common default)
+#endif
+
+#if defined(XML_DTD) && XML_GE == 0
+#  error Either undefine XML_DTD or define XML_GE to 1.
+#endif
+
+#if ! defined(XML_CONTEXT_BYTES) || (1 - XML_CONTEXT_BYTES - 1 == 2)           \
+    || (XML_CONTEXT_BYTES + 0 < 0)
+#  error XML_CONTEXT_BYTES must be defined, non-empty and >=0 (0 to disable, >=1 to enable; 1024 is a common default)
+#endif
+
+#if defined(HAVE_SYSCALL_GETRANDOM)
+#  if ! defined(_GNU_SOURCE)
+#    define _GNU_SOURCE 1 /* syscall prototype */
+#  endif
+#endif
+
+#ifdef _WIN32
+/* force stdlib to define rand_s() */
+#  if ! defined(_CRT_RAND_S)
+#    define _CRT_RAND_S
+#  endif
+#endif
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <string.h> /* memset(), memcpy() */
+#include <assert.h>
+#include <limits.h> /* UINT_MAX */
+#include <stdio.h>  /* fprintf */
+#include <stdlib.h> /* getenv, rand_s */
+#include <stdint.h> /* uintptr_t */
+#include <math.h>   /* isnan */
+
+#ifdef _WIN32
+#  define getpid GetCurrentProcessId
+#else
+#  include <sys/time.h>  /* gettimeofday() */
+#  include <sys/types.h> /* getpid() */
+#  include <unistd.h>    /* getpid() */
+#  include <fcntl.h>     /* O_RDONLY */
+#  include <errno.h>
+#endif
+
+#ifdef _WIN32
+#  include "winconfig.h"
+#endif
+
+#include "ascii.h"
+#include "expat.h"
+#include "siphash.h"
+
+#if defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM)
+#  if defined(HAVE_GETRANDOM)
+#    include <sys/random.h> /* getrandom */
+#  else
+#    include <unistd.h>      /* syscall */
+#    include <sys/syscall.h> /* SYS_getrandom */
+#  endif
+#  if ! defined(GRND_NONBLOCK)
+#    define GRND_NONBLOCK 0x0001
+#  endif /* defined(GRND_NONBLOCK) */
+#endif   /* defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM) */
+
+#if defined(HAVE_LIBBSD)                                                       \
+    && (defined(HAVE_ARC4RANDOM_BUF) || defined(HAVE_ARC4RANDOM))
+#  include <bsd/stdlib.h>
+#endif
+
+#if defined(_WIN32) && ! defined(LOAD_LIBRARY_SEARCH_SYSTEM32)
+#  define LOAD_LIBRARY_SEARCH_SYSTEM32 0x00000800
+#endif
+
+#if ! defined(HAVE_GETRANDOM) && ! defined(HAVE_SYSCALL_GETRANDOM)             \
+    && ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM)            \
+    && ! defined(XML_DEV_URANDOM) && ! defined(_WIN32)                         \
+    && ! defined(XML_POOR_ENTROPY)
+#  error You do not have support for any sources of high quality entropy \
+    enabled.  For end user security, that is probably not what you want. \
+    \
+    Your options include: \
+      * Linux >=3.17 + glibc >=2.25 (getrandom): HAVE_GETRANDOM, \
+      * Linux >=3.17 + glibc (including <2.25) (syscall SYS_getrandom): HAVE_SYSCALL_GETRANDOM, \
+      * BSD / macOS >=10.7 / glibc >=2.36 (arc4random_buf): HAVE_ARC4RANDOM_BUF, \
+      * BSD / macOS (including <10.7) / glibc >=2.36 (arc4random): HAVE_ARC4RANDOM, \
+      * libbsd (arc4random_buf): HAVE_ARC4RANDOM_BUF + HAVE_LIBBSD, \
+      * libbsd (arc4random): HAVE_ARC4RANDOM + HAVE_LIBBSD, \
+      * Linux (including <3.17) / BSD / macOS (including <10.7) / Solaris >=8 (/dev/urandom): XML_DEV_URANDOM, \
+      * Windows >=Vista (rand_s): _WIN32. \
+    \
+    If insist on not using any of these, bypass this error by defining \
+    XML_POOR_ENTROPY; you have been warned. \
+    \
+    If you have reasons to patch this detection code away or need changes \
+    to the build system, please open a bug.  Thank you!
+#endif
+
+#ifdef XML_UNICODE
+#  define XML_ENCODE_MAX XML_UTF16_ENCODE_MAX
+#  define XmlConvert XmlUtf16Convert
+#  define XmlGetInternalEncoding XmlGetUtf16InternalEncoding
+#  define XmlGetInternalEncodingNS XmlGetUtf16InternalEncodingNS
+#  define XmlEncode XmlUtf16Encode
+#  define MUST_CONVERT(enc, s) (! (enc)->isUtf16 || (((uintptr_t)(s)) & 1))
+typedef unsigned short ICHAR;
+#else
+#  define XML_ENCODE_MAX XML_UTF8_ENCODE_MAX
+#  define XmlConvert XmlUtf8Convert
+#  define XmlGetInternalEncoding XmlGetUtf8InternalEncoding
+#  define XmlGetInternalEncodingNS XmlGetUtf8InternalEncodingNS
+#  define XmlEncode XmlUtf8Encode
+#  define MUST_CONVERT(enc, s) (! (enc)->isUtf8)
+typedef char ICHAR;
+#endif
+
+#ifndef XML_NS
+
+#  define XmlInitEncodingNS XmlInitEncoding
+#  define XmlInitUnknownEncodingNS XmlInitUnknownEncoding
+#  undef XmlGetInternalEncodingNS
+#  define XmlGetInternalEncodingNS XmlGetInternalEncoding
+#  define XmlParseXmlDeclNS XmlParseXmlDecl
+
+#endif
+
+#ifdef XML_UNICODE
+
+#  ifdef XML_UNICODE_WCHAR_T
+#    define XML_T(x) (const wchar_t) x
+#    define XML_L(x) L##x
+#  else
+#    define XML_T(x) (const unsigned short)x
+#    define XML_L(x) x
+#  endif
+
+#else
+
+#  define XML_T(x) x
+#  define XML_L(x) x
+
+#endif
+
+/* Round up n to be a multiple of sz, where sz is a power of 2. */
+#define ROUND_UP(n, sz) (((n) + ((sz) - 1)) & ~((sz) - 1))
+
+/* Do safe (NULL-aware) pointer arithmetic */
+#define EXPAT_SAFE_PTR_DIFF(p, q) (((p) && (q)) ? ((p) - (q)) : 0)
+
+#define EXPAT_MIN(a, b) (((a) < (b)) ? (a) : (b))
+
+#include "internal.h"
+#include "xmltok.h"
+#include "xmlrole.h"
+
+typedef const XML_Char *KEY;
+
+typedef struct {
+  KEY name;
+} NAMED;
+
+typedef struct {
+  NAMED **v;
+  unsigned char power;
+  size_t size;
+  size_t used;
+  const XML_Memory_Handling_Suite *mem;
+} HASH_TABLE;
+
+static size_t keylen(KEY s);
+
+static void copy_salt_to_sipkey(XML_Parser parser, struct sipkey *key);
+
+/* For probing (after a collision) we need a step size relative prime
+   to the hash table size, which is a power of 2. We use double-hashing,
+   since we can calculate a second hash value cheaply by taking those bits
+   of the first hash value that were discarded (masked out) when the table
+   index was calculated: index = hash & mask, where mask = table->size - 1.
+   We limit the maximum step size to table->size / 4 (mask >> 2) and make
+   it odd, since odd numbers are always relative prime to a power of 2.
+*/
+#define SECOND_HASH(hash, mask, power)                                         \
+  ((((hash) & ~(mask)) >> ((power) - 1)) & ((mask) >> 2))
+#define PROBE_STEP(hash, mask, power)                                          \
+  ((unsigned char)((SECOND_HASH(hash, mask, power)) | 1))
+
+typedef struct {
+  NAMED **p;
+  NAMED **end;
+} HASH_TABLE_ITER;
+
+#define INIT_TAG_BUF_SIZE 32 /* must be a multiple of sizeof(XML_Char) */
+#define INIT_DATA_BUF_SIZE 1024
+#define INIT_ATTS_SIZE 16
+#define INIT_ATTS_VERSION 0xFFFFFFFF
+#define INIT_BLOCK_SIZE 1024
+#define INIT_BUFFER_SIZE 1024
+
+#define EXPAND_SPARE 24
+
+typedef struct binding {
+  struct prefix *prefix;
+  struct binding *nextTagBinding;
+  struct binding *prevPrefixBinding;
+  const struct attribute_id *attId;
+  XML_Char *uri;
+  int uriLen;
+  int uriAlloc;
+} BINDING;
+
+typedef struct prefix {
+  const XML_Char *name;
+  BINDING *binding;
+} PREFIX;
+
+typedef struct {
+  const XML_Char *str;
+  const XML_Char *localPart;
+  const XML_Char *prefix;
+  int strLen;
+  int uriLen;
+  int prefixLen;
+} TAG_NAME;
+
+/* TAG represents an open element.
+   The name of the element is stored in both the document and API
+   encodings.  The memory buffer 'buf' is a separately-allocated
+   memory area which stores the name.  During the XML_Parse()/
+   XML_ParseBuffer() when the element is open, the memory for the 'raw'
+   version of the name (in the document encoding) is shared with the
+   document buffer.  If the element is open across calls to
+   XML_Parse()/XML_ParseBuffer(), the buffer is re-allocated to
+   contain the 'raw' name as well.
+
+   A parser reuses these structures, maintaining a list of allocated
+   TAG objects in a free list.
+*/
+typedef struct tag {
+  struct tag *parent;  /* parent of this element */
+  const char *rawName; /* tagName in the original encoding */
+  int rawNameLength;
+  TAG_NAME name; /* tagName in the API encoding */
+  char *buf;     /* buffer for name components */
+  char *bufEnd;  /* end of the buffer */
+  BINDING *bindings;
+} TAG;
+
+typedef struct {
+  const XML_Char *name;
+  const XML_Char *textPtr;
+  int textLen;   /* length in XML_Chars */
+  int processed; /* # of processed bytes - when suspended */
+  const XML_Char *systemId;
+  const XML_Char *base;
+  const XML_Char *publicId;
+  const XML_Char *notation;
+  XML_Bool open;
+  XML_Bool is_param;
+  XML_Bool is_internal; /* true if declared in internal subset outside PE */
+} ENTITY;
+
+typedef struct {
+  enum XML_Content_Type type;
+  enum XML_Content_Quant quant;
+  const XML_Char *name;
+  int firstchild;
+  int lastchild;
+  int childcnt;
+  int nextsib;
+} CONTENT_SCAFFOLD;
+
+#define INIT_SCAFFOLD_ELEMENTS 32
+
+typedef struct block {
+  struct block *next;
+  int size;
+  XML_Char s[1];
+} BLOCK;
+
+typedef struct {
+  BLOCK *blocks;
+  BLOCK *freeBlocks;
+  const XML_Char *end;
+  XML_Char *ptr;
+  XML_Char *start;
+  const XML_Memory_Handling_Suite *mem;
+} STRING_POOL;
+
+/* The XML_Char before the name is used to determine whether
+   an attribute has been specified. */
+typedef struct attribute_id {
+  XML_Char *name;
+  PREFIX *prefix;
+  XML_Bool maybeTokenized;
+  XML_Bool xmlns;
+} ATTRIBUTE_ID;
+
+typedef struct {
+  const ATTRIBUTE_ID *id;
+  XML_Bool isCdata;
+  const XML_Char *value;
+} DEFAULT_ATTRIBUTE;
+
+typedef struct {
+  unsigned long version;
+  unsigned long hash;
+  const XML_Char *uriName;
+} NS_ATT;
+
+typedef struct {
+  const XML_Char *name;
+  PREFIX *prefix;
+  const ATTRIBUTE_ID *idAtt;
+  int nDefaultAtts;
+  int allocDefaultAtts;
+  DEFAULT_ATTRIBUTE *defaultAtts;
+} ELEMENT_TYPE;
+
+typedef struct {
+  HASH_TABLE generalEntities;
+  HASH_TABLE elementTypes;
+  HASH_TABLE attributeIds;
+  HASH_TABLE prefixes;
+  STRING_POOL pool;
+  STRING_POOL entityValuePool;
+  /* false once a parameter entity reference has been skipped */
+  XML_Bool keepProcessing;
+  /* true once an internal or external PE reference has been encountered;
+     this includes the reference to an external subset */
+  XML_Bool hasParamEntityRefs;
+  XML_Bool standalone;
+#ifdef XML_DTD
+  /* indicates if external PE has been read */
+  XML_Bool paramEntityRead;
+  HASH_TABLE paramEntities;
+#endif /* XML_DTD */
+  PREFIX defaultPrefix;
+  /* === scaffolding for building content model === */
+  XML_Bool in_eldecl;
+  CONTENT_SCAFFOLD *scaffold;
+  unsigned contentStringLen;
+  unsigned scaffSize;
+  unsigned scaffCount;
+  int scaffLevel;
+  int *scaffIndex;
+} DTD;
+
+typedef struct open_internal_entity {
+  const char *internalEventPtr;
+  const char *internalEventEndPtr;
+  struct open_internal_entity *next;
+  ENTITY *entity;
+  int startTagLevel;
+  XML_Bool betweenDecl; /* WFC: PE Between Declarations */
+} OPEN_INTERNAL_ENTITY;
+
+enum XML_Account {
+  XML_ACCOUNT_DIRECT,           /* bytes directly passed to the Expat parser */
+  XML_ACCOUNT_ENTITY_EXPANSION, /* intermediate bytes produced during entity
+                                   expansion */
+  XML_ACCOUNT_NONE              /* i.e. do not account, was accounted already */
+};
+
+#if XML_GE == 1
+typedef unsigned long long XmlBigCount;
+typedef struct accounting {
+  XmlBigCount countBytesDirect;
+  XmlBigCount countBytesIndirect;
+  unsigned long debugLevel;
+  float maximumAmplificationFactor; // >=1.0
+  unsigned long long activationThresholdBytes;
+} ACCOUNTING;
+
+typedef struct entity_stats {
+  unsigned int countEverOpened;
+  unsigned int currentDepth;
+  unsigned int maximumDepthSeen;
+  unsigned long debugLevel;
+} ENTITY_STATS;
+#endif /* XML_GE == 1 */
+
+typedef enum XML_Error PTRCALL Processor(XML_Parser parser, const char *start,
+                                         const char *end, const char **endPtr);
+
+static Processor prologProcessor;
+static Processor prologInitProcessor;
+static Processor contentProcessor;
+static Processor cdataSectionProcessor;
+#ifdef XML_DTD
+static Processor ignoreSectionProcessor;
+static Processor externalParEntProcessor;
+static Processor externalParEntInitProcessor;
+static Processor entityValueProcessor;
+static Processor entityValueInitProcessor;
+#endif /* XML_DTD */
+static Processor epilogProcessor;
+static Processor errorProcessor;
+static Processor externalEntityInitProcessor;
+static Processor externalEntityInitProcessor2;
+static Processor externalEntityInitProcessor3;
+static Processor externalEntityContentProcessor;
+static Processor internalEntityProcessor;
+
+static enum XML_Error handleUnknownEncoding(XML_Parser parser,
+                                            const XML_Char *encodingName);
+static enum XML_Error processXmlDecl(XML_Parser parser, int isGeneralTextEntity,
+                                     const char *s, const char *next);
+static enum XML_Error initializeEncoding(XML_Parser parser);
+static enum XML_Error doProlog(XML_Parser parser, const ENCODING *enc,
+                               const char *s, const char *end, int tok,
+                               const char *next, const char **nextPtr,
+                               XML_Bool haveMore, XML_Bool allowClosingDoctype,
+                               enum XML_Account account);
+static enum XML_Error processInternalEntity(XML_Parser parser, ENTITY *entity,
+                                            XML_Bool betweenDecl);
+static enum XML_Error doContent(XML_Parser parser, int startTagLevel,
+                                const ENCODING *enc, const char *start,
+                                const char *end, const char **endPtr,
+                                XML_Bool haveMore, enum XML_Account account);
+static enum XML_Error doCdataSection(XML_Parser parser, const ENCODING *enc,
+                                     const char **startPtr, const char *end,
+                                     const char **nextPtr, XML_Bool haveMore,
+                                     enum XML_Account account);
+#ifdef XML_DTD
+static enum XML_Error doIgnoreSection(XML_Parser parser, const ENCODING *enc,
+                                      const char **startPtr, const char *end,
+                                      const char **nextPtr, XML_Bool haveMore);
+#endif /* XML_DTD */
+
+static void freeBindings(XML_Parser parser, BINDING *bindings);
+static enum XML_Error storeAtts(XML_Parser parser, const ENCODING *enc,
+                                const char *attStr, TAG_NAME *tagNamePtr,
+                                BINDING **bindingsPtr,
+                                enum XML_Account account);
+static enum XML_Error addBinding(XML_Parser parser, PREFIX *prefix,
+                                 const ATTRIBUTE_ID *attId, const XML_Char *uri,
+                                 BINDING **bindingsPtr);
+static int defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId,
+                           XML_Bool isCdata, XML_Bool isId,
+                           const XML_Char *value, XML_Parser parser);
+static enum XML_Error storeAttributeValue(XML_Parser parser,
+                                          const ENCODING *enc, XML_Bool isCdata,
+                                          const char *ptr, const char *end,
+                                          STRING_POOL *pool,
+                                          enum XML_Account account);
+static enum XML_Error appendAttributeValue(XML_Parser parser,
+                                           const ENCODING *enc,
+                                           XML_Bool isCdata, const char *ptr,
+                                           const char *end, STRING_POOL *pool,
+                                           enum XML_Account account);
+static ATTRIBUTE_ID *getAttributeId(XML_Parser parser, const ENCODING *enc,
+                                    const char *start, const char *end);
+static int setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *elementType);
+#if XML_GE == 1
+static enum XML_Error storeEntityValue(XML_Parser parser, const ENCODING *enc,
+                                       const char *start, const char *end,
+                                       enum XML_Account account);
+#else
+static enum XML_Error storeSelfEntityValue(XML_Parser parser, ENTITY *entity);
+#endif
+static int reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,
+                                       const char *start, const char *end);
+static int reportComment(XML_Parser parser, const ENCODING *enc,
+                         const char *start, const char *end);
+static void reportDefault(XML_Parser parser, const ENCODING *enc,
+                          const char *start, const char *end);
+
+static const XML_Char *getContext(XML_Parser parser);
+static XML_Bool setContext(XML_Parser parser, const XML_Char *context);
+
+static void FASTCALL normalizePublicId(XML_Char *s);
+
+static DTD *dtdCreate(const XML_Memory_Handling_Suite *ms);
+/* do not call if m_parentParser != NULL */
+static void dtdReset(DTD *p, const XML_Memory_Handling_Suite *ms);
+static void dtdDestroy(DTD *p, XML_Bool isDocEntity,
+                       const XML_Memory_Handling_Suite *ms);
+static int dtdCopy(XML_Parser oldParser, DTD *newDtd, const DTD *oldDtd,
+                   const XML_Memory_Handling_Suite *ms);
+static int copyEntityTable(XML_Parser oldParser, HASH_TABLE *newTable,
+                           STRING_POOL *newPool, const HASH_TABLE *oldTable);
+static NAMED *lookup(XML_Parser parser, HASH_TABLE *table, KEY name,
+                     size_t createSize);
+static void FASTCALL hashTableInit(HASH_TABLE *table,
+                                   const XML_Memory_Handling_Suite *ms);
+static void FASTCALL hashTableClear(HASH_TABLE *table);
+static void FASTCALL hashTableDestroy(HASH_TABLE *table);
+static void FASTCALL hashTableIterInit(HASH_TABLE_ITER *iter,
+                                       const HASH_TABLE *table);
+static NAMED *FASTCALL hashTableIterNext(HASH_TABLE_ITER *iter);
+
+static void FASTCALL poolInit(STRING_POOL *pool,
+                              const XML_Memory_Handling_Suite *ms);
+static void FASTCALL poolClear(STRING_POOL *pool);
+static void FASTCALL poolDestroy(STRING_POOL *pool);
+static XML_Char *poolAppend(STRING_POOL *pool, const ENCODING *enc,
+                            const char *ptr, const char *end);
+static XML_Char *poolStoreString(STRING_POOL *pool, const ENCODING *enc,
+                                 const char *ptr, const char *end);
+static XML_Bool FASTCALL poolGrow(STRING_POOL *pool);
+static const XML_Char *FASTCALL poolCopyString(STRING_POOL *pool,
+                                               const XML_Char *s);
+static const XML_Char *poolCopyStringN(STRING_POOL *pool, const XML_Char *s,
+                                       int n);
+static const XML_Char *FASTCALL poolAppendString(STRING_POOL *pool,
+                                                 const XML_Char *s);
+
+static int FASTCALL nextScaffoldPart(XML_Parser parser);
+static XML_Content *build_model(XML_Parser parser);
+static ELEMENT_TYPE *getElementType(XML_Parser parser, const ENCODING *enc,
+                                    const char *ptr, const char *end);
+
+static XML_Char *copyString(const XML_Char *s,
+                            const XML_Memory_Handling_Suite *memsuite);
+
+static unsigned long generate_hash_secret_salt(XML_Parser parser);
+static XML_Bool startParsing(XML_Parser parser);
+
+static XML_Parser parserCreate(const XML_Char *encodingName,
+                               const XML_Memory_Handling_Suite *memsuite,
+                               const XML_Char *nameSep, DTD *dtd);
+
+static void parserInit(XML_Parser parser, const XML_Char *encodingName);
+
+#if XML_GE == 1
+static float accountingGetCurrentAmplification(XML_Parser rootParser);
+static void accountingReportStats(XML_Parser originParser, const char *epilog);
+static void accountingOnAbort(XML_Parser originParser);
+static void accountingReportDiff(XML_Parser rootParser,
+                                 unsigned int levelsAwayFromRootParser,
+                                 const char *before, const char *after,
+                                 ptrdiff_t bytesMore, int source_line,
+                                 enum XML_Account account);
+static XML_Bool accountingDiffTolerated(XML_Parser originParser, int tok,
+                                        const char *before, const char *after,
+                                        int source_line,
+                                        enum XML_Account account);
+
+static void entityTrackingReportStats(XML_Parser parser, ENTITY *entity,
+                                      const char *action, int sourceLine);
+static void entityTrackingOnOpen(XML_Parser parser, ENTITY *entity,
+                                 int sourceLine);
+static void entityTrackingOnClose(XML_Parser parser, ENTITY *entity,
+                                  int sourceLine);
+
+static XML_Parser getRootParserOf(XML_Parser parser,
+                                  unsigned int *outLevelDiff);
+#endif /* XML_GE == 1 */
+
+static unsigned long getDebugLevel(const char *variableName,
+                                   unsigned long defaultDebugLevel);
+
+#define poolStart(pool) ((pool)->start)
+#define poolLength(pool) ((pool)->ptr - (pool)->start)
+#define poolChop(pool) ((void)--(pool->ptr))
+#define poolLastChar(pool) (((pool)->ptr)[-1])
+#define poolDiscard(pool) ((pool)->ptr = (pool)->start)
+#define poolFinish(pool) ((pool)->start = (pool)->ptr)
+#define poolAppendChar(pool, c)                                                \
+  (((pool)->ptr == (pool)->end && ! poolGrow(pool))                            \
+       ? 0                                                                     \
+       : ((*((pool)->ptr)++ = c), 1))
+
+#if ! defined(XML_TESTING)
+const
+#endif
+    XML_Bool g_reparseDeferralEnabledDefault
+    = XML_TRUE; // write ONLY in runtests.c
+#if defined(XML_TESTING)
+unsigned int g_bytesScanned = 0; // used for testing only
+#endif
+
+struct XML_ParserStruct {
+  /* The first member must be m_userData so that the XML_GetUserData
+     macro works. */
+  void *m_userData;
+  void *m_handlerArg;
+
+  // How the four parse buffer pointers below relate in time and space:
+  //
+  //   m_buffer <= m_bufferPtr <= m_bufferEnd  <= m_bufferLim
+  //   |           |              |               |
+  //   <--parsed-->|              |               |
+  //               <---parsing--->|               |
+  //                              <--unoccupied-->|
+  //   <---------total-malloced/realloced-------->|
+
+  char *m_buffer; // malloc/realloc base pointer of parse buffer
+  const XML_Memory_Handling_Suite m_mem;
+  const char *m_bufferPtr; // first character to be parsed
+  char *m_bufferEnd;       // past last character to be parsed
+  const char *m_bufferLim; // allocated end of m_buffer
+
+  XML_Index m_parseEndByteIndex;
+  const char *m_parseEndPtr;
+  size_t m_partialTokenBytesBefore; /* used in heuristic to avoid O(n^2) */
+  XML_Bool m_reparseDeferralEnabled;
+  int m_lastBufferRequestSize;
+  XML_Char *m_dataBuf;
+  XML_Char *m_dataBufEnd;
+  XML_StartElementHandler m_startElementHandler;
+  XML_EndElementHandler m_endElementHandler;
+  XML_CharacterDataHandler m_characterDataHandler;
+  XML_ProcessingInstructionHandler m_processingInstructionHandler;
+  XML_CommentHandler m_commentHandler;
+  XML_StartCdataSectionHandler m_startCdataSectionHandler;
+  XML_EndCdataSectionHandler m_endCdataSectionHandler;
+  XML_DefaultHandler m_defaultHandler;
+  XML_StartDoctypeDeclHandler m_startDoctypeDeclHandler;
+  XML_EndDoctypeDeclHandler m_endDoctypeDeclHandler;
+  XML_UnparsedEntityDeclHandler m_unparsedEntityDeclHandler;
+  XML_NotationDeclHandler m_notationDeclHandler;
+  XML_StartNamespaceDeclHandler m_startNamespaceDeclHandler;
+  XML_EndNamespaceDeclHandler m_endNamespaceDeclHandler;
+  XML_NotStandaloneHandler m_notStandaloneHandler;
+  XML_ExternalEntityRefHandler m_externalEntityRefHandler;
+  XML_Parser m_externalEntityRefHandlerArg;
+  XML_SkippedEntityHandler m_skippedEntityHandler;
+  XML_UnknownEncodingHandler m_unknownEncodingHandler;
+  XML_ElementDeclHandler m_elementDeclHandler;
+  XML_AttlistDeclHandler m_attlistDeclHandler;
+  XML_EntityDeclHandler m_entityDeclHandler;
+  XML_XmlDeclHandler m_xmlDeclHandler;
+  const ENCODING *m_encoding;
+  INIT_ENCODING m_initEncoding;
+  const ENCODING *m_internalEncoding;
+  const XML_Char *m_protocolEncodingName;
+  XML_Bool m_ns;
+  XML_Bool m_ns_triplets;
+  void *m_unknownEncodingMem;
+  void *m_unknownEncodingData;
+  void *m_unknownEncodingHandlerData;
+  void(XMLCALL *m_unknownEncodingRelease)(void *);
+  PROLOG_STATE m_prologState;
+  Processor *m_processor;
+  enum XML_Error m_errorCode;
+  const char *m_eventPtr;
+  const char *m_eventEndPtr;
+  const char *m_positionPtr;
+  OPEN_INTERNAL_ENTITY *m_openInternalEntities;
+  OPEN_INTERNAL_ENTITY *m_freeInternalEntities;
+  XML_Bool m_defaultExpandInternalEntities;
+  int m_tagLevel;
+  ENTITY *m_declEntity;
+  const XML_Char *m_doctypeName;
+  const XML_Char *m_doctypeSysid;
+  const XML_Char *m_doctypePubid;
+  const XML_Char *m_declAttributeType;
+  const XML_Char *m_declNotationName;
+  const XML_Char *m_declNotationPublicId;
+  ELEMENT_TYPE *m_declElementType;
+  ATTRIBUTE_ID *m_declAttributeId;
+  XML_Bool m_declAttributeIsCdata;
+  XML_Bool m_declAttributeIsId;
+  DTD *m_dtd;
+  const XML_Char *m_curBase;
+  TAG *m_tagStack;
+  TAG *m_freeTagList;
+  BINDING *m_inheritedBindings;
+  BINDING *m_freeBindingList;
+  int m_attsSize;
+  int m_nSpecifiedAtts;
+  int m_idAttIndex;
+  ATTRIBUTE *m_atts;
+  NS_ATT *m_nsAtts;
+  unsigned long m_nsAttsVersion;
+  unsigned char m_nsAttsPower;
+#ifdef XML_ATTR_INFO
+  XML_AttrInfo *m_attInfo;
+#endif
+  POSITION m_position;
+  STRING_POOL m_tempPool;
+  STRING_POOL m_temp2Pool;
+  char *m_groupConnector;
+  unsigned int m_groupSize;
+  XML_Char m_namespaceSeparator;
+  XML_Parser m_parentParser;
+  XML_ParsingStatus m_parsingStatus;
+#ifdef XML_DTD
+  XML_Bool m_isParamEntity;
+  XML_Bool m_useForeignDTD;
+  enum XML_ParamEntityParsing m_paramEntityParsing;
+#endif
+  unsigned long m_hash_secret_salt;
+#if XML_GE == 1
+  ACCOUNTING m_accounting;
+  ENTITY_STATS m_entity_stats;
+#endif
+};
+
+#define MALLOC(parser, s) (parser->m_mem.malloc_fcn((s)))
+#define REALLOC(parser, p, s) (parser->m_mem.realloc_fcn((p), (s)))
+#define FREE(parser, p) (parser->m_mem.free_fcn((p)))
+
+XML_Parser XMLCALL
+XML_ParserCreate(const XML_Char *encodingName) {
+  return XML_ParserCreate_MM(encodingName, NULL, NULL);
+}
+
+XML_Parser XMLCALL
+XML_ParserCreateNS(const XML_Char *encodingName, XML_Char nsSep) {
+  XML_Char tmp[2] = {nsSep, 0};
+  return XML_ParserCreate_MM(encodingName, NULL, tmp);
+}
+
+// "xml=http://www.w3.org/XML/1998/namespace"
+static const XML_Char implicitContext[]
+    = {ASCII_x,     ASCII_m,     ASCII_l,      ASCII_EQUALS, ASCII_h,
+       ASCII_t,     ASCII_t,     ASCII_p,      ASCII_COLON,  ASCII_SLASH,
+       ASCII_SLASH, ASCII_w,     ASCII_w,      ASCII_w,      ASCII_PERIOD,
+       ASCII_w,     ASCII_3,     ASCII_PERIOD, ASCII_o,      ASCII_r,
+       ASCII_g,     ASCII_SLASH, ASCII_X,      ASCII_M,      ASCII_L,
+       ASCII_SLASH, ASCII_1,     ASCII_9,      ASCII_9,      ASCII_8,
+       ASCII_SLASH, ASCII_n,     ASCII_a,      ASCII_m,      ASCII_e,
+       ASCII_s,     ASCII_p,     ASCII_a,      ASCII_c,      ASCII_e,
+       '\0'};
+
+/* To avoid warnings about unused functions: */
+#if ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM)
+
+#  if defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM)
+
+/* Obtain entropy on Linux 3.17+ */
+static int
+writeRandomBytes_getrandom_nonblock(void *target, size_t count) {
+  int success = 0; /* full count bytes written? */
+  size_t bytesWrittenTotal = 0;
+  const unsigned int getrandomFlags = GRND_NONBLOCK;
+
+  do {
+    void *const currentTarget = (void *)((char *)target + bytesWrittenTotal);
+    const size_t bytesToWrite = count - bytesWrittenTotal;
+
+    const int bytesWrittenMore =
+#    if defined(HAVE_GETRANDOM)
+        getrandom(currentTarget, bytesToWrite, getrandomFlags);
+#    else
+        syscall(SYS_getrandom, currentTarget, bytesToWrite, getrandomFlags);
+#    endif
+
+    if (bytesWrittenMore > 0) {
+      bytesWrittenTotal += bytesWrittenMore;
+      if (bytesWrittenTotal >= count)
+        success = 1;
+    }
+  } while (! success && (errno == EINTR));
+
+  return success;
+}
+
+#  endif /* defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM) */
+
+#  if ! defined(_WIN32) && defined(XML_DEV_URANDOM)
+
+/* Extract entropy from /dev/urandom */
+static int
+writeRandomBytes_dev_urandom(void *target, size_t count) {
+  int success = 0; /* full count bytes written? */
+  size_t bytesWrittenTotal = 0;
+
+  const int fd = open("/dev/urandom", O_RDONLY);
+  if (fd < 0) {
+    return 0;
+  }
+
+  do {
+    void *const currentTarget = (void *)((char *)target + bytesWrittenTotal);
+    const size_t bytesToWrite = count - bytesWrittenTotal;
+
+    const ssize_t bytesWrittenMore = read(fd, currentTarget, bytesToWrite);
+
+    if (bytesWrittenMore > 0) {
+      bytesWrittenTotal += bytesWrittenMore;
+      if (bytesWrittenTotal >= count)
+        success = 1;
+    }
+  } while (! success && (errno == EINTR));
+
+  close(fd);
+  return success;
+}
+
+#  endif /* ! defined(_WIN32) && defined(XML_DEV_URANDOM) */
+
+#endif /* ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM) */
+
+#if defined(HAVE_ARC4RANDOM) && ! defined(HAVE_ARC4RANDOM_BUF)
+
+static void
+writeRandomBytes_arc4random(void *target, size_t count) {
+  size_t bytesWrittenTotal = 0;
+
+  while (bytesWrittenTotal < count) {
+    const uint32_t random32 = arc4random();
+    size_t i = 0;
+
+    for (; (i < sizeof(random32)) && (bytesWrittenTotal < count);
+         i++, bytesWrittenTotal++) {
+      const uint8_t random8 = (uint8_t)(random32 >> (i * 8));
+      ((uint8_t *)target)[bytesWrittenTotal] = random8;
+    }
+  }
+}
+
+#endif /* defined(HAVE_ARC4RANDOM) && ! defined(HAVE_ARC4RANDOM_BUF) */
+
+#ifdef _WIN32
+
+/* Provide declaration of rand_s() for MinGW-32 (not 64, which has it),
+   as it didn't declare it in its header prior to version 5.3.0 of its
+   runtime package (mingwrt, containing stdlib.h).  The upstream fix
+   was introduced at https://osdn.net/projects/mingw/ticket/39658 . */
+#  if defined(__MINGW32__) && defined(__MINGW32_VERSION)                       \
+      && __MINGW32_VERSION < 5003000L && ! defined(__MINGW64_VERSION_MAJOR)
+__declspec(dllimport) int rand_s(unsigned int *);
+#  endif
+
+/* Obtain entropy on Windows using the rand_s() function which
+ * generates cryptographically secure random numbers.  Internally it
+ * uses RtlGenRandom API which is present in Windows XP and later.
+ */
+static int
+writeRandomBytes_rand_s(void *target, size_t count) {
+  size_t bytesWrittenTotal = 0;
+
+  while (bytesWrittenTotal < count) {
+    unsigned int random32 = 0;
+    size_t i = 0;
+
+    if (rand_s(&random32))
+      return 0; /* failure */
+
+    for (; (i < sizeof(random32)) && (bytesWrittenTotal < count);
+         i++, bytesWrittenTotal++) {
+      const uint8_t random8 = (uint8_t)(random32 >> (i * 8));
+      ((uint8_t *)target)[bytesWrittenTotal] = random8;
+    }
+  }
+  return 1; /* success */
+}
+
+#endif /* _WIN32 */
+
+#if ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM)
+
+static unsigned long
+gather_time_entropy(void) {
+#  ifdef _WIN32
+  FILETIME ft;
+  GetSystemTimeAsFileTime(&ft); /* never fails */
+  return ft.dwHighDateTime ^ ft.dwLowDateTime;
+#  else
+  struct timeval tv;
+  int gettimeofday_res;
+
+  gettimeofday_res = gettimeofday(&tv, NULL);
+
+#    if defined(NDEBUG)
+  (void)gettimeofday_res;
+#    else
+  assert(gettimeofday_res == 0);
+#    endif /* defined(NDEBUG) */
+
+  /* Microseconds time is <20 bits entropy */
+  return tv.tv_usec;
+#  endif
+}
+
+#endif /* ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM) */
+
+static unsigned long
+ENTROPY_DEBUG(const char *label, unsigned long entropy) {
+  if (getDebugLevel("EXPAT_ENTROPY_DEBUG", 0) >= 1u) {
+    fprintf(stderr, "expat: Entropy: %s --> 0x%0*lx (%lu bytes)\n", label,
+            (int)sizeof(entropy) * 2, entropy, (unsigned long)sizeof(entropy));
+  }
+  return entropy;
+}
+
+static unsigned long
+generate_hash_secret_salt(XML_Parser parser) {
+  unsigned long entropy;
+  (void)parser;
+
+  /* "Failproof" high quality providers: */
+#if defined(HAVE_ARC4RANDOM_BUF)
+  arc4random_buf(&entropy, sizeof(entropy));
+  return ENTROPY_DEBUG("arc4random_buf", entropy);
+#elif defined(HAVE_ARC4RANDOM)
+  writeRandomBytes_arc4random((void *)&entropy, sizeof(entropy));
+  return ENTROPY_DEBUG("arc4random", entropy);
+#else
+  /* Try high quality providers first .. */
+#  ifdef _WIN32
+  if (writeRandomBytes_rand_s((void *)&entropy, sizeof(entropy))) {
+    return ENTROPY_DEBUG("rand_s", entropy);
+  }
+#  elif defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM)
+  if (writeRandomBytes_getrandom_nonblock((void *)&entropy, sizeof(entropy))) {
+    return ENTROPY_DEBUG("getrandom", entropy);
+  }
+#  endif
+#  if ! defined(_WIN32) && defined(XML_DEV_URANDOM)
+  if (writeRandomBytes_dev_urandom((void *)&entropy, sizeof(entropy))) {
+    return ENTROPY_DEBUG("/dev/urandom", entropy);
+  }
+#  endif /* ! defined(_WIN32) && defined(XML_DEV_URANDOM) */
+  /* .. and self-made low quality for backup: */
+
+  /* Process ID is 0 bits entropy if attacker has local access */
+  entropy = gather_time_entropy() ^ getpid();
+
+  /* Factors are 2^31-1 and 2^61-1 (Mersenne primes M31 and M61) */
+  if (sizeof(unsigned long) == 4) {
+    return ENTROPY_DEBUG("fallback(4)", entropy * 2147483647);
+  } else {
+    return ENTROPY_DEBUG("fallback(8)",
+                         entropy * (unsigned long)2305843009213693951ULL);
+  }
+#endif
+}
+
+static unsigned long
+get_hash_secret_salt(XML_Parser parser) {
+  if (parser->m_parentParser != NULL)
+    return get_hash_secret_salt(parser->m_parentParser);
+  return parser->m_hash_secret_salt;
+}
+
+static enum XML_Error
+callProcessor(XML_Parser parser, const char *start, const char *end,
+              const char **endPtr) {
+  const size_t have_now = EXPAT_SAFE_PTR_DIFF(end, start);
+
+  if (parser->m_reparseDeferralEnabled
+      && ! parser->m_parsingStatus.finalBuffer) {
+    // Heuristic: don't try to parse a partial token again until the amount of
+    // available data has increased significantly.
+    const size_t had_before = parser->m_partialTokenBytesBefore;
+    // ...but *do* try anyway if we're close to causing a reallocation.
+    size_t available_buffer
+        = EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer);
+#if XML_CONTEXT_BYTES > 0
+    available_buffer -= EXPAT_MIN(available_buffer, XML_CONTEXT_BYTES);
+#endif
+    available_buffer
+        += EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_bufferEnd);
+    // m_lastBufferRequestSize is never assigned a value < 0, so the cast is ok
+    const bool enough
+        = (have_now >= 2 * had_before)
+          || ((size_t)parser->m_lastBufferRequestSize > available_buffer);
+
+    if (! enough) {
+      *endPtr = start; // callers may expect this to be set
+      return XML_ERROR_NONE;
+    }
+  }
+#if defined(XML_TESTING)
+  g_bytesScanned += (unsigned)have_now;
+#endif
+  const enum XML_Error ret = parser->m_processor(parser, start, end, endPtr);
+  if (ret == XML_ERROR_NONE) {
+    // if we consumed nothing, remember what we had on this parse attempt.
+    if (*endPtr == start) {
+      parser->m_partialTokenBytesBefore = have_now;
+    } else {
+      parser->m_partialTokenBytesBefore = 0;
+    }
+  }
+  return ret;
+}
+
+static XML_Bool /* only valid for root parser */
+startParsing(XML_Parser parser) {
+  /* hash functions must be initialized before setContext() is called */
+  if (parser->m_hash_secret_salt == 0)
+    parser->m_hash_secret_salt = generate_hash_secret_salt(parser);
+  if (parser->m_ns) {
+    /* implicit context only set for root parser, since child
+       parsers (i.e. external entity parsers) will inherit it
+    */
+    return setContext(parser, implicitContext);
+  }
+  return XML_TRUE;
+}
+
+XML_Parser XMLCALL
+XML_ParserCreate_MM(const XML_Char *encodingName,
+                    const XML_Memory_Handling_Suite *memsuite,
+                    const XML_Char *nameSep) {
+  return parserCreate(encodingName, memsuite, nameSep, NULL);
+}
+
+static XML_Parser
+parserCreate(const XML_Char *encodingName,
+             const XML_Memory_Handling_Suite *memsuite, const XML_Char *nameSep,
+             DTD *dtd) {
+  XML_Parser parser;
+
+  if (memsuite) {
+    XML_Memory_Handling_Suite *mtemp;
+    parser = memsuite->malloc_fcn(sizeof(struct XML_ParserStruct));
+    if (parser != NULL) {
+      mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);
+      mtemp->malloc_fcn = memsuite->malloc_fcn;
+      mtemp->realloc_fcn = memsuite->realloc_fcn;
+      mtemp->free_fcn = memsuite->free_fcn;
+    }
+  } else {
+    XML_Memory_Handling_Suite *mtemp;
+    parser = (XML_Parser)malloc(sizeof(struct XML_ParserStruct));
+    if (parser != NULL) {
+      mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);
+      mtemp->malloc_fcn = malloc;
+      mtemp->realloc_fcn = realloc;
+      mtemp->free_fcn = free;
+    }
+  }
+
+  if (! parser)
+    return parser;
+
+  parser->m_buffer = NULL;
+  parser->m_bufferLim = NULL;
+
+  parser->m_attsSize = INIT_ATTS_SIZE;
+  parser->m_atts
+      = (ATTRIBUTE *)MALLOC(parser, parser->m_attsSize * sizeof(ATTRIBUTE));
+  if (parser->m_atts == NULL) {
+    FREE(parser, parser);
+    return NULL;
+  }
+#ifdef XML_ATTR_INFO
+  parser->m_attInfo = (XML_AttrInfo *)MALLOC(
+      parser, parser->m_attsSize * sizeof(XML_AttrInfo));
+  if (parser->m_attInfo == NULL) {
+    FREE(parser, parser->m_atts);
+    FREE(parser, parser);
+    return NULL;
+  }
+#endif
+  parser->m_dataBuf
+      = (XML_Char *)MALLOC(parser, INIT_DATA_BUF_SIZE * sizeof(XML_Char));
+  if (parser->m_dataBuf == NULL) {
+    FREE(parser, parser->m_atts);
+#ifdef XML_ATTR_INFO
+    FREE(parser, parser->m_attInfo);
+#endif
+    FREE(parser, parser);
+    return NULL;
+  }
+  parser->m_dataBufEnd = parser->m_dataBuf + INIT_DATA_BUF_SIZE;
+
+  if (dtd)
+    parser->m_dtd = dtd;
+  else {
+    parser->m_dtd = dtdCreate(&parser->m_mem);
+    if (parser->m_dtd == NULL) {
+      FREE(parser, parser->m_dataBuf);
+      FREE(parser, parser->m_atts);
+#ifdef XML_ATTR_INFO
+      FREE(parser, parser->m_attInfo);
+#endif
+      FREE(parser, parser);
+      return NULL;
+    }
+  }
+
+  parser->m_freeBindingList = NULL;
+  parser->m_freeTagList = NULL;
+  parser->m_freeInternalEntities = NULL;
+
+  parser->m_groupSize = 0;
+  parser->m_groupConnector = NULL;
+
+  parser->m_unknownEncodingHandler = NULL;
+  parser->m_unknownEncodingHandlerData = NULL;
+
+  parser->m_namespaceSeparator = ASCII_EXCL;
+  parser->m_ns = XML_FALSE;
+  parser->m_ns_triplets = XML_FALSE;
+
+  parser->m_nsAtts = NULL;
+  parser->m_nsAttsVersion = 0;
+  parser->m_nsAttsPower = 0;
+
+  parser->m_protocolEncodingName = NULL;
+
+  poolInit(&parser->m_tempPool, &(parser->m_mem));
+  poolInit(&parser->m_temp2Pool, &(parser->m_mem));
+  parserInit(parser, encodingName);
+
+  if (encodingName && ! parser->m_protocolEncodingName) {
+    if (dtd) {
+      // We need to stop the upcoming call to XML_ParserFree from happily
+      // destroying parser->m_dtd because the DTD is shared with the parent
+      // parser and the only guard that keeps XML_ParserFree from destroying
+      // parser->m_dtd is parser->m_isParamEntity but it will be set to
+      // XML_TRUE only later in XML_ExternalEntityParserCreate (or not at all).
+      parser->m_dtd = NULL;
+    }
+    XML_ParserFree(parser);
+    return NULL;
+  }
+
+  if (nameSep) {
+    parser->m_ns = XML_TRUE;
+    parser->m_internalEncoding = XmlGetInternalEncodingNS();
+    parser->m_namespaceSeparator = *nameSep;
+  } else {
+    parser->m_internalEncoding = XmlGetInternalEncoding();
+  }
+
+  return parser;
+}
+
+static void
+parserInit(XML_Parser parser, const XML_Char *encodingName) {
+  parser->m_processor = prologInitProcessor;
+  XmlPrologStateInit(&parser->m_prologState);
+  if (encodingName != NULL) {
+    parser->m_protocolEncodingName = copyString(encodingName, &(parser->m_mem));
+  }
+  parser->m_curBase = NULL;
+  XmlInitEncoding(&parser->m_initEncoding, &parser->m_encoding, 0);
+  parser->m_userData = NULL;
+  parser->m_handlerArg = NULL;
+  parser->m_startElementHandler = NULL;
+  parser->m_endElementHandler = NULL;
+  parser->m_characterDataHandler = NULL;
+  parser->m_processingInstructionHandler = NULL;
+  parser->m_commentHandler = NULL;
+  parser->m_startCdataSectionHandler = NULL;
+  parser->m_endCdataSectionHandler = NULL;
+  parser->m_defaultHandler = NULL;
+  parser->m_startDoctypeDeclHandler = NULL;
+  parser->m_endDoctypeDeclHandler = NULL;
+  parser->m_unparsedEntityDeclHandler = NULL;
+  parser->m_notationDeclHandler = NULL;
+  parser->m_startNamespaceDeclHandler = NULL;
+  parser->m_endNamespaceDeclHandler = NULL;
+  parser->m_notStandaloneHandler = NULL;
+  parser->m_externalEntityRefHandler = NULL;
+  parser->m_externalEntityRefHandlerArg = parser;
+  parser->m_skippedEntityHandler = NULL;
+  parser->m_elementDeclHandler = NULL;
+  parser->m_attlistDeclHandler = NULL;
+  parser->m_entityDeclHandler = NULL;
+  parser->m_xmlDeclHandler = NULL;
+  parser->m_bufferPtr = parser->m_buffer;
+  parser->m_bufferEnd = parser->m_buffer;
+  parser->m_parseEndByteIndex = 0;
+  parser->m_parseEndPtr = NULL;
+  parser->m_partialTokenBytesBefore = 0;
+  parser->m_reparseDeferralEnabled = g_reparseDeferralEnabledDefault;
+  parser->m_lastBufferRequestSize = 0;
+  parser->m_declElementType = NULL;
+  parser->m_declAttributeId = NULL;
+  parser->m_declEntity = NULL;
+  parser->m_doctypeName = NULL;
+  parser->m_doctypeSysid = NULL;
+  parser->m_doctypePubid = NULL;
+  parser->m_declAttributeType = NULL;
+  parser->m_declNotationName = NULL;
+  parser->m_declNotationPublicId = NULL;
+  parser->m_declAttributeIsCdata = XML_FALSE;
+  parser->m_declAttributeIsId = XML_FALSE;
+  memset(&parser->m_position, 0, sizeof(POSITION));
+  parser->m_errorCode = XML_ERROR_NONE;
+  parser->m_eventPtr = NULL;
+  parser->m_eventEndPtr = NULL;
+  parser->m_positionPtr = NULL;
+  parser->m_openInternalEntities = NULL;
+  parser->m_defaultExpandInternalEntities = XML_TRUE;
+  parser->m_tagLevel = 0;
+  parser->m_tagStack = NULL;
+  parser->m_inheritedBindings = NULL;
+  parser->m_nSpecifiedAtts = 0;
+  parser->m_unknownEncodingMem = NULL;
+  parser->m_unknownEncodingRelease = NULL;
+  parser->m_unknownEncodingData = NULL;
+  parser->m_parentParser = NULL;
+  parser->m_parsingStatus.parsing = XML_INITIALIZED;
+#ifdef XML_DTD
+  parser->m_isParamEntity = XML_FALSE;
+  parser->m_useForeignDTD = XML_FALSE;
+  parser->m_paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
+#endif
+  parser->m_hash_secret_salt = 0;
+
+#if XML_GE == 1
+  memset(&parser->m_accounting, 0, sizeof(ACCOUNTING));
+  parser->m_accounting.debugLevel = getDebugLevel("EXPAT_ACCOUNTING_DEBUG", 0u);
+  parser->m_accounting.maximumAmplificationFactor
+      = EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_MAXIMUM_AMPLIFICATION_DEFAULT;
+  parser->m_accounting.activationThresholdBytes
+      = EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_ACTIVATION_THRESHOLD_DEFAULT;
+
+  memset(&parser->m_entity_stats, 0, sizeof(ENTITY_STATS));
+  parser->m_entity_stats.debugLevel = getDebugLevel("EXPAT_ENTITY_DEBUG", 0u);
+#endif
+}
+
+/* moves list of bindings to m_freeBindingList */
+static void FASTCALL
+moveToFreeBindingList(XML_Parser parser, BINDING *bindings) {
+  while (bindings) {
+    BINDING *b = bindings;
+    bindings = bindings->nextTagBinding;
+    b->nextTagBinding = parser->m_freeBindingList;
+    parser->m_freeBindingList = b;
+  }
+}
+
+XML_Bool XMLCALL
+XML_ParserReset(XML_Parser parser, const XML_Char *encodingName) {
+  TAG *tStk;
+  OPEN_INTERNAL_ENTITY *openEntityList;
+
+  if (parser == NULL)
+    return XML_FALSE;
+
+  if (parser->m_parentParser)
+    return XML_FALSE;
+  /* move m_tagStack to m_freeTagList */
+  tStk = parser->m_tagStack;
+  while (tStk) {
+    TAG *tag = tStk;
+    tStk = tStk->parent;
+    tag->parent = parser->m_freeTagList;
+    moveToFreeBindingList(parser, tag->bindings);
+    tag->bindings = NULL;
+    parser->m_freeTagList = tag;
+  }
+  /* move m_openInternalEntities to m_freeInternalEntities */
+  openEntityList = parser->m_openInternalEntities;
+  while (openEntityList) {
+    OPEN_INTERNAL_ENTITY *openEntity = openEntityList;
+    openEntityList = openEntity->next;
+    openEntity->next = parser->m_freeInternalEntities;
+    parser->m_freeInternalEntities = openEntity;
+  }
+  moveToFreeBindingList(parser, parser->m_inheritedBindings);
+  FREE(parser, parser->m_unknownEncodingMem);
+  if (parser->m_unknownEncodingRelease)
+    parser->m_unknownEncodingRelease(parser->m_unknownEncodingData);
+  poolClear(&parser->m_tempPool);
+  poolClear(&parser->m_temp2Pool);
+  FREE(parser, (void *)parser->m_protocolEncodingName);
+  parser->m_protocolEncodingName = NULL;
+  parserInit(parser, encodingName);
+  dtdReset(parser->m_dtd, &parser->m_mem);
+  return XML_TRUE;
+}
+
+enum XML_Status XMLCALL
+XML_SetEncoding(XML_Parser parser, const XML_Char *encodingName) {
+  if (parser == NULL)
+    return XML_STATUS_ERROR;
+  /* Block after XML_Parse()/XML_ParseBuffer() has been called.
+     XXX There's no way for the caller to determine which of the
+     XXX possible error cases caused the XML_STATUS_ERROR return.
+  */
+  if (parser->m_parsingStatus.parsing == XML_PARSING
+      || parser->m_parsingStatus.parsing == XML_SUSPENDED)
+    return XML_STATUS_ERROR;
+
+  /* Get rid of any previous encoding name */
+  FREE(parser, (void *)parser->m_protocolEncodingName);
+
+  if (encodingName == NULL)
+    /* No new encoding name */
+    parser->m_protocolEncodingName = NULL;
+  else {
+    /* Copy the new encoding name into allocated memory */
+    parser->m_protocolEncodingName = copyString(encodingName, &(parser->m_mem));
+    if (! parser->m_protocolEncodingName)
+      return XML_STATUS_ERROR;
+  }
+  return XML_STATUS_OK;
+}
+
+XML_Parser XMLCALL
+XML_ExternalEntityParserCreate(XML_Parser oldParser, const XML_Char *context,
+                               const XML_Char *encodingName) {
+  XML_Parser parser = oldParser;
+  DTD *newDtd = NULL;
+  DTD *oldDtd;
+  XML_StartElementHandler oldStartElementHandler;
+  XML_EndElementHandler oldEndElementHandler;
+  XML_CharacterDataHandler oldCharacterDataHandler;
+  XML_ProcessingInstructionHandler oldProcessingInstructionHandler;
+  XML_CommentHandler oldCommentHandler;
+  XML_StartCdataSectionHandler oldStartCdataSectionHandler;
+  XML_EndCdataSectionHandler oldEndCdataSectionHandler;
+  XML_DefaultHandler oldDefaultHandler;
+  XML_UnparsedEntityDeclHandler oldUnparsedEntityDeclHandler;
+  XML_NotationDeclHandler oldNotationDeclHandler;
+  XML_StartNamespaceDeclHandler oldStartNamespaceDeclHandler;
+  XML_EndNamespaceDeclHandler oldEndNamespaceDeclHandler;
+  XML_NotStandaloneHandler oldNotStandaloneHandler;
+  XML_ExternalEntityRefHandler oldExternalEntityRefHandler;
+  XML_SkippedEntityHandler oldSkippedEntityHandler;
+  XML_UnknownEncodingHandler oldUnknownEncodingHandler;
+  XML_ElementDeclHandler oldElementDeclHandler;
+  XML_AttlistDeclHandler oldAttlistDeclHandler;
+  XML_EntityDeclHandler oldEntityDeclHandler;
+  XML_XmlDeclHandler oldXmlDeclHandler;
+  ELEMENT_TYPE *oldDeclElementType;
+
+  void *oldUserData;
+  void *oldHandlerArg;
+  XML_Bool oldDefaultExpandInternalEntities;
+  XML_Parser oldExternalEntityRefHandlerArg;
+#ifdef XML_DTD
+  enum XML_ParamEntityParsing oldParamEntityParsing;
+  int oldInEntityValue;
+#endif
+  XML_Bool oldns_triplets;
+  /* Note that the new parser shares the same hash secret as the old
+     parser, so that dtdCopy and copyEntityTable can lookup values
+     from hash tables associated with either parser without us having
+     to worry which hash secrets each table has.
+  */
+  unsigned long oldhash_secret_salt;
+  XML_Bool oldReparseDeferralEnabled;
+
+  /* Validate the oldParser parameter before we pull everything out of it */
+  if (oldParser == NULL)
+    return NULL;
+
+  /* Stash the original parser contents on the stack */
+  oldDtd = parser->m_dtd;
+  oldStartElementHandler = parser->m_startElementHandler;
+  oldEndElementHandler = parser->m_endElementHandler;
+  oldCharacterDataHandler = parser->m_characterDataHandler;
+  oldProcessingInstructionHandler = parser->m_processingInstructionHandler;
+  oldCommentHandler = parser->m_commentHandler;
+  oldStartCdataSectionHandler = parser->m_startCdataSectionHandler;
+  oldEndCdataSectionHandler = parser->m_endCdataSectionHandler;
+  oldDefaultHandler = parser->m_defaultHandler;
+  oldUnparsedEntityDeclHandler = parser->m_unparsedEntityDeclHandler;
+  oldNotationDeclHandler = parser->m_notationDeclHandler;
+  oldStartNamespaceDeclHandler = parser->m_startNamespaceDeclHandler;
+  oldEndNamespaceDeclHandler = parser->m_endNamespaceDeclHandler;
+  oldNotStandaloneHandler = parser->m_notStandaloneHandler;
+  oldExternalEntityRefHandler = parser->m_externalEntityRefHandler;
+  oldSkippedEntityHandler = parser->m_skippedEntityHandler;
+  oldUnknownEncodingHandler = parser->m_unknownEncodingHandler;
+  oldElementDeclHandler = parser->m_elementDeclHandler;
+  oldAttlistDeclHandler = parser->m_attlistDeclHandler;
+  oldEntityDeclHandler = parser->m_entityDeclHandler;
+  oldXmlDeclHandler = parser->m_xmlDeclHandler;
+  oldDeclElementType = parser->m_declElementType;
+
+  oldUserData = parser->m_userData;
+  oldHandlerArg = parser->m_handlerArg;
+  oldDefaultExpandInternalEntities = parser->m_defaultExpandInternalEntities;
+  oldExternalEntityRefHandlerArg = parser->m_externalEntityRefHandlerArg;
+#ifdef XML_DTD
+  oldParamEntityParsing = parser->m_paramEntityParsing;
+  oldInEntityValue = parser->m_prologState.inEntityValue;
+#endif
+  oldns_triplets = parser->m_ns_triplets;
+  /* Note that the new parser shares the same hash secret as the old
+     parser, so that dtdCopy and copyEntityTable can lookup values
+     from hash tables associated with either parser without us having
+     to worry which hash secrets each table has.
+  */
+  oldhash_secret_salt = parser->m_hash_secret_salt;
+  oldReparseDeferralEnabled = parser->m_reparseDeferralEnabled;
+
+#ifdef XML_DTD
+  if (! context)
+    newDtd = oldDtd;
+#endif /* XML_DTD */
+
+  /* Note that the magical uses of the pre-processor to make field
+     access look more like C++ require that `parser' be overwritten
+     here.  This makes this function more painful to follow than it
+     would be otherwise.
+  */
+  if (parser->m_ns) {
+    XML_Char tmp[2] = {parser->m_namespaceSeparator, 0};
+    parser = parserCreate(encodingName, &parser->m_mem, tmp, newDtd);
+  } else {
+    parser = parserCreate(encodingName, &parser->m_mem, NULL, newDtd);
+  }
+
+  if (! parser)
+    return NULL;
+
+  parser->m_startElementHandler = oldStartElementHandler;
+  parser->m_endElementHandler = oldEndElementHandler;
+  parser->m_characterDataHandler = oldCharacterDataHandler;
+  parser->m_processingInstructionHandler = oldProcessingInstructionHandler;
+  parser->m_commentHandler = oldCommentHandler;
+  parser->m_startCdataSectionHandler = oldStartCdataSectionHandler;
+  parser->m_endCdataSectionHandler = oldEndCdataSectionHandler;
+  parser->m_defaultHandler = oldDefaultHandler;
+  parser->m_unparsedEntityDeclHandler = oldUnparsedEntityDeclHandler;
+  parser->m_notationDeclHandler = oldNotationDeclHandler;
+  parser->m_startNamespaceDeclHandler = oldStartNamespaceDeclHandler;
+  parser->m_endNamespaceDeclHandler = oldEndNamespaceDeclHandler;
+  parser->m_notStandaloneHandler = oldNotStandaloneHandler;
+  parser->m_externalEntityRefHandler = oldExternalEntityRefHandler;
+  parser->m_skippedEntityHandler = oldSkippedEntityHandler;
+  parser->m_unknownEncodingHandler = oldUnknownEncodingHandler;
+  parser->m_elementDeclHandler = oldElementDeclHandler;
+  parser->m_attlistDeclHandler = oldAttlistDeclHandler;
+  parser->m_entityDeclHandler = oldEntityDeclHandler;
+  parser->m_xmlDeclHandler = oldXmlDeclHandler;
+  parser->m_declElementType = oldDeclElementType;
+  parser->m_userData = oldUserData;
+  if (oldUserData == oldHandlerArg)
+    parser->m_handlerArg = parser->m_userData;
+  else
+    parser->m_handlerArg = parser;
+  if (oldExternalEntityRefHandlerArg != oldParser)
+    parser->m_externalEntityRefHandlerArg = oldExternalEntityRefHandlerArg;
+  parser->m_defaultExpandInternalEntities = oldDefaultExpandInternalEntities;
+  parser->m_ns_triplets = oldns_triplets;
+  parser->m_hash_secret_salt = oldhash_secret_salt;
+  parser->m_reparseDeferralEnabled = oldReparseDeferralEnabled;
+  parser->m_parentParser = oldParser;
+#ifdef XML_DTD
+  parser->m_paramEntityParsing = oldParamEntityParsing;
+  parser->m_prologState.inEntityValue = oldInEntityValue;
+  if (context) {
+#endif /* XML_DTD */
+    if (! dtdCopy(oldParser, parser->m_dtd, oldDtd, &parser->m_mem)
+        || ! setContext(parser, context)) {
+      XML_ParserFree(parser);
+      return NULL;
+    }
+    parser->m_processor = externalEntityInitProcessor;
+#ifdef XML_DTD
+  } else {
+    /* The DTD instance referenced by parser->m_dtd is shared between the
+       document's root parser and external PE parsers, therefore one does not
+       need to call setContext. In addition, one also *must* not call
+       setContext, because this would overwrite existing prefix->binding
+       pointers in parser->m_dtd with ones that get destroyed with the external
+       PE parser. This would leave those prefixes with dangling pointers.
+    */
+    parser->m_isParamEntity = XML_TRUE;
+    XmlPrologStateInitExternalEntity(&parser->m_prologState);
+    parser->m_processor = externalParEntInitProcessor;
+  }
+#endif /* XML_DTD */
+  return parser;
+}
+
+static void FASTCALL
+destroyBindings(BINDING *bindings, XML_Parser parser) {
+  for (;;) {
+    BINDING *b = bindings;
+    if (! b)
+      break;
+    bindings = b->nextTagBinding;
+    FREE(parser, b->uri);
+    FREE(parser, b);
+  }
+}
+
+void XMLCALL
+XML_ParserFree(XML_Parser parser) {
+  TAG *tagList;
+  OPEN_INTERNAL_ENTITY *entityList;
+  if (parser == NULL)
+    return;
+  /* free m_tagStack and m_freeTagList */
+  tagList = parser->m_tagStack;
+  for (;;) {
+    TAG *p;
+    if (tagList == NULL) {
+      if (parser->m_freeTagList == NULL)
+        break;
+      tagList = parser->m_freeTagList;
+      parser->m_freeTagList = NULL;
+    }
+    p = tagList;
+    tagList = tagList->parent;
+    FREE(parser, p->buf);
+    destroyBindings(p->bindings, parser);
+    FREE(parser, p);
+  }
+  /* free m_openInternalEntities and m_freeInternalEntities */
+  entityList = parser->m_openInternalEntities;
+  for (;;) {
+    OPEN_INTERNAL_ENTITY *openEntity;
+    if (entityList == NULL) {
+      if (parser->m_freeInternalEntities == NULL)
+        break;
+      entityList = parser->m_freeInternalEntities;
+      parser->m_freeInternalEntities = NULL;
+    }
+    openEntity = entityList;
+    entityList = entityList->next;
+    FREE(parser, openEntity);
+  }
+
+  destroyBindings(parser->m_freeBindingList, parser);
+  destroyBindings(parser->m_inheritedBindings, parser);
+  poolDestroy(&parser->m_tempPool);
+  poolDestroy(&parser->m_temp2Pool);
+  FREE(parser, (void *)parser->m_protocolEncodingName);
+#ifdef XML_DTD
+  /* external parameter entity parsers share the DTD structure
+     parser->m_dtd with the root parser, so we must not destroy it
+  */
+  if (! parser->m_isParamEntity && parser->m_dtd)
+#else
+  if (parser->m_dtd)
+#endif /* XML_DTD */
+    dtdDestroy(parser->m_dtd, (XML_Bool)! parser->m_parentParser,
+               &parser->m_mem);
+  FREE(parser, (void *)parser->m_atts);
+#ifdef XML_ATTR_INFO
+  FREE(parser, (void *)parser->m_attInfo);
+#endif
+  FREE(parser, parser->m_groupConnector);
+  FREE(parser, parser->m_buffer);
+  FREE(parser, parser->m_dataBuf);
+  FREE(parser, parser->m_nsAtts);
+  FREE(parser, parser->m_unknownEncodingMem);
+  if (parser->m_unknownEncodingRelease)
+    parser->m_unknownEncodingRelease(parser->m_unknownEncodingData);
+  FREE(parser, parser);
+}
+
+void XMLCALL
+XML_UseParserAsHandlerArg(XML_Parser parser) {
+  if (parser != NULL)
+    parser->m_handlerArg = parser;
+}
+
+enum XML_Error XMLCALL
+XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD) {
+  if (parser == NULL)
+    return XML_ERROR_INVALID_ARGUMENT;
+#ifdef XML_DTD
+  /* block after XML_Parse()/XML_ParseBuffer() has been called */
+  if (parser->m_parsingStatus.parsing == XML_PARSING
+      || parser->m_parsingStatus.parsing == XML_SUSPENDED)
+    return XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING;
+  parser->m_useForeignDTD = useDTD;
+  return XML_ERROR_NONE;
+#else
+  UNUSED_P(useDTD);
+  return XML_ERROR_FEATURE_REQUIRES_XML_DTD;
+#endif
+}
+
+void XMLCALL
+XML_SetReturnNSTriplet(XML_Parser parser, int do_nst) {
+  if (parser == NULL)
+    return;
+  /* block after XML_Parse()/XML_ParseBuffer() has been called */
+  if (parser->m_parsingStatus.parsing == XML_PARSING
+      || parser->m_parsingStatus.parsing == XML_SUSPENDED)
+    return;
+  parser->m_ns_triplets = do_nst ? XML_TRUE : XML_FALSE;
+}
+
+void XMLCALL
+XML_SetUserData(XML_Parser parser, void *p) {
+  if (parser == NULL)
+    return;
+  if (parser->m_handlerArg == parser->m_userData)
+    parser->m_handlerArg = parser->m_userData = p;
+  else
+    parser->m_userData = p;
+}
+
+enum XML_Status XMLCALL
+XML_SetBase(XML_Parser parser, const XML_Char *p) {
+  if (parser == NULL)
+    return XML_STATUS_ERROR;
+  if (p) {
+    p = poolCopyString(&parser->m_dtd->pool, p);
+    if (! p)
+      return XML_STATUS_ERROR;
+    parser->m_curBase = p;
+  } else
+    parser->m_curBase = NULL;
+  return XML_STATUS_OK;
+}
+
+const XML_Char *XMLCALL
+XML_GetBase(XML_Parser parser) {
+  if (parser == NULL)
+    return NULL;
+  return parser->m_curBase;
+}
+
+int XMLCALL
+XML_GetSpecifiedAttributeCount(XML_Parser parser) {
+  if (parser == NULL)
+    return -1;
+  return parser->m_nSpecifiedAtts;
+}
+
+int XMLCALL
+XML_GetIdAttributeIndex(XML_Parser parser) {
+  if (parser == NULL)
+    return -1;
+  return parser->m_idAttIndex;
+}
+
+#ifdef XML_ATTR_INFO
+const XML_AttrInfo *XMLCALL
+XML_GetAttributeInfo(XML_Parser parser) {
+  if (parser == NULL)
+    return NULL;
+  return parser->m_attInfo;
+}
+#endif
+
+void XMLCALL
+XML_SetElementHandler(XML_Parser parser, XML_StartElementHandler start,
+                      XML_EndElementHandler end) {
+  if (parser == NULL)
+    return;
+  parser->m_startElementHandler = start;
+  parser->m_endElementHandler = end;
+}
+
+void XMLCALL
+XML_SetStartElementHandler(XML_Parser parser, XML_StartElementHandler start) {
+  if (parser != NULL)
+    parser->m_startElementHandler = start;
+}
+
+void XMLCALL
+XML_SetEndElementHandler(XML_Parser parser, XML_EndElementHandler end) {
+  if (parser != NULL)
+    parser->m_endElementHandler = end;
+}
+
+void XMLCALL
+XML_SetCharacterDataHandler(XML_Parser parser,
+                            XML_CharacterDataHandler handler) {
+  if (parser != NULL)
+    parser->m_characterDataHandler = handler;
+}
+
+void XMLCALL
+XML_SetProcessingInstructionHandler(XML_Parser parser,
+                                    XML_ProcessingInstructionHandler handler) {
+  if (parser != NULL)
+    parser->m_processingInstructionHandler = handler;
+}
+
+void XMLCALL
+XML_SetCommentHandler(XML_Parser parser, XML_CommentHandler handler) {
+  if (parser != NULL)
+    parser->m_commentHandler = handler;
+}
+
+void XMLCALL
+XML_SetCdataSectionHandler(XML_Parser parser,
+                           XML_StartCdataSectionHandler start,
+                           XML_EndCdataSectionHandler end) {
+  if (parser == NULL)
+    return;
+  parser->m_startCdataSectionHandler = start;
+  parser->m_endCdataSectionHandler = end;
+}
+
+void XMLCALL
+XML_SetStartCdataSectionHandler(XML_Parser parser,
+                                XML_StartCdataSectionHandler start) {
+  if (parser != NULL)
+    parser->m_startCdataSectionHandler = start;
+}
+
+void XMLCALL
+XML_SetEndCdataSectionHandler(XML_Parser parser,
+                              XML_EndCdataSectionHandler end) {
+  if (parser != NULL)
+    parser->m_endCdataSectionHandler = end;
+}
+
+void XMLCALL
+XML_SetDefaultHandler(XML_Parser parser, XML_DefaultHandler handler) {
+  if (parser == NULL)
+    return;
+  parser->m_defaultHandler = handler;
+  parser->m_defaultExpandInternalEntities = XML_FALSE;
+}
+
+void XMLCALL
+XML_SetDefaultHandlerExpand(XML_Parser parser, XML_DefaultHandler handler) {
+  if (parser == NULL)
+    return;
+  parser->m_defaultHandler = handler;
+  parser->m_defaultExpandInternalEntities = XML_TRUE;
+}
+
+void XMLCALL
+XML_SetDoctypeDeclHandler(XML_Parser parser, XML_StartDoctypeDeclHandler start,
+                          XML_EndDoctypeDeclHandler end) {
+  if (parser == NULL)
+    return;
+  parser->m_startDoctypeDeclHandler = start;
+  parser->m_endDoctypeDeclHandler = end;
+}
+
+void XMLCALL
+XML_SetStartDoctypeDeclHandler(XML_Parser parser,
+                               XML_StartDoctypeDeclHandler start) {
+  if (parser != NULL)
+    parser->m_startDoctypeDeclHandler = start;
+}
+
+void XMLCALL
+XML_SetEndDoctypeDeclHandler(XML_Parser parser, XML_EndDoctypeDeclHandler end) {
+  if (parser != NULL)
+    parser->m_endDoctypeDeclHandler = end;
+}
+
+void XMLCALL
+XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
+                                 XML_UnparsedEntityDeclHandler handler) {
+  if (parser != NULL)
+    parser->m_unparsedEntityDeclHandler = handler;
+}
+
+void XMLCALL
+XML_SetNotationDeclHandler(XML_Parser parser, XML_NotationDeclHandler handler) {
+  if (parser != NULL)
+    parser->m_notationDeclHandler = handler;
+}
+
+void XMLCALL
+XML_SetNamespaceDeclHandler(XML_Parser parser,
+                            XML_StartNamespaceDeclHandler start,
+                            XML_EndNamespaceDeclHandler end) {
+  if (parser == NULL)
+    return;
+  parser->m_startNamespaceDeclHandler = start;
+  parser->m_endNamespaceDeclHandler = end;
+}
+
+void XMLCALL
+XML_SetStartNamespaceDeclHandler(XML_Parser parser,
+                                 XML_StartNamespaceDeclHandler start) {
+  if (parser != NULL)
+    parser->m_startNamespaceDeclHandler = start;
+}
+
+void XMLCALL
+XML_SetEndNamespaceDeclHandler(XML_Parser parser,
+                               XML_EndNamespaceDeclHandler end) {
+  if (parser != NULL)
+    parser->m_endNamespaceDeclHandler = end;
+}
+
+void XMLCALL
+XML_SetNotStandaloneHandler(XML_Parser parser,
+                            XML_NotStandaloneHandler handler) {
+  if (parser != NULL)
+    parser->m_notStandaloneHandler = handler;
+}
+
+void XMLCALL
+XML_SetExternalEntityRefHandler(XML_Parser parser,
+                                XML_ExternalEntityRefHandler handler) {
+  if (parser != NULL)
+    parser->m_externalEntityRefHandler = handler;
+}
+
+void XMLCALL
+XML_SetExternalEntityRefHandlerArg(XML_Parser parser, void *arg) {
+  if (parser == NULL)
+    return;
+  if (arg)
+    parser->m_externalEntityRefHandlerArg = (XML_Parser)arg;
+  else
+    parser->m_externalEntityRefHandlerArg = parser;
+}
+
+void XMLCALL
+XML_SetSkippedEntityHandler(XML_Parser parser,
+                            XML_SkippedEntityHandler handler) {
+  if (parser != NULL)
+    parser->m_skippedEntityHandler = handler;
+}
+
+void XMLCALL
+XML_SetUnknownEncodingHandler(XML_Parser parser,
+                              XML_UnknownEncodingHandler handler, void *data) {
+  if (parser == NULL)
+    return;
+  parser->m_unknownEncodingHandler = handler;
+  parser->m_unknownEncodingHandlerData = data;
+}
+
+void XMLCALL
+XML_SetElementDeclHandler(XML_Parser parser, XML_ElementDeclHandler eldecl) {
+  if (parser != NULL)
+    parser->m_elementDeclHandler = eldecl;
+}
+
+void XMLCALL
+XML_SetAttlistDeclHandler(XML_Parser parser, XML_AttlistDeclHandler attdecl) {
+  if (parser != NULL)
+    parser->m_attlistDeclHandler = attdecl;
+}
+
+void XMLCALL
+XML_SetEntityDeclHandler(XML_Parser parser, XML_EntityDeclHandler handler) {
+  if (parser != NULL)
+    parser->m_entityDeclHandler = handler;
+}
+
+void XMLCALL
+XML_SetXmlDeclHandler(XML_Parser parser, XML_XmlDeclHandler handler) {
+  if (parser != NULL)
+    parser->m_xmlDeclHandler = handler;
+}
+
+int XMLCALL
+XML_SetParamEntityParsing(XML_Parser parser,
+                          enum XML_ParamEntityParsing peParsing) {
+  if (parser == NULL)
+    return 0;
+  /* block after XML_Parse()/XML_ParseBuffer() has been called */
+  if (parser->m_parsingStatus.parsing == XML_PARSING
+      || parser->m_parsingStatus.parsing == XML_SUSPENDED)
+    return 0;
+#ifdef XML_DTD
+  parser->m_paramEntityParsing = peParsing;
+  return 1;
+#else
+  return peParsing == XML_PARAM_ENTITY_PARSING_NEVER;
+#endif
+}
+
+int XMLCALL
+XML_SetHashSalt(XML_Parser parser, unsigned long hash_salt) {
+  if (parser == NULL)
+    return 0;
+  if (parser->m_parentParser)
+    return XML_SetHashSalt(parser->m_parentParser, hash_salt);
+  /* block after XML_Parse()/XML_ParseBuffer() has been called */
+  if (parser->m_parsingStatus.parsing == XML_PARSING
+      || parser->m_parsingStatus.parsing == XML_SUSPENDED)
+    return 0;
+  parser->m_hash_secret_salt = hash_salt;
+  return 1;
+}
+
+enum XML_Status XMLCALL
+XML_Parse(XML_Parser parser, const char *s, int len, int isFinal) {
+  if ((parser == NULL) || (len < 0) || ((s == NULL) && (len != 0))) {
+    if (parser != NULL)
+      parser->m_errorCode = XML_ERROR_INVALID_ARGUMENT;
+    return XML_STATUS_ERROR;
+  }
+  switch (parser->m_parsingStatus.parsing) {
+  case XML_SUSPENDED:
+    parser->m_errorCode = XML_ERROR_SUSPENDED;
+    return XML_STATUS_ERROR;
+  case XML_FINISHED:
+    parser->m_errorCode = XML_ERROR_FINISHED;
+    return XML_STATUS_ERROR;
+  case XML_INITIALIZED:
+    if (parser->m_parentParser == NULL && ! startParsing(parser)) {
+      parser->m_errorCode = XML_ERROR_NO_MEMORY;
+      return XML_STATUS_ERROR;
+    }
+    /* fall through */
+  default:
+    parser->m_parsingStatus.parsing = XML_PARSING;
+  }
+
+#if XML_CONTEXT_BYTES == 0
+  if (parser->m_bufferPtr == parser->m_bufferEnd) {
+    const char *end;
+    int nLeftOver;
+    enum XML_Status result;
+    /* Detect overflow (a+b > MAX <==> b > MAX-a) */
+    if ((XML_Size)len > ((XML_Size)-1) / 2 - parser->m_parseEndByteIndex) {
+      parser->m_errorCode = XML_ERROR_NO_MEMORY;
+      parser->m_eventPtr = parser->m_eventEndPtr = NULL;
+      parser->m_processor = errorProcessor;
+      return XML_STATUS_ERROR;
+    }
+    // though this isn't a buffer request, we assume that `len` is the app's
+    // preferred buffer fill size, and therefore save it here.
+    parser->m_lastBufferRequestSize = len;
+    parser->m_parseEndByteIndex += len;
+    parser->m_positionPtr = s;
+    parser->m_parsingStatus.finalBuffer = (XML_Bool)isFinal;
+
+    parser->m_errorCode
+        = callProcessor(parser, s, parser->m_parseEndPtr = s + len, &end);
+
+    if (parser->m_errorCode != XML_ERROR_NONE) {
+      parser->m_eventEndPtr = parser->m_eventPtr;
+      parser->m_processor = errorProcessor;
+      return XML_STATUS_ERROR;
+    } else {
+      switch (parser->m_parsingStatus.parsing) {
+      case XML_SUSPENDED:
+        result = XML_STATUS_SUSPENDED;
+        break;
+      case XML_INITIALIZED:
+      case XML_PARSING:
+        if (isFinal) {
+          parser->m_parsingStatus.parsing = XML_FINISHED;
+          return XML_STATUS_OK;
+        }
+      /* fall through */
+      default:
+        result = XML_STATUS_OK;
+      }
+    }
+
+    XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr, end,
+                      &parser->m_position);
+    nLeftOver = s + len - end;
+    if (nLeftOver) {
+      // Back up and restore the parsing status to avoid XML_ERROR_SUSPENDED
+      // (and XML_ERROR_FINISHED) from XML_GetBuffer.
+      const enum XML_Parsing originalStatus = parser->m_parsingStatus.parsing;
+      parser->m_parsingStatus.parsing = XML_PARSING;
+      void *const temp = XML_GetBuffer(parser, nLeftOver);
+      parser->m_parsingStatus.parsing = originalStatus;
+      // GetBuffer may have overwritten this, but we want to remember what the
+      // app requested, not how many bytes were left over after parsing.
+      parser->m_lastBufferRequestSize = len;
+      if (temp == NULL) {
+        // NOTE: parser->m_errorCode has already been set by XML_GetBuffer().
+        parser->m_eventPtr = parser->m_eventEndPtr = NULL;
+        parser->m_processor = errorProcessor;
+        return XML_STATUS_ERROR;
+      }
+      // Since we know that the buffer was empty and XML_CONTEXT_BYTES is 0, we
+      // don't have any data to preserve, and can copy straight into the start
+      // of the buffer rather than the GetBuffer return pointer (which may be
+      // pointing further into the allocated buffer).
+      memcpy(parser->m_buffer, end, nLeftOver);
+    }
+    parser->m_bufferPtr = parser->m_buffer;
+    parser->m_bufferEnd = parser->m_buffer + nLeftOver;
+    parser->m_positionPtr = parser->m_bufferPtr;
+    parser->m_parseEndPtr = parser->m_bufferEnd;
+    parser->m_eventPtr = parser->m_bufferPtr;
+    parser->m_eventEndPtr = parser->m_bufferPtr;
+    return result;
+  }
+#endif /* XML_CONTEXT_BYTES == 0 */
+  void *buff = XML_GetBuffer(parser, len);
+  if (buff == NULL)
+    return XML_STATUS_ERROR;
+  if (len > 0) {
+    assert(s != NULL); // make sure s==NULL && len!=0 was rejected above
+    memcpy(buff, s, len);
+  }
+  return XML_ParseBuffer(parser, len, isFinal);
+}
+
+enum XML_Status XMLCALL
+XML_ParseBuffer(XML_Parser parser, int len, int isFinal) {
+  const char *start;
+  enum XML_Status result = XML_STATUS_OK;
+
+  if (parser == NULL)
+    return XML_STATUS_ERROR;
+
+  if (len < 0) {
+    parser->m_errorCode = XML_ERROR_INVALID_ARGUMENT;
+    return XML_STATUS_ERROR;
+  }
+
+  switch (parser->m_parsingStatus.parsing) {
+  case XML_SUSPENDED:
+    parser->m_errorCode = XML_ERROR_SUSPENDED;
+    return XML_STATUS_ERROR;
+  case XML_FINISHED:
+    parser->m_errorCode = XML_ERROR_FINISHED;
+    return XML_STATUS_ERROR;
+  case XML_INITIALIZED:
+    /* Has someone called XML_GetBuffer successfully before? */
+    if (! parser->m_bufferPtr) {
+      parser->m_errorCode = XML_ERROR_NO_BUFFER;
+      return XML_STATUS_ERROR;
+    }
+
+    if (parser->m_parentParser == NULL && ! startParsing(parser)) {
+      parser->m_errorCode = XML_ERROR_NO_MEMORY;
+      return XML_STATUS_ERROR;
+    }
+    /* fall through */
+  default:
+    parser->m_parsingStatus.parsing = XML_PARSING;
+  }
+
+  start = parser->m_bufferPtr;
+  parser->m_positionPtr = start;
+  parser->m_bufferEnd += len;
+  parser->m_parseEndPtr = parser->m_bufferEnd;
+  parser->m_parseEndByteIndex += len;
+  parser->m_parsingStatus.finalBuffer = (XML_Bool)isFinal;
+
+  parser->m_errorCode = callProcessor(parser, start, parser->m_parseEndPtr,
+                                      &parser->m_bufferPtr);
+
+  if (parser->m_errorCode != XML_ERROR_NONE) {
+    parser->m_eventEndPtr = parser->m_eventPtr;
+    parser->m_processor = errorProcessor;
+    return XML_STATUS_ERROR;
+  } else {
+    switch (parser->m_parsingStatus.parsing) {
+    case XML_SUSPENDED:
+      result = XML_STATUS_SUSPENDED;
+      break;
+    case XML_INITIALIZED:
+    case XML_PARSING:
+      if (isFinal) {
+        parser->m_parsingStatus.parsing = XML_FINISHED;
+        return result;
+      }
+    default:; /* should not happen */
+    }
+  }
+
+  XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
+                    parser->m_bufferPtr, &parser->m_position);
+  parser->m_positionPtr = parser->m_bufferPtr;
+  return result;
+}
+
+void *XMLCALL
+XML_GetBuffer(XML_Parser parser, int len) {
+  if (parser == NULL)
+    return NULL;
+  if (len < 0) {
+    parser->m_errorCode = XML_ERROR_NO_MEMORY;
+    return NULL;
+  }
+  switch (parser->m_parsingStatus.parsing) {
+  case XML_SUSPENDED:
+    parser->m_errorCode = XML_ERROR_SUSPENDED;
+    return NULL;
+  case XML_FINISHED:
+    parser->m_errorCode = XML_ERROR_FINISHED;
+    return NULL;
+  default:;
+  }
+
+  // whether or not the request succeeds, `len` seems to be the app's preferred
+  // buffer fill size; remember it.
+  parser->m_lastBufferRequestSize = len;
+  if (len > EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_bufferEnd)
+      || parser->m_buffer == NULL) {
+#if XML_CONTEXT_BYTES > 0
+    int keep;
+#endif /* XML_CONTEXT_BYTES > 0 */
+    /* Do not invoke signed arithmetic overflow: */
+    int neededSize = (int)((unsigned)len
+                           + (unsigned)EXPAT_SAFE_PTR_DIFF(
+                               parser->m_bufferEnd, parser->m_bufferPtr));
+    if (neededSize < 0) {
+      parser->m_errorCode = XML_ERROR_NO_MEMORY;
+      return NULL;
+    }
+#if XML_CONTEXT_BYTES > 0
+    keep = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer);
+    if (keep > XML_CONTEXT_BYTES)
+      keep = XML_CONTEXT_BYTES;
+    /* Detect and prevent integer overflow */
+    if (keep > INT_MAX - neededSize) {
+      parser->m_errorCode = XML_ERROR_NO_MEMORY;
+      return NULL;
+    }
+    neededSize += keep;
+#endif /* XML_CONTEXT_BYTES > 0 */
+    if (parser->m_buffer && parser->m_bufferPtr
+        && neededSize
+               <= EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_buffer)) {
+#if XML_CONTEXT_BYTES > 0
+      if (keep < EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer)) {
+        int offset
+            = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer)
+              - keep;
+        /* The buffer pointers cannot be NULL here; we have at least some bytes
+         * in the buffer */
+        memmove(parser->m_buffer, &parser->m_buffer[offset],
+                parser->m_bufferEnd - parser->m_bufferPtr + keep);
+        parser->m_bufferEnd -= offset;
+        parser->m_bufferPtr -= offset;
+      }
+#else
+      memmove(parser->m_buffer, parser->m_bufferPtr,
+              EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr));
+      parser->m_bufferEnd
+          = parser->m_buffer
+            + EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr);
+      parser->m_bufferPtr = parser->m_buffer;
+#endif /* XML_CONTEXT_BYTES > 0 */
+    } else {
+      char *newBuf;
+      int bufferSize
+          = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_buffer);
+      if (bufferSize == 0)
+        bufferSize = INIT_BUFFER_SIZE;
+      do {
+        /* Do not invoke signed arithmetic overflow: */
+        bufferSize = (int)(2U * (unsigned)bufferSize);
+      } while (bufferSize < neededSize && bufferSize > 0);
+      if (bufferSize <= 0) {
+        parser->m_errorCode = XML_ERROR_NO_MEMORY;
+        return NULL;
+      }
+      newBuf = (char *)MALLOC(parser, bufferSize);
+      if (newBuf == 0) {
+        parser->m_errorCode = XML_ERROR_NO_MEMORY;
+        return NULL;
+      }
+      parser->m_bufferLim = newBuf + bufferSize;
+#if XML_CONTEXT_BYTES > 0
+      if (parser->m_bufferPtr) {
+        memcpy(newBuf, &parser->m_bufferPtr[-keep],
+               EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr)
+                   + keep);
+        FREE(parser, parser->m_buffer);
+        parser->m_buffer = newBuf;
+        parser->m_bufferEnd
+            = parser->m_buffer
+              + EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr)
+              + keep;
+        parser->m_bufferPtr = parser->m_buffer + keep;
+      } else {
+        /* This must be a brand new buffer with no data in it yet */
+        parser->m_bufferEnd = newBuf;
+        parser->m_bufferPtr = parser->m_buffer = newBuf;
+      }
+#else
+      if (parser->m_bufferPtr) {
+        memcpy(newBuf, parser->m_bufferPtr,
+               EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr));
+        FREE(parser, parser->m_buffer);
+        parser->m_bufferEnd
+            = newBuf
+              + EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr);
+      } else {
+        /* This must be a brand new buffer with no data in it yet */
+        parser->m_bufferEnd = newBuf;
+      }
+      parser->m_bufferPtr = parser->m_buffer = newBuf;
+#endif /* XML_CONTEXT_BYTES > 0 */
+    }
+    parser->m_eventPtr = parser->m_eventEndPtr = NULL;
+    parser->m_positionPtr = NULL;
+  }
+  return parser->m_bufferEnd;
+}
+
+enum XML_Status XMLCALL
+XML_StopParser(XML_Parser parser, XML_Bool resumable) {
+  if (parser == NULL)
+    return XML_STATUS_ERROR;
+  switch (parser->m_parsingStatus.parsing) {
+  case XML_SUSPENDED:
+    if (resumable) {
+      parser->m_errorCode = XML_ERROR_SUSPENDED;
+      return XML_STATUS_ERROR;
+    }
+    parser->m_parsingStatus.parsing = XML_FINISHED;
+    break;
+  case XML_FINISHED:
+    parser->m_errorCode = XML_ERROR_FINISHED;
+    return XML_STATUS_ERROR;
+  default:
+    if (resumable) {
+#ifdef XML_DTD
+      if (parser->m_isParamEntity) {
+        parser->m_errorCode = XML_ERROR_SUSPEND_PE;
+        return XML_STATUS_ERROR;
+      }
+#endif
+      parser->m_parsingStatus.parsing = XML_SUSPENDED;
+    } else
+      parser->m_parsingStatus.parsing = XML_FINISHED;
+  }
+  return XML_STATUS_OK;
+}
+
+enum XML_Status XMLCALL
+XML_ResumeParser(XML_Parser parser) {
+  enum XML_Status result = XML_STATUS_OK;
+
+  if (parser == NULL)
+    return XML_STATUS_ERROR;
+  if (parser->m_parsingStatus.parsing != XML_SUSPENDED) {
+    parser->m_errorCode = XML_ERROR_NOT_SUSPENDED;
+    return XML_STATUS_ERROR;
+  }
+  parser->m_parsingStatus.parsing = XML_PARSING;
+
+  parser->m_errorCode = callProcessor(
+      parser, parser->m_bufferPtr, parser->m_parseEndPtr, &parser->m_bufferPtr);
+
+  if (parser->m_errorCode != XML_ERROR_NONE) {
+    parser->m_eventEndPtr = parser->m_eventPtr;
+    parser->m_processor = errorProcessor;
+    return XML_STATUS_ERROR;
+  } else {
+    switch (parser->m_parsingStatus.parsing) {
+    case XML_SUSPENDED:
+      result = XML_STATUS_SUSPENDED;
+      break;
+    case XML_INITIALIZED:
+    case XML_PARSING:
+      if (parser->m_parsingStatus.finalBuffer) {
+        parser->m_parsingStatus.parsing = XML_FINISHED;
+        return result;
+      }
+    default:;
+    }
+  }
+
+  XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
+                    parser->m_bufferPtr, &parser->m_position);
+  parser->m_positionPtr = parser->m_bufferPtr;
+  return result;
+}
+
+void XMLCALL
+XML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status) {
+  if (parser == NULL)
+    return;
+  assert(status != NULL);
+  *status = parser->m_parsingStatus;
+}
+
+enum XML_Error XMLCALL
+XML_GetErrorCode(XML_Parser parser) {
+  if (parser == NULL)
+    return XML_ERROR_INVALID_ARGUMENT;
+  return parser->m_errorCode;
+}
+
+XML_Index XMLCALL
+XML_GetCurrentByteIndex(XML_Parser parser) {
+  if (parser == NULL)
+    return -1;
+  if (parser->m_eventPtr)
+    return (XML_Index)(parser->m_parseEndByteIndex
+                       - (parser->m_parseEndPtr - parser->m_eventPtr));
+  return -1;
+}
+
+int XMLCALL
+XML_GetCurrentByteCount(XML_Parser parser) {
+  if (parser == NULL)
+    return 0;
+  if (parser->m_eventEndPtr && parser->m_eventPtr)
+    return (int)(parser->m_eventEndPtr - parser->m_eventPtr);
+  return 0;
+}
+
+const char *XMLCALL
+XML_GetInputContext(XML_Parser parser, int *offset, int *size) {
+#if XML_CONTEXT_BYTES > 0
+  if (parser == NULL)
+    return NULL;
+  if (parser->m_eventPtr && parser->m_buffer) {
+    if (offset != NULL)
+      *offset = (int)(parser->m_eventPtr - parser->m_buffer);
+    if (size != NULL)
+      *size = (int)(parser->m_bufferEnd - parser->m_buffer);
+    return parser->m_buffer;
+  }
+#else
+  (void)parser;
+  (void)offset;
+  (void)size;
+#endif /* XML_CONTEXT_BYTES > 0 */
+  return (const char *)0;
+}
+
+XML_Size XMLCALL
+XML_GetCurrentLineNumber(XML_Parser parser) {
+  if (parser == NULL)
+    return 0;
+  if (parser->m_eventPtr && parser->m_eventPtr >= parser->m_positionPtr) {
+    XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
+                      parser->m_eventPtr, &parser->m_position);
+    parser->m_positionPtr = parser->m_eventPtr;
+  }
+  return parser->m_position.lineNumber + 1;
+}
+
+XML_Size XMLCALL
+XML_GetCurrentColumnNumber(XML_Parser parser) {
+  if (parser == NULL)
+    return 0;
+  if (parser->m_eventPtr && parser->m_eventPtr >= parser->m_positionPtr) {
+    XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
+                      parser->m_eventPtr, &parser->m_position);
+    parser->m_positionPtr = parser->m_eventPtr;
+  }
+  return parser->m_position.columnNumber;
+}
+
+void XMLCALL
+XML_FreeContentModel(XML_Parser parser, XML_Content *model) {
+  if (parser != NULL)
+    FREE(parser, model);
+}
+
+void *XMLCALL
+XML_MemMalloc(XML_Parser parser, size_t size) {
+  if (parser == NULL)
+    return NULL;
+  return MALLOC(parser, size);
+}
+
+void *XMLCALL
+XML_MemRealloc(XML_Parser parser, void *ptr, size_t size) {
+  if (parser == NULL)
+    return NULL;
+  return REALLOC(parser, ptr, size);
+}
+
+void XMLCALL
+XML_MemFree(XML_Parser parser, void *ptr) {
+  if (parser != NULL)
+    FREE(parser, ptr);
+}
+
+void XMLCALL
+XML_DefaultCurrent(XML_Parser parser) {
+  if (parser == NULL)
+    return;
+  if (parser->m_defaultHandler) {
+    if (parser->m_openInternalEntities)
+      reportDefault(parser, parser->m_internalEncoding,
+                    parser->m_openInternalEntities->internalEventPtr,
+                    parser->m_openInternalEntities->internalEventEndPtr);
+    else
+      reportDefault(parser, parser->m_encoding, parser->m_eventPtr,
+                    parser->m_eventEndPtr);
+  }
+}
+
+const XML_LChar *XMLCALL
+XML_ErrorString(enum XML_Error code) {
+  switch (code) {
+  case XML_ERROR_NONE:
+    return NULL;
+  case XML_ERROR_NO_MEMORY:
+    return XML_L("out of memory");
+  case XML_ERROR_SYNTAX:
+    return XML_L("syntax error");
+  case XML_ERROR_NO_ELEMENTS:
+    return XML_L("no element found");
+  case XML_ERROR_INVALID_TOKEN:
+    return XML_L("not well-formed (invalid token)");
+  case XML_ERROR_UNCLOSED_TOKEN:
+    return XML_L("unclosed token");
+  case XML_ERROR_PARTIAL_CHAR:
+    return XML_L("partial character");
+  case XML_ERROR_TAG_MISMATCH:
+    return XML_L("mismatched tag");
+  case XML_ERROR_DUPLICATE_ATTRIBUTE:
+    return XML_L("duplicate attribute");
+  case XML_ERROR_JUNK_AFTER_DOC_ELEMENT:
+    return XML_L("junk after document element");
+  case XML_ERROR_PARAM_ENTITY_REF:
+    return XML_L("illegal parameter entity reference");
+  case XML_ERROR_UNDEFINED_ENTITY:
+    return XML_L("undefined entity");
+  case XML_ERROR_RECURSIVE_ENTITY_REF:
+    return XML_L("recursive entity reference");
+  case XML_ERROR_ASYNC_ENTITY:
+    return XML_L("asynchronous entity");
+  case XML_ERROR_BAD_CHAR_REF:
+    return XML_L("reference to invalid character number");
+  case XML_ERROR_BINARY_ENTITY_REF:
+    return XML_L("reference to binary entity");
+  case XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF:
+    return XML_L("reference to external entity in attribute");
+  case XML_ERROR_MISPLACED_XML_PI:
+    return XML_L("XML or text declaration not at start of entity");
+  case XML_ERROR_UNKNOWN_ENCODING:
+    return XML_L("unknown encoding");
+  case XML_ERROR_INCORRECT_ENCODING:
+    return XML_L("encoding specified in XML declaration is incorrect");
+  case XML_ERROR_UNCLOSED_CDATA_SECTION:
+    return XML_L("unclosed CDATA section");
+  case XML_ERROR_EXTERNAL_ENTITY_HANDLING:
+    return XML_L("error in processing external entity reference");
+  case XML_ERROR_NOT_STANDALONE:
+    return XML_L("document is not standalone");
+  case XML_ERROR_UNEXPECTED_STATE:
+    return XML_L("unexpected parser state - please send a bug report");
+  case XML_ERROR_ENTITY_DECLARED_IN_PE:
+    return XML_L("entity declared in parameter entity");
+  case XML_ERROR_FEATURE_REQUIRES_XML_DTD:
+    return XML_L("requested feature requires XML_DTD support in Expat");
+  case XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING:
+    return XML_L("cannot change setting once parsing has begun");
+  /* Added in 1.95.7. */
+  case XML_ERROR_UNBOUND_PREFIX:
+    return XML_L("unbound prefix");
+  /* Added in 1.95.8. */
+  case XML_ERROR_UNDECLARING_PREFIX:
+    return XML_L("must not undeclare prefix");
+  case XML_ERROR_INCOMPLETE_PE:
+    return XML_L("incomplete markup in parameter entity");
+  case XML_ERROR_XML_DECL:
+    return XML_L("XML declaration not well-formed");
+  case XML_ERROR_TEXT_DECL:
+    return XML_L("text declaration not well-formed");
+  case XML_ERROR_PUBLICID:
+    return XML_L("illegal character(s) in public id");
+  case XML_ERROR_SUSPENDED:
+    return XML_L("parser suspended");
+  case XML_ERROR_NOT_SUSPENDED:
+    return XML_L("parser not suspended");
+  case XML_ERROR_ABORTED:
+    return XML_L("parsing aborted");
+  case XML_ERROR_FINISHED:
+    return XML_L("parsing finished");
+  case XML_ERROR_SUSPEND_PE:
+    return XML_L("cannot suspend in external parameter entity");
+  /* Added in 2.0.0. */
+  case XML_ERROR_RESERVED_PREFIX_XML:
+    return XML_L(
+        "reserved prefix (xml) must not be undeclared or bound to another namespace name");
+  case XML_ERROR_RESERVED_PREFIX_XMLNS:
+    return XML_L("reserved prefix (xmlns) must not be declared or undeclared");
+  case XML_ERROR_RESERVED_NAMESPACE_URI:
+    return XML_L(
+        "prefix must not be bound to one of the reserved namespace names");
+  /* Added in 2.2.5. */
+  case XML_ERROR_INVALID_ARGUMENT: /* Constant added in 2.2.1, already */
+    return XML_L("invalid argument");
+    /* Added in 2.3.0. */
+  case XML_ERROR_NO_BUFFER:
+    return XML_L(
+        "a successful prior call to function XML_GetBuffer is required");
+  /* Added in 2.4.0. */
+  case XML_ERROR_AMPLIFICATION_LIMIT_BREACH:
+    return XML_L(
+        "limit on input amplification factor (from DTD and entities) breached");
+  }
+  return NULL;
+}
+
+const XML_LChar *XMLCALL
+XML_ExpatVersion(void) {
+  /* V1 is used to string-ize the version number. However, it would
+     string-ize the actual version macro *names* unless we get them
+     substituted before being passed to V1. CPP is defined to expand
+     a macro, then rescan for more expansions. Thus, we use V2 to expand
+     the version macros, then CPP will expand the resulting V1() macro
+     with the correct numerals. */
+  /* ### I'm assuming cpp is portable in this respect... */
+
+#define V1(a, b, c) XML_L(#a) XML_L(".") XML_L(#b) XML_L(".") XML_L(#c)
+#define V2(a, b, c) XML_L("expat_") V1(a, b, c)
+
+  return V2(XML_MAJOR_VERSION, XML_MINOR_VERSION, XML_MICRO_VERSION);
+
+#undef V1
+#undef V2
+}
+
+XML_Expat_Version XMLCALL
+XML_ExpatVersionInfo(void) {
+  XML_Expat_Version version;
+
+  version.major = XML_MAJOR_VERSION;
+  version.minor = XML_MINOR_VERSION;
+  version.micro = XML_MICRO_VERSION;
+
+  return version;
+}
+
+const XML_Feature *XMLCALL
+XML_GetFeatureList(void) {
+  static const XML_Feature features[] = {
+      {XML_FEATURE_SIZEOF_XML_CHAR, XML_L("sizeof(XML_Char)"),
+       sizeof(XML_Char)},
+      {XML_FEATURE_SIZEOF_XML_LCHAR, XML_L("sizeof(XML_LChar)"),
+       sizeof(XML_LChar)},
+#ifdef XML_UNICODE
+      {XML_FEATURE_UNICODE, XML_L("XML_UNICODE"), 0},
+#endif
+#ifdef XML_UNICODE_WCHAR_T
+      {XML_FEATURE_UNICODE_WCHAR_T, XML_L("XML_UNICODE_WCHAR_T"), 0},
+#endif
+#ifdef XML_DTD
+      {XML_FEATURE_DTD, XML_L("XML_DTD"), 0},
+#endif
+#if XML_CONTEXT_BYTES > 0
+      {XML_FEATURE_CONTEXT_BYTES, XML_L("XML_CONTEXT_BYTES"),
+       XML_CONTEXT_BYTES},
+#endif
+#ifdef XML_MIN_SIZE
+      {XML_FEATURE_MIN_SIZE, XML_L("XML_MIN_SIZE"), 0},
+#endif
+#ifdef XML_NS
+      {XML_FEATURE_NS, XML_L("XML_NS"), 0},
+#endif
+#ifdef XML_LARGE_SIZE
+      {XML_FEATURE_LARGE_SIZE, XML_L("XML_LARGE_SIZE"), 0},
+#endif
+#ifdef XML_ATTR_INFO
+      {XML_FEATURE_ATTR_INFO, XML_L("XML_ATTR_INFO"), 0},
+#endif
+#if XML_GE == 1
+      /* Added in Expat 2.4.0 for XML_DTD defined and
+       * added in Expat 2.6.0 for XML_GE == 1. */
+      {XML_FEATURE_BILLION_LAUGHS_ATTACK_PROTECTION_MAXIMUM_AMPLIFICATION_DEFAULT,
+       XML_L("XML_BLAP_MAX_AMP"),
+       (long int)
+           EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_MAXIMUM_AMPLIFICATION_DEFAULT},
+      {XML_FEATURE_BILLION_LAUGHS_ATTACK_PROTECTION_ACTIVATION_THRESHOLD_DEFAULT,
+       XML_L("XML_BLAP_ACT_THRES"),
+       EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_ACTIVATION_THRESHOLD_DEFAULT},
+      /* Added in Expat 2.6.0. */
+      {XML_FEATURE_GE, XML_L("XML_GE"), 0},
+#endif
+      {XML_FEATURE_END, NULL, 0}};
+
+  return features;
+}
+
+#if XML_GE == 1
+XML_Bool XMLCALL
+XML_SetBillionLaughsAttackProtectionMaximumAmplification(
+    XML_Parser parser, float maximumAmplificationFactor) {
+  if ((parser == NULL) || (parser->m_parentParser != NULL)
+      || isnan(maximumAmplificationFactor)
+      || (maximumAmplificationFactor < 1.0f)) {
+    return XML_FALSE;
+  }
+  parser->m_accounting.maximumAmplificationFactor = maximumAmplificationFactor;
+  return XML_TRUE;
+}
+
+XML_Bool XMLCALL
+XML_SetBillionLaughsAttackProtectionActivationThreshold(
+    XML_Parser parser, unsigned long long activationThresholdBytes) {
+  if ((parser == NULL) || (parser->m_parentParser != NULL)) {
+    return XML_FALSE;
+  }
+  parser->m_accounting.activationThresholdBytes = activationThresholdBytes;
+  return XML_TRUE;
+}
+#endif /* XML_GE == 1 */
+
+XML_Bool XMLCALL
+XML_SetReparseDeferralEnabled(XML_Parser parser, XML_Bool enabled) {
+  if (parser != NULL && (enabled == XML_TRUE || enabled == XML_FALSE)) {
+    parser->m_reparseDeferralEnabled = enabled;
+    return XML_TRUE;
+  }
+  return XML_FALSE;
+}
+
+/* Initially tag->rawName always points into the parse buffer;
+   for those TAG instances opened while the current parse buffer was
+   processed, and not yet closed, we need to store tag->rawName in a more
+   permanent location, since the parse buffer is about to be discarded.
+*/
+static XML_Bool
+storeRawNames(XML_Parser parser) {
+  TAG *tag = parser->m_tagStack;
+  while (tag) {
+    int bufSize;
+    int nameLen = sizeof(XML_Char) * (tag->name.strLen + 1);
+    size_t rawNameLen;
+    char *rawNameBuf = tag->buf + nameLen;
+    /* Stop if already stored.  Since m_tagStack is a stack, we can stop
+       at the first entry that has already been copied; everything
+       below it in the stack is already been accounted for in a
+       previous call to this function.
+    */
+    if (tag->rawName == rawNameBuf)
+      break;
+    /* For reuse purposes we need to ensure that the
+       size of tag->buf is a multiple of sizeof(XML_Char).
+    */
+    rawNameLen = ROUND_UP(tag->rawNameLength, sizeof(XML_Char));
+    /* Detect and prevent integer overflow. */
+    if (rawNameLen > (size_t)INT_MAX - nameLen)
+      return XML_FALSE;
+    bufSize = nameLen + (int)rawNameLen;
+    if (bufSize > tag->bufEnd - tag->buf) {
+      char *temp = (char *)REALLOC(parser, tag->buf, bufSize);
+      if (temp == NULL)
+        return XML_FALSE;
+      /* if tag->name.str points to tag->buf (only when namespace
+         processing is off) then we have to update it
+      */
+      if (tag->name.str == (XML_Char *)tag->buf)
+        tag->name.str = (XML_Char *)temp;
+      /* if tag->name.localPart is set (when namespace processing is on)
+         then update it as well, since it will always point into tag->buf
+      */
+      if (tag->name.localPart)
+        tag->name.localPart
+            = (XML_Char *)temp + (tag->name.localPart - (XML_Char *)tag->buf);
+      tag->buf = temp;
+      tag->bufEnd = temp + bufSize;
+      rawNameBuf = temp + nameLen;
+    }
+    memcpy(rawNameBuf, tag->rawName, tag->rawNameLength);
+    tag->rawName = rawNameBuf;
+    tag = tag->parent;
+  }
+  return XML_TRUE;
+}
+
+static enum XML_Error PTRCALL
+contentProcessor(XML_Parser parser, const char *start, const char *end,
+                 const char **endPtr) {
+  enum XML_Error result = doContent(
+      parser, 0, parser->m_encoding, start, end, endPtr,
+      (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_ACCOUNT_DIRECT);
+  if (result == XML_ERROR_NONE) {
+    if (! storeRawNames(parser))
+      return XML_ERROR_NO_MEMORY;
+  }
+  return result;
+}
+
+static enum XML_Error PTRCALL
+externalEntityInitProcessor(XML_Parser parser, const char *start,
+                            const char *end, const char **endPtr) {
+  enum XML_Error result = initializeEncoding(parser);
+  if (result != XML_ERROR_NONE)
+    return result;
+  parser->m_processor = externalEntityInitProcessor2;
+  return externalEntityInitProcessor2(parser, start, end, endPtr);
+}
+
+static enum XML_Error PTRCALL
+externalEntityInitProcessor2(XML_Parser parser, const char *start,
+                             const char *end, const char **endPtr) {
+  const char *next = start; /* XmlContentTok doesn't always set the last arg */
+  int tok = XmlContentTok(parser->m_encoding, start, end, &next);
+  switch (tok) {
+  case XML_TOK_BOM:
+#if XML_GE == 1
+    if (! accountingDiffTolerated(parser, tok, start, next, __LINE__,
+                                  XML_ACCOUNT_DIRECT)) {
+      accountingOnAbort(parser);
+      return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
+    }
+#endif /* XML_GE == 1 */
+
+    /* If we are at the end of the buffer, this would cause the next stage,
+       i.e. externalEntityInitProcessor3, to pass control directly to
+       doContent (by detecting XML_TOK_NONE) without processing any xml text
+       declaration - causing the error XML_ERROR_MISPLACED_XML_PI in doContent.
+    */
+    if (next == end && ! parser->m_parsingStatus.finalBuffer) {
+      *endPtr = next;
+      return XML_ERROR_NONE;
+    }
+    start = next;
+    break;
+  case XML_TOK_PARTIAL:
+    if (! parser->m_parsingStatus.finalBuffer) {
+      *endPtr = start;
+      return XML_ERROR_NONE;
+    }
+    parser->m_eventPtr = start;
+    return XML_ERROR_UNCLOSED_TOKEN;
+  case XML_TOK_PARTIAL_CHAR:
+    if (! parser->m_parsingStatus.finalBuffer) {
+      *endPtr = start;
+      return XML_ERROR_NONE;
+    }
+    parser->m_eventPtr = start;
+    return XML_ERROR_PARTIAL_CHAR;
+  }
+  parser->m_processor = externalEntityInitProcessor3;
+  return externalEntityInitProcessor3(parser, start, end, endPtr);
+}
+
+static enum XML_Error PTRCALL
+externalEntityInitProcessor3(XML_Parser parser, const char *start,
+                             const char *end, const char **endPtr) {
+  int tok;
+  const char *next = start; /* XmlContentTok doesn't always set the last arg */
+  parser->m_eventPtr = start;
+  tok = XmlContentTok(parser->m_encoding, start, end, &next);
+  /* Note: These bytes are accounted later in:
+           - processXmlDecl
+           - externalEntityContentProcessor
+  */
+  parser->m_eventEndPtr = next;
+
+  switch (tok) {
+  case XML_TOK_XML_DECL: {
+    enum XML_Error result;
+    result = processXmlDecl(parser, 1, start, next);
+    if (result != XML_ERROR_NONE)
+      return result;
+    switch (parser->m_parsingStatus.parsing) {
+    case XML_SUSPENDED:
+      *endPtr = next;
+      return XML_ERROR_NONE;
+    case XML_FINISHED:
+      return XML_ERROR_ABORTED;
+    default:
+      start = next;
+    }
+  } break;
+  case XML_TOK_PARTIAL:
+    if (! parser->m_parsingStatus.finalBuffer) {
+      *endPtr = start;
+      return XML_ERROR_NONE;
+    }
+    return XML_ERROR_UNCLOSED_TOKEN;
+  case XML_TOK_PARTIAL_CHAR:
+    if (! parser->m_parsingStatus.finalBuffer) {
+      *endPtr = start;
+      return XML_ERROR_NONE;
+    }
+    return XML_ERROR_PARTIAL_CHAR;
+  }
+  parser->m_processor = externalEntityContentProcessor;
+  parser->m_tagLevel = 1;
+  return externalEntityContentProcessor(parser, start, end, endPtr);
+}
+
+static enum XML_Error PTRCALL
+externalEntityContentProcessor(XML_Parser parser, const char *start,
+                               const char *end, const char **endPtr) {
+  enum XML_Error result
+      = doContent(parser, 1, parser->m_encoding, start, end, endPtr,
+                  (XML_Bool)! parser->m_parsingStatus.finalBuffer,
+                  XML_ACCOUNT_ENTITY_EXPANSION);
+  if (result == XML_ERROR_NONE) {
+    if (! storeRawNames(parser))
+      return XML_ERROR_NO_MEMORY;
+  }
+  return result;
+}
+
+static enum XML_Error
+doContent(XML_Parser parser, int startTagLevel, const ENCODING *enc,
+          const char *s, const char *end, const char **nextPtr,
+          XML_Bool haveMore, enum XML_Account account) {
+  /* save one level of indirection */
+  DTD *const dtd = parser->m_dtd;
+
+  const char **eventPP;
+  const char **eventEndPP;
+  if (enc == parser->m_encoding) {
+    eventPP = &parser->m_eventPtr;
+    eventEndPP = &parser->m_eventEndPtr;
+  } else {
+    eventPP = &(parser->m_openInternalEntities->internalEventPtr);
+    eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
+  }
+  *eventPP = s;
+
+  for (;;) {
+    const char *next = s; /* XmlContentTok doesn't always set the last arg */
+    int tok = XmlContentTok(enc, s, end, &next);
+#if XML_GE == 1
+    const char *accountAfter
+        = ((tok == XML_TOK_TRAILING_RSQB) || (tok == XML_TOK_TRAILING_CR))
+              ? (haveMore ? s /* i.e. 0 bytes */ : end)
+              : next;
+    if (! accountingDiffTolerated(parser, tok, s, accountAfter, __LINE__,
+                                  account)) {
+      accountingOnAbort(parser);
+      return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
+    }
+#endif
+    *eventEndPP = next;
+    switch (tok) {
+    case XML_TOK_TRAILING_CR:
+      if (haveMore) {
+        *nextPtr = s;
+        return XML_ERROR_NONE;
+      }
+      *eventEndPP = end;
+      if (parser->m_characterDataHandler) {
+        XML_Char c = 0xA;
+        parser->m_characterDataHandler(parser->m_handlerArg, &c, 1);
+      } else if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, end);
+      /* We are at the end of the final buffer, should we check for
+         XML_SUSPENDED, XML_FINISHED?
+      */
+      if (startTagLevel == 0)
+        return XML_ERROR_NO_ELEMENTS;
+      if (parser->m_tagLevel != startTagLevel)
+        return XML_ERROR_ASYNC_ENTITY;
+      *nextPtr = end;
+      return XML_ERROR_NONE;
+    case XML_TOK_NONE:
+      if (haveMore) {
+        *nextPtr = s;
+        return XML_ERROR_NONE;
+      }
+      if (startTagLevel > 0) {
+        if (parser->m_tagLevel != startTagLevel)
+          return XML_ERROR_ASYNC_ENTITY;
+        *nextPtr = s;
+        return XML_ERROR_NONE;
+      }
+      return XML_ERROR_NO_ELEMENTS;
+    case XML_TOK_INVALID:
+      *eventPP = next;
+      return XML_ERROR_INVALID_TOKEN;
+    case XML_TOK_PARTIAL:
+      if (haveMore) {
+        *nextPtr = s;
+        return XML_ERROR_NONE;
+      }
+      return XML_ERROR_UNCLOSED_TOKEN;
+    case XML_TOK_PARTIAL_CHAR:
+      if (haveMore) {
+        *nextPtr = s;
+        return XML_ERROR_NONE;
+      }
+      return XML_ERROR_PARTIAL_CHAR;
+    case XML_TOK_ENTITY_REF: {
+      const XML_Char *name;
+      ENTITY *entity;
+      XML_Char ch = (XML_Char)XmlPredefinedEntityName(
+          enc, s + enc->minBytesPerChar, next - enc->minBytesPerChar);
+      if (ch) {
+#if XML_GE == 1
+        /* NOTE: We are replacing 4-6 characters original input for 1 character
+         *       so there is no amplification and hence recording without
+         *       protection. */
+        accountingDiffTolerated(parser, tok, (char *)&ch,
+                                ((char *)&ch) + sizeof(XML_Char), __LINE__,
+                                XML_ACCOUNT_ENTITY_EXPANSION);
+#endif /* XML_GE == 1 */
+        if (parser->m_characterDataHandler)
+          parser->m_characterDataHandler(parser->m_handlerArg, &ch, 1);
+        else if (parser->m_defaultHandler)
+          reportDefault(parser, enc, s, next);
+        break;
+      }
+      name = poolStoreString(&dtd->pool, enc, s + enc->minBytesPerChar,
+                             next - enc->minBytesPerChar);
+      if (! name)
+        return XML_ERROR_NO_MEMORY;
+      entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);
+      poolDiscard(&dtd->pool);
+      /* First, determine if a check for an existing declaration is needed;
+         if yes, check that the entity exists, and that it is internal,
+         otherwise call the skipped entity or default handler.
+      */
+      if (! dtd->hasParamEntityRefs || dtd->standalone) {
+        if (! entity)
+          return XML_ERROR_UNDEFINED_ENTITY;
+        else if (! entity->is_internal)
+          return XML_ERROR_ENTITY_DECLARED_IN_PE;
+      } else if (! entity) {
+        if (parser->m_skippedEntityHandler)
+          parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0);
+        else if (parser->m_defaultHandler)
+          reportDefault(parser, enc, s, next);
+        break;
+      }
+      if (entity->open)
+        return XML_ERROR_RECURSIVE_ENTITY_REF;
+      if (entity->notation)
+        return XML_ERROR_BINARY_ENTITY_REF;
+      if (entity->textPtr) {
+        enum XML_Error result;
+        if (! parser->m_defaultExpandInternalEntities) {
+          if (parser->m_skippedEntityHandler)
+            parser->m_skippedEntityHandler(parser->m_handlerArg, entity->name,
+                                           0);
+          else if (parser->m_defaultHandler)
+            reportDefault(parser, enc, s, next);
+          break;
+        }
+        result = processInternalEntity(parser, entity, XML_FALSE);
+        if (result != XML_ERROR_NONE)
+          return result;
+      } else if (parser->m_externalEntityRefHandler) {
+        const XML_Char *context;
+        entity->open = XML_TRUE;
+        context = getContext(parser);
+        entity->open = XML_FALSE;
+        if (! context)
+          return XML_ERROR_NO_MEMORY;
+        if (! parser->m_externalEntityRefHandler(
+                parser->m_externalEntityRefHandlerArg, context, entity->base,
+                entity->systemId, entity->publicId))
+          return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
+        poolDiscard(&parser->m_tempPool);
+      } else if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, next);
+      break;
+    }
+    case XML_TOK_START_TAG_NO_ATTS:
+      /* fall through */
+    case XML_TOK_START_TAG_WITH_ATTS: {
+      TAG *tag;
+      enum XML_Error result;
+      XML_Char *toPtr;
+      if (parser->m_freeTagList) {
+        tag = parser->m_freeTagList;
+        parser->m_freeTagList = parser->m_freeTagList->parent;
+      } else {
+        tag = (TAG *)MALLOC(parser, sizeof(TAG));
+        if (! tag)
+          return XML_ERROR_NO_MEMORY;
+        tag->buf = (char *)MALLOC(parser, INIT_TAG_BUF_SIZE);
+        if (! tag->buf) {
+          FREE(parser, tag);
+          return XML_ERROR_NO_MEMORY;
+        }
+        tag->bufEnd = tag->buf + INIT_TAG_BUF_SIZE;
+      }
+      tag->bindings = NULL;
+      tag->parent = parser->m_tagStack;
+      parser->m_tagStack = tag;
+      tag->name.localPart = NULL;
+      tag->name.prefix = NULL;
+      tag->rawName = s + enc->minBytesPerChar;
+      tag->rawNameLength = XmlNameLength(enc, tag->rawName);
+      ++parser->m_tagLevel;
+      {
+        const char *rawNameEnd = tag->rawName + tag->rawNameLength;
+        const char *fromPtr = tag->rawName;
+        toPtr = (XML_Char *)tag->buf;
+        for (;;) {
+          int bufSize;
+          int convLen;
+          const enum XML_Convert_Result convert_res
+              = XmlConvert(enc, &fromPtr, rawNameEnd, (ICHAR **)&toPtr,
+                           (ICHAR *)tag->bufEnd - 1);
+          convLen = (int)(toPtr - (XML_Char *)tag->buf);
+          if ((fromPtr >= rawNameEnd)
+              || (convert_res == XML_CONVERT_INPUT_INCOMPLETE)) {
+            tag->name.strLen = convLen;
+            break;
+          }
+          bufSize = (int)(tag->bufEnd - tag->buf) << 1;
+          {
+            char *temp = (char *)REALLOC(parser, tag->buf, bufSize);
+            if (temp == NULL)
+              return XML_ERROR_NO_MEMORY;
+            tag->buf = temp;
+            tag->bufEnd = temp + bufSize;
+            toPtr = (XML_Char *)temp + convLen;
+          }
+        }
+      }
+      tag->name.str = (XML_Char *)tag->buf;
+      *toPtr = XML_T('\0');
+      result
+          = storeAtts(parser, enc, s, &(tag->name), &(tag->bindings), account);
+      if (result)
+        return result;
+      if (parser->m_startElementHandler)
+        parser->m_startElementHandler(parser->m_handlerArg, tag->name.str,
+                                      (const XML_Char **)parser->m_atts);
+      else if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, next);
+      poolClear(&parser->m_tempPool);
+      break;
+    }
+    case XML_TOK_EMPTY_ELEMENT_NO_ATTS:
+      /* fall through */
+    case XML_TOK_EMPTY_ELEMENT_WITH_ATTS: {
+      const char *rawName = s + enc->minBytesPerChar;
+      enum XML_Error result;
+      BINDING *bindings = NULL;
+      XML_Bool noElmHandlers = XML_TRUE;
+      TAG_NAME name;
+      name.str = poolStoreString(&parser->m_tempPool, enc, rawName,
+                                 rawName + XmlNameLength(enc, rawName));
+      if (! name.str)
+        return XML_ERROR_NO_MEMORY;
+      poolFinish(&parser->m_tempPool);
+      result = storeAtts(parser, enc, s, &name, &bindings,
+                         XML_ACCOUNT_NONE /* token spans whole start tag */);
+      if (result != XML_ERROR_NONE) {
+        freeBindings(parser, bindings);
+        return result;
+      }
+      poolFinish(&parser->m_tempPool);
+      if (parser->m_startElementHandler) {
+        parser->m_startElementHandler(parser->m_handlerArg, name.str,
+                                      (const XML_Char **)parser->m_atts);
+        noElmHandlers = XML_FALSE;
+      }
+      if (parser->m_endElementHandler) {
+        if (parser->m_startElementHandler)
+          *eventPP = *eventEndPP;
+        parser->m_endElementHandler(parser->m_handlerArg, name.str);
+        noElmHandlers = XML_FALSE;
+      }
+      if (noElmHandlers && parser->m_defaultHandler)
+        reportDefault(parser, enc, s, next);
+      poolClear(&parser->m_tempPool);
+      freeBindings(parser, bindings);
+    }
+      if ((parser->m_tagLevel == 0)
+          && (parser->m_parsingStatus.parsing != XML_FINISHED)) {
+        if (parser->m_parsingStatus.parsing == XML_SUSPENDED)
+          parser->m_processor = epilogProcessor;
+        else
+          return epilogProcessor(parser, next, end, nextPtr);
+      }
+      break;
+    case XML_TOK_END_TAG:
+      if (parser->m_tagLevel == startTagLevel)
+        return XML_ERROR_ASYNC_ENTITY;
+      else {
+        int len;
+        const char *rawName;
+        TAG *tag = parser->m_tagStack;
+        rawName = s + enc->minBytesPerChar * 2;
+        len = XmlNameLength(enc, rawName);
+        if (len != tag->rawNameLength
+            || memcmp(tag->rawName, rawName, len) != 0) {
+          *eventPP = rawName;
+          return XML_ERROR_TAG_MISMATCH;
+        }
+        parser->m_tagStack = tag->parent;
+        tag->parent = parser->m_freeTagList;
+        parser->m_freeTagList = tag;
+        --parser->m_tagLevel;
+        if (parser->m_endElementHandler) {
+          const XML_Char *localPart;
+          const XML_Char *prefix;
+          XML_Char *uri;
+          localPart = tag->name.localPart;
+          if (parser->m_ns && localPart) {
+            /* localPart and prefix may have been overwritten in
+               tag->name.str, since this points to the binding->uri
+               buffer which gets reused; so we have to add them again
+            */
+            uri = (XML_Char *)tag->name.str + tag->name.uriLen;
+            /* don't need to check for space - already done in storeAtts() */
+            while (*localPart)
+              *uri++ = *localPart++;
+            prefix = tag->name.prefix;
+            if (parser->m_ns_triplets && prefix) {
+              *uri++ = parser->m_namespaceSeparator;
+              while (*prefix)
+                *uri++ = *prefix++;
+            }
+            *uri = XML_T('\0');
+          }
+          parser->m_endElementHandler(parser->m_handlerArg, tag->name.str);
+        } else if (parser->m_defaultHandler)
+          reportDefault(parser, enc, s, next);
+        while (tag->bindings) {
+          BINDING *b = tag->bindings;
+          if (parser->m_endNamespaceDeclHandler)
+            parser->m_endNamespaceDeclHandler(parser->m_handlerArg,
+                                              b->prefix->name);
+          tag->bindings = tag->bindings->nextTagBinding;
+          b->nextTagBinding = parser->m_freeBindingList;
+          parser->m_freeBindingList = b;
+          b->prefix->binding = b->prevPrefixBinding;
+        }
+        if ((parser->m_tagLevel == 0)
+            && (parser->m_parsingStatus.parsing != XML_FINISHED)) {
+          if (parser->m_parsingStatus.parsing == XML_SUSPENDED)
+            parser->m_processor = epilogProcessor;
+          else
+            return epilogProcessor(parser, next, end, nextPtr);
+        }
+      }
+      break;
+    case XML_TOK_CHAR_REF: {
+      int n = XmlCharRefNumber(enc, s);
+      if (n < 0)
+        return XML_ERROR_BAD_CHAR_REF;
+      if (parser->m_characterDataHandler) {
+        XML_Char buf[XML_ENCODE_MAX];
+        parser->m_characterDataHandler(parser->m_handlerArg, buf,
+                                       XmlEncode(n, (ICHAR *)buf));
+      } else if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, next);
+    } break;
+    case XML_TOK_XML_DECL:
+      return XML_ERROR_MISPLACED_XML_PI;
+    case XML_TOK_DATA_NEWLINE:
+      if (parser->m_characterDataHandler) {
+        XML_Char c = 0xA;
+        parser->m_characterDataHandler(parser->m_handlerArg, &c, 1);
+      } else if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, next);
+      break;
+    case XML_TOK_CDATA_SECT_OPEN: {
+      enum XML_Error result;
+      if (parser->m_startCdataSectionHandler)
+        parser->m_startCdataSectionHandler(parser->m_handlerArg);
+      /* BEGIN disabled code */
+      /* Suppose you doing a transformation on a document that involves
+         changing only the character data.  You set up a defaultHandler
+         and a characterDataHandler.  The defaultHandler simply copies
+         characters through.  The characterDataHandler does the
+         transformation and writes the characters out escaping them as
+         necessary.  This case will fail to work if we leave out the
+         following two lines (because & and < inside CDATA sections will
+         be incorrectly escaped).
+
+         However, now we have a start/endCdataSectionHandler, so it seems
+         easier to let the user deal with this.
+      */
+      else if ((0) && parser->m_characterDataHandler)
+        parser->m_characterDataHandler(parser->m_handlerArg, parser->m_dataBuf,
+                                       0);
+      /* END disabled code */
+      else if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, next);
+      result
+          = doCdataSection(parser, enc, &next, end, nextPtr, haveMore, account);
+      if (result != XML_ERROR_NONE)
+        return result;
+      else if (! next) {
+        parser->m_processor = cdataSectionProcessor;
+        return result;
+      }
+    } break;
+    case XML_TOK_TRAILING_RSQB:
+      if (haveMore) {
+        *nextPtr = s;
+        return XML_ERROR_NONE;
+      }
+      if (parser->m_characterDataHandler) {
+        if (MUST_CONVERT(enc, s)) {
+          ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
+          XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
+          parser->m_characterDataHandler(
+              parser->m_handlerArg, parser->m_dataBuf,
+              (int)(dataPtr - (ICHAR *)parser->m_dataBuf));
+        } else
+          parser->m_characterDataHandler(
+              parser->m_handlerArg, (const XML_Char *)s,
+              (int)((const XML_Char *)end - (const XML_Char *)s));
+      } else if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, end);
+      /* We are at the end of the final buffer, should we check for
+         XML_SUSPENDED, XML_FINISHED?
+      */
+      if (startTagLevel == 0) {
+        *eventPP = end;
+        return XML_ERROR_NO_ELEMENTS;
+      }
+      if (parser->m_tagLevel != startTagLevel) {
+        *eventPP = end;
+        return XML_ERROR_ASYNC_ENTITY;
+      }
+      *nextPtr = end;
+      return XML_ERROR_NONE;
+    case XML_TOK_DATA_CHARS: {
+      XML_CharacterDataHandler charDataHandler = parser->m_characterDataHandler;
+      if (charDataHandler) {
+        if (MUST_CONVERT(enc, s)) {
+          for (;;) {
+            ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
+            const enum XML_Convert_Result convert_res = XmlConvert(
+                enc, &s, next, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
+            *eventEndPP = s;
+            charDataHandler(parser->m_handlerArg, parser->m_dataBuf,
+                            (int)(dataPtr - (ICHAR *)parser->m_dataBuf));
+            if ((convert_res == XML_CONVERT_COMPLETED)
+                || (convert_res == XML_CONVERT_INPUT_INCOMPLETE))
+              break;
+            *eventPP = s;
+          }
+        } else
+          charDataHandler(parser->m_handlerArg, (const XML_Char *)s,
+                          (int)((const XML_Char *)next - (const XML_Char *)s));
+      } else if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, next);
+    } break;
+    case XML_TOK_PI:
+      if (! reportProcessingInstruction(parser, enc, s, next))
+        return XML_ERROR_NO_MEMORY;
+      break;
+    case XML_TOK_COMMENT:
+      if (! reportComment(parser, enc, s, next))
+        return XML_ERROR_NO_MEMORY;
+      break;
+    default:
+      /* All of the tokens produced by XmlContentTok() have their own
+       * explicit cases, so this default is not strictly necessary.
+       * However it is a useful safety net, so we retain the code and
+       * simply exclude it from the coverage tests.
+       *
+       * LCOV_EXCL_START
+       */
+      if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, next);
+      break;
+      /* LCOV_EXCL_STOP */
+    }
+    *eventPP = s = next;
+    switch (parser->m_parsingStatus.parsing) {
+    case XML_SUSPENDED:
+      *nextPtr = next;
+      return XML_ERROR_NONE;
+    case XML_FINISHED:
+      return XML_ERROR_ABORTED;
+    default:;
+    }
+  }
+  /* not reached */
+}
+
+/* This function does not call free() on the allocated memory, merely
+ * moving it to the parser's m_freeBindingList where it can be freed or
+ * reused as appropriate.
+ */
+static void
+freeBindings(XML_Parser parser, BINDING *bindings) {
+  while (bindings) {
+    BINDING *b = bindings;
+
+    /* m_startNamespaceDeclHandler will have been called for this
+     * binding in addBindings(), so call the end handler now.
+     */
+    if (parser->m_endNamespaceDeclHandler)
+      parser->m_endNamespaceDeclHandler(parser->m_handlerArg, b->prefix->name);
+
+    bindings = bindings->nextTagBinding;
+    b->nextTagBinding = parser->m_freeBindingList;
+    parser->m_freeBindingList = b;
+    b->prefix->binding = b->prevPrefixBinding;
+  }
+}
+
+/* Precondition: all arguments must be non-NULL;
+   Purpose:
+   - normalize attributes
+   - check attributes for well-formedness
+   - generate namespace aware attribute names (URI, prefix)
+   - build list of attributes for startElementHandler
+   - default attributes
+   - process namespace declarations (check and report them)
+   - generate namespace aware element name (URI, prefix)
+*/
+static enum XML_Error
+storeAtts(XML_Parser parser, const ENCODING *enc, const char *attStr,
+          TAG_NAME *tagNamePtr, BINDING **bindingsPtr,
+          enum XML_Account account) {
+  DTD *const dtd = parser->m_dtd; /* save one level of indirection */
+  ELEMENT_TYPE *elementType;
+  int nDefaultAtts;
+  const XML_Char **appAtts; /* the attribute list for the application */
+  int attIndex = 0;
+  int prefixLen;
+  int i;
+  int n;
+  XML_Char *uri;
+  int nPrefixes = 0;
+  BINDING *binding;
+  const XML_Char *localPart;
+
+  /* lookup the element type name */
+  elementType
+      = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, tagNamePtr->str, 0);
+  if (! elementType) {
+    const XML_Char *name = poolCopyString(&dtd->pool, tagNamePtr->str);
+    if (! name)
+      return XML_ERROR_NO_MEMORY;
+    elementType = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, name,
+                                         sizeof(ELEMENT_TYPE));
+    if (! elementType)
+      return XML_ERROR_NO_MEMORY;
+    if (parser->m_ns && ! setElementTypePrefix(parser, elementType))
+      return XML_ERROR_NO_MEMORY;
+  }
+  nDefaultAtts = elementType->nDefaultAtts;
+
+  /* get the attributes from the tokenizer */
+  n = XmlGetAttributes(enc, attStr, parser->m_attsSize, parser->m_atts);
+
+  /* Detect and prevent integer overflow */
+  if (n > INT_MAX - nDefaultAtts) {
+    return XML_ERROR_NO_MEMORY;
+  }
+
+  if (n + nDefaultAtts > parser->m_attsSize) {
+    int oldAttsSize = parser->m_attsSize;
+    ATTRIBUTE *temp;
+#ifdef XML_ATTR_INFO
+    XML_AttrInfo *temp2;
+#endif
+
+    /* Detect and prevent integer overflow */
+    if ((nDefaultAtts > INT_MAX - INIT_ATTS_SIZE)
+        || (n > INT_MAX - (nDefaultAtts + INIT_ATTS_SIZE))) {
+      return XML_ERROR_NO_MEMORY;
+    }
+
+    parser->m_attsSize = n + nDefaultAtts + INIT_ATTS_SIZE;
+
+    /* Detect and prevent integer overflow.
+     * The preprocessor guard addresses the "always false" warning
+     * from -Wtype-limits on platforms where
+     * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
+#if UINT_MAX >= SIZE_MAX
+    if ((unsigned)parser->m_attsSize > (size_t)(-1) / sizeof(ATTRIBUTE)) {
+      parser->m_attsSize = oldAttsSize;
+      return XML_ERROR_NO_MEMORY;
+    }
+#endif
+
+    temp = (ATTRIBUTE *)REALLOC(parser, (void *)parser->m_atts,
+                                parser->m_attsSize * sizeof(ATTRIBUTE));
+    if (temp == NULL) {
+      parser->m_attsSize = oldAttsSize;
+      return XML_ERROR_NO_MEMORY;
+    }
+    parser->m_atts = temp;
+#ifdef XML_ATTR_INFO
+    /* Detect and prevent integer overflow.
+     * The preprocessor guard addresses the "always false" warning
+     * from -Wtype-limits on platforms where
+     * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
+#  if UINT_MAX >= SIZE_MAX
+    if ((unsigned)parser->m_attsSize > (size_t)(-1) / sizeof(XML_AttrInfo)) {
+      parser->m_attsSize = oldAttsSize;
+      return XML_ERROR_NO_MEMORY;
+    }
+#  endif
+
+    temp2 = (XML_AttrInfo *)REALLOC(parser, (void *)parser->m_attInfo,
+                                    parser->m_attsSize * sizeof(XML_AttrInfo));
+    if (temp2 == NULL) {
+      parser->m_attsSize = oldAttsSize;
+      return XML_ERROR_NO_MEMORY;
+    }
+    parser->m_attInfo = temp2;
+#endif
+    if (n > oldAttsSize)
+      XmlGetAttributes(enc, attStr, n, parser->m_atts);
+  }
+
+  appAtts = (const XML_Char **)parser->m_atts;
+  for (i = 0; i < n; i++) {
+    ATTRIBUTE *currAtt = &parser->m_atts[i];
+#ifdef XML_ATTR_INFO
+    XML_AttrInfo *currAttInfo = &parser->m_attInfo[i];
+#endif
+    /* add the name and value to the attribute list */
+    ATTRIBUTE_ID *attId
+        = getAttributeId(parser, enc, currAtt->name,
+                         currAtt->name + XmlNameLength(enc, currAtt->name));
+    if (! attId)
+      return XML_ERROR_NO_MEMORY;
+#ifdef XML_ATTR_INFO
+    currAttInfo->nameStart
+        = parser->m_parseEndByteIndex - (parser->m_parseEndPtr - currAtt->name);
+    currAttInfo->nameEnd
+        = currAttInfo->nameStart + XmlNameLength(enc, currAtt->name);
+    currAttInfo->valueStart = parser->m_parseEndByteIndex
+                              - (parser->m_parseEndPtr - currAtt->valuePtr);
+    currAttInfo->valueEnd = parser->m_parseEndByteIndex
+                            - (parser->m_parseEndPtr - currAtt->valueEnd);
+#endif
+    /* Detect duplicate attributes by their QNames. This does not work when
+       namespace processing is turned on and different prefixes for the same
+       namespace are used. For this case we have a check further down.
+    */
+    if ((attId->name)[-1]) {
+      if (enc == parser->m_encoding)
+        parser->m_eventPtr = parser->m_atts[i].name;
+      return XML_ERROR_DUPLICATE_ATTRIBUTE;
+    }
+    (attId->name)[-1] = 1;
+    appAtts[attIndex++] = attId->name;
+    if (! parser->m_atts[i].normalized) {
+      enum XML_Error result;
+      XML_Bool isCdata = XML_TRUE;
+
+      /* figure out whether declared as other than CDATA */
+      if (attId->maybeTokenized) {
+        int j;
+        for (j = 0; j < nDefaultAtts; j++) {
+          if (attId == elementType->defaultAtts[j].id) {
+            isCdata = elementType->defaultAtts[j].isCdata;
+            break;
+          }
+        }
+      }
+
+      /* normalize the attribute value */
+      result = storeAttributeValue(
+          parser, enc, isCdata, parser->m_atts[i].valuePtr,
+          parser->m_atts[i].valueEnd, &parser->m_tempPool, account);
+      if (result)
+        return result;
+      appAtts[attIndex] = poolStart(&parser->m_tempPool);
+      poolFinish(&parser->m_tempPool);
+    } else {
+      /* the value did not need normalizing */
+      appAtts[attIndex] = poolStoreString(&parser->m_tempPool, enc,
+                                          parser->m_atts[i].valuePtr,
+                                          parser->m_atts[i].valueEnd);
+      if (appAtts[attIndex] == 0)
+        return XML_ERROR_NO_MEMORY;
+      poolFinish(&parser->m_tempPool);
+    }
+    /* handle prefixed attribute names */
+    if (attId->prefix) {
+      if (attId->xmlns) {
+        /* deal with namespace declarations here */
+        enum XML_Error result = addBinding(parser, attId->prefix, attId,
+                                           appAtts[attIndex], bindingsPtr);
+        if (result)
+          return result;
+        --attIndex;
+      } else {
+        /* deal with other prefixed names later */
+        attIndex++;
+        nPrefixes++;
+        (attId->name)[-1] = 2;
+      }
+    } else
+      attIndex++;
+  }
+
+  /* set-up for XML_GetSpecifiedAttributeCount and XML_GetIdAttributeIndex */
+  parser->m_nSpecifiedAtts = attIndex;
+  if (elementType->idAtt && (elementType->idAtt->name)[-1]) {
+    for (i = 0; i < attIndex; i += 2)
+      if (appAtts[i] == elementType->idAtt->name) {
+        parser->m_idAttIndex = i;
+        break;
+      }
+  } else
+    parser->m_idAttIndex = -1;
+
+  /* do attribute defaulting */
+  for (i = 0; i < nDefaultAtts; i++) {
+    const DEFAULT_ATTRIBUTE *da = elementType->defaultAtts + i;
+    if (! (da->id->name)[-1] && da->value) {
+      if (da->id->prefix) {
+        if (da->id->xmlns) {
+          enum XML_Error result = addBinding(parser, da->id->prefix, da->id,
+                                             da->value, bindingsPtr);
+          if (result)
+            return result;
+        } else {
+          (da->id->name)[-1] = 2;
+          nPrefixes++;
+          appAtts[attIndex++] = da->id->name;
+          appAtts[attIndex++] = da->value;
+        }
+      } else {
+        (da->id->name)[-1] = 1;
+        appAtts[attIndex++] = da->id->name;
+        appAtts[attIndex++] = da->value;
+      }
+    }
+  }
+  appAtts[attIndex] = 0;
+
+  /* expand prefixed attribute names, check for duplicates,
+     and clear flags that say whether attributes were specified */
+  i = 0;
+  if (nPrefixes) {
+    int j; /* hash table index */
+    unsigned long version = parser->m_nsAttsVersion;
+
+    /* Detect and prevent invalid shift */
+    if (parser->m_nsAttsPower >= sizeof(unsigned int) * 8 /* bits per byte */) {
+      return XML_ERROR_NO_MEMORY;
+    }
+
+    unsigned int nsAttsSize = 1u << parser->m_nsAttsPower;
+    unsigned char oldNsAttsPower = parser->m_nsAttsPower;
+    /* size of hash table must be at least 2 * (# of prefixed attributes) */
+    if ((nPrefixes << 1)
+        >> parser->m_nsAttsPower) { /* true for m_nsAttsPower = 0 */
+      NS_ATT *temp;
+      /* hash table size must also be a power of 2 and >= 8 */
+      while (nPrefixes >> parser->m_nsAttsPower++)
+        ;
+      if (parser->m_nsAttsPower < 3)
+        parser->m_nsAttsPower = 3;
+
+      /* Detect and prevent invalid shift */
+      if (parser->m_nsAttsPower >= sizeof(nsAttsSize) * 8 /* bits per byte */) {
+        /* Restore actual size of memory in m_nsAtts */
+        parser->m_nsAttsPower = oldNsAttsPower;
+        return XML_ERROR_NO_MEMORY;
+      }
+
+      nsAttsSize = 1u << parser->m_nsAttsPower;
+
+      /* Detect and prevent integer overflow.
+       * The preprocessor guard addresses the "always false" warning
+       * from -Wtype-limits on platforms where
+       * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
+#if UINT_MAX >= SIZE_MAX
+      if (nsAttsSize > (size_t)(-1) / sizeof(NS_ATT)) {
+        /* Restore actual size of memory in m_nsAtts */
+        parser->m_nsAttsPower = oldNsAttsPower;
+        return XML_ERROR_NO_MEMORY;
+      }
+#endif
+
+      temp = (NS_ATT *)REALLOC(parser, parser->m_nsAtts,
+                               nsAttsSize * sizeof(NS_ATT));
+      if (! temp) {
+        /* Restore actual size of memory in m_nsAtts */
+        parser->m_nsAttsPower = oldNsAttsPower;
+        return XML_ERROR_NO_MEMORY;
+      }
+      parser->m_nsAtts = temp;
+      version = 0; /* force re-initialization of m_nsAtts hash table */
+    }
+    /* using a version flag saves us from initializing m_nsAtts every time */
+    if (! version) { /* initialize version flags when version wraps around */
+      version = INIT_ATTS_VERSION;
+      for (j = nsAttsSize; j != 0;)
+        parser->m_nsAtts[--j].version = version;
+    }
+    parser->m_nsAttsVersion = --version;
+
+    /* expand prefixed names and check for duplicates */
+    for (; i < attIndex; i += 2) {
+      const XML_Char *s = appAtts[i];
+      if (s[-1] == 2) { /* prefixed */
+        ATTRIBUTE_ID *id;
+        const BINDING *b;
+        unsigned long uriHash;
+        struct siphash sip_state;
+        struct sipkey sip_key;
+
+        copy_salt_to_sipkey(parser, &sip_key);
+        sip24_init(&sip_state, &sip_key);
+
+        ((XML_Char *)s)[-1] = 0; /* clear flag */
+        id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, s, 0);
+        if (! id || ! id->prefix) {
+          /* This code is walking through the appAtts array, dealing
+           * with (in this case) a prefixed attribute name.  To be in
+           * the array, the attribute must have already been bound, so
+           * has to have passed through the hash table lookup once
+           * already.  That implies that an entry for it already
+           * exists, so the lookup above will return a pointer to
+           * already allocated memory.  There is no opportunaity for
+           * the allocator to fail, so the condition above cannot be
+           * fulfilled.
+           *
+           * Since it is difficult to be certain that the above
+           * analysis is complete, we retain the test and merely
+           * remove the code from coverage tests.
+           */
+          return XML_ERROR_NO_MEMORY; /* LCOV_EXCL_LINE */
+        }
+        b = id->prefix->binding;
+        if (! b)
+          return XML_ERROR_UNBOUND_PREFIX;
+
+        for (j = 0; j < b->uriLen; j++) {
+          const XML_Char c = b->uri[j];
+          if (! poolAppendChar(&parser->m_tempPool, c))
+            return XML_ERROR_NO_MEMORY;
+        }
+
+        sip24_update(&sip_state, b->uri, b->uriLen * sizeof(XML_Char));
+
+        while (*s++ != XML_T(ASCII_COLON))
+          ;
+
+        sip24_update(&sip_state, s, keylen(s) * sizeof(XML_Char));
+
+        do { /* copies null terminator */
+          if (! poolAppendChar(&parser->m_tempPool, *s))
+            return XML_ERROR_NO_MEMORY;
+        } while (*s++);
+
+        uriHash = (unsigned long)sip24_final(&sip_state);
+
+        { /* Check hash table for duplicate of expanded name (uriName).
+             Derived from code in lookup(parser, HASH_TABLE *table, ...).
+          */
+          unsigned char step = 0;
+          unsigned long mask = nsAttsSize - 1;
+          j = uriHash & mask; /* index into hash table */
+          while (parser->m_nsAtts[j].version == version) {
+            /* for speed we compare stored hash values first */
+            if (uriHash == parser->m_nsAtts[j].hash) {
+              const XML_Char *s1 = poolStart(&parser->m_tempPool);
+              const XML_Char *s2 = parser->m_nsAtts[j].uriName;
+              /* s1 is null terminated, but not s2 */
+              for (; *s1 == *s2 && *s1 != 0; s1++, s2++)
+                ;
+              if (*s1 == 0)
+                return XML_ERROR_DUPLICATE_ATTRIBUTE;
+            }
+            if (! step)
+              step = PROBE_STEP(uriHash, mask, parser->m_nsAttsPower);
+            j < step ? (j += nsAttsSize - step) : (j -= step);
+          }
+        }
+
+        if (parser->m_ns_triplets) { /* append namespace separator and prefix */
+          parser->m_tempPool.ptr[-1] = parser->m_namespaceSeparator;
+          s = b->prefix->name;
+          do {
+            if (! poolAppendChar(&parser->m_tempPool, *s))
+              return XML_ERROR_NO_MEMORY;
+          } while (*s++);
+        }
+
+        /* store expanded name in attribute list */
+        s = poolStart(&parser->m_tempPool);
+        poolFinish(&parser->m_tempPool);
+        appAtts[i] = s;
+
+        /* fill empty slot with new version, uriName and hash value */
+        parser->m_nsAtts[j].version = version;
+        parser->m_nsAtts[j].hash = uriHash;
+        parser->m_nsAtts[j].uriName = s;
+
+        if (! --nPrefixes) {
+          i += 2;
+          break;
+        }
+      } else                     /* not prefixed */
+        ((XML_Char *)s)[-1] = 0; /* clear flag */
+    }
+  }
+  /* clear flags for the remaining attributes */
+  for (; i < attIndex; i += 2)
+    ((XML_Char *)(appAtts[i]))[-1] = 0;
+  for (binding = *bindingsPtr; binding; binding = binding->nextTagBinding)
+    binding->attId->name[-1] = 0;
+
+  if (! parser->m_ns)
+    return XML_ERROR_NONE;
+
+  /* expand the element type name */
+  if (elementType->prefix) {
+    binding = elementType->prefix->binding;
+    if (! binding)
+      return XML_ERROR_UNBOUND_PREFIX;
+    localPart = tagNamePtr->str;
+    while (*localPart++ != XML_T(ASCII_COLON))
+      ;
+  } else if (dtd->defaultPrefix.binding) {
+    binding = dtd->defaultPrefix.binding;
+    localPart = tagNamePtr->str;
+  } else
+    return XML_ERROR_NONE;
+  prefixLen = 0;
+  if (parser->m_ns_triplets && binding->prefix->name) {
+    for (; binding->prefix->name[prefixLen++];)
+      ; /* prefixLen includes null terminator */
+  }
+  tagNamePtr->localPart = localPart;
+  tagNamePtr->uriLen = binding->uriLen;
+  tagNamePtr->prefix = binding->prefix->name;
+  tagNamePtr->prefixLen = prefixLen;
+  for (i = 0; localPart[i++];)
+    ; /* i includes null terminator */
+
+  /* Detect and prevent integer overflow */
+  if (binding->uriLen > INT_MAX - prefixLen
+      || i > INT_MAX - (binding->uriLen + prefixLen)) {
+    return XML_ERROR_NO_MEMORY;
+  }
+
+  n = i + binding->uriLen + prefixLen;
+  if (n > binding->uriAlloc) {
+    TAG *p;
+
+    /* Detect and prevent integer overflow */
+    if (n > INT_MAX - EXPAND_SPARE) {
+      return XML_ERROR_NO_MEMORY;
+    }
+    /* Detect and prevent integer overflow.
+     * The preprocessor guard addresses the "always false" warning
+     * from -Wtype-limits on platforms where
+     * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
+#if UINT_MAX >= SIZE_MAX
+    if ((unsigned)(n + EXPAND_SPARE) > (size_t)(-1) / sizeof(XML_Char)) {
+      return XML_ERROR_NO_MEMORY;
+    }
+#endif
+
+    uri = (XML_Char *)MALLOC(parser, (n + EXPAND_SPARE) * sizeof(XML_Char));
+    if (! uri)
+      return XML_ERROR_NO_MEMORY;
+    binding->uriAlloc = n + EXPAND_SPARE;
+    memcpy(uri, binding->uri, binding->uriLen * sizeof(XML_Char));
+    for (p = parser->m_tagStack; p; p = p->parent)
+      if (p->name.str == binding->uri)
+        p->name.str = uri;
+    FREE(parser, binding->uri);
+    binding->uri = uri;
+  }
+  /* if m_namespaceSeparator != '\0' then uri includes it already */
+  uri = binding->uri + binding->uriLen;
+  memcpy(uri, localPart, i * sizeof(XML_Char));
+  /* we always have a namespace separator between localPart and prefix */
+  if (prefixLen) {
+    uri += i - 1;
+    *uri = parser->m_namespaceSeparator; /* replace null terminator */
+    memcpy(uri + 1, binding->prefix->name, prefixLen * sizeof(XML_Char));
+  }
+  tagNamePtr->str = binding->uri;
+  return XML_ERROR_NONE;
+}
+
+static XML_Bool
+is_rfc3986_uri_char(XML_Char candidate) {
+  // For the RFC 3986 ANBF grammar see
+  // https://datatracker.ietf.org/doc/html/rfc3986#appendix-A
+
+  switch (candidate) {
+  // From rule "ALPHA" (uppercase half)
+  case 'A':
+  case 'B':
+  case 'C':
+  case 'D':
+  case 'E':
+  case 'F':
+  case 'G':
+  case 'H':
+  case 'I':
+  case 'J':
+  case 'K':
+  case 'L':
+  case 'M':
+  case 'N':
+  case 'O':
+  case 'P':
+  case 'Q':
+  case 'R':
+  case 'S':
+  case 'T':
+  case 'U':
+  case 'V':
+  case 'W':
+  case 'X':
+  case 'Y':
+  case 'Z':
+
+  // From rule "ALPHA" (lowercase half)
+  case 'a':
+  case 'b':
+  case 'c':
+  case 'd':
+  case 'e':
+  case 'f':
+  case 'g':
+  case 'h':
+  case 'i':
+  case 'j':
+  case 'k':
+  case 'l':
+  case 'm':
+  case 'n':
+  case 'o':
+  case 'p':
+  case 'q':
+  case 'r':
+  case 's':
+  case 't':
+  case 'u':
+  case 'v':
+  case 'w':
+  case 'x':
+  case 'y':
+  case 'z':
+
+  // From rule "DIGIT"
+  case '0':
+  case '1':
+  case '2':
+  case '3':
+  case '4':
+  case '5':
+  case '6':
+  case '7':
+  case '8':
+  case '9':
+
+  // From rule "pct-encoded"
+  case '%':
+
+  // From rule "unreserved"
+  case '-':
+  case '.':
+  case '_':
+  case '~':
+
+  // From rule "gen-delims"
+  case ':':
+  case '/':
+  case '?':
+  case '#':
+  case '[':
+  case ']':
+  case '@':
+
+  // From rule "sub-delims"
+  case '!':
+  case '$':
+  case '&':
+  case '\'':
+  case '(':
+  case ')':
+  case '*':
+  case '+':
+  case ',':
+  case ';':
+  case '=':
+    return XML_TRUE;
+
+  default:
+    return XML_FALSE;
+  }
+}
+
+/* addBinding() overwrites the value of prefix->binding without checking.
+   Therefore one must keep track of the old value outside of addBinding().
+*/
+static enum XML_Error
+addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,
+           const XML_Char *uri, BINDING **bindingsPtr) {
+  // "http://www.w3.org/XML/1998/namespace"
+  static const XML_Char xmlNamespace[]
+      = {ASCII_h,      ASCII_t,     ASCII_t,     ASCII_p,      ASCII_COLON,
+         ASCII_SLASH,  ASCII_SLASH, ASCII_w,     ASCII_w,      ASCII_w,
+         ASCII_PERIOD, ASCII_w,     ASCII_3,     ASCII_PERIOD, ASCII_o,
+         ASCII_r,      ASCII_g,     ASCII_SLASH, ASCII_X,      ASCII_M,
+         ASCII_L,      ASCII_SLASH, ASCII_1,     ASCII_9,      ASCII_9,
+         ASCII_8,      ASCII_SLASH, ASCII_n,     ASCII_a,      ASCII_m,
+         ASCII_e,      ASCII_s,     ASCII_p,     ASCII_a,      ASCII_c,
+         ASCII_e,      '\0'};
+  static const int xmlLen = (int)sizeof(xmlNamespace) / sizeof(XML_Char) - 1;
+  // "http://www.w3.org/2000/xmlns/"
+  static const XML_Char xmlnsNamespace[]
+      = {ASCII_h,     ASCII_t,      ASCII_t, ASCII_p, ASCII_COLON,  ASCII_SLASH,
+         ASCII_SLASH, ASCII_w,      ASCII_w, ASCII_w, ASCII_PERIOD, ASCII_w,
+         ASCII_3,     ASCII_PERIOD, ASCII_o, ASCII_r, ASCII_g,      ASCII_SLASH,
+         ASCII_2,     ASCII_0,      ASCII_0, ASCII_0, ASCII_SLASH,  ASCII_x,
+         ASCII_m,     ASCII_l,      ASCII_n, ASCII_s, ASCII_SLASH,  '\0'};
+  static const int xmlnsLen
+      = (int)sizeof(xmlnsNamespace) / sizeof(XML_Char) - 1;
+
+  XML_Bool mustBeXML = XML_FALSE;
+  XML_Bool isXML = XML_TRUE;
+  XML_Bool isXMLNS = XML_TRUE;
+
+  BINDING *b;
+  int len;
+
+  /* empty URI is only valid for default namespace per XML NS 1.0 (not 1.1) */
+  if (*uri == XML_T('\0') && prefix->name)
+    return XML_ERROR_UNDECLARING_PREFIX;
+
+  if (prefix->name && prefix->name[0] == XML_T(ASCII_x)
+      && prefix->name[1] == XML_T(ASCII_m)
+      && prefix->name[2] == XML_T(ASCII_l)) {
+    /* Not allowed to bind xmlns */
+    if (prefix->name[3] == XML_T(ASCII_n) && prefix->name[4] == XML_T(ASCII_s)
+        && prefix->name[5] == XML_T('\0'))
+      return XML_ERROR_RESERVED_PREFIX_XMLNS;
+
+    if (prefix->name[3] == XML_T('\0'))
+      mustBeXML = XML_TRUE;
+  }
+
+  for (len = 0; uri[len]; len++) {
+    if (isXML && (len > xmlLen || uri[len] != xmlNamespace[len]))
+      isXML = XML_FALSE;
+
+    if (! mustBeXML && isXMLNS
+        && (len > xmlnsLen || uri[len] != xmlnsNamespace[len]))
+      isXMLNS = XML_FALSE;
+
+    // NOTE: While Expat does not validate namespace URIs against RFC 3986
+    //       today (and is not REQUIRED to do so with regard to the XML 1.0
+    //       namespaces specification) we have to at least make sure, that
+    //       the application on top of Expat (that is likely splitting expanded
+    //       element names ("qualified names") of form
+    //       "[uri sep] local [sep prefix] '\0'" back into 1, 2 or 3 pieces
+    //       in its element handler code) cannot be confused by an attacker
+    //       putting additional namespace separator characters into namespace
+    //       declarations.  That would be ambiguous and not to be expected.
+    //
+    //       While the HTML API docs of function XML_ParserCreateNS have been
+    //       advising against use of a namespace separator character that can
+    //       appear in a URI for >20 years now, some widespread applications
+    //       are using URI characters (':' (colon) in particular) for a
+    //       namespace separator, in practice.  To keep these applications
+    //       functional, we only reject namespaces URIs containing the
+    //       application-chosen namespace separator if the chosen separator
+    //       is a non-URI character with regard to RFC 3986.
+    if (parser->m_ns && (uri[len] == parser->m_namespaceSeparator)
+        && ! is_rfc3986_uri_char(uri[len])) {
+      return XML_ERROR_SYNTAX;
+    }
+  }
+  isXML = isXML && len == xmlLen;
+  isXMLNS = isXMLNS && len == xmlnsLen;
+
+  if (mustBeXML != isXML)
+    return mustBeXML ? XML_ERROR_RESERVED_PREFIX_XML
+                     : XML_ERROR_RESERVED_NAMESPACE_URI;
+
+  if (isXMLNS)
+    return XML_ERROR_RESERVED_NAMESPACE_URI;
+
+  if (parser->m_namespaceSeparator)
+    len++;
+  if (parser->m_freeBindingList) {
+    b = parser->m_freeBindingList;
+    if (len > b->uriAlloc) {
+      /* Detect and prevent integer overflow */
+      if (len > INT_MAX - EXPAND_SPARE) {
+        return XML_ERROR_NO_MEMORY;
+      }
+
+      /* Detect and prevent integer overflow.
+       * The preprocessor guard addresses the "always false" warning
+       * from -Wtype-limits on platforms where
+       * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
+#if UINT_MAX >= SIZE_MAX
+      if ((unsigned)(len + EXPAND_SPARE) > (size_t)(-1) / sizeof(XML_Char)) {
+        return XML_ERROR_NO_MEMORY;
+      }
+#endif
+
+      XML_Char *temp = (XML_Char *)REALLOC(
+          parser, b->uri, sizeof(XML_Char) * (len + EXPAND_SPARE));
+      if (temp == NULL)
+        return XML_ERROR_NO_MEMORY;
+      b->uri = temp;
+      b->uriAlloc = len + EXPAND_SPARE;
+    }
+    parser->m_freeBindingList = b->nextTagBinding;
+  } else {
+    b = (BINDING *)MALLOC(parser, sizeof(BINDING));
+    if (! b)
+      return XML_ERROR_NO_MEMORY;
+
+    /* Detect and prevent integer overflow */
+    if (len > INT_MAX - EXPAND_SPARE) {
+      return XML_ERROR_NO_MEMORY;
+    }
+    /* Detect and prevent integer overflow.
+     * The preprocessor guard addresses the "always false" warning
+     * from -Wtype-limits on platforms where
+     * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
+#if UINT_MAX >= SIZE_MAX
+    if ((unsigned)(len + EXPAND_SPARE) > (size_t)(-1) / sizeof(XML_Char)) {
+      return XML_ERROR_NO_MEMORY;
+    }
+#endif
+
+    b->uri
+        = (XML_Char *)MALLOC(parser, sizeof(XML_Char) * (len + EXPAND_SPARE));
+    if (! b->uri) {
+      FREE(parser, b);
+      return XML_ERROR_NO_MEMORY;
+    }
+    b->uriAlloc = len + EXPAND_SPARE;
+  }
+  b->uriLen = len;
+  memcpy(b->uri, uri, len * sizeof(XML_Char));
+  if (parser->m_namespaceSeparator)
+    b->uri[len - 1] = parser->m_namespaceSeparator;
+  b->prefix = prefix;
+  b->attId = attId;
+  b->prevPrefixBinding = prefix->binding;
+  /* NULL binding when default namespace undeclared */
+  if (*uri == XML_T('\0') && prefix == &parser->m_dtd->defaultPrefix)
+    prefix->binding = NULL;
+  else
+    prefix->binding = b;
+  b->nextTagBinding = *bindingsPtr;
+  *bindingsPtr = b;
+  /* if attId == NULL then we are not starting a namespace scope */
+  if (attId && parser->m_startNamespaceDeclHandler)
+    parser->m_startNamespaceDeclHandler(parser->m_handlerArg, prefix->name,
+                                        prefix->binding ? uri : 0);
+  return XML_ERROR_NONE;
+}
+
+/* The idea here is to avoid using stack for each CDATA section when
+   the whole file is parsed with one call.
+*/
+static enum XML_Error PTRCALL
+cdataSectionProcessor(XML_Parser parser, const char *start, const char *end,
+                      const char **endPtr) {
+  enum XML_Error result = doCdataSection(
+      parser, parser->m_encoding, &start, end, endPtr,
+      (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_ACCOUNT_DIRECT);
+  if (result != XML_ERROR_NONE)
+    return result;
+  if (start) {
+    if (parser->m_parentParser) { /* we are parsing an external entity */
+      parser->m_processor = externalEntityContentProcessor;
+      return externalEntityContentProcessor(parser, start, end, endPtr);
+    } else {
+      parser->m_processor = contentProcessor;
+      return contentProcessor(parser, start, end, endPtr);
+    }
+  }
+  return result;
+}
+
+/* startPtr gets set to non-null if the section is closed, and to null if
+   the section is not yet closed.
+*/
+static enum XML_Error
+doCdataSection(XML_Parser parser, const ENCODING *enc, const char **startPtr,
+               const char *end, const char **nextPtr, XML_Bool haveMore,
+               enum XML_Account account) {
+  const char *s = *startPtr;
+  const char **eventPP;
+  const char **eventEndPP;
+  if (enc == parser->m_encoding) {
+    eventPP = &parser->m_eventPtr;
+    *eventPP = s;
+    eventEndPP = &parser->m_eventEndPtr;
+  } else {
+    eventPP = &(parser->m_openInternalEntities->internalEventPtr);
+    eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
+  }
+  *eventPP = s;
+  *startPtr = NULL;
+
+  for (;;) {
+    const char *next = s; /* in case of XML_TOK_NONE or XML_TOK_PARTIAL */
+    int tok = XmlCdataSectionTok(enc, s, end, &next);
+#if XML_GE == 1
+    if (! accountingDiffTolerated(parser, tok, s, next, __LINE__, account)) {
+      accountingOnAbort(parser);
+      return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
+    }
+#else
+    UNUSED_P(account);
+#endif
+    *eventEndPP = next;
+    switch (tok) {
+    case XML_TOK_CDATA_SECT_CLOSE:
+      if (parser->m_endCdataSectionHandler)
+        parser->m_endCdataSectionHandler(parser->m_handlerArg);
+      /* BEGIN disabled code */
+      /* see comment under XML_TOK_CDATA_SECT_OPEN */
+      else if ((0) && parser->m_characterDataHandler)
+        parser->m_characterDataHandler(parser->m_handlerArg, parser->m_dataBuf,
+                                       0);
+      /* END disabled code */
+      else if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, next);
+      *startPtr = next;
+      *nextPtr = next;
+      if (parser->m_parsingStatus.parsing == XML_FINISHED)
+        return XML_ERROR_ABORTED;
+      else
+        return XML_ERROR_NONE;
+    case XML_TOK_DATA_NEWLINE:
+      if (parser->m_characterDataHandler) {
+        XML_Char c = 0xA;
+        parser->m_characterDataHandler(parser->m_handlerArg, &c, 1);
+      } else if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, next);
+      break;
+    case XML_TOK_DATA_CHARS: {
+      XML_CharacterDataHandler charDataHandler = parser->m_characterDataHandler;
+      if (charDataHandler) {
+        if (MUST_CONVERT(enc, s)) {
+          for (;;) {
+            ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
+            const enum XML_Convert_Result convert_res = XmlConvert(
+                enc, &s, next, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
+            *eventEndPP = next;
+            charDataHandler(parser->m_handlerArg, parser->m_dataBuf,
+                            (int)(dataPtr - (ICHAR *)parser->m_dataBuf));
+            if ((convert_res == XML_CONVERT_COMPLETED)
+                || (convert_res == XML_CONVERT_INPUT_INCOMPLETE))
+              break;
+            *eventPP = s;
+          }
+        } else
+          charDataHandler(parser->m_handlerArg, (const XML_Char *)s,
+                          (int)((const XML_Char *)next - (const XML_Char *)s));
+      } else if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, next);
+    } break;
+    case XML_TOK_INVALID:
+      *eventPP = next;
+      return XML_ERROR_INVALID_TOKEN;
+    case XML_TOK_PARTIAL_CHAR:
+      if (haveMore) {
+        *nextPtr = s;
+        return XML_ERROR_NONE;
+      }
+      return XML_ERROR_PARTIAL_CHAR;
+    case XML_TOK_PARTIAL:
+    case XML_TOK_NONE:
+      if (haveMore) {
+        *nextPtr = s;
+        return XML_ERROR_NONE;
+      }
+      return XML_ERROR_UNCLOSED_CDATA_SECTION;
+    default:
+      /* Every token returned by XmlCdataSectionTok() has its own
+       * explicit case, so this default case will never be executed.
+       * We retain it as a safety net and exclude it from the coverage
+       * statistics.
+       *
+       * LCOV_EXCL_START
+       */
+      *eventPP = next;
+      return XML_ERROR_UNEXPECTED_STATE;
+      /* LCOV_EXCL_STOP */
+    }
+
+    *eventPP = s = next;
+    switch (parser->m_parsingStatus.parsing) {
+    case XML_SUSPENDED:
+      *nextPtr = next;
+      return XML_ERROR_NONE;
+    case XML_FINISHED:
+      return XML_ERROR_ABORTED;
+    default:;
+    }
+  }
+  /* not reached */
+}
+
+#ifdef XML_DTD
+
+/* The idea here is to avoid using stack for each IGNORE section when
+   the whole file is parsed with one call.
+*/
+static enum XML_Error PTRCALL
+ignoreSectionProcessor(XML_Parser parser, const char *start, const char *end,
+                       const char **endPtr) {
+  enum XML_Error result
+      = doIgnoreSection(parser, parser->m_encoding, &start, end, endPtr,
+                        (XML_Bool)! parser->m_parsingStatus.finalBuffer);
+  if (result != XML_ERROR_NONE)
+    return result;
+  if (start) {
+    parser->m_processor = prologProcessor;
+    return prologProcessor(parser, start, end, endPtr);
+  }
+  return result;
+}
+
+/* startPtr gets set to non-null is the section is closed, and to null
+   if the section is not yet closed.
+*/
+static enum XML_Error
+doIgnoreSection(XML_Parser parser, const ENCODING *enc, const char **startPtr,
+                const char *end, const char **nextPtr, XML_Bool haveMore) {
+  const char *next = *startPtr; /* in case of XML_TOK_NONE or XML_TOK_PARTIAL */
+  int tok;
+  const char *s = *startPtr;
+  const char **eventPP;
+  const char **eventEndPP;
+  if (enc == parser->m_encoding) {
+    eventPP = &parser->m_eventPtr;
+    *eventPP = s;
+    eventEndPP = &parser->m_eventEndPtr;
+  } else {
+    /* It's not entirely clear, but it seems the following two lines
+     * of code cannot be executed.  The only occasions on which 'enc'
+     * is not 'encoding' are when this function is called
+     * from the internal entity processing, and IGNORE sections are an
+     * error in internal entities.
+     *
+     * Since it really isn't clear that this is true, we keep the code
+     * and just remove it from our coverage tests.
+     *
+     * LCOV_EXCL_START
+     */
+    eventPP = &(parser->m_openInternalEntities->internalEventPtr);
+    eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
+    /* LCOV_EXCL_STOP */
+  }
+  *eventPP = s;
+  *startPtr = NULL;
+  tok = XmlIgnoreSectionTok(enc, s, end, &next);
+#  if XML_GE == 1
+  if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,
+                                XML_ACCOUNT_DIRECT)) {
+    accountingOnAbort(parser);
+    return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
+  }
+#  endif
+  *eventEndPP = next;
+  switch (tok) {
+  case XML_TOK_IGNORE_SECT:
+    if (parser->m_defaultHandler)
+      reportDefault(parser, enc, s, next);
+    *startPtr = next;
+    *nextPtr = next;
+    if (parser->m_parsingStatus.parsing == XML_FINISHED)
+      return XML_ERROR_ABORTED;
+    else
+      return XML_ERROR_NONE;
+  case XML_TOK_INVALID:
+    *eventPP = next;
+    return XML_ERROR_INVALID_TOKEN;
+  case XML_TOK_PARTIAL_CHAR:
+    if (haveMore) {
+      *nextPtr = s;
+      return XML_ERROR_NONE;
+    }
+    return XML_ERROR_PARTIAL_CHAR;
+  case XML_TOK_PARTIAL:
+  case XML_TOK_NONE:
+    if (haveMore) {
+      *nextPtr = s;
+      return XML_ERROR_NONE;
+    }
+    return XML_ERROR_SYNTAX; /* XML_ERROR_UNCLOSED_IGNORE_SECTION */
+  default:
+    /* All of the tokens that XmlIgnoreSectionTok() returns have
+     * explicit cases to handle them, so this default case is never
+     * executed.  We keep it as a safety net anyway, and remove it
+     * from our test coverage statistics.
+     *
+     * LCOV_EXCL_START
+     */
+    *eventPP = next;
+    return XML_ERROR_UNEXPECTED_STATE;
+    /* LCOV_EXCL_STOP */
+  }
+  /* not reached */
+}
+
+#endif /* XML_DTD */
+
+static enum XML_Error
+initializeEncoding(XML_Parser parser) {
+  const char *s;
+#ifdef XML_UNICODE
+  char encodingBuf[128];
+  /* See comments about `protocolEncodingName` in parserInit() */
+  if (! parser->m_protocolEncodingName)
+    s = NULL;
+  else {
+    int i;
+    for (i = 0; parser->m_protocolEncodingName[i]; i++) {
+      if (i == sizeof(encodingBuf) - 1
+          || (parser->m_protocolEncodingName[i] & ~0x7f) != 0) {
+        encodingBuf[0] = '\0';
+        break;
+      }
+      encodingBuf[i] = (char)parser->m_protocolEncodingName[i];
+    }
+    encodingBuf[i] = '\0';
+    s = encodingBuf;
+  }
+#else
+  s = parser->m_protocolEncodingName;
+#endif
+  if ((parser->m_ns ? XmlInitEncodingNS : XmlInitEncoding)(
+          &parser->m_initEncoding, &parser->m_encoding, s))
+    return XML_ERROR_NONE;
+  return handleUnknownEncoding(parser, parser->m_protocolEncodingName);
+}
+
+static enum XML_Error
+processXmlDecl(XML_Parser parser, int isGeneralTextEntity, const char *s,
+               const char *next) {
+  const char *encodingName = NULL;
+  const XML_Char *storedEncName = NULL;
+  const ENCODING *newEncoding = NULL;
+  const char *version = NULL;
+  const char *versionend = NULL;
+  const XML_Char *storedversion = NULL;
+  int standalone = -1;
+
+#if XML_GE == 1
+  if (! accountingDiffTolerated(parser, XML_TOK_XML_DECL, s, next, __LINE__,
+                                XML_ACCOUNT_DIRECT)) {
+    accountingOnAbort(parser);
+    return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
+  }
+#endif
+
+  if (! (parser->m_ns ? XmlParseXmlDeclNS : XmlParseXmlDecl)(
+          isGeneralTextEntity, parser->m_encoding, s, next, &parser->m_eventPtr,
+          &version, &versionend, &encodingName, &newEncoding, &standalone)) {
+    if (isGeneralTextEntity)
+      return XML_ERROR_TEXT_DECL;
+    else
+      return XML_ERROR_XML_DECL;
+  }
+  if (! isGeneralTextEntity && standalone == 1) {
+    parser->m_dtd->standalone = XML_TRUE;
+#ifdef XML_DTD
+    if (parser->m_paramEntityParsing
+        == XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE)
+      parser->m_paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
+#endif /* XML_DTD */
+  }
+  if (parser->m_xmlDeclHandler) {
+    if (encodingName != NULL) {
+      storedEncName = poolStoreString(
+          &parser->m_temp2Pool, parser->m_encoding, encodingName,
+          encodingName + XmlNameLength(parser->m_encoding, encodingName));
+      if (! storedEncName)
+        return XML_ERROR_NO_MEMORY;
+      poolFinish(&parser->m_temp2Pool);
+    }
+    if (version) {
+      storedversion
+          = poolStoreString(&parser->m_temp2Pool, parser->m_encoding, version,
+                            versionend - parser->m_encoding->minBytesPerChar);
+      if (! storedversion)
+        return XML_ERROR_NO_MEMORY;
+    }
+    parser->m_xmlDeclHandler(parser->m_handlerArg, storedversion, storedEncName,
+                             standalone);
+  } else if (parser->m_defaultHandler)
+    reportDefault(parser, parser->m_encoding, s, next);
+  if (parser->m_protocolEncodingName == NULL) {
+    if (newEncoding) {
+      /* Check that the specified encoding does not conflict with what
+       * the parser has already deduced.  Do we have the same number
+       * of bytes in the smallest representation of a character?  If
+       * this is UTF-16, is it the same endianness?
+       */
+      if (newEncoding->minBytesPerChar != parser->m_encoding->minBytesPerChar
+          || (newEncoding->minBytesPerChar == 2
+              && newEncoding != parser->m_encoding)) {
+        parser->m_eventPtr = encodingName;
+        return XML_ERROR_INCORRECT_ENCODING;
+      }
+      parser->m_encoding = newEncoding;
+    } else if (encodingName) {
+      enum XML_Error result;
+      if (! storedEncName) {
+        storedEncName = poolStoreString(
+            &parser->m_temp2Pool, parser->m_encoding, encodingName,
+            encodingName + XmlNameLength(parser->m_encoding, encodingName));
+        if (! storedEncName)
+          return XML_ERROR_NO_MEMORY;
+      }
+      result = handleUnknownEncoding(parser, storedEncName);
+      poolClear(&parser->m_temp2Pool);
+      if (result == XML_ERROR_UNKNOWN_ENCODING)
+        parser->m_eventPtr = encodingName;
+      return result;
+    }
+  }
+
+  if (storedEncName || storedversion)
+    poolClear(&parser->m_temp2Pool);
+
+  return XML_ERROR_NONE;
+}
+
+static enum XML_Error
+handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName) {
+  if (parser->m_unknownEncodingHandler) {
+    XML_Encoding info;
+    int i;
+    for (i = 0; i < 256; i++)
+      info.map[i] = -1;
+    info.convert = NULL;
+    info.data = NULL;
+    info.release = NULL;
+    if (parser->m_unknownEncodingHandler(parser->m_unknownEncodingHandlerData,
+                                         encodingName, &info)) {
+      ENCODING *enc;
+      parser->m_unknownEncodingMem = MALLOC(parser, XmlSizeOfUnknownEncoding());
+      if (! parser->m_unknownEncodingMem) {
+        if (info.release)
+          info.release(info.data);
+        return XML_ERROR_NO_MEMORY;
+      }
+      enc = (parser->m_ns ? XmlInitUnknownEncodingNS : XmlInitUnknownEncoding)(
+          parser->m_unknownEncodingMem, info.map, info.convert, info.data);
+      if (enc) {
+        parser->m_unknownEncodingData = info.data;
+        parser->m_unknownEncodingRelease = info.release;
+        parser->m_encoding = enc;
+        return XML_ERROR_NONE;
+      }
+    }
+    if (info.release != NULL)
+      info.release(info.data);
+  }
+  return XML_ERROR_UNKNOWN_ENCODING;
+}
+
+static enum XML_Error PTRCALL
+prologInitProcessor(XML_Parser parser, const char *s, const char *end,
+                    const char **nextPtr) {
+  enum XML_Error result = initializeEncoding(parser);
+  if (result != XML_ERROR_NONE)
+    return result;
+  parser->m_processor = prologProcessor;
+  return prologProcessor(parser, s, end, nextPtr);
+}
+
+#ifdef XML_DTD
+
+static enum XML_Error PTRCALL
+externalParEntInitProcessor(XML_Parser parser, const char *s, const char *end,
+                            const char **nextPtr) {
+  enum XML_Error result = initializeEncoding(parser);
+  if (result != XML_ERROR_NONE)
+    return result;
+
+  /* we know now that XML_Parse(Buffer) has been called,
+     so we consider the external parameter entity read */
+  parser->m_dtd->paramEntityRead = XML_TRUE;
+
+  if (parser->m_prologState.inEntityValue) {
+    parser->m_processor = entityValueInitProcessor;
+    return entityValueInitProcessor(parser, s, end, nextPtr);
+  } else {
+    parser->m_processor = externalParEntProcessor;
+    return externalParEntProcessor(parser, s, end, nextPtr);
+  }
+}
+
+static enum XML_Error PTRCALL
+entityValueInitProcessor(XML_Parser parser, const char *s, const char *end,
+                         const char **nextPtr) {
+  int tok;
+  const char *start = s;
+  const char *next = start;
+  parser->m_eventPtr = start;
+
+  for (;;) {
+    tok = XmlPrologTok(parser->m_encoding, start, end, &next);
+    /* Note: Except for XML_TOK_BOM below, these bytes are accounted later in:
+             - storeEntityValue
+             - processXmlDecl
+    */
+    parser->m_eventEndPtr = next;
+    if (tok <= 0) {
+      if (! parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {
+        *nextPtr = s;
+        return XML_ERROR_NONE;
+      }
+      switch (tok) {
+      case XML_TOK_INVALID:
+        return XML_ERROR_INVALID_TOKEN;
+      case XML_TOK_PARTIAL:
+        return XML_ERROR_UNCLOSED_TOKEN;
+      case XML_TOK_PARTIAL_CHAR:
+        return XML_ERROR_PARTIAL_CHAR;
+      case XML_TOK_NONE: /* start == end */
+      default:
+        break;
+      }
+      /* found end of entity value - can store it now */
+      return storeEntityValue(parser, parser->m_encoding, s, end,
+                              XML_ACCOUNT_DIRECT);
+    } else if (tok == XML_TOK_XML_DECL) {
+      enum XML_Error result;
+      result = processXmlDecl(parser, 0, start, next);
+      if (result != XML_ERROR_NONE)
+        return result;
+      /* At this point, m_parsingStatus.parsing cannot be XML_SUSPENDED.  For
+       * that to happen, a parameter entity parsing handler must have attempted
+       * to suspend the parser, which fails and raises an error.  The parser can
+       * be aborted, but can't be suspended.
+       */
+      if (parser->m_parsingStatus.parsing == XML_FINISHED)
+        return XML_ERROR_ABORTED;
+      *nextPtr = next;
+      /* stop scanning for text declaration - we found one */
+      parser->m_processor = entityValueProcessor;
+      return entityValueProcessor(parser, next, end, nextPtr);
+    }
+    /* XmlPrologTok has now set the encoding based on the BOM it found, and we
+       must move s and nextPtr forward to consume the BOM.
+
+       If we didn't, and got XML_TOK_NONE from the next XmlPrologTok call, we
+       would leave the BOM in the buffer and return. On the next call to this
+       function, our XmlPrologTok call would return XML_TOK_INVALID, since it
+       is not valid to have multiple BOMs.
+    */
+    else if (tok == XML_TOK_BOM) {
+#  if XML_GE == 1
+      if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,
+                                    XML_ACCOUNT_DIRECT)) {
+        accountingOnAbort(parser);
+        return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
+      }
+#  endif
+
+      *nextPtr = next;
+      s = next;
+    }
+    /* If we get this token, we have the start of what might be a
+       normal tag, but not a declaration (i.e. it doesn't begin with
+       "<!").  In a DTD context, that isn't legal.
+    */
+    else if (tok == XML_TOK_INSTANCE_START) {
+      *nextPtr = next;
+      return XML_ERROR_SYNTAX;
+    }
+    start = next;
+    parser->m_eventPtr = start;
+  }
+}
+
+static enum XML_Error PTRCALL
+externalParEntProcessor(XML_Parser parser, const char *s, const char *end,
+                        const char **nextPtr) {
+  const char *next = s;
+  int tok;
+
+  tok = XmlPrologTok(parser->m_encoding, s, end, &next);
+  if (tok <= 0) {
+    if (! parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {
+      *nextPtr = s;
+      return XML_ERROR_NONE;
+    }
+    switch (tok) {
+    case XML_TOK_INVALID:
+      return XML_ERROR_INVALID_TOKEN;
+    case XML_TOK_PARTIAL:
+      return XML_ERROR_UNCLOSED_TOKEN;
+    case XML_TOK_PARTIAL_CHAR:
+      return XML_ERROR_PARTIAL_CHAR;
+    case XML_TOK_NONE: /* start == end */
+    default:
+      break;
+    }
+  }
+  /* This would cause the next stage, i.e. doProlog to be passed XML_TOK_BOM.
+     However, when parsing an external subset, doProlog will not accept a BOM
+     as valid, and report a syntax error, so we have to skip the BOM, and
+     account for the BOM bytes.
+  */
+  else if (tok == XML_TOK_BOM) {
+    if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,
+                                  XML_ACCOUNT_DIRECT)) {
+      accountingOnAbort(parser);
+      return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
+    }
+
+    s = next;
+    tok = XmlPrologTok(parser->m_encoding, s, end, &next);
+  }
+
+  parser->m_processor = prologProcessor;
+  return doProlog(parser, parser->m_encoding, s, end, tok, next, nextPtr,
+                  (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_TRUE,
+                  XML_ACCOUNT_DIRECT);
+}
+
+static enum XML_Error PTRCALL
+entityValueProcessor(XML_Parser parser, const char *s, const char *end,
+                     const char **nextPtr) {
+  const char *start = s;
+  const char *next = s;
+  const ENCODING *enc = parser->m_encoding;
+  int tok;
+
+  for (;;) {
+    tok = XmlPrologTok(enc, start, end, &next);
+    /* Note: These bytes are accounted later in:
+             - storeEntityValue
+    */
+    if (tok <= 0) {
+      if (! parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {
+        *nextPtr = s;
+        return XML_ERROR_NONE;
+      }
+      switch (tok) {
+      case XML_TOK_INVALID:
+        return XML_ERROR_INVALID_TOKEN;
+      case XML_TOK_PARTIAL:
+        return XML_ERROR_UNCLOSED_TOKEN;
+      case XML_TOK_PARTIAL_CHAR:
+        return XML_ERROR_PARTIAL_CHAR;
+      case XML_TOK_NONE: /* start == end */
+      default:
+        break;
+      }
+      /* found end of entity value - can store it now */
+      return storeEntityValue(parser, enc, s, end, XML_ACCOUNT_DIRECT);
+    }
+    start = next;
+  }
+}
+
+#endif /* XML_DTD */
+
+static enum XML_Error PTRCALL
+prologProcessor(XML_Parser parser, const char *s, const char *end,
+                const char **nextPtr) {
+  const char *next = s;
+  int tok = XmlPrologTok(parser->m_encoding, s, end, &next);
+  return doProlog(parser, parser->m_encoding, s, end, tok, next, nextPtr,
+                  (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_TRUE,
+                  XML_ACCOUNT_DIRECT);
+}
+
+static enum XML_Error
+doProlog(XML_Parser parser, const ENCODING *enc, const char *s, const char *end,
+         int tok, const char *next, const char **nextPtr, XML_Bool haveMore,
+         XML_Bool allowClosingDoctype, enum XML_Account account) {
+#ifdef XML_DTD
+  static const XML_Char externalSubsetName[] = {ASCII_HASH, '\0'};
+#endif /* XML_DTD */
+  static const XML_Char atypeCDATA[]
+      = {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0'};
+  static const XML_Char atypeID[] = {ASCII_I, ASCII_D, '\0'};
+  static const XML_Char atypeIDREF[]
+      = {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\0'};
+  static const XML_Char atypeIDREFS[]
+      = {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0'};
+  static const XML_Char atypeENTITY[]
+      = {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\0'};
+  static const XML_Char atypeENTITIES[]
+      = {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T,
+         ASCII_I, ASCII_E, ASCII_S, '\0'};
+  static const XML_Char atypeNMTOKEN[]
+      = {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0'};
+  static const XML_Char atypeNMTOKENS[]
+      = {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K,
+         ASCII_E, ASCII_N, ASCII_S, '\0'};
+  static const XML_Char notationPrefix[]
+      = {ASCII_N, ASCII_O, ASCII_T, ASCII_A,      ASCII_T,
+         ASCII_I, ASCII_O, ASCII_N, ASCII_LPAREN, '\0'};
+  static const XML_Char enumValueSep[] = {ASCII_PIPE, '\0'};
+  static const XML_Char enumValueStart[] = {ASCII_LPAREN, '\0'};
+
+#ifndef XML_DTD
+  UNUSED_P(account);
+#endif
+
+  /* save one level of indirection */
+  DTD *const dtd = parser->m_dtd;
+
+  const char **eventPP;
+  const char **eventEndPP;
+  enum XML_Content_Quant quant;
+
+  if (enc == parser->m_encoding) {
+    eventPP = &parser->m_eventPtr;
+    eventEndPP = &parser->m_eventEndPtr;
+  } else {
+    eventPP = &(parser->m_openInternalEntities->internalEventPtr);
+    eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
+  }
+
+  for (;;) {
+    int role;
+    XML_Bool handleDefault = XML_TRUE;
+    *eventPP = s;
+    *eventEndPP = next;
+    if (tok <= 0) {
+      if (haveMore && tok != XML_TOK_INVALID) {
+        *nextPtr = s;
+        return XML_ERROR_NONE;
+      }
+      switch (tok) {
+      case XML_TOK_INVALID:
+        *eventPP = next;
+        return XML_ERROR_INVALID_TOKEN;
+      case XML_TOK_PARTIAL:
+        return XML_ERROR_UNCLOSED_TOKEN;
+      case XML_TOK_PARTIAL_CHAR:
+        return XML_ERROR_PARTIAL_CHAR;
+      case -XML_TOK_PROLOG_S:
+        tok = -tok;
+        break;
+      case XML_TOK_NONE:
+#ifdef XML_DTD
+        /* for internal PE NOT referenced between declarations */
+        if (enc != parser->m_encoding
+            && ! parser->m_openInternalEntities->betweenDecl) {
+          *nextPtr = s;
+          return XML_ERROR_NONE;
+        }
+        /* WFC: PE Between Declarations - must check that PE contains
+           complete markup, not only for external PEs, but also for
+           internal PEs if the reference occurs between declarations.
+        */
+        if (parser->m_isParamEntity || enc != parser->m_encoding) {
+          if (XmlTokenRole(&parser->m_prologState, XML_TOK_NONE, end, end, enc)
+              == XML_ROLE_ERROR)
+            return XML_ERROR_INCOMPLETE_PE;
+          *nextPtr = s;
+          return XML_ERROR_NONE;
+        }
+#endif /* XML_DTD */
+        return XML_ERROR_NO_ELEMENTS;
+      default:
+        tok = -tok;
+        next = end;
+        break;
+      }
+    }
+    role = XmlTokenRole(&parser->m_prologState, tok, s, next, enc);
+#if XML_GE == 1
+    switch (role) {
+    case XML_ROLE_INSTANCE_START: // bytes accounted in contentProcessor
+    case XML_ROLE_XML_DECL:       // bytes accounted in processXmlDecl
+#  ifdef XML_DTD
+    case XML_ROLE_TEXT_DECL: // bytes accounted in processXmlDecl
+#  endif
+      break;
+    default:
+      if (! accountingDiffTolerated(parser, tok, s, next, __LINE__, account)) {
+        accountingOnAbort(parser);
+        return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
+      }
+    }
+#endif
+    switch (role) {
+    case XML_ROLE_XML_DECL: {
+      enum XML_Error result = processXmlDecl(parser, 0, s, next);
+      if (result != XML_ERROR_NONE)
+        return result;
+      enc = parser->m_encoding;
+      handleDefault = XML_FALSE;
+    } break;
+    case XML_ROLE_DOCTYPE_NAME:
+      if (parser->m_startDoctypeDeclHandler) {
+        parser->m_doctypeName
+            = poolStoreString(&parser->m_tempPool, enc, s, next);
+        if (! parser->m_doctypeName)
+          return XML_ERROR_NO_MEMORY;
+        poolFinish(&parser->m_tempPool);
+        parser->m_doctypePubid = NULL;
+        handleDefault = XML_FALSE;
+      }
+      parser->m_doctypeSysid = NULL; /* always initialize to NULL */
+      break;
+    case XML_ROLE_DOCTYPE_INTERNAL_SUBSET:
+      if (parser->m_startDoctypeDeclHandler) {
+        parser->m_startDoctypeDeclHandler(
+            parser->m_handlerArg, parser->m_doctypeName, parser->m_doctypeSysid,
+            parser->m_doctypePubid, 1);
+        parser->m_doctypeName = NULL;
+        poolClear(&parser->m_tempPool);
+        handleDefault = XML_FALSE;
+      }
+      break;
+#ifdef XML_DTD
+    case XML_ROLE_TEXT_DECL: {
+      enum XML_Error result = processXmlDecl(parser, 1, s, next);
+      if (result != XML_ERROR_NONE)
+        return result;
+      enc = parser->m_encoding;
+      handleDefault = XML_FALSE;
+    } break;
+#endif /* XML_DTD */
+    case XML_ROLE_DOCTYPE_PUBLIC_ID:
+#ifdef XML_DTD
+      parser->m_useForeignDTD = XML_FALSE;
+      parser->m_declEntity = (ENTITY *)lookup(
+          parser, &dtd->paramEntities, externalSubsetName, sizeof(ENTITY));
+      if (! parser->m_declEntity)
+        return XML_ERROR_NO_MEMORY;
+#endif /* XML_DTD */
+      dtd->hasParamEntityRefs = XML_TRUE;
+      if (parser->m_startDoctypeDeclHandler) {
+        XML_Char *pubId;
+        if (! XmlIsPublicId(enc, s, next, eventPP))
+          return XML_ERROR_PUBLICID;
+        pubId = poolStoreString(&parser->m_tempPool, enc,
+                                s + enc->minBytesPerChar,
+                                next - enc->minBytesPerChar);
+        if (! pubId)
+          return XML_ERROR_NO_MEMORY;
+        normalizePublicId(pubId);
+        poolFinish(&parser->m_tempPool);
+        parser->m_doctypePubid = pubId;
+        handleDefault = XML_FALSE;
+        goto alreadyChecked;
+      }
+      /* fall through */
+    case XML_ROLE_ENTITY_PUBLIC_ID:
+      if (! XmlIsPublicId(enc, s, next, eventPP))
+        return XML_ERROR_PUBLICID;
+    alreadyChecked:
+      if (dtd->keepProcessing && parser->m_declEntity) {
+        XML_Char *tem
+            = poolStoreString(&dtd->pool, enc, s + enc->minBytesPerChar,
+                              next - enc->minBytesPerChar);
+        if (! tem)
+          return XML_ERROR_NO_MEMORY;
+        normalizePublicId(tem);
+        parser->m_declEntity->publicId = tem;
+        poolFinish(&dtd->pool);
+        /* Don't suppress the default handler if we fell through from
+         * the XML_ROLE_DOCTYPE_PUBLIC_ID case.
+         */
+        if (parser->m_entityDeclHandler && role == XML_ROLE_ENTITY_PUBLIC_ID)
+          handleDefault = XML_FALSE;
+      }
+      break;
+    case XML_ROLE_DOCTYPE_CLOSE:
+      if (allowClosingDoctype != XML_TRUE) {
+        /* Must not close doctype from within expanded parameter entities */
+        return XML_ERROR_INVALID_TOKEN;
+      }
+
+      if (parser->m_doctypeName) {
+        parser->m_startDoctypeDeclHandler(
+            parser->m_handlerArg, parser->m_doctypeName, parser->m_doctypeSysid,
+            parser->m_doctypePubid, 0);
+        poolClear(&parser->m_tempPool);
+        handleDefault = XML_FALSE;
+      }
+      /* parser->m_doctypeSysid will be non-NULL in the case of a previous
+         XML_ROLE_DOCTYPE_SYSTEM_ID, even if parser->m_startDoctypeDeclHandler
+         was not set, indicating an external subset
+      */
+#ifdef XML_DTD
+      if (parser->m_doctypeSysid || parser->m_useForeignDTD) {
+        XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;
+        dtd->hasParamEntityRefs = XML_TRUE;
+        if (parser->m_paramEntityParsing
+            && parser->m_externalEntityRefHandler) {
+          ENTITY *entity = (ENTITY *)lookup(parser, &dtd->paramEntities,
+                                            externalSubsetName, sizeof(ENTITY));
+          if (! entity) {
+            /* The external subset name "#" will have already been
+             * inserted into the hash table at the start of the
+             * external entity parsing, so no allocation will happen
+             * and lookup() cannot fail.
+             */
+            return XML_ERROR_NO_MEMORY; /* LCOV_EXCL_LINE */
+          }
+          if (parser->m_useForeignDTD)
+            entity->base = parser->m_curBase;
+          dtd->paramEntityRead = XML_FALSE;
+          if (! parser->m_externalEntityRefHandler(
+                  parser->m_externalEntityRefHandlerArg, 0, entity->base,
+                  entity->systemId, entity->publicId))
+            return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
+          if (dtd->paramEntityRead) {
+            if (! dtd->standalone && parser->m_notStandaloneHandler
+                && ! parser->m_notStandaloneHandler(parser->m_handlerArg))
+              return XML_ERROR_NOT_STANDALONE;
+          }
+          /* if we didn't read the foreign DTD then this means that there
+             is no external subset and we must reset dtd->hasParamEntityRefs
+          */
+          else if (! parser->m_doctypeSysid)
+            dtd->hasParamEntityRefs = hadParamEntityRefs;
+          /* end of DTD - no need to update dtd->keepProcessing */
+        }
+        parser->m_useForeignDTD = XML_FALSE;
+      }
+#endif /* XML_DTD */
+      if (parser->m_endDoctypeDeclHandler) {
+        parser->m_endDoctypeDeclHandler(parser->m_handlerArg);
+        handleDefault = XML_FALSE;
+      }
+      break;
+    case XML_ROLE_INSTANCE_START:
+#ifdef XML_DTD
+      /* if there is no DOCTYPE declaration then now is the
+         last chance to read the foreign DTD
+      */
+      if (parser->m_useForeignDTD) {
+        XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;
+        dtd->hasParamEntityRefs = XML_TRUE;
+        if (parser->m_paramEntityParsing
+            && parser->m_externalEntityRefHandler) {
+          ENTITY *entity = (ENTITY *)lookup(parser, &dtd->paramEntities,
+                                            externalSubsetName, sizeof(ENTITY));
+          if (! entity)
+            return XML_ERROR_NO_MEMORY;
+          entity->base = parser->m_curBase;
+          dtd->paramEntityRead = XML_FALSE;
+          if (! parser->m_externalEntityRefHandler(
+                  parser->m_externalEntityRefHandlerArg, 0, entity->base,
+                  entity->systemId, entity->publicId))
+            return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
+          if (dtd->paramEntityRead) {
+            if (! dtd->standalone && parser->m_notStandaloneHandler
+                && ! parser->m_notStandaloneHandler(parser->m_handlerArg))
+              return XML_ERROR_NOT_STANDALONE;
+          }
+          /* if we didn't read the foreign DTD then this means that there
+             is no external subset and we must reset dtd->hasParamEntityRefs
+          */
+          else
+            dtd->hasParamEntityRefs = hadParamEntityRefs;
+          /* end of DTD - no need to update dtd->keepProcessing */
+        }
+      }
+#endif /* XML_DTD */
+      parser->m_processor = contentProcessor;
+      return contentProcessor(parser, s, end, nextPtr);
+    case XML_ROLE_ATTLIST_ELEMENT_NAME:
+      parser->m_declElementType = getElementType(parser, enc, s, next);
+      if (! parser->m_declElementType)
+        return XML_ERROR_NO_MEMORY;
+      goto checkAttListDeclHandler;
+    case XML_ROLE_ATTRIBUTE_NAME:
+      parser->m_declAttributeId = getAttributeId(parser, enc, s, next);
+      if (! parser->m_declAttributeId)
+        return XML_ERROR_NO_MEMORY;
+      parser->m_declAttributeIsCdata = XML_FALSE;
+      parser->m_declAttributeType = NULL;
+      parser->m_declAttributeIsId = XML_FALSE;
+      goto checkAttListDeclHandler;
+    case XML_ROLE_ATTRIBUTE_TYPE_CDATA:
+      parser->m_declAttributeIsCdata = XML_TRUE;
+      parser->m_declAttributeType = atypeCDATA;
+      goto checkAttListDeclHandler;
+    case XML_ROLE_ATTRIBUTE_TYPE_ID:
+      parser->m_declAttributeIsId = XML_TRUE;
+      parser->m_declAttributeType = atypeID;
+      goto checkAttListDeclHandler;
+    case XML_ROLE_ATTRIBUTE_TYPE_IDREF:
+      parser->m_declAttributeType = atypeIDREF;
+      goto checkAttListDeclHandler;
+    case XML_ROLE_ATTRIBUTE_TYPE_IDREFS:
+      parser->m_declAttributeType = atypeIDREFS;
+      goto checkAttListDeclHandler;
+    case XML_ROLE_ATTRIBUTE_TYPE_ENTITY:
+      parser->m_declAttributeType = atypeENTITY;
+      goto checkAttListDeclHandler;
+    case XML_ROLE_ATTRIBUTE_TYPE_ENTITIES:
+      parser->m_declAttributeType = atypeENTITIES;
+      goto checkAttListDeclHandler;
+    case XML_ROLE_ATTRIBUTE_TYPE_NMTOKEN:
+      parser->m_declAttributeType = atypeNMTOKEN;
+      goto checkAttListDeclHandler;
+    case XML_ROLE_ATTRIBUTE_TYPE_NMTOKENS:
+      parser->m_declAttributeType = atypeNMTOKENS;
+    checkAttListDeclHandler:
+      if (dtd->keepProcessing && parser->m_attlistDeclHandler)
+        handleDefault = XML_FALSE;
+      break;
+    case XML_ROLE_ATTRIBUTE_ENUM_VALUE:
+    case XML_ROLE_ATTRIBUTE_NOTATION_VALUE:
+      if (dtd->keepProcessing && parser->m_attlistDeclHandler) {
+        const XML_Char *prefix;
+        if (parser->m_declAttributeType) {
+          prefix = enumValueSep;
+        } else {
+          prefix = (role == XML_ROLE_ATTRIBUTE_NOTATION_VALUE ? notationPrefix
+                                                              : enumValueStart);
+        }
+        if (! poolAppendString(&parser->m_tempPool, prefix))
+          return XML_ERROR_NO_MEMORY;
+        if (! poolAppend(&parser->m_tempPool, enc, s, next))
+          return XML_ERROR_NO_MEMORY;
+        parser->m_declAttributeType = parser->m_tempPool.start;
+        handleDefault = XML_FALSE;
+      }
+      break;
+    case XML_ROLE_IMPLIED_ATTRIBUTE_VALUE:
+    case XML_ROLE_REQUIRED_ATTRIBUTE_VALUE:
+      if (dtd->keepProcessing) {
+        if (! defineAttribute(parser->m_declElementType,
+                              parser->m_declAttributeId,
+                              parser->m_declAttributeIsCdata,
+                              parser->m_declAttributeIsId, 0, parser))
+          return XML_ERROR_NO_MEMORY;
+        if (parser->m_attlistDeclHandler && parser->m_declAttributeType) {
+          if (*parser->m_declAttributeType == XML_T(ASCII_LPAREN)
+              || (*parser->m_declAttributeType == XML_T(ASCII_N)
+                  && parser->m_declAttributeType[1] == XML_T(ASCII_O))) {
+            /* Enumerated or Notation type */
+            if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_RPAREN))
+                || ! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
+              return XML_ERROR_NO_MEMORY;
+            parser->m_declAttributeType = parser->m_tempPool.start;
+            poolFinish(&parser->m_tempPool);
+          }
+          *eventEndPP = s;
+          parser->m_attlistDeclHandler(
+              parser->m_handlerArg, parser->m_declElementType->name,
+              parser->m_declAttributeId->name, parser->m_declAttributeType, 0,
+              role == XML_ROLE_REQUIRED_ATTRIBUTE_VALUE);
+          handleDefault = XML_FALSE;
+        }
+      }
+      poolClear(&parser->m_tempPool);
+      break;
+    case XML_ROLE_DEFAULT_ATTRIBUTE_VALUE:
+    case XML_ROLE_FIXED_ATTRIBUTE_VALUE:
+      if (dtd->keepProcessing) {
+        const XML_Char *attVal;
+        enum XML_Error result = storeAttributeValue(
+            parser, enc, parser->m_declAttributeIsCdata,
+            s + enc->minBytesPerChar, next - enc->minBytesPerChar, &dtd->pool,
+            XML_ACCOUNT_NONE);
+        if (result)
+          return result;
+        attVal = poolStart(&dtd->pool);
+        poolFinish(&dtd->pool);
+        /* ID attributes aren't allowed to have a default */
+        if (! defineAttribute(
+                parser->m_declElementType, parser->m_declAttributeId,
+                parser->m_declAttributeIsCdata, XML_FALSE, attVal, parser))
+          return XML_ERROR_NO_MEMORY;
+        if (parser->m_attlistDeclHandler && parser->m_declAttributeType) {
+          if (*parser->m_declAttributeType == XML_T(ASCII_LPAREN)
+              || (*parser->m_declAttributeType == XML_T(ASCII_N)
+                  && parser->m_declAttributeType[1] == XML_T(ASCII_O))) {
+            /* Enumerated or Notation type */
+            if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_RPAREN))
+                || ! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
+              return XML_ERROR_NO_MEMORY;
+            parser->m_declAttributeType = parser->m_tempPool.start;
+            poolFinish(&parser->m_tempPool);
+          }
+          *eventEndPP = s;
+          parser->m_attlistDeclHandler(
+              parser->m_handlerArg, parser->m_declElementType->name,
+              parser->m_declAttributeId->name, parser->m_declAttributeType,
+              attVal, role == XML_ROLE_FIXED_ATTRIBUTE_VALUE);
+          poolClear(&parser->m_tempPool);
+          handleDefault = XML_FALSE;
+        }
+      }
+      break;
+    case XML_ROLE_ENTITY_VALUE:
+      if (dtd->keepProcessing) {
+#if XML_GE == 1
+        // This will store the given replacement text in
+        // parser->m_declEntity->textPtr.
+        enum XML_Error result
+            = storeEntityValue(parser, enc, s + enc->minBytesPerChar,
+                               next - enc->minBytesPerChar, XML_ACCOUNT_NONE);
+        if (parser->m_declEntity) {
+          parser->m_declEntity->textPtr = poolStart(&dtd->entityValuePool);
+          parser->m_declEntity->textLen
+              = (int)(poolLength(&dtd->entityValuePool));
+          poolFinish(&dtd->entityValuePool);
+          if (parser->m_entityDeclHandler) {
+            *eventEndPP = s;
+            parser->m_entityDeclHandler(
+                parser->m_handlerArg, parser->m_declEntity->name,
+                parser->m_declEntity->is_param, parser->m_declEntity->textPtr,
+                parser->m_declEntity->textLen, parser->m_curBase, 0, 0, 0);
+            handleDefault = XML_FALSE;
+          }
+        } else
+          poolDiscard(&dtd->entityValuePool);
+        if (result != XML_ERROR_NONE)
+          return result;
+#else
+        // This will store "&amp;entity123;" in parser->m_declEntity->textPtr
+        // to end up as "&entity123;" in the handler.
+        if (parser->m_declEntity != NULL) {
+          const enum XML_Error result
+              = storeSelfEntityValue(parser, parser->m_declEntity);
+          if (result != XML_ERROR_NONE)
+            return result;
+
+          if (parser->m_entityDeclHandler) {
+            *eventEndPP = s;
+            parser->m_entityDeclHandler(
+                parser->m_handlerArg, parser->m_declEntity->name,
+                parser->m_declEntity->is_param, parser->m_declEntity->textPtr,
+                parser->m_declEntity->textLen, parser->m_curBase, 0, 0, 0);
+            handleDefault = XML_FALSE;
+          }
+        }
+#endif
+      }
+      break;
+    case XML_ROLE_DOCTYPE_SYSTEM_ID:
+#ifdef XML_DTD
+      parser->m_useForeignDTD = XML_FALSE;
+#endif /* XML_DTD */
+      dtd->hasParamEntityRefs = XML_TRUE;
+      if (parser->m_startDoctypeDeclHandler) {
+        parser->m_doctypeSysid = poolStoreString(&parser->m_tempPool, enc,
+                                                 s + enc->minBytesPerChar,
+                                                 next - enc->minBytesPerChar);
+        if (parser->m_doctypeSysid == NULL)
+          return XML_ERROR_NO_MEMORY;
+        poolFinish(&parser->m_tempPool);
+        handleDefault = XML_FALSE;
+      }
+#ifdef XML_DTD
+      else
+        /* use externalSubsetName to make parser->m_doctypeSysid non-NULL
+           for the case where no parser->m_startDoctypeDeclHandler is set */
+        parser->m_doctypeSysid = externalSubsetName;
+#endif /* XML_DTD */
+      if (! dtd->standalone
+#ifdef XML_DTD
+          && ! parser->m_paramEntityParsing
+#endif /* XML_DTD */
+          && parser->m_notStandaloneHandler
+          && ! parser->m_notStandaloneHandler(parser->m_handlerArg))
+        return XML_ERROR_NOT_STANDALONE;
+#ifndef XML_DTD
+      break;
+#else  /* XML_DTD */
+      if (! parser->m_declEntity) {
+        parser->m_declEntity = (ENTITY *)lookup(
+            parser, &dtd->paramEntities, externalSubsetName, sizeof(ENTITY));
+        if (! parser->m_declEntity)
+          return XML_ERROR_NO_MEMORY;
+        parser->m_declEntity->publicId = NULL;
+      }
+#endif /* XML_DTD */
+      /* fall through */
+    case XML_ROLE_ENTITY_SYSTEM_ID:
+      if (dtd->keepProcessing && parser->m_declEntity) {
+        parser->m_declEntity->systemId
+            = poolStoreString(&dtd->pool, enc, s + enc->minBytesPerChar,
+                              next - enc->minBytesPerChar);
+        if (! parser->m_declEntity->systemId)
+          return XML_ERROR_NO_MEMORY;
+        parser->m_declEntity->base = parser->m_curBase;
+        poolFinish(&dtd->pool);
+        /* Don't suppress the default handler if we fell through from
+         * the XML_ROLE_DOCTYPE_SYSTEM_ID case.
+         */
+        if (parser->m_entityDeclHandler && role == XML_ROLE_ENTITY_SYSTEM_ID)
+          handleDefault = XML_FALSE;
+      }
+      break;
+    case XML_ROLE_ENTITY_COMPLETE:
+#if XML_GE == 0
+      // This will store "&amp;entity123;" in entity->textPtr
+      // to end up as "&entity123;" in the handler.
+      if (parser->m_declEntity != NULL) {
+        const enum XML_Error result
+            = storeSelfEntityValue(parser, parser->m_declEntity);
+        if (result != XML_ERROR_NONE)
+          return result;
+      }
+#endif
+      if (dtd->keepProcessing && parser->m_declEntity
+          && parser->m_entityDeclHandler) {
+        *eventEndPP = s;
+        parser->m_entityDeclHandler(
+            parser->m_handlerArg, parser->m_declEntity->name,
+            parser->m_declEntity->is_param, 0, 0, parser->m_declEntity->base,
+            parser->m_declEntity->systemId, parser->m_declEntity->publicId, 0);
+        handleDefault = XML_FALSE;
+      }
+      break;
+    case XML_ROLE_ENTITY_NOTATION_NAME:
+      if (dtd->keepProcessing && parser->m_declEntity) {
+        parser->m_declEntity->notation
+            = poolStoreString(&dtd->pool, enc, s, next);
+        if (! parser->m_declEntity->notation)
+          return XML_ERROR_NO_MEMORY;
+        poolFinish(&dtd->pool);
+        if (parser->m_unparsedEntityDeclHandler) {
+          *eventEndPP = s;
+          parser->m_unparsedEntityDeclHandler(
+              parser->m_handlerArg, parser->m_declEntity->name,
+              parser->m_declEntity->base, parser->m_declEntity->systemId,
+              parser->m_declEntity->publicId, parser->m_declEntity->notation);
+          handleDefault = XML_FALSE;
+        } else if (parser->m_entityDeclHandler) {
+          *eventEndPP = s;
+          parser->m_entityDeclHandler(
+              parser->m_handlerArg, parser->m_declEntity->name, 0, 0, 0,
+              parser->m_declEntity->base, parser->m_declEntity->systemId,
+              parser->m_declEntity->publicId, parser->m_declEntity->notation);
+          handleDefault = XML_FALSE;
+        }
+      }
+      break;
+    case XML_ROLE_GENERAL_ENTITY_NAME: {
+      if (XmlPredefinedEntityName(enc, s, next)) {
+        parser->m_declEntity = NULL;
+        break;
+      }
+      if (dtd->keepProcessing) {
+        const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);
+        if (! name)
+          return XML_ERROR_NO_MEMORY;
+        parser->m_declEntity = (ENTITY *)lookup(parser, &dtd->generalEntities,
+                                                name, sizeof(ENTITY));
+        if (! parser->m_declEntity)
+          return XML_ERROR_NO_MEMORY;
+        if (parser->m_declEntity->name != name) {
+          poolDiscard(&dtd->pool);
+          parser->m_declEntity = NULL;
+        } else {
+          poolFinish(&dtd->pool);
+          parser->m_declEntity->publicId = NULL;
+          parser->m_declEntity->is_param = XML_FALSE;
+          /* if we have a parent parser or are reading an internal parameter
+             entity, then the entity declaration is not considered "internal"
+          */
+          parser->m_declEntity->is_internal
+              = ! (parser->m_parentParser || parser->m_openInternalEntities);
+          if (parser->m_entityDeclHandler)
+            handleDefault = XML_FALSE;
+        }
+      } else {
+        poolDiscard(&dtd->pool);
+        parser->m_declEntity = NULL;
+      }
+    } break;
+    case XML_ROLE_PARAM_ENTITY_NAME:
+#ifdef XML_DTD
+      if (dtd->keepProcessing) {
+        const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);
+        if (! name)
+          return XML_ERROR_NO_MEMORY;
+        parser->m_declEntity = (ENTITY *)lookup(parser, &dtd->paramEntities,
+                                                name, sizeof(ENTITY));
+        if (! parser->m_declEntity)
+          return XML_ERROR_NO_MEMORY;
+        if (parser->m_declEntity->name != name) {
+          poolDiscard(&dtd->pool);
+          parser->m_declEntity = NULL;
+        } else {
+          poolFinish(&dtd->pool);
+          parser->m_declEntity->publicId = NULL;
+          parser->m_declEntity->is_param = XML_TRUE;
+          /* if we have a parent parser or are reading an internal parameter
+             entity, then the entity declaration is not considered "internal"
+          */
+          parser->m_declEntity->is_internal
+              = ! (parser->m_parentParser || parser->m_openInternalEntities);
+          if (parser->m_entityDeclHandler)
+            handleDefault = XML_FALSE;
+        }
+      } else {
+        poolDiscard(&dtd->pool);
+        parser->m_declEntity = NULL;
+      }
+#else  /* not XML_DTD */
+      parser->m_declEntity = NULL;
+#endif /* XML_DTD */
+      break;
+    case XML_ROLE_NOTATION_NAME:
+      parser->m_declNotationPublicId = NULL;
+      parser->m_declNotationName = NULL;
+      if (parser->m_notationDeclHandler) {
+        parser->m_declNotationName
+            = poolStoreString(&parser->m_tempPool, enc, s, next);
+        if (! parser->m_declNotationName)
+          return XML_ERROR_NO_MEMORY;
+        poolFinish(&parser->m_tempPool);
+        handleDefault = XML_FALSE;
+      }
+      break;
+    case XML_ROLE_NOTATION_PUBLIC_ID:
+      if (! XmlIsPublicId(enc, s, next, eventPP))
+        return XML_ERROR_PUBLICID;
+      if (parser
+              ->m_declNotationName) { /* means m_notationDeclHandler != NULL */
+        XML_Char *tem = poolStoreString(&parser->m_tempPool, enc,
+                                        s + enc->minBytesPerChar,
+                                        next - enc->minBytesPerChar);
+        if (! tem)
+          return XML_ERROR_NO_MEMORY;
+        normalizePublicId(tem);
+        parser->m_declNotationPublicId = tem;
+        poolFinish(&parser->m_tempPool);
+        handleDefault = XML_FALSE;
+      }
+      break;
+    case XML_ROLE_NOTATION_SYSTEM_ID:
+      if (parser->m_declNotationName && parser->m_notationDeclHandler) {
+        const XML_Char *systemId = poolStoreString(&parser->m_tempPool, enc,
+                                                   s + enc->minBytesPerChar,
+                                                   next - enc->minBytesPerChar);
+        if (! systemId)
+          return XML_ERROR_NO_MEMORY;
+        *eventEndPP = s;
+        parser->m_notationDeclHandler(
+            parser->m_handlerArg, parser->m_declNotationName, parser->m_curBase,
+            systemId, parser->m_declNotationPublicId);
+        handleDefault = XML_FALSE;
+      }
+      poolClear(&parser->m_tempPool);
+      break;
+    case XML_ROLE_NOTATION_NO_SYSTEM_ID:
+      if (parser->m_declNotationPublicId && parser->m_notationDeclHandler) {
+        *eventEndPP = s;
+        parser->m_notationDeclHandler(
+            parser->m_handlerArg, parser->m_declNotationName, parser->m_curBase,
+            0, parser->m_declNotationPublicId);
+        handleDefault = XML_FALSE;
+      }
+      poolClear(&parser->m_tempPool);
+      break;
+    case XML_ROLE_ERROR:
+      switch (tok) {
+      case XML_TOK_PARAM_ENTITY_REF:
+        /* PE references in internal subset are
+           not allowed within declarations. */
+        return XML_ERROR_PARAM_ENTITY_REF;
+      case XML_TOK_XML_DECL:
+        return XML_ERROR_MISPLACED_XML_PI;
+      default:
+        return XML_ERROR_SYNTAX;
+      }
+#ifdef XML_DTD
+    case XML_ROLE_IGNORE_SECT: {
+      enum XML_Error result;
+      if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, next);
+      handleDefault = XML_FALSE;
+      result = doIgnoreSection(parser, enc, &next, end, nextPtr, haveMore);
+      if (result != XML_ERROR_NONE)
+        return result;
+      else if (! next) {
+        parser->m_processor = ignoreSectionProcessor;
+        return result;
+      }
+    } break;
+#endif /* XML_DTD */
+    case XML_ROLE_GROUP_OPEN:
+      if (parser->m_prologState.level >= parser->m_groupSize) {
+        if (parser->m_groupSize) {
+          {
+            /* Detect and prevent integer overflow */
+            if (parser->m_groupSize > (unsigned int)(-1) / 2u) {
+              return XML_ERROR_NO_MEMORY;
+            }
+
+            char *const new_connector = (char *)REALLOC(
+                parser, parser->m_groupConnector, parser->m_groupSize *= 2);
+            if (new_connector == NULL) {
+              parser->m_groupSize /= 2;
+              return XML_ERROR_NO_MEMORY;
+            }
+            parser->m_groupConnector = new_connector;
+          }
+
+          if (dtd->scaffIndex) {
+            /* Detect and prevent integer overflow.
+             * The preprocessor guard addresses the "always false" warning
+             * from -Wtype-limits on platforms where
+             * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
+#if UINT_MAX >= SIZE_MAX
+            if (parser->m_groupSize > (size_t)(-1) / sizeof(int)) {
+              return XML_ERROR_NO_MEMORY;
+            }
+#endif
+
+            int *const new_scaff_index = (int *)REALLOC(
+                parser, dtd->scaffIndex, parser->m_groupSize * sizeof(int));
+            if (new_scaff_index == NULL)
+              return XML_ERROR_NO_MEMORY;
+            dtd->scaffIndex = new_scaff_index;
+          }
+        } else {
+          parser->m_groupConnector
+              = (char *)MALLOC(parser, parser->m_groupSize = 32);
+          if (! parser->m_groupConnector) {
+            parser->m_groupSize = 0;
+            return XML_ERROR_NO_MEMORY;
+          }
+        }
+      }
+      parser->m_groupConnector[parser->m_prologState.level] = 0;
+      if (dtd->in_eldecl) {
+        int myindex = nextScaffoldPart(parser);
+        if (myindex < 0)
+          return XML_ERROR_NO_MEMORY;
+        assert(dtd->scaffIndex != NULL);
+        dtd->scaffIndex[dtd->scaffLevel] = myindex;
+        dtd->scaffLevel++;
+        dtd->scaffold[myindex].type = XML_CTYPE_SEQ;
+        if (parser->m_elementDeclHandler)
+          handleDefault = XML_FALSE;
+      }
+      break;
+    case XML_ROLE_GROUP_SEQUENCE:
+      if (parser->m_groupConnector[parser->m_prologState.level] == ASCII_PIPE)
+        return XML_ERROR_SYNTAX;
+      parser->m_groupConnector[parser->m_prologState.level] = ASCII_COMMA;
+      if (dtd->in_eldecl && parser->m_elementDeclHandler)
+        handleDefault = XML_FALSE;
+      break;
+    case XML_ROLE_GROUP_CHOICE:
+      if (parser->m_groupConnector[parser->m_prologState.level] == ASCII_COMMA)
+        return XML_ERROR_SYNTAX;
+      if (dtd->in_eldecl
+          && ! parser->m_groupConnector[parser->m_prologState.level]
+          && (dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type
+              != XML_CTYPE_MIXED)) {
+        dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type
+            = XML_CTYPE_CHOICE;
+        if (parser->m_elementDeclHandler)
+          handleDefault = XML_FALSE;
+      }
+      parser->m_groupConnector[parser->m_prologState.level] = ASCII_PIPE;
+      break;
+    case XML_ROLE_PARAM_ENTITY_REF:
+#ifdef XML_DTD
+    case XML_ROLE_INNER_PARAM_ENTITY_REF:
+      dtd->hasParamEntityRefs = XML_TRUE;
+      if (! parser->m_paramEntityParsing)
+        dtd->keepProcessing = dtd->standalone;
+      else {
+        const XML_Char *name;
+        ENTITY *entity;
+        name = poolStoreString(&dtd->pool, enc, s + enc->minBytesPerChar,
+                               next - enc->minBytesPerChar);
+        if (! name)
+          return XML_ERROR_NO_MEMORY;
+        entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0);
+        poolDiscard(&dtd->pool);
+        /* first, determine if a check for an existing declaration is needed;
+           if yes, check that the entity exists, and that it is internal,
+           otherwise call the skipped entity handler
+        */
+        if (parser->m_prologState.documentEntity
+            && (dtd->standalone ? ! parser->m_openInternalEntities
+                                : ! dtd->hasParamEntityRefs)) {
+          if (! entity)
+            return XML_ERROR_UNDEFINED_ENTITY;
+          else if (! entity->is_internal) {
+            /* It's hard to exhaustively search the code to be sure,
+             * but there doesn't seem to be a way of executing the
+             * following line.  There are two cases:
+             *
+             * If 'standalone' is false, the DTD must have no
+             * parameter entities or we wouldn't have passed the outer
+             * 'if' statement.  That means the only entity in the hash
+             * table is the external subset name "#" which cannot be
+             * given as a parameter entity name in XML syntax, so the
+             * lookup must have returned NULL and we don't even reach
+             * the test for an internal entity.
+             *
+             * If 'standalone' is true, it does not seem to be
+             * possible to create entities taking this code path that
+             * are not internal entities, so fail the test above.
+             *
+             * Because this analysis is very uncertain, the code is
+             * being left in place and merely removed from the
+             * coverage test statistics.
+             */
+            return XML_ERROR_ENTITY_DECLARED_IN_PE; /* LCOV_EXCL_LINE */
+          }
+        } else if (! entity) {
+          dtd->keepProcessing = dtd->standalone;
+          /* cannot report skipped entities in declarations */
+          if ((role == XML_ROLE_PARAM_ENTITY_REF)
+              && parser->m_skippedEntityHandler) {
+            parser->m_skippedEntityHandler(parser->m_handlerArg, name, 1);
+            handleDefault = XML_FALSE;
+          }
+          break;
+        }
+        if (entity->open)
+          return XML_ERROR_RECURSIVE_ENTITY_REF;
+        if (entity->textPtr) {
+          enum XML_Error result;
+          XML_Bool betweenDecl
+              = (role == XML_ROLE_PARAM_ENTITY_REF ? XML_TRUE : XML_FALSE);
+          result = processInternalEntity(parser, entity, betweenDecl);
+          if (result != XML_ERROR_NONE)
+            return result;
+          handleDefault = XML_FALSE;
+          break;
+        }
+        if (parser->m_externalEntityRefHandler) {
+          dtd->paramEntityRead = XML_FALSE;
+          entity->open = XML_TRUE;
+          entityTrackingOnOpen(parser, entity, __LINE__);
+          if (! parser->m_externalEntityRefHandler(
+                  parser->m_externalEntityRefHandlerArg, 0, entity->base,
+                  entity->systemId, entity->publicId)) {
+            entityTrackingOnClose(parser, entity, __LINE__);
+            entity->open = XML_FALSE;
+            return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
+          }
+          entityTrackingOnClose(parser, entity, __LINE__);
+          entity->open = XML_FALSE;
+          handleDefault = XML_FALSE;
+          if (! dtd->paramEntityRead) {
+            dtd->keepProcessing = dtd->standalone;
+            break;
+          }
+        } else {
+          dtd->keepProcessing = dtd->standalone;
+          break;
+        }
+      }
+#endif /* XML_DTD */
+      if (! dtd->standalone && parser->m_notStandaloneHandler
+          && ! parser->m_notStandaloneHandler(parser->m_handlerArg))
+        return XML_ERROR_NOT_STANDALONE;
+      break;
+
+      /* Element declaration stuff */
+
+    case XML_ROLE_ELEMENT_NAME:
+      if (parser->m_elementDeclHandler) {
+        parser->m_declElementType = getElementType(parser, enc, s, next);
+        if (! parser->m_declElementType)
+          return XML_ERROR_NO_MEMORY;
+        dtd->scaffLevel = 0;
+        dtd->scaffCount = 0;
+        dtd->in_eldecl = XML_TRUE;
+        handleDefault = XML_FALSE;
+      }
+      break;
+
+    case XML_ROLE_CONTENT_ANY:
+    case XML_ROLE_CONTENT_EMPTY:
+      if (dtd->in_eldecl) {
+        if (parser->m_elementDeclHandler) {
+          XML_Content *content
+              = (XML_Content *)MALLOC(parser, sizeof(XML_Content));
+          if (! content)
+            return XML_ERROR_NO_MEMORY;
+          content->quant = XML_CQUANT_NONE;
+          content->name = NULL;
+          content->numchildren = 0;
+          content->children = NULL;
+          content->type = ((role == XML_ROLE_CONTENT_ANY) ? XML_CTYPE_ANY
+                                                          : XML_CTYPE_EMPTY);
+          *eventEndPP = s;
+          parser->m_elementDeclHandler(
+              parser->m_handlerArg, parser->m_declElementType->name, content);
+          handleDefault = XML_FALSE;
+        }
+        dtd->in_eldecl = XML_FALSE;
+      }
+      break;
+
+    case XML_ROLE_CONTENT_PCDATA:
+      if (dtd->in_eldecl) {
+        dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type
+            = XML_CTYPE_MIXED;
+        if (parser->m_elementDeclHandler)
+          handleDefault = XML_FALSE;
+      }
+      break;
+
+    case XML_ROLE_CONTENT_ELEMENT:
+      quant = XML_CQUANT_NONE;
+      goto elementContent;
+    case XML_ROLE_CONTENT_ELEMENT_OPT:
+      quant = XML_CQUANT_OPT;
+      goto elementContent;
+    case XML_ROLE_CONTENT_ELEMENT_REP:
+      quant = XML_CQUANT_REP;
+      goto elementContent;
+    case XML_ROLE_CONTENT_ELEMENT_PLUS:
+      quant = XML_CQUANT_PLUS;
+    elementContent:
+      if (dtd->in_eldecl) {
+        ELEMENT_TYPE *el;
+        const XML_Char *name;
+        size_t nameLen;
+        const char *nxt
+            = (quant == XML_CQUANT_NONE ? next : next - enc->minBytesPerChar);
+        int myindex = nextScaffoldPart(parser);
+        if (myindex < 0)
+          return XML_ERROR_NO_MEMORY;
+        dtd->scaffold[myindex].type = XML_CTYPE_NAME;
+        dtd->scaffold[myindex].quant = quant;
+        el = getElementType(parser, enc, s, nxt);
+        if (! el)
+          return XML_ERROR_NO_MEMORY;
+        name = el->name;
+        dtd->scaffold[myindex].name = name;
+        nameLen = 0;
+        for (; name[nameLen++];)
+          ;
+
+        /* Detect and prevent integer overflow */
+        if (nameLen > UINT_MAX - dtd->contentStringLen) {
+          return XML_ERROR_NO_MEMORY;
+        }
+
+        dtd->contentStringLen += (unsigned)nameLen;
+        if (parser->m_elementDeclHandler)
+          handleDefault = XML_FALSE;
+      }
+      break;
+
+    case XML_ROLE_GROUP_CLOSE:
+      quant = XML_CQUANT_NONE;
+      goto closeGroup;
+    case XML_ROLE_GROUP_CLOSE_OPT:
+      quant = XML_CQUANT_OPT;
+      goto closeGroup;
+    case XML_ROLE_GROUP_CLOSE_REP:
+      quant = XML_CQUANT_REP;
+      goto closeGroup;
+    case XML_ROLE_GROUP_CLOSE_PLUS:
+      quant = XML_CQUANT_PLUS;
+    closeGroup:
+      if (dtd->in_eldecl) {
+        if (parser->m_elementDeclHandler)
+          handleDefault = XML_FALSE;
+        dtd->scaffLevel--;
+        dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel]].quant = quant;
+        if (dtd->scaffLevel == 0) {
+          if (! handleDefault) {
+            XML_Content *model = build_model(parser);
+            if (! model)
+              return XML_ERROR_NO_MEMORY;
+            *eventEndPP = s;
+            parser->m_elementDeclHandler(
+                parser->m_handlerArg, parser->m_declElementType->name, model);
+          }
+          dtd->in_eldecl = XML_FALSE;
+          dtd->contentStringLen = 0;
+        }
+      }
+      break;
+      /* End element declaration stuff */
+
+    case XML_ROLE_PI:
+      if (! reportProcessingInstruction(parser, enc, s, next))
+        return XML_ERROR_NO_MEMORY;
+      handleDefault = XML_FALSE;
+      break;
+    case XML_ROLE_COMMENT:
+      if (! reportComment(parser, enc, s, next))
+        return XML_ERROR_NO_MEMORY;
+      handleDefault = XML_FALSE;
+      break;
+    case XML_ROLE_NONE:
+      switch (tok) {
+      case XML_TOK_BOM:
+        handleDefault = XML_FALSE;
+        break;
+      }
+      break;
+    case XML_ROLE_DOCTYPE_NONE:
+      if (parser->m_startDoctypeDeclHandler)
+        handleDefault = XML_FALSE;
+      break;
+    case XML_ROLE_ENTITY_NONE:
+      if (dtd->keepProcessing && parser->m_entityDeclHandler)
+        handleDefault = XML_FALSE;
+      break;
+    case XML_ROLE_NOTATION_NONE:
+      if (parser->m_notationDeclHandler)
+        handleDefault = XML_FALSE;
+      break;
+    case XML_ROLE_ATTLIST_NONE:
+      if (dtd->keepProcessing && parser->m_attlistDeclHandler)
+        handleDefault = XML_FALSE;
+      break;
+    case XML_ROLE_ELEMENT_NONE:
+      if (parser->m_elementDeclHandler)
+        handleDefault = XML_FALSE;
+      break;
+    } /* end of big switch */
+
+    if (handleDefault && parser->m_defaultHandler)
+      reportDefault(parser, enc, s, next);
+
+    switch (parser->m_parsingStatus.parsing) {
+    case XML_SUSPENDED:
+      *nextPtr = next;
+      return XML_ERROR_NONE;
+    case XML_FINISHED:
+      return XML_ERROR_ABORTED;
+    default:
+      s = next;
+      tok = XmlPrologTok(enc, s, end, &next);
+    }
+  }
+  /* not reached */
+}
+
+static enum XML_Error PTRCALL
+epilogProcessor(XML_Parser parser, const char *s, const char *end,
+                const char **nextPtr) {
+  parser->m_processor = epilogProcessor;
+  parser->m_eventPtr = s;
+  for (;;) {
+    const char *next = NULL;
+    int tok = XmlPrologTok(parser->m_encoding, s, end, &next);
+#if XML_GE == 1
+    if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,
+                                  XML_ACCOUNT_DIRECT)) {
+      accountingOnAbort(parser);
+      return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
+    }
+#endif
+    parser->m_eventEndPtr = next;
+    switch (tok) {
+    /* report partial linebreak - it might be the last token */
+    case -XML_TOK_PROLOG_S:
+      if (parser->m_defaultHandler) {
+        reportDefault(parser, parser->m_encoding, s, next);
+        if (parser->m_parsingStatus.parsing == XML_FINISHED)
+          return XML_ERROR_ABORTED;
+      }
+      *nextPtr = next;
+      return XML_ERROR_NONE;
+    case XML_TOK_NONE:
+      *nextPtr = s;
+      return XML_ERROR_NONE;
+    case XML_TOK_PROLOG_S:
+      if (parser->m_defaultHandler)
+        reportDefault(parser, parser->m_encoding, s, next);
+      break;
+    case XML_TOK_PI:
+      if (! reportProcessingInstruction(parser, parser->m_encoding, s, next))
+        return XML_ERROR_NO_MEMORY;
+      break;
+    case XML_TOK_COMMENT:
+      if (! reportComment(parser, parser->m_encoding, s, next))
+        return XML_ERROR_NO_MEMORY;
+      break;
+    case XML_TOK_INVALID:
+      parser->m_eventPtr = next;
+      return XML_ERROR_INVALID_TOKEN;
+    case XML_TOK_PARTIAL:
+      if (! parser->m_parsingStatus.finalBuffer) {
+        *nextPtr = s;
+        return XML_ERROR_NONE;
+      }
+      return XML_ERROR_UNCLOSED_TOKEN;
+    case XML_TOK_PARTIAL_CHAR:
+      if (! parser->m_parsingStatus.finalBuffer) {
+        *nextPtr = s;
+        return XML_ERROR_NONE;
+      }
+      return XML_ERROR_PARTIAL_CHAR;
+    default:
+      return XML_ERROR_JUNK_AFTER_DOC_ELEMENT;
+    }
+    parser->m_eventPtr = s = next;
+    switch (parser->m_parsingStatus.parsing) {
+    case XML_SUSPENDED:
+      *nextPtr = next;
+      return XML_ERROR_NONE;
+    case XML_FINISHED:
+      return XML_ERROR_ABORTED;
+    default:;
+    }
+  }
+}
+
+static enum XML_Error
+processInternalEntity(XML_Parser parser, ENTITY *entity, XML_Bool betweenDecl) {
+  const char *textStart, *textEnd;
+  const char *next;
+  enum XML_Error result;
+  OPEN_INTERNAL_ENTITY *openEntity;
+
+  if (parser->m_freeInternalEntities) {
+    openEntity = parser->m_freeInternalEntities;
+    parser->m_freeInternalEntities = openEntity->next;
+  } else {
+    openEntity
+        = (OPEN_INTERNAL_ENTITY *)MALLOC(parser, sizeof(OPEN_INTERNAL_ENTITY));
+    if (! openEntity)
+      return XML_ERROR_NO_MEMORY;
+  }
+  entity->open = XML_TRUE;
+#if XML_GE == 1
+  entityTrackingOnOpen(parser, entity, __LINE__);
+#endif
+  entity->processed = 0;
+  openEntity->next = parser->m_openInternalEntities;
+  parser->m_openInternalEntities = openEntity;
+  openEntity->entity = entity;
+  openEntity->startTagLevel = parser->m_tagLevel;
+  openEntity->betweenDecl = betweenDecl;
+  openEntity->internalEventPtr = NULL;
+  openEntity->internalEventEndPtr = NULL;
+  textStart = (const char *)entity->textPtr;
+  textEnd = (const char *)(entity->textPtr + entity->textLen);
+  /* Set a safe default value in case 'next' does not get set */
+  next = textStart;
+
+  if (entity->is_param) {
+    int tok
+        = XmlPrologTok(parser->m_internalEncoding, textStart, textEnd, &next);
+    result = doProlog(parser, parser->m_internalEncoding, textStart, textEnd,
+                      tok, next, &next, XML_FALSE, XML_FALSE,
+                      XML_ACCOUNT_ENTITY_EXPANSION);
+  } else {
+    result = doContent(parser, parser->m_tagLevel, parser->m_internalEncoding,
+                       textStart, textEnd, &next, XML_FALSE,
+                       XML_ACCOUNT_ENTITY_EXPANSION);
+  }
+
+  if (result == XML_ERROR_NONE) {
+    if (textEnd != next && parser->m_parsingStatus.parsing == XML_SUSPENDED) {
+      entity->processed = (int)(next - textStart);
+      parser->m_processor = internalEntityProcessor;
+    } else if (parser->m_openInternalEntities->entity == entity) {
+#if XML_GE == 1
+      entityTrackingOnClose(parser, entity, __LINE__);
+#endif /* XML_GE == 1 */
+      entity->open = XML_FALSE;
+      parser->m_openInternalEntities = openEntity->next;
+      /* put openEntity back in list of free instances */
+      openEntity->next = parser->m_freeInternalEntities;
+      parser->m_freeInternalEntities = openEntity;
+    }
+  }
+  return result;
+}
+
+static enum XML_Error PTRCALL
+internalEntityProcessor(XML_Parser parser, const char *s, const char *end,
+                        const char **nextPtr) {
+  ENTITY *entity;
+  const char *textStart, *textEnd;
+  const char *next;
+  enum XML_Error result;
+  OPEN_INTERNAL_ENTITY *openEntity = parser->m_openInternalEntities;
+  if (! openEntity)
+    return XML_ERROR_UNEXPECTED_STATE;
+
+  entity = openEntity->entity;
+  textStart = ((const char *)entity->textPtr) + entity->processed;
+  textEnd = (const char *)(entity->textPtr + entity->textLen);
+  /* Set a safe default value in case 'next' does not get set */
+  next = textStart;
+
+  if (entity->is_param) {
+    int tok
+        = XmlPrologTok(parser->m_internalEncoding, textStart, textEnd, &next);
+    result = doProlog(parser, parser->m_internalEncoding, textStart, textEnd,
+                      tok, next, &next, XML_FALSE, XML_TRUE,
+                      XML_ACCOUNT_ENTITY_EXPANSION);
+  } else {
+    result = doContent(parser, openEntity->startTagLevel,
+                       parser->m_internalEncoding, textStart, textEnd, &next,
+                       XML_FALSE, XML_ACCOUNT_ENTITY_EXPANSION);
+  }
+
+  if (result != XML_ERROR_NONE)
+    return result;
+
+  if (textEnd != next && parser->m_parsingStatus.parsing == XML_SUSPENDED) {
+    entity->processed = (int)(next - (const char *)entity->textPtr);
+    return result;
+  }
+
+#if XML_GE == 1
+  entityTrackingOnClose(parser, entity, __LINE__);
+#endif
+  entity->open = XML_FALSE;
+  parser->m_openInternalEntities = openEntity->next;
+  /* put openEntity back in list of free instances */
+  openEntity->next = parser->m_freeInternalEntities;
+  parser->m_freeInternalEntities = openEntity;
+
+  // If there are more open entities we want to stop right here and have the
+  // upcoming call to XML_ResumeParser continue with entity content, or it would
+  // be ignored altogether.
+  if (parser->m_openInternalEntities != NULL
+      && parser->m_parsingStatus.parsing == XML_SUSPENDED) {
+    return XML_ERROR_NONE;
+  }
+
+  if (entity->is_param) {
+    int tok;
+    parser->m_processor = prologProcessor;
+    tok = XmlPrologTok(parser->m_encoding, s, end, &next);
+    return doProlog(parser, parser->m_encoding, s, end, tok, next, nextPtr,
+                    (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_TRUE,
+                    XML_ACCOUNT_DIRECT);
+  } else {
+    parser->m_processor = contentProcessor;
+    /* see externalEntityContentProcessor vs contentProcessor */
+    result = doContent(parser, parser->m_parentParser ? 1 : 0,
+                       parser->m_encoding, s, end, nextPtr,
+                       (XML_Bool)! parser->m_parsingStatus.finalBuffer,
+                       XML_ACCOUNT_DIRECT);
+    if (result == XML_ERROR_NONE) {
+      if (! storeRawNames(parser))
+        return XML_ERROR_NO_MEMORY;
+    }
+    return result;
+  }
+}
+
+static enum XML_Error PTRCALL
+errorProcessor(XML_Parser parser, const char *s, const char *end,
+               const char **nextPtr) {
+  UNUSED_P(s);
+  UNUSED_P(end);
+  UNUSED_P(nextPtr);
+  return parser->m_errorCode;
+}
+
+static enum XML_Error
+storeAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,
+                    const char *ptr, const char *end, STRING_POOL *pool,
+                    enum XML_Account account) {
+  enum XML_Error result
+      = appendAttributeValue(parser, enc, isCdata, ptr, end, pool, account);
+  if (result)
+    return result;
+  if (! isCdata && poolLength(pool) && poolLastChar(pool) == 0x20)
+    poolChop(pool);
+  if (! poolAppendChar(pool, XML_T('\0')))
+    return XML_ERROR_NO_MEMORY;
+  return XML_ERROR_NONE;
+}
+
+static enum XML_Error
+appendAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,
+                     const char *ptr, const char *end, STRING_POOL *pool,
+                     enum XML_Account account) {
+  DTD *const dtd = parser->m_dtd; /* save one level of indirection */
+#ifndef XML_DTD
+  UNUSED_P(account);
+#endif
+
+  for (;;) {
+    const char *next
+        = ptr; /* XmlAttributeValueTok doesn't always set the last arg */
+    int tok = XmlAttributeValueTok(enc, ptr, end, &next);
+#if XML_GE == 1
+    if (! accountingDiffTolerated(parser, tok, ptr, next, __LINE__, account)) {
+      accountingOnAbort(parser);
+      return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
+    }
+#endif
+    switch (tok) {
+    case XML_TOK_NONE:
+      return XML_ERROR_NONE;
+    case XML_TOK_INVALID:
+      if (enc == parser->m_encoding)
+        parser->m_eventPtr = next;
+      return XML_ERROR_INVALID_TOKEN;
+    case XML_TOK_PARTIAL:
+      if (enc == parser->m_encoding)
+        parser->m_eventPtr = ptr;
+      return XML_ERROR_INVALID_TOKEN;
+    case XML_TOK_CHAR_REF: {
+      XML_Char buf[XML_ENCODE_MAX];
+      int i;
+      int n = XmlCharRefNumber(enc, ptr);
+      if (n < 0) {
+        if (enc == parser->m_encoding)
+          parser->m_eventPtr = ptr;
+        return XML_ERROR_BAD_CHAR_REF;
+      }
+      if (! isCdata && n == 0x20 /* space */
+          && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))
+        break;
+      n = XmlEncode(n, (ICHAR *)buf);
+      /* The XmlEncode() functions can never return 0 here.  That
+       * error return happens if the code point passed in is either
+       * negative or greater than or equal to 0x110000.  The
+       * XmlCharRefNumber() functions will all return a number
+       * strictly less than 0x110000 or a negative value if an error
+       * occurred.  The negative value is intercepted above, so
+       * XmlEncode() is never passed a value it might return an
+       * error for.
+       */
+      for (i = 0; i < n; i++) {
+        if (! poolAppendChar(pool, buf[i]))
+          return XML_ERROR_NO_MEMORY;
+      }
+    } break;
+    case XML_TOK_DATA_CHARS:
+      if (! poolAppend(pool, enc, ptr, next))
+        return XML_ERROR_NO_MEMORY;
+      break;
+    case XML_TOK_TRAILING_CR:
+      next = ptr + enc->minBytesPerChar;
+      /* fall through */
+    case XML_TOK_ATTRIBUTE_VALUE_S:
+    case XML_TOK_DATA_NEWLINE:
+      if (! isCdata && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))
+        break;
+      if (! poolAppendChar(pool, 0x20))
+        return XML_ERROR_NO_MEMORY;
+      break;
+    case XML_TOK_ENTITY_REF: {
+      const XML_Char *name;
+      ENTITY *entity;
+      char checkEntityDecl;
+      XML_Char ch = (XML_Char)XmlPredefinedEntityName(
+          enc, ptr + enc->minBytesPerChar, next - enc->minBytesPerChar);
+      if (ch) {
+#if XML_GE == 1
+        /* NOTE: We are replacing 4-6 characters original input for 1 character
+         *       so there is no amplification and hence recording without
+         *       protection. */
+        accountingDiffTolerated(parser, tok, (char *)&ch,
+                                ((char *)&ch) + sizeof(XML_Char), __LINE__,
+                                XML_ACCOUNT_ENTITY_EXPANSION);
+#endif /* XML_GE == 1 */
+        if (! poolAppendChar(pool, ch))
+          return XML_ERROR_NO_MEMORY;
+        break;
+      }
+      name = poolStoreString(&parser->m_temp2Pool, enc,
+                             ptr + enc->minBytesPerChar,
+                             next - enc->minBytesPerChar);
+      if (! name)
+        return XML_ERROR_NO_MEMORY;
+      entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);
+      poolDiscard(&parser->m_temp2Pool);
+      /* First, determine if a check for an existing declaration is needed;
+         if yes, check that the entity exists, and that it is internal.
+      */
+      if (pool == &dtd->pool) /* are we called from prolog? */
+        checkEntityDecl =
+#ifdef XML_DTD
+            parser->m_prologState.documentEntity &&
+#endif /* XML_DTD */
+            (dtd->standalone ? ! parser->m_openInternalEntities
+                             : ! dtd->hasParamEntityRefs);
+      else /* if (pool == &parser->m_tempPool): we are called from content */
+        checkEntityDecl = ! dtd->hasParamEntityRefs || dtd->standalone;
+      if (checkEntityDecl) {
+        if (! entity)
+          return XML_ERROR_UNDEFINED_ENTITY;
+        else if (! entity->is_internal)
+          return XML_ERROR_ENTITY_DECLARED_IN_PE;
+      } else if (! entity) {
+        /* Cannot report skipped entity here - see comments on
+           parser->m_skippedEntityHandler.
+        if (parser->m_skippedEntityHandler)
+          parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0);
+        */
+        /* Cannot call the default handler because this would be
+           out of sync with the call to the startElementHandler.
+        if ((pool == &parser->m_tempPool) && parser->m_defaultHandler)
+          reportDefault(parser, enc, ptr, next);
+        */
+        break;
+      }
+      if (entity->open) {
+        if (enc == parser->m_encoding) {
+          /* It does not appear that this line can be executed.
+           *
+           * The "if (entity->open)" check catches recursive entity
+           * definitions.  In order to be called with an open
+           * entity, it must have gone through this code before and
+           * been through the recursive call to
+           * appendAttributeValue() some lines below.  That call
+           * sets the local encoding ("enc") to the parser's
+           * internal encoding (internal_utf8 or internal_utf16),
+           * which can never be the same as the principle encoding.
+           * It doesn't appear there is another code path that gets
+           * here with entity->open being TRUE.
+           *
+           * Since it is not certain that this logic is watertight,
+           * we keep the line and merely exclude it from coverage
+           * tests.
+           */
+          parser->m_eventPtr = ptr; /* LCOV_EXCL_LINE */
+        }
+        return XML_ERROR_RECURSIVE_ENTITY_REF;
+      }
+      if (entity->notation) {
+        if (enc == parser->m_encoding)
+          parser->m_eventPtr = ptr;
+        return XML_ERROR_BINARY_ENTITY_REF;
+      }
+      if (! entity->textPtr) {
+        if (enc == parser->m_encoding)
+          parser->m_eventPtr = ptr;
+        return XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF;
+      } else {
+        enum XML_Error result;
+        const XML_Char *textEnd = entity->textPtr + entity->textLen;
+        entity->open = XML_TRUE;
+#if XML_GE == 1
+        entityTrackingOnOpen(parser, entity, __LINE__);
+#endif
+        result = appendAttributeValue(parser, parser->m_internalEncoding,
+                                      isCdata, (const char *)entity->textPtr,
+                                      (const char *)textEnd, pool,
+                                      XML_ACCOUNT_ENTITY_EXPANSION);
+#if XML_GE == 1
+        entityTrackingOnClose(parser, entity, __LINE__);
+#endif
+        entity->open = XML_FALSE;
+        if (result)
+          return result;
+      }
+    } break;
+    default:
+      /* The only token returned by XmlAttributeValueTok() that does
+       * not have an explicit case here is XML_TOK_PARTIAL_CHAR.
+       * Getting that would require an entity name to contain an
+       * incomplete XML character (e.g. \xE2\x82); however previous
+       * tokenisers will have already recognised and rejected such
+       * names before XmlAttributeValueTok() gets a look-in.  This
+       * default case should be retained as a safety net, but the code
+       * excluded from coverage tests.
+       *
+       * LCOV_EXCL_START
+       */
+      if (enc == parser->m_encoding)
+        parser->m_eventPtr = ptr;
+      return XML_ERROR_UNEXPECTED_STATE;
+      /* LCOV_EXCL_STOP */
+    }
+    ptr = next;
+  }
+  /* not reached */
+}
+
+#if XML_GE == 1
+static enum XML_Error
+storeEntityValue(XML_Parser parser, const ENCODING *enc,
+                 const char *entityTextPtr, const char *entityTextEnd,
+                 enum XML_Account account) {
+  DTD *const dtd = parser->m_dtd; /* save one level of indirection */
+  STRING_POOL *pool = &(dtd->entityValuePool);
+  enum XML_Error result = XML_ERROR_NONE;
+#  ifdef XML_DTD
+  int oldInEntityValue = parser->m_prologState.inEntityValue;
+  parser->m_prologState.inEntityValue = 1;
+#  else
+  UNUSED_P(account);
+#  endif /* XML_DTD */
+  /* never return Null for the value argument in EntityDeclHandler,
+     since this would indicate an external entity; therefore we
+     have to make sure that entityValuePool.start is not null */
+  if (! pool->blocks) {
+    if (! poolGrow(pool))
+      return XML_ERROR_NO_MEMORY;
+  }
+
+  for (;;) {
+    const char *next
+        = entityTextPtr; /* XmlEntityValueTok doesn't always set the last arg */
+    int tok = XmlEntityValueTok(enc, entityTextPtr, entityTextEnd, &next);
+
+    if (! accountingDiffTolerated(parser, tok, entityTextPtr, next, __LINE__,
+                                  account)) {
+      accountingOnAbort(parser);
+      result = XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
+      goto endEntityValue;
+    }
+
+    switch (tok) {
+    case XML_TOK_PARAM_ENTITY_REF:
+#  ifdef XML_DTD
+      if (parser->m_isParamEntity || enc != parser->m_encoding) {
+        const XML_Char *name;
+        ENTITY *entity;
+        name = poolStoreString(&parser->m_tempPool, enc,
+                               entityTextPtr + enc->minBytesPerChar,
+                               next - enc->minBytesPerChar);
+        if (! name) {
+          result = XML_ERROR_NO_MEMORY;
+          goto endEntityValue;
+        }
+        entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0);
+        poolDiscard(&parser->m_tempPool);
+        if (! entity) {
+          /* not a well-formedness error - see XML 1.0: WFC Entity Declared */
+          /* cannot report skipped entity here - see comments on
+             parser->m_skippedEntityHandler
+          if (parser->m_skippedEntityHandler)
+            parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0);
+          */
+          dtd->keepProcessing = dtd->standalone;
+          goto endEntityValue;
+        }
+        if (entity->open || (entity == parser->m_declEntity)) {
+          if (enc == parser->m_encoding)
+            parser->m_eventPtr = entityTextPtr;
+          result = XML_ERROR_RECURSIVE_ENTITY_REF;
+          goto endEntityValue;
+        }
+        if (entity->systemId) {
+          if (parser->m_externalEntityRefHandler) {
+            dtd->paramEntityRead = XML_FALSE;
+            entity->open = XML_TRUE;
+            entityTrackingOnOpen(parser, entity, __LINE__);
+            if (! parser->m_externalEntityRefHandler(
+                    parser->m_externalEntityRefHandlerArg, 0, entity->base,
+                    entity->systemId, entity->publicId)) {
+              entityTrackingOnClose(parser, entity, __LINE__);
+              entity->open = XML_FALSE;
+              result = XML_ERROR_EXTERNAL_ENTITY_HANDLING;
+              goto endEntityValue;
+            }
+            entityTrackingOnClose(parser, entity, __LINE__);
+            entity->open = XML_FALSE;
+            if (! dtd->paramEntityRead)
+              dtd->keepProcessing = dtd->standalone;
+          } else
+            dtd->keepProcessing = dtd->standalone;
+        } else {
+          entity->open = XML_TRUE;
+          entityTrackingOnOpen(parser, entity, __LINE__);
+          result = storeEntityValue(
+              parser, parser->m_internalEncoding, (const char *)entity->textPtr,
+              (const char *)(entity->textPtr + entity->textLen),
+              XML_ACCOUNT_ENTITY_EXPANSION);
+          entityTrackingOnClose(parser, entity, __LINE__);
+          entity->open = XML_FALSE;
+          if (result)
+            goto endEntityValue;
+        }
+        break;
+      }
+#  endif /* XML_DTD */
+      /* In the internal subset, PE references are not legal
+         within markup declarations, e.g entity values in this case. */
+      parser->m_eventPtr = entityTextPtr;
+      result = XML_ERROR_PARAM_ENTITY_REF;
+      goto endEntityValue;
+    case XML_TOK_NONE:
+      result = XML_ERROR_NONE;
+      goto endEntityValue;
+    case XML_TOK_ENTITY_REF:
+    case XML_TOK_DATA_CHARS:
+      if (! poolAppend(pool, enc, entityTextPtr, next)) {
+        result = XML_ERROR_NO_MEMORY;
+        goto endEntityValue;
+      }
+      break;
+    case XML_TOK_TRAILING_CR:
+      next = entityTextPtr + enc->minBytesPerChar;
+      /* fall through */
+    case XML_TOK_DATA_NEWLINE:
+      if (pool->end == pool->ptr && ! poolGrow(pool)) {
+        result = XML_ERROR_NO_MEMORY;
+        goto endEntityValue;
+      }
+      *(pool->ptr)++ = 0xA;
+      break;
+    case XML_TOK_CHAR_REF: {
+      XML_Char buf[XML_ENCODE_MAX];
+      int i;
+      int n = XmlCharRefNumber(enc, entityTextPtr);
+      if (n < 0) {
+        if (enc == parser->m_encoding)
+          parser->m_eventPtr = entityTextPtr;
+        result = XML_ERROR_BAD_CHAR_REF;
+        goto endEntityValue;
+      }
+      n = XmlEncode(n, (ICHAR *)buf);
+      /* The XmlEncode() functions can never return 0 here.  That
+       * error return happens if the code point passed in is either
+       * negative or greater than or equal to 0x110000.  The
+       * XmlCharRefNumber() functions will all return a number
+       * strictly less than 0x110000 or a negative value if an error
+       * occurred.  The negative value is intercepted above, so
+       * XmlEncode() is never passed a value it might return an
+       * error for.
+       */
+      for (i = 0; i < n; i++) {
+        if (pool->end == pool->ptr && ! poolGrow(pool)) {
+          result = XML_ERROR_NO_MEMORY;
+          goto endEntityValue;
+        }
+        *(pool->ptr)++ = buf[i];
+      }
+    } break;
+    case XML_TOK_PARTIAL:
+      if (enc == parser->m_encoding)
+        parser->m_eventPtr = entityTextPtr;
+      result = XML_ERROR_INVALID_TOKEN;
+      goto endEntityValue;
+    case XML_TOK_INVALID:
+      if (enc == parser->m_encoding)
+        parser->m_eventPtr = next;
+      result = XML_ERROR_INVALID_TOKEN;
+      goto endEntityValue;
+    default:
+      /* This default case should be unnecessary -- all the tokens
+       * that XmlEntityValueTok() can return have their own explicit
+       * cases -- but should be retained for safety.  We do however
+       * exclude it from the coverage statistics.
+       *
+       * LCOV_EXCL_START
+       */
+      if (enc == parser->m_encoding)
+        parser->m_eventPtr = entityTextPtr;
+      result = XML_ERROR_UNEXPECTED_STATE;
+      goto endEntityValue;
+      /* LCOV_EXCL_STOP */
+    }
+    entityTextPtr = next;
+  }
+endEntityValue:
+#  ifdef XML_DTD
+  parser->m_prologState.inEntityValue = oldInEntityValue;
+#  endif /* XML_DTD */
+  return result;
+}
+
+#else /* XML_GE == 0 */
+
+static enum XML_Error
+storeSelfEntityValue(XML_Parser parser, ENTITY *entity) {
+  // This will store "&amp;entity123;" in entity->textPtr
+  // to end up as "&entity123;" in the handler.
+  const char *const entity_start = "&amp;";
+  const char *const entity_end = ";";
+
+  STRING_POOL *const pool = &(parser->m_dtd->entityValuePool);
+  if (! poolAppendString(pool, entity_start)
+      || ! poolAppendString(pool, entity->name)
+      || ! poolAppendString(pool, entity_end)) {
+    poolDiscard(pool);
+    return XML_ERROR_NO_MEMORY;
+  }
+
+  entity->textPtr = poolStart(pool);
+  entity->textLen = (int)(poolLength(pool));
+  poolFinish(pool);
+
+  return XML_ERROR_NONE;
+}
+
+#endif /* XML_GE == 0 */
+
+static void FASTCALL
+normalizeLines(XML_Char *s) {
+  XML_Char *p;
+  for (;; s++) {
+    if (*s == XML_T('\0'))
+      return;
+    if (*s == 0xD)
+      break;
+  }
+  p = s;
+  do {
+    if (*s == 0xD) {
+      *p++ = 0xA;
+      if (*++s == 0xA)
+        s++;
+    } else
+      *p++ = *s++;
+  } while (*s);
+  *p = XML_T('\0');
+}
+
+static int
+reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,
+                            const char *start, const char *end) {
+  const XML_Char *target;
+  XML_Char *data;
+  const char *tem;
+  if (! parser->m_processingInstructionHandler) {
+    if (parser->m_defaultHandler)
+      reportDefault(parser, enc, start, end);
+    return 1;
+  }
+  start += enc->minBytesPerChar * 2;
+  tem = start + XmlNameLength(enc, start);
+  target = poolStoreString(&parser->m_tempPool, enc, start, tem);
+  if (! target)
+    return 0;
+  poolFinish(&parser->m_tempPool);
+  data = poolStoreString(&parser->m_tempPool, enc, XmlSkipS(enc, tem),
+                         end - enc->minBytesPerChar * 2);
+  if (! data)
+    return 0;
+  normalizeLines(data);
+  parser->m_processingInstructionHandler(parser->m_handlerArg, target, data);
+  poolClear(&parser->m_tempPool);
+  return 1;
+}
+
+static int
+reportComment(XML_Parser parser, const ENCODING *enc, const char *start,
+              const char *end) {
+  XML_Char *data;
+  if (! parser->m_commentHandler) {
+    if (parser->m_defaultHandler)
+      reportDefault(parser, enc, start, end);
+    return 1;
+  }
+  data = poolStoreString(&parser->m_tempPool, enc,
+                         start + enc->minBytesPerChar * 4,
+                         end - enc->minBytesPerChar * 3);
+  if (! data)
+    return 0;
+  normalizeLines(data);
+  parser->m_commentHandler(parser->m_handlerArg, data);
+  poolClear(&parser->m_tempPool);
+  return 1;
+}
+
+static void
+reportDefault(XML_Parser parser, const ENCODING *enc, const char *s,
+              const char *end) {
+  if (MUST_CONVERT(enc, s)) {
+    enum XML_Convert_Result convert_res;
+    const char **eventPP;
+    const char **eventEndPP;
+    if (enc == parser->m_encoding) {
+      eventPP = &parser->m_eventPtr;
+      eventEndPP = &parser->m_eventEndPtr;
+    } else {
+      /* To get here, two things must be true; the parser must be
+       * using a character encoding that is not the same as the
+       * encoding passed in, and the encoding passed in must need
+       * conversion to the internal format (UTF-8 unless XML_UNICODE
+       * is defined).  The only occasions on which the encoding passed
+       * in is not the same as the parser's encoding are when it is
+       * the internal encoding (e.g. a previously defined parameter
+       * entity, already converted to internal format).  This by
+       * definition doesn't need conversion, so the whole branch never
+       * gets executed.
+       *
+       * For safety's sake we don't delete these lines and merely
+       * exclude them from coverage statistics.
+       *
+       * LCOV_EXCL_START
+       */
+      eventPP = &(parser->m_openInternalEntities->internalEventPtr);
+      eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
+      /* LCOV_EXCL_STOP */
+    }
+    do {
+      ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
+      convert_res
+          = XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
+      *eventEndPP = s;
+      parser->m_defaultHandler(parser->m_handlerArg, parser->m_dataBuf,
+                               (int)(dataPtr - (ICHAR *)parser->m_dataBuf));
+      *eventPP = s;
+    } while ((convert_res != XML_CONVERT_COMPLETED)
+             && (convert_res != XML_CONVERT_INPUT_INCOMPLETE));
+  } else
+    parser->m_defaultHandler(
+        parser->m_handlerArg, (const XML_Char *)s,
+        (int)((const XML_Char *)end - (const XML_Char *)s));
+}
+
+static int
+defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId, XML_Bool isCdata,
+                XML_Bool isId, const XML_Char *value, XML_Parser parser) {
+  DEFAULT_ATTRIBUTE *att;
+  if (value || isId) {
+    /* The handling of default attributes gets messed up if we have
+       a default which duplicates a non-default. */
+    int i;
+    for (i = 0; i < type->nDefaultAtts; i++)
+      if (attId == type->defaultAtts[i].id)
+        return 1;
+    if (isId && ! type->idAtt && ! attId->xmlns)
+      type->idAtt = attId;
+  }
+  if (type->nDefaultAtts == type->allocDefaultAtts) {
+    if (type->allocDefaultAtts == 0) {
+      type->allocDefaultAtts = 8;
+      type->defaultAtts = (DEFAULT_ATTRIBUTE *)MALLOC(
+          parser, type->allocDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));
+      if (! type->defaultAtts) {
+        type->allocDefaultAtts = 0;
+        return 0;
+      }
+    } else {
+      DEFAULT_ATTRIBUTE *temp;
+
+      /* Detect and prevent integer overflow */
+      if (type->allocDefaultAtts > INT_MAX / 2) {
+        return 0;
+      }
+
+      int count = type->allocDefaultAtts * 2;
+
+      /* Detect and prevent integer overflow.
+       * The preprocessor guard addresses the "always false" warning
+       * from -Wtype-limits on platforms where
+       * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
+#if UINT_MAX >= SIZE_MAX
+      if ((unsigned)count > (size_t)(-1) / sizeof(DEFAULT_ATTRIBUTE)) {
+        return 0;
+      }
+#endif
+
+      temp = (DEFAULT_ATTRIBUTE *)REALLOC(parser, type->defaultAtts,
+                                          (count * sizeof(DEFAULT_ATTRIBUTE)));
+      if (temp == NULL)
+        return 0;
+      type->allocDefaultAtts = count;
+      type->defaultAtts = temp;
+    }
+  }
+  att = type->defaultAtts + type->nDefaultAtts;
+  att->id = attId;
+  att->value = value;
+  att->isCdata = isCdata;
+  if (! isCdata)
+    attId->maybeTokenized = XML_TRUE;
+  type->nDefaultAtts += 1;
+  return 1;
+}
+
+static int
+setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *elementType) {
+  DTD *const dtd = parser->m_dtd; /* save one level of indirection */
+  const XML_Char *name;
+  for (name = elementType->name; *name; name++) {
+    if (*name == XML_T(ASCII_COLON)) {
+      PREFIX *prefix;
+      const XML_Char *s;
+      for (s = elementType->name; s != name; s++) {
+        if (! poolAppendChar(&dtd->pool, *s))
+          return 0;
+      }
+      if (! poolAppendChar(&dtd->pool, XML_T('\0')))
+        return 0;
+      prefix = (PREFIX *)lookup(parser, &dtd->prefixes, poolStart(&dtd->pool),
+                                sizeof(PREFIX));
+      if (! prefix)
+        return 0;
+      if (prefix->name == poolStart(&dtd->pool))
+        poolFinish(&dtd->pool);
+      else
+        poolDiscard(&dtd->pool);
+      elementType->prefix = prefix;
+      break;
+    }
+  }
+  return 1;
+}
+
+static ATTRIBUTE_ID *
+getAttributeId(XML_Parser parser, const ENCODING *enc, const char *start,
+               const char *end) {
+  DTD *const dtd = parser->m_dtd; /* save one level of indirection */
+  ATTRIBUTE_ID *id;
+  const XML_Char *name;
+  if (! poolAppendChar(&dtd->pool, XML_T('\0')))
+    return NULL;
+  name = poolStoreString(&dtd->pool, enc, start, end);
+  if (! name)
+    return NULL;
+  /* skip quotation mark - its storage will be reused (like in name[-1]) */
+  ++name;
+  id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, name,
+                              sizeof(ATTRIBUTE_ID));
+  if (! id)
+    return NULL;
+  if (id->name != name)
+    poolDiscard(&dtd->pool);
+  else {
+    poolFinish(&dtd->pool);
+    if (! parser->m_ns)
+      ;
+    else if (name[0] == XML_T(ASCII_x) && name[1] == XML_T(ASCII_m)
+             && name[2] == XML_T(ASCII_l) && name[3] == XML_T(ASCII_n)
+             && name[4] == XML_T(ASCII_s)
+             && (name[5] == XML_T('\0') || name[5] == XML_T(ASCII_COLON))) {
+      if (name[5] == XML_T('\0'))
+        id->prefix = &dtd->defaultPrefix;
+      else
+        id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes, name + 6,
+                                      sizeof(PREFIX));
+      id->xmlns = XML_TRUE;
+    } else {
+      int i;
+      for (i = 0; name[i]; i++) {
+        /* attributes without prefix are *not* in the default namespace */
+        if (name[i] == XML_T(ASCII_COLON)) {
+          int j;
+          for (j = 0; j < i; j++) {
+            if (! poolAppendChar(&dtd->pool, name[j]))
+              return NULL;
+          }
+          if (! poolAppendChar(&dtd->pool, XML_T('\0')))
+            return NULL;
+          id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes,
+                                        poolStart(&dtd->pool), sizeof(PREFIX));
+          if (! id->prefix)
+            return NULL;
+          if (id->prefix->name == poolStart(&dtd->pool))
+            poolFinish(&dtd->pool);
+          else
+            poolDiscard(&dtd->pool);
+          break;
+        }
+      }
+    }
+  }
+  return id;
+}
+
+#define CONTEXT_SEP XML_T(ASCII_FF)
+
+static const XML_Char *
+getContext(XML_Parser parser) {
+  DTD *const dtd = parser->m_dtd; /* save one level of indirection */
+  HASH_TABLE_ITER iter;
+  XML_Bool needSep = XML_FALSE;
+
+  if (dtd->defaultPrefix.binding) {
+    int i;
+    int len;
+    if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_EQUALS)))
+      return NULL;
+    len = dtd->defaultPrefix.binding->uriLen;
+    if (parser->m_namespaceSeparator)
+      len--;
+    for (i = 0; i < len; i++) {
+      if (! poolAppendChar(&parser->m_tempPool,
+                           dtd->defaultPrefix.binding->uri[i])) {
+        /* Because of memory caching, I don't believe this line can be
+         * executed.
+         *
+         * This is part of a loop copying the default prefix binding
+         * URI into the parser's temporary string pool.  Previously,
+         * that URI was copied into the same string pool, with a
+         * terminating NUL character, as part of setContext().  When
+         * the pool was cleared, that leaves a block definitely big
+         * enough to hold the URI on the free block list of the pool.
+         * The URI copy in getContext() therefore cannot run out of
+         * memory.
+         *
+         * If the pool is used between the setContext() and
+         * getContext() calls, the worst it can do is leave a bigger
+         * block on the front of the free list.  Given that this is
+         * all somewhat inobvious and program logic can be changed, we
+         * don't delete the line but we do exclude it from the test
+         * coverage statistics.
+         */
+        return NULL; /* LCOV_EXCL_LINE */
+      }
+    }
+    needSep = XML_TRUE;
+  }
+
+  hashTableIterInit(&iter, &(dtd->prefixes));
+  for (;;) {
+    int i;
+    int len;
+    const XML_Char *s;
+    PREFIX *prefix = (PREFIX *)hashTableIterNext(&iter);
+    if (! prefix)
+      break;
+    if (! prefix->binding) {
+      /* This test appears to be (justifiable) paranoia.  There does
+       * not seem to be a way of injecting a prefix without a binding
+       * that doesn't get errored long before this function is called.
+       * The test should remain for safety's sake, so we instead
+       * exclude the following line from the coverage statistics.
+       */
+      continue; /* LCOV_EXCL_LINE */
+    }
+    if (needSep && ! poolAppendChar(&parser->m_tempPool, CONTEXT_SEP))
+      return NULL;
+    for (s = prefix->name; *s; s++)
+      if (! poolAppendChar(&parser->m_tempPool, *s))
+        return NULL;
+    if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_EQUALS)))
+      return NULL;
+    len = prefix->binding->uriLen;
+    if (parser->m_namespaceSeparator)
+      len--;
+    for (i = 0; i < len; i++)
+      if (! poolAppendChar(&parser->m_tempPool, prefix->binding->uri[i]))
+        return NULL;
+    needSep = XML_TRUE;
+  }
+
+  hashTableIterInit(&iter, &(dtd->generalEntities));
+  for (;;) {
+    const XML_Char *s;
+    ENTITY *e = (ENTITY *)hashTableIterNext(&iter);
+    if (! e)
+      break;
+    if (! e->open)
+      continue;
+    if (needSep && ! poolAppendChar(&parser->m_tempPool, CONTEXT_SEP))
+      return NULL;
+    for (s = e->name; *s; s++)
+      if (! poolAppendChar(&parser->m_tempPool, *s))
+        return 0;
+    needSep = XML_TRUE;
+  }
+
+  if (! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
+    return NULL;
+  return parser->m_tempPool.start;
+}
+
+static XML_Bool
+setContext(XML_Parser parser, const XML_Char *context) {
+  if (context == NULL) {
+    return XML_FALSE;
+  }
+
+  DTD *const dtd = parser->m_dtd; /* save one level of indirection */
+  const XML_Char *s = context;
+
+  while (*context != XML_T('\0')) {
+    if (*s == CONTEXT_SEP || *s == XML_T('\0')) {
+      ENTITY *e;
+      if (! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
+        return XML_FALSE;
+      e = (ENTITY *)lookup(parser, &dtd->generalEntities,
+                           poolStart(&parser->m_tempPool), 0);
+      if (e)
+        e->open = XML_TRUE;
+      if (*s != XML_T('\0'))
+        s++;
+      context = s;
+      poolDiscard(&parser->m_tempPool);
+    } else if (*s == XML_T(ASCII_EQUALS)) {
+      PREFIX *prefix;
+      if (poolLength(&parser->m_tempPool) == 0)
+        prefix = &dtd->defaultPrefix;
+      else {
+        if (! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
+          return XML_FALSE;
+        prefix
+            = (PREFIX *)lookup(parser, &dtd->prefixes,
+                               poolStart(&parser->m_tempPool), sizeof(PREFIX));
+        if (! prefix)
+          return XML_FALSE;
+        if (prefix->name == poolStart(&parser->m_tempPool)) {
+          prefix->name = poolCopyString(&dtd->pool, prefix->name);
+          if (! prefix->name)
+            return XML_FALSE;
+        }
+        poolDiscard(&parser->m_tempPool);
+      }
+      for (context = s + 1; *context != CONTEXT_SEP && *context != XML_T('\0');
+           context++)
+        if (! poolAppendChar(&parser->m_tempPool, *context))
+          return XML_FALSE;
+      if (! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
+        return XML_FALSE;
+      if (addBinding(parser, prefix, NULL, poolStart(&parser->m_tempPool),
+                     &parser->m_inheritedBindings)
+          != XML_ERROR_NONE)
+        return XML_FALSE;
+      poolDiscard(&parser->m_tempPool);
+      if (*context != XML_T('\0'))
+        ++context;
+      s = context;
+    } else {
+      if (! poolAppendChar(&parser->m_tempPool, *s))
+        return XML_FALSE;
+      s++;
+    }
+  }
+  return XML_TRUE;
+}
+
+static void FASTCALL
+normalizePublicId(XML_Char *publicId) {
+  XML_Char *p = publicId;
+  XML_Char *s;
+  for (s = publicId; *s; s++) {
+    switch (*s) {
+    case 0x20:
+    case 0xD:
+    case 0xA:
+      if (p != publicId && p[-1] != 0x20)
+        *p++ = 0x20;
+      break;
+    default:
+      *p++ = *s;
+    }
+  }
+  if (p != publicId && p[-1] == 0x20)
+    --p;
+  *p = XML_T('\0');
+}
+
+static DTD *
+dtdCreate(const XML_Memory_Handling_Suite *ms) {
+  DTD *p = ms->malloc_fcn(sizeof(DTD));
+  if (p == NULL)
+    return p;
+  poolInit(&(p->pool), ms);
+  poolInit(&(p->entityValuePool), ms);
+  hashTableInit(&(p->generalEntities), ms);
+  hashTableInit(&(p->elementTypes), ms);
+  hashTableInit(&(p->attributeIds), ms);
+  hashTableInit(&(p->prefixes), ms);
+#ifdef XML_DTD
+  p->paramEntityRead = XML_FALSE;
+  hashTableInit(&(p->paramEntities), ms);
+#endif /* XML_DTD */
+  p->defaultPrefix.name = NULL;
+  p->defaultPrefix.binding = NULL;
+
+  p->in_eldecl = XML_FALSE;
+  p->scaffIndex = NULL;
+  p->scaffold = NULL;
+  p->scaffLevel = 0;
+  p->scaffSize = 0;
+  p->scaffCount = 0;
+  p->contentStringLen = 0;
+
+  p->keepProcessing = XML_TRUE;
+  p->hasParamEntityRefs = XML_FALSE;
+  p->standalone = XML_FALSE;
+  return p;
+}
+
+static void
+dtdReset(DTD *p, const XML_Memory_Handling_Suite *ms) {
+  HASH_TABLE_ITER iter;
+  hashTableIterInit(&iter, &(p->elementTypes));
+  for (;;) {
+    ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);
+    if (! e)
+      break;
+    if (e->allocDefaultAtts != 0)
+      ms->free_fcn(e->defaultAtts);
+  }
+  hashTableClear(&(p->generalEntities));
+#ifdef XML_DTD
+  p->paramEntityRead = XML_FALSE;
+  hashTableClear(&(p->paramEntities));
+#endif /* XML_DTD */
+  hashTableClear(&(p->elementTypes));
+  hashTableClear(&(p->attributeIds));
+  hashTableClear(&(p->prefixes));
+  poolClear(&(p->pool));
+  poolClear(&(p->entityValuePool));
+  p->defaultPrefix.name = NULL;
+  p->defaultPrefix.binding = NULL;
+
+  p->in_eldecl = XML_FALSE;
+
+  ms->free_fcn(p->scaffIndex);
+  p->scaffIndex = NULL;
+  ms->free_fcn(p->scaffold);
+  p->scaffold = NULL;
+
+  p->scaffLevel = 0;
+  p->scaffSize = 0;
+  p->scaffCount = 0;
+  p->contentStringLen = 0;
+
+  p->keepProcessing = XML_TRUE;
+  p->hasParamEntityRefs = XML_FALSE;
+  p->standalone = XML_FALSE;
+}
+
+static void
+dtdDestroy(DTD *p, XML_Bool isDocEntity, const XML_Memory_Handling_Suite *ms) {
+  HASH_TABLE_ITER iter;
+  hashTableIterInit(&iter, &(p->elementTypes));
+  for (;;) {
+    ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);
+    if (! e)
+      break;
+    if (e->allocDefaultAtts != 0)
+      ms->free_fcn(e->defaultAtts);
+  }
+  hashTableDestroy(&(p->generalEntities));
+#ifdef XML_DTD
+  hashTableDestroy(&(p->paramEntities));
+#endif /* XML_DTD */
+  hashTableDestroy(&(p->elementTypes));
+  hashTableDestroy(&(p->attributeIds));
+  hashTableDestroy(&(p->prefixes));
+  poolDestroy(&(p->pool));
+  poolDestroy(&(p->entityValuePool));
+  if (isDocEntity) {
+    ms->free_fcn(p->scaffIndex);
+    ms->free_fcn(p->scaffold);
+  }
+  ms->free_fcn(p);
+}
+
+/* Do a deep copy of the DTD. Return 0 for out of memory, non-zero otherwise.
+   The new DTD has already been initialized.
+*/
+static int
+dtdCopy(XML_Parser oldParser, DTD *newDtd, const DTD *oldDtd,
+        const XML_Memory_Handling_Suite *ms) {
+  HASH_TABLE_ITER iter;
+
+  /* Copy the prefix table. */
+
+  hashTableIterInit(&iter, &(oldDtd->prefixes));
+  for (;;) {
+    const XML_Char *name;
+    const PREFIX *oldP = (PREFIX *)hashTableIterNext(&iter);
+    if (! oldP)
+      break;
+    name = poolCopyString(&(newDtd->pool), oldP->name);
+    if (! name)
+      return 0;
+    if (! lookup(oldParser, &(newDtd->prefixes), name, sizeof(PREFIX)))
+      return 0;
+  }
+
+  hashTableIterInit(&iter, &(oldDtd->attributeIds));
+
+  /* Copy the attribute id table. */
+
+  for (;;) {
+    ATTRIBUTE_ID *newA;
+    const XML_Char *name;
+    const ATTRIBUTE_ID *oldA = (ATTRIBUTE_ID *)hashTableIterNext(&iter);
+
+    if (! oldA)
+      break;
+    /* Remember to allocate the scratch byte before the name. */
+    if (! poolAppendChar(&(newDtd->pool), XML_T('\0')))
+      return 0;
+    name = poolCopyString(&(newDtd->pool), oldA->name);
+    if (! name)
+      return 0;
+    ++name;
+    newA = (ATTRIBUTE_ID *)lookup(oldParser, &(newDtd->attributeIds), name,
+                                  sizeof(ATTRIBUTE_ID));
+    if (! newA)
+      return 0;
+    newA->maybeTokenized = oldA->maybeTokenized;
+    if (oldA->prefix) {
+      newA->xmlns = oldA->xmlns;
+      if (oldA->prefix == &oldDtd->defaultPrefix)
+        newA->prefix = &newDtd->defaultPrefix;
+      else
+        newA->prefix = (PREFIX *)lookup(oldParser, &(newDtd->prefixes),
+                                        oldA->prefix->name, 0);
+    }
+  }
+
+  /* Copy the element type table. */
+
+  hashTableIterInit(&iter, &(oldDtd->elementTypes));
+
+  for (;;) {
+    int i;
+    ELEMENT_TYPE *newE;
+    const XML_Char *name;
+    const ELEMENT_TYPE *oldE = (ELEMENT_TYPE *)hashTableIterNext(&iter);
+    if (! oldE)
+      break;
+    name = poolCopyString(&(newDtd->pool), oldE->name);
+    if (! name)
+      return 0;
+    newE = (ELEMENT_TYPE *)lookup(oldParser, &(newDtd->elementTypes), name,
+                                  sizeof(ELEMENT_TYPE));
+    if (! newE)
+      return 0;
+    if (oldE->nDefaultAtts) {
+      /* Detect and prevent integer overflow.
+       * The preprocessor guard addresses the "always false" warning
+       * from -Wtype-limits on platforms where
+       * sizeof(int) < sizeof(size_t), e.g. on x86_64. */
+#if UINT_MAX >= SIZE_MAX
+      if ((size_t)oldE->nDefaultAtts
+          > ((size_t)(-1) / sizeof(DEFAULT_ATTRIBUTE))) {
+        return 0;
+      }
+#endif
+      newE->defaultAtts
+          = ms->malloc_fcn(oldE->nDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));
+      if (! newE->defaultAtts) {
+        return 0;
+      }
+    }
+    if (oldE->idAtt)
+      newE->idAtt = (ATTRIBUTE_ID *)lookup(oldParser, &(newDtd->attributeIds),
+                                           oldE->idAtt->name, 0);
+    newE->allocDefaultAtts = newE->nDefaultAtts = oldE->nDefaultAtts;
+    if (oldE->prefix)
+      newE->prefix = (PREFIX *)lookup(oldParser, &(newDtd->prefixes),
+                                      oldE->prefix->name, 0);
+    for (i = 0; i < newE->nDefaultAtts; i++) {
+      newE->defaultAtts[i].id = (ATTRIBUTE_ID *)lookup(
+          oldParser, &(newDtd->attributeIds), oldE->defaultAtts[i].id->name, 0);
+      newE->defaultAtts[i].isCdata = oldE->defaultAtts[i].isCdata;
+      if (oldE->defaultAtts[i].value) {
+        newE->defaultAtts[i].value
+            = poolCopyString(&(newDtd->pool), oldE->defaultAtts[i].value);
+        if (! newE->defaultAtts[i].value)
+          return 0;
+      } else
+        newE->defaultAtts[i].value = NULL;
+    }
+  }
+
+  /* Copy the entity tables. */
+  if (! copyEntityTable(oldParser, &(newDtd->generalEntities), &(newDtd->pool),
+                        &(oldDtd->generalEntities)))
+    return 0;
+
+#ifdef XML_DTD
+  if (! copyEntityTable(oldParser, &(newDtd->paramEntities), &(newDtd->pool),
+                        &(oldDtd->paramEntities)))
+    return 0;
+  newDtd->paramEntityRead = oldDtd->paramEntityRead;
+#endif /* XML_DTD */
+
+  newDtd->keepProcessing = oldDtd->keepProcessing;
+  newDtd->hasParamEntityRefs = oldDtd->hasParamEntityRefs;
+  newDtd->standalone = oldDtd->standalone;
+
+  /* Don't want deep copying for scaffolding */
+  newDtd->in_eldecl = oldDtd->in_eldecl;
+  newDtd->scaffold = oldDtd->scaffold;
+  newDtd->contentStringLen = oldDtd->contentStringLen;
+  newDtd->scaffSize = oldDtd->scaffSize;
+  newDtd->scaffLevel = oldDtd->scaffLevel;
+  newDtd->scaffIndex = oldDtd->scaffIndex;
+
+  return 1;
+} /* End dtdCopy */
+
+static int
+copyEntityTable(XML_Parser oldParser, HASH_TABLE *newTable,
+                STRING_POOL *newPool, const HASH_TABLE *oldTable) {
+  HASH_TABLE_ITER iter;
+  const XML_Char *cachedOldBase = NULL;
+  const XML_Char *cachedNewBase = NULL;
+
+  hashTableIterInit(&iter, oldTable);
+
+  for (;;) {
+    ENTITY *newE;
+    const XML_Char *name;
+    const ENTITY *oldE = (ENTITY *)hashTableIterNext(&iter);
+    if (! oldE)
+      break;
+    name = poolCopyString(newPool, oldE->name);
+    if (! name)
+      return 0;
+    newE = (ENTITY *)lookup(oldParser, newTable, name, sizeof(ENTITY));
+    if (! newE)
+      return 0;
+    if (oldE->systemId) {
+      const XML_Char *tem = poolCopyString(newPool, oldE->systemId);
+      if (! tem)
+        return 0;
+      newE->systemId = tem;
+      if (oldE->base) {
+        if (oldE->base == cachedOldBase)
+          newE->base = cachedNewBase;
+        else {
+          cachedOldBase = oldE->base;
+          tem = poolCopyString(newPool, cachedOldBase);
+          if (! tem)
+            return 0;
+          cachedNewBase = newE->base = tem;
+        }
+      }
+      if (oldE->publicId) {
+        tem = poolCopyString(newPool, oldE->publicId);
+        if (! tem)
+          return 0;
+        newE->publicId = tem;
+      }
+    } else {
+      const XML_Char *tem
+          = poolCopyStringN(newPool, oldE->textPtr, oldE->textLen);
+      if (! tem)
+        return 0;
+      newE->textPtr = tem;
+      newE->textLen = oldE->textLen;
+    }
+    if (oldE->notation) {
+      const XML_Char *tem = poolCopyString(newPool, oldE->notation);
+      if (! tem)
+        return 0;
+      newE->notation = tem;
+    }
+    newE->is_param = oldE->is_param;
+    newE->is_internal = oldE->is_internal;
+  }
+  return 1;
+}
+
+#define INIT_POWER 6
+
+static XML_Bool FASTCALL
+keyeq(KEY s1, KEY s2) {
+  for (; *s1 == *s2; s1++, s2++)
+    if (*s1 == 0)
+      return XML_TRUE;
+  return XML_FALSE;
+}
+
+static size_t
+keylen(KEY s) {
+  size_t len = 0;
+  for (; *s; s++, len++)
+    ;
+  return len;
+}
+
+static void
+copy_salt_to_sipkey(XML_Parser parser, struct sipkey *key) {
+  key->k[0] = 0;
+  key->k[1] = get_hash_secret_salt(parser);
+}
+
+static unsigned long FASTCALL
+hash(XML_Parser parser, KEY s) {
+  struct siphash state;
+  struct sipkey key;
+  (void)sip24_valid;
+  copy_salt_to_sipkey(parser, &key);
+  sip24_init(&state, &key);
+  sip24_update(&state, s, keylen(s) * sizeof(XML_Char));
+  return (unsigned long)sip24_final(&state);
+}
+
+static NAMED *
+lookup(XML_Parser parser, HASH_TABLE *table, KEY name, size_t createSize) {
+  size_t i;
+  if (table->size == 0) {
+    size_t tsize;
+    if (! createSize)
+      return NULL;
+    table->power = INIT_POWER;
+    /* table->size is a power of 2 */
+    table->size = (size_t)1 << INIT_POWER;
+    tsize = table->size * sizeof(NAMED *);
+    table->v = table->mem->malloc_fcn(tsize);
+    if (! table->v) {
+      table->size = 0;
+      return NULL;
+    }
+    memset(table->v, 0, tsize);
+    i = hash(parser, name) & ((unsigned long)table->size - 1);
+  } else {
+    unsigned long h = hash(parser, name);
+    unsigned long mask = (unsigned long)table->size - 1;
+    unsigned char step = 0;
+    i = h & mask;
+    while (table->v[i]) {
+      if (keyeq(name, table->v[i]->name))
+        return table->v[i];
+      if (! step)
+        step = PROBE_STEP(h, mask, table->power);
+      i < step ? (i += table->size - step) : (i -= step);
+    }
+    if (! createSize)
+      return NULL;
+
+    /* check for overflow (table is half full) */
+    if (table->used >> (table->power - 1)) {
+      unsigned char newPower = table->power + 1;
+
+      /* Detect and prevent invalid shift */
+      if (newPower >= sizeof(unsigned long) * 8 /* bits per byte */) {
+        return NULL;
+      }
+
+      size_t newSize = (size_t)1 << newPower;
+      unsigned long newMask = (unsigned long)newSize - 1;
+
+      /* Detect and prevent integer overflow */
+      if (newSize > (size_t)(-1) / sizeof(NAMED *)) {
+        return NULL;
+      }
+
+      size_t tsize = newSize * sizeof(NAMED *);
+      NAMED **newV = table->mem->malloc_fcn(tsize);
+      if (! newV)
+        return NULL;
+      memset(newV, 0, tsize);
+      for (i = 0; i < table->size; i++)
+        if (table->v[i]) {
+          unsigned long newHash = hash(parser, table->v[i]->name);
+          size_t j = newHash & newMask;
+          step = 0;
+          while (newV[j]) {
+            if (! step)
+              step = PROBE_STEP(newHash, newMask, newPower);
+            j < step ? (j += newSize - step) : (j -= step);
+          }
+          newV[j] = table->v[i];
+        }
+      table->mem->free_fcn(table->v);
+      table->v = newV;
+      table->power = newPower;
+      table->size = newSize;
+      i = h & newMask;
+      step = 0;
+      while (table->v[i]) {
+        if (! step)
+          step = PROBE_STEP(h, newMask, newPower);
+        i < step ? (i += newSize - step) : (i -= step);
+      }
+    }
+  }
+  table->v[i] = table->mem->malloc_fcn(createSize);
+  if (! table->v[i])
+    return NULL;
+  memset(table->v[i], 0, createSize);
+  table->v[i]->name = name;
+  (table->used)++;
+  return table->v[i];
+}
+
+static void FASTCALL
+hashTableClear(HASH_TABLE *table) {
+  size_t i;
+  for (i = 0; i < table->size; i++) {
+    table->mem->free_fcn(table->v[i]);
+    table->v[i] = NULL;
+  }
+  table->used = 0;
+}
+
+static void FASTCALL
+hashTableDestroy(HASH_TABLE *table) {
+  size_t i;
+  for (i = 0; i < table->size; i++)
+    table->mem->free_fcn(table->v[i]);
+  table->mem->free_fcn(table->v);
+}
+
+static void FASTCALL
+hashTableInit(HASH_TABLE *p, const XML_Memory_Handling_Suite *ms) {
+  p->power = 0;
+  p->size = 0;
+  p->used = 0;
+  p->v = NULL;
+  p->mem = ms;
+}
+
+static void FASTCALL
+hashTableIterInit(HASH_TABLE_ITER *iter, const HASH_TABLE *table) {
+  iter->p = table->v;
+  iter->end = iter->p ? iter->p + table->size : NULL;
+}
+
+static NAMED *FASTCALL
+hashTableIterNext(HASH_TABLE_ITER *iter) {
+  while (iter->p != iter->end) {
+    NAMED *tem = *(iter->p)++;
+    if (tem)
+      return tem;
+  }
+  return NULL;
+}
+
+static void FASTCALL
+poolInit(STRING_POOL *pool, const XML_Memory_Handling_Suite *ms) {
+  pool->blocks = NULL;
+  pool->freeBlocks = NULL;
+  pool->start = NULL;
+  pool->ptr = NULL;
+  pool->end = NULL;
+  pool->mem = ms;
+}
+
+static void FASTCALL
+poolClear(STRING_POOL *pool) {
+  if (! pool->freeBlocks)
+    pool->freeBlocks = pool->blocks;
+  else {
+    BLOCK *p = pool->blocks;
+    while (p) {
+      BLOCK *tem = p->next;
+      p->next = pool->freeBlocks;
+      pool->freeBlocks = p;
+      p = tem;
+    }
+  }
+  pool->blocks = NULL;
+  pool->start = NULL;
+  pool->ptr = NULL;
+  pool->end = NULL;
+}
+
+static void FASTCALL
+poolDestroy(STRING_POOL *pool) {
+  BLOCK *p = pool->blocks;
+  while (p) {
+    BLOCK *tem = p->next;
+    pool->mem->free_fcn(p);
+    p = tem;
+  }
+  p = pool->freeBlocks;
+  while (p) {
+    BLOCK *tem = p->next;
+    pool->mem->free_fcn(p);
+    p = tem;
+  }
+}
+
+static XML_Char *
+poolAppend(STRING_POOL *pool, const ENCODING *enc, const char *ptr,
+           const char *end) {
+  if (! pool->ptr && ! poolGrow(pool))
+    return NULL;
+  for (;;) {
+    const enum XML_Convert_Result convert_res = XmlConvert(
+        enc, &ptr, end, (ICHAR **)&(pool->ptr), (const ICHAR *)pool->end);
+    if ((convert_res == XML_CONVERT_COMPLETED)
+        || (convert_res == XML_CONVERT_INPUT_INCOMPLETE))
+      break;
+    if (! poolGrow(pool))
+      return NULL;
+  }
+  return pool->start;
+}
+
+static const XML_Char *FASTCALL
+poolCopyString(STRING_POOL *pool, const XML_Char *s) {
+  do {
+    if (! poolAppendChar(pool, *s))
+      return NULL;
+  } while (*s++);
+  s = pool->start;
+  poolFinish(pool);
+  return s;
+}
+
+static const XML_Char *
+poolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n) {
+  if (! pool->ptr && ! poolGrow(pool)) {
+    /* The following line is unreachable given the current usage of
+     * poolCopyStringN().  Currently it is called from exactly one
+     * place to copy the text of a simple general entity.  By that
+     * point, the name of the entity is already stored in the pool, so
+     * pool->ptr cannot be NULL.
+     *
+     * If poolCopyStringN() is used elsewhere as it well might be,
+     * this line may well become executable again.  Regardless, this
+     * sort of check shouldn't be removed lightly, so we just exclude
+     * it from the coverage statistics.
+     */
+    return NULL; /* LCOV_EXCL_LINE */
+  }
+  for (; n > 0; --n, s++) {
+    if (! poolAppendChar(pool, *s))
+      return NULL;
+  }
+  s = pool->start;
+  poolFinish(pool);
+  return s;
+}
+
+static const XML_Char *FASTCALL
+poolAppendString(STRING_POOL *pool, const XML_Char *s) {
+  while (*s) {
+    if (! poolAppendChar(pool, *s))
+      return NULL;
+    s++;
+  }
+  return pool->start;
+}
+
+static XML_Char *
+poolStoreString(STRING_POOL *pool, const ENCODING *enc, const char *ptr,
+                const char *end) {
+  if (! poolAppend(pool, enc, ptr, end))
+    return NULL;
+  if (pool->ptr == pool->end && ! poolGrow(pool))
+    return NULL;
+  *(pool->ptr)++ = 0;
+  return pool->start;
+}
+
+static size_t
+poolBytesToAllocateFor(int blockSize) {
+  /* Unprotected math would be:
+  ** return offsetof(BLOCK, s) + blockSize * sizeof(XML_Char);
+  **
+  ** Detect overflow, avoiding _signed_ overflow undefined behavior
+  ** For a + b * c we check b * c in isolation first, so that addition of a
+  ** on top has no chance of making us accept a small non-negative number
+  */
+  const size_t stretch = sizeof(XML_Char); /* can be 4 bytes */
+
+  if (blockSize <= 0)
+    return 0;
+
+  if (blockSize > (int)(INT_MAX / stretch))
+    return 0;
+
+  {
+    const int stretchedBlockSize = blockSize * (int)stretch;
+    const int bytesToAllocate
+        = (int)(offsetof(BLOCK, s) + (unsigned)stretchedBlockSize);
+    if (bytesToAllocate < 0)
+      return 0;
+
+    return (size_t)bytesToAllocate;
+  }
+}
+
+static XML_Bool FASTCALL
+poolGrow(STRING_POOL *pool) {
+  if (pool->freeBlocks) {
+    if (pool->start == 0) {
+      pool->blocks = pool->freeBlocks;
+      pool->freeBlocks = pool->freeBlocks->next;
+      pool->blocks->next = NULL;
+      pool->start = pool->blocks->s;
+      pool->end = pool->start + pool->blocks->size;
+      pool->ptr = pool->start;
+      return XML_TRUE;
+    }
+    if (pool->end - pool->start < pool->freeBlocks->size) {
+      BLOCK *tem = pool->freeBlocks->next;
+      pool->freeBlocks->next = pool->blocks;
+      pool->blocks = pool->freeBlocks;
+      pool->freeBlocks = tem;
+      memcpy(pool->blocks->s, pool->start,
+             (pool->end - pool->start) * sizeof(XML_Char));
+      pool->ptr = pool->blocks->s + (pool->ptr - pool->start);
+      pool->start = pool->blocks->s;
+      pool->end = pool->start + pool->blocks->size;
+      return XML_TRUE;
+    }
+  }
+  if (pool->blocks && pool->start == pool->blocks->s) {
+    BLOCK *temp;
+    int blockSize = (int)((unsigned)(pool->end - pool->start) * 2U);
+    size_t bytesToAllocate;
+
+    /* NOTE: Needs to be calculated prior to calling `realloc`
+             to avoid dangling pointers: */
+    const ptrdiff_t offsetInsideBlock = pool->ptr - pool->start;
+
+    if (blockSize < 0) {
+      /* This condition traps a situation where either more than
+       * INT_MAX/2 bytes have already been allocated.  This isn't
+       * readily testable, since it is unlikely that an average
+       * machine will have that much memory, so we exclude it from the
+       * coverage statistics.
+       */
+      return XML_FALSE; /* LCOV_EXCL_LINE */
+    }
+
+    bytesToAllocate = poolBytesToAllocateFor(blockSize);
+    if (bytesToAllocate == 0)
+      return XML_FALSE;
+
+    temp = (BLOCK *)pool->mem->realloc_fcn(pool->blocks,
+                                           (unsigned)bytesToAllocate);
+    if (temp == NULL)
+      return XML_FALSE;
+    pool->blocks = temp;
+    pool->blocks->size = blockSize;
+    pool->ptr = pool->blocks->s + offsetInsideBlock;
+    pool->start = pool->blocks->s;
+    pool->end = pool->start + blockSize;
+  } else {
+    BLOCK *tem;
+    int blockSize = (int)(pool->end - pool->start);
+    size_t bytesToAllocate;
+
+    if (blockSize < 0) {
+      /* This condition traps a situation where either more than
+       * INT_MAX bytes have already been allocated (which is prevented
+       * by various pieces of program logic, not least this one, never
+       * mind the unlikelihood of actually having that much memory) or
+       * the pool control fields have been corrupted (which could
+       * conceivably happen in an extremely buggy user handler
+       * function).  Either way it isn't readily testable, so we
+       * exclude it from the coverage statistics.
+       */
+      return XML_FALSE; /* LCOV_EXCL_LINE */
+    }
+
+    if (blockSize < INIT_BLOCK_SIZE)
+      blockSize = INIT_BLOCK_SIZE;
+    else {
+      /* Detect overflow, avoiding _signed_ overflow undefined behavior */
+      if ((int)((unsigned)blockSize * 2U) < 0) {
+        return XML_FALSE;
+      }
+      blockSize *= 2;
+    }
+
+    bytesToAllocate = poolBytesToAllocateFor(blockSize);
+    if (bytesToAllocate == 0)
+      return XML_FALSE;
+
+    tem = pool->mem->malloc_fcn(bytesToAllocate);
+    if (! tem)
+      return XML_FALSE;
+    tem->size = blockSize;
+    tem->next = pool->blocks;
+    pool->blocks = tem;
+    if (pool->ptr != pool->start)
+      memcpy(tem->s, pool->start, (pool->ptr - pool->start) * sizeof(XML_Char));
+    pool->ptr = tem->s + (pool->ptr - pool->start);
+    pool->start = tem->s;
+    pool->end = tem->s + blockSize;
+  }
+  return XML_TRUE;
+}
+
+static int FASTCALL
+nextScaffoldPart(XML_Parser parser) {
+  DTD *const dtd = parser->m_dtd; /* save one level of indirection */
+  CONTENT_SCAFFOLD *me;
+  int next;
+
+  if (! dtd->scaffIndex) {
+    /* Detect and prevent integer overflow.
+     * The preprocessor guard addresses the "always false" warning
+     * from -Wtype-limits on platforms where
+     * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
+#if UINT_MAX >= SIZE_MAX
+    if (parser->m_groupSize > ((size_t)(-1) / sizeof(int))) {
+      return -1;
+    }
+#endif
+    dtd->scaffIndex = (int *)MALLOC(parser, parser->m_groupSize * sizeof(int));
+    if (! dtd->scaffIndex)
+      return -1;
+    dtd->scaffIndex[0] = 0;
+  }
+
+  if (dtd->scaffCount >= dtd->scaffSize) {
+    CONTENT_SCAFFOLD *temp;
+    if (dtd->scaffold) {
+      /* Detect and prevent integer overflow */
+      if (dtd->scaffSize > UINT_MAX / 2u) {
+        return -1;
+      }
+      /* Detect and prevent integer overflow.
+       * The preprocessor guard addresses the "always false" warning
+       * from -Wtype-limits on platforms where
+       * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
+#if UINT_MAX >= SIZE_MAX
+      if (dtd->scaffSize > (size_t)(-1) / 2u / sizeof(CONTENT_SCAFFOLD)) {
+        return -1;
+      }
+#endif
+
+      temp = (CONTENT_SCAFFOLD *)REALLOC(
+          parser, dtd->scaffold, dtd->scaffSize * 2 * sizeof(CONTENT_SCAFFOLD));
+      if (temp == NULL)
+        return -1;
+      dtd->scaffSize *= 2;
+    } else {
+      temp = (CONTENT_SCAFFOLD *)MALLOC(parser, INIT_SCAFFOLD_ELEMENTS
+                                                    * sizeof(CONTENT_SCAFFOLD));
+      if (temp == NULL)
+        return -1;
+      dtd->scaffSize = INIT_SCAFFOLD_ELEMENTS;
+    }
+    dtd->scaffold = temp;
+  }
+  next = dtd->scaffCount++;
+  me = &dtd->scaffold[next];
+  if (dtd->scaffLevel) {
+    CONTENT_SCAFFOLD *parent
+        = &dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]];
+    if (parent->lastchild) {
+      dtd->scaffold[parent->lastchild].nextsib = next;
+    }
+    if (! parent->childcnt)
+      parent->firstchild = next;
+    parent->lastchild = next;
+    parent->childcnt++;
+  }
+  me->firstchild = me->lastchild = me->childcnt = me->nextsib = 0;
+  return next;
+}
+
+static XML_Content *
+build_model(XML_Parser parser) {
+  /* Function build_model transforms the existing parser->m_dtd->scaffold
+   * array of CONTENT_SCAFFOLD tree nodes into a new array of
+   * XML_Content tree nodes followed by a gapless list of zero-terminated
+   * strings. */
+  DTD *const dtd = parser->m_dtd; /* save one level of indirection */
+  XML_Content *ret;
+  XML_Char *str; /* the current string writing location */
+
+  /* Detect and prevent integer overflow.
+   * The preprocessor guard addresses the "always false" warning
+   * from -Wtype-limits on platforms where
+   * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
+#if UINT_MAX >= SIZE_MAX
+  if (dtd->scaffCount > (size_t)(-1) / sizeof(XML_Content)) {
+    return NULL;
+  }
+  if (dtd->contentStringLen > (size_t)(-1) / sizeof(XML_Char)) {
+    return NULL;
+  }
+#endif
+  if (dtd->scaffCount * sizeof(XML_Content)
+      > (size_t)(-1) - dtd->contentStringLen * sizeof(XML_Char)) {
+    return NULL;
+  }
+
+  const size_t allocsize = (dtd->scaffCount * sizeof(XML_Content)
+                            + (dtd->contentStringLen * sizeof(XML_Char)));
+
+  ret = (XML_Content *)MALLOC(parser, allocsize);
+  if (! ret)
+    return NULL;
+
+  /* What follows is an iterative implementation (of what was previously done
+   * recursively in a dedicated function called "build_node".  The old recursive
+   * build_node could be forced into stack exhaustion from input as small as a
+   * few megabyte, and so that was a security issue.  Hence, a function call
+   * stack is avoided now by resolving recursion.)
+   *
+   * The iterative approach works as follows:
+   *
+   * - We have two writing pointers, both walking up the result array; one does
+   *   the work, the other creates "jobs" for its colleague to do, and leads
+   *   the way:
+   *
+   *   - The faster one, pointer jobDest, always leads and writes "what job
+   *     to do" by the other, once they reach that place in the
+   *     array: leader "jobDest" stores the source node array index (relative
+   *     to array dtd->scaffold) in field "numchildren".
+   *
+   *   - The slower one, pointer dest, looks at the value stored in the
+   *     "numchildren" field (which actually holds a source node array index
+   *     at that time) and puts the real data from dtd->scaffold in.
+   *
+   * - Before the loop starts, jobDest writes source array index 0
+   *   (where the root node is located) so that dest will have something to do
+   *   when it starts operation.
+   *
+   * - Whenever nodes with children are encountered, jobDest appends
+   *   them as new jobs, in order.  As a result, tree node siblings are
+   *   adjacent in the resulting array, for example:
+   *
+   *     [0] root, has two children
+   *       [1] first child of 0, has three children
+   *         [3] first child of 1, does not have children
+   *         [4] second child of 1, does not have children
+   *         [5] third child of 1, does not have children
+   *       [2] second child of 0, does not have children
+   *
+   *   Or (the same data) presented in flat array view:
+   *
+   *     [0] root, has two children
+   *
+   *     [1] first child of 0, has three children
+   *     [2] second child of 0, does not have children
+   *
+   *     [3] first child of 1, does not have children
+   *     [4] second child of 1, does not have children
+   *     [5] third child of 1, does not have children
+   *
+   * - The algorithm repeats until all target array indices have been processed.
+   */
+  XML_Content *dest = ret; /* tree node writing location, moves upwards */
+  XML_Content *const destLimit = &ret[dtd->scaffCount];
+  XML_Content *jobDest = ret; /* next free writing location in target array */
+  str = (XML_Char *)&ret[dtd->scaffCount];
+
+  /* Add the starting job, the root node (index 0) of the source tree  */
+  (jobDest++)->numchildren = 0;
+
+  for (; dest < destLimit; dest++) {
+    /* Retrieve source tree array index from job storage */
+    const int src_node = (int)dest->numchildren;
+
+    /* Convert item */
+    dest->type = dtd->scaffold[src_node].type;
+    dest->quant = dtd->scaffold[src_node].quant;
+    if (dest->type == XML_CTYPE_NAME) {
+      const XML_Char *src;
+      dest->name = str;
+      src = dtd->scaffold[src_node].name;
+      for (;;) {
+        *str++ = *src;
+        if (! *src)
+          break;
+        src++;
+      }
+      dest->numchildren = 0;
+      dest->children = NULL;
+    } else {
+      unsigned int i;
+      int cn;
+      dest->name = NULL;
+      dest->numchildren = dtd->scaffold[src_node].childcnt;
+      dest->children = jobDest;
+
+      /* Append scaffold indices of children to array */
+      for (i = 0, cn = dtd->scaffold[src_node].firstchild;
+           i < dest->numchildren; i++, cn = dtd->scaffold[cn].nextsib)
+        (jobDest++)->numchildren = (unsigned int)cn;
+    }
+  }
+
+  return ret;
+}
+
+static ELEMENT_TYPE *
+getElementType(XML_Parser parser, const ENCODING *enc, const char *ptr,
+               const char *end) {
+  DTD *const dtd = parser->m_dtd; /* save one level of indirection */
+  const XML_Char *name = poolStoreString(&dtd->pool, enc, ptr, end);
+  ELEMENT_TYPE *ret;
+
+  if (! name)
+    return NULL;
+  ret = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, name,
+                               sizeof(ELEMENT_TYPE));
+  if (! ret)
+    return NULL;
+  if (ret->name != name)
+    poolDiscard(&dtd->pool);
+  else {
+    poolFinish(&dtd->pool);
+    if (! setElementTypePrefix(parser, ret))
+      return NULL;
+  }
+  return ret;
+}
+
+static XML_Char *
+copyString(const XML_Char *s, const XML_Memory_Handling_Suite *memsuite) {
+  size_t charsRequired = 0;
+  XML_Char *result;
+
+  /* First determine how long the string is */
+  while (s[charsRequired] != 0) {
+    charsRequired++;
+  }
+  /* Include the terminator */
+  charsRequired++;
+
+  /* Now allocate space for the copy */
+  result = memsuite->malloc_fcn(charsRequired * sizeof(XML_Char));
+  if (result == NULL)
+    return NULL;
+  /* Copy the original into place */
+  memcpy(result, s, charsRequired * sizeof(XML_Char));
+  return result;
+}
+
+#if XML_GE == 1
+
+static float
+accountingGetCurrentAmplification(XML_Parser rootParser) {
+  //                                          1.........1.........12 => 22
+  const size_t lenOfShortestInclude = sizeof("<!ENTITY a SYSTEM 'b'>") - 1;
+  const XmlBigCount countBytesOutput
+      = rootParser->m_accounting.countBytesDirect
+        + rootParser->m_accounting.countBytesIndirect;
+  const float amplificationFactor
+      = rootParser->m_accounting.countBytesDirect
+            ? (countBytesOutput
+               / (float)(rootParser->m_accounting.countBytesDirect))
+            : ((lenOfShortestInclude
+                + rootParser->m_accounting.countBytesIndirect)
+               / (float)lenOfShortestInclude);
+  assert(! rootParser->m_parentParser);
+  return amplificationFactor;
+}
+
+static void
+accountingReportStats(XML_Parser originParser, const char *epilog) {
+  const XML_Parser rootParser = getRootParserOf(originParser, NULL);
+  assert(! rootParser->m_parentParser);
+
+  if (rootParser->m_accounting.debugLevel == 0u) {
+    return;
+  }
+
+  const float amplificationFactor
+      = accountingGetCurrentAmplification(rootParser);
+  fprintf(stderr,
+          "expat: Accounting(%p): Direct " EXPAT_FMT_ULL(
+              "10") ", indirect " EXPAT_FMT_ULL("10") ", amplification %8.2f%s",
+          (void *)rootParser, rootParser->m_accounting.countBytesDirect,
+          rootParser->m_accounting.countBytesIndirect,
+          (double)amplificationFactor, epilog);
+}
+
+static void
+accountingOnAbort(XML_Parser originParser) {
+  accountingReportStats(originParser, " ABORTING\n");
+}
+
+static void
+accountingReportDiff(XML_Parser rootParser,
+                     unsigned int levelsAwayFromRootParser, const char *before,
+                     const char *after, ptrdiff_t bytesMore, int source_line,
+                     enum XML_Account account) {
+  assert(! rootParser->m_parentParser);
+
+  fprintf(stderr,
+          " (+" EXPAT_FMT_PTRDIFF_T("6") " bytes %s|%d, xmlparse.c:%d) %*s\"",
+          bytesMore, (account == XML_ACCOUNT_DIRECT) ? "DIR" : "EXP",
+          levelsAwayFromRootParser, source_line, 10, "");
+
+  const char ellipis[] = "[..]";
+  const size_t ellipsisLength = sizeof(ellipis) /* because compile-time */ - 1;
+  const unsigned int contextLength = 10;
+
+  /* Note: Performance is of no concern here */
+  const char *walker = before;
+  if ((rootParser->m_accounting.debugLevel >= 3u)
+      || (after - before)
+             <= (ptrdiff_t)(contextLength + ellipsisLength + contextLength)) {
+    for (; walker < after; walker++) {
+      fprintf(stderr, "%s", unsignedCharToPrintable(walker[0]));
+    }
+  } else {
+    for (; walker < before + contextLength; walker++) {
+      fprintf(stderr, "%s", unsignedCharToPrintable(walker[0]));
+    }
+    fprintf(stderr, ellipis);
+    walker = after - contextLength;
+    for (; walker < after; walker++) {
+      fprintf(stderr, "%s", unsignedCharToPrintable(walker[0]));
+    }
+  }
+  fprintf(stderr, "\"\n");
+}
+
+static XML_Bool
+accountingDiffTolerated(XML_Parser originParser, int tok, const char *before,
+                        const char *after, int source_line,
+                        enum XML_Account account) {
+  /* Note: We need to check the token type *first* to be sure that
+   *       we can even access variable <after>, safely.
+   *       E.g. for XML_TOK_NONE <after> may hold an invalid pointer. */
+  switch (tok) {
+  case XML_TOK_INVALID:
+  case XML_TOK_PARTIAL:
+  case XML_TOK_PARTIAL_CHAR:
+  case XML_TOK_NONE:
+    return XML_TRUE;
+  }
+
+  if (account == XML_ACCOUNT_NONE)
+    return XML_TRUE; /* because these bytes have been accounted for, already */
+
+  unsigned int levelsAwayFromRootParser;
+  const XML_Parser rootParser
+      = getRootParserOf(originParser, &levelsAwayFromRootParser);
+  assert(! rootParser->m_parentParser);
+
+  const int isDirect
+      = (account == XML_ACCOUNT_DIRECT) && (originParser == rootParser);
+  const ptrdiff_t bytesMore = after - before;
+
+  XmlBigCount *const additionTarget
+      = isDirect ? &rootParser->m_accounting.countBytesDirect
+                 : &rootParser->m_accounting.countBytesIndirect;
+
+  /* Detect and avoid integer overflow */
+  if (*additionTarget > (XmlBigCount)(-1) - (XmlBigCount)bytesMore)
+    return XML_FALSE;
+  *additionTarget += bytesMore;
+
+  const XmlBigCount countBytesOutput
+      = rootParser->m_accounting.countBytesDirect
+        + rootParser->m_accounting.countBytesIndirect;
+  const float amplificationFactor
+      = accountingGetCurrentAmplification(rootParser);
+  const XML_Bool tolerated
+      = (countBytesOutput < rootParser->m_accounting.activationThresholdBytes)
+        || (amplificationFactor
+            <= rootParser->m_accounting.maximumAmplificationFactor);
+
+  if (rootParser->m_accounting.debugLevel >= 2u) {
+    accountingReportStats(rootParser, "");
+    accountingReportDiff(rootParser, levelsAwayFromRootParser, before, after,
+                         bytesMore, source_line, account);
+  }
+
+  return tolerated;
+}
+
+unsigned long long
+testingAccountingGetCountBytesDirect(XML_Parser parser) {
+  if (! parser)
+    return 0;
+  return parser->m_accounting.countBytesDirect;
+}
+
+unsigned long long
+testingAccountingGetCountBytesIndirect(XML_Parser parser) {
+  if (! parser)
+    return 0;
+  return parser->m_accounting.countBytesIndirect;
+}
+
+static void
+entityTrackingReportStats(XML_Parser rootParser, ENTITY *entity,
+                          const char *action, int sourceLine) {
+  assert(! rootParser->m_parentParser);
+  if (rootParser->m_entity_stats.debugLevel == 0u)
+    return;
+
+#  if defined(XML_UNICODE)
+  const char *const entityName = "[..]";
+#  else
+  const char *const entityName = entity->name;
+#  endif
+
+  fprintf(
+      stderr,
+      "expat: Entities(%p): Count %9d, depth %2d/%2d %*s%s%s; %s length %d (xmlparse.c:%d)\n",
+      (void *)rootParser, rootParser->m_entity_stats.countEverOpened,
+      rootParser->m_entity_stats.currentDepth,
+      rootParser->m_entity_stats.maximumDepthSeen,
+      (rootParser->m_entity_stats.currentDepth - 1) * 2, "",
+      entity->is_param ? "%" : "&", entityName, action, entity->textLen,
+      sourceLine);
+}
+
+static void
+entityTrackingOnOpen(XML_Parser originParser, ENTITY *entity, int sourceLine) {
+  const XML_Parser rootParser = getRootParserOf(originParser, NULL);
+  assert(! rootParser->m_parentParser);
+
+  rootParser->m_entity_stats.countEverOpened++;
+  rootParser->m_entity_stats.currentDepth++;
+  if (rootParser->m_entity_stats.currentDepth
+      > rootParser->m_entity_stats.maximumDepthSeen) {
+    rootParser->m_entity_stats.maximumDepthSeen++;
+  }
+
+  entityTrackingReportStats(rootParser, entity, "OPEN ", sourceLine);
+}
+
+static void
+entityTrackingOnClose(XML_Parser originParser, ENTITY *entity, int sourceLine) {
+  const XML_Parser rootParser = getRootParserOf(originParser, NULL);
+  assert(! rootParser->m_parentParser);
+
+  entityTrackingReportStats(rootParser, entity, "CLOSE", sourceLine);
+  rootParser->m_entity_stats.currentDepth--;
+}
+
+static XML_Parser
+getRootParserOf(XML_Parser parser, unsigned int *outLevelDiff) {
+  XML_Parser rootParser = parser;
+  unsigned int stepsTakenUpwards = 0;
+  while (rootParser->m_parentParser) {
+    rootParser = rootParser->m_parentParser;
+    stepsTakenUpwards++;
+  }
+  assert(! rootParser->m_parentParser);
+  if (outLevelDiff != NULL) {
+    *outLevelDiff = stepsTakenUpwards;
+  }
+  return rootParser;
+}
+
+const char *
+unsignedCharToPrintable(unsigned char c) {
+  switch (c) {
+  case 0:
+    return "\\0";
+  case 1:
+    return "\\x1";
+  case 2:
+    return "\\x2";
+  case 3:
+    return "\\x3";
+  case 4:
+    return "\\x4";
+  case 5:
+    return "\\x5";
+  case 6:
+    return "\\x6";
+  case 7:
+    return "\\x7";
+  case 8:
+    return "\\x8";
+  case 9:
+    return "\\t";
+  case 10:
+    return "\\n";
+  case 11:
+    return "\\xB";
+  case 12:
+    return "\\xC";
+  case 13:
+    return "\\r";
+  case 14:
+    return "\\xE";
+  case 15:
+    return "\\xF";
+  case 16:
+    return "\\x10";
+  case 17:
+    return "\\x11";
+  case 18:
+    return "\\x12";
+  case 19:
+    return "\\x13";
+  case 20:
+    return "\\x14";
+  case 21:
+    return "\\x15";
+  case 22:
+    return "\\x16";
+  case 23:
+    return "\\x17";
+  case 24:
+    return "\\x18";
+  case 25:
+    return "\\x19";
+  case 26:
+    return "\\x1A";
+  case 27:
+    return "\\x1B";
+  case 28:
+    return "\\x1C";
+  case 29:
+    return "\\x1D";
+  case 30:
+    return "\\x1E";
+  case 31:
+    return "\\x1F";
+  case 32:
+    return " ";
+  case 33:
+    return "!";
+  case 34:
+    return "\\\"";
+  case 35:
+    return "#";
+  case 36:
+    return "$";
+  case 37:
+    return "%";
+  case 38:
+    return "&";
+  case 39:
+    return "'";
+  case 40:
+    return "(";
+  case 41:
+    return ")";
+  case 42:
+    return "*";
+  case 43:
+    return "+";
+  case 44:
+    return ",";
+  case 45:
+    return "-";
+  case 46:
+    return ".";
+  case 47:
+    return "/";
+  case 48:
+    return "0";
+  case 49:
+    return "1";
+  case 50:
+    return "2";
+  case 51:
+    return "3";
+  case 52:
+    return "4";
+  case 53:
+    return "5";
+  case 54:
+    return "6";
+  case 55:
+    return "7";
+  case 56:
+    return "8";
+  case 57:
+    return "9";
+  case 58:
+    return ":";
+  case 59:
+    return ";";
+  case 60:
+    return "<";
+  case 61:
+    return "=";
+  case 62:
+    return ">";
+  case 63:
+    return "?";
+  case 64:
+    return "@";
+  case 65:
+    return "A";
+  case 66:
+    return "B";
+  case 67:
+    return "C";
+  case 68:
+    return "D";
+  case 69:
+    return "E";
+  case 70:
+    return "F";
+  case 71:
+    return "G";
+  case 72:
+    return "H";
+  case 73:
+    return "I";
+  case 74:
+    return "J";
+  case 75:
+    return "K";
+  case 76:
+    return "L";
+  case 77:
+    return "M";
+  case 78:
+    return "N";
+  case 79:
+    return "O";
+  case 80:
+    return "P";
+  case 81:
+    return "Q";
+  case 82:
+    return "R";
+  case 83:
+    return "S";
+  case 84:
+    return "T";
+  case 85:
+    return "U";
+  case 86:
+    return "V";
+  case 87:
+    return "W";
+  case 88:
+    return "X";
+  case 89:
+    return "Y";
+  case 90:
+    return "Z";
+  case 91:
+    return "[";
+  case 92:
+    return "\\\\";
+  case 93:
+    return "]";
+  case 94:
+    return "^";
+  case 95:
+    return "_";
+  case 96:
+    return "`";
+  case 97:
+    return "a";
+  case 98:
+    return "b";
+  case 99:
+    return "c";
+  case 100:
+    return "d";
+  case 101:
+    return "e";
+  case 102:
+    return "f";
+  case 103:
+    return "g";
+  case 104:
+    return "h";
+  case 105:
+    return "i";
+  case 106:
+    return "j";
+  case 107:
+    return "k";
+  case 108:
+    return "l";
+  case 109:
+    return "m";
+  case 110:
+    return "n";
+  case 111:
+    return "o";
+  case 112:
+    return "p";
+  case 113:
+    return "q";
+  case 114:
+    return "r";
+  case 115:
+    return "s";
+  case 116:
+    return "t";
+  case 117:
+    return "u";
+  case 118:
+    return "v";
+  case 119:
+    return "w";
+  case 120:
+    return "x";
+  case 121:
+    return "y";
+  case 122:
+    return "z";
+  case 123:
+    return "{";
+  case 124:
+    return "|";
+  case 125:
+    return "}";
+  case 126:
+    return "~";
+  case 127:
+    return "\\x7F";
+  case 128:
+    return "\\x80";
+  case 129:
+    return "\\x81";
+  case 130:
+    return "\\x82";
+  case 131:
+    return "\\x83";
+  case 132:
+    return "\\x84";
+  case 133:
+    return "\\x85";
+  case 134:
+    return "\\x86";
+  case 135:
+    return "\\x87";
+  case 136:
+    return "\\x88";
+  case 137:
+    return "\\x89";
+  case 138:
+    return "\\x8A";
+  case 139:
+    return "\\x8B";
+  case 140:
+    return "\\x8C";
+  case 141:
+    return "\\x8D";
+  case 142:
+    return "\\x8E";
+  case 143:
+    return "\\x8F";
+  case 144:
+    return "\\x90";
+  case 145:
+    return "\\x91";
+  case 146:
+    return "\\x92";
+  case 147:
+    return "\\x93";
+  case 148:
+    return "\\x94";
+  case 149:
+    return "\\x95";
+  case 150:
+    return "\\x96";
+  case 151:
+    return "\\x97";
+  case 152:
+    return "\\x98";
+  case 153:
+    return "\\x99";
+  case 154:
+    return "\\x9A";
+  case 155:
+    return "\\x9B";
+  case 156:
+    return "\\x9C";
+  case 157:
+    return "\\x9D";
+  case 158:
+    return "\\x9E";
+  case 159:
+    return "\\x9F";
+  case 160:
+    return "\\xA0";
+  case 161:
+    return "\\xA1";
+  case 162:
+    return "\\xA2";
+  case 163:
+    return "\\xA3";
+  case 164:
+    return "\\xA4";
+  case 165:
+    return "\\xA5";
+  case 166:
+    return "\\xA6";
+  case 167:
+    return "\\xA7";
+  case 168:
+    return "\\xA8";
+  case 169:
+    return "\\xA9";
+  case 170:
+    return "\\xAA";
+  case 171:
+    return "\\xAB";
+  case 172:
+    return "\\xAC";
+  case 173:
+    return "\\xAD";
+  case 174:
+    return "\\xAE";
+  case 175:
+    return "\\xAF";
+  case 176:
+    return "\\xB0";
+  case 177:
+    return "\\xB1";
+  case 178:
+    return "\\xB2";
+  case 179:
+    return "\\xB3";
+  case 180:
+    return "\\xB4";
+  case 181:
+    return "\\xB5";
+  case 182:
+    return "\\xB6";
+  case 183:
+    return "\\xB7";
+  case 184:
+    return "\\xB8";
+  case 185:
+    return "\\xB9";
+  case 186:
+    return "\\xBA";
+  case 187:
+    return "\\xBB";
+  case 188:
+    return "\\xBC";
+  case 189:
+    return "\\xBD";
+  case 190:
+    return "\\xBE";
+  case 191:
+    return "\\xBF";
+  case 192:
+    return "\\xC0";
+  case 193:
+    return "\\xC1";
+  case 194:
+    return "\\xC2";
+  case 195:
+    return "\\xC3";
+  case 196:
+    return "\\xC4";
+  case 197:
+    return "\\xC5";
+  case 198:
+    return "\\xC6";
+  case 199:
+    return "\\xC7";
+  case 200:
+    return "\\xC8";
+  case 201:
+    return "\\xC9";
+  case 202:
+    return "\\xCA";
+  case 203:
+    return "\\xCB";
+  case 204:
+    return "\\xCC";
+  case 205:
+    return "\\xCD";
+  case 206:
+    return "\\xCE";
+  case 207:
+    return "\\xCF";
+  case 208:
+    return "\\xD0";
+  case 209:
+    return "\\xD1";
+  case 210:
+    return "\\xD2";
+  case 211:
+    return "\\xD3";
+  case 212:
+    return "\\xD4";
+  case 213:
+    return "\\xD5";
+  case 214:
+    return "\\xD6";
+  case 215:
+    return "\\xD7";
+  case 216:
+    return "\\xD8";
+  case 217:
+    return "\\xD9";
+  case 218:
+    return "\\xDA";
+  case 219:
+    return "\\xDB";
+  case 220:
+    return "\\xDC";
+  case 221:
+    return "\\xDD";
+  case 222:
+    return "\\xDE";
+  case 223:
+    return "\\xDF";
+  case 224:
+    return "\\xE0";
+  case 225:
+    return "\\xE1";
+  case 226:
+    return "\\xE2";
+  case 227:
+    return "\\xE3";
+  case 228:
+    return "\\xE4";
+  case 229:
+    return "\\xE5";
+  case 230:
+    return "\\xE6";
+  case 231:
+    return "\\xE7";
+  case 232:
+    return "\\xE8";
+  case 233:
+    return "\\xE9";
+  case 234:
+    return "\\xEA";
+  case 235:
+    return "\\xEB";
+  case 236:
+    return "\\xEC";
+  case 237:
+    return "\\xED";
+  case 238:
+    return "\\xEE";
+  case 239:
+    return "\\xEF";
+  case 240:
+    return "\\xF0";
+  case 241:
+    return "\\xF1";
+  case 242:
+    return "\\xF2";
+  case 243:
+    return "\\xF3";
+  case 244:
+    return "\\xF4";
+  case 245:
+    return "\\xF5";
+  case 246:
+    return "\\xF6";
+  case 247:
+    return "\\xF7";
+  case 248:
+    return "\\xF8";
+  case 249:
+    return "\\xF9";
+  case 250:
+    return "\\xFA";
+  case 251:
+    return "\\xFB";
+  case 252:
+    return "\\xFC";
+  case 253:
+    return "\\xFD";
+  case 254:
+    return "\\xFE";
+  case 255:
+    return "\\xFF";
+  default:
+    assert(0); /* never gets here */
+    return "dead code";
+  }
+  assert(0); /* never gets here */
+}
+
+#endif /* XML_GE == 1 */
+
+static unsigned long
+getDebugLevel(const char *variableName, unsigned long defaultDebugLevel) {
+  const char *const valueOrNull = getenv(variableName);
+  if (valueOrNull == NULL) {
+    return defaultDebugLevel;
+  }
+  const char *const value = valueOrNull;
+
+  errno = 0;
+  char *afterValue = NULL;
+  unsigned long debugLevel = strtoul(value, &afterValue, 10);
+  if ((errno != 0) || (afterValue == value) || (afterValue[0] != '\0')) {
+    errno = 0;
+    return defaultDebugLevel;
+  }
+
+  return debugLevel;
+}
+
+#endif /* LV_USE_XML */
+
diff --git a/src/libs/expat/xmlrole.c b/src/libs/expat/xmlrole.c
new file mode 100644
index 000000000..5424f693a
--- /dev/null
+++ b/src/libs/expat/xmlrole.c
@@ -0,0 +1,1261 @@
+/*
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2002      Greg Stein <gstein@users.sourceforge.net>
+   Copyright (c) 2002-2006 Karl Waclawek <karl@waclawek.net>
+   Copyright (c) 2002-2003 Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
+   Copyright (c) 2005-2009 Steven Solie <steven@solie.ca>
+   Copyright (c) 2016-2023 Sebastian Pipping <sebastian@pipping.org>
+   Copyright (c) 2017      Rhodri James <rhodri@wildebeest.org.uk>
+   Copyright (c) 2019      David Loffredo <loffredo@steptools.com>
+   Copyright (c) 2021      Donghee Na <donghee.na@python.org>
+   Licensed under the MIT license:
+
+   Permission is  hereby granted,  free of charge,  to any  person obtaining
+   a  copy  of  this  software   and  associated  documentation  files  (the
+   "Software"),  to  deal in  the  Software  without restriction,  including
+   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
+   distribute, sublicense, and/or sell copies of the Software, and to permit
+   persons  to whom  the Software  is  furnished to  do so,  subject to  the
+   following conditions:
+
+   The above copyright  notice and this permission notice  shall be included
+   in all copies or substantial portions of the Software.
+
+   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
+   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
+   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+   USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include "../../lv_conf_internal.h"
+#if LV_USE_XML
+
+#include "expat_config.h"
+
+#include <stddef.h>
+
+#ifdef _WIN32
+#  include "winconfig.h"
+#endif
+
+#include "expat_external.h"
+#include "internal.h"
+#include "xmlrole.h"
+#include "ascii.h"
+
+/* Doesn't check:
+
+ that ,| are not mixed in a model group
+ content of literals
+
+*/
+
+static const char KW_ANY[] = {ASCII_A, ASCII_N, ASCII_Y, '\0'};
+static const char KW_ATTLIST[]
+    = {ASCII_A, ASCII_T, ASCII_T, ASCII_L, ASCII_I, ASCII_S, ASCII_T, '\0'};
+static const char KW_CDATA[]
+    = {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0'};
+static const char KW_DOCTYPE[]
+    = {ASCII_D, ASCII_O, ASCII_C, ASCII_T, ASCII_Y, ASCII_P, ASCII_E, '\0'};
+static const char KW_ELEMENT[]
+    = {ASCII_E, ASCII_L, ASCII_E, ASCII_M, ASCII_E, ASCII_N, ASCII_T, '\0'};
+static const char KW_EMPTY[]
+    = {ASCII_E, ASCII_M, ASCII_P, ASCII_T, ASCII_Y, '\0'};
+static const char KW_ENTITIES[] = {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T,
+                                   ASCII_I, ASCII_E, ASCII_S, '\0'};
+static const char KW_ENTITY[]
+    = {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\0'};
+static const char KW_FIXED[]
+    = {ASCII_F, ASCII_I, ASCII_X, ASCII_E, ASCII_D, '\0'};
+static const char KW_ID[] = {ASCII_I, ASCII_D, '\0'};
+static const char KW_IDREF[]
+    = {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\0'};
+static const char KW_IDREFS[]
+    = {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0'};
+#ifdef XML_DTD
+static const char KW_IGNORE[]
+    = {ASCII_I, ASCII_G, ASCII_N, ASCII_O, ASCII_R, ASCII_E, '\0'};
+#endif
+static const char KW_IMPLIED[]
+    = {ASCII_I, ASCII_M, ASCII_P, ASCII_L, ASCII_I, ASCII_E, ASCII_D, '\0'};
+#ifdef XML_DTD
+static const char KW_INCLUDE[]
+    = {ASCII_I, ASCII_N, ASCII_C, ASCII_L, ASCII_U, ASCII_D, ASCII_E, '\0'};
+#endif
+static const char KW_NDATA[]
+    = {ASCII_N, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0'};
+static const char KW_NMTOKEN[]
+    = {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0'};
+static const char KW_NMTOKENS[] = {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K,
+                                   ASCII_E, ASCII_N, ASCII_S, '\0'};
+static const char KW_NOTATION[] = {ASCII_N, ASCII_O, ASCII_T, ASCII_A, ASCII_T,
+                                   ASCII_I, ASCII_O, ASCII_N, '\0'};
+static const char KW_PCDATA[]
+    = {ASCII_P, ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0'};
+static const char KW_PUBLIC[]
+    = {ASCII_P, ASCII_U, ASCII_B, ASCII_L, ASCII_I, ASCII_C, '\0'};
+static const char KW_REQUIRED[] = {ASCII_R, ASCII_E, ASCII_Q, ASCII_U, ASCII_I,
+                                   ASCII_R, ASCII_E, ASCII_D, '\0'};
+static const char KW_SYSTEM[]
+    = {ASCII_S, ASCII_Y, ASCII_S, ASCII_T, ASCII_E, ASCII_M, '\0'};
+
+#ifndef MIN_BYTES_PER_CHAR
+#  define MIN_BYTES_PER_CHAR(enc) ((enc)->minBytesPerChar)
+#endif
+
+#ifdef XML_DTD
+#  define setTopLevel(state)                                                   \
+    ((state)->handler                                                          \
+     = ((state)->documentEntity ? internalSubset : externalSubset1))
+#else /* not XML_DTD */
+#  define setTopLevel(state) ((state)->handler = internalSubset)
+#endif /* not XML_DTD */
+
+typedef int PTRCALL PROLOG_HANDLER(PROLOG_STATE *state, int tok,
+                                   const char *ptr, const char *end,
+                                   const ENCODING *enc);
+
+static PROLOG_HANDLER prolog0, prolog1, prolog2, doctype0, doctype1, doctype2,
+    doctype3, doctype4, doctype5, internalSubset, entity0, entity1, entity2,
+    entity3, entity4, entity5, entity6, entity7, entity8, entity9, entity10,
+    notation0, notation1, notation2, notation3, notation4, attlist0, attlist1,
+    attlist2, attlist3, attlist4, attlist5, attlist6, attlist7, attlist8,
+    attlist9, element0, element1, element2, element3, element4, element5,
+    element6, element7,
+#ifdef XML_DTD
+    externalSubset0, externalSubset1, condSect0, condSect1, condSect2,
+#endif /* XML_DTD */
+    declClose, error;
+
+static int FASTCALL common(PROLOG_STATE *state, int tok);
+
+static int PTRCALL
+prolog0(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    state->handler = prolog1;
+    return XML_ROLE_NONE;
+  case XML_TOK_XML_DECL:
+    state->handler = prolog1;
+    return XML_ROLE_XML_DECL;
+  case XML_TOK_PI:
+    state->handler = prolog1;
+    return XML_ROLE_PI;
+  case XML_TOK_COMMENT:
+    state->handler = prolog1;
+    return XML_ROLE_COMMENT;
+  case XML_TOK_BOM:
+    return XML_ROLE_NONE;
+  case XML_TOK_DECL_OPEN:
+    if (! XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end,
+                              KW_DOCTYPE))
+      break;
+    state->handler = doctype0;
+    return XML_ROLE_DOCTYPE_NONE;
+  case XML_TOK_INSTANCE_START:
+    state->handler = error;
+    return XML_ROLE_INSTANCE_START;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+prolog1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_PI:
+    return XML_ROLE_PI;
+  case XML_TOK_COMMENT:
+    return XML_ROLE_COMMENT;
+  case XML_TOK_BOM:
+    /* This case can never arise.  To reach this role function, the
+     * parse must have passed through prolog0 and therefore have had
+     * some form of input, even if only a space.  At that point, a
+     * byte order mark is no longer a valid character (though
+     * technically it should be interpreted as a non-breaking space),
+     * so will be rejected by the tokenizing stages.
+     */
+    return XML_ROLE_NONE; /* LCOV_EXCL_LINE */
+  case XML_TOK_DECL_OPEN:
+    if (! XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end,
+                              KW_DOCTYPE))
+      break;
+    state->handler = doctype0;
+    return XML_ROLE_DOCTYPE_NONE;
+  case XML_TOK_INSTANCE_START:
+    state->handler = error;
+    return XML_ROLE_INSTANCE_START;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+prolog2(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_PI:
+    return XML_ROLE_PI;
+  case XML_TOK_COMMENT:
+    return XML_ROLE_COMMENT;
+  case XML_TOK_INSTANCE_START:
+    state->handler = error;
+    return XML_ROLE_INSTANCE_START;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+doctype0(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_DOCTYPE_NONE;
+  case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
+    state->handler = doctype1;
+    return XML_ROLE_DOCTYPE_NAME;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+doctype1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_DOCTYPE_NONE;
+  case XML_TOK_OPEN_BRACKET:
+    state->handler = internalSubset;
+    return XML_ROLE_DOCTYPE_INTERNAL_SUBSET;
+  case XML_TOK_DECL_CLOSE:
+    state->handler = prolog2;
+    return XML_ROLE_DOCTYPE_CLOSE;
+  case XML_TOK_NAME:
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
+      state->handler = doctype3;
+      return XML_ROLE_DOCTYPE_NONE;
+    }
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
+      state->handler = doctype2;
+      return XML_ROLE_DOCTYPE_NONE;
+    }
+    break;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+doctype2(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_DOCTYPE_NONE;
+  case XML_TOK_LITERAL:
+    state->handler = doctype3;
+    return XML_ROLE_DOCTYPE_PUBLIC_ID;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+doctype3(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_DOCTYPE_NONE;
+  case XML_TOK_LITERAL:
+    state->handler = doctype4;
+    return XML_ROLE_DOCTYPE_SYSTEM_ID;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+doctype4(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_DOCTYPE_NONE;
+  case XML_TOK_OPEN_BRACKET:
+    state->handler = internalSubset;
+    return XML_ROLE_DOCTYPE_INTERNAL_SUBSET;
+  case XML_TOK_DECL_CLOSE:
+    state->handler = prolog2;
+    return XML_ROLE_DOCTYPE_CLOSE;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+doctype5(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_DOCTYPE_NONE;
+  case XML_TOK_DECL_CLOSE:
+    state->handler = prolog2;
+    return XML_ROLE_DOCTYPE_CLOSE;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+internalSubset(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+               const ENCODING *enc) {
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_DECL_OPEN:
+    if (XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end,
+                            KW_ENTITY)) {
+      state->handler = entity0;
+      return XML_ROLE_ENTITY_NONE;
+    }
+    if (XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end,
+                            KW_ATTLIST)) {
+      state->handler = attlist0;
+      return XML_ROLE_ATTLIST_NONE;
+    }
+    if (XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end,
+                            KW_ELEMENT)) {
+      state->handler = element0;
+      return XML_ROLE_ELEMENT_NONE;
+    }
+    if (XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end,
+                            KW_NOTATION)) {
+      state->handler = notation0;
+      return XML_ROLE_NOTATION_NONE;
+    }
+    break;
+  case XML_TOK_PI:
+    return XML_ROLE_PI;
+  case XML_TOK_COMMENT:
+    return XML_ROLE_COMMENT;
+  case XML_TOK_PARAM_ENTITY_REF:
+    return XML_ROLE_PARAM_ENTITY_REF;
+  case XML_TOK_CLOSE_BRACKET:
+    state->handler = doctype5;
+    return XML_ROLE_DOCTYPE_NONE;
+  case XML_TOK_NONE:
+    return XML_ROLE_NONE;
+  }
+  return common(state, tok);
+}
+
+#ifdef XML_DTD
+
+static int PTRCALL
+externalSubset0(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+                const ENCODING *enc) {
+  state->handler = externalSubset1;
+  if (tok == XML_TOK_XML_DECL)
+    return XML_ROLE_TEXT_DECL;
+  return externalSubset1(state, tok, ptr, end, enc);
+}
+
+static int PTRCALL
+externalSubset1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+                const ENCODING *enc) {
+  switch (tok) {
+  case XML_TOK_COND_SECT_OPEN:
+    state->handler = condSect0;
+    return XML_ROLE_NONE;
+  case XML_TOK_COND_SECT_CLOSE:
+    if (state->includeLevel == 0)
+      break;
+    state->includeLevel -= 1;
+    return XML_ROLE_NONE;
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_CLOSE_BRACKET:
+    break;
+  case XML_TOK_NONE:
+    if (state->includeLevel)
+      break;
+    return XML_ROLE_NONE;
+  default:
+    return internalSubset(state, tok, ptr, end, enc);
+  }
+  return common(state, tok);
+}
+
+#endif /* XML_DTD */
+
+static int PTRCALL
+entity0(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ENTITY_NONE;
+  case XML_TOK_PERCENT:
+    state->handler = entity1;
+    return XML_ROLE_ENTITY_NONE;
+  case XML_TOK_NAME:
+    state->handler = entity2;
+    return XML_ROLE_GENERAL_ENTITY_NAME;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+entity1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ENTITY_NONE;
+  case XML_TOK_NAME:
+    state->handler = entity7;
+    return XML_ROLE_PARAM_ENTITY_NAME;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+entity2(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ENTITY_NONE;
+  case XML_TOK_NAME:
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
+      state->handler = entity4;
+      return XML_ROLE_ENTITY_NONE;
+    }
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
+      state->handler = entity3;
+      return XML_ROLE_ENTITY_NONE;
+    }
+    break;
+  case XML_TOK_LITERAL:
+    state->handler = declClose;
+    state->role_none = XML_ROLE_ENTITY_NONE;
+    return XML_ROLE_ENTITY_VALUE;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+entity3(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ENTITY_NONE;
+  case XML_TOK_LITERAL:
+    state->handler = entity4;
+    return XML_ROLE_ENTITY_PUBLIC_ID;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+entity4(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ENTITY_NONE;
+  case XML_TOK_LITERAL:
+    state->handler = entity5;
+    return XML_ROLE_ENTITY_SYSTEM_ID;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+entity5(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ENTITY_NONE;
+  case XML_TOK_DECL_CLOSE:
+    setTopLevel(state);
+    return XML_ROLE_ENTITY_COMPLETE;
+  case XML_TOK_NAME:
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_NDATA)) {
+      state->handler = entity6;
+      return XML_ROLE_ENTITY_NONE;
+    }
+    break;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+entity6(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ENTITY_NONE;
+  case XML_TOK_NAME:
+    state->handler = declClose;
+    state->role_none = XML_ROLE_ENTITY_NONE;
+    return XML_ROLE_ENTITY_NOTATION_NAME;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+entity7(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ENTITY_NONE;
+  case XML_TOK_NAME:
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
+      state->handler = entity9;
+      return XML_ROLE_ENTITY_NONE;
+    }
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
+      state->handler = entity8;
+      return XML_ROLE_ENTITY_NONE;
+    }
+    break;
+  case XML_TOK_LITERAL:
+    state->handler = declClose;
+    state->role_none = XML_ROLE_ENTITY_NONE;
+    return XML_ROLE_ENTITY_VALUE;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+entity8(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ENTITY_NONE;
+  case XML_TOK_LITERAL:
+    state->handler = entity9;
+    return XML_ROLE_ENTITY_PUBLIC_ID;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+entity9(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ENTITY_NONE;
+  case XML_TOK_LITERAL:
+    state->handler = entity10;
+    return XML_ROLE_ENTITY_SYSTEM_ID;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+entity10(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ENTITY_NONE;
+  case XML_TOK_DECL_CLOSE:
+    setTopLevel(state);
+    return XML_ROLE_ENTITY_COMPLETE;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+notation0(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+          const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NOTATION_NONE;
+  case XML_TOK_NAME:
+    state->handler = notation1;
+    return XML_ROLE_NOTATION_NAME;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+notation1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+          const ENCODING *enc) {
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NOTATION_NONE;
+  case XML_TOK_NAME:
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
+      state->handler = notation3;
+      return XML_ROLE_NOTATION_NONE;
+    }
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
+      state->handler = notation2;
+      return XML_ROLE_NOTATION_NONE;
+    }
+    break;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+notation2(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+          const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NOTATION_NONE;
+  case XML_TOK_LITERAL:
+    state->handler = notation4;
+    return XML_ROLE_NOTATION_PUBLIC_ID;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+notation3(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+          const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NOTATION_NONE;
+  case XML_TOK_LITERAL:
+    state->handler = declClose;
+    state->role_none = XML_ROLE_NOTATION_NONE;
+    return XML_ROLE_NOTATION_SYSTEM_ID;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+notation4(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+          const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NOTATION_NONE;
+  case XML_TOK_LITERAL:
+    state->handler = declClose;
+    state->role_none = XML_ROLE_NOTATION_NONE;
+    return XML_ROLE_NOTATION_SYSTEM_ID;
+  case XML_TOK_DECL_CLOSE:
+    setTopLevel(state);
+    return XML_ROLE_NOTATION_NO_SYSTEM_ID;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+attlist0(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ATTLIST_NONE;
+  case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
+    state->handler = attlist1;
+    return XML_ROLE_ATTLIST_ELEMENT_NAME;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+attlist1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ATTLIST_NONE;
+  case XML_TOK_DECL_CLOSE:
+    setTopLevel(state);
+    return XML_ROLE_ATTLIST_NONE;
+  case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
+    state->handler = attlist2;
+    return XML_ROLE_ATTRIBUTE_NAME;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+attlist2(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ATTLIST_NONE;
+  case XML_TOK_NAME: {
+    static const char *const types[] = {
+        KW_CDATA,  KW_ID,       KW_IDREF,   KW_IDREFS,
+        KW_ENTITY, KW_ENTITIES, KW_NMTOKEN, KW_NMTOKENS,
+    };
+    int i;
+    for (i = 0; i < (int)(sizeof(types) / sizeof(types[0])); i++)
+      if (XmlNameMatchesAscii(enc, ptr, end, types[i])) {
+        state->handler = attlist8;
+        return XML_ROLE_ATTRIBUTE_TYPE_CDATA + i;
+      }
+  }
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_NOTATION)) {
+      state->handler = attlist5;
+      return XML_ROLE_ATTLIST_NONE;
+    }
+    break;
+  case XML_TOK_OPEN_PAREN:
+    state->handler = attlist3;
+    return XML_ROLE_ATTLIST_NONE;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+attlist3(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ATTLIST_NONE;
+  case XML_TOK_NMTOKEN:
+  case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
+    state->handler = attlist4;
+    return XML_ROLE_ATTRIBUTE_ENUM_VALUE;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+attlist4(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ATTLIST_NONE;
+  case XML_TOK_CLOSE_PAREN:
+    state->handler = attlist8;
+    return XML_ROLE_ATTLIST_NONE;
+  case XML_TOK_OR:
+    state->handler = attlist3;
+    return XML_ROLE_ATTLIST_NONE;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+attlist5(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ATTLIST_NONE;
+  case XML_TOK_OPEN_PAREN:
+    state->handler = attlist6;
+    return XML_ROLE_ATTLIST_NONE;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+attlist6(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ATTLIST_NONE;
+  case XML_TOK_NAME:
+    state->handler = attlist7;
+    return XML_ROLE_ATTRIBUTE_NOTATION_VALUE;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+attlist7(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ATTLIST_NONE;
+  case XML_TOK_CLOSE_PAREN:
+    state->handler = attlist8;
+    return XML_ROLE_ATTLIST_NONE;
+  case XML_TOK_OR:
+    state->handler = attlist6;
+    return XML_ROLE_ATTLIST_NONE;
+  }
+  return common(state, tok);
+}
+
+/* default value */
+static int PTRCALL
+attlist8(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ATTLIST_NONE;
+  case XML_TOK_POUND_NAME:
+    if (XmlNameMatchesAscii(enc, ptr + MIN_BYTES_PER_CHAR(enc), end,
+                            KW_IMPLIED)) {
+      state->handler = attlist1;
+      return XML_ROLE_IMPLIED_ATTRIBUTE_VALUE;
+    }
+    if (XmlNameMatchesAscii(enc, ptr + MIN_BYTES_PER_CHAR(enc), end,
+                            KW_REQUIRED)) {
+      state->handler = attlist1;
+      return XML_ROLE_REQUIRED_ATTRIBUTE_VALUE;
+    }
+    if (XmlNameMatchesAscii(enc, ptr + MIN_BYTES_PER_CHAR(enc), end,
+                            KW_FIXED)) {
+      state->handler = attlist9;
+      return XML_ROLE_ATTLIST_NONE;
+    }
+    break;
+  case XML_TOK_LITERAL:
+    state->handler = attlist1;
+    return XML_ROLE_DEFAULT_ATTRIBUTE_VALUE;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+attlist9(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ATTLIST_NONE;
+  case XML_TOK_LITERAL:
+    state->handler = attlist1;
+    return XML_ROLE_FIXED_ATTRIBUTE_VALUE;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+element0(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ELEMENT_NONE;
+  case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
+    state->handler = element1;
+    return XML_ROLE_ELEMENT_NAME;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+element1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ELEMENT_NONE;
+  case XML_TOK_NAME:
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_EMPTY)) {
+      state->handler = declClose;
+      state->role_none = XML_ROLE_ELEMENT_NONE;
+      return XML_ROLE_CONTENT_EMPTY;
+    }
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_ANY)) {
+      state->handler = declClose;
+      state->role_none = XML_ROLE_ELEMENT_NONE;
+      return XML_ROLE_CONTENT_ANY;
+    }
+    break;
+  case XML_TOK_OPEN_PAREN:
+    state->handler = element2;
+    state->level = 1;
+    return XML_ROLE_GROUP_OPEN;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+element2(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ELEMENT_NONE;
+  case XML_TOK_POUND_NAME:
+    if (XmlNameMatchesAscii(enc, ptr + MIN_BYTES_PER_CHAR(enc), end,
+                            KW_PCDATA)) {
+      state->handler = element3;
+      return XML_ROLE_CONTENT_PCDATA;
+    }
+    break;
+  case XML_TOK_OPEN_PAREN:
+    state->level = 2;
+    state->handler = element6;
+    return XML_ROLE_GROUP_OPEN;
+  case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
+    state->handler = element7;
+    return XML_ROLE_CONTENT_ELEMENT;
+  case XML_TOK_NAME_QUESTION:
+    state->handler = element7;
+    return XML_ROLE_CONTENT_ELEMENT_OPT;
+  case XML_TOK_NAME_ASTERISK:
+    state->handler = element7;
+    return XML_ROLE_CONTENT_ELEMENT_REP;
+  case XML_TOK_NAME_PLUS:
+    state->handler = element7;
+    return XML_ROLE_CONTENT_ELEMENT_PLUS;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+element3(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ELEMENT_NONE;
+  case XML_TOK_CLOSE_PAREN:
+    state->handler = declClose;
+    state->role_none = XML_ROLE_ELEMENT_NONE;
+    return XML_ROLE_GROUP_CLOSE;
+  case XML_TOK_CLOSE_PAREN_ASTERISK:
+    state->handler = declClose;
+    state->role_none = XML_ROLE_ELEMENT_NONE;
+    return XML_ROLE_GROUP_CLOSE_REP;
+  case XML_TOK_OR:
+    state->handler = element4;
+    return XML_ROLE_ELEMENT_NONE;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+element4(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ELEMENT_NONE;
+  case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
+    state->handler = element5;
+    return XML_ROLE_CONTENT_ELEMENT;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+element5(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ELEMENT_NONE;
+  case XML_TOK_CLOSE_PAREN_ASTERISK:
+    state->handler = declClose;
+    state->role_none = XML_ROLE_ELEMENT_NONE;
+    return XML_ROLE_GROUP_CLOSE_REP;
+  case XML_TOK_OR:
+    state->handler = element4;
+    return XML_ROLE_ELEMENT_NONE;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+element6(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ELEMENT_NONE;
+  case XML_TOK_OPEN_PAREN:
+    state->level += 1;
+    return XML_ROLE_GROUP_OPEN;
+  case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
+    state->handler = element7;
+    return XML_ROLE_CONTENT_ELEMENT;
+  case XML_TOK_NAME_QUESTION:
+    state->handler = element7;
+    return XML_ROLE_CONTENT_ELEMENT_OPT;
+  case XML_TOK_NAME_ASTERISK:
+    state->handler = element7;
+    return XML_ROLE_CONTENT_ELEMENT_REP;
+  case XML_TOK_NAME_PLUS:
+    state->handler = element7;
+    return XML_ROLE_CONTENT_ELEMENT_PLUS;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+element7(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ELEMENT_NONE;
+  case XML_TOK_CLOSE_PAREN:
+    state->level -= 1;
+    if (state->level == 0) {
+      state->handler = declClose;
+      state->role_none = XML_ROLE_ELEMENT_NONE;
+    }
+    return XML_ROLE_GROUP_CLOSE;
+  case XML_TOK_CLOSE_PAREN_ASTERISK:
+    state->level -= 1;
+    if (state->level == 0) {
+      state->handler = declClose;
+      state->role_none = XML_ROLE_ELEMENT_NONE;
+    }
+    return XML_ROLE_GROUP_CLOSE_REP;
+  case XML_TOK_CLOSE_PAREN_QUESTION:
+    state->level -= 1;
+    if (state->level == 0) {
+      state->handler = declClose;
+      state->role_none = XML_ROLE_ELEMENT_NONE;
+    }
+    return XML_ROLE_GROUP_CLOSE_OPT;
+  case XML_TOK_CLOSE_PAREN_PLUS:
+    state->level -= 1;
+    if (state->level == 0) {
+      state->handler = declClose;
+      state->role_none = XML_ROLE_ELEMENT_NONE;
+    }
+    return XML_ROLE_GROUP_CLOSE_PLUS;
+  case XML_TOK_COMMA:
+    state->handler = element6;
+    return XML_ROLE_GROUP_SEQUENCE;
+  case XML_TOK_OR:
+    state->handler = element6;
+    return XML_ROLE_GROUP_CHOICE;
+  }
+  return common(state, tok);
+}
+
+#ifdef XML_DTD
+
+static int PTRCALL
+condSect0(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+          const ENCODING *enc) {
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_NAME:
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_INCLUDE)) {
+      state->handler = condSect1;
+      return XML_ROLE_NONE;
+    }
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_IGNORE)) {
+      state->handler = condSect2;
+      return XML_ROLE_NONE;
+    }
+    break;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+condSect1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+          const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_OPEN_BRACKET:
+    state->handler = externalSubset1;
+    state->includeLevel += 1;
+    return XML_ROLE_NONE;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+condSect2(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+          const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_OPEN_BRACKET:
+    state->handler = externalSubset1;
+    return XML_ROLE_IGNORE_SECT;
+  }
+  return common(state, tok);
+}
+
+#endif /* XML_DTD */
+
+static int PTRCALL
+declClose(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+          const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return state->role_none;
+  case XML_TOK_DECL_CLOSE:
+    setTopLevel(state);
+    return state->role_none;
+  }
+  return common(state, tok);
+}
+
+/* This function will only be invoked if the internal logic of the
+ * parser has broken down.  It is used in two cases:
+ *
+ * 1: When the XML prolog has been finished.  At this point the
+ * processor (the parser level above these role handlers) should
+ * switch from prologProcessor to contentProcessor and reinitialise
+ * the handler function.
+ *
+ * 2: When an error has been detected (via common() below).  At this
+ * point again the processor should be switched to errorProcessor,
+ * which will never call a handler.
+ *
+ * The result of this is that error() can only be called if the
+ * processor switch failed to happen, which is an internal error and
+ * therefore we shouldn't be able to provoke it simply by using the
+ * library.  It is a necessary backstop, however, so we merely exclude
+ * it from the coverage statistics.
+ *
+ * LCOV_EXCL_START
+ */
+static int PTRCALL
+error(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+      const ENCODING *enc) {
+  UNUSED_P(state);
+  UNUSED_P(tok);
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  return XML_ROLE_NONE;
+}
+/* LCOV_EXCL_STOP */
+
+static int FASTCALL
+common(PROLOG_STATE *state, int tok) {
+#ifdef XML_DTD
+  if (! state->documentEntity && tok == XML_TOK_PARAM_ENTITY_REF)
+    return XML_ROLE_INNER_PARAM_ENTITY_REF;
+#else
+  UNUSED_P(tok);
+#endif
+  state->handler = error;
+  return XML_ROLE_ERROR;
+}
+
+void
+XmlPrologStateInit(PROLOG_STATE *state) {
+  state->handler = prolog0;
+#ifdef XML_DTD
+  state->documentEntity = 1;
+  state->includeLevel = 0;
+  state->inEntityValue = 0;
+#endif /* XML_DTD */
+}
+
+#ifdef XML_DTD
+
+void
+XmlPrologStateInitExternalEntity(PROLOG_STATE *state) {
+  state->handler = externalSubset0;
+  state->documentEntity = 0;
+  state->includeLevel = 0;
+}
+
+#endif /* XML_DTD */
+
+#endif /* LV_USE_XML */
+
diff --git a/src/libs/expat/xmlrole.h b/src/libs/expat/xmlrole.h
new file mode 100644
index 000000000..587840b54
--- /dev/null
+++ b/src/libs/expat/xmlrole.h
@@ -0,0 +1,148 @@
+/*
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2002      Karl Waclawek <karl@waclawek.net>
+   Copyright (c) 2002      Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
+   Copyright (c) 2017-2024 Sebastian Pipping <sebastian@pipping.org>
+   Licensed under the MIT license:
+
+   Permission is  hereby granted,  free of charge,  to any  person obtaining
+   a  copy  of  this  software   and  associated  documentation  files  (the
+   "Software"),  to  deal in  the  Software  without restriction,  including
+   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
+   distribute, sublicense, and/or sell copies of the Software, and to permit
+   persons  to whom  the Software  is  furnished to  do so,  subject to  the
+   following conditions:
+
+   The above copyright  notice and this permission notice  shall be included
+   in all copies or substantial portions of the Software.
+
+   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
+   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
+   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+   USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include "../../lv_conf_internal.h"
+#if LV_USE_XML
+
+#ifndef XmlRole_INCLUDED
+#define XmlRole_INCLUDED 1
+
+#ifdef __VMS
+/*      0        1         2         3      0        1         2         3
+        1234567890123456789012345678901     1234567890123456789012345678901 */
+#  define XmlPrologStateInitExternalEntity XmlPrologStateInitExternalEnt
+#endif
+
+#include "xmltok.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+  XML_ROLE_ERROR = -1,
+  XML_ROLE_NONE = 0,
+  XML_ROLE_XML_DECL,
+  XML_ROLE_INSTANCE_START,
+  XML_ROLE_DOCTYPE_NONE,
+  XML_ROLE_DOCTYPE_NAME,
+  XML_ROLE_DOCTYPE_SYSTEM_ID,
+  XML_ROLE_DOCTYPE_PUBLIC_ID,
+  XML_ROLE_DOCTYPE_INTERNAL_SUBSET,
+  XML_ROLE_DOCTYPE_CLOSE,
+  XML_ROLE_GENERAL_ENTITY_NAME,
+  XML_ROLE_PARAM_ENTITY_NAME,
+  XML_ROLE_ENTITY_NONE,
+  XML_ROLE_ENTITY_VALUE,
+  XML_ROLE_ENTITY_SYSTEM_ID,
+  XML_ROLE_ENTITY_PUBLIC_ID,
+  XML_ROLE_ENTITY_COMPLETE,
+  XML_ROLE_ENTITY_NOTATION_NAME,
+  XML_ROLE_NOTATION_NONE,
+  XML_ROLE_NOTATION_NAME,
+  XML_ROLE_NOTATION_SYSTEM_ID,
+  XML_ROLE_NOTATION_NO_SYSTEM_ID,
+  XML_ROLE_NOTATION_PUBLIC_ID,
+  XML_ROLE_ATTRIBUTE_NAME,
+  XML_ROLE_ATTRIBUTE_TYPE_CDATA,
+  XML_ROLE_ATTRIBUTE_TYPE_ID,
+  XML_ROLE_ATTRIBUTE_TYPE_IDREF,
+  XML_ROLE_ATTRIBUTE_TYPE_IDREFS,
+  XML_ROLE_ATTRIBUTE_TYPE_ENTITY,
+  XML_ROLE_ATTRIBUTE_TYPE_ENTITIES,
+  XML_ROLE_ATTRIBUTE_TYPE_NMTOKEN,
+  XML_ROLE_ATTRIBUTE_TYPE_NMTOKENS,
+  XML_ROLE_ATTRIBUTE_ENUM_VALUE,
+  XML_ROLE_ATTRIBUTE_NOTATION_VALUE,
+  XML_ROLE_ATTLIST_NONE,
+  XML_ROLE_ATTLIST_ELEMENT_NAME,
+  XML_ROLE_IMPLIED_ATTRIBUTE_VALUE,
+  XML_ROLE_REQUIRED_ATTRIBUTE_VALUE,
+  XML_ROLE_DEFAULT_ATTRIBUTE_VALUE,
+  XML_ROLE_FIXED_ATTRIBUTE_VALUE,
+  XML_ROLE_ELEMENT_NONE,
+  XML_ROLE_ELEMENT_NAME,
+  XML_ROLE_CONTENT_ANY,
+  XML_ROLE_CONTENT_EMPTY,
+  XML_ROLE_CONTENT_PCDATA,
+  XML_ROLE_GROUP_OPEN,
+  XML_ROLE_GROUP_CLOSE,
+  XML_ROLE_GROUP_CLOSE_REP,
+  XML_ROLE_GROUP_CLOSE_OPT,
+  XML_ROLE_GROUP_CLOSE_PLUS,
+  XML_ROLE_GROUP_CHOICE,
+  XML_ROLE_GROUP_SEQUENCE,
+  XML_ROLE_CONTENT_ELEMENT,
+  XML_ROLE_CONTENT_ELEMENT_REP,
+  XML_ROLE_CONTENT_ELEMENT_OPT,
+  XML_ROLE_CONTENT_ELEMENT_PLUS,
+  XML_ROLE_PI,
+  XML_ROLE_COMMENT,
+#ifdef XML_DTD
+  XML_ROLE_TEXT_DECL,
+  XML_ROLE_IGNORE_SECT,
+  XML_ROLE_INNER_PARAM_ENTITY_REF,
+#endif /* XML_DTD */
+  XML_ROLE_PARAM_ENTITY_REF
+};
+
+typedef struct prolog_state {
+  int(PTRCALL *handler)(struct prolog_state *state, int tok, const char *ptr,
+                        const char *end, const ENCODING *enc);
+  unsigned level;
+  int role_none;
+#ifdef XML_DTD
+  unsigned includeLevel;
+  int documentEntity;
+  int inEntityValue;
+#endif /* XML_DTD */
+} PROLOG_STATE;
+
+void XmlPrologStateInit(PROLOG_STATE *state);
+#ifdef XML_DTD
+void XmlPrologStateInitExternalEntity(PROLOG_STATE *state);
+#endif /* XML_DTD */
+
+#define XmlTokenRole(state, tok, ptr, end, enc)                                \
+  (((state)->handler)(state, tok, ptr, end, enc))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* not XmlRole_INCLUDED */
+
+#endif /* LV_USE_XML */
+
diff --git a/src/libs/expat/xmltok.c b/src/libs/expat/xmltok.c
new file mode 100644
index 000000000..c8e265996
--- /dev/null
+++ b/src/libs/expat/xmltok.c
@@ -0,0 +1,1678 @@
+/*
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2001-2003 Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
+   Copyright (c) 2002      Greg Stein <gstein@users.sourceforge.net>
+   Copyright (c) 2002-2016 Karl Waclawek <karl@waclawek.net>
+   Copyright (c) 2005-2009 Steven Solie <steven@solie.ca>
+   Copyright (c) 2016-2024 Sebastian Pipping <sebastian@pipping.org>
+   Copyright (c) 2016      Pascal Cuoq <cuoq@trust-in-soft.com>
+   Copyright (c) 2016      Don Lewis <truckman@apache.org>
+   Copyright (c) 2017      Rhodri James <rhodri@wildebeest.org.uk>
+   Copyright (c) 2017      Alexander Bluhm <alexander.bluhm@gmx.net>
+   Copyright (c) 2017      Benbuck Nason <bnason@netflix.com>
+   Copyright (c) 2017      José Gutiérrez de la Concha <jose@zeroc.com>
+   Copyright (c) 2019      David Loffredo <loffredo@steptools.com>
+   Copyright (c) 2021      Donghee Na <donghee.na@python.org>
+   Copyright (c) 2022      Martin Ettl <ettl.martin78@googlemail.com>
+   Copyright (c) 2022      Sean McBride <sean@rogue-research.com>
+   Copyright (c) 2023      Hanno Böck <hanno@gentoo.org>
+   Licensed under the MIT license:
+
+   Permission is  hereby granted,  free of charge,  to any  person obtaining
+   a  copy  of  this  software   and  associated  documentation  files  (the
+   "Software"),  to  deal in  the  Software  without restriction,  including
+   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
+   distribute, sublicense, and/or sell copies of the Software, and to permit
+   persons  to whom  the Software  is  furnished to  do so,  subject to  the
+   following conditions:
+
+   The above copyright  notice and this permission notice  shall be included
+   in all copies or substantial portions of the Software.
+
+   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
+   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
+   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+   USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include "../../lv_conf_internal.h"
+#if LV_USE_XML
+
+#include "expat_config.h"
+
+#include <stddef.h>
+#include <string.h> /* memcpy */
+#include <stdbool.h>
+
+#ifdef _WIN32
+#  include "winconfig.h"
+#endif
+
+#include "expat_external.h"
+#include "internal.h"
+#include "xmltok.h"
+#include "nametab.h"
+
+#ifdef XML_DTD
+#  define IGNORE_SECTION_TOK_VTABLE , PREFIX(ignoreSectionTok)
+#else
+#  define IGNORE_SECTION_TOK_VTABLE /* as nothing */
+#endif
+
+#define VTABLE1                                                                \
+  {PREFIX(prologTok), PREFIX(contentTok),                                      \
+   PREFIX(cdataSectionTok) IGNORE_SECTION_TOK_VTABLE},                         \
+      {PREFIX(attributeValueTok), PREFIX(entityValueTok)},                     \
+      PREFIX(nameMatchesAscii), PREFIX(nameLength), PREFIX(skipS),             \
+      PREFIX(getAtts), PREFIX(charRefNumber), PREFIX(predefinedEntityName),    \
+      PREFIX(updatePosition), PREFIX(isPublicId)
+
+#define VTABLE VTABLE1, PREFIX(toUtf8), PREFIX(toUtf16)
+
+#define UCS2_GET_NAMING(pages, hi, lo)                                         \
+  (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1u << ((lo) & 0x1F)))
+
+/* A 2 byte UTF-8 representation splits the characters 11 bits between
+   the bottom 5 and 6 bits of the bytes.  We need 8 bits to index into
+   pages, 3 bits to add to that index and 5 bits to generate the mask.
+*/
+#define UTF8_GET_NAMING2(pages, byte)                                          \
+  (namingBitmap[((pages)[(((byte)[0]) >> 2) & 7] << 3)                         \
+                + ((((byte)[0]) & 3) << 1) + ((((byte)[1]) >> 5) & 1)]         \
+   & (1u << (((byte)[1]) & 0x1F)))
+
+/* A 3 byte UTF-8 representation splits the characters 16 bits between
+   the bottom 4, 6 and 6 bits of the bytes.  We need 8 bits to index
+   into pages, 3 bits to add to that index and 5 bits to generate the
+   mask.
+*/
+#define UTF8_GET_NAMING3(pages, byte)                                          \
+  (namingBitmap                                                                \
+       [((pages)[((((byte)[0]) & 0xF) << 4) + ((((byte)[1]) >> 2) & 0xF)]      \
+         << 3)                                                                 \
+        + ((((byte)[1]) & 3) << 1) + ((((byte)[2]) >> 5) & 1)]                 \
+   & (1u << (((byte)[2]) & 0x1F)))
+
+/* Detection of invalid UTF-8 sequences is based on Table 3.1B
+   of Unicode 3.2: https://www.unicode.org/unicode/reports/tr28/
+   with the additional restriction of not allowing the Unicode
+   code points 0xFFFF and 0xFFFE (sequences EF,BF,BF and EF,BF,BE).
+   Implementation details:
+     (A & 0x80) == 0     means A < 0x80
+   and
+     (A & 0xC0) == 0xC0  means A > 0xBF
+*/
+
+#define UTF8_INVALID2(p)                                                       \
+  ((*p) < 0xC2 || ((p)[1] & 0x80) == 0 || ((p)[1] & 0xC0) == 0xC0)
+
+#define UTF8_INVALID3(p)                                                       \
+  (((p)[2] & 0x80) == 0                                                        \
+   || ((*p) == 0xEF && (p)[1] == 0xBF ? (p)[2] > 0xBD                          \
+                                      : ((p)[2] & 0xC0) == 0xC0)               \
+   || ((*p) == 0xE0                                                            \
+           ? (p)[1] < 0xA0 || ((p)[1] & 0xC0) == 0xC0                          \
+           : ((p)[1] & 0x80) == 0                                              \
+                 || ((*p) == 0xED ? (p)[1] > 0x9F : ((p)[1] & 0xC0) == 0xC0)))
+
+#define UTF8_INVALID4(p)                                                       \
+  (((p)[3] & 0x80) == 0 || ((p)[3] & 0xC0) == 0xC0 || ((p)[2] & 0x80) == 0     \
+   || ((p)[2] & 0xC0) == 0xC0                                                  \
+   || ((*p) == 0xF0                                                            \
+           ? (p)[1] < 0x90 || ((p)[1] & 0xC0) == 0xC0                          \
+           : ((p)[1] & 0x80) == 0                                              \
+                 || ((*p) == 0xF4 ? (p)[1] > 0x8F : ((p)[1] & 0xC0) == 0xC0)))
+
+static int PTRFASTCALL
+isNever(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  UNUSED_P(p);
+  return 0;
+}
+
+static int PTRFASTCALL
+utf8_isName2(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return UTF8_GET_NAMING2(namePages, (const unsigned char *)p);
+}
+
+static int PTRFASTCALL
+utf8_isName3(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return UTF8_GET_NAMING3(namePages, (const unsigned char *)p);
+}
+
+#define utf8_isName4 isNever
+
+static int PTRFASTCALL
+utf8_isNmstrt2(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return UTF8_GET_NAMING2(nmstrtPages, (const unsigned char *)p);
+}
+
+static int PTRFASTCALL
+utf8_isNmstrt3(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return UTF8_GET_NAMING3(nmstrtPages, (const unsigned char *)p);
+}
+
+#define utf8_isNmstrt4 isNever
+
+static int PTRFASTCALL
+utf8_isInvalid2(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return UTF8_INVALID2((const unsigned char *)p);
+}
+
+static int PTRFASTCALL
+utf8_isInvalid3(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return UTF8_INVALID3((const unsigned char *)p);
+}
+
+static int PTRFASTCALL
+utf8_isInvalid4(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return UTF8_INVALID4((const unsigned char *)p);
+}
+
+struct normal_encoding {
+  ENCODING enc;
+  unsigned char type[256];
+#ifdef XML_MIN_SIZE
+  int(PTRFASTCALL *byteType)(const ENCODING *, const char *);
+  int(PTRFASTCALL *isNameMin)(const ENCODING *, const char *);
+  int(PTRFASTCALL *isNmstrtMin)(const ENCODING *, const char *);
+  int(PTRFASTCALL *byteToAscii)(const ENCODING *, const char *);
+  int(PTRCALL *charMatches)(const ENCODING *, const char *, int);
+#endif /* XML_MIN_SIZE */
+  int(PTRFASTCALL *isName2)(const ENCODING *, const char *);
+  int(PTRFASTCALL *isName3)(const ENCODING *, const char *);
+  int(PTRFASTCALL *isName4)(const ENCODING *, const char *);
+  int(PTRFASTCALL *isNmstrt2)(const ENCODING *, const char *);
+  int(PTRFASTCALL *isNmstrt3)(const ENCODING *, const char *);
+  int(PTRFASTCALL *isNmstrt4)(const ENCODING *, const char *);
+  int(PTRFASTCALL *isInvalid2)(const ENCODING *, const char *);
+  int(PTRFASTCALL *isInvalid3)(const ENCODING *, const char *);
+  int(PTRFASTCALL *isInvalid4)(const ENCODING *, const char *);
+};
+
+#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc))
+
+#ifdef XML_MIN_SIZE
+
+#  define STANDARD_VTABLE(E)                                                   \
+    E##byteType, E##isNameMin, E##isNmstrtMin, E##byteToAscii, E##charMatches,
+
+#else
+
+#  define STANDARD_VTABLE(E) /* as nothing */
+
+#endif
+
+#define NORMAL_VTABLE(E)                                                       \
+  E##isName2, E##isName3, E##isName4, E##isNmstrt2, E##isNmstrt3,              \
+      E##isNmstrt4, E##isInvalid2, E##isInvalid3, E##isInvalid4
+
+#define NULL_VTABLE                                                            \
+  /* isName2 */ NULL, /* isName3 */ NULL, /* isName4 */ NULL,                  \
+      /* isNmstrt2 */ NULL, /* isNmstrt3 */ NULL, /* isNmstrt4 */ NULL,        \
+      /* isInvalid2 */ NULL, /* isInvalid3 */ NULL, /* isInvalid4 */ NULL
+
+static int FASTCALL checkCharRefNumber(int result);
+
+#include "xmltok_impl.h"
+#include "ascii.h"
+
+#ifdef XML_MIN_SIZE
+#  define sb_isNameMin isNever
+#  define sb_isNmstrtMin isNever
+#endif
+
+#ifdef XML_MIN_SIZE
+#  define MINBPC(enc) ((enc)->minBytesPerChar)
+#else
+/* minimum bytes per character */
+#  define MINBPC(enc) 1
+#endif
+
+#define SB_BYTE_TYPE(enc, p)                                                   \
+  (((const struct normal_encoding *)(enc))->type[(unsigned char)*(p)])
+
+#ifdef XML_MIN_SIZE
+static int PTRFASTCALL
+sb_byteType(const ENCODING *enc, const char *p) {
+  return SB_BYTE_TYPE(enc, p);
+}
+#  define BYTE_TYPE(enc, p) (AS_NORMAL_ENCODING(enc)->byteType(enc, p))
+#else
+#  define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p)
+#endif
+
+#ifdef XML_MIN_SIZE
+#  define BYTE_TO_ASCII(enc, p) (AS_NORMAL_ENCODING(enc)->byteToAscii(enc, p))
+static int PTRFASTCALL
+sb_byteToAscii(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return *p;
+}
+#else
+#  define BYTE_TO_ASCII(enc, p) (*(p))
+#endif
+
+#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p))
+#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p))
+#ifdef XML_MIN_SIZE
+#  define IS_INVALID_CHAR(enc, p, n)                                           \
+    (AS_NORMAL_ENCODING(enc)->isInvalid##n                                     \
+     && AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p))
+#else
+#  define IS_INVALID_CHAR(enc, p, n)                                           \
+    (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p))
+#endif
+
+#ifdef XML_MIN_SIZE
+#  define IS_NAME_CHAR_MINBPC(enc, p)                                          \
+    (AS_NORMAL_ENCODING(enc)->isNameMin(enc, p))
+#  define IS_NMSTRT_CHAR_MINBPC(enc, p)                                        \
+    (AS_NORMAL_ENCODING(enc)->isNmstrtMin(enc, p))
+#else
+#  define IS_NAME_CHAR_MINBPC(enc, p) (0)
+#  define IS_NMSTRT_CHAR_MINBPC(enc, p) (0)
+#endif
+
+#ifdef XML_MIN_SIZE
+#  define CHAR_MATCHES(enc, p, c)                                              \
+    (AS_NORMAL_ENCODING(enc)->charMatches(enc, p, c))
+static int PTRCALL
+sb_charMatches(const ENCODING *enc, const char *p, int c) {
+  UNUSED_P(enc);
+  return *p == c;
+}
+#else
+/* c is an ASCII character */
+#  define CHAR_MATCHES(enc, p, c) (*(p) == (c))
+#endif
+
+#define PREFIX(ident) normal_##ident
+#define XML_TOK_IMPL_C
+#include "xmltok_impl.c"
+#undef XML_TOK_IMPL_C
+
+#undef MINBPC
+#undef BYTE_TYPE
+#undef BYTE_TO_ASCII
+#undef CHAR_MATCHES
+#undef IS_NAME_CHAR
+#undef IS_NAME_CHAR_MINBPC
+#undef IS_NMSTRT_CHAR
+#undef IS_NMSTRT_CHAR_MINBPC
+#undef IS_INVALID_CHAR
+
+enum { /* UTF8_cvalN is value of masked first byte of N byte sequence */
+       UTF8_cval1 = 0x00,
+       UTF8_cval2 = 0xc0,
+       UTF8_cval3 = 0xe0,
+       UTF8_cval4 = 0xf0
+};
+
+void
+_INTERNAL_trim_to_complete_utf8_characters(const char *from,
+                                           const char **fromLimRef) {
+  const char *fromLim = *fromLimRef;
+  size_t walked = 0;
+  for (; fromLim > from; fromLim--, walked++) {
+    const unsigned char prev = (unsigned char)fromLim[-1];
+    if ((prev & 0xf8u)
+        == 0xf0u) { /* 4-byte character, lead by 0b11110xxx byte */
+      if (walked + 1 >= 4) {
+        fromLim += 4 - 1;
+        break;
+      } else {
+        walked = 0;
+      }
+    } else if ((prev & 0xf0u)
+               == 0xe0u) { /* 3-byte character, lead by 0b1110xxxx byte */
+      if (walked + 1 >= 3) {
+        fromLim += 3 - 1;
+        break;
+      } else {
+        walked = 0;
+      }
+    } else if ((prev & 0xe0u)
+               == 0xc0u) { /* 2-byte character, lead by 0b110xxxxx byte */
+      if (walked + 1 >= 2) {
+        fromLim += 2 - 1;
+        break;
+      } else {
+        walked = 0;
+      }
+    } else if ((prev & 0x80u)
+               == 0x00u) { /* 1-byte character, matching 0b0xxxxxxx */
+      break;
+    }
+  }
+  *fromLimRef = fromLim;
+}
+
+static enum XML_Convert_Result PTRCALL
+utf8_toUtf8(const ENCODING *enc, const char **fromP, const char *fromLim,
+            char **toP, const char *toLim) {
+  bool input_incomplete = false;
+  bool output_exhausted = false;
+
+  /* Avoid copying partial characters (due to limited space). */
+  const ptrdiff_t bytesAvailable = fromLim - *fromP;
+  const ptrdiff_t bytesStorable = toLim - *toP;
+  UNUSED_P(enc);
+  if (bytesAvailable > bytesStorable) {
+    fromLim = *fromP + bytesStorable;
+    output_exhausted = true;
+  }
+
+  /* Avoid copying partial characters (from incomplete input). */
+  {
+    const char *const fromLimBefore = fromLim;
+    _INTERNAL_trim_to_complete_utf8_characters(*fromP, &fromLim);
+    if (fromLim < fromLimBefore) {
+      input_incomplete = true;
+    }
+  }
+
+  {
+    const ptrdiff_t bytesToCopy = fromLim - *fromP;
+    memcpy(*toP, *fromP, bytesToCopy);
+    *fromP += bytesToCopy;
+    *toP += bytesToCopy;
+  }
+
+  if (output_exhausted) /* needs to go first */
+    return XML_CONVERT_OUTPUT_EXHAUSTED;
+  else if (input_incomplete)
+    return XML_CONVERT_INPUT_INCOMPLETE;
+  else
+    return XML_CONVERT_COMPLETED;
+}
+
+static enum XML_Convert_Result PTRCALL
+utf8_toUtf16(const ENCODING *enc, const char **fromP, const char *fromLim,
+             unsigned short **toP, const unsigned short *toLim) {
+  enum XML_Convert_Result res = XML_CONVERT_COMPLETED;
+  unsigned short *to = *toP;
+  const char *from = *fromP;
+  while (from < fromLim && to < toLim) {
+    switch (SB_BYTE_TYPE(enc, from)) {
+    case BT_LEAD2:
+      if (fromLim - from < 2) {
+        res = XML_CONVERT_INPUT_INCOMPLETE;
+        goto after;
+      }
+      *to++ = (unsigned short)(((from[0] & 0x1f) << 6) | (from[1] & 0x3f));
+      from += 2;
+      break;
+    case BT_LEAD3:
+      if (fromLim - from < 3) {
+        res = XML_CONVERT_INPUT_INCOMPLETE;
+        goto after;
+      }
+      *to++ = (unsigned short)(((from[0] & 0xf) << 12) | ((from[1] & 0x3f) << 6)
+                               | (from[2] & 0x3f));
+      from += 3;
+      break;
+    case BT_LEAD4: {
+      unsigned long n;
+      if (toLim - to < 2) {
+        res = XML_CONVERT_OUTPUT_EXHAUSTED;
+        goto after;
+      }
+      if (fromLim - from < 4) {
+        res = XML_CONVERT_INPUT_INCOMPLETE;
+        goto after;
+      }
+      n = ((from[0] & 0x7) << 18) | ((from[1] & 0x3f) << 12)
+          | ((from[2] & 0x3f) << 6) | (from[3] & 0x3f);
+      n -= 0x10000;
+      to[0] = (unsigned short)((n >> 10) | 0xD800);
+      to[1] = (unsigned short)((n & 0x3FF) | 0xDC00);
+      to += 2;
+      from += 4;
+    } break;
+    default:
+      *to++ = *from++;
+      break;
+    }
+  }
+  if (from < fromLim)
+    res = XML_CONVERT_OUTPUT_EXHAUSTED;
+after:
+  *fromP = from;
+  *toP = to;
+  return res;
+}
+
+#ifdef XML_NS
+static const struct normal_encoding utf8_encoding_ns
+    = {{VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0},
+       {
+#  include "asciitab.h"
+#  include "utf8tab.h"
+       },
+       STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)};
+#endif
+
+static const struct normal_encoding utf8_encoding
+    = {{VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0},
+       {
+#define BT_COLON BT_NMSTRT
+#include "asciitab.h"
+#undef BT_COLON
+#include "utf8tab.h"
+       },
+       STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)};
+
+#ifdef XML_NS
+
+static const struct normal_encoding internal_utf8_encoding_ns
+    = {{VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0},
+       {
+#  include "iasciitab.h"
+#  include "utf8tab.h"
+       },
+       STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)};
+
+#endif
+
+static const struct normal_encoding internal_utf8_encoding
+    = {{VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0},
+       {
+#define BT_COLON BT_NMSTRT
+#include "iasciitab.h"
+#undef BT_COLON
+#include "utf8tab.h"
+       },
+       STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)};
+
+static enum XML_Convert_Result PTRCALL
+latin1_toUtf8(const ENCODING *enc, const char **fromP, const char *fromLim,
+              char **toP, const char *toLim) {
+  UNUSED_P(enc);
+  for (;;) {
+    unsigned char c;
+    if (*fromP == fromLim)
+      return XML_CONVERT_COMPLETED;
+    c = (unsigned char)**fromP;
+    if (c & 0x80) {
+      if (toLim - *toP < 2)
+        return XML_CONVERT_OUTPUT_EXHAUSTED;
+      *(*toP)++ = (char)((c >> 6) | UTF8_cval2);
+      *(*toP)++ = (char)((c & 0x3f) | 0x80);
+      (*fromP)++;
+    } else {
+      if (*toP == toLim)
+        return XML_CONVERT_OUTPUT_EXHAUSTED;
+      *(*toP)++ = *(*fromP)++;
+    }
+  }
+}
+
+static enum XML_Convert_Result PTRCALL
+latin1_toUtf16(const ENCODING *enc, const char **fromP, const char *fromLim,
+               unsigned short **toP, const unsigned short *toLim) {
+  UNUSED_P(enc);
+  while (*fromP < fromLim && *toP < toLim)
+    *(*toP)++ = (unsigned char)*(*fromP)++;
+
+  if ((*toP == toLim) && (*fromP < fromLim))
+    return XML_CONVERT_OUTPUT_EXHAUSTED;
+  else
+    return XML_CONVERT_COMPLETED;
+}
+
+#ifdef XML_NS
+
+static const struct normal_encoding latin1_encoding_ns
+    = {{VTABLE1, latin1_toUtf8, latin1_toUtf16, 1, 0, 0},
+       {
+#  include "asciitab.h"
+#  include "latin1tab.h"
+       },
+       STANDARD_VTABLE(sb_) NULL_VTABLE};
+
+#endif
+
+static const struct normal_encoding latin1_encoding
+    = {{VTABLE1, latin1_toUtf8, latin1_toUtf16, 1, 0, 0},
+       {
+#define BT_COLON BT_NMSTRT
+#include "asciitab.h"
+#undef BT_COLON
+#include "latin1tab.h"
+       },
+       STANDARD_VTABLE(sb_) NULL_VTABLE};
+
+static enum XML_Convert_Result PTRCALL
+ascii_toUtf8(const ENCODING *enc, const char **fromP, const char *fromLim,
+             char **toP, const char *toLim) {
+  UNUSED_P(enc);
+  while (*fromP < fromLim && *toP < toLim)
+    *(*toP)++ = *(*fromP)++;
+
+  if ((*toP == toLim) && (*fromP < fromLim))
+    return XML_CONVERT_OUTPUT_EXHAUSTED;
+  else
+    return XML_CONVERT_COMPLETED;
+}
+
+#ifdef XML_NS
+
+static const struct normal_encoding ascii_encoding_ns
+    = {{VTABLE1, ascii_toUtf8, latin1_toUtf16, 1, 1, 0},
+       {
+#  include "asciitab.h"
+           /* BT_NONXML == 0 */
+       },
+       STANDARD_VTABLE(sb_) NULL_VTABLE};
+
+#endif
+
+static const struct normal_encoding ascii_encoding
+    = {{VTABLE1, ascii_toUtf8, latin1_toUtf16, 1, 1, 0},
+       {
+#define BT_COLON BT_NMSTRT
+#include "asciitab.h"
+#undef BT_COLON
+           /* BT_NONXML == 0 */
+       },
+       STANDARD_VTABLE(sb_) NULL_VTABLE};
+
+static int PTRFASTCALL
+unicode_byte_type(char hi, char lo) {
+  switch ((unsigned char)hi) {
+  /* 0xD800-0xDBFF first 16-bit code unit or high surrogate (W1) */
+  case 0xD8:
+  case 0xD9:
+  case 0xDA:
+  case 0xDB:
+    return BT_LEAD4;
+  /* 0xDC00-0xDFFF second 16-bit code unit or low surrogate (W2) */
+  case 0xDC:
+  case 0xDD:
+  case 0xDE:
+  case 0xDF:
+    return BT_TRAIL;
+  case 0xFF:
+    switch ((unsigned char)lo) {
+    case 0xFF: /* noncharacter-FFFF */
+    case 0xFE: /* noncharacter-FFFE */
+      return BT_NONXML;
+    }
+    break;
+  }
+  return BT_NONASCII;
+}
+
+#define DEFINE_UTF16_TO_UTF8(E)                                                \
+  static enum XML_Convert_Result PTRCALL E##toUtf8(                            \
+      const ENCODING *enc, const char **fromP, const char *fromLim,            \
+      char **toP, const char *toLim) {                                         \
+    const char *from = *fromP;                                                 \
+    UNUSED_P(enc);                                                             \
+    fromLim = from + (((fromLim - from) >> 1) << 1); /* shrink to even */      \
+    for (; from < fromLim; from += 2) {                                        \
+      int plane;                                                               \
+      unsigned char lo2;                                                       \
+      unsigned char lo = GET_LO(from);                                         \
+      unsigned char hi = GET_HI(from);                                         \
+      switch (hi) {                                                            \
+      case 0:                                                                  \
+        if (lo < 0x80) {                                                       \
+          if (*toP == toLim) {                                                 \
+            *fromP = from;                                                     \
+            return XML_CONVERT_OUTPUT_EXHAUSTED;                               \
+          }                                                                    \
+          *(*toP)++ = lo;                                                      \
+          break;                                                               \
+        }                                                                      \
+        /* fall through */                                                     \
+      case 0x1:                                                                \
+      case 0x2:                                                                \
+      case 0x3:                                                                \
+      case 0x4:                                                                \
+      case 0x5:                                                                \
+      case 0x6:                                                                \
+      case 0x7:                                                                \
+        if (toLim - *toP < 2) {                                                \
+          *fromP = from;                                                       \
+          return XML_CONVERT_OUTPUT_EXHAUSTED;                                 \
+        }                                                                      \
+        *(*toP)++ = ((lo >> 6) | (hi << 2) | UTF8_cval2);                      \
+        *(*toP)++ = ((lo & 0x3f) | 0x80);                                      \
+        break;                                                                 \
+      default:                                                                 \
+        if (toLim - *toP < 3) {                                                \
+          *fromP = from;                                                       \
+          return XML_CONVERT_OUTPUT_EXHAUSTED;                                 \
+        }                                                                      \
+        /* 16 bits divided 4, 6, 6 amongst 3 bytes */                          \
+        *(*toP)++ = ((hi >> 4) | UTF8_cval3);                                  \
+        *(*toP)++ = (((hi & 0xf) << 2) | (lo >> 6) | 0x80);                    \
+        *(*toP)++ = ((lo & 0x3f) | 0x80);                                      \
+        break;                                                                 \
+      case 0xD8:                                                               \
+      case 0xD9:                                                               \
+      case 0xDA:                                                               \
+      case 0xDB:                                                               \
+        if (toLim - *toP < 4) {                                                \
+          *fromP = from;                                                       \
+          return XML_CONVERT_OUTPUT_EXHAUSTED;                                 \
+        }                                                                      \
+        if (fromLim - from < 4) {                                              \
+          *fromP = from;                                                       \
+          return XML_CONVERT_INPUT_INCOMPLETE;                                 \
+        }                                                                      \
+        plane = (((hi & 0x3) << 2) | ((lo >> 6) & 0x3)) + 1;                   \
+        *(*toP)++ = (char)((plane >> 2) | UTF8_cval4);                         \
+        *(*toP)++ = (((lo >> 2) & 0xF) | ((plane & 0x3) << 4) | 0x80);         \
+        from += 2;                                                             \
+        lo2 = GET_LO(from);                                                    \
+        *(*toP)++ = (((lo & 0x3) << 4) | ((GET_HI(from) & 0x3) << 2)           \
+                     | (lo2 >> 6) | 0x80);                                     \
+        *(*toP)++ = ((lo2 & 0x3f) | 0x80);                                     \
+        break;                                                                 \
+      }                                                                        \
+    }                                                                          \
+    *fromP = from;                                                             \
+    if (from < fromLim)                                                        \
+      return XML_CONVERT_INPUT_INCOMPLETE;                                     \
+    else                                                                       \
+      return XML_CONVERT_COMPLETED;                                            \
+  }
+
+#define DEFINE_UTF16_TO_UTF16(E)                                               \
+  static enum XML_Convert_Result PTRCALL E##toUtf16(                           \
+      const ENCODING *enc, const char **fromP, const char *fromLim,            \
+      unsigned short **toP, const unsigned short *toLim) {                     \
+    enum XML_Convert_Result res = XML_CONVERT_COMPLETED;                       \
+    UNUSED_P(enc);                                                             \
+    fromLim = *fromP + (((fromLim - *fromP) >> 1) << 1); /* shrink to even */  \
+    /* Avoid copying first half only of surrogate */                           \
+    if (fromLim - *fromP > ((toLim - *toP) << 1)                               \
+        && (GET_HI(fromLim - 2) & 0xF8) == 0xD8) {                             \
+      fromLim -= 2;                                                            \
+      res = XML_CONVERT_INPUT_INCOMPLETE;                                      \
+    }                                                                          \
+    for (; *fromP < fromLim && *toP < toLim; *fromP += 2)                      \
+      *(*toP)++ = (GET_HI(*fromP) << 8) | GET_LO(*fromP);                      \
+    if ((*toP == toLim) && (*fromP < fromLim))                                 \
+      return XML_CONVERT_OUTPUT_EXHAUSTED;                                     \
+    else                                                                       \
+      return res;                                                              \
+  }
+
+#define GET_LO(ptr) ((unsigned char)(ptr)[0])
+#define GET_HI(ptr) ((unsigned char)(ptr)[1])
+
+DEFINE_UTF16_TO_UTF8(little2_)
+DEFINE_UTF16_TO_UTF16(little2_)
+
+#undef GET_LO
+#undef GET_HI
+
+#define GET_LO(ptr) ((unsigned char)(ptr)[1])
+#define GET_HI(ptr) ((unsigned char)(ptr)[0])
+
+DEFINE_UTF16_TO_UTF8(big2_)
+DEFINE_UTF16_TO_UTF16(big2_)
+
+#undef GET_LO
+#undef GET_HI
+
+#define LITTLE2_BYTE_TYPE(enc, p)                                              \
+  ((p)[1] == 0 ? SB_BYTE_TYPE(enc, p) : unicode_byte_type((p)[1], (p)[0]))
+#define LITTLE2_BYTE_TO_ASCII(p) ((p)[1] == 0 ? (p)[0] : -1)
+#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == (c))
+#define LITTLE2_IS_NAME_CHAR_MINBPC(p)                                         \
+  UCS2_GET_NAMING(namePages, (unsigned char)p[1], (unsigned char)p[0])
+#define LITTLE2_IS_NMSTRT_CHAR_MINBPC(p)                                       \
+  UCS2_GET_NAMING(nmstrtPages, (unsigned char)p[1], (unsigned char)p[0])
+
+#ifdef XML_MIN_SIZE
+
+static int PTRFASTCALL
+little2_byteType(const ENCODING *enc, const char *p) {
+  return LITTLE2_BYTE_TYPE(enc, p);
+}
+
+static int PTRFASTCALL
+little2_byteToAscii(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return LITTLE2_BYTE_TO_ASCII(p);
+}
+
+static int PTRCALL
+little2_charMatches(const ENCODING *enc, const char *p, int c) {
+  UNUSED_P(enc);
+  return LITTLE2_CHAR_MATCHES(p, c);
+}
+
+static int PTRFASTCALL
+little2_isNameMin(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return LITTLE2_IS_NAME_CHAR_MINBPC(p);
+}
+
+static int PTRFASTCALL
+little2_isNmstrtMin(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return LITTLE2_IS_NMSTRT_CHAR_MINBPC(p);
+}
+
+#  undef VTABLE
+#  define VTABLE VTABLE1, little2_toUtf8, little2_toUtf16
+
+#else /* not XML_MIN_SIZE */
+
+#  undef PREFIX
+#  define PREFIX(ident) little2_##ident
+#  define MINBPC(enc) 2
+/* CHAR_MATCHES is guaranteed to have MINBPC bytes available. */
+#  define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p)
+#  define BYTE_TO_ASCII(enc, p) LITTLE2_BYTE_TO_ASCII(p)
+#  define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c)
+#  define IS_NAME_CHAR(enc, p, n) 0
+#  define IS_NAME_CHAR_MINBPC(enc, p) LITTLE2_IS_NAME_CHAR_MINBPC(p)
+#  define IS_NMSTRT_CHAR(enc, p, n) (0)
+#  define IS_NMSTRT_CHAR_MINBPC(enc, p) LITTLE2_IS_NMSTRT_CHAR_MINBPC(p)
+
+#  define XML_TOK_IMPL_C
+#  include "xmltok_impl.c"
+#  undef XML_TOK_IMPL_C
+
+#  undef MINBPC
+#  undef BYTE_TYPE
+#  undef BYTE_TO_ASCII
+#  undef CHAR_MATCHES
+#  undef IS_NAME_CHAR
+#  undef IS_NAME_CHAR_MINBPC
+#  undef IS_NMSTRT_CHAR
+#  undef IS_NMSTRT_CHAR_MINBPC
+#  undef IS_INVALID_CHAR
+
+#endif /* not XML_MIN_SIZE */
+
+#ifdef XML_NS
+
+static const struct normal_encoding little2_encoding_ns
+    = {{VTABLE, 2, 0,
+#  if BYTEORDER == 1234
+        1
+#  else
+        0
+#  endif
+       },
+       {
+#  include "asciitab.h"
+#  include "latin1tab.h"
+       },
+       STANDARD_VTABLE(little2_) NULL_VTABLE};
+
+#endif
+
+static const struct normal_encoding little2_encoding
+    = {{VTABLE, 2, 0,
+#if BYTEORDER == 1234
+        1
+#else
+        0
+#endif
+       },
+       {
+#define BT_COLON BT_NMSTRT
+#include "asciitab.h"
+#undef BT_COLON
+#include "latin1tab.h"
+       },
+       STANDARD_VTABLE(little2_) NULL_VTABLE};
+
+#if BYTEORDER != 4321
+
+#  ifdef XML_NS
+
+static const struct normal_encoding internal_little2_encoding_ns
+    = {{VTABLE, 2, 0, 1},
+       {
+#    include "iasciitab.h"
+#    include "latin1tab.h"
+       },
+       STANDARD_VTABLE(little2_) NULL_VTABLE};
+
+#  endif
+
+static const struct normal_encoding internal_little2_encoding
+    = {{VTABLE, 2, 0, 1},
+       {
+#  define BT_COLON BT_NMSTRT
+#  include "iasciitab.h"
+#  undef BT_COLON
+#  include "latin1tab.h"
+       },
+       STANDARD_VTABLE(little2_) NULL_VTABLE};
+
+#endif
+
+#define BIG2_BYTE_TYPE(enc, p)                                                 \
+  ((p)[0] == 0 ? SB_BYTE_TYPE(enc, p + 1) : unicode_byte_type((p)[0], (p)[1]))
+#define BIG2_BYTE_TO_ASCII(p) ((p)[0] == 0 ? (p)[1] : -1)
+#define BIG2_CHAR_MATCHES(p, c) ((p)[0] == 0 && (p)[1] == (c))
+#define BIG2_IS_NAME_CHAR_MINBPC(p)                                            \
+  UCS2_GET_NAMING(namePages, (unsigned char)p[0], (unsigned char)p[1])
+#define BIG2_IS_NMSTRT_CHAR_MINBPC(p)                                          \
+  UCS2_GET_NAMING(nmstrtPages, (unsigned char)p[0], (unsigned char)p[1])
+
+#ifdef XML_MIN_SIZE
+
+static int PTRFASTCALL
+big2_byteType(const ENCODING *enc, const char *p) {
+  return BIG2_BYTE_TYPE(enc, p);
+}
+
+static int PTRFASTCALL
+big2_byteToAscii(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return BIG2_BYTE_TO_ASCII(p);
+}
+
+static int PTRCALL
+big2_charMatches(const ENCODING *enc, const char *p, int c) {
+  UNUSED_P(enc);
+  return BIG2_CHAR_MATCHES(p, c);
+}
+
+static int PTRFASTCALL
+big2_isNameMin(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return BIG2_IS_NAME_CHAR_MINBPC(p);
+}
+
+static int PTRFASTCALL
+big2_isNmstrtMin(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return BIG2_IS_NMSTRT_CHAR_MINBPC(p);
+}
+
+#  undef VTABLE
+#  define VTABLE VTABLE1, big2_toUtf8, big2_toUtf16
+
+#else /* not XML_MIN_SIZE */
+
+#  undef PREFIX
+#  define PREFIX(ident) big2_##ident
+#  define MINBPC(enc) 2
+/* CHAR_MATCHES is guaranteed to have MINBPC bytes available. */
+#  define BYTE_TYPE(enc, p) BIG2_BYTE_TYPE(enc, p)
+#  define BYTE_TO_ASCII(enc, p) BIG2_BYTE_TO_ASCII(p)
+#  define CHAR_MATCHES(enc, p, c) BIG2_CHAR_MATCHES(p, c)
+#  define IS_NAME_CHAR(enc, p, n) 0
+#  define IS_NAME_CHAR_MINBPC(enc, p) BIG2_IS_NAME_CHAR_MINBPC(p)
+#  define IS_NMSTRT_CHAR(enc, p, n) (0)
+#  define IS_NMSTRT_CHAR_MINBPC(enc, p) BIG2_IS_NMSTRT_CHAR_MINBPC(p)
+
+#  define XML_TOK_IMPL_C
+#  include "xmltok_impl.c"
+#  undef XML_TOK_IMPL_C
+
+#  undef MINBPC
+#  undef BYTE_TYPE
+#  undef BYTE_TO_ASCII
+#  undef CHAR_MATCHES
+#  undef IS_NAME_CHAR
+#  undef IS_NAME_CHAR_MINBPC
+#  undef IS_NMSTRT_CHAR
+#  undef IS_NMSTRT_CHAR_MINBPC
+#  undef IS_INVALID_CHAR
+
+#endif /* not XML_MIN_SIZE */
+
+#ifdef XML_NS
+
+static const struct normal_encoding big2_encoding_ns
+    = {{VTABLE, 2, 0,
+#  if BYTEORDER == 4321
+        1
+#  else
+        0
+#  endif
+       },
+       {
+#  include "asciitab.h"
+#  include "latin1tab.h"
+       },
+       STANDARD_VTABLE(big2_) NULL_VTABLE};
+
+#endif
+
+static const struct normal_encoding big2_encoding
+    = {{VTABLE, 2, 0,
+#if BYTEORDER == 4321
+        1
+#else
+        0
+#endif
+       },
+       {
+#define BT_COLON BT_NMSTRT
+#include "asciitab.h"
+#undef BT_COLON
+#include "latin1tab.h"
+       },
+       STANDARD_VTABLE(big2_) NULL_VTABLE};
+
+#if BYTEORDER != 1234
+
+#  ifdef XML_NS
+
+static const struct normal_encoding internal_big2_encoding_ns
+    = {{VTABLE, 2, 0, 1},
+       {
+#    include "iasciitab.h"
+#    include "latin1tab.h"
+       },
+       STANDARD_VTABLE(big2_) NULL_VTABLE};
+
+#  endif
+
+static const struct normal_encoding internal_big2_encoding
+    = {{VTABLE, 2, 0, 1},
+       {
+#  define BT_COLON BT_NMSTRT
+#  include "iasciitab.h"
+#  undef BT_COLON
+#  include "latin1tab.h"
+       },
+       STANDARD_VTABLE(big2_) NULL_VTABLE};
+
+#endif
+
+#undef PREFIX
+
+static int FASTCALL
+streqci(const char *s1, const char *s2) {
+  for (;;) {
+    char c1 = *s1++;
+    char c2 = *s2++;
+    if (ASCII_a <= c1 && c1 <= ASCII_z)
+      c1 += ASCII_A - ASCII_a;
+    if (ASCII_a <= c2 && c2 <= ASCII_z)
+      /* The following line will never get executed.  streqci() is
+       * only called from two places, both of which guarantee to put
+       * upper-case strings into s2.
+       */
+      c2 += ASCII_A - ASCII_a; /* LCOV_EXCL_LINE */
+    if (c1 != c2)
+      return 0;
+    if (! c1)
+      break;
+  }
+  return 1;
+}
+
+static void PTRCALL
+initUpdatePosition(const ENCODING *enc, const char *ptr, const char *end,
+                   POSITION *pos) {
+  UNUSED_P(enc);
+  normal_updatePosition(&utf8_encoding.enc, ptr, end, pos);
+}
+
+static int
+toAscii(const ENCODING *enc, const char *ptr, const char *end) {
+  char buf[1];
+  char *p = buf;
+  XmlUtf8Convert(enc, &ptr, end, &p, p + 1);
+  if (p == buf)
+    return -1;
+  else
+    return buf[0];
+}
+
+static int FASTCALL
+isSpace(int c) {
+  switch (c) {
+  case 0x20:
+  case 0xD:
+  case 0xA:
+  case 0x9:
+    return 1;
+  }
+  return 0;
+}
+
+/* Return 1 if there's just optional white space or there's an S
+   followed by name=val.
+*/
+static int
+parsePseudoAttribute(const ENCODING *enc, const char *ptr, const char *end,
+                     const char **namePtr, const char **nameEndPtr,
+                     const char **valPtr, const char **nextTokPtr) {
+  int c;
+  char open;
+  if (ptr == end) {
+    *namePtr = NULL;
+    return 1;
+  }
+  if (! isSpace(toAscii(enc, ptr, end))) {
+    *nextTokPtr = ptr;
+    return 0;
+  }
+  do {
+    ptr += enc->minBytesPerChar;
+  } while (isSpace(toAscii(enc, ptr, end)));
+  if (ptr == end) {
+    *namePtr = NULL;
+    return 1;
+  }
+  *namePtr = ptr;
+  for (;;) {
+    c = toAscii(enc, ptr, end);
+    if (c == -1) {
+      *nextTokPtr = ptr;
+      return 0;
+    }
+    if (c == ASCII_EQUALS) {
+      *nameEndPtr = ptr;
+      break;
+    }
+    if (isSpace(c)) {
+      *nameEndPtr = ptr;
+      do {
+        ptr += enc->minBytesPerChar;
+      } while (isSpace(c = toAscii(enc, ptr, end)));
+      if (c != ASCII_EQUALS) {
+        *nextTokPtr = ptr;
+        return 0;
+      }
+      break;
+    }
+    ptr += enc->minBytesPerChar;
+  }
+  if (ptr == *namePtr) {
+    *nextTokPtr = ptr;
+    return 0;
+  }
+  ptr += enc->minBytesPerChar;
+  c = toAscii(enc, ptr, end);
+  while (isSpace(c)) {
+    ptr += enc->minBytesPerChar;
+    c = toAscii(enc, ptr, end);
+  }
+  if (c != ASCII_QUOT && c != ASCII_APOS) {
+    *nextTokPtr = ptr;
+    return 0;
+  }
+  open = (char)c;
+  ptr += enc->minBytesPerChar;
+  *valPtr = ptr;
+  for (;; ptr += enc->minBytesPerChar) {
+    c = toAscii(enc, ptr, end);
+    if (c == open)
+      break;
+    if (! (ASCII_a <= c && c <= ASCII_z) && ! (ASCII_A <= c && c <= ASCII_Z)
+        && ! (ASCII_0 <= c && c <= ASCII_9) && c != ASCII_PERIOD
+        && c != ASCII_MINUS && c != ASCII_UNDERSCORE) {
+      *nextTokPtr = ptr;
+      return 0;
+    }
+  }
+  *nextTokPtr = ptr + enc->minBytesPerChar;
+  return 1;
+}
+
+static const char KW_version[]
+    = {ASCII_v, ASCII_e, ASCII_r, ASCII_s, ASCII_i, ASCII_o, ASCII_n, '\0'};
+
+static const char KW_encoding[] = {ASCII_e, ASCII_n, ASCII_c, ASCII_o, ASCII_d,
+                                   ASCII_i, ASCII_n, ASCII_g, '\0'};
+
+static const char KW_standalone[]
+    = {ASCII_s, ASCII_t, ASCII_a, ASCII_n, ASCII_d, ASCII_a,
+       ASCII_l, ASCII_o, ASCII_n, ASCII_e, '\0'};
+
+static const char KW_yes[] = {ASCII_y, ASCII_e, ASCII_s, '\0'};
+
+static const char KW_no[] = {ASCII_n, ASCII_o, '\0'};
+
+static int
+doParseXmlDecl(const ENCODING *(*encodingFinder)(const ENCODING *, const char *,
+                                                 const char *),
+               int isGeneralTextEntity, const ENCODING *enc, const char *ptr,
+               const char *end, const char **badPtr, const char **versionPtr,
+               const char **versionEndPtr, const char **encodingName,
+               const ENCODING **encoding, int *standalone) {
+  const char *val = NULL;
+  const char *name = NULL;
+  const char *nameEnd = NULL;
+  ptr += 5 * enc->minBytesPerChar;
+  end -= 2 * enc->minBytesPerChar;
+  if (! parsePseudoAttribute(enc, ptr, end, &name, &nameEnd, &val, &ptr)
+      || ! name) {
+    *badPtr = ptr;
+    return 0;
+  }
+  if (! XmlNameMatchesAscii(enc, name, nameEnd, KW_version)) {
+    if (! isGeneralTextEntity) {
+      *badPtr = name;
+      return 0;
+    }
+  } else {
+    if (versionPtr)
+      *versionPtr = val;
+    if (versionEndPtr)
+      *versionEndPtr = ptr;
+    if (! parsePseudoAttribute(enc, ptr, end, &name, &nameEnd, &val, &ptr)) {
+      *badPtr = ptr;
+      return 0;
+    }
+    if (! name) {
+      if (isGeneralTextEntity) {
+        /* a TextDecl must have an EncodingDecl */
+        *badPtr = ptr;
+        return 0;
+      }
+      return 1;
+    }
+  }
+  if (XmlNameMatchesAscii(enc, name, nameEnd, KW_encoding)) {
+    int c = toAscii(enc, val, end);
+    if (! (ASCII_a <= c && c <= ASCII_z) && ! (ASCII_A <= c && c <= ASCII_Z)) {
+      *badPtr = val;
+      return 0;
+    }
+    if (encodingName)
+      *encodingName = val;
+    if (encoding)
+      *encoding = encodingFinder(enc, val, ptr - enc->minBytesPerChar);
+    if (! parsePseudoAttribute(enc, ptr, end, &name, &nameEnd, &val, &ptr)) {
+      *badPtr = ptr;
+      return 0;
+    }
+    if (! name)
+      return 1;
+  }
+  if (! XmlNameMatchesAscii(enc, name, nameEnd, KW_standalone)
+      || isGeneralTextEntity) {
+    *badPtr = name;
+    return 0;
+  }
+  if (XmlNameMatchesAscii(enc, val, ptr - enc->minBytesPerChar, KW_yes)) {
+    if (standalone)
+      *standalone = 1;
+  } else if (XmlNameMatchesAscii(enc, val, ptr - enc->minBytesPerChar, KW_no)) {
+    if (standalone)
+      *standalone = 0;
+  } else {
+    *badPtr = val;
+    return 0;
+  }
+  while (isSpace(toAscii(enc, ptr, end)))
+    ptr += enc->minBytesPerChar;
+  if (ptr != end) {
+    *badPtr = ptr;
+    return 0;
+  }
+  return 1;
+}
+
+static int FASTCALL
+checkCharRefNumber(int result) {
+  switch (result >> 8) {
+  case 0xD8:
+  case 0xD9:
+  case 0xDA:
+  case 0xDB:
+  case 0xDC:
+  case 0xDD:
+  case 0xDE:
+  case 0xDF:
+    return -1;
+  case 0:
+    if (latin1_encoding.type[result] == BT_NONXML)
+      return -1;
+    break;
+  case 0xFF:
+    if (result == 0xFFFE || result == 0xFFFF)
+      return -1;
+    break;
+  }
+  return result;
+}
+
+int FASTCALL
+XmlUtf8Encode(int c, char *buf) {
+  enum {
+    /* minN is minimum legal resulting value for N byte sequence */
+    min2 = 0x80,
+    min3 = 0x800,
+    min4 = 0x10000
+  };
+
+  if (c < 0)
+    return 0; /* LCOV_EXCL_LINE: this case is always eliminated beforehand */
+  if (c < min2) {
+    buf[0] = (char)(c | UTF8_cval1);
+    return 1;
+  }
+  if (c < min3) {
+    buf[0] = (char)((c >> 6) | UTF8_cval2);
+    buf[1] = (char)((c & 0x3f) | 0x80);
+    return 2;
+  }
+  if (c < min4) {
+    buf[0] = (char)((c >> 12) | UTF8_cval3);
+    buf[1] = (char)(((c >> 6) & 0x3f) | 0x80);
+    buf[2] = (char)((c & 0x3f) | 0x80);
+    return 3;
+  }
+  if (c < 0x110000) {
+    buf[0] = (char)((c >> 18) | UTF8_cval4);
+    buf[1] = (char)(((c >> 12) & 0x3f) | 0x80);
+    buf[2] = (char)(((c >> 6) & 0x3f) | 0x80);
+    buf[3] = (char)((c & 0x3f) | 0x80);
+    return 4;
+  }
+  return 0; /* LCOV_EXCL_LINE: this case too is eliminated before calling */
+}
+
+int FASTCALL
+XmlUtf16Encode(int charNum, unsigned short *buf) {
+  if (charNum < 0)
+    return 0;
+  if (charNum < 0x10000) {
+    buf[0] = (unsigned short)charNum;
+    return 1;
+  }
+  if (charNum < 0x110000) {
+    charNum -= 0x10000;
+    buf[0] = (unsigned short)((charNum >> 10) + 0xD800);
+    buf[1] = (unsigned short)((charNum & 0x3FF) + 0xDC00);
+    return 2;
+  }
+  return 0;
+}
+
+struct unknown_encoding {
+  struct normal_encoding normal;
+  CONVERTER convert;
+  void *userData;
+  unsigned short utf16[256];
+  char utf8[256][4];
+};
+
+#define AS_UNKNOWN_ENCODING(enc) ((const struct unknown_encoding *)(enc))
+
+int
+XmlSizeOfUnknownEncoding(void) {
+  return sizeof(struct unknown_encoding);
+}
+
+static int PTRFASTCALL
+unknown_isName(const ENCODING *enc, const char *p) {
+  const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
+  int c = uenc->convert(uenc->userData, p);
+  if (c & ~0xFFFF)
+    return 0;
+  return UCS2_GET_NAMING(namePages, c >> 8, c & 0xFF);
+}
+
+static int PTRFASTCALL
+unknown_isNmstrt(const ENCODING *enc, const char *p) {
+  const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
+  int c = uenc->convert(uenc->userData, p);
+  if (c & ~0xFFFF)
+    return 0;
+  return UCS2_GET_NAMING(nmstrtPages, c >> 8, c & 0xFF);
+}
+
+static int PTRFASTCALL
+unknown_isInvalid(const ENCODING *enc, const char *p) {
+  const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
+  int c = uenc->convert(uenc->userData, p);
+  return (c & ~0xFFFF) || checkCharRefNumber(c) < 0;
+}
+
+static enum XML_Convert_Result PTRCALL
+unknown_toUtf8(const ENCODING *enc, const char **fromP, const char *fromLim,
+               char **toP, const char *toLim) {
+  const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
+  char buf[XML_UTF8_ENCODE_MAX];
+  for (;;) {
+    const char *utf8;
+    int n;
+    if (*fromP == fromLim)
+      return XML_CONVERT_COMPLETED;
+    utf8 = uenc->utf8[(unsigned char)**fromP];
+    n = *utf8++;
+    if (n == 0) {
+      int c = uenc->convert(uenc->userData, *fromP);
+      n = XmlUtf8Encode(c, buf);
+      if (n > toLim - *toP)
+        return XML_CONVERT_OUTPUT_EXHAUSTED;
+      utf8 = buf;
+      *fromP += (AS_NORMAL_ENCODING(enc)->type[(unsigned char)**fromP]
+                 - (BT_LEAD2 - 2));
+    } else {
+      if (n > toLim - *toP)
+        return XML_CONVERT_OUTPUT_EXHAUSTED;
+      (*fromP)++;
+    }
+    memcpy(*toP, utf8, n);
+    *toP += n;
+  }
+}
+
+static enum XML_Convert_Result PTRCALL
+unknown_toUtf16(const ENCODING *enc, const char **fromP, const char *fromLim,
+                unsigned short **toP, const unsigned short *toLim) {
+  const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
+  while (*fromP < fromLim && *toP < toLim) {
+    unsigned short c = uenc->utf16[(unsigned char)**fromP];
+    if (c == 0) {
+      c = (unsigned short)uenc->convert(uenc->userData, *fromP);
+      *fromP += (AS_NORMAL_ENCODING(enc)->type[(unsigned char)**fromP]
+                 - (BT_LEAD2 - 2));
+    } else
+      (*fromP)++;
+    *(*toP)++ = c;
+  }
+
+  if ((*toP == toLim) && (*fromP < fromLim))
+    return XML_CONVERT_OUTPUT_EXHAUSTED;
+  else
+    return XML_CONVERT_COMPLETED;
+}
+
+ENCODING *
+XmlInitUnknownEncoding(void *mem, int *table, CONVERTER convert,
+                       void *userData) {
+  int i;
+  struct unknown_encoding *e = (struct unknown_encoding *)mem;
+  memcpy(mem, &latin1_encoding, sizeof(struct normal_encoding));
+  for (i = 0; i < 128; i++)
+    if (latin1_encoding.type[i] != BT_OTHER
+        && latin1_encoding.type[i] != BT_NONXML && table[i] != i)
+      return 0;
+  for (i = 0; i < 256; i++) {
+    int c = table[i];
+    if (c == -1) {
+      e->normal.type[i] = BT_MALFORM;
+      /* This shouldn't really get used. */
+      e->utf16[i] = 0xFFFF;
+      e->utf8[i][0] = 1;
+      e->utf8[i][1] = 0;
+    } else if (c < 0) {
+      if (c < -4)
+        return 0;
+      /* Multi-byte sequences need a converter function */
+      if (! convert)
+        return 0;
+      e->normal.type[i] = (unsigned char)(BT_LEAD2 - (c + 2));
+      e->utf8[i][0] = 0;
+      e->utf16[i] = 0;
+    } else if (c < 0x80) {
+      if (latin1_encoding.type[c] != BT_OTHER
+          && latin1_encoding.type[c] != BT_NONXML && c != i)
+        return 0;
+      e->normal.type[i] = latin1_encoding.type[c];
+      e->utf8[i][0] = 1;
+      e->utf8[i][1] = (char)c;
+      e->utf16[i] = (unsigned short)(c == 0 ? 0xFFFF : c);
+    } else if (checkCharRefNumber(c) < 0) {
+      e->normal.type[i] = BT_NONXML;
+      /* This shouldn't really get used. */
+      e->utf16[i] = 0xFFFF;
+      e->utf8[i][0] = 1;
+      e->utf8[i][1] = 0;
+    } else {
+      if (c > 0xFFFF)
+        return 0;
+      if (UCS2_GET_NAMING(nmstrtPages, c >> 8, c & 0xff))
+        e->normal.type[i] = BT_NMSTRT;
+      else if (UCS2_GET_NAMING(namePages, c >> 8, c & 0xff))
+        e->normal.type[i] = BT_NAME;
+      else
+        e->normal.type[i] = BT_OTHER;
+      e->utf8[i][0] = (char)XmlUtf8Encode(c, e->utf8[i] + 1);
+      e->utf16[i] = (unsigned short)c;
+    }
+  }
+  e->userData = userData;
+  e->convert = convert;
+  if (convert) {
+    e->normal.isName2 = unknown_isName;
+    e->normal.isName3 = unknown_isName;
+    e->normal.isName4 = unknown_isName;
+    e->normal.isNmstrt2 = unknown_isNmstrt;
+    e->normal.isNmstrt3 = unknown_isNmstrt;
+    e->normal.isNmstrt4 = unknown_isNmstrt;
+    e->normal.isInvalid2 = unknown_isInvalid;
+    e->normal.isInvalid3 = unknown_isInvalid;
+    e->normal.isInvalid4 = unknown_isInvalid;
+  }
+  e->normal.enc.utf8Convert = unknown_toUtf8;
+  e->normal.enc.utf16Convert = unknown_toUtf16;
+  return &(e->normal.enc);
+}
+
+/* If this enumeration is changed, getEncodingIndex and encodings
+must also be changed. */
+enum {
+  UNKNOWN_ENC = -1,
+  ISO_8859_1_ENC = 0,
+  US_ASCII_ENC,
+  UTF_8_ENC,
+  UTF_16_ENC,
+  UTF_16BE_ENC,
+  UTF_16LE_ENC,
+  /* must match encodingNames up to here */
+  NO_ENC
+};
+
+static const char KW_ISO_8859_1[]
+    = {ASCII_I, ASCII_S, ASCII_O,     ASCII_MINUS, ASCII_8, ASCII_8,
+       ASCII_5, ASCII_9, ASCII_MINUS, ASCII_1,     '\0'};
+static const char KW_US_ASCII[]
+    = {ASCII_U, ASCII_S, ASCII_MINUS, ASCII_A, ASCII_S,
+       ASCII_C, ASCII_I, ASCII_I,     '\0'};
+static const char KW_UTF_8[]
+    = {ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_8, '\0'};
+static const char KW_UTF_16[]
+    = {ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_1, ASCII_6, '\0'};
+static const char KW_UTF_16BE[]
+    = {ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_1,
+       ASCII_6, ASCII_B, ASCII_E, '\0'};
+static const char KW_UTF_16LE[]
+    = {ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_1,
+       ASCII_6, ASCII_L, ASCII_E, '\0'};
+
+static int FASTCALL
+getEncodingIndex(const char *name) {
+  static const char *const encodingNames[] = {
+      KW_ISO_8859_1, KW_US_ASCII, KW_UTF_8, KW_UTF_16, KW_UTF_16BE, KW_UTF_16LE,
+  };
+  int i;
+  if (name == NULL)
+    return NO_ENC;
+  for (i = 0; i < (int)(sizeof(encodingNames) / sizeof(encodingNames[0])); i++)
+    if (streqci(name, encodingNames[i]))
+      return i;
+  return UNKNOWN_ENC;
+}
+
+/* For binary compatibility, we store the index of the encoding
+   specified at initialization in the isUtf16 member.
+*/
+
+#define INIT_ENC_INDEX(enc) ((int)(enc)->initEnc.isUtf16)
+#define SET_INIT_ENC_INDEX(enc, i) ((enc)->initEnc.isUtf16 = (char)i)
+
+/* This is what detects the encoding.  encodingTable maps from
+   encoding indices to encodings; INIT_ENC_INDEX(enc) is the index of
+   the external (protocol) specified encoding; state is
+   XML_CONTENT_STATE if we're parsing an external text entity, and
+   XML_PROLOG_STATE otherwise.
+*/
+
+static int
+initScan(const ENCODING *const *encodingTable, const INIT_ENCODING *enc,
+         int state, const char *ptr, const char *end, const char **nextTokPtr) {
+  const ENCODING **encPtr;
+
+  if (ptr >= end)
+    return XML_TOK_NONE;
+  encPtr = enc->encPtr;
+  if (ptr + 1 == end) {
+    /* only a single byte available for auto-detection */
+#ifndef XML_DTD /* FIXME */
+    /* a well-formed document entity must have more than one byte */
+    if (state != XML_CONTENT_STATE)
+      return XML_TOK_PARTIAL;
+#endif
+    /* so we're parsing an external text entity... */
+    /* if UTF-16 was externally specified, then we need at least 2 bytes */
+    switch (INIT_ENC_INDEX(enc)) {
+    case UTF_16_ENC:
+    case UTF_16LE_ENC:
+    case UTF_16BE_ENC:
+      return XML_TOK_PARTIAL;
+    }
+    switch ((unsigned char)*ptr) {
+    case 0xFE:
+    case 0xFF:
+    case 0xEF: /* possibly first byte of UTF-8 BOM */
+      if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC && state == XML_CONTENT_STATE)
+        break;
+      /* fall through */
+    case 0x00:
+    case 0x3C:
+      return XML_TOK_PARTIAL;
+    }
+  } else {
+    switch (((unsigned char)ptr[0] << 8) | (unsigned char)ptr[1]) {
+    case 0xFEFF:
+      if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC && state == XML_CONTENT_STATE)
+        break;
+      *nextTokPtr = ptr + 2;
+      *encPtr = encodingTable[UTF_16BE_ENC];
+      return XML_TOK_BOM;
+    /* 00 3C is handled in the default case */
+    case 0x3C00:
+      if ((INIT_ENC_INDEX(enc) == UTF_16BE_ENC
+           || INIT_ENC_INDEX(enc) == UTF_16_ENC)
+          && state == XML_CONTENT_STATE)
+        break;
+      *encPtr = encodingTable[UTF_16LE_ENC];
+      return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
+    case 0xFFFE:
+      if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC && state == XML_CONTENT_STATE)
+        break;
+      *nextTokPtr = ptr + 2;
+      *encPtr = encodingTable[UTF_16LE_ENC];
+      return XML_TOK_BOM;
+    case 0xEFBB:
+      /* Maybe a UTF-8 BOM (EF BB BF) */
+      /* If there's an explicitly specified (external) encoding
+         of ISO-8859-1 or some flavour of UTF-16
+         and this is an external text entity,
+         don't look for the BOM,
+         because it might be a legal data.
+      */
+      if (state == XML_CONTENT_STATE) {
+        int e = INIT_ENC_INDEX(enc);
+        if (e == ISO_8859_1_ENC || e == UTF_16BE_ENC || e == UTF_16LE_ENC
+            || e == UTF_16_ENC)
+          break;
+      }
+      if (ptr + 2 == end)
+        return XML_TOK_PARTIAL;
+      if ((unsigned char)ptr[2] == 0xBF) {
+        *nextTokPtr = ptr + 3;
+        *encPtr = encodingTable[UTF_8_ENC];
+        return XML_TOK_BOM;
+      }
+      break;
+    default:
+      if (ptr[0] == '\0') {
+        /* 0 isn't a legal data character. Furthermore a document
+           entity can only start with ASCII characters.  So the only
+           way this can fail to be big-endian UTF-16 if it it's an
+           external parsed general entity that's labelled as
+           UTF-16LE.
+        */
+        if (state == XML_CONTENT_STATE && INIT_ENC_INDEX(enc) == UTF_16LE_ENC)
+          break;
+        *encPtr = encodingTable[UTF_16BE_ENC];
+        return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
+      } else if (ptr[1] == '\0') {
+        /* We could recover here in the case:
+            - parsing an external entity
+            - second byte is 0
+            - no externally specified encoding
+            - no encoding declaration
+           by assuming UTF-16LE.  But we don't, because this would mean when
+           presented just with a single byte, we couldn't reliably determine
+           whether we needed further bytes.
+        */
+        if (state == XML_CONTENT_STATE)
+          break;
+        *encPtr = encodingTable[UTF_16LE_ENC];
+        return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
+      }
+      break;
+    }
+  }
+  *encPtr = encodingTable[INIT_ENC_INDEX(enc)];
+  return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
+}
+
+#define NS(x) x
+#define ns(x) x
+#define XML_TOK_NS_C
+#include "xmltok_ns.c"
+#undef XML_TOK_NS_C
+#undef NS
+#undef ns
+
+#ifdef XML_NS
+
+#  define NS(x) x##NS
+#  define ns(x) x##_ns
+
+#  define XML_TOK_NS_C
+#  include "xmltok_ns.c"
+#  undef XML_TOK_NS_C
+
+#  undef NS
+#  undef ns
+
+ENCODING *
+XmlInitUnknownEncodingNS(void *mem, int *table, CONVERTER convert,
+                         void *userData) {
+  ENCODING *enc = XmlInitUnknownEncoding(mem, table, convert, userData);
+  if (enc)
+    ((struct normal_encoding *)enc)->type[ASCII_COLON] = BT_COLON;
+  return enc;
+}
+
+#endif /* XML_NS */
+
+#endif /* LV_USE_XML */
+
diff --git a/src/libs/expat/xmltok.h b/src/libs/expat/xmltok.h
new file mode 100644
index 000000000..5690b0b5f
--- /dev/null
+++ b/src/libs/expat/xmltok.h
@@ -0,0 +1,327 @@
+/*
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2002      Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
+   Copyright (c) 2002-2005 Karl Waclawek <karl@waclawek.net>
+   Copyright (c) 2016-2024 Sebastian Pipping <sebastian@pipping.org>
+   Copyright (c) 2017      Rhodri James <rhodri@wildebeest.org.uk>
+   Licensed under the MIT license:
+
+   Permission is  hereby granted,  free of charge,  to any  person obtaining
+   a  copy  of  this  software   and  associated  documentation  files  (the
+   "Software"),  to  deal in  the  Software  without restriction,  including
+   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
+   distribute, sublicense, and/or sell copies of the Software, and to permit
+   persons  to whom  the Software  is  furnished to  do so,  subject to  the
+   following conditions:
+
+   The above copyright  notice and this permission notice  shall be included
+   in all copies or substantial portions of the Software.
+
+   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
+   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
+   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+   USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include "../../lv_conf_internal.h"
+#if LV_USE_XML
+
+#ifndef XmlTok_INCLUDED
+#define XmlTok_INCLUDED 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* The following token may be returned by XmlContentTok */
+#define XML_TOK_TRAILING_RSQB                                                  \
+  -5 /* ] or ]] at the end of the scan; might be                               \
+        start of illegal ]]> sequence */
+/* The following tokens may be returned by both XmlPrologTok and
+   XmlContentTok.
+*/
+#define XML_TOK_NONE -4 /* The string to be scanned is empty */
+#define XML_TOK_TRAILING_CR                                                    \
+  -3                            /* A CR at the end of the scan;                \
+                                   might be part of CRLF sequence */
+#define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */
+#define XML_TOK_PARTIAL -1      /* only part of a token */
+#define XML_TOK_INVALID 0
+
+/* The following tokens are returned by XmlContentTok; some are also
+   returned by XmlAttributeValueTok, XmlEntityTok, XmlCdataSectionTok.
+*/
+#define XML_TOK_START_TAG_WITH_ATTS 1
+#define XML_TOK_START_TAG_NO_ATTS 2
+#define XML_TOK_EMPTY_ELEMENT_WITH_ATTS 3 /* empty element tag <e/> */
+#define XML_TOK_EMPTY_ELEMENT_NO_ATTS 4
+#define XML_TOK_END_TAG 5
+#define XML_TOK_DATA_CHARS 6
+#define XML_TOK_DATA_NEWLINE 7
+#define XML_TOK_CDATA_SECT_OPEN 8
+#define XML_TOK_ENTITY_REF 9
+#define XML_TOK_CHAR_REF 10 /* numeric character reference */
+
+/* The following tokens may be returned by both XmlPrologTok and
+   XmlContentTok.
+*/
+#define XML_TOK_PI 11       /* processing instruction */
+#define XML_TOK_XML_DECL 12 /* XML decl or text decl */
+#define XML_TOK_COMMENT 13
+#define XML_TOK_BOM 14 /* Byte order mark */
+
+/* The following tokens are returned only by XmlPrologTok */
+#define XML_TOK_PROLOG_S 15
+#define XML_TOK_DECL_OPEN 16  /* <!foo */
+#define XML_TOK_DECL_CLOSE 17 /* > */
+#define XML_TOK_NAME 18
+#define XML_TOK_NMTOKEN 19
+#define XML_TOK_POUND_NAME 20 /* #name */
+#define XML_TOK_OR 21         /* | */
+#define XML_TOK_PERCENT 22
+#define XML_TOK_OPEN_PAREN 23
+#define XML_TOK_CLOSE_PAREN 24
+#define XML_TOK_OPEN_BRACKET 25
+#define XML_TOK_CLOSE_BRACKET 26
+#define XML_TOK_LITERAL 27
+#define XML_TOK_PARAM_ENTITY_REF 28
+#define XML_TOK_INSTANCE_START 29
+
+/* The following occur only in element type declarations */
+#define XML_TOK_NAME_QUESTION 30        /* name? */
+#define XML_TOK_NAME_ASTERISK 31        /* name* */
+#define XML_TOK_NAME_PLUS 32            /* name+ */
+#define XML_TOK_COND_SECT_OPEN 33       /* <![ */
+#define XML_TOK_COND_SECT_CLOSE 34      /* ]]> */
+#define XML_TOK_CLOSE_PAREN_QUESTION 35 /* )? */
+#define XML_TOK_CLOSE_PAREN_ASTERISK 36 /* )* */
+#define XML_TOK_CLOSE_PAREN_PLUS 37     /* )+ */
+#define XML_TOK_COMMA 38
+
+/* The following token is returned only by XmlAttributeValueTok */
+#define XML_TOK_ATTRIBUTE_VALUE_S 39
+
+/* The following token is returned only by XmlCdataSectionTok */
+#define XML_TOK_CDATA_SECT_CLOSE 40
+
+/* With namespace processing this is returned by XmlPrologTok for a
+   name with a colon.
+*/
+#define XML_TOK_PREFIXED_NAME 41
+
+#ifdef XML_DTD
+#  define XML_TOK_IGNORE_SECT 42
+#endif /* XML_DTD */
+
+#ifdef XML_DTD
+#  define XML_N_STATES 4
+#else /* not XML_DTD */
+#  define XML_N_STATES 3
+#endif /* not XML_DTD */
+
+#define XML_PROLOG_STATE 0
+#define XML_CONTENT_STATE 1
+#define XML_CDATA_SECTION_STATE 2
+#ifdef XML_DTD
+#  define XML_IGNORE_SECTION_STATE 3
+#endif /* XML_DTD */
+
+#define XML_N_LITERAL_TYPES 2
+#define XML_ATTRIBUTE_VALUE_LITERAL 0
+#define XML_ENTITY_VALUE_LITERAL 1
+
+/* The size of the buffer passed to XmlUtf8Encode must be at least this. */
+#define XML_UTF8_ENCODE_MAX 4
+/* The size of the buffer passed to XmlUtf16Encode must be at least this. */
+#define XML_UTF16_ENCODE_MAX 2
+
+typedef struct position {
+  /* first line and first column are 0 not 1 */
+  XML_Size lineNumber;
+  XML_Size columnNumber;
+} POSITION;
+
+typedef struct {
+  const char *name;
+  const char *valuePtr;
+  const char *valueEnd;
+  char normalized;
+} ATTRIBUTE;
+
+struct encoding;
+typedef struct encoding ENCODING;
+
+typedef int(PTRCALL *SCANNER)(const ENCODING *, const char *, const char *,
+                              const char **);
+
+enum XML_Convert_Result {
+  XML_CONVERT_COMPLETED = 0,
+  XML_CONVERT_INPUT_INCOMPLETE = 1,
+  XML_CONVERT_OUTPUT_EXHAUSTED
+  = 2 /* and therefore potentially input remaining as well */
+};
+
+struct encoding {
+  SCANNER scanners[XML_N_STATES];
+  SCANNER literalScanners[XML_N_LITERAL_TYPES];
+  int(PTRCALL *nameMatchesAscii)(const ENCODING *, const char *, const char *,
+                                 const char *);
+  int(PTRFASTCALL *nameLength)(const ENCODING *, const char *);
+  const char *(PTRFASTCALL *skipS)(const ENCODING *, const char *);
+  int(PTRCALL *getAtts)(const ENCODING *enc, const char *ptr, int attsMax,
+                        ATTRIBUTE *atts);
+  int(PTRFASTCALL *charRefNumber)(const ENCODING *enc, const char *ptr);
+  int(PTRCALL *predefinedEntityName)(const ENCODING *, const char *,
+                                     const char *);
+  void(PTRCALL *updatePosition)(const ENCODING *, const char *ptr,
+                                const char *end, POSITION *);
+  int(PTRCALL *isPublicId)(const ENCODING *enc, const char *ptr,
+                           const char *end, const char **badPtr);
+  enum XML_Convert_Result(PTRCALL *utf8Convert)(const ENCODING *enc,
+                                                const char **fromP,
+                                                const char *fromLim, char **toP,
+                                                const char *toLim);
+  enum XML_Convert_Result(PTRCALL *utf16Convert)(const ENCODING *enc,
+                                                 const char **fromP,
+                                                 const char *fromLim,
+                                                 unsigned short **toP,
+                                                 const unsigned short *toLim);
+  int minBytesPerChar;
+  char isUtf8;
+  char isUtf16;
+};
+
+/* Scan the string starting at ptr until the end of the next complete
+   token, but do not scan past eptr.  Return an integer giving the
+   type of token.
+
+   Return XML_TOK_NONE when ptr == eptr; nextTokPtr will not be set.
+
+   Return XML_TOK_PARTIAL when the string does not contain a complete
+   token; nextTokPtr will not be set.
+
+   Return XML_TOK_INVALID when the string does not start a valid
+   token; nextTokPtr will be set to point to the character which made
+   the token invalid.
+
+   Otherwise the string starts with a valid token; nextTokPtr will be
+   set to point to the character following the end of that token.
+
+   Each data character counts as a single token, but adjacent data
+   characters may be returned together.  Similarly for characters in
+   the prolog outside literals, comments and processing instructions.
+*/
+
+#define XmlTok(enc, state, ptr, end, nextTokPtr)                               \
+  (((enc)->scanners[state])(enc, ptr, end, nextTokPtr))
+
+#define XmlPrologTok(enc, ptr, end, nextTokPtr)                                \
+  XmlTok(enc, XML_PROLOG_STATE, ptr, end, nextTokPtr)
+
+#define XmlContentTok(enc, ptr, end, nextTokPtr)                               \
+  XmlTok(enc, XML_CONTENT_STATE, ptr, end, nextTokPtr)
+
+#define XmlCdataSectionTok(enc, ptr, end, nextTokPtr)                          \
+  XmlTok(enc, XML_CDATA_SECTION_STATE, ptr, end, nextTokPtr)
+
+#ifdef XML_DTD
+
+#  define XmlIgnoreSectionTok(enc, ptr, end, nextTokPtr)                       \
+    XmlTok(enc, XML_IGNORE_SECTION_STATE, ptr, end, nextTokPtr)
+
+#endif /* XML_DTD */
+
+/* This is used for performing a 2nd-level tokenization on the content
+   of a literal that has already been returned by XmlTok.
+*/
+#define XmlLiteralTok(enc, literalType, ptr, end, nextTokPtr)                  \
+  (((enc)->literalScanners[literalType])(enc, ptr, end, nextTokPtr))
+
+#define XmlAttributeValueTok(enc, ptr, end, nextTokPtr)                        \
+  XmlLiteralTok(enc, XML_ATTRIBUTE_VALUE_LITERAL, ptr, end, nextTokPtr)
+
+#define XmlEntityValueTok(enc, ptr, end, nextTokPtr)                           \
+  XmlLiteralTok(enc, XML_ENTITY_VALUE_LITERAL, ptr, end, nextTokPtr)
+
+#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2)                             \
+  (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2))
+
+#define XmlNameLength(enc, ptr) (((enc)->nameLength)(enc, ptr))
+
+#define XmlSkipS(enc, ptr) (((enc)->skipS)(enc, ptr))
+
+#define XmlGetAttributes(enc, ptr, attsMax, atts)                              \
+  (((enc)->getAtts)(enc, ptr, attsMax, atts))
+
+#define XmlCharRefNumber(enc, ptr) (((enc)->charRefNumber)(enc, ptr))
+
+#define XmlPredefinedEntityName(enc, ptr, end)                                 \
+  (((enc)->predefinedEntityName)(enc, ptr, end))
+
+#define XmlUpdatePosition(enc, ptr, end, pos)                                  \
+  (((enc)->updatePosition)(enc, ptr, end, pos))
+
+#define XmlIsPublicId(enc, ptr, end, badPtr)                                   \
+  (((enc)->isPublicId)(enc, ptr, end, badPtr))
+
+#define XmlUtf8Convert(enc, fromP, fromLim, toP, toLim)                        \
+  (((enc)->utf8Convert)(enc, fromP, fromLim, toP, toLim))
+
+#define XmlUtf16Convert(enc, fromP, fromLim, toP, toLim)                       \
+  (((enc)->utf16Convert)(enc, fromP, fromLim, toP, toLim))
+
+typedef struct {
+  ENCODING initEnc;
+  const ENCODING **encPtr;
+} INIT_ENCODING;
+
+int XmlParseXmlDecl(int isGeneralTextEntity, const ENCODING *enc,
+                    const char *ptr, const char *end, const char **badPtr,
+                    const char **versionPtr, const char **versionEndPtr,
+                    const char **encodingNamePtr,
+                    const ENCODING **namedEncodingPtr, int *standalonePtr);
+
+int XmlInitEncoding(INIT_ENCODING *p, const ENCODING **encPtr,
+                    const char *name);
+const ENCODING *XmlGetUtf8InternalEncoding(void);
+const ENCODING *XmlGetUtf16InternalEncoding(void);
+int FASTCALL XmlUtf8Encode(int charNumber, char *buf);
+int FASTCALL XmlUtf16Encode(int charNumber, unsigned short *buf);
+int XmlSizeOfUnknownEncoding(void);
+
+typedef int(XMLCALL *CONVERTER)(void *userData, const char *p);
+
+ENCODING *XmlInitUnknownEncoding(void *mem, int *table, CONVERTER convert,
+                                 void *userData);
+
+int XmlParseXmlDeclNS(int isGeneralTextEntity, const ENCODING *enc,
+                      const char *ptr, const char *end, const char **badPtr,
+                      const char **versionPtr, const char **versionEndPtr,
+                      const char **encodingNamePtr,
+                      const ENCODING **namedEncodingPtr, int *standalonePtr);
+
+int XmlInitEncodingNS(INIT_ENCODING *p, const ENCODING **encPtr,
+                      const char *name);
+const ENCODING *XmlGetUtf8InternalEncodingNS(void);
+const ENCODING *XmlGetUtf16InternalEncodingNS(void);
+ENCODING *XmlInitUnknownEncodingNS(void *mem, int *table, CONVERTER convert,
+                                   void *userData);
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* not XmlTok_INCLUDED */
+
+#endif /* LV_USE_XML */
+
diff --git a/src/libs/expat/xmltok_impl.c b/src/libs/expat/xmltok_impl.c
new file mode 100644
index 000000000..85334d8cf
--- /dev/null
+++ b/src/libs/expat/xmltok_impl.c
@@ -0,0 +1,1825 @@
+/* This file is included (from xmltok.c, 1-3 times depending on XML_MIN_SIZE)!
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2002      Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
+   Copyright (c) 2002-2016 Karl Waclawek <karl@waclawek.net>
+   Copyright (c) 2016-2022 Sebastian Pipping <sebastian@pipping.org>
+   Copyright (c) 2017      Rhodri James <rhodri@wildebeest.org.uk>
+   Copyright (c) 2018      Benjamin Peterson <benjamin@python.org>
+   Copyright (c) 2018      Anton Maklakov <antmak.pub@gmail.com>
+   Copyright (c) 2019      David Loffredo <loffredo@steptools.com>
+   Copyright (c) 2020      Boris Kolpackov <boris@codesynthesis.com>
+   Copyright (c) 2022      Martin Ettl <ettl.martin78@googlemail.com>
+   Licensed under the MIT license:
+
+   Permission is  hereby granted,  free of charge,  to any  person obtaining
+   a  copy  of  this  software   and  associated  documentation  files  (the
+   "Software"),  to  deal in  the  Software  without restriction,  including
+   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
+   distribute, sublicense, and/or sell copies of the Software, and to permit
+   persons  to whom  the Software  is  furnished to  do so,  subject to  the
+   following conditions:
+
+   The above copyright  notice and this permission notice  shall be included
+   in all copies or substantial portions of the Software.
+
+   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
+   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
+   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+   USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include "../../lv_conf_internal.h"
+#if LV_USE_XML
+
+#ifdef XML_TOK_IMPL_C
+
+#  ifndef IS_INVALID_CHAR // i.e. for UTF-16 and XML_MIN_SIZE not defined
+#    define IS_INVALID_CHAR(enc, ptr, n) (0)
+#  endif
+
+#  define INVALID_LEAD_CASE(n, ptr, nextTokPtr)                                \
+  case BT_LEAD##n:                                                             \
+    if (end - ptr < n)                                                         \
+      return XML_TOK_PARTIAL_CHAR;                                             \
+    if (IS_INVALID_CHAR(enc, ptr, n)) {                                        \
+      *(nextTokPtr) = (ptr);                                                   \
+      return XML_TOK_INVALID;                                                  \
+    }                                                                          \
+    ptr += n;                                                                  \
+    break;
+
+#  define INVALID_CASES(ptr, nextTokPtr)                                       \
+    INVALID_LEAD_CASE(2, ptr, nextTokPtr)                                      \
+    INVALID_LEAD_CASE(3, ptr, nextTokPtr)                                      \
+    INVALID_LEAD_CASE(4, ptr, nextTokPtr)                                      \
+  case BT_NONXML:                                                              \
+  case BT_MALFORM:                                                             \
+  case BT_TRAIL:                                                               \
+    *(nextTokPtr) = (ptr);                                                     \
+    return XML_TOK_INVALID;
+
+#  define CHECK_NAME_CASE(n, enc, ptr, end, nextTokPtr)                        \
+  case BT_LEAD##n:                                                             \
+    if (end - ptr < n)                                                         \
+      return XML_TOK_PARTIAL_CHAR;                                             \
+    if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) {         \
+      *nextTokPtr = ptr;                                                       \
+      return XML_TOK_INVALID;                                                  \
+    }                                                                          \
+    ptr += n;                                                                  \
+    break;
+
+#  define CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)                          \
+  case BT_NONASCII:                                                            \
+    if (! IS_NAME_CHAR_MINBPC(enc, ptr)) {                                     \
+      *nextTokPtr = ptr;                                                       \
+      return XML_TOK_INVALID;                                                  \
+    }                                                                          \
+    /* fall through */                                                         \
+  case BT_NMSTRT:                                                              \
+  case BT_HEX:                                                                 \
+  case BT_DIGIT:                                                               \
+  case BT_NAME:                                                                \
+  case BT_MINUS:                                                               \
+    ptr += MINBPC(enc);                                                        \
+    break;                                                                     \
+    CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr)                              \
+    CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr)                              \
+    CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr)
+
+#  define CHECK_NMSTRT_CASE(n, enc, ptr, end, nextTokPtr)                      \
+  case BT_LEAD##n:                                                             \
+    if ((end) - (ptr) < (n))                                                   \
+      return XML_TOK_PARTIAL_CHAR;                                             \
+    if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) {       \
+      *nextTokPtr = ptr;                                                       \
+      return XML_TOK_INVALID;                                                  \
+    }                                                                          \
+    ptr += n;                                                                  \
+    break;
+
+#  define CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)                        \
+  case BT_NONASCII:                                                            \
+    if (! IS_NMSTRT_CHAR_MINBPC(enc, ptr)) {                                   \
+      *nextTokPtr = ptr;                                                       \
+      return XML_TOK_INVALID;                                                  \
+    }                                                                          \
+    /* fall through */                                                         \
+  case BT_NMSTRT:                                                              \
+  case BT_HEX:                                                                 \
+    ptr += MINBPC(enc);                                                        \
+    break;                                                                     \
+    CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr)                            \
+    CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr)                            \
+    CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr)
+
+#  ifndef PREFIX
+#    define PREFIX(ident) ident
+#  endif
+
+#  define HAS_CHARS(enc, ptr, end, count)                                      \
+    ((end) - (ptr) >= ((count) * MINBPC(enc)))
+
+#  define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1)
+
+#  define REQUIRE_CHARS(enc, ptr, end, count)                                  \
+    {                                                                          \
+      if (! HAS_CHARS(enc, ptr, end, count)) {                                 \
+        return XML_TOK_PARTIAL;                                                \
+      }                                                                        \
+    }
+
+#  define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1)
+
+/* ptr points to character following "<!-" */
+
+static int PTRCALL
+PREFIX(scanComment)(const ENCODING *enc, const char *ptr, const char *end,
+                    const char **nextTokPtr) {
+  if (HAS_CHAR(enc, ptr, end)) {
+    if (! CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+    ptr += MINBPC(enc);
+    while (HAS_CHAR(enc, ptr, end)) {
+      switch (BYTE_TYPE(enc, ptr)) {
+        INVALID_CASES(ptr, nextTokPtr)
+      case BT_MINUS:
+        ptr += MINBPC(enc);
+        REQUIRE_CHAR(enc, ptr, end);
+        if (CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
+          ptr += MINBPC(enc);
+          REQUIRE_CHAR(enc, ptr, end);
+          if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) {
+            *nextTokPtr = ptr;
+            return XML_TOK_INVALID;
+          }
+          *nextTokPtr = ptr + MINBPC(enc);
+          return XML_TOK_COMMENT;
+        }
+        break;
+      default:
+        ptr += MINBPC(enc);
+        break;
+      }
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+/* ptr points to character following "<!" */
+
+static int PTRCALL
+PREFIX(scanDecl)(const ENCODING *enc, const char *ptr, const char *end,
+                 const char **nextTokPtr) {
+  REQUIRE_CHAR(enc, ptr, end);
+  switch (BYTE_TYPE(enc, ptr)) {
+  case BT_MINUS:
+    return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+  case BT_LSQB:
+    *nextTokPtr = ptr + MINBPC(enc);
+    return XML_TOK_COND_SECT_OPEN;
+  case BT_NMSTRT:
+  case BT_HEX:
+    ptr += MINBPC(enc);
+    break;
+  default:
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  }
+  while (HAS_CHAR(enc, ptr, end)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+    case BT_PERCNT:
+      REQUIRE_CHARS(enc, ptr, end, 2);
+      /* don't allow <!ENTITY% foo "whatever"> */
+      switch (BYTE_TYPE(enc, ptr + MINBPC(enc))) {
+      case BT_S:
+      case BT_CR:
+      case BT_LF:
+      case BT_PERCNT:
+        *nextTokPtr = ptr;
+        return XML_TOK_INVALID;
+      }
+      /* fall through */
+    case BT_S:
+    case BT_CR:
+    case BT_LF:
+      *nextTokPtr = ptr;
+      return XML_TOK_DECL_OPEN;
+    case BT_NMSTRT:
+    case BT_HEX:
+      ptr += MINBPC(enc);
+      break;
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+static int PTRCALL
+PREFIX(checkPiTarget)(const ENCODING *enc, const char *ptr, const char *end,
+                      int *tokPtr) {
+  int upper = 0;
+  UNUSED_P(enc);
+  *tokPtr = XML_TOK_PI;
+  if (end - ptr != MINBPC(enc) * 3)
+    return 1;
+  switch (BYTE_TO_ASCII(enc, ptr)) {
+  case ASCII_x:
+    break;
+  case ASCII_X:
+    upper = 1;
+    break;
+  default:
+    return 1;
+  }
+  ptr += MINBPC(enc);
+  switch (BYTE_TO_ASCII(enc, ptr)) {
+  case ASCII_m:
+    break;
+  case ASCII_M:
+    upper = 1;
+    break;
+  default:
+    return 1;
+  }
+  ptr += MINBPC(enc);
+  switch (BYTE_TO_ASCII(enc, ptr)) {
+  case ASCII_l:
+    break;
+  case ASCII_L:
+    upper = 1;
+    break;
+  default:
+    return 1;
+  }
+  if (upper)
+    return 0;
+  *tokPtr = XML_TOK_XML_DECL;
+  return 1;
+}
+
+/* ptr points to character following "<?" */
+
+static int PTRCALL
+PREFIX(scanPi)(const ENCODING *enc, const char *ptr, const char *end,
+               const char **nextTokPtr) {
+  int tok;
+  const char *target = ptr;
+  REQUIRE_CHAR(enc, ptr, end);
+  switch (BYTE_TYPE(enc, ptr)) {
+    CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+  default:
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  }
+  while (HAS_CHAR(enc, ptr, end)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+      CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+    case BT_S:
+    case BT_CR:
+    case BT_LF:
+      if (! PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
+        *nextTokPtr = ptr;
+        return XML_TOK_INVALID;
+      }
+      ptr += MINBPC(enc);
+      while (HAS_CHAR(enc, ptr, end)) {
+        switch (BYTE_TYPE(enc, ptr)) {
+          INVALID_CASES(ptr, nextTokPtr)
+        case BT_QUEST:
+          ptr += MINBPC(enc);
+          REQUIRE_CHAR(enc, ptr, end);
+          if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
+            *nextTokPtr = ptr + MINBPC(enc);
+            return tok;
+          }
+          break;
+        default:
+          ptr += MINBPC(enc);
+          break;
+        }
+      }
+      return XML_TOK_PARTIAL;
+    case BT_QUEST:
+      if (! PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
+        *nextTokPtr = ptr;
+        return XML_TOK_INVALID;
+      }
+      ptr += MINBPC(enc);
+      REQUIRE_CHAR(enc, ptr, end);
+      if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
+        *nextTokPtr = ptr + MINBPC(enc);
+        return tok;
+      }
+      /* fall through */
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+static int PTRCALL
+PREFIX(scanCdataSection)(const ENCODING *enc, const char *ptr, const char *end,
+                         const char **nextTokPtr) {
+  static const char CDATA_LSQB[]
+      = {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, ASCII_LSQB};
+  int i;
+  UNUSED_P(enc);
+  /* CDATA[ */
+  REQUIRE_CHARS(enc, ptr, end, 6);
+  for (i = 0; i < 6; i++, ptr += MINBPC(enc)) {
+    if (! CHAR_MATCHES(enc, ptr, CDATA_LSQB[i])) {
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+  }
+  *nextTokPtr = ptr;
+  return XML_TOK_CDATA_SECT_OPEN;
+}
+
+static int PTRCALL
+PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr, const char *end,
+                        const char **nextTokPtr) {
+  if (ptr >= end)
+    return XML_TOK_NONE;
+  if (MINBPC(enc) > 1) {
+    size_t n = end - ptr;
+    if (n & (MINBPC(enc) - 1)) {
+      n &= ~(MINBPC(enc) - 1);
+      if (n == 0)
+        return XML_TOK_PARTIAL;
+      end = ptr + n;
+    }
+  }
+  switch (BYTE_TYPE(enc, ptr)) {
+  case BT_RSQB:
+    ptr += MINBPC(enc);
+    REQUIRE_CHAR(enc, ptr, end);
+    if (! CHAR_MATCHES(enc, ptr, ASCII_RSQB))
+      break;
+    ptr += MINBPC(enc);
+    REQUIRE_CHAR(enc, ptr, end);
+    if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) {
+      ptr -= MINBPC(enc);
+      break;
+    }
+    *nextTokPtr = ptr + MINBPC(enc);
+    return XML_TOK_CDATA_SECT_CLOSE;
+  case BT_CR:
+    ptr += MINBPC(enc);
+    REQUIRE_CHAR(enc, ptr, end);
+    if (BYTE_TYPE(enc, ptr) == BT_LF)
+      ptr += MINBPC(enc);
+    *nextTokPtr = ptr;
+    return XML_TOK_DATA_NEWLINE;
+  case BT_LF:
+    *nextTokPtr = ptr + MINBPC(enc);
+    return XML_TOK_DATA_NEWLINE;
+    INVALID_CASES(ptr, nextTokPtr)
+  default:
+    ptr += MINBPC(enc);
+    break;
+  }
+  while (HAS_CHAR(enc, ptr, end)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+#  define LEAD_CASE(n)                                                         \
+  case BT_LEAD##n:                                                             \
+    if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) {                       \
+      *nextTokPtr = ptr;                                                       \
+      return XML_TOK_DATA_CHARS;                                               \
+    }                                                                          \
+    ptr += n;                                                                  \
+    break;
+      LEAD_CASE(2)
+      LEAD_CASE(3)
+      LEAD_CASE(4)
+#  undef LEAD_CASE
+    case BT_NONXML:
+    case BT_MALFORM:
+    case BT_TRAIL:
+    case BT_CR:
+    case BT_LF:
+    case BT_RSQB:
+      *nextTokPtr = ptr;
+      return XML_TOK_DATA_CHARS;
+    default:
+      ptr += MINBPC(enc);
+      break;
+    }
+  }
+  *nextTokPtr = ptr;
+  return XML_TOK_DATA_CHARS;
+}
+
+/* ptr points to character following "</" */
+
+static int PTRCALL
+PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr, const char *end,
+                   const char **nextTokPtr) {
+  REQUIRE_CHAR(enc, ptr, end);
+  switch (BYTE_TYPE(enc, ptr)) {
+    CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+  default:
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  }
+  while (HAS_CHAR(enc, ptr, end)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+      CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+    case BT_S:
+    case BT_CR:
+    case BT_LF:
+      for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) {
+        switch (BYTE_TYPE(enc, ptr)) {
+        case BT_S:
+        case BT_CR:
+        case BT_LF:
+          break;
+        case BT_GT:
+          *nextTokPtr = ptr + MINBPC(enc);
+          return XML_TOK_END_TAG;
+        default:
+          *nextTokPtr = ptr;
+          return XML_TOK_INVALID;
+        }
+      }
+      return XML_TOK_PARTIAL;
+#  ifdef XML_NS
+    case BT_COLON:
+      /* no need to check qname syntax here,
+         since end-tag must match exactly */
+      ptr += MINBPC(enc);
+      break;
+#  endif
+    case BT_GT:
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_END_TAG;
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+/* ptr points to character following "&#X" */
+
+static int PTRCALL
+PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr, const char *end,
+                       const char **nextTokPtr) {
+  if (HAS_CHAR(enc, ptr, end)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+    case BT_DIGIT:
+    case BT_HEX:
+      break;
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+    for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) {
+      switch (BYTE_TYPE(enc, ptr)) {
+      case BT_DIGIT:
+      case BT_HEX:
+        break;
+      case BT_SEMI:
+        *nextTokPtr = ptr + MINBPC(enc);
+        return XML_TOK_CHAR_REF;
+      default:
+        *nextTokPtr = ptr;
+        return XML_TOK_INVALID;
+      }
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+/* ptr points to character following "&#" */
+
+static int PTRCALL
+PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr, const char *end,
+                    const char **nextTokPtr) {
+  if (HAS_CHAR(enc, ptr, end)) {
+    if (CHAR_MATCHES(enc, ptr, ASCII_x))
+      return PREFIX(scanHexCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+    switch (BYTE_TYPE(enc, ptr)) {
+    case BT_DIGIT:
+      break;
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+    for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) {
+      switch (BYTE_TYPE(enc, ptr)) {
+      case BT_DIGIT:
+        break;
+      case BT_SEMI:
+        *nextTokPtr = ptr + MINBPC(enc);
+        return XML_TOK_CHAR_REF;
+      default:
+        *nextTokPtr = ptr;
+        return XML_TOK_INVALID;
+      }
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+/* ptr points to character following "&" */
+
+static int PTRCALL
+PREFIX(scanRef)(const ENCODING *enc, const char *ptr, const char *end,
+                const char **nextTokPtr) {
+  REQUIRE_CHAR(enc, ptr, end);
+  switch (BYTE_TYPE(enc, ptr)) {
+    CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+  case BT_NUM:
+    return PREFIX(scanCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+  default:
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  }
+  while (HAS_CHAR(enc, ptr, end)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+      CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+    case BT_SEMI:
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_ENTITY_REF;
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+/* ptr points to character following first character of attribute name */
+
+static int PTRCALL
+PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
+                 const char **nextTokPtr) {
+#  ifdef XML_NS
+  int hadColon = 0;
+#  endif
+  while (HAS_CHAR(enc, ptr, end)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+      CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+#  ifdef XML_NS
+    case BT_COLON:
+      if (hadColon) {
+        *nextTokPtr = ptr;
+        return XML_TOK_INVALID;
+      }
+      hadColon = 1;
+      ptr += MINBPC(enc);
+      REQUIRE_CHAR(enc, ptr, end);
+      switch (BYTE_TYPE(enc, ptr)) {
+        CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+      default:
+        *nextTokPtr = ptr;
+        return XML_TOK_INVALID;
+      }
+      break;
+#  endif
+    case BT_S:
+    case BT_CR:
+    case BT_LF:
+      for (;;) {
+        int t;
+
+        ptr += MINBPC(enc);
+        REQUIRE_CHAR(enc, ptr, end);
+        t = BYTE_TYPE(enc, ptr);
+        if (t == BT_EQUALS)
+          break;
+        switch (t) {
+        case BT_S:
+        case BT_LF:
+        case BT_CR:
+          break;
+        default:
+          *nextTokPtr = ptr;
+          return XML_TOK_INVALID;
+        }
+      }
+      /* fall through */
+    case BT_EQUALS: {
+      int open;
+#  ifdef XML_NS
+      hadColon = 0;
+#  endif
+      for (;;) {
+        ptr += MINBPC(enc);
+        REQUIRE_CHAR(enc, ptr, end);
+        open = BYTE_TYPE(enc, ptr);
+        if (open == BT_QUOT || open == BT_APOS)
+          break;
+        switch (open) {
+        case BT_S:
+        case BT_LF:
+        case BT_CR:
+          break;
+        default:
+          *nextTokPtr = ptr;
+          return XML_TOK_INVALID;
+        }
+      }
+      ptr += MINBPC(enc);
+      /* in attribute value */
+      for (;;) {
+        int t;
+        REQUIRE_CHAR(enc, ptr, end);
+        t = BYTE_TYPE(enc, ptr);
+        if (t == open)
+          break;
+        switch (t) {
+          INVALID_CASES(ptr, nextTokPtr)
+        case BT_AMP: {
+          int tok = PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, &ptr);
+          if (tok <= 0) {
+            if (tok == XML_TOK_INVALID)
+              *nextTokPtr = ptr;
+            return tok;
+          }
+          break;
+        }
+        case BT_LT:
+          *nextTokPtr = ptr;
+          return XML_TOK_INVALID;
+        default:
+          ptr += MINBPC(enc);
+          break;
+        }
+      }
+      ptr += MINBPC(enc);
+      REQUIRE_CHAR(enc, ptr, end);
+      switch (BYTE_TYPE(enc, ptr)) {
+      case BT_S:
+      case BT_CR:
+      case BT_LF:
+        break;
+      case BT_SOL:
+        goto sol;
+      case BT_GT:
+        goto gt;
+      default:
+        *nextTokPtr = ptr;
+        return XML_TOK_INVALID;
+      }
+      /* ptr points to closing quote */
+      for (;;) {
+        ptr += MINBPC(enc);
+        REQUIRE_CHAR(enc, ptr, end);
+        switch (BYTE_TYPE(enc, ptr)) {
+          CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+        case BT_S:
+        case BT_CR:
+        case BT_LF:
+          continue;
+        case BT_GT:
+        gt:
+          *nextTokPtr = ptr + MINBPC(enc);
+          return XML_TOK_START_TAG_WITH_ATTS;
+        case BT_SOL:
+        sol:
+          ptr += MINBPC(enc);
+          REQUIRE_CHAR(enc, ptr, end);
+          if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) {
+            *nextTokPtr = ptr;
+            return XML_TOK_INVALID;
+          }
+          *nextTokPtr = ptr + MINBPC(enc);
+          return XML_TOK_EMPTY_ELEMENT_WITH_ATTS;
+        default:
+          *nextTokPtr = ptr;
+          return XML_TOK_INVALID;
+        }
+        break;
+      }
+      break;
+    }
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+/* ptr points to character following "<" */
+
+static int PTRCALL
+PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
+               const char **nextTokPtr) {
+#  ifdef XML_NS
+  int hadColon;
+#  endif
+  REQUIRE_CHAR(enc, ptr, end);
+  switch (BYTE_TYPE(enc, ptr)) {
+    CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+  case BT_EXCL:
+    ptr += MINBPC(enc);
+    REQUIRE_CHAR(enc, ptr, end);
+    switch (BYTE_TYPE(enc, ptr)) {
+    case BT_MINUS:
+      return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+    case BT_LSQB:
+      return PREFIX(scanCdataSection)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+    }
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  case BT_QUEST:
+    return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+  case BT_SOL:
+    return PREFIX(scanEndTag)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+  default:
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  }
+#  ifdef XML_NS
+  hadColon = 0;
+#  endif
+  /* we have a start-tag */
+  while (HAS_CHAR(enc, ptr, end)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+      CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+#  ifdef XML_NS
+    case BT_COLON:
+      if (hadColon) {
+        *nextTokPtr = ptr;
+        return XML_TOK_INVALID;
+      }
+      hadColon = 1;
+      ptr += MINBPC(enc);
+      REQUIRE_CHAR(enc, ptr, end);
+      switch (BYTE_TYPE(enc, ptr)) {
+        CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+      default:
+        *nextTokPtr = ptr;
+        return XML_TOK_INVALID;
+      }
+      break;
+#  endif
+    case BT_S:
+    case BT_CR:
+    case BT_LF: {
+      ptr += MINBPC(enc);
+      while (HAS_CHAR(enc, ptr, end)) {
+        switch (BYTE_TYPE(enc, ptr)) {
+          CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+        case BT_GT:
+          goto gt;
+        case BT_SOL:
+          goto sol;
+        case BT_S:
+        case BT_CR:
+        case BT_LF:
+          ptr += MINBPC(enc);
+          continue;
+        default:
+          *nextTokPtr = ptr;
+          return XML_TOK_INVALID;
+        }
+        return PREFIX(scanAtts)(enc, ptr, end, nextTokPtr);
+      }
+      return XML_TOK_PARTIAL;
+    }
+    case BT_GT:
+    gt:
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_START_TAG_NO_ATTS;
+    case BT_SOL:
+    sol:
+      ptr += MINBPC(enc);
+      REQUIRE_CHAR(enc, ptr, end);
+      if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) {
+        *nextTokPtr = ptr;
+        return XML_TOK_INVALID;
+      }
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_EMPTY_ELEMENT_NO_ATTS;
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+static int PTRCALL
+PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
+                   const char **nextTokPtr) {
+  if (ptr >= end)
+    return XML_TOK_NONE;
+  if (MINBPC(enc) > 1) {
+    size_t n = end - ptr;
+    if (n & (MINBPC(enc) - 1)) {
+      n &= ~(MINBPC(enc) - 1);
+      if (n == 0)
+        return XML_TOK_PARTIAL;
+      end = ptr + n;
+    }
+  }
+  switch (BYTE_TYPE(enc, ptr)) {
+  case BT_LT:
+    return PREFIX(scanLt)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+  case BT_AMP:
+    return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+  case BT_CR:
+    ptr += MINBPC(enc);
+    if (! HAS_CHAR(enc, ptr, end))
+      return XML_TOK_TRAILING_CR;
+    if (BYTE_TYPE(enc, ptr) == BT_LF)
+      ptr += MINBPC(enc);
+    *nextTokPtr = ptr;
+    return XML_TOK_DATA_NEWLINE;
+  case BT_LF:
+    *nextTokPtr = ptr + MINBPC(enc);
+    return XML_TOK_DATA_NEWLINE;
+  case BT_RSQB:
+    ptr += MINBPC(enc);
+    if (! HAS_CHAR(enc, ptr, end))
+      return XML_TOK_TRAILING_RSQB;
+    if (! CHAR_MATCHES(enc, ptr, ASCII_RSQB))
+      break;
+    ptr += MINBPC(enc);
+    if (! HAS_CHAR(enc, ptr, end))
+      return XML_TOK_TRAILING_RSQB;
+    if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) {
+      ptr -= MINBPC(enc);
+      break;
+    }
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+    INVALID_CASES(ptr, nextTokPtr)
+  default:
+    ptr += MINBPC(enc);
+    break;
+  }
+  while (HAS_CHAR(enc, ptr, end)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+#  define LEAD_CASE(n)                                                         \
+  case BT_LEAD##n:                                                             \
+    if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) {                       \
+      *nextTokPtr = ptr;                                                       \
+      return XML_TOK_DATA_CHARS;                                               \
+    }                                                                          \
+    ptr += n;                                                                  \
+    break;
+      LEAD_CASE(2)
+      LEAD_CASE(3)
+      LEAD_CASE(4)
+#  undef LEAD_CASE
+    case BT_RSQB:
+      if (HAS_CHARS(enc, ptr, end, 2)) {
+        if (! CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_RSQB)) {
+          ptr += MINBPC(enc);
+          break;
+        }
+        if (HAS_CHARS(enc, ptr, end, 3)) {
+          if (! CHAR_MATCHES(enc, ptr + 2 * MINBPC(enc), ASCII_GT)) {
+            ptr += MINBPC(enc);
+            break;
+          }
+          *nextTokPtr = ptr + 2 * MINBPC(enc);
+          return XML_TOK_INVALID;
+        }
+      }
+      /* fall through */
+    case BT_AMP:
+    case BT_LT:
+    case BT_NONXML:
+    case BT_MALFORM:
+    case BT_TRAIL:
+    case BT_CR:
+    case BT_LF:
+      *nextTokPtr = ptr;
+      return XML_TOK_DATA_CHARS;
+    default:
+      ptr += MINBPC(enc);
+      break;
+    }
+  }
+  *nextTokPtr = ptr;
+  return XML_TOK_DATA_CHARS;
+}
+
+/* ptr points to character following "%" */
+
+static int PTRCALL
+PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end,
+                    const char **nextTokPtr) {
+  REQUIRE_CHAR(enc, ptr, end);
+  switch (BYTE_TYPE(enc, ptr)) {
+    CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+  case BT_S:
+  case BT_LF:
+  case BT_CR:
+  case BT_PERCNT:
+    *nextTokPtr = ptr;
+    return XML_TOK_PERCENT;
+  default:
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  }
+  while (HAS_CHAR(enc, ptr, end)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+      CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+    case BT_SEMI:
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_PARAM_ENTITY_REF;
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+static int PTRCALL
+PREFIX(scanPoundName)(const ENCODING *enc, const char *ptr, const char *end,
+                      const char **nextTokPtr) {
+  REQUIRE_CHAR(enc, ptr, end);
+  switch (BYTE_TYPE(enc, ptr)) {
+    CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+  default:
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  }
+  while (HAS_CHAR(enc, ptr, end)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+      CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+    case BT_CR:
+    case BT_LF:
+    case BT_S:
+    case BT_RPAR:
+    case BT_GT:
+    case BT_PERCNT:
+    case BT_VERBAR:
+      *nextTokPtr = ptr;
+      return XML_TOK_POUND_NAME;
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+  }
+  return -XML_TOK_POUND_NAME;
+}
+
+static int PTRCALL
+PREFIX(scanLit)(int open, const ENCODING *enc, const char *ptr, const char *end,
+                const char **nextTokPtr) {
+  while (HAS_CHAR(enc, ptr, end)) {
+    int t = BYTE_TYPE(enc, ptr);
+    switch (t) {
+      INVALID_CASES(ptr, nextTokPtr)
+    case BT_QUOT:
+    case BT_APOS:
+      ptr += MINBPC(enc);
+      if (t != open)
+        break;
+      if (! HAS_CHAR(enc, ptr, end))
+        return -XML_TOK_LITERAL;
+      *nextTokPtr = ptr;
+      switch (BYTE_TYPE(enc, ptr)) {
+      case BT_S:
+      case BT_CR:
+      case BT_LF:
+      case BT_GT:
+      case BT_PERCNT:
+      case BT_LSQB:
+        return XML_TOK_LITERAL;
+      default:
+        return XML_TOK_INVALID;
+      }
+    default:
+      ptr += MINBPC(enc);
+      break;
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+static int PTRCALL
+PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
+                  const char **nextTokPtr) {
+  int tok;
+  if (ptr >= end)
+    return XML_TOK_NONE;
+  if (MINBPC(enc) > 1) {
+    size_t n = end - ptr;
+    if (n & (MINBPC(enc) - 1)) {
+      n &= ~(MINBPC(enc) - 1);
+      if (n == 0)
+        return XML_TOK_PARTIAL;
+      end = ptr + n;
+    }
+  }
+  switch (BYTE_TYPE(enc, ptr)) {
+  case BT_QUOT:
+    return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC(enc), end, nextTokPtr);
+  case BT_APOS:
+    return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC(enc), end, nextTokPtr);
+  case BT_LT: {
+    ptr += MINBPC(enc);
+    REQUIRE_CHAR(enc, ptr, end);
+    switch (BYTE_TYPE(enc, ptr)) {
+    case BT_EXCL:
+      return PREFIX(scanDecl)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+    case BT_QUEST:
+      return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+    case BT_NMSTRT:
+    case BT_HEX:
+    case BT_NONASCII:
+    case BT_LEAD2:
+    case BT_LEAD3:
+    case BT_LEAD4:
+      *nextTokPtr = ptr - MINBPC(enc);
+      return XML_TOK_INSTANCE_START;
+    }
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  }
+  case BT_CR:
+    if (ptr + MINBPC(enc) == end) {
+      *nextTokPtr = end;
+      /* indicate that this might be part of a CR/LF pair */
+      return -XML_TOK_PROLOG_S;
+    }
+    /* fall through */
+  case BT_S:
+  case BT_LF:
+    for (;;) {
+      ptr += MINBPC(enc);
+      if (! HAS_CHAR(enc, ptr, end))
+        break;
+      switch (BYTE_TYPE(enc, ptr)) {
+      case BT_S:
+      case BT_LF:
+        break;
+      case BT_CR:
+        /* don't split CR/LF pair */
+        if (ptr + MINBPC(enc) != end)
+          break;
+        /* fall through */
+      default:
+        *nextTokPtr = ptr;
+        return XML_TOK_PROLOG_S;
+      }
+    }
+    *nextTokPtr = ptr;
+    return XML_TOK_PROLOG_S;
+  case BT_PERCNT:
+    return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+  case BT_COMMA:
+    *nextTokPtr = ptr + MINBPC(enc);
+    return XML_TOK_COMMA;
+  case BT_LSQB:
+    *nextTokPtr = ptr + MINBPC(enc);
+    return XML_TOK_OPEN_BRACKET;
+  case BT_RSQB:
+    ptr += MINBPC(enc);
+    if (! HAS_CHAR(enc, ptr, end))
+      return -XML_TOK_CLOSE_BRACKET;
+    if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) {
+      REQUIRE_CHARS(enc, ptr, end, 2);
+      if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_GT)) {
+        *nextTokPtr = ptr + 2 * MINBPC(enc);
+        return XML_TOK_COND_SECT_CLOSE;
+      }
+    }
+    *nextTokPtr = ptr;
+    return XML_TOK_CLOSE_BRACKET;
+  case BT_LPAR:
+    *nextTokPtr = ptr + MINBPC(enc);
+    return XML_TOK_OPEN_PAREN;
+  case BT_RPAR:
+    ptr += MINBPC(enc);
+    if (! HAS_CHAR(enc, ptr, end))
+      return -XML_TOK_CLOSE_PAREN;
+    switch (BYTE_TYPE(enc, ptr)) {
+    case BT_AST:
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_CLOSE_PAREN_ASTERISK;
+    case BT_QUEST:
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_CLOSE_PAREN_QUESTION;
+    case BT_PLUS:
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_CLOSE_PAREN_PLUS;
+    case BT_CR:
+    case BT_LF:
+    case BT_S:
+    case BT_GT:
+    case BT_COMMA:
+    case BT_VERBAR:
+    case BT_RPAR:
+      *nextTokPtr = ptr;
+      return XML_TOK_CLOSE_PAREN;
+    }
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  case BT_VERBAR:
+    *nextTokPtr = ptr + MINBPC(enc);
+    return XML_TOK_OR;
+  case BT_GT:
+    *nextTokPtr = ptr + MINBPC(enc);
+    return XML_TOK_DECL_CLOSE;
+  case BT_NUM:
+    return PREFIX(scanPoundName)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+#  define LEAD_CASE(n)                                                         \
+  case BT_LEAD##n:                                                             \
+    if (end - ptr < n)                                                         \
+      return XML_TOK_PARTIAL_CHAR;                                             \
+    if (IS_INVALID_CHAR(enc, ptr, n)) {                                        \
+      *nextTokPtr = ptr;                                                       \
+      return XML_TOK_INVALID;                                                  \
+    }                                                                          \
+    if (IS_NMSTRT_CHAR(enc, ptr, n)) {                                         \
+      ptr += n;                                                                \
+      tok = XML_TOK_NAME;                                                      \
+      break;                                                                   \
+    }                                                                          \
+    if (IS_NAME_CHAR(enc, ptr, n)) {                                           \
+      ptr += n;                                                                \
+      tok = XML_TOK_NMTOKEN;                                                   \
+      break;                                                                   \
+    }                                                                          \
+    *nextTokPtr = ptr;                                                         \
+    return XML_TOK_INVALID;
+    LEAD_CASE(2)
+    LEAD_CASE(3)
+    LEAD_CASE(4)
+#  undef LEAD_CASE
+  case BT_NMSTRT:
+  case BT_HEX:
+    tok = XML_TOK_NAME;
+    ptr += MINBPC(enc);
+    break;
+  case BT_DIGIT:
+  case BT_NAME:
+  case BT_MINUS:
+#  ifdef XML_NS
+  case BT_COLON:
+#  endif
+    tok = XML_TOK_NMTOKEN;
+    ptr += MINBPC(enc);
+    break;
+  case BT_NONASCII:
+    if (IS_NMSTRT_CHAR_MINBPC(enc, ptr)) {
+      ptr += MINBPC(enc);
+      tok = XML_TOK_NAME;
+      break;
+    }
+    if (IS_NAME_CHAR_MINBPC(enc, ptr)) {
+      ptr += MINBPC(enc);
+      tok = XML_TOK_NMTOKEN;
+      break;
+    }
+    /* fall through */
+  default:
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  }
+  while (HAS_CHAR(enc, ptr, end)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+      CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+    case BT_GT:
+    case BT_RPAR:
+    case BT_COMMA:
+    case BT_VERBAR:
+    case BT_LSQB:
+    case BT_PERCNT:
+    case BT_S:
+    case BT_CR:
+    case BT_LF:
+      *nextTokPtr = ptr;
+      return tok;
+#  ifdef XML_NS
+    case BT_COLON:
+      ptr += MINBPC(enc);
+      switch (tok) {
+      case XML_TOK_NAME:
+        REQUIRE_CHAR(enc, ptr, end);
+        tok = XML_TOK_PREFIXED_NAME;
+        switch (BYTE_TYPE(enc, ptr)) {
+          CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+        default:
+          tok = XML_TOK_NMTOKEN;
+          break;
+        }
+        break;
+      case XML_TOK_PREFIXED_NAME:
+        tok = XML_TOK_NMTOKEN;
+        break;
+      }
+      break;
+#  endif
+    case BT_PLUS:
+      if (tok == XML_TOK_NMTOKEN) {
+        *nextTokPtr = ptr;
+        return XML_TOK_INVALID;
+      }
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_NAME_PLUS;
+    case BT_AST:
+      if (tok == XML_TOK_NMTOKEN) {
+        *nextTokPtr = ptr;
+        return XML_TOK_INVALID;
+      }
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_NAME_ASTERISK;
+    case BT_QUEST:
+      if (tok == XML_TOK_NMTOKEN) {
+        *nextTokPtr = ptr;
+        return XML_TOK_INVALID;
+      }
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_NAME_QUESTION;
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+  }
+  return -tok;
+}
+
+static int PTRCALL
+PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr, const char *end,
+                          const char **nextTokPtr) {
+  const char *start;
+  if (ptr >= end)
+    return XML_TOK_NONE;
+  else if (! HAS_CHAR(enc, ptr, end)) {
+    /* This line cannot be executed.  The incoming data has already
+     * been tokenized once, so incomplete characters like this have
+     * already been eliminated from the input.  Retaining the paranoia
+     * check is still valuable, however.
+     */
+    return XML_TOK_PARTIAL; /* LCOV_EXCL_LINE */
+  }
+  start = ptr;
+  while (HAS_CHAR(enc, ptr, end)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+#  define LEAD_CASE(n)                                                         \
+  case BT_LEAD##n:                                                             \
+    ptr += n; /* NOTE: The encoding has already been validated. */             \
+    break;
+      LEAD_CASE(2)
+      LEAD_CASE(3)
+      LEAD_CASE(4)
+#  undef LEAD_CASE
+    case BT_AMP:
+      if (ptr == start)
+        return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+      *nextTokPtr = ptr;
+      return XML_TOK_DATA_CHARS;
+    case BT_LT:
+      /* this is for inside entity references */
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    case BT_LF:
+      if (ptr == start) {
+        *nextTokPtr = ptr + MINBPC(enc);
+        return XML_TOK_DATA_NEWLINE;
+      }
+      *nextTokPtr = ptr;
+      return XML_TOK_DATA_CHARS;
+    case BT_CR:
+      if (ptr == start) {
+        ptr += MINBPC(enc);
+        if (! HAS_CHAR(enc, ptr, end))
+          return XML_TOK_TRAILING_CR;
+        if (BYTE_TYPE(enc, ptr) == BT_LF)
+          ptr += MINBPC(enc);
+        *nextTokPtr = ptr;
+        return XML_TOK_DATA_NEWLINE;
+      }
+      *nextTokPtr = ptr;
+      return XML_TOK_DATA_CHARS;
+    case BT_S:
+      if (ptr == start) {
+        *nextTokPtr = ptr + MINBPC(enc);
+        return XML_TOK_ATTRIBUTE_VALUE_S;
+      }
+      *nextTokPtr = ptr;
+      return XML_TOK_DATA_CHARS;
+    default:
+      ptr += MINBPC(enc);
+      break;
+    }
+  }
+  *nextTokPtr = ptr;
+  return XML_TOK_DATA_CHARS;
+}
+
+static int PTRCALL
+PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr, const char *end,
+                       const char **nextTokPtr) {
+  const char *start;
+  if (ptr >= end)
+    return XML_TOK_NONE;
+  else if (! HAS_CHAR(enc, ptr, end)) {
+    /* This line cannot be executed.  The incoming data has already
+     * been tokenized once, so incomplete characters like this have
+     * already been eliminated from the input.  Retaining the paranoia
+     * check is still valuable, however.
+     */
+    return XML_TOK_PARTIAL; /* LCOV_EXCL_LINE */
+  }
+  start = ptr;
+  while (HAS_CHAR(enc, ptr, end)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+#  define LEAD_CASE(n)                                                         \
+  case BT_LEAD##n:                                                             \
+    ptr += n; /* NOTE: The encoding has already been validated. */             \
+    break;
+      LEAD_CASE(2)
+      LEAD_CASE(3)
+      LEAD_CASE(4)
+#  undef LEAD_CASE
+    case BT_AMP:
+      if (ptr == start)
+        return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+      *nextTokPtr = ptr;
+      return XML_TOK_DATA_CHARS;
+    case BT_PERCNT:
+      if (ptr == start) {
+        int tok = PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+        return (tok == XML_TOK_PERCENT) ? XML_TOK_INVALID : tok;
+      }
+      *nextTokPtr = ptr;
+      return XML_TOK_DATA_CHARS;
+    case BT_LF:
+      if (ptr == start) {
+        *nextTokPtr = ptr + MINBPC(enc);
+        return XML_TOK_DATA_NEWLINE;
+      }
+      *nextTokPtr = ptr;
+      return XML_TOK_DATA_CHARS;
+    case BT_CR:
+      if (ptr == start) {
+        ptr += MINBPC(enc);
+        if (! HAS_CHAR(enc, ptr, end))
+          return XML_TOK_TRAILING_CR;
+        if (BYTE_TYPE(enc, ptr) == BT_LF)
+          ptr += MINBPC(enc);
+        *nextTokPtr = ptr;
+        return XML_TOK_DATA_NEWLINE;
+      }
+      *nextTokPtr = ptr;
+      return XML_TOK_DATA_CHARS;
+    default:
+      ptr += MINBPC(enc);
+      break;
+    }
+  }
+  *nextTokPtr = ptr;
+  return XML_TOK_DATA_CHARS;
+}
+
+#  ifdef XML_DTD
+
+static int PTRCALL
+PREFIX(ignoreSectionTok)(const ENCODING *enc, const char *ptr, const char *end,
+                         const char **nextTokPtr) {
+  int level = 0;
+  if (MINBPC(enc) > 1) {
+    size_t n = end - ptr;
+    if (n & (MINBPC(enc) - 1)) {
+      n &= ~(MINBPC(enc) - 1);
+      end = ptr + n;
+    }
+  }
+  while (HAS_CHAR(enc, ptr, end)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+      INVALID_CASES(ptr, nextTokPtr)
+    case BT_LT:
+      ptr += MINBPC(enc);
+      REQUIRE_CHAR(enc, ptr, end);
+      if (CHAR_MATCHES(enc, ptr, ASCII_EXCL)) {
+        ptr += MINBPC(enc);
+        REQUIRE_CHAR(enc, ptr, end);
+        if (CHAR_MATCHES(enc, ptr, ASCII_LSQB)) {
+          ++level;
+          ptr += MINBPC(enc);
+        }
+      }
+      break;
+    case BT_RSQB:
+      ptr += MINBPC(enc);
+      REQUIRE_CHAR(enc, ptr, end);
+      if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) {
+        ptr += MINBPC(enc);
+        REQUIRE_CHAR(enc, ptr, end);
+        if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
+          ptr += MINBPC(enc);
+          if (level == 0) {
+            *nextTokPtr = ptr;
+            return XML_TOK_IGNORE_SECT;
+          }
+          --level;
+        }
+      }
+      break;
+    default:
+      ptr += MINBPC(enc);
+      break;
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+#  endif /* XML_DTD */
+
+static int PTRCALL
+PREFIX(isPublicId)(const ENCODING *enc, const char *ptr, const char *end,
+                   const char **badPtr) {
+  ptr += MINBPC(enc);
+  end -= MINBPC(enc);
+  for (; HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+    case BT_DIGIT:
+    case BT_HEX:
+    case BT_MINUS:
+    case BT_APOS:
+    case BT_LPAR:
+    case BT_RPAR:
+    case BT_PLUS:
+    case BT_COMMA:
+    case BT_SOL:
+    case BT_EQUALS:
+    case BT_QUEST:
+    case BT_CR:
+    case BT_LF:
+    case BT_SEMI:
+    case BT_EXCL:
+    case BT_AST:
+    case BT_PERCNT:
+    case BT_NUM:
+#  ifdef XML_NS
+    case BT_COLON:
+#  endif
+      break;
+    case BT_S:
+      if (CHAR_MATCHES(enc, ptr, ASCII_TAB)) {
+        *badPtr = ptr;
+        return 0;
+      }
+      break;
+    case BT_NAME:
+    case BT_NMSTRT:
+      if (! (BYTE_TO_ASCII(enc, ptr) & ~0x7f))
+        break;
+      /* fall through */
+    default:
+      switch (BYTE_TO_ASCII(enc, ptr)) {
+      case 0x24: /* $ */
+      case 0x40: /* @ */
+        break;
+      default:
+        *badPtr = ptr;
+        return 0;
+      }
+      break;
+    }
+  }
+  return 1;
+}
+
+/* This must only be called for a well-formed start-tag or empty
+   element tag.  Returns the number of attributes.  Pointers to the
+   first attsMax attributes are stored in atts.
+*/
+
+static int PTRCALL
+PREFIX(getAtts)(const ENCODING *enc, const char *ptr, int attsMax,
+                ATTRIBUTE *atts) {
+  enum { other, inName, inValue } state = inName;
+  int nAtts = 0;
+  int open = 0; /* defined when state == inValue;
+                   initialization just to shut up compilers */
+
+  for (ptr += MINBPC(enc);; ptr += MINBPC(enc)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+#  define START_NAME                                                           \
+    if (state == other) {                                                      \
+      if (nAtts < attsMax) {                                                   \
+        atts[nAtts].name = ptr;                                                \
+        atts[nAtts].normalized = 1;                                            \
+      }                                                                        \
+      state = inName;                                                          \
+    }
+#  define LEAD_CASE(n)                                                         \
+  case BT_LEAD##n: /* NOTE: The encoding has already been validated. */        \
+    START_NAME ptr += (n - MINBPC(enc));                                       \
+    break;
+      LEAD_CASE(2)
+      LEAD_CASE(3)
+      LEAD_CASE(4)
+#  undef LEAD_CASE
+    case BT_NONASCII:
+    case BT_NMSTRT:
+    case BT_HEX:
+      START_NAME
+      break;
+#  undef START_NAME
+    case BT_QUOT:
+      if (state != inValue) {
+        if (nAtts < attsMax)
+          atts[nAtts].valuePtr = ptr + MINBPC(enc);
+        state = inValue;
+        open = BT_QUOT;
+      } else if (open == BT_QUOT) {
+        state = other;
+        if (nAtts < attsMax)
+          atts[nAtts].valueEnd = ptr;
+        nAtts++;
+      }
+      break;
+    case BT_APOS:
+      if (state != inValue) {
+        if (nAtts < attsMax)
+          atts[nAtts].valuePtr = ptr + MINBPC(enc);
+        state = inValue;
+        open = BT_APOS;
+      } else if (open == BT_APOS) {
+        state = other;
+        if (nAtts < attsMax)
+          atts[nAtts].valueEnd = ptr;
+        nAtts++;
+      }
+      break;
+    case BT_AMP:
+      if (nAtts < attsMax)
+        atts[nAtts].normalized = 0;
+      break;
+    case BT_S:
+      if (state == inName)
+        state = other;
+      else if (state == inValue && nAtts < attsMax && atts[nAtts].normalized
+               && (ptr == atts[nAtts].valuePtr
+                   || BYTE_TO_ASCII(enc, ptr) != ASCII_SPACE
+                   || BYTE_TO_ASCII(enc, ptr + MINBPC(enc)) == ASCII_SPACE
+                   || BYTE_TYPE(enc, ptr + MINBPC(enc)) == open))
+        atts[nAtts].normalized = 0;
+      break;
+    case BT_CR:
+    case BT_LF:
+      /* This case ensures that the first attribute name is counted
+         Apart from that we could just change state on the quote. */
+      if (state == inName)
+        state = other;
+      else if (state == inValue && nAtts < attsMax)
+        atts[nAtts].normalized = 0;
+      break;
+    case BT_GT:
+    case BT_SOL:
+      if (state != inValue)
+        return nAtts;
+      break;
+    default:
+      break;
+    }
+  }
+  /* not reached */
+}
+
+static int PTRFASTCALL
+PREFIX(charRefNumber)(const ENCODING *enc, const char *ptr) {
+  int result = 0;
+  /* skip &# */
+  UNUSED_P(enc);
+  ptr += 2 * MINBPC(enc);
+  if (CHAR_MATCHES(enc, ptr, ASCII_x)) {
+    for (ptr += MINBPC(enc); ! CHAR_MATCHES(enc, ptr, ASCII_SEMI);
+         ptr += MINBPC(enc)) {
+      int c = BYTE_TO_ASCII(enc, ptr);
+      switch (c) {
+      case ASCII_0:
+      case ASCII_1:
+      case ASCII_2:
+      case ASCII_3:
+      case ASCII_4:
+      case ASCII_5:
+      case ASCII_6:
+      case ASCII_7:
+      case ASCII_8:
+      case ASCII_9:
+        result <<= 4;
+        result |= (c - ASCII_0);
+        break;
+      case ASCII_A:
+      case ASCII_B:
+      case ASCII_C:
+      case ASCII_D:
+      case ASCII_E:
+      case ASCII_F:
+        result <<= 4;
+        result += 10 + (c - ASCII_A);
+        break;
+      case ASCII_a:
+      case ASCII_b:
+      case ASCII_c:
+      case ASCII_d:
+      case ASCII_e:
+      case ASCII_f:
+        result <<= 4;
+        result += 10 + (c - ASCII_a);
+        break;
+      }
+      if (result >= 0x110000)
+        return -1;
+    }
+  } else {
+    for (; ! CHAR_MATCHES(enc, ptr, ASCII_SEMI); ptr += MINBPC(enc)) {
+      int c = BYTE_TO_ASCII(enc, ptr);
+      result *= 10;
+      result += (c - ASCII_0);
+      if (result >= 0x110000)
+        return -1;
+    }
+  }
+  return checkCharRefNumber(result);
+}
+
+static int PTRCALL
+PREFIX(predefinedEntityName)(const ENCODING *enc, const char *ptr,
+                             const char *end) {
+  UNUSED_P(enc);
+  switch ((end - ptr) / MINBPC(enc)) {
+  case 2:
+    if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_t)) {
+      switch (BYTE_TO_ASCII(enc, ptr)) {
+      case ASCII_l:
+        return ASCII_LT;
+      case ASCII_g:
+        return ASCII_GT;
+      }
+    }
+    break;
+  case 3:
+    if (CHAR_MATCHES(enc, ptr, ASCII_a)) {
+      ptr += MINBPC(enc);
+      if (CHAR_MATCHES(enc, ptr, ASCII_m)) {
+        ptr += MINBPC(enc);
+        if (CHAR_MATCHES(enc, ptr, ASCII_p))
+          return ASCII_AMP;
+      }
+    }
+    break;
+  case 4:
+    switch (BYTE_TO_ASCII(enc, ptr)) {
+    case ASCII_q:
+      ptr += MINBPC(enc);
+      if (CHAR_MATCHES(enc, ptr, ASCII_u)) {
+        ptr += MINBPC(enc);
+        if (CHAR_MATCHES(enc, ptr, ASCII_o)) {
+          ptr += MINBPC(enc);
+          if (CHAR_MATCHES(enc, ptr, ASCII_t))
+            return ASCII_QUOT;
+        }
+      }
+      break;
+    case ASCII_a:
+      ptr += MINBPC(enc);
+      if (CHAR_MATCHES(enc, ptr, ASCII_p)) {
+        ptr += MINBPC(enc);
+        if (CHAR_MATCHES(enc, ptr, ASCII_o)) {
+          ptr += MINBPC(enc);
+          if (CHAR_MATCHES(enc, ptr, ASCII_s))
+            return ASCII_APOS;
+        }
+      }
+      break;
+    }
+  }
+  return 0;
+}
+
+static int PTRCALL
+PREFIX(nameMatchesAscii)(const ENCODING *enc, const char *ptr1,
+                         const char *end1, const char *ptr2) {
+  UNUSED_P(enc);
+  for (; *ptr2; ptr1 += MINBPC(enc), ptr2++) {
+    if (end1 - ptr1 < MINBPC(enc)) {
+      /* This line cannot be executed.  The incoming data has already
+       * been tokenized once, so incomplete characters like this have
+       * already been eliminated from the input.  Retaining the
+       * paranoia check is still valuable, however.
+       */
+      return 0; /* LCOV_EXCL_LINE */
+    }
+    if (! CHAR_MATCHES(enc, ptr1, *ptr2))
+      return 0;
+  }
+  return ptr1 == end1;
+}
+
+static int PTRFASTCALL
+PREFIX(nameLength)(const ENCODING *enc, const char *ptr) {
+  const char *start = ptr;
+  for (;;) {
+    switch (BYTE_TYPE(enc, ptr)) {
+#  define LEAD_CASE(n)                                                         \
+  case BT_LEAD##n:                                                             \
+    ptr += n; /* NOTE: The encoding has already been validated. */             \
+    break;
+      LEAD_CASE(2)
+      LEAD_CASE(3)
+      LEAD_CASE(4)
+#  undef LEAD_CASE
+    case BT_NONASCII:
+    case BT_NMSTRT:
+#  ifdef XML_NS
+    case BT_COLON:
+#  endif
+    case BT_HEX:
+    case BT_DIGIT:
+    case BT_NAME:
+    case BT_MINUS:
+      ptr += MINBPC(enc);
+      break;
+    default:
+      return (int)(ptr - start);
+    }
+  }
+}
+
+static const char *PTRFASTCALL
+PREFIX(skipS)(const ENCODING *enc, const char *ptr) {
+  for (;;) {
+    switch (BYTE_TYPE(enc, ptr)) {
+    case BT_LF:
+    case BT_CR:
+    case BT_S:
+      ptr += MINBPC(enc);
+      break;
+    default:
+      return ptr;
+    }
+  }
+}
+
+static void PTRCALL
+PREFIX(updatePosition)(const ENCODING *enc, const char *ptr, const char *end,
+                       POSITION *pos) {
+  while (HAS_CHAR(enc, ptr, end)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+#  define LEAD_CASE(n)                                                         \
+  case BT_LEAD##n:                                                             \
+    ptr += n; /* NOTE: The encoding has already been validated. */             \
+    pos->columnNumber++;                                                       \
+    break;
+      LEAD_CASE(2)
+      LEAD_CASE(3)
+      LEAD_CASE(4)
+#  undef LEAD_CASE
+    case BT_LF:
+      pos->columnNumber = 0;
+      pos->lineNumber++;
+      ptr += MINBPC(enc);
+      break;
+    case BT_CR:
+      pos->lineNumber++;
+      ptr += MINBPC(enc);
+      if (HAS_CHAR(enc, ptr, end) && BYTE_TYPE(enc, ptr) == BT_LF)
+        ptr += MINBPC(enc);
+      pos->columnNumber = 0;
+      break;
+    default:
+      ptr += MINBPC(enc);
+      pos->columnNumber++;
+      break;
+    }
+  }
+}
+
+#  undef DO_LEAD_CASE
+#  undef MULTIBYTE_CASES
+#  undef INVALID_CASES
+#  undef CHECK_NAME_CASE
+#  undef CHECK_NAME_CASES
+#  undef CHECK_NMSTRT_CASE
+#  undef CHECK_NMSTRT_CASES
+
+#endif /* XML_TOK_IMPL_C */
+
+#endif /* LV_USE_XML */
+
diff --git a/src/libs/expat/xmltok_impl.h b/src/libs/expat/xmltok_impl.h
new file mode 100644
index 000000000..0d7848369
--- /dev/null
+++ b/src/libs/expat/xmltok_impl.h
@@ -0,0 +1,80 @@
+/*
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2017-2019 Sebastian Pipping <sebastian@pipping.org>
+   Licensed under the MIT license:
+
+   Permission is  hereby granted,  free of charge,  to any  person obtaining
+   a  copy  of  this  software   and  associated  documentation  files  (the
+   "Software"),  to  deal in  the  Software  without restriction,  including
+   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
+   distribute, sublicense, and/or sell copies of the Software, and to permit
+   persons  to whom  the Software  is  furnished to  do so,  subject to  the
+   following conditions:
+
+   The above copyright  notice and this permission notice  shall be included
+   in all copies or substantial portions of the Software.
+
+   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
+   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
+   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+   USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include "../../lv_conf_internal.h"
+#if LV_USE_XML
+
+enum {
+  BT_NONXML,   /* e.g. noncharacter-FFFF */
+  BT_MALFORM,  /* illegal, with regard to encoding */
+  BT_LT,       /* less than = "<" */
+  BT_AMP,      /* ampersand = "&" */
+  BT_RSQB,     /* right square bracket = "[" */
+  BT_LEAD2,    /* lead byte of a 2-byte UTF-8 character */
+  BT_LEAD3,    /* lead byte of a 3-byte UTF-8 character */
+  BT_LEAD4,    /* lead byte of a 4-byte UTF-8 character */
+  BT_TRAIL,    /* trailing unit, e.g. second 16-bit unit of a 4-byte char. */
+  BT_CR,       /* carriage return = "\r" */
+  BT_LF,       /* line feed = "\n" */
+  BT_GT,       /* greater than = ">" */
+  BT_QUOT,     /* quotation character = "\"" */
+  BT_APOS,     /* apostrophe = "'" */
+  BT_EQUALS,   /* equal sign = "=" */
+  BT_QUEST,    /* question mark = "?" */
+  BT_EXCL,     /* exclamation mark = "!" */
+  BT_SOL,      /* solidus, slash = "/" */
+  BT_SEMI,     /* semicolon = ";" */
+  BT_NUM,      /* number sign = "#" */
+  BT_LSQB,     /* left square bracket = "[" */
+  BT_S,        /* white space, e.g. "\t", " "[, "\r"] */
+  BT_NMSTRT,   /* non-hex name start letter = "G".."Z" + "g".."z" + "_" */
+  BT_COLON,    /* colon = ":" */
+  BT_HEX,      /* hex letter = "A".."F" + "a".."f" */
+  BT_DIGIT,    /* digit = "0".."9" */
+  BT_NAME,     /* dot and middle dot = "." + chr(0xb7) */
+  BT_MINUS,    /* minus = "-" */
+  BT_OTHER,    /* known not to be a name or name start character */
+  BT_NONASCII, /* might be a name or name start character */
+  BT_PERCNT,   /* percent sign = "%" */
+  BT_LPAR,     /* left parenthesis = "(" */
+  BT_RPAR,     /* right parenthesis = "(" */
+  BT_AST,      /* asterisk = "*" */
+  BT_PLUS,     /* plus sign = "+" */
+  BT_COMMA,    /* comma = "," */
+  BT_VERBAR    /* vertical bar = "|" */
+};
+
+#include <stddef.h>
+
+#endif /* LV_USE_XML */
+
diff --git a/src/libs/expat/xmltok_ns.c b/src/libs/expat/xmltok_ns.c
new file mode 100644
index 000000000..595d7084d
--- /dev/null
+++ b/src/libs/expat/xmltok_ns.c
@@ -0,0 +1,128 @@
+/* This file is included!
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2002      Greg Stein <gstein@users.sourceforge.net>
+   Copyright (c) 2002      Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
+   Copyright (c) 2002-2006 Karl Waclawek <karl@waclawek.net>
+   Copyright (c) 2017-2021 Sebastian Pipping <sebastian@pipping.org>
+   Licensed under the MIT license:
+
+   Permission is  hereby granted,  free of charge,  to any  person obtaining
+   a  copy  of  this  software   and  associated  documentation  files  (the
+   "Software"),  to  deal in  the  Software  without restriction,  including
+   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
+   distribute, sublicense, and/or sell copies of the Software, and to permit
+   persons  to whom  the Software  is  furnished to  do so,  subject to  the
+   following conditions:
+
+   The above copyright  notice and this permission notice  shall be included
+   in all copies or substantial portions of the Software.
+
+   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
+   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
+   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+   USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include "../../lv_conf_internal.h"
+#if LV_USE_XML
+
+#ifdef XML_TOK_NS_C
+
+const ENCODING *
+NS(XmlGetUtf8InternalEncoding)(void) {
+  return &ns(internal_utf8_encoding).enc;
+}
+
+const ENCODING *
+NS(XmlGetUtf16InternalEncoding)(void) {
+#  if BYTEORDER == 1234
+  return &ns(internal_little2_encoding).enc;
+#  elif BYTEORDER == 4321
+  return &ns(internal_big2_encoding).enc;
+#  else
+  const short n = 1;
+  return (*(const char *)&n ? &ns(internal_little2_encoding).enc
+                            : &ns(internal_big2_encoding).enc);
+#  endif
+}
+
+static const ENCODING *const NS(encodings)[] = {
+    &ns(latin1_encoding).enc, &ns(ascii_encoding).enc,
+    &ns(utf8_encoding).enc,   &ns(big2_encoding).enc,
+    &ns(big2_encoding).enc,   &ns(little2_encoding).enc,
+    &ns(utf8_encoding).enc /* NO_ENC */
+};
+
+static int PTRCALL
+NS(initScanProlog)(const ENCODING *enc, const char *ptr, const char *end,
+                   const char **nextTokPtr) {
+  return initScan(NS(encodings), (const INIT_ENCODING *)enc, XML_PROLOG_STATE,
+                  ptr, end, nextTokPtr);
+}
+
+static int PTRCALL
+NS(initScanContent)(const ENCODING *enc, const char *ptr, const char *end,
+                    const char **nextTokPtr) {
+  return initScan(NS(encodings), (const INIT_ENCODING *)enc, XML_CONTENT_STATE,
+                  ptr, end, nextTokPtr);
+}
+
+int
+NS(XmlInitEncoding)(INIT_ENCODING *p, const ENCODING **encPtr,
+                    const char *name) {
+  int i = getEncodingIndex(name);
+  if (i == UNKNOWN_ENC)
+    return 0;
+  SET_INIT_ENC_INDEX(p, i);
+  p->initEnc.scanners[XML_PROLOG_STATE] = NS(initScanProlog);
+  p->initEnc.scanners[XML_CONTENT_STATE] = NS(initScanContent);
+  p->initEnc.updatePosition = initUpdatePosition;
+  p->encPtr = encPtr;
+  *encPtr = &(p->initEnc);
+  return 1;
+}
+
+static const ENCODING *
+NS(findEncoding)(const ENCODING *enc, const char *ptr, const char *end) {
+#  define ENCODING_MAX 128
+  char buf[ENCODING_MAX] = "";
+  char *p = buf;
+  int i;
+  XmlUtf8Convert(enc, &ptr, end, &p, p + ENCODING_MAX - 1);
+  if (ptr != end)
+    return 0;
+  *p = 0;
+  if (streqci(buf, KW_UTF_16) && enc->minBytesPerChar == 2)
+    return enc;
+  i = getEncodingIndex(buf);
+  if (i == UNKNOWN_ENC)
+    return 0;
+  return NS(encodings)[i];
+}
+
+int
+NS(XmlParseXmlDecl)(int isGeneralTextEntity, const ENCODING *enc,
+                    const char *ptr, const char *end, const char **badPtr,
+                    const char **versionPtr, const char **versionEndPtr,
+                    const char **encodingName, const ENCODING **encoding,
+                    int *standalone) {
+  return doParseXmlDecl(NS(findEncoding), isGeneralTextEntity, enc, ptr, end,
+                        badPtr, versionPtr, versionEndPtr, encodingName,
+                        encoding, standalone);
+}
+
+#endif /* XML_TOK_NS_C */
+
+#endif /* LV_USE_XML */
+
diff --git a/src/lv_conf_internal.h b/src/lv_conf_internal.h
index d8c2eb66e..44e74c0cd 100644
--- a/src/lv_conf_internal.h
+++ b/src/lv_conf_internal.h
@@ -3436,7 +3436,7 @@
 #endif
 #if LV_USE_FONT_MANAGER
 
-/*Font manager name max length*/
+/**Font manager name max length*/
 #ifndef LV_FONT_MANAGER_NAME_MAX_LEN
     #ifdef CONFIG_LV_FONT_MANAGER_NAME_MAX_LEN
         #define LV_FONT_MANAGER_NAME_MAX_LEN CONFIG_LV_FONT_MANAGER_NAME_MAX_LEN
@@ -3447,6 +3447,15 @@
 
 #endif
 
+/** Enable loading XML UIs runtime */
+#ifndef LV_USE_XML
+    #ifdef CONFIG_LV_USE_XML
+        #define LV_USE_XML CONFIG_LV_USE_XML
+    #else
+        #define LV_USE_XML	0
+    #endif
+#endif
+
 /*==================
  * DEVICES
  *==================*/
diff --git a/src/lv_init.c b/src/lv_init.c
index 69239f722..463001060 100644
--- a/src/lv_init.c
+++ b/src/lv_init.c
@@ -6,7 +6,6 @@
 /*********************
  *      INCLUDES
  *********************/
-#include "others/sysmon/lv_sysmon_private.h"
 #include "misc/lv_timer_private.h"
 #include "misc/lv_profiler_builtin_private.h"
 #include "misc/lv_anim_private.h"
@@ -39,6 +38,8 @@
 #include "themes/simple/lv_theme_simple.h"
 #include "misc/lv_fs.h"
 #include "osal/lv_os_private.h"
+#include "others/sysmon/lv_sysmon_private.h"
+#include "others/xml/lv_xml.h"
 
 #if LV_USE_NEMA_GFX
     #include "draw/nema_gfx/lv_draw_nema_gfx.h"
@@ -357,6 +358,10 @@ void lv_init(void)
     lv_ffmpeg_init();
 #endif
 
+#if LV_USE_XML
+    lv_xml_init();
+#endif
+
     lv_initialized = true;
 
     LV_LOG_TRACE("finished");
diff --git a/src/misc/lv_types.h b/src/misc/lv_types.h
index 91612f882..7250282ac 100644
--- a/src/misc/lv_types.h
+++ b/src/misc/lv_types.h
@@ -348,6 +348,11 @@ typedef struct _lv_sysmon_perf_info_t lv_sysmon_perf_info_t;
 
 #endif /*LV_USE_SYSMON*/
 
+
+typedef struct _lv_xml_component_ctx_t lv_xml_component_ctx_t;
+
+typedef struct _lv_xml_parser_state_t lv_xml_parser_state_t;
+
 #endif /*__ASSEMBLY__*/
 
 /**********************
diff --git a/src/others/xml/lv_xml.c b/src/others/xml/lv_xml.c
new file mode 100644
index 000000000..d937c548a
--- /dev/null
+++ b/src/others/xml/lv_xml.c
@@ -0,0 +1,389 @@
+/**
+ * @file lv_xml.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "lv_xml.h"
+#if LV_USE_XML
+
+#include "lv_xml_base_types.h"
+#include "lv_xml_parser.h"
+#include "lv_xml_component.h"
+#include "lv_xml_component_private.h"
+#include "lv_xml_widget.h"
+#include "lv_xml_style.h"
+#include "lv_xml.h"
+#include "lv_xml_utils.h"
+#include "lv_xml_private.h"
+#include "parsers/lv_xml_obj_parser.h"
+#include "parsers/lv_xml_button_parser.h"
+#include "parsers/lv_xml_label_parser.h"
+#include "parsers/lv_xml_image_parser.h"
+#include "parsers/lv_xml_slider_parser.h"
+#include "parsers/lv_xml_tabview_parser.h"
+#include "parsers/lv_xml_chart_parser.h"
+#include "../../libs/expat/expat.h"
+#include "../../draw/lv_draw_image.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static void view_start_element_handler(void * user_data, const char * name, const char ** attrs);
+static void view_end_element_handler(void * user_data, const char * name);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+static lv_ll_t font_ll;
+static lv_ll_t image_ll;
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_xml_init(void)
+{
+    lv_ll_init(&font_ll, sizeof(lv_xml_font_t));
+    lv_ll_init(&image_ll, sizeof(lv_xml_image_t));
+
+#if LV_FONT_MONTSERRAT_14
+    lv_xml_register_font("lv_montserrat_14", &lv_font_montserrat_14);
+#endif
+
+#if LV_FONT_MONTSERRAT_16
+    lv_xml_register_font("lv_montserrat_16", &lv_font_montserrat_16);
+#endif
+
+#if LV_FONT_MONTSERRAT_18
+    lv_xml_register_font("lv_montserrat_18", &lv_font_montserrat_18);
+#endif
+
+#if LV_FONT_MONTSERRAT_20
+    lv_xml_register_font("lv_montserrat_20", &lv_font_montserrat_20);
+#endif
+
+    lv_xml_component_init();
+
+    lv_xml_widget_register("lv_obj", lv_xml_obj_create, lv_xml_obj_apply);
+    lv_xml_widget_register("lv_button", lv_xml_button_create, lv_xml_button_apply);
+    lv_xml_widget_register("lv_label", lv_xml_label_create, lv_xml_label_apply);
+    lv_xml_widget_register("lv_image", lv_xml_image_create, lv_xml_image_apply);
+    lv_xml_widget_register("lv_slider", lv_xml_slider_create, lv_xml_slider_apply);
+    lv_xml_widget_register("lv_tabview", lv_xml_tabview_create, lv_xml_tabview_apply);
+    lv_xml_widget_register("lv_tabview-tab_bar", lv_xml_tabview_tab_bar_create, lv_xml_tabview_tab_bar_apply);
+    lv_xml_widget_register("lv_tabview-tab", lv_xml_tabview_tab_create, lv_xml_tabview_tab_apply);
+    lv_xml_widget_register("lv_chart", lv_xml_chart_create, lv_xml_chart_apply);
+    lv_xml_widget_register("lv_chart-cursor", lv_xml_chart_cursor_create, lv_xml_chart_cursor_apply);
+    lv_xml_widget_register("lv_chart-series", lv_xml_chart_series_create, lv_xml_chart_series_apply);
+}
+
+lv_obj_t * lv_xml_create_from_ctx(lv_obj_t * parent, lv_xml_component_ctx_t * parent_ctx, lv_xml_component_ctx_t * ctx,
+                                  const char ** attrs)
+{
+    /* Initialize the parser state */
+    lv_xml_parser_state_t state;
+    lv_xml_parser_state_init(&state);
+    state.ctx = *ctx;
+    state.parent = parent;
+    state.parent_attrs = attrs;
+    state.parent_ctx = parent_ctx;
+
+    lv_obj_t ** parent_node = lv_ll_ins_head(&state.parent_ll);
+    *parent_node = parent;
+
+    /* Create an XML parser and set handlers */
+    XML_Parser parser = XML_ParserCreate(NULL);
+    XML_SetUserData(parser, &state);
+    XML_SetElementHandler(parser, view_start_element_handler, view_end_element_handler);
+
+    /* Parse the XML */
+    if(XML_Parse(parser, ctx->view_def, lv_strlen(ctx->view_def), XML_TRUE) == XML_STATUS_ERROR) {
+        LV_LOG_WARN("XML parsing error: %s on line %lu", XML_ErrorString(XML_GetErrorCode(parser)),
+                    XML_GetCurrentLineNumber(parser));
+        XML_ParserFree(parser);
+        return NULL;
+    }
+
+    state.item = state.view;
+
+    if(attrs) {
+        ctx->root_widget->apply_cb(&state, attrs);
+    }
+
+    lv_ll_clear(&state.parent_ll);
+    XML_ParserFree(parser);
+
+    return state.view;
+}
+
+lv_obj_t * lv_xml_create(lv_obj_t * parent, const char * name, const char ** attrs)
+{
+    lv_obj_t * item = NULL;
+
+    /* Select the widget specific parser type based on the name */
+    lv_widget_processor_t * p = lv_xml_widget_get_processor(name);
+    if(p) {
+        lv_xml_parser_state_t state;
+        lv_xml_parser_state_init(&state);
+        state.parent = parent;
+        state.item = p->create_cb(&state, attrs);
+        if(attrs) {
+            p->apply_cb(&state, attrs);
+        }
+        return state.item;
+    }
+
+    lv_xml_component_ctx_t * ctx = lv_xml_component_get_ctx(name);
+    if(ctx) {
+        item = lv_xml_create_from_ctx(parent, NULL, ctx, attrs);
+        return item;
+    }
+
+    /* If it isn't a component either then it is unknown */
+    LV_LOG_WARN("'%s' in not a known widget, element, or component", name);
+    return NULL;
+}
+
+
+lv_result_t lv_xml_register_font(const char * name, const lv_font_t * font)
+{
+    lv_xml_font_t * f = lv_ll_ins_head(&font_ll);
+    f->name = lv_strdup(name);
+    f->font = font;
+
+    return LV_RESULT_OK;
+}
+
+const lv_font_t * lv_xml_get_font(const char * name)
+{
+    lv_xml_font_t * f;
+    LV_LL_READ(&font_ll, f) {
+        if(lv_streq(f->name, name)) return f->font;
+    }
+
+    return NULL;
+}
+
+lv_result_t lv_xml_register_image(const char * name, const void * src)
+{
+    lv_xml_image_t * img = lv_ll_ins_head(&image_ll);
+    img->name = lv_strdup(name);
+    if(lv_image_src_get_type(src) == LV_IMAGE_SRC_FILE) {
+        img->src = lv_strdup(src);
+    }
+    else {
+        img->src = src;
+    }
+
+    return LV_RESULT_OK;
+}
+
+const void * lv_xml_get_image(const char * name)
+{
+    lv_xml_image_t * img;
+    LV_LL_READ(&image_ll, img) {
+        if(lv_streq(img->name, name)) return img->src;
+    }
+
+    return NULL;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static const char * get_param_type(lv_xml_component_ctx_t * ctx, const char * name)
+{
+    lv_xml_param_t * p;
+    LV_LL_READ(&ctx->param_ll, p) {
+        if(lv_streq(p->name, name)) return p->type;
+    }
+    return NULL;
+}
+
+static const char * get_param_default(lv_xml_component_ctx_t * ctx, const char * name)
+{
+    lv_xml_param_t * p;
+    LV_LL_READ(&ctx->param_ll, p) {
+        if(lv_streq(p->name, name)) return p->def;
+    }
+    return NULL;
+}
+
+static void resolve_params(lv_xml_component_ctx_t * item_ctx, lv_xml_component_ctx_t * parent_ctx,
+                           const char ** item_attrs, const char ** parent_attrs)
+{
+    uint32_t i;
+    for(i = 0; item_attrs[i]; i += 2) {
+        const char * name = item_attrs[i];
+        const char * value = item_attrs[i + 1];
+        if(lv_streq(name, "styles")) continue; /*Styles will handle it themselves*/
+        if(value[0] == '$') {
+            /*E.g. the ${my_color} value is the my_color attribute name on the parent*/
+            const char * name_clean = &value[1]; /*skips `$`*/
+
+            const char * type = get_param_type(item_ctx, name_clean);
+            if(type == NULL) {
+                LV_LOG_WARN("'%s' parameter is not defined on '%s'", name_clean, item_ctx->name);
+            }
+            const char * ext_value = lv_xml_get_value_of(parent_attrs, name_clean);
+            if(ext_value) {
+                /*If the value is not resolved earlier (e.g. it's a top level element created manually)
+                 * use the default value*/
+                if(ext_value[0] == '#' || ext_value[0] == '$') {
+                    ext_value = get_param_default(item_ctx, name_clean);
+                }
+                else if(lv_streq(type, "style")) {
+                    lv_xml_style_t * s = lv_xml_get_style_by_name(parent_ctx, ext_value);
+                    ext_value = s->long_name;
+                }
+            }
+            else {
+                /*If the API attribute is not provide don't set it*/
+                ext_value = get_param_default(item_ctx, name_clean);
+            }
+            if(ext_value) {
+                item_attrs[i + 1] = ext_value;
+            }
+            else {
+                /*Not set and no default value either
+                 *Don't set this property*/
+                item_attrs[i] = "";
+                item_attrs[i + 1] = "";
+            }
+        }
+    }
+}
+
+static void resolve_consts(const char ** item_attrs, lv_xml_component_ctx_t * ctx)
+{
+    uint32_t i;
+    for(i = 0; item_attrs[i]; i += 2) {
+        const char * name = item_attrs[i];
+        const char * value = item_attrs[i + 1];
+        if(lv_streq(name, "styles")) continue; /*Styles will handle it themselves*/
+        if(value[0] == '#') {
+            const char * value_clean = &value[1];
+
+            lv_xml_const_t * c;
+            LV_LL_READ(&ctx->const_ll, c) {
+                if(lv_streq(c->name, value_clean)) {
+                    item_attrs[i + 1] = c->value;
+                    break;
+                }
+            }
+
+            /*If the const attribute is not provide don't set it*/
+            if(c == NULL) {
+                item_attrs[i] = "";
+                item_attrs[i + 1] = "";
+            }
+        }
+    }
+}
+
+static void view_start_element_handler(void * user_data, const char * name, const char ** attrs)
+{
+    lv_xml_parser_state_t * state = (lv_xml_parser_state_t *)user_data;
+    bool is_view = false;
+
+    if(lv_streq(name, "view")) {
+        const char * extends = lv_xml_get_value_of(attrs, "extends");
+        name = extends ? extends : "lv_obj";
+        is_view = true;
+    }
+
+    lv_obj_t ** current_parent_p = lv_ll_get_tail(&state->parent_ll);
+    if(current_parent_p == NULL) {
+        if(state->parent == NULL) {
+            LV_LOG_ERROR("There is no parent object available for %s. This also should never happen.", name);
+            return;
+        }
+        else {
+            current_parent_p = &state->parent;
+        }
+    }
+    else {
+        state->parent = *current_parent_p;
+    }
+
+    /*In `state->attrs` we have parameters of the component creation
+     *E.g. <my_button x="10" title="Hello"/>
+     *In `attrs` we have the attributes of child of the view.
+     *E.g. in `my_button` `<lv_label x="5" text="${title}".
+     *This function changes the pointers in the child attributes if the start with '$'
+     *with the corresponding parameter. E.g. "text", "${title}" -> "text", "Hello" */
+    resolve_params(&state->ctx, state->parent_ctx, attrs, state->parent_attrs);
+
+    resolve_consts(attrs, &state->ctx);
+
+    void * item = NULL;
+    /* Select the widget specific parser type based on the name */
+    lv_widget_processor_t * p = lv_xml_widget_get_processor(name);
+    if(p) {
+        item = p->create_cb(state, attrs);
+        state->item = item;
+
+
+        /*If it's a widget remove all styles. E.g. if it extends an `lv_button`
+         *now it has the button theme styles. However if it were a real widget
+         *it had e.g. `my_widget_class` so the button's theme wouldn't apply on it.
+         *Removing the style will ensure a better preview*/
+        if(state->ctx.is_widget) lv_obj_remove_style_all(item);
+
+        /*Apply the attributes from e.g. `<lv_slider value="30" x="20">`*/
+        if(item) {
+            p->apply_cb(state, attrs);
+        }
+    }
+
+    /* If not a widget, check if it is a component */
+    if(item == NULL) {
+        item = lv_xml_component_process(state, name, attrs);
+        state->item = item;
+    }
+
+    /* If it isn't a component either then it is unknown */
+    if(item == NULL) {
+        LV_LOG_WARN("'%s' in not a known widget, element, or component", name);
+        return;
+    }
+
+    void ** new_parent = lv_ll_ins_tail(&state->parent_ll);
+    *new_parent = item;
+
+    if(is_view) {
+        state->view = item;
+    }
+}
+
+static void view_end_element_handler(void * user_data, const char * name)
+{
+    LV_UNUSED(name);
+
+    lv_xml_parser_state_t * state = (lv_xml_parser_state_t *)user_data;
+
+    lv_obj_t ** current_parent = lv_ll_get_tail(&state->parent_ll);
+    if(current_parent) {
+        lv_ll_remove(&state->parent_ll, current_parent);
+        lv_free(current_parent);
+    }
+}
+
+#endif /* LV_USE_XML */
diff --git a/src/others/xml/lv_xml.h b/src/others/xml/lv_xml.h
new file mode 100644
index 000000000..1b5646097
--- /dev/null
+++ b/src/others/xml/lv_xml.h
@@ -0,0 +1,57 @@
+/**
+ * @file lv_xml.h
+ *
+ */
+
+#ifndef LV_XML_H
+#define LV_XML_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../../misc/lv_types.h"
+#if LV_USE_XML
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void lv_xml_init(void);
+
+lv_obj_t * lv_xml_create(lv_obj_t * parent, const char * name, const char ** attrs);
+
+lv_obj_t * lv_xml_create_from_ctx(lv_obj_t * parent, lv_xml_component_ctx_t * parent_ctx, lv_xml_component_ctx_t * ctx,
+                                  const char ** attrs);
+
+lv_result_t lv_xml_register_font(const char * name, const lv_font_t * font);
+
+const lv_font_t * lv_xml_get_font(const char * name);
+
+lv_result_t lv_xml_register_image(const char * name, const void * src);
+
+const void * lv_xml_get_image(const char * name);
+
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /* LV_USE_XML */
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_XML_H*/
diff --git a/src/others/xml/lv_xml_base_types.c b/src/others/xml/lv_xml_base_types.c
new file mode 100644
index 000000000..b1aa834af
--- /dev/null
+++ b/src/others/xml/lv_xml_base_types.c
@@ -0,0 +1,111 @@
+/**
+ * @file lv_xml_base_parser.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../../lvgl.h"
+#if LV_USE_XML
+
+#include "lv_xml_base_types.h"
+#include "lv_xml_private.h"
+#include "lv_xml_parser.h"
+#include "lv_xml_style.h"
+#include "lv_xml_component_private.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+int32_t lv_xml_to_size(const char * txt)
+{
+    if(lv_streq(txt, "content")) return LV_SIZE_CONTENT;
+
+    int32_t v = lv_xml_atoi(txt);
+    if(txt[lv_strlen(txt) - 1] == '%') return lv_pct(v);
+    else return v;
+}
+
+lv_align_t lv_xml_align_string_to_enum_value(const char * txt)
+{
+    if(lv_streq("top_left", txt)) return LV_ALIGN_TOP_LEFT;
+    if(lv_streq("top_mid", txt)) return LV_ALIGN_TOP_MID;
+    if(lv_streq("top_right", txt)) return LV_ALIGN_TOP_LEFT;
+    if(lv_streq("bottom_left", txt)) return LV_ALIGN_BOTTOM_LEFT;
+    if(lv_streq("bottom_mid", txt)) return LV_ALIGN_BOTTOM_MID;
+    if(lv_streq("bottom_right", txt)) return LV_ALIGN_BOTTOM_RIGHT;
+    if(lv_streq("right_mid", txt)) return LV_ALIGN_RIGHT_MID;
+    if(lv_streq("left_mid", txt)) return LV_ALIGN_LEFT_MID;
+    if(lv_streq("center", txt)) return LV_ALIGN_CENTER;
+
+    LV_LOG_WARN("%s is an unknown value for align", txt);
+    return 0; /*Return 0 in lack of a better option. */
+}
+
+lv_dir_t lv_xml_dir_string_to_enum_value(const char * txt)
+{
+    if(lv_streq("top", txt)) return LV_DIR_TOP;
+    if(lv_streq("bottom", txt)) return LV_DIR_BOTTOM;
+    if(lv_streq("left", txt)) return LV_DIR_LEFT;
+    if(lv_streq("right", txt)) return LV_DIR_RIGHT;
+    if(lv_streq("all", txt)) return LV_DIR_ALL;
+
+    LV_LOG_WARN("%s is an unknown value for dir", txt);
+    return 0; /*Return 0 in lack of a better option. */
+}
+
+lv_flex_flow_t lv_xml_flex_flow_string_to_enum_value(const char * txt)
+{
+    if(lv_streq("column", txt)) return LV_FLEX_FLOW_COLUMN;
+    if(lv_streq("column_reverse", txt)) return LV_FLEX_FLOW_COLUMN_REVERSE;
+    if(lv_streq("column_wrap", txt)) return LV_FLEX_FLOW_COLUMN_WRAP;
+    if(lv_streq("column_wrap_reverse", txt)) return LV_FLEX_FLOW_COLUMN_WRAP_REVERSE;
+    if(lv_streq("row", txt)) return LV_FLEX_FLOW_ROW;
+    if(lv_streq("row_reverse", txt)) return LV_FLEX_FLOW_ROW_REVERSE;
+    if(lv_streq("row_wrap", txt)) return LV_FLEX_FLOW_ROW_WRAP;
+    if(lv_streq("row_wrap_reverse", txt)) return LV_FLEX_FLOW_ROW_WRAP_REVERSE;
+
+    LV_LOG_WARN("%s is an unknown value for flex flow", txt);
+    return 0; /*Return 0 in lack of a better option. */
+}
+
+lv_flex_align_t lv_xml_flex_align_string_to_enum_value(const char * txt)
+{
+    if(lv_streq("center", txt)) return LV_FLEX_ALIGN_CENTER;
+    if(lv_streq("end", txt)) return LV_FLEX_ALIGN_END;
+    if(lv_streq("start", txt)) return LV_FLEX_ALIGN_START;
+    if(lv_streq("space_around", txt)) return LV_FLEX_ALIGN_SPACE_AROUND;
+    if(lv_streq("space_between", txt)) return LV_FLEX_ALIGN_SPACE_BETWEEN;
+    if(lv_streq("space_evenly", txt)) return LV_FLEX_ALIGN_SPACE_EVENLY;
+
+    LV_LOG_WARN("%s is an unknown value for flex align", txt);
+    return 0; /*Return 0 in lack of a better option. */
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+#endif /* LV_USE_XML */
diff --git a/src/others/xml/lv_xml_base_types.h b/src/others/xml/lv_xml_base_types.h
new file mode 100644
index 000000000..bd8bd6863
--- /dev/null
+++ b/src/others/xml/lv_xml_base_types.h
@@ -0,0 +1,76 @@
+/**
+ * @file lv_xml_base_types.h
+ *
+ */
+
+#ifndef LV_XML_BASE_TYPES_H
+#define LV_XML_BASE_TYPES_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../../misc/lv_types.h"
+#include "../../misc/lv_style.h"
+#if LV_USE_XML
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Process inputs "content", "32", "32px", or "25%"
+ * and convert them to integer
+ * @param txt       the input string
+ * @return          the integer size
+ */
+int32_t lv_xml_to_size(const char * txt);
+
+
+/**
+ * Convert an align string to enum
+ * @param txt       e.g. "center"
+ * @return          the related enum, e.g. `LV_ALIGN_CENTER`
+ */
+lv_align_t lv_xml_align_string_to_enum_value(const char * txt);
+
+/**
+ * Convert a direction string to enum
+ * @param txt       e.g. "top"
+ * @return          the related enum, e.g. `LV_DIR_TOP`
+ */
+lv_dir_t lv_xml_dir_string_to_enum_value(const char * txt);
+
+
+/**
+ * Convert a flex flow string to enum
+ * @param txt       e.g. "row_wrap"
+ * @return          the related enum, e.g. `LV_FLEX_FLOW_ROW_WRAP`
+ */
+lv_flex_flow_t lv_xml_flex_flow_string_to_enum_value(const char * txt);
+
+/**
+ * Convert a flex align string to enum
+ * @param txt       e.g. "space_between"
+ * @return          the related enum, e.g. `LV_FLEX_ALIGN_SPACE_BETWEEN`
+ */
+lv_flex_align_t lv_xml_flex_align_string_to_enum_value(const char * txt);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /* LV_USE_XML */
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_XML_BASE_TYPES_H*/
diff --git a/src/others/xml/lv_xml_component.c b/src/others/xml/lv_xml_component.c
new file mode 100644
index 000000000..439fdd8a2
--- /dev/null
+++ b/src/others/xml/lv_xml_component.c
@@ -0,0 +1,306 @@
+/**
+ * @file lv_xml_component.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_xml_component.h"
+#if LV_USE_XML
+
+#include "lv_xml_component_private.h"
+#include "lv_xml_private.h"
+#include "lv_xml_parser.h"
+#include "lv_xml_style.h"
+#include "lv_xml_base_types.h"
+#include "lv_xml_widget.h"
+#include "parsers/lv_xml_obj_parser.h"
+#include "../../libs/expat/expat.h"
+#include "../../misc/lv_fs.h"
+#include <string.h>
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static void start_metadata_handler(void * user_data, const char * name, const char ** attrs);
+static void end_metadata_handler(void * user_data, const char * name);
+static void process_const_element(lv_xml_parser_state_t * state, const char ** attrs);
+static void process_prop_element(lv_xml_parser_state_t * state, const char ** attrs);
+static char * extract_view_content(const char * xml_definition);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+static lv_ll_t component_ctx_ll;
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_xml_component_init(void)
+{
+    lv_ll_init(&component_ctx_ll, sizeof(lv_xml_component_ctx_t));
+}
+
+
+lv_obj_t * lv_xml_component_process(lv_xml_parser_state_t * state, const char * name, const char ** attrs)
+{
+    lv_xml_component_ctx_t * ctx = lv_xml_component_get_ctx(name);
+    if(ctx == NULL) return NULL;
+    lv_obj_t * item = lv_xml_create_from_ctx(state->parent, &state->ctx, ctx, attrs);
+    if(item == NULL) {
+        LV_LOG_WARN("Couldn't create component '%s'", name);
+        return NULL;
+    }
+
+    /* Apply the properties of the component, e.g. <my_button x="20" styles="red"/> */
+    state->item = item;
+    ctx->root_widget->apply_cb(state, attrs);
+
+    return item;
+}
+
+lv_xml_component_ctx_t * lv_xml_component_get_ctx(const char * component_name)
+{
+    lv_xml_component_ctx_t * ctx;
+    LV_LL_READ(&component_ctx_ll, ctx) {
+        if(lv_streq(ctx->name, component_name)) return ctx;
+    }
+
+    return NULL;
+}
+
+lv_result_t lv_xml_component_register_from_data(const char * name, const char * xml_def)
+{
+    /* Create a temporary parser state to extract styles/params/consts */
+    lv_xml_parser_state_t state;
+    lv_xml_parser_state_init(&state);
+    state.ctx.name = name;
+
+    /* Parse the XML to extract metadata */
+    XML_Parser parser = XML_ParserCreate(NULL);
+    XML_SetUserData(parser, &state);
+    XML_SetElementHandler(parser, start_metadata_handler, end_metadata_handler);
+
+    if(XML_Parse(parser, xml_def, lv_strlen(xml_def), XML_TRUE) == XML_STATUS_ERROR) {
+        LV_LOG_WARN("XML parsing error: %s on line %lu",
+                    XML_ErrorString(XML_GetErrorCode(parser)),
+                    (unsigned long)XML_GetCurrentLineNumber(parser));
+        XML_ParserFree(parser);
+        return LV_RESULT_INVALID;
+    }
+
+    XML_ParserFree(parser);
+
+    /* Copy extracted metadata to component processor */
+    lv_xml_component_ctx_t * ctx = lv_ll_ins_head(&component_ctx_ll);
+    lv_memzero(ctx, sizeof(lv_xml_component_ctx_t));
+    lv_memcpy(ctx, &state.ctx, sizeof(lv_xml_component_ctx_t));
+
+    /* Extract view content directly instead of using XML parser */
+    ctx->view_def = extract_view_content(xml_def);
+    ctx->name = lv_strdup(name);
+    if(!ctx->view_def) {
+        LV_LOG_WARN("Failed to extract view content");
+        /* Clean up and return error */
+        lv_free(ctx);
+        return LV_RESULT_INVALID;
+    }
+
+    return LV_RESULT_OK;
+}
+
+
+lv_result_t lv_xml_component_register_from_file(const char * path)
+{
+    /* Extract component name from path */
+    /* Create a copy of the filename to modify */
+    char * filename = lv_strdup(lv_fs_get_last(path));
+    const char * ext = lv_fs_get_ext(filename);
+    filename[lv_strlen(filename) - lv_strlen(ext) - 1] = '\0'; /*Trim the extension*/
+
+    lv_fs_res_t fs_res;
+    lv_fs_file_t f;
+    fs_res = lv_fs_open(&f, path, LV_FS_MODE_RD);
+    if(fs_res != LV_FS_RES_OK) {
+        LV_LOG_WARN("Couldn't open %s", path);
+        lv_free(filename);
+        return LV_RESULT_INVALID;
+    }
+
+    /* Determine file size */
+    lv_fs_seek(&f, 0, LV_FS_SEEK_END);
+    uint32_t file_size = 0;
+    lv_fs_tell(&f, &file_size);
+    lv_fs_seek(&f, 0, LV_FS_SEEK_SET);
+
+    /* Create the buffer */
+    char * xml_buf = lv_malloc(file_size + 1);
+    if(xml_buf == NULL) {
+        LV_LOG_WARN("Memory allocation failed for file %s (%d bytes)", path, file_size + 1);
+        lv_free(filename);
+        lv_fs_close(&f);
+        return LV_RESULT_INVALID;
+    }
+
+    /* Read the file content  */
+    uint32_t rn;
+    lv_fs_read(&f, xml_buf, file_size, &rn);
+    if(rn != file_size) {
+        LV_LOG_WARN("Couldn't read %s fully", path);
+        lv_free(filename);
+        lv_free(xml_buf);
+        lv_fs_close(&f);
+        return LV_RESULT_INVALID;
+    }
+
+    /* Null-terminate the buffer */
+    xml_buf[rn] = '\0';
+
+    /* Register the component */
+    lv_result_t res = lv_xml_component_register_from_data(filename, xml_buf);
+
+    /* Housekeeping */
+    lv_free(filename);
+    lv_free(xml_buf);
+    lv_fs_close(&f);
+
+    return res;
+}
+
+lv_result_t lv_xml_component_unregister(const char * name)
+{
+    lv_xml_component_ctx_t * ctx = lv_xml_component_get_ctx(name);
+    if(ctx == NULL) return LV_RESULT_INVALID;
+
+    lv_ll_remove(&component_ctx_ll, ctx);
+
+    lv_free((char *)ctx->name);
+    lv_free((char *)ctx->view_def);
+    lv_ll_clear(&ctx->param_ll);
+    lv_ll_clear(&ctx->style_ll);
+    lv_free(ctx);
+
+    return LV_RESULT_OK;
+}
+
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static void process_const_element(lv_xml_parser_state_t * state, const char ** attrs)
+{
+    const char * name = lv_xml_get_value_of(attrs, "name");
+    const char * value = lv_xml_get_value_of(attrs, "value");
+
+    if(name == NULL) {
+        LV_LOG_WARN("'name' is missing from a constant");
+        return;
+    }
+    if(value == NULL) {
+        LV_LOG_WARN("'value' is missing from a constant");
+        return;
+    }
+
+    lv_xml_const_t * cnst = lv_ll_ins_tail(&state->ctx.const_ll);
+    cnst->name = lv_strdup(name);
+    cnst->value = lv_strdup(value);
+}
+
+static void process_prop_element(lv_xml_parser_state_t * state, const char ** attrs)
+{
+    lv_xml_param_t * cnst = lv_ll_ins_tail(&state->ctx.param_ll);
+    cnst->name = lv_strdup(lv_xml_get_value_of(attrs, "name"));
+    const char * def = lv_xml_get_value_of(attrs, "default");
+    if(def) cnst->def = lv_strdup(def);
+    else cnst->def = NULL;
+
+    const char * type = lv_xml_get_value_of(attrs, "type");
+    if(type == NULL) type = "compound"; /*If there in no type it means there are <param>s*/
+    cnst->type = lv_strdup(lv_xml_get_value_of(attrs, "type"));
+}
+
+static void start_metadata_handler(void * user_data, const char * name, const char ** attrs)
+{
+    lv_xml_parser_state_t * state = (lv_xml_parser_state_t *)user_data;
+
+    lv_xml_parser_section_t old_section = state->section;
+    lv_xml_parser_start_section(state, name);
+    if(lv_streq(name, "view")) {
+        const char * extends = lv_xml_get_value_of(attrs, "extends");
+        if(extends == NULL) extends = "lv_obj";
+        state->ctx.root_widget = lv_xml_widget_get_processor(extends);
+    }
+
+    if(lv_streq(name, "widget")) state->ctx.is_widget = 1;
+
+    if(old_section != state->section) return;   /*Ignore the section opening, e.g. <styles>*/
+
+    /* Process elements based on current context */
+    switch(state->section) {
+        case LV_XML_PARSER_SECTION_API:
+            process_prop_element(state, attrs);
+            break;
+
+        case LV_XML_PARSER_SECTION_CONSTS:
+            process_const_element(state, attrs);
+            break;
+
+        case LV_XML_PARSER_SECTION_STYLES:
+            if(lv_streq(name, "style")) {
+                lv_xml_style_register(&state->ctx, attrs);
+            }
+            break;
+
+        default:
+            break;
+    }
+}
+
+static void end_metadata_handler(void * user_data, const char * name)
+{
+    lv_xml_parser_state_t * state = (lv_xml_parser_state_t *)user_data;
+    lv_xml_parser_end_section(state, name);
+}
+
+static char * extract_view_content(const char * xml_definition)
+{
+    if(!xml_definition) return NULL;
+
+    /* Find start of view tag */
+    const char * start = strstr(xml_definition, "<view");
+    if(!start) return NULL;
+
+    /* Find end of view tag */
+    const char * end = strstr(xml_definition, "</view>");
+    if(!end) return NULL;
+    end += 7; /* Include "</view>" in result */
+
+    /* Calculate and allocate length */
+    size_t len = end - start;
+    char * view_content = lv_malloc(len + 1);
+    if(!view_content) return NULL;
+
+    /* Copy content and null terminate */
+    lv_memcpy(view_content, start, len);
+    view_content[len] = '\0';
+
+    return view_content;
+}
+
+#endif /* LV_USE_XML */
diff --git a/src/others/xml/lv_xml_component.h b/src/others/xml/lv_xml_component.h
new file mode 100644
index 000000000..16ed1b2ac
--- /dev/null
+++ b/src/others/xml/lv_xml_component.h
@@ -0,0 +1,78 @@
+/**
+ * @file lv_xml_component.h
+ *
+ */
+
+#ifndef LV_LABEL_XML_COMPONENT_H
+#define LV_LABEL_XML_COMPONENT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../../misc/lv_types.h"
+#if LV_USE_XML
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Process a component during parsing an XML. It create a widget and apply all the attributes
+ * @param state     the current parsing state
+ * @param name      name of the component
+ * @param attrs     attributes of the widget
+ * @return
+ */
+lv_obj_t * lv_xml_component_process(lv_xml_parser_state_t * state, const char * name, const char ** attrs);
+
+/**
+ * Load the styles, constants, another data of the component. It needs to be called only once for each component.
+ * @param name      the name as the component will be referenced later in other components
+ * @param xml_def   the XML definition of the component as a NULL terminated string
+ * @return          LV_RES_OK: loaded successfully, LV_RES_INVALID: otherwise
+ */
+lv_result_t lv_xml_component_register_from_data(const char * name, const char * xml_def);
+
+/**
+ * Load the styles, constants, another data of the component. It needs to be called only once for each component.
+ * @param path      path to an XML file
+ * @return          LV_RES_OK: loaded successfully, LV_RES_INVALID: otherwise
+ */
+lv_result_t lv_xml_component_register_from_file(const char * path);
+
+/**
+ * Get the ctx of a component which was registered by
+ * `lv_xml_component_register_from_data` or `lv_xml_component_register_from_file`
+ * @param component_name    name of the component
+ * @return                  pointer the ctx or NULL if not found
+ */
+lv_xml_component_ctx_t * lv_xml_component_get_ctx(const char * component_name);
+
+/**
+ * Remove a component from from the list.
+ * @param name      the name of the component (used during registration)
+ * @return          LV_RESULT_OK on successful  unregistration, LV_RESULT_INVALID otherwise.
+ */
+lv_result_t lv_xml_component_unregister(const char * name);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /* LV_USE_XML */
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_XML_COMPONENT_H*/
+
+
diff --git a/src/others/xml/lv_xml_component_private.h b/src/others/xml/lv_xml_component_private.h
new file mode 100644
index 000000000..f3a12aaf6
--- /dev/null
+++ b/src/others/xml/lv_xml_component_private.h
@@ -0,0 +1,58 @@
+/**
+ * @file lv_xml_component_private.h
+ *
+ */
+
+#ifndef LV_XML_COMPONENT_PRIVATE_H
+#define LV_XML_COMPONENT_PRIVATE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_xml.h"
+#if LV_USE_XML
+
+#include "lv_xml_utils.h"
+#include "../../misc/lv_ll.h"
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef  void * (*lv_xml_component_process_cb_t)(lv_obj_t * parent, const char * data, const char ** attrs);
+
+struct _lv_xml_component_ctx_t {
+    const char * name;
+    lv_ll_t style_ll;
+    lv_ll_t const_ll;
+    lv_ll_t param_ll;
+    const char * view_def;
+    struct _lv_widget_processor_t * root_widget;
+    uint32_t is_widget : 1;                         /*1: not component but widget registered as a component for preview*/
+    struct _lv_xml_component_ctx_t * next;
+};
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Initialize the components system.
+ */
+void lv_xml_component_init(void);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /* LV_USE_XML */
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_XML_COMPONENT_PRIVATE_H*/
diff --git a/src/others/xml/lv_xml_parser.c b/src/others/xml/lv_xml_parser.c
new file mode 100644
index 000000000..63d6c0e9f
--- /dev/null
+++ b/src/others/xml/lv_xml_parser.c
@@ -0,0 +1,98 @@
+/**
+ * @file lv_xml.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_xml.h"
+#if LV_USE_XML
+
+#include "lv_xml_private.h"
+#include "lv_xml_parser.h"
+#include "lv_xml_style.h"
+#include "lv_xml_component_private.h"
+#include "lv_xml_base_types.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_xml_parser_state_init(lv_xml_parser_state_t * state)
+{
+    lv_memzero(state, sizeof(lv_xml_parser_state_t));
+    lv_ll_init(&state->ctx.style_ll, sizeof(lv_xml_style_t));
+    lv_ll_init(&state->ctx.const_ll, sizeof(lv_xml_const_t));
+    lv_ll_init(&state->ctx.param_ll, sizeof(lv_xml_param_t));
+    lv_ll_init(&state->parent_ll, sizeof(lv_obj_t *));
+}
+
+void lv_xml_parser_start_section(lv_xml_parser_state_t * state, const char * name)
+{
+    /* Check for context changes */
+    if(lv_streq(name, "api")) {
+        state->section = LV_XML_PARSER_SECTION_API;
+        return;
+    }
+    else if(lv_streq(name, "consts")) {
+        state->section = LV_XML_PARSER_SECTION_CONSTS;
+        return;
+    }
+    else if(lv_streq(name, "styles")) {
+        state->section = LV_XML_PARSER_SECTION_STYLES;
+        return;
+    }
+    else if(lv_streq(name, "view")) {
+        state->section = LV_XML_PARSER_SECTION_VIEW;
+        return;
+    }
+}
+
+void lv_xml_parser_end_section(lv_xml_parser_state_t * state, const char * name)
+{
+
+    /* Reset context when leaving a block */
+    if(lv_streq(name, "params") ||
+       lv_streq(name, "consts") ||
+       lv_streq(name, "styles") ||
+       lv_streq(name, "view")) {
+        state->section = LV_XML_PARSER_SECTION_NONE;
+    }
+}
+
+void * lv_xml_state_get_parent(lv_xml_parser_state_t * state)
+{
+    return state->parent;
+}
+
+void * lv_xml_state_get_item(lv_xml_parser_state_t * state)
+{
+    return state->item;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+#endif /* LV_USE_XML */
diff --git a/src/others/xml/lv_xml_parser.h b/src/others/xml/lv_xml_parser.h
new file mode 100644
index 000000000..5c5f7c00a
--- /dev/null
+++ b/src/others/xml/lv_xml_parser.h
@@ -0,0 +1,84 @@
+/**
+ * @file lv_xml_parser.h
+ *
+ */
+
+#ifndef LV_XML_PARSER_H
+#define LV_XML_PARSER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../../misc/lv_types.h"
+#if LV_USE_XML
+
+#include "lv_xml_component.h"
+#include "lv_xml_component_private.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef enum {
+    LV_XML_PARSER_SECTION_NONE,
+    LV_XML_PARSER_SECTION_API,
+    LV_XML_PARSER_SECTION_CONSTS,
+    LV_XML_PARSER_SECTION_STYLES,
+    LV_XML_PARSER_SECTION_VIEW
+} lv_xml_parser_section_t;
+
+struct _lv_xml_parser_state_t {
+    lv_xml_component_ctx_t ctx;
+    lv_ll_t parent_ll;
+    lv_obj_t * parent;
+    lv_obj_t * item;
+    lv_obj_t * view;    /*Pointer to the created view during component creation*/
+    const char ** parent_attrs;
+    lv_xml_component_ctx_t * parent_ctx;
+    lv_xml_parser_section_t section;
+};
+
+typedef struct {
+    const char * name;
+    const char * value;
+} lv_xml_const_t;
+
+typedef struct {
+    const char * name;
+    const char * def;
+    const char * type;
+} lv_xml_param_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void lv_xml_parser_state_init(lv_xml_parser_state_t * state);
+
+void lv_xml_parser_start_section(lv_xml_parser_state_t * state, const char * name);
+
+void lv_xml_parser_end_section(lv_xml_parser_state_t * state, const char * name);
+
+void * lv_xml_state_get_parent(lv_xml_parser_state_t * state);
+
+void * lv_xml_state_get_item(lv_xml_parser_state_t * state);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /* LV_USE_XML */
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_XML_PARSER_H*/
diff --git a/src/others/xml/lv_xml_private.h b/src/others/xml/lv_xml_private.h
new file mode 100644
index 000000000..ad67f9bf2
--- /dev/null
+++ b/src/others/xml/lv_xml_private.h
@@ -0,0 +1,58 @@
+/**
+ * @file lv_xml_ptivate.h
+ *
+ */
+
+#ifndef LV_XML_PRIVATE_H
+#define LV_XML_PRIVATE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_xml.h"
+#if LV_USE_XML
+
+#include "parsers/lv_xml_obj_parser.h"
+#include "lv_xml_parser.h"
+#include "lv_xml_base_types.h"
+#include "lv_xml_utils.h"
+#include "lv_xml_style.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct {
+    const char * name;
+    const lv_font_t * font;
+} lv_xml_font_t;
+
+typedef struct {
+    const char * name;
+    const void * src;
+} lv_xml_image_t;
+
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /* LV_USE_XML */
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_XML_PRIVATE_H*/
diff --git a/src/others/xml/lv_xml_style.c b/src/others/xml/lv_xml_style.c
new file mode 100644
index 000000000..aaf294b0f
--- /dev/null
+++ b/src/others/xml/lv_xml_style.c
@@ -0,0 +1,202 @@
+/**
+ * @file lv_xml_style.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../../lvgl.h"
+#if LV_USE_XML
+
+#include "lv_xml_base_types.h"
+#include "lv_xml_parser.h"
+#include "lv_xml_style.h"
+#include "lv_xml_utils.h"
+#include "lv_xml_component_private.h"
+#include <string.h>
+
+/*********************
+ *      DEFINES
+ *********************/
+#ifdef _MSC_VER
+    #define strtok_r strtok_s  // Use strtok_s as an equivalent to strtok_r in Visual Studio
+#endif
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+lv_state_t lv_xml_style_state_string_to_enum_value(const char * txt)
+{
+    if(lv_streq("default", txt)) return LV_STATE_DEFAULT;
+    if(lv_streq("pressed", txt)) return LV_STATE_PRESSED;
+    if(lv_streq("checked", txt)) return LV_STATE_CHECKED;
+    if(lv_streq("scrolled", txt)) return LV_STATE_SCROLLED;
+
+    return 0; /*Return 0 in lack of a better option. */
+}
+
+lv_part_t lv_xml_style_part_string_to_enum_value(const char * txt)
+{
+    if(lv_streq("main", txt)) return LV_PART_MAIN;
+    if(lv_streq("scrollbar", txt)) return LV_PART_SCROLLBAR;
+    if(lv_streq("indicator", txt)) return LV_PART_INDICATOR;
+    if(lv_streq("knob", txt)) return LV_PART_KNOB;
+
+    return 0; /*Return 0 in lack of a better option. */
+}
+
+void lv_xml_style_register(lv_xml_component_ctx_t * ctx, const char ** attrs)
+{
+    const char * style_name =  lv_xml_get_value_of(attrs, "name");
+    if(style_name == NULL) {
+        LV_LOG_WARN("'name' is missing from a style");
+        return;
+    }
+    lv_xml_style_t * xml_style = lv_ll_ins_tail(&ctx->style_ll);
+    lv_style_t * style = &xml_style->style;
+    lv_style_init(style);
+    xml_style->name = lv_strdup(style_name);
+
+    size_t long_name_len = lv_strlen(ctx->name) + 1 + lv_strlen(style_name) + 1;
+    xml_style->long_name = lv_malloc(long_name_len);
+    lv_snprintf((char *)xml_style->long_name, long_name_len, "%s.%s", ctx->name, style_name); /*E.g. my_button.style1*/
+
+    for(int i = 0; attrs[i]; i += 2) {
+        const char * name = attrs[i];
+        const char * value = attrs[i + 1];
+        if(lv_streq(name, "name")) continue;
+        if(lv_streq(name, "help")) continue;
+
+        if(value[0] == '#') {
+            const char * value_clean = &value[1];
+            lv_xml_const_t * c;
+            LV_LL_READ(&ctx->const_ll, c) {
+                if(lv_streq(c->name, value_clean)) {
+                    value = c->value;
+                    break;
+                }
+            }
+        }
+
+        if(lv_streq(name, "width")) lv_style_set_width(style, lv_xml_to_size(value));
+        else if(lv_streq(name, "height")) lv_style_set_height(style, lv_xml_to_size(value));
+        else if(lv_streq(name, "radius")) lv_style_set_radius(style, lv_xml_atoi(value));
+        else if(lv_streq(name, "bg_opa")) lv_style_set_bg_opa(style, lv_xml_atoi(value));
+        else if(lv_streq(name, "bg_color")) lv_style_set_bg_color(style, lv_xml_to_color(value));
+        else if(lv_streq(name, "border_color")) lv_style_set_border_color(style, lv_xml_to_color(value));
+        else if(lv_streq(name, "border_width")) lv_style_set_border_width(style, lv_xml_atoi(value));
+        else if(lv_streq(name, "border_opa")) lv_style_set_border_opa(style, lv_xml_atoi(value));
+        else if(lv_streq(name, "text_color")) lv_style_set_text_color(style, lv_xml_to_color(value));
+        else if(lv_streq(name, "text_font")) lv_style_set_text_font(style, lv_xml_get_font(value));
+        else if(lv_streq(name, "bg_image_src")) lv_style_set_bg_image_src(style, lv_xml_get_image(value));
+        else if(lv_streq(name, "bg_image_tiled")) lv_style_set_bg_image_tiled(style, lv_xml_to_bool(value));
+        else {
+            LV_LOG_WARN("%s style property is not supported", name);
+        }
+    }
+}
+
+const char * lv_xml_style_string_process(char * txt, lv_style_selector_t * selector)
+{
+    *selector = 0;
+
+    char * style_name = lv_xml_split_str(&txt, ':');
+    char * selector_str = lv_xml_split_str(&txt, ':');
+    while(selector_str != NULL) {
+        /* Handle different states and parts */
+        *selector |= lv_xml_style_state_string_to_enum_value(selector_str);
+        *selector |= lv_xml_style_part_string_to_enum_value(selector_str);
+
+        /* Move to the next token */
+        selector_str = lv_xml_split_str(&txt, ':');
+    }
+
+    return style_name;
+}
+
+void lv_xml_style_add_to_obj(lv_xml_parser_state_t * state, lv_obj_t * obj, const char * text)
+{
+    char * str = lv_strdup(text);
+    char * str_ori = str;
+
+    /* Split the string based on space and colons */
+    char * onestyle_str = lv_xml_split_str(&str, ' ');
+    while(onestyle_str != NULL) {
+        /* Parse the parts and states after the space */
+        lv_style_selector_t selector = 0;
+        const char * style_name = lv_xml_style_string_process(onestyle_str, &selector);
+        if(style_name != NULL) {
+            lv_xml_style_t * xml_style = NULL;
+            /*Resolve parameters or just find the style*/
+            if(style_name[0] == '$') {
+                /*E.g. `$pr_style` style name means use the value
+                 *coming from the parent's `pr_style` named attribute*/
+                const char * name_clean = &style_name[1];
+                const char * parent_style_name = lv_xml_get_value_of(state->parent_attrs, name_clean);
+                if(parent_style_name) {
+                    xml_style = lv_xml_get_style_by_name(state->parent_ctx, parent_style_name);
+                }
+            }
+            else {
+                xml_style = lv_xml_get_style_by_name(&state->ctx, style_name);
+            }
+            if(xml_style) {
+                /* Apply with the selector */
+                lv_obj_add_style(obj, &xml_style->style, selector);
+            }
+        }
+        onestyle_str = lv_xml_split_str(&str, ' ');
+    }
+
+    lv_free(str_ori);
+}
+
+lv_xml_style_t * lv_xml_get_style_by_name(lv_xml_component_ctx_t * ctx, const char * style_name_raw)
+{
+    const char * style_name = strrchr(style_name_raw, '.');
+
+    if(style_name) {
+        char component_name[256];
+        size_t len = (size_t)(style_name - style_name_raw);
+        lv_memcpy(component_name, style_name_raw, len);
+        component_name[len] = '\0';
+        ctx = lv_xml_component_get_ctx(component_name);
+        style_name++; /*Skip the dot*/
+    }
+    else {
+        style_name = style_name_raw;
+    }
+
+    lv_xml_style_t * xml_style;
+    LV_LL_READ(&ctx->style_ll, xml_style) {
+        if(lv_streq(xml_style->name, style_name)) return xml_style;
+    }
+
+    LV_LOG_WARN("No style found with %s name", style_name_raw);
+
+    return NULL;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+#endif /* LV_USE_XML */
diff --git a/src/others/xml/lv_xml_style.h b/src/others/xml/lv_xml_style.h
new file mode 100644
index 000000000..d7288bd34
--- /dev/null
+++ b/src/others/xml/lv_xml_style.h
@@ -0,0 +1,91 @@
+/**
+ * @file lv_xml_style.h
+ *
+ */
+
+#ifndef LV_XML_STYLE_H
+#define LV_XML_STYLE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../../misc/lv_types.h"
+#include "../../misc/lv_style.h"
+#include "../../core/lv_obj_style.h"
+
+#if LV_USE_XML
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef struct _lv_xml_style_t {
+    const char * name;
+    const char * long_name;
+    lv_style_t style;
+} lv_xml_style_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Add a style to `ctx` and set the style properties from `attrs`
+ * @param ctx       add styles here. (Constants should be already added as style properties might use them)
+ * @param attrs     list of attribute names and values
+ */
+void lv_xml_style_register(lv_xml_component_ctx_t * ctx, const char ** attrs);
+
+/**
+ * Add the styles to an object. Handles multiple styles and selectors too.
+ * @param state     the parser state
+ * @param obj       the target widget
+ * @param text      the styles' string, e.g. "blue red:pressed:knob"
+ */
+void lv_xml_style_add_to_obj(lv_xml_parser_state_t * state, lv_obj_t * obj, const char * text);
+
+/**
+ * Convert a style state to enum
+ * @param txt       e.g. "pressed"
+ * @return          the enum `LV_STATE_PRESSED`
+ */
+lv_state_t lv_xml_style_state_string_to_enum_value(const char * txt);
+
+/**
+ * Convert a style part to enum
+ * @param txt       e.g. "knob"
+ * @return          the enum `LV_PART_KNOB`
+ */
+lv_part_t lv_xml_style_part_string_to_enum_value(const char * txt);
+
+/**
+ * Decompose a string like `"style1:pressed:checked:knob"` to style name and selector
+ * @param txt           the input string
+ * @param selector      store the selectors here
+ * @return              the style name or `NULL` on any error
+ */
+const char * lv_xml_style_string_process(char * txt, lv_style_selector_t * selector);
+
+/**
+ * Find a style by name which was added by `lv_xml_style_register`
+ * @param ctx       the default context to search in
+ * @param name      the name of the style. Can start with a component name prefix (e.g. `my_button.blue`) to overwrite the ctx
+ * @return          the style structure
+ */
+lv_xml_style_t * lv_xml_get_style_by_name(lv_xml_component_ctx_t * ctx, const char * name);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /* LV_USE_XML */
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_XML_STYLE_H*/
diff --git a/src/others/xml/lv_xml_utils.c b/src/others/xml/lv_xml_utils.c
new file mode 100644
index 000000000..ad4f72523
--- /dev/null
+++ b/src/others/xml/lv_xml_utils.c
@@ -0,0 +1,237 @@
+/**
+ * @file lv_xml_utils.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_xml_utils.h"
+#include "../../stdlib/lv_string.h"
+#if LV_USE_XML
+
+#if LV_USE_STDLIB_STRING == LV_STDLIB_CLIB
+    #include <stdlib.h>
+#endif
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+#if LV_USE_STDLIB_STRING != LV_STDLIB_CLIB
+    static bool lv_xml_is_digit(char c, int base);
+#endif
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+
+const char * lv_xml_get_value_of(const char ** attrs, const char * name)
+{
+    if(attrs == NULL) return NULL;
+    if(name == NULL) return NULL;
+
+    for(int i = 0; attrs[i]; i += 2) {
+        if(lv_streq(attrs[i], name)) return attrs[i + 1];
+    }
+
+    return NULL;
+}
+
+lv_color_t lv_xml_to_color(const char * str)
+{
+    return lv_color_hex(lv_xml_strtol(str, NULL, 16));
+}
+
+bool lv_xml_to_bool(const char * str)
+{
+    return lv_streq(str, "false") ? false : true;
+}
+
+
+#if LV_USE_STDLIB_STRING == LV_STDLIB_CLIB
+int32_t lv_xml_atoi(const char * str)
+{
+    return atoi(str);
+}
+
+
+int32_t lv_xml_strtol(const char * str, char ** endptr, int32_t base)
+{
+    return strtol(str, endptr, base);
+}
+
+#else /*LV_USE_STDLIB_STRING == LV_STDLIB_CLIB*/
+
+int32_t lv_xml_atoi(const char * str)
+{
+    const char * s = str;
+    int32_t result = 0;
+    int sign = 1;
+
+    /* Skip leading whitespace */
+    while(*s == ' ' || *s == '\t')  s++;
+
+    /* Handle optional sign */
+    if(*s == '-') {
+        sign = -1;
+        s++;
+    }
+    else if(*s == '+') {
+        s++;
+    }
+
+    /* Convert the string*/
+    while(*s) {
+        if(*s >= '0' && *s <= '9') {
+            int32_t digit = *s - '0';
+
+            /* Check for overflow before it happens */
+            if(result > (INT_MAX - digit) / 10) {
+                return (sign == 1) ? INT_MAX : INT_MIN; // Return limits on overflow
+            }
+
+            result = result * 10 + digit;
+            s++;
+        }
+        else {
+            break; // Non-digit character
+        }
+    }
+
+    return result * sign;
+}
+
+int32_t lv_xml_strtol(const char * str, char ** endptr, int32_t base)
+{
+    const char * s = str;
+    int32_t result = 0;
+    int32_t sign = 1;
+
+    /* Skip leading whitespace */
+    while(*s == ' ' || *s == '\t') s++;
+
+    /* Handle optional sign*/
+    if(*s == '-') {
+        sign = -1;
+        s++;
+    }
+    else if(*s == '+') {
+        s++;
+    }
+
+    /* Determine base if 0 is passed as base*/
+    if(base == 0) {
+        if(*s == '0') {
+            if(*(s + 1) == 'x' || *(s + 1) == 'X') {
+                base = 16;
+                s += 2;
+            }
+            else {
+                base = 8;
+                s++;
+            }
+        }
+        else {
+            base = 10;
+        }
+    }
+
+    /* Convert the string*/
+    while(*s) {
+        int32_t digit;
+
+        if(lv_xml_is_digit(*s, base)) {
+            if(*s >= '0' && *s <= '9') {
+                digit = *s - '0';
+            }
+            else if(*s >= 'a' && *s <= 'f') {
+                digit = *s - 'a' + 10;
+            }
+            else if(*s >= 'A' && *s <= 'F') {
+                digit = *s - 'A' + 10;
+            }
+            else {
+                /* This should not happen due to lv_xml_is_digit check*/
+                break;
+            }
+
+            /* Check for overflow */
+            if(result > (INT32_MAX - digit) / base) {
+                result = (sign == 1) ? INT32_MAX : INT32_MIN;
+                if(endptr) *endptr = (char *)s;
+                return result;
+            }
+
+            result = result * base + digit;
+        }
+        s++;
+    }
+
+    /* Set end pointer to the last character processed*/
+    if(endptr) {
+        *endptr = (char *)s;
+    }
+
+    return result * sign;
+}
+
+#endif /*LV_USE_STDLIB_STRING == LV_STDLIB_CLIB*/
+
+char * lv_xml_split_str(char ** src, char delimiter)
+{
+    if(*src[0] == '\0') return NULL;
+
+    char * src_first = *src;
+    char * src_next = *src;
+
+    /*Find the delimiter*/
+    while(*src_next != '\0') {
+        if(*src_next == delimiter) {
+            *src_next = '\0';       /*Close the string on the delimiter*/
+            *src = src_next + 1;    /*Change the source continue after the found delimiter*/
+            return src_first;
+        }
+        src_next++;
+    }
+
+    /*No delimiter found, return the string as it is*/
+    *src = src_next;    /*Move the source point to the end*/
+
+    return src_first;
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+#if LV_USE_STDLIB_STRING != LV_STDLIB_CLIB
+static bool lv_xml_is_digit(char c, int base)
+{
+    if(base <= 10) {
+        return (c >= '0' && c < '0' + base);
+    }
+    else {
+        return (c >= '0' && c <= '9') || (c >= 'a' && c < 'a' + (base - 10)) || (c >= 'A' && c < 'A' + (base - 10));
+    }
+}
+
+#endif /*LV_USE_STDLIB_STRING == LV_STDLIB_CLIB*/
+
+#endif /* LV_USE_XML */
diff --git a/src/others/xml/lv_xml_utils.h b/src/others/xml/lv_xml_utils.h
new file mode 100644
index 000000000..dfde5f894
--- /dev/null
+++ b/src/others/xml/lv_xml_utils.h
@@ -0,0 +1,50 @@
+/**
+ * @file lv_xml_utils.h
+ *
+ */
+
+#ifndef LV_XML_UTILS_H
+#define LV_XML_UTILS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../../lv_conf_internal.h"
+#if LV_USE_XML
+
+#include LV_STDINT_INCLUDE
+#include "../../misc/lv_color.h"
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+const char * lv_xml_get_value_of(const char ** attrs, const char * name);
+
+int32_t lv_xml_atoi(const char * str);
+
+lv_color_t lv_xml_to_color(const char * str);
+
+bool lv_xml_to_bool(const char * str);
+
+int32_t lv_xml_strtol(const char * str, char ** endptr, int32_t base);
+
+/**
+ * Find a delimiter in a string, terminate the string on the delimiter and
+ * update the source string to the next part
+ * @param src           point to a variable containing the input string
+ * @param delimiter     a delimiter character, e.g. ':'
+ * @return              the beginning of next section in the string closed at the delimiter
+ */
+char * lv_xml_split_str(char ** src, char delimiter);
+
+#endif /* LV_USE_XML */
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_XML_UTILS_H*/
diff --git a/src/others/xml/lv_xml_widget.c b/src/others/xml/lv_xml_widget.c
new file mode 100644
index 000000000..b468038dd
--- /dev/null
+++ b/src/others/xml/lv_xml_widget.c
@@ -0,0 +1,78 @@
+/**
+ * @file lv_xml_widget.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_xml_widget.h"
+#include "lv_xml_parser.h"
+#include "../../stdlib/lv_string.h"
+#include "../../stdlib/lv_mem.h"
+
+#if LV_USE_XML
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+static lv_widget_processor_t * widget_processor_head;
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+lv_result_t lv_xml_widget_register(const char * name, lv_xml_widget_create_cb_t create_cb,
+                                   lv_xml_widget_apply_cb_t apply_cb)
+{
+    lv_widget_processor_t * p = lv_malloc(sizeof(lv_widget_processor_t));
+    lv_memzero(p, sizeof(lv_widget_processor_t));
+
+    p->name = lv_strdup(name);
+    p->create_cb = create_cb;
+    p->apply_cb = apply_cb;
+
+    if(widget_processor_head == NULL) widget_processor_head = p;
+    else {
+        p->next = widget_processor_head;
+        widget_processor_head = p;
+    }
+    return LV_RESULT_OK;
+}
+
+lv_widget_processor_t * lv_xml_widget_get_processor(const char * name)
+{
+    /* Select the widget specific parser type based on the name */
+    lv_widget_processor_t * p = widget_processor_head;
+    while(p) {
+        if(lv_streq(p->name, name)) {
+            return p;
+        }
+
+        p = p->next;
+    }
+    return NULL;
+}
+
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+#endif /* LV_USE_XML */
diff --git a/src/others/xml/lv_xml_widget.h b/src/others/xml/lv_xml_widget.h
new file mode 100644
index 000000000..a9305829c
--- /dev/null
+++ b/src/others/xml/lv_xml_widget.h
@@ -0,0 +1,57 @@
+/**
+ * @file lv_xml_widget.h
+ *
+ */
+
+#ifndef LV_XML_WIDGET_H
+#define LV_XML_WIDGET_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../../misc/lv_types.h"
+#if LV_USE_XML
+
+#include "lv_xml.h"
+#include "lv_xml_utils.h"
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+typedef  void * (*lv_xml_widget_create_cb_t)(lv_xml_parser_state_t * state, const char ** parent_attrs);
+typedef  void (*lv_xml_widget_apply_cb_t)(lv_xml_parser_state_t * state, const char ** parent_attrs);
+
+typedef struct _lv_widget_processor_t {
+    const char * name;
+    lv_xml_widget_create_cb_t create_cb;
+    lv_xml_widget_apply_cb_t apply_cb;
+    struct _lv_widget_processor_t * next;
+} lv_widget_processor_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+lv_result_t lv_xml_widget_register(const char * name, lv_xml_widget_create_cb_t create_cb,
+                                   lv_xml_widget_apply_cb_t apply_cb);
+
+lv_widget_processor_t * lv_xml_widget_get_processor(const char * name);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /* LV_USE_XML */
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_XML_WIDGET_H*/
+
+
diff --git a/src/others/xml/parsers/lv_xml_button_parser.c b/src/others/xml/parsers/lv_xml_button_parser.c
new file mode 100644
index 000000000..0ab77008b
--- /dev/null
+++ b/src/others/xml/parsers/lv_xml_button_parser.c
@@ -0,0 +1,59 @@
+/**
+ * @file lv_xml_button_parser.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "lv_xml_button_parser.h"
+#if LV_USE_XML
+#include "../../../lvgl.h"
+#include "../../../lvgl_private.h"
+
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void * lv_xml_button_create(lv_xml_parser_state_t * state, const char ** attrs)
+{
+    LV_UNUSED(attrs);
+
+    void * item = lv_button_create(lv_xml_state_get_parent(state));
+
+    return item;
+}
+
+void lv_xml_button_apply(lv_xml_parser_state_t * state, const char ** attrs)
+{
+    /*Apply the common properties, e.g. width, height, styles flags etc*/
+    lv_xml_obj_apply(state, attrs);
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+#endif /* LV_USE_XML */
diff --git a/src/others/xml/parsers/lv_xml_button_parser.h b/src/others/xml/parsers/lv_xml_button_parser.h
new file mode 100644
index 000000000..7bfcf5be6
--- /dev/null
+++ b/src/others/xml/parsers/lv_xml_button_parser.h
@@ -0,0 +1,41 @@
+/**
+ * @file lv_xml_button_parser.h
+ *
+ */
+
+#ifndef LV_BUTTON_XML_PARSER_H
+#define LV_BUTTON_XML_PARSER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../lv_xml.h"
+#if LV_USE_XML
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void * lv_xml_button_create(lv_xml_parser_state_t * state, const char ** attrs);
+void lv_xml_button_apply(lv_xml_parser_state_t * state, const char ** attrs);
+
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /* LV_USE_XML */
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_BUTTON_XML_PARSE_H*/
diff --git a/src/others/xml/parsers/lv_xml_chart_parser.c b/src/others/xml/parsers/lv_xml_chart_parser.c
new file mode 100644
index 000000000..5ef70d882
--- /dev/null
+++ b/src/others/xml/parsers/lv_xml_chart_parser.c
@@ -0,0 +1,145 @@
+/**
+ * @file lv_xml_chart_parser.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_xml_chart_parser.h"
+#if LV_USE_XML
+
+#include "../../../lvgl.h"
+#include "../../../lvgl_private.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static lv_chart_type_t chart_type_string_to_enum_value(const char * txt);
+static lv_chart_update_mode_t chart_update_mode_string_to_enum_value(const char * txt);
+static lv_chart_axis_t chart_axis_string_to_enum_value(const char * txt);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void * lv_xml_chart_create(lv_xml_parser_state_t * state, const char ** attrs)
+{
+    LV_UNUSED(attrs);
+    void * item = lv_chart_create(lv_xml_state_get_parent(state));
+
+    return item;
+}
+
+
+void lv_xml_chart_apply(lv_xml_parser_state_t * state, const char ** attrs)
+{
+    void * item = lv_xml_state_get_item(state);
+
+    lv_xml_obj_apply(state, attrs); /*Apply the common properties, e.g. width, height, styles flags etc*/
+
+    for(int i = 0; attrs[i]; i += 2) {
+        const char * name = attrs[i];
+        const char * value = attrs[i + 1];
+
+        if(lv_streq("point_count", name)) lv_chart_set_point_count(item, lv_xml_atoi(value));
+        if(lv_streq("type", name)) lv_chart_set_type(item, chart_type_string_to_enum_value(value));
+        if(lv_streq("mode", name)) lv_chart_set_update_mode(item, chart_update_mode_string_to_enum_value(value));
+    }
+}
+
+void * lv_xml_chart_series_create(lv_xml_parser_state_t * state, const char ** attrs)
+{
+    const char * color = lv_xml_get_value_of(attrs, "color");
+    const char * axis = lv_xml_get_value_of(attrs, "axis");
+    void * item = lv_chart_add_series(lv_xml_state_get_parent(state), lv_color_hex(lv_xml_strtol(color, NULL, 16)),
+                                      chart_axis_string_to_enum_value(axis));
+
+    lv_obj_t * parent = lv_xml_state_get_parent(state);
+    lv_chart_set_all_value(parent, item, lv_rand(10, 90));
+
+    return item;
+}
+
+void lv_xml_chart_series_apply(lv_xml_parser_state_t * state, const char ** attrs)
+{
+    LV_UNUSED(state);
+    LV_UNUSED(attrs);
+
+    /*Nothing to apply*/
+}
+
+void * lv_xml_chart_cursor_create(lv_xml_parser_state_t * state, const char ** attrs)
+{
+    const char * color = lv_xml_get_value_of(attrs, "color");
+    const char * dir = lv_xml_get_value_of(attrs, "dir");
+    void * item = lv_chart_add_cursor(lv_xml_state_get_parent(state), lv_color_hex(lv_xml_strtol(color, NULL, 16)),
+                                      lv_xml_dir_string_to_enum_value(dir));
+
+    lv_obj_t * parent = lv_xml_state_get_parent(state);
+    lv_point_t p = {30, 40};
+    lv_chart_set_cursor_pos(parent, item, &p);
+
+    /* There are no properties to process */
+
+    return item;
+}
+
+void lv_xml_chart_cursor_apply(lv_xml_parser_state_t * state, const char ** attrs)
+{
+    LV_UNUSED(state);
+    LV_UNUSED(attrs);
+
+    /*Nothing to apply*/
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static lv_chart_type_t chart_type_string_to_enum_value(const char * txt)
+{
+    if(lv_streq("none", txt)) return LV_CHART_TYPE_NONE;
+    if(lv_streq("line", txt)) return LV_CHART_TYPE_LINE;
+    if(lv_streq("bar", txt)) return LV_CHART_TYPE_BAR;
+    if(lv_streq("scatter", txt)) return LV_CHART_TYPE_SCATTER;
+
+    LV_LOG_WARN("%s is an unknown value for chart's chart_type", txt);
+    return 0; /*Return 0 in lack of a better option. */
+}
+static lv_chart_update_mode_t chart_update_mode_string_to_enum_value(const char * txt)
+{
+    if(lv_streq("shift", txt)) return LV_CHART_UPDATE_MODE_SHIFT;
+    if(lv_streq("circular", txt)) return LV_CHART_UPDATE_MODE_CIRCULAR;
+
+    LV_LOG_WARN("%s is an unknown value for chart's chart_update_mode", txt);
+    return 0; /*Return 0 in lack of a better option. */
+}
+static lv_chart_axis_t chart_axis_string_to_enum_value(const char * txt)
+{
+    if(lv_streq("primary_x", txt)) return LV_CHART_AXIS_PRIMARY_X;
+    if(lv_streq("primary_y", txt)) return LV_CHART_AXIS_PRIMARY_Y;
+    if(lv_streq("secondary_x", txt)) return LV_CHART_AXIS_SECONDARY_X;
+    if(lv_streq("secondary_y", txt)) return LV_CHART_AXIS_SECONDARY_Y;
+
+    LV_LOG_WARN("%s is an unknown value for chart's chart_axis", txt);
+    return 0; /*Return 0 in lack of a better option. */
+}
+
+#endif /* LV_USE_XML */
diff --git a/src/others/xml/parsers/lv_xml_chart_parser.h b/src/others/xml/parsers/lv_xml_chart_parser.h
new file mode 100644
index 000000000..34a3104c9
--- /dev/null
+++ b/src/others/xml/parsers/lv_xml_chart_parser.h
@@ -0,0 +1,43 @@
+/**
+ * @file lv_xml_chart_parser.h
+ *
+ */
+
+#ifndef LV_CHART_XML_PARSER_H
+#define LV_CHART_XML_PARSER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../lv_xml.h"
+#if LV_USE_XML
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void * lv_xml_chart_create(lv_xml_parser_state_t * state, const char ** attrs);
+void lv_xml_chart_apply(lv_xml_parser_state_t * state, const char ** attrs);
+void * lv_xml_chart_series_create(lv_xml_parser_state_t * state, const char ** attrs);
+void lv_xml_chart_series_apply(lv_xml_parser_state_t * state, const char ** attrs);
+void * lv_xml_chart_cursor_create(lv_xml_parser_state_t * state, const char ** attrs);
+void lv_xml_chart_cursor_apply(lv_xml_parser_state_t * state, const char ** attrs);
+
+/**********************
+ *      MACROS
+ **********************/
+#endif /* LV_USE_XML */
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_CHART_XML_PARSE_H*/
diff --git a/src/others/xml/parsers/lv_xml_image_parser.c b/src/others/xml/parsers/lv_xml_image_parser.c
new file mode 100644
index 000000000..b33c1abff
--- /dev/null
+++ b/src/others/xml/parsers/lv_xml_image_parser.c
@@ -0,0 +1,112 @@
+/**
+ * @file lv_xml_image_parser.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_xml_image_parser.h"
+#if LV_USE_XML
+
+#include "../../../lvgl.h"
+#include "../../../lvgl_private.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void * lv_xml_image_create(lv_xml_parser_state_t * state, const char ** attrs)
+{
+    LV_UNUSED(attrs);
+    void * item = lv_image_create(lv_xml_state_get_parent(state));
+
+    if(item == NULL) {
+        LV_LOG_ERROR("Failed to create image");
+        return NULL;
+    }
+
+    return item;
+}
+
+void lv_xml_check_file(const char * filepath)
+{
+    lv_fs_file_t f;
+    lv_fs_res_t res = lv_fs_open(&f, filepath, LV_FS_MODE_RD);
+
+    if(res == LV_FS_RES_OK) {
+        uint32_t size;
+        uint8_t buffer[10];
+        lv_fs_read(&f, buffer, 0, &size);
+
+        lv_fs_seek(&f, 0, LV_FS_SEEK_END);
+        lv_fs_tell(&f, &size);
+        LV_LOG_USER("File %s exists (%u bytes)", filepath, size);
+
+
+        lv_fs_close(&f);
+
+        lv_image_header_t info;
+        lv_image_decoder_get_info(filepath, &info);
+        LV_LOG_USER("Image info: %d x %d, %d color", info.w, info.h, info.cf);
+    }
+    else {
+        LV_LOG_ERROR("Failed to open file: %s", filepath);
+    }
+}
+
+void lv_xml_image_apply(lv_xml_parser_state_t * state, const char ** attrs)
+{
+    void * item = lv_xml_state_get_item(state);
+
+    if(item == NULL) {
+        LV_LOG_ERROR("Failed to get image");
+        return;
+    }
+
+    lv_xml_obj_apply(state, attrs); /*Apply the common properties, e.g. width, height, styles flags etc*/
+
+    for(int i = 0; attrs[i]; i += 2) {
+        const char * name = attrs[i];
+        const char * value = attrs[i + 1];
+
+        if(lv_streq("src", name)) {
+            const void * img_src = lv_xml_get_image(value);
+            if(img_src == NULL) {
+                LV_LOG_WARN("Failed to get image source for '%s'", value);
+                return;
+            }
+
+            lv_image_set_src(item, (const char *)img_src);
+
+        }
+
+    }
+
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+#endif /* LV_USE_XML */
diff --git a/src/others/xml/parsers/lv_xml_image_parser.h b/src/others/xml/parsers/lv_xml_image_parser.h
new file mode 100644
index 000000000..19a978a33
--- /dev/null
+++ b/src/others/xml/parsers/lv_xml_image_parser.h
@@ -0,0 +1,43 @@
+/**
+ * @file lv_xml_image_parser.h
+ *
+ */
+
+#ifndef LV_XML_IMAGE_PARSER_H
+#define LV_XML_IMAGE_PARSER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../lv_xml.h"
+#if LV_USE_XML
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void * lv_xml_image_create(lv_xml_parser_state_t * state, const char ** attrs);
+
+void lv_xml_image_apply(lv_xml_parser_state_t * state, const char ** attrs);
+
+void lv_xml_check_file(const char * filepath);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /* LV_USE_XML */
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_XML_IMAGE_PARSER_H*/
\ No newline at end of file
diff --git a/src/others/xml/parsers/lv_xml_label_parser.c b/src/others/xml/parsers/lv_xml_label_parser.c
new file mode 100644
index 000000000..a861c2931
--- /dev/null
+++ b/src/others/xml/parsers/lv_xml_label_parser.c
@@ -0,0 +1,76 @@
+/**
+ * @file lv_xml_label_parser.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_xml_label_parser.h"
+#if LV_USE_XML
+
+#include "../../../lvgl.h"
+#include "../../../lvgl_private.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static lv_label_long_mode_t long_mode_text_to_enum_value(const char * txt);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void * lv_xml_label_create(lv_xml_parser_state_t * state, const char ** attrs)
+{
+    LV_UNUSED(attrs);
+    void * item = lv_label_create(lv_xml_state_get_parent(state));
+
+    return item;
+}
+
+void lv_xml_label_apply(lv_xml_parser_state_t * state, const char ** attrs)
+{
+    void * item = lv_xml_state_get_item(state);
+
+    lv_xml_obj_apply(state, attrs); /*Apply the common properties, e.g. width, height, styles flags etc*/
+
+    for(int i = 0; attrs[i]; i += 2) {
+        const char * name = attrs[i];
+        const char * value = attrs[i + 1];
+
+        if(lv_streq("text", name)) lv_label_set_text(item, value);
+        if(lv_streq("long_mode", name)) lv_label_set_long_mode(item, long_mode_text_to_enum_value(value));
+    }
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static lv_label_long_mode_t long_mode_text_to_enum_value(const char * txt)
+{
+    if(lv_streq("wrap", txt)) return LV_LABEL_LONG_MODE_WRAP;
+    if(lv_streq("scroll", txt)) return LV_LABEL_LONG_MODE_SCROLL;
+
+    LV_LOG_WARN("%s is an unknown value for label's long_mode", txt);
+    return 0; /*Return 0 in lack of a better option. */
+}
+
+#endif /* LV_USE_XML */
diff --git a/src/others/xml/parsers/lv_xml_label_parser.h b/src/others/xml/parsers/lv_xml_label_parser.h
new file mode 100644
index 000000000..da1ef79be
--- /dev/null
+++ b/src/others/xml/parsers/lv_xml_label_parser.h
@@ -0,0 +1,41 @@
+/**
+ * @file lv_xml_label_parser.h
+ *
+ */
+
+#ifndef LV_LABEL_XML_PARSER_H
+#define LV_LABEL_XML_PARSER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../lv_xml.h"
+#if LV_USE_XML
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void * lv_xml_label_create(lv_xml_parser_state_t * state, const char ** attrs);
+
+void lv_xml_label_apply(lv_xml_parser_state_t * state, const char ** attrs);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /* LV_USE_XML */
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_LABEL_XML_PARSE_H*/
diff --git a/src/others/xml/parsers/lv_xml_obj_parser.c b/src/others/xml/parsers/lv_xml_obj_parser.c
new file mode 100644
index 000000000..2af6b02f4
--- /dev/null
+++ b/src/others/xml/parsers/lv_xml_obj_parser.c
@@ -0,0 +1,89 @@
+/**
+ * @file lv_xml_obj_parser.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_xml_obj_parser.h"
+#if LV_USE_XML
+
+#include "../../../lvgl.h"
+#include "../../../lvgl_private.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void * lv_xml_obj_create(lv_xml_parser_state_t * state, const char ** attrs)
+{
+    LV_UNUSED(attrs);
+    void * item = lv_obj_create(lv_xml_state_get_parent(state));
+
+    return item;
+}
+
+void lv_xml_obj_apply(lv_xml_parser_state_t * state, const char ** attrs)
+{
+    void * item = lv_xml_state_get_item(state);
+
+    for(int i = 0; attrs[i]; i += 2) {
+        const char * name = attrs[i];
+        const char * value = attrs[i + 1];
+
+        if(lv_streq("x", name)) lv_obj_set_x(item, lv_xml_to_size(value));
+        if(lv_streq("y", name)) lv_obj_set_y(item, lv_xml_to_size(value));
+        if(lv_streq("width", name)) lv_obj_set_width(item, lv_xml_to_size(value));
+        if(lv_streq("height", name)) lv_obj_set_height(item, lv_xml_to_size(value));
+        if(lv_streq("align", name)) lv_obj_set_align(item, lv_xml_align_string_to_enum_value(value));
+
+        if(lv_streq("styles", name)) lv_xml_style_add_to_obj(state, item, value);
+
+        if(lv_strlen(name) > 6 && lv_memcmp("style_", name, 6) == 0) {
+            char name_local[512];
+            lv_strlcpy(name_local, name, sizeof(name_local));
+
+            lv_style_selector_t selector;
+            const char * prop_name = lv_xml_style_string_process(name_local, &selector);
+
+            if(lv_streq("style_radius", prop_name)) lv_obj_set_style_radius(item, lv_xml_atoi(value), selector);
+            if(lv_streq("style_bg_color", prop_name)) lv_obj_set_style_bg_color(item, lv_xml_to_color(value), selector);
+            if(lv_streq("style_bg_opa", prop_name)) lv_obj_set_style_bg_opa(item, lv_xml_atoi(value), selector);
+            if(lv_streq("style_border_color", prop_name)) lv_obj_set_style_border_color(item, lv_xml_to_color(value), selector);
+            if(lv_streq("style_border_opa", prop_name)) lv_obj_set_style_border_opa(item, lv_xml_atoi(value), selector);
+            if(lv_streq("style_border_width", prop_name)) lv_obj_set_style_border_width(item, lv_xml_atoi(value), selector);
+            if(lv_streq("style_bg_image_src", prop_name)) lv_obj_set_style_bg_image_src(item, lv_xml_get_image(value), selector);
+            if(lv_streq("style_bg_image_tiled", prop_name)) lv_obj_set_style_bg_image_tiled(item, lv_xml_to_bool(value), selector);
+            if(lv_streq("style_text_color", prop_name)) lv_obj_set_style_text_color(item, lv_xml_to_color(value), selector);
+            if(lv_streq("style_text_font", prop_name)) lv_obj_set_style_text_font(item, lv_xml_get_font(value), selector);
+        }
+    }
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+
+#endif /* LV_USE_XML */
diff --git a/src/others/xml/parsers/lv_xml_obj_parser.h b/src/others/xml/parsers/lv_xml_obj_parser.h
new file mode 100644
index 000000000..d08014560
--- /dev/null
+++ b/src/others/xml/parsers/lv_xml_obj_parser.h
@@ -0,0 +1,41 @@
+/**
+ * @file lv_xml_obj_parser.h
+ *
+ */
+
+#ifndef LV_OBJ_XML_PARSER_H
+#define LV_OBJ_XML_PARSER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../lv_xml.h"
+#if LV_USE_XML
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void * lv_xml_obj_create(lv_xml_parser_state_t * state, const char ** attrs);
+void lv_xml_obj_apply(lv_xml_parser_state_t * state, const char ** attrs);
+
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /* LV_USE_XML */
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_OBJ_XML_PARSE_H*/
diff --git a/src/others/xml/parsers/lv_xml_slider_parser.c b/src/others/xml/parsers/lv_xml_slider_parser.c
new file mode 100644
index 000000000..428c7b30f
--- /dev/null
+++ b/src/others/xml/parsers/lv_xml_slider_parser.c
@@ -0,0 +1,99 @@
+/**
+ * @file lv_xml_slider_parser.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_xml_slider_parser.h"
+#if LV_USE_XML
+
+#include "../../../lvgl.h"
+#include "../../../lvgl_private.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static lv_slider_orientation_t orentation_text_to_enum_value(const char * txt);
+static lv_slider_mode_t mode_text_to_enum_value(const char * txt);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void * lv_xml_slider_create(lv_xml_parser_state_t * state, const char ** attrs)
+{
+    LV_UNUSED(attrs);
+
+    void * item = lv_slider_create(lv_xml_state_get_parent(state));
+    return item;
+}
+
+void lv_xml_slider_apply(lv_xml_parser_state_t * state, const char ** attrs)
+{
+    void * item = lv_xml_state_get_item(state);
+    lv_xml_obj_apply(state, attrs); /*Apply the common properties, e.g. width, height, styles flags etc*/
+
+    for(int i = 0; attrs[i]; i += 2) {
+        const char * name = attrs[i];
+        const char * value = attrs[i + 1];
+
+        if(lv_streq("value", name)) lv_slider_set_value(item, lv_xml_atoi(value), LV_ANIM_OFF);
+        if(lv_streq("left_value", name)) lv_slider_set_left_value(item, lv_xml_atoi(value), LV_ANIM_OFF);
+        if(lv_streq("orientation", name)) lv_slider_set_orientation(item, orentation_text_to_enum_value(value));
+        if(lv_streq("mode", name)) lv_slider_set_mode(item, mode_text_to_enum_value(value));
+        if(lv_streq("range_min", name)) lv_slider_set_range(item, lv_xml_atoi(value), lv_slider_get_max_value(item));
+        if(lv_streq("range_max", name)) lv_slider_set_range(item, lv_slider_get_min_value(item), lv_xml_atoi(value));
+        if(lv_streq("range", name)) {
+            char buf[64];
+            lv_strlcpy(buf, value, sizeof(buf));
+            char * buf_p = buf;
+            int32_t v1 = lv_xml_atoi(lv_xml_split_str(&buf_p, ' '));
+            int32_t v2 = lv_xml_atoi(buf_p);
+            lv_slider_set_range(item, v1, v2);
+        }
+    }
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static lv_slider_orientation_t orentation_text_to_enum_value(const char * txt)
+{
+    if(lv_streq("auto", txt)) return LV_SLIDER_ORIENTATION_AUTO;
+    if(lv_streq("horizontal", txt)) return LV_SLIDER_ORIENTATION_HORIZONTAL;
+    if(lv_streq("vertical", txt)) return LV_SLIDER_ORIENTATION_VERTICAL;
+
+    LV_LOG_WARN("%s is an unknown value for slider's orientation", txt);
+    return 0; /*Return 0 in lack of a better option. */
+}
+
+static lv_slider_mode_t mode_text_to_enum_value(const char * txt)
+{
+    if(lv_streq("normal", txt)) return LV_SLIDER_MODE_NORMAL;
+    if(lv_streq("range", txt)) return LV_SLIDER_MODE_RANGE;
+    if(lv_streq("symmetrical", txt)) return LV_SLIDER_MODE_SYMMETRICAL;
+
+    LV_LOG_WARN("%s is an unknown value for slider's mode", txt);
+    return 0; /*Return 0 in lack of a better option. */
+}
+
+#endif /* LV_USE_XML */
diff --git a/src/others/xml/parsers/lv_xml_slider_parser.h b/src/others/xml/parsers/lv_xml_slider_parser.h
new file mode 100644
index 000000000..cd387efcb
--- /dev/null
+++ b/src/others/xml/parsers/lv_xml_slider_parser.h
@@ -0,0 +1,40 @@
+/**
+ * @file lv_xml_slider_parser.h
+ *
+ */
+
+#ifndef LV_SLIDER_XML_PARSER_H
+#define LV_SLIDER_XML_PARSER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../lv_xml.h"
+#if LV_USE_XML
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void * lv_xml_slider_create(lv_xml_parser_state_t * state, const char ** attrs);
+void lv_xml_slider_apply(lv_xml_parser_state_t * state, const char ** attrs);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /* LV_USE_XML */
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_SLIDER_XML_PARSE_H*/
diff --git a/src/others/xml/parsers/lv_xml_tabview_parser.c b/src/others/xml/parsers/lv_xml_tabview_parser.c
new file mode 100644
index 000000000..93c020d59
--- /dev/null
+++ b/src/others/xml/parsers/lv_xml_tabview_parser.c
@@ -0,0 +1,109 @@
+/**
+ * @file lv_xml_tabview_parser.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_xml_tabview_parser.h"
+#if LV_USE_XML
+
+#include "../../../lvgl.h"
+#include "../../../lvgl_private.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void * lv_xml_tabview_create(lv_xml_parser_state_t * state, const char ** attrs)
+{
+    void * item = lv_tabview_create(lv_xml_state_get_parent(state));
+
+    lv_xml_obj_apply(state, attrs); /*Apply the common properties, e.g. width, height, styles flags etc*/
+
+    for(int i = 0; attrs[i]; i += 2) {
+        const char * name = attrs[i];
+        const char * value = attrs[i + 1];
+
+        if(lv_streq("active", name)) lv_tabview_set_active(item, lv_xml_atoi(value), 0);
+        if(lv_streq("tab_bar_position", name)) lv_tabview_set_tab_bar_position(item, lv_xml_dir_string_to_enum_value(value));
+    }
+    return item;
+}
+
+
+void lv_xml_tabview_apply(lv_xml_parser_state_t * state, const char ** attrs)
+{
+    void * item = lv_xml_state_get_item(state);
+
+    lv_xml_obj_apply(state, attrs); /*Apply the common properties, e.g. width, height, styles flags etc*/
+
+    for(int i = 0; attrs[i]; i += 2) {
+        const char * name = attrs[i];
+        const char * value = attrs[i + 1];
+
+        if(lv_streq("active", name)) lv_tabview_set_active(item, lv_xml_atoi(value), 0);
+        if(lv_streq("tab_bar_position", name)) lv_tabview_set_tab_bar_position(item, lv_xml_dir_string_to_enum_value(value));
+    }
+}
+
+void * lv_xml_tabview_tab_bar_create(lv_xml_parser_state_t * state, const char ** attrs)
+{
+    void * item = lv_tabview_get_tab_bar(lv_xml_state_get_parent(state));
+
+    /*Apply the common properties, e.g. width, height, styles flags etc*/
+    lv_xml_obj_apply(state, attrs);
+
+    return item;
+}
+
+
+void lv_xml_tabview_tab_bar_apply(lv_xml_parser_state_t * state, const char ** attrs)
+{
+    /*Apply the common properties, e.g. width, height, styles flags etc*/
+    lv_xml_obj_apply(state, attrs);
+}
+
+void * lv_xml_tabview_tab_create(lv_xml_parser_state_t * state, const char ** attrs)
+{
+    const char * text = lv_xml_get_value_of(attrs, "text");
+    void * item = lv_tabview_add_tab(lv_xml_state_get_parent(state), text);
+
+    /*Apply the common properties, e.g. width, height, styles flags etc*/
+    lv_xml_obj_apply(state, attrs);
+
+    return item;
+}
+
+void lv_xml_tabview_tab_apply(lv_xml_parser_state_t * state, const char ** attrs)
+{
+    /*Apply the common properties, e.g. width, height, styles flags etc*/
+    lv_xml_obj_apply(state, attrs);
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+#endif /* LV_USE_XML */
diff --git a/src/others/xml/parsers/lv_xml_tabview_parser.h b/src/others/xml/parsers/lv_xml_tabview_parser.h
new file mode 100644
index 000000000..9959da806
--- /dev/null
+++ b/src/others/xml/parsers/lv_xml_tabview_parser.h
@@ -0,0 +1,44 @@
+/**
+ * @file lv_xml_tabview_parser.h
+ *
+ */
+
+#ifndef LV_TABVIEW_XML_PARSER_H
+#define LV_TABVIEW_XML_PARSER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../lv_xml.h"
+#if LV_USE_XML
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+void * lv_xml_tabview_create(lv_xml_parser_state_t * state, const char ** attrs);
+void lv_xml_tabview_apply(lv_xml_parser_state_t * state, const char ** attrs);
+void * lv_xml_tabview_tab_bar_create(lv_xml_parser_state_t * state, const char ** attrs);
+void lv_xml_tabview_tab_bar_apply(lv_xml_parser_state_t * state, const char ** attrs);
+void * lv_xml_tabview_tab_create(lv_xml_parser_state_t * state, const char ** attrs);
+void lv_xml_tabview_tab_apply(lv_xml_parser_state_t * state, const char ** attrs);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#endif /* LV_USE_XML */
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_TABVIEW_XML_PARSE_H*/
diff --git a/src/stdlib/lv_string.h b/src/stdlib/lv_string.h
index d9101a512..cd24e08f5 100644
--- a/src/stdlib/lv_string.h
+++ b/src/stdlib/lv_string.h
@@ -128,6 +128,17 @@ int lv_strcmp(const char * s1, const char * s2);
  */
 int lv_strncmp(const char * s1, const char * s2, size_t len);
 
+/** Returns true if the two strings are equal.
+ * Just a wrapper around strcmp for convenience.
+ * @param s1    pointer to the first string
+ * @param s2    pointer to the second string
+ * @return      true: the strings are equal; false: otherwise
+ */
+static inline bool lv_streq(const char * s1, const char * s2)
+{
+    return lv_strcmp(s1, s2) == 0;
+}
+
 /**
  * @brief Duplicate a string by allocating a new one and copying the content.
  * @param src Pointer to the source of data to be copied.
diff --git a/tests/ref_imgs/xml/complex_1.png b/tests/ref_imgs/xml/complex_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..3371568d3dcee1083ff3938bbe22b3911610f9ed
GIT binary patch
literal 11154
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
L+RCU$mVf^*C#~!-

literal 0
HcmV?d00001

diff --git a/tests/ref_imgs/xml/component_create_1.png b/tests/ref_imgs/xml/component_create_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..562841305b3dd760b3f88ba421a8e25b2607c1cb
GIT binary patch
literal 3937
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

literal 0
HcmV?d00001

diff --git a/tests/ref_imgs/xml/consts_1.png b/tests/ref_imgs/xml/consts_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..59c25791369f858f139a806924d55c6c0cd42955
GIT binary patch
literal 2808
zcmeAS@N?(olHy`uVBq!ia0y~yU{+vYV0^&A1QfZHI&TpJ1J`~}7srr_IdAX!cgH=I
zJn-=LqXQ~#9$bRL2C9NlvplrQ!r09JMS6yJt-dn#f%=Ew64k$KOIKf7w@UkB?9nDM
z!4MuFrY=tf1K}$#tsm&bq`a6Bbi}jH*z<Ae+H+?<pPO0z^YNbNHqZC<_VzL|Ecm?H
z+LnRgz+SfmMusCSVhj#GWHH|SyZi5;{Ji=E{bvu<-)%KFfA@uhVL~A*H-kdib=GS?
zH-A3#(%P1V;Xv+=sRyclJ=s&HH$UZeQua0R>e3>HhT09Ut2cbRb>D91Wnl(}JM%0y
z%&SSMtFEc5OSmTXx&Qq0`0%_atMVj1y|dHf&)yb)e$@E$x1+P|3J(9=y!pnhb89}Q
zr`HyzJ^OOea)-(4?9azqcka8{$HO3?&HVaj{JB#fE3-@2)!3@{pLt(rdiwkM-SKD6
z>?x>{tInu?d87IBr^oi+=4c;JFU|e;>!XhT+0DzJecwOR{-3doB*TK~tk)hsjkL6@
z|5;(T*UY&1<*%H)v&H@AfMz^=TKQ(->}l7`pD#7Gf3@ZRzp{USE`Iy?D=98^=Hb(N
zNsJ8TTi<9NO6EUzrp)Q?hl5jR&TQxZ+rRX^{QnKzudR=V@1Hr-a#M|UG84m_owj$D
zJv?ylj>G;vThy1cGOS2xEPeWV=FE8cyFbsqTx@I{zW-)i)uS8dE`9H3WO!$|y>9Bu
zCl6=W?J23fx8Fv8?#-Pi|E`Qb6TRBl_`3P?zo&11-*bP*$-g_@)6>MFw;NkB9Eg1-
z#{BxhrFwhLAHS+UKWmMQf0J|h!}s%LWr;gBewm*u_3z6=JvkK?h9Ccn?jJk$E^gE8
zJ#T(KbpHJ6)SiFyo-^KjmU^Dyj`z1r_3z>HW}IF7^U19>`p-@@RzAD3X5C6{h6ney
z_&0t%)@oUvG|$qMeR^81p?u7|a=o|b>)9A?<nR91CBV=izpec@Fopdw;nZPhm~nuK
xp<|RW8VI8)VKf(v=7P~&Fq#X7dM>DCPgY#*u3r|l57?q*@O1TaS?83{1ONl{)$ITP

literal 0
HcmV?d00001

diff --git a/tests/ref_imgs/xml/image_and_font_1.png b/tests/ref_imgs/xml/image_and_font_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..7b464b4ffffc3d236d0e3b074ddfff0887e97c99
GIT binary patch
literal 9693
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
KQf%mQ|9=4^Rw6q9

literal 0
HcmV?d00001

diff --git a/tests/ref_imgs/xml/lv_slider.png b/tests/ref_imgs/xml/lv_slider.png
new file mode 100644
index 0000000000000000000000000000000000000000..e58e8bc21d1410a61ce13f1cae598c8c06ee017b
GIT binary patch
literal 5010
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

literal 0
HcmV?d00001

diff --git a/tests/ref_imgs/xml/nested_1.png b/tests/ref_imgs/xml/nested_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..bfd8e823b5fa040f109db22974d4575cdaf42646
GIT binary patch
literal 10919
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%0AfVo~uK{!hm$
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

literal 0
HcmV?d00001

diff --git a/tests/ref_imgs/xml/params_1.png b/tests/ref_imgs/xml/params_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..82a4f8e3ba1fdcd05d972b4a6fdaf2aca015da73
GIT binary patch
literal 5000
zcmeI0YgAKL+Q&DbU<JXJ83BdRu>tC(1d0j>A)<~D62Jw@MJ|a{MT`MNxd}<IbcUgb
z)I>$(5?d}AUkHRtpeg2}3}BXAO2Rcjf(66?feIl&LdbhMALh1J-?el;zCCN5FMIFv
zoPD0N_y70&ckbx`pB>wGZwCPEK>MBy0>I#70Q4rd=|e4|i)G&dU>=A*>3t@xL@_=}
zJToNge6`r{<y8#c**7syV1p0xE;+N)ck4H2cG9-%Kbc67ZvQgaJ8}QSX+5KB#@n+^
z9w3h|-9#Abe`U>DFUsxgEx*g|Y&4sT!E9buD3HYK*IfYUFDg<(udB)z=z~w~Spa<f
z!9kD}qi+lzKYYg~lIm^iuv7}mKZU^Y=DCy&>BAT%`xBo#T|GTL-QE5-4+2(!<n`;<
zWv<YeUOH;%?0g78F<k#eV`C!?whheZag7G^ED+7j&D5^0u7d{;c6E2JX9!Vy@=uM9
zj_%pB$HT(|{d#7m0ERp&_trbcMH&v;CbL;ACrgw6@oB%e$212T)E5S@Pq<@KUc2)<
zl9Olq_a(Q(OboMw83A@963OoTQ#6<<_}wT5kECpR3ZFlJzOj+HlIC_03T&}!*OK~%
zepXz=oIoO#E^vFhx*oRv^vMpx?4qI~sYazzRdniu`zbbIlg39UIYw)~ljg#+$3azB
zt-;*%%R;ng=U+aWG>^*+(i8L#C*$+!H>Yz=?pe}(VU>o0dvDLW1JJ%@7dYm8Yb!X7
z#p{9JnTNe&)7dHnV%69}rP>Fa{I?7`vQ>q3WF6Tsy9DVGU0qkB9C`@^=a)w+j1mP(
z9EHTbp*RQgd@(z_78McMC6WB?&s)Jp;kKIbI2_qM`VE0#WvWXnu0SASoh}myq_`*J
z++sM>4!yXz$f&ECQm?4y!%?Y@p>;g2Etq(GJvY&I?E5}M)NE{zGNMJz%~+&J5s@z>
z=R!g?%!u&lcpPaULAs%A+X7U%Ry8+?*Xqp-(USG$MT%rmmcZW-EshiN^3X|}nSn{u
ze%Kg2LDSAK`dF!laIV&m+7#Ps@46d2E)zWZX0*k{^0q~1<$%4LC3t)<gXP7ktb~V0
z5F7$-<Io)_y)601ELEo{C}WK!`@Sz>>`fq@r$t9Z&KEkeZOLyA9MHb*=Kb)f{g193
z1Hqwdxrw-@JPVEbrsj1qc_S@e+SO`)MxkCItFG4K5>VRy0^8o{moPB^;tFDX{KA!N
zhrlwpJ4vnFyq$Amrmx%w9Z=@!F24niSru;6`}NI2OEV2wW;#*IS1C9nu-5C6{hq(O
zzRfaBOOf*#x-xQnUB=pB?TpA-4+Kw5Yz@&l%M+rtt4g|<zc$g$56~RpJdDJ``foF2
z2Zqgn(_yb-B~X2b@^|EsuOH!*G?($HDzVYkr}xMniWZVJ3?#m=d1_TtuNs{j(p8e6
z?i58ShOF&W%4lWex$cb+{{0j?#m3wRtP09q@*J~>HJLCtkK(agT+q5a%-3}(->+TD
z0l?@mYqLUokBkaWUuo8rMEdglaejm1L7eMgyK+FOkz?esH24AGId#$!vEkm>@boR2
z><=LEjm-<pR}>;LJb+5JSH!4CnsU(8Ryn%Xp3XpGZSB#mnk(h1fnpowd5L=A&ibaQ
z9;o`1waK~%=V)J3qdeZW%&8F6YGDK|P}?>4xd9la?b}{6J=GJD(Cg3^nl~xBvPkSJ
zU@#dt|5}H(3;WVD3<*EGz63yb*>B<5tc>xQ{SftOPmOV0Z#0)0iqc*697_I7@hanh
zXIktzLgw2K!NdvceybW+Gv3kSNMFt8r0IeD(~9%zD-yQSyP>SazqSguQSIY$J9s{6
zDOk<9u)-`D6b*_f*g@*FYfG>0PabihB7Ok1M&~co13AK5CN(KPb+eyt9tsb{kr{MJ
zs@#nF5*kCdAJVCxg(||;Nez!8F$)euxZYcKibCZ}p`YZwa#YwNl*mk87b*vu*h+@5
zFt>GFZ{kNnadC00WI{-DKnKvhv>$e6>f%48!nICbesll2V2k!~jEunq|HONV4zzsd
z8v`jXT2mJ?)!DFZGxkUT9)D%^3oOhZK0BJ)gWUm~y1U*nI3%P@HoUy=vaMm;w=Q0H
zI~;xwu=!C&gLgmip<Yc$SZu?)-RN)-tySn}J*l4)JSr{qZ>X=YH_LwYqZQqElC~XG
zb<`RV;^S-C&5eyN)~2gp9J7YCy-JLYWw4L9y1L5i!Ldq+2ITqSdN@Rfh=_=R$ycml
zhy;PS{6Gir&_3gXnvs!__4Rdlfi3Dt0Yr<Ow$1`uhax&Xm9#TUE{5W)Hcvxj>Tn5j
zad9y=HokuS`ex8l@2T=W2nih>9X&k(R472XPeH)V)8KT%;;s7^4()~jley9P`Q}I&
zMVw)afS6|Ok%GNz;KcOOtVO-q@AXaa)~plH?T&ldKx*O!S6PNp`UfB);hp{p`+ab{
zoAn*tpH6?F=X77Sg!>B0Qe-G2pfo6S{u$oMEqV3~mC5`J*SbZZ9Qh~A*3R!>87(g_
zLz7G=9n}*Y8cD_z6B1UXv6n7&MZLXinEkA)3%fWT8lmrW@z*()nQm?OFL~dMIv_H)
z`qbI$?q(X;2e3I%MoobLwewx!_3ttmQp9^YhKL*<WdOmU55rpfB{-g1tFbakQq89^
zc?}{Q!T{uS$I@T|JuyYQG9Y3T(trNAx_UB|c+HtWFyFHa{EXYnN@0-Jr_;WzV_tOI
zm?TnpPfMOXW-?bQD^phEsZ9^yTt1)9YoN{zjW)(=$2gH(wTcX~vU}{FlM*LS@ozk#
zyNeUXXIB@vx^#Zx9|(l-C`C*B#dHp7<t#saS!`wwh8-@kX4&oSUY78<nO?pwj!)rh
zmoWU)y3ZW#h3m^m;r#>7xm$twIG&W0x&W_h-H#TPA&bW@gRGnSgyZqD9=ububzw;H
z1Ri7sEj&|CJ$OL9KxCG>Ig{<IbX!1Gwm@Qw!6;s}k)b(VD@T#kDhCLjxF7n-Yu`d#
zFLu?;UfE?a4rN~aH)!g8j?wdTbBf{w_1j5Ky31m~Y4+TZW~7lr=4zF}D6(fEA_Hpx
zu(W0lhf}?y%rl)jrId>`E-=$lp8}Yjd-~E;g^@nE7`b=LuNQy*Ke>l>w>;0xlIln{
zU;-sH`ESaX`fQ6ZZD)mUeE^|-X|I(UDb`Pfj1EC!5<Jm}Hp3&-;;Eln`9HW6-38$3
z;zTz-pDmM;kQm)wxqK#?`6EA2ht#I2nN0`c^6D6^n;kOdAO)*K%H=I0zVA{!^gUHl
z?;SO(Y?&yOwg)Zht%$-nRw1Fgu1Xe&^FwJ?M|A^Nv@=u3mx$`1hO*|e&2}H#ZQx;w
z(b7lfJ>D+B#fqk0S_P?)jL=eqNs!Vfphd7MGg`&Cwv)tbIftU9IBTy;+Tg-*B|MbY
zi<&(K1pOZ0+!~<U<9I9NwZWzKCJ*_ln5TKucF+zT&yVAz#86DP0BoUwRoHq?_;=5$
z>Dn|&<JX^*Qp^(}N@;F<4Djc$y~r@M`t8&ywO`WA05Zt-;s!m}LR7}RX;(+y^~)R`
zA=IiZ7I{5zbUZv&MD}yE$H-;;Xib15Mm;3QF>C`-g-T_eY*gM_&CZcm#|=Rw((Tm-
zCFurGACV_+fvh(9vFN>59jGg*WO1n27LF0dKvkDqR>iEWV~qQ2>_~@+ik0q&HYH<G
z$~i1m&_h~_RZ;5fsU!$P4B<+XOvKks7;r{yfNABwFD~0_UCpaRvjTD$ta9Z|UpX8q
zph}d-z~e4&?#XT7XS&_{dJNSF12r}7k?N)OHY>SKg8{&bz4S{kf4t$`n0uoOBq8rw
zW{oD}*@M*Er^-o|COJK8CwJ4&KxGr8iavL&(G6TK_dhw4l5#`{$-S4!pHIYQ?#&O}
z4<7DrHLZd6*PsM)If-s#1$x)gAbymVmJUkB#>W0`7gR|!P5l?0)T_`%B%UqEX^SBc
z2%e<FUZnv4Xx@%>DK>UyW`^cT-Wc}WmEmM<YKtP5Tp*LBE8d_ga1@F&`T!CA)Up@f
z{SRM+`9FLS*C>SAcUifyzAVjnmE~q~j?j6>CU^>9s|&W*)GHJUsB>u=Q`wFpFm2qE
zE~KOkMkxTc<x9x&O%Qqejo#h;y|-=r?ZN-rdH<He-%|K~XEy(@R?e`_Ks9o?tW-+c
R1|4|;^dAFG)*i=y`M(bOHnac$

literal 0
HcmV?d00001

diff --git a/tests/ref_imgs/xml/styles_1.png b/tests/ref_imgs/xml/styles_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..4800c46a20607d653d4a16cb87711a3dfc44ccb0
GIT binary patch
literal 4701
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

literal 0
HcmV?d00001

diff --git a/tests/ref_imgs/xml/widget_create_1.png b/tests/ref_imgs/xml/widget_create_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..d36b8b67b4f94d33627081aa106fd1379fd21fda
GIT binary patch
literal 3880
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
O0_P*{4%9=)jDG@r^LF9@

literal 0
HcmV?d00001

diff --git a/tests/ref_imgs_vg_lite/xml/complex_1.png b/tests/ref_imgs_vg_lite/xml/complex_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..f901497ac1ca5135e76e731dc05fb50930f17b12
GIT binary patch
literal 12155
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

literal 0
HcmV?d00001

diff --git a/tests/ref_imgs_vg_lite/xml/component_create_1.png b/tests/ref_imgs_vg_lite/xml/component_create_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..44e39615697f655cf13f18280a473f608bcb512e
GIT binary patch
literal 4481
zcmeI0SyWT!7RNs(L6E^^0TlvjZ>1Fwtq>Um6a)v5C>V%@Nt9HEg2k91gMf%sXy95b
zGRUA7kOV>$5(a?;C{D;Egb)ZILkI*&7!$&HgWiYhvh8gj?tSv<to7}0I{WPX+y8xT
zpLRH=D8F4E0HAo{_)$jyq;>!x@lH-sJo45j>mdM}kDoYt<ZQ_O$=-f{H=n^5(;WM}
zQ^~uXodUdlkGQLLzg9D>ZcTW*y3w<yU)M(=tOQ%P>n)Oh^Wj55<-vrn>v%UJqi@7p
z`8GOtI5OjN$R|>ue%Fnfl4h$_)N)@1em9bAf4$1%p3bbj)+l-;lVftl!RWvNCjegh
zqQk`3K;meUKyC{Hfb)_HV28bz1h~0T4@B*YmH{feNdVMItAWF*>y!L3VUmT}xs`5P
z36{%5H_c)lR3i-gIxEx1GjbcGz(GszQ9b+-SMY^|m)&Dl!sU#Gh0tq5-YfGLtGlJL
zLUO7MyF)N*p$_tZvOAhQudjFS0B2lCB&Iu41*`|$xl8oYtD68s1%YJM1z#J8VZ(@J
z`-T^yg9R6@FGw8j36Br_;k#yrJ{|rI`w_p9pw9EHPymQCOF9*vmDiV8?1mN{>}qM(
zoNv{BdTuGUd(q5=`(mUR0!fvJ$pL5$-fwPhLQ7L~yB2S9+<(@jyK7ff$yw?=bFQa<
z!b8nj1L1zMz>dySm(uPt5_S)HE_v((JudJ`$Tp_gw{M@fVkmO`ivf!Uj1KxO#u4{l
z9BZn3u|6nlAQX_89rH~Z2Llsv<o%^=S|xf#(9^%b>Q!roO^yk^06C3fQ&US5*%Z&F
znPRWCb<?5K^wOU<c=Zs*kwZg8N`59Ji)<E?s{$=RDwtK8%Ye}u=Gd5XT&X6)$<Dk;
z>4BN4g=K`_tIWF~N6$c?Z2GJCoMPq-KgZ0p?-gX?oc$Xq04=kHH4^OfWjp!W<?ZX6
zJ%A|mW=R6H=Nj!W!P-@+&=T^!09^yEGaU^{n0m=eDZ4M>MJT{O7#MJtC2Jy%3Hgil
zd=wJWfI<hfw7g%-?7MRZO62r4$J(wfPrTFC&UlhYZlgn16wJF1VjuV8XcAq|@qT=3
zWis|FAtvyb*@Q+*mW41Ww$W1Hu(w=&U;`X`dB5<Ub_E9AswVa-3_fp|u_7fk9${bw
zz2nl%;CuL*M8P0L2kk2wR^XD88S-YpuKZ(!Az4?A;K9S!rhTu<fXOWgq+7|E=B$82
zk)s|lV;uwBres_mLk6H}Y6F<*G3EJjbuJ;9VDYZ?^tI_RZrVyG5#%^Y`fHpcHs(%?
zU#v0qNvJnv+1QiE*I!y}d~%2TTkT9o4SpvP>^QO>{U(eJf1U?_DOo;G`Xi`xP6(u<
zs{RT_D5ZWVR9?>&@UumYM_)N2()?VpAWBE;YXclKtCyOUEZOBDtrh@LXk@<;Emji<
zdGum)>|;}NSEJ0`fV4qu+bp)lDyLXh^ws@yNcJ@|SrI3r!pT&n{3vEm3KxHOrcKDE
zD+o(jGKcLtx&IK_F@mz6RV|2yo3qt2`l#oNJ|&440gtzZweV_d#VONQQv=sl?f)1g
zq`h3nlkRv7b?d?uv4Wws)-9BmaCL%*9kUfA{#3Y7zpOTZ%s#coPOrRiwc}%u^jN$1
zSN$+F($y7jxk<J&cf72B^|_f*z_*-y0Xj?`WV~&9@<dco@hmA$YMjNk@pmDOg&R%s
zcSTV;=8LAMpDBySXJ2J9b)-9Mi((<-{H39c%*-Q%wU@n4>Ca!xR$1VG0Ev4E=q{})
zMXy_W8Eyku;7=He5Y=Wi{B{UX9@)0Y6YK_Piz`ytr!cv~m=7SKq3D+TF0U_H8M{=H
zKTFMvPC-}Mgj^KL>!^UKemK2#YN|J`KKd$pjcB<X2wl2Qb2X!IIDs$;FQ;y^Z=Vj%
zvu4$|ugsRjM1}`EH&rXlu6(o>lq6_^aIx*!C^a~}FHXyK@+41$WG@fSD3`UYTo{;1
zs!mqm*~s}5dGEY=2A08-qdEFkQDIJS^Cr|9jTYLUpfVc&fg_@pG^aR1`wP}Bl^uFi
z8##2tSQ~dCy7Sh3<I^7DuI>`U8}+(&rQ^hfWk_T#+-{$*<Pww>U|1~+3MG&?N%ZhV
z>y^dWMeZ<O+1T)`M|fo@ib~dvBJU!3DY*W3j&%OKUM{b!%KW=<erCZRvEXBY@%Q{x
z$ei2=4y)_Y*>#AO0W5nk#C$*UdZm+KLQl-~(c@QVytYAz+u>#TFHz1-Z{DE8lmLnN
z2PE;f+l&AKU;Z9RPFatOB~VYpr<$Z~kHI!TN%({$REo1sMSoUi=Ka*vv~*Vw*FEHW
zyGhqqO?rf@R6&H%fvI-y_Gij#&iCH-`Hu753bZq*7_`@(Lpz}bA88ci{F!O}x=LaY
zE~#Hrqa98&MLs4_Pi<O@@D5@2C{yA09J!9<r3P9Ywy9dMz^HL~8FZE|uGQ6FeyO{<
zk7^U*AHF<-)8NV@A|o@lu8x;idVdA!5bLL&o(LBdhJ&h4In6j2#40y|QU;a9IU9z-
zko%=cdFyu--W~{SxuHM4+>sRsi^h$Lk+jTW^}eW&HZs|Neo}rkUbseX=~ngU5PWqJ
zg}=VPW`waO;($}LgmmQ)AuU?Gu4tmOE>Zkc^uvTM@?r*PVt>50*hw=_cjbzOQ5Wq4
zi<;O7X8iOPr9#`JgT^^#yzz4r?~Q#HT62;YRCS-jj7b<}B~-S`J1vOTWl#Ce*4D(>
z^?mV?Ua_-V>Y|Md53$<R&r5XATPi!up=<1Go$1rZ+VAx0-v3T27k}%P%ff1~F)4Iu
z(fQe+8ZAAvG>8`&r&DRJKq<TscAY0a?#FdHhnNeOzX_vCr|4Eljq}&EH2v=`77x|i
zWfr@T8ai@`-I3=Gy%#-NhSYiO;^8bRyxCxcGZKhPYH@%W=<nU5?`0lwfFWG{EylBX
z({g!v{rb25Px+I3*Ab7;XHIBuMexHmOVXaty%sI@>gu})3+m}(7dnsno?7*|2}t`h
zwTcq8FMa>=wiLS|pRTGe&X550CR>xRr_;+1!W8qwm^%oArd#as&D6I7luTIUV^8X7
z&rG*@iMU&@6JRba6J;2ijP>|!3wGa&V`yLZ-1`%KO9}ghC^#~R$?#0Xoz+oF$rr#C
zf3T5#FZFRgzpMWLUUL3fAMtso{{;>|d;CwE*Uv%se+s&Etaf^8>cUK;0f)n3L_z`3
zI2jbgPlj2D-o+?W4E<tN^~9arRDwt(GN@U2NIyf7lK`v9c)Tm*sg;+xXgImLy85;V
zfPlbfm`T&%;p2oy__VY%a;hSrQG60qez!YY)ix<v*)FGgdtUr&1)Q*PI7+ngy74b~
CB-Ts-

literal 0
HcmV?d00001

diff --git a/tests/ref_imgs_vg_lite/xml/consts_1.png b/tests/ref_imgs_vg_lite/xml/consts_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..4fba9f2a7a688e95fb4f51d60a35632902aa3800
GIT binary patch
literal 2779
zcmeAS@N?(olHy`uVBq!ia0y~yU{+vYV0^&A1QfZHI&TpJ1J@!?7srr_IdAV8X2(94
zJ@Bx87Drx`e$zDt9~+G+O;UFpZ_Wvf-kf#iRer!P#a%zOQ@%u$U(VuS<<&hpVcMOe
zDpFB3?QRnfNE*EeI;z`p;-6>P+~+g<&Q*WCSN^B)o#p$=*H50LFfhFM^CVQCf#HF#
z@&*QmBqnYK1vRo5-_E7}f5^Z8@6FIP&GI|%|9uHGmXX0|T>>M+k+|Iltacdxwq9Q)
z$iSfg(3L4Wzq+p8JpSaZo93IXcCR|g$gu9<()R~<W%0}He<jMmuxF0NhIjkScSmpj
zc{#GywtwE4iyw=f<?qfrdQ9ejHQ)5j`;FUAKesD*_u$-|+Rf+IG+S@BnmhC7*Rzp1
zXFk2O`Lp|VG{b?{>v-1m*IVx1{_MkN%YRwh%%4AwKl^BI<(HJSwEFb2ymjr{^3EL0
zuX{0P_x7}(C2}_Nj^5t9-Il%l*}wURRhb#SY&vi&=FGdbl^?cO{#ieB=F=>{`DgF_
z{`}%(j$YdHXT{E|FW>zCfZezHTaMk&*S{)C&A!{sIosMD!Ehj3x4Ns~^|3Q+gkRmc
zIQ{kK|JGmbK7PMFCRRqi-qd*W&v&PFgc%;3ihXFt`#vw`<d*L3>r<i_8ob0Jo==}%
zR##V;_FVk+=jYD5qs5)?+p;lK9NzQ8Hsbc|^M7~7oV_T%`TxPAzVFKO&p&)_Y`l82
z<*%gL^S^)kzN>zJ{>&V^>X}oS8TKrTGuR*|{r|7ZgTMaIAKIstmTmMseE7UxS)zsf
zuk&WS^Zz^*;um6K_)`x`2u1ogedE6EDNTM?Yw_LwtBpc-+&7*Bv!Bc=E84%^dinWh
zAMMji&1QGsyglz}a49Rpo|)@3H~jl?v!<l_+qU$LhO5^<e^J3V{rcy#3=G%bUa}Wt
zV)*cPU4gs~Lxa3}BP)Y|a0CN`;V5G?5JpqNXf7Dd1*5rOG#3o<T(B{pF=4`L2i{vJ
R<AIG<22WQ%mvv4FO#rr%iaY=S

literal 0
HcmV?d00001

diff --git a/tests/ref_imgs_vg_lite/xml/image_and_font_1.png b/tests/ref_imgs_vg_lite/xml/image_and_font_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..ebb68bd4bf272e201c2135500e80f4af44d90dd3
GIT binary patch
literal 5232
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

literal 0
HcmV?d00001

diff --git a/tests/ref_imgs_vg_lite/xml/lv_slider.png b/tests/ref_imgs_vg_lite/xml/lv_slider.png
new file mode 100644
index 0000000000000000000000000000000000000000..44857bb41e78dcb5cbd6e106dae2b914f5ddefb4
GIT binary patch
literal 5679
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
Z?uY$0WYHYi4<>?va~2m)7oWt&{0ANFAzlCg

literal 0
HcmV?d00001

diff --git a/tests/ref_imgs_vg_lite/xml/nested_1.png b/tests/ref_imgs_vg_lite/xml/nested_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..8b70ec3ca678ad7beac599694329f1cc10f3d2f8
GIT binary patch
literal 11209
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

literal 0
HcmV?d00001

diff --git a/tests/ref_imgs_vg_lite/xml/params_1.png b/tests/ref_imgs_vg_lite/xml/params_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..d56711158d8a3002516822da171b89c5789ae377
GIT binary patch
literal 5027
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
A@Bjb+

literal 0
HcmV?d00001

diff --git a/tests/ref_imgs_vg_lite/xml/styles_1.png b/tests/ref_imgs_vg_lite/xml/styles_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..e69994bfb7214520e7ab36b56de5bcf7a2925f73
GIT binary patch
literal 5198
zcmeI0X;@R&*2gy>(qfhNVNwKfXjLY;6%fl53R+4SVi^RPLP4RSOfm!{kU*{aDhgFd
zF$_V}fCwZYGl78eBJ(VSDMT(L5T-CCkOY!@(A(#JzVG|xKKJo_JA1Fa_TFp%_xi1K
z?p|`V*)Ojq4*=M2`{M;C0A!8=Aocz;X{cr38u2LrO3JnuzITbuUSi;a-$fH!S9_y`
z{_<mI%N-FHE=_glE91c1nXeDF;QqYupv=4+7tB|XzAFyA@IQwYB`XS1l1aO-#ZyQh
zvN-SCxR}o`-2KTh@{ft1l~^fnl|9Tn4weUB4|tv<@{gE#6&K?uA`(nCW1k-jG0^Z?
zXBsdy4G7S)2Uup4(Fy>}8A|U1M;|vygU?Qu0`S}Cx**Z_-)tJzSU0TnV0Y?MnF+?C
zNerPp&|tQQL?Ap4BvzB`e(lVlht^-`zm}scPF(S<CU;{%qQv;D!M-zjWdGK<TpVrT
zrh?U8qxK2@(vT`Ln<`pHD@Xwo<{RlEk0l1RS~TP~%{Qdu8Pp>E#_YJbG4nlO?&`kJ
zij!4E#MtAaew#c@W+-~Rs$+ptV3o(P28k&~%%+!@F)_=F7IB7g2pz9lE^XeFdp<=L
z7`B^nk9S$@Z1h%;o!|^j?BfJB0ZjqGWH>&>cgR9;l_R5I=<lG@t^VDk(Yi{84oE!k
zZtJUJ4?WRDq=WlFP|m70NWA!Bs_7;1{6o>!bbvjoY@+`e9svv4lm|~_jMUvD!)T-T
zH9~&EER>)Tkn2nSNv<WAF)8Y(o=4~AZb){5D#w<Ufn@<ox3q&5fsS}(>+C`K)$gg-
znQDwI=tHUPD~6K>OwAe3wMyv5=H7)aV-3>KaXpY7o|y28kyEyfsWme;rvK$6ATUsM
zE%%z!l1<~=!TH<7K%7bG$sC`yM@1@I_W;1Ypyt`ogDP)r2i_U5=7ssdMUa`>08yA)
zG`M9&L?8QT_6t!HZvZnLm=e<G4T%U+5iCEQUm$ZU>f5v+&w;XLlntB{KK9VIavBx6
z6NZF~<T-v?tm^0fJc}aDogfw#B<4OPCGlW~9Q?zcKZGXmM|Gw|ZRJJHg^!h;(3s3Q
zkdj}PJ`n5C0Mj^V_e|iTX7`Lb_<9Jn?LHP^Qi9q<gG3m8MC(n!K|~Sr#}fsEnZmno
zx;e3M6wV}EH{`}QOIOkyxwaH_M^kjcO`g9u?-|lf^K(!-QUNQSKP3gN#SP~S7Zfp5
zN&R}9k$FQb?>9Z@yvRFAt}(hHg_;>c1Kx->DPD_(+mHev*+E2k{W6z>Iq_h|xloLE
zdMWXQ3;GSwN0*q{DRlj}(!hOtOw%2T({fZe6jqqV`E0bhJ(d1^kazfVo52xwR6H^c
zrTgFrA`6PhJnq$Z8WdzL?*}yjcUDmfsNB4G{oV?`A~0GF_88rm&SyCnV$DT%DCTNK
zEjHKJ0`Fss`C)J*B`P-3#NyH93#RX51j(9n%#A7olHmaX0qg=;oS&ax?9v#!1l52u
zjSgzLr@Z7N1)|b#Bfi2i$HyV9ttKFm)KdUxK*G#Cq#pb>rRwpOs$z!Xu6*5nubm|j
ztnwh0aS^wyPNt!Dl{#ps;yxP8&vMAhG$iqQ7+B1?tPc|2?eO;Yo?Wgj*c|~|Zm2FQ
z+6i-kW_<j1?J0#qi5bkln^N;|rK>Kwp?Y#`)+7cT_3%%^ce3ua{M{ziY~Z<3$p#|T
z!o<+<9h1piKK4=TaTrX7p659X-8(mQeE9kICD;8#{87{8gX-#w91dzzWp`2WvI9*`
zO)D!acT!;%-<nO_|6VT~y)>431QQ$^8|&-)gyFfnr*L21=B8?L%i+*EjwX63bNi6b
zeWS8a25fmOdRnhqDf!~8oK#{!o0wnS7_t#26bk>;y>iyvV4VUjSi*?0#%);}{Atu&
zu*t;D(Hm)e;R3g2I>oPSPQ?m5Iix1ieN&{3@0gjHxvO~Uj8Faf4IUlG<BuE1uU_1$
zu~a;KE`DRB*;&Vpy)H22)<+7~Sj(DwK;~6q5+ouQ?ZLspQwXA2B-<X28WpVL1fzjE
z2x5J{i-(hTbVg^M>0$IY8Px1vWXEi8@JP6@YMiF0;tVgkT;kD)-HE1q7mz_Bn}G8r
zrIWpCowV`!`T34HCa&6e>A+h$O7hLk%`JXqmrln*cjif<ijsSDhCY%O#Tlq(Voi;V
zqNm>6f|H!iWCR8VTJyU-&t-M9B5J+Jmrj4NfB*gi2M&DkMa@eM@Jmu+)61gEMNpqp
zVOMu|cTdl7P~{&5Io0+j)4Btwb#+kSgd$M`QyKJ~{W(b%SmtbMf&T|D{?DNKj~*D^
zYUWUap6b+>>@Z>^E0Y+U8HSIT?MZ+cD6V&{50yu8j5;$ECSs?%6)b83W_ysup7cp`
z&?M0$5M(p@YW-U+V#NXqZ0qRNOKHVpv;<MIz7KAbv2;WlMA2krhl4AHlamdSwfUl?
zo0;=u230dwz#<cgA7DAUEweyPR%OQh{cgEtf|BWr(aWLZ{I&(krmFl055+h3?s|wZ
zjd4^rSF?B_8(Pn$HDYHqTFXG<Ny4o6?{|n;VW5Yb7O7kl8#_k``~V#H_3wU*=BFXV
z{3N-|vV1%?dZz7OiRbt(j4U5$zJ570iCeBcsf()YiB$$o$Dv#4Ks>+N-KuHq4^Pf9
zjf+|vM0~W~FE>2<5sRxWo?(?3Y0#GhVJ@gLj@|Z<t&6%zVd5G+N~-?iUqtP8L3{g2
z2ULTdq9P>ET@X7Cy8A*GpkpH{Ex*DiI<C&Cu;MTK+S*zVIpub*e{qo$I@e!bUcOJz
z8;ULAKWl_hW4iH$tGQw`!9y9lsuX)OYQQo7`F|3!tm)+tw*C+7(=Z?G3vu`Ro&-kA
zkgCtPv!pDq?p|e++a9oD4e?hR4}*D00yyR;MoEHQK(3vTBRAk;=mYV*qG{Dueg+Jd
zJzg^{3{-HSm6C)*tLXzx`kQ*=wcM^rqt0COcbIkd2C}u8CUnTh>q~+662so!<M&<T
zBZAw9A9Cn?ds-=r+Is*gS<IVwtHJ73K$=99Zq2yE3#m1Ae~Wv+&9(V8!)_J_i{rGt
z=Juu{Ap6D1#PZ((DD#Nhv(T!l<fh*cI5U6Eoj2`zt6wHfKe%>fjHs-iD{cw%X%CsW
z4h<B3MbUAdjx-<@rS1Xl!4Tqj>j}p7;fwQOb$_xcSQyXv+3u@oecDZb1ft*!WD*Uz
zBIIc8tZaJQt!a@K2jT;4X=s7X5wJ^OiCVFcK>NniCMd&>M@e_uVRk**?sN8sg5pLq
zvDkR$o^?kWY#S~q6hl*Iq^RrOKhl<}-UcmbX@}}2UXBW#PDvktM&Kzal2tC!L?Y^^
zWf?1MM<90)+DHxVA&-Wu3vG`|P7uBkNO&A6;1Tju_VIdXb5I<R7|HVM91%MJ&RZCj
z!`4!`?CwB5*;Z@lOh!I(+yI(iu--gGNkNKdjn8O&cYfpD$b>y7i)lU+6a##JYVYdm
z+TO51*xT3B&>`!?6_XUl9FH=;i&Qs=tE5%u-y0en9`_$1&}bj4y5^)Iqw^yWeETbd
zuY81WSyRW=vy59-yZWrU)OIy~-~jlt7-|hDw=)h28b}}Zj1Vo223P$h=jiC@{S%Rh
zU3>8)hFUi!`2i{n@1S(`p}ZS9Qc+lNBJ}IUE7i+F&#<M)98>UR3FM6x(c*W#{Y0uE
z%0WjjVWU4UFHbBMe@F!m{z*gQ<J92MSB*6b<cX>f2eo%<wM*l7mTUaO!%GVa3U>MF
zIJlzxql}CUL=n1~IJS2s++c5|W$#!e-Hbm1vA3zol3M+-nwaNu^;MFMC!+={sc4?~
z3;nnA-qoSLbh2ypgp;mH&Mx$Rw%F`rtqUF;HukBGU^O`-cwx*Vw89%gZX@n}`>B08
zmy3~&w7&1d=464c_JahKDOWuFT13R!|K3$p)%U4i<I$N7J7`w2{+m|W`SH>`$<!UH
z8@X$CJ!bO8>>8_+0sCyXbeGW~xfHtO7ZgBby}|Axqz^0#*2{AfE}P$osB+2F!?QbB
zeL4FVI#{m+@opAO>d)4_A=S~!$yy{=h^)v)aoqyh*$r5(cfm@X;BI6uEj--W*}1?m
zM;i}MDu1Iae`{)L%CF4*v{F6B6!f|5lP|98gveSK#TgH4%*o8G3!kzgIca5dLaF7L
zh^?2^&4##o#_hDy?c2Ba%E`&?-Rm`U09067`VP4k4MBZ{E^Ia%s?dL}^k^IG@jRK<
z9#9UIR|yFTJ3Bj*TzT*dp%nTAd(va0Ap`a(x&!cfj|#B-8wA@g?R}*_HGPW2Cry01
i3ZIg~e{U`nE1r&=wYHDnmjL}I1hy9)FOaQ#fBOezI~e!?

literal 0
HcmV?d00001

diff --git a/tests/ref_imgs_vg_lite/xml/widget_create_1.png b/tests/ref_imgs_vg_lite/xml/widget_create_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..82be27bec4f119894bb2909a2aacc9fe7e1491d9
GIT binary patch
literal 4315
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

literal 0
HcmV?d00001

diff --git a/tests/src/lv_test_conf_full.h b/tests/src/lv_test_conf_full.h
index 4fa8c8a61..4b1ea9583 100644
--- a/tests/src/lv_test_conf_full.h
+++ b/tests/src/lv_test_conf_full.h
@@ -101,6 +101,7 @@
 #define LV_USE_PROFILER         1
 #define LV_PROFILER_INCLUDE     "lv_profiler_builtin.h"
 #define LV_USE_GRIDNAV          1
+#define LV_USE_XML              1
 
 #define LV_BUILD_EXAMPLES       1
 #define LV_USE_DEMO_WIDGETS     1
diff --git a/tests/src/test_assets/lv_example_xml.h b/tests/src/test_assets/lv_example_xml.h
new file mode 100644
index 000000000..341144881
--- /dev/null
+++ b/tests/src/test_assets/lv_example_xml.h
@@ -0,0 +1,38 @@
+/**
+ * @file lv_example_xml.h
+ *
+ */
+
+#ifndef LV_EXAMPLE_XML_H
+#define LV_EXAMPLE_XML_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+void lv_example_xml_1(void);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*LV_EXAMPLE_XML_H*/
diff --git a/tests/src/test_assets/xml/my_button.xml b/tests/src/test_assets/xml/my_button.xml
new file mode 100644
index 000000000..5afb24c59
--- /dev/null
+++ b/tests/src/test_assets/xml/my_button.xml
@@ -0,0 +1,15 @@
+<component>
+	<consts>
+		<px name="size" value="100"/>
+		<color name="orange" value="0xffa020"/>
+	</consts>
+
+	<api>
+		<prop type="string" name="btn_text"/>
+	</api>
+
+	<view extends="lv_button" width="#size">
+		<my_h3 text="$btn_text" align="center" color="#orange"/>
+	</view>
+</component>
+
diff --git a/tests/src/test_assets/xml/my_card.xml b/tests/src/test_assets/xml/my_card.xml
new file mode 100644
index 000000000..de787fa07
--- /dev/null
+++ b/tests/src/test_assets/xml/my_card.xml
@@ -0,0 +1,23 @@
+<component>
+	<consts>
+		<px name="size" value="100%"/>
+	</consts>
+
+	<api>
+		<prop type="string" name="title" default="No title"/>
+		<prop type="string" name="action" default="No action"/>
+		<prop type="color" name="bg_color" default="0xcccccc"/>
+		<prop type="style" name="btn_rel_style"/>
+		<prop type="style" name="btn_pr_style"/>
+	</api>
+
+	<styles>
+		<style name="gray" bg_color="0x888888"/>
+		<style name="blue" bg_color="0x0000ff"/>
+	</styles>
+
+	<view extends="lv_obj" style_radius="3" width="#size" height="content" style_bg_color="$bg_color" >
+		<lv_label text="$title" align="left_mid"/>
+		<my_button styles="$btn_rel_style $btn_pr_style:pressed" btn_text="$action" align="right_mid"/>
+	</view>
+</component>
diff --git a/tests/src/test_assets/xml/my_h3.xml b/tests/src/test_assets/xml/my_h3.xml
new file mode 100644
index 000000000..fc1c9e98b
--- /dev/null
+++ b/tests/src/test_assets/xml/my_h3.xml
@@ -0,0 +1,10 @@
+<component>
+    <api>
+        <prop type="color" name="color" default="0"/>
+        <prop type="style" name="style"/>
+    </api>
+    <view extends="lv_label"
+		  style_text_color="$color"
+		  styles="$style"
+		  style_text_font="lv_montserrat_18"></view>
+</component>
\ No newline at end of file
diff --git a/tests/src/test_assets/xml/view.xml b/tests/src/test_assets/xml/view.xml
new file mode 100644
index 000000000..a59d948e0
--- /dev/null
+++ b/tests/src/test_assets/xml/view.xml
@@ -0,0 +1,25 @@
+<component>
+	<consts>
+		<color name="light_blue" value="0xbbbbff"/>
+		<color name="dark_blue" value="0x000080"/>
+	</consts>
+
+	<styles>
+		<style name="btn_style" bg_color="#dark_blue" bg_opa="150"/>
+		<style name="btn_pr_style" bg_opa="255"/>
+	</styles>
+
+	<view extends="lv_obj" width="280" height="content" style_bg_color="#light_blue">
+		<lv_label text="Hello"/>
+		<my_card title="Card 1"
+				 y="0"
+				 btn_rel_style="btn_style"
+				 btn_pr_style="btn_pr_style"/>
+
+		<my_card y="85"
+				 bg_color="0xffaaaa"
+				 action="Apply"
+				 btn_rel_style="btn_style"
+				 btn_pr_style="btn_pr_style"/>
+	</view>
+</component>
diff --git a/tests/src/test_cases/xml/test_xml_general.c b/tests/src/test_cases/xml/test_xml_general.c
new file mode 100644
index 000000000..0512ffc5a
--- /dev/null
+++ b/tests/src/test_cases/xml/test_xml_general.c
@@ -0,0 +1,348 @@
+#if LV_BUILD_TEST
+#include "../lvgl.h"
+
+#include "unity/unity.h"
+
+void setUp(void)
+{
+    /* Function run before every test */
+}
+
+void tearDown(void)
+{
+    /* Function run after every test */
+    lv_obj_clean(lv_screen_active());
+}
+
+
+void test_xml_widget_direct_create(void)
+{
+    lv_obj_set_style_pad_all(lv_screen_active(), 16, 0);
+
+    lv_obj_t * slider;
+
+    /*Simple create*/
+    slider = lv_xml_create(lv_screen_active(), "lv_slider", NULL);
+
+    /*Adjust the returned widget*/
+    slider = lv_xml_create(lv_screen_active(), "lv_slider", NULL);
+    lv_obj_set_pos(slider, 10, 100);
+    lv_slider_set_value(slider, 40, LV_ANIM_OFF);
+
+    /*Use attributes*/
+    const char * attrs[] = {
+        "range_min", "-100",
+        "range_max", "100",
+        "mode", "symmetrical",
+        "value", "50",
+        NULL, NULL,
+    };
+
+    slider = lv_xml_create(lv_screen_active(), "lv_slider", attrs);
+    lv_obj_set_pos(slider, 10, 200);
+
+    TEST_ASSERT_EQUAL_SCREENSHOT("xml/widget_create_1.png");
+}
+
+void test_xml_widget_create_from_component(void)
+{
+    lv_obj_set_style_pad_all(lv_screen_active(), 16, 0);
+
+    const char * red_slider_xml =
+        "<component>"
+        "<view extends=\"lv_slider\" value=\"20\" width=\"100%\" style_bg_color=\"0xff0000\">"
+        "</view>"
+        "</component>";
+
+    lv_xml_component_register_from_data("red_slider", red_slider_xml);
+
+    lv_obj_t * slider;
+
+    /*Simple create*/
+    slider = lv_xml_create(lv_screen_active(), "red_slider", NULL);
+
+    /*Adjust the returned widget*/
+    slider = lv_xml_create(lv_screen_active(), "red_slider", NULL);
+    lv_obj_set_pos(slider, 10, 100);
+    lv_slider_set_value(slider, 40, LV_ANIM_OFF);
+
+    /*Use attributes*/
+    const char * attrs[] = {
+        "range_min", "-100",
+        "range_max", "100",
+        "mode", "symmetrical",
+        "value", "50",
+        NULL, NULL,
+    };
+
+    slider = lv_xml_create(lv_screen_active(), "red_slider", attrs);
+    lv_obj_set_pos(slider, 10, 200);
+
+
+    TEST_ASSERT_EQUAL_SCREENSHOT("xml/component_create_1.png");
+}
+
+void test_xml_nesting(void)
+{
+    const char * red_button_xml =
+        "<component>"
+        "<view extends=\"lv_button\" radius=\"0\" style_bg_color=\"0xff0000\">"
+        "</view>"
+        "</component>";
+
+    const char * card_xml =
+        "<component>"
+        "<view width=\"200\" height=\"content\">"
+        "<lv_label text=\"Some text here\" align=\"top_mid\"/>"
+        "<red_button y=\"20\">"
+        "<lv_label text=\"Button 1\" align=\"center\"/>"
+        "</red_button>"
+        "</view>"
+        "</component>";
+
+    lv_xml_component_register_from_data("red_button", red_button_xml);
+    lv_xml_component_register_from_data("card", card_xml);
+
+    lv_obj_t * card;
+    card = lv_xml_create(lv_screen_active(), "card", NULL);
+    card = lv_xml_create(lv_screen_active(), "card", NULL);
+    lv_obj_set_y(card, 80);
+
+    /*Use attributes*/
+    const char * attrs[] = {
+        "y", "160",
+        NULL, NULL,
+    };
+    card = lv_xml_create(lv_screen_active(), "card", attrs);
+
+    TEST_ASSERT_EQUAL_SCREENSHOT("xml/nested_1.png");
+}
+
+/*Pass style and simple properties 3 level deep*/
+void test_xml_component_params(void)
+{
+    const char * h3_xml =
+        "<component>"
+        "<api>"
+        "<prop name=\"style\" type=\"style\"/>"
+        "</api>"
+        "<view extends=\"lv_label\" styles=\"$style\">"
+        "</view>"
+        "</component>";
+
+    const char * red_button_xml =
+        "<component>"
+        "<api>"
+        "<prop type=\"string\" name=\"btn_text\"/>"
+        "<prop type=\"style\" name=\"label_style\"/>"
+        "</api>"
+        "<view extends=\"lv_button\" style_radius=\"0\" style_bg_color=\"0xff0000\">"
+        "<h3 text=\"$btn_text\" style=\"$label_style\"/>"
+        "</view>"
+        "</component>";
+
+    const char * card_xml =
+        "<component>"
+        "<api>"
+        "<prop type=\"string\" name=\"action\" default=\"Default\"/>"
+        "</api>"
+        "<styles>"
+        "<style name=\"style1\" text_color=\"0xffff00\"/>"
+        "</styles>"
+        "<view width=\"200\" height=\"content\">"
+        "<h3 text=\"Title\" align=\"top_mid\" style_text_color=\"0xff0000\"/>"
+        "<red_button btn_text=\"$action\" label_style=\"style1\" y=\"20\"/>"
+        "</view>"
+        "</component>";
+
+    lv_xml_component_register_from_data("h3", h3_xml);
+    lv_xml_component_register_from_data("red_button", red_button_xml);
+    lv_xml_component_register_from_data("card", card_xml);
+
+    lv_xml_create(lv_screen_active(), "card", NULL);
+
+    /*Use attributes*/
+    const char * attrs[] = {
+        "y", "100",
+        "action", "Ext. text",
+        NULL, NULL,
+    };
+    lv_xml_create(lv_screen_active(), "card", attrs);
+
+    TEST_ASSERT_EQUAL_SCREENSHOT("xml/params_1.png");
+}
+
+void test_xml_component_consts(void)
+{
+    const char * h3_xml =
+        "<component>"
+        "<consts>"
+        "<string name=\"action\" value=\"Log in\"/>"
+        "<color name=\"dark_color\" value=\"0x804000\"/>"
+        "<color name=\"accent_color\" value=\"0xff8000\"/>"
+        "<int name=\"size\" value=\"200\"/>"
+        "</consts>"
+        "<styles>"
+        "<style name=\"style1\" bg_color=\"#dark_color\" bg_opa=\"255\"/>"
+        "</styles>"
+        "<view extends=\"lv_label\" width=\"#size\" style_text_color=\"#accent_color\" text=\"#action\" styles=\"style1\">"
+        "</view>"
+        "</component>";
+
+    lv_xml_component_register_from_data("h3", h3_xml);
+
+    lv_xml_create(lv_screen_active(), "h3", NULL);
+
+    TEST_ASSERT_EQUAL_SCREENSHOT("xml/consts_1.png");
+}
+
+void test_xml_component_styles(void)
+{
+    const char * my_btn_xml =
+        "<component>"
+        "<styles>"
+        "<style name=\"rel_style\" bg_color=\"0xff0000\"/>"
+        "<style name=\"pr_style\" bg_color=\"0x800000\"/>"
+        "</styles>"
+        "<view extends=\"lv_button\" style_text_color=\"0x0000ff\" style_text_color:checked=\"0xa0a0ff\" styles=\"rel_style pr_style:checked\">"
+        "<lv_label/>"
+        "</view>"
+        "</component>";
+
+    lv_xml_component_register_from_data("my_btn", my_btn_xml);
+
+    lv_xml_create(lv_screen_active(), "my_btn", NULL);
+    lv_obj_t * btn = lv_xml_create(lv_screen_active(), "my_btn", NULL);
+    lv_obj_set_pos(btn, 0, 100);
+    lv_obj_add_state(btn, LV_STATE_CHECKED);
+
+    lv_test_wait(300); /*Wait for the state transition animation*/
+    TEST_ASSERT_EQUAL_SCREENSHOT("xml/styles_1.png");
+}
+
+void test_xml_error_resilience_syntax_ok(void)
+{
+    const char * my_btn_xml =
+        "<component>"
+        "<consts>"
+        "<int name=\"abc\" value=\"0xff0000\"/>"
+        "<not_a_type name=\"xyz\" value=\"0xff0000\"/>"
+        "<int not_a_prop=\"abc\" value=\"0xff0000\"/>"
+        "<int name=\"abc\" not_a_value=\"0xff0000\"/>"
+        "</consts>"
+        "<styles>"
+        "<style name=\"rel_style\" bg_color=\"0xff0000\" not_a_prop=\"0xff0000\"/>"
+        "<inv_style name=\"rel_style\" bg_color=\"0x800000\"/>"
+        "<style bg_color=\"0x800000\"/>"
+        "</styles>"
+
+        "<view extends=\"not_a_widget\" style_text_color=\"0x0000ff\" style_text_color:checked=\"0x8080ff\" styles=\"rel_style pr_style:checked\">"
+        "<unknown/>"
+        "<lv_label not_an_attr=\"40\"/>"
+        "</view>"
+        "</component>";
+
+    lv_xml_component_register_from_data("my_btn", my_btn_xml);
+
+    lv_obj_t * btn = lv_xml_create(lv_screen_active(), "my_btn", NULL);
+    if(btn) lv_obj_set_pos(btn, 0, 100);
+}
+
+void test_xml_image_and_font(void)
+{
+    const char * btn_xml =
+        "<component>"
+        "<consts>"
+        "<font name=\"font1\" value=\"lv_montserrat_18\"/>"
+        "<image name=\"image1\" value=\"test_img1\"/>"
+        "</consts>"
+        "<styles>"
+        "<style name=\"style_rel\" text_font=\"#font1\" text_color=\"0xffffff\" bg_image_src=\"#image1\" bg_image_tiled=\"true\" radius=\"0\"/>"
+        "<style name=\"style_chk\" text_font=\"lv_montserrat_16\" text_color=\"0xffff00\" bg_image_src=\"test_img2\"/>"
+        "</styles>"
+        "<view extends=\"lv_obj\" width=\"100\" height=\"70\" styles=\"style_rel style_chk:checked\" >"
+        "<lv_label text=\"hello\" align=\"center\" style_bg_color=\"0x888888\" style_bg_opa=\"200\"/>"
+        "</view>"
+        "</component>";
+
+    /*Monstserrat fonts are registered by LVGL */
+    LV_IMAGE_DECLARE(img_render_lvgl_logo_l8);
+    LV_IMAGE_DECLARE(img_render_lvgl_logo_rgb565);
+    lv_xml_register_image("test_img1", &img_render_lvgl_logo_l8);
+    lv_xml_register_image("test_img2", &img_render_lvgl_logo_rgb565);
+
+    lv_xml_component_register_from_data("btn", btn_xml);
+
+    lv_obj_t * btn;
+    btn = lv_xml_create(lv_screen_active(), "btn", NULL);
+
+    btn = lv_xml_create(lv_screen_active(), "btn", NULL);
+    lv_obj_set_pos(btn, 0, 100);
+    lv_obj_add_state(btn, LV_STATE_CHECKED);
+
+    TEST_ASSERT_EQUAL_SCREENSHOT("xml/image_and_font_1.png");
+}
+
+void test_xml_error_resilience_not_closed_tag(void)
+{
+    const char * my_btn_xml =
+        "<component>"
+        "<view extends=\"lv_button\">"
+        "<lv_label/>"
+        "</component>";
+
+    lv_xml_component_register_from_data("my_btn", my_btn_xml);
+
+    lv_obj_t * btn = lv_xml_create(lv_screen_active(), "my_btn", NULL);
+    if(btn) lv_obj_set_pos(btn, 0, 100);
+}
+
+void test_xml_error_resilience_string(void)
+{
+    const char * my_btn_xml =
+        "<component>"
+        "<view extends=\"lv_button>"
+        "<lv_label/>"
+        "</component>";
+
+    lv_xml_component_register_from_data("my_btn", my_btn_xml);
+
+    lv_obj_t * btn = lv_xml_create(lv_screen_active(), "my_btn", NULL);
+    if(btn) lv_obj_set_pos(btn, 0, 100);
+}
+
+void test_xml_complex(void)
+{
+    lv_xml_component_register_from_file("A:src/test_assets/xml/my_h3.xml");
+    lv_xml_component_register_from_file("A:src/test_assets/xml/my_card.xml");
+    lv_xml_component_register_from_file("A:src/test_assets/xml/my_button.xml");
+    lv_xml_component_register_from_file("A:src/test_assets/xml/view.xml");
+
+    lv_obj_t * obj = lv_xml_create(lv_screen_active(), "view", NULL);
+    lv_obj_set_pos(obj, 10, 10);
+
+    const char * my_button_attrs[] = {
+        "x", "10",
+        "y", "-10",
+        "align", "bottom_left",
+        "btn_text", "New button",
+        NULL, NULL,
+    };
+
+    lv_xml_create(lv_screen_active(), "my_button", my_button_attrs);
+
+    const char * slider_attrs[] = {
+        "x", "200",
+        "y", "-15",
+        "align", "bottom_left",
+        "value", "30",
+        NULL, NULL,
+    };
+
+    lv_obj_t * slider = lv_xml_create(lv_screen_active(), "lv_slider", slider_attrs);
+    lv_obj_set_width(slider, 100);
+
+    TEST_ASSERT_EQUAL_SCREENSHOT("xml/complex_1.png");
+}
+
+#endif
diff --git a/tests/src/test_cases/xml/test_xml_slider.c b/tests/src/test_cases/xml/test_xml_slider.c
new file mode 100644
index 000000000..d8cc5c9a1
--- /dev/null
+++ b/tests/src/test_cases/xml/test_xml_slider.c
@@ -0,0 +1,75 @@
+#if LV_BUILD_TEST
+#include "../lvgl.h"
+
+#include "unity/unity.h"
+
+void setUp(void)
+{
+    /* Function run before every test */
+}
+
+void tearDown(void)
+{
+    /* Function run after every test */
+    lv_obj_clean(lv_screen_active());
+}
+
+static void test_with_attrs(const char * name)
+{
+    lv_obj_t * scr = lv_screen_active();
+
+    lv_obj_set_flex_flow(scr, LV_FLEX_FLOW_COLUMN);
+    lv_obj_set_flex_align(scr, LV_FLEX_ALIGN_SPACE_EVENLY, LV_FLEX_ALIGN_CENTER, LV_FLEX_ALIGN_CENTER);
+
+    lv_xml_create(scr, name, NULL);
+
+    const char * attrs_1[] = {
+        "value", "30",
+        "width", "100",
+        NULL, NULL,
+    };
+
+    lv_xml_create(scr, name, attrs_1);
+
+    const char * attrs_2[] = {
+        "range_min", "-100",
+        "range_max", "100",
+        "mode", "symmetrical",
+        "value", "50",
+        NULL, NULL,
+    };
+
+    lv_xml_create(scr, name, attrs_2);
+
+    const char * attrs_3[] = {
+        "orientation", "vertical",
+        "height", "80",
+        "width", "30",
+        "value", "40",
+        NULL, NULL,
+    };
+
+    lv_xml_create(scr, name, attrs_3);
+
+
+    TEST_ASSERT_EQUAL_SCREENSHOT("xml/lv_slider.png");
+}
+
+void test_xml_slider_widget(void)
+{
+    test_with_attrs("lv_slider");
+}
+
+void test_xml_slider_component(void)
+{
+    const char * xml = "<component>"
+                       "<view extends=\"lv_slider\">"
+                       "</view>"
+                       "</component>";
+
+    lv_xml_component_register_from_data("slider_test", xml);
+
+    test_with_attrs("slider_test");
+}
+
+#endif
diff --git a/xmls/globals.xml b/xmls/globals.xml
new file mode 100644
index 000000000..c4e6e7278
--- /dev/null
+++ b/xmls/globals.xml
@@ -0,0 +1,45 @@
+<const name="size_content" help="Involve all children"/>
+
+<api>
+    <enumdef name="lv_style_state">
+        <enum name="default" help="Some help"/>
+        <enum name="pressed" help="Some help"/>
+        <enum name="checked" help="Some help"/>
+    </enumdef>
+    <enumdef name="lv_style_part">
+        <enum name="main" help="Some help"/>
+        <enum name="scrollbar" help="Some help"/>
+        <enum name="indicator" help="Some help"/>
+        <enum name="knob" help="Some help"/>
+    </enumdef>
+    <enumdef name="lv_align">
+        <enum name="top_left" help="Some help"/>
+        <enum name="bottom_right" help="Some help"/>
+        <enum name="center" help="Some help"/>
+    </enumdef>
+    <enumdef name="lv_dir">
+        <enum name="top" help="Some help"/>
+        <enum name="bottom" help="Some help"/>
+        <enum name="left" help="Some help"/>
+        <enum name="right" help="Some help"/>
+    </enumdef>
+    <enumdef name="lv_flex_flow">
+            <enum name="row"            		help="In a row"/>
+            <enum name="row_wrap"       		help="In rows and wrap"/>
+            <enum name="row_reverse"    		help="In a row with reverse"/>
+            <enum name="row_wrap_reverse"   	help="In rows with wrap and reverse"/>
+            <enum name="column"         		help="In a column"/>
+            <enum name="column_wrap"    		help="In columns and wrap"/>
+            <enum name="column_reverse"         help="In a column with reverse"/>
+            <enum name="column_wrap_reverse"    help="In columns with wrap and reverse"/>
+    </enumdef>
+    <enumdef name="lv_flex_align">
+            <enum name="center"         help=""/>
+            <enum name="start"    		help=""/>
+            <enum name="end"       		help=""/>
+            <enum name="space_around"  	help=""/>
+            <enum name="space_between"  help=""/>
+             <enum name="space_evenly"  help=""/>
+    </enumdef>
+
+</api>
diff --git a/xmls/lv_animimg.xml b/xmls/lv_animimg.xml
new file mode 100644
index 000000000..7bb07ea74
--- /dev/null
+++ b/xmls/lv_animimg.xml
@@ -0,0 +1,18 @@
+<!--
+Example
+<lv_animinmg src="img1 img2" duration="300" repeat_count="3"/>
+-->
+<widget>
+	<api>
+	    <const name="infinite" help="Repeat the animation infinite times"/>
+	    <prop name="src"  help="Image sources">
+	        <param name="src_array" type="image_src[count]"/>
+	    </prop>
+	    <prop name="duration" help="Length of the animation in milliseconds">
+	        <param name="time_ms" type="int"/>
+	    </prop>
+	    <prop name="repeat_count">
+	        <param name="cnt" type="int"/>
+	    </prop>
+	</api>
+</widget>
diff --git a/xmls/lv_arc.xml b/xmls/lv_arc.xml
new file mode 100644
index 000000000..8be65957f
--- /dev/null
+++ b/xmls/lv_arc.xml
@@ -0,0 +1,32 @@
+<!--
+Example
+<lv_arc mode="reverse" angles="100° 200°" bg_angles="30° 150° range="40 100" value="60"/>
+-->
+
+<widget>
+	<api>
+	    <enumdef name="lv_arc_mode" help="the mode">
+	        <enum name="normal" help="normal"/>
+	        <enum name="symmetrical" help="sym"/>
+	        <enum name="reverse" help="reverse"/>
+	    </enumdef>
+	    <prop name="angles" help="Start and end angles of the indicator">
+	        <param name ="start_angle" type="deg" help="The start angle"/>
+	        <param name ="end_angle" type="deg" help="The end angle"/>
+	    </prop>
+	    <prop name="bg_angles" help="Start and end angles of the background">
+	        <param name ="start_angle" type="deg" help="The start angle"/>
+	        <param name ="end_angle" type="deg" help="The end angle"/>
+	    </prop>
+	    <prop name="range" help="The range">
+	        <param name ="min" type="int" help="The min range"/>
+	        <param name ="max" type="int" help="The max range"/>
+	    </prop>
+	    <prop name="value" help="The current value">
+	        <param name="value" type="int"/>
+	    </prop>
+	    <prop name="mode" help="The mode">
+	        <param name="mode" type="enum:lv_arc_mode"/>
+	    </prop>
+	</api>
+</widget>
diff --git a/xmls/lv_bar.xml b/xmls/lv_bar.xml
new file mode 100644
index 000000000..87b9d5036
--- /dev/null
+++ b/xmls/lv_bar.xml
@@ -0,0 +1,38 @@
+<!--
+Example
+<lv_bar mode="symmetrical" angles="100° 200°" bg_angles="30° 150° range="40 100" value="60"/>
+-->
+
+<widget>
+	<api>
+		<enumdef name="lv_bar_mode" help="the mode">
+			<enum name="normal" help="normal"/>
+			<enum name="symmetrical" help="sym"/>
+			<enum name="range" help="range"/>
+		</enumdef>
+
+		<enumdef name="bar_orientation" help="">
+			<enum name="auto" help=""/>
+			<enum name="horizontal" help=""/>
+			<enum name="vertical" help=""/>
+		</enumdef>
+
+	    <prop name="range" help="The range">
+	    	<param name ="min" type="int" help="The min range"/>
+	    	<param name ="max" type="int" help="The max range"/>
+	   	</prop>
+
+	    <prop name="value" help="The current value">
+	    	<param name ="value" type="int" help="The current value"/>
+	    	<param name ="animated" type="bool" help="Set the value with animation" optional="true" default="false"/>
+	   	</prop>
+
+	    <prop name="mode" help="The mode">
+	    	<param name="mode" type="enum:lv_bar_mode"/>
+	   	</prop>
+
+	    <prop name="orientation" help="Orientation">
+	    	<param name="mode" type="enum:lv_bar_orientation"/>
+	   	</prop>
+	</api>
+</widget>
\ No newline at end of file
diff --git a/xmls/lv_button.xml b/xmls/lv_button.xml
new file mode 100644
index 000000000..755c93694
--- /dev/null
+++ b/xmls/lv_button.xml
@@ -0,0 +1,11 @@
+<!--
+Example:
+<lv_button>
+	<lv_label text="hello"/>
+</lv_button>
+-->
+
+<widget>
+	<api>
+	</api>
+</widget>
\ No newline at end of file
diff --git a/xmls/lv_buttonmatrix.xml b/xmls/lv_buttonmatrix.xml
new file mode 100644
index 000000000..94da83802
--- /dev/null
+++ b/xmls/lv_buttonmatrix.xml
@@ -0,0 +1,46 @@
+<!--
+Example
+<lv_buttonmatrix map="'1' '2' '\n' '3'" ctrl_map="checked|width_3 none disabled"/>
+-->
+
+<widget>
+	<api>
+		<enumdef name="lv_buttonamtrix_ctrl" multi="true" help="control flags for the buttons">
+			<enum name="none"      help="No special control"/>
+			<enum name="width_1"   help="Relative width is 1 in its row"/>
+			<enum name="width_2"   help="Relative width is 2 in its row"/>
+			<enum name="width_3"   help="Relative width is 3 in its row"/>
+			<enum name="width_4"   help="Relative width is 4 in its row"/>
+			<enum name="width_5"   help="Relative width is 5 in its row"/>
+			<enum name="width_6"   help="Relative width is 6 in its row"/>
+			<enum name="width_7"   help="Relative width is 7 in its row"/>
+			<enum name="width_8"   help="Relative width is 8 in its row"/>
+			<enum name="width_9"   help="Relative width is 9 in its row"/>
+			<enum name="width_10"   help="Relative width is 10 in its row"/>
+			<enum name="width_11"   help="Relative width is 11 in its row"/>
+			<enum name="width_12"   help="Relative width is 12 in its row"/>
+			<enum name="width_13"   help="Relative width is 13 in its row"/>
+			<enum name="width_14"   help="Relative width is 14 in its row"/>
+			<enum name="width_15"   help="Relative width is 15 in its row"/>
+			<enum name="hidden"      help="Button hidden"/>
+			<enum name="no_repeat"   help="Do not repeat press this button."/>
+			<enum name="disabled"    help="Disable this button."/>
+			<enum name="checkable"   help="The button can be toggled."/>
+			<enum name="checked"     help="Button is currently toggled (e.g. checked)."/>
+			<enum name="click_trig"  help="1: Send LV_EVENT_VALUE_CHANGE on CLICK, 0: Send LV_EVENT_VALUE_CHANGE on PRESS"/>
+			<enum name="popover"     help="Show a popover when pressing this key"/>
+			<enum name="reserved_1"  help="Reserved for later use"/>
+			<enum name="reserved_2"  help="Reserved for later use"/>
+			<enum name="reserved_3"  help="Reserved for later use"/>
+			<enum name="custom_1"    help="Custom free to use flag"/>
+			<enum name="custom_2"    help="Custom free to use flag"/>
+		</enumdef>
+
+	    <prop name="map" help="">
+	    	<param name="map"  type="string[NULL]" />
+	    </prop>
+	    <prop name="ctrl_map" help="">
+	    	<param name="map"  type="enum:lv_buttonmatrix_ctrl[]+" />
+	   	</prop>
+	</api>
+</widget>
\ No newline at end of file
diff --git a/xmls/lv_calendar.xml b/xmls/lv_calendar.xml
new file mode 100644
index 000000000..7afca8a29
--- /dev/null
+++ b/xmls/lv_calendar.xml
@@ -0,0 +1,36 @@
+<!--
+Example
+<lv_calendar src="img1 img2" duration="300" repeat_count="3"/>
+-->
+
+<widget>
+	<api>
+	    <prop name="today_date" help="Current date">
+	    	<param name="year" type="int" help=""/>
+	    	<param name="month" type="int" help=""/>
+	    	<param name="day" type="int" help=""/>
+	    </prop>
+	    <prop name="shown_date" help="Shown date">
+	    	<param name="year" type="int" help=""/>
+	    	<param name="month" type="int" help=""/>
+	    	<param name="day" type="int" help=""/>
+	    </prop>
+	    <prop name="shown_date" help="Shown date">
+	    	<param name="year" type="int" help=""/>
+	    	<param name="month" type="int" help=""/>
+	    	<param name="day" type="int" help=""/>
+	    </prop>
+	    <prop name="day_names" help="set the names for the days">
+	    	<param name="names" type="string[7]" help="the 7 day names as an array"/>
+	    </prop>
+	    <prop name="chinese_mode" help="">
+		    <param name="enable" type="bool" help=""/>
+	    </prop>
+		<element name="header_arrow" access="explicit" help=""/>
+		<element name="header_dropdown" access="explicit" help="">
+			<prop name="year_list">
+				<param name="list" type="string" />
+			</prop>
+		</element>
+	</api>
+</widget>
\ No newline at end of file
diff --git a/xmls/lv_canvas.xml b/xmls/lv_canvas.xml
new file mode 100644
index 000000000..5798d4945
--- /dev/null
+++ b/xmls/lv_canvas.xml
@@ -0,0 +1,10 @@
+<!--
+Example (the buffer needs to be set by the user)
+<lv_canvas width="100" height="100"/>
+
+-->
+
+<widget>
+	<api>
+	</api>
+</widget>
diff --git a/xmls/lv_chart.xml b/xmls/lv_chart.xml
new file mode 100644
index 000000000..cc7ab250a
--- /dev/null
+++ b/xmls/lv_chart.xml
@@ -0,0 +1,66 @@
+<!--
+<lv_chart type="bar" point_count="30">
+	<lv_chart-series color="0xff0000" axis="primary_y" values="10, 20, 10, 33"/>
+	<lv_chart-series color="0x00ff00" axis="secondary_y" values="1, 5, 4 8"/>
+	<lv_chart-cursor color="0x0000ff" dir="right" pos="30, 70"/>
+	<lv_chart-axis name="primary_y" range="10, 40"/>
+</lv_chart>
+ -->
+
+<widget>
+	<api>
+	    <enumdef name="lv_chart_type" help="Type of the chart">
+	        <enum name="none"/>
+	        <enum name="line"/>
+	        <enum name="bar"/>
+	        <enum name="scatter"/>
+	    </enumdef>
+
+	    <enumdef name="lv_chart_update_mode" help="The update mode">
+	        <enum name="shift"/>
+	        <enum name="circular"/>
+	    </enumdef>
+
+	    <enumdef name="lv_chart_axis" help="The axis">
+	        <enum name="primary_x"/>
+	        <enum name="primary_y"/>
+	        <enum name="secondary_x"/>
+	        <enum name="secondary_y"/>
+	    </enumdef>
+
+	    <prop name="point_count" help="">
+	    	<param name="count" type="int" help=""/>
+	    </prop>
+	    <prop name="update_mode" help="">
+	    	<param name="mode" type="enum:lv_chart_chart_update_mode" help=""/>
+	    </prop>
+	    <prop name="div_line_count" help="">
+	    	<param name="hdiv" type="int" help=""/>
+	    	<param name="vdiv" type="int" help=""/>
+	    </prop>
+
+	    <element name="series" type="custom:chart_series" access="add">
+	        <arg name="color" type="color" help=""/>
+	        <arg name="axis" type="enum:lv_chart_axis+" help="The axis"/>
+	    	<prop name="values" help="set values from an array">
+	    		<param name="values" type="int[count]" help="the values as an array"/>
+	    	</prop>
+	    </element>
+
+	    <element name="cursor" type="custom:chart_cursor" access="add">
+	        <arg name="color" type="color" arg="true"/>
+	        <arg name="dir" type="enum:lv_dir" arg="true"/>
+	    	<prop name="pos" help="position of the cursor">
+	    		<param name="point" type="point" help="the point"/>
+	   		</prop>
+	    </element>
+
+	    <element name="axis" access="set">
+	    	<arg name="axis" type="enum:lv_chart_axis"/>
+	    	<prop name="range">
+	    		<param name="min" type="int" help="the min value"/>
+	    		<param name="max" type="int" help="the max value"/>
+	    	</prop>
+	    </element>
+	</api>
+</widget>
\ No newline at end of file
diff --git a/xmls/lv_checkbox.xml b/xmls/lv_checkbox.xml
new file mode 100644
index 000000000..bdf1febc4
--- /dev/null
+++ b/xmls/lv_checkbox.xml
@@ -0,0 +1,12 @@
+<!--
+Example
+<lv_checkbox text="Option 1"/>
+-->
+
+<widget>
+	<api>
+	    <prop name="text" help="The text of the checkbox">
+	    	<param name="text" type="string" help=""/>
+	    </prop>
+	</api>
+</widget>
\ No newline at end of file
diff --git a/xmls/lv_dropdown.xml b/xmls/lv_dropdown.xml
new file mode 100644
index 000000000..3c48ff553
--- /dev/null
+++ b/xmls/lv_dropdown.xml
@@ -0,0 +1,24 @@
+<!--
+Example
+<lv_dropdown options="option1\noption2" dir="left">
+	<lv_dropdown-list style="red"/>
+</lv_dropdown>
+-->
+
+<widget>
+	<api>
+	    <prop name="text" help="Show it instead of the selected options">
+	    	<param name="text" type="string" help=""/>
+	    </prop>
+	    <prop name="options" help="The options as a \n separated string">
+	    	<param name="text" type="string" help=""/>
+	    </prop>
+	    <prop name="selected" help="The index of the selected option">
+	    	<param name="idx" type="int" help=""/>
+	    </prop>
+	    <prop name="symbol" help="The symbol, usually a caret">
+	    	<param name="img_src" type="simg_src" help=""/>
+	    </prop>
+	    <element name="list" access="get" help=""/>
+	</api>
+</widget>
diff --git a/xmls/lv_label.xml b/xmls/lv_label.xml
new file mode 100644
index 000000000..a70c16584
--- /dev/null
+++ b/xmls/lv_label.xml
@@ -0,0 +1,27 @@
+<!--
+Example
+<lv_label text="Hello"/>
+-->
+
+<widget>
+	<api>
+	    <enumdef name="lv_label_long_mode">
+	        <enum name="wrap" help=""/>
+	        <enum name="scroll" help=""/>
+	        <enum name="scroll_circular" help=""/>
+	        <enum name="clip" help=""/>
+	        <enum name="dots" help=""/>
+	    </enumdef>
+
+	    <prop name="text">
+	    	<param name="text" type="string" />
+	   	</prop>
+	    <prop name="text_fmt">
+	    	<param name="fmt" type="string" />
+	    	<param name="params" type="arglist" />
+	   	</prop>
+	    <prop name="long_mode">
+	    	<param name="mode" type="enum:lv_label_long_mode" />
+	   	</prop>
+	</api>
+</widget>
\ No newline at end of file
diff --git a/xmls/lv_obj.xml b/xmls/lv_obj.xml
new file mode 100644
index 000000000..9449e689b
--- /dev/null
+++ b/xmls/lv_obj.xml
@@ -0,0 +1,71 @@
+<!--
+Example
+<lv_obj width="100" add_flag="hidden"/>
+ -->
+
+<widget>
+	<api>
+	    <prop name="name">
+	    	<param name="text"  type="string"/>
+	   	</prop>
+
+	    <prop name="store">
+	    	<param name="en"  type="bool"/>
+	   	</prop>
+
+	    <prop name="x">
+	    	<param name="value"  type="px|%"/>
+	   	</prop>
+
+	    <prop name="y">
+	    	<param name="value"  type="px|%"/>
+	   	</prop>
+
+	    <prop name="width">
+	    	<param name="value"  type="px|%"/>
+	   	</prop>
+
+	    <prop name="height">
+	    	<param name="value"  type="px|%"/>
+	   	</prop>
+
+	    <prop name="align">
+	    	<param name="value"  type="align"/>
+	   	</prop>
+
+	    <prop name="styles">
+	    	<param name="styles"  type="styles[]"/>
+	   	</prop>
+
+	    <prop name="style_bg_color">
+	    	<param name="color"  type="color"/>
+	   	</prop>
+	    <prop name="style_border_color">
+	    	<param name="color"  type="color"/>
+	   	</prop>
+	    <prop name="style_border_width">
+	    	<param name="width"  type="int"/>
+	   	</prop>
+	    <prop name="style_text_color">
+	    	<param name="color"  type="color"/>
+	   	</prop>
+	    <prop name="style_radius">
+	    	<param name="radius"  type="int"/>
+	   	</prop>
+	    <prop name="style_radius">
+	    	<param name="radius"  type="int"/>
+	   	</prop>
+
+	    <prop name="clickable">
+	    	<param name="value" type="bool"/>
+	   	</prop>
+
+	    <prop name="scrollable">
+	    	<param name="value" type="bool"/>
+	   	</prop>
+
+	    <prop name="checkable">
+	    	<param name="value" type="bool"/>
+	   	</prop>
+	</api>
+</widget>
\ No newline at end of file
diff --git a/xmls/lv_scale.xml b/xmls/lv_scale.xml
new file mode 100644
index 000000000..b41a74607
--- /dev/null
+++ b/xmls/lv_scale.xml
@@ -0,0 +1,61 @@
+<!--
+<lv_scale total_tick_count="30">
+	<lv_scale-section column="2" range="30 40" style="indicator style1"/>
+</lv_scale>
+-->
+
+<widget>
+	<api>
+	    <enumdef name="lv_scale_mode" help="">
+	        <enum name="horizontal_top" help=""/>
+	        <enum name="horizontal_bottom" help=""/>
+	        <enum name="vertical_top" help=""/>
+	        <enum name="vertical_bottom" help=""/>
+	        <enum name="round_inner" help=""/>
+	        <enum name="round_outer" help=""/>
+	    </enumdef>
+
+	    <prop name="mode" help="">
+	    	<param name="mode" type="enum:lv_scale_mode" help=""/>
+	    </prop>
+	    <prop name="total_tick_count" help="">
+	    	<param name="cnt" type="int" help=""/>
+	    </prop>
+	    <prop name="major_tick_every" help="">
+	    	<param name="cnt" type="int" help=""/>
+	    </prop>
+	    <prop name="label_show" help="">
+	    	<param name="en" type="bool" help=""/>
+	    </prop>
+	    <prop name="range" help="">
+	    	<param name="range_min" type="int" help=""/>
+	    	<param name="range_max" type="int" help=""/>
+	    </prop>
+	    <prop name="angle_range" help="">
+	    	<param name="range" type="deg" help=""/>
+	    </prop>
+	    <prop name="rotation" help="">
+	    	<param name="rotation" type="deg" help=""/>
+	    </prop>
+	    <prop name="text_src" help="">
+	    	<param name="texts" type="string[NULL]" help=""/>
+	    </prop>
+	    <prop name="post_draw" help="">
+	    	<param name="en" type="bool" help=""/>
+	    </prop>
+	    <prop name="draw_ticks_on_top" help="">
+	    	<param name="en" type="bool" help=""/>
+	    </prop>
+
+	    <element name="section" type="custom:scale_section" access="add">
+	    	<prop name="range" help="">
+	    		<param name="int" type="minor_range" help=""/>
+	    		<param name="int" type="major_range" help=""/>
+	    	</prop>
+	    	<prop name="style" help="">
+	    		<param name="part" type="part" help=""/>
+	    		<param name="style" type="style" help=""/>
+	    	</prop>
+	    </element>
+	</api>
+</widget>
diff --git a/xmls/lv_slider.xml b/xmls/lv_slider.xml
new file mode 100644
index 000000000..259db28b6
--- /dev/null
+++ b/xmls/lv_slider.xml
@@ -0,0 +1,27 @@
+<!--
+Example
+<lv_slider mode="range" value="30"/>
+ -->
+
+<widget>
+	<api>
+	    <enumdef name="lv_slider_mode">
+	        <enum name="normal" help="Normal left to right slider"/>
+	        <enum name="range" help="Two knobs with to set a range"/>
+	        <enum name="symmetrical" help="The indicaror is grwing from zero"/>
+	    </enumdef>
+	    <prop name="range" type="int">
+	    	<param name="range_min" type="int"/>
+	    	<param name="range_max" type="int"/>
+	    </prop>
+
+	    <prop name="value" type="int">
+	    	<param name="range_min" type="int"/>
+	    	<param name="anim" type="bool" default="false"/>
+	    </prop>
+
+	    <prop name="mode" type="enum:lv_slider_mode">
+	    	<param name="range_min" type="int"/>
+	    </prop>
+	</api>
+</widget>
\ No newline at end of file
diff --git a/xmls/lv_spangroup.xml b/xmls/lv_spangroup.xml
new file mode 100644
index 000000000..62836ae53
--- /dev/null
+++ b/xmls/lv_spangroup.xml
@@ -0,0 +1,46 @@
+<!--
+Example
+<lv_spangroup mode="fixed">
+	<lv_spangroup-span text="hello " style="red"/>
+	<lv_spangroup-span text="world" style="blue"/>
+</lv_spangroup>
+-->
+
+<widget>
+	<api>
+		<enumdef name="lv_span_overflow">
+			<enum name="clip" help=""/>
+			<enum name="ellipses" help=""/>
+		</enumdef>
+		<enumdef name="lv_span_mode">
+			<enum name="fixed" help=""/>
+			<enum name="expand" help=""/>
+			<enum name="break" help=""/>
+		</enumdef>
+
+	    <prop name="align" help="align the text of the span group">
+	    	<param name="align" type="enum:lv_text_align" help=""/>
+	    </prop>
+
+	    <prop name="overflow" help="">
+	    	<param name="overflow" type="enum:lv_span_overflow" help=""/>
+	    </prop>
+
+	    <prop name="mode" help="">
+	    	<param name="mode" type="enum:lv_span_mode" help=""/>
+	    </prop>
+
+	    <prop name="max_lines" help="">
+	    	<param name="max_lines" type="int" help=""/>
+	    </prop>
+
+	    <prop name="indent" help="">
+	    	<param name="indent" type="int" help=""/>
+	    </prop>
+
+		<element name="span" type="custom:span" access="add">
+			<param name="text" type="string" help=""/>
+			<param name="style" type="style" help=""/>
+		</element>
+	</api>
+</widget>
\ No newline at end of file
diff --git a/xmls/lv_table.xml b/xmls/lv_table.xml
new file mode 100644
index 000000000..799f84a44
--- /dev/null
+++ b/xmls/lv_table.xml
@@ -0,0 +1,50 @@
+<!--
+<lv_table col_cnt="4">
+	<lv_table-column column="2" width="30px"/>
+	<lv_table-cell row="2" column="1" value="hello" ctrl="text_crop merge_right"/>
+	<lv_table-cell row="3" column="0" value="world"/>
+</lv_table>
+-->
+
+<widget>
+	<api>
+	    <enumdef name="lv_table_cell_ctrl" help="Type of the chart">
+	        <enum name="merge_right"/>
+	        <enum name="text_crop"/>
+	        <enum name="custom_1"/>
+	        <enum name="custom_2"/>
+	        <enum name="custom_3"/>
+	        <enum name="custom_4"/>
+	    </enumdef>
+
+
+	    <prop name="row_cnt" help="">
+	    	<param name="cnt" type="int" help=""/>
+	    </prop>
+	    <prop name="column_cnt" help="">
+	    	<param name="cnt" type="int" help=""/>
+	    </prop>
+	    <prop name="selected cell" help="">
+	    	<param name="row" type="int" help=""/>
+	    	<param name="column" type="int" help=""/>
+	    </prop>
+
+	    <element name="column" access="set">
+	        <arg name="column" type="int" help=""/>
+	    	<prop name="values" help="set values from an array">
+	    		<param name="width" type="px" help="width of the column"/>
+	    	</prop>
+	    </element>
+
+	    <element name="cell" access="set">
+	        <arg name="row" type="int" help=""/>
+	        <arg name="column" type="int" help=""/>
+	    	<prop name="value" help="">
+	    		<param name="text" type="string" help=""/>
+	    	</prop>
+	    	<prop name="ctrl" help="">
+	    		<param name="ctrl" type="enum:lv_table_cell_ctrl+" help=""/>
+	    	</prop>
+	    </element>
+	</api>
+</widget>
diff --git a/xmls/lv_tabview.xml b/xmls/lv_tabview.xml
new file mode 100644
index 000000000..b7ddbc258
--- /dev/null
+++ b/xmls/lv_tabview.xml
@@ -0,0 +1,24 @@
+<!--
+Example
+<lv_tabview active="3">
+	<lv_tabview-tab text="First">
+		<lv_button/>
+	</lv_tabview-tab/>
+</lv_tabview>
+ -->
+
+<widget>
+	<api>
+	    <prop name="active" help="Set the current tab">
+	    	<param name="idx" type="int" help="zero based index of the tab to select"/>
+	    </prop>
+	    <prop name="tab_bar_position" type="dir">
+	    	<param name="idx" type="dir(top bottom left right)" help=""/>
+	    </prop>
+	    <element name="tab_bar" type="obj" access="get">
+	    </element>
+	    <element name="tab" type="obj" access="add">
+	        <arg name="text" type="string" arg="true"/>
+	    </element>
+	</api>
+</widget>