use core::ops::Range;
use crate::{
MAX_DEPTH,
body::{BodyComment, BodyNode, BodyPI},
error::Error,
xml_element::XmlElement,
xml_text::XmlText,
};
pub(crate) fn bom_len(text: &str) -> usize {
if text.starts_with('\u{FEFF}') { 3 } else { 0 }
}
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> {
bytes
.get(start..)
.unwrap_or_default()
.windows(needle.len())
.position(|w| w == needle)
.map(|p| p + start)
}
pub(crate) fn skip_past(bytes: &[u8], start: usize, needle: &[u8]) -> usize {
find_bytes(bytes, start, needle).map_or(bytes.len(), |p| p + needle.len())
}
pub(crate) fn find_tag_end(text: &str, start: usize) -> usize {
let b = text.as_bytes();
let mut q: u8 = 0;
b[start..]
.iter()
.position(|&c| {
match c {
b'"' | b'\'' if q == 0 => q = c,
_ if c == q => q = 0,
b'>' if q == 0 => return true,
_ => {}
}
false
})
.map_or(b.len(), |p| start + p + 1)
}
pub(crate) fn check_open_tag(text: &str, mut pos: usize) -> Result<usize, Error> {
let b = text.as_bytes();
loop {
let start = skip_whitespace(text, pos);
match b.get(start) {
Some(b'>') => return Ok(start + 1),
Some(b'/') if b.get(start + 1) == Some(&b'>') => return Ok(start + 2),
Some(_) if start > pos => {}
_ => return Err(Error::MalformedXml),
}
let name_len = b[start..]
.iter()
.position(|c| matches!(c, b' ' | b'\t' | b'\n' | b'\r' | b'=' | b'/' | b'>' | b'"' | b'\''))
.unwrap_or(b.len() - start);
if name_len == 0 {
return Err(Error::MalformedXml);
}
let eq = skip_whitespace(text, start + name_len);
if b.get(eq) != Some(&b'=') {
return Err(Error::MalformedXml);
}
let open_quote = skip_whitespace(text, eq + 1);
let quote = match b.get(open_quote) {
Some(&q @ (b'"' | b'\'')) => q,
_ => return Err(Error::MalformedXml),
};
pos = find_bytes(b, open_quote + 1, &[quote]).ok_or(Error::MalformedXml)? + 1;
}
}
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]
}
pub(crate) fn is_tag_name(name: &str) -> bool {
!name.is_empty() && !name.contains(['"', '\''])
}
pub(crate) fn split_qname(name: &str) -> (Option<&str>, &str) {
match name.split_once(':') {
Some((prefix, local)) => (Some(prefix), local),
None => (None, name),
}
}
pub(crate) fn self_closing(bytes: &[u8], tag_end: usize) -> bool {
bytes[tag_end - 2] == b'/'
}
pub(crate) fn comment_text(source: &str) -> &str {
source
.strip_prefix("<!--")
.and_then(|r| r.strip_suffix("-->"))
.unwrap_or(source)
}
pub(crate) fn pi_target<'a>(text: &'a str, range: &Range<usize>) -> &'a str {
extract_tag_name(text, range.start + 2)
}
pub(crate) fn pi_content<'a>(text: &'a str, range: &Range<usize>) -> &'a str {
let after_target = range.start + 2 + pi_target(text, range).len();
let end = range.end.saturating_sub(2).max(after_target);
text[after_target..end].trim_start_matches(|c: char| c.is_ascii_whitespace())
}
pub(crate) fn is_doctype_at(bytes: &[u8], pos: usize) -> bool {
bytes.get(pos + 1..pos + 9) == Some(b"!DOCTYPE")
}
pub(crate) fn find_doctype_end(bytes: &[u8], pos: usize) -> Option<usize> {
let mut i = pos + 9;
let mut quote: u8 = 0;
let mut in_subset = false;
while i < bytes.len() {
let c = bytes[i];
if quote != 0 {
if c == quote {
quote = 0;
}
i += 1;
continue;
}
match c {
b'"' | b'\'' => quote = c,
b'[' if !in_subset => in_subset = true,
b']' if in_subset => in_subset = false,
b'<' if in_subset && bytes.get(i + 1..i + 4) == Some(b"!--") => {
i = find_bytes(bytes, i + 4, b"-->")? + 3;
continue;
}
b'<' if in_subset && bytes.get(i + 1) == Some(&b'?') => {
i = find_bytes(bytes, i + 2, b"?>")? + 2;
continue;
}
b'>' if !in_subset => return Some(i + 1),
_ => {}
}
i += 1;
}
None
}
pub(crate) fn is_declaration_at(bytes: &[u8], pos: usize) -> bool {
bytes.get(pos..pos + 5) == Some(b"<?xml") && matches!(bytes.get(pos + 5), Some(b' ' | b'\t' | b'\n' | b'\r' | b'?'))
}
pub(crate) fn is_reserved_pi_at(bytes: &[u8], pos: usize) -> bool {
bytes
.get(pos + 2..pos + 5)
.is_some_and(|target| target.eq_ignore_ascii_case(b"xml"))
&& matches!(bytes.get(pos + 5), Some(b' ' | b'\t' | b'\n' | b'\r' | b'?'))
}
pub(crate) fn skip_misc(text: &str, mut pos: usize, allow_doctype: bool) -> Result<usize, Error> {
let b = text.as_bytes();
loop {
pos = skip_whitespace(text, pos);
if pos >= b.len() {
return Ok(b.len());
}
if b[pos] != b'<' {
return Err(Error::MalformedXml);
}
if b.get(pos + 1) == Some(&b'?') {
if is_reserved_pi_at(b, pos) {
return Err(Error::MalformedXml);
}
pos = find_bytes(b, pos + 2, b"?>").ok_or(Error::MalformedXml)? + 2;
} else if b.get(pos + 1..pos + 4) == Some(b"!--") {
pos = find_bytes(b, pos + 4, b"-->").ok_or(Error::MalformedXml)? + 3;
} else if allow_doctype && is_doctype_at(b, pos) {
pos = find_doctype_end(b, pos).ok_or(Error::MalformedXml)?;
} else {
return Ok(pos);
}
}
}
pub(crate) trait Offset: Copy + Default + TryFrom<usize> + Into<usize> {}
impl Offset for u16 {}
impl Offset for usize {}
#[inline(never)]
pub(crate) fn check_element_content<O: Offset>(text: &str, start: usize, tag_name: &str) -> Result<Range<usize>, Error> {
let b = text.as_bytes();
let mut open = [O::default(); MAX_DEPTH - 1];
let mut depth = 0usize;
let mut pos = start;
loop {
pos += b[pos..]
.iter()
.position(|&c| c == b'<')
.ok_or(Error::MalformedXml)?;
match b.get(pos + 1) {
Some(b'!') => {
if b.get(pos + 2..pos + 4) == Some(b"--") {
pos = find_bytes(b, pos + 4, b"-->").ok_or(Error::MalformedXml)? + 3;
} else if b.get(pos + 2..pos + 9) == Some(b"[CDATA[") {
pos = find_bytes(b, pos + 9, b"]]>").ok_or(Error::MalformedXml)? + 3;
} else {
return Err(Error::MalformedXml);
}
}
Some(b'?') => {
if is_reserved_pi_at(b, pos) {
return Err(Error::MalformedXml);
}
pos = find_bytes(b, pos + 2, b"?>").ok_or(Error::MalformedXml)? + 2;
}
Some(b'/') => {
let name = extract_tag_name(text, pos + 2);
let expected = if depth == 0 {
tag_name
} else {
extract_tag_name(text, start + open[depth - 1].into())
};
if name != expected {
return Err(Error::MalformedXml);
}
let gt = skip_whitespace(text, pos + 2 + name.len());
if b.get(gt) != Some(&b'>') {
return Err(Error::MalformedXml);
}
if depth == 0 {
return Ok(pos..gt + 1);
}
depth -= 1;
pos = gt + 1;
}
_ => {
let name = extract_tag_name(text, pos + 1);
if !is_tag_name(name) {
return Err(Error::MalformedXml);
}
let tag_end = check_open_tag(text, pos + 1 + name.len())?;
if !self_closing(b, tag_end) {
if depth == open.len() {
return Err(Error::TooDeep);
}
open[depth] = O::try_from(pos + 1 - start).unwrap_or_default();
depth += 1;
}
pos = tag_end;
}
}
}
}
pub(crate) fn check_root_at(xml_text: &str, pos: usize) -> Result<XmlElement<'_>, Error> {
let b = xml_text.as_bytes();
let tag_name = extract_tag_name(xml_text, pos + 1);
if !is_tag_name(tag_name) || tag_name.starts_with('!') {
return Err(Error::MalformedXml);
}
let tag_end = check_open_tag(xml_text, pos + 1 + tag_name.len())?;
let close = if self_closing(b, tag_end) {
tag_end..tag_end
} else if b.len() - tag_end <= usize::from(u16::MAX) {
check_element_content::<u16>(xml_text, tag_end, tag_name)?
} else {
check_element_content::<usize>(xml_text, tag_end, tag_name)?
};
let end = close.end;
Ok(XmlElement::new(xml_text, pos..tag_end, close, end))
}
pub(crate) fn find_close_tag(text: &str, start: usize) -> Range<usize> {
let b = text.as_bytes();
let mut depth = 0usize;
let mut pos = start;
loop {
pos += b[pos..]
.iter()
.position(|&c| c == b'<')
.unwrap_or(b.len() - pos);
match b.get(pos + 1) {
Some(b'!') if b.get(pos + 2) == Some(&b'-') => pos = skip_past(b, pos + 4, b"-->"),
Some(b'!') => pos = skip_past(b, pos + 9, b"]]>"),
Some(b'?') => pos = skip_past(b, pos + 2, b"?>"),
Some(b'/') | None => {
let gt = skip_past(b, pos, b">");
if depth == 0 {
return pos..gt;
}
depth -= 1;
pos = gt;
}
Some(_) => {
let tag_end = find_tag_end(text, pos + 1);
if !self_closing(b, tag_end) {
depth += 1;
}
pos = tag_end;
}
}
}
}
pub(crate) fn parse_element_at(xml_text: &str, pos: usize, content_end: usize) -> XmlElement<'_> {
let tag_end = find_tag_end(xml_text, pos + 1);
let close = if self_closing(xml_text.as_bytes(), tag_end) {
tag_end..tag_end
} else {
find_close_tag(xml_text, tag_end)
};
XmlElement::new(xml_text, pos..tag_end, close, content_end)
}
pub(crate) fn advance_body_cursor(xml_text: &str, pos: usize, end: usize) -> Option<usize> {
let b = xml_text.as_bytes();
let next = skip_whitespace(xml_text, pos);
if next >= end {
return None;
}
if b[next] == b'<' {
Some(next)
} else {
Some(pos) }
}
pub(crate) fn parse_body_node_at(xml_text: &str, pos: usize, content_end: usize) -> BodyNode<'_> {
let b = xml_text.as_bytes();
if b[pos] != b'<' {
let len = b[pos..content_end]
.iter()
.position(|&c| c == b'<')
.unwrap_or(content_end - pos);
return BodyNode::Text(XmlText::new(xml_text, pos..pos + len, content_end));
}
if b.get(pos + 1..pos + 4) == Some(b"!--") {
let end = skip_past(b, pos + 4, b"-->");
return BodyNode::Comment(BodyComment::new(xml_text, pos..end, content_end));
}
if b.get(pos + 1..pos + 9) == Some(b"![CDATA[") {
let end = skip_past(b, pos + 9, b"]]>");
return BodyNode::Text(XmlText::new(xml_text, pos..end, content_end));
}
if b.get(pos + 1) == Some(&b'?') {
let end = skip_past(b, pos + 2, b"?>");
return BodyNode::PI(BodyPI::new(xml_text, pos..end, content_end));
}
BodyNode::Element(parse_element_at(xml_text, pos, content_end))
}
pub(crate) fn next_body_sibling(xml_text: &str, pos: usize, content_end: usize) -> Option<BodyNode<'_>> {
advance_body_cursor(xml_text, pos, content_end).map(|pos| parse_body_node_at(xml_text, pos, content_end))
}