boxberry/cmd/main.cc

#include <getopt.h>
#include <string.h>
#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <utility>
#include <stdexcept>

#include "BXParser.h"
#include "parallel.h"
#include "toolchain.h"
#include "globals.h"
#include "logger.h"
#include "sys.h"
#include "build.h"
#include "compdb.h"

struct Conf {
	std::vector<std::string> args;
	std::vector<std::string> args2;
	std::vector<std::pair<std::string, std::string>> kvargs;
	bool exec = false;
};

static void run(Conf conf) {
	std::string op;
	std::string path;

	if (conf.args.size() == 0) {
		op = "build";
		path = "./bx-out";
	} else if (conf.args[0][0] == '.' || conf.args[0][0] == '/') {
		op = "build";
		path = conf.args[0];
	} else if (conf.args.size() == 1) {
		op = conf.args[0];
		path = "./bx-out";
	} else if (conf.args.size() == 2) {
		op = conf.args[0];
		path = conf.args[1];
	} else {
		// TODO: Print usage instead?
		throw std::runtime_error("Incorrect number of arguments");
	}

	sys::mkdirp(path);

	auto buildVariables = [&]() -> BXVariables {
		BXVariables variables;
		if (sys::fileExists(path + "/.config.bx")) {
			bufio::IFStream f(path + "/.config.bx");
			BXParser parser(f);
			parser.parse(variables);
		}

		for (auto &pair: conf.kvargs) {
			bufio::ISStream ss(pair.second);
			BXParser parser(ss);
			auto &list = variables[pair.first];
			list.clear();
			parser.parseList(variables, list);
		}

		if (conf.kvargs.size() > 0) {
			bufio::OFStream f(path + "/.config.bx");
			BXWriter w(f);
			w.write(variables);
		}

		return variables;
	};

	auto buildTree = [&](BXVariables vars) -> std::unique_ptr<DepNode> {
		return build::buildDepTree(path, std::move(vars));
	};

	auto buildCompileCommands = [&](DepNode &root) {
		bufio::OFStream f(path + "/compile_commands.json");
		compdb::Writer w(f);
		root.writeCompDB(path, w);
		sys::symlink(path + "/compile_commands.json", "compile_commands.json");
	};

	if (op == "build") {
		auto vars = buildVariables();
		std::string targetName = build::findTargetName(vars);
		auto root = buildTree(vars);
		buildCompileCommands(*root);

		if (root->hasChanged(path)) {
			root->startBuild(path);
			root->joinBuild();
		} else {
			logger::log("Nothing to do.");
		}

		if (conf.exec) {
			std::vector<std::string> argv;
			argv.reserve(conf.args2.size() + 1);
			argv.push_back(path + '/' + targetName);
			for (const auto &arg: conf.args2) {
				argv.push_back(std::move(arg));
			}

			try {
				sys::ProcConf conf;
				conf.forwardSignals = true;
				sys::execute(argv, conf);
			} catch (std::exception &ex) {
				logger::log(ex.what());
			}
		}

	} else if (op == "config") {
		BXVariables variables = buildVariables();

		printf("%s:\n", (path + "/.config.bx").c_str());
		if (variables.size() == 0) {
			printf("No config options set.\n");
		}
		for (auto &pair: variables) {
			printf("%s:", pair.first.c_str());
			for (auto &val: pair.second) {
				printf(" %s", val.c_str());
			}
			printf("\n");
		}

	} else if (op == "compile-commands") {
		buildCompileCommands(*buildTree(buildVariables()));

	} else if (op == "clean") {
		// TODO: Remove what's needed, instead of removing everything and
		// re-creating .config.bx
		BXVariables variables = buildVariables();
		sys::rmrf(path);
		sys::rmrf("compile_commands.json");
		sys::mkdirp(path);
		bufio::OFStream f(path + "/.config.bx");
		BXWriter w(f);
		w.write(variables);

	} else {
		throw std::runtime_error("Unknown operation '" + op + "'");
	}
}

int main(int argc, char **argv) {
	int jobs = parallel::coreCount() * 1.2 + 2;
	Conf conf;
	std::string workDir = "";
	std::string target = "";

	const char *shortopts = "hvj:C:";
	const struct option opts[] = {
		{ "help",             no_argument,       NULL, 'h' },
		{ "verbose",          no_argument,       NULL, 'v' },
		{ "jobs",             required_argument, NULL, 'j' },
		{ "directory",        required_argument, NULL, 'C' },
		{ "run",              no_argument,       NULL, 'R' },
		{},
	};

	const char usage[] =
		"Usage: %s [options...] [build | config | compile-commands | clean] [path]\n"
		"\n"
		"  -h, --help              "
			"Show this help text.\n"
		"  -v, --verbose           "
			"Show every command as it's executing.\n"
		"  -j, --jobs <count>      "
			"Set the number of jobs run simultaneously. "
			"Default: the number of cores in the machine.\n"
		"  -C, --directory <dir>   "
			"Change directory before doing anything else.\n"
		"  -R, --run <args...>     "
			"Run executable after building.\n";

	// Parse options from argv
	bool parsingOpts = true;
	while (parsingOpts) {
		int optidx;
		int c = getopt_long(argc, argv, shortopts, opts, &optidx);

		if (c < 0) {
			break;
		}

		switch (c) {
			case 'h':
				printf(usage, argv[0]);
				return 0;

			case 'v':
				global::verbose += 1;
				break;

			case 'j':
				jobs = atoi(optarg);
				if (jobs <= 0) {
					fprintf(stderr, "Can't run %i jobs.\n", jobs);
					return 1;
				}
				break;

			case 'C':
				workDir = optarg;
				break;

			case 'R':
				conf.exec = true;
				parsingOpts = false;
				for (; optind < argc; ++optind) {
					conf.args2.push_back(argv[optind]);
				}
				break;

			default:
				printf("Unknown option: '%c'.\n", (char)c);
				printf(usage, argv[0]);
				return 1;
		}
	}

	parallel::ParallelContext par = parallel::init(jobs);

	// Change directory?
	if (workDir.size() > 0) {
		fprintf(stderr, "Entering directory '%s'\n", workDir.c_str());
		sys::chdir(workDir);
	}

	// Find args and keyword args
	for (; optind < argc; ++optind) {
		char *arg = argv[optind++];
		char *eq = strchr(arg, '=');
		if (eq == nullptr) {
			conf.args.push_back(arg);
		} else {
			conf.kvargs.push_back(std::make_pair(
					std::string(arg, eq - arg), std::string(eq + 1)));
		}
	}

	run(std::move(conf));
}