VSI Pascal V6.4-147 for OpenVMS x86-64

In an unpacked array, the specified bit position must not conflict with the default preferred alignment of the field's type.

Use a non-local GOTO to transfer control to a label in an enclosing block.

Return SS$_CONTINUE if the handler wants the error dismissed and to continue processing.

Return SS$_RESIGNAL if the handler wants the system to continue searching for additional handlers to call.

Call the $UNWIND system service to establish a new point to resume execution when the handler returns to the system.

The QUADRUPLE is not supported and will result in internal compiler errors. Unlike C and Fortran, there is no command line qualifier to downgrade QUADRUPLE to DOUBLE. We expect to add QUADRUPLE support in an upcoming release, as well as a command line option to downgrade QUADRUPLEs to DOUBLEs.

The /MACHINE_CODE qualifier is ignored. We are still working on getting the generated code listing out of LLVM. In the meantime, you can do ANALYZE/OBJECT/DISASSEMBLE and append the output to the compiler listing file.

Non-local GOTOs do not currently work in some rare circumstances. These issues are resolved by V9.2-2 Update 2.

Most forms of run-time checking enabled with /CHECK do not detect the errors.

The debugger support is still being implemented. There may be missing variables, incomplete types, or incorrect output. The debugger in V9.2-2 Update 1 is highly recommended. Bugs and comments can be submitted through the support portal or on the OpenVMS Forums at https://vmssoftware.com/.

PROCEDURE parameters can generate ACCVIOs in the compiler-generated code that creates the bound-procedure values (BPVs) that are used to implement the functionality. The fix (located in the LIBRTL.EXE image) is included in the V9.2-2 release.

UNSIGNED8 and UNSIGNED16 Predeclared Subranges

The UNSIGNED8 and UNSIGNED16 predeclared subrange types are documented as being subranges of UNSIGNED. However, they are actually subranges of INTEGER with positive values that correspond to an UNSIGNED subrange of the same size. This subtle distinction in the definition is almost impossible to detect from a program and should not be a problem in the general case.

One visible difference is that expressions involving UNSIGNED8 and UNSIGNED16 values are performed with overflow detection enabled (just like any INTEGER expression). So, if you multiply the largest UNSIGNED16 value with itself, the operation will produce an overflow where you would not expect an overflow. For example:

    VAR A,B : UNSIGNED16 VALUE 65535;
    A := A * B;

This will produce an integer overflow where you would expect the rules for unsigned arithmetic to produce the value 1.

Using Discriminated Schema as Formal Discriminant Types

Extended Pascal allows a discriminated ordinal schema type to be subsequently used as the type of a formal schema discriminant. For example:

    TYPE SUBR(L,U:INTEGER) = L..U;
      DSUBR = SUBR(expression,expression);
      SCH1(D:DSUBR) = ARRAY [1..D] OF INTEGER;
      SCH2(D:DSUBR) = RECORD
                        CASE D OF
                        1: (F1:INTEGER);
                        2: (F2:CHAR);
                       END;

VSI Pascal does not currently support this construct.

Files with Schema Components

Extended Pascal allows file components to contain schematic items and therefore provide run-time sized file components. For example:

    TYPE SUBR(L,U:INTEGER) = L..U;
          FILE_COMP = ARRAY [SUBR(expr,expr)] OF INTEGER;

    VAR  F : FILE OF FILE_COMP;

VSI Pascal does not currently support this feature and requires that the component sizes of files be known at compile-time.

Using Formal Discriminants Inside Initial State Specifiers

Extended Pascal allows the formal discriminant to appear in an initial state specifier in the schema definition. For example:

    TYPE R(D:INTEGER) = RECORD
                        F1 : INTEGER VALUE D;
                        END;
         A(D:INTEGER) = ARRAY [1..D] OF INTEGER VALUE [OTHERWISE D];

VSI Pascal does not currently support this feature and requires that all initial state values be compile-time expressions.

Changing Variants When Selector Is A Discriminant

If a formal discriminant is used as a variant tag, it is illegal to change the variant once the variable has been created. For example:

    TYPE R(D:INTEGER) = RECORD
                        CASE D OF
                        1: (ONE : INTEGER);
                        2: (TWO : INTEGER);
                        OTHERWISE (OTHERS : BOOLEAN);
                         END;

    VAR V : R(1);

    BEGIN
    V.TWO := 2; { Is illegal since it changes variants from 1 to 2 }
    END;

VSI Pascal does not currently generate run-time checking code to detect this violation.

The AND_THEN and OR_ELSE Boolean operators do not short-circuit when used in constant expressions. All constant expressions currently do full evaluation in a left-to-right order. For example:

    CONST X = FALSE AND_THEN (1 DIV 0 = 0);

This example will currently generate a compilation error instead of correctly defining the constant X to be the value FALSE.

The VSI Pascal compiler currently allows you to use the SIZE function on TIMESTAMP variables. As in the case for file variables, these types are abstract objects and the compiler should not permit assumptions about their size to be used.

When the buffer variable of a file is passed as a VAR parameter, the allocation size of the formal VAR parameter must match that of the components of the file. Failure to do so will result in an Internal Compiler Error. For example:

    PROGRAM A;
    VAR
       F : PACKED FILE OF 0..65535;
       G : FILE OF [WORD] 0..65535;

    PROCEDURE P( VAR I : INTEGER ); EXTERNAL;

    BEGIN
    P(F^); { causes an Internal Compiler Error }
    P(G^); { causes an Internal Compiler Error }
    END.

