PL/I Reference Manual	C.1 Using a Parameter Block

Routine		to divide single precision float value by 2

cseg
public		div2
extrn 		?signal:near

entry:
pl		fixed(7) power of two
	p2		floating point number
	exit:
pl		(unchanged)
p2		p2 / (2**pl)

div2:	;BX = 		low(.pl)
mov		si,[bx]	;SI =	pl
mov		bx,2[bx]	;BX =	p2
lods		al	;AL = pl (power of 2)

AL = power of 2, BX = low byte of fp num

cmp		byte ptr 3[bx],O	;p2 already zero?
	jz		done		;exit if so
dby2:				;divide	by two
	test		al,al		;counted power of 2 to zero?
	jz		done		;return if so
	dec		al		;count power of two down
sub		word ptr 2[bxl,80h	;count exponent down
test		word ptr 2[bxl,7f8Oh	;test for underflow
jnz		dby2	;loop again if no underflow

Underflow occurred, signal underflow condition

	mov		bx,offset siglst,-signal parameter list
	call		?signal	;signal underflow
done:		ret		;normally, no return
	dseg
siglst		dw	offset sigcod	;address of signal code
	dw		offset sigsub	;address of subcode
	dw		offset sigfil	;address of file code
	dw		offset sigaux	;address of aux message
end of parameter vector, start of params
sigcod		db	3	;03 = underflow
sigsub		db	128	;arbitrary subcode for id
sigfil		dw	0000	;no associated file name
sigaux		dw	offset undmsg	;0000 if no aux message
undmsg		db	32,'Underflow in Divide by Two',O

end

Listing C-3. DIV2.A86 Assembly Language Program (8086)

C-5
PL/I Reference Manual	C.1 Using a Parameter Block

A>dtest

100	2	0	=	1.OOOOOOE+02
100	2	1	=	5.OOOOOOE+01
100	2	2	=	2.500000E+01
100	2	3	=	1.250000E+01
100	2	4	=	0.625000E+01
100	2	5	=	3.125000E+00
100	2	6	=	1.562500E+00
100	2	7	=	0.781250E+00
100	2	8	=	3.906250E-01
100	2	9	=	1.953125E-01
100	2	10	=	0.976562E-01
100	2	127	=	0.587747E-36
100	2	-128	=	2.938735E-37
100	2	-127	=	1.469367E-37
100	2	-126	=	0.734683E-37
100	2	-125	=	3.673419E-38
100	2	-124	=	1.836709E-38
100	2	-123	=	0.918354E-38
100	2	-122	= 	4.591774E-39
UNDERFLOW (128), Underflow in Divide By Two
Traceback: 017F 011B
A>

Listing C-4. DTEST Output (Abbreviated)

C.2 Returning Values in Registers or on the Stack

As an alternative to returning values through a Parameter Block,
PL/I has subroutines that produce function values that are then
returned directly in the registers or on the stack. This section
shows the conventions for returning data as functional values.
References to 8086 registers are in parentheses.

C.2.1 Returning FIXED BINARY Data

Functions that return FIXED BINARY data items do so by leaving the
result in a register, or register pair, depending upon the precision
of the data item.

PL/I returns FIXED BINARY data with precision 1-7 in the A(AL)
register, and data with precision 8-15 in the HL(BX) register pair.
It is always safe to return the value in HL (BX) , and copy the low
order byte to A(AL) so register A(AL) is equal to register L(BL)
upon return.

c-6
PL/I Reference Manual	C.2 Using Registers or the Stack

C.2.2 Returning FLOAT BINARY Data

PL/I-80 R1.4 returns single-precision, floating-point numbers on the
stack as four contiguous bytes in the Microsoft format. The low
order byte of the mantissa is at the top of the stack, followed by
the middle byte, then the high byte. The fourth byte is the
exponent of the number. The high-order bit of the mantissa is the
sign bit.

For example, the value 1.5 is returned as

!0010014018		(low stack)
t
SP

PL/I-86 R1.0 returns single-precision, floating-point numbers on the
stack as four contiguous bytes in the IEEE format. The low-order
byte of the mantissa is at the top of the stack, followed by the
middle byte, then the high byte. The high-order bit is the sign
bit, and the low-order bit of the exponent is in the high-order byte
of the mantissa.

For example, the value 1.5 is returned as

LI
00,001C013F1 (low stack)

SP

PL/I-80 R1.4 and PL/I-86 Rl.l return double-precision, floating
point numbers as eight contiguous bytes on the stack. The low-order
byte of the mantissa is at the top of the stack. The exponent
occupies three nibbles: the eighth byte, and the high-order nibble
of the seventh byte.

For example, the value -39.5 is returned as

L00		- - CO 431CO	(low stack)
l*~ 0 01 0 0 1
SP

C.2.3		Returning FIXED DECIMAL Data

PL/I returns FIXED DECIMAL data on the stack as 8 contiguous bytes.
The low-order BCD pair is at the top of the stack. The number is
represented in ten's complement form, and sign-extended through the
high-order digit position, with a positive sign denoted by 0, and a
negative sign denoted by 9.

For example, PL/I returns the decimal number -2 as

19819919919~ 	91 (low stack) 		-->

SP

C-7
PL/I Reference Manual	C.2	Using Registers or the Stack

C.2.4	Returning CHARACTER Data

PL/I-80 and PL/I-86 R1.0 return CHARACTER data items on the stack,
with the length of the string in a register. For example, the
string

'Walla Walla Wash'

is returned as shown:

A	(8080)
-Ts
-Ta	h] (low stack)
Fl _0~	bJWJaJlJlJaFW [W 	T
AL (8086)

SP

where register contains the string length 10 (hexadecimal), and the
Stack Pointer SP addresses the first character in the string.

PL/I-86 Rl.l returns CHARACTER data items on the stack as varying
length string with the 4-byte length field first. For example, the
string:

'Walla Walla Wash'

is returned as
1 10100100100 - I_WJaJlJlJaJ	(low stack)
f
SP

C.2.5	Returning BIT Data

PL/I returns bit-string data in a register, or register pair,
depending upon the precision of the data item.

PL/I returns bit strings of length 1-8 in the A(AL) register, and
bit strings of length 9-16 in the HL(BX) register pair. Bit strings
are left justified in their fields, so the BIT(l) value true is
returned in the HL(BX) register as 80 (hexadecimal) . It is safe to
return a bit value in the HL(BX) register pair and copy the high
order byte in A(AL), so register A(AL) is equal to register H(BH)
upon return.

C.2.6	Returning POINTER Variables

PL/I-80 and PL/I-86 return POINTER variables in the HL(BX) register
pair. When returning a label variable that can be the target of a
GOTO operation, the subroutine containing the label must restore the
stack to the proper level when control reaches the label.

C-8
PL/I Reference Manual	C-2		Using Registers or the Stack

C.2.7		Returning ENTRY and LABEL Variables

PL/I-80 R1.4 and PL/I-86 R1.0 return ENTRY and LABEL variables in
the HL(BX) register pair. When returning a label variable that can
be the target of a GOTO operation, the subroutine containing the
label must restore the stack to the proper level when control
reaches the label.

PL/I-86 R1.1 returns ENTRY and LABEL variables on the stack as 8
contiguous bytes. The low-order byte is at the top of the stack.
Offseti Code segment I Stack Framel Stack	(low stack)-
f
bil

The following program listings illustrate the concept of returning a
functional value. Listing C-5 shows the program called FDTEST that
is similar to the previous floating-point divide test. However,
FDTEST includes an entry definition for an assembly language
subroutine called FDIV2 that returns the result on the stack.
Listing C-6 shows FDIV2.ASM in 8080 assembly language, and Listing
C-7 shows FDIV2.A86, the same routine in 8086 assembly language.

FDIV2 resembles the previous subroutine DIV2 with some minor
changes. First, FDIV2 loads the input floating-point value into the
BC(CX) and DE(DX) registers so that it can manipulate a temporary
copy and not effect the original input value. FDIV2 then decreases
the exponent field in register B(CH) by the input count, and returns
it on the stack before executing the PCHL instruction.

	1			a
	2			a	/* This program tests the assembly language routine
	3			a	/* called FDIV2 which returns a FLOAT BINARY value.
	4			a
	5			a	fdtest:
	6			b		procedure options(main);
	7			b		declare
	8			b		fdiv2 entry(fixed(7),float) returns(float),
	9			b		i fixed(7),
	10			b		f float;
	11			b
	12			c		do i = 0 by 1;
13			c		put skip list('100 / 2 **',i,'=',fdiv2(i,l00));
14			c		end;
15			b
16			b	end fdtest;

Listing C-5. The FDTEST Program

C-9
PL/I Reference Manual	C.2 Using Registers or the Stack

title	'div by power of two (function)'
public	fdiv2
extrn	?signal
entry:
pl	fixed(7) power of two
	p2	floating-point number
	exit:
pl 	(unchanged)
	p2		(unchanged)
stack:	p2	(2 ** pl)
fdiv2:			;HL =	low(.pl)
	mov	e,m	;low(.Pl)
	inx	h	;HL =	high(.pl)
	mov	d,m	;DE =	pl
	inx	h	;HL =	low(p2)
	ldax	d	;a = pl (power of two)
	mov	e,m	;low(.p2)
	inx	h	;HL =	high(.p2)
	mov	d,m	;DE =	p2
	xchg		;HL = 	p2

A = power of 2, HL = low byte of fp num
mov	e,m	;E = low mantissa
inx	h	;to middle of mantissa
mov	d,m	;D = middle mantissa
inx	h	;to high byte of mantissa
mov	C'm	;C = high mantissa
inx	h	;to exponent byte
mov	b,m	;B = exponent
inr	b	;B = 00?
dcr	b	;becomes 00 if so
jz	fdret	;to return from float div

dby2:	;divide by two
ora	a	;counted power of 2 to zero?
jz	fdret	;return if so
dcr	a	;count power of two down
dcr	b	;count exponent down
jnz	dby2	;loop again if no underflow

;underflow occurred, signal underflow condition
lxi	h,siglst;signal parameter list
call	?signal ;signal underflow
	lxi	b,O	;clear to zero
	lxi	d,O	;for default return
fdret:	pop	h	;recall return address
	push	b	;save high order fp num
	push	d	;save low order fp num
	pchl		;return to calling routine

Listing C-6. FDIV2.ASK Assembly Language Program (8080)

C-10
PL/I Reference Manual	C.2 Using Registers or the Stack

	dseg
siglst:		dw	sigcod	;address	of	signal code
	dw		sigsub	;address	of	subcode
	dw		sigfil	;address	of	file code
	dw		sigaux	;address	of	aux message
end of parameter vector, start of params
sigcod:		db	3		;03 = underflow
sigsub:		db	128		;arbitrary subcode for id
sigfil:		dw	0000	;no associated file name
sigaux:		dw	undmsg	;0000 if no aux message
undmsg:		db	32,'Underflow in Divide by Two',O
	end
			Listing C-6. (continued)
		Division by power of two (function)
	cseg
public		fdiv2
extrn		?signal:near

entry:
pl		fixed(7) power of two
	p2		floating point number
	exit:
pl 		(unchanged)
	p2			(unchanged)
stack:		p2	(2 ** pl)

fdiv2:	;BX = 		low(.pl)
mov		si,[bxl	;SI =	p1
lods		al	;AL = pl (power of 2)
mov		bx,2[bx]	;BX = 	p2

AL = power of 2, BX = low byte of fp num

mov		dx,[bxl	;DX = low and middle mantissa
mov		cx,2[bx]	;CL = high mantissa, CH = exponent
test		cx,7f8Oh	;exponent zero?
jz		fdret	;to return from float div

Listing C-7. FDIV2.A86 Assembly Language Program (8086)

C-11
PL/I Reference Manual		C.2	Using Registers or the Stack
dby2:	;divide		by two
test	al,al	;counted power of 2 to zero?
jz	fdret	;return if so
dec	al	;count power of two down
sub	cx,80h	;count exponent down
test	cx,7f8Oh	;test for underflow
jnz	dby2	;loop again if no underflow

Underflow occurred, signal underflow condition

mov	bx,offset siglst;signal parameter list
call	?signal	;signal underflow
sub	cx,cx	;clear result to zero for default return
mov	dx,cx

fdret:	POP	bx	;recall return address
	push	cX	;save high order fp num
	push	dx	;save low order fp num
	imp	bx	;return to calling routine

	dseg
siglst	dw	offset		sigcod	;address	of	signal code
	dw	offset		sigsub	;address	of	subcode
	dw	offset		sigfil	;address	of	file code
	dw	offset		sigaux	;address	of	aux message
end of parameter vector, start of params
sigcod	db	3	;03 = underflow
sigsub	db	128	;arbitrary subcode for id
sigfil	dw	0000	;no associated file name
sigaux	dw	offset undmsg	;0000 if no aux message
undmsg	db	32,'Underflow in Divide by Two',O

end

Listing C-7. (continued)

C.3 Direct Operating System Function Calls

You can have direct access to all the operating system functions
through the optional subroutines in assembly language programs that
are included in source form on your PL/I sample program disk. The
sample program disk also contains the file RELNOTES.PRN which
describes these assembly language programs and several PL/I programs
that test the various function calls.

The subroutines in these programs are not included in the standard
PLILIB because specific applications might require changes to the
system functions that either remove operations to decrease space or
alter the interface to a specific function. If the interface to a
function changes, you must change the entry point to avoid
confusion.

End of Appendix C

C-12
	Appendix D
Compiler Options

Table D-1 lists the compiler options and gives a brief description
of their use. In each case, the single-letter option follows the $
symbol in the command line. You can specify a maximum of seven
options following the dollar sign. The default mode using no
options compiles the program but produces no source listing and
sends all error messages to the console.

Table D-1. PL/I Compiler Options

Option	Action Enabled

A		Abbreviated listing. Disables the listing of
parameter and %INCLUDE listings statements during
the compiler's first pass.

B		Built-in subroutine trace. Shows the Run-time
Subroutine Library functions that are called by your
PL/I program.

D		Disk file print. Sends the listing file to disk,
using the filetype PRN.

I		Interlist source and machine code. Decodes the
machine language code produced by the Compiler in a
pseudo-assembly language form.

K		Same as A. (8080 implementations)

L		List source program. Produces a listing of the
source program with line numbers and machine code
locations (automatically set by the I switch).

N		Nesting level display. Enables a pass 1 trace that
shows exact balance of DO, PROCEDURE, and BEGIN
statements with their corresponding END statements.

0		Object code off. Disables the output of relocatable
object code normally produced by the Compiler.

P		Page mode print. Inserts form-feeds every 60 lines,
and sends the listing to the printer.

S		Symbol Table display. Shows the program variable
names, along with their assigned, defaulted, and
augmented attributes.

End of Appendix D

D-1
	Appendix E
Error Messages and Condition Codes

PL/I can detect two kinds of errors: compilation errors and run-time
errors. The compiler marks each compilation error with a ?
character near the position of the error in the line, and an error
message following the line containing the error. The ? might follow
the actual error position by a few columns. In some cases, an error
on one line can lead to errors on subsequent lines.

PL/I categorizes errors as either recoverable or nonrecoverable.
Most compilation errors are recoverable, and the compiler continues
processing the source file. However, some compilation errors are
nonrecoverable. The compiler stops processing and control
immediately returns to the operating system.

The run-time system detects errors while the program is running.
Most run-time errors are recoverable if intercepted by an ON-unit.
However, some run-time errors are nonrecoverable. The program stops
and control immediately returns to the operating system.

This appendix lists the error messages that appear in each
implementation. The errors are listed in the following order:

9 General errors
* Compilation errors (by pass)
e Run-time errors

Note: all nonrecoverable errors are marked with an asterisk.

E-1
PL/I Reference Manual	PL/I-80 R1.4 and PL/I-86 R1.0

E.1	PL/1-80 RIA and PL/I-86 R1.0

Table E-1. General Errors

Error	Description
DIR FULL*
	There is no more space available in the
	operating system's disk directory. You
	should erase all unnecessary files and try
	again.
DISK FULL*
	There is no more disk file space
	available. You should erase all
	unnecessary files and try again.
INVALID INCLUDE
	There is a syntax error in an %INCLUDE
	statement. The %INCLUDE statement has the
	general form
	%include 'd:filename.typ';
	where d is the (optional) drive, and
	filename.typ is the file specification.
LENGTH
	The item exceeds the maximum field width
	for the keyword or data item (31
	characters for identifiers, 128 for
	strings).
NO FILE x*
	The file x is not on the disk. If x is of
	type PLI, then ensure that your source
	file is on the named disk. If the type is
	OVR, or OVL, then ensure that all three
	PL/I compiler overlays (PLIO, PLI1, PL12)
	are on the default disk.

E-2
PL/I Reference Manual	PL/I-80R1.4 and PL/I-86 R1.0

Table E-1. (continued)

Error	Description

OUT OF MEMORY

The size of your system's Transient
Program Area (TPA) is too small. You must
re-configure the system.

READ ONLY X*

PL/I cannot close the file named x. This
is typically caused by disk that is set to
Read-Only through hardware.

TERMINATED.*

The number of compilation errors exceeds
255, or the compilation has been
terminated at the console by the user.

TRUNC

A line exceeds 120 characters in length
and has been truncated.

U--N-EXPECT-ED EOF*

The compiler has encountered the end of
the source program before the logical end
of program. This is typically due to
unbalanced block levels (recompile with
the $n option for a nesting trace) , or
unbalanced comments and strings (check
balance for missing */ or apostrophe
characters).

VALUE

Indicates that the converted number
exceeds the 16-bit capacity for FIXED
BINARY constants (-32768, +32767).

E-3
PL/I Reference Manual	PL/I-80 R1.4 and PL/I-86 R1.0

Table E-2. Compilation Errors

Pass 1 Errors

Error	Description
BAD VAL
	The constant encountered in a format is
	invalid for this format item.
BALANCE
	The left and right parentheses for the
	expression are not balanced.
BLOCK AT LINE 	x VARIABLE v EXCEEDS STORAGE
	The block beginning at source line x
	contains a variable v that caused the
	collective allocation of storage to exceed
	65535 bytes.
BLOCK OVERFLOW
	The nesting level of PROCEDURE, DO, and
	BEGIN blocks exceeds thirty-one levels.
	You must simplify the program structure
	and try again.
CONFLICT
	The data attributes given in a DECLARE
	statement conflict with one another.
DUPLIC
	The indicated variable is declared more
	than once within this block.
LABEL
	The label for this statement is not
	properly formed. Only one label per
	statement is allowed, and subscripted
	label constants must have constant
	indices.

-,-IN

E-4
PL/I Reference Manual	PL/I-80 R1.4 and PL/I-86 R1.0

Table E-2. (continued)

Error	Description
LENGTH
	The length of the indicated symbol exceeds
	the maximum symbol size. You must
	simplify the structure and try again.
	This error can also be caused by an
	unbalanced string.
NESTED REP
	The %REPLACE statement is improperly
	placed in the block structure. All
	%REPLACE statements must occur at the
	outer block level before the occurrence of
	nested inner blocks.
NO DCL: vl, 		v2, ... vn
	The listed procedure parameters occurs in
	the procedure header, but are not declared
	within the procedure body.
NOT BIF
	The BUILTIN attribute is applied to an
	identifier that is not a PL/I built-in
	function.
NOT IMP
	The statement uses a feature that is not
	implemented in PL/I.
NOT VARIABLE
	The declared name is treated as a
	variable, but does not have the VARIABLE
	attribute.

E-5
PL/I Reference Manual	PL/I-80 R1.4 and PL/I-86 R1.0

Table E-2. (continued)

Error	Description
NUMBER
	A numeric constant is required at this
	position in the format.
ON BODY
	An invalid statement occurs in the ON
	condition body. You cannot use a RETURN
	statement to exit from an ON-unit. DO and
	IF statements require an enclosing
	BEGIN ... END block.
PICTURE
	There is a syntax error in a Picture
	specification or P format item.
RECUR PROC
	A recursive procedure contains an invalid
	nested block. Only embedded DO-groups are
	allowed in recursive procedures.
STRUCTURE
	The indicated structure is improperly
	formed. Nesting levels cannot exceed 255.
SYMBOL LENGTH 	OVERFLOW
The maximum symbol size is exceeded during
construction of the Symbol Table entry.
You must simplify the program and try
again.
SYMBOL TABLE 	OVERFLOW*
This program cannot be compiled in the
current memory size. You must break the
module into separate compilations, or
increase the size of the TPA on your
system.

E-6
PL/I Reference Manual	PL/I-80 R1.4 and PL/I-86 R1.0

Table E-2. (continued)

Error	Description
SYNTAX
	There is a syntax error in the specified
	statement. See the appropriate section of
	the PL/I Language Reference Manual for
	proper syntax.
	Pass 2 Errors
AGG VAL
	The actual parameter is an aggregate value
	that does not match the formal parameter.
	Change the actual or formal parameter to
	match.
ARG COUNT
	One of the following errors occurs: a
	subscript count does not match the
	declaration; there is a DEFINED reference
	to an array element; there are more than
	15 bound pairs; some bound pairs do not
	match; or the formal and actual parameter
	count does not match.
BASE
	There is an invalid based variable
	reference. This can occur when a pointer
	qualifier references a nonbased variable,
	or when a variable is declared BASED(x),
	where x is not a simple pointer variable
	or simple pointer function call, as in
	BASED(P) or BASED(Qo).
BASED REQ
	A based variable is required in this
	context.

E-7
PL/I Reference Manual	PL/I-80 R1.4 and PL/I-86 R1.0

Table E-2. (continued)

Error	Description
BAD TYPE
	The control variable in an iterative DO
	group is invalid. Only scalar variables
	are allowed.
BAD VALUE
	There is an invalid argument to a built-in
	function.
BALANCE
	The left and right parentheses for this
	expression are unbalanced.
BIT CON
	A bit substring constant is out of range.
	The third argument to bit SUBSTR must be a
	constant in the range 1 to 16.
BIT REQ
	A bit expression is required in this
	context.
CLOSURE
	The label following the END does not match
	the name on the corresponding block.
COMP REQ
	A noncomputational expression is used
	where a computational expression is
	required.
COMPILER
	A compiler error has occurred. The error
	might be due to previous errors.

E-8
PL/I Reference Manual	PL/I-80 R1.4 and PL/I-86 R1.0

Table E-2. (continued)

Error	Description
CONFLICT
	Data attributes are in conflict, or the
	attributes in an OPEN statement are not
	compatible.
CONVERT
	The compiler cannot convert the constant
	to the required type.
EXPRESSION 		OVERFLOW*
	The expression overflows the compiler's
	internal structures. You must simplify
	the program and try again.
ID REQ
	An identifier is required in this context.
INT REQ
	An integer (FIXED BINARY) expression is
	required in this context.
LABEL
	An improperly formed label is encountered
	where a label is expected.
NO BUILTIN
	The referenced built-in function is not
	implemented in PL/I.
NO DCL
	The indicated variable is not declared in
	the scope of this reference.

E-9
PL/I Reference Manual	PL/I-80 R1.4 and PL/I-86 R1.0

Table E-2. (continued)

Error	Description
NOT FILE
	The reference within a FILE Option is not
	a file variable or file constant.
NOT FORMAT
	The format field of a GET or PUT EDIT
	statement does not reference a format.
NOT IMP
	The construct in this statement is not
	implemented in PL/I.
NOT KEY
	The expression within a KEYTO, KEYFROM, or
	KEY option is not a FIXED BINARY variable.
NOT LABEL
	The target of this GOTO statement is not a
	label value.
NOT PROC
	The reference following the keyword CALL
	is not a procedure value.
NOT SCALAR
	A nonscalar value is encountered in a
	context requiring a scalar expression.
NOT STATIC
	An attempt is made to initialize automatic
	storage. You must declare the variable
	with the STATIC attribute and try again.

E-10
PL/I Reference Manual	PL/I-80 R1.4 and PL/I-86 R1.0

Table E-2. (continued)

Error	Description
PTR REQ
	A pointer variable is required in this
	context.
IFY
	This reference to a structure does not
	properly qualify the variable name. This
	is usually due to a nonunique substructure
	reference.
RET EXP
	The expression in a RETURN statement is
	not compatible with the RETURNS attribute
	of the corresponding procedure.
RETURN
	An attempt is made to return a value from
	a procedure without the RETURNS attribute.
SYNTAX
	There is a syntax error in this statement.
	See the appropriate section of the PL/I
	Language Reference Manual for the proper
	syntax.
SCALE GREATER 		THAN 0
The resulting FIXED BINARY expression
produces a nonzero scale factor. If the
expression involves division, you must
replace x/y by DIVIDE (x, y, 0) . This
replacement is necessary to maintain full
language compatibility.
SYMBOL TABLE 		OVERFLOW*
The free memory space is exhausted during
compilation. (See similar error in Pass
1.)

E-11
PL/I Reference Manual	PL/I-80 R1.4 and PL/I-86 R1.0

Table E-2. (continued)

Error	Description
STR REQ
	A string variable is required in this
	context. In the case of the SUBSTR built
	in function, you must assign the
	expression to a temporary variable before
	the substring operation takes place.
TYPES NOT=
	The types of a binary operation are not
	compatible. You can check all
	declarations and review the conversion
	rules (Section 4). This error might be
	due to aggregate data items that do not
	match in structure.
UNSPEC
	The source or target of an UNSPEC
	operation is not an 8- or 16-bit variable.
# VALUES
	The number of items specified in an
	INITIAL statement is not compatible with
	the variable being initialized.
VAR REQ
	A variable is required in this context.

E-12
PL/I Reference Manual	PL/I-80 R1.4 and PL/I-86 R1.0

Table E-2. (continued)

Error 	Description

Pass 3 Errors

***AUTOMATIC STORAGE OVERFLOW***

The total storage defined within this
program module exceeds 65535 bytes.

BAD INT FILE

The intermediate file sent to Pass 3 is
invalid. This is usually due to a
hardware malfunction.

BLOCK OVERFLOW

The nesting level has exceeded the
compiler's internal tables (maximum 32
levels).

