There's a difference in the way REXX programs handle parameters when they're called from the command line (e.g. you enter erexxtry in an OS/2 window) and when they're called from another REXX program (e.g. you write myRC = rexxtry() in your REXX program):
In the first case (when called from the command line), the REXX program always retrieves the parameters given on the command line as single string. Thus, the programmer must include code in the REXX program to parse the string into individual parameters. In the second case (when called from within a REXX program), the REXX interpreter itself splits the parameter string into its parts, much as if it has been called by a REXX routine (see also How to use parse arg).
To get around the differences in these behaviors, you can check the "call type", returned by PARSE SOURCE (see also Simple parameter parsing routine). Then, having identified the type of call that was used, your program can branch to code based on the identified call type:
/* simple example code to handle parameters to a REXX program */
/* in a manner equivalent to the handling of parameters for a */
/* REXX routine */
/* */
/* get the call type of this routine */
/* DO NOT turn NOVALUE on at this time! */
parse source . callType .
if callType <> "COMMAND" then
signal Main /* called as function or procedure */
else
do
/* called from the command line */
args = ""
if pos( ",", arg(1)) = 0 then
do
/* no comma found in the parameters -- use blanks */
/* as argument delimiter */
/* split argument in multiple arguments using */
/* blanks as argument separator */
do i = 1 to words( arg(1) )
args = args "'" || word( arg(1),i ) || "'"
args = args ","
end /* do i = 1 to words( arg(1) ) */
end /* if pos( ... */
else
do
/* at least one comma found in the parameters -- */
/* assume commas are used to separate the */
/* parameters */
/* split argument in multiple arguments using */
/* commas as argument separator */
argT = strip( arg(1) )
do while argT <> ""
parse var argT argC "," argT
argC = strip( argC )
args = args || "'" || argC || "'"
args = args ","
end /* while argT <> "" */
end /* else */
drop argT argC
interpret "call Main " || args
if symbol( "RESULT" ) = "VAR" then
do
/* return the return code to the caller */
return result
end /* if symbol( "RESULT" ) = "VAR" then */
else
return
end /* else */
/* main function entry point */
/* Note: Do not use PROCEDURE for this routine */
Main:
say "Main called with " || arg() || " arguments:"
do i = 1 to arg()
say " Argument " || i || " is <" || arg(i) || ">"
end /* do i = 1 to arg() */
return arg(1)