The function calling mechanism is identical with that for subroutines. The only difference
between functions and subroutines is that functions must return data,
whereas subroutines need not.
The following types of routines can be called as functions:
the routine name exists as a label in the program, the current processing
status is saved, so that it is later possible to return to the point
of invocation to resume execution. Control is then passed to the first
label in the program that matches the name. As with a routine called
by the CALL instruction, various other status information (TRACE and
NUMERIC settings and so forth) is saved too. See CALL for
details about this. You can use SIGNAL and CALL together to call an
internal routine whose name is determined at the time of execution;
this is known as a multi-way call (see SIGNAL).
If you are calling an internal routine as a function, you must specify
an expression in any RETURN instruction to return from it. This is
not necessary if it is called as a subroutine.
/* Recursive internal function execution... */
say x'! =' factorial(x)
factorial: procedure /* Calculate factorial by */
arg n /* recursive invocation. */
if n=0 then return 1
return factorial(n-1) * n
FACTORIAL is unusual
in that it calls itself (this is recursive invocation). The PROCEDURE
instruction ensures that a new variable n is created
for each invocation.
Note: When there is a search for a routine,
the language processor currently scans the statements in the REXX
program to locate the internal label. During the search, the language
processor may encounter a syntax error. As a result, a syntax error
may be raised on a statement different from the original line being
- These functions are always available and are defined in the next
section of this manual. (See Built-in functions to X2D (Hexadecimal to Decimal).)
- You can write or use functions that are external to your
program and to the language processor. An external routine can be
written in any language (including REXX) that supports the system-dependent
interfaces the language processor uses to call it. You can call a
REXX program as a function and, in this case, pass more than one argument
string. The ARG or PARSE ARG instructions or the ARG built-in function
can retrieve these argument strings. When called as a function, a
program must return data to the caller. For information about writing
external functions and subroutines and the system dependent interfaces,
see External functions and subroutines, and function packages.
- Calling an external REXX program as a function is similar to calling
an internal routine. The external routine is, however, an implicit
PROCEDURE in that all the caller's variables are always hidden and
the status of internal values (NUMERIC settings and so forth) start
with their defaults (rather than inheriting those of the caller).
- Other REXX programs can be called as functions. You can use either
EXIT or RETURN to leave the called REXX program, and in either case
you must specify an expression.
- With care, you can use the INTERPRET instruction to process a
function with a variable function name. However, you should avoid
this if possible because it reduces the clarity of the program.