boxberry/src/main.cc

#include <unistd.h>
#include <getopt.h>
#include <dirent.h>
#include <stdexcept>
#include <string.h>
#include <errno.h>
#include <fstream>
#include <iostream>
#include <unordered_set>
#include <mutex>

#include "SourceFile.h"
#include "BBBParser.h"
#include "parallel.h"
#include "toolchain.h"
#include "globals.h"

static void readDir(std::string dir, std::vector<SourceFile> &sources,
		BBBParser::Variables vars);

static void readPath(std::string dir, std::string name,
		std::vector<SourceFile> &sources, BBBParser::Variables vars) {
	std::string path = dir + "/" + name;
	sys::FileInfo finfo = sys::fileInfo(path);

	if (finfo.isDir) {
		// We don't want to send 'files'
		BBBParser::Variables subvars = vars;
		subvars.erase("files");
		readDir(path, sources, std::move(subvars));
	} else {
		SourceFile::FileType type = SourceFile::fileTypeFrom(name);
		if (type != SourceFile::FileType::UNKNOWN) {
			sources.emplace_back(dir, name, type, vars);
		}
	}
}

static void readDir(std::string dir, std::vector<SourceFile> &sources,
		BBBParser::Variables vars) {
	std::ifstream buildFile(dir + "/build.bbb");
	std::vector<std::string> files;
	bool hasFiles = false;

	// Parse $dir/build.bbb, see if it specifies a 'files' value.
	if (buildFile.good()) {
		BBBParser parser(buildFile, BBBParser::FLAG_NONE);
		parser.parse(vars);

		auto it = vars.find("files");
		if (it != vars.end()) {
			files = it->second;
			hasFiles = true;
		}
	}

	// If build.bbb didn't specify 'files', we have to readdir
	if (!hasFiles) {
		DIR *d = opendir(dir.c_str());
		if (d == NULL) {
			throw std::runtime_error("opendir '" + dir + "': " + strerror(errno));
			return;
		}

		struct dirent *ent;
		while ((ent = readdir(d)) != NULL) {
			if (ent->d_name[0] == '.')
				continue;
			files.emplace_back(ent->d_name);
		}

		closedir(d);
	}

	// Go through files
	for (auto &ent: files) {
		std::string path = dir + "/" + ent;
		BBBParser::Variables subvars = vars;
		readPath(dir, ent, sources, vars);
	}
}

static void printState(const std::vector<SourceFile> &sources) {
	for (auto &source: sources) {
		std::cout << source.dir() << '/' << source.name() << ":\n";
		for (auto &kv: source.vars()) {
			std::cout << "    " << kv.first << ":\n";
			for (auto &val: kv.second) {
				std::cout << "        " << val << '\n';
			}
		}
	}
}

static bool compile(const std::vector<SourceFile> &sources, const std::string &outDir, int jobs) {
	bool compiled = false;
	std::mutex mut;
	parallel::parallel(jobs, sources, [&](const SourceFile &source) {
		if (source.needsRecompile(outDir)) {
			source.compile(outDir);
			mut.lock();
			compiled = true;
			mut.unlock();
		}
	});

	return compiled;
}

static void link(
		const std::vector<SourceFile> &sources,
		const std::string &outDir, const std::string &name,
		toolchain::TargetType targetType) {
	std::cerr << "Link " << outDir << '/' << name << '\n';

	std::vector<std::string> ldFlags;
	std::unordered_set<std::string> ldFlagsSet;
	std::vector<std::string> ldLibs;
	std::unordered_set<std::string> ldLibsSet;
	std::vector<std::string> objects;

	SourceFile::FileType type = SourceFile::FileType::C;

	// Gather ldflags, ldlibs and objects from sources
	std::vector<std::string> flags;
	for (auto &source: sources) {
		if (source.type() != SourceFile::FileType::C) {
			type = source.type();
		}

		flags = source.ldFlags();
		for (auto &flag: flags) {
			if (flag[0] == '-' && flag[1] == 'l') {
				std::cerr << "Warning: -l flags should go in ldlibs "
					<< "(at " << source.path() << ": " << flag << ")\n";
			}

			auto it = ldFlagsSet.find(flag);
			if (it == ldFlagsSet.end()) {
				ldFlagsSet.emplace(flag);
				ldFlags.push_back(std::move(flag));
			}
		}

		flags = source.ldLibs();
		for (auto &flag: flags) {
			auto it = ldLibsSet.find(flag);
			if (it == ldLibsSet.end()) {
				ldLibsSet.emplace(flag);
				ldLibs.push_back(std::move(flag));
			}
		}

		objects.push_back(std::move(source.objectPath(outDir)));
	}

	flags.clear();

	toolchain::link(name, ldFlags, ldLibs, type, targetType, objects, outDir);
}

static bool compileAndLink(
		const std::vector<SourceFile> &sources, const std::string &outDir,
		int jobs, const std::string &target, toolchain::TargetType targetType) {
	std::string targetPath = toolchain::targetFilePath(targetType, target, outDir);

	if (compile(sources, outDir, jobs) || !sys::fileExists(targetPath)) {
		link(sources, outDir, target, targetType);
		return true;
	}

	return false;
}

int main(int argc, char **argv) {
	std::vector<std::string> srcDirs;
	std::string outDir = "bbbuild";
	int jobs = parallel::coreCount();
	std::string workDir = "";
	std::string target = "";

	enum class Action {
		BUILD, PRINT_STATE,
	};
	Action action = Action::BUILD;

	const char *shortopts = "hvo:j:C:t:p";
	const struct option opts[] = {
		{ "help",        no_argument,       NULL, 'h' },
		{ "verbose",     no_argument,       NULL, 'v' },
		{ "output",      required_argument, NULL, 'o' },
		{ "jobs",        required_argument, NULL, 'j' },
		{ "directory",   required_argument, NULL, 'C' },
		{ "target",      required_argument, NULL, 't' },
		{ "print-state", no_argument,       NULL, 'p' },
		{},
	};

	const char usage[] =
		"Usage: bbbuild [options...] [sources]\n"
		"\n"
		"  -h, --help             "
			"Show this help text.\n"
		"  -v, --verbose          "
			"Show every command as it's executing."
		"  -o, --output <dir>     "
			"Set output directory. Default: bbbuild\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"
		"  -t, --target <name>    "
			"Set the name of the executable.\n"
		"  -p, --print-state      "
			"Print the state instead of building.\n";

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

		if (c < 0) {
			break;
		}

		switch (c) {
			case 'h':
				puts(usage);
				return 0;

			case 'v':
				global::verbose = true;
				break;

			case 'o':
				outDir = optarg;
				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 't':
				target = optarg;
				break;

			case 'p':
				action = Action::PRINT_STATE;
				break;

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

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

		if (chdir(workDir.c_str()) < 0) {
			perror(workDir.c_str());
			return 1;
		}
	}

	// TODO: Read this from build.bbb
	if (target.size() == 0) {
		target = "target";
	}

	// Parse non-opt argv as source dirs
	if (optind < argc) {
		while (optind < argc) {
			srcDirs.push_back(argv[optind++]);
		}
	} else {
		srcDirs.push_back(".");
	}

	// Read configs from source dirs
	std::vector<SourceFile> sources;
	for (std::string &dir: srcDirs) {
		readDir(dir, sources, {});
	}

	switch (action) {
	case Action::BUILD:
		// TODO: Support more types than BINARY
		if (!compileAndLink(sources, outDir, jobs, target, toolchain::TargetType::BINARY)) {
			std::cerr << "Nothing to do.\n";
		}
		break;

	case Action::PRINT_STATE:
		printState(sources);
		break;
	}
}