BinToHex Probleme

[delphinia]

Hallo habe einen Binary< Wert in der Registry

diesen will ich umwandeln:

Delphi-Quellcode:

            BufferSize := Reg.GetDataSize('Typename');
            GetMem(Buffer, BufferSize);
            GetMem(Text, BufferSize * 2);
            try
               Reg.ReadBinaryData('Typename', Buffer^, BufferSize);

              BinToHex(Buffer, Text, BufferSize);
            finally
              FreeMem(Text);
              FreeMem(Buffer);
            end;

Das funktioniert auch soweit nur ist in "Text" der Wert PLUS einem * am Ende wo kommt das her?

der Binary Wert ist := 00 00 11 00

Was ich damit bezwecke will den Binary in DWORD umwandeln bzw halt in Integer

[p80286]

Also zu nächst würde mich das Ergebnis interessieren, ist das x04,x4,04 oder 12 oder 0C oder was?
Dann frage ich mich mit welchenPuffergrößen Du arbeitest.
für ein Byte benötigst Du 8 Bit = 8 Zeichen. in der Hexadezimaldarstellung solltest Du aber mit 2 Zeichen auskommen, und nicht die doppelte Menge benötigen.
Und woher weißt Du denn was in "Text" steht?

Gruß
K-H

[Aphton]

Delphi-Quellcode:

            BufferSize := Reg.GetDataSize('Typename');
            GetMem(Buffer, BufferSize);
            GetMem(Text, BufferSize * 2);
            FillChar(Text^, BufferSize, #0);
            try
               Reg.ReadBinaryData('Typename', Buffer^, BufferSize);

              BinToHex(Buffer, Text, BufferSize);
            finally
              FreeMem(Text);
              FreeMem(Buffer);
            end;

Kommts immernoch?! Falls nein, dann hast du nen Fehler - GetMem(Text, BufferSize) wäre dann die Ausbesserung!

[delphinia]

@Aphton

ja


das hier ist meine komplette procedure:

Delphi-Quellcode:

var

  Buffer, Text: PAnsiChar;
  BufferSize: Integer;
  reg: TRegistry;
begin
  reg := TRegistry.Create;
  try
    reg.RootKey := HKEY_LOCAL_MACHINE;

    if reg.OpenKey('\Software\MikroFil', false) then
    begin

      if (reg.ValueExists('Typename')) then
        if (reg.GetDataType('Typename') = rdBinary) then
        begin
          BufferSize := Reg.GetDataSize('Typename');
          GetMem(Buffer, BufferSize);
          GetMem(Text, BufferSize * 2);
          FillChar(Text^, BufferSize, #0);
          try
            Reg.ReadBinaryData('Typename', Buffer^, BufferSize);
            BinToHex(Buffer, Text, BufferSize);
          finally
            ShowMessage(Text); <----------------- Hier habe ich dann den * am Ende des sonst richtigen Wertes
            FreeMem(Text);
            FreeMem(Buffer);
          end;
        end;
    end;
  finally
    FreeAndNil(reg);
  end;

[Satty67]

Delphi-Quellcode:

GetMem(Text, BufferSize * 2);
FillChar(Text^, BufferSize, #0);

Da Text ein PAnsiChar ist, sollte das Füllen dann nicht auch mit

Delphi-Quellcode:

BufferSize * 2

arbeiten?

Delphi-Quellcode:

FillChar(Text^, BufferSize * 2, #0);

.

Sonst füllt man ja nur den Bereich, der sowieso mit den richtigen Daten gefüllt wird und kann garnicht testen, ob im Puffer mehr liegt.

[DeddyH]

Wäre es nicht generell angesagt, nicht mit 2, sondern mit SizeOf(Char) zu multiplizieren? Dann muss man sich um die Ansi-/Unicode-Problematik keinen Kopf machen.

[Blup]

Sollte "Text" nicht um ein Zeichen länger sein, um mit einem abschließenden #0-Zeichen das Ende der Zeichenkette zu markieren?

[DeddyH]

Laut Hilfe nicht (Unicode-Version):

Zitat:

BufSize legt die Größe von Buffer fest. Text muss auf eine Zeichenfolge zeigen, die mindestens 2*BufSize-Byte groß ist, da jedes Hexadezimalzeichen zwei Bytes darstellt.

[Blup]

Hier wird mit PAnsiChar gearbeitet:

Zitat:

Text gibt einen nullterminierten String zurück, der den in Buffer übergebenen Wert als Hexadezimalzahl darstellt.

BufSize legt die Größe von Buffer fest. Text muss auf eine Zeichenfolge zeigen, die mindestens 2*BufSize-Byte groß ist, da jedes Hexadezimalzeichen zwei Bytes darstellt.

Für die Funktion BinToHex mag das Nullzeichen am Ende egal sein (BuffSize wird ja übergeben).
Aber ShowMessage möchte sicher auch wissen, wie lang der übergebene Text ist.

[DeddyH]

Bei solchen Dingen gehe ich persönlich immer auf Nummer Sicher und schreibe noch

Delphi-Quellcode:

SetLength(StringVar, StrLen(PChar(StringVar)));

dahinter, bevor ich auf den ermittelten String zugreife.

[delphinia]

habe nun drei stunden rumgespielt - versteh zwar nur die Hälfte; aber auch ein blinde Huhn findet mal ein Korn!


Das hier funktioniert, zumindest bis jetzt...

Delphi-Quellcode:

var
  Len: Integer;
  Buffer: array[0..4095] of Byte;
  txt: string;

begin
[....]
            Len := Reg.GetDataSize('Typename');
            if Len > 0 then
            begin
              Reg.ReadBinaryData('Typename', Buffer, SizeOf(Buffer));
              SetLength(txt, Min(Len, SizeOf(Buffer)) * 2);
              BinToHex(@Buffer, PChar(txt), Len);
            end;
            ShowMessage(txt);

ShowMessage enthält nun genau den richtigen String!

Mag das jemand mir mal jemand gegenprüfen ob das auch nicht nur in meinem hier vorliegendem Beispiel standhält?





EDIT:
Was bedeutet das @ in Delphi?
Was bedeutet das ^ in Delphi?

Frage nur da man danach schlecht hier oder bei Google suchen kann...

[DeddyH]

@Var = Speicheradresse von Var
^Var = Zeiger auf Var
Var^ = Inhalt, der hinter dem Zeiger Var steckt

[Namenloser]

Zitat:

Zitat von delphinia (Beitrag 1107934)

EDIT:
Was bedeutet das @ in Delphi?
Was bedeutet das ^ in Delphi?

Das sind Pointer-Operatoren:

Delphi-Quellcode:

@Foobar

bedeutet „Die Adresse von Foobar im Speicher“ (Referenzierungsoperator)

Delphi-Quellcode:

Adresse^

bedeutet „Ding, das an dieser Adresse im Speicher steht“ (Dereferenzierungsoperator)
Achja, und

Delphi-Quellcode:

^Datentyp

bedeutet „Zeiger auf einen Datentyp“.

Delphi-Quellcode:

^Integer

wäre z.B. ein Zeiger auf einen Integer. Das braucht man zum dereferenzieren, damit der Compiler weiß, was für ein Typ sich überhaupt hinter einer Adresse verbirgt.

Für eine genauere Erklärung kannst du dir dieses Pointer-Tutorial aus der DP durchlesen.

[delphinia]

Danke Euch! :) werde ich heute abend lesen!