Hex to String

[XXcD]

Hallo,
ich versuche gerade Hexwerte in Strings umzuwandeln.
Folgendes habe ich bisher ausprobiert:

Delphi-Quellcode:

function HexStringToStr(s : string):string;
begin
  if s = '' then
    Result := ''
  else
  begin
    if Odd(length(s)) then
      s := '0'+s;
    SetLength(Result, Length(s) div 2);
    HexToBin(Pchar(s), PChar(Result), Length(Result));
  end;
end;

Procedure TForm1.Button1Click(Sender: TObject)
begin
HexStringToStr('01010005200B000D600200000100012806050000000205000D6002000101000560');
end;

Sowas kommt dabei raus:



Was mache ich falsch?

[DeddyH]

:wiejetzt: Ein Hexwert ist nur eine Darstellungsform einer Zahl. Stellst Du sie $FF dar, ist dies bereits ein String.

[XXcD]

???

Ich verstehe nicht ganz, ich weiß nicht was das damit zu tun hat.
Ich möchte gerne den gesammten string aus Hex werten umwandeln.
Normalerweise müsste da ein kommpletter Satz rauskommen.

Und ich habe noch herausgefunden, dass wenn man die Hexwerte einzeln umwandelt dann funkioniert es.

HexStringToStr('01');
HexStringToStr('01');
HexStringToStr('00');
HexStringToStr('05');
usw..

Aber ich brauche das ja in einem String.

[DeddyH]

Und welcher Satz?

[Dax]

"010100" wäre #1#1#0, was - in einem Windows-Control ausgegeben - zwei komischen Zeichen entspricht. Offensichtlich stimmt der Algorithmus, aber die Eingaben sind falsch ;)

[XXcD]

Also ich habe jetzt etwas kleines zusammen gebastelt, aber das funktioniert nicht richtig.
Also wo der Fehler jetzt ist weiß ich, aber wie kann ich das anders machen?

Delphi-Quellcode:

function hexinstring(d : string): string;
var
  I, s: Integer;
  t, n, y: string;
begin
s:=1;
for I := 1 to length(d) div 2 do
begin
 n:= copy(d, s, 2);
 y:=HexStrToString(n);
 t:=t+y; <--- hier liegt wohl der Fehler
s:= I * 2 + 1;
end;
Result:= t;
end;

[Muetze1]

Ich denke nicht, dass der Fehler dort liegt. Dax hat vollkommen Recht mit seinem Beitrag zuvor. Dein Hexadezimaler Eingabestring enthält definitiv keine Zeichenkodes. Schau dir mal die Signatur von mir an, da sieht man doch auf Anhieb, dass die Zeichenkodes deutlich grösser sind - das ergibt auch richtige Zeichen.

[XXcD]

Ok habe es jetzt hibekommen, der Hexwert war auch richtig(ist halt nur nen Beispiel gewesen),
aber wie kann ich die Funktion so umschreiben, dass die auch den HexWert 00 mit umwandelt.
Der wird nämlich einfach rausgeschnitten.

[turboPASCAL]

Zitat:

Zitat von Muetze1

49 63 68 20 68 61 62 65 20 6B 65 69 6E 65 20 41 68 6E 75 6E 67 20 21

44 61 73 20 67 6C 61 75 62 65 20 69 63 68 20 64 69 72 20 6E 69 63 68 74 20 !

Zitat:

Zitat von XXcD

aber wie kann ich die Funktion so umschreiben, dass die auch den HexWert 00 mit umwandelt.
Der wird nämlich einfach rausgeschnitten.

Nein, nur nicht angezeigt in deinem Memo oder was auch immer.

[Dani]

Was ist denn nach deiner Auffassung das richtige Ergebnis für den Wert 00? :|

[XXcD]

Hmm ich würde mal sagen garnichts.

Ich habe einen Hexwert der so aussieht: 01001770010004
Den muss ich in ein String umwandeln und zu einen Server schicken.
Wenn ich jetzt die gegenprobe mache und das wieder in einen Hexwert umwandel passiert folgendes: 0117700104
Die 00 sind einfach weg.

[Muetze1]

Das sind eindeutig Binärdaten und hexadezimal ist nur eine Darstellungsform. Somit glaube ich hier eher, dass du gar nicht richtig weisst, was du hier machst. Du willst Binärdaten dem Server schicken und somit ist der String nicht die geeignete Ablageform. Somit bekommst du diese Probleme.

