Technischer Artikel

BIFF8-Font-Index überspringt 4: Rich-Text-Runs mit HotXLS

Eine BIFF8-Arbeitsmappe mit acht FONT-Records enthält einen XF-Record, dessen Font-Feld 8 liest. Ab null gezählt ist das ein Slot hinter dem Tabellenende, doch Excel rendert die Zelle ohne Murren in der achten Schrift. Der Wert ist legal: [MS-XLS] §2.5.129 nummeriert die ersten vier FONT-Records 0 bis 3, überspringt die 4 vollständig und nummeriert jeden späteren Record nach seiner Eins-basierten Position

Der fünfte FONT-Record ist also ifnt 5, und eine wohlgeformte Datei braucht nie einen Wert größer als ihre FONT-Record-Anzahl. Die Regel liest sich wie ein Tippfehler in der Spec, genau deshalb „korrigieren“ Leute sie, und weil Zellformate, Rich Text in Shared Strings und Kommentar-Runs alle denselben FontIndex-Typ tragen, bindet eine Lesart, die zwischen Wegen variiert, manche Schriften korrekt und andere einen Record daneben. Sie gehört zur selben Familie wie die Längen- und Kodierungs-Eigenheiten im Artikel zum Dekodieren von BIFF8 XLUnicodeString cch und fHigh — die Datei ist in Ordnung, das Lesen von ihr nicht

Was [MS-XLS] §2.5.129 sagt und wie man es an einer echten Datei prüft

[MS-XLS] §2.5.129 definiert FontIndex als Record-Position mit einem Loch. Werte unter 4 sind nullbasiert, Werte über 4 sind einsbasiert, und der Wert 4 DARF NICHT benutzt werden. XF-Records zeigen damit auf Fonts, die FormatRun-Einträge eines Rich-Shared-Strings nutzen ihn, und ebenso die TXO-Formatierungs-Runs aus §2.5.272

Man muss der Spec nicht aufs Wort glauben. Dumpen Sie eine von Excel selbst gespeicherte .xls mit einem beliebigen BIFF-Record-Viewer, zählen Sie die FONT-Records (Record-Typ $0031) und scannen Sie dann das Font-Feld am Anfang jedes XF-Records ($00E0). Der höchste Wert bleibt innerhalb der Record-Anzahl, und die Zahl 4 fehlt in der Liste. Finden Sie eine 4 oder einen Wert über der FONT-Anzahl, stammt die Datei von etwas anderem als Excel, und ihre Font-Nummerierung verdient einen genaueren Blick. Für ein Diagnosewerkzeug oder einen Test passt die ganze Abbildung in zwei Funktionen

// Eigene Helper, kein Teil irgendeiner Bibliothek
// [MS-XLS] 2.5.129 FontIndex: 0..3 nullbasiert, > 4 einsbasiert, 4 ungültig
function FontIndexToRecordNo(Ifnt: Word): Integer;  // einsbasierter FONT-Record
begin
  if Ifnt < 4 then
    Result := Ifnt + 1
  else if Ifnt > 4 then
    Result := Ifnt
  else
    Result := -1;  // 4 darf nicht auftreten
end;

function RecordNoToFontIndex(RecordNo: Integer): Word;
begin
  if RecordNo <= 4 then
    Result := RecordNo - 1
  else
    Result := RecordNo;
end;
FontIndex-Abbildung nach MS-XLS 2.5.129, bei der ifnt 0 bis 3 nullbasierte FONT-Record-Positionen sind, ifnt 5 und höher einsbasiert und der Wert 4 nie auftritt, mit der FontIndexToRecordNo-Konvertierung
Der fünfte FONT-Record ist ifnt 5, also ist in einer Datei mit N FONT-Records der größte legale ifnt N, und der Wert 4 wird nie gespeichert

Wie HotXLS Fonts in XF-Records und Rich-Text-Runs nummeriert

HotXLS liest und schreibt jede BIFF8-Font-Referenz in Spec-Nummerierung. Beim Speichern wird die Font-Tabelle auf die tatsächlich referenzierten Fonts verdichtet, und die Position jedes überlebenden Fonts wird zu einem FontIndex: Positionen 1 bis 4 werden als 0 bis 3 geschrieben, Position 5 und höher gehen unverändert raus. Das Laden dreht es um, also rückt jeder Wert ab 5 um eins nach unten, um den Font im Speicher zu finden, und alles unter 5 bleibt, wo es ist. Dieselbe Konvertierung gilt für XF-Records, für Rich-Text-Runs in der Shared-String-Tabelle, für Kommentar- und Textbox-Runs und für die Font-Referenzen in klassischen Chart-Records

Für Anwendungscode ist der sichtbare Teil TextRuns an TXLSComment und TXLSTextBox. TextRuns.FontIndex[I] liefert die Datei-Nummerierung exakt wie gelesen, mit übersprungener 4. Run-Indizes zählen ab 1, und CharIndex[I] ist der Zeichen-Offset, an dem Run I beginnt. Die Dateinummer statt eines nullbasierten Tabellen-Slots offenzulegen ist hier die bessere Default-Wahl: Was die API meldet, passt zu dem, was ein Record-Dump zeigt. Der Preis ist ein Aufruf des Helpers oben, bevor man den Wert als Tabellenposition behandelt

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];   // Datei-Nummerierung, 4 übersprungen
      // eigene Plausibilitätskontrolle: 4 heißt, die Datei bricht 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;

Nach einem Speichern kann die für einen Run gespeicherte Zahl von der abweichen, die Sie gelesen oder gesetzt haben. Das Speichern nummeriert Runs zusammen mit der verdichteten Font-Tabelle um, daher ändert sich die Zahl, und der Font, auf den sie zeigt, nicht

Warum eine Nullbasiert-Korrektur jeden eigenen Font verschiebt

Die Falle beginnt meist mit einem plausibel aussehenden Bug-Report. Jemand dump't eine Mappe mit acht FONT-Records, sieht einen XF, der auf Font 8 zeigt, schließt, der Writer habe einen Index außerhalb des Bereichs produziert, und schaltet Writer und Reader auf schlichte Nullbasiert-Arithmetik um. Der Round-Trip-Test geht weiter durch, weil der gepatchte Writer und der gepatchte Reader sich gegenseitig verstehen. Excel versteht sich nicht mit ihnen. Eine so geschriebene Datei speichert den ersten eigenen Font als ifnt 4, was Excel auf den Default-Font auflöst, und jeder spätere eigene Font landet einen Record zu früh. Excel-Dateien zu lesen geht in die andere Richtung: Jeder Font bindet einen Record zu spät

Die Nullbasiert-Fehllesart, bei der Writer und Reader einsbasierte FontIndex-Werte als nullbasiert behandeln, den ersten eigenen Font als die verbotene ifnt 4 speichern, die Excel auf den Default-Font auflöst, und jeden späteren Font einen Record zu früh landen lassen, während Round Trips zwischen den beiden weiterhin durchgehen
Writer und Reader, die dieselbe Fehllesart teilen, bestehen jeden Save-und-Wiederöffnen-Test, während jeder Font, den Excel öffnet, einen Record daneben landet

Zwei Signate verraten die Fehllesart, bevor sie ausgeliefert wird. Das eine ist ein Test, der ifnt < FontCount behauptet. Er sieht wie eine Bereichsprüfung aus und schreibt die Fehllesart tatsächlich als Anforderung fest. Ein Test, der jedes geschriebene ifnt über die Spec-Formel auf einen FONT-Record-Namen zurückabbildet, erwischt die Verschiebung beim ersten Lauf

Das andere Signat ist Code, der mit sich selbst nicht einig ist. Ein vollständiger BIFF8-Reader und -Writer wendet die Skip-4-Regel an mehreren Stellen an: XF-Ausgabe, XF-Eingabe, Run-Remapping in Shared Strings, Kommentar-Runs, Chart-Font-Records. Wenn eine Änderung einige davon auf nullbasiert umstellt und den Rest in Ruhe lässt, sind die unberührten Stellen der Beweis, verdächtigen Sie also die Änderung, bevor Sie die Stellen verdächtigen. Eine Teiländerung kann lange versteckt bleiben, denn Fonts, die in Rich Text benutzt werden, referenziert meist auch irgendein Zellformat

Warum brechen Kommentar-Font-Runs erst beim zweiten Speichern?

Kommentar- und Textbox-Runs können ein Speichern überleben und am nächsten brechen, wenn zwei Writer-Gewohnheiten zusammentreffen. Die erste Gewohnheit ist asymmetrisches Beschneiden: die ersten N-1 FONT-Records bedingungslos behalten und nur den letzten fallen lassen, wenn kein XF ihn referenziert. Die zweite ist, die TXO-Formatierungs-Runs ([MS-XLS] §2.4.329) Byte für Byte zurückzuschreiben, ohne sie umzunummerieren. Jede Gewohnheit besteht für sich einen Einmal-Speichern-Test. Zusammen bauen sie einen Font-Verlust auf, der eine Generation wartet

Der Grund liegt darin, was Excel schreibt. Von Excel erzeugte .xls-Dateien enden häufig mit einem nicht referenzierten Font am Ende; auf einem System mit chinesischem Locale ist das ein DengXian mit 9 pt. Beim ersten Speichern ist der Font, den nur ein Kommentar-Run benutzt, daher nie der letzte, und nichts verschiebt sich sichtbar. Dieses Speichern wirft aber den End-Font raus und befördert den Nur-Kommentar-Font auf die letzte Position. Das zweite Speichern findet einen letzten Font ohne XF-Referenz und verwirft ihn. Der ifnt des Runs zeigt nun hinter das Tabellenende, und Excel fällt auf den Default-Font zurück. Hat die Mappe zwischendurch einen Font dazubekommen, bindet der Run stattdessen an den Neuling. Notizen, die immer wieder geöffnet, kommentiert und neu gespeichert werden, wie die aus dem Artikel zu einem Review-Workflow mit Kommentaren und Hyperlinks, sind der Ort, an dem das zuerst auftaucht

Font-Tabelle über zwei Speicherungen, bei denen der nicht referenzierte End-FONT-Record, den Excel schreibt, zuerst fallen gelassen wird, der Nur-Kommentar-Font zuletzt landet und beim zweiten Speichern verworfen wird, wenn TXO-Formatierungs-Runs zurückgeschrieben werden, ohne sie als Font-Referenzen zu zählen
Das erste Speichern sieht sauber aus, weil der End-Font den Verlust nimmt; der Kommentar-Font verschwindet erst beim zweiten, daher muss eine Font-Prüfung mehr als eine Speicherung spannen

HotXLS behandelt Kommentar- und Textbox-Runs genauso wie Shared-String-Runs. Bevor die Font-Tabelle verdichtet wird, wird jeder Run auf jedem Arbeitsblatt von seinem Skip-4-FontIndex in einen Tabellen-Slot konvertiert und als Referenz gezählt, was einen Font hält, den nur ein Run benutzt. Auf dem Weg hinaus laufen die Runs durch dieselbe Slot-zu-gespeichertem-Index-Tabelle, die die XF-Records umnummeriert. Der abschließende TxOLastRun-Eintrag trägt keinen Font und wird geschrieben, wie er gelesen wurde. Wegen dieser Umnummerierung sagen Ihnen Vergleiche von FontIndex-Werten vor und nach einem Speichern nichts; vergleichen Sie die Font-Namen, zu denen sie sich auflösen

Kopien, Zeilen-Einfügungen und Runs, die Mappen wechseln

In der klassischen Engine laufen Range.Copy, CopyRange, Sheets.AddCopy und die Zellverschiebungen hinter Range.Insert und Range.Delete durch einen einzigen Zellkopf-Pfad, und eine Verschiebung ist nur eine Kopie gefolgt von einem Leeren. Eine Kopie, die nur Kommentartext und Autor mitnähme, würde aus einer Zwei-Run-Notiz nach einer einzigen Zeilen-Einfügung eine Ein-Font-Notiz machen, ohne dass der User den Kommentar überhaupt anfasst

HotXLS kopiert den Start-Offset und den Font jedes Runs mit dem Text mit. Innerhalb einer Mappe wird der FontIndex unverändert wiederverwendet. Über Mappengrenzen hinweg wandert der Font by value: Die Skip-4-Nummer wird in einen Slot konvertiert, der Font wird in der Zielfont-Tabelle über seine Attribute gefunden oder ergänzt, und der entstandene Slot wird zurück in Datei-Nummerierung konvertiert. Rich Text in Shared Strings durchläuft dieselbe Konvertierung, wenn Sheets.AddCopy ein Blatt in eine andere Mappe kopiert, also können die beiden Run-Arten nicht auseinanderdriften. Die Font-Tabellen-Seite folgt demselben by-value-Ansatz wie die Formelseite aus dem Artikel zu Cross-Workbook-Kopie und Formula-Rebinding

Zwei Randfälle sind es wert, zu kennen, wenn Sie dafür Tests schreiben:

  • Ein Paste an Ort und Stelle, bei dem Quelle und Ziel auf denselben Kommentar aufgelöst werden, behält seine Runs; nichts wird geklärt, bevor es gelesen wurde
  • Sheets.AddCopy kopiert auch Kommentare, die an Zellen ohne gespeicherten Zell-Record hängen, was eine Schleife über gespeicherte Zellen allein verpassen würde

Auf der XLSX-Engine klonen Kopien Kommentar-Runs by value, und der Comments-Teil wird mit rFont, strike, u und vertAlign gelesen und geschrieben. Font-Name, Durchstreichung, Unterstreichung und Hoch- oder Tiefstellung eines Runs kommen nach Speichern und Wiederöffnen also intakt zurück

Ein Regressionstest, der Umnummerierung überlebt

Jede Falle in diesem Artikel besteht einen Speicher-Test. Die Nullbasiert-Fehllesart lebt in einem aufeinander abgestimmten Writer-und-Reader-Paar, der Kommentar-Font-Verlust braucht zwei Speicherungen, und verlorene Kommentar-Runs auf XLSX zeigen sich erst nach einem Wiederöffnen. Der Test muss also von der Platte wiederöffnen, mindestens zwei Speichergenerationen laufen und die Run-Struktur statt roher Font-Nummern prüfen. Beginnen Sie mit einer Mappe, die Excel selbst gespeichert hat, mit einem Zwei-Run-Kommentar auf C2, dessen zweiter Run einen Font benutzt, den sonst nichts in der Datei referenziert; das ist der Font, den das zweite Speichern sonst fallen ließe

procedure CheckNoteAcrossTwoSaves(const SrcFile, Out1, Out2: string);
var
  Book: IXLSWorkbook;
  Note: TXLSComment;
  RunCount: Integer;
  SecondRunAt: Word;
begin
  // Assert-Aufrufe sind Ihre eigenen Testkontrollen
  Book := TXLSWorkbook.Create;
  Assert(Book.Open(SrcFile) = 1);          // von Excel gespeichert, C2 hat zwei Runs
  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 wandert nach C3
  Assert(Book.SaveAs(Out1) = 1);

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

  Book := TXLSWorkbook.Create;               // wieder öffnen, dem Speicher nie trauen
  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;

Run-Zähler und Start-Offsets erwischen plattgemachte Notizen. Der Font selbst braucht einen Schritt außerhalb des Tests: Out2 in einem Record-Viewer öffnen, den ifnt jedes Runs durch FontIndexToRecordNo schicken und bestätigen, dass der FONT-Record, auf dem es landet, denselben Font-Namen trägt wie in der Quelldatei. In Excel zeigt sich ein verlorener Font als Default-Schrift auf dem zweiten Run der C3-Notiz

Klassisches XLS taucht weiterhin in etlichen Delphi- und C++Builder-Projekten auf, und jeder Font-Verbraucher in einer BIFF8-Datei muss sich auf §2.5.129 einigen, damit die Ausgabe in Excel korrekt aufgeht. HotXLS, die Delphi-Spreadsheet-Komponente, wendet die Skip-4-Nummerierung über Zellformate, Shared Strings, Kommentare, Textboxen und Charts hinweg an, nummeriert Runs bei jedem Speichern um und bewegt sie by value zwischen Mappen, und liest und schreibt XLS wie XLSX ohne Excel oder OLE-Automatisierung