Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


Quellcodebibliothek Statistik Leitseite products/sources/formale Sprachen/Delphi/Bille 0.71/__history/ (Columbo Version 0.7^©) Datei vom 14.0.2013 mit Größe 71 kB

Quelle csq4cvb2.cob Sprache: Cobol

      *                  5695-137                                     *
CBL NODYNAM,LIB,OBJECT,RENT,RES,APOST
      * ------------------------------------------------------------- *
       IDENTIFICATION DIVISION.
      * ------------------------------------------------------------- *
       PROGRAM-ID. CSQ4CVB2.
      *REMARKS
      *****************************************************************
      *   @START_COPYRIGHT@                                           *
      *   Statement:     Licensed Materials - Property of IBM         *
      *                                                               *
      *                  5695-137                                     *
      *                  (C) Copyright IBM Corporation. 1993, 1997    *
      *                                                               *
      *   Status:        Version 1 Release 2                          *
      *   @END_COPYRIGHT@                                             *
      *                                                               *
      *  Module Name           : CSQ4CVB2                             *
      *                                                               *
      *  Environment           : CICS/ESA Version 3.3; COBOL II       *
      *                                                               *
      *  CICS Transaction Name : MVB2                                 *
      *                                                               *
      *  Description : Sample program to show the decomposition of an *
      *                inquiry message to a number of queries, the    *
      *                replies from the queries are received and      *
      *                when all are available a response is built and *
      *                sent to the reply to queue of the inquiry.     *
      *                Part completed inquiries are recovered after   *
      *                the application terminates or after system     *
      *                failure.                                       *
      *                                                               *
      *  Function    : This program provides the credit application   *
      *                manager function for the credit check sample   *
      *                See IBM MQSeries for MVS/ESA Application       *
      *                Programming Reference for details.             *
      *                                                               *
      * ************************************************************* *
         EJECT
      * ************************************************************* *
      *                                                               *
      *                    Program logic                              *
      *                    -------------                              *
      *                                                               *
      *START.                                                         *
      *    check the program is started with data.                    *
      *    if no go to invalid-start-routine                          *
      *    end-if                                                     *
      *    get storage for signal processing.                         *
      *    retrieve trigger data.                                     *
      *    if userdata (amount) passed to program                     *
      *        update threshold amount                                *
      *    end-if                                                     *
      *    open inquiry queue.                                        *
      *    if msg on inquiry queue                                    *
      *        open reply queue (loop through names until o.k.)       *
      *    else                                                       *
      *        open reply queue (name from mqtm-userdata)             *
      *    end-if                                                     *
      *    open waiting queue.                                        *
      *    open checking account queue.                               *
      *    open distribution queue. (change name!)                    *
      *    get browse first msg from waiting queue.                   *
      *                                                               *
      *      evaluate msgtype                                         *
      *        when inquiry msg                                       *
      *          perform irt-add-entry                                *
      *        when response or propagation msg                       *
      *          perform irt-update-entry                             *
      *          if match not found                                   *
      *            perform irt-rebuild-no-match                       *
      *          end-if                                               *
      *        when other                                             *
      *          perform irt-rebuild-unknown-msg                      *
      *      end-evaluate                                             *
      *      get browse next msg from waiting queue                   *
      *    end-perform.                                               *
      *    if unexpected compcode                                     *
      *        exit program.                                          *
      *    perform  main-process until stop-process.                  *
      *    close all queues.                                          *
      *    return to cics.                                            *
      *                                                               *
      * ************************************************************* *
      *MAIN-PROCESS.                                                  *
      *    evaluate                                                   *
      *      when irt table full and inquiryq open                    *
      *        close inquiry queue                                    *
      *      when irt table not full and inquiryq close               *
      *        open inquiry queue                                     *
      *    end-evaluate.                                              *
      *    if irt full                                                *
      *      getwait on reply queue                                   *
      *      evaluate return-codes                                    *
      *        when msg got                                           *
      *          perform process-reply-queue                          *
      *        when no msg                                            *
      *          set flag to stop main-process                        *
      *        when other                                             *
      *          report error                                         *
      *          set flag to call-error                               *
      *      end-evaluate                                             *
      *    else                                                       *
      *      getwait with signal on inquiry queue                     *
      *      evaluate return-codes                                    *
      *        when msg got                                           *
      *          perform process-inquiry-queue                        *
      *        when signal accepted or outstanding                    *
      *          perform process-signal-accepted                      *
      *        when other                                             *
      *          report error                                         *
      *          set flag to call-error                               *
      *      end-evaluate                                             *
      *    end-if.                                                    *
      *    evaluate                                                   *
      *      when calls ok and msg complete                           *
      *        perform send-answer                                    *
      *        if error occured                                       *
      *          rollback uow                                         *
      *          set flag to stop main-process                        *
      *        end-if                                                 *
      *      when calls ok                                            *
      *        syncpoint                                              *
      *      when other                                               *
      *        rollback uow                                           *
      *        set flag to stop main-process                          *
      *    end-evaluate.                                              *
      * ************************************************************* *
      *IRT-ADD-ENTRY.                                                 *
      *    search irt-table                                           *
      *      at end                                                   *
      *         set reply queue trigger control to off                *
      *      when empty entry                                         *
      *         fill entry with data from inquiry msg                 *
      *    end-search.                                                *
      *    if current entries = limit                                 *
      *      set table status to full                                 *
      *    end-if .                                                   *
      *                                                               *
      * ************************************************************* *
      *IRT-UPDATE-ENTRY.                                              *
      *    set update status to ok                                    *
      *    search irt-table                                           *
      *      at end                                                   *
      *         set update status to match not found                  *
      *      when entry msgid = mqmd-correlid                         *
      *         evaluate                                              *
      *           when propagation msg                                *
      *             add/subtract entry counters                       *
      *           when response msg                                   *
      *             add/subtract entry counters                       *
      *         end-evaluate                                          *
      *         if msg complete                                       *
      *           set msg complete flag to true                       *
      *         end-if                                                *
      *                                                               *
      * ************************************************************* *
      *                                                               *
      *IRT-REBUILD-UNKNOWN-MSG.                                       *
      *    report error.                                              *
      *    get msg under cursor.                                      *
      *    if error occured                                           *
      *      report error                                             *
      *      exit this section                                        *
      *    end-if.                                                    *
      *    perform forward-msg-to-dlq.                                *
      *    restore gmo options to browse next                         *
      *                                                               *
      * ************************************************************* *
      *IRT-DELETE-ENTRY.                                              *
      *    initialise irt table entry.                                *
      *    subtract 1 from current entries count.                     *
      *    set irt status to not full.                                *
      *                                                               *
      * ************************************************************* *
      *IRT-REBUILD-NO-MATCH.                                          *
      *    report error.                                              *
      *    get msg under cursor.                                      *
      *    if error occured                                           *
      *      report error                                             *
      *      exit this section                                        *
      *    end-if.                                                    *
      *    set irt status to not full.                                *
      *    restore gmo options to browse next                         *
      *                                                               *
      * ************************************************************* *
      *IRT-NO-MATCH.                                                  *
      *    report error.                                              *
      *                                                               *
      * ************************************************************* *
      *FORWARD-MSG-TO-DLQ.                                            *
      *    mqput1 msg received to dlq.                                *
      *    evaluate return codes                                      *
      *      when ok                                                  *
      *        report that msg has been put to dlq                    *
      *      when other                                               *
      *        report error                                           *
      *    end-evaluate.                                              *
      *                                                               *
      * ************************************************************* *
      *PROCESS-SIGNAL-ACCEPTED.                                       *
      *    perform replyq-getsignal.                                  *
      *    evaluate return codes                                      *
      *      when ok                                                  *
      *        perform process-replyq-msg                             *
      *      when signal accepted or outstanding                      *
      *        perform external-wait                                  *
      *      when other                                               *
      *        report error                                           *
      *        set call-error flag                                    *
      *    end-evaluate.                                              *
      *                                                               *
      *      when ok                                                  *
      *EXTERNAL-WAIT.                                                 *
      *    execute cics wait on the two ecbs                          *
      *    if inquiryq ecb posted                                     *
      *      perform test-inquiryq-ecb                                *
      *    else                                                       *
      *      perform test-replyq-ecb                                  *
      *    end-if.                                                    *
      *                                                               *
      * ************************************************************* *
      *TEST-INQUIRYQ-ECB.                                             *
      *    evaluate inquiryq ecb                                      *
      *      when msg arrived                                         *
      *        reset ecb                                              *
      *        perform inquiryq-get                                   *
      *        evaluate return codes                                  *
      *          when ok                                              *
      *            perform process-inquiryq-msg                       *
      *          when no msg                                          *
      *            continue                                           *
      *          when other                                           *
      *            report error                                       *
      *            set call-error flag                                *
      *        end-evaluate                                           *
      *      when wait interval expired                               *
      *        set flag to stop main-process                          *
      *      when wait cancelled                                      *
      *        set flag to stop main-process                          *
      *      when other                                               *
      *        report error                                           *
      *        set call-error flag                                    *
      *    end-evaluate                                               *
      *                                                               *
      * ************************************************************* *
      *TEST-REPLYQ-ECB.                                               *
      *    evaluate replyq ecb                                        *
      *      when msg arrived                                         *
      *        reset ecb                                              *
      *        perform replyq-get                                     *
      *        evaluate return codes                                  *
      *          when ok                                              *
      *            perform process-replyq-msg                         *
      *          when other                                           *
      *            report error                                       *
      *            set call-error flag                                *
      *        end-evaluate                                           *
      *      when wait interval expired                               *
      *        set flag to stop main-process                          *
      *      when wait cancelled                                      *
      *        set flag to stop main-process                          *
      *      when other                                               *
      *        report error                                           *
      *        set call-error flag                                    *
      *    end-evaluate                                               *
      *                                                               *
      * ************************************************************* *
      *INQUIRYQ-GET.                                                  *
      *    mqget msg                                                  *
      *                                                               *
      * ************************************************************* *
      *REPLYQ-GET.                                                    *
      *    mqget msg                                                  *
      *                                                               *
      * ************************************************************* *
      *REPLYQ-GETWAIT.                                                *
      *    mqget wait msg                                             *
      *                                                               *
      * ************************************************************* *
      *PROCESS-REPLYQ-MSG.                                            *
      *    evaluate                                                   *
      *      when response or propagation                             *
      *        perform irt-update-table                               *
      *        if no match                                            *
      *          perform irt-no-match                                 *
      *          perform replyq-unknown-msg                           *
      *        end-if                                                 *
      *      when other                                               *
      *        perform replyq-unknown-msg                             *
      *        exit this section                                      *
      *    end-evaluate.                                              *
      *    mqput msg to waiting queue                                 *
      *    if error occured                                           *
      *      report error                                             *
      *      set call-error flag                                      *
      *    end-if.                                                    *
      *                                                               *
      * ************************************************************* *
      *PROCESS-INQUIRYQ-MSG.                                          *
      *    if not inquiry msg                                         *
      *      perform iquiryq-unknown-msg                              *
      *      exit this section                                        *
      *    end-if.                                                    *
      *    perform irt-add-entry                                      *
      *    mqput msg to waiting queue                                 *
      *    if error occured                                           *
      *      report error                                             *
      *      set call-error flag                                      *
      *      exit this section                                        *
      *    end-if.                                                    *
      *    mqput msg to checking account queue                        *
      *    if error occured                                           *
      *      report error                                             *
      *      set call-error flag                                      *
      *      exit this section                                        *
      *    end-if.                                                    *
      *    if loan figure > threshold amount                          *
      *      mqput to distribution queue                              *
      *      if error occured                                         *
      *        report error                                           *
      *        set call-error flag                                    *
      *        exit this section                                      *
      *      end-if                                                   *
      *                                                               *
      * ************************************************************* *
      *INQUIRYQ-GETSIGNAL.                                            *
      *    mqget with signal                                          *
      *                                                               *
      * ************************************************************* *
      *REPLYQ-GETSIGNAL.                                              *
      *    mqget with signal                                          *
      *                                                               *
      * ************************************************************* *
      *REPLYQ-UNKNOWN-MSG.                                            *
      *    report error                                               *
      *    perform forward-msg-to-dlq.                                *
      *                                                               *
      * ************************************************************* *
      *INQUIRYQ-UNKNOWN-MSG.                                          *
      *    report error                                               *
      *    perform forward-msg-to-dlq.                                *
      *                                                               *
      * ************************************************************* *
      *WAITQ-UNKNOWN-MSG.                                             *
      *    report error                                               *
      *    perform forward-msg-to-dlq.                                *
      *                                                               *
      * ************************************************************* *
      *SEND-ANSWER.                                                   *
      *    perform until all messages retreived or compcode not = ok  *
      *      get msg from waiting queue with correlid.                *
      *      evaluate msgtype                                         *
      *        when inquiry msg                                       *
      *          move data to output msg                              *
      *        when response msg                                      *
      *          move data to output msg                              *
      *        when propagation msg                                   *
      *          continue                                             *
      *        when other                                             *
      *          perform waitq-unknown-msg                            *
      *      end-evaluate                                             *
      *    end-perform.                                               *
      *    if error                                                   *
      *      report error                                             *
      *      set call-error flag                                      *
      *      exit this section                                        *
      *    end-if.                                                    *
      *    reset msg complete flag                                    *
      *    mqput1 answer msg to replytoq                              *
      *    if error occured                                           *
      *      report error                                             *
      *      set call-error flag                                      *
      *      exit this section                                        *
      *    end-if.                                                    *
      *                                                               *
      * ************************************************************* *
      *SET-REPLYQ-TC-OFF.                                             *
      *    mqset tc off                                               *
      *    if error occured                                           *
      *      report error                                             *
      *      set call-error flag                                      *
      *      exit this section                                        *
      *    end-if.                                                    *
      *                                                               *
      * ************************************************************* *
      *INVALID-START-ROUTINE.                                         *
      *    build error message                                        *
      *    send message                                               *
      *    return to cics.                                            *
      *                                                               *
      * ************************************************************* *
       EJECT      * ------------------------------------------------------------- *
      * ------------------------------------------------------------- *
       ENVIRONMENT DIVISION.
      * ------------------------------------------------------------- *
      * ------------------------------------------------------------- *
       DATA DIVISION.
      * ------------------------------------------------------------- *
      * ------------------------------------------------------------- *
       WORKING-STORAGE SECTION.
      * ------------------------------------------------------------- *
      *
      *    W00 - General work fields
      *
       01         1W00-STARTCODE X02.
       01  W00-STARTCODE               PIC*
       DATADIVISION.
