Using Intrinsics

Specifying Intrinsic Files

When compiling a program that references an intrinsic, the compiler reads the intrinsic definition from an intrinsic file. The intrinsic file can be the default intrinsic file for the system, or it can be one that you or another programmer built (see “How to Build or Change an Intrinsic File ”). The program can specify different intrinsic files for different intrinsics.

The SYSINTR compiler option determines the intrinsic file. If the program does not contain a SYSINTR option, or if the SYSINTR option does not specify a file name, the compiler reads intrinsic definitions from the default intrinsic file. (The default intrinsic file is system-dependent. See Appendix A “MPE/iX Dependencies ” for the MPE/iX operating system; Appendix B “HP-UX Dependencies ” for the HP-UX operating system.) Otherwise, the compiler reads intrinsic definitions from the file that the SYSINTR option specifies, until another SYSINTR option specifies another file. (See the HP Pascal/iX Reference Manual or the HP Pascal/HP-UX Reference Manual, depending on your implementation, for more information on the SYSINTR compiler option.)

To list an intrinsic file, use the LISTINTR compiler option (refer to the HP Pascal/iX Reference Manual the HP Pascal/HP-UX Reference Manual, depending on your implementation, for more information on the LISTINTR compiler option).

	NOTE: The compiler options LITERAL_ALIAS and UPPERCASE apply to all external routine names, including intrinsic names. When either of these options is set, the compiler performs a case-sensitive search of the intrinsic file for the intrinsic names.

INTRINSIC Directive

The INTRINSIC directive allows a program to access an intrinsic routine. It follows the routine declaration.

Example

PROGRAM p;
 
VAR
   f,m : shortint;
 
PROCEDURE FSETMODE; INTRINSIC;
 
BEGIN
   FSETMODE(f,m);
END.

The program p can call the intrinsic procedure FSETMODE because it declares it with the INTRINSIC directive.

The system name of an intrinsic is the name by which the operating system recognizes it, the name that it has in the intrinsic file.

The system names of some intrinsics are illegal in HP Pascal. If you want to use such an intrinsic in your program, give it a legal name in your program and specify its system name with the ALIAS compiler option (refer to the HP PascaliX Reference Manual the HP Pascal/HP-UX Reference Manual, depending on your implementation, for more information on ALIAS).

Example

$SYSINTR 'myintr'$  {myintr contains the intrinsic P'F'INFO}
PROGRAM q (output);
 
PROCEDURE pfileinfo $ALIAS 'PFINFO'$; INTRINSIC;
BEGIN
   pfileinfo;
END.

The name P'F'INFO is illegal in HP Pascal because it contains single quotes. The program q can call the intrinsic procedure P'F'INFO by the name pfileinfo because it declares it with the INTRINSIC directive and specifies its system name with the ALIAS compiler option.

Actual and Intrinsic Parameter Compatibility

An intrinsic's actual parameters are those with which your program calls it. Its intrinsic parameters are those in its definition, in the intrinsic file. Its formal parameters are those that your program declares for it.

Formal parameters are optional. If you do not declare them, you can pass the intrinsic actual parameters of types that would otherwise be incompatible. Usually, programmers want this flexibility; therefore, they rarely declare formal parameters.

If you do not declare a formal parameter, its actual parameters are type-checked against their corresponding intrinsic parameters. Type checking depends upon whether the intrinsic parameter is a reference, value, or function or procedure parameter. The following subsections explain these three cases, using these terms:

Using Strings as Actual Parameters

If you use a string variable as an actual value parameter to an intrinsic routine, HP Pascal passes a copy of the data portion only of the string. The length portion is ignored.

If you use a string variable as an actual reference parameter to an intrinsic routine, HP Pascal passes the address of the data portion of the string, and not the string length. If the intrinsic returns data in the string variable, you must determine and update the length of the string when the intrinsic returns control to your program.

There are a number of ways to obtain and update the string length:

• If the intrinsic returns the correct length as a parameter or function return, use the setstrlen procedure with the returned value.

• If the length is defined in documentation of the intrinsic, use the setstrlen procedure with that value.

• If the intrinsic appends some end-of-string character (such as NUL), scan for the character and set the string length with the setstrlen procedure to one less than the character's position.

• If the intrinsic does not provide any length indication, you can use the strrpt function to fill the string with blanks to its full physical length, call the intrinsic, and then use the strrtrim function to get rid of the trailing blanks and update the string length.

Example

This example demonstrates the sequence of filling a string with blanks, calling an intrinsic that returns a value in the string, and updating the string length.

PROGRAM TestIntrin ; VAR Str : string [80] ; PROCEDURE Dateline ; INTRINSIC ; BEGIN { main program } ... Str := strrpt ( ' ' , 80 ) ; { fill string with blanks } Dateline ( Str ) ; { call intrinsic } Str := strrtrim ( Str ) ; { remove trailing blanks } ... END .

Formal and Intrinsic Function Type Compatibility

