hash.cpp

Go to the documentation of this file.

 
// C++ libraries
#include "fstream"
#include "iostream"
#include "regex"
#include "sstream"
#include "string"
#include "vector"
// CBuild headers
#include "../../headers/CBuild_defs.hpp"
#include "../../headers/build_data.hpp"
#include "../../headers/filesystem++.hpp"
#include "../../headers/hash.hpp"
#include "../../headers/map.hpp"
#include "../../headers/optional.hpp"
#include "../../headers/print.hpp"
// Code
/* namespace CBuild */
namespace CBuild {
namespace consts {
std::regex cxx_line_comment("//.*");
std::regex c_multiline_comment("/\\*([\\s\\S]*?)\\*/");
std::regex doxygen_comment("/\\*\\*([\\s\\S]*?)\\*/");
std::regex include_parser("#include\\s+[\"<]([^\">]+)[\">]");
std::regex check_type("\\.(cpp|cxx|cc|c)");
} // namespace consts
namespace types {
struct file {
    std::string abs_path;
    std::vector<CBuild::types::file> includes;
    uint64_t hash_new;
    lib::optional<uint64_t> hash_old;
    bool cpp;
    bool change;
    std::string object;
    file(std::string path) {
        this->change = false;
        this->hash_new = 0;
        this->hash_old.clear();
        this->abs_path = path;
        this->includes.clear();
        if (std::regex_search(this->abs_path, CBuild::consts::check_type)) {
            this->cpp = true;
        } else {
            this->cpp = false;
        }
        this->object = "";
    }
};
struct file_content {
    std::string content;
    std::string path;
    std::vector<std::string> includes;
};
} // namespace types
namespace vars {
std::vector<CBuild::types::file> filelist;
lib::map<std::string, uint64_t> headers;
lib::map<std::string, uint64_t> old_hashes;
} // namespace vars
CBuild::types::file_content get_file_data(std::string path, std::string included_from = "") {
    // Return variable
    std::string p = path;
    // Set path to file
    included_from = CBuild::fs::base(included_from);
    try {
        p = CBuild::fs::normalize_relative_path(path);
    } catch (const std::exception& e) {
        CBuild::print_full(std::string("Error in path creation, path - \"") + path +
                               std::string("\", included_from - \"") + included_from +
                               std::string("\""),
                           CBuild::RED);
        exit(0xFF);
    }
    CBuild::types::file_content f;
    f.path = p;
    // Load file content to string
    std::ifstream file(path);
    std::stringstream buff;
    buff << file.rdbuf();
    file.close();
    std::string str = buff.str();
    // Strip comments from file
    str = std::regex_replace(str, CBuild::consts::cxx_line_comment, "");
    str = std::regex_replace(str, CBuild::consts::c_multiline_comment, "");
    str = std::regex_replace(str, CBuild::consts::doxygen_comment, "");
    f.content = str;
    // Get includes
    std::smatch match;
    std::string::const_iterator start(str.cbegin());
    // Base file path
    std::string base = CBuild::fs::base(path);
    while (std::regex_search(start, str.cend(), match, CBuild::consts::include_parser)) {
        // Get file
        std::string head = match[1];
        bool err = false;
        // Convert to CBuild.run-relative path
        try {
            head = CBuild::fs::normalize_relative_path(head, base);
        } catch (const std::exception& e) {
        }
        // Check for system includes
        err = !CBuild::fs::exists(head);
        // Push path, if it is project include
        if (!err) {
            f.includes.push_back(head);
        }
        start = match.suffix().first;
    }
    return f;
}
// /**
//  * @brief djb2 hashing function for std::string
//  *
//  * @param str => std::string -> Input string
//  * @return uint64_t -> Hash of data
//  */
// uint64_t hash(std::string str) {
//   uint64_t hash = 5381;
//   for (auto ch : str) {
//     hash = ((hash << 5) + hash) + ch;
//   }
//   return hash;
// }
uint64_t hash(std::string str) {
    uint64_t hash = 14695981039346656037ULL;
    for (char c : str) {
        hash ^= static_cast<uint64_t>(c);
        hash *= 1099511628211ULL;
    }
    return hash;
}
void procces_files(std::vector<std::string> files, std::vector<std::string> objects,
                   std::string toolchain_id) {
    CBuild::print_full("\t\t\tCBuild hash v3.0", CBuild::color::MAGENTA);
    // For every input file
    for (size_t i = 0; i < files.size(); i++) {
        std::string file, object;
        file = files.at(i);
        object = objects.at(i);
        // Get file data
        auto data = CBuild::get_file_data(file);
        auto cpp = CBuild::types::file(data.path);
        cpp.object = object;
        //  Get file hash
        cpp.hash_new = CBuild::hash(data.content);
        CBuild::print_full("Calculating hash for \"" + cpp.abs_path + "\"", CBuild::color::GREEN);
        CBuild::print_full("Need to calculate hash...", CBuild::color::RED);
        auto old = CBuild::vars::old_hashes.get(cpp.abs_path);
        if (old != NULL) {
            cpp.hash_old.set(*old);
        }
        // For every invclude
        for (auto inc : data.includes) {
            // Get file data
            auto hdata = CBuild::get_file_data(inc, cpp.abs_path);
 
            auto hpp = CBuild::types::file(hdata.path);
            // Check if hash is already stored in hash
            const uint64_t* hash = NULL;
            CBuild::print_full("Calculating hash for \"" + hpp.abs_path + "\"",
                               CBuild::color::GREEN);
            if ((hash = CBuild::vars::headers.get(hpp.abs_path)) != NULL) {
                // Use stored hash
                hpp.hash_new = *hash;
                CBuild::print_full("Using hash from cache.", CBuild::color::GREEN);
            } else {
                // Calculate file hash
                hpp.hash_new = CBuild::hash(hdata.content);
                CBuild::print_full("Need to calculate hash...", CBuild::color::RED);
            }
            auto old = CBuild::vars::old_hashes.get(hpp.abs_path);
            if (old != NULL) {
                hpp.hash_old.set(*old);
            }
            // Store hash
            try {
                CBuild::vars::headers.push_back_check(hpp.abs_path, hpp.hash_new);
            } catch (std::exception& e) {
                // So, we already have this hash, we dont need to do anything
            }
            // Store proccesed include
            cpp.includes.push_back(hpp);
        }
        // Store proccesed file
        CBuild::vars::filelist.push_back(cpp);
    }
}
void store_hash(std::string toolchain_id) {
    for (auto cpp : CBuild::vars::filelist) {
        int err = CBuild::write_file_hash(toolchain_id, cpp.abs_path, &cpp.hash_new);
        if (err == -1) {
            CBuild::fs::create({CBuild::get_file_metadata_path(toolchain_id, cpp.abs_path)},
                               CBuild::fs::FILE);
            CBuild::source_metadata_file m;
            for (auto inc : cpp.includes) {
                m.deps.push_back(inc.abs_path);
            }
            m.hash = cpp.hash_new;
            m.source = cpp.abs_path;
            m.object = cpp.object;
            CBuild::write_file_metadata(toolchain_id, cpp.abs_path, &m);
        }
    }
    for (auto hpp : CBuild::vars::headers) {
        int err = CBuild::write_file_hash(toolchain_id, hpp.key, &hpp.data);
        if (err == -1) {
            CBuild::fs::create({CBuild::get_file_metadata_path(toolchain_id, hpp.key)},
                               CBuild::fs::FILE);
            CBuild::source_metadata_file m;
            m.hash = hpp.data;
            m.deps = {};
            m.source = hpp.key;
            m.object = "header";
            CBuild::write_file_metadata(toolchain_id, hpp.key, &m);
        }
    }
}
void load_hash(std::string toolchain_id) {
    std::string path = CBUILD_BUILD_DIR + "/" + toolchain_id + "/" + CBUILD_METADATA_FOLDER + "/";
    auto files = CBuild::fs::dir(path, ".*\\.meta");
    for (auto f : files) {
        CBuild::source_metadata_file m;
        CBuild::read_file_metadata_direct(toolchain_id, f, &m);
        auto file = m.source;
        auto hash = m.hash;
        try {
            CBuild::vars::old_hashes.push_back_check(file, hash);
        } catch (std::exception& e) {
            CBuild::print_full(std::string("Error, multiple metadata files found for file ") + file,
                               CBuild::RED);
        }
    }
    // std::string path =
    //     CBUILD_BUILD_DIR + "/" + toolchain_id + "/" + CBUILD_HASH_DIR + "/" + CBUILD_HASH_FILE;
    // if (!CBuild::fs::exists(path)) {
    //     return;
    // }
    // std::ifstream file(path);
    // std::string line;
    // while (std::getline(file, line)) {
    //     std::istringstream iss(line);
    //     std::string key;
    //     uint64_t value;
    //     iss >> key >> std::hex >> value;
 
    //     try {
    //         CBuild::vars::old_hashes.push_back_check(key, value);
    //     } catch (const std::exception& e) {
    //         // Maybe we have some previvous errors, and somehowe we have two
    //         // simmilar hashes, so, save only first, in future we fix this by
    //         // fully recreating file
    //     }
    // }
    // file.close();
}
} // namespace CBuild
/* hash.hpp */
void CBuild::print_files() {
    CBuild::print_full("\t\t\tCBuild hash v3.0 - Filelist", CBuild::color::MAGENTA);
    std::stringstream buff;
    for (auto file : CBuild::vars::filelist) {
        buff << "\t\t" << file.abs_path << "\n"
             << std::hex << "New hash: " << file.hash_new << ", old hash: ";
        if (file.hash_old.is()) {
            buff << std::hex << file.hash_old.get() << "\n";
        } else {
            buff << " null\n";
        }
        CBuild::print_full(buff.str());
        buff.str("");
        for (auto hfile : file.includes) {
            buff << "\t\t\t" << hfile.abs_path << "\n"
                 << std::hex << "\tNew hash: " << hfile.hash_new << ", old hash: ";
            if (hfile.hash_old.is()) {
                buff << std::hex << hfile.hash_old.get() << "\n";
            } else {
                buff << " null\n";
            }
            CBuild::print_full(buff.str());
            buff.str("");
        }
    }
}
std::vector<std::string> CBuild::get_files(std::vector<std::string> files,
                                           std::vector<std::string> objects,
                                           std::string toolchain_id) {
    // Variables
    std::vector<std::string> ret;
    // Gather all file info and relevant hashes
    CBuild::load_hash(toolchain_id);
    CBuild::procces_files(files, objects, toolchain_id);
    CBuild::store_hash(toolchain_id);
    CBuild::print_files();
    // Check differences in hashes
    for (auto file : CBuild::vars::filelist) {
        if ((!file.hash_old.is()) || (file.hash_new != file.hash_old.get())) {
            ret.push_back(file.abs_path);
        } else {
            for (auto inc : file.includes) {
                if ((!inc.hash_old.is()) || (inc.hash_new != inc.hash_old.get())) {
                    ret.push_back(file.abs_path);
                } else {
                }
            }
        }
    }
    // Clear oll things
    CBuild::vars::headers.clear();
    CBuild::vars::filelist.clear();
    CBuild::vars::old_hashes.clear();
    // Return value
    return ret;
}