HexDump ausgeben

[MaBuSE]

Hier ist eine einfache Funktion um einen HexDump auszugeben.
Nichts besonderes, aber vieleicht kann es ja jemand gebrauchen.
(Sollte als Beispiel für einen typenlosen Parameter dienen.)
Viel Spaß
MabuSE

obiger Text als HexDump:

Code:

Größe: 215 Bytes
0000 : 48 69 65 72 20 69 73 74  20 65 69 6E 65 20 65 69 : Hier ist  eine ei
0010 : 6E 66 61 63 68 65 20 46  75 6E 6B 74 69 6F 6E 20 : nfache F unktion 
0020 : 75 6D 20 0D 0A 65 69 6E  65 6E 20 48 65 78 44 75 : um ..ein en HexDu
0030 : 6D 70 20 61 75 73 7A 75  67 65 62 65 6E 2E 0D 0A : mp auszu geben...
0040 : 4E 69 63 68 74 73 20 62  65 73 6F 6E 64 65 72 65 : Nichts b esondere
0050 : 73 2C 20 61 62 65 72 20  76 69 65 6C 65 69 63 68 : s, aber  vieleich
0060 : 74 20 0D 0A 6B 61 6E 6E  20 65 73 20 6A 61 20 6A : t ..kann  es ja j
0070 : 65 6D 61 6E 64 20 67 65  62 72 61 75 63 68 65 6E : emand ge brauchen
0080 : 2E 0D 0A 28 53 6F 6C 6C  74 65 20 61 6C 73 20 42 : ...(Soll te als B
0090 : 65 69 73 70 69 65 6C 20  66 FC 72 20 65 69 6E 65 : eispiel  für eine
00A0 : 6E 20 0D 0A 74 79 70 65  6E 6C 6F 73 65 6E 20 50 : n ..type nlosen P
00B0 : 61 72 61 6D 65 74 65 72  20 64 69 65 6E 65 6E 2E : arameter  dienen.
00C0 : 29 0D 0A 56 69 65 6C 20  53 70 61 DF 0D 0A 4D 61 : )..Viel  Spaß..Ma
00D0 : 62 75 53 45 0D 0A 00                             : buSE...

Delphi-Quellcode:

// Funktion: HexDump
// Gibt 1. Parameter als HexDump aus.
// Als 2. Parameter muß die Größe angegeben werden.
function HexDump(const y; size: Integer): string;
type
  TBytes = array[0..MaxInt - 1] of Byte;
var
  i, j: Integer;
  s: string;
begin
//  // Das würde reichen. Der Rest ist nur Optik ;-)
//  for i := 0 to size - 1 do
//  begin
//    j := TBytes(y)[i];
//    Result := Result + IntToHex(j, 2) + ' ';
//  end;

  Result := 'Größe: ' + IntToStr(size) + ' Bytes' + sLineBreak;
  for i := 0 to size - 1 do
  begin
    if (i mod 16) = 0 then Result := Result + IntToHex(i, 4) + ' : ';
    // Das i. Byte von y ermitteln
    j := TBytes(y)[i];
    // Hex Zahl ausgeben
    Result := Result + IntToHex(j, 2) + ' ';
    // lesbaren Bereich rechts ausgeben
    if j > 31 then s := s + Chr(j)
              else s := s + '.';
    // nach 8 Bytes Leerzeichen und
    // nach 16 Byte lesbaren Text sowie Zeilenumbruch ausgeben
    if (i mod 16) = 15 then
    begin
      Result := Result + ': ' + s + sLineBreak;
      s := '';
    end
    else if (i mod 8) = 7 then
    begin
      Result := Result + ' ';
      s := s + ' ';
    end;
  end;
  // Letzte Zeile kann weniger als 16 Byte haben -> mit Leerzeichen auffüllen
  if ((size-1) mod 16) < 15 then
  begin
    for i := ((size-1) mod 16) to 14 do Result := Result + '   ';
    if ((size-1) mod 16) < 7 then Result := Result + ' ';
    Result := Result + ': ' + s + sLineBreak;
  end;
end;

procedure TForm1.Button2Click(Sender: TObject);
var
  s1: string;
  s2: shortstring;
  a: array[0..2] of record x,y: Integer end;
begin
  // Test von HexDump
  s1 := 'Hallo, das ist ein Test.';
  s2 := 'Hallo, das ist ein Test.';
  a[0].x := 0;
  a[0].y := 1;
  a[1].x := 2;
  a[1].y := 3;
  a[2].x := 4;
  a[2].y := 5;
  // Courier sieht beim Dump schöner aus ;-)
  Memo1.Font.Name := 'Courier New';
  // Huch, es werden nur 4 Byte ausgegeben -> Ein String ist also ein Pointer
  Memo1.Lines.add(HexDump(s1, SizeOf(s1)));
  // Hier ist der Text ;-)
  // (Length + 1 ist immer 0, da es intern ein nullterminierter String ist.)
  Memo1.Lines.add(HexDump(Pointer(s1)^, Length(s1)+1));
  // Aha, wie früher in Turbo Pascal -> String ist 256 Byte groß und
  // 1. Byte beinhaltet die Größe (Länge) des Strings
  Memo1.Lines.add(HexDump(s2, SizeOf(s2)));
  // Das Array ist 25 Byte größ 3 x 2 Integer á 4 Byte
  Memo1.Lines.add(HexDump(a, SizeOf(a)));

  // Ausgabe letzter HexDump(a):
  // Größe: 24 Bytes
  // 0000 : 00 00 00 00 01 00 00 00  02 00 00 00 03 00 00 00 : ........ ........
  // 0010 : 04 00 00 00 05 00 00 00                          : ........
end;