variable.h

   1 /* Definitions for using variables in GNU Make.
   2 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
   3 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
   4 2010 Free Software Foundation, Inc.
   5 This file is part of GNU Make.
   6
   7 GNU Make is free software; you can redistribute it and/or modify it under the
   8 terms of the GNU General Public License as published by the Free Software
   9 Foundation; either version 3 of the License, or (at your option) any later
  10 version.
  11
  12 GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  14 A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License along with
  17 this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 #include "hash.h"
  20
  21 /* Codes in a variable definition saying where the definition came from.
  22    Increasing numeric values signify less-overridable definitions.  */
  23 enum variable_origin
  24   {
  25     o_default,          /* Variable from the default set.  */
  26     o_env,              /* Variable from environment.  */
  27     o_file,             /* Variable given in a makefile.  */
  28     o_env_override,     /* Variable from environment, if -e.  */
  29     o_command,          /* Variable given by user.  */
  30     o_override,         /* Variable from an `override' directive.  */
  31     o_automatic,        /* Automatic variable -- cannot be set.  */
  32     o_invalid           /* Core dump time.  */
  33   };
  34
  35 enum variable_flavor
  36   {
  37     f_bogus,            /* Bogus (error) */
  38     f_simple,           /* Simple definition (:=) */
  39     f_recursive,        /* Recursive definition (=) */
  40     f_append,           /* Appending definition (+=) */
  41     f_conditional       /* Conditional definition (?=) */
  42   };
  43
  44 /* Structure that represents one variable definition.
  45    Each bucket of the hash table is a chain of these,
  46    chained through `next'.  */
  47
  48 #define EXP_COUNT_BITS  15      /* This gets all the bitfields into 32 bits */
  49 #define EXP_COUNT_MAX   ((1<<EXP_COUNT_BITS)-1)
  50
  51 struct variable
  52   {
  53     char *name;                 /* Variable name.  */
  54     int length;                 /* strlen (name) */
  55     char *value;                /* Variable value.  */
  56     struct floc fileinfo;       /* Where the variable was defined.  */
  57     unsigned int recursive:1;   /* Gets recursively re-evaluated.  */
  58     unsigned int append:1;      /* Nonzero if an appending target-specific
  59                                    variable.  */
  60     unsigned int conditional:1; /* Nonzero if set with a ?=. */
  61     unsigned int per_target:1;  /* Nonzero if a target-specific variable.  */
  62     unsigned int special:1;     /* Nonzero if this is a special variable.  */
  63     unsigned int exportable:1;  /* Nonzero if the variable _could_ be
  64                                    exported.  */
  65     unsigned int expanding:1;   /* Nonzero if currently being expanded.  */
  66     unsigned int private_var:1; /* Nonzero avoids inheritance of this
  67                                    target-specific variable.  */
  68     unsigned int exp_count:EXP_COUNT_BITS;
  69                                 /* If >1, allow this many self-referential
  70                                    expansions.  */
  71     enum variable_flavor
  72       flavor ENUM_BITFIELD (3); /* Variable flavor.  */
  73     enum variable_origin
  74       origin ENUM_BITFIELD (3); /* Variable origin.  */
  75     enum variable_export
  76       {
  77         v_export,               /* Export this variable.  */
  78         v_noexport,             /* Don't export this variable.  */
  79         v_ifset,                /* Export it if it has a non-default value.  */
  80         v_default               /* Decide in target_environment.  */
  81       } export ENUM_BITFIELD (2);
  82   };
  83
  84 /* Structure that represents a variable set.  */
  85
  86 struct variable_set
  87   {
  88     struct hash_table table;    /* Hash table of variables.  */
  89   };
  90
  91 /* Structure that represents a list of variable sets.  */
  92
  93 struct variable_set_list
  94   {
  95     struct variable_set_list *next;     /* Link in the chain.  */
  96     struct variable_set *set;           /* Variable set.  */
  97     int next_is_parent;                 /* True if next is a parent target.  */
  98   };
  99
 100 /* Structure used for pattern-specific variables.  */
 101
 102 struct pattern_var
 103   {
 104     struct pattern_var *next;
 105     const char *suffix;
 106     const char *target;
 107     unsigned int len;
 108     struct variable variable;
 109   };
 110
 111 extern char *variable_buffer;
 112 extern struct variable_set_list *current_variable_set_list;
 113 extern struct variable *default_goal_var;
 114
 115 /* expand.c */
 116 char *variable_buffer_output (char *ptr, const char *string, unsigned int length);
 117 char *variable_expand (const char *line);
 118 char *variable_expand_for_file (const char *line, struct file *file);
 119 char *allocated_variable_expand_for_file (const char *line, struct file *file);
 120 #define allocated_variable_expand(line) \
 121   allocated_variable_expand_for_file (line, (struct file *) 0)
 122 char *expand_argument (const char *str, const char *end);
 123 char *variable_expand_string (char *line, const char *string, long length);
 124 void install_variable_buffer (char **bufp, unsigned int *lenp);
 125 void restore_variable_buffer (char *buf, unsigned int len);
 126
 127 /* function.c */
 128 int handle_function (char **op, const char **stringp);
 129 int pattern_matches (const char *pattern, const char *percent, const char *str);
 130 char *subst_expand (char *o, const char *text, const char *subst,
 131                     const char *replace, unsigned int slen, unsigned int rlen,
 132                     int by_word);
 133 char *patsubst_expand_pat (char *o, const char *text, const char *pattern,
 134                            const char *replace, const char *pattern_percent,
 135                            const char *replace_percent);
 136 char *patsubst_expand (char *o, const char *text, char *pattern, char *replace);
 137
 138 /* expand.c */
 139 char *recursively_expand_for_file (struct variable *v, struct file *file);
 140 #define recursively_expand(v)   recursively_expand_for_file (v, NULL)
 141
 142 /* variable.c */
 143 struct variable_set_list *create_new_variable_set (void);
 144 void free_variable_set (struct variable_set_list *);
 145 struct variable_set_list *push_new_variable_scope (void);
 146 void pop_variable_scope (void);
 147 void define_automatic_variables (void);
 148 void initialize_file_variables (struct file *file, int reading);
 149 void print_file_variables (const struct file *file);
 150 void print_variable_set (struct variable_set *set, char *prefix);
 151 void merge_variable_set_lists (struct variable_set_list **to_list,
 152                                struct variable_set_list *from_list);
 153 struct variable *do_variable_definition (const struct floc *flocp,
 154                                          const char *name, const char *value,
 155                                          enum variable_origin origin,
 156                                          enum variable_flavor flavor,
 157                                          int target_var);
 158 char *parse_variable_definition (const char *line,
 159                                  enum variable_flavor *flavor);
 160 struct variable *assign_variable_definition (struct variable *v, char *line);
 161 struct variable *try_variable_definition (const struct floc *flocp, char *line,
 162                                           enum variable_origin origin,
 163                                           int target_var);
 164 void init_hash_global_variable_set (void);
 165 void hash_init_function_table (void);
 166 struct variable *lookup_variable (const char *name, unsigned int length);
 167 struct variable *lookup_variable_in_set (const char *name, unsigned int length,
 168                                          const struct variable_set *set);
 169
 170 struct variable *define_variable_in_set (const char *name, unsigned int length,
 171                                          const char *value,
 172                                          enum variable_origin origin,
 173                                          int recursive,
 174                                          struct variable_set *set,
 175                                          const struct floc *flocp);
 176
 177 /* Define a variable in the current variable set.  */
 178
 179 #define define_variable(n,l,v,o,r) \
 180           define_variable_in_set((n),(l),(v),(o),(r),\
 181                                  current_variable_set_list->set,NILF)
 182
 183 /* Define a variable with a constant name in the current variable set.  */
 184
 185 #define define_variable_cname(n,v,o,r) \
 186           define_variable_in_set((n),(sizeof (n) - 1),(v),(o),(r),\
 187                                  current_variable_set_list->set,NILF)
 188
 189 /* Define a variable with a location in the current variable set.  */
 190
 191 #define define_variable_loc(n,l,v,o,r,f) \
 192           define_variable_in_set((n),(l),(v),(o),(r),\
 193                                  current_variable_set_list->set,(f))
 194
 195 /* Define a variable with a location in the global variable set.  */
 196
 197 #define define_variable_global(n,l,v,o,r,f) \
 198           define_variable_in_set((n),(l),(v),(o),(r),NULL,(f))
 199
 200 /* Define a variable in FILE's variable set.  */
 201
 202 #define define_variable_for_file(n,l,v,o,r,f) \
 203           define_variable_in_set((n),(l),(v),(o),(r),(f)->variables->set,NILF)
 204
 205 void undefine_variable_in_set (const char *name, unsigned int length,
 206                                enum variable_origin origin,
 207                                struct variable_set *set);
 208
 209 /* Remove variable from the current variable set. */
 210
 211 #define undefine_variable_global(n,l,o) \
 212           undefine_variable_in_set((n),(l),(o),NULL)
 213
 214 /* Warn that NAME is an undefined variable.  */
 215
 216 #define warn_undefined(n,l) do{\
 217                               if (warn_undefined_variables_flag) \
 218                                 error (reading_file, \
 219                                        _("warning: undefined variable `%.*s'"), \
 220                                 (int)(l), (n)); \
 221                               }while(0)
 222
 223 char **target_environment (struct file *file);
 224
 225 struct pattern_var *create_pattern_var (const char *target,
 226                                         const char *suffix);
 227
 228 extern int export_all_variables;
 229
 230 #define MAKELEVEL_NAME "MAKELEVEL"
 231 #define MAKELEVEL_LENGTH (sizeof (MAKELEVEL_NAME) - 1)