Quantcast
Channel: IBM Mainframe Computers Forums
Viewing all articles
Browse latest Browse all 9405

COBOL Programming :: RE: Wildcard logic in COBOL

$
0
0
Author: dudenithy
Posted: Tue Sep 06, 2016 6:55 pm (GMT 5.5)

Hello all again,

Good News.. I believe I have done the Wildcard logic process in COBOL itself icon_biggrin.gif. Please find the code below. This should work according to below restrictions:
1. Wildcard Symbol * shouldn't occur continuously. 2. Wildcard symbols * and ? shouldn't occur contiuously.
You are much appreciated to correct me if you find something which can be done efficiently or logic holes any.
Code:
       FD  INPUT-FILE                                                   
           RECORDING MODE IS F BLOCK CONTAINS 0 RECORDS.                 
       01  IN-RECORD.                                                   
           05  WS-STRING             PIC X(20).                         
           05  FILLER                PIC X(30).                         
      *                                                                 
       WORKING-STORAGE SECTION.                                         
       01 WS-DATA.                                                       
           03  EOF                   PIC X(01) VALUE 'N'.               
      *        PARAMETER WITH / WITHOUT WILDCARD SYMBOLS '*' '?'         
      *    03  PARM                  PIC X(20) VALUE '*345'.             
      *    03  PARM                  PIC X(20) VALUE '*ES'.             
      *    03  PARM                  PIC X(20) VALUE '123*'.             
      *    03  PARM                  PIC X(20) VALUE 'PAY PAL*'.         
      *    03  PARM                  PIC X(20) VALUE '*AL SER*'.         
      *    03  PARM                  PIC X(20) VALUE 'E?AY?SE?'.         
           03  PARM                  PIC X(20) VALUE '*L SERV?C* LT?'.   
      *        CHARACTERS AFTER WILDCARD * IN PARAMETER                 
           03  PART1                 PIC X(20).                         
      *        CHARACTERS AFTER WILDCARD * BUT BEFORE ? IN PARAMETER     
           03  PART2                 PIC X(20).                         
      *        LENGTH OF PART1                                           
           03  WS-PART1              PIC 9(02) VALUE 0.                 
      *        LENGTH OF PART2                                           
           03  WS-PART2              PIC 9(02) VALUE 0.                 
      *        COUNT FOR WILDCARD '?'                                   
           03  WS-Q                  PIC 9(02) VALUE 0.                 
      *        COUNT FOR WILDCARD '*'                                   
           03  WS-A                  PIC 9(02) VALUE 0.                 
      *        STRING BYTE REFERENCE                                     
           03  WS-I                  PIC 9(02) VALUE 0.                 
      *        PARAMETER BYTE REFERENCE                                 
           03  WS-J                  PIC 9(02) VALUE 0.                 
      *        PARM LENGTH UNTIL NEXT WILDCARD                           
           03  WS-K                  PIC 9(02) VALUE 0.                 
      *        PARM LENGTH EXCL.TRAILING SPACES WHEN NO MORE WILDCARDS   
           03  WS-L                  PIC 9(02) VALUE 0.                 
      *        MATCHING PARM CHARS AFTER WILDCARD * AGAINST INPUT STRING
           03  WS-MATCH-FND          PIC X(01) VALUE ' '.               
               88 MATCH-FND                    VALUE 'Y'.               
      *        RESULT                                                   
           03  WS-COMPARE-FLAG       PIC X(01) VALUE ' '.               
               88 WS-COMPARE-TRUE              VALUE 'Y'.               
               88 WS-COMPARE-FALSE             VALUE 'N'.               
      *                                                               
       PROCEDURE DIVISION.                                           
      *                                                               
       0000-MAIN-CONTROL.                                             
           PERFORM 0100-MAIN-CONTROL                                 
           GOBACK                                                     
           .                                                         
      *                                                               
       0100-MAIN-CONTROL.                                             
           INSPECT PARM TALLYING WS-Q FOR ALL '?'                     
           INSPECT PARM TALLYING WS-A FOR ALL '*'                     
      *                                                               
           OPEN INPUT INPUT-FILE                                     
      *                                                               
           READ INPUT-FILE                                           
              AT END MOVE 'Y' TO EOF                                 
           END-READ                                                   
      *                                                               
           PERFORM UNTIL EOF = 'Y'                                   
              MOVE SPACE                 TO WS-COMPARE-FLAG           
              MOVE ZEROS                 TO WS-I                     
                                            WS-J                     
                                            WS-L                     
      *                                                                 
              EVALUATE TRUE ALSO TRUE                                   
                  WHEN WS-Q = 0        ALSO WS-A = 0                   
                       IF  PARM          IS EQUAL WS-STRING             
                           SET WS-COMPARE-TRUE  TO TRUE                 
                       ELSE                                             
                           SET WS-COMPARE-FALSE TO TRUE                 
                       END-IF                                           
                  WHEN OTHER                                           
                       PERFORM COMPLEX-LOGIC                           
                       IF NOT WS-COMPARE-TRUE  AND NOT WS-COMPARE-FALSE
                          SET WS-COMPARE-TRUE   TO TRUE                 
                       END-IF                                           
              END-EVALUATE                                             
      *                                                                 
              READ INPUT-FILE                                           
                 AT END MOVE 'Y' TO EOF                                 
                 NOT AT END                                             
                   IF WS-STRING IS EQUAL SPACES                         
                      MOVE 'Y' TO EOF                                   
                   END-IF                                               
              END-READ                                                 
           END-PERFORM                                                 
      *                                                                 
           CLOSE INPUT-FILE                                             
           .                                                           
      *                                                                 
       COMPLEX-LOGIC.                                                   
           MOVE 1                        TO WS-I                       
                                            WS-J                       
           PERFORM UNTIL WS-COMPARE-TRUE OR WS-COMPARE-FALSE    OR     
                           WS-I > LENGTH OF WS-STRING           OR     
                           WS-J > LENGTH OF WS-STRING                   
              EVALUATE TRUE                                             
                  WHEN PARM (WS-J:1)      = '?'                         
                       ADD 1             TO WS-I                       
                                            WS-J                     
                       SUBTRACT 1      FROM WS-Q                     
                  WHEN PARM (WS-J:1)      = WS-STRING (WS-I:1) AND   
                       PARM (WS-J:1)  NOT = '*'                     
                       ADD 1             TO WS-I                     
                                            WS-J                     
                  WHEN (PARM (WS-J:1) NOT = WS-STRING (WS-I:1) AND   
                        PARM (WS-J:1) NOT = '*')                     
                       SET WS-COMPARE-FALSE TO TRUE                 
                  WHEN PARM (WS-J:1)      = '*'                AND   
                       PARM (WS-J + 1:)   = SPACES                   
                       SET WS-COMPARE-TRUE  TO TRUE                 
                  WHEN OTHER                                         
                       ADD  1            TO WS-J                     
                       SUBTRACT 1      FROM WS-A                     
                       UNSTRING PARM(WS-J:) DELIMITED BY '*'         
                           INTO PART1 COUNT IN WS-PART1             
                       END-UNSTRING                                 
      *                                                             
                       IF  WS-A           = 0                       
                           INSPECT FUNCTION REVERSE(PART1)           
                                   TALLYING WS-L FOR LEADING SPACES 
                              COMPUTE WS-L = LENGTH OF PART1 - WS-L 
                              MOVE WS-L  TO WS-PART1                 
                       END-IF                                       
      *                                                             
                       IF  WS-Q           > 0                       
                           UNSTRING PART1   DELIMITED BY '?'         
                               INTO PART2 COUNT IN WS-PART2         
                           END-UNSTRING                             
                           MOVE WS-PART2 TO WS-PART1                 
                       END-IF                                       
      *                                                             
                       MOVE SPACE        TO WS-MATCH-FND             
                       COMPUTE WS-K       = LENGTH OF WS-STRING -   
                                            WS-PART1 + 1             
                       PERFORM UNTIL MATCH-FND  OR  WS-K < WS-I     
                           IF  WS-STRING(WS-K:WS-PART1) =           
                                      PART1(1:WS-PART1)             
                               SET MATCH-FND TO TRUE                 
                               COMPUTE WS-I = WS-K + WS-PART1       
                               COMPUTE WS-J = WS-J + WS-PART1       
                           ELSE                                     
                               SUBTRACT 1 FROM WS-K                 
                           END-IF                                   
                       END-PERFORM                                   
                       IF NOT MATCH-FND                             
                          SET WS-COMPARE-FALSE TO TRUE               
                       END-IF                                       
              END-EVALUATE                                           
           END-PERFORM                                               
           .                                                         


Viewing all articles
Browse latest Browse all 9405

Trending Articles