boxberry/src/toolchain.cc

#include "toolchain.h"

#include <stdexcept>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include "sys.h"
#include "globals.h"

namespace toolchain {

static const char *getPkgConfig() {
	static const char *pkgConfig = nullptr;
	if (pkgConfig != nullptr) {
		return pkgConfig;
	}

	pkgConfig = getenv("PKG_CONFIG");
	if (pkgConfig != nullptr) {
		return pkgConfig;
	}

	return (pkgConfig = "pkg-config");
}

static const char *getCCompiler() {
	static const char *cCompiler = nullptr;
	if (cCompiler != nullptr) {
		return cCompiler;
	}

	cCompiler = getenv("CC");
	if (cCompiler != nullptr) {
		return cCompiler;
	}

	return (cCompiler = "cc");
}

static const char *getCXXCompiler() {
	static const char *cxxCompiler = nullptr;
	if (cxxCompiler != nullptr) {
		return cxxCompiler;
	}

	cxxCompiler = getenv("CC");
	if (cxxCompiler != nullptr) {
		return cxxCompiler;
	}

	return (cxxCompiler = "g++");
}

static const char *getCompilerFor(SourceFile::FileType type) {
	switch (type) {
	case SourceFile::FileType::C:
		return getCCompiler();

	case SourceFile::FileType::CXX:
		return getCXXCompiler();

	case SourceFile::FileType::UNKNOWN:
		abort();
	}

	abort();
}

static bool isWhitespace(char ch) {
	return ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r';
}

static void parseWhitespaceSeparated(
		const std::string &input,
		std::vector<std::string> &output,
		size_t pos = 0) {
	size_t i = pos;
	while (true) {
		// Skip leading whitespace
		char ch = input[i];
		while (isWhitespace(ch) || (ch == '\\' && isWhitespace(input[i + 1]))) {
			ch = input[i += 1];
		}

		// Read non-whitespace
		std::string str;
		while (!isWhitespace(ch) && ch != '\0') {
			if (ch == '\\') {
				str += input[i + 1];
				ch = input[i += 2];
			} else {
				str += input[i];
				ch = input[i += 1];
			}
		}

		output.push_back(std::move(str));

		if (ch == '\0') {
			break;
		}
	}
}

std::string objectFilePath(
		const std::string &srcDir,
		const std::string &name,
		const std::string &outDir) {
	return outDir + '/' + srcDir + '/' + name + ".o";
}

std::string targetFilePath(
		TargetType type,
		const std::string &name,
		const std::string &outDir) {
	std::string base = outDir + '/' + name;

	switch (type) {
	case TargetType::BINARY:
		return base;
	case TargetType::SHARED_LIBRARY:
		return base + ".so";
	case TargetType::STATIC_LIBRARY:
		return base + ".a";
	}

	abort();
}

void getPkgConfigFlags(const std::vector<std::string> &pkgs, std::vector<std::string> &flags) {
	std::vector<std::string> argv;
	argv.push_back(getPkgConfig());
	argv.push_back("--cflags");
	for (auto &pkg: pkgs) {
		argv.push_back(pkg);
	}

	// Execute $(PKG_CONFIG) --cflags $(PKGS)
	std::string output;
	sys::execute(argv, &output, global::verbose >= 2);
	parseWhitespaceSeparated(output, flags);
}

void getPkgConfigLDLibs(const std::vector<std::string> &pkgs, std::vector<std::string> &flags) {
	std::vector<std::string> argv;
	argv.push_back(getPkgConfig());
	argv.push_back("--libs");
	for (auto &pkg: pkgs) {
		argv.push_back(pkg);
	}

	// Execute $(PKG_CONFIG) --libs $(PKGS)
	std::string output;
	sys::execute(argv, &output, global::verbose >= 2);
	parseWhitespaceSeparated(output, flags);
}

void getDependencies(
		const std::vector<std::string> &flags,
		SourceFile::FileType type,
		const std::string &srcDir,
		const std::string &name,
		std::vector<std::string> &deps) {
	std::string sourcePath = srcDir + "/" + name;

	std::vector<std::string> argv;

	// $(compiler)
	argv.push_back(getCompilerFor(type));

	// $(flags)
	for (auto &flag: flags) {
		argv.push_back(flag);
	}

	// -MM $<
	argv.push_back("-MM");
	argv.push_back(sourcePath);

	// Execute $(compiler) $(flags) -MM $<
	std::string output;
	sys::execute(argv, &output, global::verbose >= 2);

	size_t idx = output.find(':');
	if (idx != std::string::npos) {
		parseWhitespaceSeparated(output, deps, idx + 1);
	}
}

std::vector<std::string> getCompileCommand(
		const std::vector<std::string> &flags,
		SourceFile::FileType type,
		const std::string &srcDir,
		const std::string &name,
		const std::string &outDir) {
	std::string sourcePath = srcDir + "/" + name;
	std::string objectPath = objectFilePath(srcDir, name, outDir);

	std::vector<std::string> argv;

	// $(compiler)
	argv.push_back(getCompilerFor(type));

	// $(cflags)
	for (auto &flag: flags) {
		argv.push_back(flag.c_str());
	}

	// -o $@ -c $<
	argv.push_back("-o");
	argv.push_back(std::move(objectPath));
	argv.push_back("-c");
	argv.push_back(std::move(sourcePath));

	return argv;
}

void compile(
		const std::vector<std::string> &flags,
		SourceFile::FileType type,
		const std::string &srcDir,
		const std::string &name,
		const std::string &outDir) {
	// Ensure the output directory actually exists
	std::string destDir = outDir + "/" + srcDir;
	sys::mkdirp(destDir);

	std::vector<std::string> argv = getCompileCommand(flags, type, srcDir, name, outDir);
	sys::execute(argv, nullptr, global::verbose >= 1);
}

void link(
		const std::string &name,
		const std::vector<std::string> &ldFlags,
		const std::vector<std::string> &ldLibs,
		SourceFile::FileType type,
		TargetType targetType,
		const std::vector<std::string> &objs,
		const std::string &outDir) {
	const std::string outPath = targetFilePath(targetType, name, outDir);

	// TODO: Use ar to create STATIC_LIBRARY,
	// use GCC with -shared to make SHARED_LIBRARY

	std::vector<std::string> argv;

	// $(compiler)
	argv.push_back(getCompilerFor(type));

	// $(ldflags)
	for (auto &flag: ldFlags) {
		argv.push_back(flag);
	}

	// -o $@
	argv.push_back("-o");
	argv.push_back(outPath);

	// $(objs)
	for (auto &obj: objs) {
		argv.push_back(obj);
	}

	// $(ldlibs)
	for (auto &flag: ldLibs) {
		argv.push_back(flag);
	}

	// Execute $(compiler) $(ldflags) -o $@ $(objs) $(ldlibs)
	sys::execute(argv, nullptr, global::verbose >= 1);
}

}