Leverage your OPM RPG knowledge with this simple and practical example of using procedures.

I've been getting great feedback from the readers since the first TechTip of this series. I got lots of questions, suggestions, and even some constructive criticism. One of the main "complaints" was that the OPM scenario that was presented in the first TechTip (see Figure 1 below) was too old-fashioned and simplistic.

Figure 1: This is the traditional OPM scenario.

That reader was right, of course. Even in OPM, it's possible to avoid duplicating the same code over and over again in multiple programs. To be fair, a more accurate scenario would be the one depicted in Figure 2, in which the code related with the business rules is isolated in several standalone programs (BR1, BR2…BRx) that are called as needed by programs A and B:

Figure 2: This is an evolved OPM scenario.

This more-realistic and up-to-date scenario will be my starting point for the creation of a simple procedure. I'll stick to the scenario described in the first TechTip: programs A and B both handle inventory, but they do slightly different things. While A imports inventory items from a cargo manifest CSV file, B handles the user inventory management via screen interaction. They both use some of the same business rules, which I've isolated into programs BRx in this new scenario. Let's say that BR1, one of those programs, translates the supplier's item ID into the company's item ID. PGM A would call BR1 whenever it needs to import a new item, passing the external item ID and supplier ID codes and receiving the internal item ID. This means that a PLIst would be defined with the necessary variables:

C     PL_BR1       PList                            

C                   Parm                   P_ExtItmID

C                   Parm                   P_SupID  

C                   Parm                   P_IntItmID

All of this should be familiar. Now let's transform BR1 into a procedure, step by step.

To use a procedure, I need to "tell" the program how to call it, the same way I would do for a program. For that, I'll use a prototype definition. This definition must be used in every program or service program that uses the procedure. Since the idea here is reusing code instead of duplicating it, I usually create a source member in a separate source file, named QCPYLESRC, with all the module's procedure prototypes and include it in the programs/service program where I need to use it. In fact, as you can see below, the prototype definition (shown below as part of the QCPYLESRC/BR_INV_PR source member) is actually quite similar to a PList:

* -----------------------------------------------------------------------*

*   Prototype . : BR_INV_PR                                             *

*   Description : Inventory Related Procedures                           *

*   Author .... : Rafael Victoria-Pereira                               *

*   Date ...... : March 2014                                            *

*   Changes ... :                                                       *

* -----------------------------------------------------------------------*

* -----------------------------------------------------------------------*

*   Convert the External Item ID into the Internal Item ID              

* -----------------------------------------------------------------------*

D CvtItmId       PR                                                      

D P_ExtItmID                   50                                        

D P_SupId                     256                                        

D P_IntItmID                   50                                        

Then all I need to do is include this definition in my program/service program, using either /Copy or /Include:

* Prototype definition for Inventory Related Procedures

/COPY QCPYLESRC,BR_INV_PR                  

Just a note about the procedure name: instead of BR1, I'm using a (slightly) clearer name for the procedure: CvtItmID. I like to use a verb to identity the procedure type (Cvt, short for Convert in this case), followed by the subject (ItmID, short for Item ID). You can argue that ConvertItemID would be even clearer, but it's important to avoid getting carried away with huge names; it will cost you additional time and increase the misspelling chances when you need to call the procedure. Speaking of calling, the way to call a procedure is also different from calling a program:

C                   CallP     CvtItmID(P_ExtItmID : P_SupID : P_IntItmID)

CallP is used instead of Call, and the parameters follow the procedure name enclosed by parentheses and separated by a colon, just like in a built-in function. You can also use a slightly different notation, similar to a program call with parameters:

C                   CallP     CvtItmID(P_ExtItmID :

C                                     P_SupID   :

C                                     P_IntItmID )

OK, that's how the procedure is defined and called. Now let's see how to create it! Here's an example of a simple procedure structure, without the actual code:

*-------------------------------------------------------------------------*

*   Convert the External Item ID into the Internal Item ID      

*-------------------------------------------------------------------------*

P CvtItmID       B                   EXPORT                        

D                 PI                                              

D P_ExtItmId                   50                                  

D P_SupId                       10 0                                

D P_IntItmId                   50                                

C*                                                                  

C* The procedure's code goes here                      

C*                                                                

P CvtItmId       E                                                

As I explained in the second TechTip of this series, procedures are part of modules. A module can contain one or more procedures. This means that the compiler needs to know where each procedure begins and ends. The P-lines you see above delimit the CvtItmId procedure. Note that the first P-line has the keyword EXPORT. This means that this procedure will be exported by the module; other words, it means that this procedure will be available to the programs and/or service program that are bound to this module.

Right after the beginning of the procedure comes the Procedure Interface (PI). The set of D-lines shown here is used to define the procedure's parameters, just like an *Entry PList would in an OPM program. Note that this list begins with a D-line that holds only PI; this marks the start of the Procedure Interface. Also note that the D-lines don't have the usual "S," "C," or "DS" in positions 24-25 for the Definition Type because they are part of the Prototype Interface. It's also possible to define variables within a procedure (more on this in the next TechTip); these variables would be defined using the usual notation in positions 24-25 ("S," "C," or "DS").

Finally, there would be a bunch of C-lines containing the actual procedure code, just like in a regular program. One of these lines would assign a value to P_IntItmID, thus allowing the procedure to return the internal item ID to the calling program.

Let's do a quick recap. In order to use a procedure in a program or service program, you need to do the following:

• Define the procedure's prototype (preferably) in a separate source member. I use a member in QCPYLESRC for each module.
• Create the procedure, respective module, and program or service program, as described in the previous TechTip of this series.

 In your program or service program, do this:

• Include the source member with the prototype definition in your program/service program using /Copy or /Include.
• Declare the procedure's parameters. I prefer to use the same names I used in the prototype, but as long as the variable types and lengths match, any name will do.
• Set up the parameters' values as needed, just like you would do before calling a program with parameters.
• Call the procedure, using CallP instead of Call.

That's all for now! The next TechTip will continue to discuss procedures: when to create them, what you should and shouldn't do, and other interesting things!

Rafael Victória-Pereira has more than 20 years of IBM i experience as a programmer, analyst, and manager. Over that period, he has been an active voice in the IBM i community, encouraging and helping programmers transition to ILE and free-format RPG. Rafael has written more than 100 technical articles about topics ranging from interfaces (the topic for his first book, Flexible Input, Dazzling Output with IBM i) to modern RPG and SQL in his popular RPG Academy and SQL 101 series on mcpressonline.com and in his books Evolve Your RPG Coding and SQL for IBM i: A Database Modernization Guide. Rafael writes in an easy-to-read, practical style that is highly popular with his audience of IBM technology professionals.

Rafael is the Deputy IT Director - Infrastructures and Services at the Luis Simões Group in Portugal. His areas of expertise include programming in the IBM i native languages (RPG, CL, and DB2 SQL) and in "modern" programming languages, such as Java, C#, and Python, as well as project management and consultancy.

---

MC Press books written by Rafael Victória-Pereira available now on the MC Press Bookstore.

		Evolve Your RPG Coding: Move from OPM to ILE...and Beyond Transition to modern RPG programming with this step-by-step guide through ILE and free-format RPG, SQL, and modernization techniques. List Price $79.95 Now On Sale
		Flexible Input, Dazzling Output with IBM i Uncover easier, more flexible ways to get data into your system, plus some methods for exporting and presenting the vital business data it contains. List Price $79.95 Now On Sale
		SQL for IBM i: A Database Modernization Guide Learn how to use SQL’s capabilities to modernize and enhance your IBM i database. List Price $79.95 Now On Sale

Also Read

H and F Position-less Specs

Practical RPG: AI and IBM i

Programming in ILE RPG - Defining Standalone Variables & Assigning Initial Values to Data