1 /* Variable expansion functions for 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 Free Software
4 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 2, or (at your option) any later version.
10 
11 GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
13 A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
14 
15 You should have received a copy of the GNU General Public License along with
16 GNU Make; see the file COPYING.  If not, write to the Free Software
17 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.  */
18 
19 #include "make.h"
20 
21 #include <assert.h>
22 
23 #include "filedef.h"
24 #include "job.h"
25 #include "commands.h"
26 #include "variable.h"
27 #include "rule.h"
28 
29 /* Initially, any errors reported when expanding strings will be reported
30    against the file where the error appears.  */
31 const struct floc **expanding_var = &reading_file;
32 
33 /* The next two describe the variable output buffer.
34    This buffer is used to hold the variable-expansion of a line of the
35    makefile.  It is made bigger with realloc whenever it is too small.
36    variable_buffer_length is the size currently allocated.
37    variable_buffer is the address of the buffer.
38 
39    For efficiency, it's guaranteed that the buffer will always have
40    VARIABLE_BUFFER_ZONE extra bytes allocated.  This allows you to add a few
41    extra chars without having to call a function.  Note you should never use
42    these bytes unless you're _sure_ you have room (you know when the buffer
43    length was last checked.  */
44 
45 #define VARIABLE_BUFFER_ZONE    5
46 
47 static unsigned int variable_buffer_length;
48 char *variable_buffer;
49 
50 /* Subroutine of variable_expand and friends:
51    The text to add is LENGTH chars starting at STRING to the variable_buffer.
52    The text is added to the buffer at PTR, and the updated pointer into
53    the buffer is returned as the value.  Thus, the value returned by
54    each call to variable_buffer_output should be the first argument to
55    the following call.  */
56 
57 char *
variable_buffer_output(char * ptr,char * string,unsigned int length)58 variable_buffer_output (char *ptr, char *string, unsigned int length)
59 {
60   register unsigned int newlen = length + (ptr - variable_buffer);
61 
62   if ((newlen + VARIABLE_BUFFER_ZONE) > variable_buffer_length)
63     {
64       unsigned int offset = ptr - variable_buffer;
65       variable_buffer_length = (newlen + 100 > 2 * variable_buffer_length
66 				? newlen + 100
67 				: 2 * variable_buffer_length);
68       variable_buffer = (char *) xrealloc (variable_buffer,
69 					   variable_buffer_length);
70       ptr = variable_buffer + offset;
71     }
72 
73   bcopy (string, ptr, length);
74   return ptr + length;
75 }
76 
77 /* Return a pointer to the beginning of the variable buffer.  */
78 
79 static char *
initialize_variable_output(void)80 initialize_variable_output (void)
81 {
82   /* If we don't have a variable output buffer yet, get one.  */
83 
84   if (variable_buffer == 0)
85     {
86       variable_buffer_length = 200;
87       variable_buffer = (char *) xmalloc (variable_buffer_length);
88       variable_buffer[0] = '\0';
89     }
90 
91   return variable_buffer;
92 }
93 
94 /* Recursively expand V.  The returned string is malloc'd.  */
95 
96 static char *allocated_variable_append PARAMS ((const struct variable *v));
97 
98 char *
recursively_expand_for_file(struct variable * v,struct file * file)99 recursively_expand_for_file (struct variable *v, struct file *file)
100 {
101   char *value;
102   const struct floc *this_var;
103   const struct floc **saved_varp;
104   struct variable_set_list *save = 0;
105   int set_reading = 0;
106 
107   /* Don't install a new location if this location is empty.
108      This can happen for command-line variables, builtin variables, etc.  */
109   saved_varp = expanding_var;
110   if (v->fileinfo.filenm)
111     {
112       this_var = &v->fileinfo;
113       expanding_var = &this_var;
114     }
115 
116   /* If we have no other file-reading context, use the variable's context. */
117   if (!reading_file)
118     {
119       set_reading = 1;
120       reading_file = &v->fileinfo;
121     }
122 
123   if (v->expanding)
124     {
125       if (!v->exp_count)
126         /* Expanding V causes infinite recursion.  Lose.  */
127         fatal (*expanding_var,
128                _("Recursive variable `%s' references itself (eventually)"),
129                v->name);
130       --v->exp_count;
131     }
132 
133   if (file)
134     {
135       save = current_variable_set_list;
136       current_variable_set_list = file->variables;
137     }
138 
139   v->expanding = 1;
140   if (v->append)
141     value = allocated_variable_append (v);
142   else
143     value = allocated_variable_expand (v->value);
144   v->expanding = 0;
145 
146   if (set_reading)
147     reading_file = 0;
148 
149   if (file)
150     current_variable_set_list = save;
151 
152   expanding_var = saved_varp;
153 
154   return value;
155 }
156 
157 /* Expand a simple reference to variable NAME, which is LENGTH chars long.  */
158 
159 #ifdef __GNUC__
160 __inline
161 #endif
162 static char *
reference_variable(char * o,char * name,unsigned int length)163 reference_variable (char *o, char *name, unsigned int length)
164 {
165   register struct variable *v;
166   char *value;
167 
168   v = lookup_variable (name, length);
169 
170   if (v == 0)
171     warn_undefined (name, length);
172 
173   /* If there's no variable by that name or it has no value, stop now.  */
174   if (v == 0 || (*v->value == '\0' && !v->append))
175     return o;
176 
177   value = (v->recursive ? recursively_expand (v) : v->value);
178 
179   o = variable_buffer_output (o, value, strlen (value));
180 
181   if (v->recursive)
182     free (value);
183 
184   return o;
185 }
186 
187 /* Scan STRING for variable references and expansion-function calls.  Only
188    LENGTH bytes of STRING are actually scanned.  If LENGTH is -1, scan until
189    a null byte is found.
190 
191    Write the results to LINE, which must point into `variable_buffer'.  If
192    LINE is NULL, start at the beginning of the buffer.
193    Return a pointer to LINE, or to the beginning of the buffer if LINE is
194    NULL.  */
195 
196 char *
variable_expand_string(char * line,char * string,long length)197 variable_expand_string (char *line, char *string, long length)
198 {
199   register struct variable *v;
200   register char *p, *o, *p1;
201   char save_char = '\0';
202   unsigned int line_offset;
203 
204   if (!line)
205     line = initialize_variable_output();
206 
207   p = string;
208   o = line;
209   line_offset = line - variable_buffer;
210 
211   if (length >= 0)
212     {
213       save_char = string[length];
214       string[length] = '\0';
215     }
216 
217   while (1)
218     {
219       /* Copy all following uninteresting chars all at once to the
220          variable output buffer, and skip them.  Uninteresting chars end
221 	 at the next $ or the end of the input.  */
222 
223       p1 = strchr (p, '$');
224 
225       o = variable_buffer_output (o, p, p1 != 0 ? (unsigned int)(p1 - p) : strlen (p) + 1);
226 
227       if (p1 == 0)
228 	break;
229       p = p1 + 1;
230 
231       /* Dispatch on the char that follows the $.  */
232 
233       switch (*p)
234 	{
235 	case '$':
236 	  /* $$ seen means output one $ to the variable output buffer.  */
237 	  o = variable_buffer_output (o, p, 1);
238 	  break;
239 
240 	case '(':
241 	case '{':
242 	  /* $(...) or ${...} is the general case of substitution.  */
243 	  {
244 	    char openparen = *p;
245 	    char closeparen = (openparen == '(') ? ')' : '}';
246 	    register char *beg = p + 1;
247 	    int free_beg = 0;
248 	    char *op, *begp;
249 	    char *end, *colon;
250 
251 	    op = o;
252 	    begp = p;
253 	    if (handle_function (&op, &begp))
254 	      {
255 		o = op;
256 		p = begp;
257 		break;
258 	      }
259 
260 	    /* Is there a variable reference inside the parens or braces?
261 	       If so, expand it before expanding the entire reference.  */
262 
263 	    end = strchr (beg, closeparen);
264 	    if (end == 0)
265               /* Unterminated variable reference.  */
266               fatal (*expanding_var, _("unterminated variable reference"));
267 	    p1 = lindex (beg, end, '$');
268 	    if (p1 != 0)
269 	      {
270 		/* BEG now points past the opening paren or brace.
271 		   Count parens or braces until it is matched.  */
272 		int count = 0;
273 		for (p = beg; *p != '\0'; ++p)
274 		  {
275 		    if (*p == openparen)
276 		      ++count;
277 		    else if (*p == closeparen && --count < 0)
278 		      break;
279 		  }
280 		/* If COUNT is >= 0, there were unmatched opening parens
281 		   or braces, so we go to the simple case of a variable name
282 		   such as `$($(a)'.  */
283 		if (count < 0)
284 		  {
285 		    beg = expand_argument (beg, p); /* Expand the name.  */
286 		    free_beg = 1; /* Remember to free BEG when finished.  */
287 		    end = strchr (beg, '\0');
288 		  }
289 	      }
290 	    else
291 	      /* Advance P to the end of this reference.  After we are
292                  finished expanding this one, P will be incremented to
293                  continue the scan.  */
294 	      p = end;
295 
296 	    /* This is not a reference to a built-in function and
297 	       any variable references inside are now expanded.
298 	       Is the resultant text a substitution reference?  */
299 
300 	    colon = lindex (beg, end, ':');
301 	    if (colon)
302 	      {
303 		/* This looks like a substitution reference: $(FOO:A=B).  */
304 		char *subst_beg, *subst_end, *replace_beg, *replace_end;
305 
306 		subst_beg = colon + 1;
307 		subst_end = lindex (subst_beg, end, '=');
308 		if (subst_end == 0)
309 		  /* There is no = in sight.  Punt on the substitution
310 		     reference and treat this as a variable name containing
311 		     a colon, in the code below.  */
312 		  colon = 0;
313 		else
314 		  {
315 		    replace_beg = subst_end + 1;
316 		    replace_end = end;
317 
318 		    /* Extract the variable name before the colon
319 		       and look up that variable.  */
320 		    v = lookup_variable (beg, colon - beg);
321 		    if (v == 0)
322 		      warn_undefined (beg, colon - beg);
323 
324                     /* If the variable is not empty, perform the
325                        substitution.  */
326 		    if (v != 0 && *v->value != '\0')
327 		      {
328 			char *pattern, *replace, *ppercent, *rpercent;
329 			char *value = (v->recursive
330                                        ? recursively_expand (v)
331 				       : v->value);
332 
333                         /* Copy the pattern and the replacement.  Add in an
334                            extra % at the beginning to use in case there
335                            isn't one in the pattern.  */
336                         pattern = (char *) alloca (subst_end - subst_beg + 2);
337                         *(pattern++) = '%';
338                         bcopy (subst_beg, pattern, subst_end - subst_beg);
339                         pattern[subst_end - subst_beg] = '\0';
340 
341                         replace = (char *) alloca (replace_end
342                                                    - replace_beg + 2);
343                         *(replace++) = '%';
344                         bcopy (replace_beg, replace,
345                                replace_end - replace_beg);
346                         replace[replace_end - replace_beg] = '\0';
347 
348                         /* Look for %.  Set the percent pointers properly
349                            based on whether we find one or not.  */
350 			ppercent = find_percent (pattern);
351 			if (ppercent)
352                           {
353                             ++ppercent;
354                             rpercent = 0;
355                           }
356 			else
357                           {
358                             ppercent = pattern;
359                             rpercent = replace;
360                             --pattern;
361                             --replace;
362                           }
363 
364                         o = patsubst_expand (o, value, pattern, replace,
365                                              ppercent, rpercent);
366 
367 			if (v->recursive)
368 			  free (value);
369 		      }
370 		  }
371 	      }
372 
373 	    if (colon == 0)
374 	      /* This is an ordinary variable reference.
375 		 Look up the value of the variable.  */
376 		o = reference_variable (o, beg, end - beg);
377 
378 	  if (free_beg)
379 	    free (beg);
380 	  }
381 	  break;
382 
383 	case '\0':
384 	  break;
385 
386 	default:
387 	  if (isblank ((unsigned char)p[-1]))
388 	    break;
389 
390 	  /* A $ followed by a random char is a variable reference:
391 	     $a is equivalent to $(a).  */
392           o = reference_variable (o, p, 1);
393 
394 	  break;
395 	}
396 
397       if (*p == '\0')
398 	break;
399       else
400 	++p;
401     }
402 
403   if (save_char)
404     string[length] = save_char;
405 
406   (void)variable_buffer_output (o, "", 1);
407   return (variable_buffer + line_offset);
408 }
409 
410 /* Scan LINE for variable references and expansion-function calls.
411    Build in `variable_buffer' the result of expanding the references and calls.
412    Return the address of the resulting string, which is null-terminated
413    and is valid only until the next time this function is called.  */
414 
415 char *
variable_expand(char * line)416 variable_expand (char *line)
417 {
418   return variable_expand_string(NULL, line, (long)-1);
419 }
420 
421 /* Expand an argument for an expansion function.
422    The text starting at STR and ending at END is variable-expanded
423    into a null-terminated string that is returned as the value.
424    This is done without clobbering `variable_buffer' or the current
425    variable-expansion that is in progress.  */
426 
427 char *
expand_argument(const char * str,const char * end)428 expand_argument (const char *str, const char *end)
429 {
430   char *tmp;
431 
432   if (str == end)
433     return xstrdup("");
434 
435   if (!end || *end == '\0')
436     return allocated_variable_expand ((char *)str);
437 
438   tmp = (char *) alloca (end - str + 1);
439   bcopy (str, tmp, end - str);
440   tmp[end - str] = '\0';
441 
442   return allocated_variable_expand (tmp);
443 }
444 
445 /* Expand LINE for FILE.  Error messages refer to the file and line where
446    FILE's commands were found.  Expansion uses FILE's variable set list.  */
447 
448 char *
variable_expand_for_file(char * line,struct file * file)449 variable_expand_for_file (char *line, struct file *file)
450 {
451   char *result;
452   struct variable_set_list *save;
453 
454   if (file == 0)
455     return variable_expand (line);
456 
457   save = current_variable_set_list;
458   current_variable_set_list = file->variables;
459   if (file->cmds && file->cmds->fileinfo.filenm)
460     reading_file = &file->cmds->fileinfo;
461   else
462     reading_file = 0;
463   result = variable_expand (line);
464   current_variable_set_list = save;
465   reading_file = 0;
466 
467   return result;
468 }
469 
470 /* Like allocated_variable_expand, but for += target-specific variables.
471    First recursively construct the variable value from its appended parts in
472    any upper variable sets.  Then expand the resulting value.  */
473 
474 static char *
variable_append(const char * name,unsigned int length,const struct variable_set_list * set)475 variable_append (const char *name, unsigned int length,
476                  const struct variable_set_list *set)
477 {
478   const struct variable *v;
479   char *buf = 0;
480 
481   /* If there's nothing left to check, return the empty buffer.  */
482   if (!set)
483     return initialize_variable_output ();
484 
485   /* Try to find the variable in this variable set.  */
486   v = lookup_variable_in_set (name, length, set->set);
487 
488   /* If there isn't one, look to see if there's one in a set above us.  */
489   if (!v)
490     return variable_append (name, length, set->next);
491 
492   /* If this variable type is append, first get any upper values.
493      If not, initialize the buffer.  */
494   if (v->append)
495     buf = variable_append (name, length, set->next);
496   else
497     buf = initialize_variable_output ();
498 
499   /* Append this value to the buffer, and return it.
500      If we already have a value, first add a space.  */
501   if (buf > variable_buffer)
502     buf = variable_buffer_output (buf, " ", 1);
503 
504   /* Either expand it or copy it, depending.  */
505   if (! v->recursive)
506     return variable_buffer_output (buf, v->value, strlen (v->value));
507 
508   buf = variable_expand_string (buf, v->value, strlen (v->value));
509   return (buf + strlen (buf));
510 }
511 
512 
513 static char *
allocated_variable_append(const struct variable * v)514 allocated_variable_append (const struct variable *v)
515 {
516   char *val;
517 
518   /* Construct the appended variable value.  */
519 
520   char *obuf = variable_buffer;
521   unsigned int olen = variable_buffer_length;
522 
523   variable_buffer = 0;
524 
525   val = variable_append (v->name, strlen (v->name), current_variable_set_list);
526   variable_buffer_output (val, "", 1);
527   val = variable_buffer;
528 
529   variable_buffer = obuf;
530   variable_buffer_length = olen;
531 
532   return val;
533 }
534 
535 /* Like variable_expand_for_file, but the returned string is malloc'd.
536    This function is called a lot.  It wants to be efficient.  */
537 
538 char *
allocated_variable_expand_for_file(char * line,struct file * file)539 allocated_variable_expand_for_file (char *line, struct file *file)
540 {
541   char *value;
542 
543   char *obuf = variable_buffer;
544   unsigned int olen = variable_buffer_length;
545 
546   variable_buffer = 0;
547 
548   value = variable_expand_for_file (line, file);
549 
550 #if 0
551   /* Waste a little memory and save time.  */
552   value = xrealloc (value, strlen (value))
553 #endif
554 
555   variable_buffer = obuf;
556   variable_buffer_length = olen;
557 
558   return value;
559 }
560 
561 /* Install a new variable_buffer context, returning the current one for
562    safe-keeping.  */
563 
564 void
install_variable_buffer(char ** bufp,unsigned int * lenp)565 install_variable_buffer (char **bufp, unsigned int *lenp)
566 {
567   *bufp = variable_buffer;
568   *lenp = variable_buffer_length;
569 
570   variable_buffer = 0;
571   initialize_variable_output ();
572 }
573 
574 /* Restore a previously-saved variable_buffer setting (free the current one).
575  */
576 
577 void
restore_variable_buffer(char * buf,unsigned int len)578 restore_variable_buffer (char *buf, unsigned int len)
579 {
580   free (variable_buffer);
581 
582   variable_buffer = buf;
583   variable_buffer_length = len;
584 }
585