workbench/libs/locale/opencataloga.c

   1 /*
   2     Copyright © 1995-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5 #define AROS_ALMOST_COMPATIBLE
   6
   7 #include <exec/types.h>
   8 #include <exec/memory.h>
   9 #include <exec/lists.h>
  10 #include <proto/exec.h>
  11 #include <proto/dos.h>
  12 #include <libraries/iffparse.h>
  13 #include <proto/iffparse.h>
  14 #include <proto/utility.h>
  15 #include <string.h>
  16 #include "locale_intern.h"
  17
  18 #include <aros/debug.h>
  19
  20 #define DEBUG_OPENCATALOG(x)    ;
  21
  22 struct header
  23 {
  24     unsigned char id[4];
  25     unsigned char len[4];
  26 };
  27
  28 /*****************************************************************************
  29
  30     NAME */
  31 #include <proto/locale.h>
  32
  33         AROS_LH3(struct Catalog *, OpenCatalogA,
  34
  35 /*  SYNOPSIS */
  36         AROS_LHA(struct Locale  *, locale, A0),
  37         AROS_LHA(STRPTR          , name, A1),
  38         AROS_LHA(struct TagItem *, tags, A2),
  39
  40 /*  LOCATION */
  41         struct LocaleBase *, LocaleBase, 25, Locale)
  42
  43 /*  FUNCTION
  44
  45     INPUTS
  46
  47     RESULT
  48
  49     NOTES
  50
  51     EXAMPLE
  52
  53     BUGS
  54
  55     SEE ALSO
  56
  57     INTERNALS
  58
  59     HISTORY
  60         27-11-96    digulla automatically created from
  61                             locale_lib.fd and clib/locale_protos.h
  62
  63 *****************************************************************************/
  64 {
  65     AROS_LIBFUNC_INIT
  66
  67     struct Locale       * def_locale = NULL;
  68     struct IntCatalog   * catalog = NULL;
  69     char                * language;
  70     char                * app_language;
  71     char                * specific_language;
  72     struct Process      * MyProcess;
  73 #define FILENAMESIZE 256
  74
  75     char                  filename[FILENAMESIZE];
  76     char                  buf[100];
  77     LONG                  chars;
  78     ULONG                 version;
  79     ULONG                         catversion,catrevision;
  80     WORD                  pref_language;
  81     UWORD                 i;
  82
  83     DEBUG_OPENCATALOG(dprintf("OpenCatalogA: locale 0x%lx name <%s> Tags 0x%lx localebase 0x%lx\n",
  84                                 locale,
  85                                 name,
  86                                 tags,
  87                                 LocaleBase));
  88
  89     SetIoErr(0);
  90
  91     if (!locale)
  92     {
  93         DEBUG_OPENCATALOG(dprintf("OpenCatalogA: no locale\n"));
  94         locale = def_locale = OpenLocale(NULL);
  95         DEBUG_OPENCATALOG(dprintf("OpenCatalogA: def_locale 0x%lx\n",
  96                                 def_locale));
  97     }
  98
  99     if (!locale)
 100     {
 101         DEBUG_OPENCATALOG(dprintf("OpenCatalogA: nolocale..done\n"));
 102         return NULL;
 103     }
 104
 105     MyProcess=(struct Process *)FindTask(NULL);
 106
 107     specific_language = (char *)GetTagData(OC_Language, (IPTR)0, tags);
 108
 109     DEBUG_OPENCATALOG(dprintf("OpenCatalogA: specific lang 0x%lx\n",specific_language));
 110     if (specific_language)
 111     {
 112         language = specific_language;
 113         pref_language = -1;
 114         DEBUG_OPENCATALOG(dprintf("OpenCatalogA: language 0x%lx\n",language));
 115     }
 116     else
 117     {
 118         language = locale->loc_PrefLanguages[0];
 119         pref_language = 0;
 120         DEBUG_OPENCATALOG(dprintf("OpenCatalogA: language 0x%lx\n",language));
 121     }
 122
 123     if (language == NULL)
 124     {
 125         if (def_locale) CloseLocale(def_locale);
 126         DEBUG_OPENCATALOG(dprintf("OpenCatalogA: nolanguage..done\n"));
 127         return NULL;
 128     }
 129
 130     /*
 131     ** Check whether the built in language of the application matches
 132     ** the language of the default locale. If it matches, then I
 133     ** don't need to load anything.
 134     */
 135
 136     app_language = "english";
 137     app_language = (char *)GetTagData(OC_BuiltInLanguage,
 138                                       (IPTR)app_language,
 139                                       tags);
 140
 141     DEBUG_OPENCATALOG(dprintf("OpenCatalogA: app_language 0x%lx\n",
 142                                 app_language));
 143
 144     if (NULL != app_language && 0 == strcmp(app_language, language))
 145     {
 146         if (def_locale) CloseLocale(def_locale);
 147         DEBUG_OPENCATALOG(dprintf("OpenCatalogA: failure..done\n"));
 148         return NULL;
 149     }
 150
 151     version = GetTagData(OC_Version,
 152                          0,
 153                          tags);
 154
 155     DEBUG_OPENCATALOG(dprintf("OpenCatalogA: version %ld\n",version));
 156
 157     if (NULL != name)
 158     {
 159         struct IFFHandle * iff = NULL;
 160
 161         /*
 162         ** The wanted catalog might be in the list of catalogs that are
 163         ** already loaded. So check that list first.
 164         */
 165
 166         DEBUG_OPENCATALOG(dprintf("OpenCatalogA: CatalogLock 0x%lx\n",
 167                                         &IntLB(LocaleBase)->lb_CatalogLock));
 168
 169         ObtainSemaphore(&IntLB(LocaleBase)->lb_CatalogLock);
 170
 171         DEBUG_OPENCATALOG(dprintf("OpenCatalogA: search cached Catalog\n"));
 172
 173         ForeachNode(&IntLB(LocaleBase)->lb_CatalogList, catalog)
 174         {
 175             if (catalog->ic_Name &&
 176                 0 == strcmp(catalog->ic_Name, name) &&
 177                 catalog->ic_Catalog.cat_Language &&
 178                 0 == strcmp(catalog->ic_Catalog.cat_Language, language))
 179             {
 180                 DEBUG_OPENCATALOG(dprintf("OpenCatalogA: found Catalog 0x%lx\n",catalog));
 181                 catalog->ic_UseCount++;
 182                 ReleaseSemaphore(&IntLB(LocaleBase)->lb_CatalogLock);
 183
 184                 if (def_locale)
 185                 {
 186                     CloseLocale(def_locale);
 187                 }
 188
 189                 SetIoErr(ERROR_ACTION_NOT_KNOWN);
 190
 191                 DEBUG_OPENCATALOG(dprintf("OpenCatalogA: return Catalog 0x%lx\n",catalog));
 192                 return (struct Catalog *)catalog;
 193             }
 194         }
 195         DEBUG_OPENCATALOG(dprintf("OpenCatalogA: found none\n"));
 196
 197         ReleaseSemaphore(&IntLB(LocaleBase)->lb_CatalogLock);
 198
 199
 200         /* Clear error condition before we start. */
 201         SetIoErr(0);
 202
 203         iff = AllocIFF();
 204
 205         DEBUG_OPENCATALOG(dprintf("OpenCatalogA: iff 0x%lx\n",iff));
 206         if (NULL == iff)
 207         {
 208             if (def_locale) CloseLocale(def_locale);
 209             SetIoErr(ERROR_NO_FREE_STORE);
 210
 211             return NULL;
 212         }
 213
 214         DEBUG_OPENCATALOG(dprintf("OpenCatalogA: pref_language %ld language 0x%lx\n",
 215                                 pref_language,
 216                                 language));
 217
 218         while ((pref_language < 10) && language)
 219         {
 220             if (app_language && (strcmp(language, app_language) == 0))
 221             {
 222                 FreeIFF(iff);
 223                 if (def_locale) CloseLocale(def_locale);
 224                 SetIoErr(0);
 225                 return NULL;
 226             }
 227
 228             if ((MyProcess->pr_HomeDir) != NULL)
 229             {
 230                 DEBUG_OPENCATALOG(dprintf("OpenCatalogA: HomeDir !=NULL..try progdir\n"));
 231                 strcpy(filename, "PROGDIR:Catalogs");
 232                 DEBUG_OPENCATALOG(dprintf("OpenCatalogA: filename <%s>\n",filename));
 233                 AddPart(filename, language, FILENAMESIZE);
 234                 DEBUG_OPENCATALOG(dprintf("OpenCatalogA: filename <%s>\n",filename));
 235                 AddPart(filename, name    , FILENAMESIZE);
 236
 237                 DEBUG_OPENCATALOG(dprintf("OpenCatalogA: filename <%s>\n",filename));
 238                 iff->iff_Stream = (IPTR)Open(filename, MODE_OLDFILE);
 239                 DEBUG_OPENCATALOG(dprintf("OpenCatalogA: iffstream 0x%lx\n",
 240                                         iff->iff_Stream));
 241             }
 242             if (iff->iff_Stream) break;
 243
 244 #ifdef __MORPHOS__
 245             strcpy(filename, "MOSSYS:LOCALE/Catalogs");
 246
 247             DEBUG_OPENCATALOG(dprintf("OpenCatalogA: filename <%s>\n",filename));
 248             AddPart(filename, language, FILENAMESIZE);
 249             DEBUG_OPENCATALOG(dprintf("OpenCatalogA: filename <%s>\n",filename));
 250             AddPart(filename, name    , FILENAMESIZE);
 251
 252             DEBUG_OPENCATALOG(dprintf("OpenCatalogA: try filename <%s>\n",filename));
 253
 254             {   APTR oldwinptr=MyProcess->pr_WindowPtr;
 255                 MyProcess->pr_WindowPtr=(APTR)-1;
 256                 iff->iff_Stream = (IPTR)Open(filename, MODE_OLDFILE);
 257                 MyProcess->pr_WindowPtr=oldwinptr;
 258             }
 259
 260             if (iff->iff_Stream) break;
 261 #endif
 262             strcpy(filename, "LOCALE:Catalogs");
 263
 264             DEBUG_OPENCATALOG(dprintf("OpenCatalogA: filename <%s>\n",filename));
 265             AddPart(filename, language, FILENAMESIZE);
 266             DEBUG_OPENCATALOG(dprintf("OpenCatalogA: filename <%s>\n",filename));
 267             AddPart(filename, name    , FILENAMESIZE);
 268
 269             DEBUG_OPENCATALOG(dprintf("OpenCatalogA: try filename <%s>\n",filename));
 270
 271             iff->iff_Stream = (IPTR)Open(filename, MODE_OLDFILE);
 272             if (iff->iff_Stream) break;
 273
 274             pref_language++;
 275             language = locale->loc_PrefLanguages[pref_language];
 276         }
 277
 278         DEBUG_OPENCATALOG(dprintf("OpenCatalogA: language 0x%lx\n",language));
 279
 280         /* I no longer need the locale. So close it if we opened it */
 281
 282         if (def_locale)
 283         {
 284             CloseLocale(def_locale);
 285             def_locale = NULL;
 286         }
 287
 288 #undef FILENAMESIZE
 289
 290         if (iff->iff_Stream == 0)
 291         {
 292             DEBUG_OPENCATALOG(dprintf("OpenCatalogA: end..nostream\n"));
 293             FreeIFF(iff);
 294             SetIoErr(ERROR_OBJECT_NOT_FOUND);
 295             return NULL;
 296         }
 297
 298         DEBUG_OPENCATALOG(dprintf("OpenCatalogA: catalog name <%s>\n",name));
 299         catalog = AllocVec(sizeof(struct IntCatalog) + strlen(name) + 1, MEMF_CLEAR | MEMF_PUBLIC);
 300         DEBUG_OPENCATALOG(dprintf("OpenCatalogA: catalog 0x%lx\n",catalog));
 301         if (NULL == catalog)
 302         {
 303             DEBUG_OPENCATALOG(dprintf("OpenCatalogA: end..no catalog\n"));
 304             Close((BPTR)iff->iff_Stream);
 305             FreeIFF(iff);
 306             SetIoErr(ERROR_NO_FREE_STORE);
 307             return NULL;
 308         }
 309
 310         catalog->ic_UseCount = 1;
 311         catalog->ic_Catalog.cat_Language = catalog->ic_LanguageName;
 312         strcpy(catalog->ic_Name, name);
 313
 314         InitIFFasDOS(iff);
 315
 316         if (!OpenIFF(iff, IFFF_READ))
 317         {
 318             while (1)
 319             {
 320                 LONG error = ParseIFF(iff, IFFPARSE_STEP);
 321
 322                 if (IFFERR_EOF == error)
 323                 {
 324                     DEBUG_OPENCATALOG(dprintf("OpenCatalogA: parsed catalog\n"));
 325                     /* Did everything go fine? */
 326
 327                     if (!(catalog->ic_LanguageName[0]))
 328                     {
 329                         /* No ID_LANG chunk found. So setup languagename ourselves.
 330                            Hmm ... maybe this should be done anyway always. Because
 331                            if the catalog file *does* contain an ID_LANG chunk then
 332                            this should be the same as "language" anyway. And if it
 333                            is not, then maybe OpenCatalogA() should fail :-\ */
 334
 335                         strcpy(catalog->ic_LanguageName, language);
 336                     }
 337
 338                     /* Connect this catalog to the list of catalogs */
 339                     ObtainSemaphore (&IntLB(LocaleBase)->lb_CatalogLock);
 340                     AddHead((struct List *)&IntLB(LocaleBase)->lb_CatalogList,
 341                             &catalog->ic_Catalog.cat_Link);
 342                     ReleaseSemaphore(&IntLB(LocaleBase)->lb_CatalogLock);
 343
 344                     CloseIFF(iff);
 345                     Close((BPTR)iff->iff_Stream);
 346                     FreeIFF(iff);
 347
 348                     DEBUG_OPENCATALOG(dprintf("OpenCatalogA: return catalog 0x%lx\n",catalog));
 349
 350                     return &catalog->ic_Catalog;
 351                 }
 352
 353                 if (IFFERR_EOC == error) /* end of chunk */
 354                     continue;
 355
 356                 if (0 == error)
 357                 {
 358                     struct ContextNode * top = CurrentChunk(iff);
 359
 360                     switch (top->cn_ID)
 361                     {
 362                         case ID_FORM:
 363                             break;
 364
 365                         case ID_FVER:
 366
 367                             if (top->cn_Size > 100) break; /*max 100 bytes*/
 368
 369                             error = ReadChunkBytes(iff, buf, top->cn_Size);
 370                             if (error == top->cn_Size)
 371                             {
 372                                 error = 0;
 373                             }
 374                             else
 375                             {
 376                                 break;
 377                             }
 378
 379                 buf[99] = 0;
 380
 381                 /*Ok now we want to get the version and the revision.
 382                 They are separated by a blank space*/
 383
 384                                 i = 0;
 385                 while (buf[i] && (buf[i] != ' '))
 386                 i++;
 387                 while (buf[i] && (buf[i] == ' '))
 388                 i++;
 389                 while (buf[i] && (buf[i] != ' '))
 390                 i++;
 391
 392                 if (buf[i])
 393                 {
 394                         if ((chars = StrToLong(&buf[i],(LONG *)&catversion)) < 0)
 395                                 break;
 396
 397                         i += chars;
 398                         if (buf[i++])
 399                         {
 400                                 if (StrToLong(&buf[i],(LONG *)&catrevision) < 0)
 401                         break;
 402                                 }
 403
 404                         catalog->ic_Catalog.cat_Version  = catversion;
 405                         catalog->ic_Catalog.cat_Revision = catrevision;
 406
 407                         if (version && (catversion != version))
 408                         {
 409                                 error = RETURN_ERROR;
 410                         }
 411
 412                         break;
 413                 }
 414
 415
 416                         case ID_LANG:
 417                             /* The IntCatalog structure has only 30 bytes reserved for
 418                                the language name. So make sure the chunk is not bigger. */
 419
 420                             if (top->cn_Size > 30) break;
 421
 422                             error = ReadChunkBytes(iff, catalog->ic_LanguageName, top->cn_Size);
 423                             if (error == top->cn_Size)
 424                             {
 425                                 error = 0;
 426                             }
 427                             break;
 428
 429                         case ID_CSET:
 430                             if (top->cn_Size != sizeof(struct CodeSet)) break;
 431                             if (top->cn_Size == ReadChunkBytes(iff,
 432                                                                &catalog->ic_CodeSet,
 433                                                                top->cn_Size))
 434                             {
 435                                 /* Who cares: codeset is not used at the moment */
 436                             }
 437                             break;
 438
 439                         case ID_STRS:
 440                             if (!(catalog->ic_StringChunk = AllocVec(top->cn_Size, MEMF_PUBLIC | MEMF_CLEAR)))
 441                             {
 442                                 error = ERROR_NO_FREE_STORE;
 443                                 SetIoErr(error);
 444                                 break;
 445                             }
 446
 447                             error = ReadChunkBytes(iff, catalog->ic_StringChunk, top->cn_Size);
 448                             if (error == top->cn_Size)
 449                             {
 450                                 error = 0;
 451                             }
 452                             else
 453                             {
 454                                 break;
 455                             }
 456
 457                             /* Count the number of strings */
 458
 459                             {
 460                                 UBYTE *buffer = catalog->ic_StringChunk;
 461                                 LONG   c = 0, strlen;
 462
 463                                 catalog->ic_NumStrings = 0;
 464
 465                                 while(c < top->cn_Size)
 466                                 {
 467                                     catalog->ic_NumStrings++;
 468
 469                                     strlen = (buffer[4] << 24) +
 470                                              (buffer[5] << 16) +
 471                                              (buffer[6] << 8) +
 472                                              (buffer[7]);
 473
 474                                     strlen  = 8 + strlen + (strlen & 1);
 475                                     if (strlen & 3) strlen += 4 - (strlen & 3);
 476
 477                                     c += strlen; buffer += strlen;
 478                                 }
 479
 480                             }
 481
 482                             if (catalog->ic_NumStrings == 0) break; /* Paranoia? */
 483
 484                             if (!(catalog->ic_CatStrings = AllocVec(catalog->ic_NumStrings * sizeof(struct CatStr), MEMF_PUBLIC | MEMF_CLEAR)))
 485                             {
 486                                 error = ERROR_NO_FREE_STORE;
 487                                 SetIoErr(error);
 488                                 break;
 489                             }
 490
 491                             /* Fill out catalog->ic_CatStrings array */
 492
 493                             {
 494                                 UBYTE *buffer = catalog->ic_StringChunk;
 495                                 ULONG i, strlen, id, previd = 0;
 496                                 BOOL  inorder = TRUE;
 497
 498                                 for(i = 0; i < catalog->ic_NumStrings; i++)
 499                                 {
 500                                     id = (buffer[0] << 24) +
 501                                          (buffer[1] << 16) +
 502                                          (buffer[2] << 8) +
 503                                          (buffer[3]);
 504
 505                                     strlen = (buffer[4] << 24) +
 506                                              (buffer[5] << 16) +
 507                                              (buffer[6] << 8) +
 508                                              (buffer[7]);
 509
 510                                     catalog->ic_CatStrings[i].cs_String = &buffer[8];
 511                                     catalog->ic_CatStrings[i].cs_Id = id;
 512
 513                                     //kprintf("Catalog String #%d id=%d string=\"%s\"\n", i, id, catalog->ic_CatStrings[i].cs_String);
 514
 515                                     strlen  = 8 + strlen + (strlen & 1);
 516                                     if (strlen & 3) strlen += 4 - (strlen & 3);
 517
 518                                     if (id < previd) inorder = FALSE;
 519
 520                                     buffer += strlen;
 521                                     previd = id;
 522                                 }
 523
 524                                 if (inorder) catalog->ic_Flags |= ICF_INORDER;
 525                             }
 526                             break;
 527
 528                     } /* switch (top->cn_ID) */
 529
 530                 } /* if (0 == error) */
 531
 532                 if (error)
 533                 {
 534                     dispose_catalog(catalog, LocaleBase);
 535                     /*
 536                     ** An error with the file occurred
 537                     */
 538                     break;
 539                 }
 540
 541             } /* while (1) */
 542
 543             CloseIFF(iff);
 544
 545         } /* if (!OpenIFF(iff, IFFF_READ)) */
 546
 547
 548         Close((BPTR)iff->iff_Stream);
 549         FreeIFF(iff);
 550         FreeVec(catalog);
 551
 552     } /* if (NULL != name) */
 553
 554     if (def_locale) CloseLocale(def_locale);
 555
 556     DEBUG_OPENCATALOG(dprintf("OpenCatalogA: catalog not loaded\n"));
 557     return NULL;
 558
 559     AROS_LIBFUNC_EXIT
 560
 561 } /* OpenCatalogA */
 562