static int _log_config(char *cp, size_t len, const char *arg)
{
int enable;
size_t i;
while (*arg && ((*arg == ' ') || (*arg == '\t'))) {
arg++;
}
enable = (*arg == '+') ? 1 : (*arg == '-') ? 0 : -1;
if (enable == -1) {
return 0;
}
_parse_string(cp, len, &arg);
for (i = 0; i < ARRAY_COUNT(flog_cfg); i++) {
if (flog_cfg[i].bit & FLOG_FLAGS_NONCONFIG) {
continue;
}
if (_str_nccmp(cp, flog_cfg[i].name) == 0) {
if (enable) {
flog_flags |= flog_cfg[i].bit;
} else {
flog_flags &= ~flog_cfg[i].bit;
}
return 1;
}
}
return -1;
}
static int _parse(char **s, struct json_result *result) {
eat_whitespace(s);
if (**s == '[') {
++*s;
return _parse_array(s, result);
}
else if (**s == '"') {
++*s;
return _parse_string(s, result);
}
else {
return 0;
}
}
static enum RPC_Error _parse_node(uchar **str, struct RPC_Node *node)
{
switch( **str )
{
case RPC_NULL:
return _parse_null(str,node);
case RPC_TRUE:
return _parse_true(str,node);
case RPC_FALSE:
return _parse_false(str,node);
case RPC_BYTE:
return _parse_byte(str,node);
case RPC_INT16:
return _parse_int16(str,node);
case RPC_INT32:
return _parse_int32(str,node);
case RPC_INT64:
return _parse_int64(str,node);
case RPC_UUID:
return _parse_uuid(str,node);
case RPC_FLOAT:
return _parse_float(str,node);
default:
break;
}
switch( **str & 0xF0 )
{
case RPC_STRING:
return _parse_string(str,node);
case RPC_ARRAY:
return _parse_array(str,node);
case RPC_HASH:
return _parse_hash(str,node);
default:
break;
}
return RPC_PARSE_ERROR;
}
QFLAGS_INLINE int boolean_option::_parse_boolean(int argc,
char const* const* argv,
std::string* value_string,
bool* value_boolean,
std::string* errors) const
{
assert(argv && "argv must not be null!");
assert(errors && "errors must not be null!");
assert(value_string && "value_string must not be null!");
assert(value_boolean && "value_boolean must not be null!");
// Parse the argument as a string.
int argn = _parse_string(argc, argv, value_string, errors);
if (argn > 0) {
// Check if argument matches any of the following:
// "true" "True" "TRUE" "1"
if ((*value_string) == std::string("true") || (*value_string) == std::string("True")
|| (*value_string) == std::string("TRUE") || (*value_string) == std::string("1")) {
(*value_boolean) = true;
}
// Check if argument matches any of the following:
// "false" "False" "FALSE" "0"
else if ((*value_string) == std::string("false") || (*value_string) == std::string("False")
|| (*value_string) == std::string("FALSE") || (*value_string) == std::string("0")) {
(*value_boolean) = false;
}
// Invalid argument.
else {
errors->append("Error: Invalid argument for boolean option '");
errors->append(_name);
errors->append("': '");
errors->append(*value_string);
errors->append("'.\n");
return -1;
}
}
return argn;
}
void EditorExportPlatformAndroid::_fix_resources(Vector<uint8_t>& p_manifest) {
const int UTF8_FLAG = 0x00000100;
print_line("*******************GORRRGLE***********************");
uint32_t header = decode_uint32(&p_manifest[0]);
uint32_t filesize = decode_uint32(&p_manifest[4]);
uint32_t string_block_len = decode_uint32(&p_manifest[16]);
uint32_t string_count = decode_uint32(&p_manifest[20]);
uint32_t string_flags = decode_uint32(&p_manifest[28]);
const uint32_t string_table_begins = 40;
Vector<String> string_table;
printf("stirng block len: %i\n",string_block_len);
printf("stirng count: %i\n",string_count);
printf("flags: %x\n",string_flags);
for(int i=0;i<string_count;i++) {
uint32_t offset = decode_uint32(&p_manifest[string_table_begins+i*4]);
offset+=string_table_begins+string_count*4;
String str = _parse_string(&p_manifest[offset],string_flags&UTF8_FLAG);
if (str.begins_with("godot-project-name")) {
if (str=="godot-project-name") {
//project name
str = get_project_name();
} else {
String lang = str.substr(str.find_last("-")+1,str.length()).replace("-","_");
String prop = "application/name_"+lang;
if (Globals::get_singleton()->has(prop)) {
str = Globals::get_singleton()->get(prop);
} else {
str = get_project_name();
}
}
}
string_table.push_back(str);
}
//write a new string table, but use 16 bits
Vector<uint8_t> ret;
ret.resize(string_table_begins+string_table.size()*4);
for(int i=0;i<string_table_begins;i++) {
ret[i]=p_manifest[i];
}
int ofs=0;
for(int i=0;i<string_table.size();i++) {
encode_uint32(ofs,&ret[string_table_begins+i*4]);
ofs+=string_table[i].length()*2+2+2;
}
ret.resize(ret.size()+ofs);
uint8_t *chars=&ret[ret.size()-ofs];
for(int i=0;i<string_table.size();i++) {
String s = string_table[i];
encode_uint16(s.length(),chars);
chars+=2;
for(int j=0;j<s.length();j++) {
encode_uint16(s[j],chars);
chars+=2;
}
encode_uint16(0,chars);
chars+=2;
}
//pad
while(ret.size()%4)
ret.push_back(0);
//change flags to not use utf8
encode_uint32(string_flags&~0x100,&ret[28]);
//change length
encode_uint32(ret.size()-12,&ret[16]);
//append the rest...
int rest_from = 12+string_block_len;
int rest_to = ret.size();
int rest_len = (p_manifest.size() - rest_from);
ret.resize(ret.size() + (p_manifest.size() - rest_from) );
for(int i=0;i<rest_len;i++) {
ret[rest_to+i]=p_manifest[rest_from+i];
}
//finally update the size
encode_uint32(ret.size(),&ret[4]);
p_manifest=ret;
printf("end\n");
}
int parse_json_file(FILE *fptr, JSON_T *json_obj)
{
int ret;
char *key;
char first_meet;
char *tmpstr;
long long tmpnum;
double floatnum, decimal;
JSON_T *value;
if (!json_obj)
return -ENOMEM;
key = NULL;
tmpstr = NULL;
value = NULL;
memset(json_obj, 0, sizeof(JSON_T));
json_obj->type = JSON;
json_obj->keys = NULL;
_PARSE_SYMBOL(fptr, "{", NULL);
while (!feof(fptr)) {
_PARSE_SYMBOL(fptr, "\"}", &first_meet);
if (first_meet == '}')
break;
ret = _parse_string(fptr, &key);
if (ret < 0)
goto error_handle;
//printf("string = %s : ", key);
_PARSE_SYMBOL(fptr, ":", NULL);
_PARSE_SYMBOL(fptr, "\"{-0123456789.", &first_meet);
value = malloc(sizeof(JSON_T));
if (!value) {
ret = -ENOMEM;
goto error_handle;
}
memset(value, 0, sizeof(JSON_T));
switch (first_meet) {
case '\"':
ret = _parse_string(fptr, &tmpstr);
if (ret < 0)
goto error_handle;
value->type = STRING;
value->str = tmpstr;
//printf("value = %s\n", tmpstr);
break;
case '{':
fseek(fptr, -1, SEEK_CUR);
ret = parse_json_file(fptr, value);
if (ret < 0)
goto error_handle;
break;
case '-':
ret = _parse_integer(fptr, &tmpnum);
if (ret < 0) {
goto error_handle;
} else if (ret == 1) {
ret = _parse_decimal(fptr, &decimal);
if (ret < 0)
goto error_handle;
floatnum = tmpnum + decimal;
value->type = FLOAT;
value->floating = -floatnum;
} else {
value->type = INTEGER;
value->integer = -tmpnum;
}
//printf("value = %lld\n", -tmpnum);
break;
default:
fseek(fptr, -1, SEEK_CUR);
ret = _parse_integer(fptr, &tmpnum);
if (ret < 0) {
goto error_handle;
} else if (ret == 1) {
ret = _parse_decimal(fptr, &decimal);
if (ret < 0)
goto error_handle;
floatnum = tmpnum + decimal;
value->type = FLOAT;
value->floating = floatnum;
} else {
value->type = INTEGER;
value->integer = tmpnum;
}
//printf("value = %lld\n", tmpnum);
break;
}
/* Insert */
ret = insert_json_obj(json_obj, key, value);
if (ret < 0)
goto error_handle;
key = NULL;
tmpstr = NULL;
value = NULL;
_PARSE_SYMBOL(fptr, "},", &first_meet);
if (first_meet == '}')
break;
}
return 0;
error_handle:
/* Do not free self because it perhaps results in
double free error when recursing */
free_json_obj_field(json_obj);
if (key)
free(key);
if (tmpstr)
free(tmpstr);
if (value)
free(value);
return ret;
}
int flog_interact_s(const char *arg, char *outStr, size_t outStrLen)
{
flog_severity_t s;
flog_module_t m;
int r;
char str[32];
psn_t p = {outStr, outStrLen};
if (arg == NULL) {
flog_psnprintf(&p, "No arg!\n");
return -1;
}
r = _log_config(str, sizeof(str), arg);
if (r == 1) {
flog_psnprintf(&p, "Set configuration '%s'\n", str);
return 0;
} else if (r == -1) {
flog_psnprintf(&p, "Unknown configuration '%s'\n", str);
_print_configs(&p);
return -1;
}
_parse_string(str, sizeof(str), &arg);
m = _module_from_string(str);
if (!MODULE_IS_VALID(m) && m != FLOG_MOD_ALL) {
if (_str_nccmp(str, "init") == 0) {
flog_psnprintf(&p, "Resetting all modules\n");
flog_init();
return 0;
}
flog_psnprintf(&p, "Unknown request '%s'\n", str);
_print_modules(&p);
_print_configs(&p);
return -1;
}
_parse_string(str, sizeof(str), &arg);
s = _severity_from_string(str);
if (SEVERITY_IS_VALID(s)) {
if (flog_set(s, m) == 0) {
flog_psnprintf(&p, "Successfully set severity\n");
}
} else if (str[0]) {
flog_psnprintf(&p, "Unknown severity '%s' %d\n", str, s);
_print_severities(&p);
return -1;
} else {
flog_psnprintf(&p, "Current setting:\n");
}
if (m == FLOG_MOD_ALL) {
flog_psnprintf(&p, " ALL = %s(%d)\n", _severity_to_string(s), s);
} else {
_print_module(m, &p);
flog_psnprintf(&p, "\n");
}
return 0;
}
