*
   * Define a basing pointer field and initialize to the address of the
   * data structure My_Struct.
   *
  D  My_Struct      DS
  D   My_array                    10    DIM(50)
  D
  D Ptr1            S             16*   INZ(%ADDR(My_Struct))

But I don't think that this really has the same effect as
  D  My_Struct      DS              BASED(Ptr1)
  D   My_array                    10    DIM(50)
  D
  D Ptr1            S             16*

Yup, you must be using p = %addr(arr(offset+1)) to do pointer advancing. This is ok, although handling an offset greater than 32766 leads to additional ugly coding usually involving a based multiple occurrence DS with the char(1) array in it. Brrr. What you can't do with an array but you can with pointer arithmetic is EVAL p = p - offset and even better, EVAL offset = ptr1 - ptr2.

---

I thought you could already do this in V3R2. I'm sure we're using it for APIs that access a user space. Or is it because we're actually advancing in an array....

---

Charles, you're right that the members in that file are not as useful as they could be. They were written in V3R1 before prototypes were supported in RPG IV. The problem with the data structures not being based is a holdover from the RPG III versions which couldn't declare based data structures. The RPG IV headers were supposed to be "the same" as the RPG III ones so customers could convert their programs to RPG IV without difficulty. But I agree that it's time to do something about them (note that I'm not speaking officially for IBM here). My guess is that we'd have to create a whole new source file to avoid disrupting current users of QRPGLESRC. For now, you can copy (not /COPY) in the data structure subfields into your own source, and unfortunately write the prototypes yourself. Sometimes it's helpful to look at the C prototypes in QSYSINC/H (although sometimes they're just confusing e.g. "void *"). P.S. not sure if anyone answered your question about pointer arithmetic, but yes, starting in V3R7 you can EVAL ptr = ptr + offset (zowie!). Thanks for reminding us about QSYSINC

---

Thanks for your reply. Have a couple of things... > From V3R1 to V3R6, you cannot calculate with pointers. You can have them set > with QUSRPTRUS and %ADDR and that's it. With V3R7, you can calculate with > them like > EVAL Pointer = Pointer + %size(structure). > > Before, you have to use some kind of workaround. That explains this little code snippet in IBM's example correct? C* and then incrementing LSTPTR to the Input Parameter Header C* C EVAL LSTPTR = %ADDR(ARR(QUSOIP + 1)) I wondered why they needed that array defined. In v3r7 can you say add the offset to a pointer with the following: C EVAL LSTPRT = LSTPRT + SizeOfEntry Thanks for you help.

---

you are completely right. Accessing user spaces with pointers is *much* faster than QUSRTVUS. The best thing about it, as you surely discovered, is the possibility of shifting a data area over the user space instead of retrieving them with a call. I saw programs that did then some MOVEing with the data. That has to be slower and it is. What we really miss with the /COPY is the possibility to change the source of the included /COPY member as we were able to with good old Auto Report. But there was only support for field names and attributes, and this can be done with ILE RPG, so i think that there's a little gap in programmer's support. At least is that my state of knowledge, i couldn't find anything about this feature on the handbook CD. Perhaps this is read by a IBMer/ress who solves the riddle or maybe this becomes a requirement? Back to the topic: When you code a DS that is "based", you have to get your pointer field filled. Before that, your DS is somewhere in nirvana. After that, you use a piece of storage that is accessable for you; that is a user space or variable storage of your program. A DS without "based" occupies the same place in the storage all the (run)time and cannot be shifted around. From V3R1 to V3R6, you cannot calculate with pointers. You can have them set with QUSRPTRUS and %ADDR and that's it. With V3R7, you can calculate with them like

EVAL Pointer = Pointer + %size(structure).

Before, you have to use some kind of workaround. You might be able to use this:

D Structure   DS      BASED(PtrStruct)
D Struct_F1             10
D Struct_F2             10
D Struct_Next            1

to move the structure, you use

EVAL PtrStruct = %ADDR(Struct_Next)

If you have to deal with offsets, what you have to when you use APIs, you might want to use an array.

D UserSpace  DS   BASED(PtrUsp)
D Offset               9B 0
D Array      1  32767  DIM(32767)

and use

EVAL PtrUsp = %ADDR(Array(Offset+1))

Has the disadvantage that you can only jump in 32K-steps in storage. But
that can easily be solved by a subroutine that does these jumps in a loop.

Hope this helps.

---