diff options
Diffstat (limited to 'function.c')
| -rw-r--r-- | function.c | 2668 |
1 files changed, 1483 insertions, 1185 deletions
@@ -1,4 +1,4 @@ -/* Variable function expansion for GNU Make. +/* Builtin function expansion for GNU Make. Copyright (C) 1988,89,91,92,93,94,95,96,97 Free Software Foundation, Inc. This file is part of GNU Make. @@ -27,13 +27,19 @@ Boston, MA 02111-1307, USA. */ #ifdef _AMIGA #include "amiga.h" #endif -#ifdef WINDOWS32 -#include <windows.h> -#include <io.h> -#include "sub_proc.h" -#endif -static char *string_glob PARAMS ((char *line)); + +struct function_table_entry + { + const char *name; + int len; + int required_arguments; + int expand_all_arguments; + char *(*func_ptr) PARAMS((char *output, char **argv, const char*funcname)); + }; + +static struct function_table_entry function_table[]; + /* 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 @@ -214,75 +220,29 @@ patsubst_expand (o, text, pattern, replace, pattern_percent, replace_percent) 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_wordlist, - function_findstring, - function_strip, - function_join, - function_patsubst, - function_filter, - function_filter_out, - function_foreach, - function_sort, - function_origin, - function_shell, - function_invalid - }; +/* Look up a function by name. + The table is currently small enough that it's not really worthwhile to use + a fancier lookup algorithm. If it gets larger, maybe... +*/ -/* Greater than the length of any function name. */ -#define MAXFUNCTIONLEN 11 +static const struct function_table_entry * +lookup_function (table, s) + const struct function_table_entry *table; + const char *s; +{ + int len = strlen(s); -/* The function names and lengths of names, for looking them up. */ + for (; table->name != NULL; ++table) + if (table->len <= len + && (isblank (s[table->len]) || s[table->len] == '\0') + && strneq (s, table->name, table->len)) + return table; -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 }, - { "wordlist", 8, function_wordlist }, - { "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 NULL; +} + /* Return 1 if PATTERN matches STR, 0 if not. */ int @@ -294,9 +254,9 @@ pattern_matches (pattern, percent, str) if (percent == 0) { unsigned int len = strlen (pattern) + 1; - char *new = (char *) alloca (len); - bcopy (pattern, new, len); - pattern = new; + char *new_chars = (char *) alloca (len); + bcopy (pattern, new_chars, len); + pattern = new_chars; percent = find_percent (pattern); if (percent == 0) return streq (pattern, str); @@ -312,1288 +272,1626 @@ pattern_matches (pattern, percent, str) return !strcmp (percent + 1, str + (strlength - sfxlen)); } -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. */ +/* Find the next comma or ENDPAREN (counting nested STARTPAREN and + ENDPARENtheses), starting at PTR before END. Return a pointer to + next character. + + If no next argument is found, return NULL. +*/ + +static char * +find_next_argument (startparen, endparen, ptr, end) + char startparen; + char endparen; + const char *ptr; + const char *end; +{ + int count = 0; + + for (; ptr < end; ++ptr) + if (*ptr == startparen) + ++count; -/* Note this absorbs a semicolon and is safe to use in conditionals. */ -#define BADARGS(func) do { \ - fatal (reading_file, "insufficient arguments to function `%s'", func); \ - } while (0) + else if (*ptr == endparen) + { + --count; + if (count < 0) + return NULL; + } + + else if (*ptr == ',' && !count) + return (char *)ptr; + + /* We didn't find anything. */ + return NULL; +} + static char * -expand_function (o, function, text, end) +expand_builtin_function (o, argc, argv, entry_p) char *o; - enum function function; - char *text; - char *end; + int argc; + char **argv; + struct function_table_entry *entry_p; +{ + if (argc < entry_p->required_arguments && entry_p->required_arguments >= 0) + fatal (reading_file, + "Insufficient number of arguments (%d) to function `%s'", + argc, entry_p->name); + + if (!entry_p->func_ptr) + fatal (reading_file, "Unimplemented on this platform: function `%s'", + entry_p->name); + + return entry_p->func_ptr (o, argv, entry_p->name); +} + +/* 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; +{ + const struct function_table_entry *entry_p; + char openparen = (*stringp)[0]; + char closeparen = openparen == '(' ? ')' : '}'; + char *beg = *stringp + 1; + char *endref; + int count = 0; + char *argbeg; + register char *p; + char **argv, **argvp; + int nargs; + + entry_p = lookup_function (function_table, beg); + + if (!entry_p) + return 0; + + /* We have found a call to a builtin function. Find the end of the + arguments, and do the function. */ + + endref = beg + entry_p->len; + + /* Space after function name isn't part of the args. */ + p = next_token (endref); + argbeg = p; + + /* Find the end of the function invocation, counting nested use of + whichever kind of parens we use. Since we're looking, count commas + to get a rough estimate of how many arguments we might have. The + count might be high, but it'll never be low. */ + + for (nargs=1; *p != '\0'; ++p) + if (*p == ',') + ++nargs; + else if (*p == openparen) + ++count; + else if (*p == closeparen && --count < 0) + break; + + if (count >= 0) + fatal (reading_file, + "unterminated call to function `%s': missing `%c'", + entry_p->name, closeparen); + + /* Get some memory to store the arg pointers. */ + argvp = argv = (char **) alloca (sizeof(char *) * (nargs + 2)); + + /* Chop the string into arguments, then store the end pointer and a nul. */ + *argvp = argbeg; + nargs = 1; + while (1) + { + char *next = find_next_argument (openparen, closeparen, *argvp, p); + + if (!next) + break; + + *(++argvp) = next+1; + ++nargs; + } + + *(++argvp) = p+1; + *(++argvp) = 0; + + /* If we should expand, do it. */ + if (entry_p->expand_all_arguments) + { + for (argvp=argv; argvp[1] != 0; ++argvp) + *argvp = expand_argument (*argvp, argvp[1]-1); + + /* end pointer doesn't make sense for expanded stuff. */ + *argvp = 0; + } + + /* Finally! Run the function... */ + *op = expand_builtin_function (*op, nargs, argv, entry_p); + + /* If we allocated memory for the expanded args, free it again. */ + if (entry_p->expand_all_arguments) + for (argvp=argv; *argvp != 0; ++argvp) + free (*argvp); + + *stringp = p; + + return 1; +} + + +/* 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), + /* We do not want parse_file_seq to strip `./'s. + That would break examples like: + $(patsubst ./%.c,obj/%.o,$(wildcard ./*.c)). */ + + /* Yep, and the preceding comment triggers a GCC + warning. Nothing wrong though. */ + 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; +} + +/* + Builtin functions + */ + +static char * +func_patsubst (o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + o = patsubst_expand (o, argv[2], argv[0], argv[1], (char *) 0, (char *) 0); + return o; +} + + +static char * +func_join(o, argv, funcname) + char *o; + char **argv; + const char *funcname; { - char *p, *p2, *p3; - unsigned int i, j, len; int doneany = 0; - int count; - char endparen = *end, startparen = *end == ')' ? '(' : '{'; - switch (function) + /* 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; + register char *pp; + char *list1_iterator = argv[0]; + char *list2_iterator = argv[1]; + do { - default: - abort (); - break; + unsigned int len1, len2; + + tp = find_next_token (&list1_iterator, &len1); + if (tp != 0) + o = variable_buffer_output (o, tp, len1); + + pp = find_next_token (&list2_iterator, &len2); + if (pp != 0) + o = variable_buffer_output (o, pp, len2); -#ifndef VMS /* not supported for vms yet */ - case function_shell: + 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; + + return o; +} + + +static char * +func_origin(o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + /* Expand the argument. */ + register struct variable *v = lookup_variable (argv[0], strlen (argv[0])); + if (v == 0) + o = variable_buffer_output (o, "undefined", 9); + else + switch (v->origin) { - char* batch_filename = NULL; -#ifdef WINDOWS32 - SECURITY_ATTRIBUTES saAttr; - HANDLE hIn; - HANDLE hErr; - HANDLE hChildOutRd; - HANDLE hChildOutWr; - HANDLE hProcess; -#endif + 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; + } + + return o; +} + +#ifdef VMS +#define IS_PATHSEP(c) ((c) == ']') +#else #ifdef __MSDOS__ - FILE *fpipe; +#define IS_PATHSEP(c) ((c) == '/' || (c) == '\\') +#else +#define IS_PATHSEP(c) ((c) == '/') #endif - char **argv; - char *error_prefix; -#ifndef _AMIGA - char **envp; - int pipedes[2]; - int pid; #endif - /* Expand the command line. */ - text = expand_argument (text, end); -#ifndef __MSDOS__ - /* Construct the argument list. */ - argv = construct_command_argv (text, - (char **) NULL, (struct file *) 0, &batch_filename); - if (argv == 0) - break; -#endif +static char * +func_notdir_suffix(o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + /* Expand the argument. */ + char *list_iterator = argv[0]; + char *p2 =0; + int doneany =0; + int len=0; + + int is_suffix = streq(funcname, "suffix"); + int is_notdir = !is_suffix; + while ((p2 = find_next_token (&list_iterator, &len)) != 0) + { + char *p = p2 + len; -#ifndef _AMIGA - /* Using a target environment for `shell' loses in cases like: - export var = $(shell echo foobie) - because target_environment hits a loop trying to expand $(var) - to put it in the environment. This is even more confusing when - var was not explicitly exported, but just appeared in the - calling environment. */ -#if 1 - envp = environ; -#else - /* Construct the environment. */ - envp = target_environment ((struct file *) 0); -#endif -#endif /* Not Amiga. */ - /* For error messages. */ - if (reading_file != 0) - { - error_prefix = (char *) alloca (strlen(reading_file->filenm)+100); - sprintf (error_prefix, - "%s:%lu: ", reading_file->filenm, reading_file->lineno); - } - else - error_prefix = ""; + while (p >= p2 && (!is_suffix || *p != '.')) + { + if (IS_PATHSEP (*p)) + break; + --p; + } -#ifndef _AMIGA -# ifdef WINDOWS32 - saAttr.nLength = sizeof(SECURITY_ATTRIBUTES); - saAttr.bInheritHandle = TRUE; - saAttr.lpSecurityDescriptor = NULL; - - if (DuplicateHandle(GetCurrentProcess(), - GetStdHandle(STD_INPUT_HANDLE), - GetCurrentProcess(), - &hIn, - 0, - TRUE, - DUPLICATE_SAME_ACCESS) == FALSE) { - fatal (NILF, "create_child_process: DuplicateHandle(In) failed (e=%d)\n", - GetLastError()); + if (p >= p2) + { + if (is_notdir) + ++p; + else if (*p != '.') + continue; + o = variable_buffer_output (o, p, len - (p - p2)); } - if (DuplicateHandle(GetCurrentProcess(), - GetStdHandle(STD_ERROR_HANDLE), - GetCurrentProcess(), - &hErr, - 0, - TRUE, - DUPLICATE_SAME_ACCESS) == FALSE) { - fatal (NILF, "create_child_process: DuplicateHandle(Err) failed (e=%d)\n", - GetLastError()); +#if defined(WINDOWS32) || defined(__MSDOS__) + /* Handle the case of "d:foo/bar". */ + else if (streq(funcname, "notdir") && p2[0] && p2[1] == ':') + { + p = p2 + 2; + o = variable_buffer_output (o, p, len - (p - p2)); } +#endif + else if (is_notdir) + o = variable_buffer_output (o, p2, len); - if (!CreatePipe(&hChildOutRd, &hChildOutWr, &saAttr, 0)) - fatal (NILF, "CreatePipe() failed (e=%d)\n", GetLastError()); - - hProcess = process_init_fd(hIn, hChildOutWr, hErr); + if (is_notdir || p >= p2) + { + o = variable_buffer_output (o, " ", 1); + doneany = 1; + } + } + if (doneany) + /* Kill last space. */ + --o; - if (!hProcess) - fatal (NILF, "expand_function: process_init_fd() failed\n"); - else - process_register(hProcess); - /* make sure that CreateProcess() has Path it needs */ - sync_Path_environment(); + return o; - if (!process_begin(hProcess, argv, envp, argv[0], NULL)) - pid = (int) hProcess; - else - fatal (NILF, "expand_function: unable to launch process (e=%d)\n", - process_last_err(hProcess)); +} - /* set up to read data from child */ - pipedes[0] = _open_osfhandle((long) hChildOutRd, O_RDONLY); - /* this will be closed almost right away */ - pipedes[1] = _open_osfhandle((long) hChildOutWr, O_APPEND); -# else /* WINDOWS32 */ -# ifdef __MSDOS__ +static char * +func_basename_dir(o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + /* Expand the argument. */ + char *p3 = argv[0]; + char *p2=0; + int doneany=0; + int len=0; + char *p=0; + int is_basename= streq(funcname, "basename"); + int is_dir= !is_basename; + + while ((p2 = find_next_token (&p3, &len)) != 0) { - /* MSDOS can't fork, but it has `popen'. - (Bwt, why isn't `popen' used in all the versions?) */ - struct variable *sh = lookup_variable ("SHELL", 5); - int e; - extern int dos_command_running, dos_status; - - /* Make sure not to bother processing an empty line. */ - while (isblank (*text)) - ++text; - if (*text == '\0') - break; - - if (sh) + p = p2 + len; + while (p >= p2 && (!is_basename || *p != '.')) { - char buf[PATH_MAX + 7]; - /* This makes sure $SHELL value is used by $(shell), even - though the target environment is not passed to it. */ - sprintf (buf, "SHELL=%s", sh->value); - putenv (buf); + if (IS_PATHSEP(*p)) + break; + --p; } - e = errno; - errno = 0; - dos_command_running = 1; - dos_status = 0; - fpipe = popen (text, "rt"); - dos_command_running = 0; - if (!fpipe || dos_status) - { - pipedes[0] = -1; - pid = -1; - if (dos_status) - errno = EINTR; - else if (errno == 0) - errno = ENOMEM; - shell_function_completed = -1; - } + if (p >= p2 && (is_dir)) + o = variable_buffer_output (o, p2, ++p - p2); + else if (p >= p2 && (*p == '.')) + o = variable_buffer_output (o, p2, p - p2); +#if defined(WINDOWS32) || defined(__MSDOS__) + /* Handle the "d:foobar" case */ + else if (p2[0] && p2[1] == ':' && is_dir) + o = variable_buffer_output (o, p2, 2); +#endif + else if (is_dir) +#ifdef VMS + o = variable_buffer_output (o, "[]", 2); +#else +#ifndef _AMIGA + o = variable_buffer_output (o, "./", 2); +#else + ; /* Just a nop... */ +#endif /* AMIGA */ +#endif /* !VMS */ else - { - pipedes[0] = fileno (fpipe); - pid = 42; - errno = e; - shell_function_completed = 1; - } + /* The entire name is the basename. */ + o = variable_buffer_output (o, p2, len); + + o = variable_buffer_output (o, " ", 1); + doneany = 1; } - if (pipedes[0] < 0) -# else /* ! __MSDOS__ */ - if (pipe (pipedes) < 0) -# endif /* __MSDOS__ */ - { - perror_with_name (error_prefix, "pipe"); - break; - } + if (doneany) + /* Kill last space. */ + --o; -# ifndef __MSDOS__ - pid = vfork (); - if (pid < 0) - perror_with_name (error_prefix, "fork"); - else if (pid == 0) - child_execute_job (0, pipedes[1], argv, envp); - else -# endif /* ! __MSDOS__ */ -# endif /* WINDOWS32 */ - { - /* We are the parent. */ - - char *buffer; - unsigned int maxlen; - int cc; -#if 0 - for (i = 0; envp[i] != 0; ++i) - free (envp[i]); - free ((char *) envp); -#endif - /* Record the PID for reap_children. */ - shell_function_pid = pid; -#ifndef __MSDOS__ - shell_function_completed = 0; + return o; +} - /* Free the storage only the child needed. */ - free (argv[0]); - free ((char *) argv); +static char * +func_addsuffix_addprefix(o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + int fixlen = strlen (argv[0]); + char *list_iterator = argv[1]; + int is_addprefix = streq (funcname, "addprefix"); + int is_addsuffix = !is_addprefix; - /* Close the write side of the pipe. */ - (void) close (pipedes[1]); -#endif + int doneany =0; + char *p=0; + int len =0; - /* Set up and read from the pipe. */ - - maxlen = 200; - buffer = (char *) xmalloc (maxlen + 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 + while ((p = find_next_token (&list_iterator, &len)) != 0) + { + if (is_addprefix) + o = variable_buffer_output (o, argv[0], fixlen); + o = variable_buffer_output (o, p, len); + if (is_addsuffix) + o = variable_buffer_output (o, argv[0], fixlen); + o = variable_buffer_output (o, " ", 1); + doneany = 1; + } - /* Close the read side of the pipe. */ -#ifdef __MSDOS__ - if (fpipe) - (void) pclose (fpipe); -#else - (void) close (pipedes[0]); -#endif + if (doneany) + /* Kill last space. */ + --o; - /* Loop until child_handler sets shell_function_completed - to the status of our child shell. */ - while (shell_function_completed == 0) - reap_children (1, 0); - - if (batch_filename) { - if (debug_flag) - printf("Cleaning up temporary batch file %s\n", batch_filename); - remove(batch_filename); - free(batch_filename); - } - 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') - { - if (i > 1 && buffer[i - 2] == '\r') - --i; - buffer[--i] = '\0'; - } - else - buffer[i] = '\0'; - - p = buffer; - for (p2=p; *p != '\0'; ++p) - { - if (p[0] == '\r' && p[1] == '\n') - continue; - if (*p == '\n') - *p2++ = ' '; - else - *p2++ = *p; - } - *p2 = '\0'; - o = variable_buffer_output (o, buffer, i); - } - } - - free (buffer); - } -#else /* Amiga */ - { - /* Amiga can't fork nor spawn, but I can start a program with - redirection of my choice. However, this means that we - don't have an opportunity to reopen stdout to trap it. Thus, - we save our own stdout onto a new descriptor and dup a temp - file's descriptor onto our stdout temporarily. After we - spawn the shell program, we dup our own stdout back to the - stdout descriptor. The buffer reading is the same as above, - except that we're now reading from a file. */ -#include <dos/dos.h> -#include <proto/dos.h> + return o; +} - BPTR child_stdout; - char tmp_output[FILENAME_MAX]; - unsigned int maxlen = 200; - int cc; - char * buffer, * ptr; - char ** aptr; - int len = 0; - - strcpy (tmp_output, "t:MakeshXXXXXXXX"); - mktemp (tmp_output); - child_stdout = Open (tmp_output, MODE_NEWFILE); - - for (aptr=argv; *aptr; aptr++) - { - len += strlen (*aptr) + 1; - } - - buffer = xmalloc (len + 1); - ptr = buffer; - - for (aptr=argv; *aptr; aptr++) - { - strcpy (ptr, *aptr); - ptr += strlen (ptr) + 1; - *ptr ++ = ' '; - *ptr = 0; - } - - ptr[-1] = '\n'; - - Execute (buffer, NULL, child_stdout); - free (buffer); - - Close (child_stdout); - - child_stdout = Open (tmp_output, MODE_OLDFILE); - - buffer = xmalloc (maxlen); - i = 0; - do - { - if (i == maxlen) - { - maxlen += 512; - buffer = (char *) xrealloc (buffer, maxlen + 1); - } - - cc = Read (child_stdout, &buffer[i], maxlen - i); - if (cc > 0) - i += cc; - } while (cc > 0); - - Close (child_stdout); - DeleteFile (tmp_output); - - if (i > 0) - { - if (buffer[i - 1] == '\n') - buffer[--i] = '\0'; - else - buffer[i] = '\0'; - p = buffer; - while ((p = index (p, '\n')) != 0) - *p++ = ' '; - o = variable_buffer_output (o, buffer, i); - } - free (buffer); - } -#endif /* Not Amiga. */ - - free (text); - break; - } -#endif /* !VMS */ +static char * +func_subst(o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + o = subst_expand (o, argv[2], argv[0], argv[1], strlen (argv[0]), + strlen (argv[1]), 0, 0); - case function_origin: - /* Expand the argument. */ - text = expand_argument (text, end); + return o; +} - { - 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; +static char * +func_firstword(o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + int i=0; + char *words = argv[0]; + char *p = find_next_token (&words, &i); - case function_sort: - /* Expand the argument. */ - text = expand_argument (text, end); + if (p != 0) + o = variable_buffer_output (o, p, i); - { - 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)) != 0) - { - if (wordi >= nwords - 1) - { - nwords *= 2; - words = (char **) xrealloc ((char *) words, - nwords * sizeof (char *)); - } - words[wordi++] = savestring (p, len); - } + return o; +} - 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); - } +static char * +func_words(o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + int i = 0; + char *word_iterator = argv[0]; + char buf[20]; - free (text); - break; + while (find_next_token (&word_iterator, (unsigned int *) 0) != 0) + ++i; - case function_foreach: - { - /* Get three comma-separated arguments but - expand only the first two. */ - char *var, *list; - register struct variable *v; + sprintf (buf, "%d", i); + o = variable_buffer_output (o, buf, strlen (buf)); - 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); + return o; +} - ++p; - text = savestring (p, end - p); - - push_new_variable_scope (); - v = define_variable (var, strlen (var), "", o_automatic, 0); - free (v->value); - v->value = 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; +char * +strip_whitespace (begpp, endpp) + char **begpp; + char **endpp; +{ + while (isspace (**begpp) && *begpp <= *endpp) + (*begpp) ++; + while (isspace (**endpp) && *endpp >= *begpp) + (*endpp) --; + return *begpp; +} - v->value = 0; - pop_variable_scope (); +int +is_numeric (p) + char *p; +{ + char *end = p + strlen (p) -1; + char *beg = p; + strip_whitespace (&p, &end); + while (p <= end) + { + if (!isdigit (*p)) + return 0; - free (var); - free (list); - free (text); - } - break; + p++; + } - case function_filter: - case function_filter_out: - { - struct a_word - { - struct a_word *next; - char *str; - 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); + return (end - beg >= 0); +} - text = expand_argument (p + 1, end); +void +check_numeric (s, message) + char *s; + char *message; +{ + if (!is_numeric (s)) + fatal (reading_file, message); +} - /* 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 a_word *w = (struct a_word *)alloca(sizeof(struct a_word)); - if (words == 0) - words = w; - else - wordtail->next = w; - wordtail = w; - - if (*p3 != '\0') - ++p3; - p[len] = '\0'; - w->str = 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->str) - : pattern_matches (p, percent, wp->str)); - - 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->str, strlen (wp->str)); - o = variable_buffer_output (o, " ", 1); - doneany = 1; - } - if (doneany) - /* Kill the last space. */ - --o; - } - free (p2); - free (text); - } +static char * +func_word(o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + char *end_p=0; + int i=0; + char *p=0; + + /* Check the first argument. */ + check_numeric (argv[0], "non-numeric first argument to `word' function"); + i = atoi (argv[0]); + + if (i == 0) + fatal (reading_file, "the `word' function takes a positive index argument"); + + + end_p = argv[1]; + while ((p = find_next_token (&end_p, 0)) != 0) + if (--i == 0) 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"); + if (i == 0) + o = variable_buffer_output (o, p, end_p - p); - 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"); + return o; +} - text = expand_argument (text, p2); - p3 = expand_argument (p2 + 1, p); - p2 = expand_argument (p + 1, end); +static char * +func_wordlist (o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + int i=0; + int j=0; - o = patsubst_expand (o, p2, text, p3, (char *) 0, (char *) 0); + /* Check the first argument. */ + check_numeric (argv[0], + "non-numeric first argument to `wordlist' function"); + i =atoi(argv[0]); + check_numeric (argv[1], + "non-numeric second argument to `wordlist' function"); - free (text); - free (p3); - free (p2); - break; + j = atoi(argv[1]); - 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); + { + char *p; + char *end_p = argv[2]; + + int start = (i < j) ? i : j; + int count = j -i ; + if (count < 0) + count = - count; + count ++; + + + while (((p = find_next_token (&end_p, 0)) != 0) && --start) + {} + if (p) { - /* 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; + while (--count && (find_next_token (&end_p, 0) != 0)) + {} + o = variable_buffer_output (o, p, end_p - p); + } + } + return o; +} - tp = find_next_token (&p2, &tlen); - if (tp != 0) - o = variable_buffer_output (o, tp, tlen); +static char* +func_findstring(o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + /* Find the first occurrence of the first string in the second. */ + int i = strlen (argv[0]); + if (sindex (argv[1], 0, argv[0], i) != 0) + o = variable_buffer_output (o, argv[0], i); - pp = find_next_token (&p3, &plen); - if (pp != 0) - o = variable_buffer_output (o, pp, plen); + return o; +} - 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; +static char * +func_foreach (o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + /* expand only the first two. */ + char *varname = expand_argument (argv[0], argv[1] -1); + char *list = expand_argument (argv[1], argv[2] -1); + char *body = savestring (argv[2], argv[3] - argv[2] -1 ); + + int len =0; + char *list_iterator = list; + char *p; + register struct variable *var=0; + int doneany =0; + + push_new_variable_scope (); + var = define_variable (varname, strlen (varname), "", o_automatic, 0); + + /* loop through LIST, put the value in VAR and expand BODY */ + while ((p = find_next_token (&list_iterator, &len)) != 0) + { + char *result = 0; + + { + char save = p[len]; + + p[len] = '\0'; + free (var->value); + var->value = (char *) xstrdup ((char*) p); + p[len] = save; } - free (text); - free (p); - break; + result = allocated_variable_expand (body); + + 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 (varname); + free (list); + free (body); + + return o; +} + +struct a_word +{ + struct a_word *next; + char *str; + int matched; +}; + +static char * +func_filter_filterout (o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + struct a_word *wordhead =0; + struct a_word *wordtail =0; + + int is_filter = streq (funcname, "filter"); + char *patterns = argv[0]; + - case function_strip: - /* Expand the argument. */ - text = expand_argument (text, end); + char *p; + int len; + char *word_iterator = argv[1]; + + /* Chop ARGV[1] up into words and then run each pattern through. */ + while ((p = find_next_token (&word_iterator, &len)) != 0) + { + struct a_word *w = (struct a_word *)alloca(sizeof(struct a_word)); + if (wordhead == 0) + wordhead = w; + else + wordtail->next = w; + wordtail = w; + + if (*word_iterator != '\0') + ++word_iterator; + p[len] = '\0'; + w->str = p; + w->matched = 0; + } + + if (wordhead != 0) + { + struct a_word *wp =0; + char *pat_iterator = patterns; + int doneany = 0; - p2 = text; - while (*p2 != '\0') + wordtail->next = 0; + + + /* Run each pattern through the words, killing words. */ + while ((p = find_next_token (&pat_iterator, &len)) != 0) { - while (isspace(*p2)) - ++p2; - p = p2; - for (i=0; *p2 != '\0' && !isspace(*p2); ++p2, ++i) - {} - if (!i) - break; - o = variable_buffer_output (o, p, i); - o = variable_buffer_output (o, " ", 1); - doneany = 1; + char *percent; + char save = p[len]; + p[len] = '\0'; + + percent = find_percent (p); + for (wp = wordhead; wp != 0; wp = wp->next) + wp->matched |= (percent == 0 ? streq (p, wp->str) + : pattern_matches (p, percent, wp->str)); + + p[len] = save; } + + /* Output the words that matched (or didn't, for filter-out). */ + for (wp = wordhead; wp != 0; wp = wp->next) + if (is_filter ? wp->matched : !wp->matched) + { + o = variable_buffer_output (o, wp->str, strlen (wp->str)); + o = variable_buffer_output (o, " ", 1); + doneany = 1; + } + if (doneany) /* Kill the last space. */ --o; + } - free (text); - break; + return o; +} - case function_wildcard: - text = expand_argument (text, end); -#ifdef _AMIGA - o = wildcard_expansion (text, o); -#else - p = string_glob (text); - o = variable_buffer_output (o, p, strlen (p)); -#endif +static char * +func_strip(o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + char *p = argv[0]; + int doneany =0; - free (text); - break; + while (*p != '\0') + { + int i=0; + char *word_start=0; - 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"); + while (isspace(*p)) + ++p; + word_start = p; + for (i=0; *p != '\0' && !isspace(*p); ++p, ++i) + {} + if (!i) + break; + o = variable_buffer_output (o, word_start, i); + o = variable_buffer_output (o, " ", 1); + doneany = 1; + } - 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"); + if (doneany) + /* Kill the last space. */ + --o; + return o; +} - text = expand_argument (text, p2); - p3 = expand_argument (p2 + 1, p); - p2 = expand_argument (p + 1, end); +/* + Print a warning or fatal message. +*/ +static char * +func_error (o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + char **argvp; + char *msg, *p; + int len; - o = subst_expand (o, p2, text, p3, strlen (text), strlen (p3), 0, 0); + /* The arguments will be broken on commas. Rather than create yet + another special case where function arguments aren't broken up, + just create a format string that puts them back together. */ + for (len=0, argvp=argv; *argvp != 0; ++argvp) + len += strlen(*argvp) + 2; - free (text); - free (p3); - free (p2); - break; + p = msg = alloca (len + 1); - case function_firstword: - /* Expand the argument. */ - text = expand_argument (text, end); + for (argvp=argv; argvp[1] != 0; ++argvp) + { + strcpy(p, *argvp); + p += strlen(*argvp); + *(p++) = ','; + *(p++) = ' '; + } + strcpy(p, *argvp); - /* Find the first word in TEXT. */ - p2 = text; - p = find_next_token (&p2, &i); - if (p != 0) - o = variable_buffer_output (o, p, i); + if (*funcname == 'e') + fatal (reading_file, "%s", msg); - free (text); - break; + /* The warning function expands to the empty string. */ + error (reading_file, "%s", msg); + + return o; +} - case function_word: - /* Get two comma-separated arguments and expand each one. */ - count = 0; - for (p = text; p < end; ++p) + +/* + chop argv[0] into words, and sort them. + */ +static char * +func_sort (o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + char **words = 0; + int nwords = 0; + register int wordi = 0; + + /* Chop ARGV[0] into words and put them in WORDS. */ + char *t = argv[0]; + char *p=0; + int len; + while ((p = find_next_token (&t, &len)) != 0) + { + if (wordi >= nwords - 1) { - if (*p == startparen) - ++count; - else if (*p == endparen) - --count; - else if (*p == ',' && count <= 0) - break; + nwords = 2* nwords + 5; + words = (char **) xrealloc ((char *) words, + nwords * sizeof (char *)); } - 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') - fatal (reading_file, - "non-numeric first argument to `word' function"); - - i = (unsigned int) atoi (text); - if (i == 0) - fatal (reading_file, - "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; + words[wordi++] = savestring (p, len); + } - case function_words: - /* Expand the argument. */ - text = expand_argument (text, end); + if (wordi > 0) + { + int i; + /* Now sort the list of words. */ + qsort ((char *) words, wordi, sizeof (char *), alpha_compare); - i = 0; - p2 = text; - while (find_next_token (&p2, (unsigned int *) 0) != 0) - ++i; + /* 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; + } - { - char buf[20]; - sprintf (buf, "%d", i); - o = variable_buffer_output (o, buf, strlen (buf)); - } + free ((char *) words); + return o; +} - free (text); - break; +static char * +func_wildcard(o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ - case function_wordlist: - /* 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 ("wordlist"); - text = expand_argument (text, p); - - /* Check the first argument. */ - for (p2 = text; *p2 != '\0'; ++p2) - if (*p2 < '0' || *p2 > '9') - fatal (reading_file, - "non-numeric first argument to `wordlist' function"); - i = (unsigned int)atoi(text); - free (text); - - /* Check the next argument */ - for (p2 = p + 1; isblank(*p2); ++p2) - {} - count = 0; - for (p = p2; p < end; ++p) +#ifdef _AMIGA + o = wildcard_expansion (argv[0], o); +#else + char *p = string_glob (argv[0]); + o = variable_buffer_output (o, p, strlen (p)); +#endif + return o; +} + +/* + \r is replaced on UNIX as well. Is this desirable? + */ +void +fold_newlines (buffer, length) + char *buffer; + int *length; +{ + char *dst = buffer; + char *src = buffer; + char *last_nonnl = buffer -1; + src[*length] = 0; + for (; *src != '\0'; ++src) + { + if (src[0] == '\r' && src[1] == '\n') + continue; + if (*src == '\n') { - if (*p == startparen) - ++count; - else if (*p == endparen) - --count; - else if (*p == ',' && count <= 0) - break; + *dst++ = ' '; } - if (p == end) - BADARGS ("wordlist"); - text = expand_argument (p2, p); - - for (p2 = text; *p2 != '\0'; ++p2) - if (*p2 < '0' || *p2 > '9') - fatal (reading_file, - "non-numeric second argument to `wordlist' function"); - j = (unsigned int)atoi(text); - free (text); - - if (j > i) - j -= i; else { - unsigned int k; - k = j; - j = i - j; - i = k; + last_nonnl = dst; + *dst++ = *src; } - ++j; + } + *(++last_nonnl) = '\0'; + *length = last_nonnl - buffer; +} - /* Extract the requested words */ - text = expand_argument (p + 1, end); - p2 = text; - while (((p = find_next_token (&p2, &len)) != 0) && --i) - {} - if (p) - { - while (--j && (find_next_token (&p2, &len) != 0)) - {} - o = variable_buffer_output (o, p, p2 - p); - } - free (text); - break; +int shell_function_pid = 0, shell_function_completed; - 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); +#ifdef WINDOWS32 +/*untested*/ - /* 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); +#include <windows.h> +#include <io.h> +#include "sub_proc.h" - 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); +void +windows32_openpipe (int *pipedes, int *pid_p, char **command_argv, char **envp) +{ + SECURITY_ATTRIBUTES saAttr; + HANDLE hIn; + HANDLE hErr; + HANDLE hChildOutRd; + HANDLE hChildOutWr; + HANDLE hProcess; + + + saAttr.nLength = sizeof(SECURITY_ATTRIBUTES); + saAttr.bInheritHandle = TRUE; + saAttr.lpSecurityDescriptor = NULL; + + if (DuplicateHandle(GetCurrentProcess(), + GetStdHandle(STD_INPUT_HANDLE), + GetCurrentProcess(), + &hIn, + 0, + TRUE, + DUPLICATE_SAME_ACCESS) == FALSE) { + fatal (NILF, "create_child_process: DuplicateHandle(In) failed (e=%d)\n", + GetLastError()); + + } + if (DuplicateHandle(GetCurrentProcess(), + GetStdHandle(STD_ERROR_HANDLE), + GetCurrentProcess(), + &hErr, + 0, + TRUE, + DUPLICATE_SAME_ACCESS) == FALSE) { + fatal (NILF, "create_child_process: DuplicateHandle(Err) failed (e=%d)\n", + GetLastError()); + } + + if (!CreatePipe(&hChildOutRd, &hChildOutWr, &saAttr, 0)) + fatal (NILF, "CreatePipe() failed (e=%d)\n", GetLastError()); + + + + hProcess = process_init_fd(hIn, hChildOutWr, hErr); + + if (!hProcess) + fatal (NILF, "windows32_openpipe (): process_init_fd() failed\n"); - p2 = expand_argument (p + 1, end); + else + process_register(hProcess); - 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; + /* make sure that CreateProcess() has Path it needs */ + sync_Path_environment(); - free (p2); - free (text); - break; + if (!process_begin(hProcess, command_argv, envp, command_argv[0], NULL)) + *pid_p = (int) hProcess; + else + fatal (NILF, "windows32_openpipe (): unable to launch process (e=%d)\n", + process_last_err(hProcess)); - case function_dir: - case function_basename: - /* Expand the argument. */ - text = expand_argument (text, end); + /* set up to read data from child */ + pipedes[0] = _open_osfhandle((long) hChildOutRd, O_RDONLY); - p3 = text; - while ((p2 = find_next_token (&p3, &len)) != 0) - { - p = p2 + len; -#ifdef VMS - while (p >= p2 && *p != ']' - && (function != function_basename || *p != '.')) -#else -# ifdef __MSDOS__ - while (p >= p2 && *p != '/' && *p != '\\' - && (function != function_basename || *p != '.')) -# else - while (p >= p2 && *p != '/' - && (function != function_basename || *p != '.')) -# endif + /* this will be closed almost right away */ + pipedes[1] = _open_osfhandle((long) hChildOutWr, O_APPEND); +} #endif - --p; - if (p >= p2 && (function == function_dir)) - o = variable_buffer_output (o, p2, ++p - p2); - else if (p >= p2 && (*p == '.')) - o = variable_buffer_output (o, p2, p - p2); -#if defined(WINDOWS32) || defined(__MSDOS__) - /* Handle the "d:foobar" case */ - else if (p2[0] && p2[1] == ':' && function == function_dir) - o = variable_buffer_output (o, p2, 2); + + +#ifdef __MSDOS__ +/* + untested +*/ +int +msdos_openpipe (int* pipedes, int *pidp, char *text) +{ + FILE *fpipe=0; + /* MSDOS can't fork, but it has `popen'. + (Bwt, why isn't `popen' used in all the versions?) */ + struct variable *sh = lookup_variable ("SHELL", 5); + int e; + extern int dos_command_running, dos_status; + + /* Make sure not to bother processing an empty line. */ + while (isblank (*text)) + ++text; + if (*text == '\0') + return 0; + + if (sh) + { + char buf[PATH_MAX + 7]; + /* This makes sure $SHELL value is used by $(shell), even + though the target environment is not passed to it. */ + sprintf (buf, "SHELL=%s", sh->value); + putenv (buf); + } + + e = errno; + errno = 0; + dos_command_running = 1; + dos_status = 0; + fpipe = popen (text, "rt"); + dos_command_running = 0; + if (!fpipe || dos_status) + { + pipedes[0] = -1; + *pidp = -1; + if (dos_status) + errno = EINTR; + else if (errno == 0) + errno = ENOMEM; + shell_function_completed = -1; + } + else + { + pipedes[0] = fileno (fpipe); + *pidp = 42; /* uh? The meaning of Life?*/ + errno = e; + shell_function_completed = 1; + } + return fpipe; +} #endif - else if (function == function_dir) + +/* + Do shell spawning, with the naughty bits for different OSes. + */ + #ifdef VMS - o = variable_buffer_output (o, "[]", 2); + +/* VMS can't do $(shell ...) */ +#define func_shell 0 + #else #ifndef _AMIGA - o = variable_buffer_output (o, "./", 2); -#else - /* o = o */; /* Just a nop... */ -#endif /* AMIGA */ -#endif /* !VMS */ - else - /* The entire name is the basename. */ - o = variable_buffer_output (o, p2, len); +static char * +func_shell (o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + char* batch_filename = NULL; + int i; - o = variable_buffer_output (o, " ", 1); - doneany = 1; - } - if (doneany) - /* Kill last space. */ - --o; +#ifdef __MSDOS__ + FILE *fpipe; +#endif + char **command_argv; + char *error_prefix; + char **envp; + int pipedes[2]; + int pid; - free (text); - break; +#ifndef __MSDOS__ + /* Construct the argument list. */ + command_argv = construct_command_argv (argv[0], + (char **) NULL, (struct file *) 0, + &batch_filename); + if (command_argv == 0) + return o; +#endif - case function_notdir: - case function_suffix: - /* Expand the argument. */ - text = expand_argument (text, end); + /* Using a target environment for `shell' loses in cases like: + export var = $(shell echo foobie) + because target_environment hits a loop trying to expand $(var) + to put it in the environment. This is even more confusing when + var was not explicitly exported, but just appeared in the + calling environment. */ + + envp = environ; + + /* For error messages. */ + if (reading_file != 0) + { + error_prefix = (char *) alloca (strlen(reading_file->filenm)+100); + + sprintf (error_prefix, + "%s:%lu: ", reading_file->filenm, reading_file->lineno); + + } + else + error_prefix = ""; + +#ifdef WINDOWS32 + windows32_openpipe (pipedes, &pid, command_argv, envp); +#else /* WINDOWS32 */ - p3 = text; - while ((p2 = find_next_token (&p3, &len)) != 0) - { - p = p2 + len; -#ifdef VMS - while (p >= p2 && *p != ']' - && (function != function_suffix || *p != '.')) -#else # ifdef __MSDOS__ - while (p >= p2 && *p != '/' && *p != '\\' - && (function != function_suffix || *p != '.')) + fpipe = msdos_openpipe (pipedes, argv[0], command_argv, envp); + if (!fpipe || pipedes[0] < 0) + { + perror_with_name (error_prefix, "pipe"); + return o; + } # else - while (p >= p2 && *p != '/' - && (function != function_suffix || *p != '.')) -# endif + if (pipe (pipedes) < 0) + { + perror_with_name (error_prefix, "pipe"); + return o; + } + + pid = vfork (); + if (pid < 0) + perror_with_name (error_prefix, "fork"); + else if (pid == 0) + child_execute_job (0, pipedes[1], command_argv, envp); + else +# endif /* ! __MSDOS__ */ + +#endif /* WINDOWS32 */ + { + /* We are the parent. */ + + char *buffer; + unsigned int maxlen; + int cc; + + /* Record the PID for reap_children. */ + shell_function_pid = pid; +#ifndef __MSDOS__ + shell_function_completed = 0; + + /* Free the storage only the child needed. */ + free (command_argv[0]); + free ((char *) command_argv); + + /* Close the write side of the pipe. */ + (void) close (pipedes[1]); #endif - --p; - if (p >= p2) - { - if (function == function_notdir) - ++p; - else if (*p != '.') - continue; - o = variable_buffer_output (o, p, len - (p - p2)); - } -#if defined(WINDOWS32) || defined(__MSDOS__) - /* Handle the case of "d:foo/bar". */ - else if (function == function_notdir && p2[0] && p2[1] == ':') + + /* Set up and read from the pipe. */ + + maxlen = 200; + buffer = (char *) xmalloc (maxlen + 1); + + /* Read from the pipe until it gets EOF. */ + i = 0; + do + { + if (i == maxlen) { - p = p2 + 2; - o = variable_buffer_output (o, p, len - (p - p2)); + 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 - 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; - } + /* Close the read side of the pipe. */ +#ifdef __MSDOS__ + if (fpipe) + (void) pclose (fpipe); +#else + (void) close (pipedes[0]); +#endif + + /* Loop until child_handler sets shell_function_completed + to the status of our child shell. */ + while (shell_function_completed == 0) + reap_children (1, 0); + + if (batch_filename) { + if (debug_flag) + printf("Cleaning up temporary batch file %s\n", batch_filename); + remove(batch_filename); + free(batch_filename); + } + 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. */ + fold_newlines (buffer, &i); + o = variable_buffer_output (o, buffer, i); } - if (doneany) - /* Kill last space. */ - --o; - free (text); - break; + free (buffer); } 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; +#else /* _AMIGA */ + +/* Do the Amiga version of func_shell. */ +static char * +func_shell (char *o, char **argv, const char *funcname) { - register unsigned int code; - unsigned int maxlen; - char *beg = *stringp + 1; - char *endref; + /* Amiga can't fork nor spawn, but I can start a program with + redirection of my choice. However, this means that we + don't have an opportunity to reopen stdout to trap it. Thus, + we save our own stdout onto a new descriptor and dup a temp + file's descriptor onto our stdout temporarily. After we + spawn the shell program, we dup our own stdout back to the + stdout descriptor. The buffer reading is the same as above, + except that we're now reading from a file. */ + +#include <dos/dos.h> +#include <proto/dos.h> + + BPTR child_stdout; + char tmp_output[FILENAME_MAX]; + unsigned int maxlen = 200; + int cc, i; + char * buffer, * ptr; + char ** aptr; + int len = 0; + char* batch_filename = NULL; - endref = lindex (beg, beg + MAXFUNCTIONLEN, '\0'); - maxlen = endref != 0 ? endref - beg : MAXFUNCTIONLEN; + /* Construct the argument list. */ + command_argv = construct_command_argv (argv[0], (char **) NULL, + (struct file *) 0, &batch_filename); + if (command_argv == 0) + return o; - for (code = 0; function_table[code].name != 0; ++code) + + strcpy (tmp_output, "t:MakeshXXXXXXXX"); + mktemp (tmp_output); + child_stdout = Open (tmp_output, MODE_NEWFILE); + + for (aptr=command_argv; *aptr; aptr++) + len += strlen (*aptr) + 1; + + buffer = xmalloc (len + 1); + ptr = buffer; + + for (aptr=command_argv; *aptr; aptr++) { - 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; + strcpy (ptr, *aptr); + ptr += strlen (ptr) + 1; + *ptr ++ = ' '; + *ptr = 0; } - 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; + ptr[-1] = '\n'; + + Execute (buffer, NULL, child_stdout); + free (buffer); - /* Space after function name isn't part of the args. */ - p = next_token (endref); - argbeg = p; + Close (child_stdout); - /* Count nested use of whichever kind of parens we use, - so that nested calls and variable refs work. */ + child_stdout = Open (tmp_output, MODE_OLDFILE); - for (; *p != '\0'; ++p) + buffer = xmalloc (maxlen); + i = 0; + do + { + if (i == maxlen) { - if (*p == openparen) - ++count; - else if (*p == closeparen && --count < 0) - break; + maxlen += 512; + buffer = (char *) xrealloc (buffer, maxlen + 1); } - if (count >= 0) - fatal (reading_file, - "unterminated call to function `%s': missing `%c'", - function_table[code].name, closeparen); + cc = Read (child_stdout, &buffer[i], maxlen - i); + if (cc > 0) + i += cc; + } while (cc > 0); - /* We found the end; expand the function call. */ + Close (child_stdout); - *op = expand_function (*op, function_table[code].function, argbeg, p); - *stringp = p; - return 1; - } + fold_newlines (buffer, &i); + o = variable_buffer_output (o, buffer, i); + free (buffer); + return o; +} +#endif /* _AMIGA */ +#endif /* !VMS */ + +#ifdef EXPERIMENTAL - return 0; +/* + equality. Return is string-boolean, ie, the empty string is false. + */ +static char * +func_eq (char* o, char **argv, char *funcname) +{ + int result = ! strcmp (argv[0], argv[1]); + o = variable_buffer_output (o, result ? "1" : "", result); + return o; } - -/* Glob-expand LINE. The returned pointer is - only good until the next call to string_glob. */ + +/* + string-boolean not operator. + */ static char * -string_glob (line) - char *line; +func_not (char* o, char **argv, char *funcname) { - static char *result = 0; - static unsigned int length; - register struct nameseq *chain; - register unsigned int idx; + char * s = argv[0]; + int result = 0; + while (isspace (*s)) + s++; + result = ! (*s); + o = variable_buffer_output (o, result ? "1" : "", result); + return o; +} - chain = multi_glob (parse_file_seq - (&line, '\0', sizeof (struct nameseq), - /* We do not want parse_file_seq to strip `./'s. - That would break examples like: - $(patsubst ./%.c,obj/%.o,$(wildcard ./*.c)). */ - 0), - sizeof (struct nameseq)); - if (result == 0) - { - length = 100; - result = (char *) xmalloc (100); - } - idx = 0; - while (chain != 0) +/* + This is an experimental conditional function. + + Syntax: + + $(if condition, true-part, false-part) + + This is fully not consistent with make's syntax, but more in line + with `normal' programming languages. + + Semantics: + + - CONDITION is false iff it evaluates to an empty string. White + space before and after condition are stripped before evaluation. + + - If CONDITION is true, then TRUE-PART is evaluated, otherwise + FALSE-PART is evaluated. Because only one of the two PARTs is + evaluated, you can use $(if ) to create side-effects with the + $(shell ) function + + */ +static char * +func_if (char* o, char **argv, char *funcname) +{ + char *begp = argv[0]; + char *endp = argv[1]-2; + char *expansion =0; + int result = 0; + + strip_whitespace (&begp, &endp); + if(begp <= endp) + expansion = expand_argument (begp, endp + 1); + + result = expansion + ? strlen (expansion) + : 0; + + result = !result; + free (expansion); + + expansion = expand_argument (argv[1 + result], argv[2+result] -1); + o = variable_buffer_output (o, expansion, strlen (expansion)); + + return o; +} +#endif + +/* This might not be very useful, but the code was simple to + implement, I just had to do it. + + Here goes anyway + + Apply & User defined functions. + + SYNTAX + + $(apply funcname, arg1, arg2, .. ) + + SEMANTICS + + You can specify a builtin function, for funcname, eg + + f = addprefix + $(apply addprefix,a, b c d) + + This will result in + + ab ac ad + + You can specify your own functions, eg + + funcname=BODY + + BODY contains $(1) .. $(N) as argument markers. + upon expansions the strings ARG1 .. ARGN are substituted for $(1) .. $(N) + into BODY + + Because the funcname is computed as well you can combine this do some + funky things, eg + + map=$(foreach a, $(2), $(apply $(1), $(a))) + + + LIMITATIONS. + + Make has no support for nested lists (or tuples), so you can't do + stuff like (Haskell notation): + + f :: (a,b) -> c -- type of F + map :: (a->b) -> [a] -> b -- type of MAP + + map f [(1,2), (2,3)] -- map F over list containing (1,2) and (2,3) + + to get + + [f (1, 2), f (2, 3)] + + + If only we had nested lists and quotes, we could duplicate LISP in make by + transforming + + $(a, b, c) <-> (a b c) + $(quote $(a, b, c)) <-> '(a b c) + + (or something alike ;-) (We could have automatic integration of + GUILE and make :-) + + [Actually -- why should this be a joke? If we could somehow integrate the + rules and targets into a functional model make could be a lot cleaner in + concept. ] + +*/ +char * +func_apply (o, argv, funcname) + char *o; + char **argv; + const char *funcname; +{ + char *userfunc_name; + int func_len; + char *body = 0; + char *expanded_body = 0; + int i; + const struct function_table_entry *entry_p; + + userfunc_name = argv[0]; + while (isspace (*userfunc_name)) + ++userfunc_name; + + entry_p = lookup_function (function_table, userfunc_name); + + /* builtin function? */ + if (entry_p) { - register char *name = chain->name; - unsigned int len = strlen (name); + for (i=0; argv[i+1]; i++) + ; - struct nameseq *next = chain->next; - free ((char *) chain); - chain = next; + o = expand_builtin_function (o, i, argv + 1, entry_p); + return o; + } - /* 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++] = ' '; - } + func_len = strlen (userfunc_name); + body = xmalloc (func_len + 4); + strcpy (body + 2, userfunc_name); + body [func_len+2]=')'; + body [func_len+3]= 0; + body [1]='('; + body [0]='$'; - free (name); + push_new_variable_scope (); + + /* set up arguments $(1) .. $(N) */ + for (i=0; argv[i]; i++) + { + char num[10]; + struct variable* var; + sprintf (num, "%d", i); + var = define_variable (num, strlen (num), argv[i], o_automatic, 0); } - /* Kill the last space and terminate the string. */ - if (idx == 0) - result[0] = '\0'; - else - result[idx - 1] = '\0'; + expanded_body = allocated_variable_expand (body); + o = variable_buffer_output (o, expanded_body, strlen (expanded_body)); + free (expanded_body); + pop_variable_scope (); - return result; + free (body); + return o; } + + +#define STRING_SIZE_TUPLE(s) (s), (sizeof(s)-1) + +/* Lookup table for builtin functions. + + This doesn't have to be sorted; we use a straight lookup. We might gain + some efficiency by moving most often used functions to the start of the + table. + + REQUIRED_ARGUMENTS is the minimum number of arguments. A function + can have more, but they will be ignored. + + EXPAND_ALL_ARGUMENTS means that all arguments should be expanded + before invocation. Functions that do namespace tricks (foreach) + don't automatically expand. */ + +static struct function_table_entry function_table[] = +{ + /* Name/size */ /* ARG EXP? Function */ + { STRING_SIZE_TUPLE("addprefix"), 2, 1, func_addsuffix_addprefix}, + { STRING_SIZE_TUPLE("addsuffix"), 2, 1, func_addsuffix_addprefix}, + { STRING_SIZE_TUPLE("basename"), 1, 1, func_basename_dir}, + { STRING_SIZE_TUPLE("dir"), 1, 1, func_basename_dir}, + { STRING_SIZE_TUPLE("notdir"), 1, 1, func_notdir_suffix}, + { STRING_SIZE_TUPLE("subst"), 3, 1, func_subst}, + { STRING_SIZE_TUPLE("suffix"), 1, 1, func_notdir_suffix}, + { STRING_SIZE_TUPLE("filter"), 2, 1, func_filter_filterout}, + { STRING_SIZE_TUPLE("filter-out"), 2, 1, func_filter_filterout}, + { STRING_SIZE_TUPLE("findstring"), 2, 1, func_findstring}, + { STRING_SIZE_TUPLE("firstword"), 1, 1, func_firstword}, + { STRING_SIZE_TUPLE("join"), 2, 1, func_join}, + { STRING_SIZE_TUPLE("patsubst"), 3, 1, func_patsubst}, + { STRING_SIZE_TUPLE("shell"), 1, 1, func_shell}, + { STRING_SIZE_TUPLE("sort"), 1, 1, func_sort}, + { STRING_SIZE_TUPLE("strip"), 1, 1, func_strip}, + { STRING_SIZE_TUPLE("wildcard"), 1, 1, func_wildcard}, + { STRING_SIZE_TUPLE("word"), 2, 1, func_word}, + { STRING_SIZE_TUPLE("wordlist"), 3, 1, func_wordlist}, + { STRING_SIZE_TUPLE("words"), 1, 1, func_words}, + { STRING_SIZE_TUPLE("origin"), 1, 1, func_origin}, + { STRING_SIZE_TUPLE("error"), 1, 1, func_error}, + { STRING_SIZE_TUPLE("warning"), 1, 1, func_error}, + { STRING_SIZE_TUPLE("foreach"), 3, 0, func_foreach}, +#ifdef EXPERIMENTAL + { STRING_SIZE_TUPLE("apply"), 1, 1, func_apply}, + { STRING_SIZE_TUPLE("eq"), 2, 1, func_eq}, + { STRING_SIZE_TUPLE("if"), 3, 0, func_if}, + { STRING_SIZE_TUPLE("not"), 1, 1, func_not}, +#endif + { 0 } +}; |