Special Variables

When writing methods, you can use some special variables available in REXX. A special variable is one that may be set automatically during processing of a REXX program. There are five such variables:

RC

is set to the return code from any executed command (including those submitted with the ADDRESS instruction). After the trapping of ERROR or FAILURE conditions, it is also set to the command return code. When the SYNTAX condition is trapped, RC is set to the syntax error number (1-99). RC is unchanged when any other condition is trapped.

Note: Commands executed manually while tracing interactively do not change the value of RC.

RESULT
is set by a RETURN instruction(**) in a subroutine that has been called, or a method that was activated by a message instruction, if the RETURN instruction specifies an expression. If the RETURN instruction has no expression on it then RESULT is dropped (becomes uninitialized).
SELF
is set when a method is activated. Its value is the object that forms the execution context for the method (that is, the receiver object of the activating message).

You can use SELF to:

• Run a method in an object in which a method is already running. For example, a FIND_CLUES method is running in an object called Mystery_Novel. When FIND_CLUES finds a clue, it sends a READ_LAST_PAGE message to Mystery_Novel:

  self~read_last_page
  

  
  
• Pass references about an object to the methods of other objects. For example, a SING method is running in object Song. The code:

  Singer2~duet(self)
  

  would give the DUET method access to the same Song.

SIGL
is set to the line number of the last instruction that caused a transfer of control to a label (that is, any SIGNAL, CALL, internal function call, or trapped condition).
SUPER
is set when a method is activated. Its value is the class object that is the usual starting point for a superclass method lookup for the SELF object. This is the first immediate superclass of the class that defined the method currently running.

The special variable SUPER lets you call a method in the superclass of an object. For example, the following Savings class has INIT methods that the Savings class, Account class, and Object class define.

::class Account

  ::method INIT
    expose balance
    use arg balance
    self~init:super    /* Forwards to the Object INIT method  */

  ::method TYPE
    return "an account"

  ::method name attribute

::class Savings subclass Account

  ::method INIT
    expose interest_rate
    use arg balance, interest_rate
    self~init:super(balance)       /* Forwards to the Account INIT method */

  ::method type
    return "a savings account"

When the INIT method of the Savings class is called, the variable SUPER is set to the Account class object. The instruction:

self~init:super(balance)

calls the INIT method of the Account class rather than recursively calling the INIT method of the Savings class. When the INIT method of the Account class is called, the variable SUPER is assigned to the Object class. Specifying

self~init:super

calls the INIT method the Object class defines.

You can alter these variables, just like any other variable, but REXX continues to set RC, RESULT, and SIGL automatically when appropriate. EXPOSE, PROCEDURE, USE, and DROP instruction also affect these variables in their usual way.

Certain other information is available to a REXX program. This usually includes the name the program was called by and the source of the program (which are available using the PARSE SOURCE instruction.) In addition, PARSE VERSION makes available the language version and date of REXX implementation that is running. The built-in functions ADDRESS, DIGITS, FUZZ, FORM, and TRACE return other settings that affect the execution of a program.

---

[Back: Uninitializing and Deleting Instances Using UNINIT]
[Next: Public, Local, and Built-in Environment Objects]