Free-format RPG IV has been criticized for not including many favorite operation codes that are available in fixed-format RPG IV. The MoveA operation code is one of them.
The MoveA (Move array) operation code was introduced in RPG II back in the early 1970s. With no character manipulation operations available (except for Move and MoveL), MoveA provided a valuable method to manage character strings. Here's how it worked (and still does in some programs): First, a character field of interest was moved to an array using MoveA. The array was defined with character data type, length one, and dimension the same value as the field's length. The MoveA operation moved byte one of the field to array element one, byte two to array element two, etc. Array operations, such as Lookup, could then be performed, and array indices could be used to change desired elements of the array. After completing the array modifications, the array could then be moved back to a field for display, print, or database output. It seems like a crude way to handle character strings, but RPG II did not have concatenation, substringing, or the Check, CheckR, Translate, or Scan operations.
When considering replacing a MoveA operation with free-format functions, a couple of questions need answering: - Is the purpose of the MoveA operation to begin or end a character string manipulation, using array operations (as explained above)? If so, replacing MoveA will be very easy. All that's required is to understand the desired output and then do it using a modern operation code or built-in function. Two examples of this situation and solutions appear below.
- Is the purpose of the MoveA to move array data from one array to another array? When using this function, all or part of an array is moved (without regard to element boundaries) to another array, starting at the beginning of the second array or at any element of the array. A typical use of this is moving one array (the whole thing) to an element of another array. An example of this situation and solutions appears below.
Example 1 A field named LONGNAME is being converted from another system's database. The other database used a pound sign (#) as a delimiter between portions of the name. John A. Smith, Jr. would be encoded as John#A.#Smith#Jr. The following code uses the MoveA operation to replace the # character with a blank:
C MoveA LongName ArrName
C Eval Index = 1
C Dou *In90 = *Off
C '#' Lookup ArrName(Index) 90
C If *In90 = *on
C Eval ArrName(Index) = ' '
C If Index < %len(LongName)
C Eval Index = Index + 1
C Endif
C Endif
C Enddo
C MoveA ArrName LongName
The same function can be performed with the following free-format code:
/free
LongName = %xlate('#':' ':LongName);
/end-free Example 2 A numeric nine-digit number may have some leading zeroes. The desired output is the number in character form with the leading zeroes changed to blanks. An indicator, *In50, with value *On tells the routine to right-justify the result; indicator *In50 with value *Off tells the routine to left-justify the result.
C Move Num9 Char9
C MoveA Char9 Ary9
C 1 Do 9 x
C If Ary(x) = '0'
C Move *blank Ary9(x)
C Else
C Leave
C Enddo
C If *In50
C MoveA Ary9 Char9
C Else
C 1 Do 9 x
C If Ar9(x) <> ' '
C Leave
C Endif
C Enddo
C Clear Char9
C MoveA Ar9(x) Char9
C Endif The following free-format code does the same job:
/free
Char9 = %char(Num9); // Left Adj.
If *In50;
EvalR Char9 = %trim(Char9); // Right Adj.
Endif;
/end-free Example 3 Array 1 (Ary1) has elements 100 bytes long. Array 2 (Ary2) has elements 1 byte long with dimension 100. Ary2 is to be stored in element x of Ary1. This is done in fixed-format as follows:
C MoveA Ary2 Ary1(x) There are two ways of doing this in free-format. Here's one:
/free
For j = 1 to %elem(Ary2);
%subst(Ary1(x):j:1) = Ary2(j);
EndFor;
/end-free Here's another way to do this, using the %subarr built-in function and a based array:
D Arb S Like(Ary2) Dim(%elem(Ary2))
D Based(Ptr)
/free
Ptr = %addr(Ary1(x)); // put template over Ary1 element
Arb = %subarr(Ary2:1); // Move the data
/end-free It is true that the MoveA operation is an efficient array-to-array function. However, the free-format method to do the same function is really very easy.
Don't let lack of support for favorite operations be a hindrance to considering free-format RPG IV. Dive right in.
Jim Martin, the author of Free-Format RPG IV, is a corporate technical instructor at Jack Henry & Associates in Monett, Missouri. He is a veteran of RPG programming, beginning in 1967 with a position at IBM as a systems engineer and later as a staff programmer at the Rochester systems programming lab. For eight years, he was at Lakeview Technology as an AS/400 and RPG instructor and was a speaker at various local midrange user group meetings and conferences. He can be reached by email at jmartin@truevine.net.
| 
