mirror of
https://github.com/KhronosGroup/Vulkan-Utility-Libraries.git
synced 2025-05-15 09:18:49 +00:00
632 lines
20 KiB
C++
632 lines
20 KiB
C++
/*
|
|
* Copyright (c) 2015-2022 The Khronos Group Inc.
|
|
* Copyright (c) 2015-2022 Valve Corporation
|
|
* Copyright (c) 2015-2022 LunarG, Inc.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
* Authors:
|
|
* - Christophe Riccio <christophe@lunarg.com>
|
|
* - Mark Lobodzinski <mark@lunarg.com>
|
|
* - Jon Ashburn
|
|
* - Courtney Goeltzenleuchter
|
|
* - Tobin Ehlis
|
|
*/
|
|
|
|
#include "vk_layer_settings.h"
|
|
|
|
#include <cstdlib>
|
|
#include <cassert>
|
|
#include <cstring>
|
|
#include <cctype>
|
|
#include <cstdarg>
|
|
#include <fstream>
|
|
#include <array>
|
|
#include <map>
|
|
#include <sstream>
|
|
#include <regex>
|
|
#include <sys/stat.h>
|
|
|
|
#include <vulkan/vk_layer.h>
|
|
|
|
#if defined(_WIN32)
|
|
#include <windows.h>
|
|
#include <direct.h>
|
|
#define GetCurrentDir _getcwd
|
|
#else
|
|
#include <unistd.h>
|
|
#define GetCurrentDir getcwd
|
|
#endif
|
|
|
|
#ifdef __ANDROID__
|
|
#include <sys/system_properties.h>
|
|
#endif
|
|
|
|
namespace vku {
|
|
|
|
static std::string format(const char *message, ...) {
|
|
std::size_t const STRING_BUFFER(4096);
|
|
|
|
assert(message != nullptr);
|
|
assert(strlen(message) >= 0 && strlen(message) < STRING_BUFFER);
|
|
|
|
char buffer[STRING_BUFFER];
|
|
va_list list;
|
|
|
|
va_start(list, message);
|
|
vsnprintf(buffer, STRING_BUFFER, message, list);
|
|
va_end(list);
|
|
|
|
return buffer;
|
|
}
|
|
|
|
static bool IsFrames(const std::string &s) {
|
|
static const std::regex FRAME_REGEX("^([0-9]+([-][0-9]+){0,2})(,([0-9]+([-][0-9]+){0,2}))*$");
|
|
|
|
return std::regex_search(s, FRAME_REGEX);
|
|
}
|
|
|
|
static bool IsNumber(const std::string &s) {
|
|
static const std::regex FRAME_REGEX("^-?[0-9]*$");
|
|
|
|
return std::regex_search(s, FRAME_REGEX);
|
|
}
|
|
|
|
static bool IsFloat(const std::string &s) {
|
|
static const std::regex FRAME_REGEX("^-?[0-9]*([.][0-9]*)?$");
|
|
|
|
return std::regex_search(s, FRAME_REGEX);
|
|
}
|
|
|
|
enum Source {
|
|
SOURCE_VKCONFIG,
|
|
SOURCE_ENV_VAR,
|
|
SOURCE_LOCAL,
|
|
};
|
|
|
|
struct SettingsFileInfo {
|
|
SettingsFileInfo() : file_found(false), source(SOURCE_LOCAL) {}
|
|
|
|
bool file_found;
|
|
std::string location;
|
|
Source source;
|
|
};
|
|
|
|
class LayerSettings {
|
|
public:
|
|
LayerSettings();
|
|
~LayerSettings(){};
|
|
|
|
void SetCallback(LAYER_SETTING_LOG_CALLBACK callback) { this->callback_ = callback; }
|
|
void Log(const std::string &setting_key, const std::string &message);
|
|
|
|
bool Is(const std::string &setting_key);
|
|
const char *Get(const std::string &setting_key);
|
|
void Set(const std::string &setting_key, const std::string &setting_value);
|
|
|
|
std::string vk_layer_disables_env_var;
|
|
SettingsFileInfo settings_info;
|
|
|
|
private:
|
|
bool file_is_parsed_;
|
|
std::map<std::string, std::string> value_map_;
|
|
|
|
std::string last_log_setting;
|
|
std::string last_log_message;
|
|
|
|
std::string FindSettings();
|
|
void ParseFile(const char *filename);
|
|
LAYER_SETTING_LOG_CALLBACK callback_;
|
|
};
|
|
|
|
static LayerSettings vk_layer_settings;
|
|
|
|
#if defined(__ANDROID__)
|
|
std::string GetAndroidProperty(const char* name) {
|
|
std::string output;
|
|
const prop_info* pi = __system_property_find(name);
|
|
if (pi) {
|
|
__system_property_read_callback(
|
|
pi,
|
|
[](void* cookie, const char* name, const char* value, uint32_t serial) {
|
|
reinterpret_cast<std::string*>(cookie)->assign(value);
|
|
},
|
|
reinterpret_cast<void*>(&output));
|
|
}
|
|
return output;
|
|
}
|
|
#endif
|
|
|
|
static bool IsEnvironment(const char *variable) {
|
|
#if defined(__ANDROID__)
|
|
return !GetAndroidProperty(variable).empty();
|
|
#else
|
|
return std::getenv(variable) != NULL;
|
|
#endif
|
|
}
|
|
|
|
static std::string GetEnvironment(const char *variable) {
|
|
#if defined(__ANDROID__)
|
|
return GetAndroidProperty(variable);
|
|
#else
|
|
const char *output = std::getenv(variable);
|
|
return output == NULL ? "" : output;
|
|
#endif
|
|
}
|
|
|
|
static std::string string_tolower(const std::string &s) {
|
|
std::string result = s;
|
|
for (auto &c : result) {
|
|
c = (char) std::tolower(c);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static std::string string_toupper(const std::string &s) {
|
|
std::string result = s;
|
|
for (auto &c : result) {
|
|
c = (char) std::toupper(c);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
const char *GetLayerEnvVar(const char *setting_env) {
|
|
vk_layer_settings.vk_layer_disables_env_var = GetEnvironment(setting_env);
|
|
return vk_layer_settings.vk_layer_disables_env_var.c_str();
|
|
}
|
|
|
|
static std::string TrimPrefix(const std::string &layer_key) {
|
|
std::string key {};
|
|
if (layer_key.find("VK_LAYER_") == 0) {
|
|
std::size_t prefix = std::strlen("VK_LAYER_");
|
|
key = layer_key.substr(prefix, layer_key.size() - prefix);
|
|
} else {
|
|
key = layer_key;
|
|
}
|
|
return key;
|
|
}
|
|
|
|
static std::string GetSettingKey(const char *layer_key, const char *setting_key) {
|
|
std::stringstream result;
|
|
result << string_tolower(TrimPrefix(layer_key)) << "." << setting_key;
|
|
return result.str();
|
|
}
|
|
|
|
static inline std::string TrimVendor(const std::string &layer_key) {
|
|
static const char *separator = "_";
|
|
|
|
const std::string &namespace_key = TrimPrefix(layer_key);
|
|
|
|
const auto trimmed_beg = namespace_key.find_first_of(separator);
|
|
if (trimmed_beg == std::string::npos) return namespace_key;
|
|
|
|
assert(namespace_key.find_last_not_of(separator) != std::string::npos &&
|
|
trimmed_beg <= namespace_key.find_last_not_of(separator));
|
|
|
|
return namespace_key.substr(trimmed_beg + 1, namespace_key.size());
|
|
}
|
|
|
|
enum TrimMode {
|
|
TRIM_NONE,
|
|
TRIM_VENDOR,
|
|
TRIM_NAMESPACE,
|
|
|
|
TRIM_FIRST = TRIM_NONE,
|
|
TRIM_LAST = TRIM_NAMESPACE,
|
|
};
|
|
|
|
static std::string GetEnvVarKey(const char *layer_key, const char *setting_key, TrimMode trim_mode) {
|
|
std::stringstream result;
|
|
|
|
#if defined(__ANDROID__)
|
|
switch (trim_mode) {
|
|
default:
|
|
case TRIM_NONE: {
|
|
result << "debug.vulkan." << GetSettingKey(layer_key, setting_key);
|
|
break;
|
|
}
|
|
case TRIM_VENDOR: {
|
|
result << "debug.vulkan." << GetSettingKey(TrimVendor(layer_key).c_str(), setting_key);
|
|
break;
|
|
}
|
|
case TRIM_NAMESPACE: {
|
|
result << "debug.vulkan." << setting_key;
|
|
break;
|
|
}
|
|
}
|
|
#else
|
|
switch (trim_mode) {
|
|
default:
|
|
case TRIM_NONE: {
|
|
result << "VK_" << string_toupper(TrimPrefix(layer_key)) << "_" << string_toupper(setting_key);
|
|
break;
|
|
}
|
|
case TRIM_VENDOR: {
|
|
result << "VK_" << string_toupper(TrimVendor(layer_key)) << "_" << string_toupper(setting_key);
|
|
break;
|
|
}
|
|
case TRIM_NAMESPACE: {
|
|
result << "VK_" << string_toupper(setting_key);
|
|
break;
|
|
}
|
|
}
|
|
|
|
#endif
|
|
return result.str();
|
|
}
|
|
|
|
void InitLayerSettingsLogCallback(LAYER_SETTING_LOG_CALLBACK callback) {
|
|
vk_layer_settings.SetCallback(callback);
|
|
return;
|
|
}
|
|
|
|
bool IsLayerSetting(const char *layer_key, const char *setting_key) {
|
|
assert(layer_key);
|
|
assert(!std::string(layer_key).empty());
|
|
assert(setting_key);
|
|
assert(!std::string(setting_key).empty());
|
|
|
|
for (int i = TRIM_FIRST, n = TRIM_LAST; i <= n; ++i) {
|
|
if (IsEnvironment(GetEnvVarKey(layer_key, setting_key, static_cast<TrimMode>(i)).c_str())) return true;
|
|
}
|
|
|
|
return vk_layer_settings.Is(GetSettingKey(layer_key, setting_key).c_str());
|
|
}
|
|
|
|
static std::string GetLayerSettingData(const char *layer_key, const char *setting_key) {
|
|
// First search in the environment variables
|
|
for (int i = TRIM_FIRST, n = TRIM_LAST; i <= n; ++i) {
|
|
std::string setting = GetLayerEnvVar(GetEnvVarKey(layer_key, setting_key, static_cast<TrimMode>(i)).c_str());
|
|
if (!setting.empty()) return setting;
|
|
}
|
|
|
|
// Second search in vk_layer_settings.txt
|
|
return vk_layer_settings.Get(GetSettingKey(layer_key, setting_key).c_str());
|
|
}
|
|
|
|
bool GetLayerSettingBool(const char *layer_key, const char *setting_key) {
|
|
assert(IsLayerSetting(layer_key, setting_key));
|
|
|
|
bool result = false; // default value
|
|
|
|
std::string setting = string_tolower(GetLayerSettingData(layer_key, setting_key));
|
|
if (setting.empty()) {
|
|
vk_layer_settings.Log(setting_key,
|
|
"The setting is used but the value is empty which is invalid for a boolean setting type.");
|
|
} else if (IsNumber(setting)) {
|
|
result = std::atoi(setting.c_str()) != 0;
|
|
} else if (setting == "true" || setting == "false") {
|
|
result = setting == "true";
|
|
} else {
|
|
std::string message = format("The data provided (%s) is not a boolean value.", setting.c_str());
|
|
vk_layer_settings.Log(setting_key, message);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
int GetLayerSettingInt(const char *layer_key, const char *setting_key) {
|
|
assert(IsLayerSetting(layer_key, setting_key));
|
|
|
|
int result = 0; // default value
|
|
|
|
std::string setting = GetLayerSettingData(layer_key, setting_key);
|
|
if (setting.empty()) {
|
|
std::string message = "The setting is used but the value is empty which is invalid for a integer setting type.";
|
|
vk_layer_settings.Log(setting_key, message);
|
|
} else if (!IsNumber(setting)) {
|
|
std::string message = format("The data provided (%s) is not an integer value.", setting.c_str());
|
|
vk_layer_settings.Log(setting_key, message);
|
|
} else {
|
|
result = std::atoi(setting.c_str());
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
double GetLayerSettingFloat(const char *layer_key, const char *setting_key) {
|
|
assert(IsLayerSetting(layer_key, setting_key));
|
|
|
|
double result = 0.0; // default value
|
|
|
|
std::string setting = GetLayerSettingData(layer_key, setting_key);
|
|
if (setting.empty()) {
|
|
std::string message = "The setting is used but the value is empty which is invalid for a floating-point setting type.";
|
|
vk_layer_settings.Log(setting_key, message);
|
|
} else if (!IsFloat(setting)) {
|
|
std::string message = format("The data provided (%s) is not a floating-point value.", setting.c_str());
|
|
vk_layer_settings.Log(setting_key, message);
|
|
} else {
|
|
result = std::atof(setting.c_str());
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
std::string GetLayerSettingString(const char *layer_key, const char *setting_key) {
|
|
assert(IsLayerSetting(layer_key, setting_key));
|
|
|
|
std::string setting = GetLayerSettingData(layer_key, setting_key);
|
|
if (setting.empty()) {
|
|
std::string message = "The setting is used but the value is empty which is invalid for a string setting type.";
|
|
vk_layer_settings.Log(setting_key, message);
|
|
}
|
|
|
|
return setting;
|
|
}
|
|
|
|
std::string GetLayerSettingFrames(const char *layer_key, const char *setting_key) {
|
|
assert(IsLayerSetting(layer_key, setting_key));
|
|
|
|
std::string setting = GetLayerSettingData(layer_key, setting_key);
|
|
if (!setting.empty() && !IsFrames(setting)) {
|
|
std::string message = format("The data provided (%s) is not a frames value.", setting.c_str());
|
|
vk_layer_settings.Log(setting_key, message);
|
|
}
|
|
|
|
return setting;
|
|
}
|
|
|
|
static inline std::vector<std::string> Split(const std::string &value, const std::string &delimiter) {
|
|
std::vector<std::string> result;
|
|
|
|
std::string parse = value;
|
|
|
|
std::size_t start = 0;
|
|
std::size_t end = parse.find(delimiter);
|
|
while (end != std::string::npos) {
|
|
result.push_back(parse.substr(start, end - start));
|
|
start = end + delimiter.length();
|
|
end = parse.find(delimiter, start);
|
|
}
|
|
|
|
const std::string last = parse.substr(start, end);
|
|
if (!last.empty()) {
|
|
result.push_back(last);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
Strings GetLayerSettingStrings(const char *layer_key, const char *setting_key) {
|
|
assert(IsLayerSetting(layer_key, setting_key));
|
|
|
|
std::string setting = GetLayerSettingData(layer_key, setting_key);
|
|
if (setting.find_first_of(",") != std::string::npos) {
|
|
return Split(setting, ",");
|
|
} else {
|
|
#ifdef _WIN32
|
|
const char *delimiter = ";";
|
|
#else
|
|
const char *delimiter = ":";
|
|
#endif
|
|
return Split(setting, delimiter);
|
|
}
|
|
}
|
|
|
|
List GetLayerSettingList(const char *layer_key, const char *setting_key) {
|
|
assert(IsLayerSetting(layer_key, setting_key));
|
|
|
|
std::vector<std::string> inputs = GetLayerSettingStrings(layer_key, setting_key);
|
|
|
|
List result;
|
|
for (std::size_t i = 0, n = inputs.size(); i < n; ++i) {
|
|
std::pair<std::string, int> value;
|
|
if (IsNumber(inputs[i])) {
|
|
value.second = atoi(inputs[i].c_str());
|
|
} else {
|
|
value.first = inputs[i];
|
|
}
|
|
result.push_back(value);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// Constructor for ConfigFile. Initialize layers to log error messages to stdout by default. If a vk_layer_settings file is present,
|
|
// its settings will override the defaults.
|
|
LayerSettings::LayerSettings() : file_is_parsed_(false), callback_(nullptr) {}
|
|
|
|
void LayerSettings::Log(const std::string &setting_key, const std::string &message) {
|
|
this->last_log_setting = setting_key;
|
|
this->last_log_message = message;
|
|
|
|
if (this->callback_ == nullptr) {
|
|
fprintf(stderr, "LAYER SETTING (%s) error: %s\n", this->last_log_setting.c_str(), this->last_log_message.c_str());
|
|
} else {
|
|
this->callback_(this->last_log_setting.c_str(), this->last_log_message.c_str());
|
|
}
|
|
}
|
|
|
|
bool LayerSettings::Is(const std::string &setting_key) {
|
|
std::map<std::string, std::string>::const_iterator it;
|
|
if (!file_is_parsed_) {
|
|
std::string settings_file = FindSettings();
|
|
ParseFile(settings_file.c_str());
|
|
}
|
|
|
|
return value_map_.find(setting_key) != value_map_.end();
|
|
}
|
|
|
|
const char *LayerSettings::Get(const std::string &setting_key) {
|
|
std::map<std::string, std::string>::const_iterator it;
|
|
if (!file_is_parsed_) {
|
|
std::string settings_file = FindSettings();
|
|
ParseFile(settings_file.c_str());
|
|
}
|
|
|
|
if ((it = value_map_.find(setting_key)) == value_map_.end()) {
|
|
return "";
|
|
} else {
|
|
return it->second.c_str();
|
|
}
|
|
}
|
|
|
|
void LayerSettings::Set(const std::string &setting_key, const std::string &value) {
|
|
if (!file_is_parsed_) {
|
|
std::string settings_file = FindSettings();
|
|
ParseFile(settings_file.c_str());
|
|
}
|
|
|
|
value_map_[setting_key] = value;
|
|
}
|
|
|
|
#if defined(WIN32)
|
|
// Check for admin rights
|
|
static inline bool IsHighIntegrity() {
|
|
HANDLE process_token;
|
|
if (OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY | TOKEN_QUERY_SOURCE, &process_token)) {
|
|
// Maximum possible size of SID_AND_ATTRIBUTES is maximum size of a SID + size of attributes DWORD.
|
|
uint8_t mandatory_label_buffer[SECURITY_MAX_SID_SIZE + sizeof(DWORD)];
|
|
DWORD buffer_size;
|
|
if (GetTokenInformation(process_token, TokenIntegrityLevel, mandatory_label_buffer, sizeof(mandatory_label_buffer),
|
|
&buffer_size) != 0) {
|
|
const TOKEN_MANDATORY_LABEL *mandatory_label = (const TOKEN_MANDATORY_LABEL *)mandatory_label_buffer;
|
|
const DWORD sub_authority_count = *GetSidSubAuthorityCount(mandatory_label->Label.Sid);
|
|
const DWORD integrity_level = *GetSidSubAuthority(mandatory_label->Label.Sid, sub_authority_count - 1);
|
|
|
|
CloseHandle(process_token);
|
|
return integrity_level > SECURITY_MANDATORY_MEDIUM_RID;
|
|
}
|
|
|
|
CloseHandle(process_token);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
std::string LayerSettings::FindSettings() {
|
|
struct stat info;
|
|
|
|
#if defined(WIN32)
|
|
// Look for VkConfig-specific settings location specified in the windows registry
|
|
HKEY key;
|
|
|
|
const std::array<HKEY, 2> hives = {HKEY_LOCAL_MACHINE, HKEY_CURRENT_USER};
|
|
const size_t hives_to_check_count = IsHighIntegrity() ? 1 : hives.size(); // Admin checks only the default hive
|
|
|
|
for (size_t hive_index = 0; hive_index < hives_to_check_count; ++hive_index) {
|
|
LSTATUS err = RegOpenKeyEx(hives[hive_index], "Software\\Khronos\\Vulkan\\Settings", 0, KEY_READ, &key);
|
|
if (err == ERROR_SUCCESS) {
|
|
char name[2048];
|
|
DWORD i = 0, name_size, type, value, value_size;
|
|
while (ERROR_SUCCESS == RegEnumValue(key, i++, name, &(name_size = sizeof(name)), nullptr, &type,
|
|
reinterpret_cast<LPBYTE>(&value), &(value_size = sizeof(value)))) {
|
|
// Check if the registry entry is a dword with a value of zero
|
|
if (type != REG_DWORD || value != 0) {
|
|
continue;
|
|
}
|
|
|
|
// Check if this actually points to a file
|
|
if ((stat(name, &info) != 0) || !(info.st_mode & S_IFREG)) {
|
|
continue;
|
|
}
|
|
|
|
// Use this file
|
|
RegCloseKey(key);
|
|
settings_info.source = SOURCE_VKCONFIG;
|
|
settings_info.location = name;
|
|
return name;
|
|
}
|
|
|
|
RegCloseKey(key);
|
|
}
|
|
}
|
|
|
|
#else
|
|
// Look for VkConfig-specific settings location specified in a specific spot in the linux settings store
|
|
std::string search_path = GetEnvironment("XDG_DATA_HOME");
|
|
if (search_path == "") {
|
|
search_path = GetEnvironment("HOME");
|
|
if (search_path != "") {
|
|
search_path += "/.local/share";
|
|
}
|
|
}
|
|
// Use the vk_layer_settings.txt file from here, if it is present
|
|
if (search_path != "") {
|
|
std::string home_file = search_path + "/vulkan/settings.d/vk_layer_settings.txt";
|
|
if (stat(home_file.c_str(), &info) == 0) {
|
|
if (info.st_mode & S_IFREG) {
|
|
settings_info.source = SOURCE_VKCONFIG;
|
|
settings_info.location = home_file;
|
|
return home_file;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
#ifdef __ANDROID__
|
|
std::string env_path = GetEnvironment("debug.vulkan.khronos_profiles.settings_path");
|
|
#else
|
|
// Look for an environment variable override for the settings file location
|
|
std::string env_path = GetEnvironment("VK_LAYER_SETTINGS_PATH");
|
|
#endif
|
|
|
|
// If the path exists use it, else use vk_layer_settings
|
|
if (stat(env_path.c_str(), &info) == 0) {
|
|
// If this is a directory, append settings file name
|
|
if (info.st_mode & S_IFDIR) {
|
|
env_path.append("/vk_layer_settings.txt");
|
|
}
|
|
settings_info.source = SOURCE_ENV_VAR;
|
|
settings_info.location = env_path;
|
|
return env_path;
|
|
}
|
|
|
|
// Default -- use the current working directory for the settings file location
|
|
settings_info.source = SOURCE_LOCAL;
|
|
char buff[512];
|
|
auto buf_ptr = GetCurrentDir(buff, 512);
|
|
if (buf_ptr) {
|
|
settings_info.location = buf_ptr;
|
|
settings_info.location.append("/vk_layer_settings.txt");
|
|
}
|
|
return "vk_layer_settings.txt";
|
|
}
|
|
|
|
static inline std::string TrimWhitespace(const std::string &s) {
|
|
const char *whitespace = " \t\f\v\n\r";
|
|
|
|
const auto trimmed_beg = s.find_first_not_of(whitespace);
|
|
if (trimmed_beg == std::string::npos) return "";
|
|
|
|
const auto trimmed_end = s.find_last_not_of(whitespace);
|
|
assert(trimmed_end != std::string::npos && trimmed_beg <= trimmed_end);
|
|
|
|
return s.substr(trimmed_beg, trimmed_end - trimmed_beg + 1);
|
|
}
|
|
|
|
void LayerSettings::ParseFile(const char *filename) {
|
|
file_is_parsed_ = true;
|
|
|
|
// Extract option = value pairs from a file
|
|
std::ifstream file(filename);
|
|
if (file.good()) {
|
|
settings_info.file_found = true;
|
|
for (std::string line; std::getline(file, line);) {
|
|
// discard comments, which start with '#'
|
|
const auto comments_pos = line.find_first_of('#');
|
|
if (comments_pos != std::string::npos) line.erase(comments_pos);
|
|
|
|
const auto value_pos = line.find_first_of('=');
|
|
if (value_pos != std::string::npos) {
|
|
const std::string setting_key = TrimWhitespace(line.substr(0, value_pos));
|
|
const std::string setting_value = TrimWhitespace(line.substr(value_pos + 1));
|
|
value_map_[setting_key] = setting_value;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
} // namespace vku
|