xls.rs

//! 旧形式の表計算 (BIFF8)
//!
//! .xls は複合ファイルの中の Workbook ストリームで、レコードを並べたものである。
//! レコードは 2 バイトの種類、2 バイトの長さ、中身の順に続く。
//!
//! 先頭は全体にかかる区画で、シートの名前、共有文字列、書式が入っている。
//! そのあとにシートごとの区画が続き、行とセルのレコードが並ぶ。
//!
//! # 続きのレコード
//!
//! 1 つのレコードは 8224 バイトまでしか入らない。あふれたぶんは CONTINUE レコードに続く。
//! 文字列がこの継ぎ目をまたぐと、続きの先頭に「残りが 1 バイト文字か 2 バイト文字か」を
//! 言い直す 1 バイトが入る。ここがいちばん間違えやすいところである。
//!
//! # 読めるもの
//!
//! Excel 97 から 2003 までの形式 (BIFF8) を読む。それより前の形式は、
//! 文字がその土地の符号で入っていて戻せないので、はっきり断る。

use crate::cell::{Cell, Row, Value};
use crate::error::Error;
use crate::shared::Shared;
use crate::style::Style;
use std::sync::Arc;


/// 区画の始まり
const BOF: u16 = 0x0809;

/// 区画の終わり
const END: u16 = 0x000a;

/// 前のレコードの続き
const CONTINUE: u16 = 0x003c;

/// 共有文字列
const SST: u16 = 0x00fc;

/// パスワードが掛かっている印
const FILEPASS: u16 = 0x002f;

/// 日付の数え方
const DATEMODE: u16 = 0x0022;

/// シートの名前と位置
const BOUNDSHEET: u16 = 0x0085;

/// 表示形式の文字列
const FORMAT: u16 = 0x041e;

/// 書式
const XF: u16 = 0x00e0;

/// 空のセル
const BLANK: u16 = 0x0201;

/// 空のセルの並び
const MULBLANK: u16 = 0x00be;

/// 数のセル
const NUMBER: u16 = 0x0203;

/// 縮めて入れた数のセル
const RK: u16 = 0x027e;

/// 縮めて入れた数の並び
const MULRK: u16 = 0x00bd;

/// 共有文字列を指すセル
const LABELSST: u16 = 0x00fd;

/// 文字を直に持つセル
const LABEL: u16 = 0x0204;

/// 飾りつきの文字を直に持つセル
const RSTRING: u16 = 0x00d6;

/// 真偽かエラーのセル
const BOOLERR: u16 = 0x0205;

/// 数式のセル
const FORMULA: u16 = 0x0006;

/// 数式の答えが文字だったとき、次に続くレコード
const STRING: u16 = 0x0207;


/// ワークブックに載っているシート
#[derive(Debug, Clone)]
pub struct Sheet {
    /// 見出しに出る名前
    pub name: String,
    /// シートの区画が始まる位置
    pub offset: usize,
    /// 隠していないか
    pub visible: bool,
}


/// 読み込んだ旧形式のワークブック
pub struct Book {
    data: Arc<Vec<u8>>,
    pub sheet: Vec<Sheet>,
    pub shared: Shared,
    pub style: Style,
    pub epoch1904: bool,
}


impl Book {
    /// Workbook ストリームを読む
    pub fn open(data: Vec<u8>) -> Result<Book, Error> {
        let mut result = Book {
            data: Arc::new(data),
            sheet: Vec::new(),
            shared: Shared::new(),
            style: Style::new(),
            epoch1904: false,
        };

        let data = result.data.clone();
        let mut cursor = Walk {data: &data, position: 0};

        let Some(first) = cursor.next() else {
            return Err(Error::new("Workbook ストリームが空です"));
        };

        if first.kind != BOF {
            return Err(Error::new("BIFF の区画が始まっていません"));
        }

        let version = short(&data, first.start)?;

        if version != 0x0600 {
            return Err(Error::new(format!(
                "Excel 97 より前の形式です (BIFF の版 0x{version:04x})。文字の符号が戻せないので読めません"
            )));
        }

        while let Some(one) = cursor.next() {
            match one.kind {
                END => break,

                FILEPASS => {
                    return Err(Error::new("パスワードが掛かっているので読めません"));
                }

                DATEMODE => result.epoch1904 = short(&data, one.start)? == 1,

                BOUNDSHEET => {
                    let offset = long(&data, one.start)? as usize;
                    let state = data[one.start + 4];
                    let kind = data[one.start + 5];
                    let mut piece = Piece::over(&data[one.start + 6..one.start + one.length]);
                    let name = piece.read_short()?;

                    // 0 が worksheet。グラフだけのシートやマクロのシートは読まない
                    if kind == 0 {
                        result.sheet.push(Sheet {name, offset, visible: state == 0});
                    }
                }

                FORMAT => {
                    let id = short(&data, one.start)? as u32;
                    let mut piece = Piece::over(&data[one.start + 2..one.start + one.length]);
                    let code = piece.read_text()?;
                    result.style.put_format(id, &code);
                }

                XF => result.style.put_xf(short(&data, one.start + 2)? as u32),

                SST => {
                    let piece = cursor.gather(&one);
                    read_shared(piece, &mut result.shared)?;
                }

                _ => {}
            }
        }

        Ok(result)
    }

