xml_compiler::url_loader::~url_loader(void) {
std::string raw_identifier("system.vk_open_url_definition");
auto identifier = raw_identifier;
normalize_identifier_(identifier);
uint32_t config_index = symbol_map_.add("ConfigIndex", identifier);
identifier_map_[config_index] = raw_identifier;
try {
remapclasses_initialize_vector_.start(config_index, raw_identifier);
{
for (const auto& it : vk_open_url_map_) {
remapclasses_initialize_vector_.push_back(2);
remapclasses_initialize_vector_.push_back(BRIDGE_VK_OPEN_URL);
remapclasses_initialize_vector_.push_back(it.first);
}
}
remapclasses_initialize_vector_.end();
} catch (std::exception& e) {
assert(!"exception in ~url_loader");
}
}
bool
xml_compiler::debug_get_initialize_vector(std::vector<uint32_t>& out, const std::string& raw_identifier) const
{
std::string identifier = raw_identifier;
normalize_identifier_(identifier);
uint32_t target_config_index = symbol_map_.get("ConfigIndex", identifier);
auto& initialize_vector = remapclasses_initialize_vector_.get();
size_t i = 2;
for (;;) {
if (i >= initialize_vector.size()) return false;
uint32_t count = initialize_vector.at(i);
++i;
if (count == 0) return false;
uint32_t config_index = initialize_vector.at(i);
if (target_config_index != config_index) {
i += count;
continue;
}
out.clear();
++i;
--count;
while (count > 0) {
out.push_back(initialize_vector.at(i));
++i;
--count;
}
return true;
}
return false;
}
void
xml_compiler::filter_vector::add_(uint32_t filter_type,
const std::string& prefix,
const std::string& string)
{
std::string string_no_whitespaces(string);
pqrs::string::remove_whitespaces(string_no_whitespaces);
size_t count_index = data_.size();
uint32_t count = 0;
data_.push_back(count);
data_.push_back(filter_type);
++count;
pqrs::string::tokenizer tokenizer_comma(string_no_whitespaces, ',');
std::string arg;
while (tokenizer_comma.split_removing_empty(arg)) {
uint32_t filter_value = 0;
switch (filter_type) {
case BRIDGE_FILTERTYPE_MODIFIER_NOT:
case BRIDGE_FILTERTYPE_MODIFIER_ONLY:
{
// support '|' for <modifier_only>.
// For example: <modifier_only>ModifierFlag::COMMAND_L|ModifierFlag::CONTROL_L, ModifierFlag::COMMAND_L|ModifierFlag::OPTION_L</modifier_only>
pqrs::string::tokenizer tokenizer_pipe(arg, '|');
std::string value;
while (tokenizer_pipe.split_removing_empty(value)) {
std::string key = prefix + value;
normalize_identifier_(key);
filter_value |= symbol_map_.get(key);
}
break;
}
case BRIDGE_FILTERTYPE_DEVICE_NOT:
case BRIDGE_FILTERTYPE_DEVICE_ONLY:
{
if (boost::starts_with(arg, "DeviceVendor")) {
fill_omitted_device_specifying(count);
}
// pass-through (== no break)
}
default:
{
std::string key = prefix + arg;
normalize_identifier_(key);
filter_value = symbol_map_.get(key);
break;
}
}
data_.push_back(filter_value);
++count;
}
// ------------------------------------------------------------
// Fill DeviceProduct, DeviceLocation if needed.
if (filter_type == BRIDGE_FILTERTYPE_DEVICE_NOT ||
filter_type == BRIDGE_FILTERTYPE_DEVICE_ONLY) {
fill_omitted_device_specifying(count);
}
// ------------------------------------------------------------
if (count == 1) {
// Rollback if filter is empty.
data_.resize(count_index);
} else {
data_[count_index] = count;
}
}
void traverse(const extracted_ptree& pt) {
for (const auto& it : pt) {
// Hack for speed improvement.
// We can stop traversing when we met <autogen>.
if (it.get_tag_name() == "autogen") {
continue;
}
// traverse
{
if (it.get_tag_name() != "item") {
if (! it.children_empty()) {
traverse(it.children_extracted_ptree());
}
} else {
// preferences_node_tree
assert(preferences_node_tree_);
std::tr1::shared_ptr<preferences_node_tree_t> ptr(new preferences_node_tree_t(preferences_node_tree_->get_node()));
for (const auto& child : it.children_extracted_ptree()) {
ptr->handle_item_child(child);
if (child.get_tag_name() == "identifier") {
auto raw_identifier = boost::trim_copy(child.get_data());
if (xml_compiler_.valid_identifier_(raw_identifier, it.get_tag_name())) {
auto identifier = raw_identifier;
normalize_identifier_(identifier);
// ----------------------------------------
auto attr_essential = child.get_optional("<xmlattr>.essential");
if (attr_essential) {
essential_configurations_.push_back(std::tr1::shared_ptr<essential_configuration>(new essential_configuration(ptr->get_node())));
// Do not treat essentials anymore.
continue;
}
// ----------------------------------------
auto attr_vk_config = child.get_optional("<xmlattr>.vk_config");
if (attr_vk_config) {
const char* names[] = {
"VK_CONFIG_TOGGLE_",
"VK_CONFIG_FORCE_ON_",
"VK_CONFIG_FORCE_OFF_",
"VK_CONFIG_SYNC_KEYDOWNUP_",
};
for (const auto& n : names) {
symbol_map_.add("KeyCode", std::string(n) + identifier);
}
}
// ----------------------------------------
if (boost::starts_with(identifier, "notsave_")) {
identifiers_notsave_.push_back(identifier);
} else {
identifiers_except_notsave_.push_back(identifier);
}
}
}
}
auto saved_preferences_node_tree = preferences_node_tree_;
preferences_node_tree_ = ptr.get();
{
if (! it.children_empty()) {
traverse(it.children_extracted_ptree());
}
}
preferences_node_tree_ = saved_preferences_node_tree;
auto attr_hidden = it.get_optional("<xmlattr>.hidden");
if (! attr_hidden) {
preferences_node_tree_->push_back(ptr);
}
}
}
}
}
