kProjectNone,

kProjectCMake,

kProjectCodeBlocks,

kProjectMSVC,

kProjectXcode

#ifndef USE_WIN32_API

// Initialize random number generator for UUID creation

std::srand((unsigned int)std::time(nullptr));

#endif

if (argc < 2) {

displayHelp(argv[0]);

return -1;

}

const std::string srcDir = argv[1];

BuildSetup setup;

setup.srcDir = unifyPath(srcDir);

removeTrailingSlash(setup.srcDir);

setup.filePrefix = setup.srcDir;

setup.outputDir = '.';

setup.engines = parseEngines(setup.srcDir);

if (setup.engines.empty()) {

std::cout << "WARNING: No engines found in configure file or configure file missing in \"" << setup.srcDir << "\"\n";

return 0;

}

setup.features = getAllFeatures();

setup.components = getAllComponents(setup.srcDir, setup.features);

ProjectType projectType = kProjectNone;

const MSVCVersion *msvc = nullptr;

int msvcVersion = 0;

// Parse command line arguments

using std::cout;

for (int i = 2; i < argc; ++i) {

if (!std::strcmp(argv[i], "--list-engines")) {

cout << " The following enables are available in the " PROJECT_DESCRIPTION " source distribution\n"

<< " located at \"" << srcDir << "\":\n";

cout << " state | name | description\n\n";

cout.setf(std::ios_base::left, std::ios_base::adjustfield);

for (EngineDescList::const_iterator j = setup.engines.begin(); j != setup.engines.end(); ++j)

cout << ' ' << (j->enable ? " enabled" : "disabled") << " | " << std::setw((std::streamsize)15) << j->name << std::setw((std::streamsize)0) << " | " << j->desc << "\n";

cout.setf(std::ios_base::right, std::ios_base::adjustfield);

return 0;

} else if (!std::strcmp(argv[i], "--cmake")) {

if (projectType != kProjectNone) {

std::cerr << "ERROR: You cannot pass more than one project type!\n";

return -1;

}

projectType = kProjectCMake;

} else if (!std::strcmp(argv[i], "--codeblocks")) {

if (projectType != kProjectNone) {

std::cerr << "ERROR: You cannot pass more than one project type!\n";

return -1;

}

projectType = kProjectCodeBlocks;

} else if (!std::strcmp(argv[i], "--msvc")) {

if (projectType != kProjectNone) {

std::cerr << "ERROR: You cannot pass more than one project type!\n";

return -1;

}

projectType = kProjectMSVC;

#ifdef ENABLE_XCODE

} else if (!std::strcmp(argv[i], "--xcode")) {

if (projectType != kProjectNone) {

std::cerr << "ERROR: You cannot pass more than one project type!\n";

return -1;

}

projectType = kProjectXcode;

} else if (!std::strcmp(argv[i], "--ios")) {

setup.appleEmbedded = true;

} else if (!std::strcmp(argv[i], "--tvos")) {

setup.appleEmbedded = true;

#endif

} else if (!std::strcmp(argv[i], "--msvc-version")) {

if (i + 1 >= argc) {

std::cerr << "ERROR: Missing \"version\" parameter for \"--msvc-version\"!\n";

return -1;

}

msvcVersion = atoi(argv[++i]);

} else if (!strncmp(argv[i], "--enable-engine=", 16)) {

const char *names = &argv[i][16];

if (!*names) {

std::cerr << "ERROR: Invalid command \"" << argv[i] << "\"\n";

return -1;

}

TokenList tokens = tokenize(names, ',');

TokenList::const_iterator token = tokens.begin();

while (token != tokens.end()) {

std::string name = *token++;

if (!setEngineBuildState(name, setup.engines, true)) {

std::cerr << "ERROR: \"" << name << "\" is not a known engine!\n";

return -1;

}

}

} else if (!strncmp(argv[i], "--disable-engine=", 17)) {

const char *names = &argv[i][17];

if (!*names) {

std::cerr << "ERROR: Invalid command \"" << argv[i] << "\"\n";

return -1;

}

TokenList tokens = tokenize(names, ',');

TokenList::const_iterator token = tokens.begin();

while (token != tokens.end()) {

std::string name = *token++;

if (!setEngineBuildState(name, setup.engines, false)) {

std::cerr << "ERROR: \"" << name << "\" is not a known engine!\n";

return -1;

}

}

} else if (!strncmp(argv[i], "--enable-", 9)) {

const char *name = &argv[i][9];

if (!*name) {

std::cerr << "ERROR: Invalid command \"" << argv[i] << "\"\n";

return -1;

}

if (!std::strcmp(name, "all-engines")) {

for (EngineDescList::iterator j = setup.engines.begin(); j != setup.engines.end(); ++j)

j->enable = true;

} else if (!setFeatureBuildState(name, setup.features, true)) {

std::cerr << "ERROR: \"" << name << "\" is not a feature!\n";

return -1;

}

} else if (!strncmp(argv[i], "--disable-", 10)) {

const char *name = &argv[i][10];

if (!*name) {

std::cerr << "ERROR: Invalid command \"" << argv[i] << "\"\n";

return -1;

}

if (!std::strcmp(name, "all-engines")) {

for (EngineDescList::iterator j = setup.engines.begin(); j != setup.engines.end(); ++j)

j->enable = false;

} else if (!setFeatureBuildState(name, setup.features, false)) {

std::cerr << "ERROR: \"" << name << "\" is not a feature!\n";

return -1;

}

} else if (!std::strcmp(argv[i], "--file-prefix")) {

if (i + 1 >= argc) {

std::cerr << "ERROR: Missing \"prefix\" parameter for \"--file-prefix\"!\n";

return -1;

}

setup.filePrefix = unifyPath(argv[++i]);

removeTrailingSlash(setup.filePrefix);

} else if (!std::strcmp(argv[i], "--output-dir")) {

if (i + 1 >= argc) {

std::cerr << "ERROR: Missing \"path\" parameter for \"--output-dir\"!\n";

return -1;

}

setup.outputDir = unifyPath(argv[++i]);

removeTrailingSlash(setup.outputDir);

} else if (!std::strcmp(argv[i], "--include-dir")) {

if (i + 1 >= argc) {

std::cerr << "ERROR: Missing \"path\" parameter for \"--include-dir\"!\n";

return -1;

}

std::string includeDir = unifyPath(argv[++i]);

removeTrailingSlash(includeDir);

setup.includeDirs.push_back(includeDir);

} else if (!std::strcmp(argv[i], "--library-dir")) {

if (i + 1 >= argc) {

std::cerr << "ERROR: Missing \"path\" parameter for \"--library-dir\"!\n";

return -1;

}

std::string libraryDir = unifyPath(argv[++i]);

removeTrailingSlash(libraryDir);

setup.libraryDirs.push_back(libraryDir);

} else if (!std::strcmp(argv[i], "--build-events")) {

setup.runBuildEvents = true;

} else if (!std::strcmp(argv[i], "--installer")) {

setup.runBuildEvents = true;

setup.createInstaller = true;

} else if (!std::strcmp(argv[i], "--tools")) {

setup.devTools = true;

} else if (!std::strcmp(argv[i], "--tests")) {

setup.tests = true;

} else if (!std::strcmp(argv[i], "--sdl1")) {

setup.useSDL = kSDLVersion1;

} else if (!std::strcmp(argv[i], "--sdl2")) {

setup.useSDL = kSDLVersion2;

} else if (!std::strcmp(argv[i], "--sdl3")) {

setup.useSDL = kSDLVersion3;

} else if (!std::strcmp(argv[i], "--use-canonical-lib-names")) {

// Deprecated: Kept here so it doesn't error

} else if (!std::strcmp(argv[i], "--use-slnx")) {

setup.useSlnx = true;

} else if (!std::strcmp(argv[i], "--use-windows-unicode")) {

setup.useWindowsUnicode = true;

} else if (!std::strcmp(argv[i], "--use-windows-ansi")) {

setup.useWindowsUnicode = false;

} else if (!std::strcmp(argv[i], "--use-windows-subsystem")) {

setup.useWindowsSubsystem = true;

} else if (!std::strcmp(argv[i], "--use-xcframework")) {

setup.useXCFramework = true;

} else if (!std::strcmp(argv[i], "--vcpkg")) {

setup.useVcpkg = true;

} else if (!std::strcmp(argv[i], "--libs-path")) {

if (i + 1 >= argc) {

std::cerr << "ERROR: Missing \"path\" parameter for \"--libs-path\"!\n";

return -1;

}

std::string libsDir = unifyPath(argv[++i]);

removeTrailingSlash(libsDir);

setup.libsDir = libsDir;

} else if (!std::strcmp(argv[i], "--list-components")) {

for (ComponentList::const_iterator j = setup.components.begin(); j != setup.components.end(); ++j)

cout << ' ' << j->description << "\n";

return 0;

} else {

std::cerr << "ERROR: Unknown parameter \"" << argv[i] << "\"\n";

return -1;

}

}

