Routine_Call

 A routine call executes  all  statements  in  the  body  of  the
 declared  routine.   You  must  declare a routine before you can
 call it.  You can call routines in the executable section  of  a
 program or in the body of another routine.

 When the routine finishes executing, control returns to the next
 executable  statement  in  the  calling  block  that follows the
 routine call.


 Syntax:

    routine-identifier [[ ({actual-parameter-list},...) ]]


 The 'routine-identifier' is the name of a procedure or function.

 The 'actual-parameter-list' is one or more run-time  expressions
 of  an appropriate type, or the name of a procedure or function.
 The appropriate type is determined by the  corresponding  formal
 parameter.

 Actual parameters have the following syntax:

     ({ [[mechanism-specifier]] procedure-identifier
        [[mechanism-specifier]] function-identifier
        [[mechanism-specifier]] expression
        type-identifier
        write-list-element },...)


 The 'mechanism-specifier' is any one of the foreign specifiers.

 The  'procedure-identifier'  is  the  name  of   a   predeclared
 procedure.

 The 'function-identifier' is the name of a predeclared function.

 The 'expression' is any compile-time or run-time expression.

 The 'type-identifier' is a predeclared identifier of any type.

 The 'write-list-element' has the format:

    expression[[:expression[[:expression]]]]

 Example:
    Tollbooth (Change, 0.25, Lane[1]);


 This statement calls the procedure 'Tollbooth', and  passes  the
 variable  'Change',  the  real  constant  '0.25',  and the first
 component of the array 'Lane' as actual parameters.

 Example:
    Taxes (Rate*Income, 'Pay');


 This statement calls the procedure 'Taxes', with the  expression
 'Rate*Income'   and   the   string   constant  'Pay'  as  actual
 parameters.