StartModule     DC.L    (EndModule-StartModule)/4
EntryPoint      EQU     *
#
# // "Include files containing useful constants"
#
# GET "LIBHDR"
# GET "IOHDR"
# GET "MANHDR"
# GET "EXECHDR"
#
# // This is a handler for the port tasks
#
# // When the task is creates, the parameter packet contains
# // parm.pkt!pkt.arg1 = BPTR to BCPL string of device name, i.e.  ("SKEL:")
# // parm.pkt!pkt.arg2 = extra info (if needed)
# // parm.pkt!pkt.arg3 = BPTR to device info node
#
# MANIFEST
# $(
#    IO.blocksize = 30 // size of devices IO block
# $)
#
# LET start(parm.pkt) BE
# $(
310044:         MOVE.L  D1,D2 
# LET extrainfo = parm.pkt!pkt.arg2
310046:         LSL.L   #2,D2 
310048:         MOVE.L  18(A0,D2.L),4(A1) 
# LET read.pkt = 0
31004E:         CLR.L   8(A1) 
# LET write.pkt = 0
310052:         CLR.L   C(A1) 
#
# LET openstring = parm.pkt!pkt.arg1
310056:         MOVE.L 14(A0,D2.L),10(A1) 
#
# LET inpkt  = VEC pkt.res1
31005C:         MOVE.L #18,D3 
31005E:         ADD.L A1,D3 
310060:         LSR.L #2,D3 
310062:         MOVE.L D3,14(A1)
# LET outpkt  = VEC pkt.res1
310066:         MOVE.L #2C,D4 
310068:         ADD.L A1,D4 
31006A:         LSR.L #2,D4 
31006C:         MOVE.L D4,28(A1) 
# LET IOB     = VEC IO.blocksize
310070:         MOVE.L #40,D5 
310072:         ADD.L A1,D5 
310074:         LSR.L #2,D5 
310076:         MOVE.L D5,3C(A1) 
# LET IOIBO    = VEC IO.blocksize
31007A:         MOVE.L #C0,D6 
310080:         ADD.L A1,D6 
310082:         LSR.L #2,D6 
310084:         MOVE.L D6,BC(A1) 

# LET error = FALSE
310088:         CLR.L 13C(A1) 
#
# TEST extrainfo = 0 THEN    // is it a open on SER:
31008C:         TST.L 4(A1) 
310090:         BNE 3100A0 
#     LET devname = "serial.device*X00"
310094:         LEA 464(A4),A3 
310098:         MOVE.L A3,D1 
31009A:         LSR.L #2,D1 
# ELSE
31009C:         BRA 3100BE 
#     TEST extrainfo = 1 THEN   // is it an open on PAR:
3100A0:         MOVE.L #1,D1 
3100A2:         CMP.L 4(A1),D1 
3100A6:         BNE 3100B6
#        LET devname = "parallel.device*X00"
3100AA:         LEA 474(A4),A3 
3100AE:         MOVE.L A3,D1 
3100B0:         LSR.L #2,D1
#     ELSE 
3100B2:         BRA 3100BE 
#        LET devname = "printer.device*X00"
3100B6:         LEA 488(A4),A3 
3100BA:         MOVE.L A3,D1 
3100BC:         LSR.L #2,D1
# 
3100BE:         MOVE.L D1,140(A1) 
#
# LET ?? = TRUE
3100C2:         MOVE.L #FFFFFFFF,D2 
3100C4:         MOVE.L D2,144(A1) 
#
# 
3100C8:         LEA 498(A4),A3 
3100CC:         MOVE.L A3,D3 
3100CE:         LSR.L #2,D3 
3100D0:         MOVE.L D3,148(A1) 
#
# LET ?? = 0
3100D4:         CLR.L 14C(A1) 
#
# LET ?? = 0
3100D8:         CLR.L 150(A1) 
#
# LET ?? = node = parm.pkt!pkt.arg3
3100DC:         MOVE.L (A1),D4 
3100DE:         LSL.L #2,D4 
3100E0:         MOVE.L 1C(A0,D4.L),154(A1) 
#
# FOR i=0 to IO.blocksize DO IOB!i := 0
3100E6:         CLR.L   158(A1) 
3100EA:         MOVE.L  #1E,D5 
3100EC:         MOVE.L  D5,15C(A1) 
3100F0:         BRA     310106 
3100F4:         MOVE.L  3C(A1),D1 
3100F8:         ADD.L   158(A1),D1 
3100FC:         LSL.L   #2,D1 
3100FE:         CLR.L   0(A0,D1.L) 
310102:         ADD.L   #1,158(A1) 
310106:         MOVE.L  15C(A1),D1 
31010A:         CMP.L   158(A1),D1 
31010E:         BGE     3100F4 

# IF OpenDevice( IOB, devname, 0, 0) = 0
310110:         MOVE.L #0,D4 
310112:         MOVE.L D4,D3 
310114:         MOVE.L 140(A1),D2 
310118:         MOVE.L 3C(A1),D1 
31011C:         MOVE.L #164,D0 
310122:         MOVE.L 7C(A2),A4 
310126:         JSR (A5) 
310128:         TST.L D1 
31012A:         BNE 310134 
#    error := TRUE
31012E:         MOVE.L #FFFFFFFF,D1 
310130:         MOVE.L D1,13C(A1) 
#
# IF error THEN
310134:         TST.L 13C(A1) 
310138:         BEQ 310154 
#    $( returnpkt(parm.pkt, FALSE, error, objectinuse)
31013C:         MOVE.L #CA,D3 
310142:         MOVE.L #0,D2 
310144:         MOVE.L (A1),D1 
310146:         MOVE.L #164,D0 
31014C:         MOVE.L C4(A2),A4 
310150:         JSR (A5)
#    return
310152:         JMP (A6) 
#    $)
#
# // Copy all the necessary info to the Output buffer too.
#
# FOR i=0 TO IO.blocksize DO IOBO!i := IOB!
310154:         CLR.L 158(A1) 
310158:         MOVE.L #1E,D1 
31015A:         MOVE.L D1,15C(A1) 
31015E:         BRA 310180 
310162:         MOVE.L 3C(A1),D1 
310166:         ADD.L 158(A1),D1 
31016A:         LSL.L #2,D1 
31016C:         MOVE.L BC(A1),D2 
310170:         ADD.L 158(A1),D2 
310174:         LSL.L #2,D2 
310176:         MOVE.L 0(A0,D1.L),0(A0,D2.L) 
31017C:         ADD.L #1,158(A1) 
310180:         MOVE.L 15C(A1),D1 
310184:         CMP.L 158(A1),D1 
310188:         BGE 310162
#
# TEST extrainfo = 2 &&         // did they ask for the printer
31018A:         MOVE.L #2,D2 
31018C:         CMP.L 4(A1),D2 
310190:         BNE 3101F8 
#      LEN(openstring < 4) THEN // with a name longer than PRT:?
310194:         MOVE.L 10(A1),D3 
310198:         LSL.L #2,D3 
31019A:         MOVE.L #0,D4 
31019C:         MOVE.B 0(A0,D3.L),D4 
3101A0:         MOVE.L #4,D5 
3101A2:         CMP.L D5,D4 
3101A4:         BLE 3101F8
#    $(
3101A8:         MOVE.L 148(A1),D4 
3101AC:         LSL.L #2,D4 
3101AE:         MOVE.L #0,D6 
3101B0:         MOVE.B 0(A0,D4.L),D6 
3101B4:         MOVE.L D6,D4 
3101B6:         MOVE.L 16C(A1),D3 
3101BA:         MOVE.L #3,D2 
3101BC:         MOVE.L BC(A1),D1 
3101C0:         MOVE.L #164,D0 
3101C6:         MOVE.L 18(A2),A4 
3101CA:         JSR (A5) 
3101CC:         MOVE.L 148(A1),D1 
3101D0:         LSL.L #2,D1 
3101D2:         ADD.L #1,D1 
3101D4:         MOVE.L D1,D3 
3101D6:         MOVE.L #28,D2 
3101D8:         MOVE.L BC(A1),D1 
3101DC:         MOVE.L #164,D0 
3101E2:         MOVE.L 1BC(A2),A4 
3101E6:         JSR (A5) 
3101E8:         MOVE.L BC(A1),D1 
3101EC:         MOVE.L #164,D0 
3101F2:         MOVE.L 54(A2),A4 
3101F6:         JSR (A5)
#    $) 
#
# outpkt!pkt.type := act.write
3101F8:         MOVE.L 28(A1),D1 
3101FC:         LSL.L #2,D1 
3101FE:         MOVE.L #3EA,8(A0,D1.L)
# inpkt!pkt.type := act.read
310206:         MOVE.L 14(A1),D1 
31020A:         LSL.L #2,D1 
31020C:         MOVE.L #3E9,8(A0,D1.L) 
# node!dev.task := taskid()
310214:         MOVE.L #164,D0 
31021A:         MOVE.L 38(A2),A4  ;tadkid()
31021E:         JSR (A5) 
310220:         MOVE.L 154(A1),D2 
310224:         LSL.L #2,D2 
310226:         MOVE.L D1,8(A0,D2.L) 
#
# // Finished with parameter packer...send back...
#
# returnpkt( park.pkt, TRUE )
31022A:         MOVE.L #FFFFFFFF,D2 
31022C:         MOVE.L (A1),D1 
31022E:         MOVE.L #164,D0 
310234:         MOVE.L C4(A2),A4 
310238:         JSR (A5)
#
# // This is the main repeat loop waiting for an event
#
# $( LET p = taskwait() 
31023A:         MOVE.L #164,D0 
310240:         MOVE.L A4(A2),A4 
310244:         JSR (A5)
310246:         MOVE.L D1,158(A1)
#
# SWITCHON p!pkt.type INTO 
31024A:         BRA 310426
# CASE ????:
31024E:         MOVE.L 158(A1),D1 
310252:         LSL.L #2,D1 
310254:         MOVE.L 14(A0,D1.L),15C(A1) 
31025A:         TST.L 14C(A1) 
31025E:         BEQ 31027E 
310262:         MOVE.L #CA,D3 
310268:         MOVE.L #0,D2 
31026A:         MOVE.L 158(A1),D1 
31026E:         MOVE.L #16C,D0 
310274:         MOVE.L C4(A2),A4 
310278:         JSR (A5) 
31027A:         BRA 310474 
#
# CASE ????:
31027E:         MOVE.L #FFFFFFFF,D1 
310280:         MOVE.L D1,14C(A1) 
310284:         MOVE.L 15C(A1),D2 
310288:         LSL.L #2,D2 
31028A:         MOVE.L D1,4(A0,D2.L) 
31028E:         MOVE.L 15C(A1),D2 
310292:         LSL.L #2,D2 
310294:         MOVE.L #3ED,24(A0,D2.L) 
31029C:         MOVE.L D1,D2 
31029E:         MOVE.L 158(A1),D1 
3102A2:         MOVE.L #16C,D0 
3102A8:         MOVE.L C4(A2),A4 
3102AC:         JSR (A5) 
3102AE:         BRA 310474 
#
# CASE ????:               
3102B2:         MOVE.L 158(A1),D1 
3102B6:         LSL.L #2,D1 
3102B8:         MOVE.L 14(A0,D1.L),15C(A1) 
3102BE:         TST.L 150(A1) 
3102C2:         BEQ 3102E2 
3102C6:         MOVE.L #CA,D3 
3102CC:         MOVE.L #0,D2 
3102CE:         MOVE.L 158(A1),D1 
3102D2:         MOVE.L #16C,D0 
3102D8:         MOVE.L C4(A2),A4 
3102DC:         JSR (A5) 
3102DE:         BRA 310474 
#
# CASE ????:
3102E2:         MOVE.L #FFFFFFFF,D1 
3102E4:         MOVE.L D1,150(A1) 
3102E8:         MOVE.L 15C(A1),D2 
3102EC:         LSL.L #2,D2 
3102EE:         MOVE.L D1,4(A0,D2.L) 
3102F2:         MOVE.L 15C(A1),D2 
3102F6:         LSL.L #2,D2 
3102F8:         MOVE.L #3EE,24(A0,D2.L) 
310300:         MOVE.L D1,D2 
310302:         MOVE.L 158(A1),D1 
310306:         MOVE.L #16C,D0 
31030C:         MOVE.L C4(A2),A4 
310310:         JSR (A5) 
310312:         BRA 310474 
#
# CASE ????:
310316:         MOVE.L 158(A1),D1 
31031A:         LSL.L #2,D1 
31031C:         CMP.L #3ED,14(A0,D1.L) 
310324:         BNE 310330 
310328:         CLR.L 14C(A1) 
31032C:         BRA 310334 
310330:         CLR.L 150(A1) 
310334:         TST.L 14C(A1) 
310338:         BNE 31034E 
31033C:         TST.L 150(A1) 
310340:         BNE 31034E 
310344:         MOVE.L 154(A1),D1 
310348:         LSL.L #2,D1 
31034A:         CLR.L 8(A0,D1.L) 
31034E:         MOVE.L #FFFFFFFF,D2 
310350:         MOVE.L 158(A1),D1 
310354:         MOVE.L #168,D0 
31035A:         MOVE.L C4(A2),A4 
31035E:         JSR (A5) 
310360:         BRA 310474 
#
# CASE ????:
310364:         MOVE.L 158(A1),14(A1) 
31036A:         MOVE.L 8(A1),D2 
31036E:         MOVE.L 3C(A1),D1 
310372:         MOVE.L #168,D0 
310378:         LEA 4E4(A4),A4 
31037C:         JSR (A5) 
31037E:         BRA 310474 
#
# CASE ????:
310382:         MOVE.L 158(A1),28(A1) 
310388:         MOVE.L C(A1),D2 
31038C:         MOVE.L BC(A1),D1 
310390:         MOVE.L #168,D0 
310396:         LEA 4E4(A4),A4 
31039A:         JSR (A5) 
31039C:         BRA 310474 
#
# CASE ????:
3103A0:         MOVE.L 158(A1),8(A1) 
3103A6:         MOVE.L 14(A1),D4 
3103AA:         MOVE.L 158(A1),D3 
3103AE:         MOVE.L #2,D2 
3103B0:         MOVE.L 3C(A1),D1 
3103B4:         MOVE.L #168,D0 
3103BA:         LEA 4A0(A4),A4 
3103BE:         JSR (A5) 
3103C0:         CLR.L 14(A1) 
3103C4:         BRA 310474 
#
# CASE ????:
3103C8:         MOVE.L 158(A1),C(A1) 
3103CE:         MOVE.L 28(A1),D4 
3103D2:         MOVE.L 158(A1),D3 
3103D6:         MOVE.L #3,D2 
3103D8:         MOVE.L BC(A1),D1 
3103DC:         MOVE.L #168,D0 
3103E2:         LEA 4A0(A4),A4 
3103E6:         JSR (A5) 
3103E8:         CLR.L 28(A1) 
3103EC:         BRA 310474 
#
# DEFAULT:
3103F0:         TST.L 14C(A1) 
3103F4:         BNE 31040A 
3103F8:         TST.L 150(A1) 
3103FC:         BNE 31040A 
310400:         MOVE.L 154(A1),D1 
310404:         LSL.L #2,D1 
310406:         CLR.L 8(A0,D1.L) 
31040A:         MOVE.L #D1,D3 
310410:         MOVE.L #0,D2 
310412:         MOVE.L 158(A1),D1 
310416:         MOVE.L #168,D0 
31041C:         MOVE.L C4(A2),A4 
310420:         JSR (A5) 
310422:         BRA 310474 
#
# // SWITCHON p!pkt.type INTO 
310426:         MOVE.L 158(A1),D1 
31042A:         LSL.L #2,D1 
31042C:         MOVE.L 8(A0,D1.L),D1 