// When building tests, disable some features and all engines

if (setup.tests) {

setup.useStaticDetection = false;

setFeatureBuildState("mt32emu", setup.features, false);

setFeatureBuildState("eventrecorder", setup.features, false);

for (EngineDescList::iterator j = setup.engines.begin(); j != setup.engines.end(); ++j)

j->enable = false;

} else if (setup.devTools) {

setup.useStaticDetection = false;

}

if (!getFeatureBuildState("detection-static", setup.features)) {

setup.useStaticDetection = false;

}

fixupFeatures(projectType, setup);

// Disable engines for which we are missing dependencies and mark components as needed

for (EngineDescList::const_iterator i = setup.engines.begin(); i != setup.engines.end(); ++i) {

if (!i->enable) {

continue;

}

bool enabled = true;

std::list<FeatureList::iterator> missingFeatures;

for (StringList::const_iterator ef = i->requiredFeatures.begin(); ef != i->requiredFeatures.end(); ++ef) {

FeatureList::iterator feature = std::find(setup.features.begin(), setup.features.end(), *ef);

if (feature == setup.features.end()) {

std::cerr << "ERROR: Missing feature " << *ef << " from engine " << i->name << '\n';

return -1;

} else if (!feature->enable) {

enabled = false;

missingFeatures.push_back(feature);

}

}

isEngineEnabled[i->name] = enabled;

if (!enabled) {

setEngineBuildState(i->name, setup.engines, false);

std::cout << "WARNING: Disabling engine " << i->desc << " because the following dependencies are unmet:";

for (std::list<FeatureList::iterator>::iterator itr = missingFeatures.begin(); itr != missingFeatures.end(); itr++) {

std::cout << " " << (*itr)->description;

}

std::cout << "\n";

continue;

}

// Mark components as needed now the engine is definitely enabled

for (StringList::const_iterator ef = i->requiredFeatures.begin(); ef != i->requiredFeatures.end(); ++ef) {

ComponentList::iterator component = std::find(setup.components.begin(), setup.components.end(), *ef);

if (component == setup.components.end()) {

continue;

}

component->needed = true;

}

for (StringList::const_iterator ef = i->wishedComponents.begin(); ef != i->wishedComponents.end(); ++ef) {

ComponentList::iterator component = std::find(setup.components.begin(), setup.components.end(), *ef);

if (component == setup.components.end()) {

std::cerr << "ERROR: Missing component " << *ef << " from engine " << i->name << '\n';

return -1;

}

component->needed = true;

}

}

