home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Programming / Pascal / HISOFTPASCAL2,0-3.DMS / in.adf / Units / Rexx.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1992-05-20  |  12.0 KB  |  752 lines
  1. unit Rexx;
  2.  
  3. INTERFACE
  4. uses Exec;
  5.  
  6.  
  7. type
  8.     pRexxMsg = ^tRexxMsg;
  9.     tRexxMsg = record
  10.         rm_Node: tMessage;
  11.         rm_TaskBlock: pointer;
  12.         rm_LibBase: pointer;
  13.         rm_Action: longint;
  14.         rm_Result1: longint;
  15.         rm_Result2: longint;
  16.         rm_Args: array [0..15] of STRPTR;
  17.         rm_PassPort: pMsgPort;
  18.         rm_CommAddr: STRPTR;
  19.         rm_FileExt: STRPTR;
  20.         rm_Stdin: longint;
  21.         rm_Stdout: longint;
  22.         rm_avail: longint;
  23.         end;
  24.  
  25.     pRexxTask = ^tRexxTask;
  26.     tRexxTask = record
  27.         rt_Global: array [0..199] of shortint;
  28.         rt_MsgPort: tMsgPort;
  29.         rt_Flags: byte;
  30.         rt_SigBit: shortint;
  31.         rt_ClientID: pointer;
  32.         rt_MsgPkt: pointer;
  33.         rt_TaskID: pointer;
  34.         rt_RexxPort: pointer;
  35.         rt_ErrTrap: pointer;
  36.         rt_StackPtr: pointer;
  37.         rt_Header1: tList;
  38.         rt_Header2: tList;
  39.         rt_Header3: tList;
  40.         rt_Header4: tList;
  41.         rt_Header5: tList;
  42.         end;
  43.  
  44.     pNexxStr = ^tNexxStr;
  45.     tNexxStr = record
  46.         ns_Ivalue: longint;
  47.         ns_Length: word;
  48.         ns_Flags: byte;
  49.         ns_Hash: byte;
  50.         ns_Buff: array [0..7] of shortint;
  51.         end;
  52.  
  53.     pRexxRsrc = ^tRexxRsrc;
  54.     tRexxRsrc = record
  55.         rr_Node: tNode;
  56.         rr_Func: integer;
  57.         rr_Base: pointer;
  58.         rr_Size: longint;
  59.         rr_Arg1: longint;
  60.         rr_Arg2: longint;
  61.         end;
  62.  
  63.     pRexxMsgPort = ^tRexxMsgPort;
  64.     tRexxMsgPort = record
  65.         rmp_Node: tRexxRsrc;
  66.         rmp_Port: tMsgPort;
  67.         rmp_ReplyList: tList;
  68.         end;
  69.  
  70.     pIoBuff = ^tIoBuff;
  71.     tIoBuff = record
  72.         iobNode: tRexxRsrc;
  73.         iobRpt: pointer;
  74.         iobRct: longint;
  75.         iobDFH: longint;
  76.         iobLock: pointer;
  77.         iobBct: longint;
  78.         iobArea: array [0..203] of shortint;
  79.         end;
  80.  
  81.     pSrcNode = ^tSrcNode;
  82.     tSrcNode = record
  83.         sn_Succ: pSrcNode;
  84.         sn_Pred: pSrcNode;
  85.         sn_Ptr: pointer;
  86.         sn_Size: longint;
  87.         end;
  88.  
  89.     pRxsLib = ^tRxsLib;
  90.     tRxsLib = record
  91.         rl_Node: tLibrary;
  92.         rl_Flags: byte;
  93.         rl_Shadow: byte;
  94.         rl_SysBase: pointer;
  95.         rl_DOSBase: pointer;
  96.         rl_IeeeDPBase: pointer;
  97.         rl_SegList: longint;
  98.         rl_NIL: longint;
  99.         rl_Chunk: longint;
  100.         rl_MaxNest: longint;
  101.         rl_NULL: pNexxStr;
  102.         rl_FALSE: pNexxStr;
  103.         rl_TRUE: pNexxStr;
  104.         rl_REXX: pNexxStr;
  105.         rl_COMMAND: pNexxStr;
  106.         rl_STDIN: pNexxStr;
  107.         rl_STDOUT: pNexxStr;
  108.         rl_STDERR: pNexxStr;
  109.         rl_Version: STRPTR;
  110.         rl_TaskName: STRPTR;
  111.         rl_TaskPri: longint;
  112.         rl_TaskSeg: longint;
  113.         rl_StackSize: longint;
  114.         rl_RexxDir: STRPTR;
  115.         rl_CTABLE: STRPTR;
  116.         rl_Notice: STRPTR;
  117.         rl_RexxPort: tMsgPort;
  118.         rl_ReadLock: word;
  119.         rl_TraceFH: longint;
  120.         rl_TaskList: tList;
  121.         rl_NumTask: integer;
  122.         rl_LibList: tList;
  123.         rl_NumLib: integer;
  124.         rl_ClipList: tList;
  125.         rl_NumClip: integer;
  126.         rl_MsgList: tList;
  127.         rl_NumMsg: integer;
  128.         rl_PgmList: tList;
  129.         rl_NumPgm: integer;
  130.         rl_TraceCnt: word;
  131.         rl_avail: integer;
  132.         end;
  133.  
  134.     pRexxArg = ^tRexxArg;
  135.     tRexxArg = record
  136.         ra_Size: longint;
  137.         ra_Length: word;
  138.         ra_Flags: byte;
  139.         ra_Hash: byte;
  140.         ra_Buff: array [0..7] of shortint;
  141.         end;
  142.  
  143.  
  144.  
  145. var
  146.     RexxSysBase: pLibrary;
  147.  
  148.  
  149. const
  150.     NSF_OWNED = $C1;
  151.     GLOBALSZ = $C8;
  152.     MAXRMARG = $F;
  153.     CTB_UPPER = 6;
  154.     CTF_LOWER = $80;
  155.     RXFB_NOIO = $10;
  156.     RXIO_WRITE = 2;
  157.     CTF_UPPER = $40;
  158.     RXIO_EXIST = $FFFFFFFF;
  159.     ACTION_STACK = $7D2;
  160.     NSF_DPNUM = $28;
  161.     RXREMLIB = $9000000;
  162.     RXFF_NOIO = $10000;
  163.     RXADDFH = $7000000;
  164.     RLFB_STOP = 6;
  165.     NSB_KEEP = 0;
  166.     MEMQUANT = $10;
  167.     NSF_KEEP = 1;
  168.     RLFB_SUSP = 2;
  169.     RXREMCON = $B000000;
  170.     MEMMASK = $FFFFFFF0;
  171.     ERRC_MSG = 0;
  172.     RXSTNAME = 'ARexx';
  173.     RTFB_SUSP = 2;
  174.     ACTION_QUEUE = $7D3;
  175.     RXSSTACK = $1000;
  176.     RLFMASK = 7;
  177.     RXSCHUNK = $400;
  178.     RRT_FILE = 3;
  179.     RXIO_CURR = 0;
  180.     RXIO_END = 1;
  181.     KEEPNUM = $9A;
  182.     RXBUFFSZ = $CC;
  183.     RXIO_STRF = 0;
  184.     RC_ERROR = $A;
  185.     RRT_CLIP = 5;
  186.     KEEPSTR = $86;
  187.     RXSNAME = 'rexxsyslib.library';
  188.     RXCLOSE = $3000000;
  189.     RXTCCLS = $D000000;
  190.     RXCODEMASK = $FF000000;
  191.     RXIO_APPEND = 3;
  192.     RLFB_TRACE = 0;
  193.     RC_WARN = 5;
  194.     RXTCOPN = $C000000;
  195.     RRT_LIB = 1;
  196.     RRT_HOST = 4;
  197.     RLFB_CLOSE = 7;
  198.     RTFB_TRACE = 0;
  199.     NSB_EXT = 6;
  200.     CTB_REXXSPC = 5;
  201.     NSF_EXT = $40;
  202.     RRT_PORT = 2;
  203.     RXSNEST = $20;
  204.     RXFB_NONRET = $14;
  205.     RXFB_STRING = $12;
  206.     RTFB_CLOSE = 7;
  207.     CTB_ALPHA = 2;
  208.     ERR10_001 = 1;
  209.     ERR10_010 = $A;
  210.     CTF_REXXSPC = $20;
  211.     ERR10_002 = 2;
  212.     ERR10_011 = $B;
  213.     ERR10_020 = $14;
  214.     RXCOMM = $1000000;
  215.     RXFUNC = $2000000;
  216.     DT_DEV = 0;
  217.     DT_DIR = 1;
  218.     ERR10_003 = 3;
  219.     ERR10_012 = $C;
  220.     ERR10_021 = $15;
  221.     ERR10_030 = $1E;
  222.     RXFF_NONRET = $100000;
  223.     RXIO_BEGIN = $FFFFFFFF;
  224.     RXSTPRI = 0;
  225.     ERR10_004 = 4;
  226.     ERR10_013 = $D;
  227.     ERR10_022 = $16;
  228.     ERR10_031 = $1F;
  229.     ERR10_040 = $28;
  230.     NSB_BINARY = 4;
  231.     RXFF_STRING = $40000;
  232.     CTF_ALPHA = 4;
  233.     ERR10_005 = 5;
  234.     ERR10_014 = $E;
  235.     ERR10_023 = $17;
  236.     ERR10_032 = $20;
  237.     ERR10_041 = $29;
  238.     ERR10_006 = 6;
  239.     ERR10_015 = $F;
  240.     ERR10_024 = $18;
  241.     ERR10_033 = $21;
  242.     ERR10_042 = $2A;
  243.     RRT_ANY = 0;
  244.     CTB_SPACE = 0;
  245.     ERR10_007 = 7;
  246.     ERR10_016 = $10;
  247.     ERR10_025 = $19;
  248.     ERR10_034 = $22;
  249.     ERR10_043 = $2B;
  250.     RXQUERY = $4000000;
  251.     ERR10_008 = 8;
  252.     ERR10_017 = $11;
  253.     ERR10_026 = $1A;
  254.     ERR10_035 = $23;
  255.     ERR10_044 = $2C;
  256.     NSB_NUMBER = 3;
  257.     NSF_BINARY = $10;
  258.     RXFB_RESULT = $11;
  259.     RXSDIR = 'REXX';
  260.     CTB_REXXOPR = 4;
  261.     ERR10_009 = 9;
  262.     ERR10_018 = $12;
  263.     ERR10_027 = $1B;
  264.     ERR10_036 = $24;
  265.     ERR10_045 = $2D;
  266.     ERR10_019 = $13;
  267.     ERR10_028 = $1C;
  268.     ERR10_037 = $25;
  269.     ERR10_046 = $2E;
  270.     CTF_SPACE = 1;
  271.     ERR10_029 = $1D;
  272.     ERR10_038 = $26;
  273.     ERR10_047 = $2F;
  274.     CTB_DIGIT = 1;
  275.     ERR10_039 = $27;
  276.     ERR10_048 = $30;
  277.     NSF_NUMBER = 8;
  278.     RXFF_RESULT = $20000;
  279.     CTF_REXXOPR = $10;
  280.     MEMCLEAR = $10000;
  281.     NSF_ALPHA = 6;
  282.     RTFB_TCUSE = 3;
  283.     RXFB_TOKEN = $13;
  284.     CTF_DIGIT = 2;
  285.     NSB_SOURCE = 7;
  286.     RLFB_HALT = 1;
  287.     CTB_REXXSYM = 3;
  288.     RXADDLIB = $8000000;
  289.     RXARGMASK = $F;
  290.     RXFF_TOKEN = $80000;
  291.     NSF_SOURCE = $80;
  292.     DT_VOL = 2;
  293.     CTF_REXXSYM = 8;
  294.     NXADDLEN = 9;
  295.     NSB_STRING = 1;
  296.     RTFB_HALT = 1;
  297.     NSB_FLOAT = 5;
  298.     NSF_STRING = 2;
  299.     RXADDCON = $A000000;
  300.     NSF_FLOAT = $20;
  301.     NSF_INTNUM = $1A;
  302.     RC_OK = 0;
  303.     RXIO_READ = 1;
  304.     NSB_NOTNUM = 2;
  305.     RC_FATAL = $14;
  306.     MEMQUICK = 1;
  307.     CTB_LOWER = 7;
  308.     NSF_NOTNUM = 4;
  309.     RTFB_WAIT = 6;
  310.  
  311.  
  312. function CreateArgstring
  313.         (string_: STRPTR;
  314.         length: long): STRPTR;
  315.  
  316. procedure DeleteArgstring (argstring: STRPTR);
  317. function LengthArgstring (argstring: STRPTR): long;
  318. function CreateRexxMsg
  319.         (port: pMsgPort;
  320.         extension: STRPTR;
  321.         host: STRPTR): pRexxMsg;
  322.  
  323. procedure DeleteRexxMsg (packet: pRexxMsg);
  324. procedure ClearRexxMsg
  325.         (msgptr: pRexxMsg;
  326.         count: long);
  327.  
  328. function FillRexxMsg
  329.         (msgptr: pRexxMsg;
  330.         count: long;
  331.         mask: long): boolean;
  332.  
  333. function IsRexxMsg (msgptr: pRexxMsg): boolean;
  334. procedure LockRexxBase (resource: long);
  335. procedure UnlockRexxBase (resource: long);
  336.  
  337.  
  338. function ARG0 (rmp: pRexxMsg): pbyte;
  339. function ARG1 (rmp: pRexxMsg): pbyte;
  340. function ARG2 (rmp: pRexxMsg): pbyte;
  341. function CLVALUE (rrp: pRexxRsrc): pbyte;
  342. function IVALUE (nsPtr: pNexxStr): longint;
  343. function LLOFFSET (rrp: pRexxRsrc): longint;
  344. function LLVERS (rrp: pRexxRsrc): longint;
  345.  
  346. (* Amiga.lib ARexx support *)
  347. function CheckRexxMsg (rexxmsg: pMessage): boolean;
  348. function GetRexxVar (rexxmsg: pMessage;
  349.         name: STRPTR; result: ppByte): longint;
  350. function SetRexxVar (rexxmsg: pMessage;
  351.         name, value: STRPTR; length: longint): longint;
  352.  
  353.  
  354. IMPLEMENTATION
  355. function ARG0;
  356. begin
  357.     ARG0 := rmp^.rm_Args[0]
  358. end;
  359.  
  360. function ARG1;
  361. begin
  362.     ARG1 := rmp^.rm_Args[1]
  363. end;
  364.  
  365. function ARG2;
  366. begin
  367.     ARG2 := rmp^.rm_Args[2]
  368. end;
  369.  
  370. function IVALUE;
  371. begin
  372.     IVALUE := nsPtr^.ns_Ivalue
  373. end;
  374.  
  375. function CLVALUE;
  376. begin
  377.     CLVALUE := pbyte(rrp^.rr_Arg1)
  378. end;
  379.  
  380. function LLOFFSET;
  381. begin
  382.     LLOFFSET := rrp^.rr_Arg1
  383. end;
  384.  
  385. function LLVERS;
  386. begin
  387.     LLVERS := rrp^.rr_Arg2
  388. end;
  389.  
  390. procedure CheckRexxMsg_; xassembler;
  391. asm
  392.     movem.l    d2/a2/a6,-(sp)
  393.     move.l    a0,a2
  394.     move.l    SysBase,a6
  395.     lea        @2(pc),a1
  396.     moveq    #0,d0
  397.     jsr        -$228(a6)
  398.     move.l    d0,d2
  399.     beq        @1
  400.     movea.l    d0,a1
  401.     jsr        -$19E(a6)
  402.     moveq    #0,d0
  403.     cmp.l    $18(a2),d2
  404.     bne        @1
  405.     move.l    $14(a2),d1
  406.     beq        @1
  407.     move.l    a2,a0
  408.     move.l    d2,a6
  409.     jsr        -$A8(a6)
  410. @1:
  411.     tst.l    d0
  412.     movem.l    (sp)+,d2/a2/a6
  413.     rts
  414.  
  415. @2:    dc.b    'rexxsyslib.library',0
  416. end;
  417.  
  418. function CheckRexxMsg (rexxmsg: pMessage): boolean; assembler;
  419. asm
  420.     move.l    rexxmsg,a0
  421.     jsr        CheckRexxMsg_
  422.     sne        d0
  423.     neg.b    d0
  424.     move.b    d0,@result
  425. end;
  426.  
  427. procedure rexx2; xassembler;
  428. asm
  429.     movem.l    d0/a1,-(sp)
  430.     addq.l    #8,d0
  431.     addq.l    #1,d0
  432.     jsr        -$72(a6)
  433.     movem.l    (sp)+,d0/a1
  434.     beq        @1
  435.     move.l    a0,-(sp)
  436.     clr.l    (a0)
  437.     move.w    d0,4(a0)
  438.     move.b    #2,6(a0)
  439.     clr.b    8(a0,d0.l)
  440.     addq.l    #8,a0
  441.     jsr        -$10E(a6)
  442.     move.l    (sp)+,a0
  443.     move.b    d0,7(a0)
  444. @1:
  445.     move.l    a0,d0
  446. end;
  447.  
  448. procedure rexx3; xassembler;
  449. asm
  450.     move.l    a1,d1
  451.     beq        @1
  452.     moveq    #1,d0
  453.     and.b    6(a1),d0
  454.     bne        @1
  455.     move.w    4(a1),d0
  456.     addq.l    #8,d0
  457.     addq.l    #1,d0
  458.     jsr        -$78(a6)
  459. @1:
  460. end;
  461.  
  462. procedure rexx1; xassembler;
  463. asm
  464.     movem.l    d2-d3/a2-a3,-(sp)
  465.     moveq    #0,d2
  466.     moveq    #0,d3
  467.     jsr        -$120(a6)
  468.     move.l    a0,a1
  469.     move.l    a4,a0
  470.     jsr        rexx2
  471.     move.l    d0,a2
  472.     beq        @3
  473.     lea        8(a2),a1
  474.     move.w    4(a2),d0
  475.     move.l    a1,d1
  476. @1:
  477.     cmpi.b    #$2E,(a1)+
  478.     dbeq    d0,@1
  479.     bne        @2
  480.     exg    d1,a1
  481.     sub.l    a1,d1
  482.     move.l    a2,d3
  483.     move.l    a4,a0
  484.     move.l    d1,d0
  485.     jsr        rexx2
  486.     move.l    d0,a2
  487.     beq        @3
  488. @2:
  489.     lea        8(a2),a0
  490.     jsr        -$66(a6)
  491.     cmp.w    4(a2),d1
  492.     beq        @4
  493.     moveq    #$28,d2
  494.     bra        @4
  495. @3:
  496.     moveq    #3,d2
  497. @4:
  498.     tst.l    d2
  499.     beq        @5
  500.     move.l    a4,a0
  501.     move.l    a2,a1
  502.     jsr        rexx3
  503.     move.l    a4,a0
  504.     move.l    d3,a1
  505.     jsr        rexx3
  506. @5:
  507.     move.l    a2,a1
  508.     move.l    d3,d1
  509.     move.l    d2,d0
  510.     movem.l    (sp)+,d2-d3/a2-a3
  511. end;
  512.  
  513. procedure GetRexxVar_; xassembler;
  514. asm
  515.     movem.l    d2-d3/a2-a6,-(sp)
  516.     move.l    a0,a2
  517.     move.l    a1,a3
  518.     jsr        CheckRexxMsg_
  519.     beq        @1
  520.     move.l    $18(a2),a6
  521.     move.l    $14(a2),a0
  522.     jsr        -$6C(a6)
  523.     move.l    a0,a4
  524.     move.l    a3,a0
  525.     jsr        rexx1
  526.     bne        @2
  527.     move.l    a1,a2
  528.     move.l    d1,d2
  529.     move.l    a4,a0
  530.     move.l    d2,d0
  531.     moveq    #0,d1
  532.     jsr        -$48(a6)
  533.     moveq    #0,d0
  534.     addq.l    #8,a1
  535.     tst.l    d1
  536.     beq        @2
  537.     suba.l    a1,a1
  538.     bra        @2
  539. @1:
  540.     moveq    #$A,d0
  541. @2:
  542.     tst.l    d0
  543.     movem.l    (sp)+,d2-d3/a2-a6
  544. end;
  545.  
  546. function GetRexxVar (rexxmsg: pMessage;
  547.         name: STRPTR; result: ppByte): longint; assembler;
  548. asm
  549.     move.l    rexxmsg,a0
  550.     move.l    name,a1
  551.     jsr        GetRexxVar_
  552.     move.l    d0,@result
  553.     bne        @1
  554.     move.l    result,a0
  555.     move.l    a1,(a0)
  556. @1:
  557. end;
  558.  
  559. procedure rexx4; xassembler;
  560. asm
  561.     move.l    a3,-(sp)
  562.     move.l    $14(a2),a3
  563.     move.l    a2,0(a1)
  564.     movem.l    $FC(a3),d0-d1
  565.     movem.l    a0-a1,$FC(a3)
  566.     movem.l    d0-d1,4(a1)
  567.     move.l    (sp)+,a3
  568. end;
  569.  
  570. procedure rexx5; xassembler;
  571. asm
  572.     move.l    0(a0),a1
  573.     move.l    $14(a1),a1
  574.     movem.l    4(a0),d0-d1
  575.     movem.l    d0-d1,$FC(a1)
  576. end;
  577.  
  578. procedure SetRexxVar_; xassembler;
  579. asm
  580.     movem.l    d2-d7/a2-a6,-(sp)
  581.     lea        -$C(sp),sp
  582.     move.l    a0,a2
  583.     move.l    a1,a3
  584.     move.l    d0,a5
  585.     move.l    d1,d3
  586.     lea        @1(pc),a0
  587.     move.l    sp,a1
  588.     jsr        rexx4
  589.     move.l    a2,a0
  590.     jsr        CheckRexxMsg_
  591.     beq        @2
  592.     move.l    $18(a2),a6
  593.     moveq    #9,d0
  594.     cmpi.l    #$FFFF,d3
  595.     bgt        @3
  596.     move.l    $14(a2),a0
  597.     jsr        -$6C(a6)
  598.     move.l    a0,a4
  599.     move.l    a3,a0
  600.     jsr        rexx1
  601.     bne        @3
  602.     move.l    a1,a2
  603.     move.l    d1,d2
  604.     move.l    a4,a0
  605.     move.l    d2,d0
  606.     jsr        -$42(a6)
  607.     move.l    d0,d4
  608.     move.l    a4,a0
  609.     move.l    a5,a1
  610.     move.l    d3,d0
  611.     jsr        rexx2
  612.     beq        @1
  613.     move.l    a4,a0
  614.     move.l    d0,a1
  615.     move.l    d4,d0
  616.     jsr        -$54(a6)
  617.     moveq    #0,d0
  618.     bra        @3
  619. @1:
  620.     moveq    #3,d0
  621.     bra        @3
  622. @2:
  623.     moveq    #$A,d0
  624. @3:
  625.     move.l    sp,a0
  626.     move.l    d0,-(sp)
  627.     jsr        rexx5
  628.     move.l    (sp)+,d0
  629.     lea        $C(sp),sp
  630.     movem.l    (sp)+,d2-d7/a2-a6
  631. end;
  632.  
  633. function SetRexxVar (rexxmsg: pMessage;
  634.         name, value: STRPTR; length: longint): longint; assembler;
  635. asm
  636.     move.l    rexxmsg,a0
  637.     move.l    name,a1
  638.     move.l    value,d0
  639.     move.l    length,d1
  640.     jsr        SetRexxVar_
  641.     move.l    d0,@result
  642. end;
  643.  
  644. function CreateArgstring; xassembler;
  645. asm
  646.     move.l    a6,-(sp)
  647.     movem.l    8(sp),d0/a0
  648.     move.l    RexxSysBase,a6
  649.     jsr        -$7E(a6)
  650.     move.l    d0,$10(sp)
  651.     move.l    (sp)+,a6
  652. end;
  653.  
  654. procedure DeleteArgstring; xassembler;
  655. asm
  656.     move.l    a6,-(sp)
  657.     move.l    8(sp),a0
  658.     move.l    RexxSysBase,a6
  659.     jsr        -$84(a6)
  660.     move.l    (sp)+,a6
  661. end;
  662.  
  663. function LengthArgstring; xassembler;
  664. asm
  665.     move.l    a6,-(sp)
  666.     move.l    8(sp),a0
  667.     move.l    RexxSysBase,a6
  668.     jsr        -$8A(a6)
  669.     move.l    d0,$C(sp)
  670.     move.l    (sp)+,a6
  671. end;
  672.  
  673. function CreateRexxMsg; xassembler;
  674. asm
  675.     move.l    a6,-(sp)
  676.     lea        8(sp),a6
  677.     move.l    (a6)+,d0
  678.     move.l    (a6)+,a1
  679.     move.l    (a6)+,a0
  680.     move.l    RexxSysBase,a6
  681.     jsr        -$90(a6)
  682.     move.l    d0,$14(sp)
  683.     move.l    (sp)+,a6
  684. end;
  685.  
  686. procedure DeleteRexxMsg; xassembler;
  687. asm
  688.     move.l    a6,-(sp)
  689.     move.l    8(sp),a0
  690.     move.l    RexxSysBase,a6
  691.     jsr        -$96(a6)
  692.     move.l    (sp)+,a6
  693. end;
  694.  
  695. procedure ClearRexxMsg; xassembler;
  696. asm
  697.     move.l    a6,-(sp)
  698.     movem.l    8(sp),d0/a0
  699.     move.l    RexxSysBase,a6
  700.     jsr        -$9C(a6)
  701.     move.l    (sp)+,a6
  702. end;
  703.  
  704. function FillRexxMsg; xassembler;
  705. asm
  706.     move.l    a6,-(sp)
  707.     lea        8(sp),a6
  708.     move.l    (a6)+,d1
  709.     move.l    (a6)+,d0
  710.     move.l    (a6)+,a0
  711.     move.l    RexxSysBase,a6
  712.     jsr        -$A2(a6)
  713.     tst.l    d0
  714.     sne        d0
  715.     neg.b    d0
  716.     move.b    d0,$14(sp)
  717.     move.l    (sp)+,a6
  718. end;
  719.  
  720. function IsRexxMsg; xassembler;
  721. asm
  722.     move.l    a6,-(sp)
  723.     move.l    8(sp),a0
  724.     move.l    RexxSysBase,a6
  725.     jsr        -$A8(a6)
  726.     tst.l    d0
  727.     sne        d0
  728.     neg.b    d0
  729.     move.b    d0,$C(sp)
  730.     move.l    (sp)+,a6
  731. end;
  732.  
  733. procedure LockRexxBase; xassembler;
  734. asm
  735.     move.l    a6,-(sp)
  736.     move.l    8(sp),d0
  737.     move.l    RexxSysBase,a6
  738.     jsr        -$1C2(a6)
  739.     move.l    (sp)+,a6
  740. end;
  741.  
  742. procedure UnlockRexxBase; xassembler;
  743. asm
  744.     move.l    a6,-(sp)
  745.     move.l    8(sp),d0
  746.     move.l    RexxSysBase,a6
  747.     jsr        -$1C8(a6)
  748.     move.l    (sp)+,a6
  749. end;
  750.  
  751. end.
  752.