Reihenfolge der Parameter in Prozeduren

[kmais]

Hallo Experten ...,

Ich habe beim Rumexperimentieren folgendes festgestellt:

Beim Übergeben von Parametern an eine Prozedur werden diese (anscheinend) von hinten nach vorne, also vom letzten
zum ersten, abgearbeitet.

Code: Alles auswählen

Define myVar.s

Procedure dummy(P1.i,P2.i,P3.i)
EndProcedure

Procedure Param2()
  Shared myVar
  Debug myVar
  ProcedureReturn #True 
EndProcedure

Procedure Param1(lokVar.s)
  Shared myVar
  myVar = lokVar
  ProcedureReturn #True 
EndProcedure

Procedure Param3()
  Shared myVar

  ProcedureReturn #True 
EndProcedure

dummy(Param1("Hallo Welt"),Param2(),Param3())
dummy(Param2(),Param1("Hallo Welt"),Param3())

Beim zweiten Durchlauf wird "Hallo Welt" ausgegeben, da die Variable in Param1 zugewiesen wird.
Beim ersten Durchlauf ist sie unbekannt, da die Prozedur, welche den Wert zuweist, noch nicht aufgerufen wurde. Entsprechend ihrer Reihenfolge bei der Parameterübergabe.

Meine Frage wäre, ist das grundsätzlich so, dass die Reihenfolge der Abarbeitung vom letzten zum ersten ist oder gerade mal ein Zufall.
Wenn ich mich darauf verlassen kann, könnte ich dies als Feature nutzen.

[ST4242]

Hallo,

das macht auch Sinn, das die Parameter von hinten nach vorne abgearbeitet werden.

Die Parameter müssen alle auf den Stack gelegt werden. Dannach ist der erste Parameter ganz oben.

Eventuelle optionale Parameter ganz unten (oder eben gar nicht vorhanden)

Daher denke ich das die immer so sein wird.

Grüße

[STARGÅTE]

Ja, die Prozedurparameter werden immer vom letzten zum ersten Parameter ausgeführt.

[NicTheQuick]

Trotzdem ist es kein guter Programmierstil auf so etwas aufzubauen. Das gehört dann zu den Nebeneffekten, die man vermeiden sollte.

[juergenkulow]

Code: Alles auswählen

; Reihenfolge Parameteraufruf 
Procedure.i dummy(P1.i,P2.i)
EndProcedure

Procedure Proc(Wert.i) 
  Debug Wert 
  ProcedureReturn Wert
EndProcedure

dummy(Proc(2),Proc(1)) 
; 1
; 2

; pbcompiler Kommandozeilen-Compiler erzeugt unter Windows x64 mit --commented: 
; dummy(Proc(2),Proc(1)) 
;   MOV    rcx,qword 1  ; Speichere im Stack-Register rcx den Wert 1 aus Proc(1).
;   CALL  _Procedure2   ; Rufe die Procedure Proc unter dem Namen _Procedure2 auf. 
;   PUSH   rax          ; Speichere das Ergebnisregister rax von ProcedureReturn Wert auf dem Stack. 
;   SUB    rsp,8        ; Berichtige den Zeiger auf den Stack. 
;   MOV    rcx,qword 2  ; Speichere im Stack-Register rcx den wert 2 aus Proc(2).
;   SUB    rsp,32       ; Berichtige den Zeiger auf den Stack. 
;   CALL  _Procedure2   ; Rufe die Procedure  Proc unter dem Namen _Procedure2 auf. 
;   ADD    rsp,40       ; Berichtige den Zeiger auf den Stack. 
;   MOV    rcx,rax      ; Speichere das Ergebnisregister rax im Stack-Register rcx.
;   POP    rdx          ; Hole das Ergebnis vom vorletzten Proc Aufruf vom Stack und 
;                       ;   speichere es auf dem Stackregister rdx.                      
;   CALL  _Procedure0   ; Rufe die Procedure dummy unter dem Namen _Procedure0 auf. 

; Mit dem Open-Source Programm x64dbg kann dummy(Proc(2),Proc(1)) Schritt für Schritt angezeigt werden.