(*--------------------------------------------------------------------------- :Program. ARP.def :Author. M2 implementation by Fridtjof Siebert :Address. Nobileweg 67, D-7-Stgt-40 :Shortcut. [fbs] :Version. 1.0 (ARP version 34) :Date. 14-Jan-88 :Copyright. PD :Language. Modula-II :Translator. M2Amiga v3.3d neucompiliert 26-Mar-90 :History. 30-Dec-88 v0.1 created for ARP1.0 [fbs] :History. 14-Jan-88 v1.0 implementation for ARP1.1 [fbs] :Contents. Library Modul for arp.library. :Remark. Contact me if your find errors. I wasn't able to all of it! :Remark. Thanx to Martin Taillefer for his Benchmark ARP-code ---------------------------------------------------------------------------*) DEFINITION MODULE ARP {"arp.library",34}; FROM SYSTEM IMPORT ADDRESS, LONGSET, SHIFT, BPTR; FROM Dos IMPORT DosLibrary, FileInfoBlock, FileInfoBlockPtr, FileHandlePtr, FileLockPtr, ProcessPtr, DosPacketPtr, DatePtr, BSTR, DeviceList, Date, InfoDataPtr; FROM Exec IMPORT UByte, Byte, MinList, MinNode, MsgPortPtr, MemReqSet, SignalSemaphore, TaskPtr, Node, Library, Message; FROM Graphics IMPORT GfxBasePtr; FROM Intuition IMPORT IntuitionBase, WindowPtr; (*------ Some Pointers: ------*) TYPE STRPTR = ADDRESS; (* POINTER TO ARRAY OF CHAR, used for clarity *) DeviceListPtr = POINTER TO DeviceList; (* can't be imported from DOS *) (*------ Types needed for template: ------*) StrArrayPtr = POINTER TO ARRAY [0..1000] OF STRPTR; (* StrArrayPtr is a pointer to an array of pointers to strings *) WBArgPtr = POINTER TO WBArg; WBArg = RECORD lock: FileLockPtr; (* a lock descriptor *) str : STRPTR; (* a string relative to that lock *) END; CLIArgPtr = POINTER TO CLIArg; CLIArg = RECORD CASE : CARDINAL OF 0: bool: BOOLEAN; | 1: long: LONGINT; | 2: str: STRPTR; | 3: array: StrArrayPtr;| END; END; (*------ Library Stuff: ------*) (* use Wildcards/escapes like rest of world or like current dos: *) ArpFlags = (wildWorld,wildBCPL); ArpFlagSet = SET OF ArpFlags; EnvLibPtr = POINTER TO EnvLib; ArpBasePtr = POINTER TO ArpBase; ArpBase = RECORD libNode: Library; (* Standard library node *) segList: BPTR; (* Pointer to segment list of loaded library *) flags: Byte; (* Not used, yet! *) escChar: CHAR; (* Character used for ESCaping *) abreserved: LONGCARD; (* ArpLib's use only!! *) envBase: EnvLibPtr; (* ptr to environment *) dosBase: POINTER TO DosLibrary; gfxBase: GfxBasePtr; intuiBase: POINTER TO IntuitionBase; resLists: MinList; residentPrgList: ADDRESS; (* Resident Programs. *) resPrgProtection: SignalSemaphore; (* Protection for above *) END; EnvLib = RECORD libNode: Library; space: ADDRESS; size: LONGCARD; arpBase: ArpBasePtr; END; (* library constants: *) CONST arpname = 'arp.library'; arpversion = 34; (*------ ARP Alert Numbers: ------*) aoArpLib = 8036H; (* Alert Object *) (* Alerts ARP can return *) anArpLib = 03600000H; anArpNoMem = 03610000H; (* ArpLibrary out of memory *) anArpInputMem = 03610002H; (* No memory for input buffer *) anArpNoMakeEnv = 83610003H; (* No memory for Environment library *) anArpNoDOS = 83630001H; (* Can't Open DOS library *) anArpNoGfx = 83630002H; (* Can't open Graphics library *) anArpNoIntuit = 83630003H; (* Can't open Intuition library *) anBadPackBlues = 83640000H; (* Bad packet returned to SendPacket() *) anZombie = 83600003H; (* Zombie roaming around system *) anArpScattered = 83600002H; (* Scatter loading not allowed *) (*------ Return codes from Assign() and CompareLock(): ------*) TYPE AssignRes = (assignOK,assignNoDev,assignFatal,assignCancel); LockComp = (equal,equalVolume,difVol1,difVol2); CONST maxInputBuf = 256; (* size of buffer needed for ReadLine() *) (*------ Input structure for File Requester ------*) fChars = 32; dSize = 33; frFirstGadg = 7680H; TYPE FileName = ARRAY[0..fChars] OF CHAR; DirName = ARRAY[0..dSize] OF CHAR; FileNamePtr = POINTER TO FileName; DirNamePtr = POINTER TO DirName; FileReqFlags = (listFunc,gEventFunc,addGadFunc,newWindFunc,newIDCMP, doColor,doMsgFunc,doWildFunc); FileReqFlagSet = SET OF FileReqFlags; FileReqFunc = PROCEDURE(ADDRESS,LONGCARD): LONGINT; (* I've changed the parameter's order 'cause I heard that M2-arguments are put on the stack in this order. I didn't test this yet! *) FileRequesterPtr = POINTER TO FileRequester; FileRequester = RECORD hail: STRPTR; (* Hailing text *) ddef: FileNamePtr; (* Filename array (FCHARS+1) *) ddir: DirNamePtr; (* Directory array (DSIZE+1) *) wind: WindowPtr; (* Window requesting or NULL *) funcFlags: FileReqFlagSet; (* Control. See above. *) reserved1: UByte; (* Set this to 0 *) function: FileReqFunc; (* Your function, see btdef's *) reserved2: LONGINT; (* reserved *) END; (*------ Structures and constants used by the wildcard routines ------*) CONST pAny = 80H; pSingle = 81H; pOrStart = 82H; pOrNext = 83H; pOrEnd = 84H; pTag = 85H; pTagEnd = 86H; pNotClass = 87H; pClass = 88H; pRepBeg = 89H; pReqEnd = 8AH; complexBit = 1; (* status bits *) examineBit = 2; errorBufferOverflow = 303; (* Returned by FindFirst() and FindNext(); *) errorInternal = 999; errorBreak = 304; bufSize = 200; dosTRUE = 0; dosFALSE = -1; maxFName = 200; stdAnchorSize = 256; TYPE AnchorPtr = POINTER TO Anchor; AnchorPathPtr = POINTER TO AnchorPath; AnchorPath = RECORD (* this is used by FindFirst/FindNext *) base: AnchorPtr; last: AnchorPtr; breakBits: LONGSET; foundBreak: LONGSET; length: LONGCARD; (* set this to 0 *) info: FileInfoBlock; END; StdAnchorPathPtr = POINTER TO StdAnchorPath; StdAnchorPath = RECORD anchor: AnchorPath; (* set anchor.length to stdAnchorSize *) buffer: ARRAY[0..stdAnchorSize-1] OF CHAR; END; Anchor = RECORD next: AnchorPtr; pred: AnchorPtr; lock: FileLockPtr; info: FileInfoBlockPtr; status: LONGSET; (* see bits above *) CASE : CARDINAL OF 0: text: INTEGER; | 1: actual: ARRAY[0..1] OF Byte; | END; END; (*------ Structure used by AddDANode etc.: ------*) DirEntryTypes = (devices,diskonly,volumes,dirs,det4,det5); DirEntryTypeSet = SET OF DirEntryTypes; DirectoryEntryPtr = POINTER TO DirectoryEntry; DirectoryEntry = RECORD next: DirectoryEntryPtr; type: DirEntryTypeSet; flags: Byte; name: ARRAY[0..255] OF CHAR; (* sorry, if your stuff gets longer! *) END; CONST deFile = DirEntryTypeSet{}; (* 0 *) deDir = DirEntryTypeSet{dirs}; (* 8 *) deDevice = DirEntryTypeSet{det4}; (* 16 *) deVolume = DirEntryTypeSet{dirs,det4}; (* 24 *) deUnmounted = DirEntryTypeSet{det5}; (* 32 *) deAssign = DirEntryTypeSet{dirs,det5}; (* 40 *) (*------ Resource Tracking: ------*) trakAAMem = 0; (* Default generic (ArpAlloc) element *) trakLock = 1; (* File Lock *) trakFile = 2; (* Opened File *) trakWindow = 3; (* Window (see discussion) *) trakScreen = 4; (* Screen *) trakLibrary = 5; (* Opened library *) trakDAMem = 6; (* Pointer to DosAllocMem block *) trakMemList = 7; (* Exec Memlist *) trakSegList = 8; (* Program Segment List *) trakResList = 9; (* ARP (nested) ResList *) trakMem = 10; (* Memory ptr/length *) trakGeneric = 11; (* Generic Element *) trakDAList = 12; (* DAlist ( as used by file request ) *) trakAnchor = 13; (* Anchor chain *) trakMax = 13; (* Anything else is tossed. *) TYPE ArpResListPtr = POINTER TO ArpResList; ArpResList = RECORD node: MinNode; (* line these together *) taskID: TaskPtr; firstItem: MinList; link: ArpResListPtr; (* for temp removal from task rlist *) END; TrackedResPtr = POINTER TO TrackedRes; TrackedRes = RECORD node: MinNode; flags: Byte; lock: Byte; id: INTEGER; (* see above *) CASE :INTEGER OF 0:resource: ADDRESS; value: LONGINT; | 1:function: PROC; window2: WindowPtr; | END; user1 : ADDRESS; (* A pointer you can use yourself *) user2 : LONGCARD; (* A long you can use yourself *) END; DefaultTrackerPtr = POINTER TO DefaultTracker; DefaultTracker = RECORD CASE : CARDINAL OF |0: resource : ADDRESS; (* Whatever *) |1: value : LONGCARD; (* For use during TrakGeneric *) END; CASE : CARDINAL OF |0: function : PROC; (* Function to call for TrakGeneric *) |1: window2 : WindowPtr; (* For TrakWindow *) END; user1 : ADDRESS; (* A pointer you can use yourself *) user2 : LONGCARD; (* A long you can use yourself *) END; CONST trbUnLink = 7; (* free node bit *) trbReloc = 6; (* This element may be relocated *) trbMoved = 5; (* Item moved *) trvUnLink = SHIFT(1,trbUnLink); trvReloc = SHIFT(1,trbReloc); (*------ Errors returned by SyncRun() and ASyncRun(): ------*) prbSAVEIO = 0; (* Don't free/check file handles on exit *) prbCLOSESPLAT = 1; (* Close Splat file, must request explicitly *) prbNOCLI = 2; (* Don't create a CLI process *) prbINTERACTIVE = 3; (* This should be interactive *) prbCODE = 4; (* Dangerous yet enticing *) prbSTDIO = 5; (* Do the stdio thing, splat = CON:Filename *) prfSAVEIO = SHIFT(1,0); prfCLOSESPLAT = SHIFT(1,1); prfNOCLI = SHIFT(1,2); prfINTERACTIVE = SHIFT(1,3); prfCODE = SHIFT(1,4); prfSTDIO = SHIFT(1,5); prNoFile = -1; (* Could not LoadSeg() the file *) prNoMem = -2; (* No memory for something *) prNoCLI = -3; (* Caller must be CLI (SyncRun() only) *) prNoSlot = -4; (* No slot in TaskArray *) prNoInput = -5; (* Could not open input file *) prNoOutput = -6; (* Could not get output file *) prNoLock = -7; (* Could not get a lock *) prArgErr = -8; (* Bad argument *) prNoBCPL = -9; (* Bad program passed to ASyncRun() *) prBadLib = -10; (* Bad library version *) prNoStdIO = -11; (* Couldn't get stdio handles. *) errorNotCLI = 400; (* Program/function needs to be cli *) errorBadMagic = 401; (* Invalid magic number for resident prg *) noCMD = "\n"; (*------ ZombieMsg (sent back on request by exiting process): ------*) TYPE ZombieMsgPtr = POINTER TO ZombieMsg; ZombieMsg = RECORD message: Message; (* You must init ReplyPort!!!!! *) taskNum: LONGCARD; (* Task ID *) returnCode: LONGCARD; (* Process's return code *) result2: LONGCARD; (* System return code *) exitTime: Date; (* Date stamp at time of exit *) userInfo: LONGCARD; (* For whatever you wish. *) END; PCBFlags = (saveIO, (* Don't release/check file handles *) closeSplat, (* Close Splat file *) noCLI, (* Don't create a CLI process *) interactive, (* This should be interactive, CLI's only *) code, (* Actual code ADDRESS, be CAREFUL! *) stdIO); (* Do the StdIO thing, Splat = CON:FileName *) PCBFlagSet = SET OF PCBFlags; ProcessCtrlBlkPtr = POINTER TO PCB; ProcessCtrlBlk = RECORD stackSize: LONGCARD; (* Stack for new process *) pri: Byte; (* Priority of new process *) control: PCBFlagSet; (* Control bits *) trapCode: ADDRESS; (* Optional Trap Code *) input,output: FileHandlePtr; (* Optional stdin, stdout *) CASE : CARDINAL OF 0: splatFile: FileHandlePtr; | (* File to use for Open("*") *) 1: conName: ADDRESS; | (* or CON: filename *) 2: console: ADDRESS; | (* Yippee for record variants! *) END; loadedCode: ADDRESS; (* If not null, will not load/unload code *) lastGasp: ZombieMsgPtr; (* ReplyMsg() to be filled in by exit *) wbProcess: MsgPortPtr; (* Valid when noerror and prbNOCLI is set *) END; (*------ Resident Program support: ------*) TYPE ResidentPrgNodePtr = POINTER TO ResidentProgramNode; ResidentPrgNode = RECORD next: ResidentPrgNodePtr; usage: LONGINT; (* How many programs are currently using the code *) checkSum: LONGCARD; segment: BPTR; (* Actual LoadSeg'ed segments *) name: ARRAY[0..255] OF CHAR; (* the names mem is allocated as needed !!! *) END; ResidentProgramTag = RECORD nextSeg: BPTR; (* Provided by DOS at LoadSeg time. *) bra: CARDINAL; (* Short branch to executable *) magic: CARDINAL; (* Resident majik value *) stackSize: LONGCARD; (* min stack for this process *) dataSize: LONGCARD; (* Data size to allocate if resident *) END; ProcessMemoryPtr = POINTER TO ProcessMemory; ProcessMemory = RECORD node: Node; num: CARDINAL; (* number of entries, 1 if no data 2 if data *) stack: ADDRESS; stackSize: LONGCARD; data: ADDRESS; (* pointer to data *) dataSize: LONGCARD; END; CONST residentMagic = 4AFCH; (* same as RTC_MATCHWORD (trapf) *) pMemName = "ARP_MEM"; (*------ String/Date Structures: ------*) TYPE DateType = (amigaDOS, (* dd-mmm-yy *) international, (* yy-mm-dd *) usa, (* mm-dd-yy *) european); (* dd-mm-yy *) DateTimeFlags = (subst, (* Substitute string such as "Today", ... *) future); (* Monday, Tuesday ... refer to next week *) DateTimeFlagSet = SET OF DateTimeFlags; DateTimePtr = POINTER TO DateTime; DateTime = RECORD stamp: Date; format: DateType; flags: DateTimeFlagSet; day: STRPTR; date: STRPTR; time: STRPTR; END; CONST lenDateString = 10H; (*------ Procedures: ------*) PROCEDURE Open(name{1}: STRPTR; accessMode{2}: LONGINT): FileHandlePtr; CODE -30; PROCEDURE Close(file{1}: FileHandlePtr); CODE -36; PROCEDURE Read(file{1}: FileHandlePtr; buffer{2}: ADDRESS; length{3}: LONGINT): LONGINT; CODE -42; PROCEDURE Write(file{1}: FileHandlePtr; buffer{2}: ADDRESS; length{3}: LONGINT): LONGINT; CODE -48; PROCEDURE Input(): FileHandlePtr; CODE -54; PROCEDURE Output(): FileHandlePtr; CODE -60; PROCEDURE Seek(file{1}: FileHandlePtr; position{2}: LONGINT; mode{3}: LONGINT): LONGINT; CODE -66; PROCEDURE DeleteFile(name{1}: STRPTR): BOOLEAN; CODE -72; PROCEDURE Rename(oldName{1},newName{2}: STRPTR): BOOLEAN; CODE -78; PROCEDURE Lock(name{1}: STRPTR; accessMode{2}: LONGINT): FileLockPtr; CODE -84; PROCEDURE UnLock(lock{1}: FileLockPtr); CODE -90; PROCEDURE DupLock(lock{1}: FileLockPtr): FileLockPtr; CODE -96; PROCEDURE Examine(lock{1}: FileLockPtr; infoBlock{2}: FileInfoBlockPtr): BOOLEAN; CODE -102; PROCEDURE ExNext(lock{1}: FileLockPtr; infoBlock{2}: FileInfoBlockPtr): BOOLEAN; CODE -108; PROCEDURE Info(lock{1}: FileLockPtr; parameterBlock{2}: InfoDataPtr): BOOLEAN; CODE -114; PROCEDURE CreateDir(name{1}: STRPTR): FileLockPtr; CODE -120; PROCEDURE CurrentDir(lock{1}: FileLockPtr): FileLockPtr; CODE -126; PROCEDURE IoErr(): LONGINT; CODE -132; PROCEDURE CreateProc(name{1}: STRPTR; pri{2}: LONGINT; segment{3}: BPTR; stackSize{4}: LONGINT): ProcessPtr; CODE -138; PROCEDURE Exit(returnCode{1}: LONGINT); CODE -144; PROCEDURE LoadSeg(name{1}: STRPTR): BPTR; CODE -150; PROCEDURE UnLoadSeg(segment{1}: BPTR); CODE -156; PROCEDURE GetPacket(wait{1}: LONGINT): DosPacketPtr; CODE -162; PROCEDURE QueuePacket(packet{1}: DosPacketPtr): LONGINT; CODE -168; PROCEDURE DeviceProc(name{1}: STRPTR): ProcessPtr; CODE -174; PROCEDURE SetComment(name{1},comment{2}: STRPTR): BOOLEAN; CODE -180; PROCEDURE SetProtection(name{1}:STRPTR; mask{2}:LONGSET): BOOLEAN; CODE -186; PROCEDURE DateStamp(v{1}: DatePtr); CODE -192; PROCEDURE Delay(ticks{1}: LONGINT); CODE -198; PROCEDURE WaitForChar(file{1}: FileHandlePtr; timeout{2}: LONGINT): BOOLEAN; CODE -204; PROCEDURE ParentDir(lock{1}: FileLockPtr): FileLockPtr; CODE -210; PROCEDURE IsInteractive(file{1}: FileHandlePtr): BOOLEAN; CODE -216; PROCEDURE Execute(commandString{1}: STRPTR; input{2}: FileHandlePtr; output{3}: FileHandlePtr): LONGINT; CODE -222; (*------ New ARP Routines: ------*) PROCEDURE AddDADevs(dalist{8}: DirectoryEntryPtr; select{0}: DirEntryTypeSet): LONGINT; CODE -516; PROCEDURE AddDANode(data{8}: ADDRESS; dalist{9}: DirectoryEntryPtr; length{0}: LONGINT; id{1}: DirEntryTypeSet): DirectoryEntryPtr; CODE -510; PROCEDURE AddResidentPrg(segment{1}: BPTR; name{8}: STRPTR): ResidentPrgNodePtr; CODE -582; PROCEDURE ArpAlloc(size{0}: LONGINT): ADDRESS; CODE -384; PROCEDURE ArpAllocMem(size{0}: LONGINT; reqs{1}: MemReqSet): ADDRESS; CODE -390; PROCEDURE ArpDupLock(lock{1}: FileLockPtr): FileLockPtr; CODE -402; PROCEDURE ArpExit(returncode{0}: LONGINT; fault{2}: LONGINT); CODE -378; PROCEDURE ArpLock(name{1}: STRPTR; accessMode{2}: LONGINT): FileLockPtr; CODE -408; PROCEDURE ArpOpen(name{1}: STRPTR; accessmode{2}: LONGINT): FileHandlePtr; CODE -396; PROCEDURE Assign(name{8}: STRPTR; phys{9}: STRPTR): AssignRes; CODE -336; PROCEDURE ASyncRun(command{8}: STRPTR; args{9}: STRPTR; pcb{10}: ProcessCtrlBlkPtr): LONGINT; CODE -546; PROCEDURE Atol(string{8}: STRPTR): LONGINT; CODE -258; PROCEDURE BaseName(pathname{8}: STRPTR): STRPTR; CODE -630; PROCEDURE BtoCStr(cstring{8}: STRPTR; bstr{0}: BSTR; maxlength{1}: LONGINT): LONGINT; CODE -354; PROCEDURE CheckAbort(func{9}: PROC): LONGSET; CODE -270; PROCEDURE CheckBreak(mask{1}: LONGSET; func{9}: PROC): LONGSET; CODE -276; PROCEDURE CheckSumPrg(node{1}: ResidentPrgNodePtr): LONGCARD; CODE -618; PROCEDURE CloseWindowSafely(window{8}: WindowPtr; morewindows{9}: BOOLEAN); CODE -300; PROCEDURE CompareLock(lock1{0},lock2{1}: FileLockPtr): LockComp; CODE -456; PROCEDURE CreatePort(name{8}: STRPTR; priority{0}: Byte): MsgPortPtr; CODE -306; PROCEDURE CreateTaskResList(): ArpResListPtr; CODE -468; PROCEDURE CtoBStr(cstring{8}: STRPTR; bstr{0}: BSTR; maxlength{1}: LONGINT): LONGINT; CODE -360; PROCEDURE DeletePort(port{9}: MsgPortPtr); CODE -312; PROCEDURE DosAllocMem(size{0}: LONGINT): ADDRESS; CODE -342; PROCEDURE DosFreeMem(memBlk{9}: ADDRESS); CODE -348; PROCEDURE EscapeString(string{8}: STRPTR): LONGINT; CODE -264; PROCEDURE FileRequest(filereq{8}: FileRequesterPtr): ADDRESS; CODE -294; PROCEDURE FindCLI(tasknum{0}: LONGINT): ProcessPtr; CODE -420; PROCEDURE FindFirst(pat{0}: STRPTR; chain{8}: AnchorPathPtr): LONGINT; CODE -438; PROCEDURE FindNext(chain{8}: AnchorPathPtr): LONGINT; CODE -444; PROCEDURE FindTaskResList(): ArpResListPtr; CODE -462; PROCEDURE FPrintf(file{0}: FileHandlePtr; string{8}: STRPTR; args{9}: ADDRESS): LONGINT; CODE -234; PROCEDURE FreeAccess(tracker{9}: TrackedResPtr); CODE -498; PROCEDURE FreeAnchorChain(chain{8}: AnchorPathPtr); CODE -450; PROCEDURE FreeDAList(dalist{9}: ADDRESS); CODE -504; PROCEDURE FreeResList(freelist{9}: ADDRESS); CODE -474; PROCEDURE FreeTaskResList(): BOOLEAN; CODE -372; PROCEDURE FreeTrackeItem(item{9}: TrackedResPtr); CODE -480; PROCEDURE GADS(cmdLine{8}: ADDRESS; cmdLen{0}: LONGINT; help{9}: STRPTR; argarray{10}: ADDRESS; tplate{11}: STRPTR): LONGINT; CODE -252; PROCEDURE GetAccess(tracker{9}: TrackedResPtr): TrackedResPtr; CODE -492; PROCEDURE GetDevInfo(devinfo{10}: DeviceListPtr): DeviceListPtr; CODE -366; PROCEDURE GetEnv(string{8}: STRPTR; buffer{9}: ADDRESS; size{0}: LONGINT): STRPTR; CODE -282; PROCEDURE GetTracker(id{9}: LONGINT): DefaultTrackerPtr; CODE -486; PROCEDURE InitStdPacket(action{0}: LONGINT; args{8}: ADDRESS; packet{9}: ADDRESS; replyport{10}: MsgPortPtr); CODE -324; PROCEDURE LDiv(dividend{0},divisor{1}: LONGINT): LONGINT; CODE -606; PROCEDURE LMod(dividend{0},divisor{1}: LONGINT): LONGINT; CODE -612; PROCEDURE LMult(num1{0},num2{1}: LONGINT): LONGINT; CODE -600; PROCEDURE LoadPrg(name{1}: STRPTR): BPTR; CODE -552; PROCEDURE ObtainResidentPrg(name{8}: STRPTR): ResidentPrgNodePtr;CODE -576; PROCEDURE PathName(lock{0}: FileLockPtr; dest{8}: STRPTR; numberNames{1}: LONGINT): LONGINT; CODE -330; PROCEDURE PatternMatch(pat{8}: STRPTR; str{9}: STRPTR): BOOLEAN; CODE -432; PROCEDURE PreParse(source{8}: STRPTR; dest{9}: STRPTR): BOOLEAN; CODE -558; PROCEDURE Printf(string{8}: STRPTR; args{9}: ADDRESS): LONGINT; CODE -228; PROCEDURE Puts(string{9}: STRPTR): LONGINT; CODE -240; PROCEDURE QSort(baseptr{8}: ADDRESS; regionsize{0}: LONGINT; bytesize{1}: LONGINT; userfunction{9}: PROC): BOOLEAN; CODE -426; PROCEDURE ReadLine(buffer{8}: ADDRESS): LONGINT; CODE -246; PROCEDURE ReleaseResidentPrg(segment{1}: ADDRESS): ResidentPrgNodePtr; CODE -636; PROCEDURE RemResidentPrg(name{8}: STRPTR): LONGCARD; CODE -588; PROCEDURE RListAlloc(reslist{8}: ArpResListPtr; size{0}: LONGINT): ADDRESS; CODE -414; PROCEDURE SendPacket(action{0}: LONGINT; args{8}: ADDRESS; handler{9}: MsgPortPtr): LONGINT; CODE -318; PROCEDURE SetEnv(string{8}: STRPTR; buffer{9}: ADDRESS): BOOLEAN; CODE -288; PROCEDURE StampToStr(datetime{8}: DateTimePtr): BOOLEAN; CODE -564; PROCEDURE Strcmp(s1{8},s2{9}: STRPTR): LONGINT; CODE -522; PROCEDURE Strncmp(st{8},s2{9}: STRPTR; n{0}: LONGINT): LONGINT; CODE -528; PROCEDURE StrToStamp(datetime{8}: DateTimePtr): BOOLEAN; CODE -570; PROCEDURE SyncRun(filename{8}: STRPTR; args{9}: STRPTR; input{0}: FileHandlePtr; output{1}: FileHandlePtr): LONGINT; CODE -540; PROCEDURE TackOn(pathname{8},filename{9}: STRPTR); CODE -624; PROCEDURE ToUpper(old{0}: CHAR): CHAR; CODE -534; PROCEDURE UnLoadPrg(segment{1}: BPTR); CODE -594; END ARP.