tools/flexcat/src/scanct.c

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