[XXcD]

ohhh ihr wisst nicht was ich meine es sind keine Binärdaten, es sind einfach nur Befehle an den Server die nicht als Text sein sollen sondern als Befehle.
Und in Binärdaten gibt es nur 1 oder 0 und keine 7.
Ich kann auch nen anderen Hexwert zeigen, damit ihr überzeugt seit.

2061706F6C6F67697A6520666F7220616E7920696E636F6E76 656E69656E6365206361757365642E0D0A0D0A3C623E3

Hier könnt ihr euch übersetzen, dann seht ihr, dass es doch ein Hexwert ist.

Vielleicht hilft ja noch die Funktion mir der ich die Daten die ich empfange von strings in Hex werte umwandel:

Delphi-Quellcode:

function StrToHex(const S: String): String;
const
  HexDigits: array[0..15] of Char = '0123456789ABCDEF';
var
  I: Integer;
  P1: PChar;
  P2: PChar;
  B: Byte;
begin

  SetLength(Result, Length(S) * 2);
  P1 := @S[1];
  P2 := @Result[1];

  for I := 1 to Length(S) do
  begin
    B := Byte(P1^);
    P2^ := HexDigits[B shr 4];
    Inc(P2);
    P2^ := HexDigits[B and $F];
    Inc(P1);
    Inc(P2);
  end;

end;

[Muetze1]

Zitat:

Zitat von XXcD

Und in Binärdaten gibt es nur 1 oder 0 und keine 7.

Wer hat dir denn das geflüstert? Ein Binärwert hat nur 0 und 1 - und ist wiederrum (mal) wieder nur eine Darstellungsform. Die Daten selber sind in unterschiedlich grossen Datentypen organisiert. Als kleinste Einheit gibt es das Byte (es gibt logisch kleinere Einheiten, z.B. ein Nibble) und dies kann 2^8 (256) unterschiedliche Werte annehmen (0..255). Das nicht alle diese Werte im ASCII einfach nur dargestellt werden können, liegt daran, dass die Zeichen im unteren Bereich Steuerzeichen sind und diese bestimmte Funktionen erfüllen.

So, wenn wir nun von Binärdaten sprechen, dann hier mal ein Beispiel:

Du nimmst einen Integer mit einem Wert von 3. Diesen kannst du nun sehr schön ausgeben:

binär: 00000000 00000000 00000000 00000011
oktal: 000003
dezimal: 4
hexadezimal: 00 00 00 03
etc, etc, etc

Und wenn du ihn als String darstellst bzw. als Zeichen bekommst du #0#0#0#3 und das sind Steuerzeichen.

Wenn du nun das ganze nicht als Integer sondern als eine Zusammenfassung von 4 Bytes mit einer gewissen Priorisierung bzw. Anordung, dann hast du den Binärwert des Integers. Binärwerte haben einen gewissen Umfang von Bytes und geben keine Interpretation der Daten wieder sondern nur die Daten. Die Darstellungsformen wiederrum benötigen einen interpretierten Datenwert - hier interpretiert als Integer. Dieser definiert sich dadurch, dass er 4 Bytes benötigt, das oberste Byte kommt zuerst im Speicher, das unterste zuletzt. Das oberste Bit (31. Bit) gibt das Vorzeichen an. Mit diesen Informationen kann man die Binärdaten bewerten und dementsprechend verarbeiten.

Deine Ketten sind definitiv Binärdaten und haben spezielle Bedeutungen. Diese Bedeutungen solltest du entsprechend nutzen und interpretieren. Wenn der Server z.B: ein Datenpacket wie dieses braucht: (hex) 00 03 00 04 22 0A, dann sieht das zwar in Hex recht schön aus, sagt aber nichts über die Bedeutung/Bewertung der einzelnen Bits und Bytes aus.

Die selben Daten als Struktur:
1. Byte: Type (0 = Antwort, 1 = Anfrage, 2 = Status, etc)
2. Byte: Message Identification (01 = Server Version, 02 = Server Status, 03 = etc)
...
usw.

Somit kannst du diese Struktur in einem Record definieren und entsprechend interpretieren, aufbauen, auslesen. Diesen Record im Speicher wird genauso abgelegt wie die hexadezimale Darstellung es darlegt. Der Typ der Daten wird mit der Struktur definiert und somit kann man sie interpretieren.

