home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 5 / FreshFish_July-August1994.bin / bbs / dev / flexcat-1.2.lha / FlexCat / C_c_V20.sd < prev    next >
Text File  |  1994-03-11  |  6KB  |  222 lines
  1. ##stringtype C
  2. ##shortstrings
  3. /****************************************************************
  4.    This file was created automatically by `FlexCat V1.1'
  5.    Do NOT edit by hand!
  6. ****************************************************************/
  7.  
  8. #ifndef %b_CAT_H
  9. #include "%b_CAT.h"
  10. #endif    /*  !%b_CAT_H         */
  11.  
  12. #include <string.h>
  13.  
  14. #include <exec/memory.h>
  15. #include <libraries/iffparse.h>
  16.  
  17. #include <clib/iffparse_protos.h>
  18. #include <clib/locale_protos.h>
  19. #include <clib/dos_protos.h>
  20. #include <clib/exec_protos.h>
  21. #include <clib/utility_protos.h>
  22.  
  23. #ifdef AZTEC_C
  24. #include <pragmas/locale_lib.h>
  25. #include <pragmas/iffparse_lib.h>
  26. #include <pragmas/dos_lib.h>
  27. #include <pragmas/exec_lib.h>
  28. #include <pragmas/utility_lib.h>
  29. #endif    /*  AZTEC_C            */
  30.  
  31. #if defined(__SASC)  ||  defined(_DCC)  ||  defined(__MAXON__)
  32. #include <pragmas/locale_pragmas.h>
  33. #include <pragmas/iffparse_pragmas.h>
  34. #include <pragmas/dos_pragmas.h>
  35. #include <pragmas/exec_pragmas.h>
  36. #include <pragmas/utility_pragmas.h>
  37. #endif    /*  __SASC  ||    _DCC  ||  __MAXON__ */
  38.  
  39. #ifdef __GNUC__
  40. #include <inline/locale.h>
  41. #include <inline/iffparse.h>
  42. #include <inline/dos.h>
  43. #include <inline/exec.h>
  44. #include <inline/utility.h>
  45. #endif    /*  __GNUC__    */
  46.  
  47.  
  48.  
  49.  
  50. static LONG %b_Version = %v;
  51. static const STRPTR %b_BuiltInLanguage = (STRPTR) %l;
  52.  
  53. struct FC_Type
  54. {   LONG    ID;
  55.     STRPTR  Str;
  56. };
  57.  
  58. static const struct FC_Type %b_Array [] =
  59. {
  60.     %i, (STRPTR) %s%,
  61. };
  62.  
  63. static struct Catalog *%b_Catalog = NULL;
  64. static struct FC_Type *%b_OwnCatalog = NULL;
  65. static LONG %b_OwnStrings;
  66. static LONG %b_OwnBytes;
  67.  
  68. void Open%bCatalog(struct Locale *loc, STRPTR language)
  69. { LONG tag, tagarg;
  70.   extern struct Library *LocaleBase;
  71.   extern struct Library *IFFParseBase;
  72.  
  73.   Close%bCatalog();  /*  Not needed if the programmer pairs Open-()
  74.              and CloseCatalog() right, but does no harm. */
  75.   if (language == NULL)
  76.   { tag = TAG_IGNORE;
  77.   }
  78.   else
  79.   { tag = OC_Language;
  80.     tagarg = (LONG) language;
  81.   }
  82.   if (LocaleBase != NULL  &&  %b_Catalog == NULL)
  83.   { %b_Catalog = OpenCatalog(loc, (STRPTR) "%b.catalog",
  84.                  OC_BuiltInLanguage, %b_BuiltInLanguage,
  85.                  tag, tagarg,
  86.                  OC_Version, %b_Version,
  87.                  TAG_DONE);
  88.   }
  89.   if (LocaleBase == NULL  &&  IFFParseBase != NULL  &&  language != NULL  &&
  90.       Stricmp(language, %b_BuiltInLanguage) != 0)
  91.   { struct IFFHandle *iffhandle;
  92.     char path[128]; /*    Enough to hold 4 path items (dos.library 3.0)  */
  93.  
  94.     if ((iffhandle = AllocIFF())  !=  NULL)
  95.     { /*  Trying to open the catalog  */
  96.       strcpy(path, "Catalogs");
  97.       AddPart((STRPTR) path, language, sizeof(path));
  98.       AddPart((STRPTR) path, (STRPTR) "%b.catalog", sizeof(path));
  99.       if ((iffhandle->iff_Stream = Open((STRPTR) path, MODE_OLDFILE))
  100.                  ==  NULL)
  101.       { strcpy(path, "Locale:Catalogs");
  102.     AddPart((STRPTR) path, language, sizeof(path));
  103.     AddPart((STRPTR) path, (STRPTR) "%b.catalog", sizeof(path));
  104.     iffhandle->iff_Stream = Open((STRPTR) path, MODE_OLDFILE);
  105.       }
  106.  
  107.       if (iffhandle->iff_Stream)
  108.       { InitIFFasDOS(iffhandle);
  109.     if (!OpenIFF(iffhandle, IFFF_READ))
  110.     { if (!PropChunk(iffhandle, MAKE_ID('C','T','L','G'),
  111.              MAKE_ID('S','T','R','S')))
  112.       { struct StoredProperty *sp;
  113.         int error;
  114.  
  115.         for (;;)
  116.         { if ((error = ParseIFF(iffhandle, IFFPARSE_STEP))
  117.              ==  IFFERR_EOC)
  118.           { continue;
  119.           }
  120.           if (error != 0)
  121.           { break;
  122.           }
  123.  
  124.           if (sp = FindProp(iffhandle, MAKE_ID('C','T','L','G'),
  125.                 MAKE_ID('S','T','R','S')))
  126.           { LONG *ptr;
  127.         LONG BytesToScan, StrLength;
  128.  
  129.         /*  First scan: Check the number of strings        */
  130.         /*  Note that this assumes that the strings are padded    */
  131.         /*  to a longword boundary!                */
  132.         %b_OwnBytes = 0;
  133.         %b_OwnStrings = 0;
  134.         BytesToScan = sp->sp_Size;
  135.         ptr = sp->sp_Data;
  136.         while (BytesToScan > 0)
  137.         { ++%b_OwnStrings;
  138.           ++ptr;              /*  Skip ID        */
  139.           StrLength = *ptr+1;          /*  NUL-Byte!        */
  140.           %b_OwnBytes += StrLength;
  141.           ptr += 1+(StrLength+3)/4;   /*  Skip Length and String*/
  142.           BytesToScan -= 8+((StrLength+3)/4)*4;
  143.         }
  144.  
  145.         /*  Marginal check: BytesToScan has to be 0!        */
  146.         if (BytesToScan == 0)
  147.         { char *cptr;
  148.           LONG i;
  149.  
  150.           if (%b_OwnCatalog = (struct FC_Type *)
  151.               AllocMem(%b_OwnStrings*sizeof(struct FC_Type)+%b_OwnBytes,
  152.                    MEMF_ANY))
  153.           { /*    Second scan: Copy the strings and their ID's    */
  154.             cptr = (char *) &%b_OwnCatalog[%b_OwnStrings];
  155.             BytesToScan = sp->sp_Size;
  156.             ptr = sp->sp_Data;
  157.             i = 0;
  158.             while (BytesToScan > 0)
  159.             { %b_OwnCatalog[i].ID = *(ptr++);
  160.               %b_OwnCatalog[i].Str = (STRPTR) cptr;
  161.               StrLength = *ptr+1;     /*  NUL-Byte!        */
  162.               ptr++;
  163.               strncpy(cptr, (char *) ptr, StrLength);
  164.                     /*  Not more, not less bytes!    */
  165.               cptr+=StrLength;
  166.               ptr += (StrLength+3)/4;
  167.               BytesToScan -= 8+((StrLength+3)/4)*4;
  168.               ++i;
  169.             }
  170.             break;
  171.           }
  172.         }
  173.           }
  174.         }
  175.       }
  176.       CloseIFF(iffhandle);
  177.     }
  178.     Close(iffhandle->iff_Stream);
  179.       }
  180.  
  181.       FreeIFF(iffhandle);
  182.     }
  183.   }
  184. }
  185.  
  186.  
  187. void Close%bCatalog(void)
  188. { if (LocaleBase != NULL)
  189.   { CloseCatalog(%b_Catalog);
  190.   }
  191.   %b_Catalog = NULL;
  192.   if (%b_OwnCatalog != NULL)
  193.   { FreeMem(%b_OwnCatalog,
  194.         %b_OwnStrings*sizeof(struct FC_Type)+%b_OwnBytes);
  195.     %b_OwnCatalog = NULL;
  196.   }
  197. }
  198.  
  199.  
  200. STRPTR Get%bString(LONG strnum)
  201. { STRPTR defaultstr = NULL;
  202.   LONG i;
  203.  
  204.   for (i = 0;  i < sizeof(%b_Array)/sizeof(struct FC_Type);  i++)
  205.     { if (%b_Array[i].ID == strnum)
  206.       { defaultstr = %b_Array[i].Str;
  207.     break;
  208.       }
  209.     }
  210.   if (%b_Catalog == NULL)
  211.   { if (%b_OwnCatalog != NULL)
  212.     { for (i = 0;  i < %b_OwnStrings;  i++)
  213.        { if (%b_OwnCatalog[i].ID == strnum)
  214.      { return(%b_OwnCatalog[i].Str);
  215.      }
  216.        }
  217.     }
  218.     return(defaultstr);
  219.   }
  220.   return(GetCatalogStr(%b_Catalog, strnum, defaultstr));
  221. }
  222.