Expressions and Data Type Conversions

The arithmetic operators perform calculations. Programs that accept numeric input and produce numeric output use arithmetic operators to construct expressions that perform the required calculations. The infix arithmetic operators are listed in Table 6.2, “Infix Arithmetic Operators”.

In addition, there are two prefix operators: unary plus (+) and unary minus (-). The unary plus is valid on any arithmetic operand, but it performs no actual operation. The unary minus reverses the sign of any arithmetic operand.

For any arithmetic operator, operands must be arithmetic; that is, they must be constants, variables, or other expressions with the data type attribute BINARY, DECIMAL, or PICTURE. Operands of different arithmetic types are converted to a common type before the operation is performed.

Arithmetic operators have a predefined precedence that governs the order in which operations are performed. All expressions can be enclosed in parentheses to override the rules of precedence. Table 6.4, “Precedence of Operators” lists the precedence of operators.

The logical operators perform logical operations on one or two operands. The operands of the logical operators must be bit-string expressions, except that the operand of the NOT operator can be a bit-string expression or a single relational operator. All relational expressions result in bit-string values of length 1, and they can therefore be used as operands in logical operations.

Except when the NOT operator is used as the prefix of a relational operator, the result of a logical operation is always a bit string.

Except for AND THEN and OR ELSE, logical operations are performed on their operands bit by bit. If bit-string operands are not the same length, PL/I extends the smaller of the operands on the right (that is, in the direction of the least significance) with zeros to match the length of the larger operand. This length is always the length of the result.

Table 6.3, “Logical Operators” describes the prefix and infix operators.

You can define additional operations on bit strings with the BOOL built-in function.

Logical expressions will not be completely evaluated in some cases. If the result of the total expression can be determined from the value of one or more individual operands, the evaluation can be terminated. For example:

A & B & C & D & E

In this expression, evaluation will stop when any operand or the result of any operation is a bit string containing all zeros.

Examples

DECLARE (BITA,BITB,BITC) BIT(4);
BITA = '0001'B;
BITB = '1001'B;
BITC = ^BITA;  /* BITC equals '1110'B */
BITC = BITA | BITB;    /* BITC equals '1001'B */
BITC = BITA & BITB;    /* BITC equals '0001'B */
BITC = ^(BITA & BITB); /* BITC equals '1110'B */
BITC = ^(BITA > BITB); /* BITC equals '1000'B (true) */

In the last assignment statement, the logical NOT expression yields '1'B; when this value is assigned to BITC, a BIT(4) variable, the value is padded with zeros and becomes '1000'B.

IF A ^> B THEN
       /* equivalent to IF A <= B ... */

DECLARE (BITA, BITB) BIT (4);
BITA = '0011'B;
BITB = ^BITA;

IF ^(MORE_DATA) THEN ...

DECLARE (BITA, BITB, BITC) BIT (4);
BITA = '0011'B;
BITB = '1111'B;
BITC = BITA & BITB;

IF (LINENO(PRINT_FILE) < 60) &
       (MORE_DATA = 'YES') THEN ...

DECLARE (BITA, BITB, BITC) BIT (4);
BITA = '0011'B;
BITB = '1111'B;
BITC = BITA | BITB ;

IF (LINENO(PRINT_FILE) < 60) |
       (MORE_DATA = YES) THEN ...

DECLARE (BITA, BITB, BITC) BIT (4);
BITA = '0011'B;
BITB = '1011'B;
BITC = BITA ^ BITB;

IF (A > 0) ^ (B > 0) THEN ...

IF (P ^= NULL()) &: (P->X ^= 4) THEN ...

'00001'B |: '10000'B

'1'B

IF (A=0) |: (B/A > 1) THEN ...

The relational, or comparison, operators test the relationship of two operands; the result is always a Boolean value (that is, a bit string of length 1). If the comparison is true, the resulting value is '1'B; if the comparison is false, the resulting value is '0'B. The relational operators are all infix operators. The following table describes all the relational operators:

Note that PL/I recognizes the tilde symbol (~)as synonymous with the circumflex (^).

