Release 10.1A: OpenEdge Development:
Progress 4GL Reference

> ## { } Argument reference

> References the value of an argument that a procedure passes to a called external procedure file or to an include file.

> Progress converts each argument to a character format. This conversion removes the surrounding double-quotes if the parameter was specified as a character string constant in the RUN statement or include file reference.

> When one procedure is called from another and arguments are used, Progress recompiles the called procedure, substituting the arguments that the calling procedure passes, and then runs the called procedure.

> #### Syntax

>     { { n | &argument-name } }

> Enter the braces ({}) as shown; they do not represent syntax notation in this description.

> ``n``

> The number of the argument being referred to. If `n` = 0, Progress substitutes the name of the current procedure (the name you used when you called it, not the full pathname) as the argument. If `n` = *, Progress substitutes all arguments that the calling procedure passes (but not the name {0}). If you refer to the `n`th parameter and the calling procedure does not supply it, {`n`} is ignored.

> `&`argument-name``

> The name of the argument being referred to. If you refer to an `argument-name` and the calling procedure does not supply it, Progress ignores {&`argument-name`}.

> If `argument-name` is an asterisk (*), Progress substitutes all arguments that the calling procedure passes. It also adds quotation marks to each parameter, so you can pass the named argument list through multiple levels of include files.

> Note: It is invalid to pass both numbered and named arguments within a single pair of braces. Although this will not cause a compile-time or run-time error, the arguments will not be passed correctly.

> Examples

> The procedure `r-arg.p` runs procedure `r-arg2.p`, passing the arguments customer and name to `r-arg2.p`. Progress substitutes these arguments for {1} and {2} in the `r-arg2.p` procedure:

> r-arg.p
>     RUN r-arg2.p "customer" "name"

> r-arg2.p
>     FOR EACH {1}:
>       DISPLAY {2}.
>     END.

> The `r-inc.p` procedure defines the variables `txt` and `num`, and assigns the values Progress VERSION and 7 to them. The `r-inc.p` procedure includes the `r-inc.i`file and passes the `&int` and `&str` arguments to the include file. Because the parameters are named, their order is unimportant. The called procedure can find each argument, regardless of placement. The `r-inc.i` include file displays a message that consists of the passed arguments. The asterisk argument displays all the parameters as they are listed in the `r-inc.p` procedure:

> r-inc.p
>     DEFINE VARIABLE txt AS CHARACTER.
>     DEFINE VARIABLE num AS INTEGER.

>     txt = "Progress VERSION".
>     num = 7.

>     {r-inc.i &int=num &str=txt}

> r-inc.i
>     MESSAGE {&str}     /* the &str named argument */
>             {&int}.    /* the &int named argument */

>     MESSAGE "An asterisk displays all the arguments:"
>             {*}        /* all the arguments passed by the calling procedure */

> #### Notes

> - If you pass {} arguments using the RUN statement, you cannot precompile the called procedure. When Progress compiles a procedure, it must have all the values the procedure needs. So, if you pass arguments to a procedure you are calling with the RUN statement, Progress evaluates those arguments when the calling procedure is run, not when it is compiled.

> - You can use the name of an include file as an argument to another include file. For example, a reference to {{1}} in an included procedure causes Progress to include the statements from the file with the name that passed as the first argument.

> - Use DEFINE PARAMETER to define a run-time parameter in a called subprocedure. Each parameter requires its own DEFINE statement. The parameters must be specified in the RUN statement in the same order as defined with DEFINE statements.

> - Progress disregards an empty pair of braces ({}).

> - The maximum length of the arguments you can pass to an include file is determined by the Input Characters (-inp) startup parameter.

> - An argument `argument-name` behaves like a scoped preprocessor name. Thus, if you define a preprocessor name, `argument-name`, its value replaces the value of any argument `argument-name` passed to the same file at the point where the preprocessor name, `argument-name`, is defined.

> #### See also

> ; Special character, { } Include file reference, { } Preprocessor name reference, COMPILE statement, DEFINE PARAMETER statement, RUN statement

Copyright © 2005 Progress Software Corporation www.progress.com Voice: (781) 280-4000 Fax: (781) 280-4095