    /// シートのレコードをたどるもの
    pub fn cursor(&self, index: usize) -> Result<Cursor, Error> {
        let Some(one) = self.sheet.get(index) else {
            return Err(Error::new(format!("{index} 枚目のシートはありません")));
        };

        Ok(Cursor {
            data: self.data.clone(),
            position: one.offset,
            ended: false,
            started: false,
        })
    }
}


/// シートのレコードを行ごとにたどるもの
pub struct Cursor {
    data: Arc<Vec<u8>>,
    position: usize,
    ended: bool,
    /// シート自身の区画の始まりを読んだか
    started: bool,
}


impl Cursor {
    /// 次の行を組み立てる。行があったら true
    pub fn read(&mut self, row: &mut Row, shared: &Shared) -> Result<bool, Error> {
        if self.ended {
            return Ok(false);
        }

        row.cell.clear();
        let data = self.data.clone();
        let mut number: Option<u32> = None;
        let mut waiting: Option<usize> = None;
        let mut walk = Walk {data: &data, position: self.position};

        loop {
            let save = walk.position;

            let Some(one) = walk.next() else {
                self.ended = true;
                self.position = walk.position;
                return Ok(number.is_some());
            };

            if one.kind == END {
                self.ended = true;
                self.position = walk.position;
                return Ok(number.is_some());
            }

            // シートの中に、グラフが自分の区画を持って入っていることがある。
            // その中にもセルらしいレコードが並ぶので、まとめて飛ばす
            if one.kind == BOF {
                if !self.started {
                    self.started = true;
                    self.position = walk.position;
                    continue;
                }

                let mut depth = 1;

                while depth > 0 {
                    let Some(inner) = walk.next() else {
                        break;
                    };

                    if inner.kind == BOF {
                        depth += 1;
                    }

                    if inner.kind == END {
                        depth -= 1;
                    }
                }

                self.position = walk.position;
                continue;
            }

            // 数式の答えが文字だったときは、次のレコードに入っている
            if one.kind == STRING {
                if let Some(index) = waiting.take() {
                    let piece = walk.gather(&one);
                    let text = Piece {data: piece.data, edge: piece.edge, position: 0}.into_rich()?;
                    row.cell[index].value = Value::Text(text);
                }

                continue;
            }

            let Some(at) = cell_row(one.kind, &data, one.start)? else {
                continue;
            };

            match number {
                Some(current) if at != current => {
                    self.position = save;
                    return Ok(true);
                }

                None => {
                    number = Some(at);
                    row.number = at + 1;
                }

                _ => {}
            }

            waiting = push(&one, &data, row, shared, &mut walk)?;
            self.position = walk.position;
        }
    }
}


/// レコード 1 つの位置
struct Record {
    kind: u16,
    /// 中身が始まる位置
    start: usize,
    /// 中身の長さ
    length: usize,
}


/// レコードを順にたどる
struct Walk<'a> {
    data: &'a [u8],
    position: usize,
}


impl Walk<'_> {
    /// 次のレコード
    fn next(&mut self) -> Option<Record> {
        if self.position + 4 > self.data.len() {
            return None;
        }

        let kind = u16::from_le_bytes([self.data[self.position], self.data[self.position + 1]]);
        let length = u16::from_le_bytes([self.data[self.position + 2], self.data[self.position + 3]]) as usize;
        let start = self.position + 4;

        if start + length > self.data.len() {
            return None;
        }

        self.position = start + length;
        Some(Record {kind, start, length})
    }

    /// レコードと、それに続く CONTINUE をつないで集める
    fn gather(&mut self, one: &Record) -> Piece {
        let mut data = self.data[one.start..one.start + one.length].to_vec();
        let mut edge = Vec::new();

        loop {
            let save = self.position;

            let Some(next) = self.next() else {
                break;
            };

            if next.kind != CONTINUE {
                self.position = save;
                break;
            }

            edge.push(data.len());
            data.extend_from_slice(&self.data[next.start..next.start + next.length]);
        }

        Piece {data, edge, position: 0}
    }
}