A function type must be specified when using the intrinsic directive with functions. A formal function type is compatible with an intrinsic function type as long as the size of the formal type matches the size of the intrinsic type.

	NOTE: In general, the formal type and the intrinsic type should match the function return type. If the types do not match, they are the same as a free union type coercion. This can cause problems for signed versus unsigned types.

Example

program m(output);
var a,b:shortint;
    buf:packed array[1..16] of char;
    i:integer;
function calendar:shortint; intrinsic;
function cal_16  $alias 'calendar'$:bit16; intrinsic;
function neg:shortint;
begin
neg:=-1;
end;
begin
a := calendar;
b := calendar;
writeln(a = calendar,' ',a = b);
end.

Assuming the date did not change, the output is unexpected:

FALSE TRUE

Function cal_16 shows the correct definition; a and b should be declared as bit16.

User-Defined Formal Parameters

If you want stricter type checking for an intrinsic's actual parameters, you can declare formal parameters for some or all of its intrinsic parameters. Then, actual parameter types are compared to their corresponding formal parameter types, not to their corresponding intrinsic parameter types. This type checking is as strict as that for the parameter of a nonintrinsic routine: if the actual parameter is a reference parameter, it must be of the same type as the formal parameter; if the actual parameter is a value parameter, it must be assignment-compatible with the formal parameter.

If an intrinsic is defined without an extensible parameter list, you cannot declare it with one.

If an intrinsic is defined with an extensible parameter list, you can declare it with or without one. If you declare the intrinsic with an extensible parameter list, you must declare at least as many nonextensible (required) parameters as the definition does. If you declare the intrinsic without an extensible parameter list, you must declare all of its nonextensible (required) parameters.

Example 1

The intrinsic file defines the intrinsic Pascal procedure intr this way:

PROCEDURE intr (a, b, c, d, e : integer)
               OPTION EXTENSIBLE 2;

The program can declare intr in any of these ways:

PROCEDURE intr (a, b, c, d, e : integer);  {All parameters}
               INTRINSIC;
 
PROCEDURE intr (a, b : integer);  {Required parameters only}
               INTRINSIC;
 
PROCEDURE intr (a, b, c : integer);  {First extensible parameter}
               INTRINSIC;
 
PROCEDURE intr (a, b, c, d : integer);  {Extensible parameters}
               INTRINSIC;

The program cannot declare intr in any of these ways:

PROCEDURE intr (a : integer);  {Without second nonextensible parameter}
          INTRINSIC;
 
PROCEDURE intr (a, b, c, d : integer)  {Fewer required parameters than}
          OPTION EXTENSIBLE 1;         {in the intrinsic definition}
          INTRINSIC;

If you supply default values for the formal parameters that you declare, your default values override those supplied by the intrinsic definition.

Example 2

The intrinsic file defines the intrinsic Pascal procedure intr this way:

PROCEDURE intr (a, b : integer)
               OPTION EXTENSIBLE 2
               DEFAULT_PARMS (a := 10, b := 20);

If the program declares intr this way

PROCEDURE intr (a, b: integer)
               OPTION EXTENSIBLE 2
               DEFAULT_PARMS (a := 35, b := 60);
               INTRINSIC;

Then the default value of a is 35 (not 10) and the default value of b is 60 (not 20).

If you declare a formal parameter, you must give it a type that is compatible with the type of its corresponding intrinsic parameter. Compatibility rules are different for reference and value parameters.

Using Intrinsic Functions as Procedures

Your program must use an intrinsic procedure as a procedure, but it can use an intrinsic function as a function, a procedure, or both.

To use an intrinsic function as a function, declare it as a function in your program, including its result type in the declaration. To use an intrinsic function as a procedure, declare it as a procedure in your program, omitting the result type. To use an intrinsic function as both a function and a procedure, declare it both ways, giving the routine different names in your program. Use the ALIAS compiler option to associate the intrinsic's system name with the names you have given it.

If you declare an intrinsic function as a procedure only, you cannot call it as a function.

Example

The intrinsic file defines the intrinsic Pascal functions f1 and f2 this way:

FUNCTION f1 (i1 : integer) : integer;
 
FUNCTION f2 (i1,i2 : integer) : Boolean;

The Pascal program prog declares the function f1 as a procedure. It cannot call it as a function. It declares the function f2 as a function (which it calls ffunc) and as a procedure (which it calls fproc), using the compiler option ALIAS to associate them with the system name f2. The program cannot call fproc as a function.

PROGRAM prog;
 
VAR
   x : Boolean;
   y,z : integer;
 
PROCEDURE f1 (a : integer) INTRINSIC;
 
FUNCTION $ALIAS 'f2'$ ffunc : Boolean; INTRINSIC;
 
PROCEDURE $ALIAS 'f2'$ fproc; INTRINSIC;
 
BEGIN
   f1(y);
   x := ffunc(y,z);
   fproc(y,z);
   z := f1(y);      {illegal  declared as a procedure}
END.