/**************************************************************************/ /* naming_utils.cpp */ /**************************************************************************/ /* This file is part of: */ /* GODOT ENGINE */ /* https://godotengine.org */ /**************************************************************************/ /* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */ /* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ /* */ /* Permission is hereby granted, free of charge, to any person obtaining */ /* a copy of this software and associated documentation files (the */ /* "Software"), to deal in the Software without restriction, including */ /* without limitation the rights to use, copy, modify, merge, publish, */ /* distribute, sublicense, and/or sell copies of the Software, and to */ /* permit persons to whom the Software is furnished to do so, subject to */ /* the following conditions: */ /* */ /* The above copyright notice and this permission notice shall be */ /* included in all copies or substantial portions of the Software. */ /* */ /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */ /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /**************************************************************************/ #include "naming_utils.h" #include "core/string/ucaps.h" #include "core/templates/hash_map.h" HashMap<String, String> _create_hashmap_from_vector(Vector<Pair<String, String>> vector) { HashMap<String, String> hashmap = HashMap<String, String>(vector.size()); for (const Pair<String, String> &pair : vector) { hashmap.insert(pair.first, pair.second); } return hashmap; } // Hardcoded collection of PascalCase name conversions. const HashMap<String, String> pascal_case_name_overrides = _create_hashmap_from_vector({ { "BitMap", "Bitmap" }, { "JSONRPC", "JsonRpc" }, { "Object", "GodotObject" }, { "OpenXRIPBinding", "OpenXRIPBinding" }, { "SkeletonModification2DCCDIK", "SkeletonModification2DCcdik" }, { "SkeletonModification2DFABRIK", "SkeletonModification2DFabrik" }, { "SkeletonModification3DCCDIK", "SkeletonModification3DCcdik" }, { "SkeletonModification3DFABRIK", "SkeletonModification3DFabrik" }, { "System", "System_" }, { "Thread", "GodotThread" }, }); // Hardcoded collection of PascalCase part conversions. const HashMap<String, String> pascal_case_part_overrides = _create_hashmap_from_vector({ { "AA", "AA" }, // Anti Aliasing { "AO", "AO" }, // Ambient Occlusion { "FILENAME", "FileName" }, { "FADEIN", "FadeIn" }, { "FADEOUT", "FadeOut" }, { "FX", "FX" }, { "GI", "GI" }, // Global Illumination { "GZIP", "GZip" }, { "HBOX", "HBox" }, // Horizontal Box { "ID", "Id" }, { "IO", "IO" }, // Input/Output { "IP", "IP" }, // Internet Protocol { "IV", "IV" }, // Initialization Vector { "MACOS", "MacOS" }, { "NODEPATH", "NodePath" }, { "SPIRV", "SpirV" }, { "STDIN", "StdIn" }, { "STDOUT", "StdOut" }, { "USERNAME", "UserName" }, { "UV", "UV" }, { "UV2", "UV2" }, { "VBOX", "VBox" }, // Vertical Box { "WHITESPACE", "WhiteSpace" }, { "WM", "WM" }, { "XR", "XR" }, { "XRAPI", "XRApi" }, }); String _get_pascal_case_part_override(String p_part, bool p_input_is_upper = true) { if (!p_input_is_upper) { for (int i = 0; i < p_part.length(); i++) { p_part[i] = _find_upper(p_part[i]); } } if (pascal_case_part_overrides.has(p_part)) { return pascal_case_part_overrides.get(p_part); } return String(); } Vector<String> _split_pascal_case(const String &p_identifier) { Vector<String> parts; int current_part_start = 0; bool prev_was_upper = is_ascii_upper_case(p_identifier[0]); for (int i = 1; i < p_identifier.length(); i++) { if (prev_was_upper) { if (is_digit(p_identifier[i]) || is_ascii_lower_case(p_identifier[i])) { if (!is_digit(p_identifier[i])) { // These conditions only apply when the separator is not a digit. if (i - current_part_start == 1) { // Upper character was only the beginning of a word. prev_was_upper = false; continue; } if (i != p_identifier.length()) { // If this is not the last character, the last uppercase // character is the start of the next word. i--; } } if (i - current_part_start > 0) { parts.append(p_identifier.substr(current_part_start, i - current_part_start)); current_part_start = i; prev_was_upper = false; } } } else { if (is_digit(p_identifier[i]) || is_ascii_upper_case(p_identifier[i])) { parts.append(p_identifier.substr(current_part_start, i - current_part_start)); current_part_start = i; prev_was_upper = true; } } } // Add the rest of the identifier as the last part. if (current_part_start != p_identifier.length()) { parts.append(p_identifier.substr(current_part_start)); } return parts; } String pascal_to_pascal_case(const String &p_identifier) { if (p_identifier.length() == 0) { return p_identifier; } if (p_identifier.length() <= 2) { return p_identifier.to_upper(); } if (pascal_case_name_overrides.has(p_identifier)) { // Use hardcoded value for the identifier. return pascal_case_name_overrides.get(p_identifier); } Vector<String> parts = _split_pascal_case(p_identifier); String ret; for (String &part : parts) { String part_override = _get_pascal_case_part_override(part); if (!part_override.is_empty()) { // Use hardcoded value for part. ret += part_override; continue; } if (part.length() <= 2 && part.to_upper() == part) { // Acronym of length 1 or 2. for (int j = 0; j < part.length(); j++) { part[j] = _find_upper(part[j]); } ret += part; continue; } part[0] = _find_upper(part[0]); for (int i = 1; i < part.length(); i++) { if (is_digit(part[i - 1])) { // Use uppercase after digits. part[i] = _find_upper(part[i]); continue; } part[i] = _find_lower(part[i]); } ret += part; } return ret; } String snake_to_pascal_case(const String &p_identifier, bool p_input_is_upper) { String ret; Vector<String> parts = p_identifier.split("_", true); for (int i = 0; i < parts.size(); i++) { String part = parts[i]; String part_override = _get_pascal_case_part_override(part, p_input_is_upper); if (!part_override.is_empty()) { // Use hardcoded value for part. ret += part_override; continue; } if (!part.is_empty()) { part[0] = _find_upper(part[0]); for (int j = 1; j < part.length(); j++) { if (is_digit(part[j - 1])) { // Use uppercase after digits. part[j] = _find_upper(part[j]); continue; } if (p_input_is_upper) { part[j] = _find_lower(part[j]); } } ret += part; } else { if (i == 0 || i == (parts.size() - 1)) { // Preserve underscores at the beginning and end ret += "_"; } else { // Preserve contiguous underscores if (parts[i - 1].length()) { ret += "__"; } else { ret += "_"; } } } } return ret; } String snake_to_camel_case(const String &p_identifier, bool p_input_is_upper) { String ret; Vector<String> parts = p_identifier.split("_", true); for (int i = 0; i < parts.size(); i++) { String part = parts[i]; String part_override = _get_pascal_case_part_override(part, p_input_is_upper); if (!part_override.is_empty()) { // Use hardcoded value for part. if (i == 0) { part_override[0] = _find_lower(part_override[0]); } ret += part_override; continue; } if (!part.is_empty()) { if (i == 0) { part[0] = _find_lower(part[0]); } else { part[0] = _find_upper(part[0]); } for (int j = 1; j < part.length(); j++) { if (is_digit(part[j - 1])) { // Use uppercase after digits. part[j] = _find_upper(part[j]); continue; } if (p_input_is_upper) { part[j] = _find_lower(part[j]); } } ret += part; } else { if (i == 0 || i == (parts.size() - 1)) { // Preserve underscores at the beginning and end ret += "_"; } else { // Preserve contiguous underscores if (parts[i - 1].length()) { ret += "__"; } else { ret += "_"; } } } } return ret; }