RE: Array * and big array -- RPG400-L

Yes, it is intentional.  list.item will be used as a dynamic array.

The basic idea is to allow caller to create multiple item lists.  This
will be a service program and caller will do something like below to use
it:

If list.item is to be a dynamic array, why not make THAT part of it usethe pointer logic? After all, that's the part that requires a lot ofspace, not the outer array. If you make the item list dynamic, youeliminate the 64k limitation and you eliminate the 32k limit on the numberof items in a list.

Also, I'd only make the array accessible via subprocedures in amodule, (I think that's what you intended to do, as well) and I'd putthese procedures in a module by themselves to make sure nobody tries toaccess the array directly. That way, if you ever want to chenge the logicof how it works (for example, to switch to a linked list) you can do sowithout fear of breaking any of the callers.

Unfortunately, I don't have time to test the following code -- I'vewritten enough of these things that it should be reasonably close tobeing correct, but you'll have to do the testing yourself. I'm including

it to give you a clearer idea of what I'm suggesting:

     D listMast        ds                  qualified  dim(512)
     D   last                        10i 0 inz(0)
     D   alloc                       10i 0 inz(0)
     D   item                          *   inz(*null)

     D item            s             50a   based(p_item)

     D ALLOC_BLOCK_SIZE...
     D                 C                   CONST(100)

      *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      * addItem(): Add a new item on to the end of an item list
      *            in the listMast() array.
      *
      *    no     = (input) listMast element number.
      *    value  = (input) value of the item to add
      *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     P addItem         B                   export
     D addItem         PI
     D   no                          10i 0 value
     D   value                       50a   const

     D size            s             10i 0
      /free

         // ----------------------------------------------
         //  increase the number of items stored.
         // ----------------------------------------------

         listMast(no).last = listMast(no).last + 1;

         // ----------------------------------------------
         //   expand array if necessary.
         // ----------------------------------------------

         if (listMast(no).last > listMast(no).alloc);
             listMast(no).alloc += ALLOC_BLOCK_SIZE;
             size = %size(item) * listMast(no).alloc;
             if (listMast(no).item = *null);
                 listMast(no).item = %alloc(size);
             else;
                 listMast(no).item = %realloc(listMast(no).Item: size);
             endif;
         endif;

         // ----------------------------------------------
         //   store new value.
         // ----------------------------------------------

         p_item = listMast(no).item + %size(item) * (listMast(no).last-1);
         item = value;

      /end-free
     P                 E


      *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      *  getItem(): Retrieve an item's value from the listmaster
      *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     P getItem         B                   export
     D getItem         PI            50a
     D   no                          10i 0 value
     D   elem                        10i 0 value
      /free
         if (elem < 1 or elem > listMast(no).last);
             return *blanks;
         endif;

         p_item = listMast(no).item + %size(item) * (elem-1);
         return item;
      /end-free
     P                 E


      *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      *  setItem(): Update an item's value from the listmaster
      *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     P setItem         B                   export
     D setItem         PI             1n
     D   no                          10i 0 value
     D   elem                        10i 0 value
     D   value                       50a   const
      /free
         if (elem < 1 or elem > listMast(no).last);
             return *off;
         endif;

         p_item = listMast(no).item + %size(item) * (elem-1);
         item = value;
         return *on;
      /end-free
     P                 E


      *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      * freeList(): Free up all memory used by the list
      *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     P freeList        B                   export
     D freeList        PI
     D x               s             10i 0
     D p               s               *
      /free
         for x = 1 to %elem(listMast);
             p = listMast(x).item;
             if ( p <> *null );
                dealloc p;
                listMast(x).item  = *null;
                listMast(x).last  = 0;
                listMast(x).alloc = 0;
             endif;
         endfor;
      /end-free
     P                 E

Hope that makes sense. It allows for up to 16mb in each item list, andthe amount of memory that each uses is only expanded when needed. The codeis pretty easy to follow (for pointer logic) once you understand what it'sdoing.