From 149824d9baf134db379d03898e92e9a4707ddd41 Mon Sep 17 00:00:00 2001 From: TinyAtoms Date: Mon, 28 Mar 2022 11:34:05 -0300 Subject: [PATCH] feat: :art: repo is more cluttered --- .../api/v1/query/client-vscode/query.json | 1 + .../reply/cache-v2-397ae5ffd5bdf312f93f.json | 1179 +++++++++++++++++ .../codemodel-v2-37f6a47c2b317e96ed6f.json | 59 + .../reply/index-2022-03-28T14-19-21-0832.json | 110 ++ ...irror-test-Debug-21bf0dc542351963f7de.json | 109 ++ .../toolchains-v1-e830cc8b3da0141de6d1.json | 53 + build/.ninja_deps | Bin 0 -> 12220 bytes build/.ninja_log | 5 + build/CMakeCache.txt | 363 +++++ .../CMakeCXXCompiler.cmake | 91 ++ .../CMakeDetermineCompilerABI_CXX.bin | Bin 0 -> 17408 bytes .../CMakeRCCompiler.cmake | 6 + .../3.20.21032501-MSVC_2/CMakeSystem.cmake | 15 + .../CompilerIdCXX/CMakeCXXCompilerId.cpp | 734 ++++++++++ .../CompilerIdCXX/CMakeCXXCompilerId.o | Bin 0 -> 2264 bytes build/CMakeFiles/CMakeError.log | 11 + build/CMakeFiles/CMakeOutput.log | 154 +++ build/CMakeFiles/ShowIncludes/foo.h | 1 + build/CMakeFiles/ShowIncludes/main.c | 2 + build/CMakeFiles/TargetDirectories.txt | 3 + build/CMakeFiles/cmake.check_cache | 1 + build/CMakeFiles/feature_tests.bin | Bin 0 -> 18944 bytes build/CMakeFiles/feature_tests.cxx | 398 ++++++ build/CMakeFiles/mirror-test.dir/main.cpp.obj | Bin 0 -> 23799 bytes build/CMakeFiles/rules.ninja | 64 + build/build.ninja | 144 ++ build/cmake_install.cmake | 49 + build/compile_commands.json | 7 + build/mirror-test.exe | Bin 0 -> 21504 bytes build/mirror-test.pdb | Bin 0 -> 385024 bytes main.cpp | 2 +- randomtext.txt | 1 + 32 files changed, 3561 insertions(+), 1 deletion(-) create mode 100644 build/.cmake/api/v1/query/client-vscode/query.json create mode 100644 build/.cmake/api/v1/reply/cache-v2-397ae5ffd5bdf312f93f.json create mode 100644 build/.cmake/api/v1/reply/codemodel-v2-37f6a47c2b317e96ed6f.json create mode 100644 build/.cmake/api/v1/reply/index-2022-03-28T14-19-21-0832.json create mode 100644 build/.cmake/api/v1/reply/target-mirror-test-Debug-21bf0dc542351963f7de.json create mode 100644 build/.cmake/api/v1/reply/toolchains-v1-e830cc8b3da0141de6d1.json create mode 100644 build/.ninja_deps create mode 100644 build/.ninja_log create mode 100644 build/CMakeCache.txt create mode 100644 build/CMakeFiles/3.20.21032501-MSVC_2/CMakeCXXCompiler.cmake create mode 100644 build/CMakeFiles/3.20.21032501-MSVC_2/CMakeDetermineCompilerABI_CXX.bin create mode 100644 build/CMakeFiles/3.20.21032501-MSVC_2/CMakeRCCompiler.cmake create mode 100644 build/CMakeFiles/3.20.21032501-MSVC_2/CMakeSystem.cmake create mode 100644 build/CMakeFiles/3.20.21032501-MSVC_2/CompilerIdCXX/CMakeCXXCompilerId.cpp create mode 100644 build/CMakeFiles/3.20.21032501-MSVC_2/CompilerIdCXX/CMakeCXXCompilerId.o create mode 100644 build/CMakeFiles/CMakeError.log create mode 100644 build/CMakeFiles/CMakeOutput.log create mode 100644 build/CMakeFiles/ShowIncludes/foo.h create mode 100644 build/CMakeFiles/ShowIncludes/main.c create mode 100644 build/CMakeFiles/TargetDirectories.txt create mode 100644 build/CMakeFiles/cmake.check_cache create mode 100644 build/CMakeFiles/feature_tests.bin create mode 100644 build/CMakeFiles/feature_tests.cxx create mode 100644 build/CMakeFiles/mirror-test.dir/main.cpp.obj create mode 100644 build/CMakeFiles/rules.ninja create mode 100644 build/build.ninja create mode 100644 build/cmake_install.cmake create mode 100644 build/compile_commands.json create mode 100644 build/mirror-test.exe create mode 100644 build/mirror-test.pdb create mode 100644 randomtext.txt diff --git a/build/.cmake/api/v1/query/client-vscode/query.json b/build/.cmake/api/v1/query/client-vscode/query.json new file mode 100644 index 0000000..b9dc05e --- /dev/null +++ b/build/.cmake/api/v1/query/client-vscode/query.json @@ -0,0 +1 @@ +{"requests":[{"kind":"cache","version":2},{"kind":"codemodel","version":2},{"kind":"toolchains","version":1}]} \ No newline at end of file diff --git a/build/.cmake/api/v1/reply/cache-v2-397ae5ffd5bdf312f93f.json b/build/.cmake/api/v1/reply/cache-v2-397ae5ffd5bdf312f93f.json new file mode 100644 index 0000000..720a3bb --- /dev/null +++ b/build/.cmake/api/v1/reply/cache-v2-397ae5ffd5bdf312f93f.json @@ -0,0 +1,1179 @@ +{ + "entries" : + [ + { + "name" : "CMAKE_ADDR2LINE", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Path to a program." + } + ], + "type" : "FILEPATH", + "value" : "CMAKE_ADDR2LINE-NOTFOUND" + }, + { + "name" : "CMAKE_AR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Path to a program." + } + ], + "type" : "FILEPATH", + "value" : "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/Llvm/x64/bin/llvm-ar.exe" + }, + { + "name" : "CMAKE_BUILD_TYPE", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "No help, variable specified on the command line." + } + ], + "type" : "STRING", + "value" : "Debug" + }, + { + "name" : "CMAKE_CACHEFILE_DIR", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "This is the directory where this CMakeCache.txt was created" + } + ], + "type" : "INTERNAL", + "value" : "e:/Desktop/mirror-test/build" + }, + { + "name" : "CMAKE_CACHE_MAJOR_VERSION", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Major version of cmake used to create the current loaded cache" + } + ], + "type" : "INTERNAL", + "value" : "3" + }, + { + "name" : "CMAKE_CACHE_MINOR_VERSION", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Minor version of cmake used to create the current loaded cache" + } + ], + "type" : "INTERNAL", + "value" : "20" + }, + { + "name" : "CMAKE_CACHE_PATCH_VERSION", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Patch version of cmake used to create the current loaded cache" + } + ], + "type" : "INTERNAL", + "value" : "21032501" + }, + { + "name" : "CMAKE_COMMAND", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Path to CMake executable." + } + ], + "type" : "INTERNAL", + "value" : "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/bin/cmake.exe" + }, + { + "name" : "CMAKE_CPACK_COMMAND", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Path to cpack program executable." + } + ], + "type" : "INTERNAL", + "value" : "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/bin/cpack.exe" + }, + { + "name" : "CMAKE_CTEST_COMMAND", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Path to ctest program executable." + } + ], + "type" : "INTERNAL", + "value" : "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/bin/ctest.exe" + }, + { + "name" : "CMAKE_CXX_COMPILER", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "CXX compiler" + } + ], + "type" : "STRING", + "value" : "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/Llvm/x64/bin/clang.exe" + }, + { + "name" : "CMAKE_CXX_COMPILER_AR", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "LLVM archiver" + } + ], + "type" : "FILEPATH", + "value" : "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/Llvm/x64/bin/llvm-ar.exe" + }, + { + "name" : "CMAKE_CXX_COMPILER_RANLIB", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Generate index for LLVM archive" + } + ], + "type" : "FILEPATH", + "value" : "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/Llvm/x64/bin/llvm-ranlib.exe" + }, + { + "name" : "CMAKE_CXX_FLAGS", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the CXX compiler during all build types." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_CXX_FLAGS_DEBUG", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the CXX compiler during DEBUG builds." + } + ], + "type" : "STRING", + "value" : "-g -Xclang -gcodeview -O0" + }, + { + "name" : "CMAKE_CXX_FLAGS_MINSIZEREL", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the CXX compiler during MINSIZEREL builds." + } + ], + "type" : "STRING", + "value" : "-Os -DNDEBUG" + }, + { + "name" : "CMAKE_CXX_FLAGS_RELEASE", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the CXX compiler during RELEASE builds." + } + ], + "type" : "STRING", + "value" : "-O3 -DNDEBUG" + }, + { + "name" : "CMAKE_CXX_FLAGS_RELWITHDEBINFO", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the CXX compiler during RELWITHDEBINFO builds." + } + ], + "type" : "STRING", + "value" : "-O2 -g -DNDEBUG -Xclang -gcodeview" + }, + { + "name" : "CMAKE_CXX_STANDARD_LIBRARIES", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Libraries linked by default with all C++ applications." + } + ], + "type" : "STRING", + "value" : "-lkernel32 -luser32 -lgdi32 -lwinspool -lshell32 -lole32 -loleaut32 -luuid -lcomdlg32 -ladvapi32 -loldnames" + }, + { + "name" : "CMAKE_C_COMPILER", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "No help, variable specified on the command line." + } + ], + "type" : "FILEPATH", + "value" : "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/Llvm/x64/bin/clang.exe" + }, + { + "name" : "CMAKE_DLLTOOL", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Path to a program." + } + ], + "type" : "FILEPATH", + "value" : "CMAKE_DLLTOOL-NOTFOUND" + }, + { + "name" : "CMAKE_EXECUTABLE_FORMAT", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Executable file format" + } + ], + "type" : "INTERNAL", + "value" : "Unknown" + }, + { + "name" : "CMAKE_EXE_LINKER_FLAGS", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during all build types." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_EXE_LINKER_FLAGS_DEBUG", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during DEBUG builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_EXE_LINKER_FLAGS_MINSIZEREL", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during MINSIZEREL builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_EXE_LINKER_FLAGS_RELEASE", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during RELEASE builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during RELWITHDEBINFO builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_EXPORT_COMPILE_COMMANDS", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "No help, variable specified on the command line." + } + ], + "type" : "BOOL", + "value" : "TRUE" + }, + { + "name" : "CMAKE_EXTRA_GENERATOR", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Name of external makefile project generator." + } + ], + "type" : "INTERNAL", + "value" : "" + }, + { + "name" : "CMAKE_GENERATOR", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Name of generator." + } + ], + "type" : "INTERNAL", + "value" : "Ninja" + }, + { + "name" : "CMAKE_GENERATOR_INSTANCE", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Generator instance identifier." + } + ], + "type" : "INTERNAL", + "value" : "" + }, + { + "name" : "CMAKE_GENERATOR_PLATFORM", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Name of generator platform." + } + ], + "type" : "INTERNAL", + "value" : "" + }, + { + "name" : "CMAKE_GENERATOR_TOOLSET", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Name of generator toolset." + } + ], + "type" : "INTERNAL", + "value" : "" + }, + { + "name" : "CMAKE_HOME_DIRECTORY", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Source directory with the top level CMakeLists.txt file for this project" + } + ], + "type" : "INTERNAL", + "value" : "E:/Desktop/mirror-test" + }, + { + "name" : "CMAKE_INSTALL_PREFIX", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Install path prefix, prepended onto install directories." + } + ], + "type" : "PATH", + "value" : "C:/Program Files (x86)/test" + }, + { + "name" : "CMAKE_LINKER", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Path to a program." + } + ], + "type" : "FILEPATH", + "value" : "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/Llvm/x64/bin/lld-link.exe" + }, + { + "name" : "CMAKE_MAKE_PROGRAM", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "make program" + } + ], + "type" : "FILEPATH", + "value" : "C:/PROGRA~2/MICROS~2/2019/COMMUN~1/Common7/IDE/COMMON~1/MICROS~1/CMake/Ninja/ninja.exe" + }, + { + "name" : "CMAKE_MODULE_LINKER_FLAGS", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of modules during all build types." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_MODULE_LINKER_FLAGS_DEBUG", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of modules during DEBUG builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of modules during MINSIZEREL builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_MODULE_LINKER_FLAGS_RELEASE", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of modules during RELEASE builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of modules during RELWITHDEBINFO builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_NM", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Path to a program." + } + ], + "type" : "FILEPATH", + "value" : "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/Llvm/x64/bin/llvm-nm.exe" + }, + { + "name" : "CMAKE_NUMBER_OF_MAKEFILES", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "number of local generators" + } + ], + "type" : "INTERNAL", + "value" : "1" + }, + { + "name" : "CMAKE_OBJCOPY", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Path to a program." + } + ], + "type" : "FILEPATH", + "value" : "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/Llvm/x64/bin/llvm-objcopy.exe" + }, + { + "name" : "CMAKE_OBJDUMP", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Path to a program." + } + ], + "type" : "FILEPATH", + "value" : "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/Llvm/x64/bin/llvm-objdump.exe" + }, + { + "name" : "CMAKE_PLATFORM_INFO_INITIALIZED", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Platform information initialized" + } + ], + "type" : "INTERNAL", + "value" : "1" + }, + { + "name" : "CMAKE_PROJECT_DESCRIPTION", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake" + } + ], + "type" : "STATIC", + "value" : "mirror test" + }, + { + "name" : "CMAKE_PROJECT_HOMEPAGE_URL", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake" + } + ], + "type" : "STATIC", + "value" : "" + }, + { + "name" : "CMAKE_PROJECT_NAME", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake" + } + ], + "type" : "STATIC", + "value" : "test" + }, + { + "name" : "CMAKE_PROJECT_VERSION", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake" + } + ], + "type" : "STATIC", + "value" : "1.0" + }, + { + "name" : "CMAKE_PROJECT_VERSION_MAJOR", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake" + } + ], + "type" : "STATIC", + "value" : "1" + }, + { + "name" : "CMAKE_PROJECT_VERSION_MINOR", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake" + } + ], + "type" : "STATIC", + "value" : "0" + }, + { + "name" : "CMAKE_PROJECT_VERSION_PATCH", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake" + } + ], + "type" : "STATIC", + "value" : "" + }, + { + "name" : "CMAKE_PROJECT_VERSION_TWEAK", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake" + } + ], + "type" : "STATIC", + "value" : "" + }, + { + "name" : "CMAKE_RANLIB", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "noop for ranlib" + } + ], + "type" : "INTERNAL", + "value" : ":" + }, + { + "name" : "CMAKE_RC_COMPILER", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "RC compiler" + } + ], + "type" : "FILEPATH", + "value" : "C:/Program Files (x86)/Windows Kits/10/bin/10.0.19041.0/x64/rc.exe" + }, + { + "name" : "CMAKE_RC_COMPILER_WORKS", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "" + } + ], + "type" : "INTERNAL", + "value" : "1" + }, + { + "name" : "CMAKE_RC_FLAGS", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags for Windows Resource Compiler during all build types." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_RC_FLAGS_DEBUG", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags for Windows Resource Compiler during DEBUG builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_RC_FLAGS_MINSIZEREL", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags for Windows Resource Compiler during MINSIZEREL builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_RC_FLAGS_RELEASE", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags for Windows Resource Compiler during RELEASE builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_RC_FLAGS_RELWITHDEBINFO", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags for Windows Resource Compiler during RELWITHDEBINFO builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_READELF", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Path to a program." + } + ], + "type" : "FILEPATH", + "value" : "C:/Users/Massiveatoms/.pyenv/pyenv-win/shims/readelf" + }, + { + "name" : "CMAKE_ROOT", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Path to CMake installation." + } + ], + "type" : "INTERNAL", + "value" : "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20" + }, + { + "name" : "CMAKE_SHARED_LINKER_FLAGS", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of shared libraries during all build types." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_SHARED_LINKER_FLAGS_DEBUG", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of shared libraries during DEBUG builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of shared libraries during MINSIZEREL builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_SHARED_LINKER_FLAGS_RELEASE", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of shared libraries during RELEASE builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of shared libraries during RELWITHDEBINFO builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_SKIP_INSTALL_RPATH", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "If set, runtime paths are not added when installing shared libraries, but are added when building." + } + ], + "type" : "BOOL", + "value" : "NO" + }, + { + "name" : "CMAKE_SKIP_RPATH", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "If set, runtime paths are not added when using shared libraries." + } + ], + "type" : "BOOL", + "value" : "NO" + }, + { + "name" : "CMAKE_STATIC_LINKER_FLAGS", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of static libraries during all build types." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_STATIC_LINKER_FLAGS_DEBUG", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of static libraries during DEBUG builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of static libraries during MINSIZEREL builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_STATIC_LINKER_FLAGS_RELEASE", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of static libraries during RELEASE builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Flags used by the linker during the creation of static libraries during RELWITHDEBINFO builds." + } + ], + "type" : "STRING", + "value" : "" + }, + { + "name" : "CMAKE_STRIP", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "Path to a program." + } + ], + "type" : "FILEPATH", + "value" : "CMAKE_STRIP-NOTFOUND" + }, + { + "name" : "CMAKE_VERBOSE_MAKEFILE", + "properties" : + [ + { + "name" : "ADVANCED", + "value" : "1" + }, + { + "name" : "HELPSTRING", + "value" : "If this value is on, makefiles will be generated without the .SILENT directive, and all commands will be echoed to the console during the make. This is useful for debugging only. With Visual Studio IDE projects all commands are done without /nologo." + } + ], + "type" : "BOOL", + "value" : "FALSE" + }, + { + "name" : "test_BINARY_DIR", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake" + } + ], + "type" : "STATIC", + "value" : "E:/Desktop/mirror-test/build" + }, + { + "name" : "test_SOURCE_DIR", + "properties" : + [ + { + "name" : "HELPSTRING", + "value" : "Value Computed by CMake" + } + ], + "type" : "STATIC", + "value" : "E:/Desktop/mirror-test" + } + ], + "kind" : "cache", + "version" : + { + "major" : 2, + "minor" : 0 + } +} diff --git a/build/.cmake/api/v1/reply/codemodel-v2-37f6a47c2b317e96ed6f.json b/build/.cmake/api/v1/reply/codemodel-v2-37f6a47c2b317e96ed6f.json new file mode 100644 index 0000000..1bb3368 --- /dev/null +++ b/build/.cmake/api/v1/reply/codemodel-v2-37f6a47c2b317e96ed6f.json @@ -0,0 +1,59 @@ +{ + "configurations" : + [ + { + "directories" : + [ + { + "build" : ".", + "minimumCMakeVersion" : + { + "string" : "3.7" + }, + "projectIndex" : 0, + "source" : ".", + "targetIndexes" : + [ + 0 + ] + } + ], + "name" : "Debug", + "projects" : + [ + { + "directoryIndexes" : + [ + 0 + ], + "name" : "test", + "targetIndexes" : + [ + 0 + ] + } + ], + "targets" : + [ + { + "directoryIndex" : 0, + "id" : "mirror-test::@6890427a1f51a3e7e1df", + "jsonFile" : "target-mirror-test-Debug-21bf0dc542351963f7de.json", + "name" : "mirror-test", + "projectIndex" : 0 + } + ] + } + ], + "kind" : "codemodel", + "paths" : + { + "build" : "E:/Desktop/mirror-test/build", + "source" : "E:/Desktop/mirror-test" + }, + "version" : + { + "major" : 2, + "minor" : 2 + } +} diff --git a/build/.cmake/api/v1/reply/index-2022-03-28T14-19-21-0832.json b/build/.cmake/api/v1/reply/index-2022-03-28T14-19-21-0832.json new file mode 100644 index 0000000..5fdc646 --- /dev/null +++ b/build/.cmake/api/v1/reply/index-2022-03-28T14-19-21-0832.json @@ -0,0 +1,110 @@ +{ + "cmake" : + { + "generator" : + { + "multiConfig" : false, + "name" : "Ninja" + }, + "paths" : + { + "cmake" : "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/bin/cmake.exe", + "cpack" : "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/bin/cpack.exe", + "ctest" : "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/bin/ctest.exe", + "root" : "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20" + }, + "version" : + { + "isDirty" : false, + "major" : 3, + "minor" : 20, + "patch" : 21032501, + "string" : "3.20.21032501-MSVC_2", + "suffix" : "" + } + }, + "objects" : + [ + { + "jsonFile" : "codemodel-v2-37f6a47c2b317e96ed6f.json", + "kind" : "codemodel", + "version" : + { + "major" : 2, + "minor" : 2 + } + }, + { + "jsonFile" : "cache-v2-397ae5ffd5bdf312f93f.json", + "kind" : "cache", + "version" : + { + "major" : 2, + "minor" : 0 + } + }, + { + "jsonFile" : "toolchains-v1-e830cc8b3da0141de6d1.json", + "kind" : "toolchains", + "version" : + { + "major" : 1, + "minor" : 0 + } + } + ], + "reply" : + { + "client-vscode" : + { + "query.json" : + { + "requests" : + [ + { + "kind" : "cache", + "version" : 2 + }, + { + "kind" : "codemodel", + "version" : 2 + }, + { + "kind" : "toolchains", + "version" : 1 + } + ], + "responses" : + [ + { + "jsonFile" : "cache-v2-397ae5ffd5bdf312f93f.json", + "kind" : "cache", + "version" : + { + "major" : 2, + "minor" : 0 + } + }, + { + "jsonFile" : "codemodel-v2-37f6a47c2b317e96ed6f.json", + "kind" : "codemodel", + "version" : + { + "major" : 2, + "minor" : 2 + } + }, + { + "jsonFile" : "toolchains-v1-e830cc8b3da0141de6d1.json", + "kind" : "toolchains", + "version" : + { + "major" : 1, + "minor" : 0 + } + } + ] + } + } + } +} diff --git a/build/.cmake/api/v1/reply/target-mirror-test-Debug-21bf0dc542351963f7de.json b/build/.cmake/api/v1/reply/target-mirror-test-Debug-21bf0dc542351963f7de.json new file mode 100644 index 0000000..b60012e --- /dev/null +++ b/build/.cmake/api/v1/reply/target-mirror-test-Debug-21bf0dc542351963f7de.json @@ -0,0 +1,109 @@ +{ + "artifacts" : + [ + { + "path" : "mirror-test.exe" + }, + { + "path" : "mirror-test.pdb" + } + ], + "backtrace" : 1, + "backtraceGraph" : + { + "commands" : + [ + "add_executable" + ], + "files" : + [ + "CMakeLists.txt" + ], + "nodes" : + [ + { + "file" : 0 + }, + { + "command" : 0, + "file" : 0, + "line" : 16, + "parent" : 0 + } + ] + }, + "compileGroups" : + [ + { + "compileCommandFragments" : + [ + { + "fragment" : "-g -Xclang -gcodeview -O0 -D_DEBUG -D_DLL -D_MT -Xclang --dependent-lib=msvcrtd" + }, + { + "fragment" : "-std=gnu++14" + } + ], + "language" : "CXX", + "languageStandard" : + { + "backtraces" : + [ + 1 + ], + "standard" : "14" + }, + "sourceIndexes" : + [ + 0 + ] + } + ], + "id" : "mirror-test::@6890427a1f51a3e7e1df", + "link" : + { + "commandFragments" : + [ + { + "fragment" : "-g -Xclang -gcodeview -O0 -D_DEBUG -D_DLL -D_MT -Xclang --dependent-lib=msvcrtd", + "role" : "flags" + }, + { + "fragment" : "-Xlinker /subsystem:console", + "role" : "flags" + }, + { + "fragment" : "-lkernel32 -luser32 -lgdi32 -lwinspool -lshell32 -lole32 -loleaut32 -luuid -lcomdlg32 -ladvapi32 -loldnames", + "role" : "libraries" + } + ], + "language" : "CXX" + }, + "name" : "mirror-test", + "nameOnDisk" : "mirror-test.exe", + "paths" : + { + "build" : ".", + "source" : "." + }, + "sourceGroups" : + [ + { + "name" : "Source Files", + "sourceIndexes" : + [ + 0 + ] + } + ], + "sources" : + [ + { + "backtrace" : 1, + "compileGroupIndex" : 0, + "path" : "main.cpp", + "sourceGroupIndex" : 0 + } + ], + "type" : "EXECUTABLE" +} diff --git a/build/.cmake/api/v1/reply/toolchains-v1-e830cc8b3da0141de6d1.json b/build/.cmake/api/v1/reply/toolchains-v1-e830cc8b3da0141de6d1.json new file mode 100644 index 0000000..8aaf36a --- /dev/null +++ b/build/.cmake/api/v1/reply/toolchains-v1-e830cc8b3da0141de6d1.json @@ -0,0 +1,53 @@ +{ + "kind" : "toolchains", + "toolchains" : + [ + { + "compiler" : + { + "id" : "Clang", + "implicit" : + { + "includeDirectories" : [], + "linkDirectories" : [], + "linkFrameworkDirectories" : [], + "linkLibraries" : [] + }, + "path" : "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/Llvm/x64/bin/clang.exe", + "version" : "12.0.0" + }, + "language" : "CXX", + "sourceFileExtensions" : + [ + "C", + "M", + "c++", + "cc", + "cpp", + "cxx", + "m", + "mm", + "mpp", + "CPP" + ] + }, + { + "compiler" : + { + "implicit" : {}, + "path" : "C:/Program Files (x86)/Windows Kits/10/bin/10.0.19041.0/x64/rc.exe" + }, + "language" : "RC", + "sourceFileExtensions" : + [ + "rc", + "RC" + ] + } + ], + "version" : + { + "major" : 1, + "minor" : 0 + } +} diff --git a/build/.ninja_deps b/build/.ninja_deps new file mode 100644 index 0000000000000000000000000000000000000000..de888d5fc84ac621c8cab43d456aa9268cea385f GIT binary patch literal 12220 zcmeI2_ir3U6vroYLJKu?4iX@NWcSWCCJr^2B!uMRU^|7n%+2lj#@=$;-Sh1s6y<-Q zcL=@r9y)|jL+`!!-uriU?`)8;lpn@VLL$;fI$6>8yYuGFn>VvNA>&D}pBL>)ICdSz z*c8y2=L7aE>DZy^${_HAsgWHiZ)yO~5OGbx_dKH1Dm5%{5BiZY92SmjQpC#n{uZ?Zj`b#qat+3WjG zXy$wHGuLLcbQrDKTx+W-J>gV~wkiEE3T*EF4!;V4Uwx1}p(XslHp;&dc@B!8>P6Cp zCHs{qt|52e#@H|LiwNQ>d{0z^!1hEvvHlsp$25GqyJmOKSlVLd=X7>=_25UEC0+Ua z!ud;c!$~sF8FbCKz0GuF!4wYn`pjI5ku|bI*)oU(FNJDgKM}>T>G&i3DDpENu|g)z$G|^^ zFGamq)7RM2*hfU3)zG%M7fLn1AHtKO&l6!(#J0{pfZx24^J&fVUaeaU;C<-z>d;dy zAtu9W=)MPCE$cHKw+c0T7n)1-KC6T6CeeOJw{~drK&S{a_BOQj?=1)nGG7_I1%2hC z`T%{sqGhEHn96&mx*F8BRk-cAG}26=ZB?Q zk+Bzv{IE9!((7X{z)w@nReDJdJP%F1HP?3ipq^+yHwxOKQn%Cr_gQFbS!Z?-cvue4 zKrbG7?-_+YE}c{rsHb(u2{pGl!B0V(r2f@JnFoxm)-^AQo>6{Mdu&ji8ujl9{n}Bz zqHeJmdtAFVt|e`eoH-tYw$`4mmImZe-MS%C0^xW>dn_t}FYHj&fmOPnxt3l;J`7zw zwYDCbVZ_zMt<oQ;(RM{A1~1bpI`@;gA2d= ziN+aMBkAB(zHm8Mn{aCHZF578J^?np0Ucf+sQ-|9OzrQ)i{-$gW@ zrsE3uQOsF--Cd}bu#eqIG{zV&x(YnB?|`3{zOJ$N+)fpKRhZiDACf?m?H z+;C7>;oqz+Ucj|grNV9{nm3X3&y3wd6=z%r#=@?sJ>g~|&(u(=>jZWaJhk)%E+4v^ zx)GYRcgRB{N_y2B;IDet(SFZlAO zR$c^8l3I!WK#lT3BEK}Oj4h{%X;jANS;gd=n+u4>7^^D^1oeC(KcW24ADjn2E%meU zt=G9k&#%5Y;f~GDA@XZ%*X(Q}KXt~IUdcZTeiSu&_*;Ocvr#^iXsmIG3mY5Y8B~7A z9TnTt;YYF8t6WunYTrAJXpBOrd1UNV_-R?+iJnnDh3fem>-%K*X*rvvdP%=^5;Rwg zVarhd*vg6JnKM?8XJhbtEwDCF-x9A2)&uK<4ZwzAEZ7Ka3^oCqg3Z7;u}tzF->Y0Mo&KV1IA`I1n5J4hA#8A)pf+3TA>?U^X}m%mIgkxj^Mp9?S<_ zK+Vq)pd0jnUa$}>0*k>Ca3nYi91YZY;8<`Ru)y(vg8~qs2#~r=-BtAgEE^_4KNtWG SXwKiNw&jKY=kLEae}4hjWhN&8 literal 0 HcmV?d00001 diff --git a/build/.ninja_log b/build/.ninja_log new file mode 100644 index 0000000..b8b72d7 --- /dev/null +++ b/build/.ninja_log @@ -0,0 +1,5 @@ +# ninja log v5 +0 736 6701803708622022 CMakeFiles/mirror-test.dir/main.cpp.obj dfb79aae5b2c138d +738 888 6701803710372044 mirror-test.exe 343e8e4a47f4b03d +1 559 6701804198966472 CMakeFiles/mirror-test.dir/main.cpp.obj dfb79aae5b2c138d +560 687 6701804200216175 mirror-test.exe 343e8e4a47f4b03d diff --git a/build/CMakeCache.txt b/build/CMakeCache.txt new file mode 100644 index 0000000..31a2d34 --- /dev/null +++ b/build/CMakeCache.txt @@ -0,0 +1,363 @@ +# This is the CMakeCache file. +# For build in directory: e:/Desktop/mirror-test/build +# It was generated by CMake: C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/bin/cmake.exe +# You can edit this file to change values found and used by cmake. +# If you do not want to change any of the values, simply exit the editor. +# If you do want to change a value, simply edit, save, and exit the editor. +# The syntax for the file is as follows: +# KEY:TYPE=VALUE +# KEY is the name of a variable in the cache. +# TYPE is a hint to GUIs for the type of VALUE, DO NOT EDIT TYPE!. +# VALUE is the current value for the KEY. + +######################## +# EXTERNAL cache entries +######################## + +//Path to a program. +CMAKE_ADDR2LINE:FILEPATH=CMAKE_ADDR2LINE-NOTFOUND + +//Path to a program. +CMAKE_AR:FILEPATH=C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/Llvm/x64/bin/llvm-ar.exe + +//No help, variable specified on the command line. +CMAKE_BUILD_TYPE:STRING=Debug + +//CXX compiler +CMAKE_CXX_COMPILER:STRING=C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/Llvm/x64/bin/clang.exe + +//LLVM archiver +CMAKE_CXX_COMPILER_AR:FILEPATH=C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/Llvm/x64/bin/llvm-ar.exe + +//Generate index for LLVM archive +CMAKE_CXX_COMPILER_RANLIB:FILEPATH=C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/Llvm/x64/bin/llvm-ranlib.exe + +//Flags used by the CXX compiler during all build types. +CMAKE_CXX_FLAGS:STRING= + +//Flags used by the CXX compiler during DEBUG builds. +CMAKE_CXX_FLAGS_DEBUG:STRING=-g -Xclang -gcodeview -O0 + +//Flags used by the CXX compiler during MINSIZEREL builds. +CMAKE_CXX_FLAGS_MINSIZEREL:STRING=-Os -DNDEBUG + +//Flags used by the CXX compiler during RELEASE builds. +CMAKE_CXX_FLAGS_RELEASE:STRING=-O3 -DNDEBUG + +//Flags used by the CXX compiler during RELWITHDEBINFO builds. +CMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=-O2 -g -DNDEBUG -Xclang -gcodeview + +//Libraries linked by default with all C++ applications. +CMAKE_CXX_STANDARD_LIBRARIES:STRING=-lkernel32 -luser32 -lgdi32 -lwinspool -lshell32 -lole32 -loleaut32 -luuid -lcomdlg32 -ladvapi32 -loldnames + +//No help, variable specified on the command line. +CMAKE_C_COMPILER:FILEPATH=C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/Llvm/x64/bin/clang.exe + +//Path to a program. +CMAKE_DLLTOOL:FILEPATH=CMAKE_DLLTOOL-NOTFOUND + +//Flags used by the linker during all build types. +CMAKE_EXE_LINKER_FLAGS:STRING= + +//Flags used by the linker during DEBUG builds. +CMAKE_EXE_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during MINSIZEREL builds. +CMAKE_EXE_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during RELEASE builds. +CMAKE_EXE_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during RELWITHDEBINFO builds. +CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//No help, variable specified on the command line. +CMAKE_EXPORT_COMPILE_COMMANDS:BOOL=TRUE + +//Install path prefix, prepended onto install directories. +CMAKE_INSTALL_PREFIX:PATH=C:/Program Files (x86)/test + +//Path to a program. +CMAKE_LINKER:FILEPATH=C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/Llvm/x64/bin/lld-link.exe + +//make program +CMAKE_MAKE_PROGRAM:FILEPATH=C:/PROGRA~2/MICROS~2/2019/COMMUN~1/Common7/IDE/COMMON~1/MICROS~1/CMake/Ninja/ninja.exe + +//Flags used by the linker during the creation of modules during +// all build types. +CMAKE_MODULE_LINKER_FLAGS:STRING= + +//Flags used by the linker during the creation of modules during +// DEBUG builds. +CMAKE_MODULE_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during the creation of modules during +// MINSIZEREL builds. +CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during the creation of modules during +// RELEASE builds. +CMAKE_MODULE_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during the creation of modules during +// RELWITHDEBINFO builds. +CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//Path to a program. +CMAKE_NM:FILEPATH=C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/Llvm/x64/bin/llvm-nm.exe + +//Path to a program. +CMAKE_OBJCOPY:FILEPATH=C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/Llvm/x64/bin/llvm-objcopy.exe + +//Path to a program. +CMAKE_OBJDUMP:FILEPATH=C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/Llvm/x64/bin/llvm-objdump.exe + +//Value Computed by CMake +CMAKE_PROJECT_DESCRIPTION:STATIC=mirror test + +//Value Computed by CMake +CMAKE_PROJECT_HOMEPAGE_URL:STATIC= + +//Value Computed by CMake +CMAKE_PROJECT_NAME:STATIC=test + +//Value Computed by CMake +CMAKE_PROJECT_VERSION:STATIC=1.0 + +//Value Computed by CMake +CMAKE_PROJECT_VERSION_MAJOR:STATIC=1 + +//Value Computed by CMake +CMAKE_PROJECT_VERSION_MINOR:STATIC=0 + +//Value Computed by CMake +CMAKE_PROJECT_VERSION_PATCH:STATIC= + +//Value Computed by CMake +CMAKE_PROJECT_VERSION_TWEAK:STATIC= + +//RC compiler +CMAKE_RC_COMPILER:FILEPATH=C:/Program Files (x86)/Windows Kits/10/bin/10.0.19041.0/x64/rc.exe + +//Flags for Windows Resource Compiler during all build types. +CMAKE_RC_FLAGS:STRING= + +//Flags for Windows Resource Compiler during DEBUG builds. +CMAKE_RC_FLAGS_DEBUG:STRING= + +//Flags for Windows Resource Compiler during MINSIZEREL builds. +CMAKE_RC_FLAGS_MINSIZEREL:STRING= + +//Flags for Windows Resource Compiler during RELEASE builds. +CMAKE_RC_FLAGS_RELEASE:STRING= + +//Flags for Windows Resource Compiler during RELWITHDEBINFO builds. +CMAKE_RC_FLAGS_RELWITHDEBINFO:STRING= + +//Path to a program. +CMAKE_READELF:FILEPATH=C:/Users/Massiveatoms/.pyenv/pyenv-win/shims/readelf + +//Flags used by the linker during the creation of shared libraries +// during all build types. +CMAKE_SHARED_LINKER_FLAGS:STRING= + +//Flags used by the linker during the creation of shared libraries +// during DEBUG builds. +CMAKE_SHARED_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during the creation of shared libraries +// during MINSIZEREL builds. +CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during the creation of shared libraries +// during RELEASE builds. +CMAKE_SHARED_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during the creation of shared libraries +// during RELWITHDEBINFO builds. +CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//If set, runtime paths are not added when installing shared libraries, +// but are added when building. +CMAKE_SKIP_INSTALL_RPATH:BOOL=NO + +//If set, runtime paths are not added when using shared libraries. +CMAKE_SKIP_RPATH:BOOL=NO + +//Flags used by the linker during the creation of static libraries +// during all build types. +CMAKE_STATIC_LINKER_FLAGS:STRING= + +//Flags used by the linker during the creation of static libraries +// during DEBUG builds. +CMAKE_STATIC_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during the creation of static libraries +// during MINSIZEREL builds. +CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during the creation of static libraries +// during RELEASE builds. +CMAKE_STATIC_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during the creation of static libraries +// during RELWITHDEBINFO builds. +CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//Path to a program. +CMAKE_STRIP:FILEPATH=CMAKE_STRIP-NOTFOUND + +//If this value is on, makefiles will be generated without the +// .SILENT directive, and all commands will be echoed to the console +// during the make. This is useful for debugging only. With Visual +// Studio IDE projects all commands are done without /nologo. +CMAKE_VERBOSE_MAKEFILE:BOOL=FALSE + +//Value Computed by CMake +test_BINARY_DIR:STATIC=E:/Desktop/mirror-test/build + +//Value Computed by CMake +test_SOURCE_DIR:STATIC=E:/Desktop/mirror-test + + +######################## +# INTERNAL cache entries +######################## + +//ADVANCED property for variable: CMAKE_ADDR2LINE +CMAKE_ADDR2LINE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_AR +CMAKE_AR-ADVANCED:INTERNAL=1 +//This is the directory where this CMakeCache.txt was created +CMAKE_CACHEFILE_DIR:INTERNAL=e:/Desktop/mirror-test/build +//Major version of cmake used to create the current loaded cache +CMAKE_CACHE_MAJOR_VERSION:INTERNAL=3 +//Minor version of cmake used to create the current loaded cache +CMAKE_CACHE_MINOR_VERSION:INTERNAL=20 +//Patch version of cmake used to create the current loaded cache +CMAKE_CACHE_PATCH_VERSION:INTERNAL=21032501 +//Path to CMake executable. +CMAKE_COMMAND:INTERNAL=C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/bin/cmake.exe +//Path to cpack program executable. +CMAKE_CPACK_COMMAND:INTERNAL=C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/bin/cpack.exe +//Path to ctest program executable. +CMAKE_CTEST_COMMAND:INTERNAL=C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/bin/ctest.exe +//ADVANCED property for variable: CMAKE_CXX_COMPILER +CMAKE_CXX_COMPILER-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_COMPILER_AR +CMAKE_CXX_COMPILER_AR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_COMPILER_RANLIB +CMAKE_CXX_COMPILER_RANLIB-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS +CMAKE_CXX_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_DEBUG +CMAKE_CXX_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_MINSIZEREL +CMAKE_CXX_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELEASE +CMAKE_CXX_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELWITHDEBINFO +CMAKE_CXX_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_STANDARD_LIBRARIES +CMAKE_CXX_STANDARD_LIBRARIES-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_DLLTOOL +CMAKE_DLLTOOL-ADVANCED:INTERNAL=1 +//Executable file format +CMAKE_EXECUTABLE_FORMAT:INTERNAL=Unknown +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS +CMAKE_EXE_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_DEBUG +CMAKE_EXE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_MINSIZEREL +CMAKE_EXE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELEASE +CMAKE_EXE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//Name of external makefile project generator. +CMAKE_EXTRA_GENERATOR:INTERNAL= +//Name of generator. +CMAKE_GENERATOR:INTERNAL=Ninja +//Generator instance identifier. +CMAKE_GENERATOR_INSTANCE:INTERNAL= +//Name of generator platform. +CMAKE_GENERATOR_PLATFORM:INTERNAL= +//Name of generator toolset. +CMAKE_GENERATOR_TOOLSET:INTERNAL= +//Source directory with the top level CMakeLists.txt file for this +// project +CMAKE_HOME_DIRECTORY:INTERNAL=E:/Desktop/mirror-test +//ADVANCED property for variable: CMAKE_LINKER +CMAKE_LINKER-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MAKE_PROGRAM +CMAKE_MAKE_PROGRAM-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS +CMAKE_MODULE_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_DEBUG +CMAKE_MODULE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL +CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELEASE +CMAKE_MODULE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_NM +CMAKE_NM-ADVANCED:INTERNAL=1 +//number of local generators +CMAKE_NUMBER_OF_MAKEFILES:INTERNAL=1 +//ADVANCED property for variable: CMAKE_OBJCOPY +CMAKE_OBJCOPY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_OBJDUMP +CMAKE_OBJDUMP-ADVANCED:INTERNAL=1 +//Platform information initialized +CMAKE_PLATFORM_INFO_INITIALIZED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_RANLIB +CMAKE_RANLIB-ADVANCED:INTERNAL=1 +//noop for ranlib +CMAKE_RANLIB:INTERNAL=: +//ADVANCED property for variable: CMAKE_RC_COMPILER +CMAKE_RC_COMPILER-ADVANCED:INTERNAL=1 +CMAKE_RC_COMPILER_WORKS:INTERNAL=1 +//ADVANCED property for variable: CMAKE_RC_FLAGS +CMAKE_RC_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_RC_FLAGS_DEBUG +CMAKE_RC_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_RC_FLAGS_MINSIZEREL +CMAKE_RC_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_RC_FLAGS_RELEASE +CMAKE_RC_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_RC_FLAGS_RELWITHDEBINFO +CMAKE_RC_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_READELF +CMAKE_READELF-ADVANCED:INTERNAL=1 +//Path to CMake installation. +CMAKE_ROOT:INTERNAL=C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS +CMAKE_SHARED_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_DEBUG +CMAKE_SHARED_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL +CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELEASE +CMAKE_SHARED_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SKIP_INSTALL_RPATH +CMAKE_SKIP_INSTALL_RPATH-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SKIP_RPATH +CMAKE_SKIP_RPATH-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS +CMAKE_STATIC_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_DEBUG +CMAKE_STATIC_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL +CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELEASE +CMAKE_STATIC_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STRIP +CMAKE_STRIP-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_VERBOSE_MAKEFILE +CMAKE_VERBOSE_MAKEFILE-ADVANCED:INTERNAL=1 + diff --git a/build/CMakeFiles/3.20.21032501-MSVC_2/CMakeCXXCompiler.cmake b/build/CMakeFiles/3.20.21032501-MSVC_2/CMakeCXXCompiler.cmake new file mode 100644 index 0000000..9b78259 --- /dev/null +++ b/build/CMakeFiles/3.20.21032501-MSVC_2/CMakeCXXCompiler.cmake @@ -0,0 +1,91 @@ +set(CMAKE_CXX_COMPILER "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/Llvm/x64/bin/clang.exe") +set(CMAKE_CXX_COMPILER_ARG1 "") +set(CMAKE_CXX_COMPILER_ID "Clang") +set(CMAKE_CXX_COMPILER_VERSION "12.0.0") +set(CMAKE_CXX_COMPILER_VERSION_INTERNAL "") +set(CMAKE_CXX_COMPILER_WRAPPER "") +set(CMAKE_CXX_STANDARD_COMPUTED_DEFAULT "14") +set(CMAKE_CXX_COMPILE_FEATURES "cxx_std_98;cxx_template_template_parameters;cxx_std_11;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates;cxx_std_14;cxx_std_17;cxx_std_20;cxx_std_23") +set(CMAKE_CXX98_COMPILE_FEATURES "cxx_std_98;cxx_template_template_parameters") +set(CMAKE_CXX11_COMPILE_FEATURES "cxx_std_11;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates") +set(CMAKE_CXX14_COMPILE_FEATURES "cxx_std_14") +set(CMAKE_CXX17_COMPILE_FEATURES "cxx_std_17") +set(CMAKE_CXX20_COMPILE_FEATURES "cxx_std_20") +set(CMAKE_CXX23_COMPILE_FEATURES "cxx_std_23") + +set(CMAKE_CXX_PLATFORM_ID "Windows") +set(CMAKE_CXX_SIMULATE_ID "MSVC") +set(CMAKE_CXX_COMPILER_FRONTEND_VARIANT "GNU") +set(CMAKE_CXX_SIMULATE_VERSION "19.11") +set(CMAKE_CXX_COMPILER_ARCHITECTURE_ID x64) + +set(MSVC_CXX_ARCHITECTURE_ID x64) + +set(CMAKE_AR "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/Llvm/x64/bin/llvm-ar.exe") +set(CMAKE_CXX_COMPILER_AR "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/Llvm/x64/bin/llvm-ar.exe") +set(CMAKE_RANLIB ":") +set(CMAKE_CXX_COMPILER_RANLIB "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/Llvm/x64/bin/llvm-ranlib.exe") +set(CMAKE_LINKER "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/Llvm/x64/bin/lld-link.exe") +set(CMAKE_MT "") +set(CMAKE_COMPILER_IS_GNUCXX ) +set(CMAKE_CXX_COMPILER_LOADED 1) +set(CMAKE_CXX_COMPILER_WORKS TRUE) +set(CMAKE_CXX_ABI_COMPILED TRUE) +set(CMAKE_COMPILER_IS_MINGW ) +set(CMAKE_COMPILER_IS_CYGWIN ) +if(CMAKE_COMPILER_IS_CYGWIN) + set(CYGWIN 1) + set(UNIX 1) +endif() + +set(CMAKE_CXX_COMPILER_ENV_VAR "CXX") + +if(CMAKE_COMPILER_IS_MINGW) + set(MINGW 1) +endif() +set(CMAKE_CXX_COMPILER_ID_RUN 1) +set(CMAKE_CXX_SOURCE_FILE_EXTENSIONS C;M;c++;cc;cpp;cxx;m;mm;mpp;CPP) +set(CMAKE_CXX_IGNORE_EXTENSIONS inl;h;hpp;HPP;H;o;O;obj;OBJ;def;DEF;rc;RC) + +foreach (lang C OBJC OBJCXX) + if (CMAKE_${lang}_COMPILER_ID_RUN) + foreach(extension IN LISTS CMAKE_${lang}_SOURCE_FILE_EXTENSIONS) + list(REMOVE_ITEM CMAKE_CXX_SOURCE_FILE_EXTENSIONS ${extension}) + endforeach() + endif() +endforeach() + +set(CMAKE_CXX_LINKER_PREFERENCE 30) +set(CMAKE_CXX_LINKER_PREFERENCE_PROPAGATES 1) + +# Save compiler ABI information. +set(CMAKE_CXX_SIZEOF_DATA_PTR "8") +set(CMAKE_CXX_COMPILER_ABI "") +set(CMAKE_CXX_BYTE_ORDER "LITTLE_ENDIAN") +set(CMAKE_CXX_LIBRARY_ARCHITECTURE "") + +if(CMAKE_CXX_SIZEOF_DATA_PTR) + set(CMAKE_SIZEOF_VOID_P "${CMAKE_CXX_SIZEOF_DATA_PTR}") +endif() + +if(CMAKE_CXX_COMPILER_ABI) + set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_CXX_COMPILER_ABI}") +endif() + +if(CMAKE_CXX_LIBRARY_ARCHITECTURE) + set(CMAKE_LIBRARY_ARCHITECTURE "") +endif() + +set(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX "") +if(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX) + set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_CXX_CL_SHOWINCLUDES_PREFIX}") +endif() + + + + + +set(CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES "") +set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "") +set(CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "") +set(CMAKE_CXX_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "") diff --git a/build/CMakeFiles/3.20.21032501-MSVC_2/CMakeDetermineCompilerABI_CXX.bin b/build/CMakeFiles/3.20.21032501-MSVC_2/CMakeDetermineCompilerABI_CXX.bin new file mode 100644 index 0000000000000000000000000000000000000000..f0c59c6637d93d9cb2c54ddc0c97684c0d43834c GIT binary patch literal 17408 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 NIz+_P-ye$y{s%T7;bH&) literal 0 HcmV?d00001 diff --git a/build/CMakeFiles/3.20.21032501-MSVC_2/CMakeRCCompiler.cmake b/build/CMakeFiles/3.20.21032501-MSVC_2/CMakeRCCompiler.cmake new file mode 100644 index 0000000..8af8852 --- /dev/null +++ b/build/CMakeFiles/3.20.21032501-MSVC_2/CMakeRCCompiler.cmake @@ -0,0 +1,6 @@ +set(CMAKE_RC_COMPILER "C:/Program Files (x86)/Windows Kits/10/bin/10.0.19041.0/x64/rc.exe") +set(CMAKE_RC_COMPILER_ARG1 "") +set(CMAKE_RC_COMPILER_LOADED 1) +set(CMAKE_RC_SOURCE_FILE_EXTENSIONS rc;RC) +set(CMAKE_RC_OUTPUT_EXTENSION .res) +set(CMAKE_RC_COMPILER_ENV_VAR "RC") diff --git a/build/CMakeFiles/3.20.21032501-MSVC_2/CMakeSystem.cmake b/build/CMakeFiles/3.20.21032501-MSVC_2/CMakeSystem.cmake new file mode 100644 index 0000000..e494dec --- /dev/null +++ b/build/CMakeFiles/3.20.21032501-MSVC_2/CMakeSystem.cmake @@ -0,0 +1,15 @@ +set(CMAKE_HOST_SYSTEM "Windows-10.0.19044") +set(CMAKE_HOST_SYSTEM_NAME "Windows") +set(CMAKE_HOST_SYSTEM_VERSION "10.0.19044") +set(CMAKE_HOST_SYSTEM_PROCESSOR "AMD64") + + + +set(CMAKE_SYSTEM "Windows-10.0.19044") +set(CMAKE_SYSTEM_NAME "Windows") +set(CMAKE_SYSTEM_VERSION "10.0.19044") +set(CMAKE_SYSTEM_PROCESSOR "AMD64") + +set(CMAKE_CROSSCOMPILING "FALSE") + +set(CMAKE_SYSTEM_LOADED 1) diff --git a/build/CMakeFiles/3.20.21032501-MSVC_2/CompilerIdCXX/CMakeCXXCompilerId.cpp b/build/CMakeFiles/3.20.21032501-MSVC_2/CompilerIdCXX/CMakeCXXCompilerId.cpp new file mode 100644 index 0000000..356dbc6 --- /dev/null +++ b/build/CMakeFiles/3.20.21032501-MSVC_2/CompilerIdCXX/CMakeCXXCompilerId.cpp @@ -0,0 +1,734 @@ +/* This source file must have a .cpp extension so that all C++ compilers + recognize the extension without flags. Borland does not know .cxx for + example. */ +#ifndef __cplusplus +# error "A C compiler has been selected for C++." +#endif + + +/* Version number components: V=Version, R=Revision, P=Patch + Version date components: YYYY=Year, MM=Month, DD=Day */ + +#if defined(__COMO__) +# define COMPILER_ID "Comeau" + /* __COMO_VERSION__ = VRR */ +# define COMPILER_VERSION_MAJOR DEC(__COMO_VERSION__ / 100) +# define COMPILER_VERSION_MINOR DEC(__COMO_VERSION__ % 100) + +#elif defined(__INTEL_COMPILER) || defined(__ICC) +# define COMPILER_ID "Intel" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# if defined(__GNUC__) +# define SIMULATE_ID "GNU" +# endif + /* __INTEL_COMPILER = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100) +# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10) +# if defined(__INTEL_COMPILER_UPDATE) +# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE) +# else +# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER % 10) +# endif +# if defined(__INTEL_COMPILER_BUILD_DATE) + /* __INTEL_COMPILER_BUILD_DATE = YYYYMMDD */ +# define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE) +# endif +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif +# if defined(__GNUC__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUC__) +# elif defined(__GNUG__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUG__) +# endif +# if defined(__GNUC_MINOR__) +# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif +# if defined(__GNUC_PATCHLEVEL__) +# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif + +#elif (defined(__clang__) && defined(__INTEL_CLANG_COMPILER)) || defined(__INTEL_LLVM_COMPILER) +# define COMPILER_ID "IntelLLVM" +#if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +#endif +#if defined(__GNUC__) +# define SIMULATE_ID "GNU" +#endif +/* __INTEL_LLVM_COMPILER = VVVVRP prior to 2021.2.0, VVVVRRPP for 2021.2.0 and + * later. Look for 6 digit vs. 8 digit version number to decide encoding. + * VVVV is no smaller than the current year when a versio is released. + */ +#if __INTEL_LLVM_COMPILER < 1000000L +# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/100) +# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER % 10) +#else +# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/10000) +# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/100 % 100) +# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER % 100) +#endif +#if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +#endif +#if defined(__GNUC__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUC__) +#elif defined(__GNUG__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUG__) +#endif +#if defined(__GNUC_MINOR__) +# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +#endif +#if defined(__GNUC_PATCHLEVEL__) +# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +#endif + +#elif defined(__PATHCC__) +# define COMPILER_ID "PathScale" +# define COMPILER_VERSION_MAJOR DEC(__PATHCC__) +# define COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__) +# if defined(__PATHCC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__) +# endif + +#elif defined(__BORLANDC__) && defined(__CODEGEARC_VERSION__) +# define COMPILER_ID "Embarcadero" +# define COMPILER_VERSION_MAJOR HEX(__CODEGEARC_VERSION__>>24 & 0x00FF) +# define COMPILER_VERSION_MINOR HEX(__CODEGEARC_VERSION__>>16 & 0x00FF) +# define COMPILER_VERSION_PATCH DEC(__CODEGEARC_VERSION__ & 0xFFFF) + +#elif defined(__BORLANDC__) +# define COMPILER_ID "Borland" + /* __BORLANDC__ = 0xVRR */ +# define COMPILER_VERSION_MAJOR HEX(__BORLANDC__>>8) +# define COMPILER_VERSION_MINOR HEX(__BORLANDC__ & 0xFF) + +#elif defined(__WATCOMC__) && __WATCOMC__ < 1200 +# define COMPILER_ID "Watcom" + /* __WATCOMC__ = VVRR */ +# define COMPILER_VERSION_MAJOR DEC(__WATCOMC__ / 100) +# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__WATCOMC__) +# define COMPILER_ID "OpenWatcom" + /* __WATCOMC__ = VVRP + 1100 */ +# define COMPILER_VERSION_MAJOR DEC((__WATCOMC__ - 1100) / 100) +# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__SUNPRO_CC) +# define COMPILER_ID "SunPro" +# if __SUNPRO_CC >= 0x5100 + /* __SUNPRO_CC = 0xVRRP */ +# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>12) +# define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xFF) +# define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF) +# else + /* __SUNPRO_CC = 0xVRP */ +# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>8) +# define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xF) +# define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF) +# endif + +#elif defined(__HP_aCC) +# define COMPILER_ID "HP" + /* __HP_aCC = VVRRPP */ +# define COMPILER_VERSION_MAJOR DEC(__HP_aCC/10000) +# define COMPILER_VERSION_MINOR DEC(__HP_aCC/100 % 100) +# define COMPILER_VERSION_PATCH DEC(__HP_aCC % 100) + +#elif defined(__DECCXX) +# define COMPILER_ID "Compaq" + /* __DECCXX_VER = VVRRTPPPP */ +# define COMPILER_VERSION_MAJOR DEC(__DECCXX_VER/10000000) +# define COMPILER_VERSION_MINOR DEC(__DECCXX_VER/100000 % 100) +# define COMPILER_VERSION_PATCH DEC(__DECCXX_VER % 10000) + +#elif defined(__IBMCPP__) && defined(__COMPILER_VER__) +# define COMPILER_ID "zOS" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__ibmxl__) && defined(__clang__) +# define COMPILER_ID "XLClang" +# define COMPILER_VERSION_MAJOR DEC(__ibmxl_version__) +# define COMPILER_VERSION_MINOR DEC(__ibmxl_release__) +# define COMPILER_VERSION_PATCH DEC(__ibmxl_modification__) +# define COMPILER_VERSION_TWEAK DEC(__ibmxl_ptf_fix_level__) + + +#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ >= 800 +# define COMPILER_ID "XL" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ < 800 +# define COMPILER_ID "VisualAge" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__NVCOMPILER) +# define COMPILER_ID "NVHPC" +# define COMPILER_VERSION_MAJOR DEC(__NVCOMPILER_MAJOR__) +# define COMPILER_VERSION_MINOR DEC(__NVCOMPILER_MINOR__) +# if defined(__NVCOMPILER_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__NVCOMPILER_PATCHLEVEL__) +# endif + +#elif defined(__PGI) +# define COMPILER_ID "PGI" +# define COMPILER_VERSION_MAJOR DEC(__PGIC__) +# define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__) +# if defined(__PGIC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__) +# endif + +#elif defined(_CRAYC) +# define COMPILER_ID "Cray" +# define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR) +# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR) + +#elif defined(__TI_COMPILER_VERSION__) +# define COMPILER_ID "TI" + /* __TI_COMPILER_VERSION__ = VVVRRRPPP */ +# define COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000) +# define COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000 % 1000) +# define COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__ % 1000) + +#elif defined(__FUJITSU) || defined(__FCC_VERSION) || defined(__fcc_version) +# define COMPILER_ID "Fujitsu" + +#elif defined(__ghs__) +# define COMPILER_ID "GHS" +/* __GHS_VERSION_NUMBER = VVVVRP */ +# ifdef __GHS_VERSION_NUMBER +# define COMPILER_VERSION_MAJOR DEC(__GHS_VERSION_NUMBER / 100) +# define COMPILER_VERSION_MINOR DEC(__GHS_VERSION_NUMBER / 10 % 10) +# define COMPILER_VERSION_PATCH DEC(__GHS_VERSION_NUMBER % 10) +# endif + +#elif defined(__SCO_VERSION__) +# define COMPILER_ID "SCO" + +#elif defined(__ARMCC_VERSION) && !defined(__clang__) +# define COMPILER_ID "ARMCC" +#if __ARMCC_VERSION >= 1000000 + /* __ARMCC_VERSION = VRRPPPP */ + # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/1000000) + # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 100) + # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#else + /* __ARMCC_VERSION = VRPPPP */ + # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/100000) + # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 10) + # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#endif + + +#elif defined(__clang__) && defined(__apple_build_version__) +# define COMPILER_ID "AppleClang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif +# define COMPILER_VERSION_TWEAK DEC(__apple_build_version__) + +#elif defined(__clang__) && defined(__ARMCOMPILER_VERSION) +# define COMPILER_ID "ARMClang" + # define COMPILER_VERSION_MAJOR DEC(__ARMCOMPILER_VERSION/1000000) + # define COMPILER_VERSION_MINOR DEC(__ARMCOMPILER_VERSION/10000 % 100) + # define COMPILER_VERSION_PATCH DEC(__ARMCOMPILER_VERSION % 10000) +# define COMPILER_VERSION_INTERNAL DEC(__ARMCOMPILER_VERSION) + +#elif defined(__clang__) +# define COMPILER_ID "Clang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif + +#elif defined(__GNUC__) || defined(__GNUG__) +# define COMPILER_ID "GNU" +# if defined(__GNUC__) +# define COMPILER_VERSION_MAJOR DEC(__GNUC__) +# else +# define COMPILER_VERSION_MAJOR DEC(__GNUG__) +# endif +# if defined(__GNUC_MINOR__) +# define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif +# if defined(__GNUC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif + +#elif defined(_MSC_VER) +# define COMPILER_ID "MSVC" + /* _MSC_VER = VVRR */ +# define COMPILER_VERSION_MAJOR DEC(_MSC_VER / 100) +# define COMPILER_VERSION_MINOR DEC(_MSC_VER % 100) +# if defined(_MSC_FULL_VER) +# if _MSC_VER >= 1400 + /* _MSC_FULL_VER = VVRRPPPPP */ +# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 100000) +# else + /* _MSC_FULL_VER = VVRRPPPP */ +# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 10000) +# endif +# endif +# if defined(_MSC_BUILD) +# define COMPILER_VERSION_TWEAK DEC(_MSC_BUILD) +# endif + +#elif defined(__VISUALDSPVERSION__) || defined(__ADSPBLACKFIN__) || defined(__ADSPTS__) || defined(__ADSP21000__) +# define COMPILER_ID "ADSP" +#if defined(__VISUALDSPVERSION__) + /* __VISUALDSPVERSION__ = 0xVVRRPP00 */ +# define COMPILER_VERSION_MAJOR HEX(__VISUALDSPVERSION__>>24) +# define COMPILER_VERSION_MINOR HEX(__VISUALDSPVERSION__>>16 & 0xFF) +# define COMPILER_VERSION_PATCH HEX(__VISUALDSPVERSION__>>8 & 0xFF) +#endif + +#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC) +# define COMPILER_ID "IAR" +# if defined(__VER__) && defined(__ICCARM__) +# define COMPILER_VERSION_MAJOR DEC((__VER__) / 1000000) +# define COMPILER_VERSION_MINOR DEC(((__VER__) / 1000) % 1000) +# define COMPILER_VERSION_PATCH DEC((__VER__) % 1000) +# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__) +# elif defined(__VER__) && (defined(__ICCAVR__) || defined(__ICCRX__) || defined(__ICCRH850__) || defined(__ICCRL78__) || defined(__ICC430__) || defined(__ICCRISCV__) || defined(__ICCV850__) || defined(__ICC8051__) || defined(__ICCSTM8__)) +# define COMPILER_VERSION_MAJOR DEC((__VER__) / 100) +# define COMPILER_VERSION_MINOR DEC((__VER__) - (((__VER__) / 100)*100)) +# define COMPILER_VERSION_PATCH DEC(__SUBVERSION__) +# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__) +# endif + + +/* These compilers are either not known or too old to define an + identification macro. Try to identify the platform and guess that + it is the native compiler. */ +#elif defined(__hpux) || defined(__hpua) +# define COMPILER_ID "HP" + +#else /* unknown compiler */ +# define COMPILER_ID "" +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]"; +#ifdef SIMULATE_ID +char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]"; +#endif + +#ifdef __QNXNTO__ +char const* qnxnto = "INFO" ":" "qnxnto[]"; +#endif + +#if defined(__CRAYXT_COMPUTE_LINUX_TARGET) +char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]"; +#endif + +#define STRINGIFY_HELPER(X) #X +#define STRINGIFY(X) STRINGIFY_HELPER(X) + +/* Identify known platforms by name. */ +#if defined(__linux) || defined(__linux__) || defined(linux) +# define PLATFORM_ID "Linux" + +#elif defined(__CYGWIN__) +# define PLATFORM_ID "Cygwin" + +#elif defined(__MINGW32__) +# define PLATFORM_ID "MinGW" + +#elif defined(__APPLE__) +# define PLATFORM_ID "Darwin" + +#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32) +# define PLATFORM_ID "Windows" + +#elif defined(__FreeBSD__) || defined(__FreeBSD) +# define PLATFORM_ID "FreeBSD" + +#elif defined(__NetBSD__) || defined(__NetBSD) +# define PLATFORM_ID "NetBSD" + +#elif defined(__OpenBSD__) || defined(__OPENBSD) +# define PLATFORM_ID "OpenBSD" + +#elif defined(__sun) || defined(sun) +# define PLATFORM_ID "SunOS" + +#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__) +# define PLATFORM_ID "AIX" + +#elif defined(__hpux) || defined(__hpux__) +# define PLATFORM_ID "HP-UX" + +#elif defined(__HAIKU__) +# define PLATFORM_ID "Haiku" + +#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS) +# define PLATFORM_ID "BeOS" + +#elif defined(__QNX__) || defined(__QNXNTO__) +# define PLATFORM_ID "QNX" + +#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__) +# define PLATFORM_ID "Tru64" + +#elif defined(__riscos) || defined(__riscos__) +# define PLATFORM_ID "RISCos" + +#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__) +# define PLATFORM_ID "SINIX" + +#elif defined(__UNIX_SV__) +# define PLATFORM_ID "UNIX_SV" + +#elif defined(__bsdos__) +# define PLATFORM_ID "BSDOS" + +#elif defined(_MPRAS) || defined(MPRAS) +# define PLATFORM_ID "MP-RAS" + +#elif defined(__osf) || defined(__osf__) +# define PLATFORM_ID "OSF1" + +#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv) +# define PLATFORM_ID "SCO_SV" + +#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX) +# define PLATFORM_ID "ULTRIX" + +#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX) +# define PLATFORM_ID "Xenix" + +#elif defined(__WATCOMC__) +# if defined(__LINUX__) +# define PLATFORM_ID "Linux" + +# elif defined(__DOS__) +# define PLATFORM_ID "DOS" + +# elif defined(__OS2__) +# define PLATFORM_ID "OS2" + +# elif defined(__WINDOWS__) +# define PLATFORM_ID "Windows3x" + +# elif defined(__VXWORKS__) +# define PLATFORM_ID "VxWorks" + +# else /* unknown platform */ +# define PLATFORM_ID +# endif + +#elif defined(__INTEGRITY) +# if defined(INT_178B) +# define PLATFORM_ID "Integrity178" + +# else /* regular Integrity */ +# define PLATFORM_ID "Integrity" +# endif + +#else /* unknown platform */ +# define PLATFORM_ID + +#endif + +/* For windows compilers MSVC and Intel we can determine + the architecture of the compiler being used. This is because + the compilers do not have flags that can change the architecture, + but rather depend on which compiler is being used +*/ +#if defined(_WIN32) && defined(_MSC_VER) +# if defined(_M_IA64) +# define ARCHITECTURE_ID "IA64" + +# elif defined(_M_ARM64EC) +# define ARCHITECTURE_ID "ARM64EC" + +# elif defined(_M_X64) || defined(_M_AMD64) +# define ARCHITECTURE_ID "x64" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# elif defined(_M_ARM64) +# define ARCHITECTURE_ID "ARM64" + +# elif defined(_M_ARM) +# if _M_ARM == 4 +# define ARCHITECTURE_ID "ARMV4I" +# elif _M_ARM == 5 +# define ARCHITECTURE_ID "ARMV5I" +# else +# define ARCHITECTURE_ID "ARMV" STRINGIFY(_M_ARM) +# endif + +# elif defined(_M_MIPS) +# define ARCHITECTURE_ID "MIPS" + +# elif defined(_M_SH) +# define ARCHITECTURE_ID "SHx" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__WATCOMC__) +# if defined(_M_I86) +# define ARCHITECTURE_ID "I86" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC) +# if defined(__ICCARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__ICCRX__) +# define ARCHITECTURE_ID "RX" + +# elif defined(__ICCRH850__) +# define ARCHITECTURE_ID "RH850" + +# elif defined(__ICCRL78__) +# define ARCHITECTURE_ID "RL78" + +# elif defined(__ICCRISCV__) +# define ARCHITECTURE_ID "RISCV" + +# elif defined(__ICCAVR__) +# define ARCHITECTURE_ID "AVR" + +# elif defined(__ICC430__) +# define ARCHITECTURE_ID "MSP430" + +# elif defined(__ICCV850__) +# define ARCHITECTURE_ID "V850" + +# elif defined(__ICC8051__) +# define ARCHITECTURE_ID "8051" + +# elif defined(__ICCSTM8__) +# define ARCHITECTURE_ID "STM8" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__ghs__) +# if defined(__PPC64__) +# define ARCHITECTURE_ID "PPC64" + +# elif defined(__ppc__) +# define ARCHITECTURE_ID "PPC" + +# elif defined(__ARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__x86_64__) +# define ARCHITECTURE_ID "x64" + +# elif defined(__i386__) +# define ARCHITECTURE_ID "X86" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__TI_COMPILER_VERSION__) +# if defined(__TI_ARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__MSP430__) +# define ARCHITECTURE_ID "MSP430" + +# elif defined(__TMS320C28XX__) +# define ARCHITECTURE_ID "TMS320C28x" + +# elif defined(__TMS320C6X__) || defined(_TMS320C6X) +# define ARCHITECTURE_ID "TMS320C6x" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#else +# define ARCHITECTURE_ID +#endif + +/* Convert integer to decimal digit literals. */ +#define DEC(n) \ + ('0' + (((n) / 10000000)%10)), \ + ('0' + (((n) / 1000000)%10)), \ + ('0' + (((n) / 100000)%10)), \ + ('0' + (((n) / 10000)%10)), \ + ('0' + (((n) / 1000)%10)), \ + ('0' + (((n) / 100)%10)), \ + ('0' + (((n) / 10)%10)), \ + ('0' + ((n) % 10)) + +/* Convert integer to hex digit literals. */ +#define HEX(n) \ + ('0' + ((n)>>28 & 0xF)), \ + ('0' + ((n)>>24 & 0xF)), \ + ('0' + ((n)>>20 & 0xF)), \ + ('0' + ((n)>>16 & 0xF)), \ + ('0' + ((n)>>12 & 0xF)), \ + ('0' + ((n)>>8 & 0xF)), \ + ('0' + ((n)>>4 & 0xF)), \ + ('0' + ((n) & 0xF)) + +/* Construct a string literal encoding the version number components. */ +#ifdef COMPILER_VERSION_MAJOR +char const info_version[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[', + COMPILER_VERSION_MAJOR, +# ifdef COMPILER_VERSION_MINOR + '.', COMPILER_VERSION_MINOR, +# ifdef COMPILER_VERSION_PATCH + '.', COMPILER_VERSION_PATCH, +# ifdef COMPILER_VERSION_TWEAK + '.', COMPILER_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct a string literal encoding the internal version number. */ +#ifdef COMPILER_VERSION_INTERNAL +char const info_version_internal[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','_', + 'i','n','t','e','r','n','a','l','[', + COMPILER_VERSION_INTERNAL,']','\0'}; +#endif + +/* Construct a string literal encoding the version number components. */ +#ifdef SIMULATE_VERSION_MAJOR +char const info_simulate_version[] = { + 'I', 'N', 'F', 'O', ':', + 's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[', + SIMULATE_VERSION_MAJOR, +# ifdef SIMULATE_VERSION_MINOR + '.', SIMULATE_VERSION_MINOR, +# ifdef SIMULATE_VERSION_PATCH + '.', SIMULATE_VERSION_PATCH, +# ifdef SIMULATE_VERSION_TWEAK + '.', SIMULATE_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_platform = "INFO" ":" "platform[" PLATFORM_ID "]"; +char const* info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]"; + + + +#if defined(__INTEL_COMPILER) && defined(_MSVC_LANG) && _MSVC_LANG < 201403L +# if defined(__INTEL_CXX11_MODE__) +# if defined(__cpp_aggregate_nsdmi) +# define CXX_STD 201402L +# else +# define CXX_STD 201103L +# endif +# else +# define CXX_STD 199711L +# endif +#elif defined(_MSC_VER) && defined(_MSVC_LANG) +# define CXX_STD _MSVC_LANG +#else +# define CXX_STD __cplusplus +#endif + +const char* info_language_dialect_default = "INFO" ":" "dialect_default[" +#if CXX_STD > 202002L + "23" +#elif CXX_STD > 201703L + "20" +#elif CXX_STD >= 201703L + "17" +#elif CXX_STD >= 201402L + "14" +#elif CXX_STD >= 201103L + "11" +#else + "98" +#endif +"]"; + +/*--------------------------------------------------------------------------*/ + +int main(int argc, char* argv[]) +{ + int require = 0; + require += info_compiler[argc]; + require += info_platform[argc]; +#ifdef COMPILER_VERSION_MAJOR + require += info_version[argc]; +#endif +#ifdef COMPILER_VERSION_INTERNAL + require += info_version_internal[argc]; +#endif +#ifdef SIMULATE_ID + require += info_simulate[argc]; +#endif +#ifdef SIMULATE_VERSION_MAJOR + require += info_simulate_version[argc]; +#endif +#if defined(__CRAYXT_COMPUTE_LINUX_TARGET) + require += info_cray[argc]; +#endif + require += info_language_dialect_default[argc]; + (void)argv; + return require; +} diff --git a/build/CMakeFiles/3.20.21032501-MSVC_2/CompilerIdCXX/CMakeCXXCompilerId.o b/build/CMakeFiles/3.20.21032501-MSVC_2/CompilerIdCXX/CMakeCXXCompilerId.o new file mode 100644 index 0000000000000000000000000000000000000000..dcae6903356d33b1c42c439212e79eb99732727f GIT binary patch literal 2264 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 literal 0 HcmV?d00001 diff --git a/build/CMakeFiles/feature_tests.cxx b/build/CMakeFiles/feature_tests.cxx new file mode 100644 index 0000000..82b99b9 --- /dev/null +++ b/build/CMakeFiles/feature_tests.cxx @@ -0,0 +1,398 @@ + + const char features[] = {"\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __cplusplus >= 199711L +"1" +#else +"0" +#endif +"cxx_template_template_parameters\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_alias_templates) +"1" +#else +"0" +#endif +"cxx_alias_templates\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_alignas) +"1" +#else +"0" +#endif +"cxx_alignas\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_alignas) +"1" +#else +"0" +#endif +"cxx_alignof\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_attributes) +"1" +#else +"0" +#endif +"cxx_attributes\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_auto_type) +"1" +#else +"0" +#endif +"cxx_auto_type\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_constexpr) +"1" +#else +"0" +#endif +"cxx_constexpr\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_decltype) +"1" +#else +"0" +#endif +"cxx_decltype\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_default_function_template_args) +"1" +#else +"0" +#endif +"cxx_default_function_template_args\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_defaulted_functions) +"1" +#else +"0" +#endif +"cxx_defaulted_functions\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_defaulted_functions) +"1" +#else +"0" +#endif +"cxx_defaulted_move_initializers\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_delegating_constructors) +"1" +#else +"0" +#endif +"cxx_delegating_constructors\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_deleted_functions) +"1" +#else +"0" +#endif +"cxx_deleted_functions\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_enum_forward_declarations\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_explicit_conversions) +"1" +#else +"0" +#endif +"cxx_explicit_conversions\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_extended_friend_declarations\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_extern_templates\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_override_control) +"1" +#else +"0" +#endif +"cxx_final\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_func_identifier\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_generalized_initializers) +"1" +#else +"0" +#endif +"cxx_generalized_initializers\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_inheriting_constructors) +"1" +#else +"0" +#endif +"cxx_inheriting_constructors\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_inline_namespaces\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_lambdas) +"1" +#else +"0" +#endif +"cxx_lambdas\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_local_type_template_args) +"1" +#else +"0" +#endif +"cxx_local_type_template_args\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_long_long_type\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_noexcept) +"1" +#else +"0" +#endif +"cxx_noexcept\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_nonstatic_member_init) +"1" +#else +"0" +#endif +"cxx_nonstatic_member_init\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_nullptr) +"1" +#else +"0" +#endif +"cxx_nullptr\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_override_control) +"1" +#else +"0" +#endif +"cxx_override\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_range_for) +"1" +#else +"0" +#endif +"cxx_range_for\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_raw_string_literals) +"1" +#else +"0" +#endif +"cxx_raw_string_literals\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_reference_qualified_functions) +"1" +#else +"0" +#endif +"cxx_reference_qualified_functions\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_right_angle_brackets\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_rvalue_references) +"1" +#else +"0" +#endif +"cxx_rvalue_references\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_sizeof_member\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_static_assert) +"1" +#else +"0" +#endif +"cxx_static_assert\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_strong_enums) +"1" +#else +"0" +#endif +"cxx_strong_enums\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_thread_local) +"1" +#else +"0" +#endif +"cxx_thread_local\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_trailing_return) +"1" +#else +"0" +#endif +"cxx_trailing_return_types\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_unicode_literals) +"1" +#else +"0" +#endif +"cxx_unicode_literals\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_generalized_initializers) +"1" +#else +"0" +#endif +"cxx_uniform_initialization\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_unrestricted_unions) +"1" +#else +"0" +#endif +"cxx_unrestricted_unions\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_user_literals) +"1" +#else +"0" +#endif +"cxx_user_literals\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_variadic_macros\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_variadic_templates) +"1" +#else +"0" +#endif +"cxx_variadic_templates\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_aggregate_nsdmi) +"1" +#else +"0" +#endif +"cxx_aggregate_default_initializers\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 304 && __cplusplus > 201103L +"1" +#else +"0" +#endif +"cxx_attribute_deprecated\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_binary_literals) +"1" +#else +"0" +#endif +"cxx_binary_literals\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_contextual_conversions) +"1" +#else +"0" +#endif +"cxx_contextual_conversions\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 304 && __cplusplus > 201103L +"1" +#else +"0" +#endif +"cxx_decltype_auto\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 304 && __cplusplus > 201103L +"1" +#else +"0" +#endif +"cxx_digit_separators\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 304 && __cplusplus > 201103L +"1" +#else +"0" +#endif +"cxx_generic_lambdas\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_init_captures) +"1" +#else +"0" +#endif +"cxx_lambda_init_captures\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_relaxed_constexpr) +"1" +#else +"0" +#endif +"cxx_relaxed_constexpr\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_return_type_deduction) +"1" +#else +"0" +#endif +"cxx_return_type_deduction\n" +"CXX_FEATURE:" +#if ((__clang_major__ * 100) + __clang_minor__) >= 301 && __has_feature(cxx_variable_templates) +"1" +#else +"0" +#endif +"cxx_variable_templates\n" + +}; + +int main(int argc, char** argv) { (void)argv; return features[argc]; } diff --git a/build/CMakeFiles/mirror-test.dir/main.cpp.obj b/build/CMakeFiles/mirror-test.dir/main.cpp.obj new file mode 100644 index 0000000000000000000000000000000000000000..7fbe1949139183579136467adf633c19ad3580e9 GIT binary patch literal 23799 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%0D505&6%^Pa~f} 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 ZwbqNBD|RvsgM+K^V+_%t3Svvd{{u2LcNG8t literal 0 HcmV?d00001 diff --git a/build/CMakeFiles/rules.ninja b/build/CMakeFiles/rules.ninja new file mode 100644 index 0000000..c932706 --- /dev/null +++ b/build/CMakeFiles/rules.ninja @@ -0,0 +1,64 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Ninja" Generator, CMake Version 3.20 + +# This file contains all the rules used to get the outputs files +# built from the input files. +# It is included in the main 'build.ninja'. + +# ============================================================================= +# Project: test +# Configurations: Debug +# ============================================================================= +# ============================================================================= + +############################################# +# Rule for running custom commands. + +rule CUSTOM_COMMAND + command = $COMMAND + description = $DESC + + +############################################# +# Rule for compiling CXX files. + +rule CXX_COMPILER__mirror-test_Debug + depfile = $DEP_FILE + deps = gcc + command = C:\PROGRA~2\MICROS~2\2019\COMMUN~1\VC\Tools\Llvm\x64\bin\clang.exe $DEFINES $INCLUDES $FLAGS -MD -MT $out -MF $DEP_FILE -o $out -c $in + description = Building CXX object $out + + +############################################# +# Rule for linking CXX executable. + +rule CXX_EXECUTABLE_LINKER__mirror-test_Debug + command = cmd.exe /C "$PRE_LINK && C:\PROGRA~2\MICROS~2\2019\COMMUN~1\VC\Tools\Llvm\x64\bin\clang.exe -fuse-ld=lld-link -nostartfiles -nostdlib $FLAGS $LINK_FLAGS $in -o $TARGET_FILE -Xlinker /implib:$TARGET_IMPLIB -Xlinker /pdb:$TARGET_PDB -Xlinker /version:0.0 $LINK_PATH $LINK_LIBRARIES && $POST_BUILD" + description = Linking CXX executable $TARGET_FILE + restat = $RESTAT + + +############################################# +# Rule for re-running cmake. + +rule RERUN_CMAKE + command = "C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\Common7\IDE\CommonExtensions\Microsoft\CMake\CMake\bin\cmake.exe" --regenerate-during-build -SE:\Desktop\mirror-test -BE:\Desktop\mirror-test\build + description = Re-running CMake... + generator = 1 + + +############################################# +# Rule for cleaning all built files. + +rule CLEAN + command = C:\PROGRA~2\MICROS~2\2019\COMMUN~1\Common7\IDE\COMMON~1\MICROS~1\CMake\Ninja\ninja.exe $FILE_ARG -t clean $TARGETS + description = Cleaning all built files... + + +############################################# +# Rule for printing all primary targets available. + +rule HELP + command = C:\PROGRA~2\MICROS~2\2019\COMMUN~1\Common7\IDE\COMMON~1\MICROS~1\CMake\Ninja\ninja.exe -t targets + description = All primary targets available: + diff --git a/build/build.ninja b/build/build.ninja new file mode 100644 index 0000000..6fed022 --- /dev/null +++ b/build/build.ninja @@ -0,0 +1,144 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Ninja" Generator, CMake Version 3.20 + +# This file contains all the build statements describing the +# compilation DAG. + +# ============================================================================= +# Write statements declared in CMakeLists.txt: +# +# Which is the root file. +# ============================================================================= + +# ============================================================================= +# Project: test +# Configurations: Debug +# ============================================================================= + +############################################# +# Minimal version of Ninja required by this file + +ninja_required_version = 1.5 + + +############################################# +# Set configuration variable for custom commands. + +CONFIGURATION = Debug +# ============================================================================= +# Include auxiliary files. + + +############################################# +# Include rules file. + +include CMakeFiles/rules.ninja + + +############################################# +# Utility command for rebuild_cache + +build CMakeFiles/rebuild_cache.util: CUSTOM_COMMAND + COMMAND = cmd.exe /C "cd /D E:\Desktop\mirror-test\build && "C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\Common7\IDE\CommonExtensions\Microsoft\CMake\CMake\bin\cmake.exe" --regenerate-during-build -SE:\Desktop\mirror-test -BE:\Desktop\mirror-test\build" + DESC = Running CMake to regenerate build system... + pool = console + restat = 1 + +build rebuild_cache: phony CMakeFiles/rebuild_cache.util + +# ============================================================================= +# Object build statements for EXECUTABLE target mirror-test + + +############################################# +# Order-only phony target for mirror-test + +build cmake_object_order_depends_target_mirror-test: phony || CMakeFiles/mirror-test.dir + +build CMakeFiles/mirror-test.dir/main.cpp.obj: CXX_COMPILER__mirror-test_Debug ../main.cpp || cmake_object_order_depends_target_mirror-test + DEP_FILE = CMakeFiles\mirror-test.dir\main.cpp.obj.d + FLAGS = -g -Xclang -gcodeview -O0 -D_DEBUG -D_DLL -D_MT -Xclang --dependent-lib=msvcrtd -std=gnu++14 + OBJECT_DIR = CMakeFiles\mirror-test.dir + OBJECT_FILE_DIR = CMakeFiles\mirror-test.dir + TARGET_COMPILE_PDB = CMakeFiles\mirror-test.dir\ + TARGET_PDB = mirror-test.pdb + + +# ============================================================================= +# Link build statements for EXECUTABLE target mirror-test + + +############################################# +# Link the executable mirror-test.exe + +build mirror-test.exe: CXX_EXECUTABLE_LINKER__mirror-test_Debug CMakeFiles/mirror-test.dir/main.cpp.obj + FLAGS = -g -Xclang -gcodeview -O0 -D_DEBUG -D_DLL -D_MT -Xclang --dependent-lib=msvcrtd + LINK_FLAGS = -Xlinker /subsystem:console + LINK_LIBRARIES = -lkernel32 -luser32 -lgdi32 -lwinspool -lshell32 -lole32 -loleaut32 -luuid -lcomdlg32 -ladvapi32 -loldnames + OBJECT_DIR = CMakeFiles\mirror-test.dir + POST_BUILD = cd . + PRE_LINK = cd . + TARGET_COMPILE_PDB = CMakeFiles\mirror-test.dir\ + TARGET_FILE = mirror-test.exe + TARGET_IMPLIB = mirror-test.lib + TARGET_PDB = mirror-test.pdb + + +############################################# +# Utility command for edit_cache + +build CMakeFiles/edit_cache.util: CUSTOM_COMMAND + COMMAND = cmd.exe /C "cd /D E:\Desktop\mirror-test\build && "C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\Common7\IDE\CommonExtensions\Microsoft\CMake\CMake\bin\cmake.exe" -E echo "No interactive CMake dialog available."" + DESC = No interactive CMake dialog available... + restat = 1 + +build edit_cache: phony CMakeFiles/edit_cache.util + +# ============================================================================= +# Target aliases. + +build mirror-test: phony mirror-test.exe + +# ============================================================================= +# Folder targets. + +# ============================================================================= + +############################################# +# Folder: E:/Desktop/mirror-test/build + +build all: phony mirror-test.exe + +# ============================================================================= +# Built-in targets + + +############################################# +# Re-run CMake if any of its inputs changed. + +build build.ninja: RERUN_CMAKE | ../CMakeLists.txt C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeCXXCompiler.cmake.in C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeCXXCompilerABI.cpp C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeCXXInformation.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeCommonLanguageInclude.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeCompilerIdDetection.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeDetermineCXXCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeDetermineCompileFeatures.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeDetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeDetermineCompilerABI.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeDetermineCompilerId.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeDetermineRCCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeDetermineSystem.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeFindBinUtils.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeGenericSystem.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeInitializeConfigs.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeLanguageInformation.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeNinjaFindMake.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeParseImplicitIncludeInfo.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeParseImplicitLinkInfo.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeParseLibraryArchitecture.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeRCCompiler.cmake.in C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeRCInformation.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeSystem.cmake.in C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeSystemSpecificInformation.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeSystemSpecificInitialize.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeTestCXXCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeTestCompilerCommon.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeTestRCCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/ADSP-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/ARMCC-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/ARMClang-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/AppleClang-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Borland-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/CMakeCommonCompilerMacros.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Clang-CXX-FeatureTests.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Clang-CXX-TestableFeatures.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Clang-CXX.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Clang-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Clang-DetermineCompilerInternal.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Clang-FindBinUtils.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Clang.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Comeau-CXX-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Compaq-CXX-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Cray-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Embarcadero-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Fujitsu-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/GHS-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/GNU-CXX-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/HP-CXX-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/IAR-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/IBMCPP-CXX-DetermineVersionInternal.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Intel-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/IntelLLVM-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/MSVC-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/NVHPC-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/NVIDIA-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/OpenWatcom-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/PGI-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/PathScale-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/SCO-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/SunPro-CXX-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/TI-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/VisualAge-CXX-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Watcom-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/XL-CXX-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/XLClang-CXX-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/zOS-CXX-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Internal/FeatureTesting.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Platform/Windows-Clang-CXX.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Platform/Windows-Clang.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Platform/Windows-Determine-CXX.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Platform/Windows.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Platform/WindowsPaths.cmake CMakeCache.txt CMakeFiles/3.20.21032501-MSVC_2/CMakeCXXCompiler.cmake CMakeFiles/3.20.21032501-MSVC_2/CMakeRCCompiler.cmake CMakeFiles/3.20.21032501-MSVC_2/CMakeSystem.cmake CMakeFiles/feature_tests.cxx + pool = console + + +############################################# +# A missing CMake input file is not an error. + +build ../CMakeLists.txt C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeCXXCompiler.cmake.in C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeCXXCompilerABI.cpp C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeCXXInformation.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeCommonLanguageInclude.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeCompilerIdDetection.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeDetermineCXXCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeDetermineCompileFeatures.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeDetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeDetermineCompilerABI.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeDetermineCompilerId.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeDetermineRCCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeDetermineSystem.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeFindBinUtils.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeGenericSystem.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeInitializeConfigs.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeLanguageInformation.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeNinjaFindMake.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeParseImplicitIncludeInfo.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeParseImplicitLinkInfo.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeParseLibraryArchitecture.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeRCCompiler.cmake.in C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeRCInformation.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeSystem.cmake.in C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeSystemSpecificInformation.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeSystemSpecificInitialize.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeTestCXXCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeTestCompilerCommon.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/CMakeTestRCCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/ADSP-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/ARMCC-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/ARMClang-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/AppleClang-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Borland-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/CMakeCommonCompilerMacros.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Clang-CXX-FeatureTests.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Clang-CXX-TestableFeatures.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Clang-CXX.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Clang-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Clang-DetermineCompilerInternal.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Clang-FindBinUtils.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Clang.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Comeau-CXX-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Compaq-CXX-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Cray-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Embarcadero-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Fujitsu-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/GHS-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/GNU-CXX-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/HP-CXX-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/IAR-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/IBMCPP-CXX-DetermineVersionInternal.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Intel-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/IntelLLVM-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/MSVC-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/NVHPC-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/NVIDIA-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/OpenWatcom-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/PGI-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/PathScale-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/SCO-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/SunPro-CXX-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/TI-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/VisualAge-CXX-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/Watcom-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/XL-CXX-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/XLClang-CXX-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Compiler/zOS-CXX-DetermineCompiler.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Internal/FeatureTesting.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Platform/Windows-Clang-CXX.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Platform/Windows-Clang.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Platform/Windows-Determine-CXX.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Platform/Windows.cmake C$:/Program$ Files$ (x86)/Microsoft$ Visual$ Studio/2019/Community/Common7/IDE/CommonExtensions/Microsoft/CMake/CMake/share/cmake-3.20/Modules/Platform/WindowsPaths.cmake CMakeCache.txt CMakeFiles/3.20.21032501-MSVC_2/CMakeCXXCompiler.cmake CMakeFiles/3.20.21032501-MSVC_2/CMakeRCCompiler.cmake CMakeFiles/3.20.21032501-MSVC_2/CMakeSystem.cmake CMakeFiles/feature_tests.cxx: phony + + +############################################# +# Clean all the built files. + +build clean: CLEAN + + +############################################# +# Print all primary targets available. + +build help: HELP + + +############################################# +# Make the all target the default. + +default all diff --git a/build/cmake_install.cmake b/build/cmake_install.cmake new file mode 100644 index 0000000..2920d2e --- /dev/null +++ b/build/cmake_install.cmake @@ -0,0 +1,49 @@ +# Install script for directory: E:/Desktop/mirror-test + +# Set the install prefix +if(NOT DEFINED CMAKE_INSTALL_PREFIX) + set(CMAKE_INSTALL_PREFIX "C:/Program Files (x86)/test") +endif() +string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}") + +# Set the install configuration name. +if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME) + if(BUILD_TYPE) + string(REGEX REPLACE "^[^A-Za-z0-9_]+" "" + CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}") + else() + set(CMAKE_INSTALL_CONFIG_NAME "Debug") + endif() + message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"") +endif() + +# Set the component getting installed. +if(NOT CMAKE_INSTALL_COMPONENT) + if(COMPONENT) + message(STATUS "Install component: \"${COMPONENT}\"") + set(CMAKE_INSTALL_COMPONENT "${COMPONENT}") + else() + set(CMAKE_INSTALL_COMPONENT) + endif() +endif() + +# Is this installation the result of a crosscompile? +if(NOT DEFINED CMAKE_CROSSCOMPILING) + set(CMAKE_CROSSCOMPILING "FALSE") +endif() + +# Set default install directory permissions. +if(NOT DEFINED CMAKE_OBJDUMP) + set(CMAKE_OBJDUMP "C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/Llvm/x64/bin/llvm-objdump.exe") +endif() + +if(CMAKE_INSTALL_COMPONENT) + set(CMAKE_INSTALL_MANIFEST "install_manifest_${CMAKE_INSTALL_COMPONENT}.txt") +else() + set(CMAKE_INSTALL_MANIFEST "install_manifest.txt") +endif() + +string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT + "${CMAKE_INSTALL_MANIFEST_FILES}") +file(WRITE "E:/Desktop/mirror-test/build/${CMAKE_INSTALL_MANIFEST}" + "${CMAKE_INSTALL_MANIFEST_CONTENT}") diff --git a/build/compile_commands.json b/build/compile_commands.json new file mode 100644 index 0000000..3ec9b8e --- /dev/null +++ b/build/compile_commands.json @@ -0,0 +1,7 @@ +[ +{ + "directory": "E:/Desktop/mirror-test/build", + "command": "C:\\PROGRA~2\\MICROS~2\\2019\\COMMUN~1\\VC\\Tools\\Llvm\\x64\\bin\\clang.exe -g -Xclang -gcodeview -O0 -D_DEBUG -D_DLL -D_MT -Xclang --dependent-lib=msvcrtd -std=gnu++14 -o CMakeFiles\\mirror-test.dir\\main.cpp.obj -c E:\\Desktop\\mirror-test\\main.cpp", + "file": "E:/Desktop/mirror-test/main.cpp" +} +] \ No newline at end of file diff --git a/build/mirror-test.exe b/build/mirror-test.exe new file mode 100644 index 0000000000000000000000000000000000000000..c8c88ed19a83f6601cabe059aee785c0b2c71ee4 GIT binary patch literal 21504 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 int main(){ -std::cout << "Get fucked\n"; +std::cout << "Stop getting fucked \n"; } \ No newline at end of file diff --git a/randomtext.txt b/randomtext.txt new file mode 100644 index 0000000..1240583 --- /dev/null +++ b/randomtext.txt @@ -0,0 +1 @@ +hahaha \ No newline at end of file