The new INLIST built-in function has made it easy for you to simplify code that tests if a expression is in one of a list of values. But sometimes you may want to test  if an expression is in a range of values, as in

                 IF BIRTHYEAR >= 1980 & BIRTHYEAR <= 1999 THEN

The new BETWEEN built-in function makes it easy for you to simplify such code. This function returns a bit(1) value indicating if the value of an expression is within the (closed) interval defined by the other 2 arguments to the function.

More precisely, between( x, a, b ) is equivalent to (x >= a) & (x <= b), and the arguments either must all be ordinals of the same type or must all be computational.

This function would allow you to convert the above code into the simpler

                 IF BETWEEN( BIRTHYEAR, 1980, 1999 ) THEN

This function also makes it less likely that someone would accidentally code the original statement incorrectly as something like

                 IF BIRTHYEAR >= 1980 & BIRTHDAY <= 1999 THEN

and it also eliminates the need to create a temporary value if the test expression is the result of a function. So rather than write

                 BIRTHYEAR = OBTAIN_BIRTHYEAR( ... );
                 IF BIRTHYEAR >= 1980 & BIRTHDAY <= 1999 THEN

you could simply write

                 IF BETWEEN( OBTAIN_BIRTHYEAR( ... ), 1980, 1999 ) THEN

And just as the INLIST built-in function allows the compiler to more easily optimize code that tests if an expression is one of a list of values, the BETWEEN built-in function also allows the compiler to optimize code that tests if an expression is in a range of values. For example, if x in between( x, a, b ) is FIXED BIN and a and b are FIXED BIN constants, then the compiler can generate code to make the test with just one compare and one branch.

So, this function provides a "win-win" : you can write simpler, clearer code, and we can more easily produce better machine code for you.

Finally, this built-in function became officially available with the new 4.5 release of Enterprise PL/I, and while it appears first in the documentation for that release, it is also available to users of the 4.3 and 4.4 releases who have current service applied.

When you use INLIST rather than a long list of comparisons OR'ed together, your code is easier to read and understand, but it is also easier for the compiler to understand and hence to optimize.

For example, for an invocation of INLIST such as

   inlist( x, 2, 3, 5, 7, 11, 13, 17, 19 )

if x is a FIXED BIN(31) variable, the compiler will generate a branch table to determine the result.

And in general, if x is FIXED BIN(p,0) with p <= 31 or FIXED DEC(p,0) with p <= 9, if all the values to test are similarly nice constants, then the compiler will generate a branch table to speed up the evaluation.

If x is CHAR(1) and all the values to test are CHAR(1) constants, then the compiler will generate a very speedy table look-up.

But if all the arguments are CHAR(2) or CHAR(4) (or WCHAR(1) or WCHAR(2)), a series of compares is generated (since the values are unlikely to be "close" and any tables generated to speed up the evaluation would be huge).

However, the new z13 hardware introduced some new vector string handling instructions that can help here.

For example, suppose you had some code that looked like

  dcl countryCode char(2);

  if inlist( countryCode,
             'AT', 'DE', 'CH', 'NL', 'DK', 'FI', 'SE', 'NO' ) then;
  else ...

Before the z13, the compiler would have generated code such as

   5810  1000           L        r1,COUNTRYCODE(,r1,0)
   4800  1000           LH       r0,_shadow1(,r1,0)
   A70E  C1E3           CHI      r0,H'-15901'
   A784  0026           JE       @1L13
   A70E  C4C5           CHI      r0,H'-15163'
   A784  0022           JE       @1L13
   A70E  C3C8           CHI      r0,H'-15416'
                ...

But under OPT(3) and ARCH(11), the ARCH option that indicates your code will run on a z13, four vector instructions and one branch do it faster and more simply!

   5810  1000           L        r1,COUNTRYCODE(,r1,0)
   4100  0002           LA       r0,2
   E700  1000  0037     VLL      v0,r0,_shadow1(r1,0)
   E720  E000  0006     VL       v2,+CONSTANT_AREA(,r14,0)
   E700  2000  1082     VFAE     v0,v0,v2,b'0001',b'0000'
   E700  0001  2021     VLGV     r0,v0,1,2
   EC08  000B  007E     CIJE     r0,H'0',@1L4

