mirror of
https://github.com/ksherlock/mpw.git
synced 2025-02-16 12:30:53 +00:00
468 lines
8.9 KiB
C++
468 lines
8.9 KiB
C++
/*
|
|
*
|
|
* Run MPW's make.
|
|
*
|
|
* MPW Make prints a list of commands to stdout.
|
|
* read and execute them.
|
|
*/
|
|
|
|
#include <cstdio>
|
|
#include <cstring>
|
|
#include <cerrno>
|
|
#include <cctype>
|
|
|
|
#include <algorithm>
|
|
#include <functional>
|
|
#include <string>
|
|
#include <unordered_map>
|
|
#include <vector>
|
|
|
|
|
|
#include <unistd.h>
|
|
#include <sysexits.h>
|
|
|
|
#include <stdlib.h>
|
|
#include <sys/wait.h>
|
|
#include <fcntl.h>
|
|
|
|
|
|
int parse_makefile(int fd);
|
|
void help(void);
|
|
void launch_make(std::vector<char *> &argv);
|
|
void print_command(const std::vector<char *> &argv, bool active);
|
|
void print_command(const std::vector<std::string> &argv, bool active);
|
|
|
|
int launch_command(const std::vector<std::string> &argv);
|
|
int launch_command(std::vector<char *> &argv);
|
|
|
|
bool dry_run = false;
|
|
|
|
void help(void) {
|
|
|
|
#undef _
|
|
#define _(x) puts(x)
|
|
|
|
_("Make # build up-to-date version of a program");
|
|
_("Make [option...] [target...]");
|
|
_(" -d name[=value] # define variable name (overrides makefile definition)");
|
|
_(" -e # rebuild everything regardless of dates");
|
|
_(" -f filename # read dependencies from specified file (default: MakeFile)");
|
|
_(" -i dirname # additional directory to search for include files");
|
|
_(" -[no]mf # [don't] use temporary memory (default: mf)");
|
|
_(" -p # write progress information to diagnostics");
|
|
_(" -r # display the roots of the dependency graph");
|
|
_(" -s # display the structure of the dependency graph");
|
|
_(" -t # touch dates of targets and prerequisites");
|
|
_(" -u # write list of unreachable targets to diagnostics");
|
|
_(" -v # write verbose explanations to diagnostics (implies -p)");
|
|
_(" -w # suppress warning messages");
|
|
_(" -y # like -v, but omit announcing up-to-date targets");
|
|
_("");
|
|
_(" --help # display help");
|
|
_(" --dry-run # show what commands would run");
|
|
#undef _
|
|
}
|
|
|
|
|
|
std::string &lowercase(std::string &s) {
|
|
std::transform(std::begin(s), std::end(s), std::begin(s), std::tolower);
|
|
return s;
|
|
}
|
|
|
|
std::unordered_map<std::string, std::string> environment;
|
|
std::unordered_map<std::string, std::function<int(const std::vector<std::string> &)>> builtins;
|
|
|
|
/*
|
|
* 0 = active
|
|
* 1+ = nesting level.
|
|
*/
|
|
unsigned if_status = 0;
|
|
|
|
/* true/false if true condition encountered at this level */
|
|
|
|
std::vector<unsigned> if_stack;
|
|
|
|
int builtin_set(const std::vector<std::string> &argv) {
|
|
// Set name value
|
|
|
|
bool active = if_status == 0;
|
|
print_command(argv, active);
|
|
|
|
if (!active) return 0;
|
|
|
|
if (argv.size() != 3) return 1;
|
|
std::string key = argv[1];
|
|
std::string value = argv[2];
|
|
|
|
// lower-case key...
|
|
lowercase(key);
|
|
|
|
// c++17 has insert_or_assign
|
|
environment[std::move(key)] = std::move(value);
|
|
|
|
|
|
return 0;
|
|
}
|
|
|
|
bool evaluate(const std::vector<std::string> &v)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
int builtin_if(const std::vector<std::string> &argv) {
|
|
/*
|
|
* if expression
|
|
* ...
|
|
* [else if expression]
|
|
* [else]
|
|
* end
|
|
*/
|
|
|
|
bool active = (if_status == 0);
|
|
|
|
print_command(argv, active);
|
|
|
|
|
|
if (if_status) {
|
|
if_stack.push_back(false);
|
|
++if_status;
|
|
return 0;
|
|
}
|
|
// todo... actually evaluate expression.
|
|
|
|
bool ok = evaluate(argv);
|
|
if_stack.push_back(ok);
|
|
if (!ok) ++if_status;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int builtin_else(const std::vector<std::string> &argv) {
|
|
|
|
// else
|
|
// else if ....
|
|
|
|
print_command(argv, if_status < 2);
|
|
|
|
if (if_stack.empty()) {
|
|
fprintf(stderr, "ELSE without IF\n");
|
|
return -1;
|
|
}
|
|
|
|
unsigned &processed = if_stack.back();
|
|
|
|
|
|
|
|
// best case -- entire if/else/end stmt is inactive.
|
|
|
|
if (if_status > 1) {
|
|
return 0;
|
|
}
|
|
|
|
// second best case -- a true condition has already been found.
|
|
if (processed) {
|
|
if_status = 1;
|
|
return 0;
|
|
}
|
|
|
|
// third case -- evalute a naked else
|
|
if (argv.size() == 1) {
|
|
processed = true;
|
|
if_status = 0;
|
|
return 0;
|
|
}
|
|
|
|
// fourth case -- evaluate and else if
|
|
bool ok = evaluate(argv);
|
|
if (ok) {
|
|
processed = true;
|
|
if_status = 0;
|
|
return 0;
|
|
} else {
|
|
if_status = 1;
|
|
return 0;
|
|
}
|
|
|
|
}
|
|
|
|
int builtin_end(const std::vector<std::string> &argv) {
|
|
|
|
print_command(argv, if_status < 2);
|
|
|
|
if (if_stack.empty()) {
|
|
fprintf(stderr, "END without IF\n");
|
|
return 1;
|
|
}
|
|
|
|
|
|
if_stack.pop_back();
|
|
|
|
if (if_status) {
|
|
--if_status;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int builtin_echo(const std::vector<std::string> &argv) {
|
|
// echo [-n] ...
|
|
|
|
bool active = (if_status == 0);
|
|
|
|
print_command(argv, active);
|
|
if (!active) return 0;
|
|
if (dry_run) return 0;
|
|
|
|
bool n = false;
|
|
bool printed = false;
|
|
|
|
for (auto iter = argv.begin() + 1; iter != argv.end(); ++iter) {
|
|
const std::string &s = *iter;
|
|
if (s.length() == 2 && s == "-n") {
|
|
n = true;
|
|
continue;
|
|
}
|
|
if (printed) fputs(" ", stdout);
|
|
fputs(s.c_str(), stdout);
|
|
printed = true;
|
|
}
|
|
if (!n) fputs("\n", stdout);
|
|
return 0;
|
|
}
|
|
|
|
void launch_make(std::vector<char *> &argv) {
|
|
int ok;
|
|
|
|
if (argv.empty() || argv.back() != nullptr)
|
|
argv.push_back(nullptr);
|
|
|
|
ok = execvp(argv.front(), argv.data());
|
|
perror("execvp: ");
|
|
exit(EX_OSERR);
|
|
}
|
|
|
|
void print_command(const std::vector<char *> &argv, bool active) {
|
|
|
|
if (!active) printf("# ");
|
|
for (auto cp : argv) {
|
|
if (cp) printf("%s ", cp);
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
void print_command(const std::vector<std::string> &argv, bool active) {
|
|
|
|
if (!active) printf("# ");
|
|
for (const auto &cp : argv) {
|
|
printf("%s ", cp.c_str());
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
|
|
|
|
int launch_command(std::vector<char *> &argv) {
|
|
|
|
int pid;
|
|
|
|
// parse command-line
|
|
// launch command.
|
|
// wait for a return status.
|
|
//puts(cmd.c_str());
|
|
|
|
bool active = (if_status == 0);
|
|
|
|
print_command(argv, active);
|
|
|
|
if (!active) return 0;
|
|
if (dry_run) {
|
|
printf("\n");
|
|
return 0;
|
|
}
|
|
|
|
pid = fork();
|
|
if (pid < 0) {
|
|
perror("fork: ");
|
|
exit(EX_OSERR);
|
|
}
|
|
|
|
if (pid == 0) {
|
|
execvp(argv.front(), argv.data());
|
|
perror("execvp: ");
|
|
exit(EX_OSERR);
|
|
}
|
|
|
|
for(;;) {
|
|
int status;
|
|
pid_t ok;
|
|
ok = waitpid(pid, &status, 0);
|
|
if (ok < 0) {
|
|
if (errno == EINTR) continue;
|
|
perror("waitpid:");
|
|
exit(EX_OSERR);
|
|
}
|
|
printf("\n");
|
|
|
|
if (WIFEXITED(status)) return WEXITSTATUS(status);
|
|
if (WIFSIGNALED(status)) return -1;
|
|
fprintf(stderr, "waitpid - unexpected result\n");
|
|
exit(EX_OSERR);
|
|
}
|
|
|
|
}
|
|
|
|
int launch_command(const std::vector<std::string> &argv) {
|
|
|
|
|
|
if (argv.empty()) return 0;
|
|
|
|
std::string cmd = argv[0];
|
|
lowercase(cmd);
|
|
auto iter = builtins.find(cmd);
|
|
if (iter != builtins.end()) return iter->second(argv);
|
|
|
|
std::vector<char *> cargv;
|
|
cargv.reserve(argv.size()+2);
|
|
|
|
|
|
// convert to char * for exec, add "mpw", and remove blanks.
|
|
|
|
cargv.push_back(strdup("mpw"));
|
|
for (const auto &s : argv) {
|
|
if (!s.empty()) cargv.push_back(strdup(s.c_str()));
|
|
}
|
|
|
|
// and 0-terminate.
|
|
cargv.push_back(nullptr);
|
|
|
|
int rv = launch_command(cargv);
|
|
std::for_each(cargv.begin(), cargv.end(), free);
|
|
return rv;
|
|
}
|
|
|
|
int main(int argc, char **argv) {
|
|
|
|
int pipes[2];
|
|
int ok;
|
|
int child;
|
|
|
|
#if 0
|
|
builtins.emplace("if", builtin_if);
|
|
builtins.emplace("end", builtin_end);
|
|
builtins.emplace("else", builtin_else);
|
|
builtins.emplace("set", builtin_set);
|
|
#endif
|
|
builtins = {
|
|
{"if", builtin_if},
|
|
{"end", builtin_end},
|
|
{"else", builtin_else},
|
|
{"set", builtin_set},
|
|
{"echo", builtin_echo},
|
|
};
|
|
|
|
std::vector<char *>new_argv;
|
|
new_argv.push_back((char *)"mpw");
|
|
new_argv.push_back((char *)"Make");
|
|
|
|
|
|
|
|
|
|
//new_argv.insert(new_argv.end(), argv + 1, argv + argc);
|
|
|
|
// filter out --help and --dry-run
|
|
|
|
std::copy_if(argv + 1, argv + argc, std::back_inserter(new_argv),
|
|
[](char *cp){
|
|
if (strcmp(cp, "--help") == 0) {
|
|
help();
|
|
exit(0);
|
|
return false;
|
|
}
|
|
if (strcmp(cp, "--dry-run") == 0) {
|
|
dry_run = true;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
);
|
|
|
|
|
|
ok = pipe(pipes);
|
|
if (ok < 0) {
|
|
perror("pipe: ");
|
|
}
|
|
|
|
child = fork();
|
|
if (child < 0) {
|
|
perror("fork: ");
|
|
exit(EX_OSERR);
|
|
}
|
|
|
|
if (child == 0) {
|
|
// child.
|
|
//close(STDIN_FILENO);
|
|
//close(STDOUT_FILENO);
|
|
//close(STDERR_FILENO);
|
|
|
|
ok = dup2(pipes[1], STDOUT_FILENO);
|
|
if (ok < 0) {
|
|
perror("dup2: ");
|
|
exit(EX_OSERR);
|
|
}
|
|
close(pipes[0]);
|
|
close(pipes[1]);
|
|
|
|
launch_make(new_argv); // no return.
|
|
exit(0);
|
|
}
|
|
|
|
// parent process.
|
|
// read commands from pipe[0] and execute them.
|
|
// 0xb6 is a line continuation marker.
|
|
//int fd = pipes[0];
|
|
|
|
/*
|
|
FILE *f = fdopen(pipes[0], "r");
|
|
if (!f) {
|
|
perror("fdopen: ");
|
|
exit(EX_OSERR);
|
|
}
|
|
*/
|
|
close(pipes[1]);
|
|
|
|
// prevent children from inheriting the pipe fd.
|
|
fcntl(pipes[0], F_SETFD, FD_CLOEXEC);
|
|
|
|
ok = parse_makefile(pipes[0]);
|
|
close(pipes[0]);
|
|
|
|
|
|
// return any error from make itself.
|
|
for(;;) {
|
|
int status;
|
|
int ok = waitpid(child, &status, 0);
|
|
if (ok < 0) {
|
|
if (errno == EINTR) continue;
|
|
perror("waitpid: ");
|
|
exit(EX_OSERR);
|
|
}
|
|
|
|
if (WIFEXITED(status)) {
|
|
ok = WEXITSTATUS(status);
|
|
if (ok) exit(ok);
|
|
break;
|
|
}
|
|
if (WIFSIGNALED(status))
|
|
exit(1);
|
|
|
|
fprintf(stderr, "waitpid - unexpected result\n");
|
|
exit(EX_OSERR);
|
|
}
|
|
|
|
return ok ? 2 : 0;
|
|
}
|