Operator Console

Now that we can queue messages to an operator console we need to build the code to provide the console.  Our console code will run as a separate task under its own TCB.  It will use our EXCP SVC to drive an 3270 terminal.

000000                                1 TXXCON   CSECT 
000000 05C0                           2          BALR  R12,0 
                            00002     3          USING *,R12
                                      4 
000002 58B0 0010      00010           5          L     R11,16             CVT 
000006 58B0 B014      00014           6          L     R11,CVTCCB-@CVT(,R11)  CONSOLE COMMUNICATION BLOCK 
                            00000     7          USING @CCB,R11 

We start by establishing a base register. Next we locate the Console Communication Block which is anchored in the CVT.

00000A 5850 0010      00010           9          L     R5,16              CVT ADDRESS 
00000E 5850 5008      00008          10          L     R5,CVTUCB-@CVT(,R5)  UCB TABLE                           
                            00000    11          USING @UCB,R5                                                  
                                     12 *                                                                       
000012                               13 FINDUCB  DS    0H                                                       
000012 D501 CBA6 5004 00BA8 00004    14          CLC   =X'FFFF',UCBCUA    END OF LIST                           
000018 4780 C2C2      002C4          15          BE    FINDERR              YES - ERROR                         
00001C D501 5004 B010 00004 00010    16          CLC   UCBCUA,CCBDEV      OUR TERMINAL UCB                      
000022 4780 C02C      0002E          17          BE    FIND010            YES - BRANCH                          
000026 5850 5000      00000          18          L     R5,UCBNEXT                                               
00002A 47F0 C010      00012          19          B     FINDUCB                                                  
                                     21 *                                                                       
00002E                               22 FIND010  DS    0H      

Now we search through the UCB table to find the UCB for the 3270 that will be used as our operator console. The device address is defined in the CCB.

00002E 9680 5007      00007          23          OI    UCBSTAT,UCBSONLN   FORCE DEVICE ONLINE                   
                                     24 *                                                                       
000032 5810 CB96      00B98          25          L     R1,=A(CNSLINTR)    DEVICE INTERRUPT ROUTINE              
000036 5010 5010      00010          26          ST    R1,UCBINTR                                               
00003A 4110 C352      00354          27          LA    R1,ZECB            INTERRUPT ECB                         
00003E 5010 5014      00014          28          ST    R1,UCBINTRP        SAVE AS INTERRUPT PARM

Now we have to set up the UCB. First we mark the device as online since by default we have left all devices marked offline. We still need some device initialization code to handle this but for now this will work.

We also set up a device interrupt handler that will be called when the device generates an interrupt but no I/O has been started on the device. This occurs when the enter key is pressed on the console indicating that data is available to be read.

We place the address of the interrupt routine into UCBINTR and we save the address of an ECB into the interrupt parameter UCBINTRP.

000BAA                              390 CNSLINTR DS    0H                                                       
                            00BAA   391          USING *,R15                                                    
                            00000   392          USING @UCB,R1                                                  
000BAA 5810 1014      00014         393          L     R1,UCBINTRP                                              
000BAE 58F0 0014      00014         394          L     R15,20                                                   
000BB2 58F0 F028      00028         395          L     R15,MVTPOST-@MVT(,R15)                                   
000BB6 07FF                         396          BR    R15                                                      

This is the interrupt routine. On entry R15 contains the entry point and R1 contains the address of the UCB. We get the ECB address from the interrupt parameter field and then branch to the Post routine to post the ECB. We can simply branch to the Post routine since R14 contains the return address from the caller to the interrupt routine.

000042 BE57 C2E7      002E9          30          STCM  R5,B'0111',WIOB+(IOBDCBPT-@IOB)                          
000046 BE57 C337      00339          31          STCM  R5,B'0111',RIOB+(IOBDCBPT-@IOB)                          
00004A BE57 C30F      00311          32          STCM  R5,B'0111',WIOB2+(IOBDCBPT-@IOB)                         
00004E 9680 C2E6      002E8          33          OI    WIOB+(IOBFLG4-@IOB),IOBFUCBP  DCBPT IS UCB ADDR          
000052 9680 C30E      00310          34          OI    WIOB2+(IOBFLG4-@IOB),IOBFUCBP DCBPT IS UCB ADDR          
000056 9680 C336      00338          35          OI    RIOB+(IOBFLG4-@IOB),IOBFUCBP  DCBPT IS UCB ADDR