// Disable unused features / components

if (!setup.tests)

disableComponents(setup.components);

// Handle hard-coded component logic

fixupComponents(setup);

// Print status

cout << "Enabled engines:\n\n";

for (EngineDescList::const_iterator i = setup.engines.begin(); i != setup.engines.end(); ++i) {

if (i->enable)

cout << " " << i->desc << '\n';

}

cout << "\nDisabled engines:\n\n";

for (EngineDescList::const_iterator i = setup.engines.begin(); i != setup.engines.end(); ++i) {

if (!i->enable)

cout << " " << i->desc << '\n';

}

cout << "\nEnabled features:\n\n";

for (FeatureList::const_iterator i = setup.features.begin(); i != setup.features.end(); ++i) {

if (i->enable)

cout << " " << i->description << '\n';

}

cout << "\nDisabled features:\n\n";

for (FeatureList::const_iterator i = setup.features.begin(); i != setup.features.end(); ++i) {

if (!i->enable)

cout << " " << i->description << '\n';

}

// Check if tools and tests are enabled simultaneously

if (setup.devTools && setup.tests) {

std::cerr << "ERROR: The tools and tests projects cannot be created simultaneously\n";

return -1;

}

// Setup defines and libraries

setup.defines = getEngineDefines(setup.engines);