.
       01  W00-SUB                     PIC S9(09) BINARY.
       01         1                       PIC S909 BINARY.
      *
      *    W01 - Amount
      *
       01  W01-AMOUNT                        *    W01 - Amount
      *
      *    Queue names
      *
       1  W02-QUEUE-NAMES
           05  W02-INQUIRY-QNAME       PIC X(48       0         names
           '.B2.INQUIRY '.
      *
      * The .N in the reply/waiting queue signifies a one digit
      * number 1 to 5.
      * This will be changed in the program.
      *
      *
           'CSQ4SAMP. * The .N in the reply/waiting queue signifies a one digit
           05  REDEFINES W02-REPLY-QNAME.
               0       This will be changed in the program.
               10 W02-REPLY-QNAME-NUM  PIC 9(01).
               10                      PIC X(2).
           05  W02-WAITING-QNAME       PIC X(48) VALUE
           'CSQ4SAMP.B2.WAITING 0 5 REDEFINESEDEFINESW02-REPLY-QNAME.
           0  REDEFINES W02-WAITING-QNAME
               10                        PIC X(20).
               10 W02-WAITING-QNAME-NUM  PIC 9(01).
               10                         X(27).
      *
                      0  W02-INQUIRY-QNAMEPICX4)VALUE
           'CSQ4SAMP.DEAD.QUEUE '.
      *
           5W02-CHECKACCNT-QNAME8)VALUE
           'CSQ4SAMP.B2.OUTPUT.ALIAS '.
      *
           05  W02-DIST-QNAME      * The .N in the reply/waiting queue signifies a one digit
                 * This will be changed in the program.
      *
           05  W02-ANSWER-QNAME        PIC X(48).
           05  W02-ANSWER-QMGRNAME     PIC X(48).
           05  W02-USERIDENTIFIER      PIC X(12).
      *
      *    W03 - MQM API fields
      *
       01W03-SELECTORCOUNT (9)BINARY VALUE 1.
       01  W03-INTATTRCOUNT10PICX(2)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
       01  W03-CHARATTRLENGTH          PIC S9(9) java.lang.StringIndexOutOfBoundsException: Range [62, 50) out of bounds for length 62
       01  10W02-WAITING-QNAME-NUM   9(01.
1                    S9.
       01  W03-OPTIONS                 PIC S9(9) BINARY.
       01  W03-HOBJ-REPLYQ             PIC S9(9) BINARY.
       01        *
       1W03-HOBJ-WAITQ S9 BINARY
       01  W03-HOBJ-CHECKQ             PIC S9(9) BINARY.
       01  W03-HOBJ-DISTQ              PIC S9(9) BINARY.
       01  W03-COMPCODE                PIC S910                         X(27.
       01  W03-REASON5  W02-ANSWER-QNAME0W02-DEAD-QNAMEPIC8VALUE
       1W03-SELECTORS-TABLE
           05  W03-SELECTORS           PIC S9(9)            0        PICXjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 7
       01  W03-INTATTRS-TABLE.
           05  W03-INTATTRS            PIC S9           5W02-DIST-QNAME X8 java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
0W03-DATALEN
                  5  W02-ANSWER-QNAME  W03-CHARATTRSVALUE.
      *
       01  W03-GET-BUFFER.
           5W03-CSQ4BQRM

      *
           05 W03-CSQ4BIIM      *
           CSQ4VB1
      *
0 W03-CSQ4BPGM1  W03-CHARATTRLENGTH      9  VALUE
           COPY.
      *
       1W3PUT-BUFFER
           05 W03-CSQ4BAM.
           COPY CSQ4VB2.
      *
           05 W03-CSQ4BCAQ REDEFINES W03-CSQ4BAM.
           COPY CSQ4VB3.
      *
      *    API control blocks
      *
       01  MQM-OBJECT-DESCRIPTOR.
           COPY.
0                    PICjava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
           COPY.
       01  MQM-PUT-MESSAGE-OPTIONS.
           COPY CMQPMOV.
       1  MQM-GET-MESSAGE-OPTIONSjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
           OPY.
       01  MQM-TRIGGER-MESSAGE.
           COPY CMQTML.
      *
      *    Fields for ECB handling
      *
0      POINTER      *
       01  W04-ECB-PTR              POINTER.
       01  W04-INITIMG              PIC X VALUE LOW-VALUES.
      *
      *    CICS ts queue fields
      *
      1W05-TD-MESSAGE-LENGTH    PICS() BINARY.
       01  W05-TS-MESSAGE-LENGTH    PIC S9(4) BINARY.
       01  W05-ABSTIME              java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 7
      *
      *    main process flags
      *
       01  W06-MAIN-PROCESS-FLAG    PIC 9 VALUE 0.
           88 END-PROCESS VALUE 1.
       01  W06-END-PROCESS          PIC 9 VALUE 1.
      *
       01  W06-INQUIRYQ-STATUS      PIC X(6)COPY.
           88 INQUIRYQ-OPEN   VALUE 'OPEN'.
           88 INQUIRYQ-CLOSEDCOPYCOPY.
      *
       01  W06-CALL-STATUS          PIC X(6) VALUE 'OK'.
           88 CALLS-OK       VALUE 'OK'.
       01  W06-CALL-ERROR CMQTML
      *
       01  W06-MSG-STATUS           PIC 9 VALUE 0       1  W04-ECB-ADDR-LIST-PTR    POINTER
           88 MSG-COMPLETE            0 W04-INITIMGPIC VALUE.
           88       01W04-ECB-PTRPOINTER
      *
      *    CSQ4VB8 contains error messages used in this program
      *
       COPY CSQ4VB8.
      *
      *    Inquiry Record Table definition and associated fields
      *
       01  IRT-SUB      *
       0      *
       01        PIC(9) BINARY 1.
       01  IRT-UPDATE-STATUS        PIC S9(9) BINARY VALUE ZEROS.
           88 IRT-UPDATE-NO-MATCH VALUE 1.
       1  IRT-MAX-ENTRIESPICS9(9) BINARYjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
       01  IRT-CURRENT-ENTRIES      PIC S9(9) BINARY VALUE ZEROS.
       01  IRT-TABLE-SET-FULL       PIC S9(9) BINARY VALUE 1.
         IRT-TABLE-SET-NOT-FULL S9)BINARY ZEROS
       01  IRT-TABLE-STATUS         PIC S9(9) BINARY VALUE ZEROS.
8IRT-TABLE-FULL 1.
      *
      *    Size of IRT-TABLE is set here - to 10 initially
      *
       01  IRT-TABLE
           05 IRT-TABLE-ELEMENT OCCURS 10 INDEXED BY        1 W06-CALL-ERROR           PICX(6 VALUE 'FAILED.
              1 8MSG-COMPLETE 1java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
                 15 IRT-MSGID        PIC X(24).
                 15 IRT-PROPSOUTPIC*
                 15 IRT-REPLYEXP     PIC S9(9) BINARY.
                 15 IRT-REPLYREC     PIC S9(9) BINARY.
      *
      *    MQV contains constants (for filling in the control blocks)
      *    and return codes (for testing the result of a call)
      *
       01  W99-MQV.
       COPY*
      *
      *    DFHAID contains the constants used for checking for
      *    attention identifiers
      *
       COPY SUPPRESS
      *
      * ------------------------------------------------------------- *
       LINKAGE.
      * ------------------------------------------------------------- *
       01            PIC(9) BINARY
           05  L01-ECB-ADDR1        POINTER.
           05  L01-ECB-ADDR2        POINTER
      *
       01  L02-ECBS.
           05       1  IRT-TABLE-SET-NOT-FULL S99 BINARYV ZEROS.
           05  L02-REPLY-ECB2       PIC S9(09) BINARY.
       01  REDEFINES java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
           05      *
           05  L02-INQUIRY-ECB1-CC  PIC S9      *    Size of IRT-TABLE is set here - to 10 initially
           05                       PIC  X(02).
           05  L02-REPLY-ECB2-CC    PIC S9(04) BINARY.
      *
       EJECT
      * ------------------------------------------------------------- *
       PROCEDUREDIVISION
      * ------------------------------------------------------------- *
      * ------------------------------------------------------------- *
       A-MAIN SECTION.
      * ------------------------------------------------------------- *
      *                                                               *
      *                                                               *
      * ------------------------------------------------------------- *
      *
      *
      *    Initialize IRT and compute number of entries in table
      *
           MOVE LOW-VALUES      *
           COMPUTE IRT-MAX-ENTRIES = LENGTH OF IRT-TABLE      *    DFHAID contains the constants used for checking for
                                     LENGTH OF IRT-TABLE-ENTRY.
      *
      *    Check that the program has been started with data
      *
           EXEC CICS ASSIGN
               STARTCODE(W00-STARTCODE)
           END-EXEC.
      *
           IF W00-STARTCODE NOT01L01-ECB-ADDR-LIST
               PERFORM INVALID-START-ROUTINE
      *        No return from INVALID-START-ROUTINE
           END-IF.
      *
      *    Getmain storage for possible external wait on ecbs
      *
           EXEC CICS GETMAIN
               SET(W04-ECB-ADDR-LIST-PTR)
               FLENGTH(8)
           END-EXEC.
      *
      *    get addressability to storage
      *
           5  L02-REPLY-ECB2 S99) .
      *
           EXEC CICS GETMAIN
               ET(W04-ECB-PTR)
               FLENGTH(8)
               INITIMG)
           END-EXEC.
      *
      *    get addressability to storage
      *
           SET ADDRESS OF L02-ECBS0L02-ECBS      * ------------------------------------------------------------- *
      *
      *    store address's of ebcs into list
      *
           SET L01-ECB-ADDR11 L02-ECBS.
           SET      *                                                               *
      *
      *    Retrieve the trigger data this transaction was started with
      *
                 *
                     INTO(MQTM)
           END-EXEC.
      *
      *    Get the amount, if one is passed
      *
           IF NOT=SPACE
               MOVE MQTM-USERDATA TO W01-AMOUNT
           END-IF.
      *
      *    Open the inquiry queue
      *
           PERFORM OPEN-INQUIRYQ.
      *
      *    Test the output from the open.
      *    If not ok write record the error an exit from the program
      *
           IF W03-COMPCODE NOT = MQCC-OK THEN
               GO TO A-MAIN-EXIT
           ELSE
               INQUIRYQ-OPENTO
           END-IF.
      *
      *    At this point the data retrieved determines the open
      *    queue processing.
      *
      *    If the inquiry-queue has been triggered then
      *        loop trying to open a reply-queue
      *
      *    If a reply-queue has been triggered then open that
      *        particular reply-queue
      *
           IF MQTM-QNAME = W02-INQUIRY-QNAME
               PERFORM OPEN-UNNAMED-REPLY-QUEUE
               IF W03-COMPCODE NOT = MQCC-OK
