pmake/src/js/core.js

if(!Array.prototype.includes) {
	Array.prototype.includes = function(v) {
		for(var i = 0; i < this.length; i++) {
			if(this[i] == v) return true;
		}

		return false;
	};
}

if(!Array.prototype.flat) {
	Array.prototype.flat = function() {
		const flat = function(acc, cur) {
			return acc.concat(cur);
		};

		return this.reduce(flat, []);
	};
}

const pmake = {
	VERSION : "0.0",
	compilers : {},
	options : {},
	options_category : {},
	projects : []
};

pmake.inherit = function(base, call) {
	const func = (function() {
		base.apply(this, arguments);

		if(call) call.apply(this, arguments);
	});

	Object.setPrototypeOf(func.prototype, base.prototype);

	return func;
};

pmake.inherited = function(base, parent) {
	var proto = base.prototype;

	while(proto) {
		if(proto == parent.prototype) return true;

		proto = Object.getPrototypeOf(proto);
	}

	return false;
};

pmake.register = function(target) {
	if(target instanceof pmake.Compiler) {
		pmake.compilers[target.target] = target;
	} else if(target instanceof pmake.Option) {
		if(!pmake.options_category[target.category]) pmake.options_category[target.category] = {};

		pmake.options_category[target.category][target.target] = target;
		pmake.options[target.target]			       = target;
	} else if(target instanceof pmake.Project) {
		pmake.projects.push(target);
	}
};

pmake.resolveProjects = function(arr, if_str) {
	var r = [];

	for(var i = 0; i < arr.length; i++) {
		var proj = arr[i];

		if((typeof proj) == "string" && pmake.projects[proj]) {
			proj = pmake.projects[proj];
		}

		if(proj instanceof pmake.Project) {
			r = r.concat(pmake.resolveProjects(proj.libraries));
			r.push(proj);
		} else if((typeof proj) == "string" && if_str) {
			r.push(if_str(proj));
		}
	}

	r = r.filter(function(item, pos) {
		return r.indexOf(item) == pos;
	});

	return r;
};

pmake.isCxx = function(src) {
	return src.endsWith(".cc") || src.endsWith(".cxx") || src.endsWith(".cpp");
};

pmake.includes = function(target) {
	function includes(x) {
		return x.includes;
	}

	const targets = pmake.resolveProjects(target.libraries);

	return targets.map(includes).flat();
};

pmake.libs = function(target, if_str) {
	function libs(x) {
		if(x instanceof pmake.LibraryProject) {
			return x.libraries.concat([ pmake.compiler.output(x) ]);
		} else if((typeof x) == "string") {
			return [ x ];
		}

		return [];
	}

	const targets = pmake.resolveProjects(target.libraries, if_str);

	return targets.map(libs).flat();
};

(function() {
const Compiler = function() {
	this.prefix = "";
};

Compiler.prototype.output = function(target) {
	if((typeof target) == "string") {
		if(target.endsWith(".c")) return target.replace(/\.c$/, ".o");
	} else if(target instanceof pmake.LibraryProject) {
		return "lib" + target.output + ".a";
	} else if(target instanceof pmake.ExecutableProject) {
		return target.output;
	}

	return target.output;
};

const POSIXCompiler = pmake.inherit(Compiler, function(target) {
	this.ar	 = "ar";
	this.cc	 = "cc";
	this.cxx = "c++";
});

POSIXCompiler.prototype.compile = function(target, obj, src) {
	function add_i(x) {
		return "-I" + x;
	}

	const includes = pmake.includes(target).map(add_i).join(" ");
	const flags    = includes + " -c -o " + obj + " " + src;

	if(src.endsWith(".c")) {
		return this.prefix + this.cc + " " + flags;
	} else if(is_cxx(src)) {
		return this.prefix + this.cxx + " " + flags;
	}

	return "";
};

POSIXCompiler.prototype.link = function(target, files) {
	if(target instanceof pmake.LibraryProject) {
		return this.prefix + this.ar + " rcs " + this.output(target) + " " + files.join(" ");
	} else if(target instanceof pmake.ExecutableProject) {
		var c	= "";
		var cxx = target.sources.filter(pmake.isCxx);
		if(!cxx || cxx.length == 0) {
			c = this.prefix + this.cc;
		} else {
			c = this.prefix + this.cxx;
		}

		function add_l(x) {
			return "-l" + x;
		}

		return this.prefix + c + " -o " + this.output(target) + " " + files.join(" ") + " " + pmake.libs(target, add_l).join(" ");
	}

	return "";
}

const Option = function() {};

const Project = function(target) {
	this.target    = target;
	this.sources   = [];
	this.includes  = [];
	this.libraries = [];
	this.output    = target;
};

Project.prototype.generate = function() {
};

const LibraryProject = pmake.inherit(Project, function(target) {
});

const ExecutableProject = pmake.inherit(Project, function(target) {
});

const InterfaceProject = pmake.inherit(Project, function(target) {
});

const File = function(filename, mode) {
	this.fp = fs.open(filename, mode);
};

File.prototype.write = function(string) {
	fs.write(this.fp, string);
};

File.prototype.close = function() {
	fs.close(this.fp);
};

pmake.Compiler		= Compiler;
pmake.POSIXCompiler	= POSIXCompiler;
pmake.Option		= Option;
pmake.Project		= Project;
pmake.LibraryProject	= LibraryProject;
pmake.ExecutableProject = ExecutableProject;
pmake.InterfaceProject	= InterfaceProject;
pmake.File		= File;
})();

/*** Option ***/
(function() {
const Compiler = new pmake.Option();

Compiler.category    = "General";
Compiler.target	     = "compiler";
Compiler.description = "Choose a compiler set; one of:";
Compiler.option	     = "VALUE";

Compiler.options = function() {
	return Object.keys(pmake.compilers);
};

Compiler.action = function(value) {
	pmake.compiler = pmake.compilers[value];
};

pmake.register(Compiler);
})();