Aside from the terrible trio (CABXX, TAG, and GOTO), I discussed in the previous TechTip another fact that’s hard for some to swallow: that MOVEA didn’t make it to free-format. This operation code is used for some specialized assignment functions related to arrays; it transfers character, graphic, UCS-2, or numeric values from factor 2 to the result field. However, there are some restrictions when moving numeric values. (Check IBM’s ILE RPG Reference Manual for details if you need to refresh your memory.) One of the fields must contain an array, and the fields cannot specify the same array, even if the array is indexed. The following operations are allowed:
There’s an alternative. The %SUBARR BIF allows you to refer to a subsection of an array, starting at a given index (the start position) and continuing for a given number of elements:
%Subarr(<Array Name> : <Start Position> : <Number of Elements>)
With this BIF, you can perform the three types of operations I just mentioned. In order to “move several contiguous array elements to a single field,” you use something like this:
W_SomeField = %Subarr(<Array Name> : <Start Position> : <Number of Elements>);
To perform the second type of operation, “move a single field to several contiguous array elements,” you simply swap the position of the field and the BIF in the code instruction:
%Subarr(<Array Name> : <Start Position> : <Number of Elements>) = W_SomeField;
Finally, the last type of operation, “move contiguous array elements to contiguous elements of another array,” might be a bit difficult to wrap your head around:
%Subarr(<Target Array Name> : <Target Start Position> : <Target Number of Elements>) = %Subarr(<Source Array Name> : <Source Start Position> : <Source Number of Elements>);
Here are some additional examples from IBM’s ILE RPG Language Reference Manual V7.1:
D a s 10i 0 dim(5)
D b s 10i 0 dim(15)
D resultArr s 10i 0 dim(20)
D sum s 20i 0
// Copy part of an array to another array:
resultArr = %subarr(a:4:n);
// this is equivalent to:
// resultArr(1) = a(4)
// resultArr(2) = a(5)
// resultArr(n) = a(4 + n - 1)
// Copy part of an array to part of another array:
%subarr(b:3:n) = %subarr(a:m:n);
// Specifying the array from the start element to the end of the array
// B has 15 elements and A has 5 elements. Starting from element 2
// in array A means that only 4 elements will be copied to array B.
// The remaining elements in B will not be changed.
b = %subarr(a : 2);
// Sort a subset of an array:
// Now, A=(5 9 13 16 3);
// Since only 4 elements were sorted, the fifth element
// is out of order.
// Using %SUBARR in an implicit array indexing assignment
resultArr = b + %subarr(a:2:3)
// this is equivalent to:
// resultArr(1) = b(1) + a(2)
// resultArr(2) = b(2) + a(3)
// resultArr(3) = b(3) + a(4)
// Using %SUBARR nested within an expression
resultArr = %trim(%subst(%subarr(stringArr:i):j));
// this is equivalent to:
// resultArr(1) = %trim(%subst(stringArr(i+0):j))
// resultArr(2) = %trim(%subst(stringArr(i+1):j))
// resultArr(3) = %trim(%subst(stringArr(i+2):j))
// Sum a subset of an array
sum = %xfoot (%subarr(a:2:3));
// Now sum = 9 + 13 + 16 = 38
Finally, the LOOKUP operation code, related to arrays but also to tables, was replaced by a flurry of BIFs:
These BIFs provide a finer-tuned functionality than the operation code and dispense with %EQUAL, %FOUND, or those pesky indicators. Here are a few examples, also taken from IBM’s ILE RPG Language Reference V7.1:
arr(1) = ’Cornwall’;
arr(2) = ’Kingston’;
arr(3) = ’London’;
arr(4) = ’Paris’;
arr(5) = ’Scarborough’;
arr(6) = ’York’;
n = %LOOKUP(’Paris’:arr);
// n = 4
n = %LOOKUP(’Thunder Bay’:arr);
// n = 0 (not found)
n = %LOOKUP(’Kingston’:arr:3);
// n = 0 (not found after start index)
n = %LOOKUPLE(’Paris’:arr);
// n = 4
n = %LOOKUPLE(’Milton’:arr);
// n = 3
n = %LOOKUPGT(’Sudbury’:arr);
// n = 6
n = %LOOKUPGT(’Yorks’:arr:2:4);
// n = 0 (not found between elements 2 and 5)
After this, we’re missing only two operation codes. The CAT operation code was mentioned earlier in this series. (You don’t need to go back there now; just use the plus sign instead of it in free-format). The last operation code, TESTN, doesn’t have a direct replacement, but you can test numeric values using a MONITOR/END-MON group and handle the errors in the ON-ERROR section. If you’re not familiar with these operation codes, don’t worry because I’ll review error-handling techniques in more depth later in this series.
This concludes this three-part TechTip about free-format conversion. To help you in the task of converting your own code, I prepared a table with the operation codes that don’t have a free-format equivalent and the respective alternative. You can download that table here. This is also the last article of the “/FREE Your Code” subseries. In case you’re wondering, I didn’t forget to talk about the “new” free-format H-, F- and D-specs: I’ll discuss them in detail later, along with the latest improvements that IBM introduced with TR7. But that’s for a bit later, because the next batch of TechTips will focus on the guidelines to help you improve your code’s readability and maintainability.
About the Author: Rafael Victoria-Pereira
Rafael Victória-Pereira has more than 16 years of IBM i experience, as a programmer, analyst, and manager. Over that period, he has been an active voice in the IBM i community, encouraging and helping programmers transition to ILE and free-format RPG. Rafael has written more than 50 technical articles about topics ranging from interfaces—the topic for his first book Flexible Input, Dazzling Output with IBM i—to modern RPG and SQL, in his popular RPG Academy and SQL 101 series on mcpressonline.com. He writes in an easy-to-read, practical style that's highly popular with his audience of IBM technology professionals.
Rafael currently works as an Enterprise Architect at the Luis Simões Group in Portugal. His areas of expertise include programming in the IBM i native languages (RPG, CL, and DB2 SQL) and "modern" programming languages, such as C# and Python, as well as project management and consultancy.- See more at: http://www.mcpressonline.com/rpg/rpg-academy-/free-your-code-convert-fixed-format-code-to-free-format-part-3.html#sthash.p09weZkM.dpuf
It’s the holiday season, and everyone is in the gift-giving mood. Be sure you don’t forget to invest in your company and career.
Written by Brian May
It’s a special time of the year. Family gatherings for the holidays, football season, and time in the woods all make this one of my favorite seasons. The month of December is also unique for IT departments. December is certainly not business as usual for most of us.
It’s time for budgets. That may mean requesting budget items for next year or spending surplus budget before the end of the year. It’s often when project work slows down a bit as end users, and IT staff alike, take time away from the office. It’s a time when stress is often at its lowest, and it’s just easier to get some things done.
A more “modern” alternative to STRSQL, discussed in the last two articles, is the i Navigator’s Run SQL Scripts tool. Let’s explore it together, shall we?
Written by Rafael Victória-Pereira
While STRSQL is a green-screen tool, Run SQL Scripts is part of the i Navigator package. You can access it by choosing the Run SQL Scripts option, either from the bottom-right pane of the i Navigator window after you’ve chosen the Databases tree node from the right panel, as shown in Figure 1, or by right-clicking the database name and choosing the respective option.
This is IT. We must be willing to bend.
Written by Steve Pitcher
With a growing emphasis in talking about the state of the current IBM i workforce, also known as the “IBM i skills shortage,” it behooves oneself to keep the noise level to a minimum in order to make even-keeled decisions. In short, don’t necessarily believe all the hype you read.
I’d like to think of this as an extension piece to “The IBM i Skills Shortage Myth.” It’s not necessarily a “part two” per se, but more of a story that runs parallel. I’ve been trying to write this for about six weeks, but some things are just hard to put into words, especially when they involve how you feel as opposed to what you know. Besides, writing what you know is easy. Writing what you feel leaves room for reader interpretation, so you have to be more careful.