GO      *
               END-IF
           java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
                     *        No return from INVALID-START-ROUTINE
               IF NOT =
                   GO TO A-MAIN-EXIT
               ELSE
MOVEMQTM-QNAME TO
               END-IF
           END-IF.
      *
      *    Open the Waiting Queue
      *    Use the number from the reply queue - matching pairs
      *
           MOVE MQOT-Q MQOD-OBJECTTYPE
           MOVE       *
           MOVE W02-WAITING-QNAME   TO MQOD-OBJECTNAME.
      *
      *    Initialize W03-OPTIONS to open the queue for input
      *    exclusive, browse and output
      *
           COMPUTE W03-OPTIONS = MQOO-INPUT-EXCLUSIVE +
                                 MQOO-BROWSE +
                                 MQOO-PASS-IDENTITY-CONTEXT +
                                 MQOO-SAVE-ALL-CONTEXT +
                                 MQOO-OUTPUT.
      *
      *    Open the queue
      *
           CALL 'MQOPEN'      *
                               MQOD
                               W03-OPTIONS
                               W03-HOBJ-WAITQ      *
                               W03-COMPCODE
                               .
      *
      *    Test the output from the open.
      *    If not ok then exit program
      *
IF NOT  THEN
               MOVE 'MQOPEN'        TO      *
               MOVE MQOD-OBJECTNAME TO M02-OBJECTNAME
               PERFORM RECORD-CALL-ERROR
               GO TO A-MAIN-EXIT.      *    At this point the data retrieved determines the open
      *
      *    Open the Checking Account Queue
      *
           MOVE      *        loop trying to open a reply-queue
           MOVE W02-CHECKACCNT-QNAME TO MQOD-OBJECTNAME.
      *
      *    Initialize W03-OPTIONS to open the queue for output
      *
             = MQOO-OUTPUT
                                 MQOO-PASS-IDENTITY-CONTEXT.
      *
      *    Open the queue
      *
           CALL      *
                               MQOD