Similarly, if the set of values to test has more than 8 elements, the compiler can use these new vectors instructions to search for a value via repeated compares of up to 8 values.

Analagous code will also handle INLIST with

      4 or more CHAR(4) values

      8 or more WCHAR(1) values

      4 or more WCHAR(2) values

And, as you may have already noticed, the minimum number of test values when multiplied by the size of an individual value is 16, the same as the size (in bytes) of a z13 vector. When there are fewer test values, the set of repeated simple compares is faster, and the compiler will still generate them.

So, in summary, INLIST not only gives you more expressive PL/I language, but it makes it easier for the compiler to turn your programs into better performing code.
 

There are many times when you may want to test if a value is equal (or not equal) to one of a set of values. You can do this easily with a SELECT statement or an IF statement as in the following code

                 IF (EXPLAN.ACCESSTYPE = 'I ' |
                     EXPLAN.ACCESSTYPE = 'N ' |
                     EXPLAN.ACCESSTYPE = 'DX' |
                     EXPLAN.ACCESSTYPE = 'IN' |
                     EXPLAN.ACCESSTYPE = 'MH' |
                     EXPLAN.ACCESSTYPE = 'MI' |
                     EXPLAN.ACCESSTYPE = 'MU' |
                     EXPLAN.ACCESSTYPE = 'NR' |
                     EXPLAN.ACCESSTYPE = 'P ' |
                     EXPLAN.ACCESSTYPE = 'MX')
                   & ( EXPLAN.MATCHCOLS = 0 )
                 THEN;
                 ELSE ...

But the new INLIST built-in function makes it easy for you to simplify this code. This function returns a bit(1) value indicating if the value of an expression is equal to any of the values of the other arguments to the function.

More precisely, inlist( x, y1, y2, ..., yn ) is equivalent to (x = y1) | (x = y2) | ... | (x = yn), and inlist requires at least 3 arguments and a maximum of 63 test arguments (although this maximum count is arbitrary and can be increased if some user has a need for a greater number of test values).

This function would allow you to convert the above code into the much simpler

                 IF INLIST( EXPLAN.ACCESSTYPE,
                             'I '
                             'N ',
                             'DX',
                             'IN',
                             'MH',
                             'MI',
                             'MU',
                             'NR',
                             'P ',
                             'MX'   )
                   & ( EXPLAN.MATCHCOLS = 0 )
                 THEN;
                 ELSE ...

It is also especially good for simplifying code that tests if a value is not in a set of values. So, for example, this piece of code

                 IF (KEYWORD ^= 'LVL=') & (KEYWORD ^= 'SID=')
                  & (KEYWORD ^= 'SET=') & (KEYWORD ^= 'TOP=')
                  & (KEYWORD ^= 'BEG=') & (KEYWORD ^= 'END=')
                  & (KEYWORD ^= 'BWN=') & (KEYWORD ^= 'EWN=')
                  & (KEYWORD ^= 'MBR=') & (KEYWORD ^= 'DSN=')
                 THEN DO;

could be written as the more readable

                 IF ^ INLIST( KEYWORD,
                              'LVL=',
                              'SID=',
                              'SET=',
                              'TOP=',
                              'BEG=',
                              'END=',
                              'BWN=',
                              'EWN=',
                              'MBR=',
                              'DSN='  )
                 THEN DO;

Also, not only does this function make it easier for you to write simpler, clearer code (and that is always a good thing), the compiler can do a much better job of optimizing such code (and I will talk about that in my next post).

Finally, this built-in function became officially available with the new 4.5 release of Enterprise PL/I, and while it appears first in the documentation for that release, it is also available to users of the 4.3 and 4.4 releases who have current service applied.                  

