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