Du hingegen hast bisher nur Bytes aneinander gereiht. Auch die Strings die du nachher sendest haben eine entsprechende Bedeutung. Es kommt mir eher so vor, als wenn du diese ganzen Daten einfach mit einem Sniffer mitgelesen hast und ohne zu wissen was sie im einzelnen bedeuten kommunizierst du mit dem Server.

Ob da nun kriminelle Energie zu Grunde liegt oder was auch immer, ist eine Interpretationsfrage. Grundlegend aber, fehlt hier offensichtlich Wissen deinerseits. Schon allein die Aussage

XXcD

ohhh ihr wisst nicht was ich meine es sind keine Binärdaten, es sind einfach nur Befehle an den Server die nicht als Text sein sollen sondern als Befehle.

bestätigt meine Annahme. Also entweder mehr Informationen und wissen was man tut, oder du kannst dies nicht entsprechend liefern (andere Vermutung).

Zitat:

Zitat von XXcD

Vielleicht hilft ja noch die Funktion mir der ich die Daten die ich empfange von strings in Hex werte umwandel:

Du übergibst einen String - bzw. du empfängst Daten und legst diese in einem String ab. Das bedeutet doch nicht, dass es ein String ist. Du legst Binärdaten in einem String ab - der ist nicht dazu gedacht. Und schon ist es definitiv ein String?

Ich kann auch meine EXE in einem String ablegen, aber es definitiv der falsche Kontainertyp dafür. Aber egal, du weisst es ja besser.

Und zu deiner Funktion: es gibt vorgefertigte Funktionen für beide Richtungen. Beide wurden aber schon gepostet in diesem Thread: HexToBin() und BinToHex()

[Klaus01]

Guten Morgen,

mach Dir doch ein Array of Char
und wandel mit

Delphi-Quellcode:

chr(StrToInt('$00'))

die HexWerte die in Stringform vorliegen
wieder in den ByteCode (hier char) um.
Das Array kannst Du dann zum Server übertragen.

Grüße
Klaus

[XXcD]

Ok das funktioniert genauso wie meine alte funktion.

Ich habe jetzt folgendes gemacht:

Delphi-Quellcode:

function HexStringToStr(d : string):string;
var
  I, s: Integer;
  n: string;
begin
s:=1;
for I := 1 to length(d) div 2 do
begin
n:= copy(d, s, 2);
Form6.packetinjecttemp.Text:=Form6.packetinjecttemp.Text+chr(StrToInt('$'+d));
s:= I * 2 + 1;
end;
end;

In Basic funktioniert die Function, da habe ich mir das ein wenig abgeschaut:

Code:

Public Function HexToString(sMessage As String) As String
Dim i As Integer
    For i = 1 To Len(sMessage) Step 2
        HexToString = HexToString & Chr(Int("&h" & Mid(sMessage, i, 2)))
    Next
End Function

Vielleicht weiß ja einer was da nicht stimmt.

[Klaus01]

..aber auch in dem Basic Beispiel sind
Zeichen mit einem AsciiWert von #0 nicht darstellbar.

Grüße
Klaus

[XXcD]

Hmmmmmm komisch da funktioniert das ganze ohne Probleme.
Was mache ich denn da falsch??

[Klaus01]

Vielleicht machst Du ja nichts falsch.
Im Basic Beispiel werden die Daten auch nicht angezeigt.
Du packst sie in ein Editfeld oder Memo oder sonstwas.

Die Zeichen sind alle im String enthalten, sie können aber nicht
angezeigt werden.
Setzte Dir mal einen Haltepunkt und schau Dir mal den String mit Strg-F5 an.

Grüße
Klaus

[XXcD]

Hat sich erledigt, funktioniert alles gut.

Vielen Dank :-D

[XXcD]

Hab jetzt noch eine Frage dazu, kann ich auch irgendwie die function aus VB in Delphi direkt benutzen?
Entweder den VB Code zu einem Delphi code convertieren, oder in VB eine DLL schreiben und die dann in Delphi einbinden.

Also mit dem COnverter weiß ich garnicht ob es sowas gibt und die DLL habe ich schon gemacht.

VB DLL:

