| /* 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> | |
| 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)), | |
| 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; | |
| } |