CALL-Programme als CALLP

[Fuerchau]

Wobei das bei "alten" RPG oder gar CLP's wohl etwas schwierig wird.

Soviel dazu, dass CONST im rufenden Programm mal wieder nicht sicher ist.
Was nützt mir da die Compilerprüfung im gerufenen Programm.

Jetzt muss ich ja doch wieder Hilfsvariablen rummoven um mich vor Änderungen zu schützen.

Aus dem alten simplen
CALL 'MYPGM'
PARM SOURCE DEST

wird dann wieder
DEST = SOURCE;
MYPGM(DEST);

[BenderD]

d NOP2            pr                  extpgm('NOP2')
d Kappes                        10                  
 *                                                  
d NOP2            pi                                
d Kappes                        10                  
 /free                                              
       Kappes = 'denkste';                          
       return;                                      
 /end-free 

*********************

d NOP2            pr                  extpgm('NOP2')
d Kappes                        10    const         
d noKappes        s             10                  
d                                                   
 *                                                  
 /free                                              
       noKappes = 'kein Kappes';                    
       NOP2(noKappes);                              
       dsply noKappes;                              
       return;                                      
 /end-free 

******************
call tstnop2
=> 'denkste'

D*B

PS: RPG ist und bleibt ein Wackelhaufen, der Compiler glaubt schlicht was ein Programmierer im Prototyp behauptet und wenn man nix behauptet (*entry PLIST) glaubt er alles.

=> CONST im Prototyp beim aufrufenden Programm schützt davor, dass Änderungen zurück kommen und prüft sonst nix!

CONST im Prototyp des Procedure Interfaces des aufgerufenen Programmes prüft, dass man die Finger davon lässt!

[B.Hauser]

Wobei das bei "alten" RPG oder gar CLP's wohl etwas schwierig wird.

Soviel dazu, dass CONST im rufenden Programm mal wieder nicht sicher ist.
Was nützt mir da die Compilerprüfung im gerufenen Programm.

Jetzt muss ich ja doch wieder Hilfsvariablen rummoven um mich vor Änderungen zu schützen.

Aus dem alten simplen
CALL 'MYPGM'
PARM SOURCE DEST

wird dann wieder
DEST = SOURCE;
MYPGM(DEST);

Deshalb sollte man ja auch die Prototypen für alte Programme auch nicht mit irgendwas bestücken, das vorher auch nicht unterstützt war.

Die Rummoverrei musstest Du vorher auch machen!

Noch schlimmer wird's wenn in alten Programmen optionale Parameter verwendet wurden, die zudem nicht im aufgerufenen alten Programm abgeprüft wurden.

Birgitta

[Fuerchau]

Ob dein Programm die Aufrufparameter über *ENTRY oder Interface definiert ist dem rufenden Programm letztlich egal da es sich hierbei ausschließlich um Compiler-Direktive handelt.

Wenn du dir per DSPPGM mal die Anzahl Parameter (Programmstatistik) ansiehst, so wirst du feststellen dass jedes Programm zwischen 0 und 255 Aufrufparameter hat selbst wenn du keine definiert hast.

Deshalb gibt es ja erst Laufzeitfehler nach dem Aufruf eines Programmes. Die Anzahl Parameter kannst du mit %parms() abfragen und ob ein Parameter besetzt ist mit %addr(Parm) = *NULL.

Beim CLP wird die Anzahl der Parameter festvorgegeben, weshalb es da ggf. beim Aufruf schon den Parameterfehler gibt.

Eine Mischung zwischen ILE- und OPM-Calls ist daher jederzeit möglich.