Public Function HexToString(sMessage As String) As String
Dim i As Integer
For i = 1 To Len(sMessage) Step 2
HexToString = HexToString & Chr(Int("&h" & Mid(sMessage, i, 2)))
Next
End Function


Delphi Code:

Delphi-Quellcode:

function StringToHex(sMessage: string): string; stdcall;
external 'dll.dll';

Wenn ich die Anwendung starte wird mir direkt ne Fehlermeldung rausgegeben, dass die Funktion StringToHex in der dll.dll nicht gefunden wurde.

[Muetze1]

Zitat:

Zitat von XXcD

Also mit dem COnverter weiß ich garnicht ob es sowas gibt und die DLL habe ich schon gemacht.

Ich bin erstaunt, dass VB überhaupt DLLs erstellen kann. Aber du kannst definitiv diese Funktion in Delphi genauso nachbilden, somit ist die Frage ob sich der Aufwand auch nur ansatzweise lohnt.

Zitat:

Zitat von XXcD

VB DLL:

Public Function HexToString(sMessage As String) As String
Dim i As Integer
For i = 1 To Len(sMessage) Step 2
HexToString = HexToString & Chr(Int("&h" & Mid(sMessage, i, 2)))
Next
End Function


Delphi Code:

Delphi-Quellcode:

function StringToHex(sMessage: string): string; stdcall;
external 'dll.dll';

Wenn ich die Anwendung starte wird mir direkt ne Fehlermeldung rausgegeben, dass die Funktion StringToHex in der dll.dll nicht gefunden wurde.

Naja, hier postest du eine Funktion HexToString() und versuchst aber eine StringToHex() einzubinden. Das könnte Windows vllt. nicht auf Anhieb erkennen, dass es das gleiche sein soll.

Meinen Beitrag von zuvor beachtet? Oder einfach totschweigen da es doch einen illegalen Hintergrund hat?

[XXcD]

Ohh Sorry war nur nen schreibfehler von mir ich meine natürlich StringToHex.
Also in meinem Programm habe ich schon alles richtig war nur im Forum falsch geschrieben.

Ich glaube ich habe irgendwann auch mal gelesen, dass eine compilierte DLL, egal in welche Sprache geschrieben immer gleich ist.
Also verstehe ich nicht warum das nicht funktioniert.

[Luckie]

Moment, heißt das dein Code befindet sich in einer DLL?

[XXcD]

Also Der VB Code HexToString steckt in einer DLL Datei.
Der andere Code in Delphi ist direkt meine Anwendung.

[_frank_]

mit strings über Modulgrenzen hinweg zu arbeiten ist ziemlich ungünstig. Siehe auch die Hinweise im Unitkopf, wenn du versuchst, mit Delphi eine Dll zu erstellen. mal davon abgesehen vermute ich mal, dass VB Strings anders managed.
am besten du machsts wie die winapi, die verwendet
1. nur Pchar
(2. ohne out-parameter gibt es die länge des Results zurück (für speicher-reservierung))
3. die anwendung reserviert speicher und ruft die funktion mit out-Parameter (nochmal) auf

der funktionskopf würde dann so aussehen:
function (in,out:Pchar):integer;

bei HexToStr. kannst ja normal davon ausgehen, dass der Ausgabestring halb so groß ist wie der Hex-String und vice versa.

du machst es dir it der Dll zusätzlich schwer...versuhe lieber die funktion selbst auf delphi zu portieren...

btw.

Zitat:

Zitat von Muetze1

Du nimmst einen Integer mit einem Wert von 3. Diesen kannst du nun sehr schön ausgeben:

binär: 00000000 00000000 00000000 00000011
oktal: 000003
dezimal: 4
hexadezimal: 00 00 00 03

also die dezimale Darstellung erstaunt mich ein bisschen :shock: *g*

HTH Frank

[XXcD]

Aber wenn es daran liegt dann müsste ich doch ne Fehlermeldung kriegen wenn ich die Funktion benutze, aber ich kriege den Fehler ja beim öffnen: Der Prozedureinsprungpunkt "StringToHex" wurde in der DLL "...." nicht gefunden

[_frank_]

kenn mich mit VB nicht so aus, aber wenn der Name stimmt, hast du evtl. den Export vergessen, in delphi geht das über die exports-klausel.Ohne diese wird in die dll keine Tabelle mit den Namen hinterlegt, somit sind die funktionen von außen nicht per Name anspechbar.

Gruß Frank

