321 lines
9.7 KiB
C++
321 lines
9.7 KiB
C++
#include <string>
|
|
#include <iostream>
|
|
#include <filesystem>
|
|
#include <vector>
|
|
#include <chrono>
|
|
|
|
#include <string.h>
|
|
|
|
std::string libs = "";
|
|
std::string cppflags = "";
|
|
std::string executable = "out";
|
|
std::string source_path = "";
|
|
std::string build_path = "";
|
|
|
|
std::vector<std::string> keys = {"libs", "cppflags", "executable", "sourcepath", "buildpath"};
|
|
enum tokens {LIBS, CPPFLAGS, EXECUTABLE, SOURCEPATH, BUILDPATH};
|
|
|
|
bool must_link = false;
|
|
|
|
char *getBufferFromFile(const char* filename)
|
|
{
|
|
FILE *f = fopen(filename, "rb");
|
|
fseek(f, 0, SEEK_END);
|
|
long size = ftell(f);
|
|
fseek(f, 0, SEEK_SET);
|
|
char *buffer = (char*)malloc(size+1);
|
|
fread(buffer, size, 1, f);
|
|
buffer[size] = 0;
|
|
return buffer;
|
|
}
|
|
|
|
#define IGNOREWHITESPACE while (*p!=0 && *p <= 32) { p++; }
|
|
void loadLagueirtoFile()
|
|
{
|
|
char *buffer = getBufferFromFile("lagueirtofile");
|
|
char *p = buffer;
|
|
char token[255];
|
|
while (*p!=0)
|
|
{
|
|
IGNOREWHITESPACE; // Ignore whitespace
|
|
int i=0;
|
|
while (*p>32 && *p!='=') { token[i]=*p; i++; p++; }
|
|
IGNOREWHITESPACE
|
|
if (*p=='=')
|
|
{
|
|
token[i]=0;
|
|
int tokennum = -1;
|
|
for (int j=0;j<keys.size();++j) if (keys[j]==token) tokennum = j;
|
|
if (tokennum!=-1)
|
|
{
|
|
p++;
|
|
IGNOREWHITESPACE
|
|
i=0;
|
|
while (*p!='\r' && *p!='\n' && *p!=0) { token[i]=*p; i++; p++; }
|
|
token[i]=0;
|
|
switch (tokennum)
|
|
{
|
|
case LIBS:
|
|
libs = token;
|
|
//std::cout << "LIBS: " << libs << std::endl;
|
|
break;
|
|
case CPPFLAGS:
|
|
cppflags = token;
|
|
//std::cout << "CPPFLAGS: " << cppflags << std::endl;
|
|
break;
|
|
case EXECUTABLE:
|
|
executable = token;
|
|
//std::cout << "EXECUTABLE: " << executable << std::endl;
|
|
break;
|
|
case SOURCEPATH:
|
|
source_path = token;
|
|
//std::cout << "SOURCEPATH: " << source_path << std::endl;
|
|
break;
|
|
case BUILDPATH:
|
|
build_path = token;
|
|
//std::cout << "BUILDPATH: " << build_path << std::endl;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
free(buffer);
|
|
}
|
|
|
|
std::string getFileExtension(std::string path)
|
|
{
|
|
std::size_t dotpos = path.find_last_of(".");
|
|
return dotpos <= 0 ? "" : path.substr(dotpos + 1);
|
|
}
|
|
|
|
std::string getFileNameWithoutExtension(std::string path)
|
|
{
|
|
std::size_t slashpos = path.find_last_of("/");
|
|
std::string filename = path.substr(slashpos+1);
|
|
|
|
std::size_t dotpos = filename.find_last_of(".");
|
|
if (dotpos <= 0) return filename;
|
|
|
|
return filename.substr(0, dotpos);
|
|
}
|
|
|
|
|
|
const bool textFound(char *buffer, const char *text)
|
|
{
|
|
const int strsize = strlen(text);
|
|
int i = 0;
|
|
bool equal=true;
|
|
while (equal && i<strsize)
|
|
{
|
|
if (buffer[i]!=text[i]) equal = false;
|
|
++i;
|
|
}
|
|
return equal;
|
|
}
|
|
|
|
|
|
std::vector<std::string> getIncludes(std::string filename)
|
|
{
|
|
char *buffer = getBufferFromFile(filename.c_str());
|
|
|
|
std::vector<std::string> includes;
|
|
|
|
char *p = buffer;
|
|
while (*p != 0)
|
|
{
|
|
// Ignore commented lines
|
|
if ( (*p=='/') && (*(p+1)!=0) && (*(p+1)=='/')) while( (*p != 0) && (*p != 13) ) p++;
|
|
|
|
// Ignore comment blocks
|
|
if ( (*p=='/') && (*(p+1)!=0) && (*(p+1)=='*')) {
|
|
p+=2;
|
|
while( (*p != 0) && (*p != '*') && (*(p+1)!=0) && (*(p+1)!='/') ) p++;
|
|
}
|
|
|
|
if (*p=='#')
|
|
{
|
|
if (textFound(buffer, "#include"))
|
|
{
|
|
p+=8;
|
|
while(strchr(" \t", *p)) p++; // Ignore whitespace (spaces and tabs)
|
|
if (*p == '"')
|
|
{
|
|
p++;
|
|
char *p2 = p;
|
|
while (*p2!='"' && *p2!=0 ) p2++;
|
|
if (*p2!=0) {
|
|
*p2=0;
|
|
includes.push_back(std::string(p));
|
|
p = p2+1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
p++;
|
|
}
|
|
|
|
free(buffer);
|
|
return includes;
|
|
}
|
|
|
|
std::vector<std::string> split(std::string str)
|
|
{
|
|
std::vector<std::string> strings;
|
|
char tmp[100];
|
|
int tmp_p = 0, str_p = 0;
|
|
while (str[str_p]!=0)
|
|
{
|
|
if (str[str_p]!=32)
|
|
tmp[tmp_p++] = str[str_p++];
|
|
else
|
|
{
|
|
tmp[tmp_p]=0;
|
|
strings.push_back(tmp);
|
|
tmp_p=0; while (str[str_p]==32) str_p++;
|
|
}
|
|
}
|
|
tmp[tmp_p]=0;
|
|
strings.push_back(tmp);
|
|
|
|
return strings;
|
|
}
|
|
|
|
void MaybeRecompile(std::string source_file)
|
|
{
|
|
bool must_recompile = false;
|
|
std::string object_file = build_path + "/" + getFileNameWithoutExtension(source_file)+".o";
|
|
|
|
// si el objecte no existeix, fa falta recompilar
|
|
if (!std::filesystem::exists(object_file))
|
|
{
|
|
must_recompile = true;
|
|
//std::cout << "'" << object_file << "' No existeix. ";
|
|
|
|
}
|
|
else
|
|
{
|
|
// Si sí que existeix, agafem la data de modificació
|
|
auto object_file_write_time = std::filesystem::last_write_time(object_file);
|
|
|
|
// Si la data de modificació del cpp es major que la del objecte, fa falta recompilar
|
|
auto source_file_write_time = std::filesystem::last_write_time(source_file);
|
|
if (source_file_write_time > object_file_write_time)
|
|
{
|
|
//std::cout << "'" << source_file << "' es més nou. ";
|
|
must_recompile = true;
|
|
}
|
|
else
|
|
{
|
|
// Sino, mirem els includes
|
|
auto include_files = getIncludes(source_file);
|
|
for (auto include : include_files)
|
|
{
|
|
std::filesystem::path fullpath(source_file);
|
|
auto path_without_filename = fullpath.remove_filename();
|
|
std::string src_path = path_without_filename.string();
|
|
|
|
std::string include_file = src_path + "/" + include;
|
|
if (!std::filesystem::exists(include_file))
|
|
{
|
|
std::cout << "WARNING: Include file '" << include_file << "' not found." << std::endl;
|
|
}
|
|
else
|
|
{
|
|
auto include_file_write_time = std::filesystem::last_write_time(include_file);
|
|
if (include_file_write_time > object_file_write_time)
|
|
{
|
|
//std::cout << "El include '" << include_file << "' es més nou. ";
|
|
must_recompile = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
if (must_recompile)
|
|
{
|
|
must_link = true;
|
|
//std::cout << object_file << " s'ha de reompilar" << std::endl;
|
|
std::string command = "g++ " + source_file + " " + cppflags + " -c -o " + object_file;
|
|
std::cout << command << std::endl;
|
|
|
|
std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();
|
|
system(command.c_str());
|
|
std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();
|
|
float t = float(std::chrono::duration_cast<std::chrono::microseconds>(end - begin).count())/1000000;
|
|
std::cout << "(" << t << " seconds)" << std::endl;
|
|
}
|
|
else
|
|
{
|
|
//std::cout << object_file << " està actualitzat" << std::endl;
|
|
}
|
|
}
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
if (argc>1) {
|
|
for (int i=1; i<argc; ++i) {
|
|
if (argv[i][0] == '-') {
|
|
if (strcmp(argv[i], "--clean")==0) {
|
|
system("rm -rf build");
|
|
}
|
|
} else {
|
|
std::filesystem::current_path(argv[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
loadLagueirtoFile();
|
|
|
|
std::chrono::steady_clock::time_point begin_all = std::chrono::steady_clock::now();
|
|
|
|
if (!std::filesystem::is_directory(build_path))
|
|
{
|
|
std::filesystem::create_directory(build_path);
|
|
}
|
|
|
|
auto source_paths = split(source_path);
|
|
|
|
for (auto src_path : source_paths)
|
|
{
|
|
if (!std::filesystem::is_directory(src_path))
|
|
{
|
|
if (std::filesystem::is_regular_file(src_path) && getFileExtension(src_path)=="cpp")
|
|
{
|
|
MaybeRecompile(src_path);
|
|
} else {
|
|
std::cout << "ERROR: '" << src_path <<"' does not exists." << std::endl;
|
|
exit(1);
|
|
}
|
|
} else {
|
|
std::string path = "./" + src_path;
|
|
for (const auto & entry : std::filesystem::directory_iterator(path))
|
|
{
|
|
std::string source_file = entry.path();
|
|
std::string file_extension = getFileExtension(source_file);
|
|
if (file_extension=="cpp" || file_extension=="c")
|
|
{
|
|
MaybeRecompile(source_file);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (must_link)
|
|
{
|
|
std::string command = "g++ " + build_path + "/*.o " + libs + " -o " + executable;
|
|
std::cout << command << std::endl;
|
|
if (system(command.c_str()) != 0) {
|
|
std::cout << "ABORTED!" << std::endl;
|
|
exit(1);
|
|
}
|
|
std::chrono::steady_clock::time_point end_all = std::chrono::steady_clock::now();
|
|
float t = float(std::chrono::duration_cast<std::chrono::microseconds>(end_all - begin_all).count())/1000000;
|
|
std::cout << "(" << t << " seconds)" << std::endl;
|
|
}
|
|
else
|
|
{
|
|
std::cout << "Everything is up to date. Nothing to do." << std::endl;
|
|
}
|
|
} |