*> ===============================================================
*> MAIN PROGRAM - demo of range(WS-A , WS-B)
*> ===============================================================
IDENTIFICATION DIVISION.
PROGRAM-ID. RANGEDEMO.
DATA DIVISION.
WORKING-STORAGE SECTION.
*> Range bounds (a, b)
01 WS-A PIC S9(9) COMP VALUE 3.
01 WS-B PIC S9(9) COMP VALUE 8.
*> Result table: WS-COUNT holds the number of valid elements
01 WS-RESULT.
05 WS-COUNT PIC 9(4) COMP VALUE 0.
05 WS-ITEM PIC S9(9) COMP
OCCURS 1 TO 1000 TIMES
DEPENDING ON WS-COUNT.
01 WS-RC PIC S9(4) COMP VALUE 0.
01 WS-I PIC 9(4) COMP.
01 WS-VAL-OUT PIC -(9)9.
PROCEDURE DIVISION.
MAIN-PARA.
CALL "RANGEARR" USING WS-A WS-B WS-RESULT WS-RC
END-CALL
*> Always check the return code
IF WS-RC NOT = 0
DISPLAY "Error: range exceeds table capacity (1000)"
STOP RUN
END-IF
PERFORM PRINT-ARRAY
STOP RUN.
*> Plain output: all values on one line, separated by spaces
PRINT-ARRAY.
PERFORM VARYING WS-I FROM 1 BY 1 UNTIL WS-I > WS-COUNT
MOVE WS-ITEM(WS-I) TO WS-VAL-OUT
DISPLAY FUNCTION TRIM(WS-VAL-OUT) " "
WITH NO ADVANCING
END-PERFORM
*> Finish the line
DISPLAY SPACE.
END PROGRAM RANGEDEMO.
*> ===============================================================
*> SUBPROGRAM RANGEARR - equivalent of range(a, b)
*> Fills a table with a..b (inclusive). If b < a the range
*> is descending, like PHP.
*>
*> LS-A : first value
*> LS-B : last value
*> LS-RESULT: output table (count + items)
*> LS-RC : 0 = OK, 1 = too many elements for the table
*> ===============================================================
IDENTIFICATION DIVISION.
PROGRAM-ID. RANGEARR.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-MAX-ITEMS PIC 9(4) COMP VALUE 1000.
01 WS-DIRECTION PIC S9 COMP. *> +1 or -1
01 WS-N PIC 9(9) COMP. *> number of elements
01 WS-I PIC 9(9) COMP.
LINKAGE SECTION.
01 LS-A PIC S9(9) COMP.
01 LS-B PIC S9(9) COMP.
01 LS-RESULT.
05 LS-COUNT PIC 9(4) COMP.
05 LS-ITEM PIC S9(9) COMP
OCCURS 1 TO 1000 TIMES
DEPENDING ON LS-COUNT.
01 LS-RC PIC S9(4) COMP.
PROCEDURE DIVISION USING LS-A LS-B LS-RESULT LS-RC.
MAIN-PARA.
MOVE 0 TO LS-RC
MOVE 0 TO LS-COUNT
*> 1. Direction and number of elements
IF LS-B >= LS-A
MOVE 1 TO WS-DIRECTION
ELSE
MOVE -1 TO WS-DIRECTION
END-IF
COMPUTE WS-N = FUNCTION ABS(LS-B - LS-A) + 1
*> 2. Guard against overflowing the table
IF WS-N > WS-MAX-ITEMS
MOVE 1 TO LS-RC
GOBACK
END-IF
*> 3. Set the logical size FIRST, then fill the table
MOVE WS-N TO LS-COUNT
PERFORM VARYING WS-I FROM 1 BY 1 UNTIL WS-I > WS-N
COMPUTE LS-ITEM(WS-I) = LS-A + (WS-DIRECTION * (WS-I - 1))
END-PERFORM
GOBACK.
END PROGRAM RANGEARR.
*> run:
*>
*> Array
*> (
*> [0] => 3
*> [1] => 4
*> [2] => 5
*> [3] => 6
*> [4] => 7
*> [5] => 8
*> )
