Re: unstring empty string

OK, here's the latest and greatest, taking some suggestions, and not taking
others (see below for why).

ID DIVISION.
PROGRAM-ID. UNSTR.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-INIT-PARM-LEN PIC S9(4) BINARY.
01 WS-INIT-PARM.
05 PIC X OCCURS 0 TO 60 DEPENDING ON WS-INIT-PARM-LEN.
01 PARMS-STUFF.
05 PPTR PIC S9(3) COMP.
05 PARM PIC X(60).
05 PARM-LEN PIC S9(3) COMP-3.
05 PARM-NAME PIC X(60).
05 PARM-NAME-LEN PIC S9(4) COMP.
05 PARM-VALUE PIC X(60).
05 PARM-VAL-LEN PIC S9(4) COMP.
05 PARM-DELIM PIC X.
05 PARM-SYS PIC X VALUE LOW-VALUES.
88 PARM-SYS-IS-DEV VALUES 'D' 'X' 'T'.
05 PARM-ATMSYS PIC X(4) VALUE LOW-VALUES.

LINKAGE SECTION.
01 INPUT-PARM.
05 INPUT-LEN PIC S9(4) COMP.
05 INPUT-DATA PIC X(80).

PROCEDURE DIVISION USING INPUT-PARM.
MOVE INPUT-LEN TO WS-INIT-PARM-LEN
MOVE INPUT-DATA TO WS-INIT-PARM
DISPLAY '(' WS-INIT-PARM ')'
PERFORM 0010-CHECK-INITPARMS
IF PARM-SYS = LOW-VALUES
DISPLAY 'SYSTYPE NOT SET'
ELSE
DISPLAY 'SYSTYPE = ' PARM-SYS
END-IF
IF PARM-ATMSYS = LOW-VALUES
DISPLAY 'ATMSYS NOT SET'
ELSE
DISPLAY 'ATMSYS = ' PARM-ATMSYS
END-IF
STOP RUN.

0010-CHECK-INITPARMS.
MOVE 1 TO PPTR
PERFORM UNTIL PPTR > FUNCTION LENGTH(WS-INIT-PARM)
UNSTRING WS-INIT-PARM
DELIMITED BY ',' OR ALL SPACES
INTO PARM, COUNT IN PARM-LEN
WITH POINTER PPTR
END-UNSTRING
PERFORM 0011-CHECK-PARM
END-PERFORM
EXIT.

0011-CHECK-PARM.
IF PARM-LEN > ZERO
UNSTRING PARM
DELIMITED BY '=' OR ALL SPACES
INTO PARM-NAME, DELIMITER IN PARM-DELIM
PARM-VALUE
IF PARM-DELIM = '='
EVALUATE PARM-NAME
WHEN 'SYSTYPE'
MOVE PARM-VALUE TO PARM-SYS
WHEN 'ATMSYS'
MOVE PARM-VALUE TO PARM-ATMSYS
END-EVALUATE
ELSE
DISPLAY 'IGNORING INVALID KW/VAL PAIR'
END-IF
ELSE
DISPLAY 'IGNORING PARM-LEN ZERO'
END-IF
EXIT.

END PROGRAM UNSTR.


Here is the output from many test cases (separated by
'---------------------------')
(SYSTYPE=D,ATMSYS=TAT2)
SYSTYPE = D
ATMSYS = TAT2
---------------------------
(SYSTYPE=D ATMSYS=TAT2)
SYSTYPE = D
ATMSYS = TAT2
---------------------------
(SYSTYPE=D ATMSYS=TAT2)
SYSTYPE = D
ATMSYS = TAT2
---------------------------
(SYSTYPE=D, ATMSYS=TAT2)
IGNORING PARM-LEN ZERO
SYSTYPE = D
ATMSYS = TAT2
---------------------------
(SYSTYPE=D ATMSYS=)
SYSTYPE = D
ATMSYS =
---------------------------
(SYSTYPE=D ATMSYS)
IGNORING INVALID KW/VAL PAIR
SYSTYPE = D
ATMSYS NOT SET
---------------------------
(SYSTYPE= ATMSYS=)
SYSTYPE =
ATMSYS =
---------------------------
(SYSTYPE ATMSYS=ABCD)
IGNORING INVALID KW/VAL PAIR
SYSTYPE NOT SET
ATMSYS = ABCD
---------------------------
(SYSTYPE ATMSYS)
IGNORING INVALID KW/VAL PAIR
IGNORING INVALID KW/VAL PAIR
SYSTYPE NOT SET
ATMSYS NOT SET
---------------------------
(SYSTYPE=D,ATMSYS=TAT2,,,)
IGNORING PARM-LEN ZERO
IGNORING PARM-LEN ZERO
SYSTYPE = D
ATMSYS = TAT2
---------------------------
( SYSTYPE=D ATMSYS=TAT2 )
IGNORING PARM-LEN ZERO
SYSTYPE = D
ATMSYS = TAT2
---------------------------
(=D ATMSYS=TAT2 )
SYSTYPE NOT SET
ATMSYS = TAT2

All of the test results meet my expectations. Obviously, I may have missed
a necessary test.

Anyway, I ended up not initializing PARM, PARM-NAME and PARM-VALUE, as
suggested by Richard. Here are my reasons:

PARM will always be set by the primary unstring because (my observation is)
the first target always gets set to a value, even if it just spaces.

For PARM-NAME and PARM-VALUE I'm instead depending on the '=' delimiter
between the keyword and the value. If the delimiter is not present I simply
ignore the results. It does not matter at this point if PARM-VALUE was not
initialized, since I am not checking it. On the other hand, if the '='
delimiter is present then PARM-VALUE will always be set during the unstring,
therefore no need to initialize.

Not that it would hurt me to initialize these fields. I just choose to be
stubborn! :-)

I did utilize ALL SPACES instead of just spaces. I also eliminated the
check of ', ' (comma/space), since it really isn't necessary (though could
save one UNSTRING iteration if present).

There's doesn't seem to be a need for me to check WS-Init-Parm(PPtr:) =
SPACES. The environment strips trailing spaces automatically. (And even if
it didn't I would think the ALL SPACES delimiter would handle it.)

With regard to using reference modification, I think that, as slightly
convoluted as my code ended up being I think it probably worked out better.
Not that I don't use ref-mod. Just not in this case.

Thanks for the hints! I don't enjoy COBOL all the time, but it can
occasionally be fun. :-)

Frank

.