std::string filename = setup.outputDir + "/CMakeLists.txt";

std::ofstream workspace(filename.c_str());

if (!workspace || !workspace.is_open())

error("Could not open \"" + filename + "\" for writing");

workspace << "cmake_minimum_required(VERSION 3.13)\n";

workspace << "project(" << setup.projectDescription << ")\n\n";

workspace << R"EOS(set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

)EOS";

workspace << R"EOS(function(add_engine engine_name)

target_link_libraries()EOS" << setup.projectName << R"( ${engine_name})

)";

workspace << "# Define the engines and subengines\n";

writeEngines(setup, workspace);

writeSubEngines(setup, workspace);

workspace << "# Generate options for the engines\n";

writeEngineOptions(workspace);

std::string includeDirsList;

for (const std::string &includeDir : setup.includeDirs)

includeDirsList += includeDir + ' ';

workspace << "include_directories(. ${"

<< setup.projectDescription << "_SOURCE_DIR}/" << setup.filePrefix

<< " ${" << setup.projectDescription << "_SOURCE_DIR}/" << setup.filePrefix << "/engines "

<< includeDirsList << "$ENV{"<<LIBS_DEFINE<<"}/include)\n\n";

workspace << "# Libraries and features\n\n";

writeFeatureLibSearch(setup, workspace, "sdl");

workspace << R"(# Depending on how SDL2 was built, there can be either and imported target or flags variables

)";

for (const Feature &feature : setup.features) {

if (!feature.enable || featureExcluded(feature.name)) continue;

writeFeatureLibSearch(setup, workspace, feature.name);

if (!feature.define || !feature.define[0]) continue;

workspace << "add_definitions(-D" << feature.define << ")\n";

}

workspace << "\n";

writeWarnings(workspace);

writeDefines(setup, workspace);

workspace << R"(# Generate "engines/plugins_table.h"

)";

const Library *library = getLibraryFromFeature(feature, setup.useSDL);

if (library) {

workspace << "find_feature(";

workspace << "name " << library->feature;

if (library->pkgConfig) {

workspace << " pkgconfig_name ";

workspace << library->pkgConfig;

}

if (library->package) {

workspace << " findpackage_name ";

workspace << library->package;

}

if (library->includesVar) {

workspace << " include_dirs_var ";

workspace << library->includesVar;

}

if (library->librariesVar) {

workspace << " libraries_var ";

workspace << library->librariesVar;

}

if (library->libraries) {

workspace << " libraries ";

workspace << library->libraries;

}

if (library->winLibraries) {

workspace << " win_libraries ";

workspace << library->winLibraries;

}

workspace << ")\n";

}

workspace << "set(ENGINES";

for (const EngineDesc &engine : setup.engines) {

// We ignore all sub engines here because they require special handling.

if (!engine.enable || isSubEngine(engine.name, setup.engines)) {

continue;

}

workspace << " " << toUpper(engine.name);

}

workspace << ")\n";

for (const EngineDesc &engine : setup.engines) {

// We ignore all sub engines here because they are handled in the inner loop

if (!engine.enable || isSubEngine(engine.name, setup.engines) || engine.subEngines.empty()) {

continue;

}

workspace << "set(SUB_ENGINES_" << toUpper(engine.name);

for (const std::string &subEngineName : engine.subEngines) {

const EngineDesc &subEngine = findEngineDesc(subEngineName, setup.engines);

if (!subEngine.enable) continue;

workspace << " " << toUpper(subEngineName);

}

workspace << ")\n";

}

workspace << "\n";

std::string modulePath;

if (!moduleDir.compare(0, setup.srcDir.size(), setup.srcDir)) {

modulePath = moduleDir.substr(setup.srcDir.size());

if (!modulePath.empty() && modulePath.at(0) == '/')

modulePath.erase(0, 1);

}

return modulePath.empty() ? setup.filePrefix : setup.filePrefix + '/' + modulePath;

const StringList &includeList, const StringList &excludeList, const std::string &pchIncludeRoot, const StringList &pchDirs, const StringList &pchExclude) {

const std::string projectFile = setup.outputDir + "/CMakeLists.txt";

std::ofstream project(projectFile.c_str(), std::ofstream::out | std::ofstream::app);

if (!project)

error("Could not open \"" + projectFile + "\" for writing");

if (name == setup.projectName) {

project << "add_executable(" << name;

// console subsystem is required for text-console, tools, and tests

if (setup.useWindowsSubsystem && !setup.featureEnabled("text-console") && !setup.devTools && !setup.tests) {

project << " WIN32";

}

project << "\n";

} else if (name == setup.projectName + "-detection") {

project << "list(APPEND SCUMMVM_LIBS " << name << ")\n";

project << "add_library(" << name << "\n";

} else {

enginesStr << "add_engine(" << name << "\n";

addFilesToProject(moduleDir, enginesStr, includeList, excludeList, pchIncludeRoot, pchDirs, pchExclude, filePrefix(setup, moduleDir));

enginesStr << ")\n\n";

return;

}

addFilesToProject(moduleDir, project, includeList, excludeList, pchIncludeRoot, pchDirs, pchExclude, filePrefix(setup, moduleDir));

project << ")\n";

project << "\n";

if (name == setup.projectName) {

project << "# Engines libraries handling\n";

writeEnginesLibrariesHandling(setup, project);

project << "# Libraries\n";

const Library *sdlLibrary = getLibraryFromFeature("sdl", setup.useSDL);

std::string libraryDirsList;

for (const std::string &libraryDir : setup.libraryDirs)

libraryDirsList += libraryDir + ' ';

project << "target_link_libraries(" << name << " " << libraryDirsList << "${" << sdlLibrary->librariesVar << "} ${SCUMMVM_LIBS})\n";

project << "if (WIN32)\n";

project << "\ttarget_sources(" << name << " PUBLIC " << setup.filePrefix << "/dists/" << name << ".rc)\n";

project << "\ttarget_link_libraries(" << name << " winmm)\n";

// Needed for select (used in socket.cpp), when curl is linked dynamically

project << "\tif (libcurl_FOUND)\n";

project << "\t\ttarget_link_libraries(" << name << " ws2_32)\n";

project << "\tendif()\n";

project << "endif()\n";

project << "\n";

project << "set_property(TARGET " << name << " PROPERTY CXX_STANDARD 11)\n";

project << "set_property(TARGET " << name << " PROPERTY CXX_STANDARD_REQUIRED ON)\n";

}

output << "if (MSVC)\n";

// TODO: Support MSVC warnings

output << "else()\n";

output << "\tset(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS}";

for (const std::string &warning : _globalWarnings) {

output << ' ' << warning;

}

output << "\")\n";

output << "\tif(CMAKE_CXX_COMPILER_ID STREQUAL \"GNU\")\n";

output << "\t\tif(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 7.1)\n";

output << "\t\t\tset(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -Wno-stringop-overflow\")\n";

output << "\t\tendif()\n";

output << "\t\tif(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 8.1)\n";

output << "\t\t\tset(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -Wno-stringop-truncation\")\n";

output << "\t\tendif()\n";

output << "\t\tif(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 12.0)\n";

output << "\t\t\tset(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -Wno-address-of-packed-member\")\n";

output << "\t\tendif()\n";

output << "\tendif()\n";

output << "endif()\n";

output << "if (WIN32)\n";

output << "\tadd_definitions(-DWIN32)\n";

output << "else()\n";

output << "\tadd_definitions(-DPOSIX)\n";

output << "\t# Hope for the best regarding fseeko and 64-bit off_t\n";

output << "\tadd_definitions(-D_FILE_OFFSET_BITS=64)\n";

output << "\tadd_definitions(-DHAS_FSEEKO_OFFT_64)\n";

output << "endif()\n";

output << "add_definitions(-DSDL_BACKEND)\n";

if (setup.useSDL == kSDLVersion2) {

output << "add_definitions(-DUSE_SDL2)\n";

} else if (setup.useSDL == kSDLVersion3) {

output << "add_definitions(-DUSE_SDL3)\n";

}

if (getFeatureBuildState("opengl", setup.features)) {

output << "add_definitions(-DUSE_GLAD)\n";

}

if (setup.useStaticDetection) {

output << "add_definitions(-DDETECTION_STATIC)\n";

}

const std::string &objPrefix, const std::string &filePrefix,

const std::string &pchIncludeRoot, const StringList &pchDirs, const StringList &pchExclude) {

std::string lastName;

for (const FileNode *node : dir.children) {

if (!node->children.empty()) {

writeFileListToProject(*node, projectFile, indentation + 1, objPrefix + node->name + '_', filePrefix + node->name + '/', pchIncludeRoot, pchDirs, pchExclude);

} else {

std::string name, ext;

splitFilename(node->name, name, ext);

if (name != lastName) {

if (!lastName.empty()) {

projectFile << "\n";

}

projectFile << "\t";

} else {

projectFile << " ";

}

projectFile << filePrefix + node->name;

lastName = name;

}

}

projectFile << "\n";

workspace << "foreach(ENGINE IN LISTS ENGINES)\n";

workspace << "\toption(ENABLE_${ENGINE} \"Enable ${ENGINE}\" ON)\n";

workspace << "endforeach(ENGINE)\n\n";