Professional Documents
Culture Documents
Distinguishing itself by its speed of development and ease of operation, REXX has
become the standard procedural language, and was designed with the following concepts
in mind:
REXX is a tool for use in the real world. It is designed for general use by you and your
associates. Features that yield unpredictable results when misused have not been put in
this language.
A reasonable level of consistency has been designed into the syntax of this language so
that usability is increased and the susceptibility of human error decreased.
There are no absolute data addresses. Instructions are only affected by what has already
happened in the program and not what code lies hundreds of lines above or below. This
makes a program easier to follow since there may be cases where massive printouts are
not accessible.
Because of dynamic scoping there is no GOTO instruction because labels do not have
fixed addresses within a routine.
Concatenation (placing characters next to each other) has special ease with REXX via the
blank operator that concatenates strings with a space character in between. For instance:
displays this:
25% OF CAPACITY
A blank causes continuation for the SAY, not the termination of it.
The fewer keywords to be memorized the better, making REXX one of the easiest
languages to learn.
Documentation is shorter and clearer with a smaller language.
Data has meaning that is totally dependent on how it is used. A variable can be used for
holding either character or numeric data at any time. Since all data is kept as character
strings anyway, REXX converts a numeric string to a number if it needs to.
© SecureAgent Software, Tulsa OK USA. All rights reserved.
No Defined Size or Shape Limits
REXX does not force maximum limits on the size or shape of tokens or data (though
operating system implementation limits may exist).
Only LABELS need be explicitly declared. All local variables can be declared upon use.
If you want to declare, initialize, and document your variables at the beginning of your
program, you are perfectly free to do so if you think it helps you write a better program.
If you intend to use global variables, then you should declare and document them.
A person must be able to read the program almost as if it were written in plain English.
The tokens can be created in such a manner as to be both easily unique and adequately
descriptive. The program is to be easy to read, follow, and (therefore) debug.
Binding between line ends and code is relaxed enough to allow flexibility in coding so
that several clauses can be written on one line or spread between several lines to allow
heavy commenting.
For example:
IF grass_length >= 6
/* see if grass is 6 or more inches high */
THEN
/* do this if grass is that high */
Note the use of the NOP instruction above. This instruction literally does nothing except
exist as a legitimate command. Its use is to provide something to be done after the THEN
OR ELSE sub-keywords especially when several nested IF instructions exist.
The clause is the basic syntactic unit in REXX. It is terminated by a semicolon. Several
clauses may be on the same line as long as they are separated by semicolons. A
semicolon is not necessary at the end of a line.
The short size of the syntactic units allows for easier diagnostics.
All programs are constructed from a series of one or more clauses. Each one is made up
of zero or more leading spaces; a sequence of tokens (as described below); an optional
number of trailing spaces; and the semicolon ( ; ) delimiter. The semicolon may be
implied by some keywords, a colon, or just by end-of-line. Leading spaces and those
prior to a delimiter are ignored by REXX.
SUM = 2 + 3 ;
Comments
Implied Semicolons and Continuation Characters
Literal Strings
Numbers
Operators
Special Characters
Symbols
© SecureAgent Software, Tulsa OK USA. All rights reserved.
Comments
Start with " /* " and end with " */ ". They can be put anywhere in a program, be nested,
and of any length. Comments will act as separators between other tokens.
A semicolon (;) is assumed to terminate each line unless the line is within a comment or
the final (non-comment) token was a comma (,) which is treated as a continuation
character. Otherwise, a semicolon may be used to separate clauses on one line.
/* in the instruction below, the only implied semicolon is after the last variable name
because of the comma continuation characters */
A string of any characters delimited by apostrophes(') or quotation marks ("). For use of
either delimiter within a literal string, the other delimiter must be used. Two delimiters
with nothing between is called a null string.
Numbers are one or more characters representing decimal (0-9) values which may be
optionally preceded by a plus or minus sign.
/* examples of numbers */
123
-456
'789'
+002468
The characters * / + - % | & \ < > = are used alone or in combination as arithmetic,
logical (Boolean) and comparative operators.
* Multiply
/ Divide
+ Add
- Subtract
% Integer Divide
// Remainder
| Boolean OR (if either True, returns 1)
& Boolean AND (if both True, returns 1)
&& Boolean XOR - eXclusive OR (if one, not both, True, returns 1)
\ Boolean NOT (if the opposite, returns True)
These characters ; ) ( : , are significant when not used as part of a literal string.
x=1+2;y=x+3
/* semicolon to separate assignment clauses */
x = y * (x + 1)
/* parentheses to affect calculation */
my_subroutine:
/* colon to identify a label for CALLing */
COMPARE(x,y)
/* comma to separate items in function call */
x = part1 + part2 + ,part3 + part99
/* comma as continuation character at line end */
/* final part of continued line */
Symbols are alphanumeric character groups which may also include the ! $ ? . # _ @
characters. Symbols which start with a numeric character (0-9) and end with "e" or "E"
may be concatenated with a sign and more digits to indicate exponentials.
Before use, any lower case alpha characters are converted to upper unless they are part of
a literal string.
/* examples of symbols */
REXX_text.book!
$sales
SAY
© SecureAgent Software, Tulsa OK USA. All rights reserved. Expressions and Operators
An EXPRESSION has at least one term and usually includes OPERATORS. Most
operators act on pairs of terms. Operators that are positioned between terms are dyadic,
while one or more prefix operators act on the terms that immediately follow them. Terms
may include function calls, sub-expressions, string literals, or symbols.
/* the line below is an example of the equal sign being used as a dyadic operator because
it is BETWEEN two terms */
xyz = 100
/* dyadic operator "=" in an assignment expression */
/* the lines below are examples of the minus sign begin used as a prefix operator because
it affects the term immediately to its right */
x = 100
/* initialize a variable */
SAY -x+1
/* prefix operator "-" to display "-99" expression */
SAY -LENGTH('abc')
/* prefix operator "-" to display "-3" after a function call */
Concatenation
Strings may be concatenated with the || operator or by simply placing them next to each
other without a separating blank (abuttal).
firstv = '2.00'
/* assign string value to first variable */
SAY weight
/* displays "2.00 pounds" */
x = 15 - (1 + 2) * 3
/* same as "x = 15 - 9" */
x=x*2
/* result is 12 */
alpha = an 'example'
/* result is "AN example" */
Case sensitive character comparisons are made unless BOTH terms are numeric. The
string comparisons ignore trailing blanks (the shorter string is padded on the right) as
well as leading blanks unless it is a strict comparison. Strict operators are created by
doubling the normal operators. Normal and strict comparisons both return "1" to
represent true and "0" for false .
/* Example of comparatives */
Boolean (& [AND] | [OR] && [XOR] \ [NOT]) logical comparisons have the same
result values as the other comparisons.
When an expression is seen by REXX, the normal mode of evaluation is from left to right
subject to the presence of parentheses and operator precedence.
They are followed in evaluation order by prefix operators (+ - \), arithmetic operators (* /
% // + -), concatenation operators ([space] || [abuttal]), comparison operator (= == > < >=
\> << \>> etc.), and, finally, the Boolean operators (& | && \).
x=1+3*3
/* same as "x = 1 + 9" */
x = (1 + 3) * 3
/* same as "x = 4 * 3" */
x = 1 + -3 + 5
/* same as "x = -2 + 5" (or "5 - 2") */
© SecureAgent Software, Tulsa OK USA. All rights reserved.
Clauses
CLAUSES may include expressions that produce results, and will fall into one of five
different categories:
Assignments
Commands
Instructions
Labels
Null Clauses
With an assignment clause, the value of a symbol can be set. It has the form of:
an_unnecessarily_long_symbol_name_indeed! = '?'
mytotal = 2 + 4 + (1000 / 50)
Commands are single clauses consisting of a single expression. The result of the
expression is not assigned to a symbol, as in an assignment, but is passed as a command
string to SuperVision.
The first word of an instruction is a keyword that identifies the nature of the instruction.
A good example of an instruction is the DO instruction.
/* example of DO */
DO
/* keyword causing execution of lines below */
SAY 'hello'
/* another keyword instruction */
END
/* sub-keyword instruction terminates "DO" */
Labels are used for jumping within a REXX program. A label is a single symbol
followed by a colon. Although a label is considered a clause, the semicolon is not
required. Multiple labels may follow each other.
CALL oak
/* call a subroutine */
CALL rose
/* call another one */
oak:
/* single label */
SAY 'tree'
/* execute instruction */
RETURN
/* return to calling point in program */
aster:
/* another label */
rose:
/* label called in this example */
marigold: daisy:
/* other labels which may be called */
SAY 'flower'
/* execute instruction */
RETURN
/* return to calling point */
Null Clauses
A null clause is a comment or blanks. Not being an instruction, it cannot be used as
a place holder or dummy instruction as NOP REXX (No OPeration) can.
x=0
x=2+2
x = y + (7 * z)
var_symbol.used_here#1 = !
var_symbol2 = 456
var_sym3 = "It's the first day of the process."
The PARSE instruction is also used for the assignment of values to variables.
When a symbol has not been assigned a value, its uninitialized value is the upper
case value of the symbol itself.
KEYWORDS and variable names are both considered symbols. Before use, any
lower case alpha characters are converted to upper when they are keywords or
variable names or non-delimited strings.
Constant Symbols
Simple Symbols
Compound Symbols
Stems (as part of Compound Symbols)
Begin with a numeric character (0-9). They are numeric symbols and will always
have the same value. That is, a "1" will always be a one and will constantly be that
value and no other.
/* numeric constants */
1234567
000987
2468
1
0
Begin with any non-numeric symbol character(s) and do not contain any periods.
MYWORK1
/* correct - continuous alphanumeric word*/
SUM_TOT
/* correct - underscore may link words */
$1ST_QTR93
/* correct - dollar sign may start symbol name */
@WORK
/* correct - "at" sign may start symbol name */
INBASKET!
/* correct - exclamation mark may be in symbol name */
2ND_BASE
/* wrong - starts with digit */
OFF-BASE
/* wrong - contains the minus numeric operator */
POP,FLY
/* wrong - contains comma continuation character */
HI;STYLE
/* wrong - contains semicolon clause terminator character */
UP FRONT
/* wrong - contains embedded space and would be seen by REXX as two names */
A compound symbol has at least one period and one other character but does not
begin with a period or numeric character. The part before the period is the stem
and the rest (delimited by periods) is the tail.
D. QTR.A..FEB TABLE.ROW
Prior to use, the simple symbols in the tail are replaced by their assigned or
uninitialized values and create a derived name. The use of a stem and tail allows for
subscripted variables when the symbols share the same stem name.
x=1
/* assign "1" to the variable "x" */
table.x = 100
/* 100 to derived "TABLE.1" */
x=x+1
/* increment "x" by "1" so it's now "2" */
table.x = 200
/* 200 to derived "TABLE.2" */
SAY x
/* displays "2" */
SAY table.1
/* displays "100" */
SAY table.x
/* displays "200" */
SAY table.z
/* displays "Z" since "z" was never initialized, it becomes the upper case value of
itself */
When a period is the last character, then it is still called a stem but can be assigned a
value that applies to it even in compound symbols unless another assignment is
made.
tool. = 'metric'
/* assign universal value to stem variable */
tail = 2
/* assign value to simple variable */
tool.tail = 'shim'
/* assign new value to derived "TOOL.2" */
tool.99 = 'hammer'
/* assign new value to derived "TOOL.99" */
SAY tool.
/* displays "metric" - original assignment of stem */
SAY tool.tail
/* displays "shim" - same as "TOOL.2" */
tail = 99
/* assign new value to "tail" */
SAY tool.tail
/* displays "hammer" - same as "TOOL.99" */
SAY tool.kit
/* displays "metric" since "kit" was never assigned a value */
You may enter the following commands in the command line of a SuperVision
scrolling window. You may change the command prefix from a period (.) by clicking
the Options button in SuperVision or by selecting Options from the SuperVision
File menu. If applicable, any numeric return code will be placed in the RC special
variable. Sending a command to the environment takes the form of any valid
expression.
.LIST
.MSG <host nodename> text_message or Msg(‘Node’, ‘Host’, ‘Msg’)
.PLAY soundwave.wav or .PlaySound(Wav file)
.RENAME file 1 file 2
.REXX file or .REXX file argument
.SEND <host nodename> command or Send(‘Node’, ‘Host’, ‘Msg’)
.SCRIPTfilename
.SHUTDOWN seconds
.START rexx_prog
.STOP rexx_prog or TERMINATE(‘Host’, ‘Rexxname’, [,ASID])
.STOPALL
.TERMINATE(‘Host’, ‘Rexxname’, [,ASID]) or .STOP rexx_prog
.TIME
Issues a specified DOS command directly from the command line of a SuperVision
scrolling window.
dos_function This may be any valid DOS command that DOS provides.
Remarks
X=DosCommand('Doscmd','Outfile')
.DosCommand
Issues a specified DOS command directly from the command line of a SuperVision
scrolling window.
dos_function This may be any valid DOS command that DOS provides.
Remarks
X=DosCommand('Doscmd','Outfile')
.Msg
This command allows a text message to be sent to a specified node, directly from the
command line
of a SuperVision scrolling window.
Remarks
We suggest all NEW programs use the following overhead-reducing advanced
method and where
possible, convert the standard method to the advanced:
X=Msg('Node','Host,'Msg')
Notes:
As long as a user is logged on to SuperVision, this command does not require the
target addresses to be in the IP/Nodelist table of SuperVision. If they are, any extra
information—such as the gateway address to use or an overriding User ID—will be
used; otherwise, the address will be used "as is" with the currently logged-on User
ID information.
.Play
Feature that may be utilized if the system has a soundcard. Sends a command
specifying a particular WAV file that should be launched.
Remarks
X=PlaySound(Wav file)
Feature that may be utilized if the system has a soundcard. Sends a command
specifying a particular WAV file that should be played.
Remarks
X=PlaySound(Wav file)
This command can be issued at any scrolling (host) window command line.
The argument string following the command will be interpreted as REXX code and
executed by SuperVision.
Causes a particular command to be sent to, and issued on, a specified node (host).
a REXX program.
X=Send('Node','Host','Msg')
© SecureAgent Software, Tulsa OK USA. All rights reserved.
.Shutdown
You can cancel this command by entering ".shutdown abort" in the command line.
X=Terminate('Host','Rexxname',(ASID))
X=Terminate('Host','Rexxname'(,ASID))
A computer language uses words that have special meanings within that language.
These are called KEYWORDS. These words may vary from language to language
and yet do the same thing. For example, the GOSUB keyword in BASIC and the
CALL keyword in REXX all are used to temporarily transfer control to a
subroutine whose label immediately follows that keyword.
CALL causes the named routine to begin execution. It may be an external routine ,
an internal routine, or another program. After execution of the called routine,
control is returned to that line. In the case of internal routines, previously existing
variables are accessible by the called routine.
Routines may also be nested up to 100 levels. Only one argument (up to 255
characters long) may be passed via the expression.
An internal routine may also create and use local variables, but then it cannot use
variables with the same names from the calling routine. Variables that are to be
shared with internal routines should be declared with the GLOBAL instruction. If
an internal routine is called, it should normally terminate with the return
instruction.
The use of call will not affect the status of a DO loop unless the loop control variable
has been deliberately altered within the subroutine.
/* use of CALL to internal routine */
/* sendarg.usm */
CALL my_macro 'quick brown fox'
/* send string literal argument */
/* my_macro.usm */
PARSE ARG speed color animal
/* parse into 3 local variables */
SAY speed color animal
/* display them */
Simple DO Group
Simple Repetitive Loops
Counting Loops
Conditional Loops
DO [repetitor] | [condition];
[instruction_group]
END [symbol];
IF month='March' THEN DO
/* If the condition is true */
season='Spring'
game = 'Baseball'
SAY 'Play ball!'
END
/* all instructions up to here will be executed */
© SecureAgent Software, Tulsa OK USA. All rights reserved.
Simple Repetitive Loops
DO FOREVER
SAY 'infinite loop'
END
/* will keep looping forever */
DO 3
/* do something 3 times */
SAY 'a group of 3 lines'
END
/* print a line 3 times */
/* build an expression */
a=10
/* assign values to variables */
b=25
DO (b-a)
DO n = 1 TO 3
/* will loop three times with the variable ‘n’ taking the values of 1, 2 and 3 */
DO n = 1 TO 10 BY 2
/* will loop five times with the variable ‘n’ taking the values
of 1, 3, 5, 7 and 9 */
SAY "This is line" n
END
DO n = 6 TO 1 BY –1
/* will loop six times with the variable ‘n’ taking the values
of 6, 5, 4, 3, 2 and 1 */
i=1
/* initialize our loop variable */
DO WHILE i <= 10
/* evaluation prior to execution */
SAY i
/* displays value of "i" */
i=i+1
/* increment our loop variable */
END
/* loops from 1 to 10 */
i=1
/* initialize loop variable */
DO UNTIL i = 10
/* same as "DO WHILE i < 10" */
SAY i
/* displays loop variable from 1 to 9 */
i=i+1
/* increment variable */
END
/* loops from 1 to 10 */
© SecureAgent Software, Tulsa OK USA. All rights reserved.
DROP GLOBALS
DROP varnames
x=4
park. = 'greenspace'
park.bench = 'concrete'
SAY park. park.bench x
/* Display is "greenspace concrete 4" */
DROP park. x
/* all above variables now GONE */
SAY park.bench x park.
/* Display is "PARK.BENCH X PARK" - the
uninitialized forms of all 3 variables */
© SecureAgent Software, Tulsa OK USA. All rights reserved.
EXIT [expression]
Returns various data by creating local variables and assigning values to them. Note
that if a variable of higher precedence (a node or host global) with the same name
already exists, it will be used rather than creating a local with the same name.
The compound variables created have the same base (stem) name as the EXTRACT
subkeyword, and a numeric extension: NODENAME.0, NODENAME.1, etc. The .0
variable contains the number of variables in that series created by EXTRACT, not
counting the .0 variable itself. The .1, .2, and higher variables contain the actual
extracted information. This is done so that an EXTRACT can create a list of items,
which can then be examined in sequence using a DO loop .
COAXn CONNECT
HOSTID HOSTNAME
HOSTTASKS KEYGROUPS hostid
NETCONNECTS nodename NETHOSTS nodename
NETNAMES NODEID
NODENAME NODETASKS
NODETYPE OIAn
TASK
Note: Nodename may be specified either as a full nodename, or as the text portion
only. If only the text portion is specified, then the first match encountered in the
node list is returned.
Because NETHOSTS and NETCONNECTS are the only EXTRACT subkeywords
which require a parameter, it is recommended that they be the last subkeyword
given in an EXTRACT command
CONNECT.0 = 1
CONNECT.1 = <connect string> contains text indicating the type of connection to
the scrolling (host) window in which the REXX program is running. The connection
will be either local to a mainframe or remote to another SuperVision workstation
(in which case the text will include "at" followed by the nodename). Returns "none"
if a connection does not exist.
HOSTID.0 = 1
HOSTID.1 = host ID character (A-P or S) of scrolling (host) window the REXX
program is running in.
HOSTNAME.0 = 1
HOSTNAME.1 = <name of current host>
HOSTNAME.2 = Fully qualified name of window
Example:
Extract HostName
HOSTNAME.0 = 2
HOSTNAME.1 = GISMVS
HOSTNAME.2 = GISMVS@SNS_TESTSYSTEM
Returns information about all the currently running REXX programs (tasks)
started under this scrolling (host) window.
Returns information about which keygroups are active, and what they are called,
for any given window. Where hostid is "S", "A – P" or "*". Displays for each of 16
available keygroups:
1. keygroup file name (KeyGrpNN.ini, where "NN" ranges from "01" to "16")
or "UNDEFINED" if not yet created
2. "0" meaning inactive, or "1" indicating active
3. name assigned to the keygroup (if available; i.e. SOFTDUMP)
KEYGROUPS.0 = 16
KEYGROUPS.1 = Gives information regarding keygroup 1
KEYGROUPS.n = Gives information regarding keygroup n
If " * ", the extract returns information for the scrolling (host) window in which the
REXX program is running.
© SecureAgent Software, Tulsa OK USA. All rights reserved.
EXTRACT NetConnects nodename
"Connect info" is specified as a string of the form "xx hhhhhhhhhhhh", where the
h's represent the 12-digit unique ID of the connected node, and xx is the two-
character ID for the host on that node which is making the connection. The string
will be null if no connection is made (i.e., NETCONNECTS.1 will be a null string if
Host A has no remote console #1 connected).
Keywords/Instructions
NODEID.0 = 1
NODEID.1 = the 12 hexadecimal digit ID for the network adapter hardware that is
installed within the current workstation (the "unique ID" for this network node,
same as the LAN adapter's Burned-In Address).
NODENAME.0 = 1
NODENAME.1 = the 10-char. text portion of the workstation name which is set by
the user.
Returns information about all the currently running REXX programs (tasks)
started on this node.
NODETYPE.0 = 1
NODETYPE.1 = six-digit number indicating version of SuperVision currently
running the REXX program. Major release – minor release – service pack (i.e.
050303)
TASK.0 = 3
TASK.1 = <name of current task> The name of the currently running REXX
program.
TASK.2 = <class of current task> "auto" if program started as auto-
response to a message
This is a command that can be executed from within a REXX program. When
executed, all unread messages are purged. The next "PARSE MSG" instruction will
receive the next message that arrives following the "FLUSH" command.
Creates global variables and moves variables between the several variable lists
maintained by REXX. The default list is HOST. These variable lists are as follows:
Node Global
Variables are visible to any program running on the current network node
(workstation). Each workstation has its own list.
Host Global
Variables are visible to any program running on the current host, but not on any
other host. Each host window has its own list.
Local
Variables are visible only to the current REXX program.
Node Global list: The highest level. This list only exists for one workstation.
Host Global list: This list only exists within one window.
Local list: This list only exists while a program is running.
Processing hierarchy
When a variable is used, the lists are searched in the following order for that
variable: Node Globals, Host Globals, and Locals. Thus, if another macro creates a
Host Global named "X", subsequent variable accesses to "X" will find that Host
Global and not a local variable of the same name. The same is true of variables with
higher precedence.
If, neither NODE, nor HOST is specified, then HOST is assumed. Note that multiple
variables can be specified, but NODE or HOST can only be specified at the start of
the instruction. If the named variable does not exist, it is created as an uninitialized
variable (equal to its own name).
If a local variable is moved to any of the three global lists, it ceases to exist on the
local list and can never be moved back to the local list. Once a HOST or NODE
variable is declared, it can be moved between the HOST and NODE lists at will.
The standard conditional branch which executes any instruction(s) after the sub-
keyword THEN
when the valid logical expression evaluates to a "1". But if it evaluates to a "0",
then it will execute any instruction(s) after the optional ELSE. Care should be taken
since the ELSE will link with the nearest IF regardless of any text indentation hence
the importance of the NOP instruction.
/* Example of IF use */
IF state = 'Maine'
THEN ; IF city = 'Augusta'
/* nested IF */
SAY "Capital!"
ELSE ; NOP
/* force termination of nested IF */
ELSE ; SAY "Not the state of Maine"
Without the forced termination, the final line would link itself to IF city = 'Augusta'.
The IF instruction can also set off a DO instruction so groups of instructions can be
executed if a condition is true.
IF city = 'Paris'
/* begin outer IF */
THEN DO
/* begin DO */
SAY 'The selected city is Paris'
/* show the town */
Executes instructions which have been built "on the fly" (dynamically).
shoe = 'SIZE'
INTERPRET shoe "= '8 1/2 EEE'"
/* Same as SIZE = '8 1/2 EEE' */
SAY SIZE
/* displays "8 1/2 EEE" */
Syntax: ITERATE;
i =0
/* initialize a loop variable */
DO WHILE i <= 5
/* set a condition */
i = i +1
/* increment variable */
IF i = 3 ;
/* check for value of 3 */
THEN ITERATE
/* head for end */
SAY i
/* display loop variable */
END
/* bottom of construct */
Syntax: LEAVE;
Terminates DO loop. Control passes to the first line after the END of the innermost
loop it is called from.
DO 5
/* outer loop goes 5 times */
j=0
/* set loop variable */
DO WHILE j <= 5
/* set inner loop condition */
j=j+1
/* increment it */
IF j = 3 THEN LEAVE
/* terminate inner loop */
SAY j
/* display loop variable */
END
/* bottom of inner loop */
END
/* bottom of outer loop */
/* displays "1 2 1 2 1 2 1 2 1 2" */
Syntax: NOP;
No variables are set if no template is provided however other actions prepare the
data for parsing later. PARSE VALUE will have the expression evaluated, and for
PARSE VAR, the variable name will be examined to make sure it has been
initialized to a value.
Parsing occurs upon the string passed to the function, subroutine, or program.
Each invocation of the "PARSE [UPPER] HISTORY" command will retrieve the
previous message to the last one retrieved. To enable programs to more easily keep
track of how far back in the log they have travelled, the SV timestamp is set at the
front of each message in the format "HH:MM:SS", always precisely nine (9)
characters.
Allows a REXX program to access its host console stream, one message at a time. If
no messages are waiting to be accessed, PARSE MSG will either:
1. pause up to 5 seconds, if the WAIT modifier is active (the default). If a
message is received during that time, it will be used as the value to parse; otherwise,
a null string (") will be used.
2. immediately use the null string (") as the value to parse, if the NOWAIT
modifier is active.
'.ZDSYS'
/*cause system to generate status message*/
PARSE MSG my_status
/*send entire message string to one variable*/
SAY my_status
/*have REXX display the message*/
The template will receive the REXX name of the program being parsed.
The first two variables in the template (word1 & word2) will contain "FOUR" and
"SCORE" respectively. The third variable will hold the remainder of the string in
UPPER CASE form.
Shows the revision level of REXX in operation. The first word will always be
"REXX", next is the revision level, and lastly is the date in the form "dd Mon
yyyy".
The above will yield "REXX_" in lang, something like "1.30" in rev (a 4 character
release level), and a date such as "01 Jul 1993" in the last variable.
Syntax: REXXDUMP
Causes the list of current global and local variables to be dumped into the REXX
Tracing window, which you can access by holding down the Ctrl key and pressing
the F11 key. No parameters are required. The dumped information has the format:
The operator may specify the maximum number of seconds (max_secs) to conduct
the search for before automatically terminating the search process. The highest
value allowed is 86400 (one day). If no maximum is specified, then it defaults to zero
and there is no time limit on the search.
The operator may also specify the maximum number of messages to search through
before automatically terminating the search. The minimum value is zero (no limit),
the default value is one message, and the maximum is 4294967295 (over 4 billion).
The WHEN TIME and WHEN COUNT options allow the inclusion of an action
(such as a SAY instruction or a DO construct) if either the time limit has elapsed or
the message count has been reached.
If the search string is found, the next PARSE MSG instruction will access the host
message containing the search string. If it is not found, then PARSE MSG will
access the message immediately following the last message SEARCH had examined.
Syntax: SELECT;WHEN;OTHERWISE
The example below shows a simple example of the SELECT construct with all the
whenlist items on individual lines.
SELECT
OTHERWISE
SAY 'no valid color selection'
END
In the above example (#1), the first WHEN clause evaluates as False (since color is
not "red") so the sub-keyword THEN and its clause are not executed. Evaluation
proceeds to the next WHEN. The second WHEN clause evaluates as True (since
color is "purple") so the rest of that line is executed.
Because a WHEN clause in this construct has evaluated as True, the third and
fourth WHEN clauses are skipped and the OTHERWISE is also skipped.
The next example (#2) is a bit more complex. It shows how a DO construct can be
set off by a True condition at a WHEN. The ellipsis (. . .) represents an indefinite
number of statements which may be included within an executed DO construct. It
also shows how the whenlist item can be spread among two or three lines for the
sake of readability.
This is another example of how indentation can be used to help the programmer
follow the logic of a program and ease the process of modification or debugging.
WHEN option = 3
/* item spread across three lines */
THEN
DO
...
END
OTHERWISE
DO
SAY 'No valid option found'
In this example (#2), the OTHERWISE will execute because none of the WHEN
clauses evaluated as true.
Controls the generation of tracing information sent to the scrolling (host) window. The
following TRACE options are supported:
I - Intermediate values. Traces any variable assignments made via either an assignment
statement or the PARSE instruction, at the time they are made. Also traces the result of
each expression evaluation, including expressions nested within other expressions (i.e.,
expressions in function-call parameters).
Options may be combined (e.g., "TRACE 'XI'"). Note that the 'S' option implemented by
our system is not the 'S' option described by Cowlishaw.
TRACE x
/* let's just show the results of expressions this time */
The command will pause program execution for the specified time. The numeric
expression may be a value from 1 to 255 (seconds) when it is called from a REXX
program.
WAIT 8
/* pause for 8 seconds */
A call to a built-in routine that returns a result string (function) may be part of an
expression where such a term would be valid (as in a literal string) in this form:
It is critical to remember that a function name MUST have a left parenthesis abutting the
last character of the name. If there is any space between them, it will not be recognized as
a function. Also, most functions produce a return value and it is best to use a variable to
receive that value or the value will be passed to the host.
good_function(ok)
/* correct syntax for function call*/
fail_function (bug)
/* wrong way, has embedded space */
w_count = WORDS ('returns a number')
/* this one will return a "3" in "w_count" */
All built-in functions are a part of the REXX language. They may be invoked at any time.
REXX will report any syntax errors found in either the function or the function call.
Always supply a parentheses set next to the name of the function even if no arguments
are needed (i.e. "FUNC( )" not "FUNC ( )" or "FUNC")
A comma may be used to show the omission of an optional final argument. Example,
CENTER ('THIS',8,) will show the absence of an optional padding character.
Any pad character is, as the name implies, a single valid character (one byte only).
Abbrev (string_arg,string[,length])
Abs (number)
Address()
Alert ('ATTN WARN OR PRIO', 'MSG')
Arg ([n[,option]])
Admin Functions
AdminDriverAdd
AdminDriverGetDetail
AdminDriverGetList
AdminDriverRemove
AdminDriverStart
AdminDriverStartup
AdminDriverStop
AdminEventLogGetDetail
AdminEventLogGetList
AdminPerfMon Functions - Introduction
AdminPerfMonGetCounters
AdminPerfMonGetInstances
AdminPerfMonGetObjects
AdminPerfMonGetValues
AdminRegistryAddKey
AdminRegistryGetKeyList
AdminRegistryGetValueDetail
AdminRegistryGetValueList
AdminRegistryRemoveKey
AdminRegistryRemoveValue
AdminRegistrySetValue
AdminRegistryAddKey
AdminServiceAdd
AdminServiceGetDetail
AdminServiceGetList
AdminServicePause
AdminServiceRemove
AdminServiceResume
AdminServiceStart
AdminServiceStartup
AdminServiceStop
AdminTaskGetList
AdminTaskGetThreadList
AdminTaskStart
AdminTaskStop
© SecureAgent Software, Tulsa OK USA. All rights reserved.
Abbrev Function
Syntax: Abbrev(string_arg,sting[,length])
Checks if string_arg matches string for optional length along string_arg. Returns 1 for
true; 0 for false.
Abbrev('Oklahoma','Okla',4)
== 1 /* exact */
Abbrev('Oklahoma','OK')
== 0 /* case counts */
Abbrev('Oklahoma','Okla',5)
== 0 /* too few characters in second
Syntax: Abs(number)
x = Abs(-409)
/* "X" is now 409 */
- category is the message type: ‘Attn’, ‘Warn’, ‘Prio’, or ‘0’ through ‘9’, indicating
to which keyword group this message should apply. Use SuperVision’s Automation
Rules Editor (Keygroup Editor) to set the desired value.
- msg is the message text that you want to display.
If category is ‘0’ through ‘9’ and color is ‘*’, the default color for the appropriate user
message window will be used.
Instead of ‘Attn’, ‘Warn’, or ‘Prio’, you may use ‘A’ or ‘a’, ‘W’ or ‘w’, ‘P’ or ‘p’,
respectively.
/* Example */
X=Alert('A','Attention required', 'red')
Syntax: Arg([n[,option]])
Returns string or data about argument string(s). The number of blank delimited words is
returned when there are no parameters. The nth argument string is returned when only n
(negatives prohibited) is used. A null string may be returned.
The option checks for the explicit omission or existence of the nth argument string.
Arg() == 3
/* it says there are three space delimited strings */
Arg(1) == 'abc'
/* it returns the 1st string */
Arg(4,'o') == 1
/* It returns a "True" because there is no 4th string (omitted) */
The AdminDriverAdd function is used to install a new service onto the system.
RETNUM AdminDriverAdd(
Parameters
Driver
The name of the driver to install, i.e. “TKRNG864”.
DisplayName
The driver name as presented to users, i.e. “Token-Ring Model 864”.
ImagePath
The pathname to the driver, i.e. “%SystemRoot%\System32\TKRN864.SYS”
MsgName
If this driver has a message file then this should be the appropriate event viewer
message source name, typically the same as the driver name. If there is no message file
then leave this parameter empty along with the MsgFamily and MsgPath parameters.
MsgFamily
If this driver has a message file then this should be the appropriate event viewer
family: “Application”, “Security” or “System”, otherwise leave this parameter empty
along with the MsgName and MsgPath parameters.
MsgPath
Returns
This function returns zero if the driver was installed or one if an error occurs.
Remarks
COUNT GetWebPage(“URL”,StemOutputList)
Parameters
URL
StemOutputList
The resulting output list in the form of a standard stem array. The zero element
(StemOutputList.0) will contain the number of lines of response; the first element
(StemOutputList.1) will contain the first response line, etc.
Returns
This function returns the same number as in StemOutputList.0, which is the number of
lines in the response. This number will be zero if no response was received or an error
occurs.
StemOutputList.1 contains the time, in milliseconds, that it required to retrieve the page.
StemOutputList.2 contains the size of the page.
StemOutputList.3 contains the first line of the page data. The remaining StemOutputList
lines contain the subsequent lines of the page data, if any.
The GetSystemName function is used to retrieve the name of the computer on which the
REXX program is executing.
COMPNAME GetSystemName(
Returns
This function returns an empty string if the computer name cannot be determined.
The GetIPList function is used to retrieve a list of the network IP addresses of the
computer on which the REXX program is executing.
COUNT GetIPList(
Parameters
hostname
Name of the computer on which the REXX program is executing.
StemOutputList
The resulting output list in the form of a standard stem array. The zero element
(StemOutputList.0) will contain the number of IP addresses, the first element
(StemOutputList.1) will contain the first IP address, etc.
Returns
This function returns the same number as in StemOutputList.0, which is the number of IP
addresses. This number will be zero if no IP addresses are found or an error occurs.
Functions: C
C2D
C2X
CallStack (stemvariable)
Center (string,length[,pad]) or Centre
Char (n)
CoaxCommand (coaxid, text)
CoaxGetCursor
CoaxGetNextScreen
CoaxGetScreen (coax, stem_name)
CoaxPress (‘COAXn’,’key’)
CoaxSetCursor (‘COAX#’,row,col)
CoaxText (‘COAX#’,text)
Compare (string1,string2[,pad])
Copies (string,n)
Center Function
Syntax: Center(string,length[,pad]) or
Centre(string,length[,pad])
Will return a string of length characters with string centered within it. If length (0 or
more) is greater than the actual size of string, the pad character will be added to both
sides of string. If the string is wider than length, characters are truncated one right, one
left, one right, etc.
Syntax: CHAR(n)
SAY CHAR(65)
/* the letter A */
This function is only designed for use with MCS (MVS operator) consoles. Usage on
other types of 3270 session is undefined and can lead to unpredictable results and errors.
String is read back from the operator’s input area to ensure keystrokes match before
<ENTER> key actually is pressed.
The <ENTER> key will be automatically pressed at the end of the command.
As with the CoaxText and CoaxPress functions, data will be entered into the type-ahead
buffer to be processed in the normal way. Unlike these two functions, CoaxCommand
will not return to the calling REXX program until after the text has actually been entered
on the screen and the <ENTER> key has been pressed.
The return code for this function will contain valid information as follows:
This function can replace a CoaxText followed by a CoaxPress (for the <ENTER> key)
with no ill effects. Be aware that it DOES NOT attempt to clear any command line before
starting to type its command. If you enter text in front of CoaxCommand, using
CoaxText, it will append text to that command. This allows for the definition of prefixes,
etc. as required.
This REXX function gets the coax screen data and stores it into the stem name.
Example:
count = 0
x = coaxgetscreen(coax1, scrn)
Do While count < scrn.0
count=count+1
Say scrn.count
End
Syntax: CoaxPress('COAXn','key')
The CoaxPress function allows you to press a specific key on the specified coax. COAXn
must be COAX1, COAX2, COAX3, or COAX4. Valid keys are shown below:
Return Codes:
0=OK 1=coax not available 2=hung (undesired response) 3=unknown key
Examples:
/* The following example will press the enter key on a MVS console attached to
COAX1.*/
x=CoaxPress('COAX1','ENTER')
/* The following example will press the tod enable key on an IBM 3090/9000 service
processor console attached to COAX2. NOTE that 'COAX'CoaxNum is interpreted by
REXX to be COAX2.*/
CoaxNum = 2
x=CoaxPress('COAX'CoaxNum, 'TOD_ENABLE')
Syntax: CoaxText('COAX#',text)
Syntax: Compare(string1,string2[,pad])
Identical strings cause a "0" return value. Else, the character position of the first
mismatch is returned. If one string is shorter, it will be padded on the right.
Syntax: COPIES(string,n)
Replicates the string n (0 or more) times. If 0, a null string is returned.
Copies('do',5) == "dododododo"
D2C
D2X
DataType (string [, type])
Date ([option])
DateCalc ( )
Dec2Hex (n)
Delstr (string,n[,length])
DelWord (string,n[,length])
Deq
If only string is specified, the reutrned result is ‘NUM’ (2), If string is a syntactically
valid REXX number that can be added to ‘0’ without error, or ‘CHAR’ (3) otherwise.
If type is specified, the returned result is 1. If string matches the type, or 0 otherwise. If
string is null, 0 is returned (except when type is "x", which returns 1 for a null string).
The valid types (of which the one letter is needed) are:
A - (Alphanumeric) ; returns 1 if string only contains characters from ranges "a-z", "A-
Z", and "0-9"
.
B - (Binary) ; returns 1 if string only contains the characters "0" and/or "1".
L - (Lower case) ; returns 1 if string only contains characters from the range "a-z".
M - (Mixed case) ; returns 1 of string only contains characters from the ranges "a-z" and
"A- Z".
N - (Number) ; reutrns 1 if DATETYPE(string) would return ‘NUM’(2).
S - (Symbol) ; returns 1 if string only contains characters that are vaild in REXX
symbols.
U - (Upper case) ; returns 1 if string only contains characters from the range "A-Z".
W - (Whole numbers) ; returns 1 if string is a REXX whole number.
X - (heXadecimal) ; returns 1 if string only contains characters from the range "a-f", "A-
F", "0-9".
Also returns 1 if string is a null string, which is a valid hexadecimal string.
Examples:
x = datatype('12') =2
x = datatype(' ') =3
x = datatype('123*') =3
x = datatype('12.3', 'N') =1
x = datatype('12', 'W') = 0
x = datatype('Fred', 'M') =1
x = datatype(' ', 'M') = 0
x = datatype('Minx', 'L') =0
x = datatype('3d?', 'S') = 1
x = datatype('BCd3', 'X') =1
x = datatype('BC d3', 'X') =1
x = datatype('BCd3', 'A') =1
x = datatype('10011', 'B') =1
Syntax: Date([option])
The current date (as far as the operating system knows) is returned as a string. The
default format is "[d]d Mmm yyyy". By using the FIRST letter of an option, other
formats are obtained:
Base – returns the number of complete days (that is, not including the current day) since
and including the base date, 1 Jan 0001, in the format ‘dddddd’ (no leading zeros or
blanks). This base date is determined by extending the current Gregorian calendar
backward (365 days each year, with an extra day every year tat is divisible by 4, except
century years that are not divisible by 400).
Note: The expression DATE (‘B’)//7 returns a number corresponding to the day of the
week, with 0 indicating Monday. DATE (‘B’) would have returned 693595 on 1 Jan
1900.
my_month = Date('M')
/* example of use */
Syntax: DateCalc( )
The date calculation function takes zero, one or two parameters. With no parameters it
will return today's date in various formats all contained in one string as follows:
36x = number of Days In the Year, always 365 or 366 for leap years
Note: Week number 1 may start at the end of the previous year and that all returned
values will have leading zeros as required.
The first optional parameter is a date, in various allowed formats, for which the output
should be prepared. The formats allowed are as follows:
The second optional parameter is a number of days to offset the date given as the first
parameter before the output is prepared. It may be negative to indicate earlier dates. Dates
before 1900 or after 2099 are not supported.
Returns a string containing the hexadecimal equivalent of n with a leading zero if the first
character would otherwise be in the range A-F.
Dec2Hex(254)
/* returns "0FE" */
Syntax: DelStr(string,n[,length])
Syntax: DelWord(string,n[,length])
Deletes words at a time. It is just like DELSTR except that it counts space-delimited
words instead of characters.
DialPager allows the user to specify a com port, the pager telephone number, and the
caller’s return telephone number. Additional option is the setup of modem initialization.
If this is not specified, Dialpager uses the default setting provided by the factory.
Pager Phone No: The pager’s telephone number. A "P" in front of this number
specifies a pulse mode; otherwise, the default is tone mode.
Calling Phone No: The return caller’s telephone number or PIN and then telephone
number.
Option: Any modem setting that you wish to set differently from the factory
default settings.
Examples:
x = DialPager("COM1", "555-1212", "1-918-234-9200")
x = DialPager("COM1", "9 W 555-1212", "1-918-234-9200")
x = DialPager("COM1", "P 555-1212", "1234 1-918-234-9200", "ATE1"
)(pulse mode)
x = DialPager("COM1", "555-1212", "WWWWW1-918-234-9200")
Note: You do not need to put an @ sign between parts of the telephone number or a #
sign after the caller’s return telephone number since these characters are built into the
function.
Value Meaning
0 OK
1 CONNECT
2 RING
3 NO CARRIER
4 ERROR
6 NO DIALTONE
7 BUSY
8 NO ANSWER
The time out is a period, expressed in seconds, that the program should try to get the Enq
function executed. If you specify "-1", the program will try forever. If you specify "0",
the program will try only once. The program will return either:
If you want to insure that only one copy of a program runs at a time, then:
X=Enq(task.1,0)
IF X <> 0 then exit
Good programming requires you to relinquish the Enq function (SuperVision will
relinquish in the absence of a direct command). You will need to issue the Deq function
as follows:
X=Deq(serializer name)
FileClose (str)
FileExists (str)
FileReceive (‘device’,’pc_file’,mainframefile’,’options’)
FileSearch (filemask,stemname)
FileSend (‘device’,’pc_file’,’mainframefile’,’options’)
FileSize (str)
© SecureAgent Software, Tulsa OK USA. All rights reserved.
FileClose Function
Syntax: FileCose(str)
Where ‘str’ is a string containing the name of a file previously opened by RECORDIN(),
RECORDOUT(), LINEIN, or LINEOUT. If no path is specified, the file will be closed in
the c:\SV or Sv4 directory. To close a file in the current directory, give a path to that
directory or use the '.' alias for the current directory (i.e., '.\filename.ext'). Returns "0" if
the file could be closed properly, "1" otherwise.
Note: It is not normally necessary to use this function, as all files opened by a REXX
program are automatically closed when it terminates.
Syntax: FileExists(str)
Where ‘str’ is the name of the desired [path]file. If no path is specified, the file will be
checked in the working directory as specified in the SETTINGS DIALOGUE OR IN
THE PROFILE (.INI). To check a file in the current directory, give a path to that
directory or use the '.' alias for the current directory (i.e., '.\filename.ext'). Returns: "1" if
the file exists, "0" otherwise.
Note: This function uses the MS-DOS "findfirst" directory search function to locate the
file. Thus, if a DOS wildcard is included in the filename, FILEEXISTS will still work --
but it will return "1" (TRUE) if ANY file exists matching the wildcard. Thus,
FILEEXISTS('*.log') will return TRUE if ANY files with the extension 'log' exist in the
working directory. Exercise caution when using wildcards -- they might not give the
exact results you intended!
my_stuff = FileExists('.\today.log')
say my_stuff
/* displays "1" if the file exists */
We suggest all NEW programs use the following overhead-reducing advanced method
and where possible, convert the standard method to the advanced:
crlf—Specifies that trailing spaces in the mainframe file records are to be deleted and that
carriage return/line feed character pairs are to be inserted at the end of each record. This
option is recommended if you want the file to be readable on the PC.
The CMS RECEIVE command syntax includes the following options (left parenthesis in
syntax is required):
append -- Specifies that the received file is to be appended to the end of an existing PC
file.
Note: If append is not specified and the specified PC file already exists, the received file
will replace the existing PC file.
ascii -- Specifies that the EBCDIC-stored mainframe file be converted to ASCII before
transfer. The ASCII option is recommended if a text file is to be readable on the PC.
crlf -- Specifies that trailing spaces in the mainframe file records are to be deleted and
that carriage return/line feed character pairs are to be inserted at the end of each record.
Crlf mode is recommended if you want the file to be readable on the PC.
The CICS RECEIVE command syntax includes the following options (left parenthesis in
syntax is required):
append—Lets you append the downloaded file to the end of an existing PC file.
Note: If append is not used, the receiving file will be replaced by the downloading CICS
file.
ascii—Data is translated from EBCDIC to ASCII with the RECEIVE option. The ascii
option is recommended if the file is to be readable on the mainframe and PC.
binary—The data in the file to be sent or received is binary data. That is, data that is not
readable. It is sent "as is" without any translation.
DELETE—Once you receive a file owned by you, it is deleted from the host transfer file
after it has been copied to the PC file. Delete is the default for files owned by you. (Files
received from other users with the FROM=option are never deleted).
FROM=USID—Retrieves a file that was stored as a public file or that another user shared
with you. USID is the CICS/DOS/VS ID of the person who owns the file.
HTF—The file is stored in/received from the host transfer file. (HTF, rather than TS, is
the default).
Syntax: FileSearch(filemask,stemname)
Where filemask is the name of the desired [path]file. If no path is specified, the file will
be checked in the c:\SV or Sv4 directory. To check a file in the current directory, give a
path to that directory or use the '.' alias for the current directory (i.e., '.\*.ext'). Returns the
number of files that match the pattern mask and a compound variable array containing
their names. The elements of the array will have the stem name in the function call and
will be numbered from zero to the quantity of files found.
/* this will return the count and names of all of the files in the c:\SV or Sv4 directory */
file_count = FileSearch('C:\LOG\*.*','MY_LOG')
/* if, in this example, the following five files existed in that directory:
SV_0719.LOG
AA_0719.LOG
BB_0719.LOG
CC_0719.LOG
DD_0719.LOG
my_log.2 == AA_0719.LOG
my_log.3 == BB_0719.LOG
my_log.4 == CC_0719.LOG
my_log.5 == DD_0719.LOG
*/
Note: We suggest all NEW programs use the following overhead-reducing advanced
method and where possible, convert the standard method to the advanced:
X=FileSearch('Filemask','Stemname')
© SecureAgent Software, Tulsa OK USA. All rights reserved.
FileSend Function
Syntax: FileSend('DEVICE','PC_FILE','MAINFRAMEFILE','OPTIONS')
We suggest all NEW programs use the following overhead-reducing advanced method
and where possible, convert the standard method to the advanced:
OPTIONS for
- TSO
- CMS
- CICS
irecl(n)—Specifies the Logical Record Length of the mainframe file, where n is the
number of characters in each record. Set-length PC records longer than n and variable-
length records longer the n-4 will be split into multiple mainframe records. If you omit
irecl, the default is 80 for new files. For existing files, irecl is ignored.
blksize(n)—Specifies the block size of the mainframe dataset, where n is the length in
bytes of a data block. If you are appending or replacing a dataset, blksize is ignored.
recfm(f)—Specifies that the mainframe file will contain fixed-length records. Records are
padded with space characters if they are shorter than that specified with irecl or the
default length. This is the default for new files unless crlf is specified.
recfm(u)—Specifies that the mainframe file will contain records of undefined length.
Note: For existing files, the recfm option is ignored.
recfm(v)—Specifies that the mainframe file will contain records of variable length. This
is the default for new files when crlf is specified.
Note: If is recommended that you use the recfm(v) option without the crlf option when
you must avoid padding of mainframe records or deletion of trailing spaces—for
example, binary (program) files contain variable length records.
space—Specifies the amount of space you want to be allocated for a new dataset. If you
use space,
use the following syntax:
The CMS SEND command syntax includes the following options (options must begin
with a left parenthesis):
append—Lets you append the uploaded file to the end of an existing CMS file. The
append option is ignored if the specified CMS file does not exist.
Note: If append is not used when the CMS filename already exists on the mainframe, the
existing file will be replaced by the uploaded file.
ascii—Specifies that files stored in ASCII on the PC be converted to EBCDIC before
transfer. The ascii option is recommended if the file is to be readable on the mainframe.
crlf—Specifies that carriage return/line feed character-pairs present in the PC file should
be deleted before being stored on the mainframe. Usually, alphanumeric data on the PC
contains a crlf character pair at the end of each line to denote the end of each record.
Deleting these character pairs using the crlf option lets you read the mainframe version of
the file more easily.
irecl(n)—Specifies the Logical Record Length of the mainframe file, where n is the
number of characters in each record. Set-length PC records longer than n and variable-
length records longer the n-4 will be split into multiple mainframe records. If you omit
irecl, the default is 80 for new files. For existing files, irecl is ignored.
recfm f—Specifies that the mainframe file will contain fixed-length records. Records are
padded with space characters if they are shorter than that specified with irecl or the
default length. This is the default for new files unless crlf is specified.
recfm v—Specifies that the file will contain variable length records. This is the default
for new files when crlf is specified.
Note: Use of the recfm v option without the crlf option is recommended when padding of
mainframe records or deletion of trailing spaces must not occur.
The CICS SEND command syntax includes the following options (left parenthesis in
syntax is required):
ascii—Data is translated from ASCII to EBCDIC with the Send option. The ascii option
is recommended if the file is to be readable on the mainframe and PC.
binary—The data in the file to be sent is binary. That is, data that is not readable. It is
sent "as is" without any transalation.
crlf—Specifies that carriage return/line feed character pairs present in the PC file should
be deleted before being stored on the mainframe. Usually, alphanumeric data on the PC
contains a crlf character pair at the end of each line to denote the end of each record.
Deleting these character pairs using the crlf option lets you read the mainframe version of
the file more easily.
Syntax: FileSize(str)
Where ‘str’ is a string containing the name of the file whose size is desired. If no path is
specified, the file will be checked in the C:\SV4 directory. To open a file in the current
directory, give a path to that directory or use the '.' alias for the current directory (i.e.,
".\filename.ext").
Returns "-1" if the file cannot be found; otherwise, the size of the file.
Note: This function uses the MS-DOS "findfirst" directory search function to locate the
file. Thus, if a DOS wildcard is included in the filename, FileSize will still work—but it
will return the size of the first file which matches the wildcard, which may not be what is
desired!
Syntax: Hex2Dec(str)
Will return the decimal equivalent of the hexadecimal value in str. Note that hex values
of '80000000' or greater will be converted to negative numbers, due to the
implementation of signed arithmetic on the Intel 80x86 processor family.
SAY Hex2Dec('A2BF')
/* Displays "41663" */
Syntax: InputBox('message-text','varname'[,[field-length][,['title']]])
Displays an input box containing message-text in which the user must respond to before
continuing work in other SuperVision windows. The varname must be supplied and
represents the name of the REXX local variable that will contain the value the user
enters; the varname defaults to the value of itself, but can contain a value before
InputBox is called. Thus, if the user does not update the value before pressing OK, the
varname will equal itself.
Also, if CANCEL is pressed, then the varname will always equal itself, even if the user
supplied a value. The field-length controls the length of the input field, is optional and
defaults to 255. The title is also optional and replaces the default value of the title bar of
the window. The title may be specified without the field-length, however the appropriate
number of comma's must be supplied. The default value for title is Host ID, program
name, and the program's address space identifier. (ASID).
RETURN CODES
CANCEL 0
OK 1
Examples
To display the input box to the user with the message-text of "Test Input Box", then
determine the key that was pressed and the value provided:
To add a title:
x=InputBox('Test Input Box','MYVAR',,'This is my Title')
To specify a length of 12 for the input field:
x=Inputbox ('Test Input Box','MYVAR',12)
Syntax: Insert(new,destination[,[n][,length][,pad]]])
The destination string has the new string inserted into it after position n (0 or more) for
length characters. Padding will occur when the new string is less than length. If n is more
than the size of the destination, padding occurs to reach the position.
Insert('wall','paint') == "wallpaint"
Insert(' to','wallpaint, 4,6,'-' == "wall to---paint"
Insert('paste','white',7) == "white paste"
LastPos (sub_str,main_str[,start])
Left (string,length[,pad])
Length (string)
LineIn (name)
LineOut (name[,string])
ListHostGlobals
ListNodeGlobals
LogSwitch (Host [,option])
Syntax: LastPos(sub_str,main_str[,start])
Will return the character position of the last occasion the string sub_str occurs in string
main_str. Searching proceeds backwards from the start position (default end-of-string). A
zero is returned if it is not found.
Syntax: Left(string,length[,pad])
Will return length characters starting from the left end of string. If the source string is
shorter than length, the remaining spaces are padded.
Left('-xyz',10,'$') == "-xyz$$$$$$"
Left('AEIOU',3) == "AEI"
Syntax: Length(string)
school = 'elementary'
Length(school) == 10
Syntax: LineIn(name)
Where name is the name of the text file to read. If no path is specified, the file will be
opened in the c:\SV or Sv4 directory.
To open a file in the current directory, give a path to that directory or use the '.' alias for
the current directory (i.e., '.\filename.ext'). Returns a string containing the current line
from the specified text file. Each call to LineIn returns the next line from the file. Blank
lines are skipped.
When the end of the file is reached or a DOS error occurs, a null string is returned.
Syntax: LineOut(name[,string])
Where name is the name of the text file to write. If no path is specified, the file to be
written to will be opened in the same directory in which the REXX program is located.
To write to a file in the current directory, give the path to that directory or use the '.' alias
for the current directory (i.e., '.\filename.ext').
If the file exists, it is opened and the current write position is set to the end of the file.
Any output is then appended to the current contents of the file.
If string is specified, that string will be written to the end of the file along with the
carriage return/line feed that always terminates the output. If string is not specified, a
carriage return/line feed will still be written.
Returns a "0" after a successful write and a "1" if the write fails.
/* Examples */
/* The following three calls */
The logswitch function designed for VM upload. If file does not exist this function
creates a separate .old file for the host specified and if it does exist it adds to the file so
that it may be used for VM upload function.
Option: this is to be specified only at the beginning of the program to reset the
logswitch pointer into the file.
Example:
x = logswitch(1, 1) /* this reset the logswitch pointer into the .old file */
/* and if the file does not exist it creates the file */
x = logswitch(1) /* if file exist this will add it hte file, if not it will create the
file */
Max (numlist)
MassageBox (message-text[,[title][,[buttons][,[icon]]]])
Min (numlist)
Msg
Syntax: Max(numlist)
Will return the largest value from a list of one or more numbers.
Max(2,4,6,88,7,5,3,-1)
== 88
© SecureAgent Software, Tulsa OK USA. All rights reserved.
MassageBox Function
Syntax: MessageBox(message-text[,[title][,[buttons][,[icon]]]])
Displays a message box containing message-text in which the user must respond before
continuing work in other SuperVision windows. Optionally, the title, buttons, and icon
can be specified. If message-text is the only argument specified, then the message box
will default to the following characteristics:
Title will contain the Host ID, program name, and the program's address space identifier
(ASID)
Buttons will be OKCANCEL, and the icon will be STOP. The return results depend on
the buttons definitions below. You may specify buttons without title or icon without title
and/or buttons, however the appropriate number of comma's must be supplied.
For example, to specify the icon without the title and buttons:
MessageBox('Sample Text',,'QUESTION')
Return Codes:
IGNORE 0
NO 0
OK 1
YES 1
RETRY 1
ABORT 2
CANCEL 2
ICON Definition
EXCLAMATION or ! Provides a message box with the "!" icon
Examples:
To produce a message box with the text of "Test MessageBox", two buttons (YES and
NO), and the stop sign icon:
x=MessageBox('Test MessageBox')
To produce a message box with the text of "Test MessageBox", title of "Message Box
Title", three buttons (ABORT, RETRY, and IGNORE), and the icon of question:
To produce a message box with the text of "Test MessageBox", the default title, the
default buttons, and the exclamation icon:
Syntax: MIN(numlist)
Will return the lowest value from a list of one or more numbers.
Min(2,4,-6,88,7,5,3,-1)
== -6
Syntax: Overlay(new,destination[,[n][,[length][,pad]]])
This function is exactly like the Insert function except that existing characters in the
destination string are overwritten by the new string.
Overlay('x','wallpaper',4,5,'!')
== "walx!!!!r"
Syntax: Pos(sub_str,main_str[,start])
This is just like the LastPos function except that it searches forward from either the
(default) beginning of the string or a specified position.
Random
Reboot
ReceiveFile
RecordIn (name,[rec#],recsize)
RecordOut (name,string[,[rec#],[recsize][,pad])
Reverse (string)
Right (string,length[,pad])
Syntax: RecordIn(name,[rec#],recsize)
Returns a string containing recsize bytes (or a null string if end-of-file or DOS error).
Where name is the name of the file to read. If no path is specified, the file will be opened
in the c:\SV or Sv4 directory.
To open a file in the current directory, give a path to that directory or use the '.' alias for
the current directory (i.e., '.\filename.ext'). The optional rec# is the number of the record
to read from the file. If no rec# is given, a record is read from the location immediately
after the end of the previous read (or the beginning of the file if the file was not
previously open).
Finally, recsize is the size of each record in bytes. Note that the first record in the file is
numbered zero (0), not one (1)!
myline = RecordIn('.\MY.TXT',9,80)
/* fetches TENTH line */
Syntax: RecordOut(name,string[,[rec#],[recsize][,pad])
Where name is the name of the file to which data will be written. If no path is specified,
the file will be opened in the c:\SV or Sv4 directory.
To write to a file in the current directory, give a path to that directory or use the '.' alias
for the current directory (i.e., '.\filename.ext').
If the file exists, it is opened and the current write position is set at the end of the file so
that any output is appended to the current contents of the file.
String is the text string to write at the specified location in the file. If no record size
(recsize) is given, the length of the string is used as the record size (unless a random-
access record number is specified). If a record size is given, the string is truncated or
padded on the right to the specified length.
Rec# is the record number within the file where the write should occur. If this is omitted,
the record is written immediately following the position of the previous write (or at the
end of the file if it was not previously written).
Note that all records must be of the same size, since the rec# and recsize are used to
calculate the file position for random access.
Warning: If rec# is given, then recsize MUST ALSO BE GIVEN in order to calculate
the position of the start of the record. The string being written is truncated or padded on
the right with the pad character as necessary to match this size. Returns a "0" if the write
succeeded, "1" otherwise.
Syntax: Reverse(string)
Reverse('B12345x')
== "x54321B"
Reverse('RETUPMOC')
== "COMPUTER"
Syntax: Right(string,length[,pad])
Will return length characters starting from the right end of string. If the source string is
shorter than length, the remaining spaces are padded.
Right('-xyz',10,'$')
== "$$$$$$-xyz"
Right('AEIOU',3)
== "IOU"
Sam_Alert
Send
SendFile
SendMail
SendSNMPTrap
SetComPort (‘ComPort’ [, ‘Baud Rate’] [, ‘DataBit’] [, ‘StopBit’] [, ‘Parity’])
SetCurrentHost (host)
SetCursor
SetHostName (hostid, text)
SetKeyGroup (keygroup, option)
ShellCommand
Sign (number)
SourceLine
Space (string[,[n][,pad]])
Speak
Sql_AddColumn (DatabaseID,"TableName","ColumnName","DataType")
Sql_AddEntry (DatabaseID,"TableName","Values")
Sql_CloseDatabase (DatabaseID)
Sql_CreateTable (DatabaseID,"TableName","ColumnNameAndInfo")
Sql_DeleteColumn (DatabaseID,"TableName","ColumnName")
Sql_DeleteEntry (DatabaseID,"TableName","Entry")
Sql_DeleteTable (DatabaseID,"TableName")
Sql_GetColumns (DatabaseID,"TableName","Stem")
Sql_GetEntries
(DatabaseID,"TableName","ColumnName(s)","EntriesStem"[,"SortStatement"]
[,"Delimiter"]])
Sql_GetErrorMessage ("ErrorString")
Sql_GetTables (DatabaseID,"TablesStem"[,"Wildcard"])
Sql_IssueStatement (DatabaseID,"SqlStatement")
Sql_IssueStatementAndGetResults
(DatabaseID,"SqlStatement","FieldsStem","RowsStem","Delimiter")
Sql_OpenDatabase ("DatabaseName"[,"UserID","Password"])
Sql_RenameColumn
(DatabaseID,"TableName","OriginalColumnName","NewColumnName","DataType")
Sql_RenameTable (DatabaseID,"OriginalTableName","NewTableName")
StartScript (ScriptName)
StatusDisplay (stream[,operation[,streamcommand]])
Strip (string[,[option],[char]])
StrLwr (str)
StrUpr (str)
SubStr (source,n[,[length][,pad]])
SubWord (source,n[,length])
SVAttach
SVClearLogs
SVConnect
SVDetach
SVDisconnect
SVMenu (menu, item)
SVScheduleAdd ("session_name", "command_text", "date/time"’[, "RepeatType",
"RepeatValue"])
SVScheduleDisable (ID#)
SVScheduleEnable (ID#)
SVScheduleList (list_stem_name[,session_name_filter])
SVScheduleRemove (ID#)
SVT_Dial (number_to_dial)
SVT_GetDigits (how_many_digits)
SVT_HangUp
SVT_Init (channel_to_use)
SVT_Play
SVT_Record (filename)
SVT_Speak (text_to_speak)
Symbol (symbol_string)
Allows the user to specify a com port and additional option are the baud rate, data bit,
stop bit and parity. If these are not specified, the function will use the default setting of
2400, 7, 1, even.
Data Bit: Specify number of bits in the bytes transmitted and received.
Value Meaning
0 1 stop bit
1 1.5 stop bits
2 2 stop bits
Parity: Specify the parity scheme to be used. This member can be one of the
following values:
Value Meaning
0 none
1 odd
2 even
3 mark
4 space
Examples:
x = SetComPort("COM1", 2400, 7, 0, 2)
The x return code will either be 0 for a good return or else an error number.
Syntax: SetCurrentHost(host)
This REXX function sets the host specified to the current or active host.
Example:
x = setcurrenthost(‘B’)
HostId String "A", "B", "C", etc. as appropriate, defining to which scrolling (host)
window the
Text The new name for the given Host. The name is limited to a maximum of
30 characters.
The name cannot start with "COAX" or "TWINAX"; these are reserved names.
"default" will restore the original LU name used to make the connection.
The return code for this function will contain valid information as follows:
Built-In Functions
This REXX function allows you to switch keygroups on or off under REXX control.
Where KEYGROUP is the keygroup number from 1 to 16, and OPTION is either a one
or zero, depending upon whether you want to activate or de-activate the keygroup
respectively.
Return codes:
Use AutoEdit to create one. (See AutoEdit for creating a new keygroup.)
Syntax: SIGN(number)
Will return a value signifying the sign of a number. Negative returns a "-1". Positive
returns a "1". Zero returns a "0".
SIGN(200)
== 1
SIGN('00000')
== 0
Syntax: Space(string[,[n][,pad]])
Standardizes the spacing of blank delimited words in string by removing any trailing and
leading spaces and either removing spaces and/or adding pad. The default value of n is
"1".
Syntax: Strip(string[,[option],[char]])
Takes out any cases of a single char (default space) that are trailing and/or leading the
string. There are only three possible single character options: Both, Leading, or Trailing.
The default is Both.
Syntax: StrLwr(str)
Returns a string containing str with all uppercase characters converted to lowercase.
Syntax: StrUpr(str)
Returns a string containing "str" with all lowercase characters converted to uppercase.
Syntax: SubStr(source,n[,[length][,pad]])
A substring of length (default rest of string) characters is returned from the source string
beginning at position n. The pad character will be used to achieve length as required
including filling the entire substring if n is beyond the end of the source string.
SubStr('123abc',3)
== "3abc"
SubStr('123abc',3,7,'*')
== "3abc***"
© SecureAgent Software, Tulsa OK USA. All rights reserved.
SubWord Function
Syntax: SUBWORD(source,n[,length])
Returns a substring from source string (of space delimited words) starting at word
number n and containing the rest of the source string unless a length number of words is
specified. Both trailing and leading blanks are omitted. Should n be greater than the
number of words in the source, a null string is returned.
== "and seven"
In both cases, the reference consists of the underlined letter from the appropriate menu
entry.
In each case, only the first character of the parameter is significant. Therefore, the "H"
could have been given as "Host" for the menu parameter, perhaps for clarity. However,
putting "
Select/Goto Host C" for the item parameter would result in selecting the "SuperVision
messages" entry, since it starts with the letter "S". For this reason, "C" was used to give
the item parameter.
Note: Not all menu items are supported by this function. As a general rule, only those
items that can be selected via a single hot key are supported (often denoted by a single
underlined character).
Syntax: SYMBOL(symbol_string)
a=33
/* assign value to variable */
Symbol(a) == LIT
Time ([option])
Tn3270Connect
(‘SessionName’,‘Target_IP’,‘LU_Name’,ModelNumber,‘VisaraIndicator’)
Trace
TraceRoute
Translate (stem, string [, tableo][, tablei][,pad])
Trunc
TwinaxGetCursor
TwinaxGetNextScreen
TwinaxGetScreen (twinax, stem_name)
TwinaxPress (‘TWINAXn’,’key’)
TwinaxSetCursor (‘TWINAX#’,row,col)
TwinaxText (‘TWINAX#’,text)
TypeText
Syntax: Time([option])
Will return the current system time in "hh:mm:ss" format. Default is 24-hour style.
The option string is activated by the supplying first letter of its name. The options are:
Time() == "7:30:00"
/* 7:30 in the morning */
Time('c') == "7:30:00am"
Time('H') == "7"
Time('M') == "450"
Time('n') == "17:00:00"
/* 5:00 in the afternoon */
The translate function acts by searching the input translate table, tablei, for each character
in string. If the character is found (the first (leftmost) occurrence being used if there are
duplication) then the corresponding character in the output translate table, tableo, is used
in the result string; Otherwise the original character found in string is used. (see page 111
of The REXX Language, by M.F.Cowlishaw)
Examples:
This REXX function gets the twinax screen data and stores it into the stem name.
Example:
count = 0
x = twinaxgetscreen(twinax1, scrn)
Do While count < scrn.0
count=count+1
Say scrn.count
End
© SecureAgent Software, Tulsa OK USA. All rights reserved.
TwinaxPress Function
Syntax: TwinaxPress('TWINAXn','key')
The TwinaxPress function allows you to press a specific key on the specified twinax.
TWINAXn must be TWINAX1, TWINAX2, TWINAX3, TWINAX4, TWINAX5,
TWINAX6, TWINAX7, and TWINAX8. Valid keys are shown below:
Return Codes:
0=OK 1=twinax not available 2=hung (undesired response)
3=unknown key
Examples:
/* The following example will press the enter key on an OS/400 console attached to
TWINAX1.*/
x=TwinaxPress('TWINAX1','ENTER')
Syntax: TwinaxSetCursor('TWINAX#',row,col)
Position Cursor on screen
Return Codes
0=OK
1=twinax not available
2=twinax not responding as desired (hung)
3=bad row specified
4=bad col specified
Syntax: TwinaxText('TWINAX#',text)
Verifies that the string is composed only of characters from reference, by returning the
position of the first character in the string that in not also in reference. If all the
characters were found in reference, "0" is returned.
If string is null, the function returns "0", regardless of the value of the third argument.
If reference is null, then the returned value is the value used for start, unless ‘Match’ is
specified (in which case "0" is returned).
The default for start is "1", i.e., the search starts at the first character of the string. This
can be overridden by giving a different start point, which must be positive.
The option may be either ‘Nomatch’ (default) or ‘Match’. Only the first character if the
option is significant and it may be upper case or lower case, as usual. If ‘Match’ is
specified, the position of the first character in string that is in reference is returned, or 0 if
none of the characters were found (see page 113 of The REXX Language, by
M.F.Cowlishaw).
Examples:
x = verify('123', '1234567890') =0
x = verify('1Z3', '1234567890') =2
x = verify('AB4T', '1234567890', 'M') =3
x = verify('1P3Q4', '1234567890', , 3) =4
x = verify('ABCDE', '', , 3) =3
x = verify('AB3CD5', '1234567890', 'M', 4) = 6
Word (string,n)
WordIndex (string,n)
WordLen
WordLength (string,n)
WordPos (phrase,string[,start])
Words (string)
Write2Com ("Com Port", "ASCII string")
Syntax: Word(string,n)
Same as SubWord(string,n,1). Will return just one word from word position n in the
string.
Syntax: WordIndex(string,n)
The character position of string's nth word. If n exceeds the actual number of space
delimited words, a "0" is returned.
Syntax: WordLength(string,n)
The length of word n in string is returned. Should n exceed the actual number of space
delimited words, a "0" is returned.
Syntax: WordPos(phrase,string[,start])
Searches for a space delimited phrase in string and returns the position of the first word
match. Returns a "0" if it cannot find it. It will search from the first word in string unless
a start word position is supplied.
Syntax: Words(string)
This function writes ASCII characters out to the specified com port.
Example:
x = Write2Com("com1", "Hello World, Welcome to SuperVision")
Note: Recommend calling the REXX function "setcomport()" first to set up the com
port.
The PARSE and ARG instructions have the ability to allocate parts of a specified input
string to memory variables according to a template. The different kinds of controls within
a template give these commands the option to split up the input string by numeric
position, matched strings (patterns), and/or merely by space delimited words.
Elementary Parsing
Comma as a Literal String
The template consists of the variables "a", "b", and "c". The space delimited words are
read and assigned to the space delimited variables. "a" holds the value of "The", "b" holds
"parking", and "c" holds "fee is being cut!".
If there are more variables than words to parse, the excess variables are assigned a null
value. Note that the delimiting leading and trailing spaces for the first two variables have
been removed.
The use of patterns can refine the assignment of variables when those patterns are
anticipated as part of the input. Remember that the input string can also be a variable.
In this PARSE statement, "a" will be assigned "Avail. Dec. 1" (everything up to but NOT
including the comma) and "b" is assigned the year string INCLUDING the leading space
(" because there is a pattern being used at that point rather than just spaces and "c" gets
"to owners" without the leading space. If there were no comma in the input string, the
entire string would be assigned to "a" and the other variables would be set to null.
Parsing can be done by an exact character (or column) position which will designate the
position along the input string that will begin assigning value to the next variable:
In this example, "a" will receive everything from positions 1-7 ("Avail. "). "b" will get
everything from positions 8-15 ("Dec. 1, ") and "c" gets the rest ("1993 to owners").
Should we want to assign everything to the comma and skip the rest of the input string,
we can use this:
If we just want to skip the first or last words of the input string and not use up variable
names, the period "." acts as a dummy (or placeholder):
will assign "gigabytes" to variable "x" and discard the rest. This can be used with other
controls.
There is a general rule that parsing will go from left to right and as REXX encounters
symbols in the template, parts of the input string will be assigned to variables or skipped.
Assignments or skips can be by space delimited words, up to a specified character
pattern, or to a specified character position. All template controls can be mixed together
as required.
In the above example, the text in this_string is converted to upper case (option used for
this example). The first character is "*" and it alone is assigned to "star" because the "2"
in the template begins assignment into "x1" at the second character position. Assignment
to "x1" continues until the "-" is encountered in the template. Then "IN" is discarded
because of the placeholding period character. The word "COOLING" is assigned to "b2"
and the remainder of the string ("ON EVERY CHIP") is discarded because of the final
placeholding period.
Finally, this same template could be used after invoking a routine by using PARSE ARG
in the destination routine.
Another use is just to find out what the system time is:
REXX supports 32-bit integer arithmetic. A numeric value is any continuous string of
decimal digits zero through nine (0-9). There may be a sign prefix as part of the string.
/* valid numbers */
123
/* a simple, 3 digit value */
+45
/* a positive signed number */
-789
/* a negative signed number */
2400000000
/* 2.4 billion */
The two types of errors which may occur are related to either insufficient storage for an
intermediate or final value and to arithmetic underflow or overflow by the processor.
REXX supports file I/O, output to SuperVision and input from the operator on the
SuperVision Console.
Because REXX can read text files, a program can be written to read in a console log from
Super
Vision and play it back to SuperVision as Host Output. The capability of writing text files
can be used to write logs during testing of SuperVision automation routines.
There are only reserved symbols in REXX. A programmer may indeed wish to create a
label or variable using what should normally be regarded only as a keyword or
instruction. For example:
exit:
/* EXIT as a label */
SAY 'End of program'
EXIT
/* Terminate routine */
return:
/* keyword as label */
1. It makes the program confusing to read and support. Quite frequently, programs
have to be changed after months or years of use. The original programmer can hardly be
expected to recall all the circumstances and reasoning surrounding the creation of some
code. Should another programmer need to make changes, coding clarity becomes critical.
The new programmer is expecting a keyword to have just one meaning and not two or
three as in the examples above.
2. It complicates editing. Most text editors have a "Search and Replace" feature. If a
keyword is used as a variable name and the editor is told to replace all occasions of "say"
(as in example number 3) with "pay" then all occasions of the "SAY" instruction would
also be replaced. One can easily imagine the number of errors reported if the program is
then executed.
The implementation of REXX has two special variables that can be set during program
execution.
The REXX Editor program (rexxedit.exe) is automatically loaded into the SV directory
(Sv4 if running a version prior to 5.0) as part of the Typical setup type when SuperVision
is installed. If, however, the REXX Editor should need to be re-installed as a stand-alone
program, or if you chose a setup option other than Typical, complete the following
instructions for installing Super
Vision. You will be prompted at the point of custom setup** to select only the REXX
component.
NOTE: REXX Editor upgrades will automatically install over and replace any previous
versions.
Displaying Windows
1. Select File from the program menu bar, and New from the drop-down menu that
appears, or
2. Press the New File button
1. Select File from the program menu bar, and Save from the drop-down menu that
appears, or
2. Press the Save File button
Selecting the Save option will automatically update the file for the active window, while
selecting Save As allows the user to name a file and chose the destination BEFORE
writing information to disk.
1. Select Edit from the program menu bar, and Cut from the drop-down menu that
appears, or
2. Press the Cut Highlighted Text button
The text that has been cut may now be pasted into a different position, or a different file.
1. Select Edit from the program menu bar, and Copy from the drop-down menu that
appears, or
2. Press the Copy Highlighted Text button
The text that has been copied to the clipboard may now be pasted into a different
position, or a different file.
1. Select File from the program menu bar, and Print from the drop-down menu that
appears, or
2. Press the Print Window button
A checkmark to the left of the option indicates enabled, while the absence of the
checkmark indicates disabled.
When enabled, this option automatically establishes the selected display and printing font
sizes as the default settings of the ACTIVE file window.
A checkmark to the left of the option indicates enabled, while the absence of the
checkmark indicates disabled.
When enabled, this option provides access to the following color sets of the ACTIVE file
window: Default Black, Default White, Custom, and Define Custom.
A checkmark to the left of the option indicates enabled, while the absence of the
checkmark indicates disabled.
When enabled, this option yields a menu that allows the user to select font size for text
displayed in the ACTIVE file window.
A checkmark to the left of the option indicates enabled, while the absence of the
checkmark indicates disabled.
When enabled, this option yields a menu that allows the user to select font size for
printing text in the ACTIVE file window.
A checkmark to the left of the option indicates enabled, while the absence of the
checkmark indicates disabled.
© SecureAgent Software, Tulsa OK USA. All rights reserved.
Status Bar
When enabled, this option allows the status bar to be displayed at the bottom of the
ACTIVE file window. The bar displays the line and column number associated with
cursor placement in the document.
A checkmark to the left of the option indicates enabled, while the absence of the
checkmark indicates disabled.
When enabled, this option will cause strings of text, in the ACTIVE file window, to be
displayed in their assigned color.
A checkmark to the left of the option indicates enabled, while the absence of the
checkmark indicates disabled.
When enabled, this option will cause the REXX Editor Toolbar to be displayed at the top
of the ACTIVE file window.
1 To enable or disable this option :
A checkmark to the left of the option indicates enabled, while the absence of the
checkmark indicates disabled.
1. Select Window from the program menu bar, and New Window from the drop-
down menu that appears.
1. Select Window from the program menu bar, and Cascade from the drop-down
menu that appears.
1. Select Window from the program menu bar, and Tile Horizontally from the
drop-down menu that appears.
1. Select Window from the program menu bar, and Tile Vertically from the drop-
down menu that appears.