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!
LATEST COMMENTS
MC Press Online