development/compilers/freepascal/rtl/aros/rexx.pas

   1 {
   2     This file is part of the Free Pascal run time library.
   3
   4     A file in Amiga system run time library.
   5     Copyright (c) 1998 by Nils Sjoholm
   6     member of the Amiga RTL development team.
   7
   8     See the file COPYING.FPC, included in this distribution,
   9     for details about the copyright.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  14
  15  **********************************************************************}
  16
  17
  18 UNIT rexx;
  19
  20 INTERFACE
  21 USES exec;
  22
  23
  24 { === rexx/storage.h ==================================================
  25  *
  26  * Copyright (c) 1986, 1987 by William S. Hawes (All Rights Reserved)
  27  *
  28  * =====================================================================
  29  * Header file to define ARexx data structures.
  30 }
  31
  32
  33 { The NexxStr structure is used to maintain the internal strings in REXX.
  34  * It includes the buffer area for the string and associated attributes.
  35  * This is actually a variable-length structure; it is allocated for a
  36  * specific length string, and the length is never modified thereafter
  37  * (since it's used for recycling).
  38  }
  39
  40 Type
  41
  42     pNexxStr = ^tNexxStr;
  43     tNexxStr = record
  44     ns_Ivalue   : Longint;  { integer value                 }
  45     ns_Length   : Word;     { length in bytes (excl null)   }
  46     ns_Flags    : Byte;     { attribute flags               }
  47     ns_Hash     : Byte;     { hash code                     }
  48     ns_Buff     : Array [0..7] of Byte;
  49                     { buffer area for strings       }
  50     end;                { size: 16 bytes (minimum)      }
  51
  52 Const
  53
  54     NXADDLEN    = 9;            { offset plus null byte         }
  55
  56 { String attribute flag bit definitions                                }
  57
  58     NSB_KEEP    = 0;            { permanent string?             }
  59     NSB_STRING  = 1;            { string form valid?            }
  60     NSB_NOTNUM  = 2;            { non-numeric?                  }
  61     NSB_NUMBER  = 3;            { a valid number?               }
  62     NSB_BINARY  = 4;            { integer value saved?          }
  63     NSB_FLOAT   = 5;            { floating point format?        }
  64     NSB_EXT = 6;            { an external string?           }
  65     NSB_SOURCE  = 7;            { part of the program source?   }
  66
  67 { The flag form of the string attributes                               }
  68
  69     NSF_KEEP    = 1;
  70     NSF_STRING  = 2;
  71     NSF_NOTNUM  = 4;
  72     NSF_NUMBER  = 8;
  73     NSF_BINARY  = 16;
  74     NSF_FLOAT   = 32;
  75     NSF_EXT = 64;
  76     NSF_SOURCE  = 128;
  77
  78 { Combinations of flags                                                }
  79
  80     NSF_INTNUM  = NSF_NUMBER + NSF_BINARY + NSF_STRING;
  81     NSF_DPNUM   = NSF_NUMBER + NSF_FLOAT;
  82     NSF_ALPHA   = NSF_NOTNUM + NSF_STRING;
  83     NSF_OWNED   = NSF_SOURCE + NSF_EXT    + NSF_KEEP;
  84     KEEPSTR = NSF_STRING + NSF_SOURCE + NSF_NOTNUM;
  85     KEEPNUM = NSF_STRING + NSF_SOURCE + NSF_NUMBER + NSF_BINARY;
  86
  87 { The RexxArg structure is identical to the NexxStr structure, but
  88  * is allocated from system memory rather than from internal storage.
  89  * This structure is used for passing arguments to external programs.
  90  * It is usually passed as an "argstring", a pointer to the string buffer.
  91 }
  92
  93 Type
  94
  95     pRexxArg = ^tRexxArg;
  96     tRexxArg = record
  97     ra_Size     : Longint;  { total allocated length        }
  98     ra_Length   : Word;     { length of string              }
  99     ra_Flags    : Byte;     { attribute flags               }
 100     ra_Hash     : Byte;     { hash code                     }
 101     ra_Buff     : Array [0..7] of Byte;
 102                     { buffer area                   }
 103     end;                { size: 16 bytes (minimum)      }
 104
 105 { The RexxMsg structure is used for all communications with REXX
 106  * programs.  It is an EXEC message with a parameter block appended.
 107 }
 108
 109     pRexxMsg = ^tRexxMsg;
 110     tRexxMsg = record
 111     rm_Node     : tMessage;  { EXEC message structure        }
 112     rm_TaskBlock    : Pointer;  { global structure (private)    }
 113     rm_LibBase  : Pointer;  { library base (private)        }
 114     rm_Action   : Longint;  { command (action) code         }
 115     rm_Result1  : Longint;  { primary result (return code)  }
 116     rm_Result2  : Longint;  { secondary result              }
 117     rm_Args     : Array [0..15] of STRPTR;
 118                     { argument block (ARG0-ARG15)   }
 119
 120     rm_PassPort : pMsgPort;   { forwarding port               }
 121     rm_CommAddr : STRPTR;   { host address (port name)      }
 122     rm_FileExt  : STRPTR;   { file extension                }
 123     rm_Stdin    : Longint;  { input stream (filehandle)     }
 124     rm_Stdout   : Longint;  { output stream (filehandle)    }
 125     rm_avail    : Longint;  { future expansion              }
 126     end;                { size: 128 bytes               }
 127
 128 Const
 129
 130     MAXRMARG        = 15;       { maximum arguments             }
 131
 132 { Command (action) codes for message packets                           }
 133
 134     RXCOMM      = $01000000;    { a command-level invocation    }
 135     RXFUNC      = $02000000;    { a function call               }
 136     RXCLOSE     = $03000000;    { close the REXX server         }
 137     RXQUERY     = $04000000;    { query for information         }
 138     RXADDFH     = $07000000;    { add a function host           }
 139     RXADDLIB        = $08000000;    { add a function library        }
 140     RXREMLIB        = $09000000;    { remove a function library     }
 141     RXADDCON        = $0A000000;    { add/update a ClipList string  }
 142     RXREMCON        = $0B000000;    { remove a ClipList string      }
 143     RXTCOPN     = $0C000000;    { open the trace console        }
 144     RXTCCLS     = $0D000000;    { close the trace console       }
 145
 146 { Command modifier flag bits                                           }
 147
 148     RXFB_NOIO       = 16;       { suppress I/O inheritance?     }
 149     RXFB_RESULT     = 17;       { result string expected?       }
 150     RXFB_STRING     = 18;       { program is a "string file"?   }
 151     RXFB_TOKEN      = 19;       { tokenize the command line?    }
 152     RXFB_NONRET     = 20;       { a "no-return" message?        }
 153
 154 { The flag form of the command modifiers                               }
 155
 156     RXFF_NOIO       = $00010000;
 157     RXFF_RESULT     = $00020000;
 158     RXFF_STRING     = $00040000;
 159     RXFF_TOKEN      = $00080000;
 160     RXFF_NONRET     = $00100000;
 161
 162     RXCODEMASK      = $FF000000;
 163     RXARGMASK       = $0000000F;
 164
 165 { The RexxRsrc structure is used to manage global resources.  Each node
 166  * has a name string created as a RexxArg structure, and the total size
 167  * of the node is saved in the "rr_Size" field.  The REXX systems library
 168  * provides functions to allocate and release resource nodes.  If special
 169  * deletion operations are required, an offset and base can be provided in
 170  * "rr_Func" and "rr_Base", respectively.  This "autodelete" function will
 171  * be called with the base in register A6 and the node in A0.
 172  }
 173
 174 Type
 175
 176     pRexxRsrc = ^tRexxRsrc;
 177     tRexxRsrc = record
 178     rr_Node     : tNode;
 179     rr_Func     : Integer;    { "auto-delete" offset          }
 180     rr_Base     : Pointer;  { "auto-delete" base            }
 181     rr_Size     : Longint;  { total size of node            }
 182     rr_Arg1     : Longint;  { available ...                 }
 183     rr_Arg2     : Longint;  { available ...                 }
 184     end;                { size: 32 bytes                }
 185
 186 Const
 187
 188 { Resource node types                                                  }
 189
 190     RRT_ANY     = 0;        { any node type ...             }
 191     RRT_LIB     = 1;        { a function library            }
 192     RRT_PORT        = 2;        { a public port                 }
 193     RRT_FILE        = 3;        { a file IoBuff                 }
 194     RRT_HOST        = 4;        { a function host               }
 195     RRT_CLIP        = 5;        { a Clip List node              }
 196
 197 { The RexxTask structure holds the fields used by REXX to communicate with
 198  * external processes, including the client task.  It includes the global
 199  * data structure (and the base environment).  The structure is passed to
 200  * the newly-created task in its "wake-up" message.
 201  }
 202
 203     GLOBALSZ        = 200;      { total size of GlobalData      }
 204
 205 Type
 206
 207     pRexxTask = ^tRexxTask;
 208     tRexxTask = record
 209     rt_Global   : Array [0..GLOBALSZ-1] of Byte;
 210                     { global data structure         }
 211     rt_MsgPort  : tMsgPort;  { global message port           }
 212     rt_Flags    : Byte;     { task flag bits                }
 213     rt_SigBit   : Shortint;     { signal bit                    }
 214
 215     rt_ClientID : Pointer;  { the client's task ID          }
 216     rt_MsgPkt   : Pointer;  { the packet being processed    }
 217     rt_TaskID   : Pointer;  { our task ID                   }
 218     rt_RexxPort : Pointer;  { the REXX public port          }
 219
 220     rt_ErrTrap  : Pointer;  { Error trap address            }
 221     rt_StackPtr : Pointer;  { stack pointer for traps       }
 222
 223     rt_Header1  : tList;     { Environment list              }
 224     rt_Header2  : tList;     { Memory freelist               }
 225     rt_Header3  : tList;     { Memory allocation list        }
 226     rt_Header4  : tList;     { Files list                    }
 227     rt_Header5  : tList;     { Message Ports List            }
 228     end;
 229
 230 Const
 231
 232 { Definitions for RexxTask flag bits                                   }
 233
 234     RTFB_TRACE      = 0;        { external trace flag           }
 235     RTFB_HALT       = 1;        { external halt flag            }
 236     RTFB_SUSP       = 2;        { suspend task?                 }
 237     RTFB_TCUSE      = 3;        { trace console in use?         }
 238     RTFB_WAIT       = 6;        { waiting for reply?            }
 239     RTFB_CLOSE      = 7;        { task completed?               }
 240
 241 { Definitions for memory allocation constants                          }
 242
 243     MEMQUANT        = 16;       { quantum of memory space       }
 244     MEMMASK     = $FFFFFFF0;    { mask for rounding the size    }
 245
 246     MEMQUICK        = 1;        { EXEC flags: MEMF_PUBLIC       }
 247     MEMCLEAR        = $00010000;    { EXEC flags: MEMF_CLEAR        }
 248
 249 { The SrcNode is a temporary structure used to hold values destined for
 250  * a segment array.  It is also used to maintain the memory freelist.
 251 }
 252
 253 Type
 254
 255     pSrcNode = ^tSrcNode;
 256     tSrcNode = record
 257     sn_Succ     : pSrcNode; { next node                     }
 258     sn_Pred     : pSrcNode; { previous node                 }
 259     sn_Ptr      : Pointer;  { pointer value                 }
 260     sn_Size     : Longint;  { size of object                }
 261     end;                { size: 16 bytes                }
 262
 263 { === rexx/rexxio.h ====================================================
 264  *
 265  * Copyright (c) 1986, 1987 by William S. Hawes.  All Rights Reserved.
 266  *
 267  * ======================================================================
 268  * Header file for ARexx Input/Output related structures
 269 }
 270
 271 Const
 272
 273     RXBUFFSZ    = 204;          { buffer length                 }
 274
 275 {
 276  * The IoBuff is a resource node used to maintain the File List.  Nodes
 277  * are allocated and linked into the list whenever a file is opened.
 278 }
 279
 280 Type
 281
 282     pIoBuff = ^tIoBuff;
 283     tIoBuff = record
 284     iobNode     : tRexxRsrc; { structure for files/strings   }
 285     iobRpt      : Pointer;  { read/write pointer            }
 286     iobRct      : Longint;  { character count               }
 287     iobDFH      : Longint;  { DOS filehandle                }
 288     iobLock     : Longint;  { DOS lock                      }
 289     iobBct      : Longint;  { buffer length                 }
 290     iobArea     : Array [0..RXBUFFSZ-1] of Byte;
 291                     { buffer area                   }
 292     end;                { size: 256 bytes               }
 293
 294 Const
 295
 296 { Access mode definitions                                              }
 297
 298     RXIO_EXIST      = -1;       { an external filehandle        }
 299     RXIO_STRF       = 0;        { a "string file"               }
 300     RXIO_READ       = 1;        { read-only access              }
 301     RXIO_WRITE      = 2;        { write mode                    }
 302     RXIO_APPEND     = 3;        { append mode (existing file)   }
 303
 304 {
 305  * Offset anchors for SeekF()
 306 }
 307
 308     RXIO_BEGIN      = -1;       { relative to start             }
 309     RXIO_CURR       = 0;        { relative to current position  }
 310     RXIO_END        = 1;        { relative to end               }
 311
 312 {
 313  * A message port structure, maintained as a resource node.  The ReplyList
 314  * holds packets that have been received but haven't been replied.
 315 }
 316
 317 Type
 318
 319     pRexxMsgPort = ^tRexxMsgPort;
 320     tRexxMsgPort = record
 321     rmp_Node    : tRexxRsrc; { linkage node                  }
 322     rmp_Port    : tMsgPort;  { the message port              }
 323     rmp_ReplyList   : tList;     { messages awaiting reply       }
 324     end;
 325
 326 Const
 327
 328 {
 329  * DOS Device types
 330 }
 331
 332     DT_DEV  = 0;            { a device                      }
 333     DT_DIR  = 1;            { an ASSIGNed directory         }
 334     DT_VOL  = 2;            { a volume                      }
 335
 336 {
 337  * Private DOS packet types
 338 }
 339
 340     ACTION_STACK    = 2002;     { stack a line                  }
 341     ACTION_QUEUE    = 2003;     { queue a line                  }
 342
 343 { === rexx/rxslib.h ===================================================
 344  *
 345  * Copyright (c) 1986, 1987, 1989 by William S. Hawes (All Rights Reserved)
 346  *
 347  * =====================================================================
 348  * The header file for the REXX Systems Library
 349 }
 350
 351 { Some macro definitions                                               }
 352
 353 Const
 354
 355     RXSNAME    : PChar = 'rexxsyslib.library';
 356     RXSID      : PChar = 'rexxsyslib 1.06 (07 MAR 88)';
 357     RXSDIR     : PChar = 'REXX';
 358     RXSTNAME   : PChar = 'ARexx';
 359
 360 { The REXX systems library structure.  This should be considered as    }
 361 { semi-private and read-only, except for documented exceptions.        }
 362
 363 Type
 364
 365     pRxsLib = ^tRxsLib;
 366     tRxsLib = record
 367     rl_Node     : tLibrary;  { EXEC library node             }
 368     rl_Flags    : Byte;     { global flags                  }
 369     rl_pad      : Byte;
 370     rl_SysBase  : Pointer;  { EXEC library base             }
 371     rl_DOSBase  : Pointer;  { DOS library base              }
 372     rl_IeeeDPBase   : Pointer;  { IEEE DP math library base     }
 373     rl_SegList  : Longint;  { library seglist               }
 374     rl_NIL      : Longint;  { global NIL: filehandle        }
 375     rl_Chunk    : Longint;  { allocation quantum            }
 376     rl_MaxNest  : Longint;  { maximum expression nesting    }
 377     rl_NULL     : pNexxStr;   { static string: NULL           }
 378     rl_FALSE    : pNexxStr;   { static string: FALSE          }
 379     rl_TRUE     : pNexxStr;   { static string: TRUE           }
 380     rl_REXX     : pNexxStr;   { static string: REXX           }
 381     rl_COMMAND  : pNexxStr;   { static string: COMMAND        }
 382     rl_STDIN    : pNexxStr;   { static string: STDIN          }
 383     rl_STDOUT   : pNexxStr;   { static string: STDOUT         }
 384     rl_STDERR   : pNexxStr;   { static string: STDERR         }
 385     rl_Version  : STRPTR;   { version/configuration string  }
 386
 387     rl_TaskName : STRPTR;   { name string for tasks         }
 388     rl_TaskPri  : Longint;  { starting priority             }
 389     rl_TaskSeg  : Longint;  { startup seglist               }
 390     rl_StackSize    : Longint;  { stack size                    }
 391     rl_RexxDir  : STRPTR;   { REXX directory                }
 392     rl_CTABLE   : STRPTR;   { character attribute table     }
 393     rl_Notice   : STRPTR;   { copyright notice              }
 394
 395     rl_RexxPort : tMsgPort;  { REXX public port              }
 396     rl_ReadLock : Word;    { lock count                    }
 397     rl_TraceFH  : Longint;  { global trace console          }
 398     rl_TaskList : tList;     { REXX task list                }
 399     rl_NumTask  : Integer;    { task count                    }
 400     rl_LibList  : tList;     { Library List header           }
 401     rl_NumLib   : Integer;    { library count                 }
 402     rl_ClipList : tList;     { ClipList header               }
 403     rl_NumClip  : Integer;    { clip node count               }
 404     rl_MsgList  : tList;     { pending messages              }
 405     rl_NumMsg   : Integer;    { pending count                 }
 406     rl_PgmList  : tList;     { cached programs               }
 407     rl_NumPgm   : Integer;    { program count                 }
 408
 409     rl_TraceCnt : Word;    { usage count for trace console }
 410     rl_avail    : Integer;
 411     end;
 412
 413 Const
 414
 415 { Global flag bit definitions for RexxMaster                           }
 416     RLFB_TRACE  = RTFB_TRACE;       { interactive tracing?          }
 417     RLFB_HALT   = RTFB_HALT;        { halt execution?               }
 418     RLFB_SUSP   = RTFB_SUSP;        { suspend execution?            }
 419     RLFB_STOP   = 6;            { deny further invocations      }
 420     RLFB_CLOSE  = 7;            { close the master              }
 421
 422     RLFMASK = 1 + 2 + 4;
 423
 424 { Initialization constants                                             }
 425
 426     RXSVERS = 34;           { main version                  }
 427     RXSREV  = 7;            { revision                      }
 428     RXSALLOC    = $800000;      { maximum allocation            }
 429     RXSCHUNK    = 1024;         { allocation quantum            }
 430     RXSNEST = 32;           { expression nesting limit      }
 431     RXSTPRI = 0;            { task priority                 }
 432     RXSSTACK    = 4096;         { stack size                    }
 433     RXSLISTH    = 5;            { number of list headers        }
 434
 435 { Character attribute flag bits used in REXX.                          }
 436
 437     CTB_SPACE   = 0;            { white space characters        }
 438     CTB_DIGIT   = 1;            { decimal digits 0-9            }
 439     CTB_ALPHA   = 2;            { alphabetic characters         }
 440     CTB_REXXSYM = 3;            { REXX symbol characters        }
 441     CTB_REXXOPR = 4;            { REXX operator characters      }
 442     CTB_REXXSPC = 5;            { REXX special symbols          }
 443     CTB_UPPER   = 6;            { UPPERCASE alphabetic          }
 444     CTB_LOWER   = 7;            { lowercase alphabetic          }
 445
 446 { Attribute flags                                                      }
 447
 448     CTF_SPACE   = 1;
 449     CTF_DIGIT   = 2;
 450     CTF_ALPHA   = 4;
 451     CTF_REXXSYM = 8;
 452     CTF_REXXOPR = 16;
 453     CTF_REXXSPC = 32;
 454     CTF_UPPER   = 64;
 455     CTF_LOWER   = 128;
 456
 457
 458 VAR RexxSysBase : pLibrary;
 459
 460 PROCEDURE ClearRexxMsg(msgptr : pRexxMsg; count : ULONG);
 461 FUNCTION CreateArgstring(argstring : pCHAR; length : ULONG) : pCHAR;
 462 FUNCTION CreateRexxMsg(port : pMsgPort; extension : pCHAR; host : pCHAR) : pRexxMsg;
 463 PROCEDURE DeleteArgstring(argstring : pCHAR);
 464 PROCEDURE DeleteRexxMsg(packet : pRexxMsg);
 465 FUNCTION FillRexxMsg(msgptr : pRexxMsg; count : ULONG; mask : ULONG) : BOOLEAN;
 466 FUNCTION IsRexxMsg(msgptr : pRexxMsg) : BOOLEAN;
 467 FUNCTION LengthArgstring(argstring : pCHAR) : ULONG;
 468 PROCEDURE LockRexxBase(resource : ULONG);
 469 PROCEDURE UnlockRexxBase(resource : ULONG);
 470
 471 IMPLEMENTATION
 472
 473 PROCEDURE ClearRexxMsg(msgptr : pRexxMsg; count : ULONG);
 474 BEGIN
 475   ASM
 476     MOVE.L  A6,-(A7)
 477     MOVEA.L msgptr,A0
 478     MOVE.L  count,D0
 479     MOVEA.L RexxSysBase,A6
 480     JSR -156(A6)
 481     MOVEA.L (A7)+,A6
 482   END;
 483 END;
 484
 485 FUNCTION CreateArgstring(argstring : pCHAR; length : ULONG) : pCHAR;
 486 BEGIN
 487   ASM
 488     MOVE.L  A6,-(A7)
 489     MOVEA.L argstring,A0
 490     MOVE.L  length,D0
 491     MOVEA.L RexxSysBase,A6
 492     JSR -126(A6)
 493     MOVEA.L (A7)+,A6
 494     MOVE.L  D0,@RESULT
 495   END;
 496 END;
 497
 498 FUNCTION CreateRexxMsg(port : pMsgPort; extension : pCHAR; host : pCHAR) : pRexxMsg;
 499 BEGIN
 500   ASM
 501     MOVE.L  A6,-(A7)
 502     MOVEA.L port,A0
 503     MOVEA.L extension,A1
 504     MOVE.L  host,D0
 505     MOVEA.L RexxSysBase,A6
 506     JSR -144(A6)
 507     MOVEA.L (A7)+,A6
 508     MOVE.L  D0,@RESULT
 509   END;
 510 END;
 511
 512 PROCEDURE DeleteArgstring(argstring : pCHAR);
 513 BEGIN
 514   ASM
 515     MOVE.L  A6,-(A7)
 516     MOVEA.L argstring,A0
 517     MOVEA.L RexxSysBase,A6
 518     JSR -132(A6)
 519     MOVEA.L (A7)+,A6
 520   END;
 521 END;
 522
 523 PROCEDURE DeleteRexxMsg(packet : pRexxMsg);
 524 BEGIN
 525   ASM
 526     MOVE.L  A6,-(A7)
 527     MOVEA.L packet,A0
 528     MOVEA.L RexxSysBase,A6
 529     JSR -150(A6)
 530     MOVEA.L (A7)+,A6
 531   END;
 532 END;
 533
 534 FUNCTION FillRexxMsg(msgptr : pRexxMsg; count : ULONG; mask : ULONG) : BOOLEAN;
 535 BEGIN
 536   ASM
 537     MOVE.L  A6,-(A7)
 538     MOVEA.L msgptr,A0
 539     MOVE.L  count,D0
 540     MOVE.L  mask,D1
 541     MOVEA.L RexxSysBase,A6
 542     JSR -162(A6)
 543     MOVEA.L (A7)+,A6
 544     TST.W   D0
 545     BEQ.B   @end
 546     MOVEQ   #1,D0
 547   @end: MOVE.B  D0,@RESULT
 548   END;
 549 END;
 550
 551 FUNCTION IsRexxMsg(msgptr : pRexxMsg) : BOOLEAN;
 552 BEGIN
 553   ASM
 554     MOVE.L  A6,-(A7)
 555     MOVEA.L msgptr,A0
 556     MOVEA.L RexxSysBase,A6
 557     JSR -168(A6)
 558     MOVEA.L (A7)+,A6
 559     TST.W   D0
 560     BEQ.B   @end
 561     MOVEQ   #1,D0
 562   @end: MOVE.B  D0,@RESULT
 563   END;
 564 END;
 565
 566 FUNCTION LengthArgstring(argstring : pCHAR) : ULONG;
 567 BEGIN
 568   ASM
 569     MOVE.L  A6,-(A7)
 570     MOVEA.L argstring,A0
 571     MOVEA.L RexxSysBase,A6
 572     JSR -138(A6)
 573     MOVEA.L (A7)+,A6
 574     MOVE.L  D0,@RESULT
 575   END;
 576 END;
 577
 578 PROCEDURE LockRexxBase(resource : ULONG);
 579 BEGIN
 580   ASM
 581     MOVE.L  A6,-(A7)
 582     MOVE.L  resource,D0
 583     MOVEA.L RexxSysBase,A6
 584     JSR -450(A6)
 585     MOVEA.L (A7)+,A6
 586   END;
 587 END;
 588
 589 PROCEDURE UnlockRexxBase(resource : ULONG);
 590 BEGIN
 591   ASM
 592     MOVE.L  A6,-(A7)
 593     MOVE.L  resource,D0
 594     MOVEA.L RexxSysBase,A6
 595     JSR -456(A6)
 596     MOVEA.L (A7)+,A6
 597   END;
 598 END;
 599
 600 END. (* UNIT REXXSYSLIB *)