Articolo tecnico

Indice font BIFF8 che salta il 4: run rich text in HotXLS

Un workbook BIFF8 con otto record FONT contiene un record XF il cui campo font vale 8. Conta da zero e quello è uno slot oltre la fine della tabella, eppure Excel renderizza la cella con l'ottavo font senza fiatare. Il valore è legale: [MS-XLS] §2.5.129 numera i primi quattro record FONT da 0 a 3, salta del tutto il 4, e numera ogni record successivo con la sua posizione a base uno

Quindi il quinto record FONT è ifnt 5, e un file ben formato non ha mai bisogno di un valore più grande del suo numero di record FONT. La regola sembra un refuso nella specifica, ed è esattamente per questo che la gente la "corregge", e poiché formati di cella, rich text delle shared string e run dei commenti portano tutti lo stesso tipo FontIndex, una lettura che differisce tra i percorsi lega alcuni font correttamente e altri sfalsati di un record. Appartiene alla stessa famiglia delle stranezze di lunghezza e codifica in decodificare cch e fHigh di XLUnicodeString in BIFF8 — il file è a posto, la lettura che se ne fa no

Cosa dice [MS-XLS] §2.5.129, e come verificarlo su un file reale

[MS-XLS] §2.5.129 definisce FontIndex come una posizione di record con un buco dentro. I valori sotto 4 sono a base zero, i valori sopra 4 sono a base uno, e il valore 4 NON DEVE essere usato. I record XF puntano ai font con esso, le voci FormatRun di una shared string rich lo usano, e così pure i run di formattazione TXO descritti in §2.5.272

Non devi fidarti della specifica sulla parola. Fai il dump di un .xls salvato da Excel stesso con un qualsiasi visualizzatore di record BIFF, conta i record FONT (tipo di record $0031), poi scorri il campo font all'inizio di ogni record XF ($00E0). Il valore più alto resta entro il numero di record e il numero 4 manca dalla lista. Se trovi un 4, o un valore sopra il conteggio dei FONT, il file è stato scritto da qualcosa che non è Excel e la sua numerazione dei font merita un'occhiata più attenta. Per uno strumento diagnostico o un test, l'intera mappatura sta in due funzioni

// Helper tuoi, non fanno parte di nessuna libreria
// [MS-XLS] 2.5.129 FontIndex: 0..3 a base zero, > 4 a base uno, 4 non valido
function FontIndexToRecordNo(Ifnt: Word): Integer;  // record FONT a base 1
begin
  if Ifnt < 4 then
    Result := Ifnt + 1
  else if Ifnt > 4 then
    Result := Ifnt
  else
    Result := -1;  // il 4 non deve comparire
end;

function RecordNoToFontIndex(RecordNo: Integer): Word;
begin
  if RecordNo <= 4 then
    Result := RecordNo - 1
  else
    Result := RecordNo;
end;
Mappatura FontIndex secondo MS-XLS 2.5.129 in cui ifnt da 0 a 3 sono posizioni di record FONT a base zero, ifnt 5 e oltre sono a base uno e il valore 4 non compare mai, con la conversione FontIndexToRecordNo
Il quinto record FONT è ifnt 5, quindi in un file con N record FONT il più grande ifnt legale è N e il valore 4 non viene mai memorizzato

Come HotXLS numera i font nei record XF e nei run di rich text

HotXLS legge e scrive ogni riferimento a font BIFF8 nella numerazione della specifica. Al salvataggio la tabella dei font viene compattata ai font che qualcosa referenzia davvero, e la posizione di ogni font sopravvissuto diventa un FontIndex: le posizioni da 1 a 4 vengono scritte come da 0 a 3, dalla posizione 5 in su escono invariate. Il caricamento fa l'inverso, quindi qualsiasi valore di 5 o più scende di uno per trovare il font in memoria e tutto ciò che sta sotto 5 resta dov'è. La stessa conversione si applica ai record XF, ai run di rich text nella tabella delle shared string, ai run di commenti e text box, e ai riferimenti a font dentro i record dei grafici classici

