|
|
|
|
@ -9,102 +9,275 @@
@@ -9,102 +9,275 @@
|
|
|
|
|
|
|
|
|
|
#include <string> |
|
|
|
|
#include <vector> |
|
|
|
|
#include <cstdio> |
|
|
|
|
|
|
|
|
|
static std::string exec(const char* cmd) |
|
|
|
|
{ |
|
|
|
|
FILE* pipe = _popen(cmd, "r"); |
|
|
|
|
if (!pipe) return "ERROR"; |
|
|
|
|
char buffer[128]; |
|
|
|
|
std::string result = ""; |
|
|
|
|
while(!feof(pipe)) { |
|
|
|
|
if(fgets(buffer, 128, pipe) != NULL) |
|
|
|
|
result += buffer; |
|
|
|
|
} |
|
|
|
|
_pclose(pipe); |
|
|
|
|
return result; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
#pragma comment(lib, "shlwapi.lib") //_popen, _pclose
|
|
|
|
|
#include <shlwapi.h> |
|
|
|
|
|
|
|
|
|
//
|
|
|
|
|
// Returns true if got settings, false if not.
|
|
|
|
|
//
|
|
|
|
|
bool GetVisualStudioEnv( |
|
|
|
|
const char* envVar, // [in] "INCLUDE" / "LIBPATH"
|
|
|
|
|
std::vector<std::string>& vecPathes, |
|
|
|
|
int iProbeFrom = 0, int iProbeTo = 0 // 2005 - 8, 2008 - 9, 2010 - 10
|
|
|
|
|
) |
|
|
|
|
{ |
|
|
|
|
std::string s; |
|
|
|
|
|
|
|
|
|
if( iProbeFrom == 0 && iProbeTo == 0 ) |
|
|
|
|
{ |
|
|
|
|
// Environment variable specifies which VS to use.
|
|
|
|
|
if( getenv("VSENV") != NULL ) |
|
|
|
|
{ |
|
|
|
|
int iVer = atoi( getenv("VSENV") ); |
|
|
|
|
|
|
|
|
|
if( iVer == 0 ) |
|
|
|
|
return false; |
|
|
|
|
// Include the necessary headers to interface with the Windows registry and
|
|
|
|
|
// environment.
|
|
|
|
|
#define WIN32_LEAN_AND_MEAN |
|
|
|
|
#define NOGDI |
|
|
|
|
#define NOMINMAX |
|
|
|
|
#include <Windows.h> |
|
|
|
|
|
|
|
|
|
// Has all the registry lookup related code
|
|
|
|
|
struct MSVCRegLookup { |
|
|
|
|
HKEY hRootKey; |
|
|
|
|
HKEY hKey; |
|
|
|
|
const char* subKey; |
|
|
|
|
DWORD valueType; |
|
|
|
|
|
|
|
|
|
return GetVisualStudioEnv(envVar, vecPathes, iVer, iVer ); |
|
|
|
|
MSVCRegLookup() |
|
|
|
|
: hRootKey(NULL), hKey(NULL), subKey(NULL), valueType(0) { } |
|
|
|
|
|
|
|
|
|
bool InitializeRootKey(const char *keyPath) { |
|
|
|
|
if (strncmp(keyPath, "HKEY_CLASSES_ROOT\\", 18) == 0) { |
|
|
|
|
hRootKey = HKEY_CLASSES_ROOT; |
|
|
|
|
subKey = keyPath + 18; |
|
|
|
|
} else if (strncmp(keyPath, "HKEY_USERS\\", 11) == 0) { |
|
|
|
|
hRootKey = HKEY_USERS; |
|
|
|
|
subKey = keyPath + 11; |
|
|
|
|
} else if (strncmp(keyPath, "HKEY_LOCAL_MACHINE\\", 19) == 0) { |
|
|
|
|
hRootKey = HKEY_LOCAL_MACHINE; |
|
|
|
|
subKey = keyPath + 19; |
|
|
|
|
} else if (strncmp(keyPath, "HKEY_CURRENT_USER\\", 18) == 0) { |
|
|
|
|
hRootKey = HKEY_CURRENT_USER; |
|
|
|
|
subKey = keyPath + 18; |
|
|
|
|
} else { |
|
|
|
|
return false; |
|
|
|
|
} |
|
|
|
|
return true; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
iProbeFrom = 20; |
|
|
|
|
iProbeTo = 9; |
|
|
|
|
bool FindSimpleKeyValue(const char *valueName, char *value, DWORD valueSize) { |
|
|
|
|
bool Ret = false; |
|
|
|
|
long Res = RegOpenKeyExA(hRootKey, subKey, 0, KEY_READ, &hKey); |
|
|
|
|
if (Res == ERROR_SUCCESS) { |
|
|
|
|
Res = RegQueryValueExA(hKey, valueName, NULL, &valueType, |
|
|
|
|
(LPBYTE)value, &valueSize); |
|
|
|
|
if (Res == ERROR_SUCCESS) |
|
|
|
|
Ret = true; |
|
|
|
|
RegCloseKey(hKey); |
|
|
|
|
} |
|
|
|
|
return Ret; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
for( int iProbeVer = iProbeFrom; iProbeVer >= iProbeTo; iProbeVer-- ) |
|
|
|
|
{ |
|
|
|
|
char envvar[64]; |
|
|
|
|
sprintf(envvar, "VS%d0COMNTOOLS", iProbeVer); |
|
|
|
|
bool FindBestVersionKeyValue(const char* versionIndex, |
|
|
|
|
const char *valueName, char *value, DWORD valueSize) { |
|
|
|
|
bool Ret = false; |
|
|
|
|
const char *keyEnd = versionIndex - 1; |
|
|
|
|
const char *nextKey = versionIndex; |
|
|
|
|
|
|
|
|
|
// Not defined
|
|
|
|
|
if( getenv(envvar) == NULL ) |
|
|
|
|
continue; |
|
|
|
|
// Find end of previous key.
|
|
|
|
|
while ((keyEnd > subKey) && (*keyEnd != '\\')) |
|
|
|
|
keyEnd--; |
|
|
|
|
|
|
|
|
|
// Find end of key containing $VERSION.
|
|
|
|
|
while (*nextKey && (*nextKey != '\\')) |
|
|
|
|
nextKey++; |
|
|
|
|
|
|
|
|
|
size_t partialKeyLength = keyEnd - subKey; |
|
|
|
|
char partialKey[256]; |
|
|
|
|
if (partialKeyLength > sizeof(partialKey)) |
|
|
|
|
partialKeyLength = sizeof(partialKey); |
|
|
|
|
strncpy(partialKey, subKey, partialKeyLength); |
|
|
|
|
partialKey[partialKeyLength] = '\0'; |
|
|
|
|
|
|
|
|
|
std::string cmd = getenv(envvar); |
|
|
|
|
cmd += "\\..\\..\\vc\\vcvarsall.bat"; |
|
|
|
|
HKEY hTopKey = NULL; |
|
|
|
|
long Res = RegOpenKeyExA(hRootKey, partialKey, 0, KEY_READ, &hTopKey); |
|
|
|
|
|
|
|
|
|
if( !PathFileExistsA( cmd.c_str() ) ) |
|
|
|
|
if (Res != ERROR_SUCCESS) |
|
|
|
|
return false; |
|
|
|
|
|
|
|
|
|
char keyName[256]; |
|
|
|
|
int bestIndex = -1; |
|
|
|
|
char bestName[256]; |
|
|
|
|
bestName[0] = '\0'; |
|
|
|
|
double bestValue = 0.0; |
|
|
|
|
|
|
|
|
|
// Find the highest versioned key.
|
|
|
|
|
DWORD index, size = sizeof(keyName) - 1; |
|
|
|
|
for (index = 0; RegEnumKeyExA(hTopKey, index, keyName, &size, NULL, |
|
|
|
|
NULL, NULL, NULL) == ERROR_SUCCESS; index++) { |
|
|
|
|
const char *sp = keyName; |
|
|
|
|
while (*sp && !isdigit(*sp)) |
|
|
|
|
sp++; |
|
|
|
|
if (!*sp) |
|
|
|
|
continue; |
|
|
|
|
const char *ep = sp + 1; |
|
|
|
|
while (*ep && (isdigit(*ep) || (*ep == '.'))) |
|
|
|
|
ep++; |
|
|
|
|
char numBuf[32]; |
|
|
|
|
strncpy(numBuf, sp, sizeof(numBuf) - 1); |
|
|
|
|
numBuf[sizeof(numBuf) - 1] = '\0'; |
|
|
|
|
|
|
|
|
|
//printf("Located: %s", envvar);
|
|
|
|
|
double versionValue = strtod(numBuf, NULL); |
|
|
|
|
if (versionValue > bestValue) { |
|
|
|
|
// Better values are only better if the desired key exists for them.
|
|
|
|
|
std::string candidate = std::string(keyName) + nextKey; |
|
|
|
|
Res = RegOpenKeyExA(hTopKey, candidate.c_str(), 0, KEY_READ, &hKey); |
|
|
|
|
if (Res == ERROR_SUCCESS) { |
|
|
|
|
Res = RegQueryValueExA(hKey, valueName, NULL, &valueType, |
|
|
|
|
(LPBYTE)value, &valueSize); |
|
|
|
|
if (Res == ERROR_SUCCESS) { |
|
|
|
|
bestIndex = (int)index; |
|
|
|
|
bestValue = versionValue; |
|
|
|
|
strcpy(bestName, keyName); |
|
|
|
|
} |
|
|
|
|
RegCloseKey(hKey); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
cmd = "cmd /C \"" + cmd + "\" ^>nul ^& set"; |
|
|
|
|
s = exec(cmd.c_str()); |
|
|
|
|
break; |
|
|
|
|
// If we found the highest versioned key, open the key and get the value.
|
|
|
|
|
if (bestIndex != -1) { |
|
|
|
|
// Append rest of key.
|
|
|
|
|
strncat(bestName, nextKey, sizeof(bestName) - 1); |
|
|
|
|
bestName[sizeof(bestName) - 1] = '\0'; |
|
|
|
|
// Open the chosen key path remainder.
|
|
|
|
|
Res = RegOpenKeyExA(hTopKey, bestName, 0, KEY_READ, &hKey); |
|
|
|
|
if (Res == ERROR_SUCCESS) { |
|
|
|
|
Res = RegQueryValueExA(hKey, valueName, NULL, &valueType, |
|
|
|
|
(LPBYTE)value, &valueSize); |
|
|
|
|
if (Res == ERROR_SUCCESS) |
|
|
|
|
Ret = true; |
|
|
|
|
RegCloseKey(hKey); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
RegCloseKey(hTopKey); |
|
|
|
|
return Ret; |
|
|
|
|
} |
|
|
|
|
}; |
|
|
|
|
|
|
|
|
|
/// \brief Read registry string.
|
|
|
|
|
/// This also supports a means to look for high-versioned keys by use
|
|
|
|
|
/// of a $VERSION placeholder in the key path.
|
|
|
|
|
/// $VERSION in the key path is a placeholder for the version number,
|
|
|
|
|
/// causing the highest value path to be searched for and used.
|
|
|
|
|
/// I.e. "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\$VERSION".
|
|
|
|
|
/// There can be additional characters in the component. Only the numeric
|
|
|
|
|
/// characters are compared.
|
|
|
|
|
static bool getSystemRegistryString(const char *keyPath, const char *valueName, |
|
|
|
|
char *value, size_t maxLength) { |
|
|
|
|
MSVCRegLookup Reg; |
|
|
|
|
if (!Reg.InitializeRootKey(keyPath)) |
|
|
|
|
return false; |
|
|
|
|
|
|
|
|
|
const char* versionIndex = strstr(Reg.subKey, "$VERSION"); |
|
|
|
|
// If we have a $VERSION placeholder, do the highest-version search.
|
|
|
|
|
if (versionIndex) |
|
|
|
|
return Reg.FindBestVersionKeyValue(versionIndex, valueName, |
|
|
|
|
value, maxLength-1); |
|
|
|
|
else |
|
|
|
|
return Reg.FindSimpleKeyValue(valueName, value, maxLength-1); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
if( s.length() == 0 ) |
|
|
|
|
/// \brief Get Windows SDK installation directory.
|
|
|
|
|
static bool getWindowsSDKDir(std::string &path) { |
|
|
|
|
char windowsSDKInstallDir[256]; |
|
|
|
|
// Try the Windows registry.
|
|
|
|
|
bool hasSDKDir = getSystemRegistryString( |
|
|
|
|
"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\$VERSION", |
|
|
|
|
"InstallationFolder", |
|
|
|
|
windowsSDKInstallDir, |
|
|
|
|
sizeof(windowsSDKInstallDir) - 1); |
|
|
|
|
// If we have both vc80 and vc90, pick version we were compiled with.
|
|
|
|
|
if (hasSDKDir && windowsSDKInstallDir[0]) { |
|
|
|
|
path = windowsSDKInstallDir; |
|
|
|
|
return true; |
|
|
|
|
} |
|
|
|
|
return false; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
char* envline; |
|
|
|
|
// Get Visual Studio installation directory.
|
|
|
|
|
static bool getVisualStudioDir(std::string &path) { |
|
|
|
|
// First check the environment variables that vsvars32.bat sets.
|
|
|
|
|
const char* vcinstalldir = getenv("VCINSTALLDIR"); |
|
|
|
|
if (vcinstalldir) { |
|
|
|
|
char *p = const_cast<char *>(strstr(vcinstalldir, "\\VC")); |
|
|
|
|
if (p) |
|
|
|
|
*p = '\0'; |
|
|
|
|
path = vcinstalldir; |
|
|
|
|
return true; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
vecPathes.clear(); |
|
|
|
|
char vsIDEInstallDir[256]; |
|
|
|
|
char vsExpressIDEInstallDir[256]; |
|
|
|
|
// Then try the windows registry.
|
|
|
|
|
bool hasVCDir = getSystemRegistryString( |
|
|
|
|
"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\$VERSION", |
|
|
|
|
"InstallDir", vsIDEInstallDir, sizeof(vsIDEInstallDir) - 1); |
|
|
|
|
bool hasVCExpressDir = getSystemRegistryString( |
|
|
|
|
"HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VCExpress\\$VERSION", |
|
|
|
|
"InstallDir", vsExpressIDEInstallDir, sizeof(vsExpressIDEInstallDir) - 1); |
|
|
|
|
// If we have both vc80 and vc90, pick version we were compiled with.
|
|
|
|
|
if (hasVCDir && vsIDEInstallDir[0]) { |
|
|
|
|
char *p = (char*)strstr(vsIDEInstallDir, "\\Common7\\IDE"); |
|
|
|
|
if (p) |
|
|
|
|
*p = '\0'; |
|
|
|
|
path = vsIDEInstallDir; |
|
|
|
|
return true; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
for (envline = strtok( &s[0], "\n" ); envline; envline = strtok( NULL, "\n" )) |
|
|
|
|
{ |
|
|
|
|
char* varend = strchr( envline, '='); |
|
|
|
|
if( !varend ) |
|
|
|
|
continue; |
|
|
|
|
if (hasVCExpressDir && vsExpressIDEInstallDir[0]) { |
|
|
|
|
char *p = (char*)strstr(vsExpressIDEInstallDir, "\\Common7\\IDE"); |
|
|
|
|
if (p) |
|
|
|
|
*p = '\0'; |
|
|
|
|
path = vsExpressIDEInstallDir; |
|
|
|
|
return true; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
*varend = 0; |
|
|
|
|
// Try the environment.
|
|
|
|
|
const char *vs100comntools = getenv("VS100COMNTOOLS"); |
|
|
|
|
const char *vs90comntools = getenv("VS90COMNTOOLS"); |
|
|
|
|
const char *vs80comntools = getenv("VS80COMNTOOLS"); |
|
|
|
|
const char *vscomntools = NULL; |
|
|
|
|
|
|
|
|
|
if( strcmp(envline,envVar) == 0 ) |
|
|
|
|
{ |
|
|
|
|
char* val; |
|
|
|
|
for (val = strtok( varend + 1, ";" ); val; val = strtok( NULL, ";" )) |
|
|
|
|
{ |
|
|
|
|
vecPathes.push_back(val); |
|
|
|
|
// Try to find the version that we were compiled with
|
|
|
|
|
if(false) {} |
|
|
|
|
#if (_MSC_VER >= 1600) // VC100
|
|
|
|
|
else if(vs100comntools) { |
|
|
|
|
vscomntools = vs100comntools; |
|
|
|
|
} |
|
|
|
|
#elif (_MSC_VER == 1500) // VC80
|
|
|
|
|
else if(vs90comntools) { |
|
|
|
|
vscomntools = vs90comntools; |
|
|
|
|
} |
|
|
|
|
*varend = '='; |
|
|
|
|
#elif (_MSC_VER == 1400) // VC80
|
|
|
|
|
else if(vs80comntools) { |
|
|
|
|
vscomntools = vs80comntools; |
|
|
|
|
} |
|
|
|
|
#endif |
|
|
|
|
// Otherwise find any version we can
|
|
|
|
|
else if (vs100comntools) |
|
|
|
|
vscomntools = vs100comntools; |
|
|
|
|
else if (vs90comntools) |
|
|
|
|
vscomntools = vs90comntools; |
|
|
|
|
else if (vs80comntools) |
|
|
|
|
vscomntools = vs80comntools; |
|
|
|
|
|
|
|
|
|
if (vscomntools && *vscomntools) { |
|
|
|
|
const char *p = strstr(vscomntools, "\\Common7\\Tools"); |
|
|
|
|
path = p ? std::string(vscomntools, p) : vscomntools; |
|
|
|
|
return true; |
|
|
|
|
} |
|
|
|
|
return false; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
std::vector<std::string> GetWindowsSystemIncludeDirs() { |
|
|
|
|
std::vector<std::string> Paths; |
|
|
|
|
|
|
|
|
|
std::string VSDir; |
|
|
|
|
std::string WindowsSDKDir; |
|
|
|
|
|
|
|
|
|
// When built with access to the proper Windows APIs, try to actually find
|
|
|
|
|
// the correct include paths first.
|
|
|
|
|
if (getVisualStudioDir(VSDir)) { |
|
|
|
|
Paths.push_back(VSDir + "\\VC\\include"); |
|
|
|
|
if (getWindowsSDKDir(WindowsSDKDir)) |
|
|
|
|
Paths.push_back(WindowsSDKDir + "\\include"); |
|
|
|
|
else |
|
|
|
|
Paths.push_back(VSDir + "\\VC\\PlatformSDK\\Include"); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
return Paths; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
#endif |
triton
12 years ago