workbench/libs/datatypes/helpfuncs.c

   1 /*
   2     Copyright © 1995-2012, 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 = BNULL;
 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 (!(cur->DTH.dth_MaskLen) && (cur->Function))
 335             {
 336                 found = (cur->Function)(dthc);
 337             }
 338             else if(CheckSize >= cur->DTH.dth_MaskLen)
 339             {
 340                 WORD *msk = cur->DTH.dth_Mask;
 341                 UBYTE *cmp = CheckArray;
 342                 UWORD count;
 343
 344                 found=TRUE;
 345
 346                 for(count = cur->DTH.dth_MaskLen; count--; msk++, cmp++)
 347                 {
 348                     if(*msk >= 0)
 349                     {
 350                         if(cur->DTH.dth_Flags & DTF_CASE)
 351                         {
 352                             if (*msk != *cmp)
 353                             {
 354                                 found=FALSE;
 355                                 break;
 356                             }
 357                         }
 358                         else
 359                         {
 360                             if(*msk != *cmp &&
 361                                     *msk != ToUpper((ULONG)*cmp) &&
 362                                     *msk != ToLower((ULONG)*cmp))
 363                             {
 364                                 found=FALSE;
 365                                 break;
 366                             }
 367                         }
 368                     }
 369                 }
 370
 371                 if(found)
 372                 {
 373                     if((!(cur->FlagLong & CFLGF_PATTERN_UNUSED)) &&
 374                             cur->DTH.dth_Pattern)
 375                     {
 376                         if(cur->FlagLong & CFLGF_IS_WILD)
 377                         {
 378                             if(cur->ParsePatMem)
 379                             {
 380                                 if(!MatchPatternNoCase(cur->ParsePatMem,
 381                                             Filename))
 382                                 {
 383                                     found = FALSE;
 384                                 }
 385                             }
 386                         }
 387                         else
 388                         {
 389                             if(Stricmp(cur->DTH.dth_Pattern, Filename))
 390                             {
 391                                 found = FALSE;
 392                             }
 393                         }
 394                     }
 395
 396                     if(found)
 397                     {
 398                         if(cur->Function)
 399                         {
 400                             found = (cur->Function)(dthc);
 401
 402                             if (dthc->dthc_IFF)
 403                             {
 404                                 CloseIFF(dthc->dthc_IFF);
 405                                 OpenIFF(dthc->dthc_IFF, IFFF_READ);
 406                             }
 407                             else
 408                             {
 409                                 Seek(dthc->dthc_FileHandle, 0,
 410                                         OFFSET_BEGINNING);
 411                             }
 412                         }
 413                     }
 414                 }
 415             }
 416             if(found)
 417             {
 418                 cdt = cur;
 419                 break;
 420             }
 421         }
 422     }
 423     return cdt;
 424 }
 425
 426
 427 struct CompoundDataType *ExamineData(struct Library *DataTypesBase,
 428                                      struct DTHookContext *dthc,
 429                                      UBYTE *CheckArray, UWORD CheckSize,
 430                                      UBYTE *Filename, ULONG Size)
 431 {
 432     struct CompoundDataType *cdt = NULL;
 433     struct CompoundDataType *cdt_bin = NULL;
 434     struct CompoundDataType *cdt_asc = NULL;
 435
 436     D(UWORD        type);
 437
 438     ULONG IFF_ID   = AROS_BE2LONG(*((ULONG*)CheckArray));
 439     ULONG IFF_Size = AROS_BE2LONG(*((ULONG*)(CheckArray+4)));
 440
 441     if(((!dthc->dthc_FileHandle) && (dthc->dthc_IFF)) ||
 442         (((IFF_Size + 8 == Size) && (Size > 21)) &&
 443         (IFF_ID==ID_FORM || IFF_ID==ID_CAT || IFF_ID==ID_LIST)) )
 444     {
 445         D(bug("[ExamineData] IFF detected\n"));
 446         D(type = DTF_IFF);
 447         cdt = FindDtInList(DataTypesBase, dthc, &getDTLIST->dtl_IFFList, CheckArray, CheckSize, Filename);
 448     }
 449     else
 450     {
 451         UBYTE *ptr;
 452         UWORD count;
 453         UWORD ascii;
 454
 455         dthc->dthc_IFF = NULL;
 456
 457         for (ptr=CheckArray,count=CheckSize,ascii=0 ; count-- ; ptr++)
 458         {
 459             if (ASCIITable[*ptr])
 460                 ascii++;
 461             else
 462             {
 463                 if (BinaryTable[*ptr])
 464                 {
 465                     ascii=0;
 466                     break;
 467                 }
 468             }
 469         }
 470
 471         D(bug("[ExamineData] ASCII characters: %u of %u\n", ascii, CheckSize));
 472         if (ascii > CheckSize*3/4)
 473         {
 474             D(bug("[ExamineData] Recognized as ASCII\n"));
 475             D(type = DTF_ASCII);
 476             cdt_asc = FindDtInList(DataTypesBase, dthc, &getDTLIST->dtl_ASCIIList, CheckArray, CheckSize, Filename);
 477             D(bug("[ExamineData] ASCII datatype: 0x%p\n", cdt_asc));
 478             cdt = cdt_asc;
 479             /* if the found datatype is 'only' ascii we have to look additionally in the binary list */
 480             if (cdt_asc && !strcmp(cdt_asc->DTH.dth_Name, "ascii"))
 481             {
 482                 D(bug("[ExamineData] Trying binary list\n"));
 483                 cdt_bin = FindDtInList(DataTypesBase, dthc, &getDTLIST->dtl_BinaryList, CheckArray, CheckSize, Filename);
 484                 D(bug("[[ExamineData] Binary datatype: 0x%p\n"));
 485                 /* if we find in the binary list something which is better than just 'binary' we use it */
 486                 if (cdt_bin && strcmp(cdt_bin->DTH.dth_Name, "binary"))
 487                 {
 488                     cdt = cdt_bin;
 489                 }
 490             }
 491         }
 492         else
 493         {
 494             D(bug("[ExamineData] Recognized as binary\n"));
 495             D(type = DTF_BINARY);
 496             cdt = FindDtInList(DataTypesBase, dthc, &getDTLIST->dtl_BinaryList, CheckArray, CheckSize, Filename);
 497         }
 498     }
 499
 500     D(bug("[ExamineData] Found datatype 0x%p, type 0x%u\n", cdt, type));
 501     return cdt;
 502 }
 503
 504
 505 #undef getDTLIST
 506
 507
 508 /* Putchar procedure needed by RawDoFmt() */
 509
 510 AROS_UFH2(void, putchr,
 511     AROS_UFHA(UBYTE,    chr, D0),
 512     AROS_UFHA(STRPTR *, p,   A3))
 513 {
 514     AROS_USERFUNC_INIT
 515     *(*p)++=chr;
 516     AROS_USERFUNC_EXIT
 517 }
 518
 519
 520 /* FIXME: these work only with stack growing downwards and should therefore be fixed to use macros in utility/tagitem.h */
 521
 522 ULONG setattrs(struct Library *DataTypesBase, Object *object, Tag firstTag,...)
 523 {
 524     AROS_SLOWSTACKTAGS_PRE_AS(firstTag, ULONG)
 525     retval = SetAttrsA(object, (struct TagItem *)&firstTag);
 526     AROS_SLOWSTACKTAGS_POST
 527 }
 528
 529 ULONG Do_OM_NOTIFY(struct Library *DataTypesBase, Object *object,
 530                    struct GadgetInfo *ginfo, ULONG flags, Tag firstTag,...)
 531 {
 532 /*    struct opUpdate opu;
 533
 534     opu.MethodID = OM_NOTIFY;
 535     opu.opu_AttrList = (struct TagItem *)&firstTag;
 536     opu.opu_GInfo = ginfo;
 537     opu.opu_Flags = flags;
 538
 539     return DoMethodA(object, (Msg)&opu); */
 540
 541     AROS_SLOWSTACKTAGS_PRE_AS(firstTag, ULONG)
 542     retval = DoMethod(object, OM_NOTIFY, (IPTR)AROS_SLOWSTACKTAGS_ARG(firstTag), (IPTR)ginfo, (IPTR)flags);
 543     AROS_SLOWSTACKTAGS_POST
 544 }
 545
 546
 547 ULONG DoGad_OM_NOTIFY(struct Library *DataTypesBase, Object *object,
 548                       struct Window *win, struct Requester *req,
 549                       ULONG flags, Tag firstTag, ...)
 550 {
 551 //    return(dogadgetmethod(DataTypesBase, (struct Gadget*)object, win, req, OM_NOTIFY,
 552 //                        &firstTag, NULL, flags));
 553     AROS_SLOWSTACKTAGS_PRE_AS(firstTag, ULONG)
 554     retval = DoGadgetMethod((struct Gadget*)object, win, req, OM_NOTIFY, AROS_SLOWSTACKTAGS_ARG(firstTag), NULL, flags);
 555     AROS_SLOWSTACKTAGS_POST
 556 }
 557
 558
 559 //ULONG dogadgetmethod(struct Library *DataTypesBase, struct Gadget *gad,
 560 //                   struct Window *win, struct Requester *req,
 561 //                   ULONG MethodID, ...)
 562 //{
 563 //    return(DoGadgetMethodA(gad, win, req, (Msg)&MethodID));
 564 //}
 565
 566 struct Catalog *opencatalog(struct Library *DataTypesBase, struct Locale *locale,
 567                             STRPTR name, Tag firstTag, ...)
 568 {
 569 //    return(OpenCatalogA(locale, name, (struct TagItem *)&firstTag));
 570     AROS_SLOWSTACKTAGS_PRE_AS(firstTag, struct Catalog *)
 571     retval = OpenCatalogA(locale, name, AROS_SLOWSTACKTAGS_ARG(firstTag));
 572     AROS_SLOWSTACKTAGS_POST
 573 }