This appendix contains notes and comments about migration issues. It lists and describes keywords and functions of the PL/I language that are available in other implementations of PL/I but are not included in Kednos PL/I. It also outlines the differences between Kednos PL/I for OpenVMS VAX and Kednos PL/I for OpenVMS Alpha.

The information in this appendix is not intended to represent either a complete or a formal description of migration issues. The information is presented informally and has not been subjected to extensive testing and verification.

D.1 Keywords Not Supported

Table D-1 lists keywords used in other implementations of PL/I but not in Kednos PL/I. The table does not include ENVIRONMENT keywords or implementation-specific language extensions.

Table D-1 PL/I Keywords Not Supported

Keyword	Abbreviation	Use
AFTER		Built-in function
ALL		Built-in function
ANY		Built-in function
ATTENTION	ATTN	Condition
BACKWARDS		Attribute, Option of OPEN statement
BEFORE		Built-in function
BUFFERED	BUF	Attribute, Option of OPEN statement
BY NAME		Option of assignment statement
C		Format item
CALL		Option of INITIAL attribute
CASE		Option of DO statement
CHECK		Statement, Condition, Condition prefix
COMPLETION	CPLN	Built-in function, Pseudovariable
COMPLEX	CPLX	Attribute, Built-in function, Pseudovariable
CONJG		Built-in function
CONNECTED	CONN	Attribute
CONSTANT		Attribute
CONVERSION	CONV	Condition prefix
COPY		Option of GET statement
COUNT		Built-in function
CURRENTSTORAGE	CSTG	Built-in function
DATA		Stream I/O transmission mode
DATAFIELD		Built-in function
DECAT		Built-in function
DEFAULT	DFT	Statement
DELAY		Statement
DESCRIPTORS		Option of DEFAULT statement
DISPLAY		Statement
DOT		Built-in function
ERF		Built-in function
ERFC		Built-in function
EVENT		Attribute, Option of several statements
EXCLUSIVE	EXCL	Attribute
EXIT		Statement
FETCH		Statement
FORMAT		Attribute
GENERIC		Attribute
HALT		Statement
IGNORE		Option of READ statement
IMAG		Built-in function, pseudovariable
IRREDUCIBLE	IRRED	Attribute
LIST		Option of OPEN statement
LOCAL		Attribute
LOCATE		Statement
NAME		Condition
NOCHECK		Statement, Condition prefix
NOCONVERSION	NOCONV	Condition prefix
NOFIXEDOVERFLOW	NOFOFL	Condition prefix
NOLOCK		Option of READ statement
NONE		Option of DEFAULT statement
NOOVERFLOW		Condition prefix
NOSIZE		Condition prefix
NOSTRINGRANGE	NOSTRG	Condition prefix
NOSTRINGSIZE	NOSTRZ	Condition prefix
NOSUBSCRIPTRANGE	NOSUBRG	Condition prefix
NOZERODIVIDE	NOZDIV	Condition prefix
ONCOUNT		Built-in function
ONFIELD		Built-in function
ONLOC		Built-in function
ORDER		Option of BEGIN and PROCEDURE statements
OVERFLOW	OFL	Condition prefix
PENDING		Condition
POLY		Built-in function
PRIORITY		Option of CALL statement, Built-in function, Pseudovariable
RANGE		Option of DEFAULT statement
REAL		Attribute, Built-in function, Pseudovariable
RECORD		Condition
REDUCIBLE	RED	Attribute
REENTRANT		Option of OPTIONS option
RELEASE		Statement
REORDER		Option of BEGIN and PROCEDURE statements
REPEAT		Built-in function
REPLY		Option of DISPLAY statement
SAMEKEY		Built-in function
SIZE		Condition, Condition prefix
SNAP		Option of PUT statement
STATUS		Built-in function, Pseudovariable
STORAGE	STG	Built-in function
STRINGRANGE	STRG	Condition prefix
STRINGSIZE	STRZ	Condition, Condition prefix
SUB		Dummy variable of DEFINED attribute
SUBSCRIPTRANGE	SUBRG	Condition prefix
SYSTEM		Option of DECLARE statement
TAB		Option of OPEN statement
TASK		Attribute, Option of OPTIONS option, Option of CALL statement
TRANSIENT		Attribute, option of OPEN statement
TRANSMIT		Condition
UNBUFFERED	UNBUF	Attribute, Option of OPEN statement
UNLOCK		Statement
WAIT		Statement

D.2 Differences Between Kednos PL/I for OpenVMS VAX and Kednos PL/I for OpenVMS Alpha

This section lists the differences between Kednos PL/I for OpenVMS VAX, Kednos PL/I for OpenVMS Alpha, and other PL/I compilers that require you to modify your source files to avoid compilation errors. In some cases, differences require reprogramming.

• The at sign (@) and number sign (#) characters are not allowed in identifiers; thus, you must change all identifiers that contain either of these characters.
• You must explicitly declare all names (except internal procedure and label constants) There is no I through N rule that provides an implicit declaration of FIXED BINARY to undeclared names. In fact, the compiler defaults all undeclared names to FIXED BINARY and issues a warning message to that effect.
• If the attribute FLOAT is specified and neither of the attributes BINARY or DECIMAL is specified with it, the compiler provides a default of BINARY. This should not present a problem; however, if a precision was specified under the assumption that the default floating-point base was DECIMAL, overflow conditions can result if you do not correct the declaration.
• You cannot explicitly declare internal entry constants and subscripted label constants; these names are implicitly declared by their appearance. You must remove the declarations from the source file.
• You must reprogram ON-units for unsupported conditions. For example, ON-units for SIZE, RECORD, and TRANSMIT should be modified so that they are invoked for the ERROR condition, which is the condition that is signaled for any of these errors.
• You cannot specify the ALIGNED and UNALIGNED attributes for a structure in which string variables are to be aligned or unaligned. The attribute must be specified in the declaration of each variable that is to be aligned.
• You cannot pass parameters directly to main procedures from the command stream. For examples of techniques for passing values or data to a main procedure, see the Kednos PL/I for OpenVMS Systems User Manual.
• Changes in virtual memory requirements
  The virtual memory requirements for Kednos PL/I may be extensive according to the types of PL/I language constructs that you use. Processing the PUT and GET statements, BEGIN blocks and PROCEDURE blocks with the Kednos PL/I for OpenVMS Alpha compiler tends to require more virtual memory than the same operation would if you were using the Kednos PL/I for OpenVMS VAX compiler.
  Heavy usage of these constructs in your programs may exhaust your user limits for virtual memory. The typical compiler errors that you receive are:

  %PLIG-F-TEXT, Compiler abort - virtual memory limits exceeded. %SYSTEM-F-ABORT, abort %LIB-F-INSVIRMEM, insufficient virtual memory

  
  You can recover by increasing your user page-file quota (PGFLQUOTA). See the Kednos PL/I for OpenVMS Alpha Installation Guide or the appropriate OpenVMS Alpha system manual for more information on increasing your user page-file quota.

• Changes in behavior for calls to bound procedures
  With Kednos PL/I, nested procedures can be called by other routines using the PL/I language's entry variable. However, in order to successfully reach these bound-procedure routines and ensure proper execution of uplevel referenced variables within the bound procedures, the user must keep the parent invocation of the bound procedure active.
  This ensures that the stack references to uplevel variables are still valid.
  The same situation exists with Kednos PL/I for OpenVMS Alpha. However, you may experience differences in behavior between Kednos PL/I for OpenVMS VAX and Kednos PL/I for OpenVMS Alpha if you do not keep the parent invocation active. This is because bound procedures are not created in the same way on the two compilers.
  Kednos PL/I for OpenVMS Alpha creates the bound procedure values on the stack of the parent of the bound procedure. The compiler sends an access violation message or may exhibit other undefined behavior when the parent invocation of the bound procedure is not kept active. Because the parent's stack has been destroyed, the bound procedure code found on the parent's stack may also have been destroyed or corrupted, and the user may not be able to reach the bound procedure.
  With Kednos PL/I for OpenVMS VAX you may receive the same undefined behavior. Cases may exist in which you are able to reach the bound procedure; however, you may still receive errors in results from the uplevel referenced variables within the bound procedure. This is because the bound procedure code on the parents stack may have been corrupted.
  The following example shows behavior where the bound procedure entry6a cannot be reached by Kednos PL/I for OpenVMS Alpha, because the parent procedure, entry6, has exited and its stack is free to be recovered and used by other procedures. Therefore, the bound procedure code has been destroyed.

  program: proc options(main); program: proc options(main); dcl (ent2) entry variable; dcl fnc entry returns(entry) variable; dcl evar char (25) var init(' '); fnc=entry6; ent2=fnc(); call destroy_stack(); call ent2; put skip list('Evar is =>',evar); entry6: proc returns (entry); return(entry6a); entry6a: proc; evar=evar||'entry6a*'; return; end entry6a; end entry6; destroy_stack: proc; /* Declare enough space to destroy previous * stack values before this call. */ dcl temp_space char(1000); temp_space = 'hello'; end; end program;

  
  Note that this program also fails with Kednos PL/I for OpenVMS VAX. However, it fails after having reached the bound procedure entry6a and while trying to access the uplevel referenced variables from the parent, entry6.

• Changes in behavior for overlapping static storage initialization
  In both Kednos PL/I for OpenVMS VAX and Kednos PL/I for OpenVMS Alpha, overlapping initialization of static storage is not supported. When Kednos PL/I for OpenVMS VAX finds an overlapping static initialization, the compiler uses the value of the last found initialization as the value for the static variable.
  In Kednos PL/I for OpenVMS Alpha, however, you cannot depend on the value of the last found initialization being assigned to the static variable. This behavior may affect the following user constructs:
  • Changes in behavior for PL/I external variable initialization
    If a PL/I external variable is declared with the attributes EXTERNAL STATIC INITIAL, all blocks that declare the variable MUST be initialized with the same value.
    Because Kednos PL/I for OpenVMS VAX allowed overlapping static storage initialization, you could specify different initial values for the SAME external variable within containing blocks. The last initial value encountered by the Kednos PL/I for OpenVMS VAX compiler was the value of the external variable.
    In Kednos PL/I for OpenVMS Alpha this rule is more strictly enforced: if the user specifies an initial value in the declaration of a PL/I external variable, the same initial value declaration must be specified at each occurrence of the declaration of the external variable in all blocks that declare the external variable. Failure to do so can cause unpredictable results. The following examples show correct and incorrect declarations:

    Correct Declaration of an External Variable Initialization
    

    /* A CORRECT declaration of an external * variable initialization. */ program: proc options(main); dcl test fixed external initial(5); p:proc; dcl test external initial(5); /* The value of this variable should be 5. */ put skip list ('The value of test is =>',test); end; end;

    Incorrect Declaration of an External Variable Initialization
    

    /* INCORRECT declarations of external * variable initialization. */ program: proc options(main); /* The initialization MUST be the same * for all declarations of the external * variable. */ dcl test fixed external initial(5); dcl test1 fixed external initial(5); dcl test2 fixed external; p:proc; /* The initialization MUST be the same * for all declarations of the external * variable. */ dcl test external initial(6); dcl test1 external; dcl test2 external initial(6); /* The value of these variables is unpredictable. */ put skip list ('The value of test is =>',test); put skip list ('The value of test1 is =>',test1); put skip list ('The value of test2 is =>',test2); end; end;

    Note As no guarantee exists as to which occurrence of the external variable the Kednos PL/I for OpenVMS Alpha compiler processes first, each occurrence of the variable must contain the same initial value.

  • Changes in behavior for the SUBSTR built-in function
    In Kednos PL/I for OpenVMS VAX, the SUBSTR function is defined only when the position attribute (the integer expression that indicates the position of the first bit or character in the substring) is greater than or equal to 1.
    Similarly, in Kednos PL/I for OpenVMS Alpha, the SUBSTR function is defined only when the position of the first bit or character is greater than or equal to 1. Therefore, if the position of the first bit or character to the SUBSTR built-in function is less than 1 (that is, the SUBSTR BIF is undefined), you may observe different results with Kednos PL/I for OpenVMS Alpha than with Kednos PL/I for OpenVMS VAX.
  • Changes in underflow detection behavior for Kednos PL/I for OpenVMS Alpha
    The Kednos PL/I for OpenVMS VAX compiler outputs underflow detection code, the Kednos PL/I for OpenVMS Alpha compiler does not.
  • Changes for null statements and label behavior in Kednos PL/I for OpenVMS Alpha
    Kednos PL/I for OpenVMS VAX does not compare the multiple labels of many succeeding combinations of labels and null statements so that they will have the same address. However, Kednos PL/I for OpenVMS Alpha optimizes these label-null statement sequences and compares the multiple labels so that they result in the same address. The following example shows this difference:

    X67: PROC options(main); A: ; /* Null statement. */ B: ; /* Null statement. */ C: ; /* Null statement. */ IF A=C THEN PUT LIST('NULL STATEMENT LABELS COMPARE EQUAL FOR Kednos PL/I for OpenVMS Alpha'); ELSE PUT LIST('NULL STATEMENT LABELS COMPARE NOT EQUAL FOR Kednos PL/I for OpenVMS VAX'); D: IF C=D THEN PUT LIST('ERROR THESE LABELS SHOULD NEVER COMPARE EQUAL'); END;

  • In Kednos PL/I for OpenVMS Alpha you can continue when a GOTO statement with the OTHERWISE option is used to go to an undefined label array element within a BEGIN-END block. Kednos PL/I for OpenVMS VAX does not support this function. The following example works with Kednos PL/I for OpenVMS Alpha but not Kednos PL/I for OpenVMS VAX:

    program: procedure options(main); dcl i fixed binary(31,0); begin; i = 2; goto part(i) otherwise; put skip list('At continue !!'); end; part(1): end program;

  • Run-time exception handling is more consistent when processing formats of GET EDITs and PUT EDITs in Kednos PL/I for OpenVMS Alpha than it is in Kednos PL/I for OpenVMS VAX. If Kednos PL/I for OpenVMS Alpha encounters an exception when processing a format such as PLI$_INVFMTPARM, a signal is raised. If the exception is handled, then processing continues with the next format item regardless of the nature of the signal and the format item that was being processed when the exception was detected. This is not always the case with Kednos PL/I for OpenVMS VAX.
  • Nonlocal returns work properly under Kednos PL/I for OpenVMS Alpha. A nonlocal return is a RETURN statement that is lexically nested between any number of BEGIN/END pairs; for example:

    nested_proc : proc returns (fixed); begin; begin; begin; begin; begin; return (5); end; put skip list ('shouldnt be here 1'); end; put skip list ('shouldnt be here 2'); end; put skip list ('shouldnt be here 3'); end; put skip list ('shouldnt be here 4'); end; put skip list ('shouldnt be here 5'); end; nested_proc2 : proc returns (float); begin; begin; begin; begin; begin; return (5.1); end; put skip list ('shouldnt be here 1'); end; put skip list ('shouldnt be here 2'); end; put skip list ('shouldnt be here 3'); end; put skip list ('shouldnt be here 4'); end; put skip list ('shouldnt be here 5'); end; program: proc options(main); dcl result1 fixed; dcl result2 float; result1 = nested_proc(); result2 = nested_proc2(); put skip list (result1); put skip list (result2); end;

    
    Two special considerations should be observed for nonlocal returns from OPTIONS(MAIN) procedures. First, an ON unit declared in the scope of one of the BEGIN/END pairs for FINISH will be given a chance to execute. Second, an ON unit declared in the scope of one of the BEGIN/END pairs for VAXCONDITION(ss$_unwind) will NOT be given a chance to execute with the previous construct.

  • When a program terminates abnormally due to an unhandled exception, Kednos PL/I for OpenVMS Alpha closes all open files before turning control over to the OpenVMS last-chance condition handler (the utility that prints the error and traceback).
    This means that I/O that was being held in a buffer is allowed to reach its destination before the error dump appears on the screen. This is not the case with Kednos PL/I for OpenVMS VAX, in which I/O held in a buffer is not allowed to reach its destination before the error dump appears on the screen.
  • Differences in exception handling between OpenVMS Alpha and OpenVMS VAX
    Because machine instructions on OpenVMS Alpha systems differ from those on OpenVMS VAX systems, any exception handler written to handle VAX hardware exceptions should be examined to ensure that it handles Alpha hardware exceptions similarly. For example, consider a case in which an exception handler has been written to handle an access violation. You may expect different behavior upon normal completion of the handler. In this case the handler should always perform a nonlocal GOTO to exit the handler so that program execution continues in a predictable way.

    ---

    Previous

    Next

    Contents

    Index