Wo läuft das CL

[JonnyRico]

Hi,

vielleicht kann dir die API QWVRCSTK helfen. Über SNDMSG bekommt man glaube ich nur den Namen ohne LIB. Falls ich da falsch liege bin ich auch brennen an einer Lösung interessiert.

Gruß

Sascha

[Fuerchau]

Schau mal in folgendem Beitrag:
http://www.rlpforen.de/showthread.ph...light=QWVRCSTK

Dort ist am Ende ein Beispiel des API's.

PS:
Wer weiß, wo IBM das API wieder versteckt hat, denn wenn ich auf einer Nachricht, egal ob Joblog oder MSGQ, F1 (Detail) und F9 drücke, wird mir immer das Programm und die Lib angezeigt, selbst wenn das Programm schon lange nicht mehr aktiv ist.

[Robi]

so, hab es
RCVMSG PGMQ(*PRV) MSGTYPE(*LAST) RMV(*YES) MSG(&msg) ist der 1. Befehl in meinem CLLE
in &msg steht call lib/pgm
is mehr als einfach

Ok, vielleicht kompliziert wenn man den string erst analysieren muß, aber dafür haben wir srv-pgmme
(entferne vor, entferne ab, trim ...)


Vielen Dank (auch für das Api Bsp.), sowas kann man immer brauchen
Robi

[Fuerchau]

Diese Methode ist entscheidend, ob LOGCLPGM aktiv ist und die aufrufende Quelle dies auch erlaubt !
Schalte im Job mal LOGCLPGM(*NO) ein.
Ansonsten sieht man den CALL nur noch bei in Kommandozeilen eingegebenen Befehlen.
Wenn du unabhängig sein willst, benötigst du das API.

Und was machst du, wenn dein Programm z.B. von RPG aufgerufen wurde ?
Dann steht im Joblog garantiert nichts !!!!

[Robi]

Das ist natürlich richtig

