Get to know ILE RPG’s prototype structure—essential knowledge for anyone getting used to ILE’s modular approach

by David Shirey

Editor's Note: This article is excerpted from chapter 15 of 21st Century RPG: /Free, ILE, and MVC, by David Shirey.

Prototyping is a term that describes how modules are accessed within the ILE environment. The word prototype also refers to a particular D-spec structure that is required to support this call or access.

As a result, “prototype” can function as both a verb and a noun. It can be the process of calling another module as well as the specific data structures required to do that call.

And by modules, I do not mean *MODULES, the formal object type that is the output of the CRTRPGMOD command, but just any code structure, be it a program or a sub-procedure or whatever. In the old OPM world, we might have referred to this as a “call.” You can use prototypes to access (or call) RPG programs, sub-procedures, CL, C, Cobol, and even Java classes.

So far, we have seen examples of how to prototype with both the CALLP and the function call-return values combo.

You can even use prototypes to call OPM positional programs. That is, if you have an old program with an *ENTRY opcode, you can call it from an ILE program using prototyping in the ILE program. Of course, what you should do is rewrite the old program, but whatever. But now, let’s get into some detail.

What Is a Prototype?

A prototype is a set of special D-specs with a declaration type of either PR or PI.

We will get to the differences between those two in a minute. What’s important to remember now is that the prototype structure is just a new type of D-spec. In fact, if you go back to the /Free control option statements in the last chapter, we even had specific operators for the PR and PI D-specs (dcl-pr and dcl-pi).

Prototypes are not P-specs. Those are also used in ILE but are different and simply delineate the beginning and end of a sub-procedure. Prototypes are D-specs. P-specs are not D-specs.

The prototype structures will be found in both the calling and the called program and will look something like this:

D VAL_PRDNO     PR

PR and PI

As we said a moment ago, there are two types of prototype D-specs.

The PR D-spec is the “prototype” D-spec. It is in the calling and the called program.

The PI D-spec is the “procedure interface” D-spec. It is in the called program only.

You will want to remember those names because we will be using them frequently as we go forward.

PR Details

The PR (prototype) D-spec will appear in both the calling and the called program. Have I mentioned that before?

The good thing about the PR in the calling program is that it makes it very clear what parms belong to what call (because each call to a different module will have its own unique PR D-spec).

On the other hand, the PR does not actually define the fields to the program (yep, they have to be defined separately somewhere else in the program). How weird is that?

Because the PR does not formally define the fields to the program, every subfield that is going to be passed will have two representations in the calling program: one in the PR D-spec and one where the field is actually defined (in a file or another D-spec). The names of the two field representations have to be the same (otherwise it wouldn’t be defined in the PR field, would it?). Similarly, the field types must be the same. What doesn’t have to match are the field lengths. Go figure. We will talk more in the next chapter about what to do if the lengths are not the same.

When ILE first came out and I read some of the early articles, I actually drew the conclusion that using the PR formed some sort of magical bond between the calling and the called program, so that when you did the compile it would recognize any parm differences on the call rather than just blowing up when you ran it. That is not the case.

What those articles were actually referring to was that you could set up the PR as a copybook and then use the copybook in both the calling and the called program. This gives you the same PR in both, and since the compile of the called program will identify differences between the PR and PI D-specs (that is, generate an error on the compile), it becomes impossible to have parameter mismatches between your calling and the called program.

PI Details

The PI (procedure interface) D-spec is where the actual parameters are defined; it is used in receiving those parameters into the called program. As a result, the subfields on the PI do not actually have to be defined in the called program; the PI does it for you. Ain’t that sweet?

The PI is found only in the called program. Since the called program has both a PR and a PI D-spec, the compiler will compare the two specs. The field names of the corresponding fields do not have to match, but if they don’t, the one in the PR D-spec must be defined elsewhere in the program. The field types and lengths do have to match, however, as do any keywords. In other words, in the called program, the PR and PI D-specs must be identical (except for that name thing). But you want them to be identical, otherwise you are just trolling for trouble.