EOF ON INT FILE

The compiler encounters a premature end
of-file while reading the intermediate
file. This error is usually due to a
hardware failure.

EXPRESSION OVERFLOW*

The compiler's internal structure sizes
are exceeded. You must simplify the
expression and try again.

LINE x OPERATION NOT IMPLEMENTED

An invalid intermediate operation occurs.
This error is usually due to a hardware
failure or errors in a previous pass.

E-13
PL/I Reference Manual	PL/I-80 R1.4 and PL/I-86 R1.0

Table E-3. Run-time Errors

Error 	Description

Non-recoverable Run-time Errors

FREE REQUEST OUT OF RANGE

A FREE statement specifies a storage
address outside the range of the free
storage area. This is usually caused by a
reference to an uninitialized base
pointer.

FREE SPACE OVERWRITE

The free storage area is overwritten.
This error is usually caused by an out-of
range subscript reference or a stack
overflow. If stack overflow occurs, use
the STACK(n) keyword in the OPTIONS field
to increase the stack size, and try again.

INSUFFICIENT MEMORY

The loaded program cannot run in the
memory size allocated. If possible,
increase the size of the Transient Program
Area.

INVALID 1/0 LIST

The list of active files is overwritten
while the program is running, and the
attempt to close all active files fails.
This is usually due to subscript values
out-of-range.