GO A-MAIN-EXIT
                               W03-HOBJ-CHECKQ
W03-COMPCODE
                               W03-REASON
      *
      *    Test the output from the open.
      *    If not ok then exit program
      *
           IF W03-COMPCODE NOT =MQCC-OK
               MOVE 'MQOPEN'            W02-REPLY-QNAME-NUM W02-WAITING-QNAME-NUM
                               W03-COMPCODE = MQCC-OK
               PERFORM RECORD-CALL-ERROR
               GO TO A-MAIN-EXIT.
      *
      *    Open the Distribution Queue
      *
      *
           MOVE MQOT-Q         TO MQOD-OBJECTTYPE.
           MOVE      *
      *
      *    Initialize W03-OPTIONS to open the queue for output
      *
           COMPUTE W03-OPTIONS = MQOO-OUTPUT +
                                  W02-WAITING-QNAMEjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
      *
      *    Open the queue
      *
           CALL MQOO-BROWSE
                               MQOD
W03-OPTIONS
                               W03-HOBJ-DISTQ
                               W03-COMPCODE
                               W03-REASON      *
      *
      *    Test the output from the open.
      *    If not ok then exit program
      *
           IF W03-COMPCODE NOT = MQCC-OK THEN      *
               MOVE 'MQOPEN '       TO M02-OPERATION      *
               MOVE MQOD-OBJECTNAME TO M02-OBJECTNAME
               PERFORM RECORD-CALL-ERROR
               GO TO A-MAIN-EXIT.
      *
      *****************************************************************
      *    Rebuild the IRT (Inquiry Record Table)
      *****************************************************************
      *
      *    Initialize the Get Message Options (MQGMO) control block.
      *    (The copy book initializes the remaining fields)
      *
           IFW03-COMPCODE  MQOD-OBJECTNAME
                                   MQGMO-BROWSE-FIRST 'MQOPEN'        TOM02-OPERATION
           MOVE LENGTH OF      *
      *
      *    Make the first MQGET call outside the loop
      *    using the BROWSE-FIRST option
      *
            QOD
                              W03-HOBJ-WAITQW03-OPTIONS
                              MQMD
                              MQGMO
                              W03-BUFFLENMQOO-PASS-IDENTITY-CONTEXT
                              W03-GET-BUFFER
                              W03-DATALEN

                              .
      *
      *    Test the output of the MQGET call using the PERFORM loop
      *    that follows.
      *
      *    Change the MQGMO Options field to BROWSE-NEXT
      *
           COMPUTE MQGMO-OPTIONS = MQGMO-NO-WAIT +
                                   MQGMO-BROWSE-NEXT.
      *
      *    Loop from here to END-PERFORM until the MQGET call fails
      *
