brainchime.com Latest Questions

Admin
Asked: 2024-10-09T07:47:05+05:30 In:

How to retrieve call stack information in RPG program?

How do you retrieve the call stack information in the rpgle program? For example, if we call pgm1, we want to know who called it or look for a particular program in the call stack. Is there any way to check the program call stack? Who is the program’s caller who called this program or whether a particular program is in the call stack so that we can build logic based on call stack program information?

as400rpg

Related Questions

Leave an answer

Leave an answer

Browse
Browse

Choose from here the video type.

Put Video ID here: https://www.youtube.com/watch?v=sdUUx5FdySs Ex: "sdUUx5FdySs".

2 Answers

  1. Admin

    We can use retrieve call stack API (QWVRCSTK) to retrieve the call stack information or the presence of a specific program in the call stack or find the calling program.

    I was searching for it more, and I just discovered that IBM has launched a new table function, STACK_INFO, that does the same job for us as QWVRCSTK API does. It seems to me that retrieving call stack information using the SQL table function stack_info is quite simple, as it allows us to use the SQL select to retrieve a record for each entry in the call stack for a specific thread in a job.

    You can use SQL to retrieve program stack information. The stack_info table function does the same task for us as done by the Display Job (DSPJOB) CL command and the Retrieve Call Stack (QWVRCSTK) API. table function can be used in simple SQL select statements. By the way, it works for all types of call stacks such as OPM, ILE, pase, java, and lic stack.

    This table function requires 2 input parameters namely JOB_NAME which is the qualified name of the job, * is a current job, and THREAD_ID which means all the information from all threads gets returned. The default is INITIAL.

    For example, passing qualified job name in table function stack-info and thread as ALL to select all rows of this specific job for all threads.

    select * from table(qsys2.stack_info('JobNumber/User/JobName','ALL'))

    or passing the current job (*) in the table function stack-info and thread as ‘ALL’ to select all rows of this specific job for all threads.

    select * from table(qsys2.stack_info('*','ALL'))

    sample rpgle program to retrieve call stack information using SQL table function stack_info.

         d psds           sds                                      
     d  curpgmname       *PROC                                                        
                                                               
     Dstackdsarr       DS                  dim(999) qualified  
     D l_ordpos                      10i 0                     
     D l_entrytype                    4A   varying             
     D l_stmtid                     109A   varying             
     D l_pgmname                     10A   varying             
     D l_modname                     10A   varying             
     D l_procname                  4096A   varying             
      *                                                        
     D l_loop          S              5P 0 inz(1)              
     d callerpgm       s             10a                       
      /free                                                    
       exec sql                                                
       declare getstackinfo cursor for                         
       select ordinal_position,                           
       coalesce(entry_type,' '),                          
       coalesce(statement_identifiers,' '),               
       coalesce(program_name,' '),                        
       coalesce(module_name,' '),                         
       coalesce(procedure_name,' ')                       
       from table(qsys2.stack_info('*', 'ALL'))           
       where (ordinal_position <= (select ordinal_position
       from table(qsys2.stack_info('*', 'ALL'))           
       where program_name = :curpgmname                   
       fetch first row only));                            
                                                          
       exec sql                                           
       open getstackinfo;                                 
                                                          
       exec sql                                           
       fetch getstackinfo for 999 rows                    
       into :stackdsarr;                                  
                                                          
       exec sql                                           
       close getstackinfo;                                
                                                          
       for l_loop = 1 by 1 to %elem(stackdsarr);          
        if stackdsarr(l_loop).l_pgmname <> ' ';           
         if (curpgmname <> stackdsarr(l_loop).l_pgmname); 
           callerpgm = stackdsarr(l_loop).l_pgmname;      
           leave;                                         
         endif;                                           
        else;                                             
         leave;                                           
        endif;                                            
       endfor;                                            
                                                          
       dsply callerpgm;                                   
                                                          
       return;                                            
      /end-free
  2. Admin

    We can retrieve call stack information using the retrieve call stack (QWVRCSTK) api. We use this retrieve call stack api whenever we want to find the calling program name. We use this api when we want to execute or skip some logic in the current program in the call stack based upon the calling program means who called this program. The thread’s most recent call is indicated by the first call stack record that is returned. Here is the sample program that retrieves the call stack information and finds the calling program name.

        d psds           sds                                      
     d  curpgmname       *PROC                                 
     d  curjobname           244    253                        
     d  userid               254    263                        
     d  jobnumber            264    269                        
                                                               
     d retrievecallstack...                                    
     d                 PR                  Extpgm('QWVRCSTK')  
     d recvar                     32767a                       
     d lenrecvar                     10I 0                     
     d fmtrcvvar                      8a   CONST               
     d jobidinfo                     56a                       
     d fmtjobidinfo                   8a   CONST               
     d errorcode                     15a                       
                                                               
     d recvar          DS         32767                        
     d  BytesAvl                     10I 0                     
     d  BytesRtn                     10I 0                     
     d  Entries                      10I 0                     
     d  Offset                       10I 0                     
     d  EntryCount                   10I 0                     
                                                               
     d jobidinfo       DS                                      
     d  JobName                      26a   Inz('*')            
     d  Jobid                        16a                       
     d  Reserved                      2a   Inz(*loval)         
     d  ThreadInd                    10I 0 Inz(1)              
     d  ThreadId                      8a   Inz(*loval)         
                                                               
      *  Call Stack Program Names                              
     d Entry           DS           256                        
     d  EntryLen                     10I 0                     
     d  ReqstLvl                     10I 0 Overlay(Entry:21)   
     d  PgmName                      10a   Overlay(Entry:25)   
     d  PgmLib                       10a   Overlay(Entry:35)   
                                                               
     d recvarlen       s             10I 0 Inz(%size(recvar))  
     d errorcode       s             15a                       
     d callerpgm       s             10a       
     d loop            s             10I 0     
      /free                                    
        retrievecallstack(recvar:              
                          recvarLen:           
                          'CSTK0100':          
                          jobidinfo:           
                          'JIDF0100':          
                          errorcode);          
                                               
        For loop = 1 to EntryCount;            
           Entry = %subst(recvar:Offset + 1);  
           If (curPgmName  <> Pgmname);        
              callerpgm = PgmName;             
              leave;                           
           Endif;                              
           Offset = Offset + EntryLen;         
        Endfor;                                
                                               
        dsply callerpgm;                       
                 
        return;  
      /end-free

    Here, psds is declared to fetch the current job and program information. Jobname is passed as *, indicating the current job. You can change the following check If (curPgmName Pgmname); in the program to check the provided program’s call stack entry or the call stack entry preceding it, which is the caller of the supplied program. So we can change conditions like If (Pgmname = ‘TESTPGM’); which means you are checking for the specified program in the call stack entry.