home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 5 / FreshFish_July-August1994.bin / bbs / gnu / make-3.71-src.lha / src / amiga / make-3.71 / variable.c < prev    next >
C/C++ Source or Header  |  1994-04-05  |  22KB  |  821 lines
  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.  
  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.  
  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.  
  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.  
  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.  
  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->t