Problème RTTI et Record

Version imprimable

Bonjour,

Cela fait des heures que je me prends la tête avec l'utilisation de RTTI sous Delphi XE6...

Je n'arrives pas à lister tous les noms / valeurs d'un record aussi bête que IMAGE_DOS_HEADER défini dans Windows.pas.

J'ai remarqué que le problème survient quand il tombe sur un array, logique semble t-il car il faudrait pouvoir aller plus en proffondeur, cependant j'ai essayé plein de méthodes j'obtiens à chaque fois une violation d’accès ou une exception "EInsufficientRTTI".

Des idées ???

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
var i           : integer;
fields      : TArray<TRTTIField>;
field       : TRTTIField;
 
RTTIType    : TRTTIType;
DosHeader : IMAGE_DOS_HEADER;
begin
allocconsole();
RTTIType := TRTTIContext.Create.GetType(TypeInfo(IMAGE_DOS_HEADER));
 
fields := RTTIType.getFields;
for i := 0 to High(Fields) do begin
  field := Fields[i];
 
  writeln(field.Name);
  writeln(field.getValue(@DosHeader).toString); // ERROR SUR e_res ET e_res2 QUI SONT DES ARRAY
  writeln('----');
end;

La déclaration de IMAGE_DOS_HEADER de Windows.pas

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
_IMAGE_DOS_HEADER = record             { DOS .EXE header                  }
      e_magic: Word;                     { Magic number                     }
      e_cblp: Word;                      { Bytes on last page of file       }
      e_cp: Word;                        { Pages in file                    }
      e_crlc: Word;                      { Relocations                      }
      e_cparhdr: Word;                   { Size of header in paragraphs     }
      e_minalloc: Word;                  { Minimum extra paragraphs needed  }
      e_maxalloc: Word;                  { Maximum extra paragraphs needed  }
      e_ss: Word;                        { Initial (relative) SS value      }
      e_sp: Word;                        { Initial SP value                 }
      e_csum: Word;                      { Checksum                         }
      e_ip: Word;                        { Initial IP value                 }
      e_cs: Word;                        { Initial (relative) CS value      }
      e_lfarlc: Word;                    { File address of relocation table }
      e_ovno: Word;                      { Overlay number                   }
      e_res: array [0..3] of Word;       { Reserved words                   }
      e_oemid: Word;                     { OEM identifier (for e_oeminfo)   }
      e_oeminfo: Word;                   { OEM information; e_oemid specific}
      e_res2: array [0..9] of Word;      { Reserved words                   }
      _lfanew: LongInt;                  { File address of new exe header   }
  end;

Remarque: je ne peux même pas tester quand j'arrive à e_res ou e_res2 si c'est un array, dés que je fais appel à la méthode getValue ça plante directe!

Je suis totalement perdu pour ce qu'il semble pourtant être quelque chose de très simple.

Merci d'avance pour votre précieuse aide !

Code:

e_res: array [0..3] of Word;

C'est compliqué de faire un AsString sur ce genre de valeur, un tableau comme cela pourrait être une suite de 4 valeurs mais aussi un Int64 découpé en 4 parties, la RTTI ne peut pas deviner ce que représente ce genre de valeur
une liste sérializée a souvent un séparateur entre chaque item ...

array [0..3] of Word n'est pas un type, il n'y a pas de RTTI puisque c'est une déclaration anonyme
C'est le même problème entre array of string et TStringDynArray !
Seul le dernier peut être utilisé comme type de retour d'une fonction, c'est une limitation connu du compilateur, les RTTI doivent avoir les memes

De plus, si l'on regarde le code de ToString :

Code:

tkArray: Result := '(array)'; // do not localize

la sortie n'est pas très intéressante pour un élément tableau

fait ta propre déclaration (juste pour tester)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
type
  TWordQuadArray = array [0..3] of Word;
  TWordTenArray = array [0..9] of Word;
  IMAGE_DOS_HEADER = record             { DOS .EXE header                  }
      e_magic: Word;                     { Magic number                     }
      e_cblp: Word;                      { Bytes on last page of file       }
      e_cp: Word;                        { Pages in file                    }
      e_crlc: Word;                      { Relocations                      }
      e_cparhdr: Word;                   { Size of header in paragraphs     }
      e_minalloc: Word;                  { Minimum extra paragraphs needed  }
      e_maxalloc: Word;                  { Maximum extra paragraphs needed  }
      e_ss: Word;                        { Initial (relative) SS value      }
      e_sp: Word;                        { Initial SP value                 }
      e_csum: Word;                      { Checksum                         }
      e_ip: Word;                        { Initial IP value                 }
      e_cs: Word;                        { Initial (relative) CS value      }
      e_lfarlc: Word;                    { File address of relocation table }
      e_ovno: Word;                      { Overlay number                   }
      e_res: TWordQuadArray ;       { Reserved words                   }
      e_oemid: Word;                     { OEM identifier (for e_oeminfo)   }
      e_oeminfo: Word;                   { OEM information; e_oemid specific}
      e_res2: TWordTenArray ;      { Reserved words                   }
      _lfanew: LongInt;                  { File address of new exe header   }
  end;

tu forces un nomage du type
puis sans tester j'écrirais ceci :

Code:

1
2
3
4
5
6
7
8
 
if field.getValue(@DosHeader).IsArray() then
begin
  for J := 0 to field.getValue(@DosHeader).GetArrayLength - 1 do
    writeln(field.getValue(@DosHeader).GetArrayElement(J).toString);
end
else
  writeln(field.getValue(@DosHeader).toString);

27/05/2015, 14h42
Phrozen

Merci !!!!!! :D

Je n'avais pas pensé à modifier les déclarations pour supporter le RTTI.

C'est domage que l'IDE ne supporte toujours pas la possibilité de gérer des array anonymes :(

+11