rules.c

   1 /*
   2  * Copyright 1993, 1995 Christopher Seiwald.
   3  *
   4  * This file is part of Jam - see jam.c for Copyright information.
   5  */
   6
   7 /*
   8  * rules.c - access to RULEs, TARGETs, and ACTIONs
   9  *
  10  * External routines:
  11  *
  12  *    bindrule() - return pointer to RULE, creating it if necessary
  13  *    bindtarget() - return pointer to TARGET, creating it if necessary
  14  *    copytarget() - make a new target with the old target's name
  15  *    touchtarget() - mark a target to simulate being new
  16  *    targetlist() - turn list of target names into a TARGET chain
  17  *    targetentry() - add a TARGET to a chain of TARGETS
  18  *    targetchain() - append two TARGET chains
  19  *    actionlist() - append to an ACTION chain
  20  *    addsettings() - add a deferred "set" command to a target
  21  *    copysettings() - copy a settings list for temp use
  22  *    pushsettings() - set all target specific variables
  23  *    popsettings() - reset target specific variables to their pre-push values
  24  *    freesettings() - delete a settings list
  25  *    donerules() - free RULE and TARGET tables
  26  *
  27  * 04/12/94 (seiwald) - actionlist() now just appends a single action.
  28  * 08/23/94 (seiwald) - Support for '+=' (append to variable)
  29  * 06/21/02 (seiwald) - support for named parameters
  30  * 11/04/02 (seiwald) - const-ing for string literals
  31  * 12/03/02 (seiwald) - fix odd includes support by grafting them onto depends
  32  * 12/17/02 (seiwald) - new copysettings() to protect target-specific vars
  33  * 01/14/03 (seiwald) - fix includes fix with new internal includes TARGET
  34  */
  35
  36 # include "jam.h"
  37 # include "lists.h"
  38 # include "parse.h"
  39 # include "variable.h"
  40 # include "rules.h"
  41 # include "newstr.h"
  42 # include "hash.h"
  43
  44 static struct hash *rulehash = 0;
  45 static struct hash *targethash = 0;
  46
  47
  48 /*
  49  * bindrule() - return pointer to RULE, creating it if necessary
  50  */
  51
  52 RULE *
  53 bindrule( const char *rulename )
  54 {
  55   RULE rule, *r = &rule;
  56
  57   if( !rulehash )
  58       rulehash = hashinit( sizeof( RULE ), "rules" );
  59
  60   r->name = rulename;
  61
  62   if( hashenter( rulehash, (HASHDATA **)&r ) )
  63   {
  64       r->name = newstr( rulename ); /* never freed */
  65       r->procedure = (PARSE *)0;
  66       r->actions = (char *)0;
  67       r->bindlist = L0;
  68       r->params = L0;
  69       r->flags = 0;
  70   }
  71
  72   return r;
  73 }
  74
  75 /*
  76  * bindtarget() - return pointer to TARGET, creating it if necessary
  77  */
  78
  79 TARGET *
  80 bindtarget( const char *targetname )
  81 {
  82   TARGET target, *t = &target;
  83
  84   if( !targethash )
  85       targethash = hashinit( sizeof( TARGET ), "targets" );
  86
  87   t->name = targetname;
  88
  89   if( hashenter( targethash, (HASHDATA **)&t ) )
  90   {
  91       memset( (char *)t, '\0', sizeof( *t ) );
  92       t->name = newstr( targetname ); /* never freed */
  93       t->boundname = t->name;   /* default for T_FLAG_NOTFILE */
  94   }
  95
  96   return t;
  97 }
  98
  99 /*
 100  * copytarget() - make a new target with the old target's name
 101  *
 102  * Not entered into hash table -- for internal nodes.
 103  */
 104
 105 TARGET *
 106 copytarget( const TARGET *ot )
 107 {
 108   TARGET *t;
 109
 110   t = (TARGET *)malloc( sizeof( *t ) );
 111   memset( (char *)t, '\0', sizeof( *t ) );
 112   t->name = copystr( ot->name );
 113   t->boundname = t->name;
 114
 115   t->flags |= T_FLAG_NOTFILE | T_FLAG_INTERNAL;
 116
 117   return t;
 118 }
 119
 120 /*
 121  * touchtarget() - mark a target to simulate being new
 122  */
 123
 124 void
 125 touchtarget( const char *t )
 126 {
 127   bindtarget( t )->flags |= T_FLAG_TOUCHED;
 128 }
 129
 130 /*
 131  * targetlist() - turn list of target names into a TARGET chain
 132  *
 133  * Inputs:
 134  *  chain existing TARGETS to append to
 135  *  targets list of target names
 136  */
 137
 138 TARGETS *
 139 targetlist(
 140   TARGETS *chain,
 141   LIST  *targets )
 142 {
 143   for( ; targets; targets = list_next( targets ) )
 144       chain = targetentry( chain, bindtarget( targets->string ) );
 145
 146   return chain;
 147 }
 148
 149 /*
 150  * targetentry() - add a TARGET to a chain of TARGETS
 151  *
 152  * Inputs:
 153  *  chain exisitng TARGETS to append to
 154  *  target  new target to append
 155  */
 156
 157 TARGETS *
 158 targetentry(
 159   TARGETS *chain,
 160   TARGET  *target )
 161 {
 162   TARGETS *c;
 163
 164   c = (TARGETS *)malloc( sizeof( TARGETS ) );
 165   c->target = target;
 166
 167   if( !chain ) chain = c;
 168   else chain->tail->next = c;
 169   chain->tail = c;
 170   c->next = 0;
 171
 172   return chain;
 173 }
 174
 175 /*
 176  * targetchain() - append two TARGET chains
 177  *
 178  * Inputs:
 179  *  chain exisitng TARGETS to append to
 180  *  target  new target to append
 181  */
 182
 183 TARGETS *
 184 targetchain(
 185   TARGETS *chain,
 186   TARGETS *targets )
 187 {
 188   /*k8: TARGETS *c;*/
 189
 190   if( !targets )
 191       return chain;
 192   else if( !chain )
 193       return targets;
 194
 195   chain->tail->next = targets;
 196   chain->tail = targets->tail;
 197
 198   return chain;
 199 }
 200
 201 /*
 202  * actionlist() - append to an ACTION chain
 203  */
 204
 205 ACTIONS *
 206 actionlist(
 207   ACTIONS *chain,
 208   ACTION  *action )
 209 {
 210   ACTIONS *actions = (ACTIONS *)malloc( sizeof( ACTIONS ) );
 211
 212   actions->action = action;
 213
 214   if( !chain ) chain = actions;
 215   else chain->tail->next = actions;
 216   chain->tail = actions;
 217   actions->next = 0;
 218
 219   return chain;
 220 }
 221
 222 /*
 223  * addsettings() - add a deferred "set" command to a target
 224  *
 225  * Adds a variable setting (varname=list) onto a chain of settings
 226  * for a particular target.  Replaces the previous previous value,
 227  * if any, unless 'append' says to append the new list onto the old.
 228  * Returns the head of the chain of settings.
 229  */
 230
 231 SETTINGS *
 232 addsettings(
 233   SETTINGS *head,
 234   int setflag,
 235   const char *symbol,
 236   LIST  *value )
 237 {
 238   SETTINGS *v;
 239
 240   /* Look for previous setting */
 241
 242   for( v = head; v; v = v->next )
 243       if( !strcmp( v->symbol, symbol ) )
 244     break;
 245
 246   /* If not previously set, alloc a new. */
 247   /* If appending, do so. */
 248   /* Else free old and set new. */
 249
 250   if( !v )
 251   {
 252       v = (SETTINGS *)malloc( sizeof( *v ) );
 253       v->symbol = newstr( symbol );
 254       v->value = value;
 255       v->next = head;
 256       head = v;
 257   }
 258   else switch( setflag )
 259   {
 260   case VAR_SET:
 261       /* Toss old, set new */
 262       list_free( v->value );
 263       v->value = value;
 264       break;
 265
 266   case VAR_APPEND:
 267       /* Append new to old */
 268       v->value = list_append( v->value, value );
 269       break;
 270
 271   case VAR_DEFAULT:
 272       /* Toss new, old already set */
 273       list_free( value );
 274       break;
 275   }
 276
 277   /* Return (new) head of list. */
 278
 279   return head;
 280 }
 281
 282 /*
 283  * copysettings() - copy a settings list for temp use
 284  *
 285  * When target-specific variables are pushed into place with pushsettings(),
 286  * any global variables with the same name are swapped onto the target's
 287  * SETTINGS chain.  If that chain gets modified (by using the "on target"
 288  * syntax), popsettings() would wrongly swap those modified values back
 289  * as the new global values.
 290  *
 291  * copysettings() protects the target's SETTINGS chain by providing a
 292  * copy of the chain to pass to pushsettings() and popsettings(), so that
 293  * the target's original SETTINGS chain can be modified using the usual
 294  * "on target" syntax.
 295  */
 296
 297 SETTINGS *
 298 copysettings( SETTINGS *from )
 299 {
 300   SETTINGS *head = 0 /*k8:, *v*/;
 301
 302   for( ; from; from = from->next )
 303   {
 304       SETTINGS *v = (SETTINGS *)malloc( sizeof( *v ) );
 305       v->symbol = copystr( from->symbol );
 306       v->value = list_copy( 0, from->value );
 307       v->next = head;
 308       head = v;
 309   }
 310
 311   return head;
 312 }
 313
 314 /*
 315  * pushsettings() - set all target specific variables
 316  */
 317
 318 void
 319 pushsettings( SETTINGS *v )
 320 {
 321   for( ; v; v = v->next )
 322       v->value = var_swap( v->symbol, v->value );
 323 }
 324
 325 /*
 326  * popsettings() - reset target specific variables to their pre-push values
 327  */
 328
 329 void
 330 popsettings( SETTINGS *v )
 331 {
 332   pushsettings( v );  /* just swap again */
 333 }
 334
 335 /*
 336  *    freesettings() - delete a settings list
 337  */
 338
 339 void
 340 freesettings( SETTINGS *v )
 341 {
 342   while( v )
 343   {
 344       SETTINGS *n = v->next;
 345
 346       freestr( v->symbol );
 347       list_free( v->value );
 348       free( (char *)v );
 349
 350       v = n;
 351   }
 352 }
 353
 354 /*
 355  * donerules() - free RULE and TARGET tables
 356  */
 357
 358 void
 359 donerules()
 360 {
 361   hashdone( rulehash );
 362   hashdone( targethash );
 363 }