use crate::error::ParseError;
use crate::jid::{Jid, User};
use crate::packed::{Alphabet, Packed};
use crate::reader::Reader;
use crate::token::{
self, BINARY_8, BINARY_20, BINARY_32, DICTIONARY_0, DICTIONARY_3, HEX_8, JID_FB, JID_INTEROP,
JID_PAIR, JID_USER, LIST_8, LIST_16, LIST_EMPTY, NIBBLE_8, TokenTable,
};
use crate::value::Value;
pub const DEFAULT_MAX_DEPTH: usize = 64;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Content<'a> {
None,
Value(Value<'a>),
Children(Children<'a>),
}
impl<'a> Content<'a> {
#[must_use]
pub const fn is_none(&self) -> bool {
matches!(self, Self::None)
}
#[must_use]
pub const fn as_value(&self) -> Option<Value<'a>> {
match self {
Self::Value(value) => Some(*value),
_ => None,
}
}
#[must_use]
pub const fn as_bytes(&self) -> Option<&'a [u8]> {
match self {
Self::Value(value) => value.as_bytes(),
_ => None,
}
}
#[must_use]
pub fn as_children(self) -> Option<Children<'a>> {
match self {
Self::Children(children) => Some(children),
_ => None,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct NodeRef<'a> {
table: TokenTable<'a>,
bytes: &'a [u8],
tag: Value<'a>,
attr_count: usize,
has_content: bool,
depth_budget: usize,
}
impl<'a> NodeRef<'a> {
#[must_use]
pub const fn tag(&self) -> Value<'a> {
self.tag
}
#[must_use]
pub const fn attr_count(&self) -> usize {
self.attr_count
}
#[must_use]
pub const fn has_content(&self) -> bool {
self.has_content
}
#[must_use]
pub fn attrs(&self) -> Attrs<'a> {
let mut reader = Reader::new(self.bytes);
let remaining = skip_header(&mut reader, self.table).map_or(0, |()| self.attr_count);
Attrs {
table: self.table,
reader,
remaining,
}
}
#[must_use]
pub fn attr(&self, key: &str) -> Option<Value<'a>> {
self.attrs()
.find(|(name, _)| name.eq_str(key))
.map(|(_, value)| value)
}
#[must_use]
pub fn attr_eq(&self, key: &str, expected: &str) -> bool {
self.attr(key).is_some_and(|value| value.eq_str(expected))
}
#[must_use]
pub fn content(&self) -> Content<'a> {
self.content_inner().unwrap_or(Content::None)
}
fn content_inner(&self) -> Option<Content<'a>> {
if !self.has_content {
return Some(Content::None);
}
let mut reader = Reader::new(self.bytes);
skip_header(&mut reader, self.table).ok()?;
for _ in 0..self.attr_count {
skip_value(&mut reader, self.table).ok()?;
skip_value(&mut reader, self.table).ok()?;
}
parse_content(&mut reader, self.table, self.depth_budget).ok()
}
#[must_use]
pub fn children(&self) -> Children<'a> {
self.content().as_children().unwrap_or(Children::empty())
}
#[must_use]
pub fn child_at(&self, index: usize) -> Option<NodeRef<'a>> {
self.children().nth(index)
}
#[must_use]
pub fn child(&self, tag: &str) -> Option<NodeRef<'a>> {
self.children().find(|child| child.tag().eq_str(tag))
}
#[must_use]
pub fn at_path<I>(&self, path: I) -> Option<NodeRef<'a>>
where
I: IntoIterator<Item = u16>,
{
let mut node = *self;
for component in path {
node = node.child_at(usize::from(component))?;
}
Some(node)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Attrs<'a> {
table: TokenTable<'a>,
reader: Reader<'a>,
remaining: usize,
}
impl<'a> Iterator for Attrs<'a> {
type Item = (Value<'a>, Value<'a>);
fn next(&mut self) -> Option<Self::Item> {
self.remaining = self.remaining.checked_sub(1)?;
let key = parse_value_next(&mut self.reader, self.table).ok()?;
let value = parse_value_next(&mut self.reader, self.table).ok()?;
Some((key, value))
}
fn size_hint(&self) -> (usize, Option<usize>) {
(self.remaining, Some(self.remaining))
}
}
impl ExactSizeIterator for Attrs<'_> {}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Children<'a> {
table: TokenTable<'a>,
reader: Reader<'a>,
remaining: usize,
depth_budget: usize,
}
impl Children<'_> {
const fn empty() -> Self {
Self {
table: TokenTable::empty(),
reader: Reader::new(&[]),
remaining: 0,
depth_budget: 0,
}
}
#[must_use]
pub const fn len(&self) -> usize {
self.remaining
}
#[must_use]
pub const fn is_empty(&self) -> bool {
self.remaining == 0
}
}
impl<'a> Iterator for Children<'a> {
type Item = NodeRef<'a>;
fn next(&mut self) -> Option<Self::Item> {
self.remaining = self.remaining.checked_sub(1)?;
let node = parse_node(&mut self.reader, self.table, self.depth_budget).ok()?;
skip_node_body(&mut self.reader, self.table, &node).ok()?;
Some(node)
}
fn size_hint(&self) -> (usize, Option<usize>) {
(self.remaining, Some(self.remaining))
}
}
impl ExactSizeIterator for Children<'_> {}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Parser<'a> {
table: TokenTable<'a>,
max_depth: usize,
}
impl<'a> Parser<'a> {
#[must_use]
pub const fn new(table: TokenTable<'a>) -> Self {
Self {
table,
max_depth: DEFAULT_MAX_DEPTH,
}
}
#[must_use]
pub const fn with_max_depth(mut self, max_depth: usize) -> Self {
self.max_depth = max_depth;
self
}
#[must_use]
pub const fn table(&self) -> TokenTable<'a> {
self.table
}
#[must_use]
pub const fn max_depth(&self) -> usize {
self.max_depth
}
pub fn parse(&self, frame: &'a [u8]) -> Result<NodeRef<'a>, ParseError> {
let mut reader = Reader::new(frame);
let node = parse_node(&mut reader, self.table, self.max_depth)?;
skip_node_body(&mut reader, self.table, &node)?;
if !reader.is_empty() {
return Err(ParseError::TrailingBytes(reader.remaining()));
}
Ok(node)
}
pub fn parse_prefix(&self, frame: &'a [u8]) -> Result<(NodeRef<'a>, &'a [u8]), ParseError> {
let mut reader = Reader::new(frame);
let node = parse_node(&mut reader, self.table, self.max_depth)?;
skip_node_body(&mut reader, self.table, &node)?;
Ok((node, reader.tail()))
}
}
fn parse_node<'a>(
reader: &mut Reader<'a>,
table: TokenTable<'a>,
depth_budget: usize,
) -> Result<NodeRef<'a>, ParseError> {
let depth_budget = depth_budget
.checked_sub(1)
.ok_or(ParseError::DepthLimitExceeded {
limit: DEFAULT_MAX_DEPTH,
})?;
let bytes = reader.tail();
let size = parse_list_size(reader)?;
let slots = size.checked_sub(1).ok_or(ParseError::EmptyNode)?;
let tag = parse_value_next(reader, table)?;
if !tag.is_textual() {
return Err(ParseError::NonStringTag);
}
let attr_count = slots / 2;
let has_content = slots % 2 == 1;
Ok(NodeRef {
table,
bytes,
tag,
attr_count,
has_content,
depth_budget,
})
}
fn skip_node_body<'a>(
reader: &mut Reader<'a>,
table: TokenTable<'a>,
node: &NodeRef<'a>,
) -> Result<(), ParseError> {
for _ in 0..node.attr_count {
let key = parse_value_next(reader, table)?;
let value = parse_value_next(reader, table)?;
if !key.is_textual() || !value.is_textual() {
return Err(ParseError::NonStringAttr);
}
}
if node.has_content {
match parse_content(reader, table, node.depth_budget)? {
Content::Children(children) => {
let mut cursor = children.reader;
for _ in 0..children.remaining {
let child = parse_node(&mut cursor, table, children.depth_budget)?;
skip_node_body(&mut cursor, table, &child)?;
}
*reader = cursor;
}
Content::None | Content::Value(_) => {}
}
}
Ok(())
}
fn skip_header<'a>(reader: &mut Reader<'a>, table: TokenTable<'a>) -> Result<(), ParseError> {
parse_list_size(reader)?;
parse_value_next(reader, table)?;
Ok(())
}
fn skip_value<'a>(reader: &mut Reader<'a>, table: TokenTable<'a>) -> Result<(), ParseError> {
parse_value_next(reader, table)?;
Ok(())
}
fn parse_list_size(reader: &mut Reader<'_>) -> Result<usize, ParseError> {
let tag = reader.u8()?;
match tag {
LIST_8 => Ok(usize::from(reader.u8()?)),
LIST_16 => Ok(usize::from(reader.u16()?)),
found => Err(ParseError::ExpectedList { found }),
}
}
fn parse_content<'a>(
reader: &mut Reader<'a>,
table: TokenTable<'a>,
depth_budget: usize,
) -> Result<Content<'a>, ParseError> {
let tag = reader.u8()?;
match tag {
LIST_EMPTY => Ok(Content::None),
LIST_8 | LIST_16 => {
let count = if tag == LIST_8 {
usize::from(reader.u8()?)
} else {
usize::from(reader.u16()?)
};
Ok(Content::Children(Children {
table,
reader: *reader,
remaining: count,
depth_budget,
}))
}
other => Ok(Content::Value(parse_value(reader, table, other)?)),
}
}
fn parse_value_next<'a>(
reader: &mut Reader<'a>,
table: TokenTable<'a>,
) -> Result<Value<'a>, ParseError> {
let tag = reader.u8()?;
parse_value(reader, table, tag)
}
fn parse_value<'a>(
reader: &mut Reader<'a>,
table: TokenTable<'a>,
tag: u8,
) -> Result<Value<'a>, ParseError> {
match tag {
LIST_EMPTY => Ok(Value::Nil),
JID_PAIR => Ok(Value::Jid(parse_jid_pair(reader, table)?)),
JID_USER => Ok(Value::Jid(parse_jid_user(reader, table)?)),
JID_INTEROP => Ok(Value::Jid(parse_jid_interop(reader, table)?)),
JID_FB => Ok(Value::Jid(parse_jid_messenger(reader, table)?)),
BINARY_8 | BINARY_20 | BINARY_32 => Ok(Value::Bytes(parse_binary(reader, tag)?)),
NIBBLE_8 => Ok(Value::Packed(parse_packed(reader, Alphabet::Nibble)?)),
HEX_8 => Ok(Value::Packed(parse_packed(reader, Alphabet::Hex)?)),
_ => Ok(Value::Token(parse_token(reader, table, tag)?)),
}
}
fn parse_token<'a>(
reader: &mut Reader<'a>,
table: TokenTable<'a>,
tag: u8,
) -> Result<&'a str, ParseError> {
if (DICTIONARY_0..=DICTIONARY_3).contains(&tag) {
let dictionary = tag.wrapping_sub(DICTIONARY_0);
let index = reader.u8()?;
return table
.dictionary(dictionary, index)
.ok_or(ParseError::UnknownToken {
dictionary: Some(dictionary),
index: u16::from(index),
});
}
table.single_byte(tag).ok_or(ParseError::UnknownToken {
dictionary: None,
index: u16::from(tag),
})
}
fn parse_binary<'a>(reader: &mut Reader<'a>, tag: u8) -> Result<&'a [u8], ParseError> {
let length = match tag {
BINARY_8 => u32::from(reader.u8()?),
BINARY_20 => reader.u20()?,
_ => reader.u32()?,
};
reader.take(length as usize)
}
fn parse_packed<'a>(reader: &mut Reader<'a>, alphabet: Alphabet) -> Result<Packed<'a>, ParseError> {
let length_byte = reader.u8()?;
let (count, odd) = Packed::split_length_byte(length_byte)?;
let bytes = reader.take(count)?;
Ok(Packed::new(alphabet, bytes, odd))
}
fn parse_jid_user_part<'a>(
reader: &mut Reader<'a>,
table: TokenTable<'a>,
) -> Result<User<'a>, ParseError> {
let tag = reader.u8()?;
match parse_value(reader, table, tag)? {
Value::Nil => Ok(User::None),
Value::Token(token) => Ok(User::Token(token)),
Value::Packed(packed) => Ok(User::Packed(packed)),
Value::Bytes(bytes) => Ok(User::Bytes(bytes)),
Value::Jid(_) => Err(ParseError::UnexpectedTag { tag }),
}
}
fn parse_server<'a>(reader: &mut Reader<'a>, table: TokenTable<'a>) -> Result<&'a str, ParseError> {
let tag = reader.u8()?;
match parse_value(reader, table, tag)? {
Value::Token(token) => Ok(token),
Value::Bytes(bytes) => core::str::from_utf8(bytes).map_err(|_| ParseError::NonStringAttr),
Value::Packed(_) | Value::Jid(_) | Value::Nil => Err(ParseError::UnexpectedTag { tag }),
}
}
fn parse_jid_pair<'a>(
reader: &mut Reader<'a>,
table: TokenTable<'a>,
) -> Result<Jid<'a>, ParseError> {
let user = parse_jid_user_part(reader, table)?;
let server = parse_server(reader, table)?;
Ok(Jid::pair(user, server))
}
fn parse_jid_user<'a>(
reader: &mut Reader<'a>,
table: TokenTable<'a>,
) -> Result<Jid<'a>, ParseError> {
let domain_type = reader.u8()?;
let device = u16::from(reader.u8()?);
let user = parse_jid_user_part(reader, table)?;
Ok(Jid::with_device(user, server_for(domain_type), device))
}
const fn server_for(domain_type: u8) -> &'static str {
if domain_type == token::DOMAIN_TYPE_LID {
token::SERVER_LID
} else if domain_type == token::DOMAIN_TYPE_HOSTED_LID {
token::SERVER_HOSTED_LID
} else if domain_type & token::DOMAIN_TYPE_HOSTED_MASK != 0
&& domain_type & token::DOMAIN_TYPE_LID_MASK == 0
{
token::SERVER_HOSTED
} else {
token::SERVER_PN
}
}
fn parse_jid_interop<'a>(
reader: &mut Reader<'a>,
table: TokenTable<'a>,
) -> Result<Jid<'a>, ParseError> {
let user = parse_jid_user_part(reader, table)?;
let device = reader.u16()?;
let integrator = reader.u16()?;
parse_server(reader, table)?;
Ok(Jid::interop(user, device, integrator))
}
fn parse_jid_messenger<'a>(
reader: &mut Reader<'a>,
table: TokenTable<'a>,
) -> Result<Jid<'a>, ParseError> {
let user = parse_jid_user_part(reader, table)?;
let device = reader.u16()?;
parse_server(reader, table)?;
Ok(Jid::messenger(user, device))
}
#[cfg(test)]
#[path = "node_tests.rs"]
mod tests;