dmake/rulparse.c

   1 /* $RCSfile: rulparse.c,v $
   2 -- $Revision: 1.12 $
   3 -- last change: $Author: ihi $ $Date: 2007-10-15 15:41:24 $
   4 --
   5 -- SYNOPSIS
   6 --      Perform semantic analysis on input
   7 --
   8 -- DESCRIPTION
   9 --  This code performs semantic analysis on the input, and builds
  10 --  the complex internal datastructure that is used to represent
  11 --  the user makefile.
  12 --
  13 -- AUTHOR
  14 --      Dennis Vadura, dvadura@dmake.wticorp.com
  15 --
  16 -- WWW
  17 --      http://dmake.wticorp.com/
  18 --
  19 -- COPYRIGHT
  20 --      Copyright (c) 1996,1997 by WTI Corp.  All rights reserved.
  21 --
  22 --      This program is NOT free software; you can redistribute it and/or
  23 --      modify it under the terms of the Software License Agreement Provided
  24 --      in the file <distribution-root>/readme/license.txt.
  25 --
  26 -- LOG
  27 --      Use cvs log to obtain detailed change logs.
  28 */
  29
  30 #include "extern.h"
  31
  32 /* prototypes for local functions */
  33 static  void    _add_indirect_prereq ANSI((CELLPTR));
  34 static  int     _add_root ANSI((CELLPTR));
  35 static  CELLPTR _build_graph ANSI((int, CELLPTR, CELLPTR));
  36 static  char*   _build_meta ANSI((char*));
  37 static  int _do_magic ANSI((int, char*, CELLPTR, CELLPTR, t_attr, char*));
  38 static  void    _do_special ANSI((int, int, t_attr,char*,CELLPTR,CELLPTR,int*));
  39 static  int _do_targets ANSI((int, t_attr, char*, CELLPTR, CELLPTR));
  40 static  t_attr  _is_attribute ANSI((char*));
  41 static  int _is_special ANSI((char*));
  42 static  char*   _is_magic ANSI((char*));
  43 static  int _is_percent ANSI((char*));
  44 static  CELLPTR _make_multi ANSI((CELLPTR));
  45 static  CELLPTR _replace_cell ANSI((CELLPTR,CELLPTR,CELLPTR));
  46 static  void    _set_attributes ANSI((t_attr, char*, CELLPTR ));
  47 static  void    _stick_at_head ANSI((CELLPTR, CELLPTR));
  48 static  void    _set_global_attr ANSI((t_attr));
  49
  50
  51 /* static variables that must persist across invocation of Parse_rule_def */
  52 static CELLPTR    _sv_targets = NIL(CELL);
  53 static STRINGPTR  _sv_rules   = NIL(STRING); /* first recipe element. */
  54 static STRINGPTR  _sv_crule   = NIL(STRING); /* current/last recipe element. */
  55 static CELLPTR    _sv_edgel   = NIL(CELL);
  56 static LINKPTR    _sv_ind_prq = NIL(LINK);   /* indirect prerequisites for % cell */
  57 static int    _sp_target  = FALSE;
  58 static t_attr     _sv_attr;
  59 static int        _sv_flag;
  60 static int    _sv_op;
  61 static char      *_sv_setdir;
  62 static char   _sv_globprq_only = 0;
  63
  64 /* Define for global attribute mask (A_SWAP == A_WINPATH) */
  65 #define A_GLOB   (A_PRECIOUS | A_SILENT | A_IGNORE | A_EPILOG | A_SWAP |\
  66           A_SHELL | A_PROLOG | A_NOINFER | A_SEQ | A_MKSARGS )
  67
  68
  69 PUBLIC int
  70 Parse_rule_def( state )/*
  71 =========================
  72    Parse the rule definition contained in Buffer, and modify the state
  73    if appropriate.  The function returns 0, if the definition is found to
  74    be an illegal rule definition, and it returns 1 if it is a rule definition.
  75    */
  76 int *state;
  77 {
  78   TKSTR     input;      /* input string struct for token search   */
  79   CELLPTR   targets;    /* list of targets if any         */
  80   CELLPTR   prereq;     /* list of prereq if any          */
  81   CELLPTR   prereqtail; /* tail of prerequisite list          */
  82   CELLPTR   cp;     /* temporary cell pointer for list making */
  83   char  *result;    /* temporary storage for result       */
  84   char      *tok;       /* temporary pointer for tokens       */
  85   char         *set_dir;       /* value of setdir attribute              */
  86   char      *brk;       /* break char list for Get_token      */
  87   char         *firstrcp;      /* first recipe line, from ; in rule line */
  88   t_attr       attr;           /* sum of attribute flags for current tgts*/
  89   t_attr    at;     /* temp place to keep an attribute code   */
  90   int       op;     /* rule operator              */
  91   int       special;    /* indicate special targets in rule   */
  92   int       augmeta;    /* indicate .<suffix> like target     */
  93   int       percent;    /* indicate percent rule target       */
  94   int       percent_prq;    /* indicate mixed %-rule prereq possible  */
  95
  96   DB_ENTER( "Parse_rule_def" );
  97
  98   op          = 0;
  99   attr       = 0;
 100   special    = 0;
 101   augmeta    = 0;
 102   percent    = 0;
 103   set_dir    = NIL( char );
 104   targets    = NIL(CELL);
 105   prereq     = NIL(CELL);
 106   prereqtail = NIL(CELL);
 107   percent_prq = 0;
 108
 109   /* Check to see if the line is of the form:
 110    *    targets : prerequisites; first recipe line
 111    * If so remember the first_recipe part of the line. */
 112
 113   firstrcp = strchr( Buffer, ';' );
 114   if( firstrcp != NIL( char ) ) {
 115     *firstrcp++ = 0;
 116     firstrcp = DmStrSpn( firstrcp, " \t" );
 117   }
 118
 119   result = Expand( Buffer );
 120   /* Remove CONTINUATION_CHAR, keep the <nl> */
 121   for( brk=strchr(result,CONTINUATION_CHAR); brk != NIL(char); brk=strchr(brk,CONTINUATION_CHAR) )
 122     if( brk[1] == '\n' )
 123       *brk = ' ';
 124     else
 125       brk++;
 126
 127   DB_PRINT( "par", ("Scanning: [%s]", result) );
 128
 129   SET_TOKEN( &input, result );
 130   brk = ":-^!|";
 131   Def_targets = TRUE;
 132
 133   /* Scan the input rule line collecting targets, the operator, and any
 134    * prerequisites.  Stop when we run out of targets and prerequisites. */
 135
 136   while( *(tok = Get_token( &input, brk, TRUE )) != '\0' )
 137     if( !op ) {
 138       /* we are scanning targets and attributes
 139        * check to see if token is an operator.  */
 140
 141       op = Rule_op( tok );
 142
 143       if( !op ) {
 144         /* Define a new cell, or get pointer to pre-existing cell.  */
 145         /* Do we need cells for attributes? If not move the definition
 146          * to the target part.  */
 147         cp = Def_cell( tok );
 148         /* A $ character indicates either a literal $ in the pathname (this
 149          * was broken before) or a dynamic macro (this is a syntax error).
 150          * FIXME: Here would be the place to add a sanity check. */
 151         DB_PRINT( "par", ("tg_cell [%s]", tok) );
 152
 153         if( (at = _is_attribute(tok)) != 0 ) {
 154           /* Ignore .SILENT when -vr is active. */
 155           if( (Verbose & V_FORCEECHO) && (at == A_SILENT) )
 156             at = 0;
 157
 158           /* Logically OR the attributes specified into one main
 159            * ATTRIBUTE mask. */
 160
 161           if( at == A_SETDIR ) {
 162             if( set_dir != NIL( char ) )
 163               Warning( "Multiple .SETDIR attribute ignored" );
 164             else
 165               set_dir = DmStrDup( tok );
 166           }
 167
 168           attr |= at;
 169         }
 170         else {
 171           /* Not an attribute, this must be a target. */
 172           int tmp;
 173
 174           tmp = _is_special( tok );
 175
 176           if( _is_percent( tok ) ) {
 177             /* First %-target checks if there were non-%-targets before. */
 178             if( !percent && targets != NIL(CELL) )
 179               Fatal( "A %%-target must not be mixed with non-%%-targets, offending target [%s]", tok );
 180
 181             percent++;
 182             cp->ce_flag |= F_PERCENT;
 183           } else {
 184             if( percent )
 185               Fatal( "A non-%%-target must not be mixed with %%-targets, offending target [%s]", tok );
 186           }
 187
 188           if( _is_magic( tok ) ) {
 189             /* Check that AUGMAKE targets are not mixed with other
 190              * targets. The return value of _is_magic() is discarded and
 191              * calculated again in _do_targets() if this rule definition
 192              * really is a .<suffix> like target.
 193              * If we would allow only one target per line we could easily
 194              * store the result for later, but for multiple .<suffix>
 195              * targets this creates too much overhead.
 196              * These targets should be rare (obsolete?) anyway. */
 197             if( !augmeta && targets != NIL(CELL) )
 198               Fatal( "An AUGMAKE meta target must not be mixed with non AUGMAKE meta targets, offending target [%s]", tok );
 199
 200             augmeta++;
 201             cp->ce_flag |= F_MAGIC; /* do_magic will also add F_PERCENT later. */
 202           } else {
 203             if( augmeta )
 204               Fatal( "A non AUGMAKE meta target must not be mixed with AUGMAKE meta targets, offending target [%s]", tok );
 205           }
 206
 207           if( special )
 208             Fatal( "Special target must appear alone, found [%s]", tok );
 209           else if( !(cp->ce_flag & F_MARK) ) {
 210             /* Targets are kept in this list in lexically sorted order.
 211              * This allows for easy equality comparison of target
 212              * sets.*/
 213             CELLPTR prev,cur;
 214             for(prev=NIL(CELL),cur=targets;cur;prev=cur,cur=cur->ce_link)
 215               if(strcmp(cur->CE_NAME,cp->CE_NAME) > 0)
 216                 break;
 217
 218             cp->ce_link = cur;
 219
 220             if (!prev)
 221               targets = cp;
 222             else
 223               prev->ce_link = cp;
 224
 225             cp->ce_flag |= F_MARK | F_EXPLICIT;
 226             special = tmp;
 227           }
 228           else
 229             Warning( "Duplicate target [%s]", cp->CE_NAME );
 230         }
 231       }
 232       else {
 233         /* found an operator so empty out break list and clear mark
 234          * bits on target list, setting them all to F_VISITED*/
 235
 236         brk  = "";
 237         for( cp=targets; cp != NIL(CELL); cp=cp->ce_link ) {
 238           cp->ce_flag ^= F_MARK;
 239           cp->ce_flag |= F_VISITED;
 240         }
 241
 242         Def_targets = FALSE;
 243       }
 244     }
 245     else {
 246       /* Scanning prerequisites so build the prerequisite list.  We use
 247        * F_MARK flag to make certain we have only a single copy of the
 248        * prerequisite in the list */
 249
 250       cp = Def_cell( tok );
 251
 252       /* %-prerequisits require eiter a %-target or this might be a rule of
 253        * the "ATTRIBUTE_LIST : targets" form. */
 254       if( _is_percent( tok ) ) {
 255         if( percent || ((targets == NIL(CELL)) && attr) )
 256           percent_prq = 1;
 257         else
 258           Fatal( "Syntax error in %% rule, missing %% target");
 259       }
 260
 261       if( cp->ce_flag & F_VISITED ) {
 262         if( cp->ce_attr & A_COMPOSITE )
 263           continue;
 264         else
 265           Fatal( "Detected circular dependency in graph at [%s]",
 266                  cp->CE_NAME );
 267       }
 268       else if( !(cp->ce_flag & F_MARK) ) {
 269         DB_PRINT( "par", ("pq_cell [%s]", tok) );
 270         cp->ce_flag |= F_MARK;
 271
 272         if( prereqtail == NIL(CELL) )   /* keep prereq's in order */
 273           prereq = cp;
 274         else
 275           prereqtail->ce_link = cp;
 276
 277         prereqtail = cp;
 278         cp->ce_link = NIL(CELL);
 279       }
 280       else if( !(cp->ce_attr & A_LIBRARY) && (Verbose & V_WARNALL))
 281         Warning("Duplicate entry [%s] in prerequisite list",cp->CE_NAME);
 282     }
 283
 284   /* Check to see if we have a percent rule that has only global
 285    * prerequisites, i.e. they are of the form: "%.a : foo".
 286    * If so then set the flag so that later on, we don't issue
 287    * an error if such targets supply an empty set of rules. */
 288
 289   if( percent && !percent_prq && (prereq != NIL(CELL)) )
 290     _sv_globprq_only = 1;
 291
 292   /* It's ok to have targets with attributes, and no prerequisites, but it's
 293    * not ok to have no targets and no attributes, or no operator */
 294
 295   CLEAR_TOKEN( &input ); FREE(result); result = NIL(char);
 296   if( !op ) {
 297     DB_PRINT( "par", ("Not a rule [%s]", Buffer) );
 298     DB_RETURN( 0 );
 299   }
 300
 301   /* More than one percent target didn't work with prior versions. */
 302 #if 0
 303   if( (percent > 1) && !(op & R_OP_OR) )
 304     Warning( "Prior to dmake 4.5 only one\n"
 305              "%%-target per target-definition worked reliably. Check your makefiles.\n" );
 306 #endif
 307
 308   if( !attr && targets == NIL(CELL) ) {
 309     Fatal( "Missing targets or attributes in rule" );
 310     if( set_dir != NIL( char )) FREE( set_dir );
 311     DB_RETURN( 0 );
 312   }
 313
 314   /* We have established we have a legal rules line, so we must process it.
 315    * In doing so we must handle any special targets.  Special targets must
 316    * appear alone possibly accompanied by attributes.
 317    * NOTE:  special != 0  ==> targets != NIL(CELL) */
 318
 319   if( prereqtail != NIL(CELL) ) prereqtail->ce_link = NIL(CELL);
 320
 321   /* Clear out MARK bits used in duplicate checking.  I originally wanted
 322    * to do this as the lists get processed but that got too error prone
 323    * so I bit the bullit and added these two loops. */
 324
 325   for( cp=prereq;  cp != NIL(CELL); cp=cp->ce_link ) cp->ce_flag &= ~F_MARK;
 326   for( cp=targets; cp != NIL(CELL); cp=cp->ce_link ) cp->ce_flag &= ~F_VISITED;
 327
 328   /* Check to see if the previous recipe was bound, if not the call
 329    * Bind_rules_to_targets() to bind the recipe (_sv_rules) to the
 330    * target(s) (_sv_targets). */
 331   /* was:  if( _sv_rules != NIL(STRING) ) Bind_rules_to_targets( F_DEFAULT );*/
 332   /* Only Add_recipe_to_list() sets _sv_rules and Bind_rules_to_targets()
 333    * clears the (static) variables again.  Bind_rules_to_targets() is
 334    * (should be) called after State is leaving RULE_SCAN in Parse().
 335    * Abort if there are unbound recipes. FIXME: Remove this paragraph
 336    * if this never occurs.  */
 337   if( _sv_rules != NIL(STRING) )
 338     Fatal( "Internal Error: _sv_rules not empty." );
 339
 340   /* Add the first recipe line to the list */
 341   if( firstrcp != NIL( char ) )
 342     Add_recipe_to_list( firstrcp, TRUE, FALSE );
 343
 344   /* Save these prior to calling _do_targets, since _build_graph needs the
 345    * _sv_setdir value for matching edges. */
 346   _sv_op     = op;
 347   _sv_setdir = set_dir;
 348
 349   if( special )
 350     /* _do_special() can alter *state */
 351     _do_special( special, op, attr, set_dir, targets, prereq, state );
 352   else
 353     *state = _do_targets( op, attr, set_dir, targets, prereq );
 354
 355   if( (*state != RULE_SCAN) && (_sv_rules != NIL(STRING)) )
 356     Fatal( "Unexpected recipe found." );
 357
 358   DB_RETURN( 1 );
 359 }
 360
 361
 362 PUBLIC int
 363 Rule_op( op )/*
 364 ================
 365    Check the passed in op string and map it to one of the rule operators */
 366 char *op;
 367 {
 368    int ret = 0;
 369
 370    DB_ENTER( "rule_op" );
 371
 372    if( *op == TGT_DEP_SEP ) {
 373       ret = R_OP_CL;
 374       op++;
 375
 376       /* All rule operations begin with a :, but may include any one of the
 377        * four modifiers.  In order for the rule to be properly mapped we must
 378        * check for each of the modifiers in turn, building up our return bit
 379        * string. */
 380
 381       while( *op && ret )
 382          switch( *op ) {
 383         case ':': ret |= R_OP_DCL; op++; break;
 384         case '!': ret |= R_OP_BG;  op++; break;
 385         case '^': ret |= R_OP_UP;  op++; break;
 386         case '-': ret |= R_OP_MI;  op++; break;
 387         case '|': ret |= R_OP_OR;  op++; break;
 388
 389         default : ret  = 0;  /* an invalid modifier, chuck whole string */
 390          }
 391
 392       if( *op != '\0' ) ret = 0;
 393    }
 394
 395    DB_RETURN( ret );
 396 }
 397
 398
 399 PUBLIC void
 400 Add_recipe_to_list( rule, white_too, no_check )/*
 401 =================================================
 402         Take the provided string and add it to the list of recipe lines
 403     we are saving to be added to the list of targets we have built
 404     previously.  If white_too == TRUE add the rule EVEN IF it contains only
 405         an empty string (whitespace is handled by Def_recipe()). */
 406 char *rule;
 407 int  white_too;
 408 int  no_check;
 409 {
 410    DB_ENTER( "Add_recipe_to_list" );
 411
 412    if( rule != NIL( char ) && (*rule != '\0' || white_too) ) {
 413       DB_PRINT( "par", ("Adding recipe [%s]", rule) );
 414       _sv_crule = Def_recipe( rule, _sv_crule, white_too, no_check );
 415
 416       /* If _sv_rules is not yet set this must be the first recipe line,
 417        * remember it. */
 418       if( _sv_rules == NIL(STRING) )
 419          _sv_rules = _sv_crule;
 420    }
 421
 422    DB_VOID_RETURN;
 423 }
 424
 425
 426 PUBLIC void
 427 Bind_rules_to_targets( flag )/*
 428 ===============================
 429         Take the recipe lines we have defined and bind them with proper attributes
 430         to the targets that were previously defined in the parse.  The
 431         attributes that get passed here are merged with those that are were
 432         previously defined.  (namely attribute F_SINGLE) */
 433 int flag;
 434 {
 435    CELLPTR tg;             /* pointer to current target in list */
 436    LINKPTR lp;         /* pointer to link cell      */
 437    int     magic;          /* TRUE if target of % or .xxx.yyy form */
 438    int     tflag;          /* TRUE if we assigned targets here  */
 439
 440    DB_ENTER( "Bind_rules_to_targets" );
 441
 442    /* This line is needed since Parse may call us twice when the last
 443     * GROUP rule appears at the end of file.  In this case the rules
 444     * have already been bound and we want to ignore them. */
 445
 446    if( _sv_targets == NIL(CELL) ) { DB_VOID_RETURN; }
 447
 448    tflag  = FALSE;
 449    flag  |= (_sv_flag & F_SINGLE);
 450    flag  |= ((_sv_attr & A_GROUP) ? F_GROUP : 0);
 451
 452    for( tg = _sv_targets; tg != NIL(CELL); tg = tg->ce_link ) {
 453       DB_PRINT( "par", ("Binding to %s, %04x", tg->CE_NAME, tg->ce_flag) );
 454       magic = tg->ce_flag & F_PERCENT;
 455
 456
 457       /* NOTE:  For targets that are magic or special we ignore any
 458        * previously defined rules, ie. We throw away the old definition
 459        * and use the new, otherwise we complain. */
 460       if( !(tg->ce_flag & F_MULTI) && !magic && (tg->CE_RECIPE != NIL(STRING))
 461       && !_sp_target && (_sv_rules != NIL(STRING)) )
 462          Fatal( "Multiply defined recipe for target %s", tg->CE_NAME );
 463
 464       if( (magic || _sp_target) && (_sv_rules == NIL(STRING)) &&
 465       !(tg->ce_flag & F_SPECIAL) && !_sv_globprq_only )
 466          Warning( "Empty recipe for special or meta target %s", tg->CE_NAME );
 467
 468       if( magic ) {
 469      CELLPTR ep;
 470
 471      for( ep=_sv_edgel; ep != NIL(CELL); ep=ep->ce_link ) {
 472         DB_PRINT( "par", ("ep address: %#x", ep) );
 473         /* %.xx :| '%.yy' abc xx '%.tt' ; touch $@
 474          * loops here ... */
 475         _set_attributes( _sv_attr, _sv_setdir, ep );
 476         ep->ce_flag |= (F_TARGET|flag);
 477
 478         if( _sv_rules != NIL(STRING) ) {
 479            ep->ce_recipe  = _sv_rules;
 480            ep->ce_indprq  = _sv_ind_prq;
 481         }
 482      }
 483       }
 484       else {
 485      tg->ce_attr |= _sv_attr;
 486      tg->ce_flag |= flag;
 487
 488      if( _sv_rules != NIL(STRING) ) {
 489         tg->ce_recipe  = _sv_rules;
 490         tg->ce_flag   |= F_RULES | F_TARGET;
 491
 492         /* Bind the current set of prerequisites as belonging to the
 493          * original recipe given for the target */
 494         for( lp=tg->ce_prq; lp != NIL(LINK); lp = lp->cl_next )
 495           if( !(lp->cl_flag & F_VISITED) ) lp->cl_flag |= F_TARGET;
 496          }
 497      else for( lp=tg->ce_prq; lp != NIL(LINK); lp = lp->cl_next )
 498         lp->cl_flag |= F_VISITED;
 499       }
 500
 501       tflag |= _add_root(tg);
 502    }
 503
 504    if( tflag ) Target = TRUE;
 505    if( _sv_setdir ) FREE(_sv_setdir);
 506    _sv_rules   = NIL(STRING);
 507    _sv_crule   = NIL(STRING);
 508    _sv_targets = NIL(CELL);
 509    _sv_ind_prq = NIL(LINK);
 510    _sv_edgel   = NIL(CELL);
 511    _sp_target  = FALSE;
 512    _sv_globprq_only = 0;
 513
 514    DB_VOID_RETURN;
 515 }
 516
 517
 518
 519 PUBLIC int
 520 Set_group_attributes( list )/*
 521 ==============================
 522     Scan list looking for the standard @,-,% and + (as in recipe line
 523     defs) (+ is set but ignored for group recipes)
 524     and set the flags accordingly so that they apply when we bind the
 525     rules to the appropriate targets.
 526     Return TRUE if group recipe start '[' was found, otherwise FALSE.  */
 527 char *list;
 528 {
 529    int res = FALSE;
 530    char *s;
 531
 532    if ( !((_sv_attr|Glob_attr)&A_IGNOREGROUP) ) {
 533       s = DmStrSpn(list,"@-%+ \t");
 534       res = (*s == '[');
 535       if( res ) {
 536      /* Check for non-white space characters after the [. */
 537      for( s++; *s && iswhite(*s) ; s++ )
 538         ;
 539      if( *s )
 540         Warning("Found non-white space character after '[' in [%s].", list);
 541
 542      _sv_attr |= Rcp_attribute(list);
 543       }
 544    }
 545
 546    return(res);
 547 }
 548
 549
 550 static void
 551 _do_special( special, op, attr, set_dir, target, prereq, state )/*
 552 ==================================================================
 553    Process a special target (always only a single target).  So far the only
 554    special targets we have are those recognized by the _is_special function.
 555    Some of the special targets can take recipes, they call _do_targets()
 556    and (implicitly) set *state to to RULE_SCAN. Otherwise *state remains
 557    unaffected, i.e. NORMAL_SCAN.
 558
 559    target is always only a single special target.
 560
 561    NOTE:  For the cases of .IMPORT, and .INCLUDE, the cells created by the
 562          parser are never freed.  This is due to the fact that it is too much
 563       trouble to get them out of the hash table once they are defined, and
 564       if they are per chance used again it will be ok, anyway, since the
 565       cell is not really used by the code below.  */
 566
 567 int special;
 568 int op;
 569 t_attr  attr;
 570 char    *set_dir;
 571 CELLPTR target;
 572 CELLPTR prereq;
 573 int     *state;
 574 {
 575   HASHPTR   hp;     /* pointer to macro def cell        */
 576   CELLPTR   cp;     /* temporary pointer into cells list    */
 577   CELLPTR   dp;     /* pointer to directory dir cell    */
 578   LINKPTR   lp;     /* pointer at prerequisite list     */
 579   char      *dir;       /* current dir to prepend       */
 580   char      *path;      /* resulting path to try to read    */
 581   char  *name;      /* File name for processing a .INCLUDE  */
 582   char      *tmp;       /* temporary string pointer     */
 583   FILE  *fil;       /* File descriptor returned by Openfile */
 584
 585   DB_ENTER( "_do_special" );
 586
 587   target->ce_flag = F_SPECIAL;  /* mark the target as special */
 588
 589   switch( special ) {
 590   case ST_EXPORT:
 591     for( ; prereq != NIL(CELL); prereq = prereq->ce_link ) {
 592       DB_PRINT( "par", ("Exporting [%s]", prereq->CE_NAME) );
 593       hp = GET_MACRO( prereq->CE_NAME );
 594
 595       if( hp != NIL(HASH) ) {
 596         char *tmpstr = hp->ht_value;
 597
 598         if( tmpstr == NIL(char) ) tmpstr = "";
 599
 600         if( Write_env_string( prereq->CE_NAME, tmpstr ) != 0 )
 601           Warning( "Could not export %s", prereq->CE_NAME );
 602       }
 603     }
 604     break;
 605
 606     /* Simply cause the parser to fail on the next input read */
 607   case ST_EXIT:
 608     Skip_to_eof = TRUE;
 609     break;
 610
 611   case ST_IMPORT:
 612     for( ; prereq != NIL(CELL); prereq = prereq->ce_link ) {
 613       char *tmpstr;
 614
 615       DB_PRINT( "par", ("Importing [%s]", prereq->CE_NAME) );
 616
 617       if( strcmp(prereq->CE_NAME, ".EVERYTHING") == 0 ) {
 618         t_attr sattr = Glob_attr;
 619         Glob_attr |= A_SILENT;
 620
 621         ReadEnvironment();
 622
 623         Glob_attr = sattr;
 624       }
 625       else {
 626         tmpstr = Read_env_string( prereq->CE_NAME );
 627
 628         if( tmpstr != NIL(char) )
 629           Def_macro(prereq->CE_NAME, tmpstr, M_EXPANDED|M_LITERAL);
 630         else
 631           if( !((Glob_attr | attr) & A_IGNORE) )
 632             Fatal("Imported macro `%s' not found",prereq->CE_NAME);
 633       }
 634     }
 635
 636     attr &= ~A_IGNORE;
 637     break;
 638
 639   case ST_INCLUDE:
 640     {
 641       int pushed     = FALSE;
 642       int first      = (attr & A_FIRST);
 643       int ignore     = (((Glob_attr | attr) & A_IGNORE) != 0);
 644       int found      = FALSE;
 645       int noinf      = (attr & A_NOINFER);
 646       LINKPTR prqlnk = NIL(LINK);
 647       LINKPTR prqlst = NIL(LINK);
 648
 649       if( prereq == NIL(CELL) )  Fatal( "No .INCLUDE file(s) specified" );
 650
 651       dp = Def_cell( ".INCLUDEDIRS" );
 652
 653       if( (attr & A_SETDIR) && *(dir = strchr(set_dir, '=')+1) )
 654         pushed = Push_dir( dir, ".INCLUDE", ignore );
 655
 656       for( cp=prereq; cp != NIL(CELL); cp = cp->ce_link ) {
 657         LINKPTR ltmp;
 658         TALLOC(ltmp, 1, LINK);
 659         ltmp->cl_prq = cp;
 660
 661         if( prqlnk == NIL(LINK) )
 662           prqlst = ltmp;
 663         else
 664           prqlnk->cl_next = ltmp;
 665
 666         prqlnk = ltmp;
 667       }
 668
 669       for( ; prqlst != NIL(LINK); FREE(prqlst), prqlst=prqlnk ) {
 670         prqlnk = prqlst->cl_next;
 671         cp     = prqlst->cl_prq;
 672         name   = cp->CE_NAME;
 673
 674         /* Leave this here, it ensures that prqlst gets propely free'd */
 675         if ( first && found )
 676           continue;
 677
 678         if( *name == '<' ) {
 679           /* We have a file name enclosed in <....>
 680            * so get rid of the <> arround the file name */
 681
 682           name++;
 683           if( (tmp = strrchr( name, '>' )) != NIL( char ) )
 684             *tmp = 0;
 685
 686           if( If_root_path( name ) )
 687             fil = Openfile( name, FALSE, FALSE );
 688           else
 689             fil = NIL(FILE);
 690         }
 691         else
 692           fil = Openfile( name, FALSE, FALSE );
 693
 694         if( fil == NIL(FILE) && !If_root_path( name ) ) { /*if true ==> not found in current dir*/
 695
 696           /* Now we must scan the list of prerequisites for .INCLUDEDIRS
 697            * looking for the file in each of the specified directories.
 698            * if we don't find it then we issue an error.  The error
 699            * message is suppressed if the .IGNORE attribute of attr is
 700            * set.  If a file is found we call Parse on the file to
 701            * perform the parse and then continue on from where we left
 702            * off.  */
 703
 704           for(lp=dp->CE_PRQ; lp && fil == NIL(FILE); lp=lp->cl_next) {
 705             dir  = lp->cl_prq->CE_NAME;
 706             if( strchr(dir, '$') ) dir = Expand(dir);
 707             path = Build_path( dir, name );
 708
 709             DB_PRINT( "par", ("Trying to include [%s]", path) );
 710
 711             fil = Openfile( path, FALSE, FALSE );
 712             if( dir != lp->cl_prq->CE_NAME ) FREE(dir);
 713           }
 714         }
 715
 716         if (!noinf && fil == NIL(FILE)) {
 717           t_attr glob = Glob_attr;
 718           t_attr cattr = prqlst->cl_prq->ce_attr;
 719
 720           prqlst->cl_next = NIL(LINK);
 721           Glob_attr |= (attr&A_IGNORE);
 722           prqlst->cl_prq->ce_attr &= ~A_FRINGE;
 723
 724           if( Verbose & V_FILE_IO )
 725             printf( "%s:  Inferring include file [%s].\n",
 726                     Pname, name );
 727           fil = TryFiles(prqlst);
 728
 729           Glob_attr = glob;
 730           prqlst->cl_prq->ce_attr |= (cattr & A_FRINGE);
 731         }
 732
 733         if( fil != NIL(FILE) ) {
 734           if( Verbose & V_FILE_IO )
 735             printf( "%s:  Parsing include file [%s].\n",
 736                     Pname, name );
 737           Parse( fil );
 738           found = TRUE;
 739         }
 740         else if( !(ignore || first) )
 741           Fatal( "Include file %s, not found", name );
 742         else if( Verbose & V_FILE_IO )
 743           printf( "%s:  Include file [%s] was not found.\n",
 744                   Pname, name );
 745       }
 746
 747       if ( !ignore && first && !found )
 748         Fatal( "No include file was found" );
 749
 750       if( pushed ) Pop_dir(FALSE);
 751       attr &= ~(A_IGNORE|A_SETDIR|A_FIRST|A_NOINFER);
 752     }
 753     break;
 754
 755   case ST_SOURCE:
 756     if( prereq != NIL(CELL) )
 757       _do_targets( op & (R_OP_CL | R_OP_MI | R_OP_UP), attr, set_dir,
 758                    target, prereq );
 759     else {
 760       /* The old semantics of .SOURCE were that an empty list of
 761        * prerequisites clears the .SOURCE list.  So we must implement
 762        * that here as a clearout prerequisite operation.  Since this is
 763        * a standard operation with the :- opcode we can simply call the
 764        * proper routine with the target cell and it should do the trick
 765        */
 766
 767       if( op == R_OP_CL || (op & R_OP_MI) )
 768         Clear_prerequisites( target );
 769     }
 770
 771     op &= ~(R_OP_MI | R_OP_UP);
 772     break;
 773
 774   case ST_KEEP:
 775     if( Keep_state != NIL(char) ) break;
 776     Def_macro( ".KEEP_STATE", "_state.mk", M_EXPANDED );
 777     break;
 778
 779   case ST_REST:
 780     /* The rest of the special targets can all take recipes, as such they
 781      * must be able to affect the state of the parser. */
 782
 783     {
 784       int s_targ = Target;
 785
 786       Target     = TRUE;
 787       _sp_target = TRUE;
 788       *state     = _do_targets( op, attr, set_dir, target, prereq );
 789       Target     = s_targ;
 790
 791       target->ce_flag |= F_TARGET;
 792
 793       attr    = A_DEFAULT;
 794       op      = R_OP_CL;
 795     }
 796     break;
 797
 798   default:break;
 799   }
 800
 801   if( op   != R_OP_CL   ) Warning( "Modifier(s) for operator ignored" );
 802   if( attr != A_DEFAULT ) Warning( "Extra attributes ignored" );
 803
 804   DB_VOID_RETURN;
 805 }
 806
 807
 808 static int
 809 _do_targets( op, attr, set_dir, targets, prereq )/*
 810 ===================================================
 811    Evaluate the values derived from the current target definition
 812    line. Helper functions _build_graph(), _do_magic(), _make_multi(),
 813    _add_root(), _replace_cell(), _set_attributes(), Clear_prerequisites()
 814    _stick_at_head(), Add_prerequisite() and _set_global_attr() are used.
 815    If successfull "_sv_targets" is set to "targets".
 816    Return RULE_SCAN if a recipe is expected to follow, otherwise
 817    NORMAL_SCAN. */
 818 int op;     /* rule operator                           */
 819 t_attr  attr;       /* attribute flags for current targets     */
 820 char    *set_dir;   /* value of setdir attribute               */
 821 CELLPTR targets;    /* list of targets (each cell maybe already
 822              * defined by a previous target definition
 823              * line.  */
 824 CELLPTR prereq;     /* list of prerequisites                   */
 825 {
 826    CELLPTR  tg1;        /* temporary target pointer     */
 827    CELLPTR  tp1;        /* temporary prerequisite pointer   */
 828    LINKPTR      prev_cell;  /* pointer for .UPDATEALL processing    */
 829    char     *p;     /* temporary char pointer       */
 830    int          tflag = FALSE;  /* set to TRUE if we add target to root */
 831    int          ret_state = RULE_SCAN;  /* Return state */
 832
 833    DB_ENTER( "_do_targets" );
 834
 835    /* If .UPDATEALL is set sort the target list that was temporary linked
 836     * with ce_link into a list using ce_link with ce_set pointing to the first
 837     * element. */
 838    /* FIXME: Check that .UPDATEALL and %-targets on one line work together. */
 839    if( attr & A_UPDATEALL ) {
 840       if( targets == NIL(CELL) )
 841      Fatal( ".UPDATEALL attribute requires non-empty list of targets" );
 842
 843       if (targets->ce_set == NIL(CELL)) {
 844      for(
 845         prev_cell=CeMeToo(targets),tg1=targets->ce_link;
 846         tg1 != NIL(CELL);
 847         tg1=tg1->ce_link
 848      ) {
 849         if (tg1->ce_set)
 850            Fatal( "Target [%s] appears on multiple .UPDATEALL lists",
 851               tg1->CE_NAME);
 852         tg1->ce_set = targets;
 853         TALLOC(prev_cell->cl_next, 1, LINK);
 854         prev_cell = prev_cell->cl_next;
 855         prev_cell->cl_prq = tg1;
 856      }
 857      targets->ce_set = targets;
 858       }
 859       else {
 860      LINKPTR ap;
 861      CELLPTR tp;
 862
 863      tp = targets;
 864      ap = CeMeToo(targets);
 865      while (ap && tp && ap->cl_prq == tp && tp->ce_set == targets) {
 866         ap = ap->cl_next;
 867         tp = tp->ce_link;
 868      }
 869      if (ap || tp)
 870         Fatal("Inconsistent .UPDATEALL lists for target [%s]",
 871           targets->CE_NAME);
 872       }
 873       targets->ce_link = NIL(CELL);
 874    }
 875
 876    for( tg1 = targets; tg1 != NIL(CELL); tg1 = tg1->ce_link ) {
 877       /* Check if tg1 is already marked as a %-target, but not a magic
 878        * (.xxx.yyy) target.  */
 879       int purepercent = (tg1->ce_flag & F_PERCENT) && !(tg1->ce_flag & F_MAGIC);
 880
 881       /* Check each target.  Check for inconsistencies between :: and : rule
 882        * sets.  :: may follow either : or :: but not the reverse.
 883        *
 884        * Any F_MULTI target (contains :: rules) is represented by a prerequisite
 885        * list hanging off the main target cell where each of the prerequisites
 886        * is a copy of the target cell but is not entered into the hash table.
 887        */
 888       if( !(op & R_OP_DCL ) && (tg1->ce_flag & F_MULTI) && !purepercent )
 889      Fatal( "':' vs '::' inconsistency in rules for %s", tg1->CE_NAME );
 890
 891       if( purepercent ) {
 892      /* Handle %-targets. */
 893      CELLPTR cur;
 894      CELLPTR tpq = NIL(CELL);
 895      CELLPTR nprq = NULL;
 896
 897 #ifdef DBUG
 898      DB_PRINT( "%", ("Handling %%-target [%s : : <prerequisites follow, maybe empty>]",
 899              tg1->CE_NAME) );
 900      for(cur=prereq;cur;cur=cur->ce_link) {
 901         DB_PRINT( "%", ("         %%-prerequisites : %s ",
 902                 cur->CE_NAME ? cur->CE_NAME : "<empty>") );
 903      }
 904 #endif
 905
 906      /* Handle indirect (global) prerequisites first. */
 907      for(cur=prereq;cur;cur=cur->ce_link) {
 908         char *name = cur->CE_NAME;
 909         int   len  = strlen(name);
 910
 911         if( *name == '\'' && name[len-1]=='\'' ){
 912            name[len-1] = '\0';
 913            len = strlen(name+1)+1;
 914            memmove(name,name+1,len);
 915            /* add indirect prerequisite */
 916            _add_indirect_prereq( cur );
 917         }
 918         else {
 919            /* Sort all "other" prerequisits into tpq, with nprq
 920         * pointing to the first element. */
 921            if (tpq)
 922           tpq->ce_link = cur;
 923            else
 924           nprq = cur;
 925            tpq = cur;
 926         }
 927      }
 928      /* Mark the last element of nprq. */
 929      if(tpq)
 930         tpq->ce_link=NIL(CELL);
 931      else
 932         nprq = NIL(CELL);
 933
 934      /* Handle "normal" prerequisites now. */
 935
 936      if ( op & R_OP_OR ) {
 937         /* for op == ':|' transform:
 938          * <%-target> :| <prereq_1> ... <prereq_n> ; <recipe>
 939          * into:
 940          * <%-target> : <prereq_1> ; <recipe>
 941          * ..
 942          * <%-target> : <prereq_n> ; <recipe>
 943          */
 944         for(tp1=nprq; tp1; tp1=tp1->ce_link) {
 945            CELLPTR tmpcell = tp1->ce_link;
 946            tp1->ce_link = NIL(CELL);
 947            _build_graph(op,tg1,tp1);
 948            tp1->ce_link = tmpcell;
 949         }
 950      }
 951      else {
 952         /* The inference mechanism for %-targets limits the number of
 953          * (non-indirect) prerequisite to one, but an unlimited number
 954          * of indirect prerequisites is possible. */
 955         if ( nprq && nprq->ce_link && !(op & R_OP_OR))
 956            Warning("More than one prerequisite\n"
 957            "for %%-target. Use :| ruleop or indirect prerequisites.");
 958
 959         _build_graph(op,tg1,nprq);
 960      }
 961       }
 962       else if( tg1->ce_flag & F_MAGIC &&
 963            (p = _is_magic( tg1->CE_NAME )) != NIL(char) &&
 964            _do_magic( op, p, tg1, prereq, attr, set_dir ) )
 965     ; /* _do_magic() does all that is needed (if return value is TRUE). */
 966       else if( op & R_OP_DCL ) {  /* op == :: */
 967      CELLPTR tmp_cell = _make_multi(tg1);
 968
 969      /* Add the F_MULTI master to .TARGETS (If not set already).
 970       * Do this here so that the member cell is not added instead
 971       * when the recipies are bound in Bind_rules_to_targets(). */
 972      tflag |= _add_root(tg1);
 973
 974      /* Replace the F_MULTI master with the member cell. */
 975      targets = _replace_cell( targets, tg1, tmp_cell );
 976
 977     /* We have to set (add) the attributes also for the F_MULTI master
 978      * target cell. As there is no recipe the setdir value is not
 979      * needed. _set_attributes() that follows in approx. 8 lines
 980      * will set the attributes for the F_MULTI member cell.  */
 981      tg1->ce_attr |= (attr & ~A_SETDIR);
 982
 983      /* Now switch tg1 to the current (F_MULTI prereq.) target.
 984       * All recipes have to be added to that cell and not to the
 985       * F_MULTI master.  */
 986      tg1 = tmp_cell;
 987       }
 988
 989       if( !purepercent ) _set_attributes( attr, set_dir, tg1 );
 990
 991       /* Build the proper prerequisite list of the target.  If the `-',
 992        * modifier was used clear the prerequisite list before adding any
 993        * new prerequisites.  Else add them to the head/tail as appropriate.
 994        *
 995        * If the target has F_PERCENT set then no prerequisites are used. */
 996
 997       if( !(tg1->ce_flag & F_PERCENT) ) {
 998      if( op & R_OP_MI ) Clear_prerequisites( tg1 ); /* op == :- */
 999
1000      if( (op & R_OP_UP) && (tg1->ce_prq != NIL(LINK)) ) /* op == :^ */
1001         _stick_at_head( tg1, prereq );
1002      else for( tp1=prereq; tp1 != NIL(CELL); tp1 = tp1->ce_link )
1003         Add_prerequisite( tg1, tp1, FALSE, FALSE );
1004       }
1005       else if( op & (R_OP_MI | R_OP_UP) )
1006      Warning( "Modifier(s) `^-' for %-meta target ignored" );
1007    }
1008
1009    /* In case a F_MULTI member that was the first prerequisite of .TARGETS */
1010    if(tflag)
1011       Target = TRUE;
1012
1013    /* Check to see if we have NO targets but some attributes, i.e. an
1014     * Attribute-Definition.  If so then apply all of the attributes to the
1015     * complete list of prerequisites.  No recipes are allowed to follow. */
1016
1017    if( (targets == NIL(CELL)) && attr ) {
1018       ret_state = NORMAL_SCAN;
1019       if( prereq != NIL(CELL) )
1020      for( tp1=prereq; tp1 != NIL(CELL); tp1 = tp1->ce_link )
1021         _set_attributes( attr, set_dir, tp1 );
1022       else
1023      _set_global_attr( attr );
1024    }
1025
1026    /* Now that we have built the lists of targets, the parser must parse the
1027     * recipes if there are any.  However we must start the recipe list with the
1028     * recipe specified as via the ; kludge, if there is one */
1029    _sv_targets = targets;
1030    _sv_attr    = attr;
1031    _sv_flag    = ((op & R_OP_BG) ? F_SINGLE : F_DEFAULT);
1032
1033    DB_RETURN( ret_state );
1034 }
1035
1036
1037 static int
1038 _do_magic( op, dot, target, prereq, attr, set_dir )/*
1039 =====================================================
1040    This function investigates dot for being a magic target of the form
1041    .<chars>.<chars> or .<chars> and creates the appropriate % rules for
1042    that target.
1043    If the target is given with an undefined syntax, i.e. with prerequisites,
1044    then this function terminates early without creating % rules and
1045    returns 0.
1046    If successful the function returns 1.
1047
1048    The function builds the % rule, `%.o : %.c'  from .c.o, and
1049    `% : %.a' from .a */
1050
1051 int op;
1052 char    *dot;
1053 CELLPTR target;
1054 CELLPTR prereq;
1055 t_attr  attr;
1056 char    *set_dir;
1057 {
1058    CELLPTR tg;
1059    CELLPTR prq;
1060    char    *tmp, *tmp2;
1061
1062    DB_ENTER( "_do_magic" );
1063
1064    DB_PRINT("%", ("Analysing magic target [%s]", target->CE_NAME));
1065
1066    if( prereq != NIL(CELL) ) {
1067       Warning( "Ignoring AUGMAKE meta-target [%s] because prerequisites are present.", target->CE_NAME );
1068       DB_RETURN(0);
1069    }
1070
1071    if( dot == target->CE_NAME ) {    /* its of the form .a */
1072       tg  = Def_cell( "%" );
1073       tmp = _build_meta( target->CE_NAME );
1074       prq = Def_cell( tmp );
1075       FREE( tmp );
1076
1077       _build_graph( op, tg, prq );
1078    }
1079    else {
1080       tmp = _build_meta( dot );
1081       tg  = Def_cell( tmp );
1082       FREE( tmp );
1083
1084       tmp = _build_meta( tmp2 = DmSubStr( target->CE_NAME, dot ) );
1085       prq = Def_cell( tmp );
1086       FREE( tmp  );
1087       FREE( tmp2 );
1088
1089       _build_graph( op, tg, prq );
1090    }
1091
1092    tg->ce_flag      |= F_PERCENT;
1093    target->ce_flag  |= (F_MAGIC|F_PERCENT);
1094
1095    _set_attributes( attr, set_dir, tg );
1096
1097    DB_RETURN(1);
1098 }
1099
1100
1101 static CELLPTR
1102 _replace_cell( lst, cell, rep )/*
1103 =================================
1104    Replace cell with rep in lst. Note if cell is not part of lst we are in
1105    real trouble. */
1106 CELLPTR lst;
1107 CELLPTR cell;
1108 CELLPTR rep;
1109 {
1110    register CELLPTR tp;
1111
1112    if( lst == cell ) {
1113       rep->ce_link = lst->ce_link;
1114       lst = rep;
1115    }
1116    else {
1117       for( tp=lst; tp->ce_link != cell && tp ; tp=tp->ce_link );
1118       if( !tp )
1119      Fatal( "Internal Error: cell not part of lst." );
1120       rep->ce_link = tp->ce_link->ce_link;
1121       tp->ce_link = rep;
1122    }
1123
1124    return(lst);
1125 }
1126
1127
1128 static char *
1129 _build_meta( name )/*
1130 =====================
1131    Check to see if the name is of the form .c~ if so and if Augmake
1132    translation is enabled then return s.%.c, else return %.suff, where if the
1133    suffix ends in '~' then leave it be.*/
1134 char *name;
1135 {
1136    char *tmp;
1137    int  test = (STOBOOL(Augmake) ? name[strlen(name)-1] == '~' : 0);
1138
1139    tmp = DmStrJoin( test ? "s.%" : "%", name, -1, FALSE);
1140    if( test ) tmp[ strlen(tmp)-1 ] = '\0';
1141
1142    return(tmp);
1143 }
1144
1145
1146 static CELLPTR
1147 _build_graph( op, target, prereq )/*
1148 ====================================
1149    This function is called to build the graph for the % rule given by
1150    target : prereq cell combination.  This function assumes that target
1151    is a % target and that prereq is one or multiple non-indirect prerequisite.
1152    It also assumes that target cell has F_PERCENT set already.
1153
1154    NOTE: If more than one prerequisite is present this function handles them
1155    correctly but the lookup still only uses the first (BUG!).
1156
1157    R_OP_CL (:) rules replace existing rules if any, %.o :: %.c is meaningless.
1158
1159    The function always returns NIL(CELL). */
1160 int op;
1161 CELLPTR target;
1162 CELLPTR prereq;
1163 {
1164    LINKPTR edl;
1165    CELLPTR edge = 0;
1166    CELLPTR tpq,cur;
1167    int match;
1168
1169 #ifdef DBUG
1170    DB_ENTER( "_build_graph" );
1171    DB_PRINT( "%", ("Building graph for [%s : <prerequisites follow, maybe empty>]",
1172            target->CE_NAME) );
1173    for(tpq=prereq;tpq;tpq=tpq->ce_link) {
1174       DB_PRINT( "%", ("         %%-prerequisites : %s ",
1175               tpq->CE_NAME ? tpq->CE_NAME : "<empty>") );
1176    }
1177 #endif
1178
1179    /* Currently multiple prerequisites are not (yet) handled correctly.
1180     * We already issue a warning in _do_targets(), don't issue it here
1181     * again.
1182    if ( prereq && prereq->ce_link )
1183       Warning( "Internal Error: more than one prerequisite in _build_graph." );
1184     */
1185
1186    /* There cannot be more than one target name ( linked with
1187     * (CeMeToo(target))->cl_next ) per %-target master.
1188     * FIXME: remove this check after verifying that it never triggers. */
1189    if ( (CeMeToo(target))->cl_next )
1190       Fatal( "Internal Error: more than one target name in _build_graph." );
1191
1192    /* Search the list of prerequisites for the current target and see if
1193     * any of them match the current %-meta's : prereq's pair.  NOTE that
1194     * %-metas are built as if they were F_MULTI targets, i.e. the target
1195     * definitions for the %-target members are stored in the prerequisites
1196     * list of the master target. */
1197    /* This relies on target->ce_prq being NULL if this is the first
1198     * occurrence of this %-target and therefore not yet having a %-target
1199     * master. */
1200    match = FALSE;
1201    for(edl=target->ce_prq; !match && edl != NIL(LINK); edl=edl->cl_next) {
1202       LINKPTR l1,l2;
1203       edge = edl->cl_prq;
1204
1205       DB_PRINT("%", ("Trying to match [%s]",edge?edge->CE_NAME:"(nil)"));
1206
1207       /* First we match the target sets, if this fails then we don't have to
1208        * bother with the prerequisite sets.  The targets sets are sorted.
1209        * this makes life very simple. */
1210       /* ce_dir is handled per member target, no check needed for the
1211        * master target. */
1212
1213       /* FIXME: We already checked above that there is only one target
1214        * name. Remove the comparisons for following names. */
1215       l1 = CeMeToo(target); /* Used by .UPDATEALL !!! */
1216       l2 = CeMeToo(edge);
1217       while(l1 && l2 && l1->cl_prq == l2->cl_prq) {
1218      l1=l1->cl_next;
1219      l2=l2->cl_next;
1220       }
1221       /* If both l1 and l2 are NULL we had a match. */
1222       if (l1 || l2)
1223      continue;
1224
1225       /* target sets match, so check prerequisites. */
1226       if(    (!edge->ce_prq && !prereq) /* matches both empty - separate this. */
1227       || (   edge->ce_prq
1228           && (   edge->ce_dir == _sv_setdir
1229           || (   edge->ce_dir
1230               && _sv_setdir
1231               && !strcmp(edge->ce_dir,strchr(_sv_setdir,'=')+1)
1232              )
1233          )
1234          )
1235       ) {
1236      LINKPTR prql;
1237
1238      /* this is a really gross way to compare two sets, it's n^2 but
1239       * since the sets are assumed to always be tiny, it should be ok. */
1240      for(tpq=prereq; tpq; tpq=tpq->ce_link) {
1241         for(prql=edge->ce_prq;prql;prql=prql->cl_next)
1242            if (prql->cl_prq == tpq)
1243           break;
1244
1245         if(prql == NIL(LINK))
1246            break;
1247
1248         prql->cl_prq->ce_flag |= F_MARK;
1249      }
1250
1251      if (tpq == NIL(CELL)) {
1252         for(prql=edge->ce_prq;prql;prql=prql->cl_next)
1253            if(!(prql->cl_prq->ce_flag & F_MARK))
1254           break;
1255
1256         if(prql == NIL(LINK))
1257         match = TRUE;
1258      }
1259
1260      /* clean up the mark bits. */
1261      for(prql=edge->ce_prq;prql;prql=prql->cl_next)
1262         prql->cl_prq->ce_flag &= ~F_MARK;
1263       }
1264    }
1265
1266    if( match ) {
1267       /* match is TRUE hence, we found an edge joining the target and the
1268        * prerequisite so reset the new edge so that new values replace it. */
1269       DB_PRINT( "%", ("It's an old edge") );
1270
1271       edge->ce_dir    = NIL(char);
1272       edge->ce_flag  &= (F_PERCENT|F_MAGIC|F_DFA);
1273       edge->ce_attr  &= A_NOINFER;
1274    }
1275    else {
1276       DB_PRINT( "%", ("Adding a new edge") );
1277
1278       edge = _make_multi(target);
1279
1280       /* FIXME: There can be only one %-target. */
1281       for(edl=CeMeToo(target);edl;edl=edl->cl_next) {
1282      if( !((tpq=edl->cl_prq)->ce_flag & F_DFA) ) {
1283         Add_nfa( tpq->CE_NAME );
1284         tpq->ce_flag |= F_DFA;
1285      }
1286
1287      edl->cl_prq->ce_set = edge;
1288       }
1289
1290       edge->ce_all = target->ce_all;
1291       target->ce_all.cl_next = NIL(LINK);
1292       target->ce_set = NIL(CELL);
1293
1294       /* Add all prerequisites to edge. */
1295       for(tpq=prereq; tpq; tpq=tpq->ce_link)
1296          Add_prerequisite(edge, tpq, FALSE, TRUE);
1297    }
1298
1299    if( op & R_OP_DCL )
1300    Warning("'::' operator for meta-target '%s' ignored, ':' operator assumed.",
1301        target->CE_NAME );
1302
1303    /* If edge was already added we're in BIG trouble. */
1304    /* Re-use cur as temporary variable. */
1305    for( cur=_sv_edgel; cur != NIL(CELL); cur=cur->ce_link ) {
1306       if( cur == edge )
1307      Fatal( "Internal Error: edge already in _sv_edgel." );
1308    }
1309
1310    edge->ce_link = _sv_edgel;
1311    _sv_edgel = edge;
1312    _sv_globprq_only = 0;
1313
1314    DB_RETURN(NIL(CELL));
1315 }
1316
1317
1318 static CELLPTR
1319 _make_multi( tg )/*
1320 ===================
1321    This function is called to convert tg into an F_MULTI target.
1322    Return a pointer to the new member cell.
1323    I don't know what the author intended but the ce_index entry is only
1324    used in this function (set to 0 for added targets) and undefined otherwise!
1325    The undefined value is hopefully set to 0 by the C compiler as each added
1326    target sets its ce_count to ++ce_index (==1). (FIXME) */
1327 CELLPTR tg;
1328 {
1329    CELLPTR cp;
1330
1331    /* This creates a new master F_MULTI target if tg existed before as a normal
1332     * target with prerequisites or recipes. */
1333    if( !(tg->ce_flag & F_MULTI) && (tg->ce_prq || tg->ce_recipe) ) {
1334       /* Allocate a new master cell. */
1335       TALLOC(cp, 1, CELL);
1336       *cp = *tg;
1337
1338       /* F_MULTI master */
1339       tg->ce_prq    = NIL(LINK);
1340       tg->ce_flag  |= F_RULES|F_MULTI|F_TARGET;
1341       tg->ce_attr  |= A_SEQ;
1342       tg->ce_recipe = NIL(STRING);
1343       tg->ce_dir    = NIL(char);
1344
1345       /* F_MULTI member for preexisting elements */
1346       cp->ce_count  = ++tg->ce_index;
1347       cp->ce_cond   = NIL(STRING);
1348       cp->ce_set    = NIL(CELL);
1349       cp->ce_all.cl_prq = cp;
1350       CeNotMe(cp)   = NIL(LINK);
1351
1352       Add_prerequisite(tg, cp, FALSE, TRUE);
1353    }
1354
1355    /* Alocate memory for new member of F_MULTI target */
1356    TALLOC(cp, 1, CELL);
1357    *cp = *tg;
1358
1359    /* This is reached if the target already exists, but without having
1360     * prerequisites or recepies. Morph it into a F_MULTI master cell. */
1361    if( !(tg->ce_flag & F_MULTI) ) {
1362       tg->ce_prq    = NIL(LINK);
1363       tg->ce_flag  |= F_RULES|F_MULTI|F_TARGET;
1364       tg->ce_attr  |= A_SEQ;
1365       tg->ce_recipe = NIL(STRING);
1366       tg->ce_dir    = NIL(char);
1367       cp->ce_cond   = NIL(STRING);
1368    }
1369    /* This handles the case of adding an additional target as a
1370     * prerequisite to a F_MULTI target. */
1371    else {
1372       cp->ce_flag  &= ~(F_RULES|F_MULTI);
1373       cp->ce_attr  &= ~A_SEQ;
1374       cp->ce_prq    = NIL(LINK);
1375       cp->ce_index  = 0;
1376       cp->ce_cond   = NIL(STRING);
1377    }
1378    cp->ce_count = ++tg->ce_index;
1379    cp->ce_flag |= F_TARGET;
1380    cp->ce_set   = NIL(CELL);
1381    cp->ce_all.cl_prq = cp;
1382    CeNotMe(cp)  = NIL(LINK);
1383
1384    Add_prerequisite(tg, cp, FALSE, TRUE);
1385    return(cp);
1386 }
1387
1388
1389 static void
1390 _add_indirect_prereq( pq )/*
1391 ==========================
1392    Prerequisite is an indirect prerequisite for a %-target, add it to
1393    the target's list of indirect prerequsites to add on match. */
1394 CELLPTR pq;
1395 {
1396    register LINKPTR ln;
1397
1398    /* Only add to list of indirect prerequsites if it is not in already. */
1399    for(ln=_sv_ind_prq; ln; ln=ln->cl_next)
1400       if(strcmp(ln->cl_prq->CE_NAME,pq->CE_NAME) == 0)
1401      return;
1402
1403    /* Not in, add it. */
1404    TALLOC( ln, 1, LINK );
1405    ln->cl_next = _sv_ind_prq;
1406    ln->cl_prq  = pq;
1407    _sv_ind_prq = ln;
1408 }
1409
1410
1411
1412 static void
1413 _set_attributes( attr, set_dir, cp )/*
1414 ======================================
1415     Set the appropriate attributes for a cell */
1416 t_attr  attr;
1417 char    *set_dir;
1418 CELLPTR cp;
1419 {
1420    char   *dir = 0;
1421
1422    DB_ENTER( "_set_attributes" );
1423
1424    /* If .SETDIR attribute is set then we have at least .SETDIR= in the
1425     * set_dir string.  So go and fishout what is at the end of the =.
1426     * If not set and not NULL then propagate it to the target cell. */
1427
1428    if( attr & A_SETDIR ) {
1429       char *p;
1430       if( (p = strchr( set_dir, '=' )) != NULL )
1431          dir = p + 1;
1432
1433       if( cp->ce_dir )
1434      Warning( "Multiple .SETDIR for %s ignored", cp->CE_NAME );
1435       else if( *dir )
1436          cp->ce_dir = DmStrDup(dir);
1437    }
1438    cp->ce_attr |= attr;     /* set rest of attributes for target */
1439
1440    DB_VOID_RETURN;
1441 }
1442
1443
1444
1445 static void
1446 _set_global_attr( attr )/*
1447 ==========================
1448     Handle the setting of the global attribute functions based on
1449     The attribute flags set in attr. */
1450 t_attr attr;
1451 {
1452    t_attr flag;
1453
1454    /* Some compilers can't handle a switch on a long, and t_attr is now a long
1455     * integer on some systems.  foey! */
1456    for( flag = MAX_ATTR; flag; flag >>= 1 )
1457       if( flag & attr ) {
1458      if( flag == A_PRECIOUS)      Def_macro(".PRECIOUS",  "y", M_EXPANDED);
1459      else if( flag == A_SILENT)   Def_macro(".SILENT",    "y", M_EXPANDED);
1460      else if( flag == A_IGNORE )  Def_macro(".IGNORE",    "y", M_EXPANDED);
1461      else if( flag == A_EPILOG )  Def_macro(".EPILOG",    "y", M_EXPANDED);
1462      else if( flag == A_PROLOG )  Def_macro(".PROLOG",    "y", M_EXPANDED);
1463      else if( flag == A_NOINFER ) Def_macro(".NOINFER",   "y", M_EXPANDED);
1464      else if( flag == A_SEQ )     Def_macro(".SEQUENTIAL","y", M_EXPANDED);
1465      else if( flag == A_SHELL )   Def_macro(".USESHELL",  "y", M_EXPANDED);
1466      else if( flag == A_MKSARGS ) Def_macro(".MKSARGS",   "y", M_EXPANDED);
1467 #if !defined(__CYGWIN__)
1468      else if( flag == A_SWAP )    Def_macro(".SWAP",      "y", M_EXPANDED);
1469 #else
1470      else if( flag == A_WINPATH ) Def_macro(".WINPATH",   "y", M_EXPANDED);
1471 #endif
1472       }
1473
1474    attr &= ~A_GLOB;
1475    if( attr ) Warning( "Non global attribute(s) ignored" );
1476 }
1477
1478
1479
1480 static void
1481 _stick_at_head( cp, pq )/*
1482 ==========================
1483     Add the prerequisite list to the head of the existing prerequisite
1484     list */
1485
1486 CELLPTR cp;         /* cell for target node */
1487 CELLPTR pq;     /* list of prerequisites to add */
1488 {
1489    DB_ENTER( "_stick_at_head" );
1490
1491    if( pq->ce_link != NIL(CELL) ) _stick_at_head( cp, pq->ce_link );
1492    Add_prerequisite( cp, pq, TRUE, FALSE );
1493
1494    DB_VOID_RETURN;
1495 }
1496
1497
1498
1499 static t_attr
1500 _is_attribute( name )/*
1501 =======================
1502    Check the passed name against the list of valid attributes and return the
1503    attribute index if it is, else return 0, indicating the name is not a valid
1504    attribute.  The present attributes are defined in dmake.h as A_xxx #defines,
1505    with the corresponding makefile specification:  (note they must be named
1506    exactly as defined below)
1507
1508    Valid attributes are:  .IGNORE, .SETDIR=, .SILENT, .PRECIOUS, .LIBRARY,
1509                           .EPILOG, .PROLOG,  .LIBRARYM, .SYMBOL, .UPDATEALL,
1510               .USESHELL, .NOINFER, .PHONY, .SWAP/.WINPATH, .SEQUENTIAL
1511               .NOSTATE,  .MKSARGS, .IGNOREGROUP, .GROUP, .FIRST
1512               .EXECUTE, .ERRREMOVE
1513
1514    NOTE:  The strcmp's are OK since at most three are ever executed for any
1515           one attribute check, and that happens only when we can be fairly
1516           certain we have an attribute.  */
1517 char *name;
1518 {
1519    t_attr attr = 0;
1520
1521    DB_ENTER( "_is_attribute" );
1522
1523    if( *name++ == '.' )
1524       switch( *name )
1525       {
1526          case 'E':
1527         if( !strcmp(name, "EPILOG") )           attr = A_EPILOG;
1528         else if( !strcmp(name, "EXECUTE"))      attr = A_EXECUTE;
1529         else if( !strcmp(name, "ERRREMOVE"))    attr = A_ERRREMOVE;
1530         else attr = 0;
1531         break;
1532
1533      /* A_FIRST implies A_IGNORE, handled in ST_INCLUDE */
1534          case 'F':
1535         attr = (strcmp(name, "FIRST")) ? 0 : A_FIRST;
1536         break;
1537
1538      case 'G': attr = (strcmp(name, "GROUP"))    ? 0 : A_GROUP;   break;
1539          case 'L': attr = (strcmp(name, "LIBRARY"))  ? 0 : A_LIBRARY; break;
1540          case 'M': attr = (strcmp(name, "MKSARGS"))  ? 0 : A_MKSARGS; break;
1541
1542          case 'I':
1543         if( !strcmp(name, "IGNORE") )           attr = A_IGNORE;
1544         else if( !strcmp(name, "IGNOREGROUP"))  attr = A_IGNOREGROUP;
1545         else attr = 0;
1546         break;
1547
1548          case 'N':
1549         if( !strcmp(name, "NOINFER") )      attr = A_NOINFER;
1550         else if( !strcmp(name, "NOSTATE"))  attr = A_NOSTATE;
1551         else attr = 0;
1552         break;
1553
1554          case 'U':
1555         if( !strcmp(name, "UPDATEALL") )    attr = A_UPDATEALL;
1556         else if( !strcmp(name, "USESHELL")) attr = A_SHELL;
1557         else attr = 0;
1558         break;
1559
1560          case 'P':
1561             if( !strcmp(name, "PRECIOUS") )     attr = A_PRECIOUS;
1562             else if( !strcmp(name, "PROLOG") )  attr = A_PROLOG;
1563             else if( !strcmp(name, "PHONY") )   attr = A_PHONY;
1564             else attr = 0;
1565             break;
1566
1567          case 'S':
1568             if( !strncmp(name, "SETDIR=", 7) )    attr = A_SETDIR;
1569             else if( !strcmp(name, "SILENT") )    attr = A_SILENT;
1570             else if( !strcmp(name, "SYMBOL") )    attr = A_SYMBOL;
1571             else if( !strcmp(name, "SEQUENTIAL")) attr = A_SEQ;
1572         /* A_SWAP has no meaning except for MSDOS. */
1573             else if( !strcmp(name, "SWAP"))       attr = A_SWAP;
1574             else attr = 0;
1575             break;
1576
1577          case 'W': attr = (strcmp(name, "WINPATH"))  ? 0 : A_WINPATH; break;
1578       }
1579
1580    DB_RETURN( attr );
1581 }
1582
1583
1584
1585 static int
1586 _is_special( tg )/*
1587 ===================
1588    This function returns TRUE if the name passed in represents a special
1589    target, otherwise it returns false.  A special target is one that has
1590    a special meaning to dmake, and may require processing at the time that
1591    it is parsed.
1592
1593    Current Special targets are:
1594     .GROUPPROLOG    .GROUPEPILOG    .INCLUDE    .IMPORT
1595     .EXPORT     .SOURCE     .SUFFIXES   .ERROR        .EXIT
1596     .INCLUDEDIRS    .MAKEFILES  .REMOVE     .KEEP_STATE
1597     .TARGETS    .ROOT
1598 */
1599 char *tg;
1600 {
1601    DB_ENTER( "_is_special" );
1602
1603    if( *tg++ != '.' ) DB_RETURN( 0 );
1604
1605    switch( *tg )
1606    {
1607       case 'E':
1608          if( !strcmp( tg, "ERROR" ) )       DB_RETURN( ST_REST     );
1609          else if( !strcmp( tg, "EXPORT" ) ) DB_RETURN( ST_EXPORT   );
1610          else if( !strcmp( tg, "EXIT" ) )   DB_RETURN( ST_EXIT     );
1611      break;
1612
1613       case 'G':
1614      if( !strcmp( tg, "GROUPPROLOG" ))      DB_RETURN( ST_REST     );
1615      else if( !strcmp( tg, "GROUPEPILOG" )) DB_RETURN( ST_REST     );
1616      break;
1617
1618       case 'I':
1619          if( !strcmp( tg, "IMPORT" ) )      DB_RETURN( ST_IMPORT   );
1620          else if( !strcmp( tg, "INCLUDE" ) )    DB_RETURN( ST_INCLUDE  );
1621      else if( !strcmp( tg, "INCLUDEDIRS" )) DB_RETURN( ST_REST     );
1622      break;
1623
1624       case 'K':
1625          if( !strcmp( tg, "KEEP_STATE" ) )  DB_RETURN( ST_KEEP     );
1626      break;
1627
1628       case 'M':
1629          if( !strcmp( tg, "MAKEFILES" ) )   DB_RETURN( ST_REST     );
1630      break;
1631
1632       case 'R':
1633          if( !strcmp( tg, "REMOVE" ) )      DB_RETURN( ST_REST     );
1634          else if( !strcmp( tg, "ROOT" ) )   DB_RETURN( ST_REST     );
1635      break;
1636
1637       case 'S':
1638          if( !strncmp( tg, "SOURCE", 6 ) )  DB_RETURN( ST_SOURCE   );
1639          else if( !strncmp(tg, "SUFFIXES", 8 )) {
1640             if  (Verbose & V_WARNALL)
1641                Warning( "The .SUFFIXES target has no special meaning and is deprecated." );
1642             DB_RETURN( ST_SOURCE   );
1643      }
1644      break;
1645
1646       case 'T':
1647          if( !strcmp( tg, "TARGETS" ) )     DB_RETURN( ST_REST     );
1648      break;
1649    }
1650
1651    DB_RETURN( 0 );
1652 }
1653
1654
1655
1656 static int
1657 _is_percent( np )/*
1658 ===================
1659     return TRUE if np points at a string containing a % sign */
1660 char *np;
1661 {
1662    return( (strchr(np,'%') && (*np != '\'' && np[strlen(np)-1] != '\'')) ?
1663        TRUE : FALSE );
1664 }
1665
1666
1667 static char *
1668 _is_magic( np )/*
1669 =================
1670    return NULL if np does not points at a string of the form
1671       .<chars>.<chars>  or  .<chars>
1672    where chars are "visible characters" for the current locale. If np is of the
1673    first form we return a pointer to the second '.' and for the second form we
1674    return a pointer to the '.'.
1675
1676    NOTE:  reject target if it contains / or begins with ..
1677           reject also .INIT and .DONE because they are mentioned in the
1678           man page. */
1679 char *np;
1680 {
1681    register char *n;
1682
1683    n = np;
1684    if( *n != '.' ) return( NIL(char) );
1685    if (strchr(DirBrkStr, *(n+1))!=NULL || *(n+1) == '.' )
1686       return (NIL(char));
1687    if( !strcmp( n+1, "INIT" ) || !strcmp( n+1, "DONE" ) )
1688       return (NIL(char));
1689
1690    for( n++; isgraph(*n) && (*n != '.'); n++ );
1691
1692    if( *n != '\0' ) {
1693       if( *n != '.' )  return( NIL(char) );
1694       for( np = n++; isgraph( *n ) && (*n != '.'); n++ );
1695       if( *n != '\0' ) return( NIL(char) );
1696    }
1697    /* Until dmake 4.5 a .<suffix> target was ignored when AUGMAKE was
1698     * set and evaluated as a meta target if unset (also for -A).
1699     * To keep maximum compatibility accept this regardles of the AUGMAKE
1700     * status. */
1701
1702    /* np points at the second . of .<chars>.<chars> string.
1703     * if the special target is of the form .<chars> then np points at the
1704     * first . in the token. */
1705
1706    return( np );
1707 }
1708
1709
1710 static int
1711 _add_root(tg)/*
1712 ===============
1713    Adds "tg" to the prerequisits list of "Targets" if "Target" is not TRUE,
1714    i.e. to the list of targets that are to be build.
1715    Instead io setting "Target" to TRUE, TRUE is returned as more targets
1716    might be defined in the current makefile line and they all have to be
1717    add to "Targets" in this case.  */
1718
1719 CELLPTR tg;
1720 {
1721    int res = FALSE;
1722
1723    if(tg == Targets)
1724       return(TRUE);
1725
1726    if( !Target && !(tg->ce_flag & (F_SPECIAL|F_PERCENT)) ) {
1727       Add_prerequisite(Targets, tg, FALSE, TRUE);
1728
1729       tg->ce_flag |= F_TARGET;
1730       tg->ce_attr |= A_FRINGE;
1731       res          = TRUE;
1732    }
1733
1734    return(res);
1735 }