Per il codice applicativo la parte visibile è TextRuns su TXLSComment e TXLSTextBox. TextRuns.FontIndex[I] restituisce la numerazione del file esattamente come letta, con il 4 saltato. Gli indici dei run partono da 1, e CharIndex[I] è l'offset del carattere in cui inizia il run I. Esporre il numero del file invece di uno slot di tabella a base zero è il default migliore qui: ciò che l'API riporta coincide con ciò che mostra un dump dei record. Il costo è una chiamata all'helper qui sopra prima di trattare il valore come posizione di tabella

var
  Book: IXLSWorkbook;
  Note: TXLSComment;
  I: Integer;
  Ifnt: Word;
begin
  Book := TXLSWorkbook.Create;
  if Book.Open('review-notes.xls') <> 1 then
    raise Exception.Create('Cannot open review-notes.xls');
  Note := Book.Sheets[1].Range['C2', 'C2'].Comment;
  if Note <> nil then
    for I := 1 to Note.TextRuns.Count do
    begin
      Ifnt := Note.TextRuns.FontIndex[I];   // numerazione del file, 4 saltato
      // controllo di sanità tuo: 4 significa che il file viola la 2.5.129
      if Ifnt = 4 then
        raise Exception.CreateFmt('Run %d uses invalid ifnt 4', [I]);
      Writeln(Format('run %d at char %d: ifnt %d = FONT record #%d',
        [I, Note.TextRuns.CharIndex[I], Ifnt, FontIndexToRecordNo(Ifnt)]));
    end;
end;

Dopo un salvataggio, il numero memorizzato per un run può differire da quello che hai letto o impostato. Il salvataggio rinumera i run insieme alla tabella dei font compattata, quindi il numero cambia e il font a cui punta no

Perché una correzione a base zero sposta ogni font personalizzato

La trappola di solito parte da una segnalazione di bug dall'aria ragionevole. Qualcuno fa il dump di un workbook con otto record FONT, vede un XF che punta al font 8, conclude che il writer ha prodotto un indice fuori intervallo, e passa sia il writer sia il reader a una semplice aritmetica a base zero. Il test di round trip continua a passare, perché il writer patchato e il reader patchato sono d'accordo tra loro. Excel non è d'accordo. Un file scritto in quel modo memorizza il primo font personalizzato come ifnt 4, che Excel risolve nel font predefinito, e ogni font personalizzato successivo atterra un record prima. Leggere i file di Excel stesso va nel verso opposto: ogni font si lega un record dopo

La lettura errata a base zero in cui writer e reader trattano i valori FontIndex a base uno come a base zero, memorizzando il primo font personalizzato come il proibito ifnt 4 che Excel risolve nel font predefinito e facendo atterrare ogni font successivo un record prima mentre i round trip tra i due continuano a passare
Un writer e un reader che condividono la stessa lettura errata passano ogni test di salvataggio e riapertura, mentre ogni font che Excel apre atterra sfalsato di un record

Due segnali tradiscono la lettura errata prima che vada in produzione. Uno è un test che asserisce ifnt < FontCount. Sembra un controllo sui limiti, e in realtà mette per iscritto la lettura errata come requisito. Un test che riporta ogni ifnt scritto al nome di un record FONT tramite la formula della specifica intercetta lo sfasamento alla prima esecuzione

L'altro segnale è codice in disaccordo con se stesso. Un reader e writer BIFF8 completo applica la regola del salto del 4 in diversi punti: output XF, input XF, rimappatura dei run delle shared string, run dei commenti, record font dei grafici. Quando una modifica sposta alcuni di quei punti alla numerazione a base zero e lascia stare gli altri, i punti non toccati sono una prova, quindi sospetta della modifica prima di sospettare di loro. Una modifica parziale può nascondersi a lungo, perché i font usati nel rich text sono di solito referenziati anche da qualche formato di cella

