118 lines
4.5 KiB
GDScript
118 lines
4.5 KiB
GDScript
extends Node
|
|
|
|
class XmlNode extends Reference:
|
|
func is_element() -> bool: return false
|
|
func is_text() -> bool: return false
|
|
|
|
class XmlElement extends XmlNode:
|
|
var node_name: String
|
|
var attributes: Dictionary # String to String
|
|
var children: Array # of XmlNode
|
|
|
|
func is_element() -> bool: return true
|
|
|
|
func take_named_child_element(p_node_name: String) -> XmlElement:
|
|
for idx in range(self.children.size()):
|
|
var child := self.children[idx] as XmlElement
|
|
if child != null and child.node_name == p_node_name:
|
|
self.children.remove(idx)
|
|
return child
|
|
return null
|
|
|
|
func as_string(level: int = 0) -> String:
|
|
var result = '\t'.repeat(level) + "XmlElement \"%s\"" % self.node_name
|
|
if self.attributes.size() > 0:
|
|
result += ", Attributes: " + String(self.attributes)
|
|
for child in self.children:
|
|
result += '\n' + '\t '.repeat(level) + child.as_string(level + 1)
|
|
return result
|
|
|
|
class XmlText extends XmlNode:
|
|
var data: String
|
|
|
|
func is_text() -> bool: return true
|
|
|
|
func as_string(_level: int = 0) -> String:
|
|
return "XmlText \"%s\"" % self.data
|
|
|
|
## Wrapper over XMLParser for TCP stream oriented XML data.
|
|
# todo: Save namespaces.
|
|
# todo: Ability to parse from partially arrived data, with saving for future resume.
|
|
class Parser extends Reference:
|
|
var _root: XmlElement = null
|
|
var _element_stack: Array # of XmlElement
|
|
var _pending: PoolByteArray
|
|
|
|
func take_root() -> XmlElement:
|
|
var result := self._root
|
|
assert(result != null)
|
|
self._root = null
|
|
return result
|
|
|
|
## Returns true if root element is closed, otherwise more tags are expected to come later.
|
|
func parse_a_bit(data): # -> bool or Error:
|
|
var error: int
|
|
var parser := XMLParser.new()
|
|
if data is String: data = data.to_utf8()
|
|
if data == null: data = PoolByteArray()
|
|
var total = self._pending + data
|
|
if total.size() == 0:
|
|
return false
|
|
|
|
error = parser.open_buffer(total)
|
|
if error != OK:
|
|
push_error("Error opening a buffer for XML parsing")
|
|
return error
|
|
|
|
self._pending = PoolByteArray()
|
|
|
|
while parser.read() == OK:
|
|
if parser.get_node_type() == XMLParser.NODE_ELEMENT:
|
|
var element := XmlElement.new()
|
|
element.node_name = parser.get_node_name()
|
|
var attribute_count := parser.get_attribute_count()
|
|
for idx in range(attribute_count):
|
|
element.attributes[parser.get_attribute_name(idx)] = parser.get_attribute_value(idx)
|
|
|
|
if self._root != null:
|
|
self._element_stack[self._element_stack.size() - 1].children.push_back(element)
|
|
else: self._root = element
|
|
|
|
# todo: Handle _root empty element.
|
|
if not parser.is_empty():
|
|
self._element_stack.push_back(element)
|
|
|
|
elif parser.get_node_type() == XMLParser.NODE_ELEMENT_END:
|
|
if self._element_stack.size() == 0:
|
|
push_error("Closing element </%s> closes nothing" % [parser.get_node_name()])
|
|
return ERR_PARSE_ERROR
|
|
|
|
var popped := self._element_stack.pop_back() as XmlElement
|
|
if popped.node_name != parser.get_node_name():
|
|
push_error("Element <%s> closes sooner than <%s>" % [parser.get_node_name(), popped.node_name])
|
|
return ERR_PARSE_ERROR
|
|
|
|
if self._element_stack.size() == 0:
|
|
# todo: Handle partial data.
|
|
if parser.read() == OK:
|
|
self._pending = total.subarray(parser.get_node_offset(), -1)
|
|
return true
|
|
|
|
elif parser.get_node_type() == XMLParser.NODE_TEXT:
|
|
if self._element_stack.size() == 0:
|
|
push_error("Text node should be a child of an element")
|
|
return ERR_PARSE_ERROR
|
|
|
|
var text = XmlText.new()
|
|
text.data = parser.get_node_data()
|
|
self._element_stack[self._element_stack.size() - 1].children.push_back(text)
|
|
|
|
elif parser.get_node_type() == XMLParser.NODE_UNKNOWN:
|
|
## Needed for things like <?xml ?> version specification.
|
|
pass
|
|
|
|
else:
|
|
push_error("Node type unimplemented")
|
|
|
|
return self._element_stack.size() == 0
|