[Muetze1]

Zitat:

Zitat von _frank_

also die dezimale Darstellung erstaunt mich ein bisschen :shock: *g*

Ups, damit wollte ich das alles eigentlich machen, da aber dann nur ein Bit gesetzt ist, habe ich mich auf die drei besonnen... Nun ja, ausser dort. Es sollte natürlich auch 3 sein... :oops:

Zitat:

Zitat von XXcD

..., aber ich kriege den Fehler ja beim öffnen: Der Prozedureinsprungpunkt "StringToHex" wurde in der DLL "...." nicht gefunden

Dann schau dir doch mal die Exporte der DLL an, die du erstellt hast. Dazu kannst u.a. den Dependency Walker nutzen oder auch das TDUMP Utility von Borland, was im Pfad liegt, wenn du Delphi installiert hast.

[XXcD]

Ok habe bei Google alles durchsucht aber mir hat nichts weitergeholfen.
Vielleicht weiß hier ja einer wie ich das mit den Exports mache.

[Medium]

Ich verstehe nun echt nicht, warum du statt deiner funktionierenden Delphi-Funktion auf einmal auf dem Trichter bist, auf Biegen und Brechen eine DLL mit einer anderen Sprache erstellt verwenden zu müssen. Vor allem für so eine simple Aufgabe - es gibt genau keinen Grund dafür. Das grundlegende Problem ist vermute ich noch immer, dass du nach wie vor noch nicht dahinter gestiegen bist, dass man zwischen Wert und seiner Darstellung unterscheiden muss, und dass Strings generell für dein Vorhaben einfach keine sinnvolle Wahl sind. Lass doch Strings einmal gänzlich aussen vor! (Wodurch kamst du eigentlich ursprünglich darauf, dass das Strings sein müssten?)

[_frank_]

wenn du 0-bytes bzw. steuerzeichen ausgeben willst, kannst du keinen string (auch kein PChar) nehmen, sondern musst auf ein binäres format umsteigen (z.b. array of byte oder TMemoryStream). Die geschichte mit der dll würde ich komplett außer acht lassen, da du damit nur Probleme bekommen wirst.

ungefähr so (ungetested):

Delphi-Quellcode:

ms:TMemoryStream;

ch:string[2];
b:byte;
i,c:integer;

ms:=TMemoryStream.create;
if odd(length(s)) then s:='0'+s;
c:=length(s) div 2;
for i:=0 to c-1 do
begin
  ch:=copy(s,i*2+1,2);
  b:=StrToInt('$'+ch);
  ms.write(b,1);
end;
ms.savetoFile('bin.dat');
ms.free;

HTH Frank

[XXcD]

Ja ich bin folgendermaßen auf den Trichter gekommen, weil ich in VB einen Quellcode habe der mit einem Server komuniziert.
Das wollte ich eigentlich zum größten Teil so übernehmen und auf Delphi halt anpassen.

Und jetzt habe ich eine Function fertig jetzt fängt das ganze spielchen wieder von vorne.
Ich habe nämlich noch mehr functionen die ich brauche:

Code:

Public Function StringToHex(sMessage As String) As String
Dim i As Integer
Dim sHex As String
    For i = 1 To Len(sMessage)
        sHex = Hex(Asc(Mid(sMessage, i, 1)))
        If Len(sHex) < 2 Then sHex = String(2 - Len(sHex), "0") & sHex
        StringToHex = StringToHex & sHex
    Next
End Function

Public Function LongToUnsigned(value As Long) As Double
    If value < 0 Then
        LongToUnsigned = value + 4294967296#
    Else
        LongToUnsigned = value
    End If
End Function

Public Function HexToString(sMessage As String) As String
Dim i As Integer
    For i = 1 To Len(sMessage) Step 2
        HexToString = HexToString & Chr(Int("&h" & Mid(sMessage, i, 2)))
    Next
End Function


Private Function longToHex(l As Long) As String
    longToHex = Hex(l)
    If Len(longToHex) < 4 Then longToHex = String(4 - Len(longToHex), "0") & longToHex
    longToHex = Right(longToHex, 2) & Left(longToHex, 2)
End Function

Private Function HexToDec(HexNumber As String) As String
  Dim i As Long