Relational operators compare any of the following data types: arithmetic (decimal or binary); bit-string; character-string; and entry, pointer, label, or file data. Specific results of operations on each type of data are elaborated below. The following general rules apply:

The concatenation operator produces a single string from two strings specified as operands. The concatenation operator is two vertical bars (| |).

The operands must both be character strings or both be bit strings. (If not, the appropriate conversion is performed, and you get a warning message about the conversion. The result of the operation is a string of the same type as the operands.

CONCAT: PROCEDURE OPTIONS(MAIN);
DECLARE OUTFILE STREAM OUTPUT PRINT FILE;

       PUT FILE(OUTFILE) SKIP LIST('ABC' || 'DEF');
       PUT FILE(OUTFILE) SKIP LIST('001'B || '110'B);
       PUT FILE(OUTFILE) SKIP LIST((3)'001'B !! '07'B3);

END CONCAT;

ABCDEF
'001110'B
'001001001000111'B

PL/I can perform data conversions in the following contexts:

If an attempt is made to assign a value to a target for which there is no defined conversion, the compiler generates a diagnostic message. For example:

F = '133.45';

If F is a variable with the attributes FIXED DECIMAL (5,2), then the statement assigns the numeric value 133.45 to F, as expected, although the compiler issues a WARNING message about the implicit conversion, stating that the constant '133.45' has been converted to a FIXED DECIMAL target. The warning does not prevent you from linking and running the program. However, note the following example:

F = 'ABC';

This statement results not only in a compiler WARNING message but, if you go on to link and run the program, you also receive a CONVERSION condition. This is normally fatal unless it is handled with an ON CONVERSION ON-unit.

Table 6.5, “Contexts in Which PL/I Converts Data” describes the contexts in which PL/I converts data. The table also lists the built-in conversion functions, such as BINARY and CHARACTER, which you can use when you want to explicitly indicate a conversion and to specify such characteristics as the precision or string length of the converted result.

entry-name
RETURNS (attribute ...);
⋮
RETURN (value);

Even though arithmetic operands can be of different arithmetic types, all operations will be performed on objects of the same type. Any set of operands of different arithmetic types has an associated derived type, as follows:

Table 6.6, “Derived Data Types” gives the derived data type for two arithmetic operands of different types. (Note that the types derived from FIXED DECIMAL in Table 6.6, “Derived Data Types” are also derived when one operand is pictured.)

Table 6.7, “Converted Precision as a Function of Target and Source Attributes” gives the precision resulting from the conversion of an operand to its derived type. The values p and q are known as the converted precision of an operand and are based on the values p and q of the source operand.

All arithmetic operations except exponentiation are performed in the derived type of the two operands. Exponential operations are performed in a data type that is based on the derived type of the operands. All operations, including exponentiation, have results of the same type as that in which they are performed.

The result of an arithmetic operation can be assigned to a target variable of any computational type. The result is converted to the target type, following the rules in Section 6.4.5, “Implicit Conversion During Assignment”.

As operations must be performed on operands of the same type, the following conversions are performed when operands do not match in nonarithmetic operations:

PL/I issues a warning message about a conversion in a concatenation expression, except when converting from picture to character.

The built-in conversion functions can take arguments that are either arithmetic or string expressions. They are often used to convert an operand to the type required in a certain context—for instance, to convert a bit string to an arithmetic value for use as an arithmetic operand.

For the purpose of these functions, and in a few other contexts, derived arithmetic attributes are also defined for bit- and character-string expressions:

PL/I uses these derived attributes to determine the precision of values returned by the conversion functions if no precision is specified in the functions' argument lists. Note that the value of a string argument must also be convertible to the result type; for instance, '1.333' is convertible to arithmetic, but 'XYZ' is not.

Table 6.8, “Built-In Functions for Conversions Between Arithmetic and Nonarithmetic Types” indicates which built-in functions you should use for each conversion between an arithmetic and a nonarithmetic type. In addition, you can use the BINARY, DECIMAL, FIXED, and FLOAT built-in conversion functions to control conversions between two arithmetic types.

During assignment, PL/I automatically converts the derived data type of an expression to the data type of a target, if necessary. In assignments, conversions are defined between the noncomputational types POINTER and OFFSET, and between any two computational types. However, a conversion during assignment results in an error if PL/I cannot perform it in a meaningful way. For example, you can assign the string '123.4' to a fixed decimal variable; you cannot, however, assign the string 'ABCD' to the same variable. Similarly, an assignment of an arithmetic type to a fixed variable results in the FIXEDOVERFLOW condition if integral digits are lost.

Although PL/I performs conversions in assignment statements, such conversions may represent programming errors and are in violation of the PL/I G subset standard. Therefore, the compiler issues a warning message that an implicit conversion is taking place. These messages do not terminate the compilation and may not indicate errors; they simply alert you to the fact that your program converts one data type to another in a way that may cause a problem when the program is run. You can prevent such warning messages in two ways:

For example:

DECLARE (A,B) FIXED DECIMAL (5,2);
       A = '123.45';   /* Warning message */
       B = FIXED('123.45',5,2);        /* No warning */

Both assignment statements assign the same value to their targets; however, the first statement causes a warning message from the compiler, while the second statement does not.

Expressions of any computational type can be assigned to arithmetic variables. The conversion rules for each source type are described in the following sections.

CONVTB: PROCEDURE OPTIONS(MAIN);

DECLARE STATUS FIXED BINARY(8);
DECLARE STATUS_D FIXED DECIMAL(10);
DECLARE OUT PRINT FILE;

OPEN FILE(OUT) TITLE('CONVTB.OUT');
ON FIXEDOVERFLOW PUT SKIP FILE(OUT)
LIST('Fixedoverflow:');

STATUS = '1001101'B;
PUT SKIP FILE(OUT) LIST(STATUS);

STATUS_D = '001101'B;
PUT SKIP FILE(OUT) LIST(STATUS_D);

STATUS = '1232'B2;
PUT SKIP FILE(OUT) LIST(STATUS);

STATUS = 'FF'B4;
PUT SKIP FILE(OUT) LIST(STATUS);

STATUS_D = '10111111111111111111111111111111'B;
END CONVTB;

       77
               13
       110
       255

Fixedoverflow:

DECLARE SPEED FIXED DECIMAL (9,4);
SPEED = '23344.3882';
       /* string converted to 23344.3882 */

SPEED = '32423.23SD';
       /* CONVERSION condition */

SPEED = '4324324.3933';
       /* FIXEDOVERFLOW condition */

SPEED = '1.33336';
       /* string converted to 1.3333 */

In the conversion of any data type to a bit string, PL/I first converts the source data item to an intermediate bit-string value. Then, based on the length of the target string, it does the following:

The next sections describe how PL/I arrives at the intermediate bit-string value for each data type.

CONVB: PROCEDURE OPTIONS(MAIN);

DECLARE NEW_STRING BIT(10);
DECLARE LONGSTRING BIT(16);
DECLARE OUT PRINT FILE;

OPEN FILE(OUT) TITLE('CONVB1.OUT');

NEW_STRING = 35;
PUT FILE(OUT) SKIP
       LIST('35 converted to BIT(10):',NEW_STRING);

NEW_STRING = -35;
PUT FILE(OUT) SKIP
       LIST('-35 converted to BIT(10):',NEW_STRING);

NEW_STRING = 23.12;
PUT FILE(OUT) SKIP
       LIST('23.12 converted to BIT(10):',NEW_STRING);
NEW_STRING = .2312;
PUT FILE(OUT) SKIP
       LIST('.2312 converted to BIT(10):',NEW_STRING);

NEW_STRING = 8001;
PUT FILE(OUT) SKIP
       LIST('8001 converted to BIT(10):',NEW_STRING);

LONGSTRING = 8001;
PUT FILE(OUT) SKIP
       LIST('8001 converted to BIT(16):',LONGSTRING);
END CONVB;

35       converted to BIT(10):  '0100011000'B
-35      converted to BIT(10):  '0100011000'B
23.12    converted to BIT(10):  '0010111000'B
.2312    converted to BIT(10):  '0000000000'B
8001     converted to BIT(10):  '0111110100'B
8001     converted to BIT(16):  '0111110100000100'B

DECLARE NEW_STRING BIT(4);

NEW_STRING = '0010';
       /* NEW_STRING = '0010'B */

NEW_STRING = '11';
       /* NEW_STRING = '1100'B */

NEW_STRING = 'AS110';
       /* CONVERSION condition */

In the conversion of any data type to a character string, PL/I first converts the source value to an intermediate character-string value. Then it does one of the following:

The rules for how PL/I arrives at the intermediate string for conversion of each data type are described below. Examples illustrate the intermediate value as well as the resulting value.

'BB(p)-9'

'-9V.(q)9'

'B(p-q)-9V.(q)9'

DECLARE STRING_1 CHARACTER (8),
       STRING_2 CHARACTER (4);

STRING_1 = 283472.;
       /* intermediate string = ' 283472',
       STRING_1 = ' 28347' */

STRING_2 = 283472.;
       /* intermediate string = ' 283472',
       STRING_2 = ' 2' */

STRING_2 = -283472.;
       /* intermediate string = ' -283472',
       STRING_2 = ' -2' */

STRING_2 = -.003344;
       /* intermediate string = '-0.003344',
       STRING_2 = '-0.0' */

STRING_2 = -283.472;
       /* intermediate string = ' -283.472',
       STRING_2 = ' -28' */

STRING_2 = 283.472;
       /* intermediate string = ' 283.472',
       STRING_2 = ' 28' */

CONCH: PROCEDURE OPTIONS(MAIN);

DECLARE OUT PRINT FILE;
OPEN FILE(OUT) TITLE('CONCH.OUT');

PUT SKIP FILE(OUT) EDIT('''',25E25,'''') (A);
PUT SKIP FILE(OUT) EDIT('''',-25E25,'''') (A);
PUT SKIP FILE(OUT) EDIT('''',1.233325E-5,'''') (A);
PUT SKIP FILE(OUT) EDIT('''',-1.233325E-5,'''') (A);

END CONCH;

'2.5E+26'
'-2.5E+26'
' 1.233325E-05'
'-1.233325E-05'

DECLARE STRING_1 CHARACTER (4),
       STRING_2 CHARACTER (8);

STRING_1 = '1010'B;
       /* STRING_1 = '1010' */

STRING_2 = '1010'B;
       /* STRING_2 = '1010 ' */

STRING_1 = '010011'B;
       /* STRING_1 = '0100' */

A source expression of any computational type can be assigned to a pictured variable. The target pictured variable has a precision (p), which is defined as the number of characters in the picture specification that specify decimal digits. The target also has a scale factor (q) which is defined as the number of picture characters that specify digits and occur to the right of the V character in the picture specification. If the picture specification contains no V character, or if all digit-specification characters are to the left of V, then q is zero.

The source expression is converted to a fixed-point decimal value v of precision (p,q), following the PL/I rules for the source data type. This value is then edited to a character string s, as specified by the picture specification, and the value s is assigned to the pictured target.

When the value v is being edited to the string s, the CONVERSION condition is signaled if the value of v is less than zero and the picture specification does not contain one of the characters S, +, -, T, I, R, CR, or DB. The value of s is then undefined. FIXEDOVERFLOW is signaled if the value v has more integral digits than are specified by the picture specification of the target.

Offset variables are given values by assignment from existing offset values or from conversion of pointer values. Pointer variables are given values by assignment from existing pointer values or from conversion of offset values.

The OFFSET built-in function converts a pointer value to an offset value. The POINTER built-in function converts an offset value to a pointer.

PL/I also automatically converts a pointer value to an offset value, and vice versa, in an assignment statement. The following assignments are valid:

pointer-variable = pointer-value;
offset-variable = offset-value;
pointer-variable = offset-variable;
offset-variable = pointer-value;

In the third and fourth assignments above, the offset variable must have been declared with an area reference.