tools/flexcat/src/scanct.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 #ifdef AMIGA
  24   #include <proto/locale.h>  /* This is to get locale.library/IsAlpha() */
  25 #endif
  26
  27 // #include <stdio.h>
  28 // #include <stdlib.h>
  29 #include <errno.h>
  30 #include <limits.h>
  31
  32
  33 #include "flexcat.h"
  34 #include "showfuncs.h"
  35 #include "readprefs.h"
  36 #include "globals.h"
  37 #include "utils.h"
  38 #include "createcat.h"
  39
  40 char           *CatVersionString = NULL;   /* Version string of catalog
  41                                               translation (## version) */
  42 char           *CatLanguage = NULL;        /* Language of catalog translation */
  43 char           *CatRcsId = NULL;           /* RCS ID of catalog translation
  44                                               (## rcsid) */
  45 char           *CatName = NULL;            /* Name of catalog translation */
  46 uint32          CodeSet = 0;               /* Codeset of catalog translation */
  47 int             CT_Scanned = FALSE;        /* If TRUE and we are going to
  48                                               write a new #?.ct file, then the
  49                                               user is surely updating his own
  50                                               #?.ct file, so we should write
  51                                               ***NEW*** wherever necessary. */
  52
  53 #define IS_NUMBER_OR_LETTER(c) (((c) >= '0' && (c) <= '9') || \
  54                                 ((c) >= 'a' && (c) <= 'z') || \
  55                                 ((c) >= 'A' && (c) <= 'Z'))
  56
  57 /// ScanCTFile
  58
  59 /* This scans a catalog translation file.
  60    Inputs: ctfile  - name of the translation file to scan.
  61    Result: TRUE if successful, FALSE otherwise. */
  62
  63 int ScanCTFile(char *ctfile)
  64 {
  65     FILE           *fp;
  66     char           *newline, *line, *idstr, *newidstr, *newstr;
  67     struct CatString *cs = NULL;
  68     int             Result = TRUE;
  69     int             CodeSet_checked = 0;
  70
  71     ScanFile = ctfile;
  72     ScanLine = 0;
  73
  74     if((fp = fopen(ctfile, "r")) == NULL)
  75     {
  76         ShowErrorQuick(MSG_ERR_NOCATALOGTRANSLATION, ctfile);
  77     }
  78
  79     if(!NoBufferedIO)
  80         setvbuf(fp, NULL, _IOFBF, buffer_size);
  81
  82
  83     while(!feof(fp) && (line = newline = ReadLine(fp, TRUE)) != NULL)
  84     {
  85         switch(*line)
  86         {
  87             case ';':
  88                 if(CopyNEWs == TRUE)
  89                 {
  90                     if(cs && Strnicmp(line, Old_Msg_New, (int)strlen(Old_Msg_New)) == 0)
  91                     {
  92                         cs->NotInCT = TRUE;
  93                     }
  94                 }
  95                 break;
  96
  97             case '#':
  98
  99                 /* '#' in the first  column of a line is the command introducer --
 100                 any number of # symbols, blank spaces and tabs afterwards are
 101                 skipped for compatibility with CatComp */
 102
 103                 while(*line == '#' || *line == ' ' || *line == '\t')
 104                 {
 105                     ++line;
 106                 }
 107
 108                 if(Strnicmp(line, "version", 7) == 0)
 109                 {
 110                     if(CatVersionString || CatRcsId || CatName)
 111                     {
 112                         ShowError(MSG_ERR_DOUBLECTVERSION);
 113                     }
 114                     line += 7;
 115                     OverSpace(&line);
 116                     // perform a slightly obfuscated check for the version cookie to
 117                     // avoid having multiple cookies in the final binary
 118                     if(line[0] == '$' && Strnicmp(&line[1], "VER:", 4) == 0)
 119                     {
 120                         CatVersionString = AllocString(line);
 121                     }
 122                     else
 123                     {
 124                         ShowError(MSG_ERR_BADCTVERSION);
 125                     }
 126                 }
 127                 else if(Strnicmp(line, "codeset", 7) == 0)
 128                 {
 129                     char *ptr;
 130
 131                     if(CodeSet_checked)
 132                     {
 133                         ShowError(MSG_ERR_DOUBLECTCODESET);
 134                     }
 135                     line += 7;
 136                     OverSpace(&line);
 137
 138                     if(!*line)
 139                     /* Missing argument for "## codeset" */
 140                     {
 141                         ShowError(MSG_ERR_BADCTCODESET);
 142                     }
 143
 144                     for(ptr = line; *ptr; ptr++)
 145                         if(!isdigit((int)*ptr))
 146                         /* Non-digit char detected */
 147                         {
 148                             ShowError(MSG_ERR_BADCTCODESET);
 149                         }
 150
 151                     errno = 0;
 152
 153                     CodeSet = strtoul(line, &line, 0);
 154
 155 /*                  printf("ulong_max es %lu\n",ULONG_MAX);
 156                     printf("CodeSet obtenido de strtoul es %lu\n",CodeSet);*/
 157
 158                     if(errno == ERANGE && CodeSet == ULONG_MAX)
 159                     {
 160                         ShowError(MSG_ERR_BADCTCODESET);
 161                     }
 162
 163                     CodeSet_checked = 1;
 164                     // errno = 0;
 165                 }
 166                 else if(Strnicmp(line, "language", 8) == 0)
 167                 {
 168                     char *ptr;
 169
 170                     if(CatLanguage)
 171                     {
 172                         ShowError(MSG_ERR_DOUBLECTLANGUAGE);
 173                     }
 174                     line += 8;
 175                     OverSpace(&line);
 176                     CatLanguage = AddCatalogChunk(strdup("LANG"), line);
 177
 178                     if(LANGToLower)
 179                         for(ptr = CatLanguage; *ptr; ptr++)
 180                             *ptr = tolower((int)*ptr);
 181                 }
 182                 else if(Strnicmp(line, "chunk", 5) == 0)
 183                 {
 184                     char           *ID;
 185
 186                     line += 5;
 187                     OverSpace(&line);
 188                     ID = line;
 189                     line += sizeof(ULONG);
 190                     OverSpace(&line);
 191
 192                     AddCatalogChunk(ID, AllocString(line));
 193                 }
 194                 else if(Strnicmp(line, "rcsid", 5) == 0)
 195                 {
 196                     if(CatVersionString || CatRcsId)
 197                     {
 198                         ShowError(MSG_ERR_DOUBLECTVERSION);
 199                     }
 200                     line += 5;
 201                     OverSpace(&line);
 202                     CatRcsId = AllocString(line);
 203                 }
 204                 else if(Strnicmp(line, "name", 5) == 0)
 205                 {
 206                     if(CatVersionString || CatName)
 207                     {
 208                         ShowError(MSG_ERR_DOUBLECTVERSION);
 209                     }
 210                     line += 4;
 211                     OverSpace(&line);
 212                     CatName = AllocString(line);
 213                 }
 214                 else
 215                 {
 216                     ShowWarn(MSG_ERR_UNKNOWNCTCOMMAND);
 217                 }
 218
 219                 /* Stop looking for commands */
 220
 221                 break;
 222
 223             default:
 224                 if(*line == ' ' || *line == '\t')
 225                 {
 226                     ShowError(MSG_ERR_UNEXPECTEDBLANKS);
 227                     OverSpace(&line);
 228                 }
 229                 idstr = line;
 230
 231                 while(IS_NUMBER_OR_LETTER(*line) || *line == '_')
 232                 {
 233                     ++line;
 234                 }
 235                 if(idstr == line)
 236                 {
 237                     ShowError(MSG_ERR_NOIDENTIFIER);
 238                     break;
 239                 }
 240
 241                 if((newidstr = malloc(line - idstr + 1)) == NULL)
 242                 {
 243                     MemError();
 244                 }
 245
 246                 strncpy(newidstr, idstr, line - idstr);
 247                 newidstr[line - idstr] = '\0';
 248                 OverSpace(&line);
 249
 250                 if(*line)
 251                 {
 252                     ShowError(MSG_ERR_EXTRA_CHARACTERS_ID, newidstr);
 253                 }
 254
 255                 if((newstr = ReadLine(fp, FALSE)) != NULL)
 256                 {
 257                     for(cs = FirstCatString; cs != NULL; cs = cs->Next)
 258                     {
 259                         if(strcmp(cs->ID_Str, newidstr) == 0)
 260                         {
 261                             break;
 262                         }
 263                     }
 264                     if(cs == NULL)
 265                     {
 266                         ShowWarn(MSG_ERR_UNKNOWNIDENTIFIER, newidstr);
 267                     }
 268                     else
 269                     {
 270                         size_t reallen;
 271                         size_t cd_len;
 272
 273                         if(cs->CT_Str)
 274                         {
 275                             ShowError(MSG_ERR_DOUBLE_IDENTIFIER, cs->ID_Str);
 276                             Result = FALSE;
 277                             free(cs->CT_Str);
 278                         }
 279                         cs->CT_Str = AllocString(newstr);
 280                         cs->NotInCT = FALSE;
 281
 282                         /* Get string length */
 283
 284                         reallen = strlen(cs->CT_Str);
 285                         cd_len = strlen(cs->CD_Str);
 286
 287                         if(cs->MinLen > 0 && reallen < (size_t)cs->MinLen)
 288                         {
 289                             ShowWarn(MSG_ERR_STRING_TOO_SHORT, cs->ID_Str);
 290                         }
 291                         if(cs->MaxLen > 0 && reallen > (size_t)cs->MaxLen)
 292                         {
 293                             ShowWarn(MSG_ERR_STRING_TOO_LONG, cs->ID_Str);
 294                         }
 295
 296                         // check for empty translations
 297                         if(cd_len > 0 && reallen == 0)
 298                         {
 299                             ShowWarn(MSG_ERR_EMPTYTRANSLATION, cs->ID_Str);
 300                         }
 301
 302                         /* Check for trailing ellipsis. */
 303                         if(reallen >= 3 && cd_len >= 3)
 304                         {
 305                             if(strcmp(&cs->CD_Str[cd_len - 3], "...") == 0 &&
 306                                strcmp(&cs->CT_Str[reallen - 3], "...") != 0)
 307                             {
 308                                 ShowWarn(MSG_ERR_TRAILING_ELLIPSIS, cs->ID_Str);
 309                             }
 310                             if(strcmp(&cs->CD_Str[cd_len - 3], "...") != 0 &&
 311                                strcmp(&cs->CT_Str[reallen - 3], "...") == 0)
 312                             {
 313                                 ShowWarn(MSG_ERR_NO_TRAILING_ELLIPSIS, cs->ID_Str);
 314                             }
 315                         }
 316
 317
 318                         /* Check for trailing spaces. */
 319                         if(reallen >= 1 && cd_len >= 1)
 320                         {
 321                             if(strcmp(&cs->CD_Str[cd_len - 1], " ") == 0 &&
 322                                strcmp(&cs->CT_Str[reallen - 1], " ") != 0)
 323
 324                             {
 325                                 ShowWarn(MSG_ERR_TRAILING_BLANKS, cs->ID_Str);
 326                             }
 327                             if(strcmp(&cs->CD_Str[cd_len - 1], " ") != 0 &&
 328                                strcmp(&cs->CT_Str[reallen - 1], " ") == 0)
 329
 330                             {
 331                                 ShowWarn(MSG_ERR_NO_TRAILING_BLANKS, cs->ID_Str);
 332                             }
 333                         }
 334
 335                         /* Check for matching placeholders */
 336                         if(reallen >= 1 && cd_len >= 1)
 337                         {
 338                             char *cdP = cs->CD_Str;
 339                             char *ctP = cs->CT_Str;
 340
 341                             do
 342                             {
 343                                 cdP = strchr(cdP, '%');
 344                                 ctP = strchr(ctP, '%');
 345
 346                                 if(cdP == NULL && ctP == NULL)
 347                                 {
 348                                     // no more placeholders, bail out
 349                                     break;
 350                                 }
 351                                 else if(cdP != NULL && ctP != NULL)
 352                                 {
 353                                     // skip the '%' sign
 354                                     cdP++;
 355                                     ctP++;
 356
 357                                     // check the placeholder only if the '%' is followed by an
 358                                     // alpha-numerical character or another percent sign
 359                                     if(IS_NUMBER_OR_LETTER(*cdP) || *cdP == '%')
 360                                     {
 361                                         if(*cdP != *ctP)
 362                                         {
 363                                             ShowWarn(MSG_ERR_MISMATCHING_PLACEHOLDERS, cs->ID_Str);
 364                                             break;
 365                                         }
 366                                         // skip the second '%' sign
 367                                         if(*cdP == '%')
 368                                             cdP++;
 369                                         if(*ctP == '%')
 370                                             ctP++;
 371                                     }
 372                                     else if(IS_NUMBER_OR_LETTER(*ctP) || *ctP == '%')
 373                                     {
 374                                         // the translation uses a placeholder while the description
 375                                         // uses none.
 376                                         ShowWarn(MSG_ERR_EXCESSIVE_PLACEHOLDERS, cs->ID_Str);
 377                                         break;
 378                                     }
 379                                 }
 380                                 else if(cdP != NULL && ctP == NULL)
 381                                 {
 382                                     // skip the '%' sign
 383                                     cdP++;
 384
 385                                     // check if really a placeholder follows or just another percent sign
 386                                     // the original string is allowed to contain more single percent signs than the translated string
 387                                     if(IS_NUMBER_OR_LETTER(*cdP) || *cdP == '%')
 388                                     {
 389                                         // the description uses at least one more placeholder than the translation
 390                                         ShowWarn(MSG_ERR_MISSING_PLACEHOLDERS, cs->ID_Str);
 391                                     }
 392                                     break;
 393                                 }
 394                                 else if(cdP == NULL && ctP != NULL)
 395                                 {
 396                                     // skip the '%' sign
 397                                     ctP++;
 398
 399                                     // check if really a placeholder follows or just another percent sign
 400                                     // the translated string is allowed to contain more single percent signs than the original string
 401                                     if(IS_NUMBER_OR_LETTER(*ctP) || *ctP == '%')
 402                                     {
 403                                         // the translation uses at least one more placeholder than the description
 404                                         ShowWarn(MSG_ERR_EXCESSIVE_PLACEHOLDERS, cs->ID_Str);
 405                                     }
 406                                     break;
 407                                 }
 408                             }
 409                             while(TRUE);
 410                         }
 411                     }
 412
 413                     free(newstr);
 414                 }
 415                 else
 416                 {
 417                     ShowWarn(MSG_ERR_MISSINGSTRING);
 418                     if(cs)
 419                         cs->CT_Str = (char *)"";
 420                 }
 421                 free(newidstr);
 422         }
 423         free(newline);
 424         // forget the pointers as we just freed them and 'line' must not be freed again after the loop
 425         newline = NULL;
 426         line = NULL;
 427     }
 428
 429     if(!CodeSet_checked)
 430     {
 431         ShowErrorQuick(MSG_ERR_NOCTCODESET);
 432     }
 433
 434     if(!(CatVersionString || (CatRcsId && CatName)))
 435     {
 436         ShowErrorQuick(MSG_ERR_NOCTVERSION);
 437     }
 438
 439     // check if a translation exists for all identifiers
 440     for(cs = FirstCatString; cs != NULL; cs = cs->Next)
 441     {
 442         if(cs->CT_Str == NULL)
 443         {
 444             ShowWarnQuick(MSG_ERR_MISSINGTRANSLATION, cs->ID_Str);
 445         }
 446     }
 447
 448     if(line != NULL)
 449         free(line);
 450
 451     fclose(fp);
 452
 453     if(WarnCTGaps)
 454     {
 455         for(cs = FirstCatString; cs != NULL; cs = cs->Next)
 456         {
 457             if(cs->CT_Str == NULL)
 458             {
 459                 ShowWarn(MSG_ERR_CTGAP, cs->ID_Str);
 460             }
 461         }
 462     }
 463
 464     if(Result)
 465         CT_Scanned = TRUE;
 466
 467     return(Result);
 468 }
 469
 470 ///
 471