Merge pull request #1337 from keithcsqueensu/xlsb-tables

craft-xlsx: read the tables of a binary workbook
This commit is contained in:
FredApps authored and GitHub committed 2026-11-16 19:07:25 +01:00
commit 3af2280ee3
7 files changed
+1336 -23

No files matched your search

+18 -3
View File
@@ -108,9 +108,24 @@ implicit `@`, the spaces and line breaks typed in the formula, numbers as Excel
`FormulaKind::Shared` or `FormulaKind::Array` and their ranges, and `BrtCellMeta` as the cell
metadata index. Every cell of a shared formula gets its own text, decoded at the cell, since the
file keeps the tokens once. A formula whose decoding needs something the reader does not read keeps
only its saved result, with a warning saying why: a defined name left out, table references, other
workbooks, Python code stored outside the cell, data tables. The XLSB function table
(`xlsb/ftab.rs`) and the expression printer are this crate's own, apart from `craft-xls`'s.
only its saved result, with a warning saying why: a defined name left out, a table whose part can't
be read, other workbooks, Python code stored outside the cell, data tables.
A binary workbook's tables (`tableN.bin`, listed by the sheet's `BrtListPart`s) read through
`Package::tables` into the same `Table`, as Excel writes the table in `.xlsx`: the calculated and
totals formulas decoded as cell formulas are, an XML map's column properties, and the AutoFilter and
sort state built as the `autoFilter` and `sortState` elements, with numbers in a filter spelled as
Excel writes them there (17 significant digits; Excel writes a few values shorter, such as `0.1`,
which read back the same). A filter column the reader can't spell is left out with a warning (Excel
keeps date-group filters in an extension the reader skips; a custom filter on a Boolean value has no
`.xlsx` spelling Excel has shown), as is a sort by stroke or PinYin order. The revision ids Excel
writes (`xr:uid`) are in alternate-content blocks, which are skipped. A structured reference in a
formula (`PtgList`) is spelled as `.xlsx` has it (`Sales[Val]`, `Sales[[#Headers],[Key]]`,
`Sales[[#This Row],[A]:[B]]`, with Excel's spacing flags), from the table's id, which is
workbook-wide: the workbook's table parts are indexed when its workbook part is read. A reference to
a table that can't be read, to a deleted table or into another workbook keeps the cell's saved
result. The XLSB function table (`xlsb/ftab.rs`) and the expression printer are this crate's own,
apart from `craft-xls`'s.
## Hostile input
+57 -4
View File
@@ -12,7 +12,7 @@ use crate::pivot::{CacheRecord, PivotCacheDefinition, PivotTableDefinition, read
use crate::sheet::{Row, RowReader, SheetPart};
use crate::strings::StringItem;
use crate::styles::Styles;
use crate::workbook::{SheetEntry, Workbook};
use crate::workbook::{SheetEntry, SheetKind, Workbook};
use crate::{Error, Limits, Warnings, xlsb};
/// Most bytes of `[Content_Types].xml` read from a binary workbook.
@@ -149,7 +149,12 @@ impl<'a> Package<'a> {
if self.binary.is_some() {
let bytes = self.required(&self.workbook_part.clone())?;
let rels = self.workbook_rels()?;
let (wb, links) = xlsb::workbook(&bytes, &rels, &self.limits, &self.budget, &mut self.warnings)?;
let (mut wb, mut links, names) = xlsb::workbook(&bytes, &rels, &self.limits, &self.budget, &mut self.warnings)?;
if let Some(links) = links.as_mut() {
self.index_tables(&wb, links)?;
}
// Names after tables: a name's formula may use a structured reference.
xlsb::read_names(&mut wb, names, links.as_mut(), &self.limits, &self.budget, &mut self.warnings);
self.binary_links = Some(links);
return Ok(wb);
}
@@ -314,10 +319,31 @@ impl<'a> Package<'a> {
Ok(Some((part, Drawing::read(&root), rels)))
}
/// The tables of a worksheet read by [`Package::sheet`], in the order of its `tableParts`,
/// each with its part name. A table part that does not read is skipped with a warning.
/// The tables of a worksheet read by [`Package::sheet`], in the order of its `tableParts`
/// (its `BrtListPart`s in a binary workbook), each with its part name. A table part that does
/// not read is skipped with a warning.
pub fn tables(&mut self, sheet: &SheetPart) -> Result<Vec<(String, Table)>, Error> {
let mut out = Vec::new();
if self.binary.is_some() {
let rels = self.opc.rels(&sheet.part)?;
for id in &sheet.features.table_parts {
let Some(rel) = rels.by_id(id).filter(|r| !r.external && r.kind() == "table") else {
self.warn(format!("XLSB: {}: a table part relationship is missing", sheet.part));
continue;
};
let part = rel.target.clone();
let read = self.binary_part(&part, xlsb::TABLE).and_then(|bytes| {
let links = self.binary_links.as_ref().and_then(Option::as_ref);
xlsb::table(&bytes, links, &self.limits, &self.budget, &mut self.warnings)
});
match read {
Ok(t) => out.push((part, t)),
Err(Error::TooLarge(m)) => return Err(Error::TooLarge(m)),
Err(e) => self.warn(format!("skipped {part}: {e}")),
}
}
return Ok(out);
}
for id in &sheet.features.table_parts {
let Some(rel) = sheet.rels.by_id(id).filter(|r| !r.external) else { continue };
let part = rel.target.clone();
@@ -410,6 +436,33 @@ impl<'a> Package<'a> {
Ok(root.map(|r| craft_drawingml::theme::read_theme(&mut craft_drawingml::part::NoSource, &r)))
}
/// A part of a binary workbook, checked against its content type.
fn binary_part(&mut self, part: &str, content_type: &str) -> Result<Vec<u8>, Error> {
if let Some(types) = &self.binary {
xlsb::check_type(types, part, content_type)?;
}
self.required(part)
}
/// Indexes the table parts of a binary workbook's worksheets, for the structured references
/// in its formulas. A table part that does not read is left out with a warning: formulas
/// using it keep their saved results.
fn index_tables(&mut self, wb: &Workbook, links: &mut xlsb::Links) -> Result<(), Error> {
for entry in wb.sheets.iter().filter(|e| e.kind == SheetKind::Worksheet) {
let Some(part) = &entry.part else { continue };
let rels = self.opc.rels(part)?;
for rel in rels.list.iter().filter(|r| r.kind() == "table" && !r.external) {
let read = self.binary_part(&rel.target, xlsb::TABLE).and_then(|bytes| xlsb::index_table(links, &bytes, &self.limits, &self.budget));
match read {
Ok(()) => {}
Err(Error::TooLarge(m)) => return Err(Error::TooLarge(m)),
Err(e) => self.warn(format!("XLSB: {} could not be read ({e}); formulas using its table keep their saved results", rel.target)),
}
}
}
Ok(())
}
fn required(&mut self, part: &str) -> Result<Vec<u8>, Error> {
self.opc.read(part)?.ok_or_else(|| Error::Invalid(format!("missing part {part}")))
}
+66 -11
View File
@@ -1,14 +1,15 @@
//! Binary workbooks ([MS-XLSB]): the workbook part with its defined names, shared strings and
//! worksheets (rows, cells, columns, default sizes, merged cells), from their records. Cell
//! formulas are decoded from their tokens ([`formula`]) into the text an `.xlsx` file holds;
//! one that can't be keeps only its saved result, with a warning saying why. The styles part
//! is read into the same [`crate::styles::Styles`] ([`styles`]). A record that does not parse
//! fails the read.
//! one that can't be keeps only its saved result, with a warning saying why. Table parts are
//! read in `table`; the styles part is read into the same [`crate::styles::Styles`]
//! ([`styles`]). A record that does not parse fails the read.
mod expr;
mod formula;
mod ftab;
mod styles;
mod table;
use std::collections::{HashMap, HashSet};
use std::sync::Arc;
@@ -24,6 +25,7 @@ use crate::{Error, Limits, Warnings};
pub(crate) use formula::Links;
use formula::{Book, Mode, Name, Xti};
pub(crate) use styles::styles;
pub(crate) use table::{TABLE, index_table, table};
pub(crate) const MAIN: &str = "application/vnd.ms-excel.main";
const BINARY_MAIN: &str = "application/vnd.ms-excel.sheet.binary.macroEnabled.main";
@@ -37,6 +39,8 @@ const MAX_SHEETS: usize = 1024;
const MAX_BOOKS: usize = 65_536;
/// Most merged ranges in one worksheet.
const MAX_MERGES: usize = 100_000;
/// Table parts one worksheet lists at most.
const MAX_TABLE_PARTS: usize = 65_536;
/// Most column records in one worksheet: one per column.
const MAX_COLUMNS: usize = MAX_COLS as usize;
/// The tallest row, in twips (409.6 points).
@@ -189,11 +193,13 @@ struct Records<'a, 'l> {
/// Read the alternate content meant for Excel 2007 (version 12), as an `.xlsx` reader sees
/// the main attribute where Excel keeps a newer spelling in an extension.
excel_2007: bool,
/// Future-record and alternate-content blocks skipped so far.
skipped: usize,
}
impl<'a, 'l> Records<'a, 'l> {
fn new(bytes: &'a [u8], limits: &'l Limits, budget: &'l Budget) -> Self {
Self { bytes: Bytes::new(bytes), limits, budget, blocks: vec![], excel_2007: false }
Self { bytes: Bytes::new(bytes), limits, budget, blocks: vec![], excel_2007: false, skipped: 0 }
}
fn next(&mut self, warnings: &mut Warnings) -> Result<Option<(u16, &'a [u8])>, Error> {
@@ -246,6 +252,7 @@ impl<'a, 'l> Records<'a, 'l> {
let read = read && self.blocks.iter().all(|(_, r)| *r);
self.blocks.push((id + 1, read));
if !read {
self.skipped += 1;
warnings.warn("unsupported XLSB future-record and alternate-content blocks were skipped");
}
}
@@ -282,14 +289,16 @@ impl<'a, 'l> Records<'a, 'l> {
/// The workbook part: BrtBeginBook, BrtWbProp, the BrtBundleSh list.
/// The workbook part, and the tables its formulas refer to ([`Links`]): `None` when those can't
/// be read, so that the workbook still opens, with every formula kept as its saved result.
/// be read, so that the workbook still opens, with every formula kept as its saved result. Its
/// defined names come back undecoded ([`Names`]): [`read_names`] decodes them once the workbook's
/// tables are indexed, so a name's formula can use a structured reference.
pub(crate) fn workbook(
bytes: &[u8],
rels: &Rels,
limits: &Limits,
budget: &Budget,
warnings: &mut Warnings,
) -> Result<(Workbook, Option<Links>), Error> {
) -> Result<(Workbook, Option<Links>, Names), Error> {
let mut records = Records::new(bytes, limits, budget);
records.first(131, warnings)?;
let mut wb = Workbook::default();
@@ -313,11 +322,7 @@ pub(crate) fn workbook(
if wb.sheets.is_empty() {
return Err(invalid("no supported worksheets"));
}
match links.as_mut() {
Some(l) => wb.defined_names = defined_names(pending, &bundle_sheets, l, limits, budget, warnings),
None => warnings.warn("XLSB: the workbook's sheet links or names could not be read; formulas keep their saved results"),
}
return Ok((wb, links));
return Ok((wb, links, Names { pending, sheets: bundle_sheets }));
}
39 | 355 | 357 | 358 | 362 | 667 => {
if let Some(l) = links.as_mut()
@@ -416,6 +421,22 @@ struct PendingName {
help: Option<String>,
}
/// The workbook part's defined names, not yet decoded, and each BrtBundleSh's place in
/// [`Workbook::sheets`] (`None` for a skipped one).
pub(crate) struct Names {
pending: Vec<PendingName>,
sheets: Vec<Option<u32>>,
}
/// Decodes the workbook part's defined names `names` into `wb`, after the tables in `links` are
/// indexed. Without `links` none can be read, and formulas keep their saved results.
pub(crate) fn read_names(wb: &mut Workbook, names: Names, links: Option<&mut Links>, limits: &Limits, budget: &Budget, warnings: &mut Warnings) {
match links {
Some(l) => wb.defined_names = defined_names(names.pending, &names.sheets, l, limits, budget, warnings),
None => warnings.warn("XLSB: the workbook's sheet links or names could not be read; formulas keep their saved results"),
}
}
/// The workbook's defined names, as `.xlsx` has them in `definedNames`: every `BrtName` but the
/// hidden ones for newer functions and LET parameters, which Excel doesn't write there. `sheets`
/// maps a name's `itab` (its sheet's place in `BrtBundleSh` order) to [`Workbook::sheets`].
@@ -1216,6 +1237,18 @@ pub(crate) fn worksheet(
});
col = Some(c);
}
// BrtListPart: one of the sheet's tables, by relationship id.
661 => {
if data {
return Err(invalid("table part inside worksheet data"));
}
let rel = b.text(255)?;
b.finish()?;
if sheet.features.table_parts.len() >= MAX_TABLE_PARTS {
return Err(Error::TooLarge(format!("XLSB exceeds {MAX_TABLE_PARTS} tables on a sheet")));
}
sheet.features.table_parts.push(rel);
}
485 => {
if data_seen {
return Err(invalid("sheet format after worksheet data"));
@@ -1264,3 +1297,25 @@ pub(crate) fn worksheet(
}
Err(invalid("missing worksheet end record"))
}
#[cfg(test)]
mod records_merge_tests {
use super::*;
#[test]
fn table_skip_count_preserves_excel_2007_style_blocks() {
// BrtACBegin for Excel 2007, an empty record, BrtACEnd.
let bytes = [37, 6, 1, 0, 12, 0, 0, 0, 1, 0, 38, 0];
let limits = Limits::default();
let budget = Budget::default();
let mut warnings = Warnings::default();
let mut styles = Records::new(&bytes, &limits, &budget);
styles.excel_2007 = true;
assert_eq!(styles.next(&mut warnings).unwrap(), Some((1, &[][..])));
assert_eq!(styles.skipped, 0, "supported style content was read, not skipped");
assert!(styles.next(&mut warnings).unwrap().is_none());
let mut tables = Records::new(&bytes, &limits, &budget);
assert!(tables.next(&mut warnings).unwrap().is_none());
assert_eq!(tables.skipped, 1, "table filters still detect skipped alternate content");
}
}
+3
View File
@@ -125,6 +125,8 @@ pub(crate) enum Expr {
/// Spaces and line breaks typed before and after an expression (`PtgAttrSpace`), which
/// `.xlsx` formula text keeps.
Spaced(String, Box<Expr>, String),
/// A structured reference to a table, as written (`Sales[[#Headers],[Key]]`).
Structured(String),
Unary(UnOp, Box<Expr>),
Binary(BinOp, Box<Expr>, Box<Expr>),
Call(String, Vec<Expr>),
@@ -327,6 +329,7 @@ fn write_expr(s: &mut String, e: &Expr) {
}
None => s.push_str(n),
},
Expr::Structured(t) => s.push_str(t),
Expr::Unary(UnOp::Neg, x) => {
s.push('-');
write_expr(s, x);
+101 -3
View File
@@ -5,11 +5,13 @@
//! ([`super::ftab`]) and its own copies of craft-xls's depth guards and limits. Anything outside the
//! token set it knows is reported as unsupported, and the caller keeps the cell's cached value.
//! So is a formula that needs something the reader doesn't read: a defined name whose own
//! formula could not be read, or Python code stored outside the cell. Defined names' formulas
//! are decoded here too ([`Mode::Name`]).
//! formula could not be read, a table whose part could not be read, or Python code stored
//! outside the cell. Defined names' formulas are decoded here too ([`Mode::Name`]), and
//! structured references (`PtgList`) are spelled from the tables in [`Links`].
//!
//! Names keep their file spelling (`_xlfn.CONCAT`, `_xlpm.x`), as `.xlsx` formula text has them.
use std::collections::HashMap;
use std::sync::Arc;
use craft_sheet::{CellError, CellRef, MAX_COLS, MAX_ROWS};
@@ -169,6 +171,15 @@ pub(crate) struct Links {
pub(super) names: Vec<Name>,
pub(super) books: Vec<Book>,
pub(super) xti: Vec<Xti>,
/// Every table by its `idList`, which `PtgList` names: `None` for an id two tables share.
pub(super) tables: HashMap<u32, Option<ListInfo>>,
}
/// A table as structured references need it: its display name and its columns' names.
#[derive(Clone, Debug, PartialEq)]
pub(super) struct ListInfo {
pub name: String,
pub columns: Vec<String>,
}
/// Whether a name stands for a LET parameter (`_xlpm.x`), which only the formula itself defines.
@@ -587,7 +598,13 @@ pub(super) fn decode_using(rgce: &[u8], rgcb: &[u8], links: &Links, mode: Mode,
}
0x01 => return Err(Unsupported("the shared or array formula form")),
0x02 => return Err(Unsupported("what-if data tables")),
0x18 => return Err(Unsupported("structured table references")),
0x18 => {
if t.u8()? != 0x19 {
return Err(Unsupported("unknown formula token"));
}
let text = list(&mut t, links)?;
push(&mut stack, kids, Expr::Structured(text))?;
}
0x2C => {
if mode == Mode::Cell {
return Err(Unsupported("relative references in a cell formula"));
@@ -631,6 +648,87 @@ fn bare_function(name: String) -> String {
}
}
/// `PtgList` ([MS-XLSB] 2.5.98.52), after its two token bytes: a structured reference, spelled
/// as `.xlsx` has it (`Sales[Val]`, `Sales[[#Headers],[Key]]`, `Sales[[#This Row],[A]:[B]]`).
/// The two spacing flags put a space inside the outer brackets and after each comma, as Excel
/// shows the reference.
fn list(t: &mut Bytes<'_>, links: &Links) -> Result<String, Unsupported> {
let ixti = t.u16()?;
let bits = t.u16()?;
let index = t.u32()?;
let (first, last) = (usize::from(t.u16()?), usize::from(t.u16()?));
if bits & 0x3000 != 0 {
return Err(Unsupported("structured references to deleted tables or to tables in other workbooks"));
}
// The table's sheet link: a table is always in this workbook, on one of its sheets.
links.sheet_sel(ixti)?;
let table = links.tables.get(&index).and_then(Option::as_ref).ok_or(Unsupported("structured references to tables the reader could not read"))?;
let rows: &[&str] = match (bits >> 2) & 0x1F {
0x00 => &[],
0x01 => &["#All"],
0x02 => &["#Headers"],
0x04 => &["#Data"],
0x06 => &["#Headers", "#Data"],
0x08 => &["#Totals"],
0x0C => &["#Data", "#Totals"],
0x10 => &["#This Row"],
_ => return Err(Unsupported("unknown structured reference rows")),
};
let column = |i: usize| table.columns.get(i).map(|c| escape_column(c)).ok_or(Unsupported("structured reference to a missing table column"));
let columns = match bits & 3 {
0 => None,
1 => Some((column(first)?, None)),
2 if first <= last => Some((column(first)?, Some(column(last)?))),
_ => return Err(Unsupported("invalid structured reference columns")),
};
let pad = if bits & 0x80 != 0 { " " } else { "" };
let mut s = table.name.clone();
match (rows, &columns) {
([], None) => s.push_str("[]"),
([], Some((c, None))) => {
s.push('[');
s.push_str(pad);
s.push_str(c);
s.push_str(pad);
s.push(']');
}
([row], None) => {
s.push('[');
s.push_str(pad);
s.push_str(row);
s.push_str(pad);
s.push(']');
}
_ => {
let mut items: Vec<String> = rows.iter().map(|r| format!("[{r}]")).collect();
match &columns {
Some((a, Some(b))) => items.push(format!("[{a}]:[{b}]")),
Some((a, None)) => items.push(format!("[{a}]")),
None => {}
}
let comma = if bits & 0x100 != 0 { ", " } else { "," };
s.push('[');
s.push_str(pad);
s.push_str(&items.join(comma));
s.push_str(pad);
s.push(']');
}
}
Ok(s)
}
/// A column name in a structured reference: `'` escapes `[`, `]`, `#` and `'` (`It''s '['#1']`).
fn escape_column(name: &str) -> String {
let mut s = String::with_capacity(name.len());
for c in name.chars() {
if matches!(c, '[' | ']' | '#' | '\'') {
s.push('\'');
}
s.push(c);
}
s
}
/// Text written out in the formula: a string, or strings joined with `&` (how Python code
/// longer than a string constant is written).
fn literal_text(e: &Expr) -> bool {
+770
View File
@@ -0,0 +1,770 @@
//! Table parts ([MS-XLSB] 2.1.7.51, `tableN.bin`) into the [`Table`] a `.xlsx` table part reads
//! as. The table's AutoFilter and sort state are held as `.xlsx` elements, so they are built here
//! as Excel writes them. A filter column the reader can't spell is left out with a warning, as
//! is a sort state; the table keeps the rest.
use craft_sheet::{CellRef, MAX_COLS, MAX_ROWS, Range};
use craft_xml::El;
use super::formula::{self, ListInfo, Mode};
use super::{Budget, Bytes, Links, Records, expr, invalid};
use crate::features::{Table, TableColumn, TableStyleInfo};
use crate::{Error, Limits, Warnings};
/// The content type of a table part.
pub(crate) const TABLE: &str = "application/vnd.ms-excel.table";
/// `RfX` / `UncheckedRfX` ([MS-XLSB] 2.5.118, 2.5.154): first and last row, first and last column.
fn rfx(b: &mut Bytes<'_>) -> Result<Range, Error> {
let (r0, r1, c0, c1) = (b.u32()?, b.u32()?, b.u32()?, b.u32()?);
if r0 > r1 || c0 > c1 || r1 >= MAX_ROWS || c1 >= MAX_COLS {
return Err(invalid("invalid table range"));
}
Ok(Range::new(CellRef::new(r0, c0), CellRef::new(r1, c1)))
}
/// A `DXFId`, `None` for 0xFFFFFFFF (no differential format).
fn dxf(id: u32) -> Option<u32> {
(id != u32::MAX).then_some(id)
}
/// An `XLNullableWideString` of at most `max` characters, with the empty string as none: Excel
/// writes an empty comment where `.xlsx` has no attribute.
fn text(b: &mut Bytes<'_>, max: u32) -> Result<Option<String>, Error> {
Ok(b.string(max, true)?.filter(|s| !s.is_empty()))
}
/// What a table part holds of formulas, for the reader's index of tables: its id, display name
/// and column names.
fn list_info(bytes: &[u8], limits: &Limits, budget: &Budget) -> Result<(u32, ListInfo), Error> {
let t = table(bytes, None, limits, budget, &mut Warnings::default())?;
let id = t.id.ok_or_else(|| invalid("table without an id"))?;
let name = t.display_name.or(t.name).ok_or_else(|| invalid("table without a name"))?;
// A column without a name can't be spelled in a structured reference.
let columns = t
.columns
.into_iter()
.map(|c| c.name.filter(|n| !n.is_empty()))
.collect::<Option<_>>()
.ok_or_else(|| invalid("table column without a name"))?;
Ok((id, ListInfo { name, columns }))
}
/// Adds a table part to `links`, so formulas can name it. Two tables with one id name neither.
pub(crate) fn index_table(links: &mut Links, bytes: &[u8], limits: &Limits, budget: &Budget) -> Result<(), Error> {
let (id, info) = list_info(bytes, limits, budget)?;
links.tables.entry(id).and_modify(|t| *t = None).or_insert(Some(info));
Ok(())
}
/// A table part. `links` decodes its calculated-column and totals-row formulas; without them
/// (or when one can't be decoded) a formula is left out, with a warning.
pub(crate) fn table(bytes: &[u8], links: Option<&Links>, limits: &Limits, budget: &Budget, warnings: &mut Warnings) -> Result<Table, Error> {
let mut records = Records::new(bytes, limits, budget);
let mut table = match records.next(warnings)? {
Some((343, payload)) => begin_list(payload)?,
_ => return Err(invalid("missing table begin record")),
};
let mut cols_open = false;
let mut cols_seen = false;
let mut column: Option<TableColumn> = None;
while let Some((id, payload)) = records.next(warnings)? {
let mut b = Bytes::new(payload);
match id {
161 if !cols_seen && table.auto_filter.is_none() => {
let range = rfx(&mut b)?;
b.finish()?;
table.auto_filter = Some(auto_filter(range, &mut records, warnings)?);
}
530 if !cols_seen && table.sort_state.is_none() => table.sort_state = sort_state(payload, &mut records, warnings)?,
345 if !cols_seen => {
b.u32()?;
b.finish()?;
cols_open = true;
cols_seen = true;
}
346 if cols_open && column.is_none() => {
b.finish()?;
cols_open = false;
}
347 if cols_open && column.is_none() => {
if table.columns.len() >= MAX_COLS as usize {
return Err(invalid("too many table columns"));
}
column = Some(begin_list_col(payload)?);
}
351 | 352 if column.is_some() => {
let f = list_formula(payload, links, limits, budget, warnings)?;
if let Some(c) = column.as_mut() {
*(if id == 351 { &mut c.calculated_formula } else { &mut c.totals_row_formula }) = f;
}
}
348 => {
b.finish()?;
table.columns.push(column.take().ok_or_else(|| invalid("table column end without a column"))?);
}
349 => {
let c = column.as_mut().ok_or_else(|| invalid("XML column properties outside a table column"))?;
c.other.push(xml_column(payload)?);
}
513 if !cols_open && cols_seen => {
let flags = b.u16()?;
let name = b.string(255, true)?;
b.finish()?;
let bit = |n: u16| Some(flags & (1 << n) != 0);
table.style = Some(TableStyleInfo {
name,
show_first_column: bit(0),
show_last_column: bit(1),
show_row_stripes: bit(2),
show_column_stripes: bit(3),
..TableStyleInfo::default()
});
}
344 => {
if cols_open || !cols_seen || column.is_some() {
return Err(invalid("incomplete table"));
}
records.end(payload, warnings)?;
return Ok(table);
}
// The end of an XML map's column; anything else out of place is damage.
350 => b.finish()?,
_ => return Err(invalid(format!("unexpected record {id} in a table"))),
}
}
Err(invalid("missing table end record"))
}
/// `BrtBeginList` ([MS-XLSB] 2.4.100). `.xlsx` leaves out what is the default: one header row,
/// no totals row, a totals row that has been shown, a worksheet table.
fn begin_list(payload: &[u8]) -> Result<Table, Error> {
let mut b = Bytes::new(payload);
let range = rfx(&mut b)?;
let table_type = match b.u32()? {
0 => None,
2 => Some("xml".to_string()),
3 => Some("queryTable".to_string()),
_ => return Err(invalid("invalid table type")),
};
let id = b.u32()?;
if id == 0 || id == u32::MAX {
return Err(invalid("invalid table id"));
}
let header = b.u32()?;
let totals = b.u32()?;
let flags = b.u32()?;
// fSingleCell: a single-cell table belongs in its own part type, not here.
if flags & 2 != 0 {
return Err(invalid("single-cell table in a table part"));
}
let dxfs: Vec<Option<u32>> = (0..6).map(|_| b.u32().map(dxf)).collect::<Result<_, _>>()?;
let connection = b.u32()?;
let name = b.string(255, true)?;
let display_name = b.string(255, true)?;
let comment = text(&mut b, 255)?;
let header_row_cell_style = b.string(255, true)?;
let data_cell_style = b.string(255, true)?;
let totals_row_cell_style = b.string(255, true)?;
b.finish()?;
let set = |bit: u32| (flags & bit != 0).then_some(true);
Ok(Table {
id: Some(id),
name,
display_name,
comment,
table_type,
header_row_count: (header != 1).then_some(header),
insert_row: set(4),
insert_row_shift: set(8),
totals_row_count: (totals != 0).then_some(totals),
totals_row_shown: (flags & 1 == 0).then_some(false),
published: set(16),
header_row_dxf_id: dxfs[0],
data_dxf_id: dxfs[1],
totals_row_dxf_id: dxfs[2],
table_border_dxf_id: dxfs[3],
header_row_border_dxf_id: dxfs[4],
totals_row_border_dxf_id: dxfs[5],
header_row_cell_style,
data_cell_style,
totals_row_cell_style,
connection_id: (connection != 0).then_some(connection),
range,
..Table::default()
})
}
/// `BrtBeginListCol` ([MS-XLSB] 2.4.101): `stName` is `.xlsx`'s `uniqueName`, `stCaption` its
/// `name`, and the insert row's format and style are the data's.
fn begin_list_col(payload: &[u8]) -> Result<TableColumn, Error> {
let mut b = Bytes::new(payload);
let id = b.u32()?;
let function = match b.u32()? {
0 => None,
1 => Some("average"),
2 => Some("count"),
3 => Some("countNums"),
4 => Some("max"),
5 => Some("min"),
6 => Some("sum"),
7 => Some("stdDev"),
8 => Some("var"),
9 => Some("custom"),
_ => return Err(invalid("invalid totals row function")),
};
let header_row_dxf_id = dxf(b.u32()?);
let data_dxf_id = dxf(b.u32()?);
let totals_row_dxf_id = dxf(b.u32()?);
let query = b.u32()?;
let unique_name = b.string(255, true)?;
let name = b.string(255, true)?;
let totals_row_label = b.string(8189, true)?;
let header_row_cell_style = b.string(255, true)?;
let data_cell_style = b.string(255, true)?;
let totals_row_cell_style = b.string(255, true)?;
b.finish()?;
Ok(TableColumn {
id: Some(id),
unique_name,
name,
totals_row_function: function.map(str::to_string),
totals_row_label,
query_table_field_id: (query != 0).then_some(query),
header_row_dxf_id,
data_dxf_id,
totals_row_dxf_id,
header_row_cell_style,
data_cell_style,
totals_row_cell_style,
..TableColumn::default()
})
}
/// `XmlDataType` ([MS-XLSB] 2.5.170) from 1, as `.xlsx` names the XML Schema types.
const XML_TYPES: [&str; 45] = [
"string",
"normalizedString",
"token",
"byte",
"unsignedByte",
"base64Binary",
"hexBinary",
"integer",
"positiveInteger",
"negativeInteger",
"nonPositiveInteger",
"nonNegativeInteger",
"int",
"unsignedInt",
"long",
"unsignedLong",
"short",
"unsignedShort",
"decimal",
"float",
"double",
"boolean",
"time",
"dateTime",
"duration",
"date",
"gMonth",
"gYear",
"gYearMonth",
"gDay",
"gMonthDay",
"Name",
"QName",
"NCName",
"anyURI",
"language",
"ID",
"IDREF",
"IDREFS",
"ENTITY",
"ENTITIES",
"NOTATION",
"NMTOKEN",
"NMTOKENS",
"anyType",
];
/// `BrtBeginListXmlCPr` ([MS-XLSB] 2.4.104): a column's place in an XML map, as `xmlColumnPr`.
/// `fCanBeSingle` (one node for every row) is `.xlsx`'s `denormalized`.
fn xml_column(payload: &[u8]) -> Result<El, Error> {
let mut b = Bytes::new(payload);
let map = b.u32()?;
let flags = b.u32()?;
let kind = b.u32()?;
let xpath = b.text(31_999)?;
b.finish()?;
let kind = kind.checked_sub(1).and_then(|k| XML_TYPES.get(k as usize)).ok_or_else(|| invalid("invalid XML data type"))?;
let mut el = El::new("xmlColumnPr").with_attr("mapId", map).with_attr("xpath", xpath);
if flags & 2 != 0 {
el.set_attr("denormalized", 1);
}
el.set_attr("xmlDataType", kind);
Ok(el)
}
/// `BrtListCCFmla` / `BrtListTrFmla` ([MS-XLSB] 2.4.706, 2.4.708): a flag byte (`fArray`, bit 1)
/// and a `ListParsedFormula`. Its references hold coordinates, as a cell formula's do.
fn list_formula(
payload: &[u8],
links: Option<&Links>,
limits: &Limits,
budget: &Budget,
warnings: &mut Warnings,
) -> Result<Option<(String, bool)>, Error> {
let mut b = Bytes::new(payload);
let array = b.u8()? & 2 != 0;
let cce = b.u32()?;
if !(1..=16384).contains(&cce) {
return Err(invalid("invalid formula token length"));
}
let rgce = b.take(cce as usize)?;
let cb = b.u32()?;
let rgcb = b.take(cb as usize)?;
b.finish()?;
let Some(links) = links else { return Ok(None) };
let text = match formula::decode(rgce, rgcb, links, Mode::Cell) {
Ok(e) => expr::print(&e),
Err(formula::Unsupported(why)) => {
warnings.warn(format!("XLSB: some table column formulas were left out ({why})"));
return Ok(None);
}
};
if !budget.try_formula_text(text.len(), limits) {
warnings.warn("XLSB: some table column formulas were left out (more formula text than the limits allow)");
return Ok(None);
}
Ok(Some((text, array)))
}
/// A number in a filter, as Excel writes it in `.xlsx`, which differs from a formula's: 17
/// significant digits (`1234.5678901234501`, `1.0000000000000001E-5`), written out from 0.01 up to
/// 10^16 unless that takes more than 17 decimals, and otherwise with an exponent of no fixed
/// width (`1E-4`, `1E+20`). Excel writes a few values with fewer digits (`0.1`, not
/// `0.10000000000000001`); both read back as the same number.
fn filter_number(n: f64) -> String {
if n == 0.0 || !n.is_finite() {
return "0".into();
}
let sci = format!("{:.16e}", n.abs());
let Some((mantissa, exp)) = sci.split_once('e') else { return sci };
let e: i32 = exp.parse().unwrap_or(0);
let digits = mantissa.replace('.', "");
let digits = digits.trim_end_matches('0');
let digits = if digits.is_empty() { "0" } else { digits };
let decimals = i32::try_from(digits.len()).unwrap_or(i32::MAX).saturating_sub(1).saturating_sub(e);
let mut s = String::from(if n < 0.0 { "-" } else { "" });
if !(-2..=15).contains(&e) || decimals > 17 {
s.push_str(&digits[..1]);
if digits.len() > 1 {
s.push('.');
s.push_str(&digits[1..]);
}
s.push_str(&format!("E{}{}", if e < 0 { '-' } else { '+' }, e.unsigned_abs()));
} else if e >= 0 {
let whole = e as usize + 1;
if digits.len() <= whole {
s.push_str(digits);
s.push_str(&"0".repeat(whole - digits.len()));
} else {
s.push_str(&digits[..whole]);
s.push('.');
s.push_str(&digits[whole..]);
}
} else {
s.push_str("0.");
s.push_str(&"0".repeat((-e - 1) as usize));
s.push_str(digits);
}
s
}
/// Warns that a table's filter column was left out, and why.
fn left_out(warnings: &mut Warnings, why: &str) {
warnings.warn(format!("XLSB: some table filters were left out ({why})"));
}
/// The records after `BrtBeginAFilter` ([MS-XLSB] 2.4.8) up to `BrtEndAFilter`, as `autoFilter`.
fn auto_filter(range: Range, records: &mut Records<'_, '_>, warnings: &mut Warnings) -> Result<El, Error> {
let mut el = El::new("autoFilter").with_attr("ref", range.a1());
while let Some((id, payload)) = records.next(warnings)? {
match id {
163 => {
if let Some(c) = filter_column(payload, records, warnings)? {
el.push(c);
}
}
162 => {
Bytes::new(payload).finish()?;
return Ok(el);
}
_ => return Err(invalid(format!("unexpected record {id} in a table filter"))),
}
}
Err(invalid("missing table filter end record"))
}
/// A `BrtBeginFilterColumn` ([MS-XLSB] 2.4.84) and its criteria, up to `BrtEndFilterColumn`, as
/// `filterColumn`. `None` when its criteria can't be spelled as `.xlsx` has them, or are kept
/// in an extension the reader skips (Excel's date-group filters).
fn filter_column(payload: &[u8], records: &mut Records<'_, '_>, warnings: &mut Warnings) -> Result<Option<El>, Error> {
let mut b = Bytes::new(payload);
let col = b.u32()?;
let flags = b.u16()?;
b.finish()?;
let mut el = El::new("filterColumn").with_attr("colId", col);
if flags & 1 != 0 {
el.set_attr("hiddenButton", 1);
}
if flags & 2 != 0 {
el.set_attr("showButton", 0);
}
let skipped = records.skipped;
let mut keep = true;
while let Some((id, payload)) = records.next(warnings)? {
let mut b = Bytes::new(payload);
match id {
165 => {
let blank = b.u32()?;
b.u32()?;
b.finish()?;
let mut filters = El::new("filters");
if blank == 1 {
filters.set_attr("blank", 1);
}
loop {
let (id, payload) = records.next(warnings)?.ok_or_else(|| invalid("missing filter list end record"))?;
let mut b = Bytes::new(payload);
match id {
167 => {
let val = b.text(255)?;
b.finish()?;
filters.push(El::new("filter").with_attr("val", val));
}
175 => filters.push(date_group_item(payload)?),
166 => {
b.finish()?;
break;
}
_ => return Err(invalid(format!("unexpected record {id} in a filter list"))),
}
}
el.push(filters);
}
172 => {
let and = b.u32()?;
b.finish()?;
// Excel writes 1 where `.xlsx` has `and="1"` ([MS-XLSB]'s table has them the other way round).
let mut custom = El::new("customFilters");
if and == 1 {
custom.set_attr("and", 1);
}
loop {
let (id, payload) = records.next(warnings)?.ok_or_else(|| invalid("missing custom filter end record"))?;
match id {
174 => match custom_filter(payload)? {
Some(f) => custom.push(f),
None => {
left_out(warnings, "custom filters on a Boolean value");
keep = false;
}
},
173 => {
Bytes::new(payload).finish()?;
break;
}
_ => return Err(invalid(format!("unexpected record {id} in custom filters"))),
}
}
el.push(custom);
}
170 => {
let flags = b.u8()?;
let val = b.f64()?;
let filter_val = b.f64()?;
b.finish()?;
let mut top = El::new("top10");
if flags & 1 == 0 {
top.set_attr("top", 0);
}
if flags & 2 != 0 {
top.set_attr("percent", 1);
}
top.set_attr("val", filter_number(val));
if flags & 4 != 0 {
top.set_attr("filterVal", filter_number(filter_val));
}
el.push(top);
}
171 => el.push(dynamic_filter(payload)?),
168 => {
let dxf_id = b.u32()?;
let cell = b.u32()?;
b.finish()?;
let mut color = El::new("colorFilter").with_attr("dxfId", dxf_id);
if cell == 0 {
color.set_attr("cellColor", 0);
}
el.push(color);
}
169 => {
let set = b.u32()?;
let icon = b.u32()?;
b.finish()?;
// KPINIL: no filter.
if set != u32::MAX {
let name = ICON_SETS.get(set as usize).ok_or_else(|| invalid("invalid filter icon set"))?;
el.push(El::new("iconFilter").with_attr("iconSet", name).with_attr("iconId", icon));
}
}
164 => {
b.finish()?;
if records.skipped != skipped {
left_out(warnings, "filters kept in extensions the reader skips, such as date groups");
return Ok(None);
}
return Ok(keep.then_some(el));
}
_ => return Err(invalid(format!("unexpected record {id} in a filter column"))),
}
}
Err(invalid("missing filter column end record"))
}
/// `KPISets` ([MS-XLSB] 2.5.86), as `.xlsx` names them.
const ICON_SETS: [&str; 17] = [
"3Arrows",
"3ArrowsGray",
"3Flags",
"3TrafficLights1",
"3TrafficLights2",
"3Signs",
"3Symbols",
"3Symbols2",
"4Arrows",
"4ArrowsGray",
"4RedToBlack",
"4Rating",
"4TrafficLights",
"5Arrows",
"5ArrowsGray",
"5Rating",
"5Quarters",
];
/// `BrtCustomFilter` ([MS-XLSB] 2.4.348) as `customFilter`; `None` for a Boolean value, whose
/// `.xlsx` spelling no Excel file has shown. A blank or non-blank test is `val=" "`, as Excel
/// writes it.
fn custom_filter(payload: &[u8]) -> Result<Option<El>, Error> {
let mut b = Bytes::new(payload);
let vts = b.u8()?;
let operator = match b.u8()? {
1 => Some("lessThan"),
2 => None,
3 => Some("lessThanOrEqual"),
4 => Some("greaterThan"),
5 => Some("notEqual"),
6 => Some("greaterThanOrEqual"),
_ => return Err(invalid("invalid custom filter operator")),
};
let union = b.take(8)?;
let val = match vts {
4 => {
let n = f64::from_le_bytes(union.try_into().map_err(|_| invalid("truncated number"))?);
if !n.is_finite() {
return Err(invalid("nonfinite numeric value"));
}
filter_number(n)
}
6 => b.text(255)?,
8 => return Ok(None),
0x0C | 0x0E => " ".to_string(),
_ => return Err(invalid("invalid custom filter type")),
};
b.finish()?;
let mut el = El::new("customFilter");
if let Some(op) = operator {
el.set_attr("operator", op);
}
el.set_attr("val", val);
Ok(Some(el))
}
/// `BrtDynamicFilter` ([MS-XLSB] 2.4.362) as `dynamicFilter`: the computed values only once the
/// filter has been applied, and the maximum only for date periods.
fn dynamic_filter(payload: &[u8]) -> Result<El, Error> {
let mut b = Bytes::new(payload);
let cft = b.u32()?;
let applied = b.u8()? & 1 != 0;
let val = b.f64()?;
let max = b.f64()?;
b.finish()?;
const PERIODS: [&str; 16] = [
"tomorrow",
"today",
"yesterday",
"nextWeek",
"thisWeek",
"lastWeek",
"nextMonth",
"thisMonth",
"lastMonth",
"nextQuarter",
"thisQuarter",
"lastQuarter",
"nextYear",
"thisYear",
"lastYear",
"yearToDate",
];
let kind = match cft {
0 => "null".to_string(),
1 => "aboveAverage".to_string(),
2 => "belowAverage".to_string(),
8..=0x17 => PERIODS[(cft - 8) as usize].to_string(),
0x18..=0x1B => format!("Q{}", cft - 0x17),
0x1C..=0x27 => format!("M{}", cft - 0x1B),
_ => return Err(invalid("invalid dynamic filter type")),
};
let mut el = El::new("dynamicFilter").with_attr("type", kind);
if applied && (1..=0x17).contains(&cft) {
el.set_attr("val", filter_number(val));
if cft >= 8 {
el.set_attr("maxVal", filter_number(max));
}
}
Ok(el)
}
/// `BrtAFilterDateGroupItem` ([MS-XLSB] 2.4.5) as `dateGroupItem`, with the parts of the date
/// its grouping compares.
fn date_group_item(payload: &[u8]) -> Result<El, Error> {
let mut b = Bytes::new(payload);
let year = b.u16()?;
let month = b.u16()?;
let day = b.u32()?;
let (hour, minute, second) = (b.u16()?, b.u16()?, b.u16()?);
b.take(6)?;
let grouping = b.u32()?;
b.finish()?;
const GROUPS: [&str; 6] = ["year", "month", "day", "hour", "minute", "second"];
let name = GROUPS.get(grouping as usize).ok_or_else(|| invalid("invalid date group"))?;
let mut el = El::new("dateGroupItem").with_attr("year", year);
let parts = [("month", u32::from(month)), ("day", day), ("hour", u32::from(hour)), ("minute", u32::from(minute)), ("second", u32::from(second))];
for (name, value) in parts.iter().take(grouping as usize) {
el.set_attr(name, value);
}
el.set_attr("dateTimeGrouping", name);
Ok(el)
}
/// `BrtBeginSortState` ([MS-XLSB] 2.4.227) and its `BrtBeginSortCond`s, up to `BrtEndSortState`,
/// as `sortState`. `None`, with a warning, for a sort by another method than character order,
/// which `.xlsx` names (stroke or PinYin) and the record does not.
fn sort_state(payload: &[u8], records: &mut Records<'_, '_>, warnings: &mut Warnings) -> Result<Option<El>, Error> {
let mut b = Bytes::new(payload);
let flags = b.u16()?;
let range = rfx(&mut b)?;
b.finish()?;
let mut el = El::new("sortState");
if flags & 1 != 0 {
el.set_attr("columnSort", 1);
}
if flags & 2 != 0 {
el.set_attr("caseSensitive", 1);
}
el.set_attr("ref", range.a1());
let keep = flags & 4 == 0;
if !keep {
warnings.warn("XLSB: some table sort states were left out (sorts by stroke or PinYin order)");
}
while let Some((id, payload)) = records.next(warnings)? {
let mut b = Bytes::new(payload);
match id {
532 => {
let flags = b.u16()?;
let range = rfx(&mut b)?;
let (first, second) = (b.u32()?, b.u32()?);
let list = b.string(32_767, true)?;
b.finish()?;
let mut cond = El::new("sortCondition");
if flags & 1 != 0 {
cond.set_attr("descending", 1);
}
let on = (flags >> 1) & 0xF;
match on {
0 => {}
1 => cond.set_attr("sortBy", "cellColor"),
2 => cond.set_attr("sortBy", "fontColor"),
3 => cond.set_attr("sortBy", "icon"),
_ => return Err(invalid("invalid sort condition")),
}
cond.set_attr("ref", range.a1());
match on {
0 => {
if let Some(list) = list {
cond.set_attr("customList", list);
}
}
1 | 2 => cond.set_attr("dxfId", first),
_ => {
let name = ICON_SETS.get(first as usize).ok_or_else(|| invalid("invalid sort icon set"))?;
cond.set_attr("iconSet", name);
cond.set_attr("iconId", second);
}
}
el.push(cond);
}
533 => b.finish()?,
531 => {
b.finish()?;
return Ok(keep.then_some(el));
}
_ => return Err(invalid(format!("unexpected record {id} in a sort state"))),
}
}
Err(invalid("missing sort state end record"))
}
#[cfg(test)]
mod tests {
use super::filter_number;
#[test]
fn filter_numbers_are_spelled_as_excel_writes_them() {
// Excel's `.xlsx` text for each value.
let cases = [
(20.0, "20"),
(23.25, "23.25"),
(46340.0, "46340"),
(-1.5, "-1.5"),
(1e15, "1000000000000000"),
(999_999_999_999_999.0, "999999999999999"),
(1.234_567_890_123_45e17, "1.2345678901234499E+17"),
(1e16, "1E+16"),
(-1e16, "-1E+16"),
(1e20, "1E+20"),
(2.5e300, "2.5000000000000001E+300"),
(1_234.567_890_123_45, "1234.5678901234501"),
(12_345_678_901_234.5, "12345678901234.5"),
(99_999_999_999_999.9, "99999999999999.906"),
(1.1, "1.1000000000000001"),
(0.57, "0.56999999999999995"),
(0.01, "0.01"),
(0.035, "3.5000000000000003E-2"),
(0.001, "1E-3"),
(1e-4, "1E-4"),
(1e-5, "1.0000000000000001E-5"),
(1.5e-10, "1.5E-10"),
(1e-19, "9.9999999999999998E-20"),
];
for (n, want) in cases {
assert_eq!(filter_number(n), want, "{n}");
}
}
}
+321 -2
View File
@@ -7,7 +7,7 @@ use common::{read, read_with};
use craft_xlsx::testing::zip;
use craft_xlsx::{
CellError, CellRef, Color, ColorSource, Error, Fill, FormulaKind, Limits, Package, Pattern, PatternFill, Protection, Range, Row, SheetKind,
SheetPart, Styles, Value, Visibility, is_xlsb,
SheetPart, Styles, Table, Value, Visibility, is_xlsb,
};
const ROOT: &str = r#"<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="book" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="records/book.bin"/></Relationships>"#;
@@ -590,7 +590,7 @@ fn cell_formulas_are_read_in_their_xlsx_spelling() {
assert_eq!(sheet.cell_metadata.iter().collect::<Vec<_>>(), [(&CellRef::new(0, 14), &1)]);
// Every formula cell keeps its saved result as its value.
assert!((1..=15).all(|c| sheet.value(CellRef::new(0, c)) == Value::Number(0.0)));
for why in ["other workbooks", "missing from the file", "structured table references"] {
for why in ["other workbooks", "missing from the file", "tables the reader could not read"] {
assert!(warned(&wb, why), "{why}: {:?}", wb.warnings);
}
}
@@ -1616,6 +1616,325 @@ fn references_to_macro_sheets_and_spans_over_chart_sheets_are_named() {
assert!(warned(&wb, "references to sheets with no cells"), "{:?}", wb.warnings);
}
// Tables ([MS-XLSB] 2.1.7.51): table parts assembled from the specification's records, and the
// `<table>` Excel writes for the same table in `.xlsx`.
fn rfx(r0: u32, r1: u32, c0: u32, c1: u32) -> Vec<u8> {
[r0, r1, c0, c1].iter().flat_map(|n| n.to_le_bytes()).collect()
}
/// `BrtBeginList`: a worksheet table with no formats or cell styles, its name as its display name.
fn begin_list(range: &[u8], id: u32, header: u32, totals: u32, flags: u32, name: &str) -> Vec<u8> {
begin_list_of(0, range, id, header, totals, flags, name)
}
/// `BrtBeginList` of a table type (`lt`): 0 a worksheet table, 2 an XML table.
fn begin_list_of(lt: u32, range: &[u8], id: u32, header: u32, totals: u32, flags: u32, name: &str) -> Vec<u8> {
let mut data = range.to_vec();
for n in [lt, id, header, totals, flags] {
data.extend(n.to_le_bytes());
}
data.extend(u32::MAX.to_le_bytes().repeat(6));
data.extend(0u32.to_le_bytes());
data.extend([wide(name), wide(name), wide("")].concat());
data.extend(u32::MAX.to_le_bytes().repeat(3));
record(343, &data)
}
/// `BrtBeginListCol` with its totals function (`ilta`), data format and totals label.
fn list_col(id: u32, ilta: u32, data_dxf: u32, name: &str, total: Option<&str>) -> Vec<u8> {
let mut data: Vec<u8> = [id, ilta, u32::MAX, data_dxf, u32::MAX, 0, u32::MAX].iter().flat_map(|n| n.to_le_bytes()).collect();
data.extend(wide(name));
data.extend(total.map_or_else(|| u32::MAX.to_le_bytes().to_vec(), wide));
data.extend(u32::MAX.to_le_bytes().repeat(3));
record(347, &data)
}
/// `BrtListCCFmla` (351) or `BrtListTrFmla` (352).
fn list_formula(id: u16, rgce: &[u8]) -> Vec<u8> {
record(id, &[&[0u8][..], &(rgce.len() as u32).to_le_bytes(), rgce, &0u32.to_le_bytes()].concat())
}
/// `PtgList`: the flags hold the columns (bits 0-1), the rows (2-6) and the two spacing bits.
fn ptg_list(ixti: u16, flags: u16, list: u32, first: u16, last: u16) -> Vec<u8> {
[&[0x18u8, 0x19][..], &ixti.to_le_bytes(), &flags.to_le_bytes(), &list.to_le_bytes(), &first.to_le_bytes(), &last.to_le_bytes()].concat()
}
fn filter_column(col: u32, flags: u16, criteria: &[Vec<u8>]) -> Vec<u8> {
[record(163, &[&col.to_le_bytes()[..], &flags.to_le_bytes()].concat()), criteria.concat(), record(164, &[])].concat()
}
fn custom_filter(vts: u8, op: u8, union: [u8; 8], text: Option<&str>) -> Vec<u8> {
record(174, &[&[vts, op][..], &union, &text.map(wide).unwrap_or_default()].concat())
}
fn table_style(flags: u16, name: &str) -> Vec<u8> {
record(513, &[&flags.to_le_bytes()[..], &wide(name)].concat())
}
/// The rows of a `PtgList` (bits 2-6).
const fn rows(t: u16) -> u16 {
t << 2
}
/// The filters of Sales: a value list with blanks, two custom criteria (OR), a bottom-percent
/// filter applied with its button hidden, and "today" applied.
fn sales_filters() -> Vec<Vec<u8>> {
vec![
filter_column(0, 0, &[record(165, &[1, 0, 0, 0, 0, 0, 0, 0]), record(167, &wide("k3")), record(167, &wide("k4")), record(166, &[])]),
filter_column(
1,
0,
&[
record(172, &0u32.to_le_bytes()),
custom_filter(4, 1, 20f64.to_le_bytes(), None),
custom_filter(6, 2, [0; 8], Some("k*")),
record(173, &[]),
],
),
filter_column(2, 1, &[record(170, &[&[0b110u8][..], &10f64.to_le_bytes(), &23.25f64.to_le_bytes()].concat())]),
filter_column(3, 0, &[record(171, &[&9u32.to_le_bytes()[..], &[1], &46340f64.to_le_bytes(), &46341f64.to_le_bytes()].concat())]),
]
}
/// Sales (B2:E8, id 1) with a totals row, a calculated column, a column name needing escapes,
/// `filters` and a sort.
fn sales(filters: &[Vec<u8>]) -> Vec<u8> {
[
begin_list(&rfx(1, 7, 1, 4), 1, 1, 1, 1, "Sales"),
record(161, &rfx(1, 6, 1, 4)),
filters.concat(),
record(162, &[]),
record(530, &[&0u16.to_le_bytes()[..], &rfx(2, 6, 1, 4)].concat()),
record(532, &[&1u16.to_le_bytes()[..], &rfx(1, 7, 1, 1), &[0; 8], &u32::MAX.to_le_bytes()].concat()),
record(533, &[]),
record(531, &[]),
record(345, &4u32.to_le_bytes()),
list_col(1, 0, u32::MAX, "Key", Some("Total")),
record(348, &[]),
list_col(2, 6, u32::MAX, "Val", None),
record(348, &[]),
list_col(3, 0, 2, "It's [#1]", None),
record(348, &[]),
list_col(4, 9, u32::MAX, "Calc", None),
list_formula(351, &[ptg_list(0, 1 | rows(0x10), 1, 1, 1), vec![0x1E, 2, 0, 0x05]].concat()),
list_formula(352, &[ptg_list(0, 1, 1, 3, 3), vec![0x42, 1, 7, 0]].concat()),
record(348, &[]),
record(346, &[]),
table_style(0b101, "TableStyleMedium9"),
record(344, &[]),
]
.concat()
}
/// NoHead (H10:I11, id 2): no header row, a totals row never shown, no stripes.
fn no_head() -> Vec<u8> {
[
begin_list(&rfx(9, 10, 7, 8), 2, 0, 0, 0, "NoHead"),
record(345, &2u32.to_le_bytes()),
list_col(1, 0, u32::MAX, "Column1", None),
record(348, &[]),
list_col(2, 0, u32::MAX, "Column2", None),
record(348, &[]),
record(346, &[]),
table_style(0, "TableStyleMedium2"),
record(344, &[]),
]
.concat()
}
/// XmlT (K1:L2, id 3): an XML table, its columns mapped to an XML map's elements.
fn xml_table_part() -> Vec<u8> {
let col = |id: u32, name: &str, kind: u32, xpath: &str| {
let mut data: Vec<u8> = [id, 0, u32::MAX, u32::MAX, u32::MAX, 0].iter().flat_map(|n| n.to_le_bytes()).collect();
data.extend([wide(name), wide(name)].concat());
data.extend(u32::MAX.to_le_bytes().repeat(4));
let map = [&1u32.to_le_bytes()[..], &(if id == 2 { 2u32 } else { 0 }).to_le_bytes(), &kind.to_le_bytes(), &wide(xpath)].concat();
[record(347, &data), record(349, &map), record(350, &[]), record(348, &[])].concat()
};
[
begin_list_of(2, &rfx(0, 1, 10, 11), 3, 1, 0, 0, "XmlT"),
record(345, &2u32.to_le_bytes()),
col(1, "a", 0x0D, "/rows/r/a"),
col(2, "b", 0x01, "/rows/@b"),
record(346, &[]),
table_style(0b100, "TableStyleMedium2"),
record(344, &[]),
]
.concat()
}
const XML_TABLE_XML: &str = r#"<table xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" id="3" name="XmlT" displayName="XmlT" ref="K1:L2" tableType="xml" totalsRowShown="0"><tableColumns count="2"><tableColumn id="1" uniqueName="a" name="a"><xmlColumnPr mapId="1" xpath="/rows/r/a" xmlDataType="int"/></tableColumn><tableColumn id="2" uniqueName="b" name="b"><xmlColumnPr mapId="1" xpath="/rows/@b" denormalized="1" xmlDataType="string"/></tableColumn></tableColumns><tableStyleInfo name="TableStyleMedium2" showFirstColumn="0" showLastColumn="0" showRowStripes="1" showColumnStripes="0"/></table>"#;
const SALES_XML: &str = r#"<table xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" id="1" name="Sales" displayName="Sales" ref="B2:E8" totalsRowCount="1"><autoFilter ref="B2:E7"><filterColumn colId="0"><filters blank="1"><filter val="k3"/><filter val="k4"/></filters></filterColumn><filterColumn colId="1"><customFilters><customFilter operator="lessThan" val="20"/><customFilter val="k*"/></customFilters></filterColumn><filterColumn colId="2" hiddenButton="1"><top10 top="0" percent="1" val="10" filterVal="23.25"/></filterColumn><filterColumn colId="3"><dynamicFilter type="today" val="46340" maxVal="46341"/></filterColumn></autoFilter><sortState ref="B3:E7"><sortCondition descending="1" ref="B2:B8"/></sortState><tableColumns count="4"><tableColumn id="1" name="Key" totalsRowLabel="Total"/><tableColumn id="2" name="Val" totalsRowFunction="sum"/><tableColumn id="3" name="It's [#1]" dataDxfId="2"/><tableColumn id="4" name="Calc" totalsRowFunction="custom"><calculatedColumnFormula>Sales[[#This Row],[Val]]*2</calculatedColumnFormula><totalsRowFormula>MAX(Sales[Calc])</totalsRowFormula></tableColumn></tableColumns><tableStyleInfo name="TableStyleMedium9" showFirstColumn="1" showLastColumn="0" showRowStripes="1" showColumnStripes="0"/></table>"#;
const NO_HEAD_XML: &str = r#"<table xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" id="2" name="NoHead" displayName="NoHead" ref="H10:I11" headerRowCount="0" totalsRowShown="0"><tableColumns count="2"><tableColumn id="1" name="Column1"/><tableColumn id="2" name="Column2"/></tableColumns><tableStyleInfo name="TableStyleMedium2" showFirstColumn="0" showLastColumn="0" showRowStripes="0" showColumnStripes="0"/></table>"#;
fn xml_table(xml: &str) -> Table {
let root = craft_xml::Options::canonical(&craft_xlsx::ns::CANONICAL).parse(xml.as_bytes()).unwrap();
Table::read(&root).unwrap()
}
/// `book_with_links(&xti())` whose sheet one lists `tables` (`BrtListPart`, relationship ids
/// t1, t2, ...) after `data`.
fn book_with_tables(data: &[u8], tables: &[Vec<u8>]) -> Vec<u8> {
let mut list = vec![record(660, &(tables.len() as u32).to_le_bytes())];
let mut rels = String::from(r#"<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">"#);
let mut types = TYPES.trim_end_matches("</Types>").to_string();
for i in 1..=tables.len() {
list.push(record(661, &wide(&format!("t{i}"))));
rels.push_str(&format!(r#"<Relationship Id="t{i}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/table" Target="../tables/t{i}.bin"/>"#));
types.push_str(&format!(r#"<Override PartName="/tables/t{i}.bin" ContentType="application/vnd.ms-excel.table"/>"#));
}
list.push(record(662, &[]));
rels.push_str("</Relationships>");
types.push_str("</Types>");
let names: Vec<String> = (1..=tables.len()).map(|i| format!("tables/t{i}.bin")).collect();
let (book, one, two, strings) = (book_with_links(&xti()), worksheet(data, &list.concat()), worksheet(&[], &[]), sst());
let mut entries: Vec<(&str, &[u8])> = vec![
("[Content_Types].xml", types.as_bytes()),
("_rels/.rels", ROOT.as_bytes()),
("records/book.bin", &book),
("records/_rels/book.bin.rels", RELS.as_bytes()),
("data/one.bin", &one),
("data/_rels/one.bin.rels", rels.as_bytes()),
("data/two.bin", &two),
("text/strings.bin", &strings),
];
entries.extend(names.iter().map(String::as_str).zip(tables.iter().map(Vec::as_slice)));
zip(&entries)
}
/// Sheet one's tables through `Package`, and its warnings.
fn tables_of(bytes: &[u8]) -> (Vec<Table>, Vec<String>) {
let mut p = Package::open(bytes, &Limits::default()).unwrap();
let wb = p.workbook().unwrap();
let part = p.sheet(&wb.sheets[0], |_| Ok(())).unwrap();
let tables = p.tables(&part).unwrap().into_iter().map(|(_, t)| t).collect();
(tables, p.warnings().to_vec())
}
#[test]
fn a_name_using_a_structured_reference_is_decoded_after_tables_are_indexed() {
// `Vals` = `Sales[Val]`. Names are decoded after the workbook's tables are indexed, so
// the formula and a cell that uses it are kept, instead of only their saved results.
let name = brt_name(0, 0, WORKBOOK, "Vals", &ptg_list(0, 1, 1, 1, 1), None);
let list = [record(660, &1u32.to_le_bytes()), record(661, &wide("t1")), record(662, &[])];
let mut data = row(0);
data.extend(formula_cell(1, &[0x23, 5, 0, 0, 0], &[])); // =Vals, after the four names of `book_with_links`
let types = {
let t = TYPES.trim_end_matches("</Types>");
format!(r#"{t}<Override PartName="/tables/t1.bin" ContentType="application/vnd.ms-excel.table"/></Types>"#)
};
let sheet_rels = r#"<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="t1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/table" Target="../tables/t1.bin"/></Relationships>"#;
let (one, two, strings, table) = (worksheet(&data, &list.concat()), worksheet(&[], &[]), sst(), sales(&sales_filters()));
let book = {
let plain = book_with_links(&xti());
let end = record(132, &[]);
[&plain[..plain.len() - end.len()], name.as_slice(), end.as_slice()].concat()
};
let bytes = zip(&[
("[Content_Types].xml", types.as_bytes()),
("_rels/.rels", ROOT.as_bytes()),
("records/book.bin", book.as_slice()),
("records/_rels/book.bin.rels", RELS.as_bytes()),
("data/one.bin", one.as_slice()),
("data/_rels/one.bin.rels", sheet_rels.as_bytes()),
("data/two.bin", two.as_slice()),
("text/strings.bin", strings.as_slice()),
("tables/t1.bin", table.as_slice()),
]);
let names = Package::open(&bytes, &Limits::default()).unwrap().workbook().unwrap().defined_names;
assert_eq!(names.iter().find(|n| n.name == "Vals").map(|n| n.formula.as_str()), Some("Sales[Val]"));
let wb = read(&bytes).unwrap();
assert_eq!(wb.sheets[0].formula(CellRef::new(0, 1)), Some("Vals"), "{:?}", wb.warnings);
}
#[test]
fn simple_table_references_preserve_square_bracket_spacing() {
let cases = [
(1, "Sales[Val]"),
(1 | 0x80, "Sales[ Val ]"),
(rows(1), "Sales[#All]"),
(rows(1) | 0x80, "Sales[ #All ]"),
(1 | 0x100, "Sales[Val]"),
(rows(1) | 0x100, "Sales[#All]"),
];
let mut data = row(0);
for (i, (bits, _)) in cases.iter().enumerate() {
data.extend(formula_cell(i as u32 + 1, &ptg_list(0, *bits, 1, 1, 1), &[]));
}
let bytes = book_with_tables(&data, &[sales(&sales_filters())]);
let wb = read(&bytes).unwrap();
for (i, (_, want)) in cases.iter().enumerate() {
assert_eq!(wb.sheets[0].formula(CellRef::new(0, i as u32 + 1)), Some(*want), "{:?}", wb.warnings);
}
}
#[test]
fn tables_are_read_as_their_xlsx_spelling() {
// Spacing flags: 0x80 inside the outer brackets, 0x100 after commas.
let cells: Vec<Vec<u8>> = vec![
ptg_list(0, 1, 1, 1, 1),
ptg_list(0, 1 | rows(2), 1, 0, 0),
ptg_list(0, 2 | rows(4), 1, 1, 3),
ptg_list(0, rows(1), 1, 0, 0),
ptg_list(0, 0, 1, 0, 0),
ptg_list(0, 2 | rows(0x10), 1, 1, 3),
ptg_list(0, 1, 1, 2, 2),
ptg_list(0, 1 | rows(4) | 0x180, 1, 1, 1),
ptg_list(0, rows(0x10), 2, 0, 0),
ptg_list(0, 1 | rows(0xC) | 0x100, 1, 0, 0),
ptg_list(0, rows(6), 1, 0, 0),
// Kept as their saved results: a table that isn't there, a deleted table, a column past
// the table's last.
ptg_list(0, 0, 9, 0, 0),
ptg_list(0, 0x1000, 1, 0, 0),
ptg_list(0, 1, 1, 4, 4),
];
let mut data = row(0);
for (i, rgce) in cells.iter().enumerate() {
data.extend(formula_cell(i as u32 + 1, rgce, &[]));
}
let bytes = book_with_tables(&data, &[sales(&sales_filters()), no_head(), xml_table_part()]);
let (tables, _) = tables_of(&bytes);
assert_eq!(tables, [xml_table(SALES_XML), xml_table(NO_HEAD_XML), xml_table(XML_TABLE_XML)]);
let wb = read(&bytes).unwrap();
let got: Vec<_> = (1..=14).map(|c| wb.sheets[0].formula(CellRef::new(0, c))).collect();
let want = [
Some("Sales[Val]"),
Some("Sales[[#Headers],[Key]]"),
Some("Sales[[#Data],[Val]:[Calc]]"),
Some("Sales[#All]"),
Some("Sales[]"),
Some("Sales[[#This Row],[Val]:[Calc]]"),
Some("Sales[It''s '['#1']]"),
Some("Sales[ [#Data], [Val] ]"),
Some("NoHead[#This Row]"),
Some("Sales[[#Data], [#Totals], [Key]]"),
Some("Sales[[#Headers],[#Data]]"),
None,
None,
None,
];
assert_eq!(got, want);
for why in ["tables the reader could not read", "deleted tables", "missing table column"] {
assert!(warned(&wb, why), "{why}: {:?}", wb.warnings);
}
}
#[test]
fn table_filters_and_parts_the_reader_cannot_spell_are_left_out() {
// A filter column whose criteria are in a future-record block (where Excel keeps date
// groups), and one on a Boolean value: both left out, the table kept.
let frt = [record(35, &[3, 0, 2, 0]), record(5094, &[0; 32]), record(36, &[])].concat();
let mut filters = sales_filters();
filters.push(filter_column(4, 0, &[frt]));
filters.push(filter_column(5, 0, &[record(172, &0u32.to_le_bytes()), custom_filter(8, 2, [1, 0, 0, 0, 0, 0, 0, 0], None), record(173, &[])]));
// A truncated table part: skipped, and formulas using it keep their saved results.
let mut broken = no_head();
broken.truncate(20);
let data = [row(0), formula_cell(1, &ptg_list(0, 0, 2, 0, 0), &[]), formula_cell(2, &ptg_list(0, 1, 1, 1, 1), &[])].concat();
let bytes = book_with_tables(&data, &[sales(&filters), broken]);
let (tables, warnings) = tables_of(&bytes);
assert_eq!(tables, [xml_table(SALES_XML)]);
for why in ["filters kept in extensions", "custom filters on a Boolean value", "skipped tables/t2.bin"] {
assert!(warnings.iter().any(|w| w.contains(why)), "{why}: {warnings:?}");
}
let wb = read(&bytes).unwrap();
assert_eq!([1, 2].map(|c| wb.sheets[0].formula(CellRef::new(0, c))), [None, Some("Sales[Val]")]);
assert!(warned(&wb, "tables the reader could not read"), "{:?}", wb.warnings);
}
#[test]
fn vba_function_names_without_macro_strings_are_read() {
// Excel writes a VBA function a cell calls as a BrtName with fFunc, fOB and