The LSE templates for the Pascal language are shipped as part of DECset. These templates have not yet been updated to reflect all the new language features added to VSI Pascal.

The HELP file has undergone extensive revision which included renaming some topic strings. This will cause problems with using the language-sensitive help feature from LSE.

Due to an interaction with the OpenVMS Linker and OpenVMS Image Activator, unknown results will occur if a compilation unit places a file variable in a [COMMON] block and then a shareable image is made from the object file. To share data in a shareable image, use environment files or use the [GLOBAL]/[EXTERNAL] attributes.

When using the SYS$SYSTEM:PASCAL$SET_VERSION.COM command file to select older versions of the VSI Pascal, the older compiler may issue an error if the /VERSION qualifier is specified. Normally, older compilers will simply ignore any qualifiers that were added after its release. However, due to the implementation of /VERSION, older compilers will issue errors while trying to process other qualifiers. If you receive these errors, do not use /VERSION to determine the older compiler's version. You will need to look in the first line of a listing file or in the ANALYZE/IMAGE output.

Jumping into a WITH statement with a GOTO statement may result in an Internal Compiler Error if compiled with /OPTIMIZE. Such programs are illegal in nature as bypassing the prologue of the WITH statement skips around the code that precomputes the address of the record used in the WITH statement.

The ALIGNED attribute only allows up to 8192 byte boundaries at present (i.e., ALIGNED(13)). Support for larger alignments will be considered for a future release if there is customer demand.

Incomplete support for INTEGER64/UNSIGNED64

Currently, the following uses of the INTEGER64/UNSIGNED64 data types are unsupported:

When debugging programs that contain schema, you must use the /NOOPTIMIZE qualifier on the PASCAL DCL command. If you do not use /NOOPTIMIZE, you might receive incorrect debug information or an Internal Debug Error when manipulating schema.

Pointers to undiscriminated schema cannot be correctly described to the debugger at this time since the type of the pointer is dependent upon the value pointed to by the pointer. They are described as pointers to UNSIGNED integers instead. For example:

    TYPE S(I:INTEGER) = ARRAY [1..I] OF INTEGER;
    VAR P : ^S;

    BEGIN
    NEW(P,expression);
    END;

The compiler did not generate the correct debug DWARF information for some Pascal string types. To get proper behavior, you also need the debugger from V9.2-2 Update 1.

The compiler would sometimes ACCVIO when using the /DEBUG qualifier.

The compiler would generate an assertion if the same name was used as both a routine name and a static variable in another routine. For example:

         module bug;
         [global] procedure x; begin end;
         [global] procedure y; var x : [static] integer; begin end;
         end.

The compiler would overwrite the stack when making the local copy of a VARYING OF CHAR parameter:

         type pstr = varying [1812] of char;
         procedure test(p1 : pstr); begin writeln(p1); end.

The compiler would sometimes generate include pc-line DWARF information with "line 0" information. This resulted in TRACEBACK printing messages like:

         Error: traceback pc= 0000011f was not found

The compiler would generate an assertion with using /DEBUG on a MODULE that contained no code:

         [ENVIRONMENT] MODULE BUG;
         CONST C = 13;
         END.

The compiler would sometimes ACCVIO when using /DEBUG on a program that uses %INCLUDE files that declare types and variables in different source scopes.

Calling a routine that uses the [TRUNCATE] attribute may result in the wrong number of arguments passed to the target routine. For example, the following program will get an ACCVIO:

         PROGRAM Trunc001 (OUTPUT);
         VAR
             A : CHAR := '1';
             B : CHAR := '2';
             C : INTEGER := 0;

         PROCEDURE Values (A : CHAR;
                           B : [TRUNCATE] CHAR;
                           C : [TRUNCATE] INTEGER);
             BEGIN
             IF PRESENT (A) THEN WRITE ( A  ,'-');
             IF PRESENT (B) THEN WRITE ( B  ,'-');
             IF PRESENT (C) THEN WRITE ('3!');
             WRITELN;
             END;

         BEGIN
         Values(A);
         Values(A,B);
         Values(A,B,C);
         END.

The compiler would sometimes generate incorrect code for non-local GOTOs when optimization and checking was enabled.

The compiler would generate incorrect DWARF for certain bitfields with explicit size attributes:

         type
           rec = packed record
                 f4 : [pos(2),bit(3)] 0..7;
                 f5 : [pos(9),bit(7)] 0..127;
                 f6 : [pos(17)] integer;
                 end;

The compiler would generate incorrect DWARF for packed SET types:

         type chsubt = 'a'..'f';
         var  pschsub : packed set of chsubt;
         begin
         pschsub := ['a','d','f'];
         end

The compiler would incorrectly compile a program that used a nested routine that had the same name as an outer-level routine:

         $ type levelmod.pas
         [environment('levelmod')] module levelmod(output);
         [global] procedure printit; begin writeln('printit inside module levelmod'); end;
         end.

$ type level.pas
         [inherit('levelmod')]
         program level0(input,output);

         procedure level1;
          procedure printit; begin writeln('printit inside of level1'); end;

         begin printit; end;

         procedure level2;
          procedure printit; begin writeln('printit inside of level2'); end;

         begin printit; end;

         begin
         printit;  ! From levelmod environment
         level1;
         level2;
         end.

The compiler would generate incorrect DWARF for BOOLEAN variables with explicit size attribute:

         type byte_bool = [byte] boolean;
              word_bool = [word] boolean;