workbench/c/AddDataTypes.c

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