scan.rs

//! XML をバイトのまま走査する道具
//!
//! 汎用の読み取り ([`crate::xml::Reader`]) は、タグのたびに名前と属性を文字列へ写し、
//! UTF-8 かどうかを確かめる。シートや共有文字列のように、同じ形の短い要素が大量に並ぶパートでは、
//! その手間が読み込みの時間の大半になる。
//!
//! ここにあるのは、バイト列の上で '<' を探し、タグを見分け、要る値だけを拾うための道具である。
//! UTF-8 として確かめるのは、文字として返すものだけにする。
//!
//! # 足りないときは読み直す
//!
//! パートは少しずつ届くので、要素の途中でバイトが尽きることがある。
//! どの道具も、そのときは決めずに「足りない」と返す。呼んだ側は続きを受け取り ([`Feed::fill`])、
//! 要素の頭から読み直す。要素は短いので、読み直しの手間はほとんどかからない。

use crate::error::Error;
use crate::xml;
use crate::zip;


/// パートのバイトを受け取りながら、読みかけのところを持つもの
pub(crate) struct Feed {
    source: zip::Reader,
    /// 受け取ったバイト。position より前は読み終えている
    buffer: Vec<u8>,
    /// 次に読む位置
    position: usize,
    /// source が尽きたか
    drained: bool,
}


impl Feed {
    pub(crate) fn new(source: zip::Reader) -> Feed {
        Feed {source, buffer: Vec::new(), position: 0, drained: false}
    }

    /// まだ読んでいないバイト
    pub(crate) fn data(&self) -> &[u8] {
        &self.buffer[self.position..]
    }

    /// used バイト読み終えた
    pub(crate) fn advance(&mut self, used: usize) {
        self.position += used;
    }

    /// 残りが空白だけか
    pub(crate) fn blank(&self) -> bool {
        self.data().iter().all(|byte| space(*byte))
    }

    /// 残りを最後まで受け取って捨てる
    ///
    /// パートが壊れていないかは、最後まで受け取ったときに CRC で分かる。
    /// 要るものを読み終えたあとも、これを呼んで確かめる。
    pub(crate) fn finish(&mut self) -> Result<(), Error> {
        while !self.drained {
            if self.source.next()?.is_none() {
                self.drained = true;
            }
        }

        Ok(())
    }

    /// 続きを受け取る。もうなければ false
    pub(crate) fn fill(&mut self) -> Result<bool, Error> {
        if self.drained {
            return Ok(false);
        }

        let Some(piece) = self.source.next()? else {
            self.drained = true;
            return Ok(false);
        };

        if self.position >= self.buffer.len() {
            // 読み残しがなければ、受け取ったものをそのまま持つ
            self.buffer = piece;
        } else {
            self.buffer.drain(..self.position);
            self.buffer.extend_from_slice(&piece);
        }

        self.position = 0;
        Ok(true)
    }
}


/// '<' から始まるもの
pub(crate) enum Mark {
    /// データが足りず、まだ決められない
    More,
    /// 読み飛ばすもの (注記、処理命令、宣言)。次に読む位置
    Skip(usize),
    /// CDATA。中身の範囲と、次に読む位置
    Data(usize, usize, usize),
    /// 開くタグ。'>' の位置と、名前の範囲
    Open(usize, usize, usize),
    /// 閉じるタグ。次に読む位置と、名前の範囲
    Close(usize, usize, usize),
}


/// open にある '<' から始まるものを見分ける
pub(crate) fn mark(data: &[u8], open: usize) -> Mark {
    let Some(next) = data.get(open + 1) else {
        return Mark::More;
    };

    match *next {
        b'/' => {
            let Some(bracket) = find(data, open + 2, b'>') else {
                return Mark::More;
            };

            let mut stop = bracket;

            while stop > open + 2 && space(data[stop - 1]) {
                stop -= 1;
            }

            Mark::Close(bracket + 1, open + 2, stop)
        }

        b'?' => match find_pattern(data, open + 2, b"?>") {
            Some(at) => Mark::Skip(at + 2),
            None => Mark::More,
        },

        b'!' => {
            match starts(data, open, b"<!--") {
                None => return Mark::More,

                Some(true) => {
                    return match find_pattern(data, open + 4, b"-->") {
                        Some(at) => Mark::Skip(at + 3),
                        None => Mark::More,
                    };
                }

                Some(false) => {}
            }

            match starts(data, open, b"<![CDATA[") {
                None => return Mark::More,

                Some(true) => {
                    return match find_pattern(data, open + 9, b"]]>") {
                        Some(at) => Mark::Data(open + 9, at, at + 3),
                        None => Mark::More,
                    };
                }

                Some(false) => {}
            }

            match find(data, open + 2, b'>') {
                Some(at) => Mark::Skip(at + 1),
                None => Mark::More,
            }
        }

        _ => {
            let Some(bracket) = tag_end(data, open) else {
                return Mark::More;
            };

            let mut stop = open + 1;

            while stop < bracket && !space(data[stop]) && data[stop] != b'/' {
                stop += 1;
            }

            Mark::Open(bracket, open + 1, stop)
        }
    }
}


/// タグの中の次の属性。名前は前置きを落としたもの、値は引用符の中のバイトである
///
/// cursor から stop までを見て、次に見る位置も返す。もう属性がなければ None
pub(crate) fn attribute(data: &[u8], cursor: usize, stop: usize) -> Result<Option<(&[u8], &[u8], usize)>, Error> {
    let mut at = cursor;

    while at < stop && space(data[at]) {
        at += 1;
    }

    if at >= stop {
        return Ok(None);
    }

    let key = at;

    while at < stop && data[at] != b'=' && !space(data[at]) {
        at += 1;
    }

    let key_end = at;

    while at < stop && space(data[at]) {
        at += 1;
    }

    if at >= stop || data[at] != b'=' {
        return Err(Error::new("XML の属性に = がありません"));
    }

    at += 1;

    while at < stop && space(data[at]) {
        at += 1;
    }

    if at >= stop {
        return Err(Error::new("XML の属性に値がありません"));
    }

    let quote = data[at];

    if quote != b'"' && quote != b'\'' {
        return Err(Error::new("XML の属性の値が引用符で囲まれていません"));
    }

    at += 1;
    let value = at;

    while at < stop && data[at] != quote {
        at += 1;
    }

    Ok(Some((local(&data[key..key_end]), &data[value..at], (at + 1).min(stop))))
}


/// 要素の中の文字を、閉じるタグまで読む。at は開くタグの '>' の次
///
/// 実体参照も CDATA もなければ、文字のバイトの範囲を返し、into には触らない。
/// あれば戻した文字を into に足し、範囲は None を返す。
/// 返す位置は、閉じるタグの '>' の次である。データが足りなければ None
pub(crate) fn content(data: &[u8], at: usize, into: &mut String) -> Result<Option<(Option<(usize, usize)>, usize)>, Error> {
    let Some(open) = find(data, at, b'<') else {
        return Ok(None);
    };

    if data.get(open + 1) == Some(&b'/') && !data[at..open].contains(&b'&') {
        let Some(bracket) = find(data, open + 2, b'>') else {
            return Ok(None);
        };

        return Ok(Some((Some((at, open)), bracket + 1)));
    }

    // 実体参照や CDATA が混じっている。戻しながら足す
    let length = into.len();
    let mut cursor = at;

    loop {
        let Some(open) = find(data, cursor, b'<') else {
            into.truncate(length);
            return Ok(None);
        };

        xml::unescape_into(&data[cursor..open], into)?;

        match mark(data, open) {
            Mark::More => {
                into.truncate(length);
                return Ok(None);
            }

            Mark::Close(next, _, _) => return Ok(Some((None, next))),

            Mark::Data(from, to, next) => {
                into.push_str(utf8(&data[from..to])?);
                cursor = next;
            }

            Mark::Skip(next) => cursor = next,
            Mark::Open(bracket, _, _) => cursor = bracket + 1,
        }
    }
}


/// 飾りのつく文字 (`<is>` や `<si>` の中身) を、close の閉じるタグまで読む
///
/// `<t>` の文字を into に足す。`<r>` で区切られた飾りつきの文字は、つないで 1 つにする。
/// ふりがな (`<rPh>`) の中の `<t>` は足さない。at は開くタグの '>' の次である。
/// 返す位置は閉じるタグの '>' の次で、データが足りなければ None
pub(crate) fn rich(data: &[u8], at: usize, close: &[u8], into: &mut String) -> Result<Option<usize>, Error> {
    let mut phonetic = 0u32;
    let mut at = at;

    loop {
        let Some(open) = find(data, at, b'<') else {
            return Ok(None);
        };

        match mark(data, open) {
            Mark::More => return Ok(None),
            Mark::Skip(next) | Mark::Data(_, _, next) => at = next,

            Mark::Close(next, from, to) => {
                let name = local(&data[from..to]);

                if name == close {
                    return Ok(Some(next));
                }

                if name == b"rPh" {
                    phonetic = phonetic.saturating_sub(1);
                }

                at = next;
            }

            Mark::Open(bracket, from, to) => {
                let closed = data[bracket - 1] == b'/';

                match local(&data[from..to]) {
                    b"t" if !closed => {
                        let length = into.len();

                        let Some((range, next)) = content(data, bracket + 1, into)? else {
                            return Ok(None);
                        };

                        if phonetic > 0 {
                            into.truncate(length);
                        } else if let Some((from, to)) = range {
                            into.push_str(utf8(&data[from..to])?);
                        }

                        at = next;
                    }

                    b"rPh" if !closed => {
                        phonetic += 1;
                        at = bracket + 1;
                    }

                    _ => at = bracket + 1,
                }
            }
        }
    }
}


