diff --git a/crates/xlsx/src/xlsb.rs b/crates/xlsx/src/xlsb.rs index d0bf980c9..d46c2ea20 100644 --- a/crates/xlsx/src/xlsb.rs +++ b/crates/xlsx/src/xlsb.rs @@ -542,11 +542,14 @@ fn kept(warnings: &mut Warnings, why: &str) { } /// A `BrtShrFmla`: the cells it may cover, its tokens, its first cell's text length (what a copy -/// is expected to cost) and the group's index (`si`). -struct SharedFormula { +/// is expected to cost) and the group's index (`si`). The tokens are borrowed from the worksheet +/// part, which outlives the sheet's read: a record can be up to 256 MiB, and copying every +/// shared formula's would cost as much again as the part. +#[derive(Clone, Copy)] +struct SharedFormula<'a> { range: Range, - rgce: Vec, - rgcb: Vec, + rgce: &'a [u8], + rgcb: &'a [u8], len: usize, si: u32, } @@ -576,12 +579,12 @@ fn part_of(rgce: &[u8], rgcb: &[u8], at: CellRef) -> Option>>, +struct RangeFormulas<'a> { + shared: HashMap>>, arrays: HashMap>, } -impl RangeFormulas { +impl<'a> RangeFormulas<'a> { /// The formula of another cell `at` of the shared or array formula starting at `first`. A /// shared formula's copy is decoded from the shared tokens at its own cell, as [MS-XLSB] /// defines it (relative offsets wrap around the grid), and checked like any formula: its text @@ -598,7 +601,7 @@ impl RangeFormulas { warnings: &mut Warnings, ) -> Option { if let Some(shared) = self.shared.get(&first) { - let sh = shared.clone()?; + let sh = (*shared)?; if !sh.range.contains(at) { kept(warnings, "malformed shared or array formula references"); return None; @@ -607,7 +610,7 @@ impl RangeFormulas { kept(warnings, "more formula text than the limits allow"); return None; } - let Some(text) = decode_formula(&sh.rgce, &sh.rgcb, Mode::Shared(at), links, limits, budget, warnings) else { + let Some(text) = decode_formula(sh.rgce, sh.rgcb, Mode::Shared(at), links, limits, budget, warnings) else { // A copy that was decoded but kept as its value charged nothing: one past the // allowance (it may be longer than the first cell's estimate) or one that can't be // decoded. The group's later copies would fail the same way, so they keep their @@ -634,14 +637,14 @@ impl RangeFormulas { fn range_formula( &mut self, id: u16, - payload: &[u8], + payload: &'a [u8], first: CellRef, links: Option<&Links>, limits: &Limits, budget: &Budget, warnings: &mut Warnings, ) -> Option { - let read = |b: &mut Bytes<'_>| -> Result<(Range, Vec, Vec), Error> { + let read = |b: &mut Bytes<'a>| -> Result<(Range, &'a [u8], &'a [u8]), Error> { let (r0, r1, c0, c1) = (b.u32()?, b.u32()?, b.u32()?, b.u32()?); if id == 426 { b.u8()?; // Only fAlwaysCalc, the calculator's to know. @@ -650,9 +653,9 @@ impl RangeFormulas { if !(1..=16384).contains(&cce) { return Err(invalid("invalid formula token length")); } - let rgce = b.take(cce as usize)?.to_vec(); + let rgce = b.take(cce as usize)?; let cb = b.u32()?; - let rgcb = b.take(cb as usize)?.to_vec(); + let rgcb = b.take(cb as usize)?; if r0 > r1 || c0 > c1 || r1 >= MAX_ROWS || c1 >= MAX_COLS { return Err(invalid("invalid formula range")); } @@ -673,9 +676,9 @@ impl RangeFormulas { return None; }; if id == 427 { - let text = decode_formula(&rgce, &rgcb, Mode::Shared(first), links, limits, budget, warnings); + let text = decode_formula(rgce, rgcb, Mode::Shared(first), links, limits, budget, warnings); let si = u32::try_from(self.shared.len()).unwrap_or(u32::MAX); - let shared = text.as_ref().map(|t| Arc::new(SharedFormula { range, rgce, rgcb, len: t.len(), si })); + let shared = text.as_ref().map(|t| SharedFormula { range, rgce, rgcb, len: t.len(), si }); self.shared.insert(first, shared); return text.map(|text| CellFormula { kind: FormulaKind::Shared, @@ -685,7 +688,7 @@ impl RangeFormulas { ..CellFormula::default() }); } - let text = decode_formula(&rgce, &rgcb, Mode::Cell, links, limits, budget, warnings); + let text = decode_formula(rgce, rgcb, Mode::Cell, links, limits, budget, warnings); self.arrays.insert(first, text.as_ref().map(|_| range)); text.map(|text| CellFormula { kind: FormulaKind::Array, text, range: Some(range), ..CellFormula::default() }) } @@ -761,6 +764,11 @@ pub(crate) fn worksheet( if matches!(id, 426 | 427) { let f = ranges.range_formula(id, payload, at, links, limits, budget, warnings); if let Some(cell) = row.as_mut().and_then(|r| r.cells.last_mut()).filter(|c| c.at == at) { + // A dynamic array's cell metadata describes its formula: with none kept, the + // cell is a value, and `cm` on it would mark a formula that isn't there. + if f.is_none() { + cell.cell_metadata = None; + } cell.formula = f; } continue; @@ -856,6 +864,12 @@ pub(crate) fn worksheet( if value != CellValue::Empty { budget.cell(limits)?; } + // A formula record's cell metadata describes its formula (a dynamic array), so a + // formula kept as its value drops it; the first cell of a shared or array formula + // keeps it until its formula record is read. Other cells keep theirs as the file + // has it. + let formula_kept = !(8..=11).contains(&id) || formula.is_some() || first == Some(at); + let cell_metadata = cell_metadata.filter(|_| formula_kept); current.cells.push(Cell { at, style: style & 0x00FF_FFFF, diff --git a/crates/xlsx/src/xlsb/ftab.rs b/crates/xlsx/src/xlsb/ftab.rs index 87f369519..efd6e4426 100644 --- a/crates/xlsx/src/xlsb/ftab.rs +++ b/crates/xlsx/src/xlsb/ftab.rs @@ -3,6 +3,10 @@ //! which craft-xls also carries. The entries from 380 (0x17C) on are the rest of the XLSB table: //! XLSB files call these functions by number, where `.xls` files call them by name. Kept apart from //! craft-xls's copy: the two formats follow separate specifications. +//! +//! One entry is not in the specification's table: 468 (0x1D4) is CONVERT. The table has no row +//! for it, but its grammar lists `convert-params` among the fixed-argument functions, and Excel +//! writes `=CONVERT(1,"m","ft")` in `.xlsb` as a `PtgFunc` calling 0x1D4. /// (iftab, name, fixed argument count or -1 when the function takes a variable number of /// arguments), sorted by number. @@ -467,6 +471,7 @@ const FTAB: &[(u16, &str, i8)] = &[ (465, "WEEKNUM", -1), (466, "AMORDEGRC", -1), (467, "AMORLINC", -1), + (468, "CONVERT", 3), (469, "ACCRINT", -1), (470, "ACCRINTM", -1), (471, "WORKDAY", -1), @@ -508,7 +513,9 @@ mod tests { assert_eq!(function(449), Some(("EDATE", 2))); assert_eq!(function(480), Some(("IFERROR", 2))); assert_eq!(function(482), Some(("SUMIFS", -1))); - assert_eq!(function(0x1D4), None, "unassigned"); + // Not in the specification's table, but what Excel writes for CONVERT. + assert_eq!(function(0x1D4), Some(("CONVERT", 3))); + assert_eq!(function(0x17B), Some(("RTD", -1))); assert_eq!(function(0x1E5), None); } } diff --git a/crates/xlsx/tests/xlsb.rs b/crates/xlsx/tests/xlsb.rs index 3f1c51b7f..518ca5214 100644 --- a/crates/xlsx/tests/xlsb.rs +++ b/crates/xlsx/tests/xlsb.rs @@ -885,3 +885,36 @@ fn a_shared_formula_stops_decoding_copies_once_one_is_kept_as_its_value() { assert_eq!((text("A1"), text("Z1"), text("B2")), (Some("B1"), None, None)); assert!(warned(&wb, "more formula text than the limits allow"), "{:?}", wb.warnings); } + +#[test] +fn convert_is_called_by_its_number_as_excel_writes_it() { + // Excel's tokens for `=CONVERT(1,"m","ft")` in .xlsb: PtgFunc 0x1D4, which the + // specification's Ftab table leaves out. + let rgce = [0x1E, 0x01, 0x00, 0x17, 0x01, 0x00, 0x6D, 0x00, 0x17, 0x02, 0x00, 0x66, 0x00, 0x74, 0x00, 0x41, 0xD4, 0x01]; + let wb = read(&file(&worksheet(&[row(0), formula_cell(0, &rgce, &[])].concat(), &[]))).unwrap(); + assert_eq!(wb.sheets[0].formula(CellRef::new(0, 0)), Some("CONVERT(1,\"m\",\"ft\")")); +} + +#[test] +fn a_dynamic_array_kept_as_its_value_has_no_cell_metadata() { + let meta = record(49, &1u32.to_le_bytes()); + let table_ref = [0x18, 0x19, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0]; + let data = [ + row(0), + // A1: a dynamic-array formula the reader can't decode (a table reference). + meta.clone(), + formula_cell(0, &table_ref, &[]), + // B1:B2: a dynamic array whose BrtArrFmla holds an unknown token. + meta.clone(), + part(1, (0, 1)), + range_formula(426, (0, 1, 1, 1), &[0xFF]), + // C1: a value with cell metadata keeps it, as the file has it. + meta, + cell(5, 2, &1.0f64.to_le_bytes()), + ] + .concat(); + let wb = read(&file(&worksheet(&data, &[]))).unwrap(); + let sheet = &wb.sheets[0]; + assert_eq!((sheet.formula(at("A1")), sheet.formula(at("B1"))), (None, None)); + assert_eq!(sheet.cell_metadata.iter().collect::>(), [(&at("C1"), &1)]); +}