Recoverable Run-time Errors

PL/I prints the following errors when no ON-unit is
enabled, or if control returns from an ON-unit
corresponding to a nonrecoverable condition (marked by an
asterisk). In each case, the condition prefix is listed,
followed by an optional subcode that identifies the error
source, followed in some cases by an auxiliary message
that further identifies the source of the error.

E-14
PL/I Reference Manual	PL/I-80 R1.4 and PL/I-86 R1.0

Table E-3. (continued)

Error 	Description

ERROR(l) "Conversion"

This error occurs whenever the run-time
system cannot perform the required
conversion between data types. This error
can be signaled during arithmetic
operations, assignments, and 1/0
processing with GET and PUT statements.

ERROR(2) "1/0 Stack Overflow"

The run-time 1/0 stack exceeds 16,
simultaneous, nested 1/0 operations. You
must simplify the program and try again.

ERROR (3)		A transcendental function argument is out
	of-range.

ERROR(4) "1/0 Conflict x"

A file is explicitly or implicitly opened
with one set of attributes, and
subsequently accessed with a statement
requiring conflicting attributes. The
value of x is one of the following:

 STREAM/RECORD
 SEQUEN/DIRECT
 INPUT/OUTPUT
 KEYED Access

The first conflict arises when ASCII files
are processed using READ or WRITE, but the
INTO or FROM option does not specify a
varying character string.

E-15
PL/I Reference Manual	PL/I-80 R1.4 and PL/I-86 R1.0

Table E-3. (continued)

Error 	Description
ERROR(5) 	"Format Overflow"
The nesting level of embedded formats
exceeds 32. You must simplify the program
and try again.
ERROR(6) 	"Invalid Format Item"
The format processor encounters a format
item that cannot be processed. The P
format is not implemented in PL/I.
ERROR(7) 	"Free Space Exhausted"
No more free space is available. If you
intercept this error with an ON-unit, do
not execute an ALLOCATE, OPEN, or
recursion without first releasing storage.
ERROR(8) 	"OVERLAY, NO FILE d:filename"
The overlay manager cannot find the
indicated file.
ERROR(9) 	"OVERLAY, DRIVE d:filename"
An invalid drive code is passed as a
parameter to an overlay.
ERROR(10) 	"OVERLAY, SIZE d:filename"
The indicated overlay is too large and
overwrites the PL/I stack and/or free
space if loaded.
ERROR(11) 	"OVERLAY, NESTING d:filename"
Loading the indicated overlay exceeds the
maximum nesting depth.
ERROR(12) 	"OVERLAY, READ d:filename"
There has been a disk read error while
loading an overlay. This is probably
caused by a premature EOF.

--IN

E-16
PL/I Reference Manual	PL/I-80 R1.4 and PL/I-86 R1.0

Table E-3. (continued)

Error 	Description

ERROR(13) "Invalid OS Version"

Any operation that generates an operating
system call not supported under the
current operating system causes this
error.

ERROR(14) "Unsuccessful Write"

Any unsuccessful write operation on a file
due to lack of directory space, lack of
disk space, and so on, cause this error.

ERROR(15) "File Not Open"

Any attempt to lock or unlock a record in
a file that is not open causes this error.

ERROR(16) "File Not Keyed"

Any attempt to lock or unlock a record in
a file that does not have the KEYED
attribute causes this error.

FIXEDOVERFLOW

A decimal operation produces a value
exceeding 15 decimal digits of precision,
or an attempt is made to store to a
variable with insufficient precision.

OVERFLOW(l)

A floating-point operation produces a
value too large to be represented in
floating-point format.

OVERFLOW(2)

A double-precision, floating-point value
is assigned to a single-precision value
with insufficient precision.

E-17
PL/I Reference Manual	PL/I-80 R1.4 and PL/I-86 Rl.O

Table E-3. (continued)

Error	Description
UNDERFLOW (1)
	A floating-point operation produces a
	value too small to be represented in
	floating-point format.
UNDERFLOW (2)
	A double-precision, floating-point value
	is assigned to a single-precision value
	with insufficient precision.
ZERODIVIDE(l)
	A decimal divide or modulus operation is
	attempted with a divisor of zero.
ZERODIVIDE(2)
	A floating-point divide or modulus
	operation is attempted with a divisor of
	zero.
ZERODIVIDE(3)
	An integer divide or modulus operation is
	attempted with a divisor of zero.
ENDFILE
	An attempt is made to read past the end of
	the listed file, or the disk full
	condition occurs during output.
UNDEFINEDFILE
	If this error occurs on input, the run
	time system cannot find the named file on
	the disk, or an input device is opened for
	output. If the error occurs on output,
	the run-time system cannot create an
	output file, or an output device is opened
	for input.

-,-IN

E-18
PL/I Reference Manual	PL/I-80 R1.4 and PL/1-86 R1.0

Table E-3. (continued)

Error	Description
KEY(l)
	An invalid key is detected in an output
	operation.
KEY(2)
	An invalid key is encountered during an
	input operation.
ENDPAGE
	An end-of-page condition is detected.
	This condition does not cause termination
	if no ON-unit is active.

E.2 PL/1-86 Rl.l and PL/I-86 R1.0 under DOS

In PL/I-86 Rl.l and PL/I-86 R1.0 under DOS, the compilation error
messages in Pass 3, and the run-time error messages are identical to
those in PL/I-80 R1.4 and PL/I-86 R1.0. However, there are new
error messages in Pass 1 and Pass 2. The text in the new error
messages makes them self-explanatory.

The mechanism for finding and reporting errors is also the same.
That is, the compiler marks each compilation error with a ?
character near the position of the error in the line, and an error
message following the line containing the error. The ? might follow
the actual error position by a few columns. In some cases, an error
on one line can lead to errors on subsequent lines.

E.3 Condition Categories and Codes

The condition categories describe the various conditions that the
run-time system can signal or that your program can signal by
executing a SIGNAL statement.

There are nine major condition categories with subcodes, some of
which are system-defined, and some of which you can define yourself.
Table E-4 shows the predefined subcodes.

E-19
PL/I Reference Manual	E.3	Condition Catagories and Codes

Table E-4. PL/I Condition Categories and Subcodes

Type	Meaning
ERROR
ERROR(O)	Any ERROR subcode
ERROR(l)	Data conversion
ERROR(2)	1/0 Stack overflow
ERROR(3)	Function argument invalid
ERROR(4)	1/0 Conflict
ERROR(5)	Format stack overflow
ERROR(6)	Invalid format item
ERROR(7)	Free space exhausted
ERROR(8)	Overlay error, no file
ERROR(9)	Overlay error, invalid drive
ERROR(10)	Overlay error, size
ERROR(11)	Overlay error, nesting
ERROR(12)	Overlay error, disk read error
ERROR(13)	Invalid OS call
ERROR(14)	Unsuccessful Write
ERROR(15)	File Not Open
ERROR(16)	File Not Keyed
FIXEDOVERFLOW
FIXEDOVERFLOW(O)	Any FIXEDOVERFLOW subcode
OVERFLOW
OVERFLOW(O)	Any OVERFLOW subcode
OVERFLOW(l)	Floating-point operation
OVERFLOW(2)	Float precision conversion
UNDERFLOW
UNDERFLOW(O)	Any UNDERFLOW subcode
UNDERFLOW(l)	Floating-point operation
UNDERFLOW(2)	Float precision conversion
ZERODIVIDE
ZERODIVIDE(O)	Any ZERODIVIDE subcode
ZERODIVIDE(l)	Decimal divide
ZERODIVIDE(2)	Floating-point divide
ZERODIVIDE(3)	Integer divide
ENDFILE
UNDEFINEDFILE
KEY
ENDPAGE

__1*11

End of Appendix E

E-20
Appendix F
ASCII and Hexadecimal Conversions

ASCII stands for American Standard Code for Information Interchange.
The code contains 96 printing and 32 nonprinting characters used to
store data on a disk. Table F-1 defines ASCII symbols, and Table F
2 lists the ASCII and hexadecimal conversions. The table includes
binary, decimal, hexadecimal, and ASCII conversions.

Table F-1. ASCII Symbols

Symbol		Meaning	Symbol	Meaning
	ACK		acknowledge	FS	file separator
	BEL		bell	GS	group separator
	BS		backspace	HT	horizontal tabulation
	CAN		cancel	LF	line-feed
	CR		carriage return	NAK	negative acknowledge
	DC		device control	NUL	null
	DEL		delete	RS	record separator
	DLE		data link escape	SI	shift in
	EM		end of medium	so	shift out
	ENQ		enquiry	SOH	start of heading
	EOT		end of transmission	SP	space
	ESC		escape	STX	start of text
	ETB		end of transmission	SUB	substitute
	ETX		end of text	SYN	synchronous idle
	FF		form-feed	us	unit separator
			VT		vertical tabulation

F-1
PL/I Reference Manual	F	ASCII Conversions

Table F-2. ASCII Conversion Table

Binary	Decimal	Hexadecimal	ASCII
0000000		0	0	NUL
0000001		1	1	SOH (CTRL-A)
0000010		2	2	STX (CTRL-B)
0000011		3	3	ETX (CTRL-C)
0000100		4	4	EOT (CTRL-D)
0000101		5	5	ENQ (CTRL-E)
0000110		6	6	ACK (CTRL-F)
0000111		7	7	BEL (CTRL-G)
0001000	8	8	BS	(CTRL-H)
0001001	9	9	HT	(CTRL-I)
0001010	10	A	LF	(CTRL-J)
0001011	11	B	VT	(CTRL-K)
0001100	12	C	FF	(CTRL-L)
0001101	13	D	CR	(CTRL-M)
0001110	14	E	SO	(CTRL-N)
0001111	15	F	SI	(CTRL-0)
0010000	16	10	DLE (CTRL-P)
0010001	17	11	DC1 (CTRL-Q)
0010010	18	12	DC2	(CTRL-R)
0010011	19	13	DC3	(CTRL-S)
0010100	20	14	DC4	(CTRL-T)
0010101	21	15	NAK (CTRL-U)
0010110	22	16	SYN (CTRL-V)
0010111	23	17	ETB	(CTRL-W)
0011000	24	18	CAN	(CTRL-X)
0011001	25	19	EM		(CTRL-Y)
0011010	26	1A	SUB	(CTRL-Z)
0011011	27	IB	ESC (CTRL-[)
0011100	28	1C	FS		(CTRL-\)
0011101	29	1D	GS		(CTRL-])
0011110	30	1E	RS		(CTRL-^)
0011111	31	1F	US		(CTRL--)
0100000	32	20	(SPACE)
0100001	33	21
0100010	34	22
0100011	35	23		#
0100100	36	24		$
0100101	37	25		%
0100110	38	26		&
0100111	39	27
0101000	40	28
0101001	41	29
0101010	42	2A
0101011	43	2B
0101100	44	2C
0101101	45	2D
0101110	46	2E
0101111	47	2F
0110000	48	30		0
0110001	49	31		1
0110010	50	32		2

F-2
PL/I Reference Manual	F ASCII Conversions

Table F-2. (continued)
Binary		Decimal	Hexadecimal	T 	ASCII

0110011	51	33	3
0110100	52	34	4
0110101	53	35	5
0110110	54	36	6
0110111	55	37	7
0111000	56	38	8
0111001	57	39	9
0111010	58	3A
0111011	59	3B
0111100	60	3C	<
0111101	61	3D
0111110	62	3E	>
0111111	63	3F	?
1000000	64	40	@
1000001	65	41	A
1000010	66	42	B
1000011	67	43	C
1000100	68	44	D
1000101	69	45	E
1000110	70	46	F
1000111	71	47	G
1001000	72	48	H
1001001	73	49	1
1001010	74	4A	i
1001011	75	4B	K
1001100	76	4C	L
1001101	77	4D	M
1001110	78	4E	N
1001111	79	4F	0
1010000	80	50	p
1010001	81	51	Q
1010010	82	52	R
1010011	83	53	S
1010100	84	54	T
1010101	85	55	U
1010110	86	56	V
1010111	87	57	w
1011000	88	58	X
1011001	89	59	Y
1011010	90	5A	z
1011011	91	5B
1011100	92	5C
1011101	93	5D
1011110	94	5E
1011111	95	5F	<
1100000	96	60	1
1100001	97	61	a
1100010	98	62	b
1100011	99	63	c
1100100	100	64	d

F-3
PL/I Reference Manual	F	ASCII Conversions

Table F-2. (continued)

Binary	Decimal	Hexadecimal	ASCII
1100101	101	65		e
1100110	102	66		f
1100111	103	67		9
1101000	104	68		h
1101001	105	69		i
1101010	106	6A		i
1101011	107	6B		k
1101100	108	6C		1
1101101	109	6D		m
1101110	110	6E		n
1101111	ill	6F		0
1110000	112	70		p
1110001	113	71		q
1110010	114	72		r
1110011	115	73		s
1110100	116	74		t
1110101	117	75		u
1110110	118	76		v
1110111	119	77		w
1111000	120	78		x
1111001	121	79		y
1111010	122	7A		z
1111011	123	7B
1111100	124	7C
1111101	125	7D
1111110	126	7E
1111111	127	7F		DEL

End of Appendix F

F-4
Appendix G
PL/l Bibliography

This appendix lists several PL/I programming reference books. Some
are introductory textbooks for classroom use, while others are more
advanced applications guides. Each reference is followed by a short
description of the general content. You can obtain these books
through your local bookstore, or order them directly from the
publisher.

Although there are books now being prepared that specifically cover
PL/I Subset G, the books listed here cover subsets such as PL/C and
SP/k- or the full IBM implementations of PL/I. The statement forms
of PL/C and SP/k are usually included in the Subset G definition
while full PL/I contains a number of language facilities excluded
from the subset. Therefore, be aware that differences can arise
even though the sample programs and definitions are substantially
the same.

Your own reference library might consist of Lynch's book Computers,
Their Impact and Use which covers very general aspects of computing
with introductory language details provided by the Xenakis book.
Structured programming and program formulation is presented by one
of the Conway books, such as Primer on Structured Programming.
Additional application programming details are given in the Hughes
book. Details of more advanced data structures are given in the
Augenstein book.

Readers are encouraged to critique the individual books, and any
additional reference material they find useful. Digital Research
appreciates your comments and suggestions so that we can update this
list.

Augenstein, M. , and A. Tenenbaum. Data Structures and PL/I
Programming. Prentice-Hall, Inc., Englewood Cliffs, New
Jersey, 1979 (643p, Hardback, Typeset).

An advanced presentation of full PL/I. This is a college
textbook presenting the PL/I language through a series of
progressive examples covering recursion, list processing, trees
and graphs, sorting, searching, hash coding, and storage
management. An extensive bibliography is included. Emphasis
is upon implementing data structures using a subset of full
PL/I that nearly matches subset G. Structured programming is
not emphasized.

Bates, F., and M. Douglas. Programming Language/One. Prentice
Hall, Inc., Englewood Cliffs, New Jersey, 1970 (419p,
Paperback, Hand Typed).

G-1
PL/I Reference Manual	G 	Bibliography

A simple introduction to PL/I. This book presents fundamental
elements of full PL/I, with some emphasis on commercial
processing including structures, records, formatting, and error
processing. Explanations are emphasized rather than examples.
Structured programming is not emphasized.

Cassel, D. PL/I: A Structured Approach. Reston Publishing, Inc. ,
Reston, Virginia, 1978 (219p, Paperback, Typeset).

A middle level introduction to PL/I. A portion of full PL/I is
presented emphasizing batch processing and commercial
applications. Language elements are clearly presented, but
there is no particular emphasis on program formulation or
proper structuring, as the title implies.

Clark, F. J. Introduction to PL/I Programming. Allyn and Bacon,
Inc., BosEon 1971 (243p, Paperback, Typeset).

A basic, self-study introduction to PL/I through exercises.
This text presents a portion of full PL/I from a traditional
card-oriented approach, starting with a discussion of binary
numbers and continuing through the basic statement types to
simple STREAM and RECORD 1/0. Structured programming is not
emphasized, although commercial processing examples are given.

Conway, R. A Primer on Disciplined Programming. Winthrop
Publishers, Cambridge, Mass., 1978 (419p, Paperback, Computer
Typed).

A textbook used for PL/C, Cornell University's dialect of PL/I.
One of three college textbooks by Conway, et. al., covering
introductory programming, with emphasis on techniques used to
formulate, develop, and test programs. Includes short
discussions of searching and ordering lists, accounting, string
operations, and interactive systems. Emphasis is upon
structured programming practices and programming mechanisms
rather than extensive examples of working programs.

Conway, R., and D. Gries. Primer on Structured Programming.
Winthrop Publishers, Cambridge, Mass., 1976 (397p, Paperback,
Computer Typed).

A book on structured programming centered around PL/C.
Essentially the same content as the previous book by Conway,
with perhaps more emphasis on the operation of the PL/C
programming system at Cornell.

G-2
PL/I Reference Manual	G 		Bibliography

Conway, R., D. Gries, and D. Wortman. Introduction to Structured
Programming. Winthrop Publishers, Cambridge, Mass., 1977
(420p, Paperback, Computer Typed).

A book on structured programming using Cornell's PL/C and
Toronto's SP/k systems. Again, similar to Conway's first book
with the addition of sections on file processing, and language
translation using compilers and interpreters.

Groner, G. PL/I Programming in Technological Applications. John
Wiley & Sons, New York, 1971 (230p, Paperback, Typeset).

An introduction to engineering applications programming in
PL/I. This book discusses full PL/I, with examples derived
from batch processing under IBM implementations. Program
formulation through flowcharting is presented, with many
complete examples of scientific applications. Several examples
of plot and graph generation are presented. Emphasis is upon
explanations of FLOAT BINARY computations through complete
examples. Programs are not particularly well structured.

Hughes, J. K. PL/I Structured Programming. Second edition, John
Wiley & Sons, New York, 1979 (825p, Hardback, Typeset).

A comprehensive guide to general PL/I programming. This is one
of the more complete presentations of the full PL/I language.
Topics include structured programming, processing simple data
items, record and file handling, and list processing. Emphasis
is toward commercial programming using IBM's PL/I.

Hume, J. N. P., and R. C. Holt. Structured Programming Usinq PL/I
and SP/k. Reston Publishing, Inc., Reston, Virginia 1975
(340p, Paperback, Computer Typed).

An introduction to structured PL/I programming. This textbook
introduces PL/I through a graduated series of subsets called
SP/1 through SP/8. Each successive subset incorporates more of
the full PL/I language. The text begins with basic programming
concepts, and progresses through the various PL/I language
constructs. Sample programs include string and array handling,
list processing, and file handling. machine language, assembly
language, and compiling are also presented. Emphasis is upon
structured programming.

G-3
PL/I Reference Manual	G Bibliography

Kennedy, M., and M. B. Solomon. Structured PL/Zero Plus PL/One.
Prentice-Hall, Englewood Cfllffs, New Jersey, 1977 (695p,
Paperback, Computer Typed).

A fairly comprehensive introduction to PL/I. This book covers
the basic elements of PL/I in some detail, using PL/C for
examples. IBM's PL/I Level F language is discussed briefly.
Most language facilities are well illustrated in simple
examples.

Lynch, R. E. , and J. R. Rice. Computers, Their Impact and Use.
Holt, Rhinehart and Winston, New York, 1978 (440p, Paperback,
Typeset).

A basic introductory book to computers and PL/I. This is a
college textbook intended to introduce computers to
nontechnical people. Half the book gives an overview of
computers, their history, their impact upon society, and how
they are used. Operating systems, languages, and language
types are discussed. The remainder discusses IBM PL/I using a
variety of applications, ranging up to simple file processing.
Structured programming is not emphasized.

Ruston, H. Programming with PL/I. McGraw-Hill, New York, 1978
(541p, P aperback, Typeset).

A comprehensive textbook introduction to PL/I. This book
presents PL/I from a batch processing viewpoint, using the full
PL/I language for examples. Program construction through
flowcharting is emphasized. Elements of PL/I are presented,
including simple statements, control structures, arrays,
strings, procedures, and file handling. Examples have a
scientific orientation. Basics of error processing are
discussed. Structured programming is not emphasized.

Xenakis, J. J. Structured PL/I Programming. Duxbury Press, North
Scituate, Mass., 1979 (413p, Paperback, Typeset).

A comprehensive introduction to PL/I, close to Subset G. Basic
programming concepts are presented, with a brief history of
programming languages. Elements of full PL/I are shown,
including conversion between data types, arrays, strings, and
procedures. A section on go-to-less programming is included,
followed by a game-playing section that includes a tic-tac-toe
program. The book is simple in scope and easy to read.

End of Appendix G

G-4
Appendix H
Glossary

aggregate: Collection of related data items that you can reference
together or individually.

algorithm: Any procedure consisting of a finite number of
unambiguous, repeatable steps that characterize the solution of a
problem.

allocation: A) process of obtaining storage for a variable, or B)
specific unit of storage that you obtain for a based variable.
argument: Value that you pass to a subroutine or function.

argument list: Zero or more arguments that you specify when
invoking a procedure or a built-in function.

array: Named collection of data items with the same attributes, and
in which you access individual items (elements) by subscripts.

ASCII character set: Set of numeric values that represent
characters and control information, established by American Standard
Code for Information Interchange.

assignment statement: Executable statement that assigns a value to
a variable.

attribute: Any characteristic of a data item, such as fixed- or
floating-point, decimal or binary, extent, and so on.

automatic variable: Variable for which the compiler allocates
storage when the block that declares it is activated. The storage
is released when the block is deactivated.

based variable: Variable that describes storage that you access
using a pointer.

BBGIN block: One or more statements delimited by a BEGIN statement
and a corresponding END statement. A begin block is entered when
control reaches the BEGIN statement. When control flows into a
BEGIN block, PL/I creates a block activation for it and for the
variables declared within it.
bit string: Zero or more binary digits (0 or 1).

block: Any sequence of PL/I statements delimited by one of the
statement pairs PROCEDURE and END or BEGIN and END.

H-1
PL/I Reference Manual	H Glossary

bound-pair: Expression that sets the number of elements in each
dimension of an array.

built-in function: Any function provided as part of the PL/I
language.
character string: Zero or more ASCII characters.

comment: Any sequence of characters appearing between the composite
pairs /* and */. Comments provide documentary text and are ignored
by the compiler.
comparison operator: See relational operator.

compiler: Program that translates source statements of a high-level
programming language into an object module. The object module
consists of processor instructions and certain relocation
information that the linkage editor uses to form a command file.

computational: Data type on which you can perform operations. The
computational data types are arithmetic and string.

concatenation operator: Operator, 11, that joins two string values
to form a single string.

condition: Any occurrence that interrupts the normal program
execution and initiates a user-defined, or system default response.
condition name: PL/I keyword associated with a specific condition.
connected storage: Contiguous storage locations.

constant: A) any literal value that you specify to represent a
computational data item, or B) any entry or label name that you
declare implicitly in context, or C) any identifier that you declare
with one of the attributes ENTRY or FILE but without the VARIABLE
attribute.

control variable: Variable whose value changes on each iteration of
a DO-group and that can be tested to determine whether or not to
continue executing the statements in the DO-group.

conversion: Process of transforming a value from one data type to
another.

data type: Class to which a data item belongs, and which determines
the operations that you can perform on it.

declaration: Explicit or implicit specification of an identifier
and its data type.
dimension: Set of bounds that determine one extent of an array.

H-2
PL/I Reference Manual	H Glossary

DO-group: Any sequence of executable statements delimited by a DO
statement and a corresponding END statement.

element: Any individual data item in an array, which you can
reference with subscripts.

entry point: Statement or instruction where the execution of a
procedure begins.

expression: Any valid combination of operands and operators that
reduces to a single value.

extent: Range between the low-bound and the high-bound for one
dimension of an array.

external procedure: Procedure that is not contained in any other
procedure.

external variable: Variable that is known in any block where you
declare it with the EXTERNAL attribute.

file: A) in PL/I, the input source or output target that you
specify in an 1/0 statement, or B) the collection of data on a mass
storage device.

file constant: Any identifier that you declare with the FILE
attribute but not the VARIABLE attribute.

filetype:		Zero- to three-character component of a file
specification		that generally describes the file's use.
FIXED BINARY: Data type that represents integer values.

FIXED DECIMAL: Data type that represents decimal values with a
decimal point and a fixed number of fractional digits.

floating-point: Data type that represents very small or very large
numbers. A floating-point number has a mantissa and an optionally
signed integer exponent.

flow of control: Sequence in which the processor executes the
individual instructions in a program.

format item: Value indicating data representation and formatting
information used with EDIT-directed 1/0.

format list: List of format items corresponding to data items for
EDIT-directed 1/0.

function: Procedure that executes when you use its name in an
expression, and that returns a value to its point of reference.

function reference: Any reference to the name of a built-in
function or a user-written function in a PL/I statement.

H-3
PL/I Reference Manual	H Glossary

high bound: Upper limit of an array dimension.

1/0 category: General method you use to read or write data items in
a file. The 1/0 categories are STREAM 1/0 and RECORD 1/0.

identifier: Name consisting of 1 to 31 characters that you specify
for a variable, statement label, entry point, or file constant.

%INCLUDE file: External file from which the compiler reads source
text when compiling a PL/I program.
integer constant: Any optionally signed string of decimal digits

integer data: Data represented as FIXED BINARY or FIXED DECIMAL
with a zero scale factor.

internal procedure: Procedure that is contained within some other
procedure.

internal variable: Variable whose value you can reference within
the block that declares it and any blocks contained within the block
that declares it.

iteration factor: Integer constant enclosed in parentheses that
specifies the number of times to use a value when initializing array
elements, or the number of times to use a given format item in an
EDIT-directed 1/0 statement.

key: (A) any value that you use to specify a particular record in a
file, or (B) data item that is part of a record in an indexed
sequential file, or (C) relative record number of a record in a
RECORD file.

keyword: Any PL/I identifier that has a specific meaning when you
use it in the appropriate context.

label: Any PL/I identifier, terminated by a colon, which you use to
identify a statement.

level number: Integer constant that defines the hierarchical
relationship of a name within a structure with respect to other
names in the structure.

library: File containing object modules and a directory of the
external names within the object modules.

linker: Program that arranges relocatable object modules into a
command file, and resolves references among external variables
declared in the modules.

LIST-directed 1/0: Any transmission of data between a program and
an external device, for which PL/I provides automatic data
conversion and formatting.

H-4
PL/I Reference Manual	H Glossary

listing: Output file created by the compiler that lists the
statements in the source program, with corresponding line numbers
and additional information.

logical operator: Operator that performs a logical operation on
bit-string values.
low bound: Lower limit of an array dimension.

main procedure: Procedure that receives control when the program
begins executing. The main procedure is always an external
procedure.

major structure: Name of an entire structure by which you can
specify all members of the structure in a single reference. A major
structure always has a level number of 1.

member:		Data item in a structure. A member can be a scalar data
item, an		array, or a structure.
memory:		Any addressable location that stores code or data.
minor structure: Structure that is a member of a structure.

noncomputational: Data item that is not string or arithmetic. The
noncomputational data types are ENTRY, FILE, and LABEL.

nonlocal GOTO: GOTO statement that transfers program control to a
statement in an encompassing block.

object module: Output from the compiler or assembler that you can
link with other modules to form a command file.

ON condition:		Any one of several named conditions that can
interrupt a program and generate a signal.

ON-unit: PL/I statements specifying the action to take when a
program signals a specific ON condition.
one-bit: Binary digit 1.
operator: Symbol that directs PL/I to perform a specific function.

parameter: Variable that PL/I matches with an argument when the
program invokes a procedure.

parameter list: List of variable names whose values are determined
when a procedure is invoked. The PROCEDURE statement for the
procedure's entry point specifies the parameter list.

password: User-specified extension to a filename enabling file
security.

H-5
PL/I Reference Manual	H Glossary

picture: Character-string representation of an arithmetic value
consisting of a character string constant defining the position of a
decimal point, zero suppression, and sign conventions.

pointer:	Data item whose value is the address of a storage
location.

pointer-qualified reference: Specification of a based variable in
terms of a pointer value that indicates the location of the
variable.

pointer qualifier: Pointer reference and punctuation symbol that
associates a specific storage location with a based variable.

precedence: Priority of an operator that PL/I uses when evaluating
operations in an expression. PL/I performs an operation with a
higher precedence before an operation with a lower precedence.

precision: Number of digits associated with an arithmetic data
item.

prefix operator: Operator that precedes a variable or constant to
indicate or change its sign.

PRINT file: STREAM OUTPUT file for which PL/I aligns certain data
on predefined tab stops, and controls the output with a specified
page size and line size. In a PRINT file, PL/I does not enclose
strings in apostrophes.

procedure: Sequence of statements, delimited by a PROCEDURE
statement and an END statement. A procedure can be a subroutine
that you invoke with a CALL statement or a function that you invoke
with a function reference.

procedure block: Sequence of statements delimited by a PROCEDURE
statement and an END statement. Control flows into a procedure
block when you specify its name in a CALL statement or a function
reference, at which point PL/I creates a block activation for it and
for the internal variables declared within it.

pseudo-variable: Name of a built-in function that you can use on
the left-hand side of an assignment statement to give a special
meaning to the assignment.

qualified reference: Unambiguous reference to a member of a
structure that specifies each higher-level name within the structure
and separates the names with periods.

random access: A) 1/0 operation on a RECORD file where individual
records within the file are accessed using FIXED BINARY values
called keys.

record: Organized collection of data that PL/I transmits using
RECORD 1/0 statements.

H-6
PL/I Reference Manual	H Glossary

RECORD file: File containing binary data that PL/I transmits
without conversion.

RECORD 1/0: Transmission of data grouped in user-defined units
called records.
recursive procedure: Procedure that can invoke itself.

reference: Appearance of an identifier in any context other than
its declaration.

relational operator: Operator that defines a relationship between
two expressions and results in a Boolean value indicating whether
the relationship is true or false.

return value: Value returned by a function that replaces the
function at its point of reference.

row-major order: Order in which PL/I stores elements, or assigns
values to elements in an array. In row-major order, the rightmost
subscript varies the most rapidly.

Run-time Subroutine Library: Library of procedures that support the
execution of a PL/I program.
scalar: Data item that is not an aggregate.

scale factor: Number of fractional digits that you specify for a
FIXED DECIMAL data item.

scope: Set of blocks within a program in which the declaration of
an identifier is known.

sequential access: Access method that allows you to access records
in a RECORD file serially.

sequential file: RECORD file in which the records are arranged
serially. You can only add new records at the end of the file, and
read records one after the other.

signal: Mechanism by which PL/I indicates that a condition has
occurred.

statement: Valid sequence of PL/I keywords, identifiers, and
special symbols that specifies an executable instruction or data
declaration.

static variable: Variable for which the compiler allocates storage
for the entire execution of a program.

storage: Any region of memory that is associated with a particular
variable.

H-7
PL/I Reference Manual	H Glossary

storage class: Attribute of a variable that describes how its
storage is allocated and released by PL/I. The storage classes are
AUTOMATIC, BASED, PARAMETER, and STATIC.

STREAM	1/0: Transmission and interpretation of data in terms of
sequences of ASCII characters delimited by spaces, tabs, commas, or
fields	defined by format items.
string	data: Bit-string data or character-string data.

structure: Hierarchical arrangement of logically related data
items, called members, that are not required to have the same data
type.

structure reference: Variable reference to an entire structure (as
opposed to a member of a structure).

subroutine: Procedure that receives control when you invoke it with
a CALL statement.

subscript: Integer expression specifying an individual element of
an array.

variable: Data item whose value can change during the execution of
a program.

variable reference:	Any reference to a variable including
qualification by subscripts and member names.
zero-bit: Binary digit 0.

Note: material in this appendix has been adapted in part from
publication(s) of Digital Equipment CorporationO . The material so
published herein is the sole responsibility of Digital Research Inc.

End of Appendix H

H-8
Index

%INCLUDE statement, 2-22				characters, 2-15, 3-4, 10-2
%REPLACE statement, 2-22, A-2				collating sequence, 13-6,
opicspec', Picture			13-11, 13-26
	specification, 11-11				collating sequence in
*-extents in arrays, A-1				comparisons, 6-4
		ASIN built-in function, 13-6
A			assignment statement, 2-1, 6-1
		ATAN built-in function, 13-7
ABS built-in function, 13-4				ATAND built-in function, 13-7
ACOS built-in function, 13-5				attribute factoring, 3-13
ADDR built-in function,			in an ENTRY declaration,3-1
		7-9, 13-5	attribute-list,
aggregates, 3-1, 5-1		in an array declaration, 5-1
ALLOCATE statement, 7-5, 7-10				in a DECLARE statement,
ambiguous file reference, 10-4				3-12, 3-13
argument, 6-8, 7-9		in a structure
	passed by reference, A-3				declaration, 5-8
	passed by value, A-3		attributes of an array
argument-list,			variable, 5-1
	for a function, 2-9	AUTOMATIC attribute, 5-9,
	for a procedure, 2-9				7-1, A-3
	in a CALL statement, 2-10				AUTOMATIC storage class, 7-1
arguments, 2-10, 2-11	Af(w)] format, 11-7
	values passed to a
		procedure, 2-11	B
arithmetic constant, 11-3
arithmetic conversion, 4-2				base 10 logarithmic
arithmetic data, 3-1			function, 13-1
arithmetic error	base 2 logarithmic
		conditions, 9-6			function, 13-1
	FIXEDOVERFLOW, 9-1	base e logarithmic
	OVERFLOW, 9-1			function, 13-1
	UNDERFLOW, 9-1	BASED attribute, 5-9, 7-2
	ZERODIVIDE, 9-1	BASED storage class, 7-2
arithmetic expression, 4-2				based storage for a
arithmetic to bit-string				variable, 7-2
		conversion, 4-9	based variable, 3-11, 7-2,
arithmetic to character				7-10, 13-4, B-1
		conversion, 4-9	BEGIN block, 2-2, 7-1,
arrays,			8-7, 9-2
	elements, assignment and				statements, 2-2
		output ordering of, 5-6				bias of a binary exponent,
	in assignment			B-3, B-4, B-7
		statementSr 5-7	BIF, acronymn for built-in
	of structures, 5-11			function, 1-2
	referencer 5-3	BINARY built-in function,
	variable, 5-1, 6-1, 7-1				4-6, 13-8
ASCII,		Binary Coded Decimal (BCD),
	built-in function,				B-8, C-7
		13-6, A-2		binary exponent, B-2r B-4r
					B-6, C-2, C-7
			Index-1
BIT built-in function,	DIVIDE, 13-15
		4-9, 13-8	EXP, 13-15
bit SUBSTR, 6-7	FIXED, 13-16
bit-string constant,	FLOAT, 13-16
		3-6, 11-3	FLOOR, 13-17
	data, 3-5	for arithmetic conversion,
	to arithmetic		4-6, 4-11
		conversion, 4-10	HBOUND, 13-17
	to character-string	INDEX, 13-18
		conversion, 4-11	LBOUND, 13-18
	variables, 3-6	LENGTH, 13-19
blanks, 2-19	LINENO, 13-19
block,		LOCKr 13-20, A-4
activation, 2-3, 6-4, 7-10	LOG, 13-20
balance, 2-2	LOG10, 13-21
termination, 2-3	LOG2, 13-21
block structure in PL/I, 2-2	mathematical, 13-1
BOOL built-in function,	MAX, 13-22
		6-5, 13-9	MIN, 13-22
Boolean,	miscellaneous, 13-3
	algebra, 6-5	MOD, 13-23
	expression, 8-2, 8-6	NULL, 13-23
	function, 6-5	ONCODE, 13-24
bound-pair,	ONFILE, 13-24
	in an array declaration, 5-1	ONKEY, 13-25
	list in an ENTRY	PAGENOr 13-25
		declaration, 3-10	RANK, 13-6, 13-26r A-2
Buff(b)r option in	REVERSE, 13-26
		ENVIRONMENT attribute,10-5	ROUND, 13-27
built-in function, 1-2, 3-11,	SEARCH, 13-27
	4-2, A-2	SIGNr 13-28
	(BIF), 13-1	SIN, 13-28
	ABSr 13-4	SIND, 13-29
	ACOS, 13-5	SINH, 13-29
	ADDR, 13-5	SQRT, 13-30
	arithmetic, 13-1	string-handling, 13-2
ASCII, 13-6, A-2	SUBSTRrl3-30
ASIN, 13-6	TAN, 13-31
ATAN, 13-7	TAND, 13-31
ATAND, 13-7	TANH, 13-32
SINARYf 13-8	TIME, 13-32
BIT, 13-8	TRANSLATE, 13-33
BOOL, 13-9	trigonometric, 13-1
CEILr 13-10	TRIM, 13-33
CHARACTER, 13-10	TRUNC, 13-34
COLLATE, 13-11, 13-26r A-5	UNLOCK, 13-34, A-4
condition-handling, 13-3	UNSPEC, 13-35
conversion, 13-3		VERIFY, 13-35
COPY, 13-11	BUILTIN attribute, 13-1
COS, 13-12	B[n][(w)] format, 11-7
COSD, 13-12
COSH, 13-13	C
DATE, 13-13
DECIMAL, 13-14	CALL statement, 2-10, 2-12
DIMENSION, 13-14	carriage return, 2-19

Index-2
	line-feed pair, 2-19	conflicting file attributes,
CEIL built-in function, 13-10				10-2, 10-5
CHARACTER built-in function,				connected storage of
		4-9, 13-10			aggregates, 5-7, 5-12,
character SUBSTR, 6-6			12-1, 13-5, A-3
character to arithmetic		constant, 2-15, 2-18, 3-1
		conversion, 4-11		arithmetic, 2-18
character-string,		bit, 2-18
	constant, 3-5, 11-3		character string, 2-18
	data, 3-5	contained block, 3-8, 13-1
	to bit-string	containing block, 2-6, 8-8
		conversion, 4-12	context,
	variables, 3-5		for executable
Chebyshev polynomial			statements, 2-1
		approximation, 13-2			involving default data
circumflex character in a				conversion, 4-1
		string constant, 3-5			of a declaration, 2-18
CLOSE statement, 10-8		of arithmetic conversion, 4-2
COLLATE built-in function,				requiring FIXED BINARY
		13-11, 13-26, A-5			value, 3-2
collection of data elements,				contiguous storage in free
		data set, 10-1			storage area, 7-7
COLUMN(nc) format item, 11-9				control, 2-3
command line default		characters, 1-2
		name, 10-4			in a string constant, 3-5
comments, 2-15, 2-21		data items, 3-6
commercial applications, 3-3				format item, 11-6,
common data type, 4-3			11-9, 11-19
	in a comparison, 6-4	control-variable in a
common logarithmic			DO-group, 8-2
		function, 13-1	controlled,
compatibility of programs,				DO statement, 8-2
3-5, 4-4, 7-4, 7-10, 10-5,			DO-group, 8-1
11-4, 11-7, 11-15	conversion error, 4-11, 4-12
compiler, 2-9, 7-1, 7-3, 7-4,	conversion to intermediate
	7-6, A-3	character strings, 4-9
composite operator, 2-19		converting one data type to
concatenation of strings, 2-20				another, 4-2
concatenation operator,	COPY built-in function, 13-11
		2-20, 6-3	COS built-in function, 13-12
Condition Categories, 2-19			cos hyperbolic function, 13-2
condition,	COSD built-in function, 13-12
	handling statements, 2-1			COSH built-in function, 13-13
	processing, 9-1	credit characters, 11-16
	stack, A-4	credit CR, Picture
condition-name, 9-1, 9-4				specification character,
conditional branching, 8-1				11-12, 11-16
conditional digit Picture		current column position within
		specification character,				a file, 10-9, 11-1,
		11-12, 11-14, 11-15			11-9, 11-10
conflicting attributes in a			current line,
		DECLARE statement, 3-13				count within a file,
					10-9, 10-11
				number within a file, 10-12,
					11-1, 11-10, 13-4

Index-3
current page,	FIXED DECIMAL scale
	count within a file, 10-9			factor, 3-4
	number within a file, 10-12,		FLOAT BINARY precision,
		11-1, 13-4			3-3, 4-5
	size within a file, 11-10		for a filename in a command
current record position			line, 10-4
		within a file, 10-9		of run-time stack, 2-13
			DEFINED attribute, A-1
D				Delete password protection
				level, 10-4
data,		delimiter, 2-15, 2-18
	attributes, 1-1	digit, Picture specification
conversion, 3-2, 4-1, 4-2,	character, 11-12, 11-15
		8-6, 10-13f 13-2, 13-3,	DIMENSION built-in
		13-14, 1316, B-5			function, 13-14
	format item, 11-6	dimension of an array, 13-4
	set, 10-1, 10-5, 10-8,		of an array variable,
		11-7, 12-2			5-1, 5-7
	type matching when passing	DIRECT attribute, 10-2
		parameters, 2-12	DIRECT file, 10-3, 12-1, 12-2
DATE built-in function, 13-13	DIVIDE built-in function,
debit characters, 11-16			4-7, 13-15
debit DB, Picture	DIVIDE, built-in function, 4-5
		specification character,	DO statement, 8-1
		11-12, 11-16	DO-group, 2-15, 8-1, 8-7
DECIMAL built-in function,	documentary text, 2-21
		4-7, 13-14	DOS, operating system for IBM
decimal point position,			Personal Computer,
		Picture specification			A-1, A-5
		character, 11-12	double circumflex in a string
declaration of a based			constant, 3-5
		variable, 7-2	double-precision FLOAT BINARY,
declarative statements, 2-1		3-3, 11-8, 13-2, A-4,
DECLARE statement, 3-1,		B-6, C-7
	3-11, 8-7	drifting, Picture
for a BASED variable, 7-2	specification character,
	for a FILE variable, 10-1		11-12, 11-14, 11-15, 11-16
	for scalar variables, 3-12	dynamic extents in
declared name, 2-15, 2-17		arrays, A-1
default action,	dynamic storage area,
	for an ON condition, 9-4		7-5, 7-7
	for an ON-unit, 10-11
default data attributes, 3-13	E
default 1/0 units, 10-11
default ON-units, 9-7	E(w[, d]) format, 11-8
default rules for forming a	ELSE clause, option in an IF
	Picture		statement, 8-6
	specification, 11-16	encompassing block, 2-4,
default value,	8-8,	9-3
	BIT length, 3-13	END statement, 2-2, 2-13f
	CHARACTER length, 3-13	8-1, 	8-7
FIXED BINARY precision, 3-2	ENDFILE condition, 9-1, 10-10
FIXED DECIMAL	ENDPAGE condition, 9-1, 10-10,
	precision, 3-4	11-1, 11-4, 11-10
		default action, 10-11

Index-4
ENTRY attribute, 3-9	open mode, 10-4
entry constant, 3-9, 3-10		password, 10-10
ENTRY,	specification, 2-22, 10-4
	constant, 7-9		variable, 3-11, 10-1, 10-9,
	data, 3-9, 4-1, 6-3			10-10, 12-1
	declaration, 3-9	FILE,
	statement, 8-7		constant, 7-9
entry variable, 3-9, 3-10				data, 3-11, 4-1, 6-3
environment, 2-1		option in a GET or PUT
ENVIRONMENT attribute, 10-2,					statement, 11-3, 11-19
		10-4, 12-1, 12-2			option in GET or PUT
equal comparison operator,					statement, 11-3
		3-7, 3-8	File,
equal not equal comparison					Control Block (FCB),
		operators, 3-11				10-9, B-11
ERROR condition, 9-1, 9-4,					Descriptor, 10-9
		11-7, 11-8, 11-16			Parameter Block, 6-4
	subcodes, 9-4, 9-6, 13-24					Parameter Block (FPB),
error recovery, 2-1, 8-8, 9-1,			10-9, B-10
	9-5, 10-11, 13-3, A-4		filename, 10-4
ERROR(l) condition, 4-11, 4-12			filetype, 10-4
ERROR(3) condition, 13-5,		file id, file identifier,
	13-6, 13-20, 13-21,			10-1, 10-9, 11-2,
	13-30, 13-31		11-19, 12-1
ERROR(7) condition, 7-5		FIXED BINARY, 3-1, 3-2
ERROR(14) condition, 10-10			FIXED built-in function,
executable statements, 2-1			4-7, 13-16
EXP built-in function, 13-15			FIXED DECIMAL, 3-1, 3-3, 11-9
exponentiation, 4-5, 6-5			constant, 3-4
expression, 6-1		division, 4-5
	extents in arrays, A-1			Fixed(i), 10-5
infix, 6-2	option in ENVIRONMENT
involving	attribute, 10-5
	pseudo-variables, 6-6	fixed-length record size,
	precedence rules, 6-2				10-4, 10-5, 10-9,
	prefix, 6-2			12-1, 12-2
extent of an array	fixed-record size,
		dimension, 5-2			13-20, 13-34
EXTERNAL attribute, 2-7, 3-11,				FIXEDOVERFLOW condition, 3-4,
		5-9, 10-1			9-1, 9-6
external,	FLOAT BINARY, 3-1, 3-2
	block, 2-4, 2-6		constant, 3-3
	device, 10-1, 10-3	FLOAT built-in function,
EXTERNAL option in a PROCEDURE			4-8, 13-16
	statement, 2-14	FLOAT DECIMAL attribute, A-1
external,	FLOOR built-in function, 13-17
	procedures, 2-6, 3-9		flow of control,
	system entry points, 2-17			between logical units, 2-1
variable, 2-6, 2-8	within a program, 2-9, 3-7,
	8-1, 8-7, 8-8, 9-1, 9-2,
F		9-6, 10-11, C-8, C-9
	format item,
file,	COLUMN(nc), 11-9
	constant, 3-11, 10-1,	LINE(ln), 11-10
10-9, 10-10, 12-1	PAGE, 11-10

Index-5
	Picture, 11-11	IEEE floating-point format,
	SKIP[(nl)], 11-10		3-3, A-5, B-4,
	X(sp), 11-10		B-6, C-7
format list, 11-6, 11-9, 11-10	IF statement, 8-3, 8-6
FORMAT statement, 8-7, 11-11	implicit normalized bit, B-2,
format-label on a Remote			B-4, B-7
	format item, 11-10	implied file attributes, 10-5,
format-list in a GET EDIT or			11-5, 12-1, 12-2
	PUT EDIT statement, 11-19	INDEX built-in function, 13-18
fractional digits, 3-1	infix,
FREE statement, 7-5, 7-7		expression, 6-2
free storage area, 10-9		operator, 6-2, 6-3
free-format language, 2-15	INITIAL attribute, 5-5,
fully qualified reference to			5-6, 7-4
	a structure variable,	initializing elements in an
	5-10, 5-12		array, 5-5
function, 2-9	INPUT,
	procedure, 2-10, 3-9		attribute, 10-2, 10-10
			file, 10-2, 11-4, 12-1, 12-2
G			input-list in a STREAM file,
				11-2, 11-3, 11-6,
GET	EDIT statement, 11-7,	11-9, 11-19
	11-8, 11-9, 11-10, 11-19	insertion, Picture
GET		LIST statement, 11-3	specification character,
global data in PL/I		11-12, 11-15, 11-16
	programs, 2-14	integer, 3-2, 3-3
GOTO statement, 8-3, 8-4, 8-7		exponent, 3-2, 3-3, 4-10
		subscripts, 5-1
H		values, 3-1
	Intel object file format, A-4
HBOUND built-in	interfacing PL/I programs with
		function, 13-17			assembly language
hierarchical order in a			routines, C-1
		structure variable, 5-8	internal,
high-level organization of		block, 2-4, 2-6
		PL/I programs, 2-1		buffer for a file,
hyperbolic functions,			10-4, 10-8
	cos, 13-2		procedures, 3-9
	sin, 13-2	internal representation, 3-2,
					3-4, 5-6, 6-8, 7-10,
1					10-13, 13-35, B-1
				aggregate data, B-11
1/0 categories, 10-13	BIT data, B-9
1/0 condition BIFs, 10-11	CHARACTER data, B-9
1/0 condition, 9-7	double-precision FLOAT
	ENDFILEr 9-1, 9-7, 10-10		BINARY, B-6
	ENDPAGE, 9-1, 9-7, 10-10	ENTRY and LABEL data, B-10
	KEY, 9-1, 9-7, 10-10	FILE data, B-10
	UNDEFINEDFILE, 9-1,	FIXED BINARY data, B-1
		9-7, 10-10	FIXED DECIMAL data, B-8
1/0 statements, 2-1	FLOAT BINARY, B-4
identifier, 1-1, 2-15, 2-23	POINTER data, B-10
	formation of, 2-17	single-precision FLOAT
	maximum length, 2-17		BINARY data, B-2

Index-6
invoking a procedure, 2-3,			LIST option in a GET or PUT
	2-9, 2-10, 2-11		statement, 11-3
invoking a subroutine, 2-10		local variable, 2-6, 2-8,
iteration factor,		3-8, 10-1
	for the INITIAL	LOCK built-in function,
		attribute, 5-5		13-20, A-4
in an INITIAL attribute, 7-4		Locked file open mode, 10-4
iterative DO-group, 8-1,		LOG built-in function, 13-20
	8-8, 11-2	LOG10 built-in function, 13-21
		LOG2 built-in function, 13-21
K			logical,
			And operator, 6-5
KEY condition, 9-1, 10-10	data items, 3-5
key,	Not operator, 6-5
for a RECORD file, 10-2,		Or operator, 6-5
	10-3, 10-10	units, 2-1, 2-2
for			a	record	file,	1-12	low-level organization of
for			a	RECORD	file,	12-1,	PL/I programs, 2-15
	12-2, 13-25	lower-bound of an array
KEYED,					variable, 5-1
	attribute, 10-2
	file, 10-3, 10-10,	M
	12-1, 12-2
keywords, 2-15	MAIN option,
				in a PROCEDURE
L		statement, 2-13
	main,
label,	procedure, 2-5
	constant, 3-7, 3-8,	procedure statement, 2-13
		8-8, 11-10		program, 2-13
	variables, 3-7, 3-8		structure, 5-8
LABEL,	major structure, 5-8,
	data, 3-7, 4-1, 6-3			5-11, 7-1
	constant, 7-9	mantissa, 3-2, B-2, B-4,
LBOUND built-in			B-6, C-7
		function, 13-18	MAX built-in function, 13-22
LENGTH built-in	member of a structure, 3-13,
		function, 13-19			5-1, 5-8, 7-1
level number of a structure			memory management
		member, 5-8			statements, 2-1
level numbers in a structure				microprocessors 8-bit, 8080,
		declaration, 3-13			8085, Z80, A-1
limit of dimensions in an		Microsoft,
		array variable, 5-3		floating-point format,
LINE(ln) format item, 11-10				B-2, C-7
line-feed, 2-19		object file format, A-4
linemark, 10-2, 11-1, 11-3,			micrprocessors 16-bit, 8086,
		11-4, 11-10			8088, A-1
linemarks, 1-13	MIN built-in function, 13-22
LINENO built-in function,		minor structure, 5-8, 5-11
		1-11, 1-12, 13-19	mixed,
LINESIZE attribute, 10-2, 10-5			aggregate, 5-11
linkage editor, 3-9	aggregate referencing, 5-12
linked list, 7-8	data types in an
		expression, 3-3

Index-7
operand expressions, 4-3	ONCODE built-in function,
MOD built-in function, 13-23	9-7, 13-24
most significant digit in a	one-bit, 3-5, 4-11, 4-12, 6-4,
	mantissa, 4-10	8-2, 13-20, 13-34
multiple %REPLACE	ONFILE built-in function,
	statements, 2-23	1-11,	1-12, 13-24
multiple,	ONKEY built-in function, 1-11,
	allocations of based			1-12, 13-25
		storage, 7-5	Open List, PL/I internal data
	attributes in a			structure, 10-9
		declaration, 3-12	OPEN statement, 3-11, 10-1,
	data items, 3-1, 5-1			10-2, 12-1, 12-2
	declarations, 3-12	operands in an expression, 6-1
			operating system, 2-10, 10-3,
N						10-9, 13-13, 13-20, 13-32,
					13-34, A-1, A-5,
names of external devices,			B-11, C-12
		10-3, A-5	operator, symbol for a
natural,			mathematical of logical
	exponent function, 13-2			operation, 2-19
	logarithmic function, 13-1	operators, 2-15
nested,		in an expression, 6-1
	%INCLUDE statements, 2-22	OUTPUT attribute, 10-2
	BEGIN blocks, 2-2	OUTPUT file, 10-2, 12-2
	blocks, 2-4, 2-15, 2-23	output-list in a STREAM file,
	IF statements, 8-7		11-2r 11-4, 11-6,
Newton's method, 13-2, 13-30		11-9, 11-19
nonrecoverable conditions,	OVERFLOW condition, 9-1, 9-6
		9-1, 9-5	OVERFLOW(2), arithmetic
nonzero scale factor, 4-4		condition, 4-6, 4-11
noniterative DO-group, 8-1
nonlocal GOTO statement,	P
		8-8r 9-2
nonrecoverable error, A-4	padding of strings, 4-9, 4-10,
not equal comparison operator,		4-11, 4-12, 6-4, 6-5, 7-4,
		3-7, 3-8		11-7, 11-8, 12-lr 12-2
NULL,	PAGE format item, 11-10
	built-in function, 5-5,	PAGE option in a GET or PUT
		7-8, 13-23		statement, 11-3, 11-19
	pointer value, 7-4	pagemark, 10-2, 10-13, 11-1,
null,			11-4, 11-10
	character string, 3-5	PAGENO built-in function,
	statements, 2-1		1-11, 1-12, 13-25
string, 4-11, 4-12, 10-12	PAGESTZE attribute, 10-2,
		10-3, 1-11
0			PARAMETER,
			attribute, 5-9, 7-3
object file format,		keyword, A-2
	Intel, A-4	parameter passing,
	Microsoft, A-4		by reference, 2-11, C-1
ON statement, 9-1		by value, 2-11, C-1
ON unit, 9-2	PARAMETER storage class, 7-3
	active, 9-2	parameter-list,
	enabled, 9-2, 13-3		in an ENTRY declaration, 3-9

Index-8
in a PROCEDURE	PROCEDURE		blocks, 2-2, 7-1
		statement, 2-13	PROCEDURE		statement, 2-2,
parameters, 2-11, 2-13, 3-9	2-11,		2-13, 4-1, 8-7
	values expected by a	procedure,
		procedure, 2-11	blocks,		2-9, 2-10
partially,		entry point, 2-13, 6-4, 7-1
	qualified mixed aggregate				exit point, 2-13, 4-3
		reference, 5-12		invocation, 2-3, 2-9,
	subscripted mixed aggregate				2-10, 2-11
		reference, 5-12		name, 3-11
passing parameters using a				pseudo-variables, 3-11,
		Parameter Block, C-1				6-1, 6-6
password,	PUT EDIT statement, 11-7,
	for a file, 10-4			11-8, 11-9, 11-10, 11-19
	on a file, 10-10	PUT LIST statement, 11-3
	protection level, 10-4
PICTURE attribute, A-1
Picture,
	format item, 11-11	qualified,
	semantics, 11-14		name in a structure, 5-10
specification, 11-11, 11-12,		referenceto a structure
11-14, 11-15	variable, 5-1, 5-10
	default rules, 11-16
	syntax, 11-11	R
PL/I,
character set, 2-15	RANK built-in function, 13-6,
data attributes, 3-1,				13-26, A-2
	3-12, 5-9	READ,
keywords, 1-1, 2-2, 2-17,				statement, 11-1, 12-1
6-1, 10-2	Varying statement, 11-4, A-2
syntax, 1-1	with KEY statement, 12-1
PLILIB Run-time Subroutine				with KEYTO statement, 12-2
		Library (RSL), C-2, C-12				Read password protection
pointer, 7-2			level, 10-4
POINTER data, 3-11, 4-1, 6-3				readability of programs, 2-13,
pointer-qualified reference,				2-15, 8-8
	explicit, 7-2	Readonly, file open mode, 10-4
	implicit, 7-2	RECORD,
precedence rules for		attribute, 10-2
	expression evaluation, 6-2			file, 10-2, 10-10,
precision, 2-12, 3-2, 4-2,			12-1, 12-2
	4-4, 4-5, 4-6, 4-7, 4-8			1/0, 1-13, 12-1
	11-9, 11-16, 13-8, 13-14,			record size for a RECORD file,
	13-15, 13-16,		10-2, 13-20, 13-34
predefined file	recoverable conditions,
	constants, 1-12		9-1, 9-5
prefix,	RECURSIVE attribute, 2-15,
	expression, 6-2			7-1, A-3
	operator, 6-3	referencing an element of
preprocessor statements,			an array, 5-3
		2-1, 2-22	relational operator, 6-3
PRINT,	remote format items,
	attribute, 10-2		11-6, 11-10
	file, 10-2, 1-11,	REPEAT option in a
		11-4, 11-10		DO-group, 8-2

Index-9
repetition factor for a format	SIGN built-in function, 13-28
	item, 11-6	SIGNAL statement, 9-4
result type in data	simple DO statement, 8-1
	conversion, 4-1	SIN,
RETURN statement, 2-10, 2-13,	built-in function, 13-28
	4-1, 9-2	hyperbolic function, 13-2
returning values in registers,	SIND built-in function, 13-29
		C-6, C-8, C-9	single-precision FLOAT BINARY,
	on the stack, C-6,	3-3, 11-8, 13-2, B-2,
		C-7, C-8	B-4, C-7
RETURNS,	SINH built-in function, 13-29
attribute, 2-10, 2-15, 4-3	size of internal file buffer,
statement, implicit data		10-4, 10-5, 10-9
	conversion, 4-3	SKIP option in a GET or PUT
REVERSE built-in	statement, 11-3, 11-19
	function, 13-26	SKIP[(nl)l format item, 11-10
REVERT statement, 9-3, 9-4	source program, 2-15,
reverting ON-units, 8-8,		2-21, 2-22
	9-4, A-3	source text, 2-22
ROUND built-in functionr 13-27	source type in data
row-major order, 5-6		conversion, 4-1
run-time errors, interception	spaces, 2-19
	of and recovery from, 2-1	special characters, 1-2,
run-time stack, C-6		2-20, 11-1
default value, 2-13	SQRT built-in function, 13-30
Run-time Subroutine Library	square root function, 13-2
	(RSL), 13-1, B-1	STACK(b) option in a PROCEDURE
			statement, 2-13
S		statement label, 2-2, 3-7,
			3-11, 8-8
scalar data,	statements,
	items, 3-1, 5-1, 5-8	%INCLUDE, 2-22
	type, 12-1	%REPLACE, 2-22, A-2
scale factor, 2-12, 3-2, 3-4,	ALLOCATE, 7-5, 7-10
4-2, 4-4, 4-5, 4-7, 4-8,	assignment, 2-1, 6-1
		11-9, 11-16, 13-8, 13-14r	BEGIN, 2-2
		13-15, 13-16	CALL, 2-12
scientific,	CLOSEr 10-8
	applications, 3-2	condition handling, 2-1
	notation, 3-3, 4-10, 11-8	declarative, 2-1
scope of a variable, 2-6.	DECLARE, 3-1, 3-11, 8-7
	2-9, 3-7, 3-8, 5-10r 7-3,	DO, B-1
	7-4, 8-8, 11-10r 13-1	END, 2-2, 2-13, 8-1, 8-7
SEARCH built-in	ENTRY, 8-7
	function, 13-27	executable, 2-1
separate compilation of	FORMAT, 8-7
	external procedures, 2-5	FREE, 7-5, 7-7
separator, 2-18, 11-3	GET EDIT, 11-7, 11-8, 11-9,
sequence control statements,		11-10, 11-19
	2-1, 8-1	GET LIST, 11-3
SEQUENTIAL,	GOTO, 8-3, 8-4, 8-7
	attribute, 10-2	1/0, 2-1, 4-2
	file, 10-3, 12-1, 12-2	IF, 8-3, 8-6
Shared file open mode, 10-4,	memory management, 2-1
		13-20, 13-34	null, 2-1

Index-10
U			Z
unconditional branching, 8-1	zero supression, Picture
UNDEFINEDFILE condition,		specification character,
	9-1, 1-10		11-14, 11-15, 11-16
UNDERFLOW condition, 9-1,	zero-bit, 3-5, 4-9, 4-11,
	9-6, C-2		4-12, 6-4, 12-1, 12-2,
UNDERFLOW(2), arithmetic		13-9, 13-20, 13-34
		condition, 4-6, 4-11	ZERODIVIDE condition, 9-1, 9-6
UNLOCK built-in function,
		13-34, A-4
UNSPEC built-in function,
		6-6, 6-8, 13-35
UNSPEC, as a
		pseudo-variable, 6-6
up-level reference, 2-7
UPDATE attribute, 10-2
UPDATE file, 10-2, 10-10
upper-bound of an array
		variable, 5-1
user-defined subcodes for the
		ERROR condition, 9-4
V
variables, 1-1, 3-1
	local, 2-6
	external, 2-6
VARIABLE attribute, 3-10
variable subscripts in an
		array reference, 5-3
variable-length, record,
		11-4, 11-5
	size, 10-4, 10-5, 12-2, A-2
VARYING attribute, 3-5
VERIFY built-in
		function, 13-35
W

WHILE expression in a
DO-group, 8-2
WRITE,
statement, 11-1, 12-2
Varying statement, 11-5, A-2
with KEYFROM, 12-2
Write, password protection
level, 10-4
X
X(sp) format item, 11-10

Index-12
