Combining String And Positional Patterns: A Special Case - IBM SC34-5764-01 Manual

Parsing
This instruction consists of the keywords PARSE ARG and three comma-separated templates. (For an
ARG instruction, the source strings to parse come from arguments you specify when you call a program or
CALL a subroutine or function.) Each comma is an instruction to the parser to move on to the next string.
Example:
/* Parsing multiple strings in a subroutine
num='3'
musketeers="Porthos Athos Aramis D'Artagnon"
CALL Sub num,musketeers /* Passes num and musketeers to sub
SAY total; say fourth /* Displays: "4" and " D'Artagnon"
EXIT
Sub:
parse arg subtotal, . . . fourth
total=subtotal+1
RETURN
Note that when a REXX program is started as a command, only one argument string is recognized. You
can pass multiple argument strings for parsing:
v When one REXX program calls another REXX program with the CALL instruction or a function call.
v When programs written in other languages start a REXX program.
If there are more templates than source strings, each variable in a leftover template receives a null string.
If there are more source strings than templates, the language processor ignores leftover source strings. If
a template is empty (two commas in a row) or contains no variable names, parsing proceeds to the next
template and source string.

Combining String and Positional Patterns: A Special Case

There is a special case in which absolute and relative positional patterns do not work identically. We have
shown how parsing with a template containing a string pattern skips over the data in the source string that
matches the pattern (see page 205). But a template containing the sequence:
v string pattern
v variable name
v relative positional pattern
does not skip over the matching data. A relative positional pattern moves relative to the first character
matching a string pattern. As a result, assignment includes the data in the source string that matches the
string pattern.
/* Template containing string pattern, then variable name, then */
/* relative positional pattern does not skip over any data.
string='REstructured eXtended eXecutor'
parse var string var1 3 junk 'X' var2 +1 junk 'X' var3 +1 junk
say var1||var2||var3 /* Concatenates variables; displays: "REXX" */
Here is how this template works:
│var1 3│ │junk 'X'│
└───┬───┘ └───┬────┘
│ │
Put Starting
characters at 3, put
1 through characters
2 in var1. up to (not
(Stopping including)
point is first 'X'
3.) in junk.
var1='RE' junk=
'structured
e'
212
CICS TS for VSE/ESA: REXX Guide
│var2 +1│ │junk 'X'│
└───┬───┘ └────┬────┘
│ │
Starting Starting
with first with char─
'X' put 1 acter after second 'X' acter
(+1) first 'X'
character put up to
in var2. second 'X'
in junk.
var2='X' junk=
'tended e'
*/
*/
*/
*/
│var3 +1 │ │ junk │
└───┬────┘ └──┬───┘
│ │
Starting Starting
with with char─
put 1 (+1) after sec─
character ond 'X'
in var3. put rest
in junk.
var3='X' junk=
'ecutor'