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