Created
September 28, 2012 16:02
-
-
Save anonymous/3800683 to your computer and use it in GitHub Desktop.
wx-config for Windows
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
//////////////////////////////////////////////////////////////////////////////////////////////////// | |
// Name: wx-config-win.cpp | |
// Purpose: A wx-config implementation for Windows | |
// Author: Takeshi Miya | |
// Created: 2006-03-23 | |
// Copyright: (c) Takeshi Miya | |
// Licence: wxWidgets licence | |
// $Rev$ | |
// $URL$ | |
// $Date$ | |
// $Id$ | |
//////////////////////////////////////////////////////////////////////////////////////////////////// | |
#include <iostream> | |
#include <string> | |
#include <cstdlib> | |
#include <map> | |
#include <fstream> | |
#include <algorithm> | |
#include <vector> | |
#include <windows.h> | |
// ------------------------------------------------------------------------------------------------- | |
std::string getSvnRevision() | |
{ | |
std::string str = "$Rev$"; | |
if (str.length() > 8) | |
return str.substr(6, str.length()-8); | |
else | |
return "X"; | |
} | |
std::string getSvnDate() | |
{ | |
std::string str = "$Date$"; | |
if (str.length() > 16) | |
return str.substr(7, 10); | |
else | |
return "2006-XX-XX"; | |
} | |
static const std::string g_tokError = "wx-config Error: "; | |
static const std::string g_tokWarning = "wx-config Warning: "; | |
// ------------------------------------------------------------------------------------------------- | |
/// Program options | |
class Options | |
{ | |
public: | |
std::string& operator[](const std::string& key) | |
{ | |
return m_vars[key]; | |
} | |
bool keyExists(const std::string& key) const | |
{ | |
return m_vars.count(key) != 0; | |
} | |
const std::string& keyValue(const std::string& key) const | |
{ | |
return m_vars.find(key)->second; | |
} | |
std::map<std::string,std::string>& getVars() | |
{ | |
return m_vars; | |
} | |
protected: | |
std::map<std::string,std::string> m_vars; | |
}; | |
// ------------------------------------------------------------------------------------------------- | |
/// File build.cfg/config.* options | |
class BuildFileOptions : public Options | |
{ | |
public: | |
BuildFileOptions(const std::string& filepath) | |
{ | |
parse(filepath); | |
} | |
bool parse(const std::string& filepath) | |
{ | |
std::string line; | |
std::ifstream file(filepath.c_str()); | |
if (file.is_open()) | |
{ | |
while (!file.eof() ) | |
{ | |
std::getline(file, line); | |
// it's a comment line | |
if (line.find_first_of('#') != std::string::npos) | |
continue; | |
// strip spaces | |
line.erase( std::remove(line.begin(), line.end(), ' '), line.end() ); | |
split(line); | |
} | |
file.close(); | |
if (!m_vars.empty()) | |
return true; | |
} | |
else | |
std::cout << g_tokError << "Unable to open file '" << filepath.c_str() << "'." << std::endl; | |
return false; | |
} | |
protected: | |
void split(const std::string& line) | |
{ | |
size_t sep = line.find('='); | |
if (sep != std::string::npos) | |
{ | |
std::string key = line.substr(0, sep); | |
std::string val = line.substr(sep+1, line.size()-sep-1); | |
m_vars[key] = val; | |
} | |
} | |
}; | |
// ------------------------------------------------------------------------------------------------- | |
/// File setup.h options | |
class SetupHOptions | |
{ | |
public: | |
bool& operator[](const std::string& key) | |
{ | |
return m_vars[key]; | |
} | |
bool keyExists(const std::string& key) const | |
{ | |
return m_vars.count(key) != 0; | |
} | |
bool keyValue(const std::string& key) const | |
{ | |
return m_vars.find(key)->second; | |
} | |
typedef std::map<std::string,bool> StringBoolMap; | |
StringBoolMap& getVars() | |
{ | |
return m_vars; | |
} | |
protected: | |
StringBoolMap m_vars; | |
public: | |
SetupHOptions(const std::string& filepath) | |
{ | |
parse(filepath); | |
} | |
bool parse(const std::string& filepath) | |
{ | |
std::string line; | |
std::ifstream file(filepath.c_str()); | |
if (file.is_open()) | |
{ | |
while (!file.eof()) | |
{ | |
std::getline(file, line); | |
// does the splitting/parsing | |
split(line); | |
} | |
file.close(); | |
if (!m_vars.empty()) | |
return true; | |
} | |
else | |
std::cout << g_tokError << "Unable to open file '" << filepath.c_str() << "'." << std::endl; | |
return false; | |
} | |
void printDebug() | |
{ | |
std::cout << "DEBUG: setup.h contents BEGIN -------------------------------------------------" << std::endl; | |
for (StringBoolMap::iterator it = m_vars.begin(); it != m_vars.end(); ++it) | |
std::cout << it->first << "=" << it->second << std::endl; | |
std::cout << "DEBUG: setup.h contents END ---------------------------------------------------" << std::endl; | |
} | |
protected: | |
void split(std::string& line) | |
{ | |
// it's a comment line | |
if (line.find_first_of('/') != std::string::npos) | |
return; // skips the line | |
// strip spaces and tabs | |
line.erase( std::remove(line.begin(), line.end(), ' '), line.end() ); | |
line.erase( std::remove(line.begin(), line.end(), '\t'), line.end() ); | |
std::string tokDefine("#define"); | |
size_t posDefine = line.find_first_of(tokDefine); | |
// it's a #define line | |
if (posDefine != std::string::npos) | |
{ | |
std::string key; | |
bool val; | |
// resolves val, checking if last char is 0 or 1 | |
char lastChar = line.at(line.length()-1); // TODO: I don't like this line :P | |
if (lastChar == '0') | |
val = false; | |
else if (lastChar == '1') | |
val = true; | |
else | |
return; // skips the line | |
// resolves key | |
size_t startPos = posDefine + tokDefine.length(); | |
key = line.substr(startPos, line.length() - startPos - 1); | |
// finally saves the parsed data! | |
m_vars[key] = val; | |
} | |
} | |
}; | |
// ------------------------------------------------------------------------------------------------- | |
/// Command line options | |
class CmdLineOptions : public Options | |
{ | |
public: | |
CmdLineOptions(int argc, char* argv[]) | |
{ | |
parse(argc, argv); | |
} | |
bool validArgs() | |
{ | |
bool valid = keyExists("--compiler") || | |
keyExists("--easymode") || | |
keyExists("--variable") || | |
keyExists("--define-variable") || | |
keyExists("--prefix") || | |
keyExists("--wxcfg") || | |
keyExists("--libs") || | |
keyExists("--cflags") || | |
keyExists("--cxxflags") || | |
keyExists("--cppflags") || | |
keyExists("--rcflags") || | |
keyExists("--list") || | |
keyExists("--debug") || | |
keyExists("--unicode") || | |
keyExists("--static") || | |
keyExists("--universal") || | |
keyExists("--release") || | |
keyExists("--version") || | |
keyExists("--basename") || | |
keyExists("--cc") || | |
keyExists("--cxx") || | |
keyExists("--ld") || | |
keyExists("-v"); | |
// TODO: not all flags are being validated | |
if(!valid) | |
{ | |
if (m_vars.size() > 1 && !keyExists("--help")) | |
std::cout << g_tokError << "Unrecognised option: '" << m_vars.begin()->first << "'\n" << std::endl; | |
std::cerr << "Usage: wx-config [options]\n"; | |
std::cerr << "Options:\n"; | |
std::cerr << " --prefix[=DIR] Path of the wxWidgets installation (ie. C:\\wxWidgets2.6.3)\n"; | |
std::cerr << " --wxcfg[=DIR] Relative path of the build.cfg file (ie. gcc_dll\\mswud)\n"; | |
// std::cerr << " --list Lists all the library configurations. [NOT IMPLEMENTED]\n"; | |
std::cerr << " --cflags Outputs all pre-processor and compiler flags.\n"; | |
std::cerr << " --cxxflags Same as --cflags but for C++.\n"; | |
std::cerr << " --rcflags Outputs all resource compiler flags. [UNTESTED]\n"; | |
std::cerr << " --libs Outputs all linker flags.\n"; | |
std::cerr << std::endl; | |
std::cerr << " --debug[=yes|no] Uses a debug configuration if found.\n"; | |
std::cerr << " --unicode[=yes|no] Uses an unicode configuration if found.\n"; | |
std::cerr << " --static[=yes|no] Uses a static configuration if found.\n"; | |
std::cerr << " --universal[=yes|no] Uses an universal configuration if found.\n"; | |
// std::cerr << " --easymode[=yes|no] Outputs warnings, and optimize flags.\n"; | |
std::cerr << " --compiler[=gcc,dmc,vc] Selects the compiler.\n"; | |
// std::cerr << " --variable=NAME Returns the value of a defined variable.\n"; | |
// std::cerr << " --define-variable=NAME=VAL Sets a global value for a variable.\n"; | |
std::cerr << " --release Outputs the wxWidgets release number.\n"; | |
std::cerr << " --version Outputs the wxWidgets version.\n"; | |
std::cerr << " --basename Outputs the base name of the wxWidgets libraries.\n"; | |
std::cerr << " --cc Outputs the name of the C compiler.\n"; | |
std::cerr << " --cxx Outputs the name of the C++ compiler.\n"; | |
std::cerr << " --ld Outputs the linker command.\n"; | |
std::cerr << " -v Outputs the revision of wx-config.\n"; | |
std::cerr << std::endl; | |
std::cerr << " Note that using --prefix is not needed if you have defined the \n"; | |
std::cerr << " environmental variable WXWIN.\n"; | |
std::cerr << std::endl; | |
std::cerr << " Also note that using --wxcfg is not needed if you have defined the \n"; | |
std::cerr << " environmental variable WXCFG.\n"; | |
std::cerr << std::endl; | |
} | |
return valid; | |
} | |
bool parse(int argc, char* argv[]) | |
{ | |
for(int i=0; i<argc; ++i) | |
{ | |
std::string line; | |
line = argv[i]; | |
split(line); | |
} | |
parseLibs(argv[argc-1]); | |
return true; | |
} | |
std::vector<std::string> getLibs() const | |
{ | |
return m_libs; | |
} | |
protected: | |
void split(const std::string& line) | |
{ | |
size_t sep = line.find("="); | |
if (sep != std::string::npos) | |
{ | |
std::string key = line.substr(0, sep); | |
std::string val = line.substr(sep+1, line.size()-sep-1); | |
m_vars[key] = val; | |
} | |
else | |
m_vars[line] = ""; | |
} | |
bool libExists(const std::string& lib) | |
{ | |
return std::find(m_libs.begin(), m_libs.end(), lib) != m_libs.end(); | |
} | |
void addLib(const std::string& lib) | |
{ | |
// adds the lib if its not present already | |
if (!libExists(lib)) | |
m_libs.push_back(lib); | |
} | |
void parseLibs(const std::string libs) | |
{ | |
std::string param = libs; | |
// if the last parameter doesn't haves a -- switch | |
if (param.find("--") == std::string::npos) | |
{ | |
// saves in the vector, comma separated text like "text1,text2,text3,text4" | |
while(true) | |
{ | |
size_t comma = param.find(","); | |
if (comma != std::string::npos) | |
{ | |
m_libs.push_back(param.substr(0, comma)); | |
param = param.substr(comma+1, param.size()-comma-1); | |
} | |
else | |
{ | |
m_libs.push_back(param); | |
break; | |
} | |
} | |
} | |
// assuming magic keyword 'std' as a lib parameter for non-monolithic | |
// magic keyword std: links with xrc,qa,html,adv,core,base_xml,base_net,base | |
if (m_libs.empty() || libExists("std")) | |
{ | |
addLib("xrc"); | |
addLib("qa"); | |
addLib("html"); | |
addLib("adv"); | |
addLib("core"); | |
addLib("xml"); | |
addLib("net"); | |
addLib("base"); | |
addLib("stc"); | |
addLib("gl"); | |
addLib("propgrid"); | |
} | |
} | |
std::vector<std::string> m_libs; | |
}; | |
// ------------------------------------------------------------------------------------------------- | |
/// Struct to keep programs | |
struct CompilerPrograms | |
{ | |
std::string cc; // C compiler | |
std::string cxx; // C++ compiler | |
std::string ld; // dynamic libs linker | |
std::string lib; // static libs linker | |
std::string windres; // resource compiler | |
}; | |
/// Struct to keep switches | |
struct CompilerSwitches | |
{ | |
std::string includeDirs; // -I | |
std::string resIncludeDirs; // --include-dir | |
std::string libDirs; // -L | |
std::string linkLibs; // -l | |
std::string libPrefix; // lib | |
std::string libExtension; // a | |
std::string defines; // -D | |
std::string resDefines; // --define | |
std::string genericSwitch; // - | |
std::string objectExtension; // o | |
bool forceLinkerUseQuotes; // use quotes for filenames in linker command line (needed or not)? | |
bool forceCompilerUseQuotes; // use quotes for filenames in compiler command line (needed or not)? | |
bool linkerNeedsLibPrefix; // when adding a link library, linker needs prefix? | |
bool linkerNeedsLibExtension; // when adding a link library, linker needs extension? | |
bool supportsPCH; // supports precompiled headers? | |
std::string PCHExtension; // precompiled headers extension | |
}; | |
static bool g_sEasyMode = false; | |
void checkEasyMode(CmdLineOptions& cl) | |
{ | |
if (cl.keyExists("--easymode")) | |
{ | |
if (cl["--easymode"] == "no") | |
g_sEasyMode = false; | |
else if (cl["--easymode"] == "yes" || cl["--easymode"].empty()) | |
g_sEasyMode = true; | |
} | |
} | |
/// Compiler abstract base class | |
class Compiler | |
{ | |
public: | |
Compiler(const std::string& name) : m_name(name) {} | |
// ~Compiler(); | |
std::string easyMode(const std::string& str) | |
{ | |
if (g_sEasyMode) | |
return str; | |
else | |
return std::string(); | |
} | |
std::string addFlag(const std::string& flag) | |
{ | |
if (flag.empty()) | |
return ""; | |
return flag + " "; | |
} | |
std::string addLib(const std::string& lib) | |
{ | |
std::string result; | |
result = m_switches.linkLibs; | |
if (m_switches.linkerNeedsLibPrefix) | |
result += m_switches.libPrefix; | |
result += lib; | |
if (m_switches.linkerNeedsLibExtension) | |
result += "." + m_switches.libExtension; | |
result += " "; | |
if (lib.empty()) | |
return ""; | |
return result; | |
} | |
std::string addDefine(const std::string& define) | |
{ | |
if (define.empty()) | |
return ""; | |
return m_switches.defines + define + " "; | |
} | |
std::string addResDefine(const std::string& resDefine) | |
{ | |
if (resDefine.empty()) | |
return ""; | |
return m_switches.resDefines + " " + resDefine + " "; | |
} | |
std::string addIncludeDir(const std::string& includeDir) | |
{ | |
if (includeDir.empty()) | |
return ""; | |
return m_switches.includeDirs + includeDir + " "; | |
} | |
std::string addLinkerDir(const std::string& libDir) | |
{ | |
if (libDir.empty()) | |
return ""; | |
return m_switches.libDirs + libDir + " "; | |
} | |
std::string addResIncludeDir(const std::string& resIncludeDir) | |
{ | |
if (resIncludeDir.empty()) | |
return ""; | |
return m_switches.resIncludeDirs + " " + resIncludeDir + " "; | |
} | |
/* | |
std::string addResLinkerDir(const std::string& resLibDir) | |
{ | |
if (resLibDir.empty()) | |
return ""; | |
return m_switches.libDirs + libDir + " "; | |
}*/ | |
std::string getName() const | |
{ | |
return m_name; | |
} | |
void process_3(Options& po, const CmdLineOptions& cl, BuildFileOptions& cfg) | |
{ | |
SetupHOptions sho(po["wxcfgsetuphfile"]); | |
// FIXME: proper place of this would be in a first hook, say process_1(); | |
if (cl.keyExists("--define-variable")) | |
{ | |
std::string strDef = cl.keyValue("--define-variable"); | |
size_t sep = strDef.find("="); | |
if (sep != std::string::npos) | |
{ | |
std::string key = strDef.substr(0, sep); | |
std::string val = strDef.substr(sep+1, strDef.size()-sep-1); | |
po[key] = val; | |
cfg[key] = val; | |
if (val == "1" || val == "true") | |
sho[key] = true; | |
else if (val == "0" || val == "false") | |
sho[key] = false; | |
} | |
else | |
{ | |
std::cout << g_tokError << "Failed to define a variable as '" << cl.keyValue("--define-variable") << "'." << std::endl; | |
std::cout << "The syntax is --define-variable=VARIABLENAME=VARIABLEVALUE" << std::endl; | |
exit(1); | |
} | |
} | |
/// Overriding flags sho->cfg!! | |
/// This makes sho variables haves more privilege than cfg ones | |
//------------------------------------------------------------- | |
if (sho.keyExists("wxUSE_UNICODE_MSLU")) | |
sho["wxUSE_UNICODE_MSLU"] ? cfg["MSLU"] = "1" : cfg["MSLU"] = "0"; | |
// TODO: probably better!!!: | |
if (cfg.keyExists("MSLU")) | |
sho["wxUSE_UNICODE_MSLU"] ? cfg["MSLU"] = "1" : cfg["MSLU"] = "0"; | |
//------------------------------------------------------------- | |
/// Overriding compiler programs | |
if (cfg.keyExists("CC")) | |
m_programs.cc = cfg["CC"]; | |
if (cfg.keyExists("CXX")) | |
m_programs.cxx = cfg["CXX"]; | |
if (cfg.keyExists("LD")) | |
m_programs.ld = cfg["LD"]; | |
if (cfg.keyExists("LIB")) | |
m_programs.lib = cfg["LIB"]; | |
if (cfg.keyExists("WINDRES")) | |
m_programs.windres = cfg["WINDRES"]; | |
//------------------------------------------------------------- | |
// BASENAME variables | |
po["LIB_BASENAME_MSW"] = "wx" + po["PORTNAME"] + po["WXUNIVNAME"] + po["WX_RELEASE_NODOT"]; | |
po["LIB_BASENAME_MSW"] += po["WXUNICODEFLAG"] + po["WXDEBUGFLAG"] + cfg["WX_LIB_FLAVOUR"]; | |
po["LIB_BASENAME_BASE"] = "wxbase" + po["WX_RELEASE_NODOT"] + po["WXUNICODEFLAG"]; | |
po["LIB_BASENAME_BASE"] += po["WXDEBUGFLAG"] + cfg["WX_LIB_FLAVOUR"]; | |
for (size_t i=0; i<cl.getLibs().size(); ++i) | |
{ | |
std::string lib = cl.getLibs()[i]; | |
if (lib == "base") | |
{ | |
if (cfg["MONOLITHIC"] == "0") | |
po["__WXLIB_BASE_p"] = addLib(po["LIB_BASENAME_BASE"]); | |
} | |
else if (lib == "net") | |
{ | |
if (cfg["MONOLITHIC"] == "0") | |
po["__WXLIB_NET_p"] = addLib(po["LIB_BASENAME_BASE"] + "_net"); | |
} | |
else if (lib == "xml") | |
{ | |
if (cfg["MONOLITHIC"] == "0") | |
po["__WXLIB_XML_p"] = addLib(po["LIB_BASENAME_BASE"] + "_xml"); | |
} | |
else if (lib == "core") | |
{ | |
if (cfg["MONOLITHIC"] == "0") | |
if (cfg["USE_GUI"] == "1") | |
po["__WXLIB_CORE_p"] = addLib(po["LIB_BASENAME_MSW"] + "_core"); | |
} | |
else if (lib == "adv") | |
{ | |
if (cfg["MONOLITHIC"] == "0") | |
if (cfg["USE_GUI"] == "1") | |
po["__WXLIB_ADV_p"] = addLib(po["LIB_BASENAME_MSW"] + "_adv"); | |
} | |
else if (lib == "qa") | |
{ | |
if (cfg["MONOLITHIC"] == "0") | |
{ | |
if (cfg["USE_GUI"] == "1") | |
{ | |
if (cfg["USE_QA"] == "1") | |
{ | |
po["__WXLIB_QA_p"] = addLib(po["LIB_BASENAME_MSW"] + "_qa"); | |
po["__WXLIB_CORE_p"] = addLib(po["LIB_BASENAME_MSW"] + "_core"); | |
po["__WXLIB_XML_p"] = addLib(po["LIB_BASENAME_BASE"] + "_xml"); | |
} | |
} | |
} | |
} | |
else if (lib == "xrc") | |
{ | |
if (cfg["MONOLITHIC"] == "0") | |
{ | |
if (cfg["USE_GUI"] == "1") | |
{ | |
// if (cfg["USE_XRC"] == "1") | |
{ | |
po["__WXLIB_XRC_p"] = addLib(po["LIB_BASENAME_MSW"] + "_xrc"); | |
po["__WXLIB_XML_p"] = addLib(po["LIB_BASENAME_BASE"] + "_xml"); | |
po["__WXLIB_ADV_p"] = addLib(po["LIB_BASENAME_MSW"] + "_adv"); | |
po["__WXLIB_HTML_p"] = addLib(po["LIB_BASENAME_MSW"] + "_html"); | |
} | |
} | |
} | |
} | |
else if (lib == "aui") | |
{ | |
if (cfg["MONOLITHIC"] == "0") | |
if (cfg["USE_GUI"] == "1") | |
// if (cfg["USE_AUI"] == "1") | |
po["__WXLIB_AUI_p"] = addLib(po["LIB_BASENAME_MSW"] + "_aui"); | |
} | |
else if (lib == "html") | |
{ | |
if (cfg["MONOLITHIC"] == "0") | |
if (cfg["USE_GUI"] == "1") | |
if (cfg["USE_HTML"] == "1") | |
po["__WXLIB_HTML_p"] = addLib(po["LIB_BASENAME_MSW"] + "_html"); | |
} | |
else if (lib == "media") | |
{ | |
if (cfg["MONOLITHIC"] == "0") | |
if (cfg["USE_GUI"] == "1") | |
// if (cfg["USE_MEDIA"] == "1") // TODO: wx2.7 CVS haves an USE_MEDIA | |
po["__WXLIB_MEDIA_p"] = addLib(po["LIB_BASENAME_MSW"] + "_media"); | |
} | |
else if (lib == "odbc") | |
{ | |
if (cfg["MONOLITHIC"] == "0") | |
if (sho["wxUSE_ODBC"]) | |
po["__WXLIB_ODBC_p"] = addLib(po["LIB_BASENAME_BASE"] + "_odbc"); | |
} | |
else if (lib == "dbgrid") | |
{ | |
if (cfg["MONOLITHIC"] == "0") | |
{ | |
if (cfg["USE_GUI"] == "1") | |
{ | |
if (sho["wxUSE_ODBC"]) | |
{ | |
po["__WXLIB_DBGRID_p"] = addLib(po["LIB_BASENAME_MSW"] + "_dbgrid"); | |
po["__WXLIB_ODBC_p"] = addLib(po["LIB_BASENAME_BASE"] + "_odbc"); | |
po["__WXLIB_ADV_p"] = addLib(po["LIB_BASENAME_MSW"] + "_adv"); | |
} | |
} | |
} | |
} | |
else if (lib == "opengl" || lib == "gl") | |
{ | |
// TODO: it's opengl or gl? | |
/// Doesn't matter if it's monolithic or not | |
if (cfg["USE_OPENGL"] == "1") | |
if (cfg["USE_GUI"] == "1") | |
po["__WXLIB_OPENGL_p"] = addLib(po["LIB_BASENAME_MSW"] + "_gl"); | |
po["__WXLIB_OPENGL_p"] += addLib("opengl32"); | |
po["__WXLIB_OPENGL_p"] += addLib("glu32"); | |
} | |
else | |
{ | |
/// Doesn't matter if it's monolithic or not | |
po["__WXLIB_ARGS_p"] += addLib(po["LIB_BASENAME_MSW"] + "_" + lib); | |
} | |
} | |
if (cfg["MONOLITHIC"] == "1") | |
po["__WXLIB_MONO_p"] = addLib(po["LIB_BASENAME_MSW"]); | |
/// External libs (to wxWidgets) | |
if (cfg["USE_GUI"] == "1") | |
if (sho["wxUSE_LIBTIFF"]) | |
po["__LIB_TIFF_p"] = addLib("wxtiff" + po["WXDEBUGFLAG"]); | |
if (cfg["USE_GUI"] == "1") | |
if (sho["wxUSE_LIBJPEG"]) | |
po["__LIB_JPEG_p"] = addLib("wxjpeg" + po["WXDEBUGFLAG"]); | |
if (cfg["USE_GUI"] == "1") | |
if (sho["wxUSE_LIBPNG"] && sho["wxUSE_ZLIB"]) | |
po["__LIB_PNG_p"] = addLib("wxpng" + po["WXDEBUGFLAG"]); | |
if (sho["wxUSE_ZLIB"]) | |
po["__LIB_ZLIB_p"] = addLib("wxzlib" + po["WXDEBUGFLAG"]); | |
if (sho["wxUSE_REGEX"]) | |
po["__LIB_REGEX_p"] = addLib("wxregex" + po["WXUNICODEFLAG"] + po["WXDEBUGFLAG"]); | |
// FIXME: in truth the check should be for wxUSE_XML but... the sho parser is very simple :P | |
// if (sho["wxUSE_XRC"]) | |
po["__LIB_EXPAT_p"] = addLib("wxexpat" + po["WXDEBUGFLAG"]); | |
if (cfg["MSLU"] == "1") | |
po["__LIB_UNICOWS_p"] = addLib("unicows"); | |
if (cfg["USE_GDIPLUS"] == "1") | |
po["__GDIPLUS_LIB_p"] = addLib("gdiplus"); | |
po["__LIB_KERNEL32_p"] = addLib("kernel32"); | |
po["__LIB_USER32_p"] = addLib("user32"); | |
po["__LIB_GDI32_p"] = addLib("gdi32"); | |
po["__LIB_COMDLG32_p"] = addLib("comdlg32"); | |
po["__LIB_WINSPOOL_p"] = addLib("winspool"); | |
po["__LIB_WINMM_p"] = addLib("winmm"); | |
po["__LIB_SHELL32_p"] = addLib("shell32"); | |
po["__LIB_COMCTL32_p"] = addLib("comctl32"); | |
if (sho["wxUSE_OLE"]) | |
po["__LIB_OLE32_p"] = addLib("ole32"); | |
if (sho["wxUSE_OLE"]) | |
po["__LIB_OLEAUT32_p"] = addLib("oleaut32"); | |
if (sho["wxUSE_OLE"]) | |
po["__LIB_OLEACC_p"] = addLib("oleacc"); // NOTE: not being used | |
if (sho["wxUSE_OLE"]) | |
po["__LIB_OLE2W32_p"] = addLib("ole2w32"); // NOTE: not being used | |
// po["__LIB_UUID_p"] = addLib("uuid"); | |
po["__LIB_RPCRT4_p"] = addLib("rpcrt4"); | |
po["__LIB_ADVAPI32_p"] = addLib("advapi32"); | |
if (sho["wxUSE_SOCKETS"]) | |
po["__LIB_WSOCK32_p"] = addLib("wsock32"); | |
if (sho["wxUSE_ODBC"]) | |
po["__LIB_ODBC32_p"] = addLib("odbc32"); | |
/* TODO: From BAKEFILE | |
<!-- link-in system libs that wx depends on: --> | |
<!-- If on borland, we don't need to do much --> | |
<if cond="FORMAT=='borland'"> | |
<sys-lib>ole2w32</sys-lib> | |
<sys-lib>odbc32</sys-lib> | |
</if> | |
<!-- Non-borland, on the other hand... --> | |
<if cond="FORMAT not in ['borland','msevc4prj']"> | |
<sys-lib>kernel32</sys-lib> | |
<sys-lib>user32</sys-lib> | |
<sys-lib>gdi32</sys-lib> | |
<sys-lib>comdlg32</sys-lib> | |
<sys-lib>winspool</sys-lib> | |
<sys-lib>winmm</sys-lib> | |
<sys-lib>shell32</sys-lib> | |
<sys-lib>comctl32</sys-lib> | |
<sys-lib>ole32</sys-lib> | |
<sys-lib>oleaut32</sys-lib> | |
<sys-lib>uuid</sys-lib> | |
<sys-lib>rpcrt4</sys-lib> | |
<sys-lib>advapi32</sys-lib> | |
<sys-lib>wsock32</sys-lib> | |
<sys-lib>odbc32</sys-lib> | |
</if> | |
<!-- Libs common to both borland and MSVC --> | |
<if cond="FORMAT=='msvc' or FORMAT=='msvc6prj' or FORMAT=='borland'"> | |
<sys-lib>oleacc</sys-lib> | |
*/ | |
} | |
std::string getAllLibs(Options& po) | |
{ | |
std::string libs; | |
libs += po["__WXLIB_ARGS_p"] + po["__WXLIB_OPENGL_p"] + po["__WXLIB_MEDIA_p"]; | |
libs += po["__WXLIB_DBGRID_p"] + po["__WXLIB_ODBC_p"] + po["__WXLIB_XRC_p"]; | |
libs += po["__WXLIB_QA_p"] + po["__WXLIB_AUI_p"] + po["__WXLIB_HTML_p"] + po["__WXLIB_ADV_p"]; | |
libs += po["__WXLIB_CORE_p"] + po["__WXLIB_XML_p"] + po["__WXLIB_NET_p"]; | |
libs += po["__WXLIB_BASE_p"] + po["__WXLIB_MONO_p"]; | |
libs += po["__LIB_TIFF_p"] + po["__LIB_JPEG_p"] + po["__LIB_PNG_p"]; | |
libs += po["__LIB_ZLIB_p"] + po["__LIB_REGEX_p"] + po["__LIB_EXPAT_p"]; | |
libs += po["EXTRALIBS_FOR_BASE"] + po["__UNICOWS_LIB_p"] + po["__GDIPLUS_LIB_p"]; | |
libs += po["__LIB_KERNEL32_p"] + po["__LIB_USER32_p"] + po["__LIB_GDI32_p"]; | |
libs += po["__LIB_COMDLG32_p"] + po["__LIB_REGEX_p"] + po["__LIB_WINSPOOL_p"]; | |
libs += po["__LIB_WINMM_p"] + po["__LIB_SHELL32_p"] + po["__LIB_COMCTL32_p"]; | |
libs += po["__LIB_OLE32_p"] + po["__LIB_OLEAUT32_p"] + po["__LIB_UUID_p"]; | |
libs += po["__LIB_RPCRT4_p"] + po["__LIB_ADVAPI32_p"] + po["__LIB_WSOCK32_p"]; | |
libs += po["__LIB_ODBC32_p"]; | |
return libs; | |
} | |
void getVariablesValues(Options& po, const CmdLineOptions& cl, BuildFileOptions& cfg) | |
{ | |
if (cl.keyExists("--variable")) | |
{ | |
std::string var = cl.keyValue("--variable"); | |
if (po.keyExists(var)) | |
po["variable"] += "PO: " + var + "=" + po[var] + "\n"; | |
else | |
po["variable"] += "PO: " + var + " does not exist.\n"; | |
if (cfg.keyExists(var)) | |
po["variable"] += "CFG: " + var + "=" + cfg[var] + "\n"; | |
else | |
po["variable"] += "CFG: " + var + " does not exist.\n"; | |
} | |
} | |
protected: | |
// set the following members in your class | |
std::string m_name; | |
CompilerPrograms m_programs; | |
CompilerSwitches m_switches; | |
}; | |
// ------------------------------------------------------------------------------------------------- | |
/// MinGW compiler | |
class CompilerMinGW : public Compiler | |
{ | |
public: | |
CompilerMinGW() : Compiler("gcc") | |
{ | |
m_programs.cc = "mingw32-gcc"; | |
m_programs.cxx = "mingw32-g++"; | |
m_programs.ld = "mingw32-g++ -shared -fPIC -o "; | |
m_programs.lib = "ar.exe"; | |
m_programs.windres = "windres"; | |
m_switches.includeDirs = "-I"; | |
m_switches.resIncludeDirs = "--include-dir"; | |
m_switches.libDirs = "-L"; | |
m_switches.linkLibs = "-l"; | |
m_switches.libPrefix = "lib"; | |
m_switches.libExtension = "a"; | |
m_switches.defines = "-D"; | |
m_switches.resDefines = "--define"; | |
m_switches.genericSwitch = "-"; | |
m_switches.forceCompilerUseQuotes = false; | |
m_switches.forceLinkerUseQuotes = false; | |
m_switches.linkerNeedsLibPrefix = false; | |
m_switches.linkerNeedsLibExtension = false; | |
m_switches.supportsPCH = true; | |
m_switches.PCHExtension = "h.gch"; | |
} | |
void process(Options& po, const CmdLineOptions& cl) | |
{ | |
/// Searchs for '<prefix>\build\msw\config.*' first | |
std::string cfg_first = po["prefix"] + "\\build\\msw\\config." + getName(); | |
/// config.* options | |
BuildFileOptions cfg(cfg_first); | |
/// build.cfg options | |
cfg.parse(po["wxcfgfile"]); | |
// ### Variables: ### | |
po["WX_RELEASE_NODOT"] = cfg["WXVER_MAJOR"] + cfg["WXVER_MINOR"]; | |
if (po["WX_RELEASE_NODOT"].empty()) | |
po["WX_RELEASE_NODOT"] = "26"; | |
// ### Conditionally set variables: ### | |
if (cfg["GCC_VERSION"] == "2.95") | |
po["GCCFLAGS"] = addFlag("-fvtable-thunks"); | |
if (cfg["USE_GUI"] == "0") | |
po["PORTNAME"] = "base"; | |
if (cfg["USE_GUI"] == "1") | |
po["PORTNAME"] = "msw"; | |
if (cfg["BUILD"] == "debug" && cfg["DEBUG_FLAG"] == "default") | |
po["WXDEBUGFLAG"] = "d"; | |
if (cfg["DEBUG_FLAG"] == "1") | |
po["WXDEBUGFLAG"] = "d"; | |
if (cfg["UNICODE"] == "1") | |
po["WXUNICODEFLAG"] = "u"; | |
if (cfg["WXUNIV"] == "1") | |
po["WXUNIVNAME"] = "univ"; | |
if (cfg["SHARED"] == "1") | |
po["WXDLLFLAG"] = "dll"; | |
if (cfg["SHARED"] == "0") | |
po["LIBTYPE_SUFFIX"] = "lib"; | |
if (cfg["SHARED"] == "1") | |
po["LIBTYPE_SUFFIX"] = "dll"; | |
if (cfg["MONOLITHIC"] == "0") | |
po["EXTRALIBS_FOR_BASE"] = ""; | |
if (cfg["MONOLITHIC"] == "1") | |
po["EXTRALIBS_FOR_BASE"] = ""; | |
if (cfg["BUILD"] == "debug") | |
po["__OPTIMIZEFLAG_2"] = addFlag("-O0"); | |
if (cfg["BUILD"] == "release") | |
po["__OPTIMIZEFLAG_2"] = addFlag("-O2"); | |
if (cfg["USE_RTTI"] == "1") | |
po["__RTTIFLAG_5"] = addFlag(""); | |
if (cfg["USE_EXCEPTIONS"] == "0") | |
po["__EXCEPTIONSFLAG_6"] = addFlag("-fno-exceptions"); | |
if (cfg["USE_EXCEPTIONS"] == "1") | |
po["__EXCEPTIONSFLAG_6"] = addFlag(""); | |
if (cfg["WXUNIV"] == "1") | |
po["__WXUNIV_DEFINE_p"] = addDefine("__WXUNIVERSAL__"); | |
if (cfg["WXUNIV"] == "1") | |
po["__WXUNIV_DEFINE_p_1"] = addResDefine("__WXUNIVERSAL__"); | |
if (cfg["BUILD"] == "debug" && cfg["DEBUG_FLAG"] == "default") | |
po["__DEBUG_DEFINE_p"] = addDefine("__WXDEBUG__"); | |
if (cfg["DEBUG_FLAG"] == "1") | |
po["__DEBUG_DEFINE_p"] = addDefine("__WXDEBUG__"); | |
if (cfg["BUILD"] == "debug" && cfg["DEBUG_FLAG"] == "default") | |
po["__DEBUG_DEFINE_p_1"] = addResDefine("__WXDEBUG__"); | |
if (cfg["DEBUG_FLAG"] == "1") | |
po["__DEBUG_DEFINE_p_1"] = addResDefine("__WXDEBUG__"); | |
if (cfg["USE_EXCEPTIONS"] == "0") | |
po["__EXCEPTIONS_DEFINE_p"] = addDefine("wxNO_EXCEPTIONS"); | |
if (cfg["USE_EXCEPTIONS"] == "0") | |
po["__EXCEPTIONS_DEFINE_p_1"] = addResDefine("wxNO_EXCEPTIONS"); | |
if (cfg["USE_RTTI"] == "0") | |
po["__RTTI_DEFINE_p"] = addDefine("wxNO_RTTI"); | |
if (cfg["USE_RTTI"] == "0") | |
po["__RTTI_DEFINE_p_1"] = addResDefine("wxNO_RTTI"); | |
if (cfg["USE_THREADS"] == "0") | |
po["__THREAD_DEFINE_p"] = addDefine("wxNO_THREADS"); | |
if (cfg["USE_THREADS"] == "0") | |
po["__THREAD_DEFINE_p_1"] = addResDefine("wxNO_THREADS"); | |
if (cfg["UNICODE"] == "1") | |
po["__UNICODE_DEFINE_p"] = addDefine("_UNICODE"); | |
if (cfg["UNICODE"] == "1") | |
po["__UNICODE_DEFINE_p_1"] = addResDefine("_UNICODE"); | |
if (cfg["MSLU"] == "1") | |
po["__MSLU_DEFINE_p"] = addDefine("wxUSE_UNICODE_MSLU=1"); | |
if (cfg["MSLU"] == "1") | |
po["__MSLU_DEFINE_p_1"] = addResDefine("wxUSE_UNICODE_MSLU=1"); | |
if (cfg["USE_GDIPLUS"] == "1") | |
po["__GFXCTX_DEFINE_p"] = addDefine("wxUSE_GRAPHICS_CONTEXT=1"); | |
if (cfg["USE_GDIPLUS"] == "1") | |
po["__GFXCTX_DEFINE_p_1"] = addResDefine("wxUSE_GRAPHICS_CONTEXT=1"); | |
if (cfg["SHARED"] == "1") | |
po["__DLLFLAG_p"] = addDefine("WXUSINGDLL"); | |
if (cfg["SHARED"] == "1") | |
po["__DLLFLAG_p_1"] = addResDefine("WXUSINGDLL"); | |
process_3(po, cl, cfg); | |
//---------------------------------------------------- | |
if (cfg["BUILD"] == "debug" && cfg["DEBUG_INFO"] == "default") | |
po["__DEBUGINFO"] = addFlag("-g"); | |
if (cfg["BUILD"] == "release" && cfg["DEBUG_INFO"] == "default") | |
po["__DEBUGINFO"] = addFlag(""); | |
if (cfg["DEBUG_INFO"] == "0") | |
po["__DEBUGINFO"] = addFlag(""); | |
if (cfg["DEBUG_INFO"] == "1") | |
po["__DEBUGINFO"] = addFlag("-g"); | |
if (cfg["USE_THREADS"] == "0") | |
po["__THREADSFLAG"] = addFlag(""); | |
if (cfg["USE_THREADS"] == "1") | |
po["__THREADSFLAG"] = addFlag("-mthreads"); | |
//---------------------------------------------------- | |
// ### Variables, Part 2: ### | |
po["LIBDIRNAME"] = po["prefix"] + "\\lib\\" + getName() + "_" + po["LIBTYPE_SUFFIX"] + cfg["CFG"]; | |
po["SETUPHDIR"] = po["LIBDIRNAME"] + "\\" + po["PORTNAME"] + po["WXUNIVNAME"]; | |
po["SETUPHDIR"] += po["WXUNICODEFLAG"] + po["WXDEBUGFLAG"]; | |
po["cflags"] = easyMode(po["__DEBUGINFO"]) + easyMode(po["__OPTIMIZEFLAG_2"]) + po["__THREADSFLAG"]; | |
po["cflags"] += po["GCCFLAGS"] + addDefine("HAVE_W32API_H") + addDefine("__WXMSW__") + po["__WXUNIV_DEFINE_p"]; | |
po["cflags"] += po["__DEBUG_DEFINE_p"] + po["__EXCEPTIONS_DEFINE_p"] + po["__RTTI_DEFINE_p"]; | |
po["cflags"] += po["__THREAD_DEFINE_p"] + po["__UNICODE_DEFINE_p"] + po["__MSLU_DEFINE_p"]; | |
po["cflags"] += po["__GFXCTX_DEFINE_p"]; | |
po["cflags"] += addIncludeDir(po["SETUPHDIR"]) + addIncludeDir(po["prefix"] + "\\include");/*-W */ | |
po["cflags"] += easyMode(addFlag("-Wall")) + easyMode(addIncludeDir(".")) + po["__DLLFLAG_p"]; | |
po["cflags"] += easyMode(addIncludeDir(".\\..\\..\\samples")) + /*addDefine("NOPCH") +*/ po["__RTTIFLAG_5"] + po["__EXCEPTIONSFLAG_6"]; | |
po["cflags"] += addFlag("-Wno-ctor-dtor-privacy") + addFlag("-pipe") + addFlag("-fmessage-length=0"); | |
po["cflags"] += cfg["CPPFLAGS"] + " " + cfg["CXXFLAGS"] + " "; | |
po["libs"] = cfg["LDFLAGS"] + " "; | |
po["libs"] += easyMode(po["__DEBUGINFO"]) + po["__THREADSFLAG"]; | |
po["libs"] += addLinkerDir(po["LIBDIRNAME"]); | |
po["libs"] += easyMode(addFlag("-Wl,--subsystem,windows")) + easyMode(addFlag("-mwindows")); | |
po["libs"] += getAllLibs(po); | |
/* | |
po["libs"] += po["__WXLIB_ARGS_p"] + po["__WXLIB_OPENGL_p"] + po["__WXLIB_MEDIA_p"]; | |
po["libs"] += po["__WXLIB_DBGRID_p"] + po["__WXLIB_ODBC_p"] + po["__WXLIB_XRC_p"]; | |
po["libs"] += po["__WXLIB_QA_p"] + po["__WXLIB_AUI_p"] + po["__WXLIB_HTML_p"] + po["__WXLIB_ADV_p"]; | |
po["libs"] += po["__WXLIB_CORE_p"] + po["__WXLIB_XML_p"] + po["__WXLIB_NET_p"]; | |
po["libs"] += po["__WXLIB_BASE_p"] + po["__WXLIB_MONO_p"]; | |
po["libs"] += po["__LIB_TIFF_p"] + po["__LIB_JPEG_p"] + po["__LIB_PNG_p"]; | |
po["libs"] += addLib("wxzlib" + po["WXDEBUGFLAG"]) + addLib("wxregex" + po["WXUNICODEFLAG"] + po["WXDEBUGFLAG"]); | |
po["libs"] += addLib("wxexpat" + po["WXDEBUGFLAG"]) + po["EXTRALIBS_FOR_BASE"] + po["__UNICOWS_LIB_p"]; | |
po["libs"] += addLib("kernel32") + addLib("user32") + addLib("gdi32") + addLib("comdlg32") + addLib("winspool"); | |
po["libs"] += addLib("winmm") + addLib("shell32") + addLib("comctl32") + addLib("ole32") + addLib("oleaut32"); | |
po["libs"] += addLib("uuid") + addLib("rpcrt4") + addLib("advapi32") + addLib("wsock32") + addLib("odbc32"); | |
*/ | |
po["rcflags"] = addFlag("--use-temp-file") + addResDefine("__WXMSW__") + po["__WXUNIV_DEFINE_p_1"]; | |
po["rcflags"] += po["__DEBUG_DEFINE_p_1"] + po["__EXCEPTIONS_DEFINE_p_1"]; | |
po["rcflags"] += po["__RTTI_DEFINE_p_1"] + po["__THREAD_DEFINE_p_1"] + po["__UNICODE_DEFINE_p_1"]; | |
po["rcflags"] += po["__MSLU_DEFINE_p_1"] + po["__GFXCTX_DEFINE_p_1"] + addResIncludeDir(po["SETUPHDIR"]); | |
po["rcflags"] += addResIncludeDir(po["prefix"] + "\\include") + easyMode(addResIncludeDir(".")); | |
po["rcflags"] += po["__DLLFLAG_p_1"]; | |
po["rcflags"] += easyMode(addResIncludeDir(po["prefix"] + "\\samples")); | |
po["release"] = cfg["WXVER_MAJOR"] + "." + cfg["WXVER_MINOR"]; | |
po["version"] = cfg["WXVER_MAJOR"] + "." + cfg["WXVER_MINOR"] + "." + cfg["WXVER_RELEASE"]; | |
po["basename"] = "wx" + po["PORTNAME"] + po["WXUNIVNAME"] + po["WX_RELEASE_NODOT"]; | |
po["basename"] += po["WXUNICODEFLAG"] + po["WXDEBUGFLAG"] + cfg["WX_LIB_FLAVOUR"]; | |
po["cc"] = m_programs.cc; | |
po["cxx"] = m_programs.cxx; | |
po["ld"] = m_programs.ld; | |
getVariablesValues(po, cl, cfg); | |
} | |
}; | |
// ------------------------------------------------------------------------------------------------- | |
/// DMars compiler | |
class CompilerDMC : public Compiler | |
{ | |
public: | |
CompilerDMC() : Compiler("dmc") | |
{ | |
m_programs.cc = "dmc"; | |
m_programs.cxx = "dmc"; | |
m_programs.ld = "link"; | |
m_programs.lib = "lib"; | |
m_programs.windres = "rcc"; | |
m_switches.includeDirs = "-I"; | |
m_switches.resIncludeDirs = "--include-dir"; //////////// | |
m_switches.libDirs = ""; | |
m_switches.linkLibs = ""; | |
m_switches.libPrefix = ""; | |
m_switches.libExtension = "lib"; | |
m_switches.defines = "-D"; | |
m_switches.resDefines = "-D";//////////////////////////////////(doesnt uses space) | |
m_switches.genericSwitch = "-"; | |
m_switches.forceCompilerUseQuotes = false; | |
m_switches.forceLinkerUseQuotes = true; | |
m_switches.linkerNeedsLibPrefix = false; | |
m_switches.linkerNeedsLibExtension = true; | |
} | |
void process(Options& po, const CmdLineOptions& cl) | |
{ | |
/// Searchs for '<prefix>\build\msw\config.*' first | |
std::string cfg_first = po["prefix"] + "\\build\\msw\\config." + getName(); | |
/// config.* options | |
BuildFileOptions cfg(cfg_first); | |
/// build.cfg options | |
cfg.parse(po["wxcfgfile"]); | |
// ### Variables: ### | |
po["WX_RELEASE_NODOT"] = cfg["WXVER_MAJOR"] + cfg["WXVER_MINOR"]; | |
if (po["WX_RELEASE_NODOT"].empty()) | |
po["WX_RELEASE_NODOT"] = "26"; | |
// ### Conditionally set variables: ### | |
if (cfg["USE_GUI"] == "0") | |
po["PORTNAME"] = "base"; | |
if (cfg["USE_GUI"] == "1") | |
po["PORTNAME"] = "msw"; | |
if (cfg["BUILD"] == "debug" && cfg["DEBUG_FLAG"] == "default") | |
po["WXDEBUGFLAG"] = "d"; | |
if (cfg["DEBUG_FLAG"] == "1") | |
po["WXDEBUGFLAG"] = "d"; | |
if (cfg["UNICODE"] == "1") | |
po["WXUNICODEFLAG"] = "u"; | |
if (cfg["WXUNIV"] == "1") | |
po["WXUNIVNAME"] = "univ"; | |
if (cfg["SHARED"] == "1") | |
po["WXDLLFLAG"] = "dll"; | |
if (cfg["SHARED"] == "0") | |
po["LIBTYPE_SUFFIX"] = "lib"; | |
if (cfg["SHARED"] == "1") | |
po["LIBTYPE_SUFFIX"] = "dll"; | |
if (cfg["MONOLITHIC"] == "0") | |
po["EXTRALIBS_FOR_BASE"] = ""; | |
if (cfg["MONOLITHIC"] == "1") | |
po["EXTRALIBS_FOR_BASE"] = ""; | |
//---------------------------------------------------- | |
if (cfg["BUILD"] == "debug" && cfg["DEBUG_INFO"] == "default") | |
po["__DEBUGINFO_0"] = addFlag("-g"); | |
if (cfg["BUILD"] == "release" && cfg["DEBUG_INFO"] == "default") | |
po["__DEBUGINFO_0"] = addFlag(""); | |
if (cfg["DEBUG_INFO"] == "0") | |
po["__DEBUGINFO_0"] = addFlag(""); | |
if (cfg["DEBUG_INFO"] == "1") | |
po["__DEBUGINFO_0"] = addFlag("-g"); | |
if (cfg["BUILD"] == "debug" && cfg["DEBUG_INFO"] == "default") | |
po["__DEBUGINFO_1"] = addFlag("/DEBUG /CODEVIEW"); | |
if (cfg["BUILD"] == "release" && cfg["DEBUG_INFO"] == "default") | |
po["__DEBUGINFO_1"] = addFlag(""); | |
if (cfg["DEBUG_INFO"] == "0") | |
po["__DEBUGINFO_1"] = addFlag(""); | |
if (cfg["DEBUG_INFO"] == "1") | |
po["__DEBUGINFO_1"] = addFlag("/DEBUG /CODEVIEW"); | |
/* | |
if (cfg["BUILD"] == "debug" && cfg["DEBUG_RUNTIME_LIBS"] == "default") | |
po["____DEBUGRUNTIME_2_p"] = addDefine("_DEBUG"); | |
if (cfg["BUILD"] == "release" && cfg["DEBUG_RUNTIME_LIBS"] == "default") | |
po["____DEBUGRUNTIME_2_p"] = addDefine(""); | |
if (cfg["DEBUG_RUNTIME_LIBS"] == "0") | |
po["____DEBUGRUNTIME_2_p"] = addDefine(""); | |
if (cfg["DEBUG_RUNTIME_LIBS"] == "1") | |
po["____DEBUGRUNTIME_2_p"] = addDefine("_DEBUG"); | |
if (cfg["BUILD"] == "debug" && cfg["DEBUG_RUNTIME_LIBS"] == "default") | |
po["____DEBUGRUNTIME_2_p_1"] = addResDefine("_DEBUG"); | |
if (cfg["BUILD"] == "release" && cfg["DEBUG_RUNTIME_LIBS"] == "default") | |
po["____DEBUGRUNTIME_2_p_1"] = addResDefine(""); | |
if (cfg["DEBUG_RUNTIME_LIBS"] == "0") | |
po["____DEBUGRUNTIME_2_p_1"] = addResDefine(""); | |
if (cfg["DEBUG_RUNTIME_LIBS"] == "1") | |
po["____DEBUGRUNTIME_2_p_1"] = addResDefine("_DEBUG"); | |
if (cfg["BUILD"] == "debug" && cfg["DEBUG_RUNTIME_LIBS"] == "default") | |
po["__DEBUGRUNTIME_3"] = "d"; | |
if (cfg["BUILD"] == "release" && cfg["DEBUG_RUNTIME_LIBS"] == "default") | |
po["__DEBUGRUNTIME_3"] = ""; | |
if (cfg["DEBUG_RUNTIME_LIBS"] == "0") | |
po["__DEBUGRUNTIME_3"] = ""; | |
if (cfg["DEBUG_RUNTIME_LIBS"] == "1") | |
po["__DEBUGRUNTIME_3"] = "d"; | |
*/ | |
//---------------------------------------------------- | |
if (cfg["BUILD"] == "debug") | |
po["__OPTIMIZEFLAG_4"] = addFlag("-o+none");//2 | |
if (cfg["BUILD"] == "release") | |
po["__OPTIMIZEFLAG_4"] = addFlag("-o");//2 | |
/* | |
if (cfg["USE_THREADS"] == "0") | |
po["__THREADSFLAG_7"] = "L"; | |
if (cfg["USE_THREADS"] == "1") | |
po["__THREADSFLAG_7"] = "T"; | |
*/ | |
if (cfg["RUNTIME_LIBS"] == "dynamic") | |
po["__RUNTIME_LIBS_8"] = "-ND";//5 // TODO: addFlag? | |
if (cfg["RUNTIME_LIBS"] == "static") | |
po["__RUNTIME_LIBS_8"] = "";//5 | |
//---------------------------------------------------- | |
if (cfg["USE_RTTI"] == "0") | |
po["__RTTIFLAG_9"] = addFlag("");//6 | |
if (cfg["USE_RTTI"] == "1") | |
po["__RTTIFLAG_9"] = addFlag("-Ar");//6 | |
if (cfg["USE_EXCEPTIONS"] == "0") | |
po["__EXCEPTIONSFLAG_10"] = addFlag("");//7 | |
if (cfg["USE_EXCEPTIONS"] == "1") | |
po["__EXCEPTIONSFLAG_10"] = addFlag("-Ae");//7 | |
//---------------------------------------------------- | |
/* | |
if (cfg["BUILD"] == "debug" && cfg["DEBUG_RUNTIME_LIBS"] == "0") | |
po["__NO_VC_CRTDBG_p"] = addDefine("__NO_VC_CRTDBG__"); | |
if (cfg["BUILD"] == "release" && cfg["DEBUG_FLAG"] == "1") | |
po["__NO_VC_CRTDBG_p"] = addDefine("__NO_VC_CRTDBG__"); | |
if (cfg["BUILD"] == "debug" && cfg["DEBUG_RUNTIME_LIBS"] == "0") | |
po["__NO_VC_CRTDBG_p_1"] = addResDefine("__NO_VC_CRTDBG__"); | |
if (cfg["BUILD"] == "release" && cfg["DEBUG_FLAG"] == "1") | |
po["__NO_VC_CRTDBG_p_1"] = addResDefine("__NO_VC_CRTDBG__"); | |
*/ | |
if (cfg["WXUNIV"] == "1") | |
po["__WXUNIV_DEFINE_p"] = addDefine("__WXUNIVERSAL__"); | |
/* | |
if (cfg["WXUNIV"] == "1") | |
po["__WXUNIV_DEFINE_p_1"] = addResDefine("__WXUNIVERSAL__"); | |
*/ | |
if (cfg["BUILD"] == "debug" && cfg["DEBUG_FLAG"] == "default") | |
po["__DEBUG_DEFINE_p"] = addDefine("__WXDEBUG__"); | |
if (cfg["DEBUG_FLAG"] == "1") | |
po["__DEBUG_DEFINE_p"] = addDefine("__WXDEBUG__"); | |
/* | |
if (cfg["BUILD"] == "debug" && cfg["DEBUG_FLAG"] == "default") | |
po["__DEBUG_DEFINE_p_1"] = addResDefine("__WXDEBUG__"); | |
if (cfg["DEBUG_FLAG"] == "1") | |
po["__DEBUG_DEFINE_p_1"] = addResDefine("__WXDEBUG__"); | |
*/ | |
if (cfg["USE_EXCEPTIONS"] == "0") | |
po["__EXCEPTIONS_DEFINE_p"] = addDefine("wxNO_EXCEPTIONS"); | |
/* | |
if (cfg["USE_EXCEPTIONS"] == "0") | |
po["__EXCEPTIONS_DEFINE_p_1"] = addResDefine("wxNO_EXCEPTIONS"); | |
*/ | |
if (cfg["USE_RTTI"] == "0") | |
po["__RTTI_DEFINE_p"] = addDefine("wxNO_RTTI"); | |
/* | |
if (cfg["USE_RTTI"] == "0") | |
po["__RTTI_DEFINE_p_1"] = addResDefine("wxNO_RTTI"); | |
*/ | |
if (cfg["USE_THREADS"] == "0") | |
po["__THREAD_DEFINE_p"] = addDefine("wxNO_THREADS"); | |
/* | |
if (cfg["USE_THREADS"] == "0") | |
po["__THREAD_DEFINE_p_1"] = addResDefine("wxNO_THREADS"); | |
*/ | |
if (cfg["UNICODE"] == "1") | |
po["__UNICODE_DEFINE_p"] = addDefine("_UNICODE"); | |
/* | |
if (cfg["UNICODE"] == "1") | |
po["__UNICODE_DEFINE_p_1"] = addResDefine("_UNICODE"); | |
*/ | |
if (cfg["MSLU"] == "1") | |
po["__MSLU_DEFINE_p"] = addDefine("wxUSE_UNICODE_MSLU=1"); | |
/* | |
if (cfg["MSLU"] == "1") | |
po["__MSLU_DEFINE_p_1"] = addResDefine("wxUSE_UNICODE_MSLU=1"); | |
*/ | |
if (cfg["USE_GDIPLUS"] == "1") | |
po["__GFXCTX_DEFINE_p"] = addDefine("wxUSE_GRAPHICS_CONTEXT=1"); | |
/* | |
if (cfg["USE_GDIPLUS"] == "1") | |
po["__GFXCTX_DEFINE_p_1"] = addResDefine("wxUSE_GRAPHICS_CONTEXT=1"); | |
*/ | |
if (cfg["SHARED"] == "1") | |
po["__DLLFLAG_p"] = addDefine("WXUSINGDLL"); | |
/* | |
if (cfg["SHARED"] == "1") | |
po["__DLLFLAG_p_1"] = addResDefine("WXUSINGDLL"); | |
*/ | |
process_3(po, cl, cfg); | |
// ### Variables, Part 2: ### | |
po["LIBDIRNAME"] = po["prefix"] + "\\lib\\" + getName() + "_" + po["LIBTYPE_SUFFIX"] + cfg["CFG"]; | |
po["SETUPHDIR"] = po["LIBDIRNAME"] + "\\" + po["PORTNAME"] + po["WXUNIVNAME"]; | |
po["SETUPHDIR"] += po["WXUNICODEFLAG"] + po["WXDEBUGFLAG"]; | |
po["cflags"] = easyMode(po["__DEBUGINFO_0"]) + easyMode(po["__OPTIMIZEFLAG_4"]); | |
po["cflags"] += po["__RUNTIME_LIBS_8"] + " " + addDefine("_WIN32_WINNT=0x0400"); | |
po["cflags"] += addDefine("__WXMSW__") + po["__WXUNIV_DEFINE_p"]; | |
po["cflags"] += po["__DEBUG_DEFINE_p"] + po["__EXCEPTIONS_DEFINE_p"] + po["__RTTI_DEFINE_p"]; | |
po["cflags"] += po["__THREAD_DEFINE_p"] + po["__UNICODE_DEFINE_p"] + po["__MSLU_DEFINE_p"]; | |
po["cflags"] += po["__GFXCTX_DEFINE_p"]; | |
po["cflags"] += addIncludeDir(po["SETUPHDIR"]) + addIncludeDir(po["prefix"] + "\\include") + easyMode(addFlag("-w-")) + easyMode(addIncludeDir(".")) + po["__DLLFLAG_p"] + easyMode(addFlag("-WA")); | |
po["cflags"] += easyMode(addIncludeDir(po["prefix"] + "\\samples")) + easyMode(addDefine("NOPCH")) + po["__RTTIFLAG_9"] + po["__EXCEPTIONSFLAG_10"]; | |
po["cflags"] += cfg["CPPFLAGS"] + " " + cfg["CXXFLAGS"] + " "; | |
po["libs"] = easyMode(addFlag("/NOLOGO")) + easyMode(addFlag("/SILENT")); | |
po["libs"] += easyMode(addFlag("/NOI")) + easyMode(addFlag("/DELEXECUTABLE")); | |
po["libs"] += easyMode(addFlag("/EXETYPE:NT")); | |
po["libs"] += cfg["LDFLAGS"] + " "; | |
po["libs"] += easyMode(po["__DEBUGINFO_1"]); | |
po["libs"] += addLinkerDir(po["LIBDIRNAME"] + "\\"); | |
po["libs"] += easyMode(addFlag("/su:windows:4.0")); | |
po["libs"] += getAllLibs(po); | |
po["rcflags"] = addResDefine("_WIN32_WINNT=0x0400") + addResDefine("__WXMSW__"); | |
po["rcflags"] += po["__WXUNIV_DEFINE_p"] + po["__DEBUG_DEFINE_p"] + po["__EXCEPTIONS_DEFINE_p"]; | |
po["rcflags"] += po["__RTTI_DEFINE_p"] + po["__THREAD_DEFINE_p"] + po["__UNICODE_DEFINE_p"]; | |
po["rcflags"] += po["__MSLU_DEFINE_p"] + po["__GFXCTX_DEFINE_p"] + addResIncludeDir(po["SETUPHDIR"]); | |
po["rcflags"] += addResIncludeDir(po["prefix"] + "\\include") + easyMode(addResIncludeDir(".")); | |
po["rcflags"] += po["__DLLFLAG_p"]; | |
po["rcflags"] += easyMode(addResIncludeDir(po["prefix"] + "\\samples")); | |
po["rcflags"] += easyMode(addFlag("-32")) + easyMode(addFlag("-v-")); | |
po["release"] = cfg["WXVER_MAJOR"] + "." + cfg["WXVER_MINOR"]; | |
po["version"] = cfg["WXVER_MAJOR"] + "." + cfg["WXVER_MINOR"] + "." + cfg["WXVER_RELEASE"]; | |
po["basename"] = "wx" + po["PORTNAME"] + po["WXUNIVNAME"] + po["WX_RELEASE_NODOT"]; | |
po["basename"] += po["WXUNICODEFLAG"] + po["WXDEBUGFLAG"] + cfg["WX_LIB_FLAVOUR"]; | |
po["cc"] = m_programs.cc; | |
po["cxx"] = m_programs.cxx; | |
po["ld"] = m_programs.ld; | |
getVariablesValues(po, cl, cfg); | |
} | |
}; | |
// ------------------------------------------------------------------------------------------------- | |
/// Visual Studio compiler | |
class CompilerVC : public Compiler | |
{ | |
public: | |
CompilerVC() : Compiler("vc") | |
{ | |
m_programs.cc = "cl"; | |
m_programs.cxx = "cl"; | |
m_programs.ld = "link"; | |
m_programs.lib = "link"; | |
m_programs.windres = "rc"; | |
m_switches.includeDirs = "/I"; | |
m_switches.resIncludeDirs = "--include-dir"; //////////// | |
m_switches.libDirs = "/LIBPATH:"; | |
m_switches.linkLibs = ""; | |
m_switches.libPrefix = ""; | |
m_switches.libExtension = "lib"; | |
m_switches.defines = "/D"; | |
m_switches.resDefines = "/d"; | |
m_switches.genericSwitch = "/"; | |
m_switches.forceCompilerUseQuotes = false; | |
m_switches.forceLinkerUseQuotes = false; | |
m_switches.linkerNeedsLibPrefix = false; | |
m_switches.linkerNeedsLibExtension = true; | |
} | |
void process(Options& po, const CmdLineOptions& cl) | |
{ | |
/// Searchs for '<prefix>\build\msw\config.*' first | |
std::string cfg_first = po["prefix"] + "\\build\\msw\\config." + getName(); | |
/// config.* options | |
BuildFileOptions cfg(cfg_first); | |
/// build.cfg options | |
cfg.parse(po["wxcfgfile"]); | |
// ### Variables: ### | |
po["WX_RELEASE_NODOT"] = cfg["WXVER_MAJOR"] + cfg["WXVER_MINOR"]; | |
if (po["WX_RELEASE_NODOT"].empty()) | |
po["WX_RELEASE_NODOT"] = "26"; | |
// ### Conditionally set variables: ### | |
if (cfg["USE_GUI"] == "0") | |
po["PORTNAME"] = "base"; | |
if (cfg["USE_GUI"] == "1") | |
po["PORTNAME"] = "msw"; | |
if (cfg["BUILD"] == "debug" && cfg["DEBUG_FLAG"] == "default") | |
po["WXDEBUGFLAG"] = "d"; | |
if (cfg["DEBUG_FLAG"] == "1") | |
po["WXDEBUGFLAG"] = "d"; | |
if (cfg["UNICODE"] == "1") | |
po["WXUNICODEFLAG"] = "u"; | |
if (cfg["WXUNIV"] == "1") | |
po["WXUNIVNAME"] = "univ"; | |
if (cfg["SHARED"] == "1") | |
po["WXDLLFLAG"] = "dll"; | |
if (cfg["SHARED"] == "0") | |
po["LIBTYPE_SUFFIX"] = "lib"; | |
if (cfg["SHARED"] == "1") | |
po["LIBTYPE_SUFFIX"] = "dll"; | |
if (cfg["MONOLITHIC"] == "0") | |
po["EXTRALIBS_FOR_BASE"] = ""; | |
if (cfg["MONOLITHIC"] == "1") | |
po["EXTRALIBS_FOR_BASE"] = ""; | |
if (cfg["TARGET_CPU"] == "amd64") | |
po["DIR_SUFFIX_CPU"] = "_amd64"; | |
if (cfg["TARGET_CPU"] == "ia64") | |
po["DIR_SUFFIX_CPU"] = "_ia64"; | |
// TODO: TARGET_CPU uses $(CPU), so it will be ignored unless explicitely specified | |
if (cfg["TARGET_CPU"] == "$(CPU)") | |
po["LINK_TARGET_CPU"] = ""; | |
if (cfg["TARGET_CPU"] == "amd64") | |
po["LINK_TARGET_CPU"] = addFlag("/MACHINE:AMD64"); | |
if (cfg["TARGET_CPU"] == "ia64") | |
po["LINK_TARGET_CPU"] = addFlag("/MACHINE:IA64"); | |
//---------------------------------------------------- | |
if (cfg["BUILD"] == "debug" && cfg["DEBUG_INFO"] == "default") | |
po["__DEBUGINFO_0"] = addFlag("/Zi"); | |
if (cfg["BUILD"] == "release" && cfg["DEBUG_INFO"] == "default") | |
po["__DEBUGINFO_0"] = addFlag(""); | |
if (cfg["DEBUG_INFO"] == "0") | |
po["__DEBUGINFO_0"] = addFlag(""); | |
if (cfg["DEBUG_INFO"] == "1") | |
po["__DEBUGINFO_0"] = addFlag("/Zi"); | |
if (cfg["BUILD"] == "debug" && cfg["DEBUG_INFO"] == "default") | |
po["__DEBUGINFO_1"] = addFlag("/DEBUG"); | |
if (cfg["BUILD"] == "release" && cfg["DEBUG_INFO"] == "default") | |
po["__DEBUGINFO_1"] = addFlag(""); | |
if (cfg["DEBUG_INFO"] == "0") | |
po["__DEBUGINFO_1"] = addFlag(""); | |
if (cfg["DEBUG_INFO"] == "1") | |
po["__DEBUGINFO_1"] = addFlag("/DEBUG"); | |
if (cfg["BUILD"] == "debug" && cfg["DEBUG_RUNTIME_LIBS"] == "default") | |
po["____DEBUGRUNTIME_2_p"] = addDefine("_DEBUG"); | |
if (cfg["BUILD"] == "release" && cfg["DEBUG_RUNTIME_LIBS"] == "default") | |
po["____DEBUGRUNTIME_2_p"] = addDefine(""); | |
if (cfg["DEBUG_RUNTIME_LIBS"] == "0") | |
po["____DEBUGRUNTIME_2_p"] = addDefine(""); | |
if (cfg["DEBUG_RUNTIME_LIBS"] == "1") | |
po["____DEBUGRUNTIME_2_p"] = addDefine("_DEBUG"); | |
if (cfg["BUILD"] == "debug" && cfg["DEBUG_RUNTIME_LIBS"] == "default") | |
po["____DEBUGRUNTIME_2_p_1"] = addResDefine("_DEBUG"); | |
if (cfg["BUILD"] == "release" && cfg["DEBUG_RUNTIME_LIBS"] == "default") | |
po["____DEBUGRUNTIME_2_p_1"] = addResDefine(""); | |
if (cfg["DEBUG_RUNTIME_LIBS"] == "0") | |
po["____DEBUGRUNTIME_2_p_1"] = addResDefine(""); | |
if (cfg["DEBUG_RUNTIME_LIBS"] == "1") | |
po["____DEBUGRUNTIME_2_p_1"] = addResDefine("_DEBUG"); | |
if (cfg["BUILD"] == "debug" && cfg["DEBUG_RUNTIME_LIBS"] == "default") | |
po["__DEBUGRUNTIME_3"] = "d"; | |
if (cfg["BUILD"] == "release" && cfg["DEBUG_RUNTIME_LIBS"] == "default") | |
po["__DEBUGRUNTIME_3"] = ""; | |
if (cfg["DEBUG_RUNTIME_LIBS"] == "0") | |
po["__DEBUGRUNTIME_3"] = ""; | |
if (cfg["DEBUG_RUNTIME_LIBS"] == "1") | |
po["__DEBUGRUNTIME_3"] = "d"; | |
//---------------------------------------------------- | |
if (cfg["BUILD"] == "debug") | |
po["__OPTIMIZEFLAG_4"] = addFlag("/Od"); | |
if (cfg["BUILD"] == "release") | |
po["__OPTIMIZEFLAG_4"] = addFlag("/O2"); | |
if (cfg["USE_THREADS"] == "0") | |
po["__THREADSFLAG_7"] = "L"; | |
if (cfg["USE_THREADS"] == "1") | |
po["__THREADSFLAG_7"] = "T"; | |
if (cfg["RUNTIME_LIBS"] == "dynamic") | |
po["__RUNTIME_LIBS_8"] = "D"; | |
if (cfg["RUNTIME_LIBS"] == "static") | |
po["__RUNTIME_LIBS_8"] = po["__THREADSFLAG_7"]; | |
//---------------------------------------------------- | |
if (cfg["USE_RTTI"] == "0") | |
po["__RTTIFLAG_9"] = addFlag(""); | |
if (cfg["USE_RTTI"] == "1") | |
po["__RTTIFLAG_9"] = addFlag("/GR"); | |
if (cfg["USE_EXCEPTIONS"] == "0") | |
po["__EXCEPTIONSFLAG_10"] = addFlag(""); | |
if (cfg["USE_EXCEPTIONS"] == "1") | |
po["__EXCEPTIONSFLAG_10"] = addFlag("/EHsc"); | |
//---------------------------------------------------- | |
if (cfg["BUILD"] == "debug" && cfg["DEBUG_RUNTIME_LIBS"] == "0") | |
po["__NO_VC_CRTDBG_p"] = addDefine("__NO_VC_CRTDBG__"); | |
if (cfg["BUILD"] == "release" && cfg["DEBUG_FLAG"] == "1") | |
po["__NO_VC_CRTDBG_p"] = addDefine("__NO_VC_CRTDBG__"); | |
if (cfg["BUILD"] == "debug" && cfg["DEBUG_RUNTIME_LIBS"] == "0") | |
po["__NO_VC_CRTDBG_p_1"] = addResDefine("__NO_VC_CRTDBG__"); | |
if (cfg["BUILD"] == "release" && cfg["DEBUG_FLAG"] == "1") | |
po["__NO_VC_CRTDBG_p_1"] = addResDefine("__NO_VC_CRTDBG__"); | |
if (cfg["WXUNIV"] == "1") | |
po["__WXUNIV_DEFINE_p"] = addDefine("__WXUNIVERSAL__"); | |
if (cfg["WXUNIV"] == "1") | |
po["__WXUNIV_DEFINE_p_1"] = addResDefine("__WXUNIVERSAL__"); | |
if (cfg["BUILD"] == "debug" && cfg["DEBUG_FLAG"] == "default") | |
po["__DEBUG_DEFINE_p"] = addDefine("__WXDEBUG__"); | |
if (cfg["DEBUG_FLAG"] == "1") | |
po["__DEBUG_DEFINE_p"] = addDefine("__WXDEBUG__"); | |
if (cfg["BUILD"] == "debug" && cfg["DEBUG_FLAG"] == "default") | |
po["__DEBUG_DEFINE_p_1"] = addResDefine("__WXDEBUG__"); | |
if (cfg["DEBUG_FLAG"] == "1") | |
po["__DEBUG_DEFINE_p_1"] = addResDefine("__WXDEBUG__"); | |
if (cfg["USE_EXCEPTIONS"] == "0") | |
po["__EXCEPTIONS_DEFINE_p"] = addDefine("wxNO_EXCEPTIONS"); | |
if (cfg["USE_EXCEPTIONS"] == "0") | |
po["__EXCEPTIONS_DEFINE_p_1"] = addResDefine("wxNO_EXCEPTIONS"); | |
if (cfg["USE_RTTI"] == "0") | |
po["__RTTI_DEFINE_p"] = addDefine("wxNO_RTTI"); | |
if (cfg["USE_RTTI"] == "0") | |
po["__RTTI_DEFINE_p_1"] = addResDefine("wxNO_RTTI"); | |
if (cfg["USE_THREADS"] == "0") | |
po["__THREAD_DEFINE_p"] = addDefine("wxNO_THREADS"); | |
if (cfg["USE_THREADS"] == "0") | |
po["__THREAD_DEFINE_p_1"] = addResDefine("wxNO_THREADS"); | |
if (cfg["UNICODE"] == "1") | |
po["__UNICODE_DEFINE_p"] = addDefine("_UNICODE"); | |
if (cfg["UNICODE"] == "1") | |
po["__UNICODE_DEFINE_p_1"] = addResDefine("_UNICODE"); | |
if (cfg["MSLU"] == "1") | |
po["__MSLU_DEFINE_p"] = addDefine("wxUSE_UNICODE_MSLU=1"); | |
if (cfg["MSLU"] == "1") | |
po["__MSLU_DEFINE_p_1"] = addResDefine("wxUSE_UNICODE_MSLU=1"); | |
if (cfg["USE_GDIPLUS"] == "1") | |
po["__GFXCTX_DEFINE_p"] = addDefine("wxUSE_GRAPHICS_CONTEXT=1"); | |
if (cfg["USE_GDIPLUS"] == "1") | |
po["__GFXCTX_DEFINE_p_1"] = addResDefine("wxUSE_GRAPHICS_CONTEXT=1"); | |
if (cfg["SHARED"] == "1") | |
po["__DLLFLAG_p"] = addDefine("WXUSINGDLL"); | |
if (cfg["SHARED"] == "1") | |
po["__DLLFLAG_p_1"] = addResDefine("WXUSINGDLL"); | |
process_3(po, cl, cfg); | |
// ### Variables, Part 2: ### | |
po["LIBDIRNAME"] = po["prefix"] + "\\lib\\" + getName() + po["DIR_SUFFIX_CPU"] + "_" + po["LIBTYPE_SUFFIX"] + cfg["CFG"]; | |
po["SETUPHDIR"] = po["LIBDIRNAME"] + "\\" + po["PORTNAME"] + po["WXUNIVNAME"]; | |
po["SETUPHDIR"] += po["WXUNICODEFLAG"] + po["WXDEBUGFLAG"]; | |
po["cflags"] = "/M" + po["__RUNTIME_LIBS_8"] + po["__DEBUGRUNTIME_3"] + " " + addDefine("WIN32"); | |
po["cflags"] += easyMode(po["__DEBUGINFO_0"]) + easyMode(po["____DEBUGRUNTIME_2_p"]); | |
po["cflags"] += easyMode(po["__OPTIMIZEFLAG_4"]) + po["__NO_VC_CRTDBG_p"] + addDefine("__WXMSW__") + po["__WXUNIV_DEFINE_p"]; | |
po["cflags"] += po["__DEBUG_DEFINE_p"] + po["__EXCEPTIONS_DEFINE_p"] + po["__RTTI_DEFINE_p"]; | |
po["cflags"] += po["__THREAD_DEFINE_p"] + po["__UNICODE_DEFINE_p"] + po["__MSLU_DEFINE_p"] + po["__GFXCTX_DEFINE_p"]; | |
po["cflags"] += addIncludeDir(po["SETUPHDIR"]) + addIncludeDir(po["prefix"] + "\\include") + easyMode(addFlag("/W4")) + easyMode(addIncludeDir(".")) + po["__DLLFLAG_p"] + addDefine("_WINDOWS"); | |
po["cflags"] += easyMode(addIncludeDir(po["prefix"] + "\\samples")) + easyMode(addDefine("NOPCH")) + po["__RTTIFLAG_9"] + po["__EXCEPTIONSFLAG_10"]; | |
po["cflags"] += cfg["CPPFLAGS"] + " " + cfg["CXXFLAGS"] + " "; | |
po["libs"] = easyMode(addFlag("/NOLOGO")); | |
po["libs"] += cfg["LDFLAGS"] + " "; | |
po["libs"] += easyMode(po["__DEBUGINFO_1"]) + " " + po["LINK_TARGET_CPU"] + " "; | |
po["libs"] += addLinkerDir(po["LIBDIRNAME"]); | |
po["libs"] += easyMode(addFlag("/SUBSYSTEM:WINDOWS")); | |
po["libs"] += getAllLibs(po); | |
po["rcflags"] = addResDefine("WIN32") + po["____DEBUGRUNTIME_2_p_1"] + po["__NO_VC_CRTDBG_p_1"] + addResDefine("__WXMSW__"); | |
po["rcflags"] += po["__WXUNIV_DEFINE_p_1"] + po["__DEBUG_DEFINE_p_1"] + po["__EXCEPTIONS_DEFINE_p_1"]; | |
po["rcflags"] += po["__RTTI_DEFINE_p_1"] + po["__THREAD_DEFINE_p_1"] + po["__UNICODE_DEFINE_p_1"]; | |
po["rcflags"] += po["__MSLU_DEFINE_p_1"] + po["__GFXCTX_DEFINE_p_1"] + addResIncludeDir(po["SETUPHDIR"]); | |
po["rcflags"] += addResIncludeDir(po["prefix"] + "\\include") + easyMode(addResIncludeDir(".")); | |
po["rcflags"] += po["__DLLFLAG_p_1"] + addResDefine("_WINDOWS"); | |
po["rcflags"] += easyMode(addResIncludeDir(po["prefix"] + "\\samples")); | |
po["release"] = cfg["WXVER_MAJOR"] + "." + cfg["WXVER_MINOR"]; | |
po["version"] = cfg["WXVER_MAJOR"] + "." + cfg["WXVER_MINOR"] + "." + cfg["WXVER_RELEASE"]; | |
po["basename"] = "wx" + po["PORTNAME"] + po["WXUNIVNAME"] + po["WX_RELEASE_NODOT"]; | |
po["basename"] += po["WXUNICODEFLAG"] + po["WXDEBUGFLAG"] + cfg["WX_LIB_FLAVOUR"]; | |
po["cc"] = m_programs.cc; | |
po["cxx"] = m_programs.cxx; | |
po["ld"] = m_programs.ld; | |
getVariablesValues(po, cl, cfg); | |
} | |
}; | |
// ------------------------------------------------------------------------------------------------- | |
/// OpenWatcom compiler | |
class CompilerWAT : public Compiler | |
{ | |
public: | |
CompilerWAT() : Compiler("wat") | |
{ | |
m_programs.cc = "wcl386";//TODO: wcc386 | |
m_programs.cxx = "wcl386";//TODO: wpp386 | |
m_programs.ld = "wcl386"; | |
m_programs.lib = "wlib"; | |
m_programs.windres = "wrc"; | |
m_switches.includeDirs = "-i="; | |
m_switches.resIncludeDirs = "-i="; | |
m_switches.libDirs = "libp "; | |
m_switches.linkLibs = ""; | |
m_switches.libPrefix = "libr "; | |
m_switches.libExtension = "lib"; | |
m_switches.defines = "-d"; | |
m_switches.resDefines = "-d"; | |
m_switches.genericSwitch = "-"; | |
m_switches.forceCompilerUseQuotes = false; | |
m_switches.forceLinkerUseQuotes = false; | |
m_switches.linkerNeedsLibPrefix = true;//TODO:! | |
m_switches.linkerNeedsLibExtension = true; | |
} | |
void process(Options& po, const CmdLineOptions& cl) | |
{ | |
/// Searchs for '<prefix>\build\msw\config.*' first | |
std::string cfg_first = po["prefix"] + "\\build\\msw\\config." + getName(); | |
/// config.* options | |
BuildFileOptions cfg(cfg_first); | |
/// build.cfg options | |
cfg.parse(po["wxcfgfile"]); | |
// ### Variables: ### | |
po["WX_RELEASE_NODOT"] = cfg["WXVER_MAJOR"] + cfg["WXVER_MINOR"]; | |
if (po["WX_RELEASE_NODOT"].empty()) | |
po["WX_RELEASE_NODOT"] = "26"; | |
// ### Conditionally set variables: ### | |
if (cfg["USE_GUI"] == "0") | |
po["PORTNAME"] = "base"; | |
if (cfg["USE_GUI"] == "1") | |
po["PORTNAME"] = "msw"; | |
if (cfg["BUILD"] == "debug" && cfg["DEBUG_FLAG"] == "default") | |
po["WXDEBUGFLAG"] = "d"; | |
if (cfg["DEBUG_FLAG"] == "1") | |
po["WXDEBUGFLAG"] = "d"; | |
if (cfg["UNICODE"] == "1") | |
po["WXUNICODEFLAG"] = "u"; | |
if (cfg["WXUNIV"] == "1") | |
po["WXUNIVNAME"] = "univ"; | |
if (cfg["SHARED"] == "1") | |
po["WXDLLFLAG"] = "dll"; | |
if (cfg["SHARED"] == "0") | |
po["LIBTYPE_SUFFIX"] = "lib"; | |
if (cfg["SHARED"] == "1") | |
po["LIBTYPE_SUFFIX"] = "dll"; | |
if (cfg["MONOLITHIC"] == "0") | |
po["EXTRALIBS_FOR_BASE"] = ""; | |
if (cfg["MONOLITHIC"] == "1") | |
po["EXTRALIBS_FOR_BASE"] = ""; | |
//---------till here, the same | |
if (cfg["BUILD"] == "debug" && cfg["DEBUG_INFO"] == "default") | |
po["__DEBUGINFO_0"] = addFlag("-d2"); | |
if (cfg["BUILD"] == "release" && cfg["DEBUG_INFO"] == "default") | |
po["__DEBUGINFO_0"] = addFlag("-d0"); | |
if (cfg["DEBUG_INFO"] == "0") | |
po["__DEBUGINFO_0"] = addFlag("-d0"); | |
if (cfg["DEBUG_INFO"] == "1") | |
po["__DEBUGINFO_0"] = addFlag("-d2"); | |
if (cfg["BUILD"] == "debug" && cfg["DEBUG_INFO"] == "default") | |
po["__DEBUGINFO_1"] = addFlag("debug all"); //TODO: ??? | |
if (cfg["BUILD"] == "release" && cfg["DEBUG_INFO"] == "default") | |
po["__DEBUGINFO_1"] = addFlag(""); //TODO: ??? | |
if (cfg["DEBUG_INFO"] == "0") | |
po["__DEBUGINFO_1"] = addFlag(""); //TODO: ??? | |
if (cfg["DEBUG_INFO"] == "1") | |
po["__DEBUGINFO_1"] = addFlag("debug all"); //TODO: ??? | |
//---------from here, the same | |
if (cfg["BUILD"] == "debug") | |
po["__OPTIMIZEFLAG_2"] = addFlag("-od"); | |
if (cfg["BUILD"] == "release") | |
po["__OPTIMIZEFLAG_2"] = addFlag("-ot -ox"); | |
//------from here, almost the same | |
if (cfg["USE_THREADS"] == "0") | |
po["__THREADSFLAG_5"] = addFlag(""); | |
if (cfg["USE_THREADS"] == "1") | |
po["__THREADSFLAG_5"] = addFlag("-bm"); | |
//---------from here, simmilar to VC | |
if (cfg["RUNTIME_LIBS"] == "dynamic") | |
po["__RUNTIME_LIBS_6"] = addFlag("-br"); | |
if (cfg["RUNTIME_LIBS"] == "static") | |
po["__RUNTIME_LIBS_6"] = addFlag(""); | |
//---------simmilar: | |
if (cfg["USE_RTTI"] == "0") | |
po["__RTTIFLAG_7"] = addFlag(""); | |
if (cfg["USE_RTTI"] == "1") | |
po["__RTTIFLAG_7"] = addFlag("-xr"); | |
if (cfg["USE_EXCEPTIONS"] == "0") | |
po["__EXCEPTIONSFLAG_8"] = addFlag(""); | |
if (cfg["USE_EXCEPTIONS"] == "1") | |
po["__EXCEPTIONSFLAG_8"] = addFlag("-xs"); | |
process_3(po, cl, cfg); | |
//---------the same, but without resDefines: | |
if (cfg["WXUNIV"] == "1") | |
po["__WXUNIV_DEFINE_p"] = addDefine("__WXUNIVERSAL__"); | |
if (cfg["BUILD"] == "debug" && cfg["DEBUG_FLAG"] == "default") | |
po["__DEBUG_DEFINE_p"] = addDefine("__WXDEBUG__"); | |
if (cfg["DEBUG_FLAG"] == "1") | |
po["__DEBUG_DEFINE_p"] = addDefine("__WXDEBUG__"); | |
if (cfg["USE_EXCEPTIONS"] == "0") | |
po["__EXCEPTIONS_DEFINE_p"] = addDefine("wxNO_EXCEPTIONS"); | |
if (cfg["USE_RTTI"] == "0") | |
po["__RTTI_DEFINE_p"] = addDefine("wxNO_RTTI"); | |
if (cfg["USE_THREADS"] == "0") | |
po["__THREAD_DEFINE_p"] = addDefine("wxNO_THREADS"); | |
if (cfg["UNICODE"] == "1") | |
po["__UNICODE_DEFINE_p"] = addDefine("_UNICODE"); | |
if (cfg["MSLU"] == "1") | |
po["__MSLU_DEFINE_p"] = addDefine("wxUSE_UNICODE_MSLU=1"); | |
if (cfg["USE_GDIPLUS"] == "1") | |
po["__GFXCTX_DEFINE_p"] = addDefine("wxUSE_GRAPHICS_CONTEXT=1"); | |
if (cfg["SHARED"] == "1") | |
po["__DLLFLAG_p"] = addDefine("WXUSINGDLL"); | |
// ### Variables, Part 2: ### | |
po["LIBDIRNAME"] = po["prefix"] + "\\lib\\" + getName() + "_" + po["LIBTYPE_SUFFIX"] + cfg["CFG"]; | |
po["SETUPHDIR"] = po["LIBDIRNAME"] + "\\" + po["PORTNAME"] + po["WXUNIVNAME"]; | |
po["SETUPHDIR"] += po["WXUNICODEFLAG"] + po["WXDEBUGFLAG"]; | |
po["cflags"] = easyMode(po["__DEBUGINFO_0"]) + easyMode(po["__OPTIMIZEFLAG_2"]) + po["__THREADSFLAG_5"]; | |
po["cflags"] += po["__RUNTIME_LIBS_6"] + addDefine("__WXMSW__") + po["__WXUNIV_DEFINE_p"]; | |
po["cflags"] += po["__DEBUG_DEFINE_p"] + po["__EXCEPTIONS_DEFINE_p"] + po["__RTTI_DEFINE_p"]; | |
po["cflags"] += po["__THREAD_DEFINE_p"] + po["__UNICODE_DEFINE_p"] + po["__MSLU_DEFINE_p"] + po["__GFXCTX_DEFINE_p"]; | |
po["cflags"] += addIncludeDir(po["SETUPHDIR"]) + addIncludeDir(po["prefix"] + "\\include"); | |
po["cflags"] += addFlag("-wx") + addFlag("-wcd=549") + addFlag("-wcd=656") + addFlag("-wcd=657") + addFlag("-wcd=667"); | |
po["cflags"] += easyMode(addIncludeDir(".")) + po["__DLLFLAG_p"]; | |
po["cflags"] += easyMode(addIncludeDir(po["prefix"] + "\\samples")) + addDefine("NOPCH") + po["__RTTIFLAG_7"] + po["__EXCEPTIONSFLAG_8"]; | |
po["cflags"] += cfg["CPPFLAGS"] + " " + cfg["CXXFLAGS"] + " "; | |
po["lbc"] = "option quiet\n"; | |
po["lbc"] += "name $^@\n"; | |
po["lbc"] += "option caseexact\n"; | |
po["libs"] = cfg["LDFLAGS"] + " "; | |
po["libs"] += easyMode(po["__DEBUGINFO_1"]); | |
po["libs"] += addLinkerDir(po["LIBDIRNAME"]); | |
po["lbc"] += " libpath " + po["LIBDIRNAME"] + " system nt_win ref '_WinMain@16'"; | |
po["libs"] += getAllLibs(po); | |
po["rcflags"] = addFlag("-q") + addFlag("-ad") + addFlag("-bt=nt") + addFlag("-r"); | |
po["rcflags"] += addResDefine("__WXMSW__") + po["__WXUNIV_DEFINE_p"]; | |
po["rcflags"] += po["__DEBUG_DEFINE_p"] + po["__EXCEPTIONS_DEFINE_p"]; | |
po["rcflags"] += po["__RTTI_DEFINE_p"] + po["__THREAD_DEFINE_p"] + po["__UNICODE_DEFINE_p"]; | |
po["rcflags"] += po["__MSLU_DEFINE_p"] + po["__GFXCTX_DEFINE_p"] + addResIncludeDir(po["SETUPHDIR"]); | |
po["rcflags"] += addResIncludeDir(po["prefix"] + "\\include") + easyMode(addResIncludeDir(".")); | |
po["rcflags"] += po["__DLLFLAG_p_1"]; | |
po["rcflags"] += easyMode(addResIncludeDir(po["prefix"] + "\\samples")); | |
po["release"] = cfg["WXVER_MAJOR"] + "." + cfg["WXVER_MINOR"]; | |
po["version"] = cfg["WXVER_MAJOR"] + "." + cfg["WXVER_MINOR"] + "." + cfg["WXVER_RELEASE"]; | |
po["basename"] = "wx" + po["PORTNAME"] + po["WXUNIVNAME"] + po["WX_RELEASE_NODOT"]; | |
po["basename"] += po["WXUNICODEFLAG"] + po["WXDEBUGFLAG"] + cfg["WX_LIB_FLAVOUR"]; | |
po["cc"] = m_programs.cc; | |
po["cxx"] = m_programs.cxx; | |
po["ld"] = m_programs.ld; | |
getVariablesValues(po, cl, cfg); | |
} | |
}; | |
// ------------------------------------------------------------------------------------------------- | |
/// Borland compiler | |
class CompilerBCC : public Compiler | |
{ | |
public: | |
CompilerBCC() : Compiler("bcc") | |
{ | |
m_programs.cc = "bcc32"; | |
m_programs.cxx = "bcc32"; | |
m_programs.ld = "ilink32"; | |
m_programs.lib = "tlib"; | |
m_programs.windres = "brcc32"; | |
m_switches.includeDirs = "-I"; | |
m_switches.resIncludeDirs = "--include-dir"; //////////// | |
m_switches.libDirs = "-L"; | |
m_switches.linkLibs = ""; | |
m_switches.libPrefix = ""; | |
m_switches.libExtension = "lib"; | |
m_switches.defines = "-D"; | |
m_switches.resDefines = "/d"; //////// | |
m_switches.genericSwitch = "-"; | |
m_switches.forceCompilerUseQuotes = false; | |
m_switches.forceLinkerUseQuotes = true; | |
m_switches.linkerNeedsLibPrefix = false; | |
m_switches.linkerNeedsLibExtension = true; | |
} | |
void process(Options& po, const CmdLineOptions& cl) {} | |
}; | |
// ------------------------------------------------------------------------------------------------- | |
void normalizePath(std::string& path) | |
{ | |
// converts all slashes to backslashes | |
std::replace(path.begin(), path.end(), '/', '\\'); | |
// removes the first slash (if any) from the given path | |
std::string::iterator firstChar = path.begin(); | |
if (*firstChar == '\\') | |
path.erase(firstChar); | |
// removes the last slash (if any) from the given path | |
std::string::iterator lastChar = path.end() - 1; | |
if (*lastChar == '\\') | |
path.erase(lastChar); | |
} | |
// ------------------------------------------------------------------------------------------------- | |
/// Return true if string changed | |
bool replaceCompilerIfFound(std::string& wxcfg, const std::string& compiler) | |
{ | |
size_t loc; | |
loc = wxcfg.find(compiler); | |
if (loc != std::string::npos) | |
return false; | |
std::vector<std::string> compilers; | |
compilers.push_back("gcc_"); | |
compilers.push_back("dmc_"); | |
compilers.push_back("vc_"); | |
compilers.push_back("wat_"); | |
compilers.push_back("bcc_"); | |
for(std::vector<std::string>::const_iterator it = compilers.begin(); it != compilers.end(); ++it) | |
{ | |
loc = wxcfg.find(*it); | |
if (loc != std::string::npos) | |
{ | |
wxcfg.replace(loc, (*it).length(), compiler + "_"); | |
return true; | |
} | |
} | |
return false; | |
} | |
// ------------------------------------------------------------------------------------------------- | |
/// Return true if string changed | |
bool replaceUniv(std::string& wxcfg, bool enable) | |
{ | |
const std::string univStr("univ"); | |
size_t univPos = wxcfg.rfind(univStr); | |
if (enable) | |
{ | |
/// Pattern: Replace /(msw|base)/ to /(msw|base)univ/ | |
if (univPos == std::string::npos) | |
{ | |
const std::string mswStr("msw"); | |
size_t mswPos = wxcfg.rfind(mswStr); | |
if (mswPos != std::string::npos) | |
wxcfg.insert(mswPos + mswStr.length(), univStr); | |
else | |
{ | |
const std::string baseStr("base"); | |
size_t basePos = wxcfg.rfind(baseStr); | |
if (basePos != std::string::npos) | |
wxcfg.insert(basePos + baseStr.length(), univStr); | |
} | |
return true; | |
} | |
} | |
else | |
{ | |
/// Pattern: Remove /univ/ in /(msw|base)univ/ | |
if (univPos != std::string::npos) | |
{ | |
wxcfg.erase(univPos, univStr.length()); | |
return true; | |
} | |
} | |
return false; | |
} | |
// ------------------------------------------------------------------------------------------------- | |
/// Return true if string changed | |
bool replaceUnicode(std::string& wxcfg, bool enable) | |
{ | |
std::string::iterator lastChar = wxcfg.end() - 1; | |
if (enable) | |
{ | |
/// Pattern: Add /.*u/ if it's not already or /.*ud/ if --debug is specified | |
// TODO: string::find could be better | |
if (*lastChar != 'u' && *lastChar != 'd') | |
{ | |
wxcfg += "u"; | |
return true; | |
} | |
else if (*(lastChar - 1) != 'u' && *lastChar == 'd') | |
{ | |
*lastChar = 'u'; | |
wxcfg += "d"; | |
return true; | |
} | |
} | |
else | |
{ | |
/// Pattern: Remove /.*u/ if it's present or /.*ud/ if --debug is specified | |
if (*lastChar == 'u') | |
{ | |
wxcfg.erase(lastChar); | |
return true; | |
} | |
else if (*(lastChar - 1) == 'u' && *lastChar == 'd') | |
{ | |
wxcfg.erase(lastChar - 1); | |
return true; | |
} | |
} | |
return false; | |
} | |
// ------------------------------------------------------------------------------------------------- | |
/// Return true if string changed | |
bool replaceDebug(std::string& wxcfg, bool enable) | |
{ | |
std::string::iterator lastChar = wxcfg.end() - 1; | |
if (enable) | |
{ | |
/// Pattern: Add /.*d/ if it's not already | |
if (*lastChar != 'd') | |
{ | |
wxcfg += "d"; | |
return true; | |
} | |
} | |
else | |
{ | |
/// Pattern: Remove /.*d/ if it's present | |
if (*lastChar == 'd') | |
{ | |
wxcfg.erase(lastChar); | |
return true; | |
} | |
} | |
return false; | |
} | |
// ------------------------------------------------------------------------------------------------- | |
/// Return true if string changed | |
bool replaceStatic(std::string& wxcfg, bool enable) | |
{ | |
if (enable) | |
{ | |
/// Pattern: Replace /.*_dll/ to /.*_lib/ | |
size_t loc = wxcfg.find("_dll"); | |
if (loc != std::string::npos) | |
{ | |
wxcfg.replace(loc, std::string("_lib").length(), "_lib"); | |
return true; | |
} | |
} | |
else | |
{ | |
/// Pattern: Replace /.*_lib/ to /.*_dll/ | |
size_t loc = wxcfg.find("_lib"); | |
if (loc != std::string::npos) | |
{ | |
wxcfg.replace(loc, std::string("_dll").length(), "_dll"); | |
return true; | |
} | |
} | |
return false; | |
} | |
// ------------------------------------------------------------------------------------------------- | |
void autodetectConfiguration(Options& po, const CmdLineOptions& cl) | |
{ | |
// TODO: still directory listing is needed, to account for $(CFG), $(DIR_SUFFIX_CPU), ... | |
std::vector<std::string> cfgs; | |
std::vector<std::string> newCfgs; | |
std::string cfg; | |
std::vector<std::string>::iterator curCfg; | |
// Iterate through the options the user didn't supply | |
cfgs.push_back(po["wxcfg"]); | |
if (!cl.keyExists("--universal")) | |
{ | |
cfg = po["wxcfg"]; | |
if (replaceUniv(cfg, true)) | |
cfgs.push_back(cfg); | |
cfg = po["wxcfg"]; | |
if (replaceUniv(cfg, false)) | |
cfgs.push_back(cfg); | |
} | |
if (!cl.keyExists("--unicode")) | |
{ | |
newCfgs.clear(); | |
for (curCfg = cfgs.begin(); curCfg != cfgs.end(); ++curCfg) | |
{ | |
cfg = *curCfg; | |
if (replaceUnicode(cfg, true)) | |
newCfgs.push_back(cfg); | |
cfg = *curCfg; | |
if (replaceUnicode(cfg, false)) | |
newCfgs.push_back(cfg); | |
} | |
for (curCfg = newCfgs.begin(); curCfg != newCfgs.end(); ++curCfg) | |
cfgs.push_back(*curCfg); | |
} | |
if (!cl.keyExists("--debug")) | |
{ | |
newCfgs.clear(); | |
for (curCfg = cfgs.begin(); curCfg != cfgs.end(); ++curCfg) | |
{ | |
cfg = *curCfg; | |
if (replaceDebug(cfg, true)) | |
newCfgs.push_back(cfg); | |
cfg = *curCfg; | |
if (replaceDebug(cfg, false)) | |
newCfgs.push_back(cfg); | |
} | |
for (curCfg = newCfgs.begin(); curCfg != newCfgs.end(); ++curCfg) | |
cfgs.push_back(*curCfg); | |
} | |
if (!cl.keyExists("--static")) | |
{ | |
newCfgs.clear(); | |
for (curCfg = cfgs.begin(); curCfg != cfgs.end(); ++curCfg) | |
{ | |
cfg = *curCfg; | |
if (replaceStatic(cfg, true)) | |
newCfgs.push_back(cfg); | |
cfg = *curCfg; | |
if (replaceStatic(cfg, false)) | |
newCfgs.push_back(cfg); | |
} | |
for (curCfg = newCfgs.begin(); curCfg != newCfgs.end(); ++curCfg) | |
cfgs.push_back(*curCfg); | |
} | |
if (!cl.keyExists("--compiler")) | |
{ | |
newCfgs.clear(); | |
for (curCfg = cfgs.begin(); curCfg != cfgs.end(); ++curCfg) | |
{ | |
cfg = *curCfg; | |
if (replaceCompilerIfFound(cfg, "gcc")) | |
newCfgs.push_back(cfg); | |
cfg = *curCfg; | |
if (replaceCompilerIfFound(cfg, "dmc")) | |
newCfgs.push_back(cfg); | |
cfg = *curCfg; | |
if (replaceCompilerIfFound(cfg, "vc")) | |
newCfgs.push_back(cfg); | |
cfg = *curCfg; | |
if (replaceCompilerIfFound(cfg, "wat")) | |
newCfgs.push_back(cfg); | |
cfg = *curCfg; | |
if (replaceCompilerIfFound(cfg, "bcc")) | |
newCfgs.push_back(cfg); | |
} | |
for (curCfg = newCfgs.begin(); curCfg != newCfgs.end(); ++curCfg) | |
cfgs.push_back(*curCfg); | |
} | |
// reads the first setup.h it founds | |
bool found = false; | |
for(std::vector<std::string>::const_iterator it = cfgs.begin(); it != cfgs.end(); ++it) | |
{ | |
std::string file = po["prefix"] + "\\lib\\" + *it + "\\wx\\setup.h"; | |
std::ifstream setupH(file.c_str()); | |
if (setupH.is_open()) | |
{ | |
if (!found) | |
{ | |
po["wxcfg"] = *it; | |
found = true; | |
} | |
else | |
{ | |
std::cerr << g_tokWarning << "Multiple compiled configurations of wxWidgets have been detected." << std::endl; | |
std::cerr << "Using first detected version by default." << std::endl; | |
std::cerr << std::endl; | |
std::cerr << "Please use the --wxcfg flag (as in wx-config --wxcfg=gcc_dll\\mswud)" << std::endl; | |
std::cerr << "or set the environment variable WXCFG (as in WXCFG=gcc_dll\\mswud)" << std::endl; | |
std::cerr << "to specify which configuration exactly you want to use." << std::endl; | |
return; | |
} | |
} | |
} | |
if (!po.keyExists("wxcfg")) | |
{ | |
// TODO: this never reaches thanks to the new autodetection algorithm | |
std::cout << g_tokError << "No setup.h file has been auto-detected." << std::endl; | |
std::cerr << std::endl; | |
std::cerr << "Please use the --wxcfg flag (as in wx-config --wxcfg=gcc_dll\\mswud)" << std::endl; | |
std::cerr << "or set the environment variable WXCFG (as in WXCFG=gcc_dll\\mswud)" << std::endl; | |
std::cerr << "to specify which configuration exactly you want to use." << std::endl; | |
exit(1); | |
} | |
} | |
// ------------------------------------------------------------------------------------------------- | |
void checkAdditionalFlags(Options& po, const CmdLineOptions& cl) | |
{ | |
/// Modifies wxcfg as 'vc[cpu]_[dll|lib][CFG]\[msw|base][univ][u][d]' accordingly | |
/// or 'gcc_[dll|lib][CFG]\[msw|base][univ][u][d]' | |
if (cl.keyExists("--universal")) | |
{ | |
if (cl.keyValue("--universal") == "no") | |
replaceUniv(po["wxcfg"], false); | |
else if (cl.keyValue("--universal") == "yes" || cl.keyValue("--universal").empty()) | |
replaceUniv(po["wxcfg"], true); | |
} | |
if (cl.keyExists("--unicode")) | |
{ | |
if (cl.keyValue("--unicode") == "no") | |
replaceUnicode(po["wxcfg"], false); | |
else if (cl.keyValue("--unicode") == "yes" || cl.keyValue("--unicode").empty()) | |
replaceUnicode(po["wxcfg"], true); | |
} | |
if (cl.keyExists("--debug")) | |
{ | |
if (cl.keyValue("--debug") == "no") | |
replaceDebug(po["wxcfg"], false); | |
else if (cl.keyValue("--debug") == "yes" || cl.keyValue("--debug").empty()) | |
replaceDebug(po["wxcfg"], true); | |
} | |
if (cl.keyExists("--static")) | |
{ | |
if (cl.keyValue("--static") == "no") | |
replaceStatic(po["wxcfg"], false); | |
else if (cl.keyValue("--static") == "yes" || cl.keyValue("--static").empty()) | |
replaceStatic(po["wxcfg"], true); | |
} | |
if (cl.keyExists("--compiler")) | |
{ | |
if (cl.keyValue("--compiler") == "gcc") | |
replaceCompilerIfFound(po["wxcfg"], "gcc"); | |
else if (cl.keyValue("--compiler") == "dmc") | |
replaceCompilerIfFound(po["wxcfg"], "dmc"); | |
else if (cl.keyValue("--compiler") == "vc") | |
replaceCompilerIfFound(po["wxcfg"], "vc"); | |
else if (cl.keyValue("--compiler") == "wat") | |
replaceCompilerIfFound(po["wxcfg"], "wat"); | |
else if (cl.keyValue("--compiler") == "bcc") | |
replaceCompilerIfFound(po["wxcfg"], "bcc"); | |
} | |
} | |
// ------------------------------------------------------------------------------------------------- | |
void detectCompiler(Options& po, const CmdLineOptions& cl) | |
{ | |
// input example of po["wxcfg"]: | |
// gcc_dll\\mswud | |
// vc_lib\\msw | |
if (po["wxcfg"].find("gcc_") != std::string::npos) | |
{ | |
CompilerMinGW compiler; | |
compiler.process(po, cl); | |
return; | |
} | |
else if (po["wxcfg"].find("dmc_") != std::string::npos) | |
{ | |
CompilerDMC compiler; | |
compiler.process(po, cl); | |
return; | |
} | |
else if (po["wxcfg"].find("vc_") != std::string::npos) | |
{ | |
CompilerVC compiler; | |
compiler.process(po, cl); | |
return; | |
} | |
else if (po["wxcfg"].find("wat_") != std::string::npos) | |
{ | |
CompilerWAT compiler; | |
compiler.process(po, cl); | |
return; | |
} | |
else if (po["wxcfg"].find("bcc_") != std::string::npos) | |
{ | |
CompilerBCC compiler; | |
compiler.process(po, cl); | |
return; | |
} | |
else | |
{ | |
// TODO: this never reaches thanks to the new autodetection algorithm | |
std::cout << g_tokError << "No supported compiler has been detected in the configuration '" << po["wxcfg"] << "'." << std::endl; | |
std::cerr << std::endl; | |
std::cerr << "The specified wxcfg must start with a 'gcc_', 'dmc_' or 'vc_'" << std::endl; | |
std::cerr << "to be successfully detected." << std::endl; | |
exit(1); | |
} | |
} | |
// ------------------------------------------------------------------------------------------------- | |
void validatePrefix(const std::string& prefix) | |
{ | |
// tests if prefix is a valid dir. checking if there is an \include\wx\wx.h | |
const std::string testfile = prefix + "\\include\\wx\\wx.h"; | |
std::ifstream prefixIsValid(testfile.c_str()); | |
if (!prefixIsValid.is_open()) | |
{ | |
std::cout << g_tokError << "wxWidgets hasn't been found installed at '" << prefix << "'." << std::endl; | |
std::cerr << std::endl; | |
std::cerr << "Please use the --prefix flag (as in wx-config --prefix=C:\\wxWidgets)" << std::endl; | |
std::cerr << "or set the environment variable WXWIN (as in WXWIN=C:\\wxWidgets)" << std::endl; | |
std::cerr << "to specify where is your installation of wxWidgets." << std::endl; | |
exit(1); | |
} | |
} | |
// ------------------------------------------------------------------------------------------------- | |
bool validateConfiguration(const std::string& wxcfgfile, const std::string& wxcfgsetuphfile, bool exitIfError = true) | |
{ | |
std::ifstream build_cfg(wxcfgfile.c_str()); | |
std::ifstream setup_h(wxcfgsetuphfile.c_str()); | |
bool isBuildCfgOpen = build_cfg.is_open(); | |
bool isSetupHOpen = setup_h.is_open(); | |
if (!isBuildCfgOpen && exitIfError) | |
{ | |
if (!isSetupHOpen && exitIfError) | |
{ | |
std::cout << g_tokError << "No valid setup.h of wxWidgets has been found at location: " << wxcfgsetuphfile << std::endl; | |
std::cerr << std::endl; | |
std::cerr << "Please use the --wxcfg flag (as in wx-config --wxcfg=gcc_dll\\mswud)" << std::endl; | |
std::cerr << "or set the environment variable WXCFG (as in WXCFG=gcc_dll\\mswud)" << std::endl; | |
std::cerr << "to specify which configuration exactly you want to use." << std::endl; | |
exit(1); | |
} | |
std::cout << g_tokError << "No valid configuration of wxWidgets has been found at location: " << wxcfgfile << std::endl; | |
std::cerr << std::endl; | |
std::cerr << "Please use the --wxcfg flag (as in wx-config --wxcfg=gcc_dll\\mswud)" << std::endl; | |
std::cerr << "or set the environment variable WXCFG (as in WXCFG=gcc_dll\\mswud)" << std::endl; | |
std::cerr << "to specify which configuration exactly you want to use." << std::endl; | |
exit(1); | |
} | |
return isBuildCfgOpen && isSetupHOpen; | |
} | |
// ------------------------------------------------------------------------------------------------- | |
void outputFlags(Options& po, const CmdLineOptions& cl) | |
{ | |
/// Outputs flags to console | |
if (cl.keyExists("--variable")) | |
{ | |
std::cout << po["variable"]; | |
exit(0); | |
} | |
if (cl.keyExists("--cc")) | |
std::cout << po["cc"]; | |
if (cl.keyExists("--cxx")) | |
std::cout << po["cxx"]; | |
if (cl.keyExists("--ld")) | |
std::cout << po["ld"]; | |
if (cl.keyExists("--cflags") || cl.keyExists("--cxxflags") || cl.keyExists("--cppflags")) | |
std::cout << po["cflags"] << std::endl; | |
if (cl.keyExists("--libs")) | |
std::cout << po["libs"] << std::endl; | |
if (cl.keyExists("--rcflags")) | |
std::cout << po["rcflags"] << std::endl; | |
if (cl.keyExists("--release")) | |
std::cout << po["release"]; | |
if (cl.keyExists("--version")) | |
std::cout << po["version"]; | |
if (cl.keyExists("--basename")) | |
std::cout << po["basename"]; | |
#if 0 // not implemented | |
if (cl.keyExists("--version=")) // incomplete | |
std::cout << po["version="]; | |
if (cl.keyExists("--ld")) // incomplete | |
std::cout << po["ld"]; | |
if (cl.keyExists("--rezflags")) | |
std::cout << po["rezflags"]; | |
if (cl.keyExists("--linkdeps")) | |
std::cout << po["linkdeps"]; | |
if (cl.keyExists("--version-full")) | |
std::cout << po["version-full"]; | |
if (cl.keyExists("--exec-prefix=")) | |
std::cout << po["exec-prefix="]; | |
if (cl.keyExists("--toolkit")) | |
std::cout << po["toolkit"]; | |
if (cl.keyExists("--list")) | |
std::cout << po["list"]; | |
#endif | |
} | |
// ------------------------------------------------------------------------------------------------- | |
int main(int argc, char* argv[]) | |
{ | |
/// Command line options | |
CmdLineOptions cl(argc, argv); | |
/// Program options | |
Options po; | |
if (!cl.validArgs()) | |
return 1; | |
if (cl.keyExists("-v")) | |
{ | |
std::cout << "wx-config revision " << getSvnRevision() << " " << getSvnDate() << std::endl; | |
return 0; | |
} | |
checkEasyMode(cl); | |
if (cl.keyExists("--prefix")) | |
po["prefix"] = cl["--prefix"]; | |
else if (getenv("WXWIN")) | |
po["prefix"] = getenv("WXWIN"); | |
else | |
{ | |
#ifdef _WIN32 | |
/// Assume that, like a *nix, we're installed in C:\some\path\bin, | |
/// and that the root dir of wxWidgets is therefore C:\some\path. | |
DWORD length = MAX_PATH; | |
LPSTR libPath = NULL; | |
LPSTR filePart; | |
/// Why, oh why, doesn't M$ give us a way to find the actual return length, | |
/// like they do with everything else?!? | |
do | |
{ | |
libPath = new CHAR[length]; | |
GetModuleFileName(NULL, libPath, length); | |
GetFullPathName(libPath, length, libPath, &filePart); | |
*filePart = '\0'; | |
// Add 3 for ".." and NULL | |
if (strlen(libPath) + 3 > length) | |
{ | |
length *= 2; | |
delete[] libPath; | |
libPath = NULL; | |
} | |
} while (libPath == NULL); | |
strcpy(filePart, ".."); | |
// Fix the .. | |
GetFullPathName(libPath, length, libPath, NULL); | |
po["prefix"] = libPath; | |
delete[] libPath; | |
#else | |
po["prefix"] = "C:\\wxWidgets"; | |
#endif | |
} | |
normalizePath(po["prefix"]); | |
validatePrefix(po["prefix"]); | |
if (cl.keyExists("--wxcfg")) | |
po["wxcfg"] = cl["--wxcfg"]; | |
else if (getenv("WXCFG") && !cl.keyExists("--prefix")) | |
po["wxcfg"] = getenv("WXCFG"); | |
else | |
{ | |
// Try if something valid can be found trough deriving checkAdditionalFlags() first | |
po["wxcfg"] = "gcc_dll\\msw"; | |
po["wxcfgfile"] = po["prefix"] + "\\lib\\" + po["wxcfg"] + "\\build.cfg"; | |
po["wxcfgsetuphfile"] = po["prefix"] + "\\lib\\" + po["wxcfg"] + "\\wx\\setup.h"; | |
checkAdditionalFlags(po, cl); | |
if (!validateConfiguration(po["wxcfgfile"], po["wxcfgsetuphfile"], false)) | |
autodetectConfiguration(po, cl); // important function | |
} | |
normalizePath(po["wxcfg"]); | |
checkAdditionalFlags(po, cl); | |
po["wxcfgfile"] = po["prefix"] + "\\lib\\" + po["wxcfg"] + "\\build.cfg"; | |
po["wxcfgsetuphfile"] = po["prefix"] + "\\lib\\" + po["wxcfg"] + "\\wx\\setup.h"; | |
validateConfiguration(po["wxcfgfile"], po["wxcfgsetuphfile"]); | |
detectCompiler(po, cl); | |
outputFlags(po, cl); | |
return 0; | |
} | |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment