mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-17 04:04:25 +00:00
craft-xlsx: review fixes: CONVERT, shared formula tokens borrowed, cell metadata with its formula
From the first review round: - 468 (0x1D4) is CONVERT, with 3 arguments. [MS-XLSB]'s Ftab table has no row for it, though its grammar lists convert-params among the fixed-argument functions; Excel writes =CONVERT(1,"m","ft") in .xlsb as a PtgFunc calling 0x1D4 (observed in Excel). It was the only unassigned number from 0x17C to 0x1E4. The module doc says it isn't the specification's row. - A BrtShrFmla's tokens and extra data are borrowed from the worksheet part instead of copied: a record may claim up to 256 MiB, and each shared formula is kept for the rest of the sheet, so the copies could cost as much again as the part. BrtArrFmla's are used at once and borrowed too. - A formula record's cell metadata goes with its formula: when the formula is kept as its value (tokens the reader can't decode, an unreadable BrtArrFmla), the cell loses its `cm`, which would otherwise mark a dynamic-array formula that isn't there. A value cell keeps its cell metadata, as the file has it. The CONVERT and cell-metadata tests fail without this commit. The Excel-saved workbook still reads with all 33 formulas as in its .xlsx.
This commit is contained in:
+30
-16
@@ -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<u8>,
|
||||
rgcb: Vec<u8>,
|
||||
rgce: &'a [u8],
|
||||
rgcb: &'a [u8],
|
||||
len: usize,
|
||||
si: u32,
|
||||
}
|
||||
@@ -576,12 +579,12 @@ fn part_of(rgce: &[u8], rgcb: &[u8], at: CellRef) -> Option<Result<Part, &'stati
|
||||
/// One sheet's shared and array formulas, by first cell, as the reader meets them. `None` when
|
||||
/// the formula keeps its values (so its other cells keep theirs).
|
||||
#[derive(Default)]
|
||||
struct RangeFormulas {
|
||||
shared: HashMap<CellRef, Option<Arc<SharedFormula>>>,
|
||||
struct RangeFormulas<'a> {
|
||||
shared: HashMap<CellRef, Option<SharedFormula<'a>>>,
|
||||
arrays: HashMap<CellRef, Option<Range>>,
|
||||
}
|
||||
|
||||
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<CellFormula> {
|
||||
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<CellFormula> {
|
||||
let read = |b: &mut Bytes<'_>| -> Result<(Range, Vec<u8>, Vec<u8>), 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,
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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::<Vec<_>>(), [(&at("C1"), &1)]);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user