Calls a procedure  which  is  part  of  the  user  program.   The
     debugger displays the return value of the procedure.

     One common  use  of  CALL  is  to  invoke  procedures  that  dump
     debugging information.

 Format:

     CALL routine-name [ (argument [,argument,...]) ]

 Example:

     DBG> CALL DUMP(X)

Additional information available:

ParametersQualifiers

 routine-name

     Specifies the name or the virtual address of the procedure to  be
     called.

 argument(s)

     One or more arguments required by the procedure.  These arguments
     can  be  passed  by  value,  by  reference, by descriptor, or "by
     address" (see the four subtopics for more detail).

     Note - the debugger does not know about all the parameter-passing
     mechanisms   for  all  languages.   You  therefore  may  need  to
     explicitly tell it how to pass  parameters  (for  example,  "CALL
     FOO(%VAL  X)"  instead  of just "CALL FOO(X)") in order to obtain
     correct results.  Also, subroutines  may  not  always  be  called
     correctly  if  you  are  passing  complicated  parameters such as
     arrays or records, so you should use the CALL  command  in  these
     situations  with  some  discretion.   We  hope  to  address these
     problems in a future release of DEBUG.

Additional information available:

%ADDR%DESCR%REF%VAL

 CALL SUB ( %ADDR address-expression)

     This is the default.  The debugger  obtains  the  result  of  the
     address  expression  and passes that address into the subroutine.
     For simple variables such as X, CALL SUB  (%ADDR  X)  corresponds
     exactly  to  how FORTRAN implements SUB(X).  That is, the address
     of X is passed into the subroutine SUB.  So for named  variables,
     this  corresponds  to  call  by  reference in FORTRAN.  For other
     expressions, %REF is the way to achieve call by reference.

 CALL SUB ( %DESCR lang-expression)

     The debugger evaluates  the  language  expression  and  builds  a
     VAX-standard descriptor to describe the value.  The descriptor is
     passed to the subroutine.  This is how you would pass strings  to
     FORTRAN subroutines.

 CALL SUB ( %REF lang-expression)       !  Call by reference

     The debugger evaluates the expression and passes a pointer to the
     value  into  the  called  routine.   This  corresponds to the way
     FORTRAN passes the result of expressions.  For example,  on  CALL
     SUB  (%REF  1)  a  pointer  to  a memory location containing 1 is
     passed into the subroutine.

 CALL SUB ( %VAL lang-expression)       !  Call by value

     The debugger evaluates the language  expression  and  passes  the
     value directly into the called routine.

     You can specify whether you want ASTs enabled  during  the  call.
     If you do not specify /AST or /NOAST, then the AST enable flag is
     unchanged; that is, ASTs will be enabled in the called subroutine
     if and only if they are enabled at the time of the call.

 /AST - ASTs are enabled (can be delivered) during execution  of  your
     called subroutine.

 /NOAST - ASTs are disabled (cannot be delivered) during execution  of
     your called subroutine.