variable.c

   1 /* Internals of variables for GNU Make.
   2 Copyright (C) 1988, 89, 90, 91, 92, 93, 94 Free Software Foundation, Inc.
   3 This file is part of GNU Make.
   4
   5 GNU Make is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2, or (at your option)
   8 any later version.
   9
  10 GNU Make is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with GNU Make; see the file COPYING.  If not, write to
  17 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  18
  19 #include "make.h"
  20 #include "commands.h"
  21 #include "variable.h"
  22 #include "dep.h"
  23 #include "file.h"
  24
  25 /* Hash table of all global variable definitions.  */
  26
  27 #ifndef VARIABLE_BUCKETS
  28 #define VARIABLE_BUCKETS                523
  29 #endif
  30 #ifndef PERFILE_VARIABLE_BUCKETS
  31 #define PERFILE_VARIABLE_BUCKETS        23
  32 #endif
  33 #ifndef SMALL_SCOPE_VARIABLE_BUCKETS
  34 #define SMALL_SCOPE_VARIABLE_BUCKETS    13
  35 #endif
  36 static struct variable *variable_table[VARIABLE_BUCKETS];
  37 static struct variable_set global_variable_set
  38   = { variable_table, VARIABLE_BUCKETS };
  39 static struct variable_set_list global_setlist
  40   = { 0, &global_variable_set };
  41 struct variable_set_list *current_variable_set_list = &global_setlist;
  42 \f
  43 /* Implement variables.  */
  44
  45 /* Define variable named NAME with value VALUE in SET.  VALUE is copied.
  46    LENGTH is the length of NAME, which does not need to be null-terminated.
  47    ORIGIN specifies the origin of the variable (makefile, command line
  48    or environment).
  49    If RECURSIVE is nonzero a flag is set in the variable saying
  50    that it should be recursively re-expanded.  */
  51
  52 static struct variable *
  53 define_variable_in_set (name, length, value, origin, recursive, set)
  54      char *name;
  55      unsigned int length;
  56      char *value;
  57      enum variable_origin origin;
  58      int recursive;
  59      struct variable_set *set;
  60 {
  61   register unsigned int i;
  62   register unsigned int hashval;
  63   register struct variable *v;
  64
  65   hashval = 0;
  66   for (i = 0; i < length; ++i)
  67     HASH (hashval, name[i]);
  68   hashval %= set->buckets;
  69
  70   for (v = set->table[hashval]; v != 0; v = v->next)
  71     if (*v->name == *name
  72         && !strncmp (v->name + 1, name + 1, length - 1)
  73         && v->name[length] == '\0')
  74       break;
  75
  76   if (env_overrides && origin == o_env)
  77     origin = o_env_override;
  78
  79   if (v != 0)
  80     {
  81       if (env_overrides && v->origin == o_env)
  82         /* V came from in the environment.  Since it was defined
  83            before the switches were parsed, it wasn't affected by -e.  */
  84         v->origin = o_env_override;
  85
  86       /* A variable of this name is already defined.
  87          If the old definition is from a stronger source
  88          than this one, don't redefine it.  */
  89       if ((int) origin >= (int) v->origin)
  90         {
  91           if (v->value != 0)
  92             free (v->value);
  93           v->value = savestring (value, strlen (value));
  94           v->origin = origin;
  95           v->recursive = recursive;
  96         }
  97       return v;
  98     }
  99
 100   /* Create a new variable definition and add it to the hash table.  */
 101
 102   v = (struct variable *) xmalloc (sizeof (struct variable));
 103   v->name = savestring (name, length);
 104   v->value = savestring (value, strlen (value));
 105   v->origin = origin;
 106   v->recursive = recursive;
 107   v->expanding = 0;
 108   v->export = v_default;
 109   v->next = set->table[hashval];
 110   set->table[hashval] = v;
 111   return v;
 112 }
 113
 114 /* Define a variable in the current variable set.  */
 115
 116 struct variable *
 117 define_variable (name, length, value, origin, recursive)
 118      char *name;
 119      unsigned int length;
 120      char *value;
 121      enum variable_origin origin;
 122      int recursive;
 123 {
 124   return define_variable_in_set (name, length, value, origin, recursive,
 125                                  current_variable_set_list->set);
 126 }
 127
 128 /* Define a variable in FILE's variable set.  */
 129
 130 struct variable *
 131 define_variable_for_file (name, length, value, origin, recursive, file)
 132      char *name;
 133      unsigned int length;
 134      char *value;
 135      enum variable_origin origin;
 136      int recursive;
 137      struct file *file;
 138 {
 139   return define_variable_in_set (name, length, value, origin, recursive,
 140                                  file->variables->set);
 141 }
 142 \f
 143 /* Lookup a variable whose name is a string starting at NAME
 144    and with LENGTH chars.  NAME need not be null-terminated.
 145    Returns address of the `struct variable' containing all info
 146    on the variable, or nil if no such variable is defined.  */
 147
 148 struct variable *
 149 lookup_variable (name, length)
 150      char *name;
 151      unsigned int length;
 152 {
 153   register struct variable_set_list *setlist;
 154
 155   register unsigned int i;
 156   register unsigned int rawhash = 0;
 157
 158   for (i = 0; i < length; ++i)
 159     HASH (rawhash, name[i]);
 160
 161   for (setlist = current_variable_set_list;
 162        setlist != 0; setlist = setlist->next)
 163     {
 164       register struct variable_set *set = setlist->set;
 165       register unsigned int hashval = rawhash % set->buckets;
 166       register struct variable *v;
 167
 168       for (v = set->table[hashval]; v != 0; v = v->next)
 169         if (*v->name == *name
 170             && !strncmp (v->name + 1, name + 1, length - 1)
 171             && v->name[length] == 0)
 172           return v;
 173     }
 174
 175   return 0;
 176 }
 177 \f
 178 /* Initialize FILE's variable set list.  If FILE already has a variable set
 179    list, the topmost variable set is left intact, but the the rest of the
 180    chain is replaced with FILE->parent's setlist.  */
 181
 182 void
 183 initialize_file_variables (file)
 184      struct file *file;
 185 {
 186   register struct variable_set_list *l = file->variables;
 187   if (l == 0)
 188     {
 189       l = (struct variable_set_list *)
 190         xmalloc (sizeof (struct variable_set_list));
 191       l->set = (struct variable_set *) xmalloc (sizeof (struct variable_set));
 192       l->set->buckets = PERFILE_VARIABLE_BUCKETS;
 193       l->set->table = (struct variable **)
 194         xmalloc (l->set->buckets * sizeof (struct variable *));
 195       bzero ((char *) l->set->table,
 196              l->set->buckets * sizeof (struct variable *));
 197       file->variables = l;
 198     }
 199
 200   if (file->parent == 0)
 201     l->next = &global_setlist;
 202   else
 203     {
 204       if (file->parent->variables == 0)
 205         initialize_file_variables (file->parent);
 206       l->next = file->parent->variables;
 207     }
 208 }
 209 \f
 210 /* Pop the top set off the current variable set list,
 211    and free all its storage.  */
 212
 213 void
 214 pop_variable_scope ()
 215 {
 216   register struct variable_set_list *setlist = current_variable_set_list;
 217   register struct variable_set *set = setlist->set;
 218   register unsigned int i;
 219
 220   current_variable_set_list = setlist->next;
 221   free ((char *) setlist);
 222
 223   for (i = 0; i < set->buckets; ++i)
 224     {
 225       register struct variable *next = set->table[i];
 226       while (next != 0)
 227         {
 228           register struct variable *v = next;
 229           next = v->next;
 230
 231           free (v->name);
 232           free ((char *) v);
 233         }
 234     }
 235   free ((char *) set->table);
 236   free ((char *) set);
 237 }
 238
 239 /* Create a new variable set and push it on the current setlist.  */
 240
 241 void
 242 push_new_variable_scope ()
 243 {
 244   register struct variable_set_list *setlist;
 245   register struct variable_set *set;
 246
 247   set = (struct variable_set *) xmalloc (sizeof (struct variable_set));
 248   set->buckets = SMALL_SCOPE_VARIABLE_BUCKETS;
 249   set->table = (struct variable **)
 250     xmalloc (set->buckets * sizeof (struct variable *));
 251   bzero ((char *) set->table, set->buckets * sizeof (struct variable *));
 252
 253   setlist = (struct variable_set_list *)
 254     xmalloc (sizeof (struct variable_set_list));
 255   setlist->set = set;
 256   setlist->next = current_variable_set_list;
 257   current_variable_set_list = setlist;
 258 }
 259 \f
 260 /* Merge SET1 into SET0, freeing unused storage in SET1.  */
 261
 262 static void
 263 merge_variable_sets (set0, set1)
 264      struct variable_set *set0, *set1;
 265 {
 266   register unsigned int bucket1;
 267
 268   for (bucket1 = 0; bucket1 < set1->buckets; ++bucket1)
 269     {
 270       register struct variable *v1 = set1->table[bucket1];
 271       while (v1 != 0)
 272         {
 273           struct variable *next = v1->next;
 274           unsigned int bucket0;
 275           register struct variable *v0;
 276
 277           if (set1->buckets >= set0->buckets)
 278             bucket0 = bucket1;
 279           else
 280             {
 281               register char *n;
 282               bucket0 = 0;
 283               for (n = v1->name; *n != '\0'; ++n)
 284                 HASH (bucket0, *n);
 285             }
 286           bucket0 %= set0->buckets;
 287
 288           for (v0 = set0->table[bucket0]; v0 != 0; v0 = v0->next)
 289             if (streq (v0->name, v1->name))
 290               break;
 291
 292           if (v0 == 0)
 293             {
 294               /* There is no variable in SET0 with the same name.  */
 295               v1->next = set0->table[bucket0];
 296               set0->table[bucket0] = v1;
 297             }
 298           else
 299             {
 300               /* The same variable exists in both sets.
 301                  SET0 takes precedence.  */
 302               free (v1->value);
 303               free ((char *) v1);
 304             }
 305
 306           v1 = next;
 307         }
 308     }
 309 }
 310
 311 /* Merge SETLIST1 into SETLIST0, freeing unused storage in SETLIST1.  */
 312
 313 void
 314 merge_variable_set_lists (setlist0, setlist1)
 315      struct variable_set_list **setlist0, *setlist1;
 316 {
 317   register struct variable_set_list *list0 = *setlist0;
 318   struct variable_set_list *last0 = 0;
 319
 320   while (setlist1 != 0 && list0 != 0)
 321     {
 322       struct variable_set_list *next = setlist1;
 323       setlist1 = setlist1->next;
 324
 325       merge_variable_sets (list0->set, next->set);
 326
 327       free ((char *) next);
 328
 329       last0 = list0;
 330       list0 = list0->next;
 331     }
 332
 333   if (setlist1 != 0)
 334     {
 335       if (last0 == 0)
 336         *setlist0 = setlist1;
 337       else
 338         last0->next = setlist1;
 339     }
 340 }
 341 \f
 342 /* Define the automatic variables, and record the addresses
 343    of their structures so we can change their values quickly.  */
 344
 345 void
 346 define_automatic_variables ()
 347 {
 348   extern char default_shell[];
 349   register struct variable *v;
 350   char buf[200];
 351
 352   sprintf (buf, "%u", makelevel);
 353   (void) define_variable ("MAKELEVEL", 9, buf, o_env, 0);
 354
 355   sprintf (buf, "%s%s%s",
 356            version_string,
 357            (remote_description == 0 || remote_description[0] == '\0')
 358            ? "" : "-",
 359            (remote_description == 0 || remote_description[0] == '\0')
 360            ? "" : remote_description);
 361   (void) define_variable ("MAKE_VERSION", 12, buf, o_default, 0);
 362
 363
 364   /* This won't override any definition, but it
 365      will provide one if there isn't one there.  */
 366   v = define_variable ("SHELL", 5, default_shell, o_default, 0);
 367   v->export = v_export;         /* Always export SHELL.  */
 368
 369   /* Don't let SHELL come from the environment.  */
 370   if (*v->value == '\0' || v->origin == o_env || v->origin == o_env_override)
 371     {
 372       free (v->value);
 373       v->origin = o_file;
 374       v->value = savestring (default_shell, strlen (default_shell));
 375     }
 376
 377   /* Make sure MAKEFILES gets exported if it is set.  */
 378   v = define_variable ("MAKEFILES", 9, "", o_default, 0);
 379   v->export = v_ifset;
 380
 381   /* Define the magic D and F variables in terms of
 382      the automatic variables they are variations of.  */
 383
 384   define_variable ("@D", 2, "$(patsubst %/,%,$(dir $@))", o_automatic, 1);
 385   define_variable ("%D", 2, "$(patsubst %/,%,$(dir $%))", o_automatic, 1);
 386   define_variable ("*D", 2, "$(patsubst %/,%,$(dir $*))", o_automatic, 1);
 387   define_variable ("<D", 2, "$(patsubst %/,%,$(dir $<))", o_automatic, 1);
 388   define_variable ("?D", 2, "$(patsubst %/,%,$(dir $?))", o_automatic, 1);
 389   define_variable ("^D", 2, "$(patsubst %/,%,$(dir $^))", o_automatic, 1);
 390   define_variable ("+D", 2, "$(patsubst %/,%,$(dir $+))", o_automatic, 1);
 391   define_variable ("@F", 2, "$(notdir $@)", o_automatic, 1);
 392   define_variable ("%F", 2, "$(notdir $%)", o_automatic, 1);
 393   define_variable ("*F", 2, "$(notdir $*)", o_automatic, 1);
 394   define_variable ("<F", 2, "$(notdir $<)", o_automatic, 1);
 395   define_variable ("?F", 2, "$(notdir $?)", o_automatic, 1);
 396   define_variable ("^F", 2, "$(notdir $^)", o_automatic, 1);
 397   define_variable ("+F", 2, "$(notdir $+)", o_automatic, 1);
 398 }
 399 \f
 400 int export_all_variables;
 401
 402 /* Create a new environment for FILE's commands.
 403    If FILE is nil, this is for the `shell' function.
 404    The child's MAKELEVEL variable is incremented.  */
 405
 406 char **
 407 target_environment (file)
 408      struct file *file;
 409 {
 410   struct variable_set_list *set_list;
 411   register struct variable_set_list *s;
 412   struct variable_bucket
 413     {
 414       struct variable_bucket *next;
 415       struct variable *variable;
 416     };
 417   struct variable_bucket **table;
 418   unsigned int buckets;
 419   register unsigned int i;
 420   register unsigned nvariables;
 421   char **result;
 422   unsigned int mklev_hash;
 423
 424   if (file == 0)
 425     set_list = current_variable_set_list;
 426   else
 427     set_list = file->variables;
 428
 429   /* Find the lowest number of buckets in any set in the list.  */
 430   s = set_list;
 431   buckets = s->set->buckets;
 432   for (s = s->next; s != 0; s = s->next)
 433     if (s->set->buckets < buckets)
 434       buckets = s->set->buckets;
 435
 436   /* Find the hash value of the bucket `MAKELEVEL' will fall into.  */
 437   {
 438     char *p = "MAKELEVEL";
 439     mklev_hash = 0;
 440     while (*p != '\0')
 441       HASH (mklev_hash, *p++);
 442   }
 443
 444   /* Temporarily allocate a table with that many buckets.  */
 445   table = (struct variable_bucket **)
 446     alloca (buckets * sizeof (struct variable_bucket *));
 447   bzero ((char *) table, buckets * sizeof (struct variable_bucket *));
 448
 449   /* Run through all the variable sets in the list,
 450      accumulating variables in TABLE.  */
 451   nvariables = 0;
 452   for (s = set_list; s != 0; s = s->next)
 453     {
 454       register struct variable_set *set = s->set;
 455       for (i = 0; i < set->buckets; ++i)
 456         {
 457           register struct variable *v;
 458           for (v = set->table[i]; v != 0; v = v->next)
 459             {
 460               unsigned int j = i % buckets;
 461               register struct variable_bucket *ov;
 462               register char *p = v->name;
 463
 464               if (i == mklev_hash % set->buckets
 465                   && streq (v->name, "MAKELEVEL"))
 466                 /* Don't include MAKELEVEL because it will be
 467                    added specially at the end.  */
 468                 continue;
 469
 470               switch (v->export)
 471                 {
 472                 case v_default:
 473                   if (v->origin == o_default || v->origin == o_automatic)
 474                     /* Only export default variables by explicit request.  */
 475                     continue;
 476
 477                   if (! export_all_variables
 478                       && v->origin != o_command
 479                       && v->origin != o_env && v->origin != o_env_override)
 480                     continue;
 481
 482                   if (*p != '_' && (*p < 'A' || *p > 'Z')
 483                       && (*p < 'a' || *p > 'z'))
 484                     continue;
 485                   for (++p; *p != '\0'; ++p)
 486                     if (*p != '_' && (*p < 'a' || *p > 'z')
 487                         && (*p < 'A' || *p > 'Z') && (*p < '0' || *p > '9'))
 488                       break;
 489                   if (*p != '\0')
 490                     continue;
 491
 492                 case v_export:
 493                   break;
 494
 495                 case v_noexport:
 496                   continue;
 497
 498                 case v_ifset:
 499                   if (v->origin == o_default)
 500                     continue;
 501                   break;
 502                 }
 503
 504               for (ov = table[j]; ov != 0; ov = ov->next)
 505                 if (streq (v->name, ov->variable->name))
 506                   break;
 507               if (ov == 0)
 508                 {
 509                   register struct variable_bucket *entry;
 510                   entry = (struct variable_bucket *)
 511                     alloca (sizeof (struct variable_bucket));
 512                   entry->next = table[j];
 513                   entry->variable = v;
 514                   table[j] = entry;
 515                   ++nvariables;
 516                 }
 517             }
 518         }
 519     }
 520
 521   result = (char **) xmalloc ((nvariables + 2) * sizeof (char *));
 522   nvariables = 0;
 523   for (i = 0; i < buckets; ++i)
 524     {
 525       register struct variable_bucket *b;
 526       for (b = table[i]; b != 0; b = b->next)
 527         {
 528           register struct variable *v = b->variable;
 529           /* If V is recursively expanded and didn't come from the environment,
 530              expand its value.  If it came from the environment, it should
 531              go back into the environment unchanged.  */
 532           if (v->recursive
 533               && v->origin != o_env && v->origin != o_env_override)
 534             {
 535               char *value = recursively_expand (v);
 536               result[nvariables++] = concat (v->name, "=", value);
 537               free (value);
 538             }
 539           else
 540             result[nvariables++] = concat (v->name, "=", v->value);
 541         }
 542     }
 543   result[nvariables] = (char *) xmalloc (100);
 544   (void) sprintf (result[nvariables], "MAKELEVEL=%u", makelevel + 1);
 545   result[++nvariables] = 0;
 546
 547   return result;
 548 }
 549 \f
 550 /* Try to interpret LINE (a null-terminated string) as a variable definition.
 551
 552    ORIGIN may be o_file, o_override, o_env, o_env_override,
 553    or o_command specifying that the variable definition comes
 554    from a makefile, an override directive, the environment with
 555    or without the -e switch, or the command line.
 556
 557    A variable definition has the form "name = value" or "name := value".
 558    Any whitespace around the "=" or ":=" is removed.  The first form
 559    defines a variable that is recursively re-evaluated.  The second form
 560    defines a variable whose value is variable-expanded at the time of
 561    definition and then is evaluated only once at the time of expansion.
 562
 563    If a variable was defined, a pointer to its `struct variable' is returned.
 564    If not, NULL is returned.  */
 565
 566 struct variable *
 567 try_variable_definition (filename, lineno, line, origin)
 568      char *filename;
 569      unsigned int lineno;
 570      char *line;
 571      enum variable_origin origin;
 572 {
 573   register int c;
 574   register char *p = line;
 575   register char *beg;
 576   register char *end;
 577   enum { bogus, simple, recursive, append } flavor = bogus;
 578   char *name, *expanded_name, *value;
 579   struct variable *v;
 580
 581   while (1)
 582     {
 583       c = *p++;
 584       if (c == '\0' || c == '#')
 585         return 0;
 586       if (c == '=')
 587         {
 588           end = p - 1;
 589           flavor = recursive;
 590           break;
 591         }
 592       else if (c == ':')
 593         if (*p == '=')
 594           {
 595             end = p++ - 1;
 596             flavor = simple;
 597             break;
 598           }
 599         else
 600           /* A colon other than := is a rule line, not a variable defn.  */
 601           return 0;
 602       else if (c == '+' && *p == '=')
 603         {
 604           end = p++ - 1;
 605           flavor = append;
 606           break;
 607         }
 608     }
 609
 610   beg = next_token (line);
 611   while (end > beg && isblank (end[-1]))
 612     --end;
 613   p = next_token (p);
 614
 615   /* Expand the name, so "$(foo)bar = baz" works.  */
 616   name = (char *) alloca (end - beg + 1);
 617   bcopy (beg, name, end - beg);
 618   name[end - beg] = '\0';
 619   expanded_name = allocated_variable_expand (name);
 620
 621   if (expanded_name[0] == '\0')
 622     {
 623       if (filename == 0)
 624         fatal ("empty variable name");
 625       else
 626         makefile_fatal (filename, lineno, "empty variable name");
 627     }
 628
 629   /* Calculate the variable's new value in VALUE.  */
 630
 631   switch (flavor)
 632     {
 633     case bogus:
 634       /* Should not be possible.  */
 635       abort ();
 636       return 0;
 637     case simple:
 638       /* A simple variable definition "var := value".  Expand the value.  */
 639       value = variable_expand (p);
 640       break;
 641     case recursive:
 642       /* A recursive variable definition "var = value".
 643          The value is used verbatim.  */
 644       value = p;
 645       break;
 646     case append:
 647       /* An appending variable definition "var += value".
 648          Extract the old value and append the new one.  */
 649       v = lookup_variable (expanded_name, strlen (expanded_name));
 650       if (v == 0)
 651         {
 652           /* There was no old value.
 653              This becomes a normal recursive definition.  */
 654           value = p;
 655           flavor = recursive;
 656         }
 657       else
 658         {
 659           /* Paste the old and new values together in VALUE.  */
 660
 661           unsigned int oldlen, newlen;
 662
 663           if (v->recursive)
 664             /* The previous definition of the variable was recursive.
 665                The new value comes from the unexpanded old and new values.  */
 666             flavor = recursive;
 667           else
 668             /* The previous definition of the variable was simple.
 669                The new value comes from the old value, which was expanded
 670                when it was set; and from the expanded new value.  */
 671             p = variable_expand (p);
 672
 673           oldlen = strlen (v->value);
 674           newlen = strlen (p);
 675           value = (char *) alloca (oldlen + 1 + newlen + 1);
 676           bcopy (v->value, value, oldlen);
 677           value[oldlen] = ' ';
 678           bcopy (p, &value[oldlen + 1], newlen + 1);
 679         }
 680     }
 681
 682   v = define_variable (expanded_name, strlen (expanded_name),
 683                        value, origin, flavor == recursive);
 684
 685   free (expanded_name);
 686
 687   return v;
 688 }
 689 \f
 690 /* Print information for variable V, prefixing it with PREFIX.  */
 691
 692 static void
 693 print_variable (v, prefix)
 694      register struct variable *v;
 695      char *prefix;
 696 {
 697   char *origin;
 698
 699   switch (v->origin)
 700     {
 701     case o_default:
 702       origin = "default";
 703       break;
 704     case o_env:
 705       origin = "environment";
 706       break;
 707     case o_file:
 708       origin = "makefile";
 709       break;
 710     case o_env_override:
 711       origin = "environment under -e";
 712       break;
 713     case o_command:
 714       origin = "command line";
 715       break;
 716     case o_override:
 717       origin = "`override' directive";
 718       break;
 719     case o_automatic:
 720       origin = "automatic";
 721       break;
 722     case o_invalid:
 723     default:
 724       abort ();
 725       break;
 726     }
 727   printf ("# %s\n", origin);
 728
 729   fputs (prefix, stdout);
 730
 731   /* Is this a `define'?  */
 732   if (v->recursive && index (v->value, '\n') != 0)
 733     printf ("define %s\n%s\nendef\n", v->name, v->value);
 734   else
 735     {
 736       register char *p;
 737
 738       printf ("%s %s= ", v->name, v->recursive ? "" : ":");
 739
 740       /* Check if the value is just whitespace.  */
 741       p = next_token (v->value);
 742       if (p != v->value && *p == '\0')
 743         /* All whitespace.  */
 744         printf ("$(subst ,,%s)", v->value);
 745       else if (v->recursive)
 746         fputs (v->value, stdout);
 747       else
 748         /* Double up dollar signs.  */
 749         for (p = v->value; *p != '\0'; ++p)
 750           {
 751             if (*p == '$')
 752               putchar ('$');
 753             putchar (*p);
 754           }
 755       putchar ('\n');
 756     }
 757 }
 758
 759
 760 /* Print all the variables in SET.  PREFIX is printed before
 761    the actual variable definitions (everything else is comments).  */
 762
 763 static void
 764 print_variable_set (set, prefix)
 765      register struct variable_set *set;
 766      char *prefix;
 767 {
 768   register unsigned int i, nvariables, per_bucket;
 769   register struct variable *v;
 770
 771   per_bucket = nvariables = 0;
 772   for (i = 0; i < set->buckets; ++i)
 773     {
 774       register unsigned int this_bucket = 0;
 775
 776       for (v = set->table[i]; v != 0; v = v->next)
 777         {
 778           ++this_bucket;
 779           print_variable (v, prefix);
 780         }
 781
 782       nvariables += this_bucket;
 783       if (this_bucket > per_bucket)
 784         per_bucket = this_bucket;
 785     }
 786
 787   if (nvariables == 0)
 788     puts ("# No variables.");
 789   else
 790     {
 791       printf ("# %u variables in %u hash buckets.\n",
 792               nvariables, set->buckets);
 793 #ifndef NO_FLOAT
 794       printf ("# average of %.1f variables per bucket, \
 795 max %u in one bucket.\n",
 796               (double) nvariables / (double) set->buckets,
 797               per_bucket);
 798 #endif
 799     }
 800 }
 801
 802
 803 /* Print the data base of variables.  */
 804
 805 void
 806 print_variable_data_base ()
 807 {
 808   puts ("\n# Variables\n");
 809
 810   print_variable_set (&global_variable_set, "");
 811 }
 812
 813
 814 /* Print all the local variables of FILE.  */
 815
 816 void
 817 print_file_variables (file)
 818      struct file *file;
 819 {
 820   if (file->variables != 0)
 821     print_variable_set (file->variables->set, "# ");
 822 }