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;
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
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
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.AddCopycopia 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