/// レコードの中身を、継ぎ目を知りながら読むもの
struct Piece {
    data: Vec<u8>,
    /// CONTINUE で継ぎ足された位置
    edge: Vec<usize>,
    position: usize,
}


impl Piece {
    /// 継ぎ目のない中身
    fn over(data: &[u8]) -> Piece {
        Piece {data: data.to_vec(), edge: Vec::new(), position: 0}
    }

    /// まだ読めるか
    fn more(&self) -> bool {
        self.position < self.data.len()
    }

    /// いまが継ぎ目か
    fn at_edge(&self) -> bool {
        self.edge.binary_search(&self.position).is_ok()
    }

    fn take_u8(&mut self) -> Result<u8, Error> {
        if self.position >= self.data.len() {
            return Err(Error::new("BIFF のレコードが途中で終わっています"));
        }

        let value = self.data[self.position];
        self.position += 1;
        Ok(value)
    }

    fn take_u16(&mut self) -> Result<u16, Error> {
        Ok(u16::from_le_bytes([self.take_u8()?, self.take_u8()?]))
    }

    fn take_u32(&mut self) -> Result<u32, Error> {
        Ok(u32::from_le_bytes([
            self.take_u8()?,
            self.take_u8()?,
            self.take_u8()?,
            self.take_u8()?,
        ]))
    }

    fn skip(&mut self, count: usize) {
        self.position = (self.position + count).min(self.data.len());
    }

    /// 文字数と入れ方を先に読んでから、文字を集める
    fn take_text(&mut self, count: usize, mut wide: bool) -> Result<String, Error> {
        let mut result = String::with_capacity(count);
        let mut done = 0;

        while done < count {
            // 継ぎ目では、残りがどちらで入っているかを 1 バイトで言い直す
            if self.at_edge() {
                wide = self.take_u8()? & 1 != 0;
            }

            let value = if wide {
                self.take_u16()?
            } else {
                self.take_u8()? as u16
            };

            match char::from_u32(value as u32) {
                Some(one) => result.push(one),
                None => result.push('\u{fffd}'),
            }

            done += 1;
        }

        Ok(result)
    }

    /// 飾りの情報も付いた文字列 (共有文字列やセルの文字)
    fn read_rich(&mut self) -> Result<String, Error> {
        let count = self.take_u16()? as usize;
        let flag = self.take_u8()?;
        let wide = flag & 1 != 0;
        let extended = flag & 4 != 0;
        let rich = flag & 8 != 0;
        let runs = if rich {self.take_u16()? as usize} else {0};
        let extra = if extended {self.take_u32()? as usize} else {0};
        let result = self.take_text(count, wide)?;
        self.skip(runs * 4);
        self.skip(extra);
        Ok(result)
    }

    /// 中身をまるごと 1 つの文字列として読む
    fn into_rich(mut self) -> Result<String, Error> {
        self.read_rich()
    }

    /// 長さが 2 バイトの文字列
    fn read_text(&mut self) -> Result<String, Error> {
        let count = self.take_u16()? as usize;
        let flag = self.take_u8()?;
        self.take_text(count, flag & 1 != 0)
    }

    /// 長さが 1 バイトの文字列
    fn read_short(&mut self) -> Result<String, Error> {
        let count = self.take_u8()? as usize;
        let flag = self.take_u8()?;
        self.take_text(count, flag & 1 != 0)
    }
}


/// SST レコードから共有文字列を読む
fn read_shared(mut piece: Piece, shared: &mut Shared) -> Result<(), Error> {
    piece.take_u32()?;
    let count = piece.take_u32()? as usize;

    for _ in 0..count {
        if !piece.more() {
            break;
        }

        let one = piece.read_rich()?;
        shared.push(&one);
    }

    Ok(())
}


/// そのレコードがセルなら、行の番号を返す
fn cell_row(kind: u16, data: &[u8], start: usize) -> Result<Option<u32>, Error> {
    match kind {
        BLANK | MULBLANK | NUMBER | RK | MULRK | LABELSST | LABEL | RSTRING | BOOLERR | FORMULA => {
            Ok(Some(short(data, start)? as u32))
        }

        _ => Ok(None),
    }
}


