MoveA? Again? Still? Really?

Author's note: The subject of the RPG opcode MoveA (as it pertains to free-format RPG) keeps coming up in articles, blogs, and forums throughout our industry. It's time to put it to rest. The following excerpt from the book Free-Format RPG IV should supply all you need to handle the free-format conversion of this opcode.

Solution for the Fixed-Format MoveA Operation

One of the operations that free-format RPG IV doesn't support is MoveA (Move array). You can perform the equivalent function, however, by using various built-in functions.

History

IBM created the MoveA operation for RPG II programmers, to solve a then-current need for character manipulation. At the time, no Scan (Scan string), Subst (Substring), or Cat (Concatenate two strings) operation existed, and built-in functions were still decades away. MoveA's purpose was to move a character field to an array defined as character with length 1 and a number of elements equal to the length of the field. Inside the array, programmers could scan and change the field using array indexes.

By converting the field to an array, you could perform character searches (scanning) using the array lookup function. The Lookup operation code returns the location found in the array in an index, allowing modification of the array element.

You can use the MoveA operation to load a field starting anywhere in the array, not just in position 1, to imitate a substring function. You can place multiple fields in the array, emulating the concatenation function. Character management is easy if the character locations are available using an index; in this case, the character locations are available in array elements. After performing all character management operations, you can convert the array back to a field, again using the MoveA operation.

Another function of MoveA is moving array data to another array. In the implementation of this function, there is no recognition of array boundaries. The sending array can start at any array index, and the receiving array can start at any array index.

The Free-Format Solution

In RPG IV, if you must move a field to an array rather than manage the field using character-string built-in functions, consider the following:

     D Array        S          1      Dim(30)

     D Field        S         30

     D i            S          2  0 

      /free

       For i = 1 to %len(Field);

         Array(i) = %subst(Field:i:1);

       Endfor;

To move the array back to the field:

       For i = 1 to %len(Field);

         %subst(Field:i:1) = Array(i);

       Endfor;

In most cases, however, you won't need these two routines because RPG IV provides many good character-management built-in functions.

The free-format emulation of MoveA begins with the %scan built-in function. Finding a single character or small string within a character string is easy using %scan. As an example, if you are locating the small string "qu" in another string, say 'Albuquerque', just specify:

   Location = %scan('qu':'Albuquerque');

After this line of code is executed, Location has the value 5. To find the second 'qu', you need some loop logic.

To replace one or more characters in a character string, you can use the %subst or %replace built-in function. Here's an example: Say you want to replace all occurrences of "i" in the character string "Mississippi" with "a". You can use the following routine to do so:

     D Search_char     S        1        Inz('i')

     D Char_string     S       30        Inz('Mississippi')

     D i               S        2  0        

      /free

       i = 1;

       Dou i = *Zero;

         i = %scan(Search_char:Char_string:i);

         If i > * Zero;

           %subst(Char_string:i:1) = 'a';

           i += 1;

         Endif;

       Enddo;

Another way to do the same function is to use the built-in function %xlate.

     D Search          S        1        Inz('i')

     D New             S        1        Inz('a')

     D Char_string     S       30        Inz('Mississippi')

      /free

       Char_String = %xlate(Search:New:Char_String);

To build a long character string from smaller strings, consider the following example of concatenation:

D  F1      S         10     inz ('Now')

D  F2      S         10     inz ('is')

D  F3      S         10     inz ('the')

D  F4      S         10     inz ('time')

D  String  S         50

      /free

       String = %trim(F1) + ' '

                + %trim(F2) + ' '

                + %trim(F3) + ' '

                + %trim(F4) + '.';

The %Subarr Built-in Function

Moving the data of an array to an array is a bit trickier than some of the operations examined above. V5R3 provides a new built-in function, %subarr, that helps get the job done.

Let's look at an example where an element of an array is defined as 100 bytes, and another array is defined as length 1 with 100 elements. We want to move all elements of the 100 element array (Array1) to the element of Array2, whose index is i. The fixed-format scenario would be as follows:

     D Array1           s              1    Dim(100)

     D Array2           s            100    Dim(50)

     D i                s              5U 0

     D j                s              5U 0

     D Arx              s                   Dim(100)

     D                                      Like(Array1)

     D                                      Based(Ptr)            

     C                   Movea  Array1       Array2(i)

To perform the same operation in free-format, you have two alternatives:

      /free

       For j = 1 to %elem(Array1); // Loop  1 to 100

         %subst(Array2(i):j:1) = Array1(j); // Move 1 char

       Endfor;

       // Another solution using %subarr and a based array

       // template

       Ptr = %addr(Array2(i));  // Ptr to Array2 element i 

       Arx = %subarr(Array1:1); // Move array to array

Jim Martin holds a BS degree in mathematics and an MS in computer science. For 26 years, he was employed by IBM, where he wrote RPG applications for customers and worked in the programming laboratory as a programmer on portions of CPF and the OS/400 operating system. After leaving IBM, Jim took post-graduate work in computer science and performed RPG training. He is an IBM-certified RPG IV developer and author of multiple bestselling editions of Free-Format RPG IV, which, since the book's initial publication in 2005, have taught thousands of RPG IV programmers how to be successful with the free-format coding style.

---

MC Press books written by Jim Martin available now on the MC Press Bookstore.

		Free-Format RPG IV: Third Edition Improve productivity, readability, and program maintenance with the free-format style of programming in RPG IV. List Price $59.95 Now On Sale
		Free-Format RPG IV: Second Edition >Make the transition from coding in fixed-format RPG to free format. List Price $59.95 Now On Sale
		Functions in Free-Format RPG IV Here’s the ultimate guide to writing RPG IV programs with functions in the free-format style. List Price $59.95 Now On Sale

Also Read

Advanced/Free - Function Calls and Return Values

PRACTICAL ILE - ILE Service Programs

Data-Manipulation Operations Using Free Format, Part Two