Previously, I discussed how to sort subfiles using the C language "qsort" function. Apparently, a lot more people need the capability to sort their data structures. So this week, I'll show you how to specifically sort a multiple-occurrence data structure or one of the new data structure arrays.

The first thing you need to do to sort multiple-occurrence data structures or data structure arrays is make sure your data structure is one of those two types. That is, the data structure must have the OCCURS or DIM keyword specified with a value greater than 1. If the value isn't greater than 1, sorting will, obviously, achieve nothing.

Sorting a data structure does not require any type of control on loading the data. You add and retrieve data from the data structure as you normally do, but instead of sorting an array using the SORTA opcode, you use the SORTDS procedure to sort your data structure.

Using qsort()

Sorting a data structure's occurrences (when using a traditional multiple-occurrence data structure) or array elements (when using the new data structure array) can be accomplished in a number of ways. The fastest and most flexible choice today is to use a procedure named "qsort()" from the C language runtime library. Like all C language functions, qsort() can be called from RPG IV rather easily.

The qsort() procedure sorts its data by arranging the elements of the data passed to it based on the return value of a subprocedure that you've written. That subprocedure name is specified on the fourth parameter of the call to qsort().

Since a multiple-occurrence data structure is similar to an array, qsort() can sort data structure occurrences just as easily as arrays. In fact, qsort() doesn't care if the value passed to it is an array, a data structure, or just a very long field with data that needs to be sorted. Let's look at the prototype for the qsort() procedure.

The qsort() Parameters

The qsort() procedure accepts four parameters. Within these parameters, you identify the array or data structure you would like to sort, the number of elements you want to sort, the length of each element, and a subprocedure name that is called by qsort().

Variable Name

The first parameter identifies the field, array, or data structure to be sorted. Note that this parameter is a data type of * (i.e., a pointer) and is also passed by value. This means that when you specify the variable you want to sort, you must enclose that variable name with the %ADDR() built-in function. This built-in function extracts the memory address of the field, which is what is required for this parameter. We declare the parameter in this way--versus using a traditional field and field length--because we do not want to limit the size of the sorted variable to that of a field (which is currently limited to 64 K).

Number of Elements

The second parameter identifies the number of elements to be sorted. This may or may not be the number of elements in the array or data structure. It is, however, the number of elements you want to sort. This is extremely useful when the data structure or array is declared with, for example, 500 elements and you've only populated something like 75 of them. Why sort those last 425 elements when they are empty?

Actually, those empty elements would probably appear at the beginning of the sorted array if you used the traditional SORTA opcode. This problem can be completely avoided by using qsort().

Element Length

The third parameter identifies the length of each element of the array or single occurrence of the data structure. Typically, you would specify %size(myDS) or %size(myArray) for this parameter. The length of an element of the array being sorted or the length of the data structure (one occurrence) is specified.

Subprocedure

The fourth parameter is the address of a subprocedure name. This subprocedure is called by qsort() to compare two values at a time.

This subprocedure must accept two parameters. Both parameters are pointer data types that are passed by value. The subprocedure must return a 10i0 (int4) value that indicates the results of the comparison. The prototype for this subprocedure is illustrated below:

When qsort() is evoked, it calls your subprocedure repeatedly. Each time it calls your subprocedure, it passes in two values. Your subprocedure compares those values and returns 1, -1, or 0. A return value of 1 means the value on the first parameter is greater than the value of the second parameter. A return value of zero indicates that the two values are equal. A return value of -1 means the value of the first parameter is less than the value of the second parameter. Below is a summary of the return values.

Besides comparing the values, the subprocedure can do anything you need. But remember that it should do whatever it does very quickly and return. Otherwise, the sorting process will be slower than it could be.

Calling qsort()

To call qsort(), you need to do two things: 1) Create a prototype for the C language 'qsort' function, and 2) link to the binding directory named QC2LE.

To create the prototype for qsort(), type in the following Definition specifications:

To link to the QC2LE binding directory, add the BNDDIR keyword to your Header specification, as follows:

Sorting a Data Structure

To sort a data structure, call the qsort() procedure that has been previously prototyped and pass to it the address of the data structure, the number of occurrences to sort, the length of the data structure, and the address of the name of your compare subprocedure.

In the example that follows, the data structure named MYSTUFF has an occurrence setting of 1000. There is also a field named nENTRIES that you need to use to set the number of "active" occurrences (occurrences that have data in them). You want to sort only the active occurrences, not the empty ones.

To sort this array, you could call qsort() using the SORTDS prototype as follows:

In the example above, the nENTRIES field must be set to the active number of occurrences in the data structure; otherwise, the call to qsort() will run very quickly and not sort your data structure.

The MYCOMPPROC subprocedure must also be created somewhere in your source member or program. Note that the name of the compare procedure is in all uppercase and enclosed in single quotes within the %PADDR() built-in function. This is required because RPG subprocedures are converted to all uppercase when they are compiled. A fundamental version of this subprocedure follows:

I am using OS/400 V5R1 RPG IV extensions in this example, but you can easily convert it to pre-V5R1 by fully declaring the data structures with their subfields.

Sorting Decisions

There are two styles of sorting that you can achieve: 1) Sort the data structure using the same set of data each time it is sorted (that is, the same subfield is used as the "key" whenever the data structure is sorted). This is the style used in the example above. 2) Write a subprocedure that checks a global variable for some type of value and then uses that value to conditionally sort the data structure by any or all of its subfields.

The only thing you need to keep track of is the current number of elements in the array or data structure you want to sort.

If you want to sort by different subfields within the same program, you need to be more creative in the MYCOMPPROC subprocedure. My suggestion is to create a global variable and move the field name into that field. Then, in your subprocedure, check that field for the specific field name, and compare the contents of that field in the two data structures.

For example, if I want to be able to sort the MYSTUFF data structure by customer number, customer name, phone number, or ZIP code, I could have a MYCOMPPROC subprocedure that looks like the following:

In this example, the global variable named M_SZSORTFIELD is used to identify the field to be used by the sort routine. Just before calling qsort(), you would set the value of this field to the name of the field by which you wanted to sort. So, for example, if you want to sort by ZIPCODE, you would move 'ZIPCODE' into m_SZSORTFIELD and then call SORTDS, as follows:

The qsort() procedure is much faster and more dependable than SORTA, and it allows you to sort only those entries in the data structure or array that contain data (no need to use some silly technique like initializing the entire array with all 9s). If you can get used to using %ADDR and %PADDR, there really isn't any difficulty at all.

So give it a try!

Bob Cozzi has been programming in RPG since 1978. Since then, he has written many articles and several books, including The Modern RPG Language--the most widely used RPG reference manual in the world. Bob is also a very popular speaker at industry events such as RPG World and is the author of his own Web site and of the RPG ToolKit, an add-on library for RPG IV programmers.