310430:         MOVE.L #52,D2 
310432:         CMP.L D2,D1 
310434:         BEQ 3103A0 

310438:         MOVE.L #57,D3 
31043A:         CMP.L D3,D1 
31043C:         BEQ 3103C8 

31043E:         CMP.L #3E9,D1 
310444:         BEQ 310364 

310448:         CMP.L #3EA,D1 
31044E:         BEQ 310382 

310452:         CMP.L #3ED,D1 
310458:         BEQ 31024E 

31045C:         CMP.L #3EE,D1 
310462:         BEQ 3102B2 

310466:         CMP.L #3EF,D1 
31046C:         BEQ 310316 
310470:         BRA 3103F0 

# $) REPEATWHILE open |
310474:         TST.L 14C(A1) 
310478:         BNE 31023A 
#    ??? = 0
31047C:         TST.L 150(A1) 
310480:         BNE 31023A
#    outpkt = 0 |
310484:         TST.L 28(A1) 
310488:         BEQ 31023A 
#    inpkt = 0
31048C:         TST.L 14(A1) 
310490:         BEQ 31023A 
#
# // Termination
#
# CloseDevice( IOB )
310494:         MOVE.L 3C(A1),D1 
310498:         MOVE.L #164,D0 
31049E:         MOVE.L 80(A2),A4 
3104A2:         JSR (A5) 
3104A4:         JMP (A6) 
#
# $)               
3104A6:         NOP
                CNOP    0,4
3104A8:         DC.B    14, 'serial.device',0
                CNOP    0,4
3104B8:         DC.B    16, 'parallel.device',0
                CNOP    0,4
3104C8:         DC.B    15, 'printer.device',0
               
3104DC:         ADD.B #[2,(A3)+ 
#
# // Handle an IO request.  Passed command, transmission packet (tp)
# // and request packet (rp). rp contains buffer and length in arg2/3
# AND handle.request(IOB, command, rp, tp ) BE
# $(
#    LET buff  = rp!pkt.arg2 
3104E0:         MOVE.W 0(A4),A0 
3104E4:         MOVE.L D3,D5 
3104E6:         LSL.L #2,D5
3104E8:         MOVE.L 18(A0,D5.L),10(A1) 
#    LET len   = rp!pkt.arg3
3104EE:         MOVE.L 1C(A0,D5.L),14(A1) 
3104F4:         CLR.L 34(A1)
#    SetIO( IOB, IO.data, buff )
3104F8:         MOVE.L 1C(A0,D5.L),D4 
3104FC:         MOVE.L 2C(A1),D3 
310500:         MOVE.L #$,D0 
310502:         MOVE.L 18(A2),A4 
310506:         JSR (A5)
#    putlong( IOB, IO.data, buff )
310508:         MOVE.L 10(A1),D3 
31050C:         MOVE.L #(,D2 
31050E:         MOVE.L (A1),D1 
310510:         MOVE.L #$,D0 
310512:         MOVE.L 1BC(A2),A4 
310516:         JSR (A5) 
#    SendIO(IOB, tp)               
310518:         MOVE.L C(A1),D2 
31051C:         MOVE.L (A1),D1 
31051E:         MOVE.L #$,D0 
310520:         MOVE.L 58(A2),A4 
310524:         JSR (A5) 
# $)
310526:         JMP (A6) 
#
# // Handle a returning IO request.  The user request packet is
# // passed as p, and must be returned with success/failure message.
# AND handle.return(IOB, p ) BE
# $(
#    LET errcode = IOB O.error
310528:         MOVE.L D1,D3 
31052A:         LSL.L #@,D3 
31052C:         MOVE.L #@,D4 
31052E:         MOVE.B 1F(A0,D3.L),D4 
310532:         MOVE.L D4,8(A1) 
#    LET len = getlong( IOB, IO.actual )
310536:         MOVE.L # ,D2 
310538:         MOVE.L #@,D0 
31053A:         MOVE.L 1B8(A2),A4 
31053E:         JSR (A5) 
#
#    TEST errcode = 0 THEN     // no error
310540:         MOVE.L D1,C(A1) 
310544:         TST.L 8(A1) 
310548:         BNE 31055E 
#       returnpkt(p, len )
31054C:         MOVE.L D1,D2 
31054E:         MOVE.L 4(A1),D1 
310552:         MOVE.L #@,D0 
310554:         MOVE.L C4(A2),A4 
310558:         JSR (A5) 
#    ELSE
31055A:         BRA 310570 
#       returnpkt(p, -1, errcode )
31055E:         MOVE.L 8(A1),D3 
310562:         MOVE.L #@@@@,D2 
310564:         MOVE.L 4(A1),D1 
310568:         MOVE.L #@,D0 
31056A:         MOVE.L C4(A2),A4 
31056E:         JSR (A5) 
310570:         JMP (A6) 
# $)
#
310572:         NOP  
310574:         CNOP 0,4
                DC.L    0
                DC.L    1
                DC.L    Entry-Module
                DC.L    $6f                     111
ModEnd          EQU     *