Passing information with variables

When a program and its internal subroutine or function share the same variables, the value of a variable is what was last assigned. This is regardless of whether the assignment was in the main part of the program or in the subroutine or function.

The following example shows passing information to a subroutine. The variables number1 , number2 , and answer are shared. The value of answer is assigned in the subroutine and used in the main part of the program.
Figure 1. Example of Passing Information in a Variable Using a Subroutine
/******************************* REXX
********************************/
/* This
program
receives a calculated value from an internal */
/* subroutine and uses that value in a SAY instruction. */
/*********************************************************************/

number1 = 5
number2 = 10
CALL subroutine
SAY answer /* Produces 15 */
EXIT

subroutine:
answer = number1 + number2
RETURN
The next example is the same, except it passes information to a function rather than a subroutine. The subroutine includes the variable answer on the RETURN instruction. The language processor replaces the function call with the value in answer.
Figure 2. Example of Passing Information in a Variable Using a Function
/******************************* REXX
********************************/
/* This
program
receives a calculated value from an internal */
/* function and uses SAY to produce that value. */
/*********************************************************************/

number1 = 5
number2 = 10
SAY add() /* Produces 15 */
SAY answer /* Also produces 15 */
EXIT

add:
answer = number1 + number2
RETURN answer
Using the same variables in a program and its internal subroutine or function can sometimes create problems. In the next example, the main part of the program and the subroutine use the same control variable, i , for their DO loops. As a result, the DO loop runs only once in the main program because the subroutine returns to the main program with i = 6.
Figure 3. Example of a Problem Caused by Passing Information in a Variable Using a Subroutine
/******************************* REXX
********************************/
/* NOTE: This
program
contains an error. */
/* It uses a DO loop to call an internal subroutine, and the */
/* subroutine uses a DO loop with the same control variable as the
*/
/* main
program
. The DO loop in the main
program
runs only once. */
/*********************************************************************/

number1 = 5
number2 = 10
DO i = 1 TO 5
CALL subroutine
SAY answer /* Produces 105 */
END
EXIT

subroutine:
DO i = 1 TO 5
answer = number1 + number2
number1 = number2
number2 = answer
END
RETURN
The next example is the same, except it passes information using a function instead of a subroutine.
Figure 4. Example of a Problem Caused by Passing Information in a Variable Using a Function
/******************************* REXX
********************************/
/* NOTE: This
program
contains an error. */
/* It uses a DO loop to call an internal function, and the */
/* function uses a DO loop with the same control variable as the */
/* main
program
. The DO loop in the main
program
runs only once. */
/*********************************************************************/

number1 = 5
number2 = 10
DO i = 1 TO 5
SAY add() /* Produces 105 */
END
EXIT

add:
DO i = 1 TO 5
answer = number1 + number2
number1 = number2
number2 = answer
END
RETURN answer
To avoid this kind of problem in an internal subroutine or function, you can use:
  • The PROCEDURE instruction, as the next topic describes.
  • Different variable names in a subroutine or function than in the main part of the program . For a subroutine, you can pass arguments on the CALL instruction; section Passing information with arguments describes this.

Protecting variables with the PROCEDURE instruction

When you use the PROCEDURE instruction immediately after the subroutine or function label, all variables in the subroutine or function become local to the subroutine or function; they are shielded from the main part of the program . You can also use the PROCEDURE EXPOSE instruction to protect all but a few specified variables.

The following examples show how results differ when a subroutine or function uses or does not use PROCEDURE.
Figure 5. Example of Subroutine Using the PROCEDURE Instruction
/******************************* REXX
********************************/
/* This
program
uses a PROCEDURE instruction to protect the */
/* variables within its subroutine. */
/*********************************************************************/
number1 = 10
CALL subroutine
SAY number1 number2 /* Produces 10 NUMBER2 */
EXIT

subroutine: PROCEDURE
number1 = 7
number2 = 5
RETURN
Figure 6. Example of Subroutine without the PROCEDURE Instruction
/******************************* REXX
********************************/
/* This
program
does not use a PROCEDURE instruction to protect the */
/* variables within its subroutine. */
/*********************************************************************/
number1 = 10
CALL subroutine
SAY number1 number2 /* Produces 7 5 */
EXIT

subroutine:
number1 = 7
number2 = 5
RETURN
The next two examples are the same, except they use functions rather than subroutines.
Figure 7. Example of Function Using the PROCEDURE Instruction
/******************************* REXX
********************************/
/* This
program
uses a PROCEDURE instruction to protect the */
/* variables within its function. */
/*********************************************************************/
number1 = 10
SAY pass() number2 /* Produces 7 NUMBER2 */
EXIT

pass: PROCEDURE
number1 = 7
number2 = 5
RETURN number1
Figure 8. Example of Function without the PROCEDURE Instruction
/******************************* REXX
********************************/
/* This
program
does not use a PROCEDURE instruction to protect the */
/* variables within its function. */
/*********************************************************************/
number1 = 10
SAY pass() number2 /* Produces 7 5 */
EXIT

pass:
number1 = 7
number2 = 5
RETURN number1
The next two examples are the same, except they use functions rather than subroutines.
Figure 9. Example of Function Using the PROCEDURE Instruction
/******************************* REXX
********************************/
/* This
program
uses a PROCEDURE instruction to protect the */
/* variables within its function. */
/*********************************************************************/
number1 = 10
SAY pass() number2 /* Produces 7 NUMBER2 */
EXIT

pass: PROCEDURE
number1 = 7
number2 = 5
RETURN number1
Figure 10. Example of Function without the PROCEDURE Instruction
/******************************* REXX
********************************/
/* This
program
does not use a PROCEDURE instruction to protect the */
/* variables within its function. */
/*********************************************************************/
number1 = 10
SAY pass() number2 /* Produces 7 5 */
EXIT

pass:
number1 = 7
number2 = 5
RETURN number1
The next two examples are the same, except they use functions rather than subroutines.
Figure 11. Example of Function Using the PROCEDURE Instruction
/******************************* REXX
********************************/
/* This
program
uses a PROCEDURE instruction to protect the */
/* variables within its function. */
/*********************************************************************/
number1 = 10
SAY pass() number2 /* Produces 7 NUMBER2 */
EXIT

pass: PROCEDURE
number1 = 7
number2 = 5
RETURN number1
Figure 12. Example of Function without the PROCEDURE Instruction
/******************************* REXX
********************************/
/* This
program
does not use a PROCEDURE instruction to protect the */
/* variables within its function. */
/*********************************************************************/
number1 = 10
SAY pass() number2 /* Produces 7 5 */
EXIT

pass:
number1 = 7
number2 = 5
RETURN number1
The next two examples are the same, except they use functions rather than subroutines.
Figure 13. Example of Function Using the PROCEDURE Instruction
/******************************* REXX
********************************/
/* This
program
uses a PROCEDURE instruction to protect the */
/* variables within its function. */
/*********************************************************************/
number1 = 10
SAY pass() number2 /* Produces 7 NUMBER2 */
EXIT

pass: PROCEDURE
number1 = 7
number2 = 5
RETURN number1
Figure 14. Example of Function without the PROCEDURE Instruction
/******************************* REXX
********************************/
/* This
program
does not use a PROCEDURE instruction to protect the */
/* variables within its function. */
/*********************************************************************/
number1 = 10
SAY pass() number2 /* Produces 7 5 */
EXIT

pass:
number1 = 7
number2 = 5
RETURN number1

Exposing variables with PROCEDURE EXPOSE

To protect all but specific variables, use the EXPOSE option with the PROCEDURE instruction, followed by the variables that are to remain exposed to the subroutine or function.

The next example uses PROCEDURE EXPOSE in a subroutine.
Figure 15. Example Using PROCEDURE EXPOSE in Subroutine
/******************************* REXX
********************************/
/* This
program
uses a PROCEDURE instruction with the EXPOSE option */
/* to expose one variable, number1, in its subroutine. The other */
/* variable, number2, is set to null and the SAY instruction */
/* produces this name in uppercase. */
/*********************************************************************/
number1 = 10
CALL subroutine
SAY number1 number2 /* produces 7 NUMBER2 */
EXIT

subroutine: PROCEDURE EXPOSE number1
number1 = 7
number2 = 5
RETURN
The next example is the same except PROCEDURE EXPOSE is in a function instead of a subroutine.
Figure 16. Example Using PROCEDURE EXPOSE in a Function
/******************************* REXX
********************************/
/* This
program
uses a PROCEDURE instruction with the EXPOSE option */
/* to expose one variable, number1, in its function. */
/*********************************************************************/
number1 = 10
SAY pass() number1 /* Produces 5 7 */
EXIT

pass: PROCEDURE EXPOSE number1
number1 = 7
number2 = 5
RETURN number2

For more information about the PROCEDURE instruction, see PROCEDURE.



passvar.html | Timestamp icon Last updated: Monday, 5 June 2017