Now we can save the UCB address into our IOBs. We also have to remember to set the flag bit that indicates this is a UCB address and not a DCB address. (We still have not defined what a DCB will be)

00005A 4110 C352      00354          37          LA    R1,ZECB            INTERRUPT ECB                         
00005E 5010 C356      00358          38          ST    R1,ECBLIST         SAVE INTO ECB LIST                    
000062 4110 B00C      0000C          39          LA    R1,CCBECB          GET CNSL COMM BLK ECB                 
000066 5010 C35A      0035C          40          ST    R1,ECBLIST+4       SAVE INTO ECB LIST                    
00006A 9680 C35A      0035C          41          OI    ECBLIST+4,X'80'     END OF WAIT LIST 

Now we build our ECB wait list. We will wait until either one of two ECBs are posted. First the the ECB our interrupt routine will post (ZECB). If this ECB is posted we will need to issue a read to the terminal to get the operator input. The second ECB is the Console Communication Block ECB (CCBECB) that is posted when a message is placed on the console queue.

                                     43          $WTO  'TXXOS CONSOLE - &SYSDATE &SYSTIME'                      
00006E 0700                          44+         CNOP  0,4                                                      
000070 4510 C094      00096          45+         BAL   1,IHB10001                                                
000074 1E000078                      46+         DC    AL1(30),AL3(*+3)                                         
000078 E3E7E7D6E240C3D6              47+         DC    C'TXXOS CONSOLE - 01/13/12 10.09'                        
000096                               48+IHB10001 DS    0H                                                       
000096 5810 1000      00000          49+         L     1,0(,1)                                                  
00009A 0A23                          50+         SVC   35

Now we can add a message to the console queue using our SVC 35 routine. Although our $WTO, like other macros in TXXOS, resembles the MVS version, it is not the same. Ours is much simpler.

00009C                               52 RUNLOOP  DS    0H                                                       
00009C 9240 CB0F      00B11          53          MVI   BUFR,C' '                                                
0000A0 D27E CB10 CB0F 00B12 00B11    54          MVC   BUFR+1(L'BUFR-1),BUFR   CLEAR BUFFER                     
0000A6 92C3 C376      00378          55          MVI   DATA,X'C3'              SET WCC                          
                                     56 *                                                                       
0000AA D703 C34E C34E 00350 00350    57          XC    WECB,WECB               CLEAR WRITE ECB                  
0000B0 4110 C2D2      002D4          58          LA    R1,WIOB                 POINT TO IOB                     
0000B4 0A00                          59          SVC   0                                                        
                                     60 *                                                                       
0000B6 4110 C34E      00350          61          LA    R1,WECB                                                  
0000BA 0A01                          62          SVC   1                       WAIT FOR WRITE TO COMPLETE

Now we begin our main processing loop. We start by clearing out the input buffer. We then set the 3270 Write Command Code. We issue an EXCP using our Write IOB (WIOB) and then wait for the I/O to complete. I will not go into great detail about the 3270 data stream here. You can find more information at my website www.tommysprinkle.com/mvs/P3270.

0000BC                               64 RUNLOOP1 DS    0H                                                       
0000BC D703 C352 C352 00354 00354    65          XC    ZECB,ZECB                                                
0000C2 4110 C356      00358          66          LA    R1,ECBLIST                                               
0000C6 5610 CB9A      00B9C          67          O     R1,=A(X'80000000')  INDICATE ECB LIST                    
0000CA 0A01                          68          SVC   1                   WAIT FOR SOMETHING TO HAPPEN         
                                     69 *                                                                       
0000CC 5810 C35A      0035C          70          L     R1,ECBLIST+4        CHECK FOR WTO POST                   
0000D0 9140 1000      00000          71          TM    0(R1),X'40'         IS IT WTO POST                       
0000D4 4710 C102      00104          72          BO    WTO                  YES - GET IT 

Now we wait using our ECB Wait List. When we come back from the wait we determine which ECB has been posted. We test the CCBECB to see if a message has been queued. If so we branch to process it, else we continue to process operator input.

0000D8 D703 C34A C34A 0034C 0034C    74          XC    RECB,RECB           CLEAR READ ECB                       
0000DE 4110 C322      00324          75          LA    R1,RIOB              POINT TO READ IOB                   
0000E2 0A00                          76          SVC   0                   READ INPUT FROM TERMINAL             
                                     77 *                                                                       
0000E4 4110 C34A      0034C          78          LA    R1,RECB             WAIT FOR                             
0000E8 0A01                          79          SVC   1                           I/O TO COMPLETE              
                                     80 *                                                                       
0000EA 4100 C154      00156          82          LA   R0,OPMSG                                                  
0000EE 0A0B                          83          SVC  11                  GET DATE/TIME                         
                                     84          $WTL OPMSG,L'OPMSG                                             
0000F0 4110 C154      00156          85+         LA    R1,OPMSG                                                 
0000F4 4100 0028      00028          86+         LA    R0,L'OPMSG                                               
0000F8 8900 0018      00018          87+         SLL   R0,24                                                    
0000FC 1610                          88+         OR    R1,R0                                                    
0000FE 0A23                          89+         SVC   35                                                       
                                     90 *                                                                       
000100 47F0 C09A      0009C          91          B     RUNLOOP             IGNORE FOR NOW

We issue a terminal read CCW using our Read IOB (RIOB) to get the operator input. For now we simply ignore the input but we do write a message indicating operator input. We issue a SVC 11 call to get the formatted date & time. We then use the $WTL macro to queue the message using SVC 35. Our $WTL is similar to our $WTO except that the $WTL is provided a pointer and the length of the message text. We then branch back to our main loop so we issue a write to the console and unlock the keyboard.

000104                               94 WTO      DS    0H                                                       
000104 D703 B00C B00C 0000C 0000C    95          XC    CCBECB,CCBECB      CLEAR ECB                              
00010A                               96 WTO010   DS    0H                                                       
00010A 5850 B004      00004          97          L     R5,CCBMBQ          FIRST ELEMENT ON QUEUE                
00010E 1255                          98          LTR   R5,R5                                                    
000110 4780 C13A      0013C          99          BZ    WTO030             BRANCH IF QUEUE EMPTY                 
                                    100 *                                                                       
                            00000   101          USING @CMB,R5

If we are processing a queued message we start by picking the first CMB element on the queue.

000114 4110 5004      00004         103          LA    R1,CMBTEXT         TEXT                                  
000118 4100 004F      0004F         104          LA    R0,79                                                    
00011C 45E0 C17C      0017E         105          BAL   R14,ADDLINE        ADD TEXT TO CONSOLE BUFFER

Now we point to the text in the Console Message and call the ADDLINE routine to add the text to our terminal output buffer.

000120 5820 5000      00000         107          L     R2,CMBNEXT         NEXT BUFFER                           
000124 5020 B004      00004         108          ST    R2,CCBMBQ          REMOVE FROM CCB QUEUE
                                    109 *                                                                       
000128                              110 WTO020   DS    
000128 5810 B008      00008         111          L     R1,CCBFMQ          GET TOP OF FREE QUEUE                 
00012C 5010 5000      00000         112          ST    R1,CMBNEXT                                               
000130 BA15 B008      00008         113          CS    R1,R5,CCBFMQ       PLACE ON FREE QUEUE                   
000134 4770 C126      00128         114          BNZ   WTO020                                                   
                                    115 *                                                                       
000138 47F0 C102      00104         116          B     WTO                GO PROCESS NEXT ELEMENT

Now we remove the element from the queue. We then add the CMB back to the free queue. Once that is done we go back and check to see if there is another CMB on the queue.

00013C                              119 WTO030   DS   0H                                                        
00013C 9240 C376      00378         120          MVI  DATA,X'40'          SET WCC                               
000140 D703 C34E C34E 00350 00350   121          XC   WECB,WECB           CLEAR WRITE ECB                       
000146 4110 C2FA      002FC         122          LA   R1,WIOB2            POINT TO IOB                          
00014A 0A00                         123          SVC  0                                                         
                                    124 *                                                                       
00014C 4110 C34E      00350         125          LA   R1,WECB                                                   
000150 0A01                         126          SVC  1                   WAIT FOR I/O                          
                                    127 *                                                                       
000152 47F0 C0BA      000BC         128          B    RUNLOOP1

When all the CMB elements have been processed we come here to write the updated buffer to the console terminal.

00017E                              134 ADDLINE  DS   0H                                                        
00017E 50E0 C1CE      001D0         135          ST   R14,ADDLINXT       SAVE RETURN ADDRESS                    
000182 58F0 C1D2      001D4         136          L    R15,ADDLCT                                                
000186 41F0 F001      00001         137          LA   R15,1(,R15)        ADD ONE                                
00018A 50F0 C1D2      001D4         138          ST   R15,ADDLCT                                                
                                    139 *                                                                       
00018E 59F0 CB9E      00BA0         140          C    R15,=F'24'                                                
000192 4740 C1A8      001AA         141          BL   ADDL010            DON'T NEED TO SCROLL UP                
                                    142 *                                                                       
000196 45E0 C232      00234         143          BAL  R14,PAGEUP                                                
00019A 41F0 0017      00017         144          LA   R15,23                                                    
00019E 50F0 C1D2      001D4         145          ST   R15,ADDLCT                                                
0001A2 41F0 CAB4      00AB6         146          LA   R15,L23                                                   
0001A6 47F0 C1B2      001B4         147          B    ADDL020                                                   
                                    148 *                                                                       
                                    149 *                                                                       
0001AA                              150 ADDL010   DS   0H                                                       
0001AA 06F0                         151           BCTR R15,0               SUBTRACT ONE                         
0001AC 89F0 0002      00002         152           SLL  R15,2              MULTIPLY BY 4                         
0001B0 58FF C1D6      001D8         153           L    R15,ADDLOFF(R15)   GET LINE OFFSET

The ADDLINE routine adds a line of text to the console output buffer. We get the current count of lines displayed on the terminal and add one. Since the terminal has 24 lines and one line is used for input we can display 23 lines. If we exceed 23 lines we call the PAGEUP routine to scroll the data up. If the line count is less we use the line number as an index to look up the address of the text area for the line.

0001B4                              155 ADDL020  DS    0H 
0001B4 18E0                         156          LR    R14,0              TEXT LENGTH                           
0001B6 12EE                         157          LTR   R14,R14                                                  
0001B8 4780 C1C0      001C2         158          BZ    ADDL030                                                  
                                    159 *                                                                       
0001BC 06E0                         160          BCTR  R14,0             SUBTRACT FOR EX                        
0001BE 44E0 C1C6      001C8         161          EX    R14,ADDLMVC                                              
                                    162 *                                                                       
0001C2                              163 ADDL030  DS    0H                                                       
0001C2 58E0 C1CE      001D0         164          L     R14,ADDLINXT      RESTORE R14                            
0001C6 07FE                         165          BR    R14                                                      
                                    166 *                                                                       
0001C8 D200 F000 1000 00000 00000   167 ADDLMVC  MVC   0(1,R15),0(R1)

Now we use an executed MVC to copy the text into the terminal output buffer at the proper location.

0001D0 00000000                     168 ADDLINXT DC    F'0'                                                     
0001D4 00000000                     169 ADDLCT   DC    F'0'                                                     
0001D8 0000037E000003D2             170 ADDLOFF  DC    A(L01,L02,L03,L04,L05,L06,L07,L08,L09,L10)               
000200 000006C60000071A             171          DC    A(L11,L12,L13,L14,L15,L16,L17,L18,L19,L20)               
000228 00000A0E00000A62             172          DC    A(L21,L22,L23)

This is the save area for the return address (R14), the count of lines currently displayed on the terminal, and the offset lookup table.

000234                              175 PAGEUP   DS    0H                                                       
000234 D24E C37C C3D0 0037E 003D2   176          MVC   L01,L02                                                  
00023A D24E C3D0 C424 003D2 00426   177          MVC   L02,L03                                                  
000240 D24E C424 C478 00426 0047A   178          MVC   L03,L04                                                  
000246 D24E C478 C4CC 0047A 004CE   179          MVC   L04,L05                                                  
00024C D24E C4CC C520 004CE 00522   180          MVC   L05,L06                                                  
000252 D24E C520 C574 00522 00576   181          MVC   L06,L07                                                  
000258 D24E C574 C5C8 00576 005CA   182          MVC   L07,L08                                                  
00025E D24E C5C8 C61C 005CA 0061E   183          MVC   L08,L09                                                  
000264 D24E C61C C670 0061E 00672   184          MVC   L09,L10                                                  
00026A D24E C670 C6C4 00672 006C6   185          MVC   L10,L11                                                  
000270 D24E C6C4 C718 006C6 0071A   186          MVC   L11,L12                                                  
000276 D24E C718 C76C 0071A 0076E   187          MVC   L12,L13                                                  
00027C D24E C76C C7C0 0076E 007C2   188          MVC   L13,L14                                                  
000282 D24E C7C0 C814 007C2 00816   189          MVC   L14,L15                                                  
000288 D24E C814 C868 00816 0086A   190          MVC   L15,L16                                                  
00028E D24E C868 C8BC 0086A 008BE   191          MVC   L16,L17                                                  
000294 D24E C8BC C910 008BE 00912   192          MVC   L17,L18                                                  
00029A D24E C910 C964 00912 00966   193          MVC   L18,L19                                                  
0002A0 D24E C964 C9B8 00966 009BA   194          MVC   L19,L20                                                  
0002A6 D24E C9B8 CA0C 009BA 00A0E   195          MVC   L20,L21                                                  
0002AC D24E CA0C CA60 00A0E 00A62   196          MVC   L21,L22                                                  
0002B2 D24E CA60 CAB4 00A62 00AB6   197          MVC   L22,L23                                                  	
0002B8 9240 CAB4      00AB6         198          MVI   L23,C' '                                                 
0002BC D24D CAB5 CAB4 00AB7 00AB6   199          MVC   L23+1(L'L23-1),L23                                       
0002C2 07FE                         200          BR    R14

The PAGEUP routine moves every line up one position in the output buffer. It discards the contents of line one and clears out the contents of line 23.

0002D4                              211 WIOB     DS    0F                                                       
0002D4 00000000                     212          DC    XL4'00'             FLAGS, SENSE                         
0002D8 00000350                     213          DC    A(WECB)             ECB                                  
0002DC 0000000000000000             214          DC    XL8'00'             CSW                                  
0002E4 00000360                     215          DC    A(CCW)                                                   
0002E8 00000000                     216          DC    A(0)                UCB                                  
0002EC 00000000                     217          DC    XL4'00'                                                  
0002F0 00000000                     218          DC    XL4'00'                                                  
0002F4 0000000000000000             219          DC    
                                    220 *                                                                       
                                    221 *                                                                       
0002FC                              222 WIOB2    DS    0F                                                       
0002FC 00000000                     223          DC    XL4'00'             FLAGS, SENSE                         
000300 00000350                     224          DC    A(WECB)             ECB                                  
000304 0000000000000000             225          DC    XL8'00'             CSW                                  
00030C 00000368                     226          DC    A(CCW2)                                                  
000310 00000000                     227          DC    A(0)                UCB                                  
000314 00000000                     228          DC    XL4'00'                                                  
000318 00000000                     229          DC    XL4'00'                                                  
00031C 0000000000000000             230          DC    XL8'00'                                                  
                                    231 *                                                                       
                                    232 *                                                                       
000324                              233 RIOB     DS    0F                                                       
000324 00000000                     234          DC    XL4'00'             FLAGS, SENSE                         
000328 0000034C                     235          DC    A(RECB)             ECB                                  
00032C 0000000000000000             236          DC    XL8'00'             CSW                                  
000334 00000370                     237          DC    A(CCWR)             CCW                                  
000338 00000000                     238          DC    A(0)                UCB                                  
00033C 00000000                     239          DC    XL4'00'                                                  
000340 00000000                     240          DC    XL4'00'                                                  
000344 0000000000000000             241          DC    XL8'00'                                                  
                                    242 *                                                                       
                                    243 *                                                                       
00034C 00000000                     244 RECB     DC    F'0'                READ ECB                             
000350 00000000                     245 WECB     DC    F'0'                WRITE ECB                            
000354 00000000                     246 ZECB     DC    F'0'                INTERRUPT ECB                        
000358 0000000000000000             247 ECBLIST  DC    A(0,0)                                                   
                                    248 *                                                                       
000360                              249          DS    0D                                                       
000360 0500037820000799             250 CCW      DC    X'05',AL3(DATA),X'20',AL3(DATALEN)                       
000368 0100037820000799             251 CCW2     DC    X'01',AL3(DATA),X'20',AL3(DATALEN)                       
000370 06000B1120000080             252 CCWR     DC    X'06',AL3(BUFR),X'20',AL3(BUFRLEN)

These are the definitions for our I/O Blocks (IOB), our ECBs, the ECB List, and the CCW’s.

000378 C3                           254 DATA     DC    X'C3'                                                    
                                    255          $SBA  R=1,C=1                                                  
000379 11                           256+         DC    X'11'                                                    
00037A 4040                         257+         DC   X'4040'                                                   
00037C 1DE8                         258          DC    X'1DE8'                                                  
00037E 4040404040404040             259 L01      DC    CL79' '                                                  
                                    260          $SBA  R=2,C=1                                                  
0003CD 11                           261+         DC    X'11'                                                    
0003CE C150                         262+         DC   X'C150'                                                   
0003D0 1DE8                         263          DC    X'1DE8'                                                  
0003D2 4040404040404040             264 L02      DC    CL79' ' 
                                    265          $SBA  R=3,C=1                                                  
000421 11                           266+         DC    X'11'                                                    
000422 C260                         267+         DC   X'C260'                                                   
000424 1DE8                         268          DC    X'1DE8'                                                  
                     .
                     .
                     .
                                    365          $SBA  R=23,C=1                                                 
000AB1 11                           366+         DC    X'11'                                                    
000AB2 5B60                         367+         DC   X'5B60'                                                   
000AB4 1DE8                         368          DC    X'1DE8'                                                  
000AB6 4040404040404040             369 L23      DC    CL79' '                                                  
                                    370          $SBA  R=24,C=1                                                 
000B05 11                           371+         DC    X'11'                                                    
000B06 5CF0                         372+         DC   X'5CF0'                                                   
000B08 1DE8                         373          DC    X'1DE8'                                                  
000B0A 7E7E7E6E                     374          DC    C'===>' 
000B0E 1DC113                       375          DC    X'1DC113'                                                
                            00799   376 DATALEN  EQU   *-DATA 

This is the terminal output buffer. It begins with a Write Control Character (WCC). We then define the 23 lines of output. Each line begins with a Set Buffer Address (SBA) sequence to set the Row/Column position of the buffer. (Again refer to my 3270 page on my website for more on 3270 control codes) Next comes a Start Field command (x1D) that specified a display only field (xE8). This repeats for lines 2 through 23. Line 24 is the input line. It begins with a SBA and a Start Field defining an output only field. This will be our prompt ‘===>’ and is followed by another Start Field (x1D) indicating an input field (xC1) followed by an Insert Cursor (x13) command to position the cursor in the first position of the input field.

I use the $SBA macro to generate the SBA buffer codes. I could have calculated them by hand or looked them up in a table and hard coded them. I also could have used a subroutine to calculate them at execution time. Since I already had the $SBA macro I chose to use it.

000B11                              378 BUFR     DS    CL128              INPUT BUFFER                          
                            00080   379 BUFRLEN  EQU   *-BUFR                                                   

This is the input buffer. We will never have this much input since our input line is 74 characters long but it never hurts to have a buffer a little larger.

[Next – ]

Leave a Reply

Your email address will not be published. Required fields are marked *