development/compilers/freepascal/rtl/aros/utility.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 unit utility;
  18
  19 INTERFACE
  20 uses exec;
  21
  22
  23 Type
  24       pClockData = ^tClockData;
  25       tClockData = record
  26         sec   : Word;
  27         min   : Word;
  28         hour  : Word;
  29         mday  : Word;
  30         month : Word;
  31         year  : Word;
  32         wday  : Word;
  33       END;
  34
  35       pHook = ^tHook;
  36       tHook = record
  37         h_MinNode  : tMinNode;
  38         h_Entry    : Pointer;   { assembler entry point        }
  39         h_SubEntry : Pointer;   { often HLL entry point        }
  40         h_Data     : Pointer;   { owner specific               }
  41       END;
  42
  43 {
  44  * Hook calling conventions:
  45  *      A0 - pointer to hook data structure itself
  46  *      A1 - pointer to parameter structure ("message") typically
  47  *           beginning with a longword command code, which makes
  48  *           sense in the context in which the hook is being used.
  49  *      A2 - Hook specific address data ("object," e.g, GadgetInfo)
  50  *
  51  * Control will be passed to the routine h_Entry.  For many
  52  * High-Level Languages (HLL), this will be an assembly language
  53  * stub which pushes registers on the stack, does other setup,
  54  * and then calls the function at h_SubEntry.
  55  *
  56  * The C standard receiving code is:
  57  * CDispatcher( hook, object, message )
  58  *     struct Hook      *hook;
  59  *     APTR             object;
  60  *     APTR             message;
  61  *
  62  * NOTE that register natural order differs from this convention
  63  * for C parameter order, which is A0,A2,A1.
  64  *
  65  * The assembly language stub for "vanilla" C parameter conventions
  66  * could be:
  67
  68  _hookEntry:
  69         move.l  a1,-(sp)                ; push message packet pointer
  70         move.l  a2,-(sp)                ; push object pointer
  71         move.l  a0,-(sp)                ; push hook pointer
  72         move.l  h_SubEntry(a0),a0       ; fetch C entry point ...
  73         jsr     (a0)                    ; ... and call it
  74         lea     12(sp),sp               ; fix stack
  75         rts
  76
  77  * with this function as your interface stub, you can write
  78  * a Hook setup function as:
  79
  80  SetupHook( hook, c_function, userdata )
  81  struct Hook    *hook;
  82  ULONG          (*c_function)();
  83  VOID           *userdata;
  84
  85         ULONG   (*hookEntry)();
  86
  87         hook->h_Entry =         hookEntry;
  88         hook->h_SubEntry =      c_function;
  89         hook->h_Data =                  userdata;
  90
  91
  92  * with Lattice C pragmas, you can put the C function in the
  93  * h_Entry field directly if you declare the function:
  94
  95 ULONG __saveds __asm
  96 CDispatcher(    register __a0 struct Hook       *hook,
  97                 register __a2 VOID              *object,
  98                 register __a1 ULONG             *message );
  99  *
 100  ***}
 101
 102  {      Namespace definitions      }
 103
 104
 105 Type
 106 { The named object structure }
 107  pNamedObject = ^tNamedObject;
 108  tNamedObject = record
 109     no_Object  : Pointer;       { Your pointer, for whatever you want }
 110  END;
 111
 112 const
 113 { Tags for AllocNamedObject() }
 114  ANO_NameSpace  = 4000;    { Tag to define namespace      }
 115  ANO_UserSpace  = 4001;    { tag to define userspace      }
 116  ANO_Priority   = 4002;    { tag to define priority       }
 117  ANO_Flags      = 4003;    { tag to define flags          }
 118
 119 { Flags for tag ANO_Flags }
 120  NSB_NODUPS     = 0;
 121  NSB_CASE       = 1;
 122
 123  NSF_NODUPS     = 1;      { Default allow duplicates }
 124  NSF_CASE       = 2;      { Default to caseless... }
 125
 126
 127    {    Control attributes for Pack/UnpackStructureTags() }
 128
 129
 130 { PackTable definition:
 131  *
 132  * The PackTable is a simple array of LONGWORDS that are evaluated by
 133  * PackStructureTags() and UnpackStructureTags().
 134  *
 135  * The table contains compressed information such as the tag offset from
 136  * the base tag. The tag offset has a limited range so the base tag is
 137  * defined in the first longword.
 138  *
 139  * After the first longword, the fields look as follows:
 140  *
 141  *      +--------- 1 = signed, 0 = unsigned (for bits, 1=inverted boolean)
 142  *      |
 143  *      |  +------ 00 = Pack/Unpack, 10 = Pack, 01 = Unpack, 11 = special
 144  *      | / \
 145  *      | | |  +-- 00 = Byte, 01 = Integer, 10 = Long, 11 = Bit
 146  *      | | | / \
 147  *      | | | | | /----- For bit operations: 1 = TAG_EXISTS is TRUE
 148  *      | | | | | |
 149  *      | | | | | | /-------------------- Tag offset from base tag value
 150  *      | | | | | | |                 \
 151  *      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
 152  *                                      \   | |               |
 153  *      Bit offset (for bit operations) ----/ |               |
 154  *                                            \                       |
 155  *      Offset into data structure -----------------------------------/
 156  *
 157  * A -1 longword signifies that the next longword will be a new base tag
 158  *
 159  * A 0 longword signifies that it is the end of the pack table.
 160  *
 161  * What this implies is that there are only 13-bits of address offset
 162  * and 10 bits for tag offsets from the base tag.  For most uses this
 163  * should be enough, but when this is not, either multiple pack tables
 164  * or a pack table with extra base tags would be able to do the trick.
 165  * The goal here was to make the tables small and yet flexible enough to
 166  * handle most cases.
 167  }
 168
 169 const
 170  PSTB_SIGNED =31;
 171  PSTB_UNPACK =30;    { Note that these are active low... }
 172  PSTB_PACK   =29;    { Note that these are active low... }
 173  PSTB_EXISTS =26;    { Tag exists bit true flag hack...  }
 174
 175  PSTF_SIGNED = $80000000;
 176  PSTF_UNPACK = $40000000;
 177  PSTF_PACK   = $20000000;
 178
 179  PSTF_EXISTS = $4000000;
 180
 181
 182 {***************************************************************************}
 183
 184
 185  PKCTRL_PACKUNPACK = $00000000;
 186  PKCTRL_PACKONLY   = $40000000;
 187  PKCTRL_UNPACKONLY = $20000000;
 188
 189  PKCTRL_BYTE       = $80000000;
 190  PKCTRL_WORD       = $88000000;
 191  PKCTRL_LONG       = $90000000;
 192
 193  PKCTRL_UBYTE      = $00000000;
 194  PKCTRL_UWORD      = $08000000;
 195  PKCTRL_ULONG      = $10000000;
 196
 197  PKCTRL_BIT        = $18000000;
 198  PKCTRL_FLIPBIT    = $98000000;
 199
 200
 201 {***************************************************************************}
 202
 203
 204 { Macros used by the next batch of macros below. Normally, you don't use
 205  * this batch directly. Then again, some folks are wierd
 206  }
 207
 208
 209
 210 {***************************************************************************}
 211
 212
 213 { Some handy dandy macros to easily create pack tables
 214  *
 215  * Use PACK_STARTTABLE() at the start of a pack table. You pass it the
 216  * base tag value that will be handled in the following chunk of the pack
 217  * table.
 218  *
 219  * PACK_ENDTABLE() is used to mark the end of a pack table.
 220  *
 221  * PACK_NEWOFFSET() lets you change the base tag value used for subsequent
 222  * entries in the table
 223  *
 224  * PACK_ENTRY() lets you define an entry in the pack table. You pass it the
 225  * base tag value, the tag of interest, the type of the structure to use,
 226  * the field name in the structure to affect and control bits (combinations of
 227  * the various PKCTRL_XXX bits)
 228  *
 229  * PACK_BYTEBIT() lets you define a bit-control entry in the pack table. You
 230  * pass it the same data as PACK_ENTRY, plus the flag bit pattern this tag
 231  * affects. This macro should be used when the field being affected is byte
 232  * sized.
 233  *
 234  * PACK_WORDBIT() lets you define a bit-control entry in the pack table. You
 235  * pass it the same data as PACK_ENTRY, plus the flag bit pattern this tag
 236  * affects. This macro should be used when the field being affected is Integer
 237  * sized.
 238  *
 239  * PACK_LONGBIT() lets you define a bit-control entry in the pack table. You
 240  * pass it the same data as PACK_ENTRY, plus the flag bit pattern this tag
 241  * affects. This macro should be used when the field being affected is longword
 242  * sized.
 243  *
 244  * EXAMPLE:
 245  *
 246  *    ULONG packTable[] =
 247  *    (
 248  *         PACK_STARTTABLE(GA_Dummy),
 249  *         PACK_ENTRY(GA_Dummy,GA_Left,Gadget,LeftEdge,PKCTRL_WORD|PKCTRL_PACKUNPACK),
 250  *         PACK_ENTRY(GA_Dummy,GA_Top,Gadget,TopEdge,PKCTRL_WORD|PKCTRL_PACKUNPACK),
 251  *         PACK_ENTRY(GA_Dummy,GA_Width,Gadget,Width,PKCTRL_UWORD|PKCTRL_PACKUNPACK),
 252  *         PACK_ENTRY(GA_Dummy,GA_Height,Gadget,Height,PKCTRL_UWORD|PKCTRL_PACKUNPACK),
 253  *         PACK_WORDBIT(GA_Dummy,GA_RelVerify,Gadget,Activation,PKCTRL_BIT|PKCTRL_PACKUNPACK,GACT_RELVERIFY)
 254  *         PACK_ENDTABLE
 255  *    );
 256  }
 257
 258
 259 { ======================================================================= }
 260 { ==== TagItem ========================================================== }
 261 { ======================================================================= }
 262 { This data type may propagate through the system for more general use.
 263  * In the meantime, it is used as a general mechanism of extensible data
 264  * arrays for parameter specification and property inquiry (coming soon
 265  * to a display controller near you).
 266  *
 267  * In practice, an array (or chain of arrays) of TagItems is used.
 268  }
 269 Type
 270     Tag = LongInt;
 271     pTag = ^Tag;
 272
 273     pTagItem = ^tTagItem;
 274     tTagItem = record
 275      ti_Tag  : Tag;
 276      ti_Data : LongInt;
 277     END;
 278
 279     ppTagItem = ^pTagItem;
 280
 281 { ---- system tag values ----------------------------- }
 282 CONST
 283  TAG_DONE          = 0; { terminates array of TagItems. ti_Data unused }
 284  TAG_END           = TAG_DONE;
 285  TAG_IGNORE        = 1; { ignore this item, not END of array           }
 286  TAG_MORE          = 2; { ti_Data is pointer to another array of TagItems
 287                          * note that this tag terminates the current array
 288                          }
 289  TAG_SKIP          = 3; { skip this AND the next ti_Data items         }
 290
 291 { differentiates user tags from control tags }
 292  TAG_USER          = $80000000;    { differentiates user tags from system tags}
 293
 294 {* If the TAG_USER bit is set in a tag number, it tells utility.library that
 295  * the tag is not a control tag (like TAG_DONE, TAG_IGNORE, TAG_MORE) and is
 296  * instead an application tag. "USER" means a client of utility.library in
 297  * general, including system code like Intuition or ASL, it has nothing to do
 298  * with user code.
 299  *}
 300
 301
 302 { Tag filter logic specifiers for use with FilterTagItems() }
 303  TAGFILTER_AND     = 0;       { exclude everything but filter hits   }
 304  TAGFILTER_NOT     = 1;       { exclude only filter hits             }
 305
 306 { Mapping types for use with MapTags() }
 307  MAP_REMOVE_NOT_FOUND = 0;  { remove tags that aren't in mapList }
 308  MAP_KEEP_NOT_FOUND   = 1;  { keep tags that aren't in mapList   }
 309
 310
 311
 312 Type
 313  tUtilityBase = record
 314     ub_LibNode   : tLibrary;
 315     ub_Language  : Byte;
 316     ub_Reserved  : Byte;
 317  END;
 318
 319 function AddNamedObject(nameSpace,
 320                         obj : pNamedObject) : Boolean;
 321 function AllocateTagItems(num : ULONG) : pTagItem;
 322 function AllocNamedObjectA(name : STRPTR;
 323                            TagList : pTagItem) : pNamedObject;
 324 procedure Amiga2Date(amigatime : ULONG;
 325                      resultat : pClockData);
 326 procedure ApplyTagChanges(TagList,
 327                           ChangeList : pTagItem);
 328 function AttemptRemNamedObject(obj : pNamedObject) : LongInt;
 329 function CallHookPkt(h : pHook;
 330                      obj, paramPkt : APTR) : ULONG;
 331 function CheckDate(date : pClockData) : ULONG;
 332 function CloneTagItems(tagList : pTagItem) : pTagItem;
 333 function Date2Amiga(date : pClockData) : ULONG;
 334 procedure FilterTagChanges(changelist, oldvalues : pTagItem;
 335                            apply : ULONG);
 336 function FilterTagItems(taglist : pTagItem ;
 337                         tagArray : Pointer;
 338                         logic : ULONG) : ULONG;
 339 function FindNamedObject(nameSpace : pNamedObject;
 340                          name : STRPTR;
 341                          lastobject: pNamedObject) : pNamedObject;
 342 function FindTagItem(TagVal : Tag;
 343                      TagList : pTagItem) : pTagItem;
 344 procedure FreeNamedObject(Obj : pNamedObject);
 345 procedure FreeTagItems(TagList : pTagItem);
 346 function GetTagData(tagval : Tag;
 347                     default : ULONG;
 348                     TagList : pTagItem) : ULONG;
 349 function GetUniqueID : ULONG;
 350 procedure MapTags(TagList : pTagItem;
 351                   maplist : pTagItem;
 352                   IncludeMiss : ULONG);
 353 function NamedObjectName(Obj : pNamedObject) : STRPTR;
 354 function NextTagItem(Item : ppTagItem) : pTagItem;
 355 function PackBoolTags(InitialFlags : ULONG;
 356                       TagList, boolmap : pTagItem) : ULONG;
 357 function PackStructureTags(packk: APTR;
 358                            packTable : Pointer;
 359                            TagList : pTagItem) : ULONG;
 360 procedure RefreshTagItemClones(cloneTagItems,
 361                                OriginalTagItems : pTagItem);
 362 procedure ReleaseNamedObject(Obj : pNamedObject);
 363 procedure RemNamedObject(Obj : pNamedObject;
 364                          Msg : pointer);
 365 function SDivMod32( dividend , divisor : LongInt) : LongInt;
 366 function SMult32(Arg1, Arg2 : LongInt) : LongInt;
 367 function SMult64(Arg1, Arg2 : LongInt) : LongInt;
 368 function Stricmp(Str1, Str2 : STRPTR) : LongInt;
 369 function Strnicmp(Str1, Str2 : STRPTR;
 370                   len : LongInt) : LongInt;
 371 function TagInArray(t : Tag;
 372                     TagArray : Pointer) : Boolean;
 373 function ToLower(c : ULONG) : Char;
 374 function ToUpper(c : ULONG) : Char;
 375 function UDivMod32( dividend , divisor : ULONG) : ULONG;
 376 function UMult32(Arg1, Arg2 : ULONG) : ULONG;
 377 function UMult64(Arg1, Arg2 : ULONG) : ULONG;
 378 function UnpackStructureTags(pac: APTR;
 379                              packTable: Pointer;
 380                              TagList : pTagItem) : ULONG;
 381
 382 IMPLEMENTATION
 383
 384 function AddNamedObject(nameSpace,
 385                         obj : pNamedObject) : Boolean;
 386 begin
 387    asm
 388        MOVE.L  A6,-(A7)
 389        MOVE.L  nameSpace,a0
 390        MOVE.L  obj,a1
 391        MOVE.L  _UtilityBase,A6
 392        JSR -222(A6)
 393        MOVE.L  (A7)+,A6
 394        TST.L   d0
 395        bne     @success
 396        bra     @end
 397    @success:
 398        move.b  #1,d0
 399    @end:
 400        move.b  d0,@RESULT
 401    end;
 402 end;
 403
 404 function AllocateTagItems(num : ULONG) : pTagItem;
 405 begin
 406   asm
 407       MOVE.L  A6,-(A7)
 408       MOVE.L  num,d0
 409       MOVE.L  _UtilityBase,A6
 410       JSR -066(A6)
 411       MOVE.L  (A7)+,A6
 412       MOVE.L  d0,@RESULT
 413   end;
 414 end;
 415
 416 function AllocNamedObjectA(name : STRPTR;
 417                            TagList : pTagItem) : pNamedObject;
 418 begin
 419    asm
 420        MOVE.L  A6,-(A7)
 421        MOVE.L  name,a0
 422        MOVE.L  TagList,a1
 423        MOVE.L  _UtilityBase,A6
 424        JSR -228(A6)
 425        MOVE.L  (A7)+,A6
 426        MOVE.L  d0,@RESULT
 427    end;
 428 end;
 429
 430 procedure Amiga2Date(amigatime : ULONG;
 431                      resultat : pClockData);
 432 begin
 433    asm
 434        MOVE.L  A6,-(A7)
 435        MOVE.L  amigatime,d0
 436        MOVE.L  resultat,a0
 437        MOVE.L  _UtilityBase,A6
 438        JSR -120(A6)
 439        MOVE.L  (A7)+,A6
 440    end;
 441 end;
 442
 443 procedure ApplyTagChanges(TagList,
 444                           ChangeList : pTagItem);
 445 begin
 446    asm
 447        MOVE.L  A6,-(A7)
 448        MOVE.L  TagList,a0
 449        MOVE.L  ChangeList,a1
 450        MOVE.L  _UtilityBase,A6
 451        JSR -186(A6)
 452        MOVE.L  (A7)+,A6
 453    end;
 454 end;
 455
 456 function AttemptRemNamedObject(obj : pNamedObject) : LongInt;
 457 begin
 458    asm
 459        MOVE.L  A6,-(A7)
 460        MOVE.L  obj,a0
 461        MOVE.L  _UtilityBase,A6
 462        JSR -234(A6)
 463        MOVE.L  (A7)+,A6
 464        MOVE.L  d0,@RESULT
 465    end;
 466 end;
 467
 468 function CallHookPkt(h : pHook;
 469                      obj, paramPkt : APTR) : ULONG;
 470 begin
 471    asm
 472        MOVEM.L a2/a6,-(A7)
 473        MOVE.L  h,a0
 474        MOVE.L  obj,a2
 475        MOVE.L  paramPkt,a1
 476        MOVE.L  _UtilityBase,A6
 477        JSR -102(A6)
 478        MOVEM.L (A7)+,a2/a6
 479        MOVE.L  d0,@RESULT
 480    end;
 481 end;
 482
 483 function CheckDate(date : pClockData) : ULONG;
 484 begin
 485    asm
 486        MOVE.L  A6,-(A7)
 487        MOVE.L  date,a0
 488        MOVE.L  _UtilityBase,A6
 489        JSR -132(A6)
 490        MOVE.L  (A7)+,A6
 491        MOVE.L  d0,@RESULT
 492    end;
 493 end;
 494
 495 function CloneTagItems(tagList : pTagItem) : pTagItem;
 496 begin
 497    asm
 498        MOVE.L  A6,-(A7)
 499        MOVE.L  taglist,a0
 500        MOVE.L  _UtilityBase,A6
 501        JSR -072(A6)
 502        MOVE.L  (A7)+,A6
 503        MOVE.L  d0,@RESULT
 504    end;
 505 end;
 506
 507 function Date2Amiga(date : pClockData) : ULONG;
 508 begin
 509    asm
 510        MOVE.L  A6,-(A7)
 511        MOVE.L  date,a0
 512        MOVE.L  _UtilityBase,A6
 513        JSR -126(A6)
 514        MOVE.L  (A7)+,A6
 515        MOVE.L  d0,@RESULT
 516    end;
 517 end;
 518
 519 procedure FilterTagChanges(changelist, oldvalues : pTagItem;
 520                            apply : ULONG);
 521 begin
 522    asm
 523        MOVE.L  A6,-(A7)
 524        MOVE.L  changelist,a0
 525        MOVE.L  oldvalues,a1
 526        MOVE.L  apply,d0
 527        MOVE.L  _UtilityBase,A6
 528        JSR -054(A6)
 529        MOVE.L  (A7)+,A6
 530    end;
 531 end;
 532
 533 function FilterTagItems(taglist : pTagItem ;
 534                         tagArray : Pointer;
 535                         logic : ULONG) : ULONG;
 536 begin
 537    asm
 538        MOVE.L  A6,-(A7)
 539        MOVE.L  taglist,a0
 540        MOVE.L  tagArray,a1
 541        MOVE.L  logic,d0
 542        MOVE.L  _UtilityBase,A6
 543        JSR -096(A6)
 544        MOVE.L  (A7)+,A6
 545        MOVE.L  d0,@RESULT
 546    end;
 547 end;
 548
 549 function FindNamedObject(nameSpace : pNamedObject;
 550                          name : STRPTR;
 551                          lastobject: pNamedObject) : pNamedObject;
 552 begin
 553    asm
 554        MOVEM.L a2/a6,-(A7)
 555        MOVE.L  nameSpace,a0
 556        MOVE.L  name,a1
 557        MOVE.L  lastobject,a2
 558        MOVE.L  _UtilityBase,A6
 559        JSR -240(A6)
 560        MOVEM.L (A7)+,a2/a6
 561        MOVE.L  d0,@RESULT
 562    end;
 563 end;
 564
 565 function FindTagItem(TagVal : Tag;
 566                      TagList : pTagItem) : pTagItem;
 567 begin
 568    asm
 569        MOVE.L  A6,-(A7)
 570        MOVE.L  TagVal,d0
 571        MOVE.L  TagList,a0
 572        MOVE.L  _UtilityBase,A6
 573        JSR -030(A6)
 574        MOVE.L  (A7)+,A6
 575        MOVE.L  d0,@RESULT
 576    end;
 577 end;
 578
 579 procedure FreeNamedObject(Obj : pNamedObject);
 580 begin
 581    asm
 582        MOVE.L  A6,-(A7)
 583        MOVE.L  Obj,a0
 584        MOVE.L  _UtilityBase,A6
 585        JSR -246(A6)
 586        MOVE.L  (A7)+,A6
 587    end;
 588 end;
 589
 590 procedure FreeTagItems(TagList : pTagItem);
 591 begin
 592    asm
 593        MOVE.L  A6,-(A7)
 594        MOVE.L  TagList,a0
 595        MOVE.L  _UtilityBase,A6
 596        JSR -078(A6)
 597        MOVE.L  (A7)+,A6
 598    end;
 599 end;
 600
 601 function GetTagData(tagval : Tag;
 602                     default : ULONG;
 603                     TagList : pTagItem) : ULONG;
 604 begin
 605    asm
 606        MOVE.L  A6,-(A7)
 607        MOVE.L  tagval,d0
 608        MOVE.L  default,d1
 609        MOVE.L  TagList,a0
 610        MOVE.L  _UtilityBase,A6
 611        JSR -036(A6)
 612        MOVE.L  (A7)+,A6
 613        MOVE.L  d0,@RESULT
 614    end;
 615 end;
 616
 617 function GetUniqueID : ULONG;
 618 begin
 619    asm
 620       MOVE.L  A6,-(A7)
 621       MOVE.L  _UtilityBase,A6
 622       JSR -270(A6)
 623       MOVE.L  (A7)+,A6
 624       MOVE.L  d0,@RESULT
 625    end;
 626 end;
 627
 628 procedure MapTags(TagList : pTagItem;
 629                   maplist : pTagItem;
 630                   IncludeMiss : ULONG);
 631 begin
 632    asm
 633        MOVE.L  A6,-(A7)
 634        MOVE.L  TagList,a0
 635        MOVE.L  maplist,a1
 636        MOVE.L  IncludeMiss,d0
 637        MOVE.L  _UtilityBase,A6
 638        JSR -060(A6)
 639        MOVE.L  (A7)+,A6
 640    end;
 641 end;
 642
 643 function NamedObjectName(Obj : pNamedObject) : STRPTR;
 644 begin
 645    asm
 646        MOVE.L  A6,-(A7)
 647        MOVE.L  Obj,a0
 648        MOVE.L  _UtilityBase,A6
 649        JSR -252(A6)
 650        MOVE.L  (A7)+,A6
 651        MOVE.L  d0,@RESULT
 652    end;
 653 end;
 654
 655 function NextTagItem(Item : ppTagItem) : pTagItem;
 656 begin
 657    asm
 658        MOVE.L  A6,-(A7)
 659        MOVE.L  Item,a0
 660        MOVE.L  _UtilityBase,A6
 661        JSR -048(A6)
 662        MOVE.L  (A7)+,A6
 663        MOVE.L  d0,@RESULT
 664    end;
 665 end;
 666
 667 function PackBoolTags(InitialFlags : ULONG;
 668                       TagList, boolmap : pTagItem) : ULONG;
 669 begin
 670    asm
 671        MOVE.L  A6,-(A7)
 672        MOVE.L  InitialFlags,d0
 673        MOVE.L  TagList,a0
 674        MOVE.L  boolmap,a1
 675        MOVE.L  _UtilityBase,A6
 676        JSR -042(A6)
 677        MOVE.L  (A7)+,A6
 678        MOVE.L  d0,@RESULT
 679    end;
 680 end;
 681
 682 function PackStructureTags(packk: APTR;
 683                            packTable : Pointer;
 684                            TagList : pTagItem) : ULONG;
 685 begin
 686    asm
 687        MOVEM.L a2/a6,-(A7)
 688        MOVE.L  packk,a0
 689        MOVE.L  packTable,a1
 690        MOVE.L  TagList,a2
 691        MOVE.L  _UtilityBase,A6
 692        JSR -210(A6)
 693        MOVEM.L (A7)+,a2/a6
 694        MOVE.L  d0,@RESULT
 695    end;
 696 end;
 697
 698 procedure RefreshTagItemClones(cloneTagItems,
 699                                OriginalTagItems : pTagItem);
 700 begin
 701    asm
 702        MOVE.L  A6,-(A7)
 703        MOVE.L  cloneTagItems,a0
 704        MOVE.L  OriginalTagItems,a1
 705        MOVE.L  _UtilityBase,A6
 706        JSR -084(A6)
 707        MOVE.L  (A7)+,A6
 708    end;
 709 end;
 710
 711 procedure ReleaseNamedObject(Obj : pNamedObject);
 712 begin
 713    asm
 714        MOVE.L  A6,-(A7)
 715        MOVE.L  Obj,a0
 716        MOVE.L  _UtilityBase,A6
 717        JSR -258(A6)
 718        MOVE.L  (A7)+,A6
 719    end;
 720 end;
 721
 722 procedure RemNamedObject(Obj : pNamedObject;
 723                          Msg : pointer);
 724 begin
 725    asm
 726        MOVE.L  A6,-(A7)
 727        MOVE.L  Obj,a0
 728        MOVE.L  Msg,a1
 729        MOVE.L  _UtilityBase,A6
 730        JSR -264(A6)
 731        MOVE.L  (A7)+,A6
 732    end;
 733 end;
 734
 735 function SDivMod32( dividend , divisor : LongInt) : LongInt;
 736 begin
 737    asm
 738        MOVE.L  A6,-(A7)
 739        MOVE.L  dividend,d0
 740        MOVE.L  divisor,d1
 741        MOVE.L  _UtilityBase,A6
 742        JSR -150(A6)
 743        MOVE.L  (A7)+,A6
 744        MOVE.L  d0,@RESULT
 745    end;
 746 end;
 747
 748 function SMult32(Arg1, Arg2 : LongInt) : LongInt;
 749 begin
 750    asm
 751        MOVE.L  A6,-(A7)
 752        MOVE.L  Arg1,d0
 753        MOVE.L  Arg2,d1
 754        MOVE.L  _UtilityBase,A6
 755        JSR -138(A6)
 756        MOVE.L  (A7)+,A6
 757        MOVE.L  d0,@RESULT
 758    end;
 759 end;
 760
 761 function SMult64(Arg1, Arg2 : LongInt) : LongInt;
 762 begin
 763    asm
 764        MOVE.L  A6,-(A7)
 765        MOVE.L  Arg1,d0
 766        MOVE.L  Arg2,d1
 767        MOVE.L  _UtilityBase,A6
 768        JSR -198(A6)
 769        MOVE.L  (A7)+,A6
 770        MOVE.L  d0,@RESULT
 771    end;
 772 end;
 773
 774 function Stricmp(Str1, Str2 : STRPTR) : LongInt;
 775 begin
 776    asm
 777        MOVE.L  A6,-(A7)
 778        MOVE.L  Str1,a0
 779        MOVE.L  Str2,a1
 780        MOVE.L  _UtilityBase,A6
 781        JSR -162(A6)
 782        MOVE.L  (A7)+,A6
 783        MOVE.L  d0,@RESULT
 784    end;
 785 end;
 786
 787 function Strnicmp(Str1, Str2 : STRPTR;
 788                   len : LongInt) : LongInt;
 789 begin
 790    asm
 791        MOVE.L  A6,-(A7)
 792        MOVE.L  Str1,a0
 793        MOVE.L  Str2,a1
 794        MOVE.L  len,d0
 795        MOVE.L  _UtilityBase,A6
 796        JSR -168(A6)
 797        MOVE.L  (A7)+,A6
 798        MOVE.L  d0,@RESULT
 799    end;
 800 end;
 801
 802 function TagInArray(t : Tag;
 803                     TagArray : Pointer) : Boolean;
 804 begin
 805    asm
 806        MOVE.L  A6,-(A7)
 807        MOVE.L  t,d0
 808        MOVE.L  TagArray,a0
 809        MOVE.L  _UtilityBase,A6
 810        JSR -090(A6)
 811        MOVE.L  (A7)+,A6
 812        TST.L   d0
 813        bne     @success
 814        bra     @end
 815    @success:
 816        move.b  #1,d0
 817    @end:
 818        move.b  d0,@RESULT
 819    end;
 820 end;
 821
 822 function ToLower(c : ULONG) : Char;
 823 begin
 824    asm
 825        MOVE.L  A6,-(A7)
 826        MOVE.L  c,d0
 827        MOVE.L  _UtilityBase,A6
 828        JSR -180(A6)
 829        MOVE.L  (A7)+,A6
 830        MOVE.B  d0,@RESULT
 831    end;
 832 end;
 833
 834 function ToUpper(c : ULONG) : Char;
 835 begin
 836    asm
 837        MOVE.L  A6,-(A7)
 838        MOVE.L  c,d0
 839        MOVE.L  _UtilityBase,A6
 840        JSR -174(A6)
 841        MOVE.L  (A7)+,A6
 842        MOVE.B  d0,@RESULT
 843    end;
 844 end;
 845
 846 function UDivMod32( dividend , divisor : ULONG) : ULONG;
 847 begin
 848    asm
 849        MOVE.L  A6,-(A7)
 850        MOVE.L  dividend,d0
 851        MOVE.L  divisor,d1
 852        MOVE.L  _UtilityBase,A6
 853        JSR -156(A6)
 854        MOVE.L  (A7)+,A6
 855        MOVE.L  d0,@RESULT
 856    end;
 857 end;
 858
 859 function UMult32(Arg1, Arg2 : ULONG) : ULONG;
 860 begin
 861    asm
 862        MOVE.L  A6,-(A7)
 863        MOVE.L  Arg1,d0
 864        MOVE.L  Arg2,d1
 865        MOVE.L  _UtilityBase,A6
 866        JSR -144(A6)
 867        MOVE.L  (A7)+,A6
 868        MOVE.L  d0,@RESULT
 869    end;
 870 end;
 871
 872 function UMult64(Arg1, Arg2 : ULONG) : ULONG;
 873 begin
 874    asm
 875        MOVE.L  A6,-(A7)
 876        MOVE.L  Arg1,d0
 877        MOVE.L  Arg2,d1
 878        MOVE.L  _UtilityBase,A6
 879        JSR -204(A6)
 880        MOVE.L  (A7)+,A6
 881        MOVE.L  d0,@RESULT
 882    end;
 883 end;
 884
 885 function UnpackStructureTags(pac: APTR;
 886                              packTable: Pointer;
 887                              TagList : pTagItem) : ULONG;
 888 begin
 889    asm
 890        MOVEM.L a2/a6,-(A7)
 891        MOVE.L  pac,a0
 892        MOVE.L  packTable,a1
 893        MOVE.L  TagList,a2
 894        MOVE.L  _UtilityBase,A6
 895        JSR -216(A6)
 896        MOVEM.L (A7)+,a2/a6
 897        MOVE.L  d0,@RESULT
 898    end;
 899 end;
 900
 901 end.
 902
 903
 904
 905
 906
 907
 908
 909
 910