/// セルのレコードを行に足す。数式の答えが文字なら、その置き場を返す
fn push(
    one: &Record,
    data: &[u8],
    row: &mut Row,
    shared: &Shared,
    walk: &mut Walk,
) -> Result<Option<usize>, Error> {
    let start = one.start;
    let column = short(data, start + 2)? as u32;
    let style = short(data, start + 4)? as u32;

    match one.kind {
        BLANK => row.cell.push(make(column, style, Value::Empty)),

        NUMBER => {
            let mut value = [0u8; 8];
            value.copy_from_slice(&data[start + 6..start + 14]);
            row.cell.push(make(column, style, Value::Number(f64::from_le_bytes(value))));
        }

        RK => {
            let value = rk(long(data, start + 6)?);
            row.cell.push(make(column, style, Value::Number(value)));
        }

        MULRK => {
            let count = (one.length - 6) / 6;

            for index in 0..count {
                let at = start + 4 + index * 6;
                let value = rk(long(data, at + 2)?);
                row.cell.push(make(column + index as u32, short(data, at)? as u32, Value::Number(value)));
            }
        }

        MULBLANK => {
            let count = (one.length - 6) / 2;

            for index in 0..count {
                let at = start + 4 + index * 2;
                row.cell.push(make(column + index as u32, short(data, at)? as u32, Value::Empty));
            }
        }

        LABELSST => {
            let index = long(data, start + 6)?;
            row.cell.push(make(column, style, Value::Text(shared.get(index).to_string())));
        }

        LABEL | RSTRING => {
            let mut piece = walk.gather(one);
            piece.skip(6);
            let text = piece.read_rich()?;
            row.cell.push(make(column, style, Value::Text(text)));
        }

        BOOLERR => {
            let value = data[start + 6];
            let failed = data[start + 7] != 0;

            let held = if failed {
                Value::Error(error_text(value).to_string())
            } else {
                Value::Boolean(value != 0)
            };

            row.cell.push(make(column, style, held));
        }

        FORMULA => {
            // 数式そのものは組み立てない。持っているのは計算しておいた答えだけである
            let held = if data[start + 12] == 0xff && data[start + 13] == 0xff {
                match data[start + 6] {
                    // 答えは次の STRING レコードに入っている。続かなければ空の文字のまま
                    0 => {
                        row.cell.push(make(column, style, Value::Text(String::new())));
                        return Ok(Some(row.cell.len() - 1));
                    }
                    1 => Value::Boolean(data[start + 8] != 0),
                    2 => Value::Error(error_text(data[start + 8]).to_string()),
                    _ => Value::Empty,
                }
            } else {
                let mut value = [0u8; 8];
                value.copy_from_slice(&data[start + 6..start + 14]);
                Value::Number(f64::from_le_bytes(value))
            };

            row.cell.push(make(column, style, held));
        }

        _ => {}
    }

    Ok(None)
}


/// セルを作る
fn make(column: u32, style: u32, value: Value) -> Cell {
    Cell {column: column + 1, style, value, formula: String::new()}
}


/// 縮めて入れた数を戻す
///
/// 下位 2 ビットが入れ方を表す。1 ビット目が立っていれば 100 で割り、
/// 2 ビット目が立っていれば整数、立っていなければ浮動小数の上位 30 ビットである。
fn rk(value: u32) -> f64 {
    let mut result = if value & 2 != 0 {
        ((value as i32) >> 2) as f64
    } else {
        f64::from_bits(((value & 0xfffffffc) as u64) << 32)
    };

    if value & 1 != 0 {
        result /= 100.0;
    }

    result
}


/// エラーの番号を文字にする
fn error_text(code: u8) -> &'static str {
    match code {
        0x00 => "#NULL!",
        0x07 => "#DIV/0!",
        0x0f => "#VALUE!",
        0x17 => "#REF!",
        0x1d => "#NAME?",
        0x24 => "#NUM!",
        0x2a => "#N/A",
        _ => "#ERR",
    }
}


/// 2 バイトを読む
fn short(data: &[u8], offset: usize) -> Result<u16, Error> {
    if offset + 2 > data.len() {
        return Err(Error::new("BIFF のレコードが途中で終わっています"));
    }

    Ok(u16::from_le_bytes([data[offset], data[offset + 1]]))
}


/// 4 バイトを読む
fn long(data: &[u8], offset: usize) -> Result<u32, Error> {
    if offset + 4 > data.len() {
        return Err(Error::new("BIFF のレコードが途中で終わっています"));
    }

    Ok(u32::from_le_bytes([
        data[offset],
        data[offset + 1],
        data[offset + 2],
        data[offset + 3],
    ]))
}