workbench/libs/datatypes/helpfuncs.c

   1 /*
   2     Copyright © 1995-2003, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define USE_BOOPSI_STUBS
   7 #include <aros/macros.h>
   8 #include <datatypes/datatypes.h>
   9 #include <proto/alib.h>
  10 #include <proto/utility.h>
  11 #include <proto/dos.h>
  12 #include <proto/iffparse.h>
  13 #include <proto/intuition.h>
  14 #include <proto/locale.h>
  15 #include <utility/name.h>
  16 #include <intuition/cghooks.h>
  17 #include <libraries/locale.h>
  18 #include <datatypes/datatypesclass.h>
  19 #include "datatypes_intern.h"
  20 #include <clib/boopsistubs.h>
  21
  22 #include <aros/debug.h>
  23
  24 /************************** ASCII/BINARY RECOGNITION *************************/
  25
  26 UBYTE const ASCIITable[256]=
  27 {
  28    0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,
  29    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  30    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  31    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  32    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  33    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  34    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  35    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  36 };
  37
  38
  39 UBYTE const BinaryTable[256]=
  40 {
  41    1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1,1,0,1,0,1,1,1,1,1,1,1,0,1,1,1,1,
  42    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  43    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  44    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  45    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,
  46    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  47    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
  48    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  49 };
  50
  51
  52
  53 struct DataTypesList *GetDataTypesList(struct DataTypesBase *DataTypesBase)
  54 {
  55     struct NamedObject   *no;
  56     struct DataTypesList *dtl = NULL;
  57
  58     if((no = FindNamedObject(NULL, DATATYPESLIST, NULL)))
  59     {
  60         dtl = (struct DataTypesList *)no->no_Object;
  61     }
  62
  63     if(!dtl)
  64     {
  65         struct TagItem tags[] =
  66         {
  67             {ANO_NameSpace  , TRUE                          },
  68             {ANO_UserSpace  , sizeof(struct DataTypesList)  },
  69             {ANO_Flags      , NSF_NODUPS | NSF_CASE         },
  70             {TAG_DONE                                       }
  71         };
  72
  73         if((no = AllocNamedObjectA(DATATYPESLIST, tags)))
  74             {
  75                 if(!(dtl = (struct DataTypesList*)no->no_Object))
  76                 {
  77                     FreeNamedObject(no);
  78                     no = NULL;
  79                 }
  80             }
  81
  82         if(dtl)
  83         {
  84             InitSemaphore(&dtl->dtl_Lock);
  85             NewList(&dtl->dtl_SortedList);
  86             NewList(&dtl->dtl_BinaryList);
  87             NewList(&dtl->dtl_ASCIIList);
  88             NewList(&dtl->dtl_IFFList);
  89             NewList(&dtl->dtl_MiscList);
  90
  91             if(!AddNamedObject(NULL, no))
  92             {
  93                 FreeNamedObject(no);
  94                 no = NULL;
  95                 dtl = NULL;
  96             }
  97         }
  98     }
  99
 100     if (no)
 101         ReleaseNamedObject(no);
 102
 103     return(dtl);
 104 }
 105
 106
 107 struct Node *FindNameNoCase(struct Library *DataTypesBase, struct List *list,
 108                             STRPTR name)
 109 {
 110     struct Node *node;
 111     struct Node *result = NULL;
 112
 113     for (node = list->lh_Head; node->ln_Succ; node = node->ln_Succ)
 114     {
 115         if (!Stricmp(node->ln_Name, name))
 116         {
 117             result = node;
 118             break;
 119         }
 120     }
 121
 122     return result;
 123 }
 124
 125
 126
 127 BPTR NewOpen(struct Library *DataTypesBase, STRPTR name, ULONG SourceType,
 128              ULONG Length)
 129 {
 130     BPTR returnfh = NULL;
 131     //    struct XpkFib *xpkfib=NULL;
 132     BPTR dosfile;
 133
 134     D(bug("datatypes.library/NewOpen: name = %s\n", name));
 135
 136     if((dosfile = Open(name, MODE_OLDFILE)))
 137     {
 138         D(bug("datatypes.library/NewOpen: open okay\n"));
 139
 140         returnfh = dosfile;
 141
 142 #if 0
 143         if(XpkBase)
 144         {
 145             if(xpkfib = AllocVec(sizeof(struct XpkFib),
 146                                   MEMF_PUBLIC|MEMF_CLEAR))
 147             {
 148                 if(!xpkexaminetags(DataTypesBase, xpkfib, XPK_InFH, dosfile,
 149                                    TAG_DONE))
 150                 {
 151                     switch (xpkfib->Type)
 152                     {
 153                     case XPKTYPE_UNPACKED:
 154                         returnfh=dosfile;
 155                         break;
 156
 157                     case XPKTYPE_PACKED:
 158                         Message(DataTypesBase,"file is XPK packed","okay");
 159
 160                         if (xpkfib->Flags&XPKFLAGS_PASSWORD)
 161                             Message(DataTypesBase,"file needs password","okay");
 162
 163                         if (xpkfib->Flags&XPKFLAGS_NOSEEK)
 164                             Message(DataTypesBase,"file does not support seeking",
 165                                     "okay");
 166                         if (xpkfib->Flags&XPKFLAGS_NONSTD)
 167                             Message(DataTypesBase,"file is non standard","okay");
 168
 169                         SetIoErr(ERROR_NOT_IMPLEMENTED);
 170                         break;
 171
 172                     case XPKTYPE_ARCHIVE:
 173                         SetIoErr(ERROR_NOT_IMPLEMENTED);
 174                         break;
 175                     }
 176                 }
 177                 FreeVec(xpkfib);
 178             }
 179         }
 180         if (returnfh != dosfile)
 181         {
 182             Close(dosfile);
 183         }
 184 #endif
 185
 186     }
 187
 188     return returnfh;
 189 }
 190
 191
 192
 193
 194 #define getDTLIST (GPB(DataTypesBase)->dtb_DTList)
 195
 196 struct CompoundDatatype *ExamineLock(BPTR lock, struct FileInfoBlock *fib,
 197                                      struct Library *DataTypesBase)
 198 {
 199     struct CompoundDatatype *cdt = NULL;
 200
 201     D(bug("datatypes.library/ExamineLock\n"));
 202
 203     ObtainSemaphoreShared(&getDTLIST->dtl_Lock);
 204
 205     if(Examine(lock, fib))
 206     {
 207         D(bug("datatypes.library/ExamineLock: Examine okay\n"));
 208         if (fib->fib_DirEntryType > 0)
 209         {
 210             D(bug("datatypes.library/ExamineLock: is a directory\n"));
 211             cdt = (struct CompoundDatatype *)FindNameNoCase(DataTypesBase,
 212                                                             &getDTLIST->dtl_MiscList,
 213                                                             "directory");
 214         }
 215         else
 216         {
 217             if (fib->fib_DirEntryType < 0)
 218             {
 219                 UBYTE namebuf[510];
 220
 221                 D(bug("datatypes.library/ExamineLock: is a file\n"));
 222
 223                 if (NameFromLock(lock, namebuf, sizeof(namebuf)))
 224                 {
 225                     BPTR file;
 226
 227                     D(bug("datatypes.library/ExamineLock: NameFromLock okay. Name = \"%s\"\n", namebuf));
 228
 229                     if((file = NewOpen(DataTypesBase, namebuf, DTST_FILE, 0)))
 230                     {
 231                         UBYTE *CheckArray;
 232                         UWORD CheckSize = (getDTLIST->dtl_LongestMask > 64) ?
 233                             getDTLIST->dtl_LongestMask : 64;
 234
 235                         D(bug("datatypes.library/ExamineLock: NewOpen okay\n"));
 236
 237                         if((CheckArray = AllocVec((ULONG)(CheckSize)+1,
 238                                                   MEMF_CLEAR)))
 239                         {
 240                             D(bug("datatypes.library/ExamineLock: Alloced CheckArray\n"));
 241
 242                             if((CheckSize = Read(file, CheckArray,
 243                                                  (ULONG)CheckSize)) > 0)
 244                             {
 245                                 struct DTHookContext dthc;
 246                                 struct IFFHandle *iff;
 247
 248                                 D(bug("datatypes.library/ExamineLock: Read in CheckArray size = %d\n", CheckSize));
 249
 250                                 Seek(file, 0, OFFSET_BEGINNING);
 251
 252                                 dthc.dthc_SysBase = (struct Library *)SysBase;
 253                                 dthc.dthc_DOSBase = (struct Library *)DOSBase;
 254                                 dthc.dthc_IFFParseBase = IFFParseBase;
 255                                 dthc.dthc_UtilityBase = (struct Library *)UtilityBase;
 256                                 dthc.dthc_Lock = lock;
 257                                 dthc.dthc_FIB = fib;
 258                                 dthc.dthc_FileHandle = file;
 259                                 dthc.dthc_Buffer = CheckArray;
 260                                 dthc.dthc_BufferLength = CheckSize;
 261
 262                                 if(!(iff=dthc.dthc_IFF = AllocIFF()))
 263                                     SetIoErr(ERROR_NO_FREE_STORE);
 264                                 else
 265                                 {
 266                                     D(bug("datatypes.library/ExamineLock: AllocIFF okay: iff = %x\n", iff));
 267
 268                                     iff->iff_Stream = (IPTR)file;   /* Hmm? */
 269                                     InitIFFasDOS(iff);
 270
 271                                     if (!OpenIFF(iff, IFFF_READ))
 272                                     {
 273                                         D(bug("datatypes.library/ExamineLock: OpenIFF okay. Now calling ExamineData\n"));
 274
 275                                         cdt = ExamineData(DataTypesBase,
 276                                                           &dthc,
 277                                                           CheckArray,
 278                                                           CheckSize,
 279                                                           fib->fib_FileName,
 280                                                           fib->fib_Size);
 281
 282                                         D(bug("datatypes.library/ExamineLock: ExamineData() returned %x\n", cdt));
 283
 284                                         CloseIFF(iff);
 285
 286                                     } /* OpenIFF okay */
 287
 288                                     FreeIFF(iff); /* AROS BUG FIX: was dthc.dthc_IFF) */
 289
 290                                 } /* AllocIFF okay */
 291
 292                             } /* if (CheckSize = Read(... */
 293
 294                             FreeVec(CheckArray);
 295
 296                         } /* if (CheckArray = AllocVec(... */
 297
 298                         Close(file);
 299
 300                     } /* if file opened */
 301
 302                 } /* if I got the name from the lock */
 303
 304             } /* it is a file */
 305
 306         } /* it is not a directory */
 307
 308     } /* if(Examine(lock, fib)) */
 309
 310     ReleaseSemaphore(&getDTLIST->dtl_Lock);
 311
 312     return cdt;
 313 }
 314
 315
 316 struct CompoundDatatype *FindDtInList(struct Library *DataTypesBase,
 317                                       struct DTHookContext *dthc,
 318                                       struct List *list,
 319                                       UBYTE *CheckArray,
 320                                       UWORD CheckSize,
 321                                       UBYTE *Filename)
 322 {
 323     struct CompoundDatatype *cdt = NULL;
 324     BOOL                   found = FALSE;
 325
 326     if (list)
 327     {
 328         struct CompoundDatatype *cur;
 329
 330         for(cur = (struct CompoundDatatype *)list->lh_Head;
 331                 cur->DT.dtn_Node1.ln_Succ;
 332                 cur = (struct CompoundDatatype *)cur->DT.dtn_Node1.ln_Succ)
 333         {
 334             if(CheckSize >= cur->DTH.dth_MaskLen)
 335             {
 336                 WORD *msk = cur->DTH.dth_Mask;
 337                 UBYTE *cmp = CheckArray;
 338                 UWORD count;
 339
 340                 found=TRUE;
 341
 342                 for(count = cur->DTH.dth_MaskLen; count--; msk++, cmp++)
 343                 {
 344                     if(*msk>0)
 345                     {
 346                         if(cur->DTH.dth_Flags & DTF_CASE)
 347                         {
 348                             if (*msk != *cmp)
 349                             {
 350                                 found=FALSE;
 351                                 break;
 352                             }
 353                         }
 354                         else
 355                         {
 356                             if(*msk != *cmp &&
 357                                     *msk != ToUpper((ULONG)*cmp) &&
 358                                     *msk != ToLower((ULONG)*cmp))
 359                             {
 360                                 found=FALSE;
 361                                 break;
 362                             }
 363                         }
 364                     }
 365                 }
 366
 367                 if(found)
 368                 {
 369                     if((!(cur->FlagLong & CFLGF_PATTERN_UNUSED)) &&
 370                             cur->DTH.dth_Pattern)
 371                     {
 372                         if(cur->FlagLong & CFLGF_IS_WILD)
 373                         {
 374                             if(cur->ParsePatMem)
 375                             {
 376                                 if(!MatchPatternNoCase(cur->ParsePatMem,
 377                                             Filename))
 378                                 {
 379                                     found = FALSE;
 380                                 }
 381                             }
 382                         }
 383                         else
 384                         {
 385                             if(Stricmp(cur->DTH.dth_Pattern, Filename))
 386                             {
 387                                 found = FALSE;
 388                             }
 389                         }
 390                     }
 391
 392                     if(found)
 393                     {
 394                         if(cur->Function)
 395                         {
 396                             found = (cur->Function)(dthc);
 397
 398                             if (dthc->dthc_IFF)
 399                             {
 400                                 CloseIFF(dthc->dthc_IFF);
 401                                 OpenIFF(dthc->dthc_IFF, IFFF_READ);
 402                             }
 403                             else
 404                             {
 405                                 Seek(dthc->dthc_FileHandle, 0,
 406                                         OFFSET_BEGINNING);
 407                             }
 408                         }
 409                     }
 410                 }
 411             }
 412             if(found)
 413             {
 414                 cdt = cur;
 415                 break;
 416             }
 417         }
 418     }
 419     return cdt;
 420 }
 421
 422
 423 struct CompoundDatatype *ExamineData(struct Library *DataTypesBase,
 424                                      struct DTHookContext *dthc,
 425                                      UBYTE *CheckArray, UWORD CheckSize,
 426                                      UBYTE *Filename, ULONG Size)
 427 {
 428     struct CompoundDatatype *cdt = NULL;
 429     struct CompoundDatatype *cdt_bin = NULL;
 430     struct CompoundDatatype *cdt_asc = NULL;
 431
 432     UWORD        type;
 433     struct List *list  = NULL;
 434
 435     ULONG IFF_ID   = AROS_BE2LONG(*((ULONG*)CheckArray));
 436     ULONG IFF_Size = AROS_BE2LONG(*((ULONG*)(CheckArray+4)));
 437
 438     if(((!dthc->dthc_FileHandle) && (dthc->dthc_IFF)) ||
 439             (((Size*3/4 < IFF_Size) && (Size*4/3 > IFF_Size)) &&
 440              (IFF_ID==ID_FORM || IFF_ID==ID_CAT || IFF_ID==ID_LIST)) )
 441     {
 442         type = DTF_IFF;
 443         cdt = FindDtInList(DataTypesBase, dthc, &getDTLIST->dtl_IFFList, CheckArray, CheckSize, Filename);
 444     }
 445     else
 446     {
 447         UBYTE *ptr;
 448         UWORD count;
 449         UWORD ascii;
 450
 451         dthc->dthc_IFF = NULL;
 452
 453         for (ptr=CheckArray,count=CheckSize,ascii=0 ; count-- ; ptr++)
 454         {
 455             if (ASCIITable[*ptr])
 456                 ascii++;
 457             else
 458             {
 459                 if (BinaryTable[*ptr])
 460                 {
 461                     ascii=0;
 462                     break;
 463                 }
 464             }
 465         }
 466
 467         if (ascii > CheckSize*3/4)
 468         {
 469             type = DTF_ASCII;
 470             cdt_asc = FindDtInList(DataTypesBase, dthc, &getDTLIST->dtl_ASCIIList, CheckArray, CheckSize, Filename);
 471             cdt = cdt_asc;
 472             /* if the found datatype is 'only' ascii we have to look additionally in the binary list */
 473             if (cdt_asc && !strcmp(cdt_asc->DTH.dth_Name, "ascii"))
 474             {
 475                 cdt_bin = FindDtInList(DataTypesBase, dthc, &getDTLIST->dtl_BinaryList, CheckArray, CheckSize, Filename);
 476                 /* if we find in the binary list something which is better than just 'binary' we use it */
 477                 if (cdt_bin && strcmp(cdt_bin->DTH.dth_Name, "binary"))
 478                 {
 479                     cdt = cdt_bin;
 480                 }
 481             }
 482         }
 483         else
 484         {
 485             type = DTF_BINARY;
 486             cdt = FindDtInList(DataTypesBase, dthc, &getDTLIST->dtl_BinaryList, CheckArray, CheckSize, Filename);
 487         }
 488     }
 489
 490     if(!cdt)
 491     {
 492         switch(type)
 493         {
 494             case DTF_BINARY:
 495                 cdt = (struct CompoundDatatype *)FindNameNoCase(DataTypesBase, list,
 496                         "binary");
 497                 break;
 498
 499             case DTF_ASCII:
 500                 cdt = (struct CompoundDatatype *)FindNameNoCase(DataTypesBase, list,
 501                         "ascii");
 502                 break;
 503
 504             case DTF_IFF:
 505                 cdt = (struct CompoundDatatype *)FindNameNoCase(DataTypesBase, list,
 506                         "iff");
 507                 break;
 508         }
 509     }
 510     return cdt;
 511 }
 512
 513
 514 #undef getDTLIST
 515
 516
 517 /* Putchar procedure needed by RawDoFmt() */
 518
 519 AROS_UFH2(void, putchr,
 520     AROS_UFHA(UBYTE,    chr, D0),
 521     AROS_UFHA(STRPTR *, p,   A3))
 522 {
 523     AROS_USERFUNC_INIT
 524     *(*p)++=chr;
 525     AROS_USERFUNC_EXIT
 526 }
 527
 528
 529 #warning these work only with stack growing downwards and should therefore be fixed to use macros in utility/tagitem.h
 530
 531 #define AROS_TAGRETURNTYPE ULONG
 532 ULONG setattrs(struct Library *DataTypesBase, Object *object, Tag firstTag,...)
 533 {
 534     AROS_SLOWSTACKTAGS_PRE(firstTag)
 535     retval = SetAttrsA(object, (struct TagItem *)&firstTag);
 536     AROS_SLOWSTACKTAGS_POST
 537 }
 538 #undef  AROS_TAGRETURNTYPE
 539
 540 #define AROS_TAGRETURNTYPE ULONG
 541 ULONG Do_OM_NOTIFY(struct Library *DataTypesBase, Object *object,
 542                    struct GadgetInfo *ginfo, ULONG flags, Tag firstTag,...)
 543 {
 544 /*    struct opUpdate opu;
 545
 546     opu.MethodID = OM_NOTIFY;
 547     opu.opu_AttrList = (struct TagItem *)&firstTag;
 548     opu.opu_GInfo = ginfo;
 549     opu.opu_Flags = flags;
 550
 551     return DoMethodA(object, (Msg)&opu); */
 552
 553     AROS_SLOWSTACKTAGS_PRE(firstTag)
 554     retval = DoMethod(object, OM_NOTIFY, AROS_SLOWSTACKTAGS_ARG(firstTag), ginfo, flags);
 555     AROS_SLOWSTACKTAGS_POST
 556 }
 557 #undef  AROS_TAGRETURNTYPE
 558
 559
 560 #define AROS_TAGRETURNTYPE ULONG
 561 ULONG DoGad_OM_NOTIFY(struct Library *DataTypesBase, Object *object,
 562                       struct Window *win, struct Requester *req,
 563                       ULONG flags, Tag firstTag, ...)
 564 {
 565 //    return(dogadgetmethod(DataTypesBase, (struct Gadget*)object, win, req, OM_NOTIFY,
 566 //                        &firstTag, NULL, flags));
 567     AROS_SLOWSTACKTAGS_PRE(firstTag)
 568     retval = DoGadgetMethod((struct Gadget*)object, win, req, OM_NOTIFY, AROS_SLOWSTACKTAGS_ARG(firstTag), NULL, flags);
 569     AROS_SLOWSTACKTAGS_POST
 570 }
 571 #undef  AROS_TAGRETURNTYPE
 572
 573
 574 //ULONG dogadgetmethod(struct Library *DataTypesBase, struct Gadget *gad,
 575 //                   struct Window *win, struct Requester *req,
 576 //                   ULONG MethodID, ...)
 577 //{
 578 //    return(DoGadgetMethodA(gad, win, req, (Msg)&MethodID));
 579 //}
 580
 581 #define AROS_TAGRETURNTYPE struct Catalog *
 582 struct Catalog *opencatalog(struct Library *DataTypesBase, struct Locale *locale,
 583                             STRPTR name, Tag firstTag, ...)
 584 {
 585 //    return(OpenCatalogA(locale, name, (struct TagItem *)&firstTag));
 586     AROS_SLOWSTACKTAGS_PRE(firstTag)
 587     retval = OpenCatalogA(locale, name, AROS_SLOWSTACKTAGS_ARG(firstTag));
 588     AROS_SLOWSTACKTAGS_POST
 589 }
 590 #undef  AROS_TAGRETURNTYPE