// Add features

StringList featureDefines = getFeatureDefines(setup.features);

setup.defines.splice(setup.defines.begin(), featureDefines);

if (projectType == kProjectXcode) {

setup.defines.push_back("POSIX");

if (setup.appleEmbedded) {

setup.defines.push_back("IPHONE");

setup.defines.push_back("IPHONE_IOS7");

setup.defines.push_back("SCUMMVM_NEON");

} else {

setup.defines.push_back("MACOSX");

// We have two TTS backends, one that is deprecated in macOS 11 and a newer one

// that requires macOS 10.14 minimum. Use the new one when compiling for ARM, and

// otherwise (PPC, Intel) use the old one. We assume the current arch to compile

// create_project is also the one we will be compiling ScummVM for.

#if !defined(__aarch64__)

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

setup.defines.push_back("USE_NS_SPEECH_SYNTHESIZER");

}

#endif

}

} else if (projectType == kProjectMSVC || projectType == kProjectCodeBlocks) {

setup.defines.push_back("WIN32");

setup.win32 = true;

} else {

// As a last resort, select the backend files to build based on the platform used to build create_project.

// This is broken when cross compiling.

#if defined(_WIN32) || defined(WIN32)

setup.defines.push_back("WIN32");

setup.win32 = true;

#else

setup.defines.push_back("POSIX");

#endif

}

for (FeatureList::const_iterator i = setup.features.begin(); i != setup.features.end(); ++i) {

if (i->enable) {

if (!strcmp(i->name, "updates"))

setup.defines.push_back("USE_SPARKLE");

else if (setup.win32 && !strcmp(i->name, "libcurl"))

setup.defines.push_back("CURL_STATICLIB");

else if (!strcmp(i->name, "fluidlite"))

setup.defines.push_back("USE_FLUIDSYNTH");

}

}

if (projectType != kProjectXcode || !setup.appleEmbedded) {

setup.defines.push_back("SDL_BACKEND");

if (setup.useSDL == kSDLVersion1) {

cout << "\nBuilding against SDL 1.2\n\n";

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

cout << "\nBuilding against SDL 2\n\n";

setup.defines.push_back("USE_SDL2");

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

cout << "\nBuilding against SDL 3\n\n";

setup.defines.push_back("USE_SDL3");

} else {

std::cerr << "ERROR: Unsupported SDL version\n";

return -1;

}

}

if (setup.useStaticDetection) {

setup.defines.push_back("DETECTION_STATIC");

}

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

setup.defines.push_back("USE_GLAD");

}

// HACK: Add IMGUI SDL Renderer support

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

// This needs SDL 2.0.18+

if (setup.useSDL == kSDLVersion2) {

setup.defines.push_back("USE_IMGUI_SDLRENDERER2");

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

setup.defines.push_back("USE_IMGUI_SDLRENDERER3");

}

}

// List of global warnings and map of project-specific warnings

// FIXME: As shown below these two structures have different behavior for

// Code::Blocks and MSVC. In Code::Blocks this is used to enable *and*

// disable certain warnings (and some other not warning related flags

// actually...). While in MSVC this is solely for disabling warnings.

// That is really not nice. We should consider a nicer way of doing this.

StringList globalWarnings;

StringList globalErrors;

std::map<std::string, StringList> projectWarnings;

CreateProjectTool::ProjectProvider *provider = nullptr;

switch (projectType) {

default:

case kProjectNone:

std::cerr << "ERROR: No project type has been specified!\n";

return -1;

case kProjectCMake:

if (setup.devTools || setup.tests) {

std::cerr << "ERROR: Building tools or tests is not supported for the CMake project type!\n";

return -1;

}

addGCCWarnings(globalWarnings);

provider = new CreateProjectTool::CMakeProvider(globalWarnings, projectWarnings, globalErrors);

break;

case kProjectCodeBlocks:

if (setup.devTools || setup.tests) {

std::cerr << "ERROR: Building tools or tests is not supported for the CodeBlocks project type!\n";

return -1;

}

addGCCWarnings(globalWarnings);

provider = new CreateProjectTool::CodeBlocksProvider(globalWarnings, projectWarnings, globalErrors);

break;

case kProjectMSVC:

// Auto-detect if no version is specified

if (msvcVersion == 0) {

msvcVersion = getInstalledMSVC();

if (msvcVersion == 0) {

std::cerr << "ERROR: No Visual Studio versions found, please specify one with \"--msvc-version\"\n";

return -1;

} else {

cout << "Visual Studio " << msvcVersion << " detected\n\n";

}

}

msvc = getMSVCVersion(msvcVersion);

if (!msvc) {

std::cerr << "ERROR: Unsupported version: \"" << msvcVersion << "\" passed to \"--msvc-version\"!\n";

return -1;

}

if (setup.useSlnx && msvc->version < 17) {

std::cerr << "ERROR: Using SLNX solution files requires Visual Studio 2022 17.14 or higher\n";

return 1;

}

////////////////////////////////////////////////////////////////////////////

// For Visual Studio, all warnings are on by default in the project files,

// so we pass a list of warnings to disable globally or per-project

//

////////////////////////////////////////////////////////////////////////////

//

// 4068 (unknown pragma)

// only used in scumm engine to mark code sections

//

// 4100 (unreferenced formal parameter)

//

// 4103 (alignment changed after including header, may be due to missing #pragma pack(pop))

// used by pack-start / pack-end

//

// 4127 (conditional expression is constant)

// used in a lot of engines

//

// 4244 ('conversion' conversion from 'type1' to 'type2', possible loss of data)

// throws tons and tons of warnings, most of them false positives

//

// 4250 ('class1' : inherits 'class2::member' via dominance)

// two or more members have the same name. Should be harmless

//

// 4267 ('var' : conversion from 'size_t' to 'type', possible loss of data)

// throws tons and tons of warnings (no immediate plan to fix all usages)

//

// 4310 (cast truncates constant value)

// used in some engines

//

// 4345 (behavior change: an object of POD type constructed with an

// initializer of the form () will be default-initialized)

// used in Common::Array(), and it basically means that newer VS

// versions adhere to the standard in this case. Can be safely

// disabled.

//

// 4351 (new behavior: elements of array 'array' will be default initialized)

// a change in behavior in Visual Studio 2005. We want the new behavior, so it can be disabled

//

// 4505 ('function' : unreferenced local function has been removed)

// libvpx triggers this warning a lot. The compiler eliminates the code and that's expected.

//

// 4512 ('class' : assignment operator could not be generated)

// some classes use const items and the default assignment operator cannot be generated

//

// 4577 ('noexcept' used with no exception handling mode specified)

//

// 4589 (Constructor of abstract class 'type' ignores initializer for virtual base class 'type')

// caused by Common::Stream virtual inheritance, should be harmless

//

// 4702 (unreachable code)

// mostly thrown after error() calls (marked as NORETURN)

//

// 4706 (assignment within conditional expression)

// used in a lot of engines

//

// 4800 ('type' : forcing value to bool 'true' or 'false' (performance warning))

//

// 4996 ('function': was declared deprecated)

// disabling it removes all the non-standard unsafe functions warnings (strcpy_s, etc.)

//

// 6211 (Leaking memory <pointer> due to an exception. Consider using a local catch block to clean up memory)

// we disable exceptions

//

// 6204 (possible buffer overrun in call to <function>: use of unchecked parameter <variable>)

// 6385 (invalid data: accessing <buffer name>, the readable size is <size1> bytes, but <size2> bytes may be read)

// 6386 (buffer overrun: accessing <buffer name>, the writable size is <size1> bytes, but <size2> bytes may be written)

// give way too many false positives

//

////////////////////////////////////////////////////////////////////////////

//

// 4189 (local variable is initialized but not referenced)

// false positive in lure engine

//

// 4355 ('this' : used in base member initializer list)

// only disabled for specific engines where it is used in a safe way

//

// 4373 (previous versions of the compiler did not override when parameters only differed by const/volatile qualifiers)

//

// 4510 ('class' : default constructor could not be generated)

//

// 4511 ('class' : copy constructor could not be generated)

//

// 4610 (object 'class' can never be instantiated - user-defined constructor required)

// "correct" but harmless (as is 4510)

//

// 4324 (structure was padded due to alignment specifier)

//

////////////////////////////////////////////////////////////////////////////

globalWarnings.push_back("4068");

globalWarnings.push_back("4100");

globalWarnings.push_back("4103");

globalWarnings.push_back("4127");

globalWarnings.push_back("4244");

globalWarnings.push_back("4250");

globalWarnings.push_back("4310");

globalWarnings.push_back("4324");

globalWarnings.push_back("4345");

globalWarnings.push_back("4351");

globalWarnings.push_back("4505");

globalWarnings.push_back("4512");

globalWarnings.push_back("4589");

globalWarnings.push_back("4702");

globalWarnings.push_back("4706");

globalWarnings.push_back("4800");

globalWarnings.push_back("4996");

globalWarnings.push_back("6204");

globalWarnings.push_back("6211");

globalWarnings.push_back("6385");

globalWarnings.push_back("6386");

if (msvcVersion >= 14) {

globalWarnings.push_back("4267");

globalWarnings.push_back("4577");

}

globalErrors.push_back("4701"); // potential use of uninitialized local variable

globalErrors.push_back("4703"); // potential use of uninitialized local pointer

globalErrors.push_back("4456"); // declaration hides previous local declaration

globalErrors.push_back("4003"); // not enough arguments for function-like macro invocation

globalErrors.push_back("4840"); // use of non-trivial class as an argument to a variadic function

globalErrors.push_back("4805"); // comparison of bool to non-bool, unsafe mix of bool and int in arithmetic or bitwise operation

globalErrors.push_back("4305"); // truncation of double to float or int to bool

globalErrors.push_back("4366"); // address taken of unaligned field

globalErrors.push_back("4315"); // unaligned field has constructor that expects to be aligned

globalErrors.push_back("4715"); // not all control paths return a value

globalErrors.push_back("4716"); // function must return a value

projectWarnings["agi"].push_back("4510");

projectWarnings["agi"].push_back("4610");

projectWarnings["agos"].push_back("4511");

projectWarnings["dreamweb"].push_back("4355");

projectWarnings["lure"].push_back("4189");

projectWarnings["lure"].push_back("4355");

projectWarnings["kyra"].push_back("4355");

projectWarnings["kyra"].push_back("4510");

projectWarnings["kyra"].push_back("4610");

projectWarnings["m4"].push_back("4355");

projectWarnings["sci"].push_back("4373");

projectWarnings["grim"].push_back("4611");

provider = new CreateProjectTool::MSBuildProvider(globalWarnings, projectWarnings, globalErrors, msvcVersion, *msvc);

break;

case kProjectXcode:

if (setup.devTools || setup.tests) {

std::cerr << "ERROR: Building tools or tests is not supported for the XCode project type!\n";

return -1;

}

addGCCWarnings(globalWarnings);

provider = new CreateProjectTool::XcodeProvider(globalWarnings, projectWarnings, globalErrors);

break;

}

