*DECK SCAN
#***************************************************************# 
#                                                               # 
#                          S C A N                              # 
#                                                               # 
#***************************************************************# 
#     SCAN IS A FUNCTION WHICH COMPARES AN ALPHANUMERIC STRING   #
#     (LITERAL OR DATAITEM) WITH THE CONTENTS OF A FIELD         #
#     (LITERAL OR DATAITEM).  IF ANY SEGMENT OF THE CONTENTS    # 
#     OF THE FIELD MATCHES THE STRING, A FUNCTION VALUE OF ZERO  #
#     IS RETURNED.  IF NO SEGMENT MATCHES, A NON-ZERO VALUE IS   #
#     RETURNED.                                                  #
#                                                                #
      FUNC SCAN (W1, W2, STRINGSTART, DATASTART, STRINGLOC, 
                 DATAITEMLOC, STRINGLENGTH, DATALENGTH);
        BEGIN 
        ITEM W1;
        ITEM W2;
        ITEM STRINGSTART; 
        ITEM DATASTART; 
        ITEM STRINGVAL; 
        ITEM STRINGLOC; 
        ITEM DATAITEMLOC; 
        ITEM STRINGLENGTH;
        ITEM DATALENGTH;
        ITEM I; 
        ITEM J; 
        ITEM TEMP;
        ITEM TEMP1; 
        ITEM TEMP2; 
        XREF ITEM UNIVERSAL;
        ARRAY C1 [1:2]; 
          ITEM C; 
        BASED ARRAY STRING; 
          ITEM STRINGWORD I (0,0,60); 
        BASED ARRAY DATAITEM; 
          ITEM DATAWORD I (0,0,60); 
        DEF NOCHECK#UNIVERSAL GR O"77"#;
        DEF NOMATCH#(C[1] NQ UNIVERSAL AND C[2] NQ UNIVERSAL)#; 
        STRINGVAL = 0;
        TEMP = STRINGSTART; 
        P<STRING> = STRINGLOC;
        P<DATAITEM> = DATAITEMLOC;
        FOR I = 1 STEP 1 WHILE (I + STRINGLENGTH - 1) LQ DATALENGTH DO
          BEGIN 
          TEMP1 = DATASTART;        # SAVE STARTING POSITION           #
          TEMP2 = W2; 
          W1 = 0;     # ALWAYS START WITH WORD 0 OF STRING #
          FOR J = 1 STEP 1 UNTIL STRINGLENGTH DO
            BEGIN 
            C[1] = B<STRINGSTART,6>STRINGWORD[W1];  # GET CHARACTERS #
            C[2] = B<DATASTART,6>DATAWORD[W2];   # FROM STRING AND #
                                                # DATA ITEM.  # 
            IF NOMATCH OR NOCHECK THEN
              BEGIN     # NO UNIVERSAL CHARACTER #
              IF C[1] NQ C[2] THEN   # START A NEW SEARCH # 
                BEGIN 
                J = STRINGLENGTH + 1; 
                STRINGVAL = 1;
                TEST J; 
                END 
              END 
              IF STRINGSTART EQ 54 THEN  # EQUALITY--INCREMENT #
                BEGIN 
                STRINGSTART = 0;   # START BIT AND WORD, #
                W1 = W1 + 1;       # IF NECESSARY # 
                END 
              ELSE STRINGSTART = STRINGSTART + 6; 
              IF DATASTART EQ 54 THEN 
                BEGIN 
                DATASTART = 0;
                W2 = W2 + 1;
                END 
              ELSE DATASTART = DATASTART + 6; 
            END  # END OF THE -J- LOOP #
          IF STRINGVAL EQ 0 THEN
            BEGIN 
            SCAN = 0;    # FOUND A MATCH #
            RETURN; 
            END 
          STRINGVAL = 0;    # RESTART SEARCH #
          STRINGSTART = TEMP;   # RESTORE INITIAL STATUS #
          DATASTART = TEMP1 + 6;    # INCREMENT POSITION IN DATA FIELD #
          IF DATASTART EQ 60 THEN 
            BEGIN 
            DATASTART = 0;
            W2 = TEMP2 + 1; 
            END 
          END   # END OF THE -I- LOOP # 
        SCAN = 1; 
        RETURN; 
        END 
        TERM; 
