rekursiver Call

[Marimari1009]

Hallo, *all

um einen rekursiven Call zu vermeiden benötige ich den Namen des Programms, das das aktuelle Programm aufgerufen hat.

Die SDS Definition verspricht da nicht sehr viel.
Wer kann helfen?

Danke im Voraus

K. Hardy

[Fuerchau]

Hierfür gibts leider nur ein API für den Call-Stack.
Allerdings löst das nicht dein Problem, da das aktuelle Programm von einem Rekursiv-Call gar nichts mitbekommt.
Das aufrufende Programm erhält eine Abbruch-Nachricht, dass ein rekursiver Call nicht erlaubt ist !

[Marimari1009]

Hatte ich beinahe befürchtet, daß es nur über API geht.
Dann werde ich das wohl so machen müssen.
Ich gehe davon aus, daß dieseS API hier im Forum an anderer Stelle bereits beschrieben ist (?).

Das Problem ist dann glücklicherweise sehr wohl gelöst; es handelt sich hier nämlich um eine Dialog-Anwendung. Deshalb kann ich sehr elegant den Call verhindern/verbieten (F-Taste sperren etc.)

Sehr herzlichen Dank für Mühe

Klaus Hardy

[Fuerchau]

Tja, das sehe ich da nicht ganz so.
Ein rekursiver Call gilt auch dann, wenn irgendwann das selbe Programm nochmal aufgerufen wird:

PGM A
PGM B
PGM C
PGM D
PGM B <= Fehler an PGM D

Ich würde einen Call einfach mit BZ (RPG) bzw. Monitor (RPGLE) abfangen.
Im Status der SDS steht Fehler 202, gib dann einfach eine Meldung aus.

[kuempi von stein]

Moin moin,

ich hatte mal nen Fall, da dachte ich anfangs, ich brauche so einen "rekursiven" Call trotzdem.
(Da konnte man zwischen zwei Proggis hin un her schalten per F-Taste)
Hatte das dann mit nem vorgeschalteten CL gelöst und nen zusätzlichen Parameter mitgeschliffen um das dann zu ermöglichen.

Mit ein wenig Frickelei kann man das so hinbekommen.

In der Praxis wars dann aber gar nicht notwendig, weshalb ich das dann eh wieder rausgenommen hatte.

have fun

kuempi

[Fuerchau]

Es gibt Anwendungen, die das dann ganz elegant lösen:
Bei einem Fehlerhaften CALL und Status 202 wird per CLP das aufzurufende Programm einfach mit einer Laufnummer dupliziert und dann die Kopie aufgerufen.
Dies geht natürlich nur mit "CALL VARIABLE".

[B.Hauser]

Wenn es nur darum geht das rufende Programm zu ermitteln, sind 2 CL-Befehle ausreichend.

Beispiel:

          PGM        PARM(&CALLER           +                           
                          &CALLED)                                      
/* ---------------------------------------------------------------*/    
          DCL        VAR(&CALLER) TYPE(*CHAR) LEN(10)                   
          DCL        VAR(&CALLED) TYPE(*CHAR) LEN(10)                   
          DCL        VAR(&MSGKEY)   TYPE(*CHAR) LEN(4)                  
          DCL        VAR(&SENDER)   TYPE(*CHAR) LEN(80)                 
/* ---------------------------------------------------------------*/    
          SNDPGMMSG  MSG('TEST')                                  +     
                     TOPGMQ(*PRV (&CALLED))                       +     
                     MSGTYPE(*RQS)                                +     
                     KEYVAR(&MSGKEY)                                    
                                                                        
         RCVMSG     PGMQ(*PRV (&CALLED))                         +      
                      MSGKEY(&MSGKEY)                              +    
                      SENDER(&SENDER)                                   
           CHGVAR     VAR(&CALLER) VALUE(%SST(&SENDER 56 10))           
 ENDE:     ENDPGM 

Bei CALLED übergibst Du das aktuelle Programm und in CALLER bekommst Du das rufende Programm zurück.
Jetzt brauchst Du nur noch eine Schleife darum zu bauen, und jeweils immer den CALLER als CALLED übergeben, solange, bis Du entweder Dein Programm findest (Rekursiver Aufruf) oder bis Du am Anfang des CALL-Stack bist.

Ansonsten ist es auch möglich RPGIV-Programme rekursiv aufzurufen. Sie benötigen lediglich Aktivierungsgruppe *NEW.

Birgitta

[Marimari1009]

Vielen Dank an alle,

ich habe mich entschieden, in meinem Fall das (geniale) CL von Birgitta zu verwenden (Einverständnis vorausgesetzt); ist für bestehende Anwendungen ideal, vor allem wenn man es auf den Knall beim CALL nicht ankommen lassen will, sondern vorher Fußzeile und F-Tasten verändern / sperren möchte.

Die Statusabfrage (Fuerchau) werde ich versuchen, bei jedem CALL zum Standard zu machen (wird nicht einfach; ich bin im Unternehmen nicht der einzige PGMR).

Nochmals danke

Klaus Hardy

[Frank Hildebrandt]

Hier gibt es noch ein Beispielprogramm zum besagten API. Das API liefert noch eine ganze Menge an zusätzlichen Informationen. http://www.rlpforen.de/showthread.php?t=9375