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