Init

vector-of-bool · vector-of-bool · commit 4437ab9aadbd · 2017-01-03T00:06:32.000-07:00
diff --git a/.gitignore b/.gitignore
@@ -0,0 +1,2 @@
+build/
+.vscode/.cmaketools.json
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -0,0 +1,19 @@
+cmake_minimum_required(VERSION 3.6)
+project(CMRCExample)
+
+include(CMakeToolsHelpers)
+include(CMakeRC.cmake)
+
+cmrc_add_resource_library(hello hello.txt)
+add_executable(main main.cpp)
+target_link_libraries(main PRIVATE hello)
+
+include(CTest)
+enable_testing()
+add_test(main main)
+set_property(TEST main PROPERTY PASS_REGULAR_EXPRESSION "Hello, world!")
+
+add_executable(flower flower.cpp)
+target_link_libraries(flower PRIVATE hello)
+add_test(flower flower ${CMAKE_CURRENT_SOURCE_DIR}/flower.jpg)
+cmrc_add_resources(hello flower.jpg)
diff --git a/CMakeRC.cmake b/CMakeRC.cmake
@@ -0,0 +1,234 @@
+if(_CMRC_GENERATE_MODE)
+    # Read in the digits
+    file(READ "${INPUT_FILE}" bytes HEX)
+    # Format each pair into a character literal
+    string(REGEX REPLACE "(..)" "'\\\\x\\1', " chars "${bytes}")
+    file(WRITE "${OUTPUT_FILE}" "
+namespace { const char file_array[] = { ${chars} }; }
+namespace cmrc { namespace ${LIBRARY} { namespace res_chars {
+extern const char* const ${SYMBOL}_begin = file_array;
+extern const char* const ${SYMBOL}_end = file_array + sizeof(file_array);
+}}}
+")
+    return()
+endif()
+
+if(COMMAND cmrc_add_resource_library)
+    # CMakeRC has already been included! Don't do anything
+    return()
+endif()
+
+set(this_script "${CMAKE_CURRENT_LIST_FILE}")
+
+set(CMRC_INCLUDE_DIR "${CMAKE_BINARY_DIR}/_cmrc/include" CACHE INTERNAL "Directory for CMakeRC include files")
+# Let's generate the primary include file
+file(MAKE_DIRECTORY "${CMRC_INCLUDE_DIR}/cmrc")
+file(WRITE "${CMRC_INCLUDE_DIR}/cmrc/cmrc.hpp" [==[
+#ifndef CMRC_CMRC_HPP_INCLUDED
+#define CMRC_CMRC_HPP_INCLUDED
+
+#include <string>
+#include <map>
+#include <mutex>
+
+#define CMRC_INIT(libname) \
+    do { \
+        extern void cmrc_init_resources_##libname(); \
+        cmrc_init_resources_##libname(); \
+    } while (0)
+
+namespace cmrc {
+
+class resource {
+    const char* _begin = nullptr;
+    const char* _end = nullptr;
+public:
+    const char* begin() const { return _begin; }
+    const char* end() const { return _end; }
+
+    resource() = default;
+    resource(const char* beg, const char* end) : _begin(beg), _end(end) {}
+};
+
+using resource_table = std::map<std::string, resource>;
+
+namespace detail {
+
+inline resource_table& table_instance() {
+    static resource_table table;
+    return table;
+}
+
+inline std::mutex& table_instance_mutex() {
+    static std::mutex mut;
+    return mut;
+}
+
+// We restrict access to the resource table through a mutex so that multiple
+// threads can access it safely.
+template <typename Func>
+inline auto with_table(Func fn) -> decltype(fn(std::declval<resource_table&>())) {
+    std::lock_guard<std::mutex> lk{ table_instance_mutex() };
+    return fn(table_instance());
+}
+
+}
+
+inline resource open(const char* fname) {
+    return detail::with_table([fname](const resource_table& table) {
+        auto iter = table.find(fname);
+        if (iter == table.end()) {
+            return resource {};
+        }
+        return iter->second;
+    });
+}
+
+inline resource open(const std::string& fname) {
+    return open(fname.data());
+}
+
+}
+
+#endif // CMRC_CMRC_HPP_INCLUDED
+]==])
+
+add_library(cmrc-base INTERFACE)
+target_include_directories(cmrc-base INTERFACE "${CMRC_INCLUDE_DIR}")
+target_compile_features(cmrc-base INTERFACE cxx_nullptr)
+set_property(TARGET cmrc-base PROPERTY INTERFACE_CXX_EXTENSIONS OFF)
+add_library(cmrc::base ALIAS cmrc-base)
+
+function(cmrc_add_resource_library name)
+    # Generate the identifier for the resource library's namespace
+    string(MAKE_C_IDENTIFIER "${name}" libident)
+    # Generate a library with the compiled in character arrays.
+    set(cpp_content [=[
+        #include <cmrc/cmrc.hpp>
+        #include <map>
+
+        namespace cmrc { namespace %{libident} {
+
+        namespace res_chars {
+        // These are the files which are available in this resource library
+        $<JOIN:$<TARGET_PROPERTY:%{libname},CMRC_EXTERN_DECLS>,
+        >
+        }
+
+        inline void load_resources() {
+            // This initializes the list of resources and pointers to their data
+            static std::once_flag flag;
+            std::call_once(flag, [] {
+                cmrc::detail::with_table([](resource_table& table) {
+                    $<JOIN:$<TARGET_PROPERTY:%{libname},CMRC_TABLE_POPULATE>,
+                    >
+                });
+            });
+        }
+
+        namespace {
+            extern struct resource_initializer {
+                resource_initializer() {
+                    load_resources();
+                }
+            } dummy;
+        }
+
+        }}
+
+        // The resource library initialization function. Intended to be called
+        // before anyone intends to use any of the resource defined by this
+        // resource library
+        extern void cmrc_init_resources_%{libident}() {
+            cmrc::%{libident}::load_resources();
+        }
+    ]=])
+    get_filename_component(libdir "${CMAKE_CURRENT_BINARY_DIR}/${name}" ABSOLUTE)
+    get_filename_component(libcpp "${libdir}/lib.cpp" ABSOLUTE)
+    string(REPLACE "%{libname}" "${name}" cpp_content "${cpp_content}")
+    string(REPLACE "%{libident}" "${libident}" cpp_content "${cpp_content}")
+    string(REPLACE "\n        " "\n" cpp_content "${cpp_content}")
+    file(GENERATE OUTPUT "${libcpp}" CONTENT "${cpp_content}")
+    # Generate the actual static library. Each source file is just a single file
+    # with a character array compiled in containing the contents of the
+    # corresponding resource file.
+    add_library(${name} STATIC ${libcpp})
+    target_link_libraries(${name} PUBLIC cmrc::base)
+    set_property(TARGET ${name} PROPERTY CMRC_IS_RESOURCE_LIBRARY TRUE)
+    cmrc_add_resources(${name} ${ARGN})
+endfunction()
+
+function(cmrc_add_resources name)
+    get_target_property(is_reslib ${name} CMRC_IS_RESOURCE_LIBRARY)
+    if(NOT TARGET ${name} OR NOT is_reslib)
+        message(SEND_ERROR "cmrc_add_resources called on target '${name}' which is not an existing resource library")
+        return()
+    endif()
+
+    set(options)
+    set(args WHENCE PREFIX)
+    set(list_args)
+    cmake_parse_arguments(PARSE_ARGV 1 ARG "${options}" "${args}" "${list_args}")
+
+    if(NOT ARG_WHENCE)
+        set(ARG_WHENCE ${CMAKE_CURRENT_SOURCE_DIR})
+    endif()
+
+    # Generate the identifier for the resource library's namespace
+    string(MAKE_C_IDENTIFIER "${name}" libident)
+
+    foreach(input IN LISTS ARG_UNPARSED_ARGUMENTS)
+        get_filename_component(abs_input "${input}" ABSOLUTE)
+        # Generate a filename based on the input filename that we can put in
+        # the intermediate directory.
+        file(RELATIVE_PATH relpath "${ARG_WHENCE}" "${abs_input}")
+        if(relpath MATCHES "^\\.\\.")
+            # For now we just error on files that exist outside of the soure dir.
+            message(SEND_ERROR "Cannot add file '${input}': File must be in a subdirectory of ${ARG_WHENCE}")
+            continue()
+        endif()
+        get_filename_component(abspath "${libdir}/intermediate/${relpath}.cpp" ABSOLUTE)
+        # Generate a symbol name relpath the file's character array
+        _cm_encode_fpath(sym "${relpath}")
+        # Generate the rule for the intermediate source file
+        _cmrc_generate_intermediate_cpp(${libident} ${sym} "${abspath}" "${abs_input}")
+        target_sources(${name} PRIVATE ${abspath})
+        set_property(TARGET ${name} APPEND PROPERTY CMRC_EXTERN_DECLS
+            "// Pointers to ${input}"
+            "extern const char* const ${sym}_begin\;"
+            "extern const char* const ${sym}_end\;"
+            )
+        if(ARG_PREFIX AND NOT ARG_PREFIX MATCHES "/$")
+            set(ARG_PREFIX "${ARG_PREFIX}/")
+        endif()
+        set_property(TARGET ${name} APPEND PROPERTY CMRC_TABLE_POPULATE
+            "// Table entry for ${input}"
+            "table.emplace(\"${ARG_PREFIX}${relpath}\", resource{res_chars::${sym}_begin, res_chars::${sym}_end})\;"
+            )
+    endforeach()
+endfunction()
+
+function(_cmrc_generate_intermediate_cpp libname symbol outfile infile)
+    add_custom_command(
+        # This is the file we will generate
+        OUTPUT "${outfile}"
+        # These are the primary files that affect the output
+        DEPENDS "${infile}" "${this_script}"
+        COMMAND
+            "${CMAKE_COMMAND}"
+                -D_CMRC_GENERATE_MODE=TRUE
+                -DLIBRARY=${libname}
+                -DSYMBOL=${symbol}
+                "-DINPUT_FILE=${infile}"
+                "-DOUTPUT_FILE=${outfile}"
+                -P "${this_script}"
+        COMMENT "Generating intermediate file for ${infile}"
+    )
+endfunction()
+
+function(_cm_encode_fpath var fpath)
+    string(MAKE_C_IDENTIFIER "${fpath}" ident)
+    string(MD5 hash "${fpath}")
+    string(SUBSTRING "${hash}" 0 4 hash)
+    set(${var} f_${hash}_${ident} PARENT_SCOPE)
+endfunction()
diff --git a/flower.cpp b/flower.cpp
@@ -0,0 +1,36 @@
+#include <cmrc/cmrc.hpp>
+
+#include <algorithm>
+#include <fstream>
+#include <iterator>
+#include <iostream>
+
+
+int main(int argc, char** argv) {
+    if (argc != 2) {
+        std::cerr << "Invalid arguments passed to flower\n";
+        return 2;
+    }
+    std::cout << "Reading flower from " << argv[1] << '\n';
+    std::ifstream flower_fs{ argv[1], std::ios_base::binary };
+    if (!flower_fs) {
+        std::cerr << "Invalid filename passed to flower: " << argv[1] << '\n';
+        return 2;
+    }
+
+    using iter = std::istreambuf_iterator<char>;
+    const auto fs_size = std::distance(iter(flower_fs), iter());
+    flower_fs.seekg(0);
+
+    CMRC_INIT(hello);
+    auto flower_rc = cmrc::open("flower.jpg");
+    const auto rc_size = std::distance(flower_rc.begin(), flower_rc.end());
+    if (rc_size != fs_size) {
+        std::cerr << "Flower file sizes do not match: FS == " << fs_size << ", RC == " << rc_size << "\n";
+        return 1;
+    }
+    if (!std::equal(flower_rc.begin(), flower_rc.end(), iter(flower_fs))) {
+        std::cerr << "Flower file contents do not match\n";
+        return 1;
+    }
+}
diff --git a/flower.jpg b/flower.jpg
diff --git a/hello.txt b/hello.txt
@@ -0,0 +1 @@
+Hello, world!
diff --git a/main.cpp b/main.cpp
@@ -0,0 +1,9 @@
+#include <cmrc/cmrc.hpp>
+
+#include <iostream>
+
+int main() {
+  CMRC_INIT(hello);
+  auto data = cmrc::open("hello.txt");
+  std::cout << std::string(data.begin(), data.end()) << '\n';
+}
