RPGIV @ Work

A unique site for RPG and System i Lovers


Hi, this site will provide all what you need in System i and RPG developments.

My Name is Chamara Withanachchi, System i Expert and RPG Developer. And in the field for last 11 years.

I hope you will find lot of valuable information from this site

Never use indicators Print E-mail
User Rating: / 0
Written by Chamara Withanachchi   

Using the Indicator Data Structure (INDDS) and the File Information Date Structure (INFDS), you can separate the display file indicators from the actual RPG indicators and retrieve

the Attention Indicator (AID) code for the AID-generating key pressed by the user. AID-generating keys include all the command keys, the Help key, the Page Up/Page Down keys, the

Print key, and the Enter key. With the display file indicators set aside into a data structure, you can give them descriptive names. This will make the RPG code much more

understandable to the next chump who has to modify it. The code snippet below is from a file maintenance program I recently re-wrote.

 // ------------------------------------------------------
		FPgmDisplay F   E             WORKSTN 
		F                                     INDDS(DSPIND_DS)     
		F                                     INFDS(DSPINFO_DS)    
		 // --------------------------------------------------------------- 
		 //  Workstation data structures            
		 // ---------------------------------------------------------------
		 // File information display Data structure for Display file   
		d DSPINFO_DS      ds                      
		d   AidByte             369    369         
		 // Indicator Data structure for Display file         
		d DSPIND_DS       ds            99              
		d  dspInds                       1    dim(99)          
		d  CustomerNbr_Error...                                  
		d                                 n   overlay(dspInd_DS:21)
		d  PhoneNumber_Error...                                  
		d                                 n   overlay(dspInd_DS:22)
		d  Address_Error...                                 
		d                                 n   overlay(dspInd_DS:23)
		d  selectNextChg...                             
		d                                 n   overlay(dspInd_DS:45)
		d  protectAllFields...                             
		d                                 n   overlay(dspInd_DS:50) 
		d  hideF23                        n   overlay(dspInd_DS:51) 
		d  subfileControlChanged...                      
		d                                 n   overlay(dspInd_DS:60)   
		d  displaySubfileRecs...                                      
		d                                 n   overlay(dspInd_DS:75)   
		d  displaySubfileControl...                                   
		d                                 n   overlay(dspInd_DS:76)   
		d  subfileClear...                                            
		d                                 n   overlay(dspInd_DS:77)   
		d  subfileEnd                     n   overlay(dspInd_DS:97)  

Of course, if you can't convert the RPG II code to ILE, then you’ll need to use the shorter field names when creating your data structure. The file spec defines the data structures to

receive the INDDS and the INFDS data. For complete subfield definitions for the INFDS data structure, refer to the WebSphere Development Studio: ILE RPG Reference. The AID code

(AidByte in the above code) is a hexadecimal field that corresponds to the key that the user pressed to return the control to the program. A list of the AID-generating keys and their

codes can be found at in the 5250 Data Stream Details in the IBM Infocenter. The code for the constants that I use is shown below:

		 //  Member Name: @AIDCONST                      
		 //  Description: This is a copy book containing the Aid byt
		 //                definitions for all    
		 //               the command keys and other attention keys    
		 //               including Enter, Help, and paging keys.      
		 // Function keys                    
		d F01             C                   x'31'                 
		d F02             C                   x'32'             
		d F03             C                   x'33'               
		d F04             C                   x'34'           
		d F05             C                   x'35'                 
		d F06             C                   x'36'                 
		d F07             C                   x'37'               
		d F08             C                   x'38'                
		d F09             C                   x'39'                
		d F10             C                   x'3a'                
		d F11             C                   x'3b'                  
		d F12             C                   x'3c'               
		d F13             C                   x'b1'
		d F14             C                   x'b2'
		d F15             C                   x'b3'
		d F16             C                   x'b4'
		d F17             C                   x'b5'
		d F18             C                   x'b6'
		d F19             C                   x'b7'
		d F20             C                   x'b8'
		d F21             C                   x'b9'
		d F22             C                   x'ba'
		d F23             C                   x'bb'
		d F24             C                   x'bc'
		 // Other attention keys                  
		d Clear_Key       C                   x'bd'
		d Enter           C                   x'f1'
		d Help            C                   x'f3'
		d PageUp          C                   x'f4'
		d PageDown        C                   x'f5'
		d Print_Key       C                   x'f6'
		d Auto_Enter      C                   x'50'
		d Light_Pen_Enter...
		d                 C                   x'3f'

Once you have the code in place to receive the indicators and have your descriptive name defined, you need to do one last thing before writing your new code. You need to add the

INDARA keyword to the display file DDS. Once that's done and you've recompiled the display, you can start removing the indicators from the code and replacing them with your new

descriptive field names.

Another little trick I use to make my code more understandable is two constants called TRUE and FALSE. They are defined as show below:

d TRUE            C                   '1'
		d FALSE           C                   '0'

Then, whenever I do comparisons or set the value of any of my "named indicators," I use the TRUE and FALSE constants. So the code might look something like this:


		   chain(en) Custno customer;
		   if not %found;
		      CustomerNbr_Error = TRUE;

For those of you who are thinking that we're still using "indicators" and we've just given them names, you are correct. However, in my humble opinion, you are quibbling over semantics. I could make a case that a Boolean variable in C++ is simply another name for an "indicator," and I'd be right too. But I think we can all agree that the code shown above is more clear about what is actually happening than this code:

C     custno        chain     Customer                           21  

Or even this:

		   chain(en) Custno customer;
		   if not %found;
			  *in21 = *on;

Good luck, and don't use indicators...ever!

<Previous   Next>