src/variable.c

   1 /*
   2  * Copyright 1993-2002 Christopher Seiwald and Perforce Software, Inc.
   3  *
   4  * This file is part of Jam - see jam.c for Copyright information.
   5  */
   6
   7 /*
   8  * variable.c - handle jam multi-element variables
   9  *
  10  * External routines:
  11  *
  12  *  var_defines() - load a bunch of variable=value settings
  13  *  var_string() - expand a string with variables in it
  14  *  var_get() - get value of a user defined symbol
  15  *  var_set() - set a variable in jam's user defined symbol table
  16  *  var_swap() - swap a variable's value with the given one
  17  *  var_done() - free variable tables
  18  *
  19  * Internal routines:
  20  *
  21  *  var_enter() - make new var symbol table entry, returning var ptr
  22  *  var_dump() - dump a variable to stdout
  23  *
  24  * 04/13/94 (seiwald) - added shorthand L0 for null list pointer
  25  * 08/23/94 (seiwald) - Support for '+=' (append to variable)
  26  * 01/22/95 (seiwald) - split environment variables at blanks or :'s
  27  * 05/10/95 (seiwald) - split path variables at SPLITPATH (not :)
  28  * 09/11/00 (seiwald) - defunct var_list() removed
  29  * 10/22/02 (seiwald) - list_new() now does its own newstr()/copystr()
  30  * 11/04/02 (seiwald) - const-ing for string literals
  31  */
  32
  33 # include "jam.h"
  34 # include "lists.h"
  35 # include "parse.h"
  36 # include "variable.h"
  37 # include "expand.h"
  38 # include "hash.h"
  39 # include "newstr.h"
  40
  41 static struct hash *varhash = 0;
  42
  43 /*
  44  * VARIABLE - a user defined multi-value variable
  45  */
  46
  47 typedef struct _variable VARIABLE;
  48
  49 struct _variable {
  50   const char *symbol;
  51   LIST *value;
  52 };
  53
  54
  55 static VARIABLE *var_enter (const char *symbol);
  56 static void var_dump (const char *symbol, LIST *value, const char *what);
  57
  58
  59 /*
  60  * var_defines() - load a bunch of variable=value settings
  61  *
  62  * If variable name ends in PATH, split value at :'s.
  63  * Otherwise, split at blanks.
  64  */
  65 void var_defines (const char **e) {
  66   for (; *e; e++) {
  67     const char *val;
  68     /* Just say "no": windows defines this in the env, */
  69     /* but we don't want it to override our notion of OS. */
  70     if (!strcmp(*e, "OS=Windows_NT")) continue;
  71    /* Just say "no": on Unix, variables can contain function
  72     * definitions. their value begins with "()"
  73     */
  74     if ((val = strchr(*e, '=')) && val[1] == '(' && val[2] == ')') continue;
  75 # ifdef OS_MAC
  76     /* On the mac (MPW), the var=val is actually var\0val */
  77     /* Think different. */
  78     if ((val = strchr(*e, '=')) || (val = *e + strlen(*e))) {
  79 # else
  80     if ((val = strchr(*e, '='))) {
  81 # endif
  82       LIST *l = L0;
  83       const char *pp, *p;
  84 # ifdef OS_MAC
  85       char split = ',';
  86 # else
  87       char split = ' ';
  88 # endif
  89       char buf[MAXSYM];
  90       /* Split *PATH at :'s, not spaces */
  91       if (val-4 >= *e) {
  92         if (!strncmp(val - 4, "PATH", 4) || !strncmp(val - 4, "Path", 4) || !strncmp(val - 4, "path", 4))
  93           split = SPLITPATH;
  94       }
  95       /* Do the split */
  96       for (pp = val+1; (p = strchr(pp, split)); pp = p+1) {
  97         int len = p-pp;
  98
  99         if (len >= sizeof(buf)) len = sizeof(buf)-1;
 100         strncpy(buf, pp, len);
 101         buf[len] = '\0';
 102         l = list_new(l, buf, 0);
 103       }
 104       l = list_new(l, pp, 0);
 105       /* Get name */
 106       strncpy(buf, *e, val-*e);
 107       buf[val-*e] = '\0';
 108       var_set(buf, l, VAR_SET);
 109     }
 110   }
 111 }
 112
 113
 114 /*
 115  * var_string() - expand a string with variables in it
 116  *
 117  * Copies in to out; doesn't modify targets & sources.
 118  */
 119 int var_string (const char *in, char *out, int outsize, LOL *lol) {
 120   char *out0 = out;
 121   char *oute = out+outsize-1;
 122
 123   while (*in) {
 124     char *lastword;
 125     int dollar = 0;
 126     /* Copy white space */
 127     while (isspace(*in)) {
 128       if (out >= oute) return -1;
 129       *out++ = *in++;
 130     }
 131     lastword = out;
 132     /* Copy non-white space, watching for variables */
 133     while (*in && !isspace(*in)) {
 134       if (out >= oute) return -1;
 135       if (in[0] == '$' && in[1] == '(') dollar++;
 136       *out++ = *in++;
 137     }
 138     /* If a variable encountered, expand it and and embed the */
 139     /* space-separated members of the list in the output. */
 140     if (dollar) {
 141       LIST *l = var_expand(L0, lastword, out, lol, 0);
 142       out = lastword;
 143       while (l) {
 144         int so = strlen(l->string);
 145         if (out+so >= oute) return -1;
 146         strcpy(out, l->string);
 147         out += so;
 148         /* Separate with space */
 149         if ((l = list_next(l)))
 150         *out++ = ' ';
 151       }
 152       list_free(l);
 153     }
 154   }
 155   if (out >= oute) return -1;
 156   *out++ = '\0';
 157   return out - out0;
 158 }
 159
 160
 161 /*
 162  * var_get() - get value of a user defined symbol
 163  *
 164  * Returns NULL if symbol unset.
 165  */
 166 LIST *var_get (const char *symbol) {
 167   VARIABLE var, *v = &var;
 168
 169   v->symbol = symbol;
 170   if (varhash && hashcheck(varhash, (HASHDATA **)&v)) {
 171     if (DEBUG_VARGET) var_dump(v->symbol, v->value, "get");
 172     return v->value;
 173   }
 174   return 0;
 175 }
 176
 177
 178 /*
 179  * var_set() - set a variable in jam's user defined symbol table
 180  *
 181  * 'flag' controls the relationship between new and old values of
 182  * the variable: SET replaces the old with the new; APPEND appends
 183  * the new to the old; DEFAULT only uses the new if the variable
 184  * was previously unset.
 185  *
 186  * Copies symbol.  Takes ownership of value.
 187  */
 188 void var_set (const char *symbol, LIST *value, int flag) {
 189   VARIABLE *v = var_enter(symbol);
 190
 191   if (DEBUG_VARSET) var_dump(symbol, value, "set");
 192   switch(flag) {
 193     case VAR_SET:
 194       /* Replace value */
 195       list_free(v->value);
 196       v->value = value;
 197       break;
 198     case VAR_APPEND:
 199       /* Append value */
 200       v->value = list_append(v->value, value);
 201       break;
 202     case VAR_REMOVE:
 203       /* Remove all values */
 204       v->value = list_removeall(v->value, value);
 205       list_free(value);
 206       break;
 207     case VAR_DEFAULT:
 208       /* Set only if unset */
 209       if (!v->value) v->value = value; else list_free(value);
 210       break;
 211   }
 212 }
 213
 214
 215 /*
 216  * var_swap() - swap a variable's value with the given one
 217  */
 218 LIST *var_swap (const char *symbol, LIST *value) {
 219   VARIABLE *v = var_enter(symbol);
 220   LIST *oldvalue = v->value;
 221
 222   if (DEBUG_VARSET) var_dump(symbol, value, "set");
 223   v->value = value;
 224   return oldvalue;
 225 }
 226
 227
 228 /*
 229  * var_enter() - make new var symbol table entry, returning var ptr
 230  */
 231 static VARIABLE *var_enter (const char *symbol) {
 232   VARIABLE var, *v = &var;
 233
 234   if (!varhash) varhash = hashinit(sizeof(VARIABLE), "variables");
 235   v->symbol = symbol;
 236   v->value = 0;
 237   if (hashenter(varhash, (HASHDATA **)&v)) v->symbol = newstr(symbol); /* never freed */
 238   return v;
 239 }
 240
 241
 242 /*
 243  * var_dump() - dump a variable to stdout
 244  */
 245 static void var_dump (const char *symbol, LIST *value, const char *what) {
 246   printf("%s %s = ", what, symbol);
 247   list_print(value);
 248   printf("\n");
 249 }
 250
 251
 252 /*
 253  * var_done() - free variable tables
 254  */
 255 void var_done (void) {
 256   hashdone(varhash);
 257 }