Perché i run font dei commenti si rompono solo al secondo salvataggio?

I run di commenti e text box possono sopravvivere a un salvataggio e rompersi al successivo quando due abitudini del writer si incontrano. La prima abitudine è la potatura asimmetrica: tenere al loro posto i primi N-1 record FONT incondizionatamente e scartare solo l'ultimo quando nessun XF lo referenzia. La seconda è riscrivere i run di formattazione TXO ([MS-XLS] §2.4.329) byte per byte senza rinumerarli. Ogni abitudine da sola passa un test a salvataggio singolo. Insieme preparano una perdita di font che aspetta una generazione

Il motivo sta in ciò che scrive Excel. I file .xls creati da Excel finiscono comunemente con un font in coda non referenziato; su un sistema con locale cinese è un DengXian a 9 pt. Al primo salvataggio, il font che usa solo un run di commento non è quindi mai l'ultimo, e niente si muove visibilmente. Quel salvataggio però scarta il font in coda e promuove il font usato solo dal commento all'ultima posizione. Il secondo salvataggio trova un ultimo font senza riferimenti XF e lo scarta. L'ifnt del run ora punta oltre la fine della tabella, ed Excel ripiega sul font predefinito. Se nel frattempo il workbook ha guadagnato un font, il run si lega invece al nuovo arrivato. Le note che vengono aperte, annotate e salvate di nuovo e di nuovo, come quelle in costruire un workflow di revisione con commenti e hyperlink, sono il posto in cui questo si vede per primo

Tabella dei font attraverso due salvataggi in cui il record FONT in coda non referenziato scritto da Excel viene scartato per primo, il font usato solo dal commento diventa l'ultimo e viene poi scartato al secondo salvataggio quando i run di formattazione TXO vengono riscritti senza contarli come riferimenti a font
Il primo salvataggio sembra pulito perché è il font in coda a farne le spese; il font del commento sparisce solo al secondo, quindi un controllo sui font deve coprire più di un salvataggio

HotXLS gestisce i run di commenti e text box nello stesso modo in cui gestisce i run delle shared string. Prima che la tabella dei font venga compattata, ogni run su ogni worksheet viene convertito dal suo FontIndex con salto del 4 a uno slot di tabella e contato come riferimento, il che mantiene un font usato solo da un run. In uscita, i run passano dalla stessa tabella slot-a-indice-salvato che rinumera i record XF. La voce TxOLastRun di chiusura non porta alcun font e viene scritta com'è stata letta. Per via di quella rinumerazione, confrontare i valori di FontIndex prima e dopo un salvataggio non ti dice nulla; confronta i nomi dei font a cui si risolvono

Copie, inserimenti di righe e run che attraversano i workbook

Nel motore classico, Range.Copy, CopyRange, Sheets.AddCopy e gli spostamenti di celle dietro Range.Insert e Range.Delete passano tutti da un unico percorso di copia delle celle, e uno spostamento è solo una copia seguita da una cancellazione. Una copia che portasse solo testo e autore del commento trasformerebbe una nota a due run in una nota a un solo font dopo un singolo inserimento di riga, senza che l'utente tocchi affatto il commento

HotXLS copia l'offset iniziale e il font di ogni run insieme al testo. Dentro un singolo workbook il FontIndex viene riusato così com'è. Tra workbook il font si sposta per valore: il numero con salto del 4 viene convertito in uno slot, il font viene abbinato o aggiunto nella tabella dei font di destinazione in base ai suoi attributi, e lo slot risultante viene riconvertito nella numerazione del file. Il rich text nelle shared string passa dalla stessa conversione quando Sheets.AddCopy copia un foglio in un altro workbook, così i due tipi di run non possono divergere. Il lato della tabella dei font segue lo stesso approccio per valore del lato delle formule trattato in copia tra workbook e ricollegamento delle formule

Due casi limite vale la pena conoscere quando scrivi test per questo:

  • Un incolla sul posto, in cui sorgente e destinazione si risolvono nello stesso commento, mantiene i suoi run; nulla viene cancellato prima di essere stato letto
  • Sheets.AddCopy copia anche i commenti ancorati a celle che non hanno un record di cella memorizzato, che un ciclo sulle sole celle memorizzate si perderebbe

Sul motore XLSX, le copie clonano i run dei commenti per valore, e la parte dei commenti viene letta e scritta con rFont, strike, u e vertAlign. Nome del font, barrato, sottolineatura e impostazione di apice o pedice di un run tornano quindi intatti dopo salvataggio e riapertura

Un test di regressione che sopravvive alla rinumerazione

Ogni trappola di questo articolo passa un test in memoria. La lettura errata a base zero vive in un writer e un reader accoppiati, la perdita del font del commento richiede due salvataggi, e i run di commento persi su XLSX si vedono solo dopo una riapertura. Quindi il test deve riaprire da disco, eseguire almeno due generazioni di salvataggio e controllare la struttura dei run invece dei numeri grezzi dei font. Parti da un workbook salvato da Excel stesso, con un commento a due run su C2 il cui secondo run usa un font che nient'altro nel file referenzia; è il font che il secondo salvataggio altrimenti scarterebbe

procedure CheckNoteAcrossTwoSaves(const SrcFile, Out1, Out2: string);
var
  Book: IXLSWorkbook;
  Note: TXLSComment;
  RunCount: Integer;
  SecondRunAt: Word;
begin
  // Le chiamate Assert sono controlli di test tuoi
  Book := TXLSWorkbook.Create;
  Assert(Book.Open(SrcFile) = 1);          // salvato da Excel, C2 ha due run
  Note := Book.Sheets[1].Range['C2', 'C2'].Comment;
  Assert(Note <> nil);
  RunCount := Note.TextRuns.Count;
  SecondRunAt := Note.TextRuns.CharIndex[2];

  Book.Sheets[1].Range['C2', 'C2'].Copy(Book.Sheets[1].Range['E5', 'E5']);
  Book.Sheets[1].Range['C1', 'C1'].Insert(xlShiftDown);   // C2 si sposta in C3
  Assert(Book.SaveAs(Out1) = 1);

  Book := TXLSWorkbook.Create;               // seconda generazione
  Assert(Book.Open(Out1) = 1);
  Assert(Book.SaveAs(Out2) = 1);

  Book := TXLSWorkbook.Create;               // riapri, mai fidarsi della memoria
  Assert(Book.Open(Out2) = 1);
  Note := Book.Sheets[1].Range['C3', 'C3'].Comment;
  Assert((Note <> nil) and (Note.TextRuns.Count = RunCount));
  Assert(Note.TextRuns.CharIndex[2] = SecondRunAt);
  Assert(Note.TextRuns.FontIndex[2] <> 4);
  Note := Book.Sheets[1].Range['E5', 'E5'].Comment;
  Assert((Note <> nil) and (Note.TextRuns.Count = RunCount));
end;

Il conteggio dei run e gli offset iniziali intercettano le note appiattite. Il font stesso richiede un passo in più fuori dal test: apri Out2 in un visualizzatore di record, fai passare l'ifnt di ogni run per FontIndexToRecordNo e conferma che il record FONT su cui atterra porti lo stesso nome di font del file sorgente. In Excel, un font perso si manifesta come carattere predefinito sul secondo run della nota in C3

L'XLS classico compare ancora in un sacco di progetti Delphi e C++Builder, e ogni consumatore di font in un file BIFF8 deve essere d'accordo sulla §2.5.129 perché l'output si apra correttamente in Excel. HotXLS, il componente spreadsheet per Delphi, applica la numerazione con salto del 4 a formati di cella, shared string, commenti, text box e grafici, rinumera i run a ogni salvataggio e li sposta per valore tra workbook, e legge e scrive sia XLS sia XLSX senza Excel né automazione OLE