hayro_syntax/object/

string.rs

//! Strings.

use crate::filter::ascii_hex::decode_hex_string;
use crate::object::macros::object;
use crate::object::{Object, ObjectLike};
use crate::reader::{Readable, Reader, ReaderContext, Skippable};
use crate::trivia::is_white_space_character;
use log::warn;
use std::borrow::Cow;

/// A hex-encoded string.
#[derive(PartialEq, Eq, Copy, Clone, Debug)]
struct HexString<'a>(&'a [u8], bool);

impl HexString<'_> {
    /// Returns the content of the string.
    fn get(&self) -> Vec<u8> {
        if self.1 {
            let mut cleaned = Vec::with_capacity(self.0.len() + 1);

            for b in self.0.iter().copied() {
                if !is_white_space_character(b) {
                    cleaned.push(b);
                }
            }

            if cleaned.len() % 2 != 0 {
                cleaned.push(b'0');
            }

            // We made sure while parsing that it is a valid hex string.
            decode_hex_string(&cleaned).unwrap()
        } else {
            // We made sure while parsing that it is a valid hex string.
            decode_hex_string(self.0).unwrap()
        }
    }
}

impl Skippable for HexString<'_> {
    fn skip(r: &mut Reader<'_>, _: bool) -> Option<()> {
        parse_hex(r).map(|_| {})
    }
}

impl<'a> Readable<'a> for HexString<'a> {
    fn read(r: &mut Reader<'a>, _: ReaderContext) -> Option<Self> {
        let start = r.offset();
        let mut dirty = parse_hex(r)?;
        let end = r.offset();

        // Exclude outer brackets.
        let result = r.range(start + 1..end - 1).unwrap();
        dirty |= result.len() % 2 != 0;

        Some(HexString(result, dirty))
    }
}

impl<'a> TryFrom<Object<'a>> for HexString<'a> {
    type Error = ();

    fn try_from(value: Object<'a>) -> Result<Self, Self::Error> {
        match value {
            Object::String(String(InnerString::Hex(h))) => Ok(h),
            _ => Err(()),
        }
    }
}

impl<'a> ObjectLike<'a> for HexString<'a> {}

fn parse_hex(r: &mut Reader<'_>) -> Option<bool> {
    let mut has_whitespace = false;

    r.forward_tag(b"<")?;
    while let Some(b) = r.peek_byte() {
        let is_hex = b.is_ascii_hexdigit();
        let is_whitespace = is_white_space_character(b);
        has_whitespace |= is_whitespace;

        if !is_hex && !is_whitespace {
            break;
        }

        r.read_byte()?;
    }
    r.forward_tag(b">")?;

    Some(has_whitespace)
}

/// A literal string.
#[derive(Debug, Eq, PartialEq, Clone, Copy, Hash)]
struct LiteralString<'a>(&'a [u8], bool);

impl<'a> LiteralString<'a> {
    /// Returns the content of the string.
    fn get(&self) -> Cow<'a, [u8]> {
        if self.1 {
            let mut cleaned = vec![];
            let mut r = Reader::new(self.0);

            while let Some(byte) = r.read_byte() {
                match byte {
                    b'\\' => {
                        let next = r.read_byte().unwrap();

                        if is_octal_digit(next) {
                            let second = r.read_byte();
                            let third = r.read_byte();

                            match (second, third) {
                                (Some(n1), Some(n2)) => {
                                    if is_octal_digit(n1) && is_octal_digit(n2) {
                                        let bytes = [next, n1, n2];
                                        let str = std::str::from_utf8(&bytes).unwrap();

                                        if let Ok(num) = u8::from_str_radix(str, 8) {
                                            cleaned.push(num);
                                        } else {
                                            warn!(
                                                "overflow occurred while parsing octal literal string"
                                            );
                                        }
                                    } else {
                                        // Ignore the solidus and treat as normal characters.
                                        cleaned.push(next);
                                        cleaned.push(n1);
                                        cleaned.push(n2);
                                    }
                                }
                                (Some(n1), None) => {
                                    cleaned.push(next);
                                    cleaned.push(n1);
                                }
                                _ => cleaned.push(next),
                            }
                        } else {
                            match next {
                                b'n' => cleaned.push(0xA),
                                b'r' => cleaned.push(0xD),
                                b't' => cleaned.push(0x9),
                                b'b' => cleaned.push(0x8),
                                b'f' => cleaned.push(0xC),
                                b'(' => cleaned.push(b'('),
                                b')' => cleaned.push(b')'),
                                b'\\' => cleaned.push(b'\\'),
                                b'\n' | b'\r' => {
                                    // A conforming reader shall disregard the REVERSE SOLIDUS
                                    // and the end-of-line marker following it when reading
                                    // the string; the resulting string value shall be
                                    // identical to that which would be read if the string
                                    // were not split.
                                    r.skip_eol_characters();
                                }
                                _ => cleaned.push(next),
                            }
                        }
                    }
                    // An end-of-line marker appearing within a literal string
                    // without a preceding REVERSE SOLIDUS shall be treated as
                    // a byte value of (0Ah), irrespective of whether the end-of-line
                    // marker was a CARRIAGE RETURN (0Dh), a LINE FEED (0Ah), or both.
                    b'\n' | b'\r' => {
                        cleaned.push(b'\n');
                        r.skip_eol_characters();
                    }
                    other => cleaned.push(other),
                }
            }

            Cow::Owned(cleaned)
        } else {
            Cow::Borrowed(self.0)
        }
    }
}

impl Skippable for LiteralString<'_> {
    fn skip(r: &mut Reader<'_>, _: bool) -> Option<()> {
        parse_literal(r).map(|_| ())
    }
}

impl<'a> Readable<'a> for LiteralString<'a> {
    fn read(r: &mut Reader<'a>, _: ReaderContext) -> Option<Self> {
        let start = r.offset();
        let dirty = parse_literal(r)?;
        let end = r.offset();

        // Exclude outer brackets
        let result = r.range(start + 1..end - 1).unwrap();

        Some(LiteralString(result, dirty))
    }
}

impl<'a> TryFrom<Object<'a>> for LiteralString<'a> {
    type Error = ();

    fn try_from(value: Object<'a>) -> Result<Self, Self::Error> {
        match value {
            Object::String(String(InnerString::Literal(l))) => Ok(l),
            _ => Err(()),
        }
    }
}

impl<'a> ObjectLike<'a> for LiteralString<'a> {}

fn parse_literal(r: &mut Reader<'_>) -> Option<bool> {
    r.forward_tag(b"(")?;
    let mut bracket_counter = 1;
    let mut dirty = false;

    while bracket_counter > 0 {
        let byte = r.read_byte()?;

        match byte {
            b'\\' => {
                dirty = true;

                let _ = r.read_byte()?;
            }
            b'(' => bracket_counter += 1,
            b')' => bracket_counter -= 1,
            b'\n' | b'\r' => dirty = true,
            _ => {}
        };
    }

    Some(dirty)
}

#[derive(Clone, Debug, PartialEq)]
enum InnerString<'a> {
    Hex(HexString<'a>),
    Literal(LiteralString<'a>),
}

/// A string.
#[derive(Clone, Debug, PartialEq)]
pub struct String<'a>(InnerString<'a>);

impl<'a> String<'a> {
    /// Returns the content of the string.
    pub fn get(&self) -> Cow<'a, [u8]> {
        match &self.0 {
            InnerString::Hex(hex) => Cow::Owned(hex.get()),
            InnerString::Literal(lit) => lit.get(),
        }
    }
}

impl<'a> From<HexString<'a>> for String<'a> {
    fn from(value: HexString<'a>) -> Self {
        Self(InnerString::Hex(value))
    }
}

impl<'a> From<LiteralString<'a>> for String<'a> {
    fn from(value: LiteralString<'a>) -> Self {
        Self(InnerString::Literal(value))
    }
}

object!(String<'a>, String);

impl Skippable for String<'_> {
    fn skip(r: &mut Reader<'_>, is_content_stream: bool) -> Option<()> {
        match r.peek_byte()? {
            b'<' => HexString::skip(r, is_content_stream),
            b'(' => LiteralString::skip(r, is_content_stream),
            _ => None,
        }
    }
}

impl<'a> Readable<'a> for String<'a> {
    fn read(r: &mut Reader<'a>, _: ReaderContext) -> Option<Self> {
        let inner = match r.peek_byte()? {
            b'<' => InnerString::Hex(r.read_without_context::<HexString>()?),
            b'(' => InnerString::Literal(r.read_without_context::<LiteralString>()?),
            _ => return None,
        };

        Some(String(inner))
    }
}

fn is_octal_digit(byte: u8) -> bool {
    matches!(byte, b'0'..=b'7')
}

#[cfg(test)]
mod tests {
    use crate::object::string::{HexString, LiteralString, String};
    use crate::reader::Reader;

    #[test]
    fn hex_string_empty() {
        assert_eq!(
            Reader::new("<>".as_bytes())
                .read_without_context::<HexString>()
                .unwrap()
                .get(),
            vec![]
        );
    }

    #[test]
    fn hex_string_1() {
        assert_eq!(
            Reader::new("<00010203>".as_bytes())
                .read_without_context::<HexString>()
                .unwrap()
                .get(),
            vec![0x00, 0x01, 0x02, 0x03]
        );
    }

    #[test]
    fn hex_string_2() {
        assert_eq!(
            Reader::new("<000102034>".as_bytes())
                .read_without_context::<HexString>()
                .unwrap()
                .get(),
            vec![0x00, 0x01, 0x02, 0x03, 0x40]
        );
    }

    #[test]
    fn hex_string_trailing_1() {
        assert_eq!(
            Reader::new("<000102034>dfgfg4".as_bytes())
                .read_without_context::<HexString>()
                .unwrap()
                .get(),
            vec![0x00, 0x01, 0x02, 0x03, 0x40]
        );
    }

    #[test]
    fn hex_string_trailing_2() {
        assert_eq!(
            Reader::new("<1  3 4>dfgfg4".as_bytes())
                .read_without_context::<HexString>()
                .unwrap()
                .get(),
            vec![0x13, 0x40]
        );
    }

    #[test]
    fn hex_string_trailing_3() {
        assert_eq!(
            Reader::new("<1>dfgfg4".as_bytes())
                .read_without_context::<HexString>()
                .unwrap()
                .get(),
            vec![0x10]
        );
    }

    #[test]
    fn hex_string_invalid_1() {
        assert!(
            Reader::new("<".as_bytes())
                .read_without_context::<HexString>()
                .is_none()
        );
    }

    #[test]
    fn hex_string_invalid_2() {
        assert!(
            Reader::new("34AD".as_bytes())
                .read_without_context::<HexString>()
                .is_none()
        );
    }

    #[test]
    fn literal_string_empty() {
        assert_eq!(
            Reader::new("()".as_bytes())
                .read_without_context::<LiteralString>()
                .unwrap()
                .get()
                .to_vec(),
            b"".to_vec()
        );
    }

    #[test]
    fn literal_string_1() {
        assert_eq!(
            Reader::new("(Hi there.)".as_bytes())
                .read_without_context::<LiteralString>()
                .unwrap()
                .get()
                .to_vec(),
            b"Hi there.".to_vec()
        );
    }

    #[test]
    fn literal_string_2() {
        assert!(
            Reader::new("(Hi \\777)".as_bytes())
                .read_without_context::<LiteralString>()
                .is_some()
        );
    }

    #[test]
    fn literal_string_3() {
        assert_eq!(
            Reader::new("(Hi ) there.)".as_bytes())
                .read_without_context::<LiteralString>()
                .unwrap()
                .get()
                .to_vec(),
            b"Hi ".to_vec()
        );
    }

    #[test]
    fn literal_string_4() {
        assert_eq!(
            Reader::new("(Hi (()) there)".as_bytes())
                .read_without_context::<LiteralString>()
                .unwrap()
                .get()
                .to_vec(),
            b"Hi (()) there".to_vec()
        );
    }

    #[test]
    fn literal_string_5() {
        assert_eq!(
            Reader::new("(Hi \\()".as_bytes())
                .read_without_context::<LiteralString>()
                .unwrap()
                .get()
                .to_vec(),
            b"Hi (".to_vec()
        );
    }

    #[test]
    fn literal_string_6() {
        assert_eq!(
            Reader::new("(Hi \\\nthere)".as_bytes())
                .read_without_context::<LiteralString>()
                .unwrap()
                .get()
                .to_vec(),
            b"Hi there".to_vec()
        );
    }

    #[test]
    fn literal_string_7() {
        assert_eq!(
            Reader::new("(Hi \\05354)".as_bytes())
                .read_without_context::<LiteralString>()
                .unwrap()
                .get()
                .to_vec(),
            b"Hi +54".to_vec()
        );
    }

    #[test]
    fn literal_string_8() {
        assert_eq!(
            Reader::new("(\\3)".as_bytes())
                .read_without_context::<String>()
                .unwrap()
                .get(),
            b"3".to_vec()
        )
    }

    #[test]
    fn literal_string_9() {
        assert_eq!(
            Reader::new("(\\36)".as_bytes())
                .read_without_context::<String>()
                .unwrap()
                .get(),
            b"36".to_vec()
        )
    }

    #[test]
    fn literal_string_10() {
        assert_eq!(
            Reader::new("(\\36ab)".as_bytes())
                .read_without_context::<String>()
                .unwrap()
                .get(),
            b"36ab".to_vec()
        )
    }

    #[test]
    fn literal_string_trailing() {
        assert_eq!(
            Reader::new("(Hi there.)abcde".as_bytes())
                .read_without_context::<LiteralString>()
                .unwrap()
                .get()
                .to_vec(),
            b"Hi there.".to_vec()
        );
    }

    #[test]
    fn literal_string_invalid() {
        // In this case, we just ignore the solidus and treat it as literal numbers.
        assert_eq!(
            Reader::new("(Hi \\778)".as_bytes())
                .read_without_context::<LiteralString>()
                .unwrap()
                .get()
                .to_vec(),
            b"Hi 778".to_vec()
        );
    }

    #[test]
    fn string_1() {
        assert_eq!(
            Reader::new("(Hi there.)".as_bytes())
                .read_without_context::<String>()
                .unwrap()
                .get()
                .to_vec(),
            b"Hi there.".to_vec()
        );
    }

    #[test]
    fn string_2() {
        assert_eq!(
            Reader::new("<00010203>".as_bytes())
                .read_without_context::<String>()
                .unwrap()
                .get(),
            vec![0x00, 0x01, 0x02, 0x03]
        );
    }
}