WITH BEFORE
                   UNTILGO TO.
      *
      *       Perform relevant add/update IRT entry dependent upon
      *       message. If message unknown then put it to deadq
      *
              EVALUATE      *    Open the queue
                  WHEN INITIAL-INQUIRY-MESSAGE
                      PERFORM T1-IRT-ADD-ENTRY
                  WHEN QUERY-RESPONSE-MESSAGE OR PROPAGATION-MESSAGE
                      PERFORM T2-IRT-UPDATE-ENTRY
                      IF IRT-UPDATE-NO-MATCH
                          PERFORMT5-IRT-REBUILD-NO-MATCH
                      END-IF
                  WHEN OTHER
                      PERFORM            *
              END-EVALUATE
      *
      *       Clear MQMD-MSGID and MQMD-CORRELID before the next
      *       MQGET call to ensure that all messages are retrieved
      *
              MOVE      *
              MOVE MQCI-NONE      *****************************************************************
      *
      *       Get the next message
      *
              CALL 'MQGET' USING W03-HCONN
           COMPUTE MQGMO-OPTIONSMQGMO-NO-WAIT
                                 MQMD
                                 MQGMO
W03-BUFFLEN

      *    Make the first MQGET call outside the loop
                                 W03-COMPCODE
                                 W03-REASONjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
      *
      *       Test the output of the MQGET call at the top of the loop.
      *       Exit the loop if an error occurs
      *
           END-PERFORM
      *
      *    Test the output of the MQGET call.  If the call failed,
      *    print an error message showing the completion code and
      *    reason code, unless the reason code is NO-MSG-AVAILABLE.
      *
      *    Note: When the loop reaches the end of the file, the
      *          completion code is MQCC-FAILED and the reason code
      *          is MQRC-NO-MSG-AVAILABLE
      *
           IF ( (W03-COMPCODE NOT = MQCC-FAILED) OR
                (W03-REASON NOT = MQRC-NO-MSG-AVAILABLE      *    Loop from here to END-PERFORM until the MQGET call fails
               MOVEMQGET M02-OPERATION
               PERFORM
                   QUERY-RESPONSE-MESSAGE PROPAGATION-MESSAGE
               GOTO.
      *
      *
      *    Loop until wait expired on either or both inquire and
      *    reply queue depending on IRT status. Achieved by setting
      *    flag
      *
           PERFORM MAIN-PROCESS WITH TEST
              UNTIL END-PROCESS.
      *
           PERFORM CLOSE-QUEUES.
      *
       A-MAIN-EXIT.
      *
      *
      * Return to CICS
      *
           EXEC      *       MQGET call to ensure that all messages are retrieved
           END-EXEC.
      *
           GOBACK.
           EJECT
      *
      * ------------------------------------------------------------- *
.
      * ------------------------------------------------------------- *
      *                                                              *
      * This section closes the queues.                              *
      *                                                              *
      * ------------------------------------------------------------ *
      *
           IF                                 java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
               PERFORM CLOSE-INQUIRYQ
      *
      *    Close waiting and reply queues, waiting before reply
      *    to avoid problems if multiple instances of the program
      *    are triggered
      *
           CALL 'MQCLOSE' USING W03-HCONN
                                W03-HOBJ-WAITQ
                                MQCO-NONE
                                W03-COMPCODE
                                W03-REASON.
      *
           IF W03-COMPCODE NOT = MQCC-OK
               MOVE 'MQCLOSE'            TO M02-OPERATION
                TO.
               PERFORM RECORD-CALL-ERROR
           END-IF.
      *
           CALL 'MQCLOSE' USING W03-HCONN      *    flag
                                W03-HOBJ-REPLYQ
                                MQCO-NONE
                                W03-COMPCODE
                                            CLOSE-QUEUES
      *
           IF W03-COMPCODE NOT = MQCC-OK
               MOVE      *
               MOVE W02-REPLY-QNAME      TO M02-OBJECTNAME
               PERFORM RECORD-CALL-ERROR
           END-IF.
      *
      *    Close the output queues
      *
           CALLEjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
                                W03-HOBJ-CHECKQ
                                MQCO-NONE
                                W03-COMPCODE
                                W03-REASON
      *
                       avoid if multiple instances of program
               MOVE '' USING W03-HCONN
               MOVE W02-CHECKACCNT-QNAME TO M02-OBJECTNAME
               PERFORM RECORD-CALL-ERROR
           END-IF
      *
           CALL 'MQCLOSE' USING W03-HCONN
                                W03-HOBJ-DISTQ
                                MQCO-NONEIF OT
                                W03-COMPCODE
                                W03-REASON.
      *
                      W03-COMPCODE
               MOVE 'MQCLOSE'            TO M02-OPERATION
               MOVE W02-DIST-QNAME       TO M02-OBJECTNAME
      *
           .
      *
END-IF
      *
      *    Return to performing section
      *
           EXITW03-HOBJ-REPLYQ
      *
      *
      * ------------------------------------------------------------- *
       CLOSE-INQUIRYQ       *
      * ------------------------------------------------------------- *
      *                                                              *
      *  This section closes the inquiry queue                       *
      *                                                              *
      * ------------------------------------------------------------ *
      *
           CALL 'MQCLOSE *


                                W03-COMPCODE
                                N.
      *
NOTjava.lang.StringIndexOutOfBoundsException: Range [41, 42) out of bounds for length 41
                MOVE                                .
                MOVE    TOM02-OBJECTNAME
                PERFORM
            END-IF
      *
       CLOSE-INQUIRYQ-EXIT
      *
      *    Return to performing section
      *
           EXIT.
           EJECT
      *
      * ------------------------------------------------------------- *
       MAIN-PROCESS SECTION.
      * ------------------------------------------------------------- *
      *                                                              *
      *  This section performs the main message handling of the      *
      *  program. It is called from a loop in MAIN.                  *
      *                                                              *
      *  The program gets and handles messages, depending on the     *
      *  status of the IRT. When a message is complete, an answer    *
      *  is sent. If an error occurs, it is recorded and END-PROCESS *
      *  is set.                                                     *
      *                                                              *
      * ------------------------------------------------------------ *
      *
      *    Ensure the inquiry queue is open when there is space in
      *    the IRT for a new inquiry and closed when the IRT is full
      *
            TRUE
                WHEN  INQUIRYQ-OPEN
                    PERFORM CLOSE-INQUIRYQ
                    IF= MQCC-OK
                        SET INQUIRYQ-CLOSED TO TRUE      *    Return to performing section
                    ELSEW03-REASON
                              *
                        GO TO MOVEMQCLOSEMAIN-PROCESS SECTION
                    END-IF
      *
WHEN ANDINQUIRYQ-CLOSED
                    PERFORM OPEN-INQUIRYQ
                    IF W03-COMPCODE      *
                        SETEXITjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
                    ELSE
      * ------------------------------------------------------------- *
                        GO TO MAIN-PROCESS-EXIT      *
                    END-IF
                 *                                                              *
      *
      *    If the IRT is full, get messages from the reply queue
      *    only, using get wait
      *
           IF IRT-TABLE-FULLSET TO TRUE
               PERFORM REPLYQ-GETWAIT
               EVALUATE TRUE
                   WHEN (W03-COMPCODE TOMAIN-PROCESS-EXIT      *    the IRT for a new inquiry and closed when the IRT is full
                           W03-REASON = MQRC-NONE)
                       PERFORM PROCESS-REPLYQ-MESSAGE
      *
FAILED AND
                           W03-REASON=MQRC-NO-MSG-AVAILABLE
                        W06-END-PROCESS W06-MAIN-PROCESS-FLAG
      *
                   OTHER
                       MOVE 'MQGET WAIT '   TO M02-OPERATION
                       MOVE
                       PERFORM RECORD-CALL-ERROR
                       MOVE W06-CALL-ERROR W06-CALL-STATUS
      *
               END-EVALUATE
      *
      *    Else the IRT isn't full,  get messages from both
      *    inquiry and reply queues, using get signal
      *
           ELSE      *
               PERFORM IRT-TABLE-FULL
               EVALUATE TRUE
= MQCC-OK AND
                           W03-REASON = MQRC-NONE
                                      EVALUATE TRUE
      *
                   WHEN (W03-COMPCODE = MQCC-WARNING                            W03-REASON                   WHEN
                           W03-REASON MQRC-SIGNAL-REQUEST-ACCEPTED)
                        OR
=MQCC-FAILED
                           W03-REASON = MQRC-SIGNAL-OUTSTANDING)
                       PERFORM
      *
                   WHEN OTHER
                       MOVE 'MQGET SIGNAL PROCESS-INQUIRYQ-MESSAGE
                       MOVE MQOD-OBJECTNAME TO      *    Else the IRT isn't full,  get messages from both
                       PERFORMjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
                       MOVE W06-CALL-ERROR  TO W06-CALL-STATUS
      *
               java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
           END-IF.
      *
      *    Check whether an inquiry is complete, or whether
      *    problems have occurred
      *
           EVALUATETRUEWHENOTHER
               WHENCALLS-OKMSG-COMPLETE)
                   PERFORM SEND-ANSWERMOVE MQOD-OBJECTNAME M02-OBJECTNAME
                   IFW03-COMPCODE = MQCC-OK
                       MOVEW06-CALL-ERROR  TOW06-CALL-STATUS
                       EXEC CICS SYNCPOINT ROLLBACK END-EXEC
                       GO TO MAIN-PROCESS-EXIT
                   END-IF
                   EXEC CICS SYNCPOINT END-EXEC
                   SET MSG-NOT-COMPLETE      *    problems have occurred
                   PERFORMEVALUATETRUE
               WHEN (CALLS-OK AND MSG-COMPLETE)
               WHEN CALLS-OK
                   EXEC CICSSYNCPOINT
      *
               WHEN
                   MOVEMOVEW06-END-PROCESS W06-MAIN-PROCESS-FLAG
                   EXEC  SYNCPOINT END-EXEC
           END-EVALUATE.
      *
       MAIN-PROCESS-EXITEND-IF
      *
           EXIT.
           EJECT
      *
      * ------------------------------------------------------------- *
       RECORD-CALL-ERROR.
      * ------------------------------------------------------------- *
      *                                                              *
      * This section writes an error message to the CICS td queue    *
      * 'CSML' and the CICS ts queue 'CSQ4SAMP'.                     *
      * The failing operation and object name fields are completed   *
      * by the calling application. The remaining fields of the      *
      * message are completed by this routine                        *
      *                                                              *
      * ------------------------------------------------------------ *
      *
           EXEC CICS ASKTIME
               ABSTIME(W05-ABSTIME)
           END-EXEC.
           EXECEXIT
BSTIME(W05-ABSTIME
               DATE(M02-DATE      *
               TIME(M02-TIME) TIMESEP
           END-EXECjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
      *
           MOVE EIBTRNID        TO M02-TRANSACTION
                                   M03-TRANSACTION.
           MOVE EIBTASKN        TO M02-TASK-NUMBER
                                         * 'CSML' and the CICS ts queue 'CSQ4SAMP'.                     *
           MOVE W03-COMPCODE    TO M02-COMPCODE
           MOVE W03-REASON      TO M02-REASON      * message are completed by this routine                        *
           MOVE M02-DATE            CICS ASKTIME                                                                    *
           .
           MOVE CICSFORMATTIME
                                TO W05-TS-MESSAGE-LENGTH
           MOVE LENGTH OF M03-CSML-ERROR-MSG
                                EXEC                DATE DATESEP
      *
            CICSWRITEQ
               QUEUE               (M02-TIME java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
FROMM02-CALL-ERROR-MSG)
               LENGTH(W05-TS-MESSAGE-LENGTH                                   M03-TRANSACTION
           END-EXEC.
      *
            CICS TD
               QUEUE('CSML')
               FROM (M03-CSML-ERROR-MSG)
              (W05-TD-MESSAGE-LENGTH  OF
           END-EXEC.
      *
       RECORD-CALL-ERROR-EXIT.
      *
      *    Return to performing section
      *
           EXIT.
           EJECT
      *
      * ------------------------------------------------------------- *
       T1-IRT-ADD-ENTRY SECTION.
      * ------------------------------------------------------------- *
      *                                                              *
      *  This section adds a new entry into the in memory inquiry    *
      *  record table. If the new entry fills the table, table full  *
      *  is set. If the table is already full, there is an internal  *
      *  logic error - so triggering is set off for the replyq to    *
      *  avoid repeated errors.                                      *
       RECORD-CALL-ERROR-EXIT.
               FROM (M02-CALL-ERROR-MSG)
      *
           SET      *
      *
           SEARCH        SECTION
                      ------------------------------------------------------------- *
      *             table is full - therefore a logic
      *             error has occurred. we need to set triggering off
      *             for the replyq so that the transaction does not
      *             get repeatedely started
                   PERFORM SET-REPLYQ-TC-OFF      *  This section adds a new entry into the in memory inquiry    *
                   EXEC CICS ABEND      *  record table. If the new entry fills the table, table full  *
                       ABCODE      *  logic error - so triggering is set off for the replyq to    *
                   END-EXEC
      *
               WHEN IRT-MSGID(IRT-INDEX1) = LOW-VALUES
                   ADD 1           TO IRT-CURRENT-ENTRIES
                   MOVE MQMD-MSGID TO IRT-MSGID(IRT-INDEX1)
                   MOVE           TOIRT-REPLYEXP)
                   MOVE       *
                   IF CSQ4BIIM-LOANREQ W01-AMOUNT
                       MOVE 1      TO IRT-PROPSOUT(IRT-INDEX1)
                   ELSE
                       MOVE ZEROES TO IRT-PROPSOUT(IRT-INDEX1)
                   END-IF
           END-SEARCH.
      *
                 *             get repeatedely started
BLE-SET-FULL TOIRT-TABLE-STATUS
      *
       T1-IRT-ADD-ENTRY-EXIT.
      *
      *    Return to performing section
      *
           EXIT.
           EJECT
      *
      * ------------------------------------------------------------- *
       T2-IRT-UPDATE-ENTRY SECTION.
      * ------------------------------------------------------------- *
      *                                                              *
      * This IRT update entry routine can be called from the initial *
      * rebuild of IRT at start of program OR during the main loop.  *
      *                                                              *
      * When a matched entry is found the counts are updated         *
      * dependent on type of message.                                *
      *                                                              *
      * If all the replies have been received then the message       *
      * complete flag is set to indicate this.                       *
      *                                                              *
      * ------------------------------------------------------------ *
      *
SETTO1
           MOVE IRT-STATUS-OK TO IRT-UPDATE-STATUS.
           SEARCH IRT-TABLE-ELEMENT VARYING IRT-INDEX1
      *
               AT END
                   MOVEIRT-STATUS-NO-MATCH IRT-UPDATE-STATUS
      *
               WHEN IRT-MSGID      *
                   EVALUATE TRUE
                       WHEN PROPAGATION-MESSAGE
                           ADD      1   TO IRT-REPLYREC(                   END-IF
                                      END-SEARCH
                                        TO IRT-REPLYEXP(IRT-INDEX1)
                           SUBTRACTIFIRT-CURRENT-ENTRIESIRT-MAX-ENTRIES
                       WHEN QUERY-RESPONSE-MESSAGE
                           ADD      1   TO IRT-REPLYREC(IRT-INDEX1)
                   END-EVALUATE
      *
      *            Test whether all responses have been received,
      *            if they have - set message complete
      *
                   IF IRT-REPLYREC(IRT-INDEX1      *                                                              *
                     IRT-REPLYEXP(IRT-INDEX1) AND
                     IRT-PROPSOUT(IRT-INDEX1) = ZERO
                       SET MSG-COMPLETE TO TRUE
                   ELSE
                       CONTINUE
                   END-IF
           END-SEARCH.
      *
T2-IRT-UPDATE-ENTRY-EXIT
      *
      *    Return to performing section
      *
           EXIT.
                 *                                                              * IRT-MSGIDIRT-INDEX1 java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
      *
      * ------------------------------------------------------------- *
      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
      * ------------------------------------------------------------- *
      *                                                              *
      * This section is called during the initial phase of the       *
      * program when rebuilding the IRT because an 'unknown message  *
      * has been encountered on the 'waiting' queue.                 *
      * This code will remove the message using the message          *
      * under cursor option of MQGET and MQPUT it on the deadletter  *
      * queue.                                                       *
      *                                                              *
      * ------------------------------------------------------------ *
      *
           MOVE 'UNKNOWN MSG DETECTED ON QUEUE' TO      *            Test whether all responses have been received,
           MOVEW02-WAITING-QNAME M02-OBJECTNAME
            RECORD-CALL-ERROR
      *
                                (IRT-INDEX1)AND
           IF W03-COMPCODE NOT = MQCC-OK
              GO TO T3-RESTORE
END-IF
      *
      *    put the message on the dead letter queue
      *
           MOVE W03-HOBJ-WAITQ TO MQPMO-CONTEXT.
            FORWARD-MSG-TO-DLQ
      *
       T3-RESTORE
      *
      *    Change the MQGMO Options field back to BROWSE-NEXT
      *
           COMPUTE MQGMO-OPTIONS = MQGMO-NO-WAIT +
      *                                                              *
      *
       T3-IRT-REBUILD-UNKNOWN-EXIT.
      *
      *    Return to performing section
      *
           EXIT.
           EJECT
      *
      * ------------------------------------------------------------- *
       T4-IRT-DELETE-ENTRY SECTION.
      * ------------------------------------------------------------- *
      *                                                              *
      * This section deletes and entry from the IRT                  *
      *                                                              *
      * ------------------------------------------------------------ *
      *
           MOVE LOW-VALUES IRT-TABLE-ENTRY(IRT-INDEX1.
           SUBTRACT 1 FROM IRT-CURRENT-ENTRIES.
           MOVE IRT-TABLE-SET-NOT-FULL TO IRT-TABLE-STATUS.
      *
                   W03-COMPCODEMQCC-OK
      *
      *    Return to performing section
      *
           EXIT.
           EJECT
      *
      * ------------------------------------------------------------- *
       T5-IRT-REBUILD-NO-MATCH SECTION            FORWARD-MSG-TO-DLQ.
      * ------------------------------------------------------------- *
      *                                                              *
      * This section gets an unknown message from the waiting queue, *
      * using T6-IRT-REBUILD-GET-MSG, records the error, and puts    *
      * the message to the dead queue.                               *
      *                                                              *
      * ------------------------------------------------------------ *
      *
           MOVE 'MATCH NOT FOUND IN IRT' TO M02-OPERATION.
           MOVE
           PERFORM RECORD-CALL-ERROR.
      *
           PERFORM T6-IRT-REBUILD-GET-MSG.
           IF W03-COMPCODE NOT = MQCC-OK
              GO           .
           END-IF.
      *
      *    put the message on the dead letter queue
      *
           MOVE W03-HOBJ-WAITQ      * ------------------------------------------------------------ *
           PERFORM FORWARD-MSG-TO-DLQ.
      *
       T5-RESTORE.
      *
      *    Change the MQGMO Options field back to BROWSE-NEXT
      *
           COMPUTE MQGMO-OPTIONS = MQGMO-NO-WAIT +
                                   MQGMO-BROWSE-NEXT.
      *
       T5-IRT-REBUILD-NO-MATCH-EXIT.
      *
      *    Return to performing section
      *
           EXIT.
           EJECT
      *
      * ------------------------------------------------------------- *
       T6-IRT-REBUILD-GET-MSG SECTION.
      * ------------------------------------------------------------- *
      *                                                              *
--> --------------------

--> maximum size reached

--> --------------------

quality95%

¤ Diese beiden folgenden Angebotsgruppen bietet das Unternehmen0.50Angebot ¤

*Eine klare Vorstellung vom Zielzustand

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.