tools/flexcat/src/createcat.c

   1 /*
   2  * $Id$
   3  *
   4  * Copyright (C) 1993-1999 by Jochen Wiedmann and Marcin Orlowski
   5  * Copyright (C) 2002-2010 by the FlexCat Open Source Team
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or (at
  10  * your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  *
  21  */
  22
  23 #include "flexcat.h"
  24 #include "scanct.h"
  25 #include "showfuncs.h"
  26 #include "readprefs.h"
  27 #include "swapfuncs.h"
  28 #include "globals.h"
  29 #include "utils.h"
  30
  31 struct CatString *FirstCatString = NULL;     /* First catalog string */
  32 struct CatalogChunk *FirstChunk = NULL;    /* List of catalog chunks */
  33
  34 /// CatPuts
  35
  36 /* CatPuts prints a string to a catalog. (The string is preceded by a
  37    long integer containing its length and probably padded up to word
  38    boundary or longword boundary, depending on the argument padbytes.)
  39    The arguments countnul should be TRUE if the NUL byte at the end of
  40    the string should be counted. */
  41
  42 int CatPuts(FILE *fp, char *str, int padbytes, int countnul, int lenbytes)
  43 {
  44   uint32 reallen;
  45   uint32 virtuallen;
  46   uint32 chunklen;
  47   uint32 swapped_long;
  48   int bytesread;
  49   char *oldstr;
  50   char bytes[10];
  51
  52 /* Get length of string */
  53
  54   oldstr = str;
  55   reallen = 0;
  56
  57   while(*oldstr != '\0')
  58   {
  59     bytesread = ReadChar(&oldstr, bytes);
  60     // substract one byte for double backslashes
  61     if(bytesread == 2)
  62       bytesread--;
  63
  64     reallen += bytesread;
  65   }
  66
  67   virtuallen = chunklen = reallen + lenbytes;
  68   if(countnul || chunklen % padbytes == 0)
  69     virtuallen++;
  70
  71   swapped_long = SwapLong(virtuallen);
  72
  73   fwrite(&swapped_long, sizeof(virtuallen), 1, fp);
  74   if(lenbytes > 0)
  75     fwrite(((char *)&reallen) + sizeof(reallen) - lenbytes, lenbytes, 1, fp);
  76
  77   while(*str != '\0')
  78   {
  79     bytesread = ReadChar(&str, bytes);
  80     if(bytesread > 0)
  81       fwrite(bytes + bytesread - 1, 1, 1, fp);
  82   }
  83
  84   do
  85   {
  86     putc('\0', fp);
  87   }
  88   while(++chunklen % padbytes);
  89
  90   return (int)chunklen + 4;
  91 }
  92
  93 ///
  94 /// PutCatalogChunk
  95
  96 /* This puts a string chunk into the catalog */
  97
  98 int PutCatalogChunk(FILE * fp, struct CatalogChunk *cc)
  99 {
 100   fwrite(&cc->ID, sizeof(cc->ID), 1, fp);
 101
 102   return 4 + CatPuts(fp, cc->ChunkStr, 2, TRUE, 0);
 103 }
 104
 105 ///
 106 /// CreateCatalog
 107
 108 /* This creates a catalog */
 109
 110 void CreateCat(char *CatFile)
 111 {
 112   FILE *fp;
 113   int CatLen, HeadLen;
 114   struct CatString *cs;
 115   struct CatalogChunk *cc;
 116   int i;
 117
 118   if(CatVersionString == NULL && CatRcsId == NULL)
 119   {
 120     ShowError(MSG_ERR_NOCTVERSION);
 121   }
 122
 123   if(CatLanguage == NULL)
 124   {
 125     ShowError(MSG_ERR_NOCTLANGUAGE);
 126   }
 127
 128   if(strlen(CatLanguage) == 0)
 129   {
 130     ShowError(MSG_ERR_NOCTLANGUAGE);
 131   }
 132
 133   if(CatFile == NULL)
 134   {
 135     if(BaseName == NULL)
 136       ShowError(MSG_ERR_NOCATFILENAME);
 137     else
 138     {
 139       if(asprintf(&CatFile, "%s.catalog", BaseName) < 0)
 140         MemError();
 141     }
 142   }
 143
 144   if((fp = fopen(CatFile, "wb")) == NULL)
 145   {
 146     ShowError(MSG_ERR_NOCATALOG, CatFile);
 147   }
 148
 149   if(!NoBufferedIO)
 150     setvbuf(fp, NULL, _IOFBF, buffer_size);
 151
 152   fputs("FORM0000CTLG", fp);
 153   CatLen = 4;
 154
 155   if(CatVersionString !=NULL)
 156   {
 157     struct CatalogChunk verChunk;
 158     char *found;
 159
 160     verChunk.ID = MAKE_ID('F', 'V', 'E', 'R');
 161
 162     verChunk.ChunkStr = strdup(CatVersionString);
 163
 164     /* Replace $TODAY placeholder */
 165
 166     found = strstr(verChunk.ChunkStr, "$TODAY");
 167     if(found != NULL)
 168     {
 169       char dateStr[12];
 170       time_t tim;
 171       struct tm *t;
 172       char *verStr = NULL;
 173
 174       time(&tim);
 175       t = localtime(&tim);
 176
 177       *found = '\0';
 178       strftime(dateStr, sizeof(dateStr), "%d.%m.%Y", t);
 179
 180       if(asprintf(&verStr, "%s%s%s", verChunk.ChunkStr, dateStr, found + strlen("$TODAY")) != -1)
 181       {
 182         free(verChunk.ChunkStr);
 183         verChunk.ChunkStr = verStr;
 184       }
 185       else
 186         MemError();
 187     }
 188
 189     /* Replace ".ct" with ".catalog" */
 190
 191     found = strstr(verChunk.ChunkStr, ".ct ");
 192     if(found != NULL)
 193     {
 194       char *verStr = NULL;
 195
 196       *found = '\0';
 197       if(asprintf(&verStr, "%s.catalog%s", verChunk.ChunkStr, found + 3) != -1)
 198       {
 199         free(verChunk.ChunkStr);
 200         verChunk.ChunkStr = verStr;
 201       }
 202     }
 203
 204     verChunk.ID = SwapLong(verChunk.ID);
 205     CatLen += PutCatalogChunk(fp, &verChunk);
 206     free(verChunk.ChunkStr);
 207   }
 208   else
 209   {
 210     struct CatalogChunk verChunk;
 211     char *verStr = NULL;
 212     int year = 0, month = 0, day = 0;
 213     int version = 0, revision = 0;
 214     char *name = NULL;
 215     char *ptr;
 216
 217     if(CatRcsId == NULL)
 218     {
 219       ShowError(MSG_ERR_NOCTVERSION);
 220     }
 221     else
 222     {
 223       if((ptr = strstr(CatRcsId, "$Date:")) == NULL ||
 224          sscanf(ptr + 6, " %d/%d/%d", &year, &month, &day) != 3 ||
 225          (ptr = strstr(CatRcsId, "$Revision:")) == NULL ||
 226          sscanf(ptr + 10, " %d.%d", &version, &revision) != 2)
 227       {
 228         ShowError(MSG_ERR_WRONGRCSID);
 229       }
 230       if((ptr = strstr(CatRcsId, "$Id:")) != NULL)
 231       {
 232         int len = 0;
 233         char *found;
 234
 235         ptr += 4;
 236         OverSpace(&ptr);
 237         found = ptr;
 238
 239         while(*ptr != '\0' && *ptr != '$' && *ptr != ' ' && *ptr != '\t')
 240         {
 241           ++len;
 242           ++ptr;
 243         }
 244         if((name = malloc(len + 1)) == NULL)
 245         {
 246           MemError();
 247         }
 248         strncpy(name, found, len);
 249         name[len] = '\0';
 250       }
 251     }
 252
 253     if(CatName != NULL)
 254     {
 255       name = CatName;
 256     }
 257     else if(name == NULL)
 258     {
 259       ShowError(MSG_ERR_NOCTVERSION);
 260       name = (char *)"";
 261     }
 262
 263     if(asprintf(&verStr, "%cVER: %s %d.%d(%d.%d.%d)", '$', name, version, revision, day, month, year) != -1)
 264     {
 265       verChunk.ID = MAKE_ID('F', 'V', 'E', 'R');
 266       verChunk.ID = SwapLong(verChunk.ID);
 267       verChunk.ChunkStr = verStr;
 268       CatLen += PutCatalogChunk(fp, &verChunk);
 269     }
 270     else
 271       MemError();
 272   }
 273
 274   for(cc = FirstChunk; cc != NULL; cc = cc->Next)
 275   {
 276     CatLen += PutCatalogChunk(fp, cc);
 277   }
 278
 279   i = 32;
 280   fputs("CSET", fp);
 281
 282   {
 283     int i_tmp = SwapLong(i);
 284
 285     fwrite(&i_tmp, sizeof(i_tmp), 1, fp);
 286     i_tmp = SwapLong(CodeSet);
 287     fwrite(&i_tmp, sizeof(i_tmp), 1, fp);
 288     i -= sizeof(i_tmp);
 289   }
 290
 291   while(i-- > 0)
 292   {
 293     putc('\0', fp);
 294   }
 295
 296   CatLen += 48;
 297   fprintf(fp, "STRS0000");
 298   HeadLen = CatLen;
 299
 300   for(cs = FirstCatString; cs != NULL; cs = cs->Next)
 301   {
 302     int FillUsed = FALSE;
 303     int tmp_ID = SwapLong(cs->ID);
 304
 305     if(Fill)
 306     {
 307       if(cs->CT_Str != NULL && cs->NotInCT == FALSE)
 308       {
 309         if(strlen(cs->CT_Str) == 0)
 310         {
 311           fwrite(&tmp_ID, sizeof(tmp_ID), 1, fp);
 312           CatLen += 4 + CatPuts(fp, cs->CD_Str, 4, FALSE, cs->LenBytes);
 313           FillUsed = TRUE;
 314         }
 315       }
 316       else
 317       {
 318         fwrite(&tmp_ID, sizeof(cs->ID), 1, fp);
 319         CatLen += 4 + CatPuts(fp, cs->CD_Str, 4, FALSE, cs->LenBytes);
 320         FillUsed = TRUE;
 321       }
 322     }
 323
 324     if(FillUsed == FALSE && cs->CT_Str != NULL && cs->NotInCT == FALSE &&
 325        (NoOptim ? TRUE : strcmp(cs->CT_Str, cs->CD_Str)))
 326     {
 327       fwrite(&tmp_ID, sizeof(tmp_ID), 1, fp);
 328       CatLen += 4 + CatPuts(fp, cs->CT_Str, 4, FALSE, cs->LenBytes);
 329     }
 330
 331   /* printf("LB=%d\n", cs->LenBytes); */
 332
 333   }
 334   {
 335     int tmp_Len;
 336
 337     fseek(fp, 4, SEEK_SET);
 338
 339     tmp_Len = SwapLong(CatLen);
 340     fwrite(&tmp_Len, sizeof(tmp_Len), 1, fp);
 341     fseek(fp, HeadLen - 4, SEEK_CUR);
 342
 343     CatLen -= HeadLen;
 344     tmp_Len = SwapLong(CatLen);
 345     fwrite(&tmp_Len, sizeof(CatLen), 1, fp);
 346   }
 347
 348   fclose(fp);
 349 #ifdef AMIGA
 350   SetProtection(CatFile, FILE_MASK);
 351 #endif
 352   Expunge();
 353 }
 354
 355 ///