tools/flexcat/src/scancd.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 #include "flexcat.h"
  24 #include "showfuncs.h"
  25 #include "readprefs.h"
  26 #include "globals.h"
  27 #include "utils.h"
  28 #include "createcat.h"
  29
  30 struct CDLine  *FirstCDLine = NULL;   /* First catalog description line. */
  31 char       *HeaderName  = NULL;
  32
  33 /// ScanCDFile
  34
  35 /* This scans the catalog description file.
  36    Inputs: cdfile - name of the catalog description file
  37    Result: TRUE if successful, FALSE otherwise */
  38
  39 int ScanCDFile(char *cdfile)
  40 {
  41   FILE *fp;
  42   struct CDLine  *cdline, **cdptr = &FirstCDLine;
  43   struct CatString *cs, **csptr = &FirstCatString;
  44   char *line, *newline;
  45   int NextID = 0;
  46   int Result = TRUE;
  47   int lenbytes = 0;
  48
  49   ScanFile = cdfile;
  50   ScanLine = 0;
  51
  52   if((fp = fopen(cdfile, "r")) == NULL)
  53   {
  54     ShowErrorQuick(MSG_ERR_NOCATALOGDESCRIPTION, cdfile);
  55   }
  56
  57   if(!NoBufferedIO)
  58     setvbuf(fp, NULL, _IOFBF, buffer_size);
  59
  60   // initialize "line" ahead of the loop
  61   // the loop will bail out early for empty files
  62   line = NULL;
  63   newline = NULL;
  64   while(!feof(fp) && (line = newline = ReadLine(fp, TRUE)) != NULL)
  65   {
  66     if((cdline = malloc(sizeof(*cdline))) == NULL)
  67     {
  68       MemError();
  69     }
  70
  71     *cdptr = cdline;
  72     cdptr = &cdline->Next;
  73     cdline->Next = NULL;
  74     cdline->Line = line = AllocString(newline);
  75     free(newline);
  76
  77     if(*line == ';')
  78     {
  79       continue;
  80     }
  81     else if(*line == '#')
  82     {
  83       int CheckExtra = TRUE;
  84
  85       /* '#' in the first  column of a line is the command introducer --
  86          any number of # symbols, blank spaces and tabs afterwards are
  87          skipped for compatibility with CatComp */
  88
  89       while(*line == '#' || *line == ' ' || *line == '\t')
  90       {
  91         ++line;
  92       }
  93
  94       if(Strnicmp(line, "language", 8) == 0)
  95       {
  96         char *ptr;
  97
  98         line += 9;
  99         OverSpace(&line);
 100         Language = AllocString(line);
 101         if(LANGToLower)
 102         {
 103           for(ptr = Language; *ptr; ptr++)
 104           {
 105             *ptr = tolower((int)*ptr);
 106           }
 107         }
 108         CheckExtra = FALSE;
 109       }
 110       else if(Strnicmp(line, "version", 7) == 0)
 111       {
 112         line += 8;
 113         OverSpace(&line);
 114         CatVersion = strtol(line, &line, 0);
 115         CheckExtra = TRUE;
 116       }
 117       else if(Strnicmp(line, "basename", 8) == 0)
 118       {
 119         line += 9;
 120         OverSpace(&line);
 121         free(BaseName);
 122         BaseName = AllocString(line);
 123         CheckExtra = FALSE;
 124       }
 125       else if(Strnicmp(line, "ifdef", 5) == 0)
 126       {
 127         continue;
 128       }
 129       else if(Strnicmp(line, "endif", 5) == 0)
 130       {
 131         continue;
 132       }
 133       else if(Strnicmp(line, "array", 5) == 0)
 134       {
 135         continue;
 136       }
 137       else if(Strnicmp(line, "header", 6) == 0)
 138       {
 139         line += 7;
 140         OverSpace(&line);
 141         free(HeaderName);
 142         HeaderName = AllocString(line);
 143         CheckExtra = FALSE;
 144
 145       }
 146       else if(Strnicmp(line, "lengthbytes", 11) == 0)
 147       {
 148         line += 12;
 149         OverSpace(&line);
 150         lenbytes = atoi(line);
 151         CheckExtra = FALSE;
 152       }
 153       else if(Strnicmp(line, "printf_check_off", 16) == 0)
 154       {
 155         continue;
 156       }
 157       else if(Strnicmp(line, "printf_check_on", 15) == 0)
 158       {
 159         continue;
 160       }
 161       else
 162       {
 163         ShowWarn(MSG_ERR_UNKNOWNCDCOMMAND);
 164         Result = FALSE;
 165         CheckExtra = FALSE;
 166       }
 167
 168       if(CheckExtra == TRUE)
 169       {
 170         OverSpace(&line);
 171         if(*line != '\0')
 172         {
 173           ShowError(MSG_ERR_EXTRA_CHARACTERS);
 174           Result = FALSE;
 175         }
 176       }
 177     }
 178     else
 179     {
 180       char *idstr;
 181
 182       /* Check for blanks at the start of line. */
 183
 184       if(*line == ' ' || *line == '\t')
 185       {
 186         ShowError(MSG_ERR_UNEXPECTEDBLANKS);
 187         Result = FALSE;
 188         OverSpace(&line);
 189       }
 190
 191       idstr = line;
 192       while((*line >= 'a' && *line <= 'z') ||
 193             (*line >= 'A' && *line <= 'Z') ||
 194             (*line >= '0' && *line <= '9') ||
 195             (*line == '_'))
 196       {
 197         ++line;
 198       }
 199
 200       if(idstr == line)
 201       {
 202         ShowError(MSG_ERR_NOIDENTIFIER);
 203         Result = FALSE;
 204       }
 205       else
 206       {
 207         int found;
 208
 209         if((cs = malloc(sizeof(*cs))) == NULL)
 210         {
 211           MemError();
 212         }
 213
 214         do
 215         {
 216           struct CatString *scs;
 217
 218           found = TRUE;
 219           for(scs = FirstCatString; scs != NULL; scs = scs->Next)
 220           {
 221             if(scs->ID == NextID)
 222             {
 223               found = FALSE;
 224               ++NextID;
 225               break;
 226             }
 227           }
 228         }
 229         while(found == FALSE);
 230
 231         cs->Next = NULL;
 232         cs->ID = NextID;
 233         cs->MinLen = 0;
 234         cs->MaxLen = -1;
 235         cs->CD_Str = (char *)"";
 236         cs->CT_Str = NULL;
 237         cs->NotInCT = TRUE;
 238         cs->POformat = FALSE;
 239
 240         if((cs->ID_Str = malloc((line - idstr) + 1)) == NULL)
 241         {
 242           MemError();
 243         }
 244         strncpy(cs->ID_Str, idstr, line - idstr);
 245         cs->ID_Str[line - idstr] = '\0';
 246         OverSpace(&line);
 247
 248         /* Check if next char in line is '('? (//) */
 249
 250         if(*line != '(')
 251         {
 252           ShowError(MSG_ERR_NO_LEADING_BRACKET, cs->ID_Str);
 253           Result = FALSE;
 254         }
 255         else
 256         {
 257           char *oldstr;
 258           struct CatString *scs;
 259           char bytes[10];
 260           int bytesread, reallen;
 261
 262           ++line;
 263           OverSpace(&line);
 264
 265           /* Check for default config of line (//) */
 266
 267           if(*line != '/')
 268           {
 269             if(*line == '+')
 270             {
 271               NextID = cs->ID = NextID + strtol(line, &line, 0);
 272             }
 273             else if(*line == '$')
 274             {
 275               line++;
 276               cs->ID = NextID = strtol(line, &line, 16);
 277             }
 278             else
 279             {
 280               cs->ID = NextID = strtol(line, &line, 0);
 281             }
 282             OverSpace(&line);
 283           }
 284
 285           /* Check for already used identifier. */
 286
 287           for(scs = FirstCatString; scs != NULL; scs = scs->Next)
 288           {
 289             if(scs->ID == cs->ID)
 290             {
 291               ShowError(MSG_ERR_DOUBLE_ID, cs->ID_Str);
 292               Result = FALSE;
 293             }
 294             if(strcmp(cs->ID_Str, scs->ID_Str) == 0)
 295             {
 296               ShowError(MSG_ERR_DOUBLE_IDENTIFIER, cs->ID_Str);
 297               Result = FALSE;
 298             }
 299           }
 300
 301           /* Check for min/len values (//) */
 302
 303           if(*line != '/')
 304           {
 305             ShowWarn(MSG_ERR_NO_MIN_LEN, cs->ID_Str);
 306             Result = FALSE;
 307           }
 308           else
 309           {
 310             ++line;
 311             OverSpace(&line);
 312             if(*line != '/')
 313             {
 314               cs->MinLen = strtol(line, &line, 0);
 315               OverSpace(&line);
 316             }
 317             if(*line != '/')
 318             {
 319               ShowWarn(MSG_ERR_NO_MAX_LEN, cs->ID_Str);
 320               Result = FALSE;
 321             }
 322             else
 323             {
 324               ++line;
 325               OverSpace(&line);
 326               if(*line != ')')
 327               {
 328                 cs->MaxLen = strtol(line, &line, 0);
 329                 OverSpace(&line);
 330               }
 331               if(*line != ')')
 332               {
 333                 ShowError(MSG_ERR_NO_TRAILING_BRACKET, cs->ID_Str);
 334                 Result = FALSE;
 335               }
 336               else
 337               {
 338                 ++line;
 339                 OverSpace(&line);
 340                 if(*line)
 341                 {
 342                   ShowError(MSG_ERR_EXTRA_CHARACTERS_ID, cs->ID_Str);
 343                 }
 344               }
 345             }
 346           }
 347
 348           /* Huh? There is no string for this definition? */
 349
 350           if((newline = ReadLine(fp, FALSE)) == FALSE)
 351           {
 352             ShowWarn(MSG_ERR_MISSINGSTRING);
 353             Result = FALSE;
 354             cs->CD_Str = (char *)"";
 355           }
 356           else
 357           {
 358             // Check if there are any non-ASCII characters contained in the line.
 359             // This will cause a warning only, since non-ASCII characters in the
 360             // default language are discouraged.
 361             char *p = newline;
 362             char c;
 363
 364             while((c = *p++) != '\0')
 365             {
 366               if(!isascii(c))
 367               {
 368                 int v = (int)c;
 369
 370                 ShowWarn(MSG_ERR_NON_ASCII_CHARACTER, v & 0xff, cs->ID_Str);
 371                 break;
 372               }
 373             }
 374
 375             cs->CD_Str = AllocString(newline);
 376             free(newline);
 377           }
 378
 379           /* Get string length. */
 380
 381           oldstr = cs->CD_Str;
 382           reallen = 0;
 383           while(*oldstr != '\0')
 384           {
 385             bytesread = ReadChar(&oldstr, bytes);
 386             if(bytesread == 2)
 387             {
 388               bytesread--;
 389             }
 390             reallen += bytesread;
 391           }
 392
 393           /* String too short. */
 394
 395           if(cs->MinLen > 0 && reallen < cs->MinLen)
 396           {
 397             ShowWarn(MSG_ERR_STRING_TOO_SHORT, cs->ID_Str);
 398           }
 399
 400           /* String too long. */
 401
 402           if(cs->MaxLen > 0 && reallen > cs->MaxLen)
 403           {
 404             ShowWarn(MSG_ERR_STRING_TOO_LONG, cs->ID_Str);
 405           }
 406
 407           cs->Nr = NumStrings;
 408           cs->LenBytes = lenbytes;
 409           *csptr = cs;
 410           csptr = &cs->Next;
 411           ++NumStrings;
 412         }
 413       }
 414     }
 415   }
 416
 417   fclose(fp);
 418
 419   return Result;
 420 }
 421
 422 ///