Merge pull request #1810 from Kelimion/ms_craziness

Additional cleanup of microsoft_craziness.h.

src/build_settings.cpp

@@ -1234,6 +1234,16 @@ bool init_build_paths(String init_filename) {
 				return false;
 			}
 
+			if (!build_context.use_lld && find_result.vs_exe_path.len == 0) {
+				gb_printf_err("link.exe not found.\n");
+				return false;
+			}
+
+			if (find_result.vs_library_path.len == 0) {
+				gb_printf_err("VS library path not found.\n");
+				return false;
+			}
+
 			if (find_result.windows_sdk_um_library_path.len > 0) {
 				GB_ASSERT(find_result.windows_sdk_ucrt_library_path.len > 0);
 

src/gb/gb.h

@@ -1680,7 +1680,7 @@ GB_DEF gbFileContents gb_file_read_contents(gbAllocator a, b32 zero_terminate, c
 GB_DEF void           gb_file_free_contents(gbFileContents *fc);
 
 
-// TODO(bill): Should these have different na,es as they do not take in a gbFile * ???
+// TODO(bill): Should these have different names as they do not take in a gbFile * ???
 GB_DEF b32        gb_file_exists         (char const *filepath);
 GB_DEF gbFileTime gb_file_last_write_time(char const *filepath);
 GB_DEF b32        gb_file_copy           (char const *existing_filename, char const *new_filename, b32 fail_if_exists);

src/microsoft_craziness.h

@@ -181,7 +181,6 @@ void mc_find_close(HANDLE handle) {
 
 
 // COM objects for the ridiculous Microsoft craziness.
-
 typedef WCHAR* BSTR;
 typedef const WCHAR* LPCOLESTR;
 
@@ -215,44 +214,6 @@ struct DECLSPEC_UUID("42843719-DB4C-46C2-8E7C-64F1816EFD5B") DECLSPEC_NOVTABLE I
 
 
 // The beginning of the actual code that does things.
-
-struct Version_Data {
-	i32 best_version[4];  // For Windows 8 versions, only two of these numbers are used.
-	wchar_t const *best_name;
-};
-
-bool os_file_exists(wchar_t const *name) {
-	// @Robustness: What flags do we really want to check here?
-
-	auto attrib = GetFileAttributesW(name);
-	if (attrib == INVALID_FILE_ATTRIBUTES) return false;
-	if (attrib & FILE_ATTRIBUTE_DIRECTORY) return false;
-
-	return true;
-}
-
-wchar_t *concat(wchar_t const *a, wchar_t const *b, wchar_t const *c = nullptr, wchar_t const *d = nullptr) {
-	// Concatenate up to 4 wide strings together. Allocated with malloc.
-	// If you don't like that, use a programming language that actually
-	// helps you with using custom allocators. Or just edit the code.
-
-	isize len_a = string16_len(a);
-	isize len_b = string16_len(b);
-	isize len_c = string16_len(c);
-	isize len_d = string16_len(d);
-
-	wchar_t *result = (wchar_t *)calloc(2, (len_a + len_b + len_c + len_d + 1));
-	gb_memmove(result, a, len_a*2);
-	gb_memmove(result + len_a, b, len_b*2);
-
-	if (c) gb_memmove(result + len_a + len_b, c, len_c * 2);
-	if (d) gb_memmove(result + len_a + len_b + len_c, d, len_d * 2);
-
-	result[len_a + len_b + len_c + len_d] = 0;
-
-	return result;
-}
-
 struct Version_Data_Utf8 {
 	i32 best_version[4];  // For Windows 8 versions, only two of these numbers are used.
 	String best_name;
@@ -426,7 +387,7 @@ void find_windows_kit_root(Find_Result_Utf8 *result) {
 	// If we get here, we failed to find anything.
 }
 
-bool find_visual_studio_by_fighting_through_microsoft_craziness(Find_Result *result) {
+bool find_visual_studio_by_fighting_through_microsoft_craziness(Find_Result_Utf8 *result) {
 	// The name of this procedure is kind of cryptic. Its purpose is
 	// to fight through Microsoft craziness. The things that the fine
 	// Visual Studio team want you to do, JUST TO FIND A SINGLE FOLDER
@@ -470,64 +431,49 @@ bool find_visual_studio_by_fighting_through_microsoft_craziness(Find_Result *res
 
 			defer (instance->Release());
 
-			BSTR bstr_inst_path;
+			wchar_t* inst_path_wide;
-			hr = instance->GetInstallationPath(&bstr_inst_path);
+			hr = instance->GetInstallationPath(&inst_path_wide);
 			if (hr != S_OK)  continue;
-			defer (SysFreeString(bstr_inst_path));
+			defer (SysFreeString(inst_path_wide));
 
-			auto tools_filename = concat(bstr_inst_path, L"\\VC\\Auxiliary\\Build\\Microsoft.VCToolsVersion.default.txt");
+			String inst_path = mc_wstring_to_string(inst_path_wide);
-			defer (free(tools_filename));
+			defer (mc_free(inst_path));
 
-			FILE *f = nullptr;
+			String tools_filename = mc_concat(inst_path, str_lit("\\VC\\Auxiliary\\Build\\Microsoft.VCToolsVersion.default.txt"));
-			auto open_result = _wfopen_s(&f, tools_filename, L"rt");
+			defer (mc_free(tools_filename));
-			if (open_result != 0) continue;
-			if (!f) continue;
-			defer (fclose(f));
 
-			LARGE_INTEGER tools_file_size;
+			gbFileContents tool_version = gb_file_read_contents(mc_allocator, true, (const char*)tools_filename.text);
-			auto file_handle = (HANDLE)_get_osfhandle(_fileno(f));
+			defer (gb_file_free_contents(&tool_version));
-			BOOL success = GetFileSizeEx(file_handle, &tools_file_size);
-			if (!success) continue;
 
-			auto version_bytes = (tools_file_size.QuadPart + 1) * 2;  // Warning: This multiplication by 2 presumes there is no variable-length encoding in the wchars (wacky characters in the file could betray this expectation).
+			String version_string = make_string((const u8*)tool_version.data, tool_version.size);
-			if (version_bytes > 0x7FFFFFFF) continue;   // Avoid overflow.
+			version_string = string_trim_whitespace(version_string);
 
-			wchar_t *version = (wchar_t *)calloc(1, (usize)version_bytes);
+			String base_path = mc_concat(inst_path, str_lit("\\VC\\Tools\\MSVC\\"), version_string);
-			defer (free(version));
+			defer (mc_free(base_path));
 
-			auto read_result = fgetws(version, (int)version_bytes, f);
+			String library_path = {};
-			if (!read_result) continue;
-
-			auto version_tail = wcschr(version, '\n');
-			if (version_tail)  *version_tail = 0;  // Stomp the data, because nobody cares about it.
-
-			wchar_t *library_path = nullptr;
 			if (build_context.metrics.arch == TargetArch_amd64) {
-				library_path = concat(bstr_inst_path, L"\\VC\\Tools\\MSVC\\", version, L"\\lib\\x64\\");
+				library_path = mc_concat(base_path, str_lit("\\lib\\x64\\"));
 			} else if (build_context.metrics.arch == TargetArch_i386) {
-				library_path = concat(bstr_inst_path, L"\\VC\\Tools\\MSVC\\", version, L"\\lib\\x86\\");
+				library_path = mc_concat(base_path, str_lit("\\lib\\x86\\"));
 			} else {
 				continue;
 			}
 
-			auto library_file = concat(library_path, L"vcruntime.lib");  // @Speed: Could have library_path point to this string, with a smaller count, to save on memory flailing!
+			String library_file = mc_concat(library_path, str_lit("vcruntime.lib"));
 
-			if (os_file_exists(library_file)) {
+			if (gb_file_exists((const char*)library_file.text)) {
-				wchar_t *link_exe_path = nullptr;
 				if (build_context.metrics.arch == TargetArch_amd64) {
-					link_exe_path = concat(bstr_inst_path, L"\\VC\\Tools\\MSVC\\", version, L"\\bin\\Hostx64\\x64\\");
+					result->vs_exe_path = mc_concat(base_path, str_lit("\\bin\\Hostx64\\x64\\"));
 				} else if (build_context.metrics.arch == TargetArch_i386) {
-					link_exe_path = concat(bstr_inst_path, L"\\VC\\Tools\\MSVC\\", version, L"\\bin\\Hostx86\\x86\\");
+					result->vs_exe_path = mc_concat(base_path, str_lit("\\bin\\Hostx86\\x86\\"));
 				} else {
 					continue;
 				}
 
-
-				result->vs_exe_path     = link_exe_path;
 				result->vs_library_path = library_path;
 				return true;
 			}
-
 			/*
 			   Ryan Saunderson said:
 			   "Clang uses the 'SetupInstance->GetInstallationVersion' / ISetupHelper->ParseVersion to find the newest version
@@ -542,65 +488,64 @@ bool find_visual_studio_by_fighting_through_microsoft_craziness(Find_Result *res
 	{
 		HKEY vs7_key;
 		rc = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\VisualStudio\\SxS\\VS7", 0, KEY_QUERY_VALUE | KEY_WOW64_32KEY, &vs7_key);
-		if (rc != S_OK)  return false;
+		if (rc != S_OK) return false;
 		defer (RegCloseKey(vs7_key));
 
 		// Hardcoded search for 4 prior Visual Studio versions. Is there something better to do here?
-		wchar_t const *versions[] = { L"14.0", L"13.0",  L"12.0", L"11.0", L"10.0", L"9.0", };
+		char const *versions[] = { "14.0", "13.0",  "12.0", "11.0", "10.0", "9.0", };
 		const int NUM_VERSIONS = sizeof(versions) / sizeof(versions[0]);
 
 		for (int i = 0; i < NUM_VERSIONS; i++) {
-			wchar_t const *v = versions[i];
+			char const *v = versions[i];
 
 			DWORD dw_type;
-			DWORD cb_data;
+			DWORD required_length;
 
-			auto rc = RegQueryValueExW(vs7_key, v, NULL, &dw_type, NULL, &cb_data);
+			auto rc = RegQueryValueExA(vs7_key, v, NULL, &dw_type, NULL, &required_length);
 			if ((rc == ERROR_FILE_NOT_FOUND) || (dw_type != REG_SZ)) {
 				continue;
 			}
 
-			auto buffer = (wchar_t *)calloc(1, cb_data);
+			DWORD length = required_length + 2;  // The +2 is for the maybe optional zero later on. Probably we are over-allocating.
-			if (!buffer)  return false;
+			char *c_str = gb_alloc_array(mc_allocator, char, length);
-			defer (free(buffer));
 
-			rc = RegQueryValueExW(vs7_key, v, NULL, NULL, (LPBYTE)buffer, &cb_data);
+			rc = RegQueryValueExA(vs7_key, v, NULL, NULL, (LPBYTE)c_str, &length);
 			if (rc != 0)  continue;
 
-			// @Robustness: Do the zero-termination thing suggested in the RegQueryValue docs?
+			if (c_str[required_length]) {
+				c_str[required_length+1] = 0;
+			}
+			String base_path = make_string_c(c_str);
 
-			wchar_t *lib_path = nullptr;
+			String lib_path = {};
 
 			if (build_context.metrics.arch == TargetArch_amd64) {
-				lib_path = concat(buffer, L"VC\\Lib\\amd64\\");
+				lib_path = mc_concat(base_path, str_lit("VC\\Lib\\amd64\\"));
 			} else if (build_context.metrics.arch == TargetArch_i386) {
-				lib_path = concat(buffer, L"VC\\Lib\\");
+				lib_path = mc_concat(base_path, str_lit("VC\\Lib\\"));
 			} else {
 				continue;
 			}
 
 			// Check to see whether a vcruntime.lib actually exists here.
-			auto vcruntime_filename = concat(lib_path, L"vcruntime.lib");
+			String vcruntime_filename = mc_concat(lib_path, str_lit("vcruntime.lib"));
-			defer (free(vcruntime_filename));
+			defer (mc_free(vcruntime_filename));
 
-			if (os_file_exists(vcruntime_filename)) {
+			if (gb_file_exists((const char*)vcruntime_filename.text)) {
 				if (build_context.metrics.arch == TargetArch_amd64) {
-					result->vs_exe_path = concat(buffer, L"VC\\bin\\");
+					result->vs_exe_path = mc_concat(base_path, str_lit("VC\\bin\\"));
 				} else if (build_context.metrics.arch == TargetArch_i386) {
-					result->vs_exe_path = concat(buffer, L"VC\\bin\\x86_amd64\\");
+					result->vs_exe_path = mc_concat(base_path, str_lit("VC\\bin\\x86_amd64\\"));
 				} else {
 					continue;
 				}
-
 				result->vs_library_path = lib_path;
 				return true;
 			}
-
+			mc_free(lib_path);
-			free(lib_path);
 		}
 		// If we get here, we failed to find anything.
 	}
-
 	return false;
 }
 
@@ -618,13 +563,7 @@ Find_Result_Utf8 find_visual_studio_and_windows_sdk_utf8() {
 		}
 	}
 
-	Find_Result result = {};
+	find_visual_studio_by_fighting_through_microsoft_craziness(&r);
-	bool ok = find_visual_studio_by_fighting_through_microsoft_craziness(&result);
-
-	if (ok) {
-		r.vs_exe_path     = mc_wstring_to_string(result.vs_exe_path);
-		r.vs_library_path = mc_wstring_to_string(result.vs_library_path);
-	}
 
 #if 0
 	printf("windows_sdk_root:              %.*s\n", LIT(r.windows_sdk_root));