workbench/c/AddDataTypes.c

   1 /*
   2     Copyright © 1995-2019, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: English
   7 */
   8
   9
  10 /******************************************************************************
  11
  12     NAME
  13
  14         AddDataTypes (files) [QUIET] [REFRESH] [LIST]
  15
  16     SYNOPSIS
  17
  18         FILES/M, QUIET/S, REFRESH/S, LIST/S
  19
  20     LOCATION
  21
  22         C:
  23
  24     FUNCTION
  25
  26         AddDataTypes allows you to activate a set of specific DataTypes.
  27         This might be necessary if new DataTypes were installed on your
  28         system or were not activated on startup.
  29
  30     INPUTS
  31
  32         FILES  --  The name of the file(s) of the corresponding DataType.
  33         QUIET  --  Won't output any messages
  34       REFRESH  --  Refreshes the DataTypes list?
  35          LIST  --  This will display a list of current DataTypes loaded in
  36                    memory
  37
  38     RESULT
  39
  40         Standard DOS error codes.
  41
  42     NOTES
  43
  44     EXAMPLE
  45
  46         AddDataTypes gif.datatype REFRESH
  47
  48     BUGS
  49
  50     SEE ALSO
  51
  52     INTERNALS
  53
  54     HISTORY
  55
  56 ******************************************************************************/
  57
  58 #define DEBUG 0
  59 #include <aros/debug.h>
  60
  61 #include <aros/macros.h>
  62 #include <aros/bigendianio.h>
  63 #include <exec/types.h>
  64 #include <exec/memory.h>
  65 #include <exec/execbase.h>
  66 #include <dos/dos.h>
  67 #include <dos/dosasl.h>
  68 #include <dos/dosextens.h>
  69 #include <libraries/iffparse.h>
  70 #include <utility/name.h>
  71 #include <utility/hooks.h>
  72 #include <workbench/startup.h>
  73
  74 #include <proto/exec.h>
  75 #include <proto/alib.h>
  76 #include <proto/dos.h>
  77 #include <proto/utility.h>
  78 #include <proto/iffparse.h>
  79 #include <proto/alib.h>
  80 #include <proto/arossupport.h>
  81
  82 #include <string.h>
  83
  84 #include "../libs/datatypes/datatypes_intern.h"
  85 #undef DOSBase
  86 #undef UtilityBase
  87 #undef IFFParseBase
  88 #undef LocaleBase
  89 #undef DTList
  90
  91 /******************************** STRUCTURES *********************************/
  92
  93 /* same as datatypes/datatypes.h/struct DataTypeHeader, but always big endian
  94 and 32 bit pointers (which in the file are actually offsets) */
  95
  96 struct FileDataTypeHeader
  97 {
  98     ULONG        fdth_NameOffset;     /* Name of the data type */
  99     ULONG        fdth_BaseNameOffset; /* Base name of the data type */
 100     ULONG        fdth_PatternOffset;  /* File name match pattern */
 101     ULONG        fdth_MaskOffset;     /* Comparision mask (binary) */
 102     ULONG        fdth_GroupID;        /* DataType Group */
 103     ULONG        fdth_ID;             /* DataType ID (same as IFF FORM type) */
 104     WORD         fdth_MaskLen;        /* Length of the comparision mask */
 105     WORD         fdth_Pad;            /* Unused at present (must be 0) */
 106     UWORD        fdth_Flags;          /* Flags -- see below */
 107     UWORD        fdth_Priority;
 108 };
 109
 110 #define O(x)        offsetof(struct FileDataTypeHeader,x)
 111
 112 static const IPTR FileDataTypeHeaderDesc[] =
 113 {
 114     sizeof(struct FileDataTypeHeader),
 115     SDM_ULONG(O(fdth_NameOffset)),
 116     SDM_ULONG(O(fdth_BaseNameOffset)),
 117     SDM_ULONG(O(fdth_PatternOffset)),
 118     SDM_ULONG(O(fdth_MaskOffset)),
 119     SDM_ULONG(O(fdth_GroupID)),
 120     SDM_ULONG(O(fdth_ID)),
 121     SDM_WORD(O(fdth_MaskLen)),
 122     SDM_WORD(O(fdth_Pad)),
 123     SDM_UWORD(O(fdth_Flags)),
 124     SDM_UWORD(O(fdth_Priority)),
 125     SDM_END
 126 };
 127
 128 /******************************** PROTOTYPES *********************************/
 129
 130 struct StackVars;               /* forward declaration */
 131
 132 BOOL DateScan(struct StackVars *sv);
 133 void ScanDirectory(struct StackVars *sv, STRPTR pattern);
 134 struct DataTypesList *CreateDTList(struct StackVars *sv);
 135 struct CompoundDataType *CreateBasicType(struct StackVars *sv,
 136                                          struct List *list,
 137                                          struct List *globallist, STRPTR name,
 138                                          UWORD Flags, ULONG ID, ULONG GroupID);
 139 void LoadDataType(struct StackVars *sv, STRPTR name);
 140 struct CompoundDataType *CreateDataType(struct StackVars *sv,
 141                                         struct IFFHandle *iff, STRPTR name);
 142 struct CompoundDataType *AddDataType(struct StackVars *sv,
 143                                      struct CompoundDataType *cdt);
 144 void DeleteDataType(struct StackVars *sv, struct CompoundDataType *cdt);
 145 void AlphaInsert(struct StackVars *sv, struct List *list, struct Node *node);
 146 struct Node *__FindNameNoCase(struct StackVars *sv, struct List *list,
 147                               STRPTR name);
 148
 149 AROS_UFP4(LONG, AROS_SLIB_ENTRY(ReadFunc, AddDataTypes, 0),
 150         AROS_UFPA(BPTR   , fh        , D1),
 151         AROS_UFPA(void * , buf       , D2),
 152         AROS_UFPA(LONG   , size      , D3),
 153         AROS_UFPA(struct DosLibrary *, DOSBase, A6));
 154 AROS_UFP4(LONG, AROS_SLIB_ENTRY(SeekFunc, AddDataTypes, 0),
 155         AROS_UFPA(BPTR   , fh        , D1),
 156         AROS_UFPA(LONG   , pos       , D2),
 157         AROS_UFPA(LONG   , mode      , D3),
 158         AROS_UFPA(struct DosLibrary *, DOSBase, A6));
 159 AROS_UFP3(UBYTE *, AROS_SLIB_ENTRY(AllocFunc, AddDataTypes, 0),
 160         AROS_UFPA(ULONG, size, D0),
 161         AROS_UFPA(ULONG, req,  D1),
 162         AROS_UFPA(struct DosLibrary *, DOSBase, A6));
 163 AROS_UFP3(void, AROS_SLIB_ENTRY(FreeFunc, AddDataTypes, 0),
 164         AROS_UFPA(APTR , memory, A1),
 165         AROS_UFPA(ULONG, size  , D0),
 166         AROS_UFPA(struct DosLibrary *, DOSBase, A6));
 167
 168 /********************************* CONSTANTS *********************************/
 169
 170 const TEXT Version[] = "$VER: AddDataTypes 42.2 (20.02.2019)\n";
 171
 172 #define EXCL_LEN 18
 173 UBYTE ExcludePattern[] = "#?.(info|dbg|backdrop|ppc|arm|i386|x86_64)";
 174
 175 UBYTE Template[] = "FILES/M,QUIET/S,REFRESH/S,LIST/S";
 176
 177 struct ArgArray
 178 {
 179     UBYTE **aa_Files;
 180     IPTR    aa_Quiet;
 181     IPTR   aa_Refresh;
 182     IPTR   aa_List;
 183 };
 184
 185 #define  ID_DTCD  MAKE_ID('D','T','C','D')
 186 #define  ID_DTTL  MAKE_ID('D','T','T','L')
 187
 188 #define  NUM_PROP  2
 189
 190 LONG PropArray[2*NUM_PROP]=
 191 {
 192     ID_DTYP, ID_DTHD,
 193     ID_DTYP, ID_DTCD
 194 };
 195
 196 #define  NUM_COLL  1
 197
 198 const LONG CollArray[2*NUM_COLL]=
 199 {
 200     ID_DTYP, ID_DTTL
 201 };
 202
 203
 204 const LONG_FUNC FunctionArray[]=
 205 {                               /* Note! */
 206     (LONG_FUNC)AROS_SLIB_ENTRY(ReadFunc, AddDataTypes, 0),
 207     (LONG_FUNC)AROS_SLIB_ENTRY(AllocFunc, AddDataTypes, 0),
 208     (LONG_FUNC)AROS_SLIB_ENTRY(FreeFunc, AddDataTypes, 0),
 209     (LONG_FUNC)AROS_SLIB_ENTRY(SeekFunc, AddDataTypes, 0), /* For ELF */
 210 };
 211
 212
 213 struct StackVars
 214 {
 215     struct DataTypesList *DTList;
 216     UBYTE                 ExclPat[2*EXCL_LEN+2+1];
 217     struct ArgArray  AA;
 218     UBYTE           *HookBuffer;
 219     ULONG            HookBufSize;
 220     ULONG            HookPosition;
 221 };
 222
 223 #undef  SysBase
 224 #define DTList            sv->DTList
 225 #define ExclPat           sv->ExclPat
 226 #define AA                sv->AA
 227 #define HookBuffer        sv->HookBuffer
 228 #define HookBufSize       sv->HookBufSize
 229 #define HookPosition      sv->HookPosition
 230
 231 /****** AddDataTypes/main *****************************************************
 232 *
 233 *   NAME
 234 *        main - well... main
 235 *
 236 *   SYNOPSIS
 237 *
 238 *   FUNCTION
 239 *
 240 *   INPUTS
 241 *
 242 *   RETURNS
 243 *
 244 *   EXAMPLE
 245 *
 246 *   SEE ALSO
 247 *
 248 ******************************************************************************
 249 *
 250 */
 251 int UtilityBase_version  = 37;
 252 int LocaleBase_version   = 37;
 253 int IFFParseBase_version = 37;
 254
 255 int __nocommandline = 1;
 256
 257 int main(void)
 258 {
 259     extern struct WBStartup *WBenchMsg;
 260     struct StackVars  vars;
 261     struct StackVars *sv;
 262     int    result = RETURN_FAIL;
 263
 264     memset(&vars, 0, sizeof(struct StackVars));
 265     sv = &vars;
 266
 267     if((DTList = CreateDTList(sv)))
 268     {
 269         ParsePatternNoCase(ExcludePattern, ExclPat, sizeof(ExclPat));
 270
 271         ObtainSemaphore(&DTList->dtl_Lock);
 272
 273         if(WBenchMsg)
 274         {
 275             UWORD num;
 276             struct WBArg *wa = &WBenchMsg->sm_ArgList[1];
 277
 278             for(num = 1; num<WBenchMsg->sm_NumArgs; wa++)
 279             {
 280                 BPTR olddir = CurrentDir(wa->wa_Lock);
 281                 LoadDataType(sv, wa->wa_Name);
 282                 CurrentDir(olddir);
 283             }
 284
 285             result = RETURN_OK;
 286         }
 287         else
 288         {
 289             struct RDArgs *RDArgs;
 290
 291             if(!(RDArgs = ReadArgs(Template, (SIPTR*)&AA, NULL)))
 292             {
 293                 PrintFault(IoErr(), NULL);
 294             }
 295             else
 296             {
 297                 if(AA.aa_Refresh)
 298                 {
 299                     if(DateScan(sv))
 300                     {
 301                         ScanDirectory(sv, "DEVS:DataTypes");
 302                     }
 303                 }
 304                 else
 305                 {
 306                     UBYTE **files = AA.aa_Files;
 307
 308                     if(files)
 309                     {
 310                         while(*files)
 311                         {
 312                             ScanDirectory(sv, *files);
 313                             files++;
 314                         }
 315                     }
 316                 }
 317
 318                 if(AA.aa_List)
 319                 {
 320                     struct DataTypesList *dtl = NULL;
 321                     struct NamedObject   *no  = NULL;
 322                     if((no = FindNamedObject(NULL, DATATYPESLIST, NULL)))
 323                     {
 324                         dtl = (struct DataTypesList*)no->no_Object;
 325                         ReleaseNamedObject(no);
 326                         if(dtl != NULL)
 327                         {
 328                             struct Node *node=dtl->dtl_SortedList.lh_Head;
 329                             while(node->ln_Succ != NULL)
 330                             {
 331                                 // sorted list points to DT.dtn_Node2 ....
 332                                 struct CompoundDataType *cdt;
 333                                 struct DataTypeHeader *dth;
 334
 335                                 if(CheckSignal(SIGBREAKF_CTRL_C))
 336                                 {
 337                                         Flush(Output());
 338                                         PrintFault(ERROR_BREAK,0);
 339                                         break;
 340                                 }
 341                                 cdt=(struct CompoundDataType *)(node-1);
 342                                 dth=cdt->DT.dtn_Header;
 343
 344                                 Printf("%s, \"%s\"\n", dth->dth_BaseName, dth->dth_Name);
 345                                 node = node->ln_Succ;
 346                             }
 347                         }
 348                     }
 349                 }
 350                 result = RETURN_OK;
 351                 FreeArgs(RDArgs);
 352             }
 353         }
 354
 355         ReleaseSemaphore(&DTList->dtl_Lock);
 356     }
 357
 358     return result;
 359 }
 360
 361
 362
 363 /****** AddDataTypes/DateScan *************************************************
 364 *
 365 *   NAME
 366 *        DateScan - See if DataTypes descriptors need updating
 367 *
 368 *   SYNOPSIS
 369 *
 370 *   FUNCTION
 371 *
 372 *   INPUTS
 373 *
 374 *   RETURNS
 375 *
 376 *   EXAMPLE
 377 *
 378 *   SEE ALSO
 379 *
 380 ******************************************************************************
 381 *
 382 */
 383
 384 BOOL DateScan(struct StackVars *sv)
 385 {
 386     BOOL   result = TRUE;
 387     BPTR   lock;
 388     struct FileInfoBlock *fib;
 389
 390     if((lock = Lock("DEVS:DataTypes", ACCESS_READ)))
 391     {
 392         if((fib = AllocDosObject(DOS_FIB, NULL)))
 393         {
 394             if(Examine(lock, fib))
 395             {
 396                 if(!CompareDates(&fib->fib_Date, &DTList->dtl_DateStamp))
 397                 {
 398                     result = FALSE;
 399                 }
 400                 else
 401                 {
 402                     DTList->dtl_DateStamp = fib->fib_Date;
 403                 }
 404             }
 405
 406             FreeDosObject(DOS_FIB,fib);
 407         }
 408
 409         UnLock(lock);
 410     }
 411
 412     return result;
 413 }
 414
 415
 416
 417 /****** AddDataTypes/ScanDirectory ********************************************
 418 *
 419 *   NAME
 420 *        ScanDirectory - Scan a directory recursively for DT descriptors
 421 *
 422 *   SYNOPSIS
 423 *
 424 *   FUNCTION
 425 *
 426 *   INPUTS
 427 *
 428 *   RETURNS
 429 *
 430 *   EXAMPLE
 431 *
 432 *   SEE ALSO
 433 *
 434 ******************************************************************************
 435 *
 436 */
 437
 438 void ScanDirectory(struct StackVars *sv, STRPTR pattern)
 439 {
 440     struct AnchorPath *AnchorPath;
 441     LONG               RetVal;
 442     BPTR               OldDir;
 443
 444     if((AnchorPath = (struct AnchorPath *)AllocVec(sizeof(struct AnchorPath),
 445                                                   MEMF_CLEAR)))
 446     {
 447         AnchorPath->ap_BreakBits = SIGBREAKF_CTRL_C;
 448
 449         RetVal = MatchFirst(pattern, AnchorPath);
 450
 451         while(!RetVal)
 452         {
 453             if(CheckSignal(SIGBREAKF_CTRL_C))
 454             {
 455                 if(!AA.aa_Quiet)
 456                 {
 457                     PrintFault(ERROR_BREAK, NULL);
 458                 }
 459
 460                 break;
 461             }
 462
 463             if(AnchorPath->ap_Info.fib_DirEntryType > 0L)
 464             {
 465                 if(!(AnchorPath->ap_Flags & APF_DIDDIR))
 466                 {
 467                     AnchorPath->ap_Flags |= APF_DODIR;
 468                 }
 469
 470                 AnchorPath->ap_Flags &= ~APF_DIDDIR;
 471             }
 472             else
 473             {
 474                 if(!MatchPatternNoCase(ExclPat,
 475                                        AnchorPath->ap_Info.fib_FileName))
 476                 {
 477                     OldDir = CurrentDir(AnchorPath->ap_Current->an_Lock);
 478
 479                     LoadDataType(sv, AnchorPath->ap_Info.fib_FileName);
 480
 481                     CurrentDir(OldDir);
 482                 }
 483             }
 484
 485             RetVal = MatchNext(AnchorPath);
 486         }
 487
 488         if(RetVal != ERROR_NO_MORE_ENTRIES)
 489         {
 490             if(!AA.aa_Quiet)
 491             {
 492                 PrintFault(RetVal, NULL);
 493             }
 494         }
 495
 496         MatchEnd(AnchorPath);
 497
 498         FreeVec((APTR)AnchorPath);
 499     }
 500 }
 501
 502
 503 /****** AddDataTypes/CreateDTList *********************************************
 504 *
 505 *   NAME
 506 *        CreateDTList - Create and initialize the DataTypesList
 507 *
 508 *   SYNOPSIS
 509 *
 510 *   FUNCTION
 511 *
 512 *   INPUTS
 513 *
 514 *   RETURNS
 515 *
 516 *   EXAMPLE
 517 *
 518 *   SEE ALSO
 519 *
 520 ******************************************************************************
 521 *
 522 */
 523
 524 struct DataTypesList *CreateDTList(struct StackVars *sv)
 525 {
 526     struct DataTypesList *dtl = NULL;
 527     struct NamedObject   *no  = NULL;
 528     struct Library *DTBase;
 529
 530     /* We do this in order to force datatypes.library to get
 531        loaded and initialized. During this process it will
 532        create and install DataTypes list object in memory. */
 533     DTBase = OpenLibrary("datatypes.library", 0);
 534     if (DTBase)
 535         CloseLibrary(DTBase);
 536
 537     if((no = FindNamedObject(NULL, DATATYPESLIST, NULL)))
 538     {
 539         dtl = (struct DataTypesList*)no->no_Object;
 540     }
 541
 542     if(dtl)
 543     {
 544         if(!__FindNameNoCase(sv, &dtl->dtl_BinaryList, "binary"))
 545         {
 546             CreateBasicType
 547             (
 548                 sv, &dtl->dtl_BinaryList, &dtl->dtl_SortedList,
 549                 "binary", DTF_BINARY, ID_BINARY, GID_SYSTEM
 550             );
 551         }
 552
 553         if(!__FindNameNoCase(sv, &dtl->dtl_ASCIIList, "ascii"))
 554         {
 555             CreateBasicType
 556             (
 557                 sv, &dtl->dtl_ASCIIList,  &dtl->dtl_SortedList,
 558                 "ascii", DTF_ASCII, ID_ASCII, GID_TEXT
 559             );
 560         }
 561
 562         if(!__FindNameNoCase(sv, &dtl->dtl_IFFList, "iff"))
 563         {
 564             CreateBasicType
 565             (
 566                 sv, &dtl->dtl_IFFList, &dtl->dtl_SortedList,
 567                 "iff", DTF_IFF, ID_IFF, GID_SYSTEM
 568             );
 569         }
 570
 571         if(!__FindNameNoCase(sv, &dtl->dtl_MiscList, "directory"))
 572         {
 573             CreateBasicType
 574             (
 575                 sv, &dtl->dtl_MiscList, &dtl->dtl_SortedList,
 576                 "directory", DTF_MISC, ID_DIRECTORY, GID_SYSTEM
 577             );
 578         }
 579     }
 580
 581     if(no)
 582     {
 583         ReleaseNamedObject(no);
 584     }
 585
 586
 587     return dtl;
 588 }
 589
 590
 591
 592 /****** AddDataTypes/CreateBasicType ******************************************
 593 *
 594 *   NAME
 595 *        CreateBasicType - Initialize one of the basic types
 596 *
 597 *   SYNOPSIS
 598 *
 599 *   FUNCTION
 600 *
 601 *   INPUTS
 602 *
 603 *   RETURNS
 604 *
 605 *   EXAMPLE
 606 *
 607 *   SEE ALSO
 608 *
 609 ******************************************************************************
 610 *
 611 */
 612
 613 struct CompoundDataType *CreateBasicType(struct StackVars *sv,
 614                                          struct List *list,
 615                                          struct List *globallist, STRPTR name,
 616                                          UWORD Flags, ULONG ID, ULONG GroupID)
 617 {
 618     struct CompoundDataType *cdt;
 619     ULONG AllocLen = sizeof(struct CompoundDataType) + strlen(name) + 1;
 620
 621     if((cdt = AllocVec(AllocLen, MEMF_PUBLIC | MEMF_CLEAR)))
 622     {
 623         cdt->DT.dtn_Header = &cdt->DTH;
 624
 625         strcpy((UBYTE*)(cdt + 1), name);
 626
 627         cdt->DTH.dth_Name=
 628             cdt->DTH.dth_BaseName=
 629             cdt->DT.dtn_Node1.ln_Name=
 630             cdt->DT.dtn_Node2.ln_Name=(UBYTE*)(cdt + 1);
 631
 632         cdt->DTH.dth_GroupID = GroupID;
 633         cdt->DTH.dth_ID = ID;
 634
 635         cdt->DTH.dth_Flags = Flags;
 636
 637         NewList(&cdt->DT.dtn_ToolList);
 638
 639         cdt->DT.dtn_Length = AllocLen;
 640
 641         cdt->DT.dtn_Node1.ln_Pri = -128;
 642         Enqueue(list, &cdt->DT.dtn_Node1);
 643
 644         AlphaInsert(sv, globallist, &cdt->DT.dtn_Node2);
 645     }
 646
 647     return cdt;
 648 }
 649
 650
 651
 652 /****** AddDataTypes/LoadDataType *********************************************
 653 *
 654 *   NAME
 655 *        LoadDataType - Load and install a single DataType descriptor
 656 *
 657 *   SYNOPSIS
 658 *
 659 *   FUNCTION
 660 *
 661 *   INPUTS
 662 *
 663 *   RETURNS
 664 *
 665 *   EXAMPLE
 666 *
 667 *   SEE ALSO
 668 *
 669 ******************************************************************************
 670 *
 671 */
 672
 673 void LoadDataType(struct StackVars *sv, STRPTR name)
 674 {
 675     struct IFFHandle *iff;
 676
 677     if((iff = AllocIFF()))
 678     {
 679         if((iff->iff_Stream = (IPTR)Open(name, MODE_OLDFILE))) /* Why IPTR? */
 680         {
 681             InitIFFasDOS(iff);
 682
 683             if(!OpenIFF(iff, IFFF_READ))
 684             {
 685                 if(!PropChunks(iff, PropArray, NUM_PROP))
 686                 {
 687                     if(!CollectionChunks(iff, CollArray, NUM_COLL))
 688                     {
 689                         if(!StopOnExit(iff, ID_DTYP, ID_FORM))
 690                         {
 691                             LONG error;
 692
 693                             while((error = ParseIFF(iff, IFFPARSE_SCAN)) == IFFERR_EOC)
 694                             {
 695                                 CreateDataType(sv, iff, name);
 696                                 /* FIXME: The while ParseIFF loop here crashes the 2nd time inside the loop, therefore the break below as temp fix */
 697                                 break;
 698                             }
 699                         }
 700                     }
 701                 }
 702
 703                 CloseIFF(iff);
 704             }
 705
 706             Close((BPTR)iff->iff_Stream);
 707         }
 708
 709         FreeIFF(iff);
 710     }
 711     else
 712     {
 713         SetIoErr(ERROR_NO_FREE_STORE);
 714     }
 715 }
 716
 717
 718 /****** AddDataTypes/MemStreamHook *******************************************
 719 *
 720 *   NAME
 721 *        MemStreamHook - needed by ReadStruct
 722 *
 723 *   SYNOPSIS
 724 *
 725 *   FUNCTION
 726 *
 727 *   INPUTS
 728 *
 729 *   RETURNS
 730 *
 731 *   EXAMPLE
 732 *
 733 *   SEE ALSO
 734 *
 735 ******************************************************************************
 736 *
 737 */
 738
 739 LONG MemStreamHook(struct Hook * hook, UBYTE **memptr, Msg msg)
 740 {
 741     LONG rc;
 742
 743     switch (msg->MethodID)
 744     {
 745         case BEIO_READ:
 746             rc = **memptr;
 747             (*memptr)++;
 748             break;
 749
 750         default:
 751             rc = -1;
 752             break;
 753     }
 754
 755     return rc;
 756 }
 757
 758 /****** AddDataTypes/CreateDataType *******************************************
 759 *
 760 *   NAME
 761 *        CreateDataType - create a DataType from IFF chunks
 762 *
 763 *   SYNOPSIS
 764 *
 765 *   FUNCTION
 766 *
 767 *   INPUTS
 768 *
 769 *   RETURNS
 770 *
 771 *   EXAMPLE
 772 *
 773 *   SEE ALSO
 774 *
 775 ******************************************************************************
 776 *
 777 */
 778
 779 struct CompoundDataType *CreateDataType(struct StackVars *sv,
 780                                         struct IFFHandle *iff, STRPTR name)
 781 {
 782     struct CompoundDataType *cdt = NULL;
 783     struct StoredProperty *prop;
 784 #if __mc68000
 785     LONG   DefaultStack = AROS_STACKSIZE;
 786     UBYTE *func;
 787 #endif
 788     ULONG  AllocLen, i;
 789     BPTR   SegList;
 790
 791     if((prop = FindProp(iff, ID_DTYP, ID_DTHD)))
 792     {
 793         D(bug("[AddDataTypes] sp_Size = %d", prop->sp_Size));
 794         AllocLen = sizeof(struct CompoundDataType) -
 795                   32 + /* was sizeof(struct DataTypeHeader), but we must use struct size as it would be on Amiga */
 796                   prop->sp_Size;
 797
 798         if(!(cdt = AllocVec(AllocLen, MEMF_PUBLIC | MEMF_CLEAR)))
 799         {
 800             SetIoErr(ERROR_NO_FREE_STORE);
 801         }
 802         else
 803         {
 804             struct FileDataTypeHeader *fdh = NULL;
 805             UBYTE *memptr = (UBYTE *)prop->sp_Data;
 806             struct Hook hook;
 807
 808             D(bug("[AddDataTypes] CDT @ 0x%p\n", cdt));
 809             hook.h_Entry = (HOOKFUNC)HookEntry;
 810             hook.h_SubEntry = (HOOKFUNC)MemStreamHook;
 811
 812             if (ReadStruct(&hook, (APTR *) &fdh, &memptr, FileDataTypeHeaderDesc))
 813             {
 814                 IPTR extraoffset = sizeof(struct DataTypeHeader) - 32;
 815
 816                 D(bug("[AddDataTypes] fdth_MaskOffset = %d\n", fdh->fdth_MaskOffset));
 817
 818                 cdt->DT.dtn_Header= &cdt->DTH;
 819
 820                 cdt->DTH.dth_Name = (STRPTR)(fdh->fdth_NameOffset + extraoffset + (IPTR)&cdt->DTH);
 821                 cdt->DTH.dth_BaseName = (STRPTR)(fdh->fdth_BaseNameOffset + extraoffset + (IPTR)&cdt->DTH);
 822                 cdt->DTH.dth_Pattern = (STRPTR)(fdh->fdth_PatternOffset + extraoffset + (IPTR)&cdt->DTH);
 823                 cdt->DTH.dth_Mask = (WORD *)(fdh->fdth_MaskOffset + extraoffset + (IPTR)&cdt->DTH);
 824                 cdt->DTH.dth_GroupID = fdh->fdth_GroupID;
 825                 cdt->DTH.dth_ID = fdh->fdth_ID;
 826                 cdt->DTH.dth_MaskLen = fdh->fdth_MaskLen;
 827                 cdt->DTH.dth_Pad = fdh->fdth_Pad;
 828                 cdt->DTH.dth_Flags = fdh->fdth_Flags;
 829                 cdt->DTH.dth_Priority = fdh->fdth_Priority;
 830
 831                 CopyMem(prop->sp_Data + 32, cdt + 1, prop->sp_Size - 32);
 832
 833                 D(
 834                     bug("[AddDataTypes] groupid  = %c%c%c%c\n", cdt->DTH.dth_GroupID >> 24,
 835                                                      cdt->DTH.dth_GroupID >> 16,
 836                                                      cdt->DTH.dth_GroupID >> 8,
 837                                                      cdt->DTH.dth_GroupID);
 838                     bug("[AddDataTypes] id       = %c%c%c%c\n", cdt->DTH.dth_ID >> 24,
 839                                                      cdt->DTH.dth_ID >> 16,
 840                                                      cdt->DTH.dth_ID >> 8,
 841                                                      cdt->DTH.dth_ID);
 842                     bug("[AddDataTypes] flags    = %x\n",        cdt->DTH.dth_Flags);
 843                     bug("[AddDataTypes] pri      = %d\n",        cdt->DTH.dth_Priority);
 844                     bug("[AddDataTypes] name     = %s\n",        cdt->DTH.dth_Name);
 845                     bug("[AddDataTypes] basename = %s\n",        cdt->DTH.dth_BaseName);
 846                     bug("[AddDataTypes] pattern  = %s\n",        cdt->DTH.dth_Pattern);
 847                     bug("[AddDataTypes] masklen  = %d\n",        cdt->DTH.dth_MaskLen);
 848                 )
 849                 for(i = 0; i < cdt->DTH.dth_MaskLen; i++)
 850                 {
 851                     cdt->DTH.dth_Mask[i] = AROS_BE2WORD(cdt->DTH.dth_Mask[i]);
 852                     D(bug("[AddDataTypes] mask[%d] = %04x (%c %c)\n", i,
 853                             cdt->DTH.dth_Mask[i],
 854                             cdt->DTH.dth_Mask[i] & 255,
 855                             (cdt->DTH.dth_Mask[i] >> 8) & 255);)
 856                 }
 857
 858                 NewList(&cdt->DT.dtn_ToolList);
 859
 860                 cdt->DT.dtn_Length = AllocLen;
 861
 862 #if __mc68000
 863                 if((prop = FindProp(iff, ID_DTYP, ID_DTCD)))
 864                 {
 865                     if((func = AllocVec(prop->sp_Size, MEMF_PUBLIC | MEMF_CLEAR)))
 866                     {
 867                         cdt->DTCDChunk = func;
 868                         cdt->DTCDSize = prop->sp_Size;
 869
 870                         CopyMem(prop->sp_Data,func,prop->sp_Size);
 871
 872                         HookBuffer = cdt->DTCDChunk;
 873                         HookBufSize = cdt->DTCDSize;
 874                         HookPosition = 0;
 875
 876                         /* We use a cast to BPTR, since sv may not
 877                          * be ULONG aligned. Since only our ReadFunc
 878                          * is going to be looking at it, this is ok.
 879                          */
 880                         if((SegList = InternalLoadSeg((BPTR)(sv), BNULL,
 881                                                       (LONG_FUNC *)FunctionArray,
 882                                                       &DefaultStack)))
 883                         {
 884                             cdt->SegList = SegList;
 885                             cdt->Function = BADDR(SegList) + sizeof(BPTR);
 886                         }
 887
 888                     } /* if((func = AllocVec(prop->sp_Size, MEMF_PUBLIC | MEMF_CLEAR))) */
 889
 890                 } /* if((prop = FindProp(iff, ID_DTYP, ID_DTCD))) */
 891 #else
 892                 TEXT CDname[256];
 893
 894                 __sprintf(CDname,"%s.%s", name, TARGETCPU);
 895                 D(bug("[AddDataTypes] Checking for '%s'\n", CDname);)
 896
 897                 if((SegList = LoadSeg(CDname)))
 898                 {
 899                     D(bug("[AddDataTypes] Found!\n");)
 900                     cdt->SegList = SegList;
 901                     cdt->Function = BADDR(SegList) + sizeof(BPTR);
 902                     D(bug("[AddDataTypes] Entry @ 0x%p\n", cdt->Function);)
 903                 }
 904 #endif
 905                 cdt = AddDataType(sv, cdt);
 906
 907                 FreeStruct(fdh, FileDataTypeHeaderDesc);
 908
 909             } /* if (ReadStruct(&hook, &fdh, &memptr, FileDataTypeHeaderDesc)) */
 910
 911         } /* cdt AllocVec okay */
 912
 913     } /* if((prop = FindProp(iff, ID_DTYP, ID_DTHD))) */
 914
 915     return cdt;
 916 }
 917
 918
 919
 920 /****** AddDataTypes/AddDataType **********************************************
 921 *
 922 *   NAME
 923 *        AddDataType - add a DataType to the system
 924 *
 925 *   SYNOPSIS
 926 *
 927 *   FUNCTION
 928 *
 929 *        This subroutine tries to add a DataType to the system DataTypes
 930 *        list. If the DataType already exists, it will be replaced or
 931 *        updated. In case of an error, the CompoundDataType will be deleted
 932 *        and a NULL pointer is returned.
 933 *
 934 *        The CompoundDataType pointer you passed in will be invalid after
 935 *        calling this function. Use the returned handle instead.
 936 *        DO NOT USE THE OLD POINTER IN ANY MORE!
 937 *
 938 *   INPUTS
 939 *
 940 *   RETURNS
 941 *
 942 *        A pointer to a CompoundDataType in the system DataTypes list
 943 *        or a NULL pointer for failure
 944 *
 945 *   EXAMPLE
 946 *
 947 *   SEE ALSO
 948 *
 949 ******************************************************************************
 950 *
 951 */
 952
 953 struct CompoundDataType *AddDataType(struct StackVars *sv,
 954                                      struct CompoundDataType *cdt)
 955 {
 956     struct List *typelist;
 957     BOOL   Success = FALSE;
 958     ULONG  AllocSize;
 959     ULONG  result;
 960     struct CompoundDataType *oldcdt;
 961
 962     switch(cdt->DTH.dth_Flags & DTF_TYPE_MASK)
 963     {
 964     case DTF_BINARY: typelist= &DTList->dtl_BinaryList; break;
 965     case DTF_ASCII:  typelist= &DTList->dtl_ASCIIList; break;
 966     case DTF_IFF:    typelist= &DTList->dtl_IFFList; break;
 967     case DTF_MISC:   typelist= &DTList->dtl_MiscList; break;
 968     default:         typelist= NULL;
 969     }
 970
 971     if(typelist)
 972     {
 973         cdt->DT.dtn_Node1.ln_Name = cdt->DT.dtn_Node2.ln_Name = cdt->DTH.dth_Name;
 974
 975         Success = TRUE;
 976
 977         if((!Stricmp(cdt->DTH.dth_Pattern, "#?")) ||
 978            (!strlen(cdt->DTH.dth_Pattern)) )
 979         {
 980             cdt->FlagLong |= CFLGF_PATTERN_UNUSED;
 981         }
 982         else
 983         {
 984             cdt->FlagLong &= ~(CFLGF_PATTERN_UNUSED);
 985
 986             AllocSize = 2*strlen(cdt->DTH.dth_Pattern) + 2;
 987
 988             if(!(cdt->ParsePatMem = AllocVec(AllocSize,
 989                                              MEMF_PUBLIC | MEMF_CLEAR)))
 990             {
 991                 Success = FALSE;
 992             }
 993             else
 994             {
 995                 cdt->ParsePatSize = AllocSize;
 996
 997                 result = ParsePatternNoCase(cdt->DTH.dth_Pattern,
 998                                             cdt->ParsePatMem, AllocSize);
 999
1000                 if(result == 1)
1001                 {
1002                     cdt->FlagLong |= CFLGF_IS_WILD;
1003                 }
1004                 else
1005                 {
1006                     FreeVec(cdt->ParsePatMem);
1007                     cdt->ParsePatMem = NULL;
1008                     cdt->ParsePatSize = 0;
1009
1010                     if(result == 0)
1011                     {
1012                         cdt->FlagLong &= ~(CFLGF_IS_WILD);
1013                     }
1014                     else
1015                     {
1016                         Success = FALSE;
1017                     }
1018                 }
1019             }
1020         }
1021
1022         if (Success)
1023         {
1024             if((oldcdt = (struct CompoundDataType*)__FindNameNoCase(sv,
1025                                                                     typelist,
1026                                                                     cdt->DT.dtn_Node1.ln_Name)))
1027             {
1028                 if (oldcdt->OpenCount)
1029                 {
1030                     Success = FALSE;
1031                 }
1032                 else
1033                 {
1034                     if((Stricmp(oldcdt->DTH.dth_Name, cdt->DTH.dth_Name)) ||
1035                        (Stricmp(oldcdt->DTH.dth_BaseName, cdt->DTH.dth_BaseName)) ||
1036                        (Stricmp(oldcdt->DTH.dth_Pattern, cdt->DTH.dth_Pattern)) ||
1037                        (oldcdt->DTH.dth_Flags != cdt->DTH.dth_Flags) ||
1038                        (oldcdt->DTH.dth_Priority != cdt->DTH.dth_Priority) ||
1039                        (oldcdt->DTH.dth_MaskLen != cdt->DTH.dth_MaskLen))
1040                     {
1041                         DeleteDataType(sv, oldcdt);
1042                         oldcdt = NULL;
1043                     }
1044                     else
1045                     {
1046                         oldcdt->DTH.dth_GroupID = cdt->DTH.dth_GroupID;
1047                         oldcdt->DTH.dth_ID      = cdt->DTH.dth_ID;
1048                         CopyMem(cdt->DTH.dth_Mask, oldcdt->DTH.dth_Mask,
1049                                 (ULONG)(sizeof(WORD)*cdt->DTH.dth_MaskLen));
1050                     }
1051                 }
1052             }
1053
1054             if(Success)
1055             {
1056                 if(oldcdt)
1057                 {
1058                     DeleteDataType(sv, cdt);
1059                     cdt = oldcdt;
1060                 }
1061                 else
1062                 {
1063                     if(cdt->DT.dtn_FunctionName)
1064                     {
1065                         LONG DefaultStack = 4096;
1066                         BPTR file;
1067                         ULONG AllocLen;
1068                         BPTR SegList;
1069
1070                         if((file = Open(cdt->DT.dtn_FunctionName, MODE_OLDFILE)))
1071                         {
1072                             if(Seek(file, 0, OFFSET_END) >= 0)
1073                             {
1074                                 if((AllocLen = Seek(file, 0,
1075                                                     OFFSET_BEGINNING)) > 0)
1076                                 {
1077                                     if((cdt->DTCDChunk = AllocVec(AllocLen,
1078                                                                   MEMF_PUBLIC | MEMF_CLEAR)))
1079                                     {
1080                                         cdt->DTCDSize = AllocLen;
1081
1082                                         if(Read(file, cdt->DTCDChunk, AllocLen) == AllocLen)
1083                                         {
1084                                             HookBuffer = cdt->DTCDChunk;
1085                                             HookBufSize = cdt->DTCDSize;
1086                                             HookPosition = 0;
1087
1088                                             /* We use a cast to BPTR, since sv may not
1089                                              * be ULONG aligned. Since only our ReadFunc
1090                                              * is going to be looking at it, this is ok.
1091                                              */
1092                                             if((SegList = InternalLoadSeg((BPTR)(sv), BNULL, (LONG_FUNC *)FunctionArray, &DefaultStack)))
1093                                             {
1094                                                 cdt->SegList = SegList;
1095                                                 cdt->Function = BADDR(SegList) + sizeof(BPTR);  // FIXME: is this portable?
1096                                             }
1097                                         }
1098                                         else
1099                                         {
1100                                             FreeVec(cdt->DTCDChunk);
1101                                             cdt->DTCDChunk = NULL;
1102                                             cdt->DTCDSize = 0;
1103                                         }
1104                                     }
1105                                 }
1106                             }
1107                         }
1108                         cdt->DT.dtn_FunctionName=NULL;
1109                     }
1110
1111                     if(cdt->DTH.dth_MaskLen > DTList->dtl_LongestMask)
1112                     {
1113                         DTList->dtl_LongestMask = cdt->DTH.dth_MaskLen;
1114                     }
1115
1116                     cdt->DT.dtn_Node1.ln_Pri = cdt->DTH.dth_Priority;
1117                     Enqueue(typelist, &cdt->DT.dtn_Node1);
1118
1119                     AlphaInsert(sv, &DTList->dtl_SortedList, &cdt->DT.dtn_Node2);
1120                 }
1121             }
1122         }
1123     }
1124
1125     if(!Success)
1126     {
1127         DeleteDataType(sv, cdt);
1128         cdt = NULL;
1129     }
1130
1131     return cdt;
1132 }
1133
1134
1135
1136 /****** AddDataTypes/DeleteDataType *******************************************
1137 *
1138 *   NAME
1139 *        DeleteDataType - unlink and deallocate a CompoundDataType structure
1140 *
1141 *   SYNOPSIS
1142 *
1143 *   FUNCTION
1144 *
1145 *   INPUTS
1146 *
1147 *   RETURNS
1148 *
1149 *   EXAMPLE
1150 *
1151 *   SEE ALSO
1152 *
1153 ******************************************************************************
1154 *
1155 */
1156
1157 void DeleteDataType(struct StackVars *sv, struct CompoundDataType *cdt)
1158 {
1159     if(cdt)
1160     {
1161         if(cdt->ParsePatMem)
1162         {
1163             FreeVec(cdt->ParsePatMem);
1164             cdt->ParsePatMem = NULL;
1165             cdt->ParsePatSize = 0;
1166         }
1167
1168         if(cdt->DTCDChunk)
1169         {
1170             FreeVec(cdt->DTCDChunk);
1171             cdt->DTCDChunk = NULL;
1172             cdt->DTCDSize = 0;
1173         }
1174
1175         if(cdt->SegList)
1176         {
1177             UnLoadSeg(cdt->SegList);
1178             cdt->SegList = BNULL;
1179             cdt->Function = NULL;
1180         }
1181
1182         if(cdt->DT.dtn_Node1.ln_Succ && cdt->DT.dtn_Node1.ln_Pred)
1183         {
1184             Remove(&cdt->DT.dtn_Node1);
1185             Remove(&cdt->DT.dtn_Node2);
1186             cdt->DT.dtn_Node1.ln_Succ = cdt->DT.dtn_Node1.ln_Pred =
1187                 cdt->DT.dtn_Node2.ln_Succ = cdt->DT.dtn_Node2.ln_Pred = NULL;
1188         }
1189
1190         FreeVec(cdt);
1191     }
1192 }
1193
1194
1195
1196 /****** AddDataTypes/AlphaInsert **********************************************
1197 *
1198 *   NAME
1199 *        AlphaInsert - enqueue a node alphabetically into a list
1200 *
1201 *   SYNOPSIS
1202 *
1203 *   FUNCTION
1204 *
1205 *   INPUTS
1206 *
1207 *   RETURNS
1208 *
1209 *   EXAMPLE
1210 *
1211 *   SEE ALSO
1212 *
1213 ******************************************************************************
1214 *
1215 */
1216
1217 void AlphaInsert(struct StackVars *sv, struct List *list, struct Node *node)
1218 {
1219     struct Node *cur,*prev=NULL;
1220
1221     for(cur = list->lh_Head; cur->ln_Succ; prev = cur, cur = cur->ln_Succ)
1222     {
1223         if(Stricmp(cur->ln_Name, node->ln_Name) > 0)
1224             break;
1225     }
1226
1227     Insert(list, node, prev);
1228 }
1229
1230
1231
1232 /****** AddDataTypes/__FindNameNoCase *****************************************
1233 *
1234 *   NAME
1235 *        __FindNameNoCase - find a node in a list (case insensitive)
1236 *
1237 *   SYNOPSIS
1238 *
1239 *   FUNCTION
1240 *
1241 *   INPUTS
1242 *
1243 *   RETURNS
1244 *
1245 *   EXAMPLE
1246 *
1247 *   SEE ALSO
1248 *
1249 ******************************************************************************
1250 *
1251 */
1252
1253 struct Node *__FindNameNoCase(struct StackVars *sv, struct List *list,
1254                               STRPTR name)
1255 {
1256     struct Node *node;
1257     struct Node *result = NULL;
1258
1259     for(node = list->lh_Head; node->ln_Succ; node = node->ln_Succ)
1260     {
1261         if(!Stricmp(node->ln_Name, name))
1262         {
1263             result = node;
1264             break;
1265         }
1266     }
1267
1268     return result;
1269 }
1270
1271
1272
1273 /****** AddDataTypes/ReadFunc *************************************************
1274 *
1275 *   NAME
1276 *        ReadFunc - data read hook for InternalLoadSeg
1277 *
1278 *   SYNOPSIS
1279 *
1280 *   FUNCTION
1281 *
1282 *   INPUTS
1283 *
1284 *   RETURNS
1285 *
1286 *   EXAMPLE
1287 *
1288 *   SEE ALSO
1289 *
1290 ******************************************************************************
1291 *
1292 */
1293
1294 AROS_UFH4(LONG, AROS_SLIB_ENTRY(ReadFunc, AddDataTypes, 0),
1295         AROS_UFHA(BPTR   , fh        , D1),
1296         AROS_UFHA(void * , buffer    , D2),
1297         AROS_UFHA(LONG   , length    , D3),
1298         AROS_UFHA(struct DosLibrary *, DOSBase, A6))
1299 {
1300     AROS_USERFUNC_INIT
1301
1302     struct StackVars *sv = (APTR)fh;
1303     LONG maxlen = HookBufSize-HookPosition;
1304     LONG actual = length > maxlen ? maxlen : length;
1305
1306     CopyMem(HookBuffer+HookPosition, buffer, actual);
1307
1308     HookPosition += actual;
1309
1310     return actual;
1311
1312     AROS_USERFUNC_EXIT
1313 }
1314
1315 /****** AddDataTypes/SeekFunc *************************************************
1316 *
1317 *   NAME
1318 *        SeekFunc - seek hook for InternalLoadSeg (ELF only)
1319 *
1320 *   SYNOPSIS
1321 *
1322 *   FUNCTION
1323 *
1324 *   INPUTS
1325 *
1326 *   RETURNS
1327 *
1328 *   EXAMPLE
1329 *
1330 *   SEE ALSO
1331 *
1332 ******************************************************************************
1333 *
1334 */
1335
1336 AROS_UFH4(LONG, AROS_SLIB_ENTRY(SeekFunc, AddDataTypes, 0),
1337         AROS_UFHA(BPTR   , fh        , D1),
1338         AROS_UFHA(LONG   , pos       , D2),
1339         AROS_UFHA(LONG   , mode      , D3),
1340         AROS_UFHA(struct DosLibrary *, DOSBase, A6))
1341 {
1342     AROS_USERFUNC_INIT
1343
1344     struct StackVars *sv = (APTR)fh;
1345     LONG oldpos = HookPosition;
1346
1347     switch (mode) {
1348     case OFFSET_BEGINNING: break;
1349     case OFFSET_END:       pos = HookBufSize - pos; break;
1350     case OFFSET_CURRENT:   pos = HookPosition + pos; break;
1351     default: return -1;
1352     }
1353
1354     if (pos < 0 || pos >= HookBufSize)
1355         return -1;
1356
1357     HookPosition = pos;
1358
1359     return oldpos;
1360
1361     AROS_USERFUNC_EXIT
1362 }
1363
1364 /****** AddDataTypes/AllocFunc ************************************************
1365 *
1366 *   NAME
1367 *        AllocFunc - memory allocation hook for InternalLoadSeg
1368 *
1369 *   SYNOPSIS
1370 *
1371 *   FUNCTION
1372 *
1373 *   INPUTS
1374 *
1375 *   RETURNS
1376 *
1377 *   EXAMPLE
1378 *
1379 *   SEE ALSO
1380 *
1381 ******************************************************************************
1382 *
1383 */
1384
1385 AROS_UFH3(UBYTE *, AROS_SLIB_ENTRY(AllocFunc, AddDataTypes, 0),
1386         AROS_UFHA(ULONG, size, D0),
1387         AROS_UFHA(ULONG, flags,D1),
1388         AROS_UFHA(struct DosLibrary *, DOSBase, A6))
1389 {
1390     AROS_USERFUNC_INIT
1391
1392     return(AllocMem(size, flags));
1393
1394     AROS_USERFUNC_EXIT
1395 }
1396
1397
1398
1399 /****** AddDataTypes/FreeFunc *************************************************
1400 *
1401 *   NAME
1402 *        FreeFunc - memory freeing hook for InternalLoadSeg
1403 *
1404 *   SYNOPSIS
1405 *
1406 *   FUNCTION
1407 *
1408 *   INPUTS
1409 *
1410 *   RETURNS
1411 *
1412 *   EXAMPLE
1413 *
1414 *   SEE ALSO
1415 *
1416 ******************************************************************************
1417 *
1418 */
1419
1420 AROS_UFH3(void, AROS_SLIB_ENTRY(FreeFunc, AddDataTypes, 0),
1421         AROS_UFHA(APTR , memory, A1),
1422         AROS_UFHA(ULONG, size  , D0),
1423         AROS_UFHA(struct DosLibrary *, DOSBase, A6))
1424 {
1425     AROS_USERFUNC_INIT
1426
1427     FreeMem(memory, size);
1428
1429     AROS_USERFUNC_EXIT
1430 }
1431
1432
1433
1434 /******************************* STUB ROUTINES ********************************/
1435
1436 struct NamedObject *allocnamedobject(struct StackVars *sv, STRPTR name,
1437                                      Tag FirstTag, ...)
1438 {
1439     return AllocNamedObjectA(name, (struct TagItem*)&FirstTag);
1440 }