Adresse eine Funktion / Prozedur ermitteln

[Cyf]

Also - wenn man mal außer acht lässt, dass das asm-Konstrukt viel ästhetischer ist - was spricht hier eigentlich dagegen, mit den Prozedurnamen einen enum-Typ zu erstellen und beim Programmstart alle möglichen Einsprungspunkte der Prozeduren in ein Array zu packen? Für die Überprüfung bräuchte man dann noch ein zweites Array in dem die vom Benutzer zu benutzenden Befehle (also die Funktionsnamen), als Textstrings an den Indexen die dem enum-Typ entsprechen geparkt sind und schon muss man nur den übereinstimmenden Index suchen und springt dann an den Einsprungspunkt mit dem selben Index. Das hat die Vorteile, dass man bestimmen kann welche Funktionen zugänglich sein sollen (vom Benutzer) und welche nicht, es einfach zu handhaben ist und man die Funktionen ggf. intern anders nennen kann, als sie später von außen heißen sollen. Der einzige Nachteil der mir einfällt, sind 2 Zeilen Typarbeit und vielleicht 20 Byte Speicherverbrauch pro Funktion.
Ansonsten lagert man das ganze eben in Dlls aus, da kann man dann direkt nach dem Namen suchen und hängt die ggf. als Ressource an, wenn man wirklich eine umfangreiche Funktionsmenge bereitstellen will, macht das ohne hin Sinn, da der User wohl kaum immer alle brauchen wird.
Entschuldigt wenn das etwas verwirrend geschrieben ist, ist bisschen spät und ich bin jetzt weg.

[himitsu]

man kann auch in einer EXE eine Funktion/Prozedur als External definieren (halt so wie bei einer DLL)

ich weiß jetzt nicht, wie leicht es dann ist die Adressen umzurechnen (falls man due Funktion direkt in der EXE aufrufen will), aber die EXE läßt sich notfalls wie eine DLL einbinden (mit ein paar kleinen Anpassungen)

[static_cast]

Hallo,

gibt es von der "RunMethod" eine x64 Implementierung die auch mit XE5 laufen würde? Ich verwende Sie für diverse zwecke in meiner Anwendung, jedoch wollte ich diese nun in XE5 als 64Bit kompilieren und komme da nicht voran.

Viele Grüße
Daniel

Zitat von Neutral General:

*hust* Wie bestellt ist hier auch schon der neue Code *g*

Delphi-Quellcode:

class procedure TProceduren.RunMethod(AMethod: String;
  Params: array of Const);
var proc: Pointer;
    hi: Integer;
    i, off: Integer;
    param: Byte;
begin
  proc := MethodAddress(AMethod);
  hi := High(Params);
  asm
    mov param,0
    mov i,0
    @loop:
      mov eax,i
      cmp eax,hi
      jg @loopend    
        imul eax,i,8
        add eax,4
        mov off,eax
         
        mov eax,[Params]
        add eax,off
        movzx ax,byte ptr [eax]
         
        cmp ax,vtExtended
        je @EditParam
          inc param
          cmp param,2
          jle @NextLoop
        @EditParam:
          sub off,4
          cmp ax,vtExtended
          jne @NoExt
            mov eax,[Params]
            add eax,off
            mov eax,[eax]
            movzx edx, word ptr [eax+$08]
            push edx
            push [eax+$04]
            push [eax]
            jmp @NextLoop
          @NoExt:
            mov eax,[Params]
            add eax,off
            push [eax]
        @NextLoop:
          inc i
          jmp @loop
    @loopend:

    mov param,0
    mov i,0
    @loop2:
      mov eax,i
      cmp eax,hi
      jnl @loop2end
        imul eax,i,8
        add eax,4
        mov off,eax
        
        mov eax,[Params]
        add eax,off
        mov eax,[eax]

        cmp eax,vtExtended
        je @NextLoop2
        inc param

        cmp param,1
        je @edx
        cmp param,2
        je @ecx
        jmp @loop2end

        @edx:
          sub off,4
          mov eax,[Params]
          add eax,off
          mov edx,[eax]
          jmp @NextLoop2
        @ecx:
          sub off,4
          mov eax,[Params]
          add eax,off
          mov ecx,[eax]
          jmp @Loop2End
      @NextLoop2:
        inc i
        jmp @loop2
    @loop2end:

    mov eax,self
    call proc
  end;
end;

Int64's werden jedoch noch nicht unterstützt. Ich arbeite aber daran

Gruß
Neutral General

[Neutral General]

Hallo,

Also bisher nicht. Es sollte in 64Bit auch machbar sein, aber ich weiß halt nicht ob da die Parameter genauso abgelegt werden wie bei 32 Bit und die Register müssten angepasst werden..

Also wenn sich jemand freiwillig dran setzen will, dann kann er das gerne tun.
Generell würd ichs auch machen aber ich weiß nicht ob ich die Zeit dazu aufbringen kann/will.

Müsste mich auch erstmal wieder bisschen in ASM einarbeiten^^

[himitsu]

Wenn ich es richtig im Kopf hab, dann gibt es in Win64 kein Inline-Assembler mehr.

- entweder die Funktion in Pascal umwandeln (wird nicht einfach)
- oder diese "komplett" als Assembler, also auch proc := MethodAddress(AMethod); hi := High(Params); (natürlich via IFDEFs für x86 und x64)
- oder mal versuchen das über die neue RTTI zu lösen

[static_cast]

Hallo und danke euch zwei für die Antworten

Dachte mir schon das es nicht so einfach ist, aber fragen kostet ja nichts ^^ und da ich jetzt auch kein ASM-Crack bin versuch ich das dann wohl anders umzusetzen, oder ich lass es so und es gibt halt kein x64 build

Viele Grüße
Daniel