use core::ops::Range;
pub(crate) fn skip_whitespace(text: &str, mut pos: usize) -> usize {
let b = text.as_bytes();
while pos < b.len() && matches!(b[pos], b' ' | b'\t' | b'\n' | b'\r') {
pos += 1;
}
pos
}
pub(crate) fn find_bytes(bytes: &[u8], start: usize, needle: &[u8]) -> Option<usize> {
if needle.is_empty() {
return Some(start);
}
let end = bytes.len().checked_sub(needle.len() - 1)?;
if start >= end {
return None;
}
bytes[start..end + needle.len() - 1]
.windows(needle.len())
.position(|w| w == needle)
.map(|p| p + start)
}
pub(crate) fn find_tag_end(text: &str, start: usize) -> Option<usize> {
let b = text.as_bytes();
let mut i = start;
let mut q: u8 = 0;
while i < b.len() {
match b[i] {
c @ (b'"' | b'\'') if q == 0 => q = c,
c if c == q => q = 0,
b'>' if q == 0 => return Some(i + 1),
_ => {}
}
i += 1;
}
None
}
pub(crate) fn extract_tag_name(text: &str, pos: usize) -> &str {
let b = text.as_bytes();
let mut end = pos;
while end < b.len() && !matches!(b[end], b' ' | b'\t' | b'\n' | b'\r' | b'>' | b'/' | b'?') {
end += 1;
}
&text[pos..end]
}
fn self_closing(bytes: &[u8], tag_end: usize) -> bool {
tag_end >= 2 && bytes[tag_end - 2] == b'/'
}
fn find_close_tag(text: &str, start: usize, tag_name: &str) -> Option<Range<usize>> {
let b = text.as_bytes();
let tag = tag_name.as_bytes();
let mut pos = start;
let mut depth: usize = 1;
while pos < b.len() {
let lt = b[pos..].iter().position(|&c| c == b'<')?;
pos += lt;
if b.get(pos + 1..pos + 4) == Some(b"!--") {
pos = find_bytes(b, pos + 4, b"-->")? + 3;
continue;
}
if b.get(pos + 1) == Some(&b'?') {
pos = find_bytes(b, pos + 2, b"?>")? + 2;
continue;
}
if b.get(pos + 1..pos + 9) == Some(b"![CDATA[") {
pos = find_bytes(b, pos + 9, b"]]>")? + 3;
continue;
}
if b.get(pos + 1) == Some(&b'/') {
let ns = pos + 2;
if b.get(ns..ns + tag.len()) == Some(tag)
&& matches!(
b.get(ns + tag.len()),
Some(&b'>') | Some(&b' ') | Some(&b'\t') | Some(&b'\n') | Some(&b'\r')
) {
depth -= 1;
if depth == 0 {
let gt = b[ns + tag.len()..]
.iter()
.position(|&c| c == b'>')?;
return Some(pos..ns + tag.len() + gt + 1);
}
}
pos += b[pos..].iter().position(|&c| c == b'>')? + 1;
continue;
}
let ns = pos + 1;
if b.get(ns..ns + tag.len()) == Some(tag)
&& matches!(
b.get(ns + tag.len()),
Some(&b'>') | Some(&b' ') | Some(&b'\t') | Some(&b'\n') | Some(&b'\r') | Some(&b'/')
) {
let te = find_tag_end(text, ns)?;
if !self_closing(b, te) {
depth += 1;
}
pos = te;
continue;
}
pos = find_tag_end(text, pos + 1)?;
}
None
}
pub(crate) fn parse_element_at(xml_text: &str, pos: usize, content_end: usize) -> Option<XmlElement<'_>> {
let b = xml_text.as_bytes();
if b.get(pos) != Some(&b'<') {
return None;
}
if b.get(pos + 1..pos + 4) == Some(b"!--") {
let end = find_bytes(b, pos + 4, b"-->")? + 3;
return Some(XmlElement {
xml_text,
open: pos..end,
close: end..end,
element_type: XmlElementType::Comment,
content_end,
});
}
if b.get(pos + 1) == Some(&b'?') {
let end = find_bytes(b, pos + 2, b"?>")? + 2;
return Some(XmlElement {
xml_text,
open: pos..end,
close: end..end,
element_type: XmlElementType::PI,
content_end,
});
}
if b.get(pos + 1..pos + 9) == Some(b"![CDATA[") {
let end = find_bytes(b, pos + 9, b"]]>")? + 3;
return Some(XmlElement {
xml_text,
open: pos..end,
close: end..end,
element_type: XmlElementType::Text,
content_end,
});
}
if b.get(pos + 1) == Some(&b'/') {
return None;
}
let tag_end = find_tag_end(xml_text, pos + 1)?;
if self_closing(b, tag_end) {
return Some(XmlElement {
xml_text,
open: pos..tag_end,
close: tag_end..tag_end,
element_type: XmlElementType::Element,
content_end,
});
}
let tag_name = extract_tag_name(xml_text, pos + 1);
let close = find_close_tag(xml_text, tag_end, tag_name)?;
Some(XmlElement {
xml_text,
open: pos..tag_end,
close,
element_type: XmlElementType::Element,
content_end,
})
}
#[derive(Clone)]
pub struct XmlElement<'xml> {
xml_text: &'xml str,
open: Range<usize>,
close: Range<usize>,
element_type: XmlElementType,
content_end: usize,
}
impl<'xml> XmlElement<'xml> {
pub fn attribute(&self, name: &str) -> Option<&'xml str> {
self.attributes()
.find(|a| a.name() == name)
.map(|a| a.value())
}
pub fn attributes(&self) -> XmlAttributes<'xml> {
if !matches!(self.element_type, XmlElementType::Element) {
return XmlAttributes {
xml_text: self.xml_text,
pos: 0,
end: 0,
};
}
let name_len = extract_tag_name(self.xml_text, self.open.start + 1).len();
let attr_start = self.open.start + 1 + name_len;
let attr_end = self.open.end.saturating_sub(1);
XmlAttributes {
xml_text: self.xml_text,
pos: attr_start,
end: attr_end,
}
}
pub fn tag_name(&self) -> &'xml str {
match self.element_type {
XmlElementType::Element => extract_tag_name(self.xml_text, self.open.start + 1),
_ => "",
}
}
pub fn first_child(&self) -> Option<XmlElement<'xml>> {
if self.close.start <= self.open.end {
return None;
}
let b = self.xml_text.as_bytes();
let pos = skip_whitespace(self.xml_text, self.open.end);
if pos >= self.close.start {
return None;
}
if b[pos] == b'<' {
if b.get(pos + 1) == Some(&b'/') {
return None;
}
parse_element_at(self.xml_text, pos, self.close.start)
} else {
let mut end = pos;
while end < self.close.start && b[end] != b'<' {
end += 1;
}
Some(XmlElement {
xml_text: self.xml_text,
open: pos..end,
close: end..end,
element_type: XmlElementType::Text,
content_end: self.close.start,
})
}
}
pub fn next_sibling(&self) -> Option<XmlElement<'xml>> {
let after = if self.close.is_empty() {
self.open.end
} else {
self.close.end
};
let b = self.xml_text.as_bytes();
let pos = skip_whitespace(self.xml_text, after);
if pos >= self.content_end {
return None;
}
if b[pos] == b'<' {
if b.get(pos + 1) == Some(&b'/') {
return None;
}
parse_element_at(self.xml_text, pos, self.content_end)
} else {
let mut end = pos;
while end < self.content_end && b[end] != b'<' {
end += 1;
}
Some(XmlElement {
xml_text: self.xml_text,
open: pos..end,
close: end..end,
element_type: XmlElementType::Text,
content_end: self.content_end,
})
}
}
pub fn children(&self) -> XmlChildren<'xml> {
if self.close.start <= self.open.end {
return XmlChildren {
xml_text: self.xml_text,
pos: self.open.end,
end: self.open.end,
};
}
XmlChildren {
xml_text: self.xml_text,
pos: self.open.end,
end: self.close.start,
}
}
pub fn element_type(&self) -> XmlElementType {
self.element_type
}
pub fn text(&self) -> &'xml str {
match self.element_type {
XmlElementType::Text => &self.xml_text[self.open.clone()],
XmlElementType::Comment => {
let s = &self.xml_text[self.open.clone()];
s.trim_start_matches("<!--")
.trim_end_matches("-->")
}
_ => "",
}
}
pub fn range(&self) -> Range<usize> {
let end = if self.close.is_empty() {
self.open.end
} else {
self.close.end
};
self.open.start..end
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum XmlElementType {
Element,
Comment,
Text,
PI,
}
pub struct XmlAttribute<'xml> {
xml_text: &'xml str,
name: Range<usize>,
value: Range<usize>,
}
impl<'xml> XmlAttribute<'xml> {
pub fn name(&self) -> &'xml str {
&self.xml_text[self.name.clone()]
}
pub fn value(&self) -> &'xml str {
&self.xml_text[self.value.clone()]
}
}
pub struct XmlAttributes<'xml> {
xml_text: &'xml str,
pos: usize,
end: usize,
}
impl<'xml> Iterator for XmlAttributes<'xml> {
type Item = XmlAttribute<'xml>;
fn next(&mut self) -> Option<Self::Item> {
let b = self.xml_text.as_bytes();
while self.pos < self.end && matches!(b[self.pos], b' ' | b'\t' | b'\n' | b'\r') {
self.pos += 1;
}
if self.pos >= self.end || matches!(b[self.pos], b'/' | b'>') {
return None;
}
let name_start = self.pos;
while self.pos < self.end && !matches!(b[self.pos], b'=' | b' ' | b'\t' | b'\n' | b'\r') {
self.pos += 1;
}
let name_end = self.pos;
while self.pos < self.end && b[self.pos] != b'=' {
self.pos += 1;
}
if self.pos >= self.end {
return None;
}
self.pos += 1; while self.pos < self.end && matches!(b[self.pos], b' ' | b'\t' | b'\n' | b'\r') {
self.pos += 1;
}
if self.pos >= self.end {
return None;
}
let quote = b[self.pos];
if quote != b'"' && quote != b'\'' {
return None;
}
self.pos += 1; let val_start = self.pos;
while self.pos < self.end && b[self.pos] != quote {
self.pos += 1;
}
if self.pos >= self.end {
return None;
}
let val_end = self.pos;
self.pos += 1; Some(XmlAttribute {
xml_text: self.xml_text,
name: name_start..name_end,
value: val_start..val_end,
})
}
}
pub struct XmlChildren<'xml> {
xml_text: &'xml str,
pos: usize,
end: usize,
}
impl<'xml> Iterator for XmlChildren<'xml> {
type Item = XmlElement<'xml>;
fn next(&mut self) -> Option<Self::Item> {
let b = self.xml_text.as_bytes();
while self.pos < self.end && matches!(b[self.pos], b' ' | b'\t' | b'\n' | b'\r') {
self.pos += 1;
}
if self.pos >= self.end {
return None;
}
if b[self.pos] == b'<' && b.get(self.pos + 1) == Some(&b'/') {
return None;
}
if b[self.pos] == b'<' {
let elem = parse_element_at(self.xml_text, self.pos, self.end)?;
self.pos = if elem.close.is_empty() {
elem.open.end
} else {
elem.close.end
};
return Some(elem);
}
let text_start = self.pos;
while self.pos < self.end && b[self.pos] != b'<' {
self.pos += 1;
}
Some(XmlElement {
xml_text: self.xml_text,
open: text_start..self.pos,
close: self.pos..self.pos,
element_type: XmlElementType::Text,
content_end: self.end,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
const fn is_normal<T: Sized + Send + Sync>() {}
#[test]
const fn normal_types() {
is_normal::<XmlElement>();
is_normal::<&XmlElement>();
is_normal::<XmlElementType>();
is_normal::<&XmlElementType>();
}
#[test]
fn find_bytes_empty_needle() {
assert_eq!(find_bytes(b"abc", 2, b""), Some(2));
}
#[test]
fn find_bytes_needle_larger_than_haystack() {
assert_eq!(find_bytes(b"", 0, b"abc"), None);
assert_eq!(find_bytes(b"x", 0, b"abc"), None);
}
#[test]
fn parse_element_at_rejects_non_open_bracket() {
assert!(parse_element_at("abc", 0, 3).is_none());
}
#[test]
fn parse_element_at_rejects_close_tag() {
assert!(parse_element_at("</a>", 0, 4).is_none());
}
#[test]
fn parse_element_at_fails_on_unclosed_comment() {
assert!(parse_element_at("<!--x", 0, 5).is_none());
}
#[test]
fn parse_element_at_fails_on_unclosed_pi() {
assert!(parse_element_at("<?x", 0, 3).is_none());
}
#[test]
fn parse_element_at_fails_on_unclosed_cdata() {
assert!(parse_element_at("<![CDATA[x", 0, 10).is_none());
}
#[test]
fn parse_element_at_fails_on_unclosed_tag() {
assert!(parse_element_at("<unterminated", 0, 13).is_none());
}
#[test]
fn parse_element_at_fails_on_unmatched_close() {
assert!(parse_element_at("<a>body", 0, 7).is_none());
}
#[test]
fn parse_element_at_fails_on_close_tag_with_no_gt() {
assert!(parse_element_at("<a>x</a ", 0, 10).is_none());
}
#[test]
fn parse_element_at_fails_on_foreign_close_tag_with_no_gt() {
assert!(parse_element_at("<a>x</y", 0, 7).is_none());
}
#[test]
fn parse_element_at_fails_on_nested_same_name_unclosed() {
assert!(parse_element_at("<a><a attr=\"unclosed", 0, 20).is_none());
}
#[test]
fn parse_element_at_fails_on_foreign_open_tag_unclosed() {
assert!(parse_element_at("<a><b attr=\"unclosed", 0, 20).is_none());
}
#[test]
fn parse_element_at_fails_on_unclosed_comment_in_body() {
assert!(parse_element_at("<a><!-- unclosed", 0, 16).is_none());
}
#[test]
fn parse_element_at_fails_on_unclosed_pi_in_body() {
assert!(parse_element_at("<a><?unclosed", 0, 13).is_none());
}
#[test]
fn parse_element_at_fails_on_unclosed_cdata_in_body() {
assert!(parse_element_at("<a><![CDATA[unclosed", 0, 20).is_none());
}
#[test]
fn first_child_returns_none_when_body_starts_with_close_tag() {
let xml = "<a></a></a>";
let elem = XmlElement {
xml_text: xml,
open: 0..3,
close: 7..11,
element_type: XmlElementType::Element,
content_end: xml.len(),
};
assert!(elem.first_child().is_none());
}
#[test]
fn children_iter_returns_none_on_leading_close_tag() {
let xml = "</a>";
let mut iter = XmlChildren {
xml_text: xml,
pos: 0,
end: xml.len(),
};
assert!(iter.next().is_none());
}
#[test]
fn attributes_iter_returns_none_on_unterminated_quote() {
let xml = " attr=\"value";
let mut iter = XmlAttributes {
xml_text: xml,
pos: 0,
end: xml.len(),
};
assert!(iter.next().is_none());
}
#[test]
fn public_api_smoke() {
use crate::XmlReader;
let xml = "<root a=\"v\"><!-- c --><child/>text</root>";
let reader = XmlReader::parse(xml);
let root = reader.root_element().unwrap();
let _ = root.clone();
assert_eq!(root.tag_name(), "root");
assert_eq!(root.element_type(), XmlElementType::Element);
assert_eq!(root.attribute("a"), Some("v"));
assert_eq!(root.text(), "");
assert_eq!(&xml[root.range()], xml);
let mut attrs = root.attributes();
let a0 = attrs.next().unwrap();
assert_eq!(a0.name(), "a");
assert_eq!(a0.value(), "v");
assert!(attrs.next().is_none());
let first = root.first_child().unwrap();
assert_eq!(first.element_type(), XmlElementType::Comment);
let second = first.next_sibling().unwrap();
assert_eq!(second.tag_name(), "child");
assert_eq!(root.children().count(), 3);
}
#[test]
fn children_iter_returns_none_when_parse_fails() {
let xml = "<unclosed";
let mut iter = XmlChildren {
xml_text: xml,
pos: 0,
end: xml.len(),
};
assert!(iter.next().is_none());
}
}