// Setup project name and description

setup.projectName = PROJECT_NAME;

setup.projectDescription = PROJECT_DESCRIPTION;

if (setup.devTools) {

setup.projectName += "-tools";

setup.projectDescription += "Tools";

}

if (setup.tests) {

setup.projectName += "-tests";

setup.projectDescription += "Tests";

}

provider->createProject(setup);

delete provider;

std::string result = path;

std::replace(result.begin(), result.end(), '\\', '/');

return result;

using std::cout;

cout << "Usage:\n"

<< exe << " path\\to\\source [optional options]\n"

<< "\n"

<< " Creates project files for the " PROJECT_DESCRIPTION " source located at \"path\\to\\source\".\n"

" The project files will be created in the directory where tool is run from and\n"

" will include \"path\\to\\source\" for relative file paths, thus be sure that you\n"

" pass a relative file path like \"..\\..\\trunk\".\n"

"\n"

" Additionally there are the following switches for changing various settings:\n"

"\n"

"Project specific settings:\n"

" --cmake build CMake project files\n"

" --codeblocks build Code::Blocks project files\n"

" --msvc build Visual Studio project files\n"

" --xcode build XCode project files\n"

" --file-prefix prefix allow overwriting of relative file prefix in the\n"

" MSVC project files. By default the prefix is the\n"

" \"path\\to\\source\" argument\n"

" --output-dir path overwrite path, where the project files are placed\n"

" By default this is \".\", i.e. the current working\n"

" directory\n"

" --include-dir path add a path to the include search path\n"

" --library-dir path add a path to the library search path\n"

"\n"

"MSVC specific settings:\n"

" --msvc-version version set the targeted MSVC version. Possible values:\n";

const MSVCList msvc = getAllMSVCVersions();

for (MSVCList::const_iterator i = msvc.begin(); i != msvc.end(); ++i)

cout << " " << i->version << " stands for \"" << i->name << "\"\n";

cout << " If no version is set, the latest installed version is used\n"

" --build-events Run custom build events as part of the build\n"

" (default: false)\n"

" --installer Create installer after the build (implies --build-events)\n"

" (default: false)\n"

" --tools Create project files for the devtools\n"

" (ignores --build-events and --installer, as well as engine settings)\n"

" (default: false)\n"

" --tests Create project files for the tests\n"

" (ignores --build-events and --installer, as well as engine settings)\n"

" (default: false)\n"

" --use-slnx Use new XML-based Visual Studio solution format\n"

" (default: false)\n"

" --use-windows-unicode Use Windows Unicode APIs\n"

" (default: true)\n"

" --use-windows-ansi Use Windows ANSI APIs\n"

" (default: false)\n"

" --use-windows-subsystem Use Windows subsystem instead of Console\n"

" (default: false)\n"

" --libs-path path Specify the path of pre-built libraries instead of using the\n"

" " LIBS_DEFINE " environment variable\n "

" --vcpkg Use vcpkg-provided libraries instead of pre-built libraries\n"

" (default: false)\n"

"\n"

"XCode specific settings:\n"

" --ios build for iOS or tvOS\n"

" --tvos build for iOS or tvOS\n"

"\n"

"Engines settings:\n"

" --list-engines list all available engines and their default state\n"

" --enable-engine=<name> enable building of the engine with the name \"name\"\n"

" --disable-engine=<name> disable building of the engine with the name \"name\"\n"

" --enable-all-engines enable building of all engines\n"

" --disable-all-engines disable building of all engines\n"

"\n"

"Optional features settings:\n"

" --enable-<name> enable inclusion of the feature \"name\"\n"

" --disable-<name> disable inclusion of the feature \"name\"\n"

"\n"

"SDL settings:\n"

" --sdl1 link to SDL 1.2\n"

" --sdl2 link to SDL 2 (default)\n"

" --sdl3 link to SDL 3\n"

"\n"

" There are the following features available:\n"

"\n";

cout << " state | name | description\n\n";

const FeatureList features = getAllFeatures();

cout.setf(std::ios_base::left, std::ios_base::adjustfield);

for (FeatureList::const_iterator i = features.begin(); i != features.end(); ++i)

cout << ' ' << (i->enable ? " enabled" : "disabled") << " | " << std::setw((std::streamsize)15) << i->name << std::setw((std::streamsize)0) << " | " << i->description << '\n';

cout.setf(std::ios_base::right, std::ios_base::adjustfield);

////////////////////////////////////////////////////////////////////////////

//

// -Wall

// enable all warnings

//

// -Wno-long-long -Wno-multichar -Wno-unknown-pragmas -Wno-reorder

// disable annoying and not-so-useful warnings

//

// -Wpointer-arith -Wcast-qual -Wcast-align

// -Wshadow -Wimplicit -Wnon-virtual-dtor -Wwrite-strings

// enable even more warnings...

//

// -fno-exceptions -fcheck-new

// disable exceptions, and enable checking of pointers returned by "new"

//

////////////////////////////////////////////////////////////////////////////

globalWarnings.push_back("-Wall");

globalWarnings.push_back("-Wno-long-long");

globalWarnings.push_back("-Wno-multichar");

globalWarnings.push_back("-Wno-unknown-pragmas");

globalWarnings.push_back("-Wno-reorder");

globalWarnings.push_back("-Wpointer-arith");

globalWarnings.push_back("-Wcast-qual");

globalWarnings.push_back("-Wcast-align");

globalWarnings.push_back("-Wshadow");

globalWarnings.push_back("-Wnon-virtual-dtor");

globalWarnings.push_back("-Wwrite-strings");

// The following are not warnings at all... We should consider adding them to

// a different list of parameters.

#if !NEEDS_RTTI

globalWarnings.push_back("-fno-rtti");

#endif

globalWarnings.push_back("-fno-exceptions");

globalWarnings.push_back("-fcheck-new");

using CreateProjectTool::FileList;

using CreateProjectTool::listDirectory;

EngineDescList engineList;

FileList engineFiles = listDirectory(srcDir + "/engines/");

#ifdef FIRST_ENGINE

// In case we want to sort an engine to the front of the list we will

// use some manual sorting predicate which assures that.

engineFiles.sort(&compareEngineNames);

#else

// Otherwise, we simply sort the file list alphabetically this allows

// for a nicer order in --list-engines output, for example.

engineFiles.sort(&compareFSNode);

#endif

for (FileList::const_iterator i = engineFiles.begin(), end = engineFiles.end(); i != end; ++i) {

// Each engine requires its own sub directory thus we will skip all

// non directory file nodes here.

if (!i->isDirectory) {

continue;

}

// Retrieve all engines defined in this sub directory and add them to

// the list of all engines.

EngineDescList list = parseEngineConfigure(srcDir + "/engines/" + i->name);

engineList.splice(engineList.end(), list);

}

return engineList;

for (EngineDescList::const_iterator i = engines.begin(); i != engines.end(); ++i) {

if (std::find(i->subEngines.begin(), i->subEngines.end(), name) != i->subEngines.end())

return true;

}

return false;