aber ...
in diesem Fall ging es um eine cmdlin aufruf.
Hab trotzdem jetzt das api verwendet.
Da ich da allerdings mit meinen srv-pgmmen fast nix machen kann
Frage: kann ich eine feste stelle im &rcv abfragen ( in meinem BSP-PGM Stelle 67 länge 10 ?
oder ist der &rcv aufbau abhängig von irgendwas ?

[Frank Hildebrandt]

Hallo,

Hier ist noch ein Beispiel in RPG. In dem CL ist die Empfangsvariable zum API QWVRCSTK statisch auf eine Länge von 9999 Bytes gesetzt. Liefert das API mehr als 9999 Bytes an Informationen, dann könnte es Probleme geben, insofern alle Aufrufstapeleinträge verarbeitet werden sollen.
Im RPG ist die Sache dynamisch gelöst. Das Programm muss mit CRTBNDRPG gewandelt werden, wobei der Name des Programms STACK sein muss. Wer ein bischen pfiffig ist, der kann das Programm modifizieren und sämtliche Informationen, die das API liefert verarbeiten.

Frank

h DftActGrp(*NO) ActGrp(*CALLER)                                                                           
 *                                                                                                         
 *-------------------------------------------------------------------------------------------*             
 *                                                                                                         
 * Prozedurenprototyp für Prozedur 'STACK'                                                                 
 *                                                                                                         
dSTACK            PR                                                                                       
d                               10A                                        <-- Programm                    
d                               10A                                        <-- Bibliothek / Programm       
 *                                                                                                         
 * Prozedurenschnittstelle für Prozedur 'STACK'                                                            
 *                                                                                                         
dSTACK            PI                                                                                       
d PIPgm                         10A                                        <-- Programm                    
d PILibPgm                      10A                                        <-- Bibliothek / Programm       
 *                                                                                                         
 *-------------------------------------------------------------------------------------------*             
 *                                                                                                         
 * Prozedurenprototyp für Prozedur 'QWVRCSTK'                                                              
 *                                                                                                         
dQWVRCSTK         PR                  ExtPgm('QWVRCSTK')                                                   
d                            32767A   Options(*VarSize)                    <-- Receiver variable           
d                               10I 0 Const                                --> Length of receiver variable 
d                                8A   Const                                --> Format of receiver information       
d                            32767A   Const Options(*VarSize)              --> Job identification information       
d                                8A   Const                                --> Format of JII                        
d                            32767A   Options(*VarSize)                    <-> Error code                           
 *                                                                                                                  
 * Datenstruktur für Format 'CSTK0100' für Prozedur 'QWVRCSTK'                                                      
 *                                                                                                                  
dCSTK0100         DS                  Based(CSTK0100Ptr)                                                            
d CSTKByteRtn                   10I 0                                      --> Bytes returned                       
d CSTKByteAvl                   10I 0                                      --> Bytes available                      
d CSTKNbrCSEtyT                 10I 0                                      --> Number of call stack entries thread  
d CSTKOffCSInf                  10I 0                                      --> Offset to call stack entry info.     
d CSTKNbrCSEty                  10I 0                                      --> Number of call stack entries ret.    
d CSTKThrId                      8A                                        --> Returned thread identifier           
d CSTKInfSts                     1A                                        --> Information status                   
d CSTKRsrvd1                     9A                                        --> Reserved                             
 *                                                                                                                  
dCSTK0100Ptr      S               *                                                                                 
 *                                                                                                                  
dCSTK0100Ety      DS                  Based(CSTK0100EtyPtr)                                                         
d CSTKLngCSE                    10I 0                                      --> Length of this call stack entry      
d CSTKDisStId                   10I 0                                      --> Displacement to statement identifier 
d CSTKNbrStId                   10I 0                                      --> Number of statement identifiers      
d CSTKDisPrc                    10I 0                                      --> Displacement to the procedure name   
d CSTKLngPrc                    10I 0                                      --> Length of procedure name         
d CSTKReqLvl                    10I 0                                      --> Request level                    
d CSTKPgm                       10A                                        --> Program name                     
d CSTKLibPgm                    10A                                        --> Program library name             
d CSTKMIInsNbr                  10I 0                                      --> MI instruction number            
d CSTKMod                       10A                                        --> Module name                      
d CSTKLibMod                    10A                                        --> Module library name              
d CSTKCtlBdy                     1A                                        --> Control boundary                 
d CSTKRsrvd2                     3A                                        --> Reserved                         
d CSTKActGrpNbr                 10I 0                                      --> UNSIGNED Activation group number 
d CSTKActGrpNam                 10A                                        --> Activation group name            
d CSTKRsrvd3                     2A                                        --> Reserved                         
d CSTKPgmASP1                   10A                                        --> Program ASP name                 
d CSTKLibPgmASP1                10A                                        --> Program library ASP name         
d CSTKPgmASP2                   10I 0                                      --> Program ASP number               
d CSTKLibPgmASP2                10I 0                                      --> Program library ASP number       
 *                                                                                                              
dCSTK0100EtyPtr   S               *                                                                             
 *                                                                                                              
 * Datenstruktur für Format 'JIDF0100' für Jobidentifikationsinformationen                                      
 *                                                                                                              
dJIDF0100         DS                                                                                            
d JIDFJob                       10A                                        --> Job name                         
d JIDFUsr                       10A                                        --> User name                        
d JIDFNbr                        6A                                        --> Job number               
d JIDFIntJobId                  16A                                        --> Internal job identifier  
d                                2A   Inz(X'0000')                         --> Reserved                 
d JIDFThr1                      10I 0                                      --> Thread indicator         
d JIDFThr2                       8A                                        --> Thread identifier        
 *                                                                                                      
 * Datenstruktur für zurückgegebene Daten vom API                                                       
 *                                                                                                      
dAPI              DS                                                                                    
d APIByteRtn                    10I 0                                      --> Bytes returned           
d APIByteAvl                    10I 0                                      --> Bytes available          
 *                                                                                                      
 * Datenstruktur für Format 'ERRC0100' für Fehlercode                                                   
 *                                                                                                      
dERRC0100         DS                                                                                    
d ERRCBytePrv                   10I 0 Inz(272)                             --> Bytes provided           
d ERRCByteAvl                   10I 0                                      <-- Bytes available          
d ERRCExcId                      7A                                        <-- Exeption-Id.             
d ERRCRsrvd                      1A                                        <-- Reserved                 
d ERRCExcDta                   256A                                        <-- Exeption data            
 *                                                                                                      
 * Programmstatusdatenstruktur                                                                          
 *                                                                                                      
dPSDS            SDS           429                                                                      
d ITJob                 244    253A                                                                      
d ITUsr                 254    263A                                                                      
d ITNbr                 264    269A                                                                      
 *                                                                                                       
 * Felddeklarationen                                                                                     
 *                                                                                                       
dDYN              S              1A   Based(DYNPtr)                        Dynamisch                     
dDYNPtr           S               *                                        Zeiger auf "Dynamisch"        
dITEty            S             10I 0                                      Einträge                      
dITCurPgm         S             10A                                        Aktuelles Programm            
dITCurLibPgm      S             10A                                        Aktuelle Bibliothek / Programm
 *                                                                                                       
 *-------------------------------------------------------------------------------------------*           
 *                                                                                                       
 * Programm ermitteln, welches das Programm aufgerufen hat                                               
c                   Eval      PIPgm = '*ERROR'                                                           
c                   Eval      PILibPgm = '*ERROR'                                                        
 * Job Identifikations Informationen erstellen                                                           
c                   Eval      JIDFJob = ITJob                                                            
c                   Eval      JIDFUsr = ITUsr                                                            
c                   Eval      JIDFNbr = ITNbr                                                            
c                   Eval      JIDFIntJobId = *Blanks                                                     
c                   Eval      JIDFThr1 = 1                                                               
c                   Eval      JIDFThr2 = X'0000000000000000'                                             
 * Aufrufstapel abrufen (Anzahl der benötigten Bytes ermitteln)                                               
c                   Reset                   ERRC0100                                                          
c                   CallP     QWVRCSTK(API :                               <-- Receiver variable              
c                                      %Len(API) :                         --> Length of receiver variable    
c                                      'CSTK0100' :                        --> Format of receiver information 
c                                      JIDF0100 :                          --> Job identification information 
c                                      'JIDF0100' :                        --> Format of JII                  
c                                      ERRC0100)                           <-> Error code                     
c                   If        ERRCExcId = *Blanks                                                             
 * Speicher zuordnen                                                                                          
c                   Alloc     APIByteAvl    DYNPtr                                                            
 * Aufrufstapel abrufen                                                                                       
c                   Reset                   ERRC0100                                                          
c                   CallP     QWVRCSTK(DYN :                               <-- Receiver variable              
c                                      APIByteAvl :                        --> Length of receiver variable    
c                                      'CSTK0100' :                        --> Format of receiver information 
c                                      JIDF0100 :                          --> Job identification information 
c                                      'JIDF0100' :                        --> Format of JII                  
c                                      ERRC0100)                           <-> Error code                     
c                   If        ERRCExcId = *Blanks                                                             
 * Kopfinformationen                                                                                          
c                   Eval      CSTK0100Ptr = %Addr(DYN)                                                        
 * Auf ersten Satz positionieren                                                                              
c                   Eval      CSTK0100EtyPtr = %Addr(DYN) + CSTKOffCSInf                                      
c     1             Do        CSTKNbrCSEty  ITEty                                           
 * Programm ermitteln, welches das Programm aufgerufen hat                                  
c                   Select                                                                  
c                   When      ITEty = 3                                                     
c                   Eval      ITCurPgm = CSTKPgm                                            
c                   Eval      ITCurLibPgm = CSTKLibPgm                                      
c                   When      ITEty > 3                                                     
c                   If        CSTKPgm <> ITCurPgm Or                                        
c                             CSTKLibPgm <> ITCurLibPgm                                     
c                   Eval      PIPgm = CSTKPgm                                               
c                   Eval      PILibPgm = CSTKLibPgm                                         
c                   Leave                                                                   
c                   EndIf                                                                   
c                   EndSl                                                                   
 * Auf nächsten Satz positionieren                                                          
c                   Eval      CSTK0100EtyPtr = CSTK0100EtyPtr + CSTKLngCSE                  
c                   EndDo                                                                   
c                   EndIf                                                                   
 * Speicher freigeben                                                                       
c                   DeAlloc                 DYNPtr                                          
c                   EndIf                                                                   
 * Programmende                                                                             
c                   Eval      *INLR = *On 

[Fuerchau]

Da du nur den untersten Eintrag benötigst, kannst du konstant abfragen. Aber mit dem nächsten Release könnte es schon anders aussehen.

[Frank Hildebrandt]

Konstant abfragen kann man leider nicht. Ist das Programm, welches das Programm STACK aufruft ein OPM Programm, dann befindet sich der erforderliche Aufrufstapeleintrag immer in der vierten Position. Ist es ein ILE Programm wird es schon komplizierter. Sind in diesem ILE Programm keine Prozeduren definiert, dann befindet sich der erforderliche Aufrufstapeleintrag immer in der fünften Position. Sind Prozeduren definiert, so befindet sich der erforderliche Aufrufstapeleintrag in der fünften, oder der sechsten, oder der siebten u.s.w Position, je nachdem wie tief die Prozeduren verschachtelt sind. Dieser Umstand ist im Programm STACK berücksichtigt.