Bit handling doesn't come up for discussion much anymore. In this day of gigabytes and terabytes, the bit has taken on a lowly state. When disk space was expensive, we were frugal in designing our applications, making use of bits. For example, a bit could specify marital status in payroll or HR applications. Even today, a bit can be used to represent any data that has just two states.
Prior to the arrival of the bit BIFs in RPG IV, bit operations could be performed in the RPG language with the test bit (TESTB), bit on (BITON), and bit off (BITOFF) operations, which are still available in fixed-format RPG IV. The TESTB operation uses a bit position constant (0–7), a one-position field, a hex constant, or a named constant to test the bits in a one-byte result field. Indicators are required, and one of the three is set on, depending on the bit status of the result field. The BITON and BITOFF operations use the bit position constant, etc. to set the specified bits either on or off in the result field.
The new bit BIFs are %bitand, %bitor, %bitxor, and %bitnot. The logic operations of bit "and," "or," "exclusive or," and bit reversal can be performed using these BIFs. If you are now coding in free-format RPG IV, these BIFs are the tools you will use for bit management, since the TESTB, BITON, and BITOFF operations are not available in free-format.
%bitand and %bitor
All three of the fixed-format bit operations can be done with just two of the bit BIFs, but a third does help. The %bitnot can be very helpful when converting from fixed format. Here are examples:
* The bit position constant '04' below only affects
* bits zero and four of result field Field1
C BITON '04' Field1
* After the above operation
* Field1 = X'FC' = B'1111 1100'
* Since the bit at position 4 was already 1, it was
* not changed.
The equivalent of the above operation, in free-format, would be as follows:
// Field1 = X'7C' = B'0111 1100'
Field1 = %bitor(Field1:X'88');
// Field1 = X'FC' = B'1111 1100'
// Notice that X'88' must be used instead of '04'.
// The bit BIFs do not support bit position
// constants but do support hex constants.
The following is an example of a BITOFF operation, assuming the BITON operation above has been performed.
C BITOFF X'28' Field1
* This example uses a hex constant instead of a
* bit position constant.
* After the above operation
* Field1 = X'D4' = B'1101 0100'
The equivalent of the above operation, in free-format, would be as follows:
// Field1 = X'FC' = B'1111 1100'
Field1 = %bitand(Field1:X'D7'); // -or-
Field1 = %bitand(Field1:%bitnot(X’28’);
// After the above statement
// Field1 = X'D4' = B'1101 0100'
The TESTB operation sets indicators for selected bit positions all off, mixed on and off, or all on. In free-format, any of those options can be tested with an IF statement, as follows:
If %bitand(FLD:X'80') = X'80';
---
// Checking to see if the first bit in FLD is 0
If %bitand(FLD:x'80') = X'00';
---
// Checking to see if either the first bit is on or
// the fifth bit is on in FLD
If %bitand(FLD:X'88') <> X'00'
And %bitand(FLD:X'88') <> X'88';
---
There is much more that %bitand and %bitor can do than what I have shown in my examples. Multiple bytes, either character or numeric, can be ANDed or ORed, and multiple expressions can be specified.
%bitnot
The %bitnot BIF uses one argument and inverts the bits. Ones become zeros, and zeros become ones. Here's an example:
ABC = %bitnot(ABC);
// Now field ABC = X'88' = B'1000 1000'
%bitxor
The %bitxor BIF will do an "exclusive or" on two arguments. In layman's language, the "exclusive or" will set a result bit on if one of the two bits being tested is on, but it sets the result bit off if both bits are on. Here's an example:
// Field GHI = X'46' = B'0100 0110'
Answer = %bitxor(DEF:GHI);
// Answer becomes X'39' = B'0011 1001'
Just a Little Bit
Bit BIFs can be very useful in situations requiring management of two-state data, especially for a very large number of records. By their very nature, bits do not take up much space.
For more details and examples of the bit BIFs, check the IBM RPG IV Reference manual.
Jim Martin is a corporate technical instructor at Jack Henry & Associates in Monett, Missouri, and is the author of Free-Format RPG IV. He is a veteran of RPG programming, beginning in 1967 with a position at IBM as a Systems Engineer and later was 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 is a speaker at COMMON and local midrange user group meetings and conferences. He can be reached by email at
LATEST COMMENTS
MC Press Online