Technisch artikel

FontIndex slaat 4 over: BIFF8 rich text runs in HotXLS

Een BIFF8-werkmap met acht FONT-records bevat een XF-record waarvan het fontveld 8 leest. Van nul af geteld is dat één plek voorbij het einde van de tabel, toch rendert Excel de cel klagenloos in het achtste font. De waarde is legaal: [MS-XLS] §2.5.129 nummert de eerste vier FONT-records 0 tot en met 3, slaat 4 geheel over en nummert elk later record op zijn één-based positie

Het vijfde FONT-record is dus ifnt 5, en een welgevormd bestand heeft nooit een waarde nodig die groter is dan zijn aantal FONT-records. De regel leest als een typefout in de specificatie, en dat is precies waarom mensen hem "corrigeren", en omdat celopmaak, rich text in gedeelde strings en commentaar-runs allemaal hetzelfde type FontIndex dragen, bindt een lezing die tussen paden verschilt sommige fonts correct en andere één record ernaast. Hij hoort bij dezelfde familie als de lengte- en coderingcapriolen in het decoderen van BIFF8 XLUnicodeString cch en fHigh — het bestand is in orde, de lezing ervan niet

Wat [MS-XLS] §2.5.129 zegt, en hoe je dat op een echt bestand controleert

[MS-XLS] §2.5.129 definieert FontIndex als een recordpositie met een gat erin. Waarden onder 4 zijn zero-based, waarden boven 4 zijn one-based, en de waarde 4 MAG NIET worden gebruikt. XF-records wijzen er fonts mee aan, de FormatRun-entries van een rijke gedeelde string gebruiken hem, en de TXO-formatteerruns uit §2.5.272 doen dat ook

Je hoeft het niet op de woord van de specificatie te nemen. Dump een .xls die Excel zelf heeft opgeslagen met een willekeurige BIFF-recordviewer, tel de FONT-records (recordtype $0031) en scan daarna het fontveld aan het begin van elk XF-record ($00E0). De hoogste waarde blijft binnen het recordaantal en het getal 4 ontbreekt in de lijst. Vind je een 4, of een waarde boven het FONT-aantal, dan is het bestand door iets anders dan Excel geschreven en verdient zijn fontnummering een nadere blik. Voor een diagnostische tool of een test past de hele mapping in twee functies

// Eigen helpers, geen onderdeel van een library
// [MS-XLS] 2.5.129 FontIndex: 0..3 zero-based, > 4 one-based, 4 ongeldig
function FontIndexToRecordNo(Ifnt: Word): Integer;  // 1-based FONT-record
begin
  if Ifnt < 4 then
    Result := Ifnt + 1
  else if Ifnt > 4 then
    Result := Ifnt
  else
    Result := -1;  // 4 mag niet voorkomen
end;

function RecordNoToFontIndex(RecordNo: Integer): Word;
begin
  if RecordNo <= 4 then
    Result := RecordNo - 1
  else
    Result := RecordNo;
end;
FontIndex-toewijzing volgens MS-XLS 2.5.129 waarbij ifnt 0 tot en met 3 zero-based FONT-recordposities zijn, ifnt 5 en hoger one-based en de waarde 4 nooit voorkomt, met de FontIndexToRecordNo-conversie
Het vijfde FONT-record is ifnt 5, dus in een bestand met N FONT-records is het grootste legale ifnt N, en de waarde 4 wordt nooit opgeslagen

Hoe HotXLS fonts nummert in XF-records en rich text-runs

HotXLS leest en schrijft elke BIFF8-fontverwijzing in specificatienummering. Bij het opslaan wordt de fonttabel gecomprimeerd tot de fonts die ergens echt worden gerefereerd, en de positie van elk overlevend font wordt een FontIndex: posities 1 tot en met 4 worden als 0 tot en met 3 geschreven, positie 5 en hoger gaan ongewijzigd de deur uit. Het laden draait het terug, dus elke waarde van 5 of hoger schuift er één naar beneden om het font in het geheugen te vinden en alles onder 5 blijft staan. Dezelfde conversie wordt toegepast op XF-records, op rich text-runs in de tabel met gedeelde strings, op commentaar- en tekstvak-runs en op de fontverwijzingen binnen klassieke chart-records

Voor applicatiecode is het zichtbare deel TextRuns op TXLSComment en TXLSTextBox. TextRuns.FontIndex[I] geeft de bestandsnummering exact zoals gelezen, met 4 overgeslagen. Run-indexen zijn one-based, en CharIndex[I] is de tekenoffset waar run I begint. Het bestandsnummer tonen in plaats van een zero-based tabelplek is hier de betere standaard: wat de API meldt, matcht met wat een recorddump toont. De prijs is één aanroep van de helper hierboven voordat je de waarde als tabelpositie 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];   // bestandsnummering, 4 overgeslagen
      // je eigen gezondheidscontrole: 4 betekent dat het bestand 2.5.129 schendt
      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;

Na een opslag kan het nummer dat voor een run is opgeslagen verschillen van het nummer dat je las of instelde. De opslag hernummert runs samen met de gecomprimeerde fonttabel, dus het nummer verandert en het font waar hij naar wijst niet

Waarom een zero-based "fix" elk custom font verschuift

De valkuil begint meestal met een plausibel uitziende bugmelding. Iemand dumpt een werkmap met acht FONT-records, ziet een XF die naar font 8 wijst, concludeert dat de writer een out-of-range-index heeft geproduceerd en zet zowel de writer als de reader om naar kale zero-based rekenkunde. De round-trip-test slaagt nog steeds, want de gepatchte writer en de gepatchte reader zijn het met elkaar eens. Excel is het niet met ze eens. Een bestand dat zo wordt geschreven bewaart het eerste custom font als ifnt 4, wat Excel herleidt tot het standaardfont, en elk later custom font belandt één record te vroeg. Het lezen van de eigen bestanden van Excel gaat de andere kant op: elk font bindt één record te laat

De zero-based mislezing waarbij een writer en reader one-based FontIndex-waarden als zero-based behandelen, het eerste custom font als het verboden ifnt 4 weggeschreven dat Excel naar het standaardfont herleidt, en elk later font één record te vroeg doen belanden, terwijl roundtrips tussen de twee toch slagen
Een writer en reader die dezelfde mislezing delen, doorstaan elke opslag-daarna-heropen-test, terwijl elk font dat Excel opent één record ernaast belandt

Twee signalen verraden de mislezing voordat hij verscheept. De ene is een test die ifnt < FontCount claimt. Hij lijkt op een grenscontrole en schrijft de mislezing feitelijk als eis op. Een test die elke geschreven ifnt via de specificatieformule terugmapt op een FONT-recordnaam, vangt de verschuiving bij zijn eerste keer draaien

Het andere signaal is code die zichzelf tegenspreekt. Een complete BIFF8-lezer en -writer past de skip-4-regel op meerdere plekken toe: XF-uitvoer, XF-invoer, run-hernummering van gedeelde strings, commentaar-runs, chart-fontrecords. Als een wijziging sommige van die plekken naar zero-based nummering verplaatst en de rest met rust laat, zijn de onaangeroerde plekken het bewijs, dus verdenk de wijziging voordat je ze verdenkt. Een partiële wijziging kan lang onderduiken, want fonts die in rich text worden gebruikt worden meestal ook door een of andere celopmaak gerefereerd

Waarom breken commentaar-fontruns pas bij de tweede opslag?

Commentaar- en tekstvak-runs kunnen één opslag overleven en bij de volgende breken wanneer twee schrijfhabits elkaar ontmoeten. De eerste habit is asymmetrisch snoeien: de eerste N-1 FONT-records onvoorwaardelijk op hun plek houden en alleen het laatste weggooien als geen XF ernaar verwijst. De tweede is de TXO-formatteerruns ([MS-XLS] §2.4.329) byte voor byte terugschrijven zonder ze te hernummeren. Elke habit doorstaat op zichzelf een eenmalige opslagtest. Samen leggen ze een fontverlies aan dat één generatie wacht

De oorzaak zit in wat Excel schrijft. Door Excel gemaakte .xls-bestanden eindigen vaak op een niet-gerefereerd achterste font; op een systeem met een Chinese locale is dat een DengXian van 9 pt. Bij de eerste opslag is het font dat alleen een commentaar-run gebruikt daardoor nooit het laatste, en er schuift niets zichtbaars. Die opslag gooit wel het achterste font weg en promoveert het alleen-door-commentaar-gebruikte font naar de laatste positie. De tweede opslag vindt een laatste font zonder XF-verwijzing en wipt het. De ifnt van de run wijst nu voorbij het einde van de tabel, en Excel valt terug op het standaardfont. Heeft de werkmap intussen een font gekregen, dan bindt de run aan de nieuwkomer in plaats van aan het verdwenen font. Notities die keer op keer worden geopend, van aantekeningen voorzien en opnieuw worden opgeslagen, zoals die in het bouwen van een comments- en hyperlinks-reviewworkflow, zijn waar dit het eerst opduikt

Fonttabel over twee opslagen waarbij het niet-verwezen achterste FONT-record dat Excel schrijft eerst wordt weggegooid, het alleen-door-commentaar-gebruikte font laatste wordt en dan bij de tweede opslag verdwijnt omdat TXO-opmaakruns worden teruggeschreven zonder ze als fontreferenties mee te tellen
De eerste opslag oogt schoon omdat het achterste font de klap opvangt; het commentaarfont verdwijnt pas bij de tweede, dus een fontcontrole moet zich over meer dan één opslag uitstrekken

HotXLS behandelt commentaar- en tekstvak-runs net zoals hij gedeelde-string-runs behandelt. Voordat de fonttabel wordt gecomprimeerd, wordt elke run op elk werkblad van zijn skip-4-FontIndex naar een tabelplek omgezet en als verwijzing meegeteld, wat een font dat alleen een run gebruikt in leven houdt. Op de uitgaande weg gaan de runs door dezelfde plek-naar-opslagnummer-tabel die ook de XF-records hernummert. De afsluitende TxOLastRun-entry draagt geen font en wordt geschreven zoals hij werd gelezen. Door die hernummering zegt een vergelijking van FontIndex-waarden voor en na een opslag niets; vergelijk de fontnamen waarnaar ze herleiden

Kopieën, rij-inserts en runs die werkmapgrenzen oversteken

In de klassieke engine lopen Range.Copy, CopyRange, Sheets.AddCopy en de celverschuivingen achter Range.Insert en Range.Delete door één celkopieerpad, en een verschuiving is gewoon een kopie gevolgd door een leegmaakactie. Een kopie die alleen de commentaartekst en de auteur zou meenemen, maakt van een notitie met twee runs een notitie met één font na een enkele rij-insert, zonder dat de gebruiker het commentaar aanraakt

HotXLS kopieert de startoffset en het font van elke run samen met de tekst. Binnen één werkmap wordt de FontIndex ongewijzigd hergebruikt. Over werkmappen heen verhuist het font bij waarde: het skip-4-nummer wordt naar een tabelplek omgezet, het font wordt op zijn attributen in de doeltabel gematcht of toegevoegd, en de resulterende plek wordt terug naar bestandsnummering omgezet. Rich text in gedeelde strings loopt door dezelfde conversie wanneer Sheets.AddCopy een blad naar een andere werkmap kopieert, zodat de twee runsoorten niet kunnen uiteengroeien. De fonttabelkant volgt dezelfde bij-waarde-aanpak als de formulekant die in cross-workbook copy en formula rebinding wordt behandeld

Twee randgevallen zijn het weten waard als je hier tests voor schrijft:

  • Een plakking op dezelfde plek, waarbij bron en doel naar hetzelfde commentaar herleiden, houdt zijn runs; er wordt niets leeggemaakt voordat het is gelezen
  • Sheets.AddCopy kopieert ook commentaar dat op cellen is geankerd zonder opgeslagen celrecord, wat een lus over opgeslagen cellen alleen zou missen

Op de XLSX-engine klonen kopieën commentaar-runs bij waarde, en het comments-part wordt gelezen en geschreven met rFont, strike, u en vertAlign. De fontnaam, doorhaling, onderstreping en de instelling superscript of subscript van een run komen dus intact terug na opslag en heropenen

Een regressietest die hernummering overleeft

Elke valkuil in dit artikel doorstaat een in-memory test. De zero-based mislezing woont in een op elkaar afgestemde writer en reader, het commentaarfontverlies vraagt twee opslagen, en verloren commentaar-runs op XLSX tonen zich pas na een heropening. De test moet dus vanaf schijf heropenen, ten minste twee opslaggeneraties draaien en de runstructuur controleren in plaats van rauwe fontnummers. Begin bij een werkmap die Excel zelf heeft opgeslagen, met een commentaar van twee runs op C2 waarvan de tweede run een font gebruikt dat verder niets in het bestand aanraakt; dat is precies het font dat de tweede opslag anders zou weggooien

procedure CheckNoteAcrossTwoSaves(const SrcFile, Out1, Out2: string);
var
  Book: IXLSWorkbook;
  Note: TXLSComment;
  RunCount: Integer;
  SecondRunAt: Word;
begin
  // Assert-aanroepen zijn je eigen testcontroles
  Book := TXLSWorkbook.Create;
  Assert(Book.Open(SrcFile) = 1);          // door Excel opgeslagen, C2 heeft twee 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 schuift naar C3
  Assert(Book.SaveAs(Out1) = 1);

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

  Book := TXLSWorkbook.Create;               // heropen, vertrouw nooit het geheugen
  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;

Het runaantal en de startoffsets vangen afgevlakte notities. Het font zelf vraagt één stap buiten de test: open Out2 in een recordviewer, haal de ifnt van elke run door FontIndexToRecordNo en bevestig dat het FONT-record waar hij op landt dezelfde fontnaam draagt als in het bronbestand. In Excel toont een verloren font zich als het standaardtypeface bij de tweede run van de C3-notitie

Klassieke XLS duikt nog volop op in Delphi- en C++Builder-projecten, en elke fontconsument in een BIFF8-bestand moet het over §2.5.129 eens worden wil de uitvoer correct in Excel openen. HotXLS, de Delphi-spreadsheetcomponent past de skip-4-nummering toe over celopmaak, gedeelde strings, commentaar, tekstvakken en grafieken, hernummert runs bij elke opslag en verplaatst ze bij waarde tussen werkmappen, en leest en schrijft zowel XLS als XLSX zonder Excel of OLE-automatisering