/// 開くタグから、その要素の終わりまで飛ばす。データが足りなければ None
pub(crate) fn skip(data: &[u8], bracket: usize, from: usize, to: usize) -> Option<usize> {
    if data[bracket - 1] == b'/' {
        return Some(bracket + 1);
    }

    let name = local(&data[from..to]);
    let mut depth = 1;
    let mut at = bracket + 1;

    loop {
        let open = find(data, at, b'<')?;

        match mark(data, open) {
            Mark::More => return None,
            Mark::Skip(next) | Mark::Data(_, _, next) => at = next,

            Mark::Close(next, from, to) => {
                if local(&data[from..to]) == name {
                    depth -= 1;

                    if depth == 0 {
                        return Some(next);
                    }
                }

                at = next;
            }

            Mark::Open(inner, from, to) => {
                if data[inner - 1] != b'/' && local(&data[from..to]) == name {
                    depth += 1;
                }

                at = inner + 1;
            }
        }
    }
}


/// タグを閉じる '>' を探す。引用符の中の '>' は数えない
pub(crate) fn tag_end(data: &[u8], open: usize) -> Option<usize> {
    let mut quote = 0u8;
    let mut at = open + 1;

    while at < data.len() {
        let byte = data[at];

        if quote != 0 {
            if byte == quote {
                quote = 0;
            }
        } else if byte == b'>' {
            return Some(at);
        } else if byte == b'"' || byte == b'\'' {
            quote = byte;
        }

        at += 1;
    }

    None
}


/// at から byte を探す
///
/// 8 バイトずつまとめて見る。探すバイトと xor すると、同じバイトは 0 になる。
/// 0 のバイトがあるかどうかは、1 を引いたときの繰り下がりで一度に分かる。
pub(crate) fn find(data: &[u8], at: usize, byte: u8) -> Option<usize> {
    const LOW: u64 = 0x0101010101010101;
    const HIGH: u64 = 0x8080808080808080;
    let pattern = LOW * byte as u64;
    let mut cursor = at;

    while cursor + 8 <= data.len() {
        let mut word = [0u8; 8];
        word.copy_from_slice(&data[cursor..cursor + 8]);
        let value = u64::from_le_bytes(word) ^ pattern;
        let found = value.wrapping_sub(LOW) & !value & HIGH;

        if found != 0 {
            return Some(cursor + (found.trailing_zeros() / 8) as usize);
        }

        cursor += 8;
    }

    while cursor < data.len() {
        if data[cursor] == byte {
            return Some(cursor);
        }

        cursor += 1;
    }

    None
}


/// at から並びを探す
pub(crate) fn find_pattern(data: &[u8], at: usize, pattern: &[u8]) -> Option<usize> {
    if at > data.len() {
        return None;
    }

    data[at..].windows(pattern.len()).position(|window| window == pattern).map(|found| at + found)
}


/// at から pattern で始まるか。データが足りずに決められなければ None
pub(crate) fn starts(data: &[u8], at: usize, pattern: &[u8]) -> Option<bool> {
    let rest = &data[at.min(data.len())..];

    if rest.len() >= pattern.len() {
        return Some(&rest[..pattern.len()] == pattern);
    }

    if rest == &pattern[..rest.len()] {
        None
    } else {
        Some(false)
    }
}


/// `:` から後ろ
pub(crate) fn local(name: &[u8]) -> &[u8] {
    match name.iter().rposition(|byte| *byte == b':') {
        Some(cut) => &name[cut + 1..],
        None => name,
    }
}


/// 区切りに使う空白か
pub(crate) fn space(byte: u8) -> bool {
    byte == b' ' || byte == b'\t' || byte == b'\n' || byte == b'\r'
}


/// 前後の空白を落とす
pub(crate) fn trim(text: &[u8]) -> &[u8] {
    let mut from = 0;
    let mut to = text.len();

    while from < to && space(text[from]) {
        from += 1;
    }

    while to > from && space(text[to - 1]) {
        to -= 1;
    }

    &text[from..to]
}


/// バイト列を文字列として見る
pub(crate) fn utf8(piece: &[u8]) -> Result<&str, Error> {
    xml::text_of(piece)
}