IBM has been quietly delivering a new release of the PL/I compiler every year since 1999 on System z.  The recent announcement of Enterprise PL/I for z/OS continues to show IBM’s commitment to delivering a world class PL/I compiler on System z.

Enterprise PL/I for z/OS V4.5 is enhanced to fully exploit the new z13 architecture. It uses the new Vector Facility to improve the performance of the code generated for the verify and search built-in functions and expands the use of the Decimal Floating Point Facility for fixed decimal calculations.  Enterprise PL/I for z/OS V4.5 provides significant performance improvements over Enterprise PL/I V4.4. Compute intensive applications running on z13 (compiled with Enterprise PL/I V4.5) have shown CPU time reduction of up to 17% over the same applications running on zEC12 (compiled with Enterprise PL/I V4.4). This significant improvement in performance is achieved through a combination of more powerful z13 hardware and improved compiler optimization.

Enterprise PL/I V4.5 also has many new features. It addressed 28 customer requirements. The most significant new feature is providing full, integrated support (i.e. parse, generate, and validate) for JSON, the preferred lightweight data exchange format for mobile applications. Other significant new features include raising the maximum size of strings (from 32K to 128M), generating faster code for CICS calls, allowing structures to be used as SQL indicator variables, supporting named constants as SQL host variables, and new compiler options to improve code quality and analyze runtime problems.

Enterprise PL/I for z/OS V4.5 is scheduled to become generally available on February 27, 2015. More information.

Are you looking for PL/I documentation across different releases? Do you want to access PL/I documentation of both the HTML and PDF format?

The PL/I library pages now provide the following types of PL/I documentation in one central location:

• Announcement letters
• PDF documentation
• HTML documentation URL

Start visiting the following PL/I library pages:

• Enterprise PL/I documentation library
• PL/I for AIX documentation library
• PL/I for MVS & VM
• PL/I for VSE

Peter Elderon from the IBM compiler development team will be presenting on what's new in Enterprise PL/I for z/OS at SHARE in Anaheim, March 9 to 14.

15284: PL/I - What's New

Register for SHARE in Anaheim today!

Check out all the information about the latest release of Enterprise PL/I for z/OS. You can get a summary of the release as well as all the announcement details.
 
See what's new with Enterprise PL/I for z/OS, V4.4 including enhancements to leverage the latest z/OS. For all the details about the Enterprise PL/I for z/OS, V4.4 announcement, see here.
 

ALLOCATE is a storage control built-in function, which allocates storage of the specified size in the heap. You can also use ALLOCATE to allocate the specified size in the specified area.

When you specify ALLOCATE(n), ALLOCATE allocates storage of size n in heap storage and returns the pointer to the allocated storage.  If necessary, n is converted to REAL FIXED BINARY(31,0). If the requested amount of storage is not available, the STORAGE condition is raised.

The ALLOCATE built-in function now has the AREA reference as a new optional argument. When you specify ALLOCATE(n, x), the specified number of bytes n is allocated within that area. The number is rounded up to a multiple of 8. If there is insufficient space within the specified area, the AREA condition is
raised.

For more information, see Built-in functions, pseudovariables, and subroutines.

The PL/I workstation compiler supports the following interfaces to other products:

1. Using the sort program
The compiler provides an interface called PLISRTx (x = A, B, C, or D) that allows you to make use of the IBM-supplied Sort programs. To use the Sort program you must include the correct PL/I statements in your source program and specify the correct data sets in your JCL.


2. Interlanguage Communication between PL/I and C
The Interlanguage Communication (ILC) between PL/I and C is supported. You can write PL/I code that either calls or is called by C.

3. Interfacing with Java
The Java Native Interface (JNI) is the Java interface to native programming languages and is part of the Java Development Kits. By writing programs that use
the JNI, you ensure that your code is portable across many platforms. The JNI allows Java code that runs within a Java Virtual Machine (JVM) to operate
with applications and libraries written in other languages, such as PL/I. In addition, the Invocation API allows you to embed a Java Virtual Machine into your
native PL/I applications.

For more information, see "Using interfaces to other products".