MAINSAIL Language Manual, Chapter 8

MAINSAIL Language Manual, Chapter 8

previous next top complete contents complete index framed top this page unframed

8. `PROCEDURE` Variables

A PROCEDURE variable (or $PROCVAR) is a data type for representing an invokable PROCEDURE. At runtime, a $PROCVAR can reference different PROCEDUREs at different times, and can invoke the PROCEDURE that it currently references. That is, a $PROCVAR can be used to invoke a PROCEDURE whose identity is unknown at compiletime. All PROCEDUREs that can be referenced by a particular $PROCVAR have the same characteristics (result type, parameter types, and parameter qualifiers), which are specified in the $PROCVAR's declaration.

A $PROCVAR is implemented as two components: a POINTER to a data section and a component that represents the PROCEDURE to be called in the control section corresponding to the data section. The exact layout of the components of a $PROCVAR is not documented because it is subject to change in future releases of MAINSAIL.

8.1. Declaration

A $PROCVAR p is declared as follows:

$PROCVAR(modelProc) p;

where modelProc (p's model PROCEDURE) is one of the following:

The name of an already-declared local or FORWARD PROCEDURE;
c.f, where c is a CLASS name and f is a PROCEDURE field of c;
m.f, where m is a MODULE name and f is a PROCEDURE field of m; or
f, as an abbreviation for m.f, if f uniquely determines m (i.e., only one MODULE has been declared with an interface PROCEDURE f).

The PROCEDUREs that p can reference have the same result and parameters as modelProc. If no appropriate declaration is available for modelProc, a FORWARD declaration may be provided just to serve as a model PROCEDURE (note that a body need not be provided for a FORWARD PROCEDURE if it is not called). For convenience, the macro $MODEL is defined as a synonym for FORWARD; it clarifies to the human reader that a PROCEDURE declaration will be used just as a model PROCEDURE.

The form $PROCVAR() p or $PROCVAR p declares an unmodeled $PROCVAR in which the characteristics of the PROCEDUREs that p can reference are not constrained; otherwise a $PROCVAR is modeled. p:modelProc (where modelProc is as described above) may be used to indicate explicitly the model PROCEDURE for an unmodeled $PROCVAR p. An unmodeled $PROCVAR p can be used in a call only in the form p:modelProc, since otherwise the compiler does not know the characteristics of the result and parameters. Unmodeled $PROCVARs should seldom be needed. p:modelProc is unsafe since the compiler does not currently check that the characteristics of p are really as described by modelProc (except on a SUPERCHECK platform; see Chapter 18).

Examples of $PROCVAR declarations:

$MODEL INTEGER PROCEDURE foo (REAL x);$PROCVAR(foo) ARRAY(0 TO 10) ary;$PROCVAR(foo) PROCEDURE (INTEGER i) proc;

Any variable, field, ARRAY, or PROCEDURE can be of type $PROCVAR.

A $PROCVAR can be a parameter. An OPTIONAL $PROCVAR parameter cannot be declared with an explicit default; i.e., OPTIONAL(v) is not allowed.

INIT is not allowed for a dynamic ARRAY of $PROCVARs.

8.2. Zero

$NULLPROCVAR is the Zero $PROCVAR; its components are Zero. All $PROCVARs (even local variables) are initialized to $NULLPROCVAR.

8.3. Assignment Compatibility

Two $PROCVARs pv1 and pv2 are assignment compatible, and the assignment:

pv1 := pv2

is legal, if either pv1 or pv2 is unmodeled or if they are both modeled and the model PROCEDUREs are compatible, which requires that all the following conditions be satisfied:

Either:
- Both $PROCVARs denote untyped PROCEDUREs.
- Both $PROCVARs denote typed PROCEDUREs where an expression of pv2's result type could legally be assigned to a variable of pv1's result type if STRICTCLASSES were in effect (see Section 4.42 of the MAINSAIL Compiler User's Guide for a discussion of STRICTCLASSES).
The $PROCVARs denote PROCEDUREs with the same number of parameters.
Let p_i be the ith parameter for pv1's PROCEDURE and q_i be the ith parameter for pv2's PROCEDURE. For each pair of corresponding parameters p_i and q_i:
- p_i and q_i are either both USES parameters, both $REFERENCE parameters, both MODIFIES parameters, or both PRODUCES parameters. One parameter can be OPTIONAL or REPEATABLE even if the other parameter is not.
- It would legal to pass an operand of p_i's type as an argument for q_i in a call to pv2's PROCEDURE if STRICTCLASSES were in effect.

A $PROCVAR pv2 passed to a MODIFIES $PROCVAR pv1 must be assignment compatible for both pv1 := pv2 and pv2 := pv1.

A $PROCVAR that has somehow been initialized so it does not reference a PROCEDURE compatible with its declaration results in undefined behavior when it is invoked.

8.3.1. Safe and Unsafe Assignment of `$PROCVAR`s

Assignments involving $PROCVARs can either be safe or unsafe, similar to the way that assignments involving POINTERs, ADDRESSes, or ARRAYs can be safe or unsafe. A legal assignment of $PROCVAR pv2 to $PROCVAR pv1 is safe if any of the following conditions is satisfied:

pv1 is unmodeled.
pv2 is $NULLPROCVAR.
Both $PROCVARs are modeled and all of the following conditions are satisfied:
- Either:
  - Both $PROCVARs denote untyped PROCEDUREs.
  - Both $PROCVARs denote typed PROCEDUREs where an expression of pv2's result type could safely be assigned to a variable of pv1's result type.
- Let p_i be the ith parameter for pv1's PROCEDURE and q_i be the ith parameter for pv2's PROCEDURE. For each pair of corresponding parameters p_i and q_i:
  - If p_i and q_i are both USES parameters or both MODIFIES parameters, then it would be safe to assign an expression of p_i's type to a variable of q_i's type.
  - If p_i and q_i are both MODIFIES parameters or both PRODUCES parameters, then it would be safe to assign an expression of q_i's type to a variable of p_i's type. If p_i and q_i are both $REFERENCE parameters, then p_i and q_i are any combination of parameters that would be legal except if p_i is an untyped $REFERENCE parameter and q_i is not; this combination is unsafe.

The notion of safe assignments involving $PROCVARs is used in determining the legality and the type of the result of an IF expression whose result expressions are $PROCVARs, as discussed in Section 4.5.

8.3.2. Examples of Safe and Legal `$PROCVAR` Assignments

Given the following declarations:

CLASS c (INTEGER i);CLASS(c) d (STRING s);$MODEL POINTER(c) PROCEDURE returnC;$MODEL POINTER(d) PROCEDURE returnD;$MODEL POINTER PROCEDURE returnUnclassified;$MODEL PROCEDURE cParm (POINTER(c) p);$MODEL PROCEDURE dParm (POINTER(d) p);$MODEL PROCEDURE uParm (POINTER p);$MODEL PROCEDURE cProdParm (PRODUCES POINTER(c) p);$MODEL PROCEDURE dProdParm (PRODUCES POINTER(d) p);$MODEL PROCEDURE uProdParm (PRODUCES POINTER p);$MODEL PROCEDURE cRefParm ($REFERENCE $RECORD(c) p);$MODEL PROCEDURE dRefParm ($REFERENCE $RECORD(d) p);$MODEL PROCEDURE untypedRefParm ($REFERENCE p);POINTER(c) pc;POINTER(d) pd;POINTER up;$PROCVAR unm;$PROCVAR(returnC) prc;$PROCVAR(returnD) prd;$PROCVAR(returnUnclassified) pru;$PROCVAR(cParm) pcp;$PROCVAR(dParm) pdp;$PROCVAR(uParm) pup;$PROCVAR(cProdParm) cpp;$PROCVAR(dProdParm) dpp;$PROCVAR(uProdParm) upp;$PROCVAR(cRefParm) crp;$PROCVAR(dRefParm) drp;$PROCVAR(untypedRefParm) urp;

the rules above imply the legality and safety of assignments as shown below:

unm := prc; # Legal and safeprc := unm; # Legal but not safe # (not caught by STRICTCLASSES)pc := pd; # Legalpc := up; # Legal but not safe # (but not caught by STRICTCLASSES)pd := pc; # Legal but not safe # (caught by STRICTCLASSES)pd := up; # Legal but not safe # (but not caught by STRICTCLASSES)up := pc; # Legalup := pd; # Legalprc := prd; # Legal; any PROCEDURE that returns a d POINTER # also returns a c POINTERprc := pru; # Legalprd := prc; # ILLEGAL -- returning a c doesn't necessarily # mean returning a dprd := pru; # Legalpru := prc; # Legal but not safe # (not caught by STRICTCLASSES)pru := prd; # Legal but not safe # (not caught by STRICTCLASSES)pcp := pdp; # ILLEGAL -- you can pass any POINTER to c to pcp, # but pdp's PROCEDURE would require a pdp POINTERpcp := pup; # Legalpdp := pcp; # Legal. You can only pass POINTER(d) to pdp, # which necessarily means you are passing # POINTER(c)pdp := pup; # Legalpup := pcp; # Legal but not safe # (not caught by STRICTCLASSES)pup := pdp; # Legal but not safe # (not caught by STRICTCLASSES)cpp := dpp; # Legal. You can pass a POINTER(c) to cpp, and # any POINTER(d) is also a POINTER(c)cpp := upp; # Legal but not safe # (not caught by STRICTCLASSES)dpp := cpp; # ILLEGAL -- runs risk of assigning a POINTER(c) # that is not really a POINTER(d) to a POINTER(d)dpp := upp; # Legal but not safe # (not caught by STRICTCLASSES)upp := cpp; # Legalupp := dpp; # Legalcrp := drp; # ILLEGAL -- not every $RECORD(c) $REFERENCE can be # a $RECORD(d) $REFERENCEcrp := urp; # Legaldrp := crp; # Legaldrp := urp; # Legalurp := crp; # Legal but not safe # (but not caught by STRICTCLASSES)urp := drp; # Legal but not safe # (but not caught by STRICTCLASSES)

8.4. Operations

A $PROCVAR can be an operand of OR, AND, NOT, =, NEQ, and :=. Two $PROCVARs are considered equal if and only if they represent the same PROCEDURE in the same data section.

A $PROCVAR can be assigned or passed only to an assignment-compatible $PROCVAR.

A $PROCVAR p is used to invoke the PROCEDURE it references by following it with a (possibly empty) argument list: p(...). The argument parentheses are required even if there are no arguments; in the absence of argument parentheses, a $PROCVAR is treated as a variable rather than an invocation. An attempt to use a Zero $PROCVAR in a call results in a NULLPOINTER access if checking is in effect; otherwise, the effect is undefined.

If p is a $PROCVAR:

$typeOf(p) is $procvarCode, a predefined INTEGER constant.
{$l}size($procvarCode) is a {LONG} INTEGER constant for the size of a $PROCVAR.
$dataSecPart(p) returns the data section for the PROCEDURE p references.
$procvarName(p) returns a STRING representation of p.
If a is an ADDRESS, read(a,p), write(a,p), p := $pvLoad(a), and store(a,p) are all supported.

8.4.1. `$PROCVAR`-Valued `PROCEDURE`s

Invoking a PROCEDURE returned by a $PROCVAR-valued PROCEDURE may require extra parentheses; e.g.:

$MODEL PROCEDURE foo (INTEGER i);$PROCVAR(foo) PROCEDURE p;body...p(0); # syntax error

The compiler reports a syntax error for p(0) because the parameterless PROCEDURE p has apparently been given an argument; to invoke p, then invoke the result with argument 0, use (p)(0) or p()(0).

8.5. `$PROC`

$PROC(localProc) is a $PROCVAR(localProc) that references the local PROCEDURE localProc in the current data section. The compiler ensures that a body for localProc is compiled into the current MODULE so that a $PROCVAR can reference it.

If m is a MODULE with a PROCEDURE field f, $PROC({m.}f) is a $PROCVAR({m.}f) that references the PROCEDURE that would be invoked by {m.}f. m is automatically bound if necessary to obtain a POINTER to the bound data section.

If p is a POINTER(c) and f is a PROCEDURE field of c, $PROC(p.f) is a $PROCVAR(c.f) that references the PROCEDURE that would be invoked by p.f.

A MAINSAIL system PROCEDURE must not be used as an argument to $PROC, or as a modelProc, since what appears to be a PROCEDURE might actually be a variable, macro, or GENERIC PROCEDURE. Even if a given system identifier is a PROCEDURE in the current release, XIDAK reserves the right in future releases to change it to a variable, macro, or GENERIC PROCEDURE, or to add undocumented OPTIONAL parameters (provided that its invocation syntax does not change).

8.6. Initialization

A $PROCVAR pv can be initialized (e.g., by assignment or argument passing) as illustrated by the following assignments:

pv := $NULLPROCVAR; # pv references no PROCEDUREpv := x; # x is a $PROCVARpv := y(...); # y is a PROCEDURE or $PROCVAR that returns # a $PROCVARpv := $PROC(p); # p is a PROCEDURE, which pv now references

8.7. `$newProcvar`

$newProcvar is a PROCEDURE that creates an unmodeled $PROCVAR given a data section and a PROCEDURE name. This PROCEDURE should be used only when $PROC cannot be used. It is unsafe since it allows the formation of a $PROCVAR that references a PROCEDURE of unknown characteristics.

8.8. `$PROCVAR` Example

Example use of $PROCVARs:

INTEGER PROCEDURE strCompare (STRING s1,s2); ...PROCEDURE sortStrings (STRING ARRAY(1 TO *) ary; OPTIONAL $PROCVAR(strCompare) cmpProc);BEGININTEGER i,j;IF NOT cmpProc THEN cmpProc := $PROC(strCompare); # default. . .CASE cmpProc(ary[i],ary[j]) OFB . . .END;INTEGER PROCEDURE alternateStrCompare (STRING s1,s2); ...sortStrings(ary); # Uses strCompare to compare stringssortStrings(ary,$PROC(alternateStrCompare)); # Uses alternateStrCompare instead