Article technique

Index de police BIFF8 : le 4 sauté, runs HotXLS en Delphi

Un classeur BIFF8 avec huit enregistrements FONT contient un enregistrement XF dont le champ de police vaut 8. Comptez à partir de zéro et c'est une case après la fin de la table, et pourtant Excel rend la cellule dans la huitième police sans broncher. La valeur est légale : [MS-XLS] §2.5.129 numérote les quatre premiers enregistrements FONT de 0 à 3, saute entièrement le 4, et numérote chaque enregistrement suivant par sa position en base 1

Le cinquième enregistrement FONT est donc ifnt 5, et un fichier bien formé n'a jamais besoin d'une valeur plus grande que son nombre d'enregistrements FONT. La règle se lit comme une faute de frappe dans la spec, ce qui est exactement la raison pour laquelle on la « corrige », et comme les formats de cellule, le texte enrichi des chaînes partagées et les runs de commentaires portent tous le même type FontIndex, une lecture qui diffère entre chemins lie certaines polices correctement et d'autres avec un enregistrement de décalage. Cela appartient à la même famille que les bizarreries de longueur et d'encodage dans le décodage de cch et fHigh des XLUnicodeString BIFF8 — le fichier est sain, c'est sa lecture qui ne l'est pas

Ce que dit [MS-XLS] §2.5.129, et comment le vérifier sur un vrai fichier

[MS-XLS] §2.5.129 définit FontIndex comme une position d'enregistrement avec un trou dedans. Les valeurs sous 4 sont en base 0, les valeurs au-dessus de 4 en base 1, et la valeur 4 NE DOIT PAS être utilisée. Les enregistrements XF désignent les polices avec, les entrées FormatRun d'une chaîne partagée enrichie l'utilisent, et les runs de formatage TXO décrits en §2.5.272 aussi

Vous n'êtes pas obligé de croire la spec sur parole. Dumpez un .xls qu'Excel lui-même a sauvegardé avec n'importe quel visualiseur d'enregistrements BIFF, comptez les enregistrements FONT (type $0031), puis parcourez le champ de police au début de chaque enregistrement XF ($00E0). La valeur la plus haute reste dans le nombre d'enregistrements et le nombre 4 manque à la liste. Si vous trouvez un 4, ou une valeur au-dessus du nombre de FONT, le fichier a été écrit par autre chose qu'Excel et sa numérotation de polices mérite un regard plus attentif. Pour un outil de diagnostic ou un test, tout le mappage tient en deux fonctions

// Vos propres helpers, hors de toute bibliothèque
// [MS-XLS] 2.5.129 FontIndex : 0..3 en base 0, > 4 en base 1, 4 invalide
function FontIndexToRecordNo(Ifnt: Word): Integer;  // enregistrement FONT en base 1
begin
  if Ifnt < 4 then
    Result := Ifnt + 1
  else if Ifnt > 4 then
    Result := Ifnt
  else
    Result := -1;  // 4 ne doit pas apparaître
end;

function RecordNoToFontIndex(RecordNo: Integer): Word;
begin
  if RecordNo <= 4 then
    Result := RecordNo - 1
  else
    Result := RecordNo;
end;
Mappage FontIndex selon MS-XLS 2.5.129 où ifnt 0 à 3 sont des positions d'enregistrements FONT en base 0, ifnt 5 et au-delà sont en base 1 et la valeur 4 n'apparaît jamais, avec la conversion FontIndexToRecordNo
Le cinquième enregistrement FONT est ifnt 5, donc dans un fichier à N enregistrements FONT le plus grand ifnt légal est N et la valeur 4 n'est jamais stockée

Comment HotXLS numérote les polices dans les enregistrements XF et les runs de texte enrichi

HotXLS lit et écrit chaque référence de police BIFF8 dans la numérotation de la spec. À la sauvegarde, la table de polices est compactée aux polices que quelque chose référence réellement, et la position de chaque police survivante devient un FontIndex : les positions 1 à 4 sont écrites 0 à 3, la position 5 et au-delà sortent inchangées. Le chargement fait l'inverse, donc toute valeur de 5 ou plus descend de un pour trouver la police en mémoire et tout ce qui est sous 5 reste en place. La même conversion s'applique aux enregistrements XF, aux runs de texte enrichi de la table de chaînes partagées, aux runs de commentaires et de zones de texte, et aux références de police à l'intérieur des enregistrements de graphiques classiques

Pour le code applicatif, la partie visible est TextRuns sur TXLSComment et TXLSTextBox. TextRuns.FontIndex[I] renvoie la numérotation du fichier exactement telle que lue, avec le 4 sauté. Les index de runs sont en base 1, et CharIndex[I] est l'offset de caractère où commence le run I. Exposer le numéro du fichier plutôt qu'une case de table en base 0 est le meilleur défaut ici : ce que l'API rapporte correspond à ce qu'un dump d'enregistrements montre. Le coût est un appel au helper ci-dessus avant de traiter la valeur comme une position de table

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];   // numérotation du fichier, 4 sauté
      // votre propre contrôle : 4 signifie que le fichier viole 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;

Après une sauvegarde, le numéro stocké pour un run peut différer de celui que vous avez lu ou défini. La sauvegarde renumérote les runs en même temps que la table de polices compactée, donc le numéro change et la police qu'il désigne, non

Pourquoi une correction en base 0 décale chaque police personnalisée

Le piège commence en général par un rapport de bug d'apparence raisonnable. Quelqu'un dumpe un classeur à huit enregistrements FONT, voit un XF pointer sur la police 8, conclut que l'écrivain a produit un index hors limites, et bascule l'écrivain et le lecteur sur une arithmétique en base 0 toute simple. Le test aller-retour passe toujours, parce que l'écrivain patché et le lecteur patché sont d'accord entre eux. Excel n'est pas d'accord. Un fichier écrit ainsi stocke la première police personnalisée en ifnt 4, qu'Excel résout vers la police par défaut, et chaque police personnalisée suivante atterrit un enregistrement trop tôt. Lire les propres fichiers d'Excel va dans l'autre sens : chaque police se lie un enregistrement trop tard

La mauvaise lecture en base 0 où un écrivain et un lecteur traitent des valeurs FontIndex en base 1 comme en base 0, stockent la première police personnalisée dans le ifnt 4 interdit qu'Excel résout vers la police par défaut et font atterrir chaque police suivante un enregistrement trop tôt alors que les allers-retours entre les deux passent toujours
Un écrivain et un lecteur qui partagent la même mauvaise lecture passent tous les tests sauvegarde-réouverture, tandis que chaque police qu'Excel ouvre atterrit avec un enregistrement de décalage

Deux signaux trahissent la mauvaise lecture avant qu'elle ne soit livrée. Le premier est un test qui affirme ifnt < FontCount. Il ressemble à un contrôle de bornes, et il inscrit en réalité la mauvaise lecture comme une exigence. Un test qui remappe chaque ifnt écrit vers un nom d'enregistrement FONT via la formule de la spec attrape le décalage dès sa première exécution

L'autre signal est du code en désaccord avec lui-même. Un lecteur-écrivain BIFF8 complet applique la règle du 4 sauté à plusieurs endroits : sortie XF, entrée XF, remappage des runs de chaînes partagées, runs de commentaires, enregistrements de police des graphiques. Quand un changement fait passer certains de ces endroits en base 0 et laisse les autres tranquilles, les sites intacts sont des preuves, donc soupçonnez le changement avant de les soupçonner eux. Un changement partiel peut se cacher longtemps, parce que les polices utilisées dans le texte enrichi sont en général aussi référencées par un format de cellule

Pourquoi les runs de polices des commentaires cassent-ils seulement à la seconde sauvegarde ?

Les runs de commentaires et de zones de texte peuvent survivre à une sauvegarde et casser à la suivante quand deux habitudes d'écrivain se rencontrent. La première est l'élagage asymétrique : garder les N-1 premiers enregistrements FONT en place inconditionnellement et ne laisser tomber que le dernier quand aucun XF ne le référence. La seconde est de réécrire les runs de formatage TXO ([MS-XLS] §2.4.329) octet pour octet sans les renuméroter. Chaque habitude passe seule un test à une sauvegarde. Ensemble, elles préparent une perte de police qui attend une génération

La raison tient à ce qu'Excel écrit. Les fichiers .xls produits par Excel se terminent couramment par une police de fin non référencée ; sur un système en locale chinoise, c'est un DengXian 9 pt. À la première sauvegarde, la police qu'un run de commentaire est seul à utiliser n'est donc jamais la dernière, et rien ne bouge visiblement. Cette sauvegarde laisse pourtant tomber la police de fin et promeut la police réservée au commentaire en dernière position. La seconde sauvegarde trouve une dernière police sans référence XF et la jette. Le ifnt du run pointe maintenant au-delà de la fin de la table, et Excel se rabat sur la police par défaut. Si le classeur a gagné une police entre-temps, le run se lie au nouveau venu à la place. Les notes qui sont ouvertes, annotées et sauvegardées encore et encore, comme celles de la construction d'un workflow de revue par commentaires et liens hypertextes, sont l'endroit où cela apparaît en premier

Table de polices sur deux sauvegardes où l'enregistrement FONT de fin non référencé qu'Excel écrit tombe en premier, la police réservée au commentaire devient dernière puis est jetée à la seconde sauvegarde quand les runs de formatage TXO sont réécrits sans être comptés comme références de police
La première sauvegarde paraît propre parce que la police de fin encaisse la perte ; la police du commentaire ne disparaît qu'à la seconde, donc un contrôle de polices doit couvrir plus d'une sauvegarde

HotXLS traite les runs de commentaires et de zones de texte comme les runs de chaînes partagées. Avant que la table de polices soit compactée, chaque run de chaque feuille est converti de son FontIndex à 4 sauté en case de table et compté comme une référence, ce qui conserve une police qu'un run est seul à utiliser. En sortie, les runs passent par la même table case-vers-index-sauvegardé qui renumérote les enregistrements XF. L'entrée TxOLastRun de clôture ne porte aucune police et s'écrit telle que lue. À cause de cette renumérotation, comparer les valeurs FontIndex avant et après une sauvegarde ne vous apprend rien ; comparez les noms de police vers lesquels elles se résolvent

Copies, insertions de lignes et runs qui traversent les classeurs

Dans le moteur classique, Range.Copy, CopyRange, Sheets.AddCopy et les décalages de cellules derrière Range.Insert et Range.Delete passent tous par un seul chemin de copie de cellule, et un décalage n'est qu'une copie suivie d'un effacement. Une copie qui ne transporterait que le texte et l'auteur du commentaire transformerait une note à deux runs en note à une police après une simple insertion de ligne, sans que l'utilisateur touche au commentaire

HotXLS copie l'offset de départ et la police de chaque run avec le texte. Au sein d'un même classeur, le FontIndex est réutilisé tel quel. Entre classeurs, la police voyage par valeur : le numéro à 4 sauté est converti en case, la police est retrouvée ou ajoutée dans la table de polices de destination d'après ses attributs, et la case obtenue est reconvertie en numérotation de fichier. Le texte enrichi des chaînes partagées passe par la même conversion quand Sheets.AddCopy copie une feuille dans un autre classeur, donc les deux sortes de runs ne peuvent pas dériver l'une de l'autre. Le côté table de polices suit la même approche par valeur que le côté formules couvert dans la copie entre classeurs et la reliaison des formules

Deux cas limites valent la peine d'être connus quand vous écrivez des tests pour cela :

  • Un collage sur place, où source et destination se résolvent vers le même commentaire, garde ses runs ; rien n'est effacé avant d'avoir été lu
  • Sheets.AddCopy copie aussi les commentaires ancrés sur des cellules sans enregistrement de cellule stocké, qu'une boucle sur les seules cellules stockées raterait

Sur le moteur XLSX, les copies clonent les runs de commentaires par valeur, et la partie commentaires est lue et écrite avec rFont, strike, u et vertAlign. Le nom de police, le barré, le souligné et le réglage exposant ou indice d'un run reviennent donc intacts après sauvegarde et réouverture

Un test de régression qui survit à la renumérotation

Chaque piège de cet article passe un test en mémoire. La mauvaise lecture en base 0 vit dans un écrivain et un lecteur assortis, la perte de police de commentaire demande deux sauvegardes, et les runs de commentaires perdus sur XLSX ne se montrent qu'après une réouverture. Le test doit donc rouvrir depuis le disque, enchaîner au moins deux générations de sauvegarde, et vérifier la structure des runs plutôt que les numéros de police bruts. Partez d'un classeur qu'Excel lui-même a sauvegardé, avec un commentaire à deux runs sur C2 dont le second run utilise une police que rien d'autre dans le fichier ne référence ; c'est la police que la seconde sauvegarde laisserait tomber sinon

procedure CheckNoteAcrossTwoSaves(const SrcFile, Out1, Out2: string);
var
  Book: IXLSWorkbook;
  Note: TXLSComment;
  RunCount: Integer;
  SecondRunAt: Word;
begin
  // Les appels Assert sont vos propres contrôles de test
  Book := TXLSWorkbook.Create;
  Assert(Book.Open(SrcFile) = 1);          // sauvegardé par Excel, C2 a deux 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 passe en C3
  Assert(Book.SaveAs(Out1) = 1);

  Book := TXLSWorkbook.Create;               // deuxième génération
  Assert(Book.Open(Out1) = 1);
  Assert(Book.SaveAs(Out2) = 1);

  Book := TXLSWorkbook.Create;               // rouvrir, ne jamais faire confiance à la mémoire
  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;

Le nombre de runs et les offsets de départ attrapent les notes aplaties. La police elle-même demande une étape de plus hors du test : ouvrez Out2 dans un visualiseur d'enregistrements, passez le ifnt de chaque run dans FontIndexToRecordNo, et confirmez que l'enregistrement FONT sur lequel il tombe porte le même nom de police que dans le fichier source. Dans Excel, une police perdue apparaît comme la typographie par défaut sur le second run de la note C3

Le XLS classique reste présent dans bien des projets Delphi et C++Builder, et chaque consommateur de polices d'un fichier BIFF8 doit s'accorder sur §2.5.129 pour que la sortie s'ouvre correctement dans Excel. HotXLS, le composant tableur pour Delphi, applique la numérotation à 4 sauté aux formats de cellule, aux chaînes partagées, aux commentaires, aux zones de texte et aux graphiques, renumérote les runs à chaque sauvegarde et les déplace par valeur entre classeurs, et lit et écrit XLS comme XLSX sans Excel ni automation OLE