summaryrefslogtreecommitdiff
path: root/function.c
diff options
context:
space:
mode:
Diffstat (limited to 'function.c')
-rw-r--r--function.c1193
1 files changed, 1193 insertions, 0 deletions
diff --git a/function.c b/function.c
new file mode 100644
index 0000000..1bc66e6
--- /dev/null
+++ b/function.c
@@ -0,0 +1,1193 @@
+/* Variable function expansion for GNU Make.
+Copyright (C) 1988, 1989, 1991 Free Software Foundation, Inc.
+This file is part of GNU Make.
+
+GNU Make is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Make is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Make; see the file COPYING. If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+#include "make.h"
+#include "variable.h"
+#include "dep.h"
+#include "commands.h"
+#include "job.h"
+#include <errno.h>
+
+extern int errno;
+
+static char *string_glob ();
+
+/* Store into VARIABLE_BUFFER at O the result of scanning TEXT and replacing
+ each occurrence of SUBST with REPLACE. TEXT is null-terminated. SLEN is
+ the length of SUBST and RLEN is the length of REPLACE. If BY_WORD is
+ nonzero, substitutions are done only on matches which are complete
+ whitespace-delimited words. If SUFFIX_ONLY is nonzero, substitutions are
+ done only at the ends of whitespace-delimited words. */
+
+char *
+subst_expand (o, text, subst, replace, slen, rlen, by_word, suffix_only)
+ char *o;
+ char *text;
+ char *subst, *replace;
+ unsigned int slen, rlen;
+ int by_word, suffix_only;
+{
+ register char *t = text;
+ register char *p;
+
+ if (slen == 0 && !by_word && !suffix_only)
+ {
+ /* The first occurrence of "" in any string is its end. */
+ o = variable_buffer_output (o, t, strlen (t));
+ if (rlen > 0)
+ o = variable_buffer_output (o, replace, rlen);
+ return o;
+ }
+
+ while ((p = sindex (t, 0, subst, slen)) != 0)
+ {
+ /* Output everything before this occurrence of the string to replace. */
+ if (p > t)
+ o = variable_buffer_output (o, t, p - t);
+
+ /* If we're substituting only by fully matched words,
+ or only at the ends of words, check that this case qualifies. */
+ if ((by_word
+ && ((p > t && !isblank (p[-1]))
+ || (p[slen] != '\0' && !isblank (p[slen]))))
+ || (suffix_only
+ && (p[slen] != '\0' && !isblank (p[slen]))))
+ /* Struck out. Output the rest of the string that is
+ no longer to be replaced. */
+ o = variable_buffer_output (o, subst, slen);
+ else if (rlen > 0)
+ /* Output the replacement string. */
+ o = variable_buffer_output (o, replace, rlen);
+
+ /* Advance T past the string to be replaced. */
+ t = p + slen;
+ }
+
+ /* Output everything left on the end. */
+ if (*t != '\0')
+ o = variable_buffer_output (o, t, strlen (t));
+
+ return o;
+}
+
+
+/* Store into VARIABLE_BUFFER at O the result of scanning TEXT
+ and replacing strings matching PATTERN with REPLACE.
+ If PATTERN_PERCENT is not nil, PATTERN has already been
+ run through find_percent, and PATTERN_PERCENT is the result.
+ If REPLACE_PERCENT is not nil, REPLACE has already been
+ run through find_percent, and REPLACE_PERCENT is the result. */
+
+char *
+patsubst_expand (o, text, pattern, replace, pattern_percent, replace_percent)
+ char *o;
+ char *text;
+ register char *pattern, *replace;
+ register char *pattern_percent, *replace_percent;
+{
+ register int pattern_prepercent_len, pattern_postpercent_len;
+ register int replace_prepercent_len, replace_postpercent_len;
+ register char *t;
+ unsigned int len;
+ int doneany = 0;
+
+ /* We call find_percent on REPLACE before checking PATTERN so that REPLACE
+ will be collapsed before we call subst_expand if PATTERN has no %. */
+ if (replace_percent == 0)
+ replace_percent = find_percent (replace);
+ if (replace_percent != 0)
+ {
+ /* Record the length of REPLACE before and after the % so
+ we don't have to compute these lengths more than once. */
+ replace_prepercent_len = replace_percent - replace;
+ replace_postpercent_len = strlen (replace_percent + 1);
+ }
+ else
+ /* We store the length of the replacement
+ so we only need to compute it once. */
+ replace_prepercent_len = strlen (replace);
+
+ if (pattern_percent == 0)
+ pattern_percent = find_percent (pattern);
+ if (pattern_percent == 0)
+ /* With no % in the pattern, this is just a simple substitution. */
+ return subst_expand (o, text, pattern, replace,
+ strlen (pattern), strlen (replace), 1, 0);
+
+ /* Record the length of PATTERN before and after the %
+ so we don't have to compute it more than once. */
+ pattern_prepercent_len = pattern_percent - pattern;
+ pattern_postpercent_len = strlen (pattern_percent + 1);
+
+ while (t = find_next_token (&text, &len))
+ {
+ int fail = 0;
+
+ /* Is it big enough to match? */
+ if (len < pattern_prepercent_len + pattern_postpercent_len)
+ fail = 1;
+
+ /* Does the prefix match? */
+ if (!fail && pattern_prepercent_len > 0
+ && (*t != *pattern
+ || t[pattern_prepercent_len - 1] != pattern_percent[-1]
+ || strncmp (t + 1, pattern + 1, pattern_prepercent_len - 1)))
+ fail = 1;
+
+ /* Does the suffix match? */
+ if (!fail && pattern_postpercent_len > 0
+ && (t[len - 1] != pattern_percent[pattern_postpercent_len]
+ || t[len - pattern_postpercent_len] != pattern_percent[1]
+ || strncmp (&t[len - pattern_postpercent_len],
+ &pattern_percent[1], pattern_postpercent_len - 1)))
+ fail = 1;
+
+ if (fail)
+ /* It didn't match. Output the string. */
+ o = variable_buffer_output (o, t, len);
+ else
+ {
+ /* It matched. Output the replacement. */
+
+ /* Output the part of the replacement before the %. */
+ o = variable_buffer_output (o, replace, replace_prepercent_len);
+
+ if (replace_percent != 0)
+ {
+ /* Output the part of the matched string that
+ matched the % in the pattern. */
+ o = variable_buffer_output (o, t + pattern_prepercent_len,
+ len - (pattern_prepercent_len
+ + pattern_postpercent_len));
+ /* Output the part of the replacement after the %. */
+ o = variable_buffer_output (o, replace_percent + 1,
+ replace_postpercent_len);
+ }
+ }
+
+ /* Output a space, but not if the replacement is "". */
+ if (fail || replace_prepercent_len > 0
+ || (replace_percent != 0 && len + replace_postpercent_len > 0))
+ {
+ o = variable_buffer_output (o, " ", 1);
+ doneany = 1;
+ }
+ }
+ if (doneany)
+ /* Kill the last space. */
+ --o;
+
+ return o;
+}
+
+/* Handle variable-expansion-time functions such as $(dir foo/bar) ==> foo/ */
+
+/* These enumeration constants distinguish the
+ various expansion-time built-in functions. */
+
+enum function
+ {
+ function_subst,
+ function_addsuffix,
+ function_addprefix,
+ function_dir,
+ function_notdir,
+ function_suffix,
+ function_basename,
+ function_wildcard,
+ function_firstword,
+ function_word,
+ function_words,
+ function_findstring,
+ function_strip,
+ function_join,
+ function_patsubst,
+ function_filter,
+ function_filter_out,
+ function_foreach,
+ function_sort,
+ function_origin,
+ function_shell,
+ function_invalid
+ };
+
+/* Greater than the length of any function name. */
+#define MAXFUNCTIONLEN 11
+
+/* The function names and lengths of names, for looking them up. */
+
+static struct
+ {
+ char *name;
+ unsigned int len;
+ enum function function;
+ } function_table[] =
+ {
+ { "subst", 5, function_subst },
+ { "addsuffix", 9, function_addsuffix },
+ { "addprefix", 9, function_addprefix },
+ { "dir", 3, function_dir },
+ { "notdir", 6, function_notdir },
+ { "suffix", 6, function_suffix },
+ { "basename", 8, function_basename },
+ { "wildcard", 8, function_wildcard },
+ { "firstword", 9, function_firstword },
+ { "word", 4, function_word },
+ { "words", 5, function_words },
+ { "findstring", 10, function_findstring },
+ { "strip", 5, function_strip },
+ { "join", 4, function_join },
+ { "patsubst", 8, function_patsubst },
+ { "filter", 6, function_filter },
+ { "filter-out", 10, function_filter_out },
+ { "foreach", 7, function_foreach },
+ { "sort", 4, function_sort },
+ { "origin", 6, function_origin },
+ { "shell", 5, function_shell },
+ { 0, 0, function_invalid }
+ };
+
+/* Return 1 if PATTERN matches WORD, 0 if not. */
+
+int
+pattern_matches (pattern, percent, word)
+ register char *pattern, *percent, *word;
+{
+ unsigned int len;
+
+ if (percent == 0)
+ {
+ unsigned int len = strlen (pattern) + 1;
+ char *new = (char *) alloca (len);
+ bcopy (pattern, new, len);
+ pattern = new;
+ percent = find_percent (pattern);
+ if (percent == 0)
+ return streq (pattern, word);
+ }
+
+ len = strlen (percent + 1);
+
+ if (strlen (word) < (percent - pattern) + len
+ || strncmp (pattern, word, percent - pattern))
+ return 0;
+
+ return !strcmp (percent + 1, word + (strlen (word) - len));
+}
+
+int shell_function_pid = 0, shell_function_completed;
+
+/* Perform the function specified by FUNCTION on the text at TEXT.
+ END is points to the end of the argument text (exclusive).
+ The output is written into VARIABLE_BUFFER starting at O. */
+
+/* Note this absorbs a semicolon and is safe to use in conditionals. */
+#define BADARGS(func) \
+ if (reading_filename != 0) \
+ makefile_fatal (reading_filename, *reading_lineno_ptr, \
+ "insufficient arguments to function `%s'", \
+ func); \
+ else \
+ fatal ("insufficient arguments to function `%s'", func)
+
+static char *
+expand_function (o, function, text, end)
+ char *o;
+ enum function function;
+ char *text;
+ char *end;
+{
+ char *p, *p2, *p3;
+ unsigned int i, len;
+ int doneany = 0;
+ int count;
+ char endparen = *end, startparen = *end == ')' ? '(' : '{';
+
+ switch (function)
+ {
+ default:
+ abort ();
+ break;
+
+ case function_shell:
+ {
+ extern int fork ();
+ extern int pipe ();
+ char **argv;
+ char *error_prefix;
+ int pipedes[2];
+ int pid;
+
+ /* Expand the command line. */
+ text = expand_argument (text, end);
+
+ /* Construct the argument list. */
+ argv = construct_command_argv (text, (char *) NULL, (struct file *) 0);
+ if (argv == 0)
+ break;
+
+ /* For error messages. */
+ if (reading_filename != 0)
+ {
+ error_prefix = (char *) alloca (strlen (reading_filename) + 100);
+ sprintf (error_prefix,
+ "%s:%u: ", reading_filename, *reading_lineno_ptr);
+ }
+ else
+ error_prefix = "";
+
+ if (pipe (pipedes) < 0)
+ {
+ perror_with_name (error_prefix, "pipe");
+ break;
+ }
+
+ push_signals_blocked_p (1);
+
+ pid = fork ();
+ if (pid < 0)
+ perror_with_name (error_prefix, "fork");
+ else if (pid == 0)
+ child_execute_job (0, pipedes[1], argv, environ);
+ else
+ {
+ /* We are the parent. Set up and read from the pipe. */
+ char *buffer = (char *) xmalloc (201);
+ unsigned int maxlen = 200;
+ int cc;
+
+ /* Record the PID for child_handler. */
+ shell_function_pid = pid;
+ shell_function_completed = 0;
+
+ /* Close the write side of the pipe. */
+ (void) close (pipedes[1]);
+
+ /* Read from the pipe until it gets EOF. */
+ i = 0;
+ do
+ {
+ if (i == maxlen)
+ {
+ maxlen += 512;
+ buffer = (char *) xrealloc (buffer, maxlen + 1);
+ }
+
+ errno = 0;
+ cc = read (pipedes[0], &buffer[i], maxlen - i);
+ if (cc > 0)
+ i += cc;
+ }
+#ifdef EINTR
+ while (cc > 0 || errno == EINTR);
+#else
+ while (cc > 0);
+#endif
+
+ /* Close the read side of the pipe. */
+ (void) close (pipedes[0]);
+
+ /* Loop until child_handler sets shell_function_completed
+ to the status of our child shell. */
+ while (shell_function_completed == 0)
+ wait_for_children (1, 0);
+
+ shell_function_pid = 0;
+
+ /* The child_handler function will set shell_function_completed
+ to 1 when the child dies normally, or to -1 if it
+ dies with status 127, which is most likely an exec fail. */
+
+ if (shell_function_completed == -1)
+ {
+ /* This most likely means that the execvp failed,
+ so we should just write out the error message
+ that came in over the pipe from the child. */
+ fputs (buffer, stderr);
+ fflush (stderr);
+ }
+ else
+ {
+ /* The child finished normally. Replace all
+ newlines in its output with spaces, and put
+ that in the variable output buffer. */
+ if (i > 0)
+ {
+ if (buffer[i - 1] == '\n')
+ buffer[--i] = '\0';
+ p = buffer;
+ while ((p = index (p, '\n')) != 0)
+ *p++ = ' ';
+ o = variable_buffer_output (o, buffer, i);
+ }
+ }
+
+ free (argv[0]);
+ free ((char *) argv);
+ free (buffer);
+ }
+
+ pop_signals_blocked_p ();
+
+ free (text);
+ break;
+ }
+
+ case function_origin:
+ /* Expand the argument. */
+ text = expand_argument (text, end);
+
+ {
+ register struct variable *v = lookup_variable (text, strlen (text));
+ if (v == 0)
+ o = variable_buffer_output (o, "undefined", 9);
+ else
+ switch (v->origin)
+ {
+ default:
+ case o_invalid:
+ abort ();
+ break;
+ case o_default:
+ o = variable_buffer_output (o, "default", 7);
+ break;
+ case o_env:
+ o = variable_buffer_output (o, "environment", 11);
+ break;
+ case o_file:
+ o = variable_buffer_output (o, "file", 4);
+ break;
+ case o_env_override:
+ o = variable_buffer_output (o, "environment override", 20);
+ break;
+ case o_command:
+ o = variable_buffer_output (o, "command line", 12);
+ break;
+ case o_override:
+ o = variable_buffer_output (o, "override", 8);
+ break;
+ case o_automatic:
+ o = variable_buffer_output (o, "automatic", 9);
+ break;
+ }
+ }
+
+ free (text);
+ break;
+
+ case function_sort:
+ /* Expand the argument. */
+ text = expand_argument (text, end);
+
+ {
+ char **words = (char **) xmalloc (10 * sizeof (char *));
+ unsigned int nwords = 10;
+ register unsigned int wordi = 0;
+ char *t;
+
+ /* Chop TEXT into words and put them in WORDS. */
+ t = text;
+ while (p = find_next_token (&t, &len))
+ {
+ if (wordi >= nwords - 1)
+ {
+ nwords += 5;
+ words = (char **) xrealloc ((char *) words,
+ nwords * sizeof (char *));
+ }
+ words[wordi++] = savestring (p, len);
+ }
+
+ if (wordi > 0)
+ {
+ /* Now sort the list of words. */
+ qsort ((char *) words, wordi, sizeof (char *), alpha_compare);
+
+ /* Now write the sorted list. */
+ for (i = 0; i < wordi; ++i)
+ {
+ len = strlen (words[i]);
+ if (i == wordi - 1 || strlen (words[i + 1]) != len
+ || strcmp (words[i], words[i + 1]))
+ {
+ o = variable_buffer_output (o, words[i], len);
+ o = variable_buffer_output (o, " ", 1);
+ }
+ free (words[i]);
+ }
+ /* Kill the last space. */
+ --o;
+ }
+
+ free ((char *) words);
+ }
+
+ free (text);
+ break;
+
+ case function_foreach:
+ {
+ /* Get three comma-separated arguments but
+ expand only the first two. */
+ char *var, *list;
+ register struct variable *v;
+
+ count = 0;
+ for (p = text; p < end; ++p)
+ {
+ if (*p == startparen)
+ ++count;
+ else if (*p == endparen)
+ --count;
+ else if (*p == ',' && count <= 0)
+ break;
+ }
+ if (p == end)
+ BADARGS ("foreach");
+ var = expand_argument (text, p);
+
+ p2 = p + 1;
+ count = 0;
+ for (p = p2; p < end; ++p)
+ {
+ if (*p == startparen)
+ ++count;
+ else if (*p == endparen)
+ --count;
+ else if (*p == ',' && count <= 0)
+ break;
+ }
+ if (p == end)
+ BADARGS ("foreach");
+ list = expand_argument (p2, p);
+
+ ++p;
+ text = savestring (p, end - p);
+
+ push_new_variable_scope ();
+ v = define_variable (var, strlen (var), "", o_automatic, 0);
+ p3 = list;
+ while ((p = find_next_token (&p3, &len)) != 0)
+ {
+ char *result;
+ char save = p[len];
+ p[len] = '\0';
+ v->value = p;
+ result = allocated_variable_expand (text);
+ p[len] = save;
+
+ o = variable_buffer_output (o, result, strlen (result));
+ o = variable_buffer_output (o, " ", 1);
+ doneany = 1;
+ free (result);
+ }
+ if (doneany)
+ /* Kill the last space. */
+ --o;
+
+ pop_variable_scope ();
+
+ free (var);
+ free (list);
+ free (text);
+ }
+ break;
+
+ case function_filter:
+ case function_filter_out:
+ {
+ struct word
+ {
+ struct word *next;
+ char *word;
+ int matched;
+ } *words, *wordtail, *wp;
+
+ /* Get two comma-separated arguments and expand each one. */
+ count = 0;
+ for (p = text; p < end; ++p)
+ {
+ if (*p == startparen)
+ ++count;
+ else if (*p == endparen)
+ --count;
+ else if (*p == ',' && count <= 0)
+ break;
+ }
+ if (p == end)
+ BADARGS (function == function_filter ? "filter" : "filter-out");
+ p2 = expand_argument (text, p);
+
+ text = expand_argument (p + 1, end);
+
+ /* Chop TEXT up into words and then run each pattern through. */
+ words = wordtail = 0;
+ p3 = text;
+ while ((p = find_next_token (&p3, &len)) != 0)
+ {
+ struct word *w = (struct word *) alloca (sizeof (struct word));
+ if (words == 0)
+ words = w;
+ else
+ wordtail->next = w;
+ wordtail = w;
+
+ if (*p3 != '\0')
+ ++p3;
+ p[len] = '\0';
+ w->word = p;
+ w->matched = 0;
+ }
+
+ if (words != 0)
+ {
+ wordtail->next = 0;
+
+ /* Run each pattern through the words, killing words. */
+ p3 = p2;
+ while ((p = find_next_token (&p3, &len)) != 0)
+ {
+ char *percent;
+ char save = p[len];
+ p[len] = '\0';
+
+ percent = find_percent (p);
+ for (wp = words; wp != 0; wp = wp->next)
+ wp->matched |= (percent == 0 ? streq (p, wp->word)
+ : pattern_matches (p, percent, wp->word));
+
+ p[len] = save;
+ }
+
+ /* Output the words that matched (or didn't, for filter-out). */
+ for (wp = words; wp != 0; wp = wp->next)
+ if (function == function_filter ? wp->matched : !wp->matched)
+ {
+ o = variable_buffer_output (o, wp->word, strlen (wp->word));
+ o = variable_buffer_output (o, " ", 1);
+ doneany = 1;
+ }
+ if (doneany)
+ /* Kill the last space. */
+ --o;
+ }
+
+ free (p2);
+ free (text);
+ }
+ break;
+
+ case function_patsubst:
+ /* Get three comma-separated arguments and expand each one. */
+ count = 0;
+ for (p = text; p < end; ++p)
+ {
+ if (*p == startparen)
+ ++count;
+ else if (*p == endparen)
+ --count;
+ else if (*p == ',' && count <= 0)
+ break;
+ }
+ if (p == end)
+ BADARGS ("patsubst");
+
+ p2 = p;
+ count = 0;
+ for (++p; p < end; ++p)
+ {
+ if (*p == startparen)
+ ++count;
+ else if (*p == endparen)
+ --count;
+ else if (*p == ',' && count <= 0)
+ break;
+ }
+ if (p == end)
+ BADARGS ("patsubst");
+
+ text = expand_argument (text, p2);
+ p3 = expand_argument (p2 + 1, p);
+ p2 = expand_argument (p + 1, end);
+
+ o = patsubst_expand (o, p2, text, p3, (char *) 0, (char *) 0);
+
+ free (text);
+ free (p3);
+ free (p2);
+ break;
+
+ case function_join:
+ /* Get two comma-separated arguments and expand each one. */
+ count = 0;
+ for (p = text; p < end; ++p)
+ {
+ if (*p == startparen)
+ ++count;
+ else if (*p == endparen)
+ --count;
+ else if (*p == ',' && count <= 0)
+ break;
+ }
+ if (p == end)
+ BADARGS ("join");
+ text = expand_argument (text, p);
+
+ p = expand_argument (p + 1, end);
+
+ {
+ /* Write each word of the first argument directly followed
+ by the corresponding word of the second argument.
+ If the two arguments have a different number of words,
+ the excess words are just output separated by blanks. */
+ register char *tp, *pp;
+ p2 = text;
+ p3 = p;
+ do
+ {
+ unsigned int tlen, plen;
+
+ tp = find_next_token (&p2, &tlen);
+ if (tp != 0)
+ o = variable_buffer_output (o, tp, tlen);
+
+ pp = find_next_token (&p3, &plen);
+ if (pp != 0)
+ o = variable_buffer_output (o, pp, plen);
+
+ if (tp != 0 || pp != 0)
+ {
+ o = variable_buffer_output (o, " ", 1);
+ doneany = 1;
+ }
+ }
+ while (tp != 0 || pp != 0);
+ if (doneany)
+ /* Kill the last blank. */
+ --o;
+ }
+
+ free (text);
+ free (p);
+ break;
+
+ case function_strip:
+ /* Expand the argument. */
+ text = expand_argument (text, end);
+
+ p2 = text;
+ while ((p = find_next_token (&p2, &i)) != 0)
+ {
+ o = variable_buffer_output (o, p, i);
+ o = variable_buffer_output (o, " ", 1);
+ doneany = 1;
+ }
+ if (doneany)
+ /* Kill the last space. */
+ --o;
+
+ free (text);
+ break;
+
+ case function_wildcard:
+ text = expand_argument (text, end);
+
+ p = string_glob (text);
+ o = variable_buffer_output (o, p, strlen (p));
+
+ free (text);
+ break;
+
+ case function_subst:
+ /* Get three comma-separated arguments and expand each one. */
+ count = 0;
+ for (p = text; p < end; ++p)
+ {
+ if (*p == startparen)
+ ++count;
+ else if (*p == endparen)
+ --count;
+ else if (*p == ',' && count <= 0)
+ break;
+ }
+ if (p == end)
+ BADARGS ("subst");
+
+ p2 = p;
+ count = 0;
+ for (++p; p < end; ++p)
+ {
+ if (*p == startparen)
+ ++count;
+ else if (*p == endparen)
+ --count;
+ else if (*p == ',' && count <= 0)
+ break;
+ }
+ if (p == end)
+ BADARGS ("subst");
+
+ text = expand_argument (text, p2);
+ p3 = expand_argument (p2 + 1, p);
+ p2 = expand_argument (p + 1, end);
+
+ o = subst_expand (o, p2, text, p3, strlen (text), strlen (p3), 0, 0);
+
+ free (text);
+ free (p3);
+ free (p2);
+ break;
+
+ case function_firstword:
+ /* Expand the argument. */
+ text = expand_argument (text, end);
+
+ /* Find the first word in TEXT. */
+ p2 = text;
+ p = find_next_token (&p2, &i);
+ if (p != 0)
+ o = variable_buffer_output (o, p, i);
+
+ free (text);
+ break;
+
+ case function_word:
+ /* Get two comma-separated arguments and expand each one. */
+ count = 0;
+ for (p = text; p < end; ++p)
+ {
+ if (*p == startparen)
+ ++count;
+ else if (*p == endparen)
+ --count;
+ else if (*p == ',' && count <= 0)
+ break;
+ }
+ if (p == end)
+ BADARGS ("word");
+ text = expand_argument (text, p);
+
+ p3 = expand_argument (p + 1, end);
+
+ /* Check the first argument. */
+ for (p2 = text; *p2 != '\0'; ++p2)
+ if (*p2 < '0' || *p2 > '9')
+ {
+ if (reading_filename != 0)
+ makefile_fatal (reading_filename, *reading_lineno_ptr,
+ "non-numeric first argument to `word' function");
+ else
+ fatal ("non-numeric first argument to `word' function");
+ }
+
+ i = (unsigned int) atoi (text);
+ if (i == 0)
+ {
+ if (reading_filename != 0)
+ makefile_fatal (reading_filename, *reading_lineno_ptr,
+ "the `word' function takes a one-origin \
+index argument");
+ else
+ fatal ("the `word' function takes a one-origin index argument");
+ }
+
+ p2 = p3;
+ while ((p = find_next_token (&p2, &len)) != 0)
+ if (--i == 0)
+ break;
+ if (i == 0)
+ o = variable_buffer_output (o, p, len);
+
+ free (text);
+ free (p3);
+ break;
+
+ case function_words:
+ /* Expand the argument. */
+ text = expand_argument (text, end);
+
+ i = 0;
+ p2 = text;
+ while (find_next_token (&p2, (unsigned int *) 0) != 0)
+ ++i;
+
+ {
+ char buf[20];
+ sprintf (buf, "%d", i);
+ o = variable_buffer_output (o, buf, strlen (buf));
+ }
+
+ free (text);
+ break;
+
+ case function_findstring:
+ /* Get two comma-separated arguments and expand each one. */
+ count = 0;
+ for (p = text; p < end; ++p)
+ {
+ if (*p == startparen)
+ ++count;
+ else if (*p == endparen)
+ --count;
+ else if (*p == ',' && count <= 0)
+ break;
+ }
+ if (p == end)
+ BADARGS ("findstring");
+ text = expand_argument (text, p);
+
+ p = expand_argument (p + 1, end);
+
+ /* Find the first occurrence of the first string in the second. */
+ i = strlen (text);
+ if (sindex (p, 0, text, i) != 0)
+ o = variable_buffer_output (o, text, i);
+
+ free (p);
+ free (text);
+ break;
+
+ case function_addsuffix:
+ case function_addprefix:
+ /* Get two comma-separated arguments and expand each one. */
+ count = 0;
+ for (p = text; p < end; ++p)
+ {
+ if (*p == startparen)
+ ++count;
+ else if (*p == endparen)
+ --count;
+ else if (*p == ',' && count <= 0)
+ break;
+ }
+ if (p == end)
+ BADARGS (function == function_addsuffix ? "addsuffix" : "addprefix");
+ text = expand_argument (text, p);
+ i = strlen (text);
+
+ p2 = expand_argument (p + 1, end);
+
+ p3 = p2;
+ while ((p = find_next_token (&p3, &len)) != 0)
+ {
+ if (function == function_addprefix)
+ o = variable_buffer_output (o, text, i);
+ o = variable_buffer_output (o, p, len);
+ if (function == function_addsuffix)
+ o = variable_buffer_output (o, text, i);
+ o = variable_buffer_output (o, " ", 1);
+ doneany = 1;
+ }
+ if (doneany)
+ /* Kill last space. */
+ --o;
+
+ free (p2);
+ free (text);
+ break;
+
+ case function_dir:
+ case function_basename:
+ /* Expand the argument. */
+ text = expand_argument (text, end);
+
+ p3 = text;
+ while ((p2 = find_next_token (&p3, &len)) != 0)
+ {
+ p = p2 + len;
+ while (p >= p2 && *p != (function == function_dir ? '/' : '.'))
+ --p;
+ if (p >= p2)
+ {
+ if (function == function_dir)
+ ++p;
+ o = variable_buffer_output (o, p2, p - p2);
+ }
+ else if (function == function_dir)
+ o = variable_buffer_output (o, "./", 2);
+ else
+ /* The entire name is the basename. */
+ o = variable_buffer_output (o, p2, len);
+
+ o = variable_buffer_output (o, " ", 1);
+ doneany = 1;
+ }
+ if (doneany)
+ /* Kill last space. */
+ --o;
+
+ free (text);
+ break;
+
+ case function_notdir:
+ case function_suffix:
+ /* Expand the argument. */
+ text = expand_argument (text, end);
+
+ p3 = text;
+ while ((p2 = find_next_token (&p3, &len)) != 0)
+ {
+ p = p2 + len;
+ while (p >= p2 && *p != (function == function_notdir ? '/' : '.'))
+ --p;
+ if (p >= p2)
+ {
+ if (function == function_notdir)
+ ++p;
+ o = variable_buffer_output (o, p, len - (p - p2));
+ }
+ else if (function == function_notdir)
+ o = variable_buffer_output (o, p2, len);
+
+ if (function == function_notdir || p >= p2)
+ {
+ o = variable_buffer_output (o, " ", 1);
+ doneany = 1;
+ }
+ }
+ if (doneany)
+ /* Kill last space. */
+ --o;
+
+ free (text);
+ break;
+ }
+
+ return o;
+}
+
+/* Check for a function invocation in *STRINGP. *STRINGP points at the
+ opening ( or { and is not null-terminated. If a function invocation
+ is found, expand it into the buffer at *OP, updating *OP, incrementing
+ *STRINGP past the reference and returning nonzero. If not, return zero. */
+
+int
+handle_function (op, stringp)
+ char **op;
+ char **stringp;
+
+{
+ register unsigned int code;
+ unsigned int maxlen;
+ char *beg = *stringp + 1;
+ char *endref;
+
+ endref = lindex (beg, beg + MAXFUNCTIONLEN, '\0');
+ maxlen = endref != 0 ? endref - beg : MAXFUNCTIONLEN;
+
+ for (code = 0; function_table[code].name != 0; ++code)
+ {
+ if (maxlen < function_table[code].len)
+ continue;
+ endref = beg + function_table[code].len;
+ if (isblank (*endref)
+ && !strncmp (function_table[code].name, beg,
+ function_table[code].len))
+ break;
+ }
+ if (function_table[code].name != 0)
+ {
+ /* We have found a call to an expansion-time function.
+ Find the end of the arguments, and do the function. */
+
+ char openparen = beg[-1], closeparen = openparen == '(' ? ')' : '}';
+ int count = 0;
+ char *argbeg;
+ register char *p;
+
+ /* Space after function name isn't part of the args. */
+ p = next_token (endref);
+ argbeg = p;
+
+ /* Count nested use of whichever kind of parens we use,
+ so that nested calls and variable refs work. */
+
+ for (; *p != '\0'; ++p)
+ {
+ if (*p == openparen)
+ ++count;
+ else if (*p == closeparen && --count < 0)
+ break;
+ }
+
+ /* We found the end; expand the function call. */
+
+ *op = expand_function (*op, function_table[code].function, argbeg, p);
+ *stringp = p;
+ return 1;
+ }
+
+ return 0;
+}
+
+/* Glob-expand LINE. The returned pointer is
+ only good until the next call to string_glob. */
+
+static char *
+string_glob (line)
+ char *line;
+{
+ static char *result = 0;
+ static unsigned int length;
+ register struct nameseq *chain;
+ register unsigned int idx;
+
+ chain = multi_glob (parse_file_seq (&line, '\0', sizeof (struct nameseq), 0),
+ sizeof (struct nameseq));
+
+ if (result == 0)
+ {
+ length = 100;
+ result = (char *) xmalloc (100);
+ }
+
+ idx = 0;
+ while (chain != 0)
+ {
+ register char *name = chain->name;
+ unsigned int len = strlen (name);
+
+ struct nameseq *next = chain->next;
+ free ((char *) chain);
+ chain = next;
+
+ /* multi_glob will pass names without globbing metacharacters
+ through as is, but we want only files that actually exist. */
+ if (file_exists_p (name))
+ {
+ if (idx + len + 1 > length)
+ {
+ length += (len + 1) * 2;
+ result = (char *) xrealloc (result, length);
+ }
+ bcopy (name, &result[idx], len);
+ idx += len;
+ result[idx++] = ' ';
+ }
+
+ free (name);
+ }
+
+ /* Kill the last space and terminate the string. */
+ if (idx == 0)
+ result[0] = '\0';
+ else
+ result[idx - 1] = '\0';
+
+ return result;
+}