diff options
Diffstat (limited to '')
| -rw-r--r-- | makeenv.c | 430 |
1 files changed, 430 insertions, 0 deletions
diff --git a/makeenv.c b/makeenv.c new file mode 100644 index 0000000..a091b49 --- /dev/null +++ b/makeenv.c @@ -0,0 +1,430 @@ +/* See LICENSE file for copyright and license details. */ +#include <ctype.h> +#include <errno.h> +#include <fcntl.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + + +static const char *argv0 = "makeenv"; +static const char **options = NULL; +static const char **macros = NULL; +static const char **targets = NULL; +static size_t noptions = 0; +static size_t nmacros = 0; +static size_t ntargets = 0; +static size_t options_size = 0; +static size_t macros_size = 0; +static size_t targets_size = 0; + + +static void +put_option(const char *s) +{ + if (noptions == options_size) { + options_size += 16; + options = realloc(options, options_size * sizeof(*options)); + if (!options) { + fprintf(stderr, "%s: failed to allocate enough memory to load .makeenv\n", argv0); + exit(125); + } + } + options[noptions] = s; +} + + +static void +put_option_short(int c) +{ + char buf[3]; + buf[0] = '-'; + buf[1] = (char)c; + buf[2] = '\0'; + put_option(buf); +} + + +static void +put_option_prefix_dash(const char *s) +{ + size_t len = strlen(s); + char *arg = malloc(len + 2); + if (!arg) { + fprintf(stderr, "%s: failed to allocate enough memory to load .makeenv\n", argv0); + exit(125); + } + stpcpy(stpcpy(arg, "-"), s); + put_option(arg); +} + + +static void +put_options(char *s) +{ + const char *word = s; + for (; *s; s++) { + if (isspace(*s)) { + *s = '\0'; + if (*word) + put_option(word); + word = &s[1]; + } + } + if (*word) + put_option(word); +} + + +static void +put_macro(const char *s) +{ + if (putenv(*(char **)(void *)&s)) { + fprintf(stderr, "%s: failed to update environment: %s\n", argv0, strerror(errno)); + exit(125); + } + if (nmacros == macros_size) { + macros_size += 16; + macros = realloc(macros, macros_size * sizeof(*macros)); + if (!macros) { + fprintf(stderr, "%s: failed to allocate enough memory to load .makeenv\n", argv0); + exit(125); + } + } + macros[nmacros] = s; +} + + +static void +put_target(const char *s) +{ + if (ntargets == targets_size) { + targets_size += 16; + targets = realloc(targets, targets_size * sizeof(*targets)); + if (!targets) { + fprintf(stderr, "%s: failed to allocate enough memory to load .makeenv\n", argv0); + exit(125); + } + } + targets[ntargets] = s; +} + + +static void +put_targets(char *s) +{ + const char *word = s; + for (; *s; s++) { + if (isspace(*s)) { + *s = '\0'; + if (*word) + put_target(word); + word = &s[1]; + } + } + if (*word) + put_target(word); +} + +static void +put_operand(char *s) +{ + /* + * Behaviour is unspecified if any target is specified before + * a macro, however make(1) shall allow options to be mixed in + * with both macros and targets + */ + static int warned_mixed = 0; + static int found_targets = 0; + + if (strchr(s, '=')) { + /* + * Adding macro as a target as we don't want it to be + * but into the environment and we don't want to reorder + * them if the user mixes macros with targets (targets + * ared pulled into the command line after macros so + * this will not cause any problems) + */ + put_target(s); + if (found_targets && !warned_mixed) { + warned_mixed = 1; + fprintf(stderr, "%s: warning: mixing targets and macros in the " + "command line results in unspecified behaviour\n", argv0); + } + } else { + put_target(s); + found_targets = 1; + } +} + + + +#if defined(__GNUC__) +__attribute__((__pure__)) +#endif +static int +contains(const char *set, const char *sought) +{ + size_t m, n = strlen(sought); + const char *p, *q; + for (p = set; (q = strchr(p, ' ')); p = &q[1]) { + m = (size_t)(q - p); + if (m == n && !strncmp(p, sought, n)) + return 1; + } + return !strcmp(p, sought); +} + + +static const char ** +create_cmdline(void) +{ + size_t i, j = 1, n = noptions + nmacros + ntargets + 2; + const char **args = malloc(n * sizeof(char *)); + if (!args) { + fprintf(stderr, "%s: failed to allocate enough memory to execute make\n", argv0); + exit(125); + } + for (i = 0; i < noptions; i++) + args[j++] = options[i]; + for (i = 0; i < nmacros; i++) + args[j++] = macros[i]; + for (i = 0; i < ntargets; i++) + args[j++] = targets[i]; + args[j] = NULL; + return args; +} + + +static void +trim(char *s) +{ + size_t key_start, key_end; + size_t val_start, val_end; + size_t i, n; + + key_start = 0; + while (isspace(s[key_start])) + key_start += 1; + + key_end = key_start; + while (s[key_end] != '=') + key_end += 1; + + val_start = key_end + 1; + + while (key_end > key_start && isspace(s[key_end - 1])) + key_end -= 1; + + while (isspace(s[val_start])) + key_start += 1; + + val_end = val_start; + for (i = val_end; s[i]; i++) + if (!isspace(s[i])) + val_end = i; + + memmove(s, &s[key_start], key_end - key_start); + n = key_end - key_start; + s[n++] = '='; + + memmove(&s[n], &s[val_start], val_end - val_start); + n += val_end - val_start; + s[n] = '\0'; +} + + +int +main(int argc, char *argv[]) +{ + int exitstatus, fd; + char *env = NULL; + size_t envsize = 0; + size_t envlen = 0; + ssize_t r; + size_t i; + char *line; + int has_equals; + const char **args; + const char *arg; + const char *make; + const char *unarged_opts; + const char *arged_opts; + const char *optatarged_opts; + const char *optarged_opts; + const char *unarged_longopts; + const char *arged_longopts; + const char *optarged_longopts; + int operand_found = 0; + int warned_reordered = 0; + + args = (void *)argv; + argv0 = *argv++; + (void) argc; + + fd = open(".makeenv", O_RDONLY); + if (fd < 0) { + if (errno == ENOENT) + goto exec; + fprintf(stderr, "%s: failed to open .makeenv for reading: %s\n", argv0, strerror(errno)); + return 125; + } + + for (;;) { + if (envlen == envsize) { + envsize += 8096; + env = realloc(env, envsize); + if (!env) { + fprintf(stderr, "%s: failed to allocate enough memory to load .makeenv\n", argv0); + return 125; + } + } + r = read(fd, &env[envlen], envsize - envlen); + if (r <= 0) { + if (!r) + break; + fprintf(stderr, "%s: failed to read .makeenv\n", argv0); + return 125; + } + envlen += (size_t)r; + } + + if (!envlen) { + close(fd); + goto exec; + } + + env = realloc(env, envlen + 1); + if (!env) { + fprintf(stderr, "%s: failed to allocate enough memory to load .makeenv\n", argv0); + return 125; + } + env[envlen++] = '\n'; + + line = env; + has_equals = 0; + for (i = 0; i < envlen; i++) { + if (env[i] == '\n') { + env[i] = '\0'; + trim(line); + if (line[0] == '-' && line[1]) { + put_options(line); + } else if (has_equals) { + if (*line && *line != '=' && *line != '#') + put_macro(line); + } else { + if (*line && *line != '#') + put_targets(line); + } + line = &env[i + 1]; + has_equals = 0; + } else if (env[i] == '=') { + has_equals = 1; + } + } + + close(fd); + + env = getenv("MAKEENV_OPTS_NO_ARG"); + unarged_opts = env ? env : "eiknpqrSst"; + env = getenv("MAKEENV_OPTS_ARG"); + arged_opts = env ? env : "f"; + env = getenv("MAKEENV_OPTS_OPT_ATTACHED_ARG"); + optatarged_opts = env ? env : ""; + env = getenv("MAKEENV_OPTS_OPT_ARG"); + optarged_opts = env ? env : ""; + env = getenv("MAKEENV_LONG_OPTS_NO_ARG"); + unarged_longopts = env ? env : ""; + env = getenv("MAKEENV_LONG_OPTS_ARG"); + arged_longopts = env ? env : ""; + env = getenv("MAKEENV_LONG_OPTS_OPT_ARG"); + optarged_longopts = env ? env : ""; + + for (; *argv; argv++) { + if (!strcmp(*argv, "--")) { + argv++; + break; + } else if ((*argv)[0] != '-' || !(*argv)[1]) { + /* do not break, as make(1) allows mixing options and operands */ + put_operand(*argv); + operand_found = 1; + continue; + } + + if (operand_found && !warned_reordered) { + warned_reordered = 1; + fprintf(stderr, "%s: warning: reordering operands to after options\n", argv0); + } + + if ((*argv)[1] == '-') { + arg = *argv; + if (strchr(arg, '=') || contains(unarged_longopts, arg)) { + put_option(arg); + } else if (contains(arged_longopts, arg)) { + put_option(arg); + if (!argv[1]) { + fprintf(stderr, "%s: argument for option %s missing\n", argv0, arg); + return 125; + } + put_option(*++argv); + } else if (contains(optarged_longopts, arg)) { + put_option(arg); + if (argv[1] && argv[1][0] != '-') + put_option(*++argv); + } else { + fprintf(stderr, "%s: option %s not recognised\n", argv0, arg); + return 125; + } + } else { + arg = &(*argv)[1]; + while (*arg) { + if (strchr(unarged_opts, *arg)) { + put_option_short(*arg++); + } else if (strchr(arged_opts, *arg)) { + if (arg[1]) { + put_option_short(*arg++); + put_option(arg); + break; + } else if (argv[1]) { + put_option_short(*arg++); + put_option(*++argv); + break; + } else { + fprintf(stderr, "%s: argument for option -%c missing\n", argv0, *arg); + return 125; + } + } else if (strchr(optatarged_opts, *arg)) { + put_option_prefix_dash(arg); + break; + } else if (strchr(optarged_opts, *arg)) { + if (arg[1]) { + put_option_prefix_dash(arg); + } else { + put_option_short(*arg++); + if (argv[1] && argv[1][0] != '-') + put_option(*++argv); + } + break; + } else { + fprintf(stderr, "%s: option -%c not recognised\n", argv0, *arg); + return 125; + } + } + } + } + + while (*argv) + put_operand(*argv); + + args = create_cmdline(); + +exec: + make = getenv("MAKEENV_MAKE"); + make = make ? make : getenv("MAKE"); + args[0] = make ? make : "make"; + execvp(args[0], (void *)args); + exitstatus = errno == ENOENT ? 127 : 126; + fprintf(stderr, "%s: failed to execute %s: %s\n", argv0, args[0], strerror(errno)); + return exitstatus; +} |