Dim sHexChar As String
Dim lLength As Long
Dim lPosiValue As Double
Dim Number As Double
    
    lLength = Len(HexNumber)
    For i = lLength To 1 Step -1
        sHexChar = Mid(HexNumber, i, 1)
        lPosiValue = HexToDecChart(sHexChar) * (16 ^ (lLength - i))
        Number = Number + lPosiValue
    Next
    HexToDec = Number
End Function

Private Function HexToBinChart(HexCode As String) As String

    Select Case UCase(HexCode)
    Case "0": HexToBinChart = "0000"
    Case "1": HexToBinChart = "0001"
    Case "2": HexToBinChart = "0010"
    Case "3": HexToBinChart = "0011"

    Case "4": HexToBinChart = "0100"
    Case "5": HexToBinChart = "0101"
    Case "6": HexToBinChart = "0110"
    Case "7": HexToBinChart = "0111"

    Case "8": HexToBinChart = "1000"
    Case "9": HexToBinChart = "1001"
    Case "A": HexToBinChart = "1010"
    Case "B": HexToBinChart = "1011"

    Case "C": HexToBinChart = "1100"
    Case "D": HexToBinChart = "1101"
    Case "E": HexToBinChart = "1110"
    Case "F": HexToBinChart = "1111"

    End Select

End Function

Private Function HexToDecChart(HexCode As String) As Long

    Select Case UCase(HexCode)
    Case "0": HexToDecChart = 0
    Case "1": HexToDecChart = 1
    Case "2": HexToDecChart = 2
    Case "3": HexToDecChart = 3

    Case "4": HexToDecChart = 4
    Case "5": HexToDecChart = 5
    Case "6": HexToDecChart = 6
    Case "7": HexToDecChart = 7

    Case "8": HexToDecChart = 8
    Case "9": HexToDecChart = 9
    Case "A": HexToDecChart = 10
    Case "B": HexToDecChart = 11

    Case "C": HexToDecChart = 12
    Case "D": HexToDecChart = 13
    Case "E": HexToDecChart = 14
    Case "F": HexToDecChart = 15

    End Select

End Function

Wenn ich die jetzt alle in Delphi umschreibe bin ich alt und grau.
Deshalb das mit der DLL, da ich den Code ja habe nur halt in VB.

[Medium]

Alle dieser Funktionen lassen sich mit Delphi-Bordmitteln (+ evtl. hier und da ein Kniff) in 1-3 Zeilen jeweils lösen. Schau dir doch einfach mal die Konvertierungsroutinen in der OH an!
Und selbst wenn man es selbst übersetzen wollte, ist das o.g. wohl mehr ne Aufgabe von max. nem Stündchen als von Jahren.

[Muetze1]

Die Funktionen sind grösstenteils unnötig bzw. schon in Delphi vorhanden.

[_frank_]

fertige Funktionen zur Zahlensystem-Umrechnung findest du hier im Forum, teilweise sogar in delphi vorhanden (StrToInt [Str/Hex=>Int],IntToStr,IntToHex)...du musst nicht alles neu schreiben.

dlls sind für einfache routinen und rückgabewerte sinnvoll. in dem Moment, wo du mit Strings, Speicherbereichen oder gar Objekten hantieren musst, sind sie umständlich bzw. kaum bis gar nicht zu gebrauchen.
entweder mach alles in VB, scheib die bytes in eine Datei und setze dann dort mit einer separaten Delphi-Anwendung an, oder mach alles in Delphi. du machst dir mehr arbeit, die DLL einzubinden und lauffähig zu bekommen (mal abgesehen von Fehlern die durch ungültige Speicherzugriffe entstehen) als wenn du die verabeitung gleich in einem Programm machst.

server === Hex-String ===> VB (verabeitung/Umwandlung) ==== temporäre Datei====> Delphi (Auswerten der bytes in der Datei)

irgendwann kannst du dann die Server-Kommunikation auch in delphi implementieren um den Umweg über die Datei zu verhindern. somit hält sich dein aktueller Arbeitsaufwand in Grenzen, solange du noch nicht so fit in delphi bist.

HTH Frank

[XXcD]

Aber wie mache ich z.b. ne funktion für inttohex?

[Muetze1]

Genau die gibt es schon in Delphi, unter gleichen Namen. Nutze die Hilfe. Schau in der Hilfe mal nach ähnlichen Ergebnissen. Schau nach, was in der jeweiligen Unit noch deklariert ist. etc.