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.