Subfields on the Prototype

A prototype does not have to have subfields (parameters) associated with it.

D VAL_PRDNO     PR

There is nothing wrong with calling a program or sub-procedure and not passing any subfields (like the example above), but you still need to define a prototype structure (it just won’t have any subfields associated with the PR/PI D-spec).

Most of the time, however, you are going to be passing parms into your called program, and with subfields, the prototype would look like this:

D VAL_PRDNO     PR

D   PRDNO             15

D   MSG1               60

And please remember that if you are on a release of RPG that supports the control statements, then you could set things up that way rather than using D-specs. That is, the above spec example would look like this with control statements.

dcl-pr   VAL_PRDNO;

   PRDNO     Char(15);

   MSG1     Char(60);

end-pr;

More PR and PI

There are some interesting relationships involving the size and type of the fields in both the PR and the PI.

OK, fine, I’ll say it. For prototyping, size matters. There, are you happy? Bunch of sickos.

For one thing, in the called program where we have both a PR and a PI, the subfields must match size- and type-wise in both D-specs. So, if you have parms that are 10,0 and 3 in the PR, they have to be the same parms in the PI. That is, within the calling program.

Strangely enough, the names of the two fields whose lengths must match do not have to be the same. That is, it could be Field1 in the PR and Field11 in the PI. But at the same time, remember that if they are different (and I have no idea why you would want to do that, doesn’t sound like a good idea), then you have to have the field from the PR D-spec defined somewhere else because the differently named field in the PI won’t be backing it up. Know what I mean? Just make them the same, and don’t go looking for trouble.

On the other hand, if you are in the calling program and you have a PR that has two parms, 10,0 and 3, then the actual fields in that program where those two fields are defined can have different lengths. I know, so weird. There are rules about just how different they can be, but I want to hold off on discussing that until the next chapter because I just like to put off unpleasant things.

And if that isn’t weird enough, the lengths and types of the PR subfields in the calling program do not have to match the length and type of the subfields in the called program. That is, the compiles will work fine. There may be problems when you run the program, so it is not something that I recommend, but the system won’t stop you. And, it is even possible that if you are passing large amounts of data, like if you are processing XML documents, you might want the lengths to be different.

And I guess that’s the basics of prototyping. But I know what you are probably wondering right now.

Why are both a PR and a PI required? They look essentially identical, except for the R and the I. And we already saw that the PR is primarily documentation. So why do we need both? And the answer is simple.

Because.

Yep, that’s it. Just because. Because that’s the way it is. Because that’s the way IBM designed it. Because if you don’t do it that way, it won’t work. In a nutshell, it’s because that’s the way we say it is, and there ain’t nothing you can do about it because you don’t really know who “we” are. So there!

But, as I said above, it is a story that is evolving, and so in 7.1 there are some types of programs where the prototype (that is, PR D-spec) may be left off in the called program. Those are cases where the program being called is an exit program or one that calls a command, one that is not called by another RPG program (although it can be called by a PHP or another language script), and where the sub-procedures being called are not “exported” from the program. We will talk more about exporting later. Just keep in mind that this is not a wholesale removal of the need for PR; it’s just making it optional in certain circumstances. And also remember that is only for 7.1 and above.

Now It’s Your Turn

Before continuing, are you at a point where you really feel comfortable with prototypes?

We have actually gone over the information a number of times, but feeling comfortable with the prototype structure is key to feeling comfortable with ILE. So, if you don’t feel comfortable with it, take a moment and ask yourself why? Was it the explanation? Not clear enough? Too repetitious? Or maybe you are just dumb? I am not talking here about confused or a little distracted, but just flat out butt-dumb? Might be good to just admit it. I know that works for me. Takes the pressure off, you know.

Either way, you might possibly want to reread the section above. I realize that if you are really confused that may not help much, but—it’s the best I can do. Good luck.