{ This file is part of the Free Pascal run time library. A file in Amiga system run time library. Copyright (c) 1998-2003 by Nils Sjoholm member of the Amiga RTL development team. See the file COPYING.FPC, included in this distribution, for details about the copyright. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. **********************************************************************} { History: Added functions and procedures with array of const. For use with fpc 1.0.7. Thay are in systemvartags. 11 Nov 2002. Added the define use_amiga_smartlink. 13 Jan 2003. Update for AmigaOS 3.9. Added a few overlays. 06 Feb 2003. nils.sjoholm@mailbox.swipnet.se } {$I useamigasmartlink.inc} {$ifdef use_amiga_smartlink} {$smartlink on} {$endif use_amiga_smartlink} unit utility; INTERFACE uses exec; Type pClockData = ^tClockData; tClockData = record sec : Word; min : Word; hour : Word; mday : Word; month : Word; year : Word; wday : Word; END; pHook = ^tHook; tHook = record h_MinNode : tMinNode; h_Entry : Pointer; { assembler entry point } h_SubEntry : Pointer; { often HLL entry point } h_Data : Pointer; { owner specific } END; { * Hook calling conventions: * A0 - pointer to hook data structure itself * A1 - pointer to parameter structure ("message") typically * beginning with a longword command code, which makes * sense in the context in which the hook is being used. * A2 - Hook specific address data ("object," e.g, GadgetInfo) * * Control will be passed to the routine h_Entry. For many * High-Level Languages (HLL), this will be an assembly language * stub which pushes registers on the stack, does other setup, * and then calls the function at h_SubEntry. * * The C standard receiving code is: * CDispatcher( hook, object, message ) * struct Hook *hook; * APTR object; * APTR message; * * NOTE that register natural order differs from this convention * for C parameter order, which is A0,A2,A1. * * The assembly language stub for "vanilla" C parameter conventions * could be: _hookEntry: move.l a1,-(sp) ; push message packet pointer move.l a2,-(sp) ; push object pointer move.l a0,-(sp) ; push hook pointer move.l h_SubEntry(a0),a0 ; fetch C entry point ... jsr (a0) ; ... and call it lea 12(sp),sp ; fix stack rts * with this function as your interface stub, you can write * a Hook setup function as: SetupHook( hook, c_function, userdata ) struct Hook *hook; ULONG (*c_function)(); VOID *userdata; ULONG (*hookEntry)(); hook->h_Entry = hookEntry; hook->h_SubEntry = c_function; hook->h_Data = userdata; * with Lattice C pragmas, you can put the C function in the * h_Entry field directly if you declare the function: ULONG __saveds __asm CDispatcher( register __a0 struct Hook *hook, register __a2 VOID *object, register __a1 ULONG *message ); * ***} { Namespace definitions } Type { The named object structure } pNamedObject = ^tNamedObject; tNamedObject = record no_Object : Pointer; { Your pointer, for whatever you want } END; const { Tags for AllocNamedObject() } ANO_NameSpace = 4000; { Tag to define namespace } ANO_UserSpace = 4001; { tag to define userspace } ANO_Priority = 4002; { tag to define priority } ANO_Flags = 4003; { tag to define flags } { Flags for tag ANO_Flags } NSB_NODUPS = 0; NSB_CASE = 1; NSF_NODUPS = 1; { Default allow duplicates } NSF_CASE = 2; { Default to caseless... } { Control attributes for Pack/UnpackStructureTags() } { PackTable definition: * * The PackTable is a simple array of LONGWORDS that are evaluated by * PackStructureTags() and UnpackStructureTags(). * * The table contains compressed information such as the tag offset from * the base tag. The tag offset has a limited range so the base tag is * defined in the first longword. * * After the first longword, the fields look as follows: * * +--------- 1 = signed, 0 = unsigned (for bits, 1=inverted boolean) * | * | +------ 00 = Pack/Unpack, 10 = Pack, 01 = Unpack, 11 = special * | / \ * | | | +-- 00 = Byte, 01 = Integer, 10 = Long, 11 = Bit * | | | / \ * | | | | | /----- For bit operations: 1 = TAG_EXISTS is TRUE * | | | | | | * | | | | | | /-------------------- Tag offset from base tag value * | | | | | | | \ * m n n o o p q q q q q q q q q q r r r s s s s s s s s s s s s s * \ | | | * Bit offset (for bit operations) ----/ | | * \ | * Offset into data structure -----------------------------------/ * * A -1 longword signifies that the next longword will be a new base tag * * A 0 longword signifies that it is the end of the pack table. * * What this implies is that there are only 13-bits of address offset * and 10 bits for tag offsets from the base tag. For most uses this * should be enough, but when this is not, either multiple pack tables * or a pack table with extra base tags would be able to do the trick. * The goal here was to make the tables small and yet flexible enough to * handle most cases. } const PSTB_SIGNED =31; PSTB_UNPACK =30; { Note that these are active low... } PSTB_PACK =29; { Note that these are active low... } PSTB_EXISTS =26; { Tag exists bit true flag hack... } PSTF_SIGNED = $80000000; PSTF_UNPACK = $40000000; PSTF_PACK = $20000000; PSTF_EXISTS = $4000000; {***************************************************************************} PKCTRL_PACKUNPACK = $00000000; PKCTRL_PACKONLY = $40000000; PKCTRL_UNPACKONLY = $20000000; PKCTRL_BYTE = $80000000; PKCTRL_WORD = $88000000; PKCTRL_LONG = $90000000; PKCTRL_UBYTE = $00000000; PKCTRL_UWORD = $08000000; PKCTRL_ULONG = $10000000; PKCTRL_BIT = $18000000; PKCTRL_FLIPBIT = $98000000; {***************************************************************************} { Macros used by the next batch of macros below. Normally, you don't use * this batch directly. Then again, some folks are wierd } {***************************************************************************} { Some handy dandy macros to easily create pack tables * * Use PACK_STARTTABLE() at the start of a pack table. You pass it the * base tag value that will be handled in the following chunk of the pack * table. * * PACK_ENDTABLE() is used to mark the end of a pack table. * * PACK_NEWOFFSET() lets you change the base tag value used for subsequent * entries in the table * * PACK_ENTRY() lets you define an entry in the pack table. You pass it the * base tag value, the tag of interest, the type of the structure to use, * the field name in the structure to affect and control bits (combinations of * the various PKCTRL_XXX bits) * * PACK_BYTEBIT() lets you define a bit-control entry in the pack table. You * pass it the same data as PACK_ENTRY, plus the flag bit pattern this tag * affects. This macro should be used when the field being affected is byte * sized. * * PACK_WORDBIT() lets you define a bit-control entry in the pack table. You * pass it the same data as PACK_ENTRY, plus the flag bit pattern this tag * affects. This macro should be used when the field being affected is Integer * sized. * * PACK_LONGBIT() lets you define a bit-control entry in the pack table. You * pass it the same data as PACK_ENTRY, plus the flag bit pattern this tag * affects. This macro should be used when the field being affected is longword * sized. * * EXAMPLE: * * ULONG packTable[] = * ( * PACK_STARTTABLE(GA_Dummy), * PACK_ENTRY(GA_Dummy,GA_Left,Gadget,LeftEdge,PKCTRL_WORD|PKCTRL_PACKUNPACK), * PACK_ENTRY(GA_Dummy,GA_Top,Gadget,TopEdge,PKCTRL_WORD|PKCTRL_PACKUNPACK), * PACK_ENTRY(GA_Dummy,GA_Width,Gadget,Width,PKCTRL_UWORD|PKCTRL_PACKUNPACK), * PACK_ENTRY(GA_Dummy,GA_Height,Gadget,Height,PKCTRL_UWORD|PKCTRL_PACKUNPACK), * PACK_WORDBIT(GA_Dummy,GA_RelVerify,Gadget,Activation,PKCTRL_BIT|PKCTRL_PACKUNPACK,GACT_RELVERIFY) * PACK_ENDTABLE * ); } { ======================================================================= } { ==== TagItem ========================================================== } { ======================================================================= } { This data type may propagate through the system for more general use. * In the meantime, it is used as a general mechanism of extensible data * arrays for parameter specification and property inquiry (coming soon * to a display controller near you). * * In practice, an array (or chain of arrays) of TagItems is used. } Type Tag = LongInt; pTag = ^Tag; pTagItem = ^tTagItem; tTagItem = record ti_Tag : Tag; ti_Data : LongInt; END; ppTagItem = ^pTagItem; { ---- system tag values ----------------------------- } CONST TAG_DONE = 0; { terminates array of TagItems. ti_Data unused } TAG_END = TAG_DONE; TAG_IGNORE = 1; { ignore this item, not END of array } TAG_MORE = 2; { ti_Data is pointer to another array of TagItems * note that this tag terminates the current array } TAG_SKIP = 3; { skip this AND the next ti_Data items } { differentiates user tags from control tags } TAG_USER = $80000000; { differentiates user tags from system tags} {* If the TAG_USER bit is set in a tag number, it tells utility.library that * the tag is not a control tag (like TAG_DONE, TAG_IGNORE, TAG_MORE) and is * instead an application tag. "USER" means a client of utility.library in * general, including system code like Intuition or ASL, it has nothing to do * with user code. *} { Tag filter logic specifiers for use with FilterTagItems() } TAGFILTER_AND = 0; { exclude everything but filter hits } TAGFILTER_NOT = 1; { exclude only filter hits } { Mapping types for use with MapTags() } MAP_REMOVE_NOT_FOUND = 0; { remove tags that aren't in mapList } MAP_KEEP_NOT_FOUND = 1; { keep tags that aren't in mapList } Type pUtilityBase = ^tUtilityBase; tUtilityBase = record ub_LibNode : tLibrary; ub_Language : Byte; ub_Reserved : Byte; END; function AddNamedObject(nameSpace,obj : pNamedObject) : Boolean; function AllocateTagItems(num : ULONG) : pTagItem; function AllocNamedObjectA(const name : STRPTR;const TagList : pTagItem) : pNamedObject; procedure Amiga2Date(amigatime : ULONG;resultat : pClockData); procedure ApplyTagChanges(TagList : pTagItem; const ChangeList : pTagItem); function AttemptRemNamedObject(obj : pNamedObject) : LongInt; function CallHookPkt(h : pHook;obj, paramPkt : APTR) : ULONG; function CheckDate(const date : pClockData) : ULONG; function CloneTagItems(const tagList : pTagItem) : pTagItem; function Date2Amiga(const date : pClockData) : ULONG; procedure FilterTagChanges(changelist, oldvalues : pTagItem;apply : ULONG); function FilterTagItems(taglist : pTagItem ;const tagArray : pULONG;logic : ULONG) : ULONG; function FindNamedObject(nameSpace : pNamedObject;const name : STRPTR;lastobject: pNamedObject) : pNamedObject; function FindTagItem(TagVal : Tag;const TagList : pTagItem) : pTagItem; procedure FreeNamedObject(Obj : pNamedObject); procedure FreeTagItems(TagList : pTagItem); function GetTagData(tagval : Tag;default : ULONG;const TagList : pTagItem) : ULONG; function GetUniqueID : ULONG; procedure MapTags(TagList : pTagItem;const maplist : pTagItem;IncludeMiss : ULONG); function NamedObjectName(Obj : pNamedObject) : STRPTR; function NextTagItem(Item : ppTagItem) : pTagItem; function PackBoolTags(InitialFlags : ULONG;const TagList, boolmap : pTagItem) : ULONG; function PackStructureTags(packk: APTR;const packTable : pULONG;const TagList : pTagItem) : ULONG; procedure RefreshTagItemClones(cloneTagItem : pTagItem; const OriginalTagItems : pTagItem); procedure ReleaseNamedObject(Obj : pNamedObject); procedure RemNamedObject(Obj : pNamedObject;Msg : pointer); function SDivMod32( dividend , divisor : LongInt) : LongInt; function SMult32(Arg1, Arg2 : LongInt) : LongInt; function SMult64(Arg1, Arg2 : LongInt) : LongInt; function Stricmp(const Str1: STRPTR;const Str2 : STRPTR) : LongInt; function Strnicmp(const Str1: STRPTR;const Str2 : STRPTR;len : LongInt) : LongInt; function TagInArray(t : Tag;const TagArray : pULONG) : Boolean; function ToLower(c : ULONG) : Char; function ToUpper(c : ULONG) : Char; function UDivMod32( dividend , divisor : ULONG) : ULONG; function UMult32(Arg1, Arg2 : ULONG) : ULONG; function UMult64(Arg1, Arg2 : ULONG) : ULONG; function UnpackStructureTags(const pac: APTR;const packTable: pULONG;TagList : pTagItem) : ULONG; function AllocNamedObjectA(const name : string;const TagList : pTagItem) : pNamedObject; FUNCTION FindNamedObject(nameSpace : pNamedObject; CONST name : string; lastObject : pNamedObject) : pNamedObject; FUNCTION Stricmp(CONST string1 : string; CONST string2 : pCHAR) : LONGINT; FUNCTION Stricmp(CONST string1 : pCHAR; CONST string2 : string) : LONGINT; FUNCTION Stricmp(CONST string1 : string; CONST string2 : string) : LONGINT; FUNCTION Strnicmp(CONST string1 : string; CONST string2 : pCHAR; length : LONGINT) : LONGINT; FUNCTION Strnicmp(CONST string1 : pCHAR; CONST string2 : string; length : LONGINT) : LONGINT; FUNCTION Strnicmp(CONST string1 : string; CONST string2 : string; length : LONGINT) : LONGINT; IMPLEMENTATION uses pastoc; function AddNamedObject(nameSpace,obj : pNamedObject) : Boolean; begin asm MOVE.L A6,-(A7) MOVE.L nameSpace,a0 MOVE.L obj,a1 MOVE.L _UtilityBase,A6 JSR -222(A6) MOVE.L (A7)+,A6 TST.L d0 bne @success bra @end @success: move.b #1,d0 @end: move.b d0,@RESULT end; end; function AllocateTagItems(num : ULONG) : pTagItem; begin asm MOVE.L A6,-(A7) MOVE.L num,d0 MOVE.L _UtilityBase,A6 JSR -066(A6) MOVE.L (A7)+,A6 MOVE.L d0,@RESULT end; end; function AllocNamedObjectA(const name : STRPTR;const TagList : pTagItem) : pNamedObject; begin asm MOVE.L A6,-(A7) MOVE.L name,a0 MOVE.L TagList,a1 MOVE.L _UtilityBase,A6 JSR -228(A6) MOVE.L (A7)+,A6 MOVE.L d0,@RESULT end; end; procedure Amiga2Date(amigatime : ULONG;resultat : pClockData); begin asm MOVE.L A6,-(A7) MOVE.L amigatime,d0 MOVE.L resultat,a0 MOVE.L _UtilityBase,A6 JSR -120(A6) MOVE.L (A7)+,A6 end; end; procedure ApplyTagChanges(TagList : pTagItem;const ChangeList : pTagItem); begin asm MOVE.L A6,-(A7) MOVE.L TagList,a0 MOVE.L ChangeList,a1 MOVE.L _UtilityBase,A6 JSR -186(A6) MOVE.L (A7)+,A6 end; end; function AttemptRemNamedObject(obj : pNamedObject) : LongInt; begin asm MOVE.L A6,-(A7) MOVE.L obj,a0 MOVE.L _UtilityBase,A6 JSR -234(A6) MOVE.L (A7)+,A6 MOVE.L d0,@RESULT end; end; function CallHookPkt(h : pHook;obj, paramPkt : APTR) : ULONG; begin asm MOVEM.L a2/a6,-(A7) MOVE.L h,a0 MOVE.L obj,a2 MOVE.L paramPkt,a1 MOVE.L _UtilityBase,A6 JSR -102(A6) MOVEM.L (A7)+,a2/a6 MOVE.L d0,@RESULT end; end; function CheckDate(const date : pClockData) : ULONG; begin asm MOVE.L A6,-(A7) MOVE.L date,a0 MOVE.L _UtilityBase,A6 JSR -132(A6) MOVE.L (A7)+,A6 MOVE.L d0,@RESULT end; end; function CloneTagItems(const tagList : pTagItem) : pTagItem; begin asm MOVE.L A6,-(A7) MOVE.L taglist,a0 MOVE.L _UtilityBase,A6 JSR -072(A6) MOVE.L (A7)+,A6 MOVE.L d0,@RESULT end; end; function Date2Amiga(const date : pClockData) : ULONG; begin asm MOVE.L A6,-(A7) MOVE.L date,a0 MOVE.L _UtilityBase,A6 JSR -126(A6) MOVE.L (A7)+,A6 MOVE.L d0,@RESULT end; end; procedure FilterTagChanges(changelist, oldvalues : pTagItem;apply : ULONG); begin asm MOVE.L A6,-(A7) MOVE.L changelist,a0 MOVE.L oldvalues,a1 MOVE.L apply,d0 MOVE.L _UtilityBase,A6 JSR -054(A6) MOVE.L (A7)+,A6 end; end; function FilterTagItems(taglist : pTagItem ;const tagArray : pULONG;logic : ULONG) : ULONG; begin asm MOVE.L A6,-(A7) MOVE.L taglist,a0 MOVE.L tagArray,a1 MOVE.L logic,d0 MOVE.L _UtilityBase,A6 JSR -096(A6) MOVE.L (A7)+,A6 MOVE.L d0,@RESULT end; end; function FindNamedObject(nameSpace : pNamedObject;const name : STRPTR;lastobject: pNamedObject) : pNamedObject; begin asm MOVEM.L a2/a6,-(A7) MOVE.L nameSpace,a0 MOVE.L name,a1 MOVE.L lastobject,a2 MOVE.L _UtilityBase,A6 JSR -240(A6) MOVEM.L (A7)+,a2/a6 MOVE.L d0,@RESULT end; end; function FindTagItem(TagVal : Tag;const TagList : pTagItem) : pTagItem; begin asm MOVE.L A6,-(A7) MOVE.L TagVal,d0 MOVE.L TagList,a0 MOVE.L _UtilityBase,A6 JSR -030(A6) MOVE.L (A7)+,A6 MOVE.L d0,@RESULT end; end; procedure FreeNamedObject(Obj : pNamedObject); begin asm MOVE.L A6,-(A7) MOVE.L Obj,a0 MOVE.L _UtilityBase,A6 JSR -246(A6) MOVE.L (A7)+,A6 end; end; procedure FreeTagItems(TagList : pTagItem); begin asm MOVE.L A6,-(A7) MOVE.L TagList,a0 MOVE.L _UtilityBase,A6 JSR -078(A6) MOVE.L (A7)+,A6 end; end; function GetTagData(tagval : Tag;default : ULONG;const TagList : pTagItem) : ULONG; begin asm MOVE.L A6,-(A7) MOVE.L tagval,d0 MOVE.L default,d1 MOVE.L TagList,a0 MOVE.L _UtilityBase,A6 JSR -036(A6) MOVE.L (A7)+,A6 MOVE.L d0,@RESULT end; end; function GetUniqueID : ULONG; begin asm MOVE.L A6,-(A7) MOVE.L _UtilityBase,A6 JSR -270(A6) MOVE.L (A7)+,A6 MOVE.L d0,@RESULT end; end; procedure MapTags(TagList : pTagItem;const maplist : pTagItem;IncludeMiss : ULONG); begin asm MOVE.L A6,-(A7) MOVE.L TagList,a0 MOVE.L maplist,a1 MOVE.L IncludeMiss,d0 MOVE.L _UtilityBase,A6 JSR -060(A6) MOVE.L (A7)+,A6 end; end; function NamedObjectName(Obj : pNamedObject) : STRPTR; begin asm MOVE.L A6,-(A7) MOVE.L Obj,a0 MOVE.L _UtilityBase,A6 JSR -252(A6) MOVE.L (A7)+,A6 MOVE.L d0,@RESULT end; end; function NextTagItem(Item : ppTagItem) : pTagItem; begin asm MOVE.L A6,-(A7) MOVE.L Item,a0 MOVE.L _UtilityBase,A6 JSR -048(A6) MOVE.L (A7)+,A6 MOVE.L d0,@RESULT end; end; function PackBoolTags(InitialFlags : ULONG;const TagList, boolmap : pTagItem) : ULONG; begin asm MOVE.L A6,-(A7) MOVE.L InitialFlags,d0 MOVE.L TagList,a0 MOVE.L boolmap,a1 MOVE.L _UtilityBase,A6 JSR -042(A6) MOVE.L (A7)+,A6 MOVE.L d0,@RESULT end; end; function PackStructureTags(packk: APTR;const packTable : pULONG;const TagList : pTagItem) : ULONG; begin asm MOVEM.L a2/a6,-(A7) MOVE.L packk,a0 MOVE.L packTable,a1 MOVE.L TagList,a2 MOVE.L _UtilityBase,A6 JSR -210(A6) MOVEM.L (A7)+,a2/a6 MOVE.L d0,@RESULT end; end; procedure RefreshTagItemClones(cloneTagItem : pTagItem; const OriginalTagItems : pTagItem); begin asm MOVE.L A6,-(A7) MOVE.L cloneTagItem,a0 MOVE.L OriginalTagItems,a1 MOVE.L _UtilityBase,A6 JSR -084(A6) MOVE.L (A7)+,A6 end; end; procedure ReleaseNamedObject(Obj : pNamedObject); begin asm MOVE.L A6,-(A7) MOVE.L Obj,a0 MOVE.L _UtilityBase,A6 JSR -258(A6) MOVE.L (A7)+,A6 end; end; procedure RemNamedObject(Obj : pNamedObject;Msg : pointer); begin asm MOVE.L A6,-(A7) MOVE.L Obj,a0 MOVE.L Msg,a1 MOVE.L _UtilityBase,A6 JSR -264(A6) MOVE.L (A7)+,A6 end; end; function SDivMod32( dividend , divisor : LongInt) : LongInt; begin asm MOVE.L A6,-(A7) MOVE.L dividend,d0 MOVE.L divisor,d1 MOVE.L _UtilityBase,A6 JSR -150(A6) MOVE.L (A7)+,A6 MOVE.L d0,@RESULT end; end; function SMult32(Arg1, Arg2 : LongInt) : LongInt; begin asm MOVE.L A6,-(A7) MOVE.L Arg1,d0 MOVE.L Arg2,d1 MOVE.L _UtilityBase,A6 JSR -138(A6) MOVE.L (A7)+,A6 MOVE.L d0,@RESULT end; end; function SMult64(Arg1, Arg2 : LongInt) : LongInt; begin asm MOVE.L A6,-(A7) MOVE.L Arg1,d0 MOVE.L Arg2,d1 MOVE.L _UtilityBase,A6 JSR -198(A6) MOVE.L (A7)+,A6 MOVE.L d0,@RESULT end; end; function Stricmp(const Str1: STRPTR;const Str2 : STRPTR) : LongInt; begin asm MOVE.L A6,-(A7) MOVE.L Str1,a0 MOVE.L Str2,a1 MOVE.L _UtilityBase,A6 JSR -162(A6) MOVE.L (A7)+,A6 MOVE.L d0,@RESULT end; end; function Strnicmp(const Str1: STRPTR;const Str2 : STRPTR;len : LongInt) : LongInt; begin asm MOVE.L A6,-(A7) MOVE.L Str1,a0 MOVE.L Str2,a1 MOVE.L len,d0 MOVE.L _UtilityBase,A6 JSR -168(A6) MOVE.L (A7)+,A6 MOVE.L d0,@RESULT end; end; function TagInArray(t : Tag;const TagArray : pULONG) : Boolean; begin asm MOVE.L A6,-(A7) MOVE.L t,d0 MOVE.L TagArray,a0 MOVE.L _UtilityBase,A6 JSR -090(A6) MOVE.L (A7)+,A6 TST.L d0 bne @success bra @end @success: move.b #1,d0 @end: move.b d0,@RESULT end; end; function ToLower(c : ULONG) : Char; begin asm MOVE.L A6,-(A7) MOVE.L c,d0 MOVE.L _UtilityBase,A6 JSR -180(A6) MOVE.L (A7)+,A6 MOVE.B d0,@RESULT end; end; function ToUpper(c : ULONG) : Char; begin asm MOVE.L A6,-(A7) MOVE.L c,d0 MOVE.L _UtilityBase,A6 JSR -174(A6) MOVE.L (A7)+,A6 MOVE.B d0,@RESULT end; end; function UDivMod32( dividend , divisor : ULONG) : ULONG; begin asm MOVE.L A6,-(A7) MOVE.L dividend,d0 MOVE.L divisor,d1 MOVE.L _UtilityBase,A6 JSR -156(A6) MOVE.L (A7)+,A6 MOVE.L d0,@RESULT end; end; function UMult32(Arg1, Arg2 : ULONG) : ULONG; begin asm MOVE.L A6,-(A7) MOVE.L Arg1,d0 MOVE.L Arg2,d1 MOVE.L _UtilityBase,A6 JSR -144(A6) MOVE.L (A7)+,A6 MOVE.L d0,@RESULT end; end; function UMult64(Arg1, Arg2 : ULONG) : ULONG; begin asm MOVE.L A6,-(A7) MOVE.L Arg1,d0 MOVE.L Arg2,d1 MOVE.L _UtilityBase,A6 JSR -204(A6) MOVE.L (A7)+,A6 MOVE.L d0,@RESULT end; end; function UnpackStructureTags(const pac: APTR;const packTable: pULONG;TagList : pTagItem) : ULONG; begin asm MOVEM.L a2/a6,-(A7) MOVE.L pac,a0 MOVE.L packTable,a1 MOVE.L TagList,a2 MOVE.L _UtilityBase,A6 JSR -216(A6) MOVEM.L (A7)+,a2/a6 MOVE.L d0,@RESULT end; end; function AllocNamedObjectA(const name : string;const TagList : pTagItem) : pNamedObject; begin AllocNamedObjectA := AllocNamedObjectA(pas2c(name),TagList); end; FUNCTION FindNamedObject(nameSpace : pNamedObject; CONST name : string; lastObject : pNamedObject) : pNamedObject; begin FindNamedObject := FindNamedObject(nameSpace,pas2c(name),lastObject); end; FUNCTION Stricmp(CONST string1 : string; CONST string2 : pCHAR) : LONGINT; begin Stricmp := Stricmp(pas2c(string1),string2); end; FUNCTION Stricmp(CONST string1 : pCHAR; CONST string2 : string) : LONGINT; begin Stricmp := Stricmp(string1,pas2c(string2)); end; FUNCTION Stricmp(CONST string1 : string; CONST string2 : string) : LONGINT; begin Stricmp := Stricmp(pas2c(string1),pas2c(string2)); end; FUNCTION Strnicmp(CONST string1 : string; CONST string2 : pCHAR; length : LONGINT) : LONGINT; begin Strnicmp := Strnicmp(pas2c(string1),string2,length); end; FUNCTION Strnicmp(CONST string1 : pCHAR; CONST string2 : string; length : LONGINT) : LONGINT; begin Strnicmp := Strnicmp(string1,pas2c(string2),length); end; FUNCTION Strnicmp(CONST string1 : string; CONST string2 : string; length : LONGINT) : LONGINT; begin Strnicmp := Strnicmp(pas2c(string1),pas2c(string2),length); end; end.