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