summaryrefslogtreecommitdiff
path: root/modules
diff options
context:
space:
mode:
Diffstat (limited to 'modules')
-rw-r--r--modules/gdnative/godot/string.cpp1150
-rw-r--r--modules/gdnative/godot/string.h158
-rw-r--r--modules/gdscript/gd_functions.cpp63
-rw-r--r--modules/gdscript/gd_functions.h1
-rw-r--r--modules/gdscript/gd_parser.cpp7
-rw-r--r--modules/nativescript/nativescript.cpp22
-rw-r--r--modules/visual_script/visual_script.cpp8
-rw-r--r--modules/visual_script/visual_script_editor.cpp16
-rw-r--r--modules/visual_script/visual_script_nodes.cpp49
-rw-r--r--modules/visual_script/visual_script_nodes.h10
10 files changed, 1453 insertions, 31 deletions
diff --git a/modules/gdnative/godot/string.cpp b/modules/gdnative/godot/string.cpp
index 3573f266ac..76cf1fba12 100644
--- a/modules/gdnative/godot/string.cpp
+++ b/modules/gdnative/godot/string.cpp
@@ -29,6 +29,7 @@
/*************************************************************************/
#include <godot/string.h>
+#include "core/variant.h"
#include "string_db.h"
#include "ustring.h"
@@ -112,6 +113,1155 @@ void GDAPI godot_string_destroy(godot_string *p_self) {
self->~String();
}
+/* Standard size stuff */
+
+godot_int GDAPI godot_string_length(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+
+ return self->length();
+}
+
+/* Helpers */
+
+godot_bool GDAPI godot_string_begins_with(const godot_string *p_self, const godot_string *p_string) {
+ const String *self = (const String *)p_self;
+ const String *string = (const String *)p_string;
+
+ return self->begins_with(*string);
+}
+
+godot_bool GDAPI godot_string_begins_with_char_array(const godot_string *p_self, const char *p_char_array) {
+ const String *self = (const String *)p_self;
+
+ return self->begins_with(p_char_array);
+}
+
+godot_array GDAPI godot_string_bigrams(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+ Vector<String> return_value = self->bigrams();
+
+ godot_array result;
+ memnew_placement(&result, Array);
+ Array *proxy = (Array *)&result;
+ proxy->resize(return_value.size());
+ for (int i = 0; i < return_value.size(); i++) {
+ (*proxy)[i] = return_value[i];
+ }
+
+ return result;
+};
+
+godot_string GDAPI godot_string_chr(wchar_t p_character) {
+ godot_string result;
+ memnew_placement(&result, String(String::chr(p_character)));
+
+ return result;
+}
+
+godot_bool GDAPI godot_string_ends_with(const godot_string *p_self, const godot_string *p_string) {
+ const String *self = (const String *)p_self;
+ const String *string = (const String *)p_string;
+
+ return self->ends_with(*string);
+}
+
+godot_int GDAPI godot_string_find(const godot_string *p_self, godot_string p_what) {
+ const String *self = (const String *)p_self;
+ String *what = (String *)&p_what;
+
+ return self->find(*what);
+}
+
+godot_int GDAPI godot_string_find_from(const godot_string *p_self, godot_string p_what, godot_int p_from) {
+ const String *self = (const String *)p_self;
+ String *what = (String *)&p_what;
+
+ return self->find(*what, p_from);
+}
+
+godot_int GDAPI godot_string_findmk(const godot_string *p_self, const godot_array *p_keys) {
+ const String *self = (const String *)p_self;
+
+ Vector<String> keys;
+ Array *keys_proxy = (Array *)p_keys;
+ keys.resize(keys_proxy->size());
+ for (int i = 0; i < keys_proxy->size(); i++) {
+ keys[i] = (*keys_proxy)[i];
+ }
+
+ return self->findmk(keys);
+}
+
+godot_int GDAPI godot_string_findmk_from(const godot_string *p_self, const godot_array *p_keys, godot_int p_from) {
+ const String *self = (const String *)p_self;
+
+ Vector<String> keys;
+ Array *keys_proxy = (Array *)p_keys;
+ keys.resize(keys_proxy->size());
+ for (int i = 0; i < keys_proxy->size(); i++) {
+ keys[i] = (*keys_proxy)[i];
+ }
+
+ return self->findmk(keys, p_from);
+}
+
+godot_int GDAPI godot_string_findmk_from_in_place(const godot_string *p_self, const godot_array *p_keys, godot_int p_from, godot_int *r_key) {
+ const String *self = (const String *)p_self;
+
+ Vector<String> keys;
+ Array *keys_proxy = (Array *)p_keys;
+ keys.resize(keys_proxy->size());
+ for (int i = 0; i < keys_proxy->size(); i++) {
+ keys[i] = (*keys_proxy)[i];
+ }
+
+ return self->findmk(keys, p_from, r_key);
+}
+
+godot_int GDAPI godot_string_findn(const godot_string *p_self, godot_string p_what) {
+ const String *self = (const String *)p_self;
+ String *what = (String *)&p_what;
+
+ return self->findn(*what);
+}
+
+godot_int GDAPI godot_string_findn_from(const godot_string *p_self, godot_string p_what, godot_int p_from) {
+ const String *self = (const String *)p_self;
+ String *what = (String *)&p_what;
+
+ return self->findn(*what, p_from);
+}
+
+godot_int GDAPI find_last(const godot_string *p_self, godot_string p_what) {
+ const String *self = (const String *)p_self;
+ String *what = (String *)&p_what;
+
+ return self->find_last(*what);
+}
+
+godot_string GDAPI godot_string_format(const godot_string *p_self, const godot_variant *p_values) {
+ const String *self = (const String *)p_self;
+ const Variant *values = (const Variant *)p_values;
+ godot_string result;
+ memnew_placement(&result, String(self->format(*values)));
+
+ return result;
+}
+
+godot_string GDAPI godot_string_format_with_custom_placeholder(const godot_string *p_self, const godot_variant *p_values, const char *p_placeholder) {
+ const String *self = (const String *)p_self;
+ const Variant *values = (const Variant *)p_values;
+ String placeholder = String(p_placeholder);
+ godot_string result;
+ memnew_placement(&result, String(self->format(*values, placeholder)));
+
+ return result;
+}
+
+godot_string GDAPI godot_string_hex_encode_buffer(const uint8_t *p_buffer, godot_int p_len) {
+ godot_string result;
+ memnew_placement(&result, String(String::hex_encode_buffer(p_buffer, p_len)));
+
+ return result;
+}
+
+godot_int GDAPI godot_string_hex_to_int(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+
+ return self->hex_to_int();
+}
+
+godot_int GDAPI godot_string_hex_to_int_without_prefix(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+
+ return self->hex_to_int(true);
+}
+
+godot_string GDAPI godot_string_insert(const godot_string *p_self, godot_int at_pos, godot_string p_content) {
+ const String *self = (const String *)p_self;
+ String *content = (String *)&p_content;
+ godot_string result;
+ memnew_placement(&result, String(self->insert(at_pos, *content)));
+
+ return result;
+}
+
+godot_bool GDAPI godot_string_is_numeric(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+
+ return self->is_numeric();
+}
+
+godot_bool GDAPI godot_string_is_subsequence_of(const godot_string *p_self, const godot_string *p_string) {
+ const String *self = (const String *)p_self;
+ const String *string = (const String *)p_string;
+
+ return self->is_subsequence_of(*string);
+}
+
+godot_bool GDAPI godot_string_is_subsequence_ofi(const godot_string *p_self, const godot_string *p_string) {
+ const String *self = (const String *)p_self;
+ const String *string = (const String *)p_string;
+
+ return self->is_subsequence_ofi(*string);
+}
+
+godot_string GDAPI godot_string_lpad(const godot_string *p_self, godot_int p_min_length) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ memnew_placement(&result, String(self->lpad(p_min_length)));
+
+ return result;
+}
+
+godot_string GDAPI godot_string_lpad_with_custom_character(const godot_string *p_self, godot_int p_min_length, const godot_string *p_character) {
+ const String *self = (const String *)p_self;
+ const String *character = (const String *)p_character;
+ godot_string result;
+ memnew_placement(&result, String(self->lpad(p_min_length, *character)));
+
+ return result;
+}
+
+godot_bool GDAPI godot_string_match(const godot_string *p_self, const godot_string *p_wildcard) {
+ const String *self = (const String *)p_self;
+ const String *wildcard = (const String *)p_wildcard;
+
+ return self->match(*wildcard);
+}
+
+godot_bool GDAPI godot_string_matchn(const godot_string *p_self, const godot_string *p_wildcard) {
+ const String *self = (const String *)p_self;
+ const String *wildcard = (const String *)p_wildcard;
+
+ return self->matchn(*wildcard);
+}
+
+godot_string GDAPI godot_string_md5(const uint8_t *p_md5) {
+ godot_string result;
+ memnew_placement(&result, String(String::md5(p_md5)));
+
+ return result;
+}
+
+godot_string GDAPI godot_string_num(double p_num) {
+ godot_string result;
+ memnew_placement(&result, String(String::num(p_num)));
+
+ return result;
+}
+
+godot_string GDAPI godot_string_num_int64(int64_t p_num, godot_int p_base) {
+ godot_string result;
+ memnew_placement(&result, String(String::num_int64(p_num, p_base)));
+
+ return result;
+}
+
+godot_string GDAPI godot_string_num_int64_capitalized(int64_t p_num, godot_int p_base, godot_bool p_capitalize_hex) {
+ godot_string result;
+ memnew_placement(&result, String(String::num_int64(p_num, p_base, true)));
+
+ return result;
+}
+
+godot_string GDAPI godot_string_num_real(double p_num) {
+ godot_string result;
+ memnew_placement(&result, String(String::num_real(p_num)));
+
+ return result;
+}
+
+godot_string GDAPI godot_string_num_scientific(double p_num) {
+ godot_string result;
+ memnew_placement(&result, String(String::num_scientific(p_num)));
+
+ return result;
+}
+
+godot_string GDAPI godot_string_num_with_decimals(double p_num, godot_int p_decimals) {
+ godot_string result;
+ memnew_placement(&result, String(String::num(p_num, p_decimals)));
+
+ return result;
+}
+
+godot_string GDAPI godot_string_pad_decimals(const godot_string *p_self, godot_int p_digits) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ memnew_placement(&result, String(self->pad_decimals(p_digits)));
+
+ return result;
+}
+
+godot_string GDAPI godot_string_pad_zeros(const godot_string *p_self, godot_int p_digits) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ memnew_placement(&result, String(self->pad_zeros(p_digits)));
+
+ return result;
+}
+
+godot_string GDAPI godot_string_replace(const godot_string *p_self, godot_string p_key, godot_string p_with) {
+ const String *self = (const String *)p_self;
+ String *key = (String *)&p_key;
+ String *with = (String *)&p_with;
+ godot_string result;
+ memnew_placement(&result, String(self->replace(*key, *with)));
+
+ return result;
+}
+
+godot_string GDAPI godot_string_replacen(const godot_string *p_self, godot_string p_key, godot_string p_with) {
+ const String *self = (const String *)p_self;
+ String *key = (String *)&p_key;
+ String *with = (String *)&p_with;
+ godot_string result;
+ memnew_placement(&result, String(self->replacen(*key, *with)));
+
+ return result;
+}
+
+godot_int GDAPI godot_string_rfind(const godot_string *p_self, godot_string p_what) {
+ const String *self = (const String *)p_self;
+ String *what = (String *)&p_what;
+
+ return self->rfind(*what);
+}
+
+godot_int GDAPI godot_string_rfindn(const godot_string *p_self, godot_string p_what) {
+ const String *self = (const String *)p_self;
+ String *what = (String *)&p_what;
+
+ return self->rfindn(*what);
+}
+
+godot_int GDAPI godot_string_rfind_from(const godot_string *p_self, godot_string p_what, godot_int p_from) {
+ const String *self = (const String *)p_self;
+ String *what = (String *)&p_what;
+
+ return self->rfind(*what, p_from);
+}
+
+godot_int GDAPI godot_string_rfindn_from(const godot_string *p_self, godot_string p_what, godot_int p_from) {
+ const String *self = (const String *)p_self;
+ String *what = (String *)&p_what;
+
+ return self->rfindn(*what, p_from);
+}
+
+godot_string GDAPI godot_string_replace_first(const godot_string *p_self, godot_string p_key, godot_string p_with) {
+ const String *self = (const String *)p_self;
+ String *key = (String *)&p_key;
+ String *with = (String *)&p_with;
+ godot_string result;
+ memnew_placement(&result, String(self->replace_first(*key, *with)));
+
+ return result;
+}
+
+godot_string GDAPI godot_string_rpad(const godot_string *p_self, godot_int p_min_length) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ memnew_placement(&result, String(self->rpad(p_min_length)));
+
+ return result;
+}
+
+godot_string GDAPI godot_string_rpad_with_custom_character(const godot_string *p_self, godot_int p_min_length, const godot_string *p_character) {
+ const String *self = (const String *)p_self;
+ const String *character = (const String *)p_character;
+ godot_string result;
+ memnew_placement(&result, String(self->rpad(p_min_length, *character)));
+
+ return result;
+}
+
+godot_real GDAPI godot_string_similarity(const godot_string *p_self, const godot_string *p_string) {
+ const String *self = (const String *)p_self;
+ const String *string = (const String *)p_string;
+
+ return self->similarity(*string);
+}
+
+godot_string GDAPI godot_string_sprintf(const godot_string *p_self, const godot_array *p_values, godot_bool *p_error) {
+ const String *self = (const String *)p_self;
+ const Array *values = (const Array *)p_values;
+
+ godot_string result;
+ String return_value = self->sprintf(*values, p_error);
+ memnew_placement(&result, String(return_value));
+
+ return result;
+}
+
+godot_string GDAPI godot_string_substr(const godot_string *p_self, godot_int p_from, godot_int p_chars) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ memnew_placement(&result, String(self->substr(p_from, p_chars)));
+
+ return result;
+}
+
+double GDAPI godot_string_to_double(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+
+ return self->to_double();
+}
+
+godot_real GDAPI godot_string_to_float(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+
+ return self->to_float();
+}
+
+godot_int GDAPI godot_string_to_int(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+
+ return self->to_int();
+}
+
+godot_string GDAPI godot_string_capitalize(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ memnew_placement(&result, String(self->capitalize()));
+
+ return result;
+};
+
+godot_string GDAPI godot_string_camelcase_to_underscore(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ memnew_placement(&result, String(self->camelcase_to_underscore(false)));
+
+ return result;
+};
+
+godot_string GDAPI godot_string_camelcase_to_underscore_lowercased(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ memnew_placement(&result, String(self->camelcase_to_underscore()));
+
+ return result;
+};
+
+double GDAPI godot_string_char_to_double(const char *p_what) {
+ return String::to_double(p_what);
+};
+
+godot_int GDAPI godot_string_char_to_int(const char *p_what) {
+ return String::to_int(p_what);
+};
+
+int64_t GDAPI godot_string_wchar_to_int(const wchar_t *p_str) {
+ return String::to_int(p_str);
+};
+
+godot_int GDAPI godot_string_char_to_int_with_len(const char *p_what, godot_int p_len) {
+ return String::to_int(p_what, p_len);
+};
+
+int64_t GDAPI godot_string_char_to_int64_with_len(const wchar_t *p_str, int p_len) {
+ return String::to_int(p_str, p_len);
+};
+
+int64_t GDAPI godot_string_hex_to_int64(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+
+ return self->hex_to_int64(false);
+};
+
+int64_t GDAPI godot_string_hex_to_int64_with_prefix(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+
+ return self->hex_to_int64();
+};
+
+int64_t GDAPI godot_string_to_int64(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+
+ return self->to_int64();
+};
+
+double GDAPI godot_string_unicode_char_to_double(const wchar_t *p_str, const wchar_t **r_end) {
+ return String::to_double(p_str, r_end);
+}
+
+godot_string GDAPI godot_string_get_slice(const godot_string *p_self, godot_string p_splitter, godot_int p_slice) {
+ const String *self = (const String *)p_self;
+ String *splitter = (String *)&p_splitter;
+ godot_string result;
+ memnew_placement(&result, String(self->get_slice(*splitter, p_slice)));
+
+ return result;
+};
+
+godot_string GDAPI godot_string_get_slicec(const godot_string *p_self, wchar_t p_splitter, godot_int p_slice) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ memnew_placement(&result, String(self->get_slicec(p_splitter, p_slice)));
+
+ return result;
+};
+
+godot_array GDAPI godot_string_split(const godot_string *p_self, const godot_string *p_splitter) {
+ const String *self = (const String *)p_self;
+ const String *splitter = (const String *)p_splitter;
+ godot_array result;
+ memnew_placement(&result, Array);
+ Array *proxy = (Array *)&result;
+ Vector<String> return_value = self->split(*splitter, false);
+
+ proxy->resize(return_value.size());
+ for (int i = 0; i < return_value.size(); i++) {
+ (*proxy)[i] = return_value[i];
+ }
+
+ return result;
+};
+
+godot_array GDAPI godot_string_split_allow_empty(const godot_string *p_self, const godot_string *p_splitter) {
+ const String *self = (const String *)p_self;
+ const String *splitter = (const String *)p_splitter;
+ godot_array result;
+ memnew_placement(&result, Array);
+ Array *proxy = (Array *)&result;
+ Vector<String> return_value = self->split(*splitter);
+
+ proxy->resize(return_value.size());
+ for (int i = 0; i < return_value.size(); i++) {
+ (*proxy)[i] = return_value[i];
+ }
+
+ return result;
+};
+
+godot_array GDAPI godot_string_split_floats(const godot_string *p_self, const godot_string *p_splitter) {
+ const String *self = (const String *)p_self;
+ const String *splitter = (const String *)p_splitter;
+ godot_array result;
+ memnew_placement(&result, Array);
+ Array *proxy = (Array *)&result;
+ Vector<float> return_value = self->split_floats(*splitter, false);
+
+ proxy->resize(return_value.size());
+ for (int i = 0; i < return_value.size(); i++) {
+ (*proxy)[i] = return_value[i];
+ }
+
+ return result;
+};
+
+godot_array GDAPI godot_string_split_floats_allows_empty(const godot_string *p_self, const godot_string *p_splitter) {
+ const String *self = (const String *)p_self;
+ const String *splitter = (const String *)p_splitter;
+ godot_array result;
+ memnew_placement(&result, Array);
+ Array *proxy = (Array *)&result;
+ Vector<float> return_value = self->split_floats(*splitter);
+
+ proxy->resize(return_value.size());
+ for (int i = 0; i < return_value.size(); i++) {
+ (*proxy)[i] = return_value[i];
+ }
+
+ return result;
+};
+
+godot_array GDAPI godot_string_split_floats_mk(const godot_string *p_self, const godot_array *p_splitters) {
+ const String *self = (const String *)p_self;
+
+ Vector<String> splitters;
+ Array *splitter_proxy = (Array *)p_splitters;
+ splitters.resize(splitter_proxy->size());
+ for (int i = 0; i < splitter_proxy->size(); i++) {
+ splitters[i] = (*splitter_proxy)[i];
+ }
+
+ godot_array result;
+ memnew_placement(&result, Array);
+ Array *proxy = (Array *)&result;
+ Vector<float> return_value = self->split_floats_mk(splitters, false);
+
+ proxy->resize(return_value.size());
+ for (int i = 0; i < return_value.size(); i++) {
+ (*proxy)[i] = return_value[i];
+ }
+
+ return result;
+};
+
+godot_array GDAPI godot_string_split_floats_mk_allows_empty(const godot_string *p_self, const godot_array *p_splitters) {
+ const String *self = (const String *)p_self;
+
+ Vector<String> splitters;
+ Array *splitter_proxy = (Array *)p_splitters;
+ splitters.resize(splitter_proxy->size());
+ for (int i = 0; i < splitter_proxy->size(); i++) {
+ splitters[i] = (*splitter_proxy)[i];
+ }
+
+ godot_array result;
+ memnew_placement(&result, Array);
+ Array *proxy = (Array *)&result;
+ Vector<float> return_value = self->split_floats_mk(splitters);
+
+ proxy->resize(return_value.size());
+ for (int i = 0; i < return_value.size(); i++) {
+ (*proxy)[i] = return_value[i];
+ }
+
+ return result;
+};
+
+godot_array GDAPI godot_string_split_ints(const godot_string *p_self, const godot_string *p_splitter) {
+ const String *self = (const String *)p_self;
+ const String *splitter = (const String *)p_splitter;
+ godot_array result;
+ memnew_placement(&result, Array);
+ Array *proxy = (Array *)&result;
+ Vector<int> return_value = self->split_ints(*splitter, false);
+
+ proxy->resize(return_value.size());
+ for (int i = 0; i < return_value.size(); i++) {
+ (*proxy)[i] = return_value[i];
+ }
+
+ return result;
+};
+
+godot_array GDAPI godot_string_split_ints_allows_empty(const godot_string *p_self, const godot_string *p_splitter) {
+ const String *self = (const String *)p_self;
+ const String *splitter = (const String *)p_splitter;
+ godot_array result;
+ memnew_placement(&result, Array);
+ Array *proxy = (Array *)&result;
+ Vector<int> return_value = self->split_ints(*splitter);
+
+ proxy->resize(return_value.size());
+ for (int i = 0; i < return_value.size(); i++) {
+ (*proxy)[i] = return_value[i];
+ }
+
+ return result;
+};
+
+godot_array GDAPI godot_string_split_ints_mk(const godot_string *p_self, const godot_array *p_splitters) {
+ const String *self = (const String *)p_self;
+
+ Vector<String> splitters;
+ Array *splitter_proxy = (Array *)p_splitters;
+ splitters.resize(splitter_proxy->size());
+ for (int i = 0; i < splitter_proxy->size(); i++) {
+ splitters[i] = (*splitter_proxy)[i];
+ }
+
+ godot_array result;
+ memnew_placement(&result, Array);
+ Array *proxy = (Array *)&result;
+ Vector<int> return_value = self->split_ints_mk(splitters, false);
+
+ proxy->resize(return_value.size());
+ for (int i = 0; i < return_value.size(); i++) {
+ (*proxy)[i] = return_value[i];
+ }
+
+ return result;
+};
+
+godot_array GDAPI godot_string_split_ints_mk_allows_empty(const godot_string *p_self, const godot_array *p_splitters) {
+ const String *self = (const String *)p_self;
+
+ Vector<String> splitters;
+ Array *splitter_proxy = (Array *)p_splitters;
+ splitters.resize(splitter_proxy->size());
+ for (int i = 0; i < splitter_proxy->size(); i++) {
+ splitters[i] = (*splitter_proxy)[i];
+ }
+
+ godot_array result;
+ memnew_placement(&result, Array);
+ Array *proxy = (Array *)&result;
+ Vector<int> return_value = self->split_ints_mk(splitters);
+
+ proxy->resize(return_value.size());
+ for (int i = 0; i < return_value.size(); i++) {
+ (*proxy)[i] = return_value[i];
+ }
+
+ return result;
+};
+
+godot_array GDAPI godot_string_split_spaces(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+ godot_array result;
+ memnew_placement(&result, Array);
+ Array *proxy = (Array *)&result;
+ Vector<String> return_value = self->split_spaces();
+
+ proxy->resize(return_value.size());
+ for (int i = 0; i < return_value.size(); i++) {
+ (*proxy)[i] = return_value[i];
+ }
+
+ return result;
+};
+
+godot_int GDAPI godot_string_get_slice_count(const godot_string *p_self, godot_string p_splitter) {
+ const String *self = (const String *)p_self;
+ String *splitter = (String *)&p_splitter;
+
+ return self->get_slice_count(*splitter);
+};
+
+wchar_t GDAPI godot_string_char_lowercase(wchar_t p_char) {
+ return String::char_lowercase(p_char);
+};
+
+wchar_t GDAPI godot_string_char_uppercase(wchar_t p_char) {
+ return String::char_uppercase(p_char);
+};
+
+godot_string GDAPI godot_string_to_lower(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ memnew_placement(&result, String(self->to_lower()));
+
+ return result;
+};
+
+godot_string GDAPI godot_string_to_upper(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ memnew_placement(&result, String(self->to_upper()));
+
+ return result;
+};
+
+godot_string GDAPI godot_string_get_basename(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ memnew_placement(&result, String(self->get_basename()));
+
+ return result;
+};
+
+godot_string GDAPI godot_string_get_extension(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ memnew_placement(&result, String(self->get_extension()));
+
+ return result;
+};
+
+godot_string GDAPI godot_string_left(const godot_string *p_self, godot_int p_pos) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ memnew_placement(&result, String(self->left(p_pos)));
+
+ return result;
+};
+
+wchar_t GDAPI godot_string_ord_at(const godot_string *p_self, godot_int p_idx) {
+ const String *self = (const String *)p_self;
+
+ return self->ord_at(p_idx);
+};
+
+godot_string GDAPI godot_string_plus_file(const godot_string *p_self, const godot_string *p_file) {
+ const String *self = (const String *)p_self;
+ const String *file = (const String *)p_file;
+ godot_string result;
+ memnew_placement(&result, String(self->plus_file(*file)));
+
+ return result;
+};
+
+godot_string GDAPI godot_string_right(const godot_string *p_self, godot_int p_pos) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ memnew_placement(&result, String(self->right(p_pos)));
+
+ return result;
+};
+
+godot_string GDAPI godot_string_strip_edges(const godot_string *p_self, godot_bool p_left, godot_bool p_right) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ memnew_placement(&result, String(self->strip_edges(p_left, p_right)));
+
+ return result;
+};
+
+godot_string GDAPI godot_string_strip_escapes(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ memnew_placement(&result, String(self->strip_escapes()));
+
+ return result;
+};
+
+void GDAPI godot_string_erase(godot_string *p_self, godot_int p_pos, godot_int p_chars) {
+ String *self = (String *)p_self;
+
+ return self->erase(p_pos, p_chars);
+};
+
+void GDAPI godot_string_ascii(godot_string *p_self, char *result) {
+ String *self = (String *)p_self;
+ Vector<char> return_value = self->ascii();
+
+ for (int i = 0; i < return_value.size(); i++) {
+ result[i] = return_value[i];
+ }
+}
+
+void GDAPI godot_string_ascii_extended(godot_string *p_self, char *result) {
+ String *self = (String *)p_self;
+ Vector<char> return_value = self->ascii(true);
+
+ for (int i = 0; i < return_value.size(); i++) {
+ result[i] = return_value[i];
+ }
+}
+
+void GDAPI godot_string_utf8(godot_string *p_self, char *result) {
+ String *self = (String *)p_self;
+ Vector<char> return_value = self->utf8();
+
+ for (int i = 0; i < return_value.size(); i++) {
+ result[i] = return_value[i];
+ }
+}
+
+godot_bool GDAPI godot_string_parse_utf8(godot_string *p_self, const char *p_utf8) {
+ String *self = (String *)p_self;
+
+ return self->parse_utf8(p_utf8);
+};
+
+godot_bool GDAPI godot_string_parse_utf8_with_len(godot_string *p_self, const char *p_utf8, godot_int p_len) {
+ String *self = (String *)p_self;
+
+ return self->parse_utf8(p_utf8, p_len);
+};
+
+godot_string GDAPI godot_string_chars_to_utf8(const char *p_utf8) {
+ godot_string result;
+ memnew_placement(&result, String(String::utf8(p_utf8)));
+
+ return result;
+};
+
+godot_string GDAPI godot_string_chars_to_utf8_with_len(const char *p_utf8, godot_int p_len) {
+ godot_string result;
+ memnew_placement(&result, String(String::utf8(p_utf8, p_len)));
+
+ return result;
+};
+
+uint32_t GDAPI godot_string_hash(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+
+ return self->hash();
+};
+
+uint64_t GDAPI godot_string_hash64(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+
+ return self->hash64();
+};
+
+uint32_t GDAPI godot_string_hash_chars(const char *p_cstr) {
+ return String::hash(p_cstr);
+};
+
+uint32_t GDAPI godot_string_hash_chars_with_len(const char *p_cstr, godot_int p_len) {
+ return String::hash(p_cstr, p_len);
+};
+
+uint32_t GDAPI godot_string_hash_utf8_chars(const wchar_t *p_str) {
+ return String::hash(p_str);
+};
+
+uint32_t GDAPI godot_string_hash_utf8_chars_with_len(const wchar_t *p_str, godot_int p_len) {
+ return String::hash(p_str, p_len);
+};
+
+godot_pool_byte_array GDAPI godot_string_md5_buffer(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+ Vector<uint8_t> tmp_result = self->md5_buffer();
+
+ godot_pool_byte_array result;
+ memnew_placement(&result, PoolByteArray);
+ PoolByteArray *proxy = (PoolByteArray *)&result;
+ PoolByteArray::Write proxy_writer = proxy->write();
+ proxy->resize(tmp_result.size());
+
+ for (int i = 0; i < tmp_result.size(); i++) {
+ proxy_writer[i] = tmp_result[i];
+ }
+
+ return result;
+};
+
+godot_string GDAPI godot_string_md5_text(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ memnew_placement(&result, String(self->md5_text()));
+
+ return result;
+};
+
+godot_pool_byte_array GDAPI godot_string_sha256_buffer(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+ Vector<uint8_t> tmp_result = self->sha256_buffer();
+
+ godot_pool_byte_array result;
+ memnew_placement(&result, PoolByteArray);
+ PoolByteArray *proxy = (PoolByteArray *)&result;
+ PoolByteArray::Write proxy_writer = proxy->write();
+ proxy->resize(tmp_result.size());
+
+ for (int i = 0; i < tmp_result.size(); i++) {
+ proxy_writer[i] = tmp_result[i];
+ }
+
+ return result;
+};
+
+godot_string GDAPI godot_string_sha256_text(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ memnew_placement(&result, String(self->sha256_text()));
+
+ return result;
+};
+
+godot_bool godot_string_empty(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+
+ return self->empty();
+};
+
+// path functions
+godot_string GDAPI godot_string_get_base_dir(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ String return_value = self->get_base_dir();
+ memnew_placement(&result, String(return_value));
+
+ return result;
+};
+
+godot_string GDAPI godot_string_get_file(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ String return_value = self->get_file();
+ memnew_placement(&result, String(return_value));
+
+ return result;
+};
+
+godot_string GDAPI godot_string_humanize_size(size_t p_size) {
+ godot_string result;
+ String return_value = String::humanize_size(p_size);
+ memnew_placement(&result, String(return_value));
+
+ return result;
+};
+
+godot_bool GDAPI godot_string_is_abs_path(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+
+ return self->is_abs_path();
+};
+
+godot_bool GDAPI godot_string_is_rel_path(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+
+ return self->is_rel_path();
+};
+
+godot_bool GDAPI godot_string_is_resource_file(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+
+ return self->is_resource_file();
+};
+
+godot_string GDAPI godot_string_path_to(const godot_string *p_self, const godot_string *p_path) {
+ const String *self = (const String *)p_self;
+ String *path = (String *)p_path;
+ godot_string result;
+ String return_value = self->path_to(*path);
+ memnew_placement(&result, String(return_value));
+
+ return result;
+};
+
+godot_string GDAPI godot_string_path_to_file(const godot_string *p_self, const godot_string *p_path) {
+ const String *self = (const String *)p_self;
+ String *path = (String *)p_path;
+ godot_string result;
+ String return_value = self->path_to_file(*path);
+ memnew_placement(&result, String(return_value));
+
+ return result;
+};
+
+godot_string GDAPI godot_string_simplify_path(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ String return_value = self->simplify_path();
+ memnew_placement(&result, String(return_value));
+
+ return result;
+};
+
+godot_string GDAPI godot_string_c_escape(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ String return_value = self->c_escape();
+ memnew_placement(&result, String(return_value));
+
+ return result;
+};
+
+godot_string GDAPI godot_string_c_escape_multiline(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ String return_value = self->c_escape_multiline();
+ memnew_placement(&result, String(return_value));
+
+ return result;
+};
+
+godot_string GDAPI godot_string_c_unescape(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ String return_value = self->c_unescape();
+ memnew_placement(&result, String(return_value));
+
+ return result;
+};
+
+godot_string GDAPI godot_string_http_escape(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ String return_value = self->http_escape();
+ memnew_placement(&result, String(return_value));
+
+ return result;
+};
+
+godot_string GDAPI godot_string_http_unescape(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ String return_value = self->http_unescape();
+ memnew_placement(&result, String(return_value));
+
+ return result;
+};
+
+godot_string GDAPI godot_string_json_escape(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ String return_value = self->json_escape();
+ memnew_placement(&result, String(return_value));
+
+ return result;
+};
+
+godot_string GDAPI godot_string_word_wrap(const godot_string *p_self, godot_int p_chars_per_line) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ String return_value = self->word_wrap(p_chars_per_line);
+ memnew_placement(&result, String(return_value));
+
+ return result;
+};
+
+godot_string GDAPI godot_string_xml_escape(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ String return_value = self->xml_escape();
+ memnew_placement(&result, String(return_value));
+
+ return result;
+};
+
+godot_string GDAPI godot_string_xml_escape_with_quotes(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ String return_value = self->xml_escape(true);
+ memnew_placement(&result, String(return_value));
+
+ return result;
+};
+
+godot_string GDAPI godot_string_xml_unescape(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ String return_value = self->xml_unescape();
+ memnew_placement(&result, String(return_value));
+
+ return result;
+};
+
+godot_string GDAPI godot_string_percent_decode(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ String return_value = self->percent_decode();
+ memnew_placement(&result, String(return_value));
+
+ return result;
+};
+
+godot_string GDAPI godot_string_percent_encode(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+ godot_string result;
+ String return_value = self->percent_encode();
+ memnew_placement(&result, String(return_value));
+
+ return result;
+};
+
+godot_bool GDAPI godot_string_is_valid_float(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+
+ return self->is_valid_float();
+};
+
+godot_bool GDAPI godot_string_is_valid_hex_number(const godot_string *p_self, godot_bool p_with_prefix) {
+ const String *self = (const String *)p_self;
+
+ return self->is_valid_hex_number(p_with_prefix);
+};
+
+godot_bool GDAPI godot_string_is_valid_html_color(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+
+ return self->is_valid_html_color();
+};
+
+godot_bool GDAPI godot_string_is_valid_identifier(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+
+ return self->is_valid_identifier();
+};
+
+godot_bool GDAPI godot_string_is_valid_integer(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+
+ return self->is_valid_integer();
+};
+
+godot_bool GDAPI godot_string_is_valid_ip_address(const godot_string *p_self) {
+ const String *self = (const String *)p_self;
+
+ return self->is_valid_ip_address();
+};
+
#ifdef __cplusplus
}
#endif
diff --git a/modules/gdnative/godot/string.h b/modules/gdnative/godot/string.h
index 9013326454..bfe66aa5ec 100644
--- a/modules/gdnative/godot/string.h
+++ b/modules/gdnative/godot/string.h
@@ -47,6 +47,7 @@ typedef struct {
#endif
#include <godot/gdnative.h>
+#include <godot/variant.h>
void GDAPI godot_string_new(godot_string *r_dest);
void GDAPI godot_string_new_copy(godot_string *r_dest, const godot_string *p_src);
@@ -63,9 +64,160 @@ godot_bool GDAPI godot_string_operator_equal(const godot_string *p_self, const g
godot_bool GDAPI godot_string_operator_less(const godot_string *p_self, const godot_string *p_b);
godot_string GDAPI godot_string_operator_plus(const godot_string *p_self, const godot_string *p_b);
-// @Incomplete
-// hmm, I guess exposing the whole API doesn't make much sense
-// since the language used in the library has its own string funcs
+/* Standard size stuff */
+
+godot_int GDAPI godot_string_length(const godot_string *p_self);
+
+/* Helpers */
+
+godot_bool GDAPI godot_string_begins_with(const godot_string *p_self, const godot_string *p_string);
+godot_bool GDAPI godot_string_begins_with_char_array(const godot_string *p_self, const char *p_char_array);
+godot_array GDAPI godot_string_bigrams(const godot_string *p_self);
+godot_string GDAPI godot_string_chr(wchar_t p_character);
+godot_bool GDAPI godot_string_ends_with(const godot_string *p_self, const godot_string *p_string);
+godot_int GDAPI godot_string_find(const godot_string *p_self, godot_string p_what);
+godot_int GDAPI godot_string_find_from(const godot_string *p_self, godot_string p_what, godot_int p_from);
+godot_int GDAPI godot_string_findmk(const godot_string *p_self, const godot_array *p_keys);
+godot_int GDAPI godot_string_findmk_from(const godot_string *p_self, const godot_array *p_keys, godot_int p_from);
+godot_int GDAPI godot_string_findmk_from_in_place(const godot_string *p_self, const godot_array *p_keys, godot_int p_from, godot_int *r_key);
+godot_int GDAPI godot_string_findn(const godot_string *p_self, godot_string p_what);
+godot_int GDAPI godot_string_findn_from(const godot_string *p_self, godot_string p_what, godot_int p_from);
+godot_int GDAPI find_last(const godot_string *p_self, godot_string p_what);
+godot_string GDAPI godot_string_format(const godot_string *p_self, const godot_variant *values);
+godot_string GDAPI godot_string_format_with_custom_placeholder(const godot_string *p_self, const godot_variant *values, const char *placeholder);
+godot_string GDAPI godot_string_hex_encode_buffer(const uint8_t *p_buffer, godot_int p_len);
+godot_int GDAPI godot_string_hex_to_int(const godot_string *p_self);
+godot_int GDAPI godot_string_hex_to_int_without_prefix(const godot_string *p_self);
+godot_string GDAPI godot_string_insert(const godot_string *p_self, godot_int p_at_pos, godot_string p_string);
+godot_bool GDAPI godot_string_is_numeric(const godot_string *p_self);
+godot_bool GDAPI godot_string_is_subsequence_of(const godot_string *p_self, const godot_string *p_string);
+godot_bool GDAPI godot_string_is_subsequence_ofi(const godot_string *p_self, const godot_string *p_string);
+godot_string GDAPI godot_string_lpad(const godot_string *p_self, godot_int p_min_length);
+godot_string GDAPI godot_string_lpad_with_custom_character(const godot_string *p_self, godot_int p_min_length, const godot_string *p_character);
+godot_bool GDAPI godot_string_match(const godot_string *p_self, const godot_string *p_wildcard);
+godot_bool GDAPI godot_string_matchn(const godot_string *p_self, const godot_string *p_wildcard);
+godot_string GDAPI godot_string_md5(const uint8_t *p_md5);
+godot_string GDAPI godot_string_num(double p_num);
+godot_string GDAPI godot_string_num_int64(int64_t p_num, godot_int p_base);
+godot_string GDAPI godot_string_num_int64_capitalized(int64_t p_num, godot_int p_base, godot_bool p_capitalize_hex);
+godot_string GDAPI godot_string_num_real(double p_num);
+godot_string GDAPI godot_string_num_scientific(double p_num);
+godot_string GDAPI godot_string_num_with_decimals(double p_num, godot_int p_decimals);
+godot_string GDAPI godot_string_pad_decimals(const godot_string *p_self, godot_int p_digits);
+godot_string GDAPI godot_string_pad_zeros(const godot_string *p_self, godot_int p_digits);
+godot_string GDAPI godot_string_replace_first(const godot_string *p_self, godot_string p_key, godot_string p_with);
+godot_string GDAPI godot_string_replace(const godot_string *p_self, godot_string p_key, godot_string p_with);
+godot_string GDAPI godot_string_replacen(const godot_string *p_self, godot_string p_key, godot_string p_with);
+godot_int GDAPI godot_string_rfind(const godot_string *p_self, godot_string p_what);
+godot_int GDAPI godot_string_rfindn(const godot_string *p_self, godot_string p_what);
+godot_int GDAPI godot_string_rfind_from(const godot_string *p_self, godot_string p_what, godot_int p_from);
+godot_int GDAPI godot_string_rfindn_from(const godot_string *p_self, godot_string p_what, godot_int p_from);
+godot_string GDAPI godot_string_rpad(const godot_string *p_self, godot_int p_min_length);
+godot_string GDAPI godot_string_rpad_with_custom_character(const godot_string *p_self, godot_int p_min_length, const godot_string *p_character);
+godot_real GDAPI godot_string_similarity(const godot_string *p_self, const godot_string *p_string);
+godot_string GDAPI godot_string_sprintf(const godot_string *p_self, const godot_array *p_values, godot_bool *p_error);
+godot_string GDAPI godot_string_substr(const godot_string *p_self, godot_int p_from, godot_int p_chars);
+double GDAPI godot_string_to_double(const godot_string *p_self);
+godot_real GDAPI godot_string_to_float(const godot_string *p_self);
+godot_int GDAPI godot_string_to_int(const godot_string *p_self);
+
+godot_string GDAPI godot_string_camelcase_to_underscore(const godot_string *p_self);
+godot_string GDAPI godot_string_camelcase_to_underscore_lowercased(const godot_string *p_self);
+godot_string GDAPI godot_string_capitalize(const godot_string *p_self);
+double GDAPI godot_string_char_to_double(const char *p_what);
+godot_int GDAPI godot_string_char_to_int(const char *p_what);
+int64_t GDAPI godot_string_wchar_to_int(const wchar_t *p_str);
+godot_int GDAPI godot_string_char_to_int_with_len(const char *p_what, godot_int p_len);
+int64_t GDAPI godot_string_char_to_int64_with_len(const wchar_t *p_str, int p_len);
+int64_t GDAPI godot_string_hex_to_int64(const godot_string *p_self);
+int64_t GDAPI godot_string_hex_to_int64_with_prefix(const godot_string *p_self);
+int64_t GDAPI godot_string_to_int64(const godot_string *p_self);
+double GDAPI godot_string_unicode_char_to_double(const wchar_t *p_str, const wchar_t **r_end);
+
+godot_int GDAPI godot_string_get_slice_count(const godot_string *p_self, godot_string p_splitter);
+godot_string GDAPI godot_string_get_slice(const godot_string *p_self, godot_string p_splitter, godot_int p_slice);
+godot_string GDAPI godot_string_get_slicec(const godot_string *p_self, wchar_t p_splitter, godot_int p_slice);
+
+godot_array GDAPI godot_string_split(const godot_string *p_self, const godot_string *p_splitter);
+godot_array GDAPI godot_string_split_allow_empty(const godot_string *p_self, const godot_string *p_splitter);
+godot_array GDAPI godot_string_split_floats(const godot_string *p_self, const godot_string *p_splitter);
+godot_array GDAPI godot_string_split_floats_allows_empty(const godot_string *p_self, const godot_string *p_splitter);
+godot_array GDAPI godot_string_split_floats_mk(const godot_string *p_self, const godot_array *p_splitters);
+godot_array GDAPI godot_string_split_floats_mk_allows_empty(const godot_string *p_self, const godot_array *p_splitters);
+godot_array GDAPI godot_string_split_ints(const godot_string *p_self, const godot_string *p_splitter);
+godot_array GDAPI godot_string_split_ints_allows_empty(const godot_string *p_self, const godot_string *p_splitter);
+godot_array GDAPI godot_string_split_ints_mk(const godot_string *p_self, const godot_array *p_splitters);
+godot_array GDAPI godot_string_split_ints_mk_allows_empty(const godot_string *p_self, const godot_array *p_splitters);
+godot_array GDAPI godot_string_split_spaces(const godot_string *p_self);
+
+wchar_t GDAPI godot_string_char_lowercase(wchar_t p_char);
+wchar_t GDAPI godot_string_char_uppercase(wchar_t p_char);
+godot_string GDAPI godot_string_to_lower(const godot_string *p_self);
+godot_string GDAPI godot_string_to_upper(const godot_string *p_self);
+
+godot_string GDAPI godot_string_get_basename(const godot_string *p_self);
+godot_string GDAPI godot_string_get_extension(const godot_string *p_self);
+godot_string GDAPI godot_string_left(const godot_string *p_self, godot_int p_pos);
+wchar_t GDAPI godot_string_ord_at(const godot_string *p_self, godot_int p_idx);
+godot_string GDAPI godot_string_plus_file(const godot_string *p_self, const godot_string *p_file);
+godot_string GDAPI godot_string_right(const godot_string *p_self, godot_int p_pos);
+godot_string GDAPI godot_string_strip_edges(const godot_string *p_self, godot_bool p_left, godot_bool p_right);
+godot_string GDAPI godot_string_strip_escapes(const godot_string *p_self);
+
+void GDAPI godot_string_erase(godot_string *p_self, godot_int p_pos, godot_int p_chars);
+
+void GDAPI godot_string_ascii(godot_string *p_self, char *result);
+void GDAPI godot_string_ascii_extended(godot_string *p_self, char *result);
+void GDAPI godot_string_utf8(godot_string *p_self, char *result);
+godot_bool GDAPI godot_string_parse_utf8(godot_string *p_self, const char *p_utf8);
+godot_bool GDAPI godot_string_parse_utf8_with_len(godot_string *p_self, const char *p_utf8, godot_int p_len);
+godot_string GDAPI godot_string_chars_to_utf8(const char *p_utf8);
+godot_string GDAPI godot_string_chars_utf8_with_len(const char *p_utf8, godot_int p_len);
+
+uint32_t GDAPI godot_string_hash(const godot_string *p_self);
+uint64_t GDAPI godot_string_hash64(const godot_string *p_self);
+uint32_t GDAPI godot_string_hash_chars(const char *p_cstr);
+uint32_t GDAPI godot_string_hash_chars_with_len(const char *p_cstr, godot_int p_len);
+uint32_t GDAPI godot_string_hash_utf8_chars(const wchar_t *p_str);
+uint32_t GDAPI godot_string_hash_utf8_chars_with_len(const wchar_t *p_str, godot_int p_len);
+godot_pool_byte_array GDAPI godot_string_md5_buffer(const godot_string *p_self);
+godot_string GDAPI godot_string_md5_text(const godot_string *p_self);
+godot_pool_byte_array GDAPI godot_string_sha256_buffer(const godot_string *p_self);
+godot_string GDAPI godot_string_sha256_text(const godot_string *p_self);
+
+godot_bool godot_string_empty(const godot_string *p_self);
+
+// path functions
+godot_string GDAPI godot_string_get_base_dir(const godot_string *p_self);
+godot_string GDAPI godot_string_get_file(const godot_string *p_self);
+godot_string GDAPI godot_string_humanize_size(size_t p_size);
+godot_bool GDAPI godot_string_is_abs_path(const godot_string *p_self);
+godot_bool GDAPI godot_string_is_rel_path(const godot_string *p_self);
+godot_bool GDAPI godot_string_is_resource_file(const godot_string *p_self);
+godot_string GDAPI godot_string_path_to(const godot_string *p_self, const godot_string *p_path);
+godot_string GDAPI godot_string_path_to_file(const godot_string *p_self, const godot_string *p_path);
+godot_string GDAPI godot_string_simplify_path(const godot_string *p_self);
+
+godot_string GDAPI godot_string_c_escape(const godot_string *p_self);
+godot_string GDAPI godot_string_c_escape_multiline(const godot_string *p_self);
+godot_string GDAPI godot_string_c_unescape(const godot_string *p_self);
+godot_string GDAPI godot_string_http_escape(const godot_string *p_self);
+godot_string GDAPI godot_string_http_unescape(const godot_string *p_self);
+godot_string GDAPI godot_string_json_escape(const godot_string *p_self);
+godot_string GDAPI godot_string_word_wrap(const godot_string *p_self, godot_int p_chars_per_line);
+godot_string GDAPI godot_string_xml_escape(const godot_string *p_self);
+godot_string GDAPI godot_string_xml_escape_with_quotes(const godot_string *p_self);
+godot_string GDAPI godot_string_xml_unescape(const godot_string *p_self);
+
+godot_string GDAPI godot_string_percent_decode(const godot_string *p_self);
+godot_string GDAPI godot_string_percent_encode(const godot_string *p_self);
+
+godot_bool GDAPI godot_string_is_valid_float(const godot_string *p_self);
+godot_bool GDAPI godot_string_is_valid_hex_number(const godot_string *p_self, godot_bool p_with_prefix);
+godot_bool GDAPI godot_string_is_valid_html_color(const godot_string *p_self);
+godot_bool GDAPI godot_string_is_valid_identifier(const godot_string *p_self);
+godot_bool GDAPI godot_string_is_valid_integer(const godot_string *p_self);
+godot_bool GDAPI godot_string_is_valid_ip_address(const godot_string *p_self);
void GDAPI godot_string_destroy(godot_string *p_self);
diff --git a/modules/gdscript/gd_functions.cpp b/modules/gdscript/gd_functions.cpp
index 8bc3b24a5e..209bdadd67 100644
--- a/modules/gdscript/gd_functions.cpp
+++ b/modules/gdscript/gd_functions.cpp
@@ -113,6 +113,7 @@ const char *GDFunctions::get_func_name(Function p_func) {
"ColorN",
"print_stack",
"instance_from_id",
+ "len",
};
return _names[p_func];
@@ -1154,6 +1155,62 @@ void GDFunctions::call(Function p_func, const Variant **p_args, int p_arg_count,
r_ret = ObjectDB::get_instance(id);
} break;
+ case LEN: {
+
+ VALIDATE_ARG_COUNT(1);
+ switch (p_args[0]->get_type()) {
+ case Variant::DICTIONARY: {
+ Dictionary d = *p_args[0];
+ r_ret = d.size();
+ } break;
+ case Variant::ARRAY: {
+ Array d = *p_args[0];
+ r_ret = d.size();
+ } break;
+ case Variant::POOL_BYTE_ARRAY: {
+ PoolVector<uint8_t> d = *p_args[0];
+ r_ret = d.size();
+
+ } break;
+ case Variant::POOL_INT_ARRAY: {
+ PoolVector<int> d = *p_args[0];
+ r_ret = d.size();
+ } break;
+ case Variant::POOL_REAL_ARRAY: {
+
+ PoolVector<real_t> d = *p_args[0];
+ r_ret = d.size();
+ } break;
+ case Variant::POOL_STRING_ARRAY: {
+ PoolVector<String> d = *p_args[0];
+ r_ret = d.size();
+
+ } break;
+ case Variant::POOL_VECTOR2_ARRAY: {
+ PoolVector<Vector2> d = *p_args[0];
+ r_ret = d.size();
+
+ } break;
+ case Variant::POOL_VECTOR3_ARRAY: {
+
+ PoolVector<Vector3> d = *p_args[0];
+ r_ret = d.size();
+ } break;
+ case Variant::POOL_COLOR_ARRAY: {
+
+ PoolVector<Color> d = *p_args[0];
+ r_ret = d.size();
+ } break;
+ default: {
+ r_error.error = Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
+ r_error.argument = 0;
+ r_error.expected = Variant::OBJECT;
+ r_ret = Variant();
+ r_ret = RTR("Object can't provide a length.");
+ }
+ }
+
+ } break;
case FUNC_MAX: {
ERR_FAIL();
@@ -1210,6 +1267,7 @@ bool GDFunctions::is_deterministic(Function p_func) {
case TEXT_CHAR:
case TEXT_STR:
case COLOR8:
+ case LEN:
// enable for debug only, otherwise not desirable - case GEN_RANGE:
return true;
default:
@@ -1621,6 +1679,11 @@ MethodInfo GDFunctions::get_info(Function p_func) {
mi.return_val.type = Variant::OBJECT;
return mi;
} break;
+ case LEN: {
+ MethodInfo mi("len", PropertyInfo(Variant::NIL, "var"));
+ mi.return_val.type = Variant::INT;
+ return mi;
+ } break;
case FUNC_MAX: {
diff --git a/modules/gdscript/gd_functions.h b/modules/gdscript/gd_functions.h
index 4d52abaeab..93cb524118 100644
--- a/modules/gdscript/gd_functions.h
+++ b/modules/gdscript/gd_functions.h
@@ -105,6 +105,7 @@ public:
COLORN,
PRINT_STACK,
INSTANCE_FROM_ID,
+ LEN,
FUNC_MAX
};
diff --git a/modules/gdscript/gd_parser.cpp b/modules/gdscript/gd_parser.cpp
index 36aa249398..9023fd4bf4 100644
--- a/modules/gdscript/gd_parser.cpp
+++ b/modules/gdscript/gd_parser.cpp
@@ -2369,8 +2369,7 @@ void GDParser::_parse_block(BlockNode *p_block, bool p_static) {
check_block = check_block->parent_block;
}
- p_block->variables.push_back(n); //line?
- p_block->variable_lines.push_back(tokenizer->get_token_line());
+ int var_line = tokenizer->get_token_line();
//must know when the local variable is declared
LocalVarNode *lv = alloc_node<LocalVarNode>();
@@ -2400,6 +2399,10 @@ void GDParser::_parse_block(BlockNode *p_block, bool p_static) {
c->value = Variant();
assigned = c;
}
+ //must be added later, to avoid self-referencing.
+ p_block->variables.push_back(n); //line?
+ p_block->variable_lines.push_back(var_line);
+
IdentifierNode *id = alloc_node<IdentifierNode>();
id->name = n;
diff --git a/modules/nativescript/nativescript.cpp b/modules/nativescript/nativescript.cpp
index f00917bcea..e2717b8448 100644
--- a/modules/nativescript/nativescript.cpp
+++ b/modules/nativescript/nativescript.cpp
@@ -77,14 +77,12 @@ void NativeScript::_update_placeholder(PlaceHolderScriptInstance *p_placeholder)
ERR_FAIL_COND(!script_data);
List<PropertyInfo> info;
+ get_script_property_list(&info);
Map<StringName, Variant> values;
-
- for (Map<StringName, NativeScriptDesc::Property>::Element *E = script_data->properties.front(); E; E = E->next()) {
- PropertyInfo p = E->get().info;
- p.name = String(E->key());
-
- info.push_back(p);
- values[p.name] = E->get().default_value;
+ for (List<PropertyInfo>::Element *E = info.front(); E; E = E->next()) {
+ Variant value;
+ get_property_default_value(E->get().name, value);
+ values[E->get().name] = value;
}
p_placeholder->update(info, values);
@@ -317,11 +315,11 @@ void NativeScript::get_script_signal_list(List<MethodInfo> *r_signals) const {
bool NativeScript::get_property_default_value(const StringName &p_property, Variant &r_value) const {
NativeScriptDesc *script_data = get_script_desc();
- if (!script_data)
- return false;
-
- Map<StringName, NativeScriptDesc::Property>::Element *P = script_data->properties.find(p_property);
-
+ Map<StringName, NativeScriptDesc::Property>::Element *P = NULL;
+ while (!P && script_data) {
+ P = script_data->properties.find(p_property);
+ script_data = script_data->base_data;
+ }
if (!P)
return false;
diff --git a/modules/visual_script/visual_script.cpp b/modules/visual_script/visual_script.cpp
index 376329715b..7a368fbace 100644
--- a/modules/visual_script/visual_script.cpp
+++ b/modules/visual_script/visual_script.cpp
@@ -1058,6 +1058,10 @@ MethodInfo VisualScript::get_method_info(const StringName &p_method) const {
arg.type = func->get_argument_type(i);
mi.arguments.push_back(arg);
}
+
+ if (!func->is_sequenced()) {
+ mi.flags |= METHOD_FLAG_CONST;
+ }
}
}
@@ -1401,6 +1405,10 @@ void VisualScriptInstance::get_method_list(List<MethodInfo> *p_list) const {
mi.arguments.push_back(arg);
}
+ if (!vsf->is_sequenced()) { //assumed constant if not sequenced
+ mi.flags |= METHOD_FLAG_CONST;
+ }
+
//vsf->Get_ for now at least it does not return..
}
}
diff --git a/modules/visual_script/visual_script_editor.cpp b/modules/visual_script/visual_script_editor.cpp
index a71d38f7a0..8912227692 100644
--- a/modules/visual_script/visual_script_editor.cpp
+++ b/modules/visual_script/visual_script_editor.cpp
@@ -869,15 +869,27 @@ void VisualScriptEditor::_member_edited() {
}
selected = new_name;
- _update_graph();
-
+ int node_id = script->get_function_node_id(name);
+ Ref<VisualScriptFunction> func;
+ if (script->has_node(name, node_id)) {
+ func = script->get_node(name, node_id);
+ }
undo_redo->create_action(TTR("Rename Function"));
undo_redo->add_do_method(script.ptr(), "rename_function", name, new_name);
undo_redo->add_undo_method(script.ptr(), "rename_function", new_name, name);
+ if (func.is_valid()) {
+
+ undo_redo->add_do_method(func.ptr(), "set_name", new_name);
+ undo_redo->add_undo_method(func.ptr(), "set_name", name);
+ }
undo_redo->add_do_method(this, "_update_members");
undo_redo->add_undo_method(this, "_update_members");
+ undo_redo->add_do_method(this, "_update_graph");
+ undo_redo->add_undo_method(this, "_update_graph");
undo_redo->commit_action();
+ // _update_graph();
+
return; //or crash because it will become invalid
}
diff --git a/modules/visual_script/visual_script_nodes.cpp b/modules/visual_script/visual_script_nodes.cpp
index d5d8b8fe6e..4fefa01584 100644
--- a/modules/visual_script/visual_script_nodes.cpp
+++ b/modules/visual_script/visual_script_nodes.cpp
@@ -95,6 +95,12 @@ bool VisualScriptFunction::_set(const StringName &p_name, const Variant &p_value
return true;
}
+ if (p_name == "sequenced/sequenced") {
+ sequenced = p_value;
+ ports_changed_notify();
+ return true;
+ }
+
return false;
}
@@ -133,6 +139,11 @@ bool VisualScriptFunction::_get(const StringName &p_name, Variant &r_ret) const
return true;
}
+ if (p_name == "sequenced/sequenced") {
+ r_ret = sequenced;
+ return true;
+ }
+
return false;
}
void VisualScriptFunction::_get_property_list(List<PropertyInfo> *p_list) const {
@@ -147,6 +158,9 @@ void VisualScriptFunction::_get_property_list(List<PropertyInfo> *p_list) const
p_list->push_back(PropertyInfo(Variant::INT, "argument_" + itos(i + 1) + "/type", PROPERTY_HINT_ENUM, argt));
p_list->push_back(PropertyInfo(Variant::STRING, "argument_" + itos(i + 1) + "/name"));
}
+
+ p_list->push_back(PropertyInfo(Variant::BOOL, "sequenced/sequenced"));
+
if (!stack_less) {
p_list->push_back(PropertyInfo(Variant::INT, "stack/size", PROPERTY_HINT_RANGE, "1,100000"));
}
@@ -302,6 +316,7 @@ VisualScriptFunction::VisualScriptFunction() {
stack_size = 256;
stack_less = false;
+ sequenced = true;
rpc_mode = ScriptInstance::RPC_MODE_DISABLED;
}
@@ -314,6 +329,16 @@ bool VisualScriptFunction::is_stack_less() const {
return stack_less;
}
+void VisualScriptFunction::set_sequenced(bool p_enable) {
+
+ sequenced = p_enable;
+}
+
+bool VisualScriptFunction::is_sequenced() const {
+
+ return sequenced;
+}
+
void VisualScriptFunction::set_stack_size(int p_size) {
ERR_FAIL_COND(p_size < 1 || p_size > 100000);
@@ -1467,7 +1492,7 @@ void VisualScriptGlobalConstant::_bind_methods() {
cc += ",";
cc += GlobalConstants::get_global_constant_name(i);
}
- ADD_PROPERTY(PropertyInfo(Variant::INT, "constant", PROPERTY_HINT_ENUM, cc), "set_global_constant", "get_global_constant");
+ ADD_PROPERTY(PropertyInfo(Variant::INT, "constant/constant", PROPERTY_HINT_ENUM, cc), "set_global_constant", "get_global_constant");
}
VisualScriptGlobalConstant::VisualScriptGlobalConstant() {
@@ -1572,7 +1597,7 @@ VisualScriptNodeInstance *VisualScriptClassConstant::instance(VisualScriptInstan
void VisualScriptClassConstant::_validate_property(PropertyInfo &property) const {
- if (property.name == "constant") {
+ if (property.name == "constant/constant") {
List<String> constants;
ClassDB::get_integer_constant_list(base_type, &constants, true);
@@ -1596,7 +1621,7 @@ void VisualScriptClassConstant::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_base_type"), &VisualScriptClassConstant::get_base_type);
ADD_PROPERTY(PropertyInfo(Variant::STRING, "base_type", PROPERTY_HINT_TYPE_STRING, "Object"), "set_base_type", "get_base_type");
- ADD_PROPERTY(PropertyInfo(Variant::STRING, "constant", PROPERTY_HINT_ENUM, ""), "set_class_constant", "get_class_constant");
+ ADD_PROPERTY(PropertyInfo(Variant::STRING, "constant/constant", PROPERTY_HINT_ENUM, ""), "set_class_constant", "get_class_constant");
}
VisualScriptClassConstant::VisualScriptClassConstant() {
@@ -1701,7 +1726,7 @@ VisualScriptNodeInstance *VisualScriptBasicTypeConstant::instance(VisualScriptIn
void VisualScriptBasicTypeConstant::_validate_property(PropertyInfo &property) const {
- if (property.name == "constant") {
+ if (property.name == "constant/constant") {
List<StringName> constants;
Variant::get_numeric_constants_for_type(type, &constants);
@@ -1734,7 +1759,7 @@ void VisualScriptBasicTypeConstant::_bind_methods() {
}
ADD_PROPERTY(PropertyInfo(Variant::INT, "basic_type", PROPERTY_HINT_ENUM, argt), "set_basic_type", "get_basic_type");
- ADD_PROPERTY(PropertyInfo(Variant::STRING, "constant", PROPERTY_HINT_ENUM, ""), "set_basic_type_constant", "get_basic_type_constant");
+ ADD_PROPERTY(PropertyInfo(Variant::STRING, "constant/constant", PROPERTY_HINT_ENUM, ""), "set_basic_type_constant", "get_basic_type_constant");
}
VisualScriptBasicTypeConstant::VisualScriptBasicTypeConstant() {
@@ -1855,7 +1880,7 @@ void VisualScriptMathConstant::_bind_methods() {
cc += ",";
cc += const_name[i];
}
- ADD_PROPERTY(PropertyInfo(Variant::INT, "constant", PROPERTY_HINT_ENUM, cc), "set_math_constant", "get_math_constant");
+ ADD_PROPERTY(PropertyInfo(Variant::INT, "constant/constant", PROPERTY_HINT_ENUM, cc), "set_math_constant", "get_math_constant");
}
VisualScriptMathConstant::VisualScriptMathConstant() {
@@ -1976,7 +2001,7 @@ void VisualScriptEngineSingleton::_bind_methods() {
cc += E->get().name;
}
- ADD_PROPERTY(PropertyInfo(Variant::STRING, "constant", PROPERTY_HINT_ENUM, cc), "set_singleton", "get_singleton");
+ ADD_PROPERTY(PropertyInfo(Variant::STRING, "constant/constant", PROPERTY_HINT_ENUM, cc), "set_singleton", "get_singleton");
}
VisualScriptEngineSingleton::VisualScriptEngineSingleton() {
@@ -3702,11 +3727,11 @@ void register_visual_script_nodes() {
VisualScriptLanguage::singleton->add_register_func("data/preload", create_node_generic<VisualScriptPreload>);
VisualScriptLanguage::singleton->add_register_func("data/action", create_node_generic<VisualScriptInputAction>);
- VisualScriptLanguage::singleton->add_register_func("constants/constant", create_node_generic<VisualScriptConstant>);
- VisualScriptLanguage::singleton->add_register_func("constants/math_constant", create_node_generic<VisualScriptMathConstant>);
- VisualScriptLanguage::singleton->add_register_func("constants/class_constant", create_node_generic<VisualScriptClassConstant>);
- VisualScriptLanguage::singleton->add_register_func("constants/global_constant", create_node_generic<VisualScriptGlobalConstant>);
- VisualScriptLanguage::singleton->add_register_func("constants/basic_type_constant", create_node_generic<VisualScriptBasicTypeConstant>);
+ VisualScriptLanguage::singleton->add_register_func("constant/constants/constant", create_node_generic<VisualScriptConstant>);
+ VisualScriptLanguage::singleton->add_register_func("constant/constants/math_constant", create_node_generic<VisualScriptMathConstant>);
+ VisualScriptLanguage::singleton->add_register_func("constant/constants/class_constant", create_node_generic<VisualScriptClassConstant>);
+ VisualScriptLanguage::singleton->add_register_func("constant/constants/global_constant", create_node_generic<VisualScriptGlobalConstant>);
+ VisualScriptLanguage::singleton->add_register_func("constant/constants/basic_type_constant", create_node_generic<VisualScriptBasicTypeConstant>);
VisualScriptLanguage::singleton->add_register_func("custom/custom_node", create_node_generic<VisualScriptCustomNode>);
VisualScriptLanguage::singleton->add_register_func("custom/sub_call", create_node_generic<VisualScriptSubCall>);
diff --git a/modules/visual_script/visual_script_nodes.h b/modules/visual_script/visual_script_nodes.h
index 7a3b26fe55..ff49417114 100644
--- a/modules/visual_script/visual_script_nodes.h
+++ b/modules/visual_script/visual_script_nodes.h
@@ -46,6 +46,7 @@ class VisualScriptFunction : public VisualScriptNode {
bool stack_less;
int stack_size;
ScriptInstance::RPCMode rpc_mode;
+ bool sequenced;
protected:
bool _set(const StringName &p_name, const Variant &p_value);
@@ -79,9 +80,18 @@ public:
void set_stack_less(bool p_enable);
bool is_stack_less() const;
+ void set_sequenced(bool p_enable);
+ bool is_sequenced() const;
+
void set_stack_size(int p_size);
int get_stack_size() const;
+ void set_return_type_enabled(bool p_returns);
+ bool is_return_type_enabled() const;
+
+ void set_return_type(Variant::Type p_type);
+ Variant::Type get_return_type() const;
+
void set_rpc_mode(ScriptInstance::RPCMode p_mode);
ScriptInstance::RPCMode get_rpc_mode() const;
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-30 14:09:35 +0000