soltools/mkdepend/parse.c

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /* $XConsortium: parse.c,v 1.30 94/04/17 20:10:38 gildea Exp $ */
   3 /*
   4
   5 Copyright (c) 1993, 1994  X Consortium
   6
   7 Permission is hereby granted, free of charge, to any person obtaining a copy
   8 of this software and associated documentation files (the "Software"), to deal
   9 in the Software without restriction, including without limitation the rights
  10 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  11 copies of the Software, and to permit persons to whom the Software is
  12 furnished to do so, subject to the following conditions:
  13
  14 The above copyright notice and this permission notice shall be included in
  15 all copies or substantial portions of the Software.
  16
  17 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  20 X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23
  24 Except as contained in this notice, the name of the X Consortium shall not be
  25 used in advertising or otherwise to promote the sale, use or other dealings
  26 in this Software without prior written authorization from the X Consortium.
  27
  28 */
  29
  30 #include <ctype.h>
  31
  32 #include "def.h"
  33 char *hash_lookup( char *symbol, struct symhash *symbols );
  34 void hash_undefine( char *symbol, struct symhash *symbols );
  35 int gobble( struct filepointer *filep, struct inclist *file,
  36     struct inclist *file_red, struct symhash *symbols );
  37 int deftype ( char *line, struct filepointer *filep,
  38     struct inclist *file_red, struct inclist *file,
  39     int parse_it, struct symhash *symbols);
  40 int zero_value(char *exp, struct filepointer *filep,
  41     struct inclist *file_red, struct symhash *symbols);
  42
  43 extern struct symhash *maininclist;
  44
  45 int find_includes(struct filepointer *filep, struct inclist *file, struct inclist *file_red, int recursion, boolean failOK, struct IncludesCollection* incCollection, struct symhash *symbols)
  46 {
  47     char   *line;
  48     int    type;
  49     boolean recfailOK;
  50
  51     while ((line = get_line(filep))) {
  52         switch(type = deftype(line, filep, file_red, file, TRUE, symbols)) {
  53         case IF:
  54         doif:
  55             type = find_includes(filep, file,
  56                 file_red, recursion+1, failOK, incCollection, symbols);
  57             while ((type == ELIF) || (type == ELIFFALSE) ||
  58                    (type == ELIFGUESSFALSE))
  59                 type = gobble(filep, file, file_red, symbols);
  60             if (type == ELSE)
  61                 gobble(filep, file, file_red, symbols);
  62             break;
  63         case IFFALSE:
  64         case IFGUESSFALSE:
  65             doiffalse:
  66             if (type == IFGUESSFALSE || type == ELIFGUESSFALSE)
  67                 recfailOK = TRUE;
  68             else
  69                 recfailOK = failOK;
  70             type = gobble(filep, file, file_red, symbols);
  71             if (type == ELSE)
  72                 find_includes(filep, file,
  73                       file_red, recursion+1, recfailOK, incCollection, symbols);
  74             else if (type == ELIF)
  75                 goto doif;
  76             else if ((type == ELIFFALSE) || (type == ELIFGUESSFALSE))
  77                 goto doiffalse;
  78             break;
  79         case IFDEF:
  80         case IFNDEF:
  81             if ((type == IFDEF && hash_lookup(line, symbols))
  82              || (type == IFNDEF && !hash_lookup(line, symbols))) {
  83                 debug(1,(type == IFNDEF ?
  84                     "line %d: %s !def'd in %s via %s%s\n" : "",
  85                     filep->f_line, line,
  86                     file->i_file, file_red->i_file, ": doit"));
  87                 type = find_includes(filep, file,
  88                     file_red, recursion+1, failOK, incCollection, symbols);
  89                 while (type == ELIF || type == ELIFFALSE || type == ELIFGUESSFALSE)
  90                     type = gobble(filep, file, file_red, symbols);
  91                 if (type == ELSE)
  92                     gobble(filep, file, file_red, symbols);
  93             }
  94             else {
  95                 debug(1,(type == IFDEF ?
  96                     "line %d: %s !def'd in %s via %s%s\n" : "",
  97                     filep->f_line, line,
  98                     file->i_file, file_red->i_file, ": gobble"));
  99                 type = gobble(filep, file, file_red, symbols);
 100                 if (type == ELSE)
 101                     find_includes(filep, file,
 102                         file_red, recursion + 1, failOK, incCollection, symbols);
 103                 else if (type == ELIF)
 104                         goto doif;
 105                 else if (type == ELIFFALSE || type == ELIFGUESSFALSE)
 106                         goto doiffalse;
 107             }
 108             break;
 109         case ELSE:
 110         case ELIFFALSE:
 111         case ELIFGUESSFALSE:
 112         case ELIF:
 113             if (!recursion)
 114                 gobble(filep, file, file_red, symbols);
 115             /*fall-through*/
 116         case ENDIF:
 117             if (recursion)
 118                 return type;
 119             /*fall-through*/
 120         case DEFINE:
 121             define(line, &symbols);
 122             break;
 123         case UNDEF:
 124             if (!*line) {
 125                 warning("%s, line %d: incomplete undef == \"%s\"\n",
 126                 file_red->i_file, filep->f_line, line);
 127                 break;
 128             }
 129             hash_undefine(line, symbols);
 130             break;
 131         case INCLUDE:
 132             add_include(filep, file, file_red, line, FALSE, failOK, incCollection, symbols);
 133             break;
 134         case INCLUDEDOT:
 135             add_include(filep, file, file_red, line, TRUE, failOK, incCollection, symbols);
 136             break;
 137         case ERROR:
 138                 warning("%s: %d: %s\n", file_red->i_file,
 139                  filep->f_line, line);
 140                 break;
 141
 142         case PRAGMA:
 143         case IDENT:
 144         case SCCS:
 145         case EJECT:
 146             break;
 147         case -1:
 148             warning("%s", file_red->i_file);
 149             if (file_red != file)
 150                 warning1(" (reading %s)", file->i_file);
 151             warning1(", line %d: unknown directive == \"%s\"\n",
 152                  filep->f_line, line);
 153             break;
 154         case -2:
 155             warning("%s", file_red->i_file);
 156             if (file_red != file)
 157                 warning1(" (reading %s)", file->i_file);
 158             warning1(", line %d: incomplete include == \"%s\"\n",
 159                  filep->f_line, line);
 160             break;
 161         }
 162     }
 163     return -1;
 164 }
 165
 166 int gobble(struct filepointer *filep,
 167            struct inclist *file,
 168            struct inclist *file_red,
 169            struct symhash *symbols)
 170 {
 171     char   *line;
 172     int    type;
 173
 174     while ((line = get_line(filep))) {
 175         switch(type = deftype(line, filep, file_red, file, FALSE, symbols)) {
 176         case IF:
 177         case IFFALSE:
 178         case IFGUESSFALSE:
 179         case IFDEF:
 180         case IFNDEF:
 181             type = gobble(filep, file, file_red, symbols);
 182             while ((type == ELIF) || (type == ELIFFALSE) ||
 183                    (type == ELIFGUESSFALSE))
 184                 type = gobble(filep, file, file_red, symbols);
 185             if (type == ELSE)
 186                     (void)gobble(filep, file, file_red, symbols);
 187             break;
 188         case ELSE:
 189         case ENDIF:
 190             debug(0,("%s, line %d: #%s\n",
 191                 file->i_file, filep->f_line,
 192                 directives[type]));
 193             return type;
 194         case DEFINE:
 195         case UNDEF:
 196         case INCLUDE:
 197         case INCLUDEDOT:
 198         case PRAGMA:
 199         case ERROR:
 200         case IDENT:
 201         case SCCS:
 202         case EJECT:
 203             break;
 204         case ELIF:
 205         case ELIFFALSE:
 206         case ELIFGUESSFALSE:
 207             return type;
 208         case -1:
 209             warning("%s, line %d: unknown directive == \"%s\"\n",
 210                 file_red->i_file, filep->f_line, line);
 211             break;
 212         }
 213     }
 214     return -1;
 215 }
 216
 217 /*
 218  * Decide what type of # directive this line is.
 219  */
 220 int deftype (char *line, struct filepointer *filep, struct inclist *file_red, struct inclist *file, int parse_it, struct symhash *symbols)
 221 {
 222     char   *p;
 223     char    *directive, savechar;
 224     int    ret;
 225
 226     /*
 227      * Parse the directive...
 228      */
 229     directive=line+1;
 230     while (*directive == ' ' || *directive == '\t')
 231         directive++;
 232
 233     p = directive;
 234     while (*p >= 'a' && *p <= 'z')
 235         p++;
 236     savechar = *p;
 237     *p = '\0';
 238     ret = match(directive, directives);
 239     *p = savechar;
 240
 241     /* If we don't recognize this compiler directive or we happen to just
 242      * be gobbling up text while waiting for an #endif or #elif or #else
 243      * in the case of an #elif we must check the zero_value and return an
 244      * ELIF or an ELIFFALSE.
 245      */
 246
 247     if (ret == ELIF && !parse_it)
 248     {
 249         while (*p == ' ' || *p == '\t')
 250             p++;
 251         /*
 252          * parse an expression.
 253          */
 254         debug(0,("%s, line %d: #elif %s ",
 255            file->i_file, filep->f_line, p));
 256         ret = zero_value(p, filep, file_red, symbols);
 257         if (ret != IF)
 258         {
 259           debug(0,("false...\n"));
 260           if (ret == IFFALSE)
 261               return ELIFFALSE;
 262           else
 263               return ELIFGUESSFALSE;
 264           }
 265         else
 266         {
 267           debug(0,("true...\n"));
 268           return ELIF;
 269         }
 270     }
 271
 272     if (ret < 0 || ! parse_it)
 273         return ret;
 274
 275     /*
 276      * now decide how to parse the directive, and do it.
 277      */
 278     while (*p == ' ' || *p == '\t')
 279         p++;
 280     switch (ret) {
 281     case IF:
 282         /*
 283          * parse an expression.
 284          */
 285         ret = zero_value(p, filep, file_red, symbols);
 286         debug(0,("%s, line %d: %s #if %s\n",
 287              file->i_file, filep->f_line, ret?"false":"true", p));
 288         break;
 289     case IFDEF:
 290     case IFNDEF:
 291         debug(0,("%s, line %d: #%s %s\n",
 292             file->i_file, filep->f_line, directives[ret], p));
 293         //fall-through
 294     case UNDEF:
 295         /*
 296          * separate the name of a single symbol.
 297          */
 298         while (isalnum((unsigned char)*p) || *p == '_')
 299             *line++ = *p++;
 300         *line = '\0';
 301         break;
 302     case INCLUDE:
 303         debug(2,("%s, line %d: #include %s\n",
 304             file->i_file, filep->f_line, p));
 305
 306         /* Support ANSI macro substitution */
 307         {
 308             char *sym = hash_lookup(p, symbols);
 309             while (sym)
 310             {
 311                 p = sym;
 312                 debug(3,("%s : #includes SYMBOL %s\n",
 313                             file->i_incstring,
 314                             sym));
 315                 /* mark file as having included a 'soft include' */
 316                 file->i_included_sym = TRUE;
 317                 sym = hash_lookup(p, symbols);
 318             }
 319         }
 320
 321         /*
 322          * Separate the name of the include file.
 323          */
 324         while (*p && *p != '"' && *p != '<')
 325             p++;
 326         if (! *p)
 327             return -2;
 328         if (*p++ == '"') {
 329             ret = INCLUDEDOT;
 330             while (*p && *p != '"')
 331                 *line++ = *p++;
 332         } else
 333             while (*p && *p != '>')
 334                 *line++ = *p++;
 335         *line = '\0';
 336         break;
 337     case DEFINE:
 338         /*
 339          * copy the definition back to the beginning of the line.
 340          */
 341         memmove (line, p, strlen(p));
 342         break;
 343     case ELSE:
 344     case ENDIF:
 345     case ELIF:
 346     case PRAGMA:
 347     case ERROR:
 348     case IDENT:
 349     case SCCS:
 350     case EJECT:
 351         debug(0,("%s, line %d: #%s\n",
 352             file->i_file, filep->f_line, directives[ret]));
 353         /*
 354          * nothing to do.
 355          */
 356         break;
 357     }
 358     return ret;
 359 }
 360
 361 /*
 362  * HACK! - so that we do not have to introduce 'symbols' in each cppsetup.c
 363  * function...  It's safe, functions from cppsetup.c don't return here.
 364  */
 365 static struct symhash *global_symbols = NULL;
 366
 367 char * isdefined( char *symbol )
 368 {
 369     return hash_lookup( symbol, global_symbols );
 370 }
 371
 372 /*
 373  * Return type based on if the #if expression evaluates to 0
 374  */
 375 int zero_value(char *exp, struct filepointer *filep, struct inclist *file_red, struct symhash *symbols)
 376 {
 377     global_symbols = symbols; /* HACK! see above */
 378     if (cppsetup(exp, filep, file_red))
 379         return IFFALSE;
 380     else
 381         return IF;
 382 }
 383
 384 void define( char *def, struct symhash **symbols )
 385 {
 386     char *val;
 387
 388     /* Separate symbol name and its value */
 389     val = def;
 390     while (isalnum((unsigned char)*val) || *val == '_')
 391         val++;
 392     if (*val)
 393         *val++ = '\0';
 394     while (*val == ' ' || *val == '\t')
 395         val++;
 396
 397     if (!*val)
 398         val = "1";
 399     hash_define( def, val, symbols );
 400 }
 401
 402 static int hash( char *str )
 403 {
 404     /* Hash (Kernighan and Ritchie) */
 405     unsigned int hashval = 0;
 406
 407     for ( ; *str; str++ )
 408     {
 409         hashval = ( hashval * SYMHASHSEED ) + ( *str );
 410     }
 411
 412     return hashval & ( SYMHASHMEMBERS - 1 );
 413 }
 414
 415 struct symhash *hash_copy( struct symhash *symbols )
 416 {
 417     int i;
 418     struct symhash *newsym;
 419     if ( !symbols )
 420         return NULL;
 421
 422     newsym = (struct symhash *) malloc( sizeof( struct symhash ) );
 423
 424     for ( i = 0; i < SYMHASHMEMBERS; ++i )
 425     {
 426         if ( !symbols->s_pairs[ i ] )
 427             newsym->s_pairs[ i ] = NULL;
 428         else
 429         {
 430             struct pair *it = symbols->s_pairs[ i ];
 431             struct pair *nw = newsym->s_pairs[ i ] = (struct pair*) malloc( sizeof( struct pair ) );
 432             nw->p_name = it->p_name;
 433             nw->p_value = it->p_value;
 434             nw->p_next = NULL;
 435
 436             while ( it->p_next )
 437             {
 438                 nw->p_next = (struct pair*) malloc( sizeof( struct pair ) );
 439                 it = it->p_next;
 440                 nw = nw->p_next;
 441                 nw->p_name = it->p_name;
 442                 nw->p_value = it->p_value;
 443                 nw->p_next = NULL;
 444             }
 445         }
 446     }
 447     return newsym;
 448 }
 449
 450 void hash_free( struct symhash *symbols )
 451 {
 452     int i;
 453
 454     if ( !symbols )
 455         return;
 456
 457     for ( i = 0; i < SYMHASHMEMBERS; ++i )
 458     {
 459         struct pair *it = symbols->s_pairs[ i ];
 460         struct pair *next;
 461         while ( it )
 462         {
 463             next = it->p_next;
 464             free( it );
 465             it = next;
 466         }
 467     }
 468     free( symbols->s_pairs );
 469 }
 470
 471 void hash_define( char *name, char *val, struct symhash **symbols )
 472 {
 473     int hashval;
 474     struct pair *it;
 475
 476     if ( !symbols )
 477         return;
 478
 479     /* Make space if it's needed */
 480     if ( *symbols == NULL )
 481     {
 482         int i;
 483
 484         *symbols = (struct symhash *) malloc( sizeof( struct symhash ) );
 485         if ( *symbols == NULL )
 486             fatalerr( "malloc()/realloc() failure in insert_defn()\n" );
 487
 488         for ( i = 0; i < SYMHASHMEMBERS; ++i )
 489             (*symbols)->s_pairs[i] = NULL;
 490     }
 491
 492     hashval = hash( name );
 493     it = (*symbols)->s_pairs[ hashval ];
 494
 495     /* Replace/insert the symbol */
 496     if ( it == NULL )
 497     {
 498         it = (*symbols)->s_pairs[ hashval ] = (struct pair*) malloc( sizeof( struct pair ) );
 499         it->p_name = copy( name );
 500         it->p_value = copy( val );
 501         it->p_next = NULL;
 502     }
 503     else if ( strcmp( it->p_name, name ) == 0 )
 504     {
 505         it->p_value = copy( val );
 506     }
 507     else
 508     {
 509         while ( it->p_next && ( strcmp( it->p_next->p_name, name ) != 0 ) )
 510         {
 511             it = it->p_next;
 512         }
 513         if ( it->p_next )
 514             it->p_next->p_name = copy( name );
 515         else
 516         {
 517             it->p_next = (struct pair*) malloc( sizeof( struct pair ) );
 518             it->p_next->p_name = copy( name );
 519             it->p_next->p_value = copy( val );
 520             it->p_next->p_next = NULL;
 521         }
 522     }
 523 }
 524
 525 char *hash_lookup( char *symbol, struct symhash *symbols )
 526 {
 527     struct pair *it;
 528
 529     if ( !symbols )
 530         return NULL;
 531
 532     it = symbols->s_pairs[ hash( symbol ) ];
 533
 534     while ( it && ( strcmp( it->p_name, symbol ) != 0 ) )
 535     {
 536         it = it->p_next;
 537     }
 538     if ( it )
 539         return it->p_value;
 540
 541     return NULL;
 542 }
 543
 544 void hash_undefine( char *symbol, struct symhash *symbols )
 545 {
 546     int hashval;
 547     struct pair *it;
 548
 549     if ( !symbols )
 550         return;
 551
 552     hashval = hash( symbol );
 553     it = symbols->s_pairs[ hashval ];
 554
 555     /* Replace/insert the symbol */
 556     if ( it == NULL )
 557         return;
 558     else if ( strcmp( it->p_name, symbol ) == 0 )
 559     {
 560         if ( it->p_next )
 561         {
 562             struct pair *tmp;
 563             it->p_name = it->p_next->p_name;
 564             it->p_value = it->p_next->p_value;
 565             tmp = it->p_next->p_next;
 566             free( it->p_next );
 567             it->p_next = tmp;
 568         }
 569         else
 570         {
 571             free( it );
 572             symbols->s_pairs[ hashval ] = NULL;
 573         }
 574     }
 575     else
 576     {
 577         while ( it->p_next && ( strcmp( it->p_next->p_name, symbol ) != 0 ) )
 578         {
 579             it = it->p_next;
 580         }
 581         if ( it->p_next )
 582         {
 583             struct pair *tmp = it->p_next;
 584             it->p_next = it->p_next->p_next;
 585             free( tmp );
 586         }
 587     }
 588 }
 589
 590 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */