The VSI Pascal compiler accepts programs that comply with two standards and a subset of programs that comply with a third. VSI Pascal also provides features (called extensions) that are not part of any standard. For portable code, limit your use of these extensions or isolate the extensions in separate modules.

This section discusses lexical elements of the VSI Pascal language.

PROGRAM
PRogrAm
program

'b'  'B'
"c"  "C"

For2n8
MAX_WORDS
upto
LOGICAL_NAME_TABLE       {Unique in first}
Logical_Name_Scanner     {  31 characters}

SYS$CREMBX

4Awhile                                   {Starts with a digit}
up&to                                     {Contains an ampersand}
YEAR_END_87_MASTER_FILE_TOTAL_DISCOUNT    {Not unique in first}
Year_End_87_Master_File_Total_Dollars     { 31 characters}

Comments document the actions or elements of a program. The text of a comment can contain any ASCII character except a nonprinting control character, such as an ESCAPE character. You can place comments anywhere in a program that white space can appear.

{ This is a comment. }
(* This is a comment, too. *)

{ The delimiters of this comment do not match. *)
(* VSI Pascal allows you to mix delimiters in this way. }

(* Cannot { nest  comments inside } of comments like this *)

%IF FALSE
%THEN
...code to disable...
%ENDIF

For more information on %IF, see Section 11.4, “%IF, %ELSE, %ELIF, and %ENDIF”.

VSI Pascal allows for an end-of-line comment using an exclamation point (!). If an exclamation point is encountered on a line in the source program, the remainder of that line will be treated as a comment.

This comment syntax is not recognized by SCA for report generation.

FF
%TITLE 'Variable Declarations'
end; FF
FF
FF VAR FF

BEGIN FF END

The page break does not affect the meaning of the program, but causes a page to eject at the corresponding line in a listing file.

This section describes the ordinal types that are predefined by VSI Pascal and user-defined ordinal types (types that require you to provide identifiers or boundary values to completely define the data type).

The ranges of values for these types are ordinal in nature; the values are ordered so that each has a unique ordinal value indicating its position in a list of all the values of that type. There is a one-to-one correspondence between the values in an ordinal type and the set of positive integers.

                     { decimal-number                       }
                     { base-number#[[']]extended-digit[[']] }
            {-  }    {                                      }
         [[ {   } ]] {   {b  }                              }
            {+  }    { % {o  } [[']]extended-digit[[']]     }
                     {   {   }                              }
                     {   {x  }                              }
                     {                                      }

17          0             89324

  2#10000011

  2#'1000 0011'

 32#1J

-16#'7FFF FFFF'

 %b'1000 0011'
 %O'7712'
-%x'DEC'

'A'
'z'
'0'   { This is the character 0, not the integer value 0 }
''''  { The apostrophe or single quotation mark }
'?'

"A"
"z"
"\""  { The double quotation mark }
"?"

''(7)
CHR( 7 )

"\n"

TYPE
   Seasons = ( Spring, Summer, Fall, Winter );
VAR
   Some_Seasons : Seasons VALUE Winter;  {Initialized}

TYPE
   Seasons2 = ( Fall, Winter, Spring );

TYPE
   Day = ( Mon, Tues, Wed, Thur, Fri, Sat, Sun );
   Weekday = Mon..Fri;            {subrange of base type Day}
   Weekend = Sat..Sun;            {subrange of base type Day}
   Digit   = '0'..'9';            {subrange of base type CHAR}
   Month   = 1..31;               {subrange of base type INTEGER}
   National Debt = 1..92233720368 {subrange of base type INTEGER64}
   5477580;

type word = [word] 0..65535;



procedure take_a_word( p : word );
  begin
  writeln(p);
  end;

begin
take_a_word(90000);
end.

procedure take_a_word( p_ : integer );
 var p : word;  { Local copy }
  begin
  p := p_;      { Make local copy and do range check from longword
                  integer expression into word subrange on assignment }
  writeln(p);
  end;

VSI Pascal predefines the REAL, SINGLE, DOUBLE, and QUADRUPLE data types in the floating-point formats listed in Table 2.6, “Supported Floating-Point Formats”.

VSI Pascal provides the following built-in data types to declare variables of a specific floating point type regardless of the /FLOAT setting on the command line (or FLOAT attribute on the MODULE):

To express REAL numbers, you can use either decimal or exponential notation. To express DOUBLE or QUADRUPLE numbers, you must use exponential notation.

  2.4
893.2497
  8.0
  0.0

    2.3E2
   10.0E-1
9.14159e0

To express negative real numbers in exponential notation, use the negation operator (-). Remember that a negative real number such as -4.5E+3 is not a constant, but is actually an expression consisting of the negation operator (-) and the real number 4.5E+3. Use caution when expressing negative real numbers in complex expressions.

The floating lexical functions %F_FLOAT, %D_FLOAT, %G_FLOAT, %S_FLOAT, and %T_FLOAT can be prefixed on a floating constant to select the floating type regardless of any module-level attribute or command line selection.

For More Information:

A pointer type allows you to refer to a dynamic variable. Dynamic variables do not have lifetimes that are strictly related to the scope of a routine, module, or program; you can create and eliminate them at various times during program execution. Also, pointer types clearly define the type of an object, but you can create or eliminate objects during program execution.

One or more identifiers that provide additional information about the base type.

The type identifier of the dynamic variable to which the pointer refers. The base type can be any type name or schema name. (If the base type is an undiscriminated schema type, you need to supply actual discriminants when you call the NEW function.)

Unlike other variables, dynamic variables do not have identifiers. You can access them indirectly with pointers.

When you use pointers, you call the procedure NEW to allocate storage for dynamic variables. You call the procedure DISPOSE to deallocate this storage.

TYPE
   My_Rec = RECORD
      Name : STRING( 30 );
      Age  : INTEGER;
   END VALUE [Name: 'Chris Lee'; Age: 29]; {Initialized}
VAR
   Ptr : ^My_Rec;

{In executable section:}
NEW( Ptr );

Ptr^ := My_Rec[Name: 'Kim Jones'; age: 65];

Pointers assume values through initialization, assignment, and the READ and NEW procedures. The value of a pointer is either the storage address of a dynamic variable or the predeclared identifier NIL. NIL indicates that the pointer does not currently refer to a dynamic variable.

A file referenced by a pointer is not closed until the execution of the program terminates or until the dynamic variable is deallocated with the DISPOSE procedure. If you do not want the file to remain open throughout program execution, you must use the CLOSE procedure to close it.

VAR
     Ptr : ^INTEGER VALUE NIL;

For performance reasons, on VSI OpenVMS I64 and VSI OpenVMS x86-64 systems, the VSI Pascal compiler assumes that all pointers point to objects that are aligned on at least octaword boundaries. The NEW predeclared routine always returns memory that is aligned on octaword boundaries.

For performance reasons on VSI OpenVMS Alpha systems, the VSI Pascal compiler assumes that all pointers point to objects that are aligned on at least quadword boundaries. The NEW predeclared routine always returns memory that is aligned on quadword boundaries.

 var
    p : ^ [aligned(0)] integer; { Pointer to a byte-aligned integer }

  var
       long_ptr : ^integer;
       quad_ptr : [quad] ^integer;

  begin
    new(long_ptr);
    quad_ptr := long_ptr;
    quad_ptr^ := 5;
    if quad_ptr <> long_ptr then quad_ptr := long_ptr;
    end;

When comparing a 32-bit and a 64-bit pointer, the 32-bit pointer will be sign-extended before the comparison. Also, when assigning a 32-bit pointer value into a 64-bit pointer variable, the value will be sign-extended. You cannot assign a 64-bit pointer value into a 32-bit pointer variable.

For More Information:

The structured data types are user defined and consist of components. Each component of a structured data type has its own data type; components can be any type.

To express values of structured objects (arrays, records, and sets), you can use a list of values called constructors. Constructors are valid in the TYPE, CONST, VAR, and executable sections of your program. Examples of valid constructors are provided throughout the following sections. The following sections also contain examples that show how to assign values to individual components of structured objects.

To save storage space, you can specify PACKED before any structured type identifier except VARYING OF CHAR (for example, PACKED ARRAY, PACKED RECORD, and PACKED SET). Defining PACKED structured types causes the compiler to economize storage by storing the structure in as few bits as possible. Keep in mind, however, that a packed data item is not compatible with a data item that is not packed. Also, accessing components of some packed structures can be slower than accessing components of unpacked structures.

VSI Pascal also provides the predefined structured type TIMESTAMP for more easily manipulating date and time information.

For More Information:

[[PACKED]] ARRAY [{[[attribute-list]] index-type},...] OF [[attribute-list]] component-type

TYPE
   Count = ARRAY[1..10] OF INTEGER;  {Array type of 10 integers}
VAR
   Numbers : Count;                  {Array variable}
{In the executable section:}
Numbers[5] := 18;  {Assigns the value 18 to the fifth element}

VAR
   Tic_Tac_Toe : ARRAY[1..3] OF ARRAY['a'..'c'] OF CHAR;
      {Or equivalently:}
   Tic_Tac_Toe : ARRAY[1..3, 'a'..'c'] OF CHAR; {3x3 matrix}

{In the executable section:}
Tic_Tac_Toe[ 1, 'a' ] := 'X';  {Or equivalently:}
Tic_Tac_Toe[1]['a']   := 'X';

                     {component           }
[[data-type]] [ [[{{ {component-subrange  } },... : component-value};... ]]
   [[OTHERWISE component-value [[;]] ]] ]

VAR
   Numbers : Count VALUE [1..3,5 : 1;  4,6 : 2;  7..9 : 3;  10 : 6];
{In the executable section, constructor type is required:}
Numbers := Count[1..3,5 : 1;  4,6 : 2;  7..9 : 3;  10 : x+3];

Numbers := Count[4,6 : 2;  7..9 : 3;  10 : x+3; OTHERWISE 1];

TYPE
   One_Dimension = ARRAY[1..3] OF CHAR;
   Matrix = ARRAY['a'..'b'] OF One_Dimension;
VAR
   Tic_Tac_Toe : Matrix;
{In the executable section:}
Tic_Tac_Toe := Matrix[ 1,3 : [OTHERWISE ' '];
                       2 : [ 1,3 : ' '; 2 : 'X']];

{{{field-identifier},... : [[attribute-list]] type};... [[; variant-clause]] [[;]]}
{variant-clause [[;]]}

TYPE
   Player_Rec = RECORD
      Wins       : INTEGER;
      Losses     : INTEGER;
      Percentage : REAL;
      END;
VAR
   Player1, Player2 : Player_Rec;
{In the executable section:}
Player1.Wins := 18;  {Assigns the value 18 to the Wins field.}

VAR
   Player : RECORD
      Wins       : INTEGER VALUE 18; {Initial value for one field}
      Losses     : INTEGER;
      Percentage : REAL;
      END;

TYPE
   Team_Rec = RECORD
      Total_Wins       : INTEGER;
      Total_Losses     : INTEGER;
      Total_Percentage : REAL;
      Player1          : Player_Rec;   {Defined in previous example}
      Player2          : Player_Rec;
      Player3          : Player_Rec;
      END;
VAR
   Team : Team_Rec;

Team.Total_Wins := Team.Player1.Wins +
                   Team.Player2.Wins +
                   Team.Player3.Wins;

     {[[tag-identifier : ]] [[attribute-list]] tag-type-identifier  }
CASE {discriminant-identifier                                       } OF
   {case-label-list : (field-list)};...
   [[ [[;]] OTHERWISE (field-list) ]]

TYPE
   Record_Template( a : INTEGER ) = RECORD
      Field_1 : REAL;
      CASE a OF
         0 : ( x : INTEGER );
         1 : ( y : REAL );
      END;

VAR
   Hospital : RECORD
   Patient   : Name;
   Birthdate : Date;
   Age       : INTEGER;
   CASE Pat_Sex : Sex OF
        Male   : ();
        Female : ( CASE Births : BOOLEAN OF
                       FALSE  : ();
                       TRUE   : ( Num_Kids : INTEGER ));
   END;

[[data-type]] [ [[{{component},... : component-value};... ]]
 [[ CASE [[tag-identifier :]] tag-value OF
    [{{component},... : component-value};...] ]]
 [[ OTHERWISE ZERO [[;]] ]]

VAR
   Player1 : Player_Rec VALUE [Wins: 18; Losses: 3;
                               Percentage: 21/18];
{In executable section, constructor type is required
 and run-time expressions are legal:}
Player1 := Player_Rec[Wins: 18; Losses: y; Percentage: y+18/18];

TYPE
   Team_Rec = RECORD
      Total_Wins       : INTEGER;
      Total_Losses     : INTEGER;
      Total_Percentage : REAL;
      Player1          : Player_Rec;
      Player2          : Player_Rec;
      Player3          : Player_Rec;
      END;


VAR
   Team : Team_Rec;
{In the executable section: }
Team :=
 Team_Rec[Total_Wins: 18; Total_Losses: 3; Total_Percentage: 21/18;
         Player1: [Wins: 6; Losses: 0; Percentage: 1.0 ];
         Player2: [Wins: 5; Losses: 2; Percentage: 7/5 ];
         Player3: [Wins: 7; Losses: 1; Percentage: 8/7 ]];

VAR
   Team : Team_Rec VALUE ZERO ;
   Team : Team_Rec VALUE
          [Total_Wins: 5; Total_Losses: 2; Total_Percentage: 7/5;
           Player2: [Wins: 5; Losses: 2; Percentage: 7/5 ];


OTHERWISE ZERO

]; {Initializes Player1 and Player3}

TYPE
   Orders = RECORD
   Part : 1..9999;
   CASE On_Order : BOOLEAN OF
      TRUE  : ( Order_Quantity : INTEGER;
                Price          : REAL );
      FALSE : ( Rec_Quantity   : INTEGER;
                Cost           : REAL );
   END;
VAR
   An_Order : Orders VALUE
              [Part: 2358;
               CASE On_Order : FALSE OF
               [Rec_Quantity: 10; Cost: 293.99]];

{In the executable section, constructor type is required:}
An_Order := Orders
            [Part: 2358;
            CASE On_Order : FALSE OF [Rec_Quantity: 10; Cost: 293.99]];

TYPE
   Orders = RECORD
   Part : 1..9999 VALUE 25;
   CASE On_Order : BOOLEAN OF
      TRUE  : ( Order_Quantity : INTEGER VALUE 18;
                Price          : REAL VALUE 4.65 );
      FALSE : ( Rec_Quantity   : INTEGER VALUE 10;
                Cost           : REAL VALUE 46.50 );
   END;

TYPE INTSET = SET OF 0 .. 255;

VAR
   Numbers : SET OF 35..115 VALUE [39, 67, 110..115];
{In the executable section, run-time expressions are legal:}
Numbers := [39, 67, x+95, 110..115];

VAR
   Day : SET OF 1..31 VALUE [];

VAR
   True_False_File : FILE OF BOOLEAN;    {File of TRUE and FALSE values}
   Experiment_Records : FILE OF RECORD   {File of records}
                        Trial : INTEGER; {To access, Experiment_Records^.Trial}
                        Temp, Pressure  : INTEGER;
                        Yield, Purity   : REAL;
                        END;

n OF value

VAR
   Array1 : ARRAY[1..4] OF INTEGER;
VALUE
   Array1 := ( 3 OF 15, 78 );

TYPE
   Count = ARRAY[1..10] OF INTEGER;
VAR
   Numbers : Count;
VALUE
   Count := ( 3 OF 1, 2, 1, 2, 3 OF 3, 3 );
{In the executable section, constructor type is required:}
Numbers := Count( 3 OF 1, 2, 1, 2, REPEAT 3 );

TYPE
   One_Dimension = ARRAY[1..3] OF CHAR;
   Matrix = ARRAY['a'..'b'] OF One_Dimension;
VAR
   Tic_Tac_Toe : Matrix;
   { In the executable section: }
Tic_Tac_Toe := Matrix( (3 OF ' '), (' ', 'X', ' '), (3 OF ' ') );

TYPE
   Player_Rec = RECORD
      Wins       : INTEGER;
      Losses     : INTEGER;
      Percentage : REAL;
VAR
   Player1 : Player_Rec := ( 18, 6, 24/18 );
{In the executable section, constructor type is required:}
Player1 := Player_Rec( 18,  6, 24/18 );

TYPE
   Team_Rec = RECORD
      Total_Wins       : INTEGER;
      Total_Losses     : INTEGER;
      Total_Percentage : REAL;
      Player1          : Player_Rec;
      Player2          : Player_Rec;
      Player3          : Player_Rec;
      END;
VAR
   Team : Team_Rec;
{In the executable section: }
Team :=  Team_Rec ( 18, 3, 18/21,
                    ( 6, 0, 1.0 ),
                    ( 5, 2, 5/7 ),
                    ( 7, 1, 7/8 ) );

TYPE
   Orders = RECORD
   Part : 1..9999;
   CASE On_Order : BOOLEAN OF
                  TRUE  : ( Order_Quantity : INTEGER;
                            Price          : REAL );
                  FALSE : ( Rec_Quantity   : INTEGER;
                            Cost           : REAL );
   END;
VAR
   An_order : Orders := ( 2358, FALSE, 10, 293.99 );

A schema type is a user-defined construct that provides a template for a family of distinct data types. A schema type definition contains one or more formal discriminants that take the place of specific boundary values or variant-record selectors. By specifying boundary or selector values to a schema type, you form a valid data type; the provided boundary or selector values are called actual discriminants. Schema types have the following form:

schema-identifier ({{discriminant-identifier},... :
 [[attribute-list]] ordinal-type-name};... )
 = [[attribute-list]] type-denoter;

The name of the schema.

The name of a formal discriminant.

One or more identifiers that provide additional information about the type-denoter.

The type of the formal discriminant, which must be an ordinal type (except those types that have INTEGER64 or UNSIGNED64 base types).

The type definition of the components of the schema. This must define a new record, array, set, or subrange type.

TYPE
   Array_Template( Upper_Bound : INTEGER )
                 = ARRAY[1..Upper_Bound] OF INTEGER;

TYPE
   Vector( d : INTEGER ) = ARRAY[0..d-1] OF BOOLEAN;
   Number_Line( Starting, Distance : INTEGER ) =
      Starting..Starting+Distance;
   My_Subrange( l,u : INTEGER ) = l..u;
   Shift_Array_Index( l2, u2, Length : INTEGER ) =
      ARRAY[My_Subrange( l2+10, u2+10 )] OF STRING( Length );

TYPE
   Array_Template( Upper_Bound : INTEGER )
                 = ARRAY[1..Upper_Bound] OF INTEGER;
VAR
   Array1 : Array_Template( 10 );  {ARRAY[1..10] OF INTEGER;}
   Array2 : Array_Template( x );   {Upper boundary determined at
                                    run time by variable or
                                    function call}

In the previous example, the actual discriminants 10 and x complete the boundaries for Array_Template, forming two complete data types within the same schema type family. A schema type that has been provided actual discriminants is called a discriminated schema; discriminated schema can appear in either the TYPE or VAR sections. The type specifiers Array_Template( 10 ) and Array_Template( x ) are examples of discriminated schema.

Actual discriminants can be compile- or run-time expressions. This expression must be assignment compatible with the ordinal type specified for the formal discriminant. Also, the actual discriminant value must be inside the range specified for the formal discriminant; in the case of subranges, the upper value must be greater than or equal to the lower value. In the previous example, 10 and x must be within the range -MAXINT..MAXINT.

TYPE
   Array_Type1 = Array_Template( 10 );

PROCEDURE Example( Param : Array_Type1 );  {Procedure body...}

TYPE
   My_Subrange( a, b : INTEGER ) = a..b;
   Sub_A = My_Subrange( 1, 5 );
   Sub_B = My_Subrange( 1, 5 );
   Sub_C = My_Subrange( -50, 50 );

TYPE
   My_Subrange( a, b : INTEGER ) = a..b;
   My_Array( Upper : INTEGER ) = ARRAY[1..Upper] OF INTEGER;
VAR
   i : My_Array( 10 );
   j : My_Array( 10 );
   k : My_Array( 15 );
   l : ARRAY[ My_Subrange( 1, 10 ) ] OF INTEGER;
   m : ARRAY[ My_Subrange( 1, 10 ) ] OF INTEGER;

{In the executable section:}
i := j;      {Legal; same schema family, same actual discriminant}
i := k;      {Illegal; same schema family, different actual}
i := l;      {Illegal; different types}
l := m;      {Illegal; different types}

Types l and m are not assignment compatible despite having the same subrange values specified by the same schema type; the two distinct type declarations create two distinct types, regardless of the ranges of the two types.

VAR
   Array1 : Array_Template( 10 );
{In the executable section:}
WRITELN( Array1.Upper_Bound );    {Writes 10 to the default device}

FOR i := 1 TO Array1.Upper_Bound DO
   Array1[i] := i;

You can use discriminated schema in the type-denoter of a schema definition. You can also discriminate a schema in the type-denoter of a schema definition, but the actual discriminants must be expressions whose values are nonvarying; the actual discriminants cannot be variables or function calls.

TYPE
   {   Legal schema types:    }
   Range1( a, b : INTEGER ) = SET OF a..b+1;  {Run-time bounds checking}

   My_Record( Number_Size, Status_Size : INTEGER ) = RECORD
      Part_Number : PACKED ARRAY[1..Number_Size] OF INTEGER;
      Status     : STRING( Status_Size );    {Nested schema}
      END;

   Range2( Low, Span : INTEGER ) = Low..Low + Span;
   My_Integer( Dummy : INTEGER ) = -MAXINT-1..MAXINT;
   Matrix( Bound : INTEGER ) = ARRAY[1..Bound, 1..Bound] OF REAL;

   {    Illegal schema types (they do not form "new" types):   }
   My_String( Len : INTEGER ) = VARYING[Len] OF CHAR;
   My_Integer( Dummy : INTEGER ) = INTEGER;

Objects of the CHAR data type are character strings with a length of 1 and are lowest in the order of character string complexity. You can assign CHAR data to variables of the other string types.

The PACKED ARRAY OF CHAR types allow you to specify fixed-length character strings. The VARYING OF CHAR types are a VSI Pascal extension that allows you to specify varying-length character strings with a constant maximum length. The STRING types provide a standard way for you to specify storage for varying-length character strings with a maximum length that can be specified at run time.

To provide values for variables of these types, you should use a character-string constant (or an expression that evaluates to a character string) instead of an array constructor. Using array constructors with STRING and VARYING OF CHAR types generates an error; to use array constructors with PACKED ARRAY OF CHAR types, you must specify component values for every element in the array (otherwise, you generate an error).

VAR
   String1 :

VARYING[10] OF CHAR

Generally, you can use any member of the ASCII character set in character-string constants and expressions. However, some members of the ASCII character set, including the bell, the backspace, and the carriage return, are nonprinting characters. The extended string format for character strings with nonprinting characters is as follows:

{'printing-string'({ordinal-value},...)}...

printing-string

A character-string constant.

Two bells'(7,7)' in a null-terminated ASCII string.'(0)

string-access "[" lower-bound ".." upper-bound "]"

   var s : packed array [1..10] of char;

   s[1..5] :='hello';
   s[6..10] := 'world';

  procedure do_buf(var p : packed array [1..u:integer] of char);
     begin p := '12345'; end;

  var buff : packed array [1..10] of char;

  do_buff(buff[1..5]);
  do_buff(buff[6..10);

  writeln(buff);

To avoid compile-time warning messages about passing components of PACKED structures to VAR parameters, use /USAGE=NOPACKED_ACTUALS to compile.

In expressions, substring access behaves much like the SUBSTR built-in.

VSI Pascal also provides features for handling null-terminated strings. These are useful for communicating with routines written in the C language.

For More Information:

VAR
   My_String : PACKED ARRAY[1..20] OF CHAR;

VAR
   States : PACKED ARRAY[1..20] OF CHAR
            VALUE 'Hello';                         {Is legal}
   States : PACKED ARRAY[1..20] OF CHAR
            VALUE [1:'H';2:'e';3:'l';4:'l';5:'o']  {Generates
                                                    an error}
   States : PACKED ARRAY[1..20] OF CHAR
            VALUE [1:'H';2:'e';3:'l';4:'l';5:'o';
                  OTHERWISE ' ']                   {Is legal,
                                                    but awkward}

VAR
   String1 : VARYING[10] OF CHAR VALUE '';

RECORD
   LENGTH   : [WORD] 0..upper-bound;  {Length of current string}
   BODY     : PACKED ARRAY[1..upper-bound] OF CHAR;  {Current string}
   END;

VAR
   String1 : VARYING[10] OF CHAR VALUE 'Wolf';
{In the executable section: }
Max_Length := SIZE( string1.BODY );
WRITELN( Max_Length );                {writes '10'}

String1[8] := 'L';

TYPE
   STRING( capacity : INTEGER ) = VARYING[capacity] OF CHAR;

VAR
   Short_String : STRING( 5 );    {Maximum length of 5 characters}
   Long_String  : STRING( 100 );  {Maximum length of 100 characters}

VAR
   Short_String : STRING( 5 ) VALUE '';

VAR
   String1 : STRING( 10 ) VALUE 'Wolf';
{In the executable section: }
WRITELN( String1.CAPACITY );  {prints '10'}
WRITELN(

String1.LENGTH

{prints '4'}

String1[5] := 't';

VAR
   String1 : STRING( 10 ) VALUE 'Wombat';
   x       : CHAR;
{In the executable section:}
x := String1[9];       {Generates an error}
x := String1.BODY[9];  {Provides whatever is in memory there}
x := String1[5];       {Is legal}
String1[9] := 'X';     {Generates an error}

VSI Pascal includes routines and a built-in type to better coexist with null-terminated strings in the C language.

C_STR_T = ^ ARRAY [0..0] OF CHAR;

C_STR_T is a pointer to an ARRAY OF CHARs. It does not allocate memory for any character data. C_STR_T behaves like a normal pointer type in that you can assign NIL into it and the optional pointer checking code will check for dereferencing of a NIL pointer. The individual characters can be used by dereferencing the pointer and using an array index.

In these cases, no bounds checking will be performed even if array bounds checking is enabled. However, you cannot dereference a C_STR_T pointer without also indexing a single character. If you want to access an entire null-terminated string, see the PAS_STR function.

For More Information:

The TIMESTAMP predefined type is used in conjunction with the GETTIMESTAMP procedure and with the DATE or TIME functions. GETTIMESTAMP initializes a variable of type TIMESTAMP; DATE and TIME function parameters are of type TIMESTAMP.

TIMESTAMP = PACKED RECORD
   DATEVALID, TIMEVALID   : BOOLEAN;
   YEAR                   : INTEGER;
   MONTH                  : 1..12;
   DAY                    : 1..31;
   HOUR                   : 0..23;
   MINUTE                 : 0..59;
   SECOND                 : 0..59;
   HUNDREDTH              : 0..99;
   BINARY_TIME            : [QUAD] RECORD L1,L2:INTEGER END;
                                  {64-bit VMS binary time:}
   DAY_OF_WEEK            : 1..7;   {1 is Monday and 7 is Sunday}

   END;

For More Information:

VAR
    a : INTEGER;
    b : ARRAY[1..10] OF INTEGER;

Nonstatic types require storage allocation to hold information about the type at run time. This storage, called the control part, includes information that cannot be determined until execution time; VSI Pascal needs this information to allocate and to access variables and record fields of this type.

TYPE
                               {Template is nonstatic:}
   Template( Upper : INTEGER ) = ARRAY[1..Upper] OF INTEGER;
   a = ^Template;                     {a's base type is nonstatic}
   b = Template( 5 );                 {b is nonstatic}
   My_Subrange( x, y : INTEGER ) = x..y;
                                      {c is nonstatic:}
   c = ARRAY[My_Subrange( j, k ), My_Subrange( l, m )] OF INTEGER;
   d = ARRAY[1..10] OF Template( 5 ); {d is nonstatic}
   e = RECORD                         {e is nonstatic}
      f1 : TEMPLATE( 5 );
      END;
   f = SET OF My_Subrange( 10, 20 );  {f is nonstatic}

Do not confuse static and nonstatic types with automatic and static variable allocation.

For More Information:

The following sections discuss the two forms of type compatibility: structural and assignment compatibility.

     CONST
        {constant-identifier = constant-expression};...

The identifier of the symbolic constant being defined.

Any legal compile-time expression.

Once a constant identifier is associated with an expression, the identifier retains the value of that expression throughout the scope in which it was declared. You can change the value only by changing the definition in the CONST section.

TYPE
   array_type1 = ARRAY[1..10] OF INTEGER;
CONST
   Year       = 1984;
   Tiny       = 1.7253;
   Month      = 'November';
   Initial    = 'P';
   Lie        = FALSE;
   Untruth    = Lie;
   Almost_Pi  = 22.0/7.0;
   array_const =
      array_type1[1..3,5 : 1;  4,6 : 2;  7..9 : 3;  10 : 7];

For More Information:

     LABEL
        {label},...;

A decimal integer between 0 and 9999 (as an extension, between 0 and MAXINT), or a symbolic name. When declaring several labels, you can specify them in any order. The declaration and the occurrence of the label must be at the same level in the program.

A label can appear only once within the scope of the label declaration. It can precede any executable statement in the program. Use a colon (:) to separate the label from the statement it precedes. Labels can be accessed only by GOTO statements.

LABEL
    marker, 5;
{In the executable section: }
IF a <= 150 THEN GOTO 5
ELSE GOTO marker ;
   .
   .
   .
5: a := a + 1;
   .
   .
   .
marker: WHILE x < 20 DO {Statement...}

For More Information:

The TO BEGIN DO section allows you to specify a statement, in a module that is to be executed before the executable section of the main program; it has the following form:

A Pascal statement.

The TO BEGIN DO section can only appear in modules, can only appear once in a module, and must appear as the last section in the declaration section. (If appearing together, the TO BEGIN DO section must precede the TO END DO section at the end of the declaration section.)

MODULE x( INPUT, OUTPUT );
VAR
   Debug : BOOLEAN;
PROCEDURE Test(...); {Executable section...}

TO BEGIN DO
   BEGIN
   WRITE('Debug Module x?   ');
   READLN( Debug );
   END;
END.

As a general rule, if a program or module inherits an environment file, the compiler executes the initialization section in the inherited module before the initialization section in the program or module that inherited it. If a module or program inherits more than one module that contains an initialization section, the order of execution of the inherited modules is undefined.

[ENVIRONMENT( 'Mod1' )]  MODULE Mod1;
VAR
   i : INTEGER;
TO BEGIN DO
   i := 5;

{In a separate compilation unit:}
[INHERIT( 'Mod1' )]  MODULE Mod2;
VAR
   j : INTEGER;
TO BEGIN DO
   j := i + 1;  {First execute code in Mod1 for correct results}

Figure 3.1, “Order of Execution for TO BEGIN DO and TO END DO Sections” shows the order of execution of initialization and finalization sections. Each circle is a module that contains both a TO BEGIN DO and a TO END DO section, and each arrow indicates the order of inheritance for the environment files.

[ENVIRONMENT]  MODULE Mod1; ...

[ENVIRONMENT, INHERIT( 'Mod1' )]  MODULE Mod2; ...

[ENVIRONMENT, INHERIT(' Mod1' )]  MODULE Mod3; ...

[INHERIT( 'Mod2', 'Mod3' )]       MODULE Mod4; ...

[ENVIRONMENT,GLOBAL(MYINIT)] MODULE Mod1; ...

This alternate name is encoded in the resulting environment file so all modules that inherit this environment will automatically call the initializaton routine by its new alternate name.

For More Information:

A Pascal statement.

The TO END DO section can only appear in modules, can only appear once in a module, and must appear as the last section in the declaration section. (If appearing together, the TO END DO section must come after the TO BEGIN DO section at the end of the declaration section.)

As a general rule, if a compilation unit inherits an environment file, the finalization section in the inheriting compilation unit must be executed before the finalization section in the inherited compilation unit. Also, if more than one module with a finalization section inherits a single module, the order of finalization of the inheriting modules cannot be determined. Figure 3.1, “Order of Execution for TO BEGIN DO and TO END DO Sections” shows an example of the order of execution of TO END DO sections.

The compiler implements a TO END DO section by creating an invisible TO BEGIN DO section if TO BEGIN DO wasn't used or by augmenting an existing TO BEGIN DO section with a call to the Pascal Run-Time Library to register the finalization routine.

MODULE File_Output;
VAR
   Out_File : TEXT;
   t        : TIMESTAMP;
PROCEDURE Test(...); {Executable section...}

TO BEGIN DO

   OPEN( Out_File, 'foo.dat' );


TO END DO
   BEGIN
   GETTIMESTAMP( t );
   WRITELN( 'foo.dat closed at', TIME( t ) );

   CLOSE( Out_File )

   END;
END.

For More Information:

The TYPE section introduces the name and set of values for a user-defined type or schema declaration.

         [[type-attribute-list]]
         TYPE
              {type-identifier = [[attribute-list]] type-denoter  }
            { {schema-declaration                                 }
              {                                                   }
                [[VALUE initial-state-specifier]]};...

One or more attributes that apply to the entire TYPE section. Only the ALIGN, ENUMERATION_SIZE, or HIDDEN attributes can be specified here.

The identifier of the type being defined.

One or more identifiers that provide additional information about the type-denoter.

Any legal Pascal type syntax.

The declaration of a schema type.

A compile-time expression that is assignment compatible with a variable of the TYPE identifier being defined. VSI Pascal initializes all variables declared to be of this type with the constant value or values provided (unless there is an overriding initial-state-specifier in the variable declaration).

TYPE
   Days_of_Week = ( Sun, Mon, Tues, Wed, Thurs, Fri, Sat )
                    VALUE Mon;
   Array_Template( Upper_Bound : INTEGER ) =
                   ARRAY [1..Upper_Bound] OF INTEGER;
VAR                   {Declaring variables of user-defined types:}
   week1, week2, week3, week4 : Days_of_Week; {Initial value: Mon}
   week5 : Days_of_Week VALUE Sun;            {Initial value: Sun}
   array_type2 : array_template( x ); {x is a run-time expression}

TYPE
   Ptr_to_Movie = ^Movie;               {Movie is defined later}
   Name  = PACKED ARRAY[1..20] OF CHAR; {Defined before used}
   Movie = RECORD
           Title, Director : Name;
           Year  : INTEGER;
           Stars : FILE OF Name;
           Next  : Ptr_to_Movie;
           END;

For More Information

    VALUE
        {variable-identifier := constant-expression};...

The name of the variable to be initialized. You cannot specify a list of variable identifiers. You can initialize a variable or variable component only once in the VALUE section. Any variables appearing in the VALUE section must appear in a previous VAR section.

Any constant expression that is assignment compatible with the variable identifier.

Unlike other declaration sections, the VALUE section can appear only in a program or module declaration section. You cannot use the VALUE declaration section in procedures or functions. If you wish to initialize variables in procedures and functions, use an initial-state specifier (by using the VALUE reserved word in either the TYPE or VAR section).

You can assign values to complete structured variables or to a single component of that variable.

For More Information:

The VAR section declares variables and associates each variable with an identifier, a type, and an optional initial value.

         [[var-attribute-list]]
         VAR
            {{variable-identifier},... : [[attribute-list]] type-denoter
               {:=     }
            [[ {VALUE  } initial-state-specifier ]] };...

One or more attributes that apply to the entire VAR section. Only the ALIGN, ENUMERATION_SIZE or HIDDEN attributes can be specified here.

The identifier of the variable being declared.

One or more identifiers that provide additional information about the variable.

Any legal Pascal type syntax.

Any constant expression that is assignment compatible with the variable identifier. The variable is initialized to this expression.

You can combine several identifiers in the same variable declaration if the variables are of the same type and are being initialized either with the same value or not at all.

TYPE
   Hours_Worked = ARRAY[1..10] OF INTEGER;
VAR
   Answer, Rumor : BOOLEAN;
   Temp          : INTEGER VALUE 60;
   Grade         : 'A'..'D';
   Weekly_Hours  : Hours_Worked VALUE [1..3 : 7; OTHERWISE 5];

The existence of a variable reference sometimes prohibits certain operations from being performed on the variable. Such restrictions are noted throughout this manual.

For More Information:

Pascal expressions consist of one or more operands that result in a single value. If the expression contains more than one operand, the operands are separated by operators. Operands include numbers, strings, constants, variables, and function designators. Operators include arithmetic, relational, logical, string, set, and typecast operators.

Run-time expressions result in a value at the time you execute your program. These expressions can contain variables, predeclared functions, user-declared functions, and everything that a constant expression cannot contain.

When you form an expression, the operands must be of the same data type. Under some circumstances, the compiler performs data type conversions and allows you to form an expression with operands of different types.

Pascal does not evaluate expressions contained within a single statement in a predictable order. Also, the compiler does not always evaluate all expressions in a single statement if the correct execution of the statement can be determined by evaluation of fewer expressions. For example, some IF statement conditions can be determined TRUE or FALSE by only evaluating one of the Boolean expressions in the condition. Do not write code that depends on the evaluation order of expressions, and, in some cases, on the evaluation of all expressions in a single statement. If you require a predictable order of evaluation, you can use the AND_THEN and OR_ELSE operators.

For More Information:

Pascal provides several classes of operators. You can form complex expressions by using operators to combine constants, constant identifiers, variables, and function designators.

Pascal also provides the assignment operator (:=) for use in assignment statements.

For More Information:

   {  Expressions:                      Results: }
( 4 > 3 ) AND ( 18 = 3 * 6 )            {TRUE}
( 3 > 4 ) OR  ( 18 = 3 * 6 )            {TRUE}
NOT ( 4 <> 5 )                          {FALSE}
( i < 11 ) AND_THEN ( Array_A[i] = 0 )  {Not known}
p = NIL  OR_ELSE  p^ = 0                {Not known}

Flag AND ODD( i )

IF ( i < 11 ) AND_THEN ( Array_A[i] = 0 ) THEN
   WRITELN( 'Index bounds are legal and element contained 0' );

IF (PTR <> NIL) AND_THEN (P^.DATA1 = 0) AND (P^.DATA2 = 1) THEN ...

IF ((PTR <> NIL) AND_THEN (P^.DATA1 = 0)) AND (P^.DATA2 = 1) THEN ...

IF (PTR <> NIL) AND_THEN ((P^.DATA1 = 0) AND (P^.DATA2 = 1)) THEN ...

IF (PTR <> NIL) AND_THEN (P^.DATA1 = 0) AND_THEN (P^.DATA2 = 1) THEN ...

'motherhood' > 'cherry pie'

'string1' < 'string2'

'John' < 'Johnny'
'abc' = 'abc   '

VAR
   One_String : STRING( 25 ) VALUE 'Harvey Fierstein';
{In the executable section:}
WRITELN( One_String.LENGTH, LENGTH( One_String ) );

2*3 IN [1..10]

5*3 NOT IN [1..10]

         {variable-identifier  }
         {(expression)         } :: type-identifier

TYPE
   F_float = PACKED RECORD
             Frac1 : 0..127;
             Expo  : 0..255;
             Sign  : BOOLEAN;
             Frac2 : 0..65535;
             END;
VAR
   A : REAL;
{In the executable section:}
A::F_float.Expo := A::F_float.Expo + 1;

a<=x AND b<=y

 ( a<=x ) AND ( b<=y )

( ( 8 * 5 ) DIV 2 ) -4

IF f( a ) AND f( b ) THEN {Statement...}

Because VSI Pascal is a strongly typed language, you cannot normally treat a value of one type as though it were of a different type, as you can in many languages. For example, you cannot assign the character ’1 ’ to a variable of type INTEGER, because ’1 ’ is not an integer constant but a character constant. However, there are times when it makes sense to combine values of two different types because the values have some aspect in common. For example, suppose you wish to add a value of type REAL to a value of type INTEGER. This operation is legal because the value of type INTEGER is converted to its equivalent value of type REAL before the operation is performed. The result of the operation is of type REAL.

When values of two different arithmetic or character types are combined in an expression, the lower-ranked operand is converted to its equivalent in the higher-ranked type. The result of an operation in which conversion occurs is always of the higher-ranked type.

All conversions or assignments to values of type UNSIGNED or UNSIGNED64 are never checked for overflow. When combined with other unsigned values, negative integer values are converted to large unsigned values by the calculation of the modulus with respect to 2 ^**32 or 2 ^**64.

Conversions or assignments to values of type INTEGER or INTEGER64 can overflow. Overflow will be detected at run time if overflow checking is enabled. Overflow will occur if the value is outside the range -MAXINT to MAXINT for converting to INTEGER, or outside the range -MAXINT64 to MAXINT64 for converting to INTEGER64.

A special case of conversion can occur when you attempt to assign an expression of type VARYING OF CHAR or STRING strings to a variable of type PACKED ARRAY OF CHAR or if you try to pass a string expression to a formal value parameter of type PACKED ARRAY OF CHAR. If the varying-length string has less than or exactly the same number of components as the packed array, the varying-length string is converted to a packed array of characters before the assignment is made and padded with blanks as necessary. If you attempt to perform this assignment with a varying-length string that has more components than the packed array, a run-time error occurs.

For More Information:

The assignment statement uses an assignment operator (:=) to assign a value to a variable or to a function identifier. An assignment statement has the following form:

An identifier, array component, record component, pointer dereference, pointer-function dereference, or file buffer.

A run-time expression whose type is assignment compatible with the type of the variable. The value of the expression is the value assigned to the variable.

You cannot assign values to a variable of a record type with variants if you allocated this variable using the NEW procedure. You can assign values to a field of such a record variable.

VAR
   x     : INTEGER;
   y, z  : RECORD
      f1 : real;
      f2 : integer
      END;
{In the executable section:}
x := 1;  {type of expression is same type as the variable}
y := z;  {variables are assignment compatible}
Func_Return_Ptr_To_Integer( 3 )^ := 19;

For More Information:

BREAK

REPEAT
  name := GetInput('Your name?');
  IF ExitKeyPressed THEN BREAK;
  address := GetInput('Your address?');
  IF ExitKeyPressed THEN BREAK;
  Person[Num].Name := name;
  Person[Num].Addr := address;
  Num := SUCC(Num);
UNTIL Num > 50;

In the example, a user-defined function GetInput interacts with the user and sets a global Boolean variable ExitKeyPressed if the user presses an Exit key. The BREAK statement exits the loop here, without storing data in the array.

Use caution when using the BREAK statement because future additions to the code can result in the BREAK statement leaving a different loop than was originally intended.

         CASE case-selector OF
            [[{{case-label-list};...: statement};...]]
            [[ [[;]] OTHERWISE {statement};... ]]
            [[;]]
         END

An expression of an ordinal type.

One or more case labels of the same ordinal type as the case selector, separated by commas. A case label can be a single constant expression, such as 1, or a range of expressions, such as 5..10.

Any statement to be executed depending on the values of both the case-selector and the case-label.

You can specify case labels in any order within the case-label-list. Each case label can appear only once within a given CASE statement.

At run time, the system evaluates the case selector expression and chooses which statement to execute. If the value of the case selector does not appear in the case-label-list, the system executes the statement in the OTHERWISE clause. If you omit the OTHERWISE clause, the value of the case selector must be equal to one of the case labels. If the value is not equal to a label, the CASE statement result is undefined.

CASE Age OF
   1..4   : School := 'preschool';   {Subranges}
   5..8   : School := 'elementary';
   9..13  : School := 'middle';
   14..18 : BEGIN
            School := 'high';
            WRITELN( 'Difficult years!' );
            END;                     {Compound statements}
   19     : School := 'reform';      {Single ordinal value}
   OTHERWISE  School := 'graduated'; {If 1 > Age > 18 ...}
   END;

For More Information:

    BEGIN
        {statement};...
    END

Any Pascal statement, including other compound statements.

The statements that make up the compound statement must be separated with semicolons (;), although the semicolon before the END delimiter is optional.

IF a < 10 THEN
   BEGIN        {A compound statement}
   x := 10;
   y := 20;
   z := x + y;
   END          {No semicolon in THEN clause before an ELSE}
ELSE z := 29;   {A single statement}

For More Information:

The body of a FOR, WHILE, or REPEAT loop can include the CONTINUE statement. The CONTINUE statement is equivalent to a GOTO to a label placed at the end of the statements in the body of the FOR, WHILE, or REPEAT statement. The CONTINUE statement appears as a single word:

In a loop that processes a series of data items, you can use the CONTINUE statement to indicate that the rest of the loop does not apply to the current item, and that the program should continue to the next statement.

Use caution when using the CONTINUE statement because future additions to the code can result in the CONTINUE statement continuing with a different loop than was originally intended.

The empty statement causes no other action to occur than the advancement of program flow to the next statement. To use the empty statement, place a semicolon where the language syntax calls for a statement.

CASE Alphabetic OF
   'A','E','I','O','U' : Alpha_Flag := Vowel;
                   'Y' : ;  {Empty statement as selector; no action}
   OTHERWISE Alpha_Flag := Consonant;
   END;

                                      {TO      }
FOR control-variable := initial-value {DOWNTO  } final-value DO statement

FOR control-variable IN set-expression DO statement

The name of a previously declared variable of an ordinal type.

Expressions that form a range and whose type is assignment compatible with the type of the control variable.

An expression resulting in a value of SET type. The base type of the set must be assignment compatible with the control variable.

Any Pascal statement that does not change the value of the control variable.

After normal termination of the FOR statement, the control-variable does not retain a value. You must assign a new value to this variable before you use it elsewhere in the program. If the FOR loop terminates with a GOTO statement, the control-variable retains the last assigned value. In this case, you can use the variable again without assigning a new value.

FOR Year := 1899 DOWNTO 1801 DO  {Print leap years in 1800's}
   IF ( Year MOD 4 ) = 0 THEN
      WRITELN( Year:4, ' is a leap year' );

FOR I IN Set1 DO  {Set2 members are successors of Set1 members}
    Set2 := Set2 + [I + 1];

For More Information:

The GOTO statement causes an unconditional branch to a statement prefixed by a label. A GOTO statement has the following form:

An unsigned decimal integer or symbolic name that represents a statement label.

FOR I := 1 TO 10 DO
   BEGIN
   IF Real_Array[I] = 0.0 THEN
      BEGIN
      Result := 0.0;
      GOTO 10;       {Use GOTO to exit from loop}
      END;
   Result := Result + 1.0/Real_Array[I];  {Compute sum of inverses}
   END;

10: Invertsum := Result;

For More Information:

The IF statement tests a Boolean expression and performs a specified action if the result of the test is TRUE. The ELSE clause, when it appears, executes only if the test condition results to FALSE. An IF statement has the following form:

Any Boolean expression.

The statement to be executed if the value of the Boolean expression is TRUE.

The statement to be executed if the value of the Boolean expression is FALSE.

IF x > 10 THEN y := 4           IF x > 10 THEN BEGIN y := 4;
          ELSE y := 5;                               z := 5;
                                               END
                                          ELSE y := 5;

IF A = 1 THEN    {First IF}
   IF B<>1 THEN  {Second IF}
      C := 1
ELSE             {Appears to modify first IF}
   C := 0;       {Actually modifies second IF}

VSI Pascal can not always evaluate all the terms of a Boolean expression if it can evaluate the entire expression based on the value of one term. Either do not write code that depends on actual evaluation (or evaluation order) of Boolean expressions, or use the AND_THEN and OR_ELSE operators for a predictable order of evaluation.

For More Information:

Syntactically, a procedure call is a statement. A procedure call has the following form:

The name of a procedure or function.

An expression that is of a type that is compatible with the type of the formal parameter, or the name of a procedure or function.

In VSI Pascal, you can use procedure-call syntax to call a function, even though function calls are usually considered to be expressions. If you do this, the compiler invokes the function but ignores the return value.

For More Information:

On procedures and functions (Chapter 6, Procedures and Functions)

The REPEAT statement is a looping statement and executes one or more statements until a specified condition is true. A REPEAT statement has the following form:

    REPEAT
        {statement};...
    UNTIL expression

Any Pascal statement.

Any Boolean expression.

Pascal always executes a REPEAT statement for one iteration; iterations continue as long as the Boolean expression is FALSE. When specifying more than one statement as the loop body to a REPEAT statement, do not enclose the statements with the BEGIN and END reserved words. Multiple statements are legal in the REPEAT loop body.

REPEAT
   READ( x );     {Attempts to read at least one character}
   IF ( x IN ['0'..'9'] ) THEN
      BEGIN       {Keep count of numbers and increase total}
      Digit_Count := Digit_Count + 1;
      Digit_Sum := Digit_Sum + ORD( x ) - ORD( '0' );
      END
   ELSE
      Char_Count := Char_Count+1;   {Count characters}
UNTIL EOLN(INPUT); {Reads from default device until end of line}

For More Information:

The RETURN statement passes control back to the caller of a PROCEDURE, FUNCTION, PROGRAM, or module initialization or finalization section. A RETURN statement is equivalent to a GOTO to a label placed just before the END of the body, and in a PROGRAM, has the effect of stopping the program. A RETURN statement has the following form:

Inside a FUNCTION, return-value specifies an ending value for the FUNCTION. If no return-value is provided, the last value assigned to the function identifier is used as the function result. The return-value type and function type must be the same.

Inside a PROGRAM, the return-value specifies an ending value for the PROGRAM. If you do not provide a return-value, VSI Pascal uses the value 1.

A function returns a result to its caller. A function can specify its result by assigning a value to the function identifier. This does not cause a return to the caller, and can occur many times per call. When the function finally returns, the last assignment becomes the result of the function. If a function uses the RETURN statement and includes a value, then the function returns immediately and returns the specified value. This value overrides any previous values specified by an assignment.

If a function uses the RETURN statement but does not specify a value, the return value is the last value that the function specified by assignment. If the function has not assigned a value to the function identifier during a given call to the function, VSI Pascal does not define the function result.

FUNCTION FindFirst(StartingPoint: INTEGER) : INTEGER;
               VAR i: INTEGER;
               BEGIN
               FOR i := StartingPoint TO MaximumNumber DO
                 BEGIN
                 IF Data[i] = Suitable THEN
                  BEGIN
                  AttributesOfDesiredData = Attributes[i];
                  Subscript := i;
                  RETURN i;
                  END;
               END;
            END;

For More Information:

The SELECT statement causes zero or more statements to be executed. The SELECTONE statement causes zero or one statement to be executed. Execution depends on the value of an ordinal expression called the select-selector.

A SELECT statement has the following form:

SELECT select-selector OF
[[{{select-label-list},...: statement};...]]
[[ [[OTHERWISE {statement};...]]
[[ALWAYS {statement};...]] ]]
[[;]]
END

where 'select-label-list' is expression [[.. expression]].

The expressions in the 'select-label-list' can be full run-time expressions.

When two expressions are provided as a lower and upper bound, they must be of the same ordinal type. There is no check to ensure that the lower bound expression is less than or equal to the upper bound expression. If that occurs, then there are simply no values of the select-selector that can be in the range.

The SELECT statement checks to see if the value of the select-selector is contained in the select-label-list. If so, then the corresponding statement is executed. The select-label-lists are checked in the same lexical order that they appear in the source file. The same value can appear in more than one select-label-list.

The optional OTHERWISE and ALWAYS clauses can appear in either order. The ALWAYS clause is always executed. The OTHERWISE clause is executed only if none of the prior statements (except for an optional ALWAYS statement) have been executed.

The syntax for the SELECTONE statement is almost identical but does not provide for an ALWAYS clause.

SELECTONE select-selector OF
[[{{select-label-list},...: statement};...]]
[[ OTHERWISE {statement};... ]]
[[;]]
END

Unlike the SELECT statement, the SELECTONE statement stops processing after it executes the first statement that corresponds to a select-label-list that contains the select-selector value.

The SELECT/SELECTONE statements can be used similar to the CASE statement. For example:

SELECT expression OF
 1: WRITELN('ONE');
 2: WRITELN('TWO');
 OTHERWISE WRITELN('not ONE or TWO')
END

However, a more subtle (and powerful) form uses the Boolean constant 'TRUE' as the select-selector. For example:

SELECTONE True OF
 expression < 10: WRITELN('Value is small');
 expression < 100: WRITELN('Value is medium');
 expression < 1000: WRITELN('Value is big');
 OTHERWISE WRITELN('Value is too big');
END

SELECTONE True OF
 expression = "AAA": writeln('String is AAA');
 expression = "BBB": writeln('String is BBB');
 expression = "CCC": writeln('String is CCC');
 OTHERWISE writeln('unknown string');
END

FOR i := 1 TO 10 DO
  SELECT True OF
   ODD(i): WRITELN('value ',i:1,' is odd');
   (i MOD 3) = 0:
           WRITELN('value ',i:1,' is also a multiple of 3');
END;

         WHILE expression DO
            statement

Any Boolean expression.

Any Pascal statement.

Pascal checks the value of the Boolean expression before executing the loop body for the first time; if the expression is FALSE, the loop body is not executed. If the initial value is TRUE, loop iterations continue until the condition is FALSE. When specifying more than one statement as the loop body to a WHILE statement, enclose the statements with the BEGIN and END reserved words, since the syntax calls for a single statement to follow the DO reserved word. If you do not use a compound statement for the loop body, Pascal executes the first statement following the DO reserved word as the loop body.

WHILE NOT EOF( File1 ) DO  {If EOF from the start, the loop}
   READLN( File1 );        {   body is not executed.       }

WHILE NOT EOLN( INPUT ) DO
   BEGIN                 {Use compound statement:}
   READ( x );
   IF NOT ( x IN ['A'..'Z', 'a'..'z', '0'..'9'] )
   THEN
      Err := Err + 1;    {Count odd characters as errors}
   END;

For More Information:

The WITH statement provides an abbreviated notation for references to the fields of a record variable or to the formal discriminants of a discriminated schema type. A WITH statement has the following form:

               {record-variable  }
         WITH {{schema-variable  }},... DO statement

The name of the record variable being referenced.

The name of the variable being referenced whose type is a discriminated schema type. This underlying type of the schema can be a record.

Any Pascal statement.

The WITH statement allows you to refer to the fields of a record or to a formal discriminant of a schema by their names alone, rather than by the record.field-identifier or schema-variable.formal-discriminant syntax. In effect, the WITH statement opens the scope so that references to field identifiers or to formal discriminants alone are unambiguous. When you access a variable or one of its components using a WITH statement, the reference syntax lasts throughout the execution of the statement.

{The record Dog is nested in the record Cat:}
WITH Cat, Dog DO    {Specify Cat before Dog}
   Bills := Bills + Cat_Vet + Dog_Vet;

WITH Cat DO   {This is equivalent to the previous WITH}
     WITH Dog DO
          Bills := Bills + Cat_Vet + Dog_Vet;

VAR
   x : STRING( 10 );
   y : STRING( 15 );

{In the executable section:}
WITH x, y DO
   WRITELN( CAPACITY );       {y.CAPACITY is used}

{The following is equivalent:}
WITH x DO
   WITH y DO
      WRITELN( CAPACITY );

For More Information:

You must declare a routine before you call it. Routine declarations have the following formats:

[[attribute-list]] PROCEDURE routine-identifier [[(formal-parameter-list)]];
    {[[declaration-section]] BEGIN {statement};... END  }
    {{ EXTERN    }                                      }
    {{ EXTERNAL  }                                      }
    {{           }                                      } ;
    {{ FORTRAN   }                                      }
    {{ FORWARD   }                                      }

[[attribute-list]] FUNCTION routine-identifier [[(formal-parameter-list)]]
   : [[attribute-list]] result-type-id;
    {[[declaration-section]] BEGIN {statement};... END  }
    {{ EXTERN    }                                      }
    {{ EXTERNAL  }                                      }
    {{           }                                      } ;
    {{ FORTRAN   }                                      }
    {{ FORWARD   }                                      }
     {                                                   }

One or more identifiers that provide additional information about the type-denoter.

The name of the routine. If you use the routine-identifier within the routine body (with the exception of assigning a value to the routine-identifier of a function), the result is a recursive call to the routine. The routine-identifier of a procedure can be redeclared in the procedure's declaration-section. The routine-identifier of a function cannot be redeclared in the function's declaration-section; however, it can be redeclared in any nested routines within the function's declaration-section.

A comma list of the routine's formal parameters. A procedure can have as many as 255 formal parameters. A function can also have as many as 255 formal parameters unless returning a structured type, in which case a function is limited to 254 formal parameters. Optionally, you can specify a mechanism specifier and an attribute list for each parameter.

A routine declaration section can include all sections except TO BEGIN DO, TO END DO, and VALUE sections. Data specified in this declaration section is local to the routine and to any nested routines; you can redeclare identifiers that are declared in an outer block. You cannot redeclare a formal parameter identifier to be a local variable in the routine.

By default, the system does not retain the values of local variables after it exits from a routine. Each call to a routine creates copies of the local variables. This means you can call a routine recursively without affecting the values held by the local variables at each activation of the routine. To preserve the value of a local variable (not the copy) from one call to the next, you must declare the local variable with the STATIC attribute.

Any Pascal statement. In a function executable section, there must be either a RETURN statement containing a value, or at least one statement of the following form:

The routine-identifier is the name of the function. The result is a value of either an ordinal, real, structured, or pointer type that VSI Pascal returns when the function is called. (This value cannot be a file type or a structured type with a file component.) This value must be of the same type as the result-type-id.

Predeclared identifiers that direct VSI Pascal to find the body of the routine elsewhere. The EXTERN, EXTERNAL, and FORTRAN identifiers declare routines that are independently compiled by VSI Pascal or that are written in other languages. In VSI Pascal, these identifiers are equivalent. Although not part of the Pascal standard, many Pascal compilers only accept the FORTRAN identifier for external routines actually written in FORTRAN; if portability is a concern, you may wish to use FORTRAN only for external FORTRAN routines.

The FORWARD identifier declares a routine whose block is specified in a subsequent part of the same procedure and function section, allowing you to call a routine before you specify its routine body. As an extension, VSI Pascal will allow the body to be in a different declaration part. If the body and heading are specified in different procedure and function sections, a FORWARD declared function should not be used as an actual discriminant to a schema type.

When you specify the body of the routine in subsequent code, include only the FUNCTION or PROCEDURE predeclared identifier, the routine-identifier, and the body of the routine. Do not repeat the formal-parameter, the attribute-list, or the result-type-id.

The type specification of the function return value. The function's result must be of this data type. This type cannot be a file type or a structured type with a file component.

{Function body contained in subsequent code:}
FUNCTION Adder( Op1, Op2, Op3 : REAL ) : REAL; FORWARD;

PROCEDURE Introduction;
VAR
    a, b, c, z : REAL;    {Variables local to the procedure}
BEGIN
WRITELN( 'This is the Inventory Program Version 5.6.' );
WRITELN;
WRITELN( 'Press Ctrl/H for help.  Press Return to continue.' );
a := 4.6;   b := 12.1;   c := 201.45;
z := Adder( a, b, c );    {Call the function Adder}
END;

{System_Routine_Tanh available with the operating system:}
FUNCTION System_Routine_Tanh( Angle : REAL ) : REAL;

EXTERNAL;


FUNCTION Adder;  {Do not repeat attributes or parameters}
BEGIN
Adder := Op1 + Op2 + Op3;   {Assign a function return value}
END;

For More Information:

A routine call executes all statements in the body of the declared routine. You must declare a routine before you can call it. Syntactically, procedure calls are statements, and function calls, which return a single value, are expressions. You can call a function anywhere that an expression of the declared result type is legal. If the result of a function is irrelevant, you can call the function as a statement in the same way that you call a procedure. You can call routines in the executable section of a program or in the body of another routine. Routine calls have the following forms:

                                   [%IMMED    ]
                                   [%REF      ]
         procedure-identifier [[({ [%DESCR    ] actual-parameter},...)]]
                                   [          ]
                                   [%STDESCR  ]

                                  [%IMMED    ]
                                  [%REF      ]
         function-identifier [[({ [%DESCR    ] actual-parameter},...)]]
                                  [          ]
                                  [%STDESCR  ]

The declared routine identifier. The scope of a routine identifier is the block in which it is declared, excluding any nested blocks that redeclare the same identifier.

The actual parameter whose data type matches the type of the corresponding formal parameter. Optionally, you can specify a passing mechanism for each parameter. When a mechanism specifier appears in a call, it overrides the type, semantics, mechanism specified, and even the number of parameters in the formal parameter declaration. Thus, type checking is suspended for the parameter association to which the specifier applies.

VAR
   a, b, c, z : REAL;

PROCEDURE Introduction;
BEGIN
WRITELN( 'This is the Inventory Program Version 5.6.' );
WRITELN;
WRITELN( ' Press Ctrl/H for help.  Press Return to continue.' );
END;

FUNCTION Adder( Op1, Op2, Op3 : REAL ) : REAL;
BEGIN
Adder := Op1 + Op2 + Op3;   {Assign a function return value}
END;

{In the executable section:}
Introduction;    {No parameters necessary in the call}
a := 3.14;      b := 14.78;      c := 112.456;
z := Adder( a, b, c );  {Function used as an expression
                         evaluating to a REAL value}

TYPE
   Player_Rec = RECORD
      Wins       : INTEGER;
      Losses     : INTEGER;
      Percentage : REAL;
      END;
VAR
   Number : INTEGER;

FUNCTION Return_Player_Info( Player_Num : INTEGER ) : Player_Rec;
   {In the function body:}
   Return_Player_Info := Player_Rec[Wins: 3; Losses: 18;
                                    Percentage: 21/3];
{In the executable section:}
WRITELN( Return_Player_Info( Number ).Losses, 'losses is poor!');

For More Information:

In VSI Pascal, there are two types of parameters: formal and actual parameters. A formal parameter (also called an argument) is located in the header of the routine declaration. You cannot redeclare a formal parameter in a routine's declaration section, but you can redeclare it in nested routines within the routine's declaration section.

The formal parameter establishes the semantics, the data type, and the required passing mechanism of the parameter. The general format of the formal parameter list is as follows.

              {value-parameter-spec     }
              {variable-parameter-spec  }
         [[({ {routine-parameter-spec   } };...)]]
              {foreign-parameter-spec   }

The specific format of a formal parameter specification depends on the semantics (value, variable, routine, foreign) of the formal parameter you are declaring (conformant parameters also have a unique syntax).

The actual parameter must be of the same data type and passing mechanism as the corresponding formal parameter. VSI Pascal uses the default passing mechanism for each actual parameter depending on its data type and formal definition. If the called routine is external to VSI Pascal, you can specify an explicit passing mechanism on the actual parameter that overrides the type and number of formal parameters.

For More Information:

                                      {type-identifier              }
{identifier},... : [[attribute-list]] {undiscriminated-schema-name  }
                                      {conformant-parameter-syntax  }
   [[:= [[mechanism-specifier]] default-value]]

VAR
   Old_Number, x, y : INTEGER;
FUNCTION Random( Seed : INTEGER ): INTEGER;
       {Function body...}
PROCEDURE Alpha( a, b : INTEGER; c : CHAR );
       {Procedure body...}

{In the executable section:}
New_Number := Random( Old_Number );
Alpha ( x+y, 11, 'G' );  {Actual parameters are integer
                          and character expressions}

                                          {type-identifier              }
VAR {identifier},... : [[attribute-list]] {undiscriminated-schema-name  }
                                          {conformant-parameter-syntax  }
     [[:= [[mechanism-specifier]] default-value]]

VAR  My_String :

VARYING [20] OF CHAR

PROCEDURE Name( VAR A_String :

VARYING [String_Size] OF CHAR

{Body}

{In the executable section:}
Name( My_String );
WRITELN( 'The new name is ', My_String );

PROCEDURE Apply( FUNCTION Operation( Left, Right : REAL ) : REAL;
                 VAR Result : REAL );

FUNCTION Copy( PROCEDURE Get_Char( VAR c : CHAR );
               PROCEDURE Put_Char( i : CHAR ) ) : BOOLEAN;

VAR
   Costs, Pay, Fedtax, Food : REAL;
   Housing                  : INTEGER;

FUNCTION Income( Salary, Tax : REAL ) : REAL;
   {Function body...}

FUNCTION Expenses( Rent : INTEGER; Grocery : REAL ) : REAL;
   {Function body...}

FUNCTION Budget( FUNCTION Credit( Earnings, UStax : REAL ) : REAL;
  FUNCTION Debit( Housing : INTEGER; Eat : REAL ) : REAL ) : REAL;
   VAR   Deduct : REAL;
   BEGIN {FUNCTION Budget}
   Deduct := Debit(

Eat := Food, Housing := Housing

   Budget := Credit( Pay, Fedtax ) - Deduct;
   END;

{In the executable section:}
Costs := Budget( Income, Expenses );

program math(output);

   procedure a( function f(r:real):real );
     begin
     writeln(f(1.0));
     end;

   begin
   a(sin);
   a(cos);
   end.

p( %IMMED f );    {Address of function f is passed}

p( %IMMED (f) );  {Result of function f is passed}

TYPE
   Array_Template( lbnd, hbnd : INTEGER ) =
      ARRAY[lbnd..hbnd] OF INTEGER;
VAR
   Even_Numbers : Array_Template( 1, 30 );
   Odd_Numbers  : Array_Template( 1, 60 );

PROCEDURE Print_Array( Array_To_Print : Array_Template );
   VAR
      i : INTEGER;
   BEGIN
   WRITELN( 'The maximum number of elements is ',
             Array_To_Print.hbnd );
   WRITELN;
   FOR I := LOWER( Array_To_Print ) TO UPPER( Array_To_Print ) DO
      WRITELN( Array_To_Print[i] );
   END;

{In the executable section:}
Print_Array( Even_Numbers );
Print_Array( Odd_Numbers );

TYPE
   Array_Template( Upper_Bound : INTEGER )
                 = ARRAY[1..Upper_Bound] OF INTEGER;
VAR
   Actual_1, Actual_2 : Array_Template( 10 );
   Actual_3           : Array_Template( 20 );

   PROCEDURE Schema_Proc1( Only_One : Array_Template );
        {Body...}
   PROCEDURE Schema_Proc2( One, Two : Array_Template );
        {Body...}

{In the executable section:}
Schema_Proc1( Actual_1 );             {Legal}
Schema_Proc1( Actual_3 );             {Legal}
Schema_Proc2( Actual_1, Actual_2 );   {Legal}
Schema_Proc2( Actual_1, Actual_3 );   {Illegal}

VAR
   One_String, Two_String : STRING( 15 );
   Three_String           : STRING( 20 );

PROCEDURE Test_Strings( One, Two : STRING );
        {Body...}

{In the executable section:}
Test_Strings( 'a', 'b' );       {Legal}
Test_Strings( 'a', 'bb' );      {Illegal}
One_String := 'Hello';
Two_String := 'Hello there';
Three_String := 'olleH';
Test_Strings( One_String, Two_String );   {Illegal}
Test_Strings( One_String, Three_String ); {Legal}

    ARRAY[{lower-bound-identifier..upper-bound-identifier :
       [[attribute-list]] index-type-identifier};...] OF [[attribute-list]]
        {type-identifier              }
        {conformant-parameter-syntax  }

    PACKED ARRAY[lower-bound-identifier..upper-bound-identifier :
       [[attribute-list]] index-type-identifier] OF [[attribute-list]] type-identifier

PACKED ARRAY[l1..u1: INTEGER; l2..u2: INTEGER] OF CHAR

ARRAY[l1..u1: INTEGER] OF PACKED ARRAY[l2..u2: INTEGER] OF CHAR

TYPE
   Workdays = 1..31;
   Feb_Days = 1..28;
   Mar_Days = 1..31;
VAR
   Feb_Arr              : ARRAY[Feb_Days] OF INTEGER;
   Mar_Arr              : ARRAY[Mar_Days] OF INTEGER;
   Feb_Total, Mar_Total : INTEGER;

FUNCTION Inventory( VAR Amt_Sold :
   ARRAY[First_Day..Last_Day : Workdays] OF INTEGER ) : INTEGER;
{In executable section:}
{Amt_Sold : ARRAY[1..28] OF INTEGER...}
Feb_Total := Inventory( Feb_Arr );

{Amt_Sold : ARRAY[1..31] OF INTEGER...}
Mar_Total := Inventory( Mar_Arr );

VAR
   Short_String : VARYING[40] OF CHAR := PAD( '', '-', 40 );
   Long_String  : VARYING[80] OF CHAR := PAD( '', '-', 80 );

PROCEDURE Dashed_Line( VAR String : VARYING[Len] OF CHAR ); {Body...}

{In the executable section:}
Dashed_Line( Short_String );
Dashed_Line( Long_String );

VAR
   Actual_1, Actual_2 : ARRAY[1..10] OF INTEGER;
   Actual_3           : ARRAY[5..10] OF INTEGER;

PROCEDURE TestArr( One, Two : ARRAY [L1..U1 : INTEGER] OF INTEGER );
          {Procedure body...}
PROCEDURE TestStr( One, Two : PACKED [L2..U2 : INTEGER] OF CHAR );
          {Procedure body...}

{In the executable section:}
TestArr( Actual_1, Actual_2);     {Legal}
TestArr( Actual_2, Actual_3);     {Illegal}
TestStr( 'ABC', 'XYZ' );          {Legal}
TestStr( 'HELLO', 'GOODBYE' );    {Illegal}

PROCEDURE Compute_Sum( x, y : INTEGER; VAR z : INTEGER ); {Body...}

{In the executable section:}
{Positional syntax:}
Compute_Sum( Quantity + 6, 15, Total );

{Nonpositional syntax:}
Compute_Sum(

z := Total, x := Quantity + 6, y := 15


{Both syntaxes:}
Compute_Sum( Quantity + 6,

z := Total, y := 15

FUNCTION Net_Pay( Hours    : INTEGER;
                  Tax      : REAL := 0.05;
                  Rate     : REAL;
                  Fica     : REAL := 0.07;
                  Overtime : INTEGER )  : REAL;  {Body...}
{In the executable section:}
{Nonpositional syntax:}
Take_Home_Year := Take_Home_Year +
                  Net_Pay ( Overtime := Overtime_Week,
                            Rate := Pay_Rate,
                            Hours := Hours_Week );
{Positional syntax:}
Take_Home_Year := Take_Home_Year +
                  Net_Pay( Hours_Week, , Pay_Rate, ,
                           Overtime_Week );

Take_Home_Year:= Take_Home_Year +
   Net_Pay( Hours_Week, 0.06, Pay_Rate, , Overtime_Week );

A block is a declaration section and an executable section. Programs, modules, and routines are structured in blocks. A declaration section can contain routine blocks nested within the outer program or module block; routine blocks can also be nested within other routines.

The declaration section contains data definitions and declarations, and nested routine declarations that are local to the enclosing block. The executable section contains the statements that specify the block's actions. You can cause an exit from a block with the last executable statement of the block, which causes normal termination, or with a GOTO statement, which transfers control to an outer block.

For More Information:

The scope of an identifier is the part of the program in which the identifier has a particular meaning. In Pascal, the scope of an identifier is the block in which it is defined or declared, including nested blocks (but excluding any nested blocks that redeclare the same identifier). Outside its scope and assuming that it is not declared elsewhere, an identifier has no meaning; in this case, attempts to use the identifier generate an error.

Routine names can be redeclared like any other identifier. A block, in its declaration section, can specify routines with the same names as those outside the block. This changes the meaning of function and procedure calls when they occur within the block.

A procedure can redeclare its own identifier. For example, the declaration section of the procedure Sum can declare a different procedure called Sum. The scope of this second declaration is only within the first block; calls to Sum within the block are not recursive but are calls to the locally declared routine.

You can also redeclare a function identifier within its own declaration. However, the function then cannot use the function identifier in an assignment to return a value to the caller. A function that redeclares its own identifier must use the RETURN statement (see Section 5.12, “RETURN Statement”) to specify a return value.

In the declaration section you cannot redeclare an identifier used in the formal parameter list of the routine. However, a block nested in the declaration section can do so. The following example shows the scope of identifiers that appear in several blocks in a program.

For More Information:

A module is a set of instructions that can be compiled, but not executed, by itself. Module blocks contain only a declaration section and TO BEGIN DO and TO END DO sections. A program is a set of instructions that can be compiled and executed by itself. Program blocks contain a declaration and an executable section. A compilation unit is a unit of VSI Pascal code that can be compiled independently; the term compilation unit refers to either a program or a module.

Each module and program must be in a separate file; you cannot place multiple modules (or a module and a program) in the same file. You can compile modules and a program together or separately (the syntax of compilation depends on the operating system you are using).

[[attribute-list]] PROGRAM comp-unit-identifier [[({file-identifier},...)]];
   [[declaration-section]]
   BEGIN
   {statement};...
   END.

[[attribute-list]] MODULE comp-unit-identifier
   [[({file-identifier},...)]];
   [[declaration-section]]
   [[TO BEGIN DO statement;]]
   [[TO END DO statement;]]
   END.

The module syntax of VSI Pascal is slightly different than that of Extended Pascal. However, the concepts in both languages are the same.

One or more identifiers that provide additional information about the compilation unit.

Specifies the name of the program or module. The identifier appears only in the heading and has no other purpose within the compilation unit.

Specifies the names of any file variables associated with the external files used by the compilation unit.

A Pascal declaration section.

A Pascal statement.

The program or module heading includes all information preceding the program or module block. If your program contains any input or output routines, you must list all the external file variables that you are using in the compilation unit's heading. File variables listed in a heading must also be declared locally in the block, except for the predeclared file variables INPUT and OUTPUT. The INPUT identifier corresponds to a predefined external file that accepts input from the default device (usually, your terminal). The OUTPUT identifier corresponds to a predefined external file that sends output to the default device (usually, your terminal). the ERR identifier corresponds If you redeclare INPUT and OUTPUT in a nested block, you lose access to the default input and output devices.

PROGRAM Write_Var(OUTPUT);   {Header}
VAR                          {Declaration section}
   Number : INTEGER VALUE 3;
BEGIN                        {Executable section}
WRITELN( Number );           {Writes 3 to the default device}
END.

For More Information:

When dividing code into programs and modules, you may want to share declarations among compilation units. The following sections discuss ways of sharing data.

{Contained in one file:}
[INHERIT ('file_name')]
PROGRAM a( INPUT, OUTPUT );
BEGIN
READ( Amount );
Calc;
WRITELN( 'Purchase Amount:  ', Amount:10:2)
WRITELN( '              +   ', Tax:10:2)
WRITELN( 'Pay This Total:   ', Total:10:2)
END.

{Contained in a separate file:}
[ENVIRONMENT('file_name')]
MODULE B;        {Keep all global data in one module}
CONST            {Compile this unit first to create file}
   Rate = 0.06;
VAR
   Amount, Total, Tax: REAL;
PROCEDURE Glf; BEGIN...END;
PROCEDURE Calc;
   BEGIN
   Tax := Amount * Rate;
   Total := Tax + Amount;
   Glf;
   END;
END.

{In one compilation unit:}
[ENVIRONMENT('extern.pen')] MODULE Mod1;
[EXTERNAL] PROCEDURE Inst; EXTERN;
END.

{In another compilation unit:}
[INHERIT('extern.pen')] MODULE Mod2;
[GLOBAL] PROCEDURE Inst;  {Body...}
END.

{Contained in one file:}
PROGRAM a( INPUT, OUTPUT );
VAR
   Amount, Total, Tax : [EXTERNAL] REAL;  {Defined elsewhere}
[EXTERNAL] PROCEDURE Calc; EXTERNAL;      {Defined elsewhere}
[GLOBAL]   PROCEDURE Glf; {Body...}       {Available outside}
BEGIN
READ( Amount );
Calc;
WRITELN( 'Purchase Amount:  ', Amount:10:2)
WRITELN( '              +   ', Tax:10:2)
WRITELN( 'Pay This Total:   ', Total:10:2)
END.

{Contained in a separate file:}
MODULE B;
CONST
   Rate = 0.06;
VAR
   Amount, Total, Tax: [GLOBAL] REAL; {Available outside}
[EXTERNAL] PROCEDURE Glf; EXTERNAL;   {Defined elsewhere}
[GLOBAL] PROCEDURE Calc;              {Available outside}
   BEGIN
   Tax := Amount * Rate;
   Total := Tax + Amount;
   Glf;
   END;
END.

The parameter x can be of any arithmetic type.

The type of the expression e must be assignment compatible with that of the variable v. The variable v must be an INTEGER, UNSIGNED, INTEGER64, or UNSIGNED variable and must be allocated on a natural boundary, such as longword for INTEGER and UNSIGNED and quadword for INTEGER64 and UNSIGNED64. The result of ADD_ATOMIC is the same type as the variable v.

Overflow and subrange checking are never performed on the ADD_ATOMIC operation, even if these options are in effect for the rest of the function or compilation unit.

The ADD_ATOMIC function does not provide memory synchronization between multiple processors. The BARRIER predeclared routine must be used for that purpose.

This function is used to access data that is shared between two or more threads of execution.

For More Information

The type of the expression e must be assignment compatible with that of the variable v. The variable v must be an integer or an unsigned subrange; v must have an allocation size of two bytes and must be aligned on a word boundary. The type of e must be assignment compatible with that of v.

Note that unless the type of v is an integer subrange that includes negative values, the result of the ADD_INTERLOCKED function is never -1.

Overflow and subrange checking are never performed on the ADD_INTERLOCKED operation, even if these options are in effect for the rest of the function or compilation unit.

This function is used to access data that is shared between two or more threads of execution.

For More Information

The parameter x can be a variable of any type except a component of a packed structured type. A compile-time warning results if x is a formal VAR parameter, a component of a formal VAR parameter, or a variable that does not have the READONLY or VOLATILE attribute.

A pointer can only refer to a VOLATILE variable or a variable allocated by the NEW procedure.

For More Information:

The type of the expression e must be assignment compatible with that of the variable v. The variable v must be an INTEGER, UNSIGNED, INTEGER64, or UNSIGNED64 variable and must be allocated on a natural boundary, such as longword for INTEGER and UNSIGNED and quadword for INTERGER64 and UNSIGNED64. The result of AND_ATOMIC is the same type as the variable v.

The AND_ATOMIC function does not provide memory synchronization between multiple processors. The BARRIER predeclared routine must be used for that purpose.

This function is used to access data that is shared between two or more threads of execution.

For More Information

The parameter x can be an integer or REAL type.

The parameter-name argument specifies the name of a parameter declared with the LIST attribute. The parameter n specifies a positive integer value that identifies the argument. The first argument in a list is always 1. An error occurs if the value supplied for n is less than 1, or exceeds the ARGUMENT_LIST_LENGTH parameter (which indicates the total number of arguments).

If the LIST parameter is a value parameter, ARGUMENT indicates the corresponding value in the argument list. If the LIST parameter is a VAR parameter, ARGUMENT is a reference to the corresponding variable in the argument list.

Also, you can use the IADDRESS function with the ARGUMENT function to return the address of a selected argument.

For More Information:

The parameter-name argument specifies the name of the parameter declared with the LIST attribute.

PROGRAM Show_Arg( OUTPUT );
                  {Ax corresponds to any number of char. arguments}
PROCEDURE Variable_Write( Fl : VARYING[len] OF CHAR;
                          Ax : [LIST] CHAR );
   VAR
      i : INTEGER;
   BEGIN
   WRITE( Fl, ', ' );
   {For however many arguments there are:}
   FOR i := 1 TO ARGUMENT_LIST_LENGTH( Ax ) DO
      WRITE( ARGUMENT( Ax, i ) );               {Write an argument}
   WRITELN;
   END;
{In the executable section:}
Variable_Write( ' hello', '*' );  {One argument: Writes ' hello, *'}
Variable_Write( ' hello','s','a','i','l','o','r','!' );
                      {Seven arguments: Writes ' hello, sailor!'}

For More Information: