mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-04-18 14:42:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

* Cut down on strlcat calls when possible and replace them with clever

Browse Source 
usage of strlcpy (when position/offset of previous strlcpy/snprintf call
is known. strlcat implementation in libretro-common makes implicit strlen
call, using strlcpy avoids this
* Reduce a bunch of local char variables by use of said clever usage,
should save up on local stack size usage
This commit is contained in:
libretroadmin 2023-06-18 12:06:12 +02:00
parent dbc1a41cf6
commit 631301b3f7
23 changed files with 345 additions and 361 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
cheat_manager.c
View File

@ -193,37 +193,34 @@ bool cheat_manager_save(
for (i = 0; i < cheat_st->size; i++) for (i = 0; i < cheat_st->size; i++)
{ {
size_t _len;
unsigned j; unsigned j;
char endian_key[100];
char key[256];
char desc_key[128];
char code_key[128];
char enable_key[128];
char formatted_number[12]; char formatted_number[12];
char var_key[128];
char key[256];
formatted_number[0] = '\0'; formatted_number[0] = '\0';
snprintf(formatted_number, sizeof(formatted_number), "cheat%u_", i); snprintf(formatted_number, sizeof(formatted_number), "cheat%u_", i);
strlcpy(endian_key, formatted_number, sizeof(endian_key)); _len = strlcpy(var_key, formatted_number, sizeof(var_key));
strlcat(endian_key, "big_endian", sizeof(endian_key));
strlcpy(desc_key, formatted_number, sizeof(desc_key));
strlcat(desc_key, "desc", sizeof(desc_key));
strlcpy(code_key, formatted_number, sizeof(code_key));
strlcat(code_key, "code", sizeof(code_key));
strlcpy(enable_key, formatted_number, sizeof(enable_key));
strlcat(enable_key, "enable", sizeof(enable_key));
strlcpy(var_key + _len, "desc", sizeof(var_key) - _len);
if (!string_is_empty(cheat_st->cheats[i].desc)) if (!string_is_empty(cheat_st->cheats[i].desc))
config_set_string(conf, desc_key, cheat_st->cheats[i].desc); config_set_string(conf, var_key, cheat_st->cheats[i].desc);
else else
config_set_string(conf, desc_key, cheat_st->cheats[i].code); config_set_string(conf, var_key, cheat_st->cheats[i].code);
config_set_string(conf, code_key, cheat_st->cheats[i].code); strlcpy(var_key + _len, "code", sizeof(var_key) - _len);
config_set_string(conf, enable_key, config_set_string(conf, var_key, cheat_st->cheats[i].code);
strlcpy(var_key + _len, "enable", sizeof(var_key) - _len);
config_set_string(conf, var_key,
cheat_st->cheats[i].state cheat_st->cheats[i].state
? "true" ? "true"
: "false"); : "false");
config_set_string(conf, endian_key,
strlcpy(var_key + _len, "big_endian", sizeof(var_key) - _len);
config_set_string(conf, var_key,
cheat_st->cheats[i].big_endian cheat_st->cheats[i].big_endian
? "true" ? "true"
: "false" : "false"

14
command.c
View File

@ -1257,6 +1257,7 @@ bool command_event_save_auto_state(
bool savestate_auto_save, bool savestate_auto_save,
const enum rarch_core_type current_core_type) const enum rarch_core_type current_core_type)
{ {
size_t _len;
runloop_state_t *runloop_st = runloop_state_get_ptr(); runloop_state_t *runloop_st = runloop_state_get_ptr();
char savestate_name_auto[PATH_MAX_LENGTH]; char savestate_name_auto[PATH_MAX_LENGTH];
@ -1271,12 +1272,12 @@ bool command_event_save_auto_state(
if (string_is_empty(path_basename(path_get(RARCH_PATH_BASENAME)))) if (string_is_empty(path_basename(path_get(RARCH_PATH_BASENAME))))
return false; return false;
strlcpy(savestate_name_auto, _len = strlcpy(savestate_name_auto,
runloop_st->name.savestate, runloop_st->name.savestate,
sizeof(savestate_name_auto)); sizeof(savestate_name_auto));
strlcat(savestate_name_auto, strlcpy(savestate_name_auto + _len,
".auto", ".auto",
sizeof(savestate_name_auto)); sizeof(savestate_name_auto) - _len);
if (content_save_state((const char*)savestate_name_auto, true, true)) if (content_save_state((const char*)savestate_name_auto, true, true))
RARCH_LOG("%s \"%s\" %s.\n", RARCH_LOG("%s \"%s\" %s.\n",
@ -1367,6 +1368,7 @@ bool command_event_load_entry_state(settings_t *settings)
void command_event_load_auto_state(void) void command_event_load_auto_state(void)
{ {
size_t _len;
char savestate_name_auto[PATH_MAX_LENGTH]; char savestate_name_auto[PATH_MAX_LENGTH];
runloop_state_t *runloop_st = runloop_state_get_ptr(); runloop_state_t *runloop_st = runloop_state_get_ptr();
@ -1382,12 +1384,12 @@ void command_event_load_auto_state(void)
return; return;
#endif #endif
strlcpy(savestate_name_auto, _len = strlcpy(savestate_name_auto,
runloop_st->name.savestate, runloop_st->name.savestate,
sizeof(savestate_name_auto)); sizeof(savestate_name_auto));
strlcat(savestate_name_auto, strlcpy(savestate_name_auto + _len,
".auto", ".auto",
sizeof(savestate_name_auto)); sizeof(savestate_name_auto) - _len);
if (!path_is_valid(savestate_name_auto)) if (!path_is_valid(savestate_name_auto))
return; return;

64
configuration.c
View File

@ -3648,21 +3648,20 @@ static bool config_load_file(global_t *global,
size_t _len = strlcpy(prefix, "input_player", sizeof(prefix)); size_t _len = strlcpy(prefix, "input_player", sizeof(prefix));
for (i = 0; i < MAX_USERS; i++) for (i = 0; i < MAX_USERS; i++)
{ {
size_t _len2;
char buf[64]; char buf[64];
buf[0] = '\0';
snprintf(prefix + _len, sizeof(prefix) - _len, "%u", i + 1); snprintf(prefix + _len, sizeof(prefix) - _len, "%u", i + 1);
strlcpy(buf, prefix, sizeof(buf)); _len2 = strlcpy(buf, prefix, sizeof(buf));
strlcat(buf, "_analog_dpad_mode", sizeof(buf));
CONFIG_GET_INT_BASE(conf, settings, uints.input_analog_dpad_mode[i], buf);
strlcpy(buf, prefix, sizeof(buf)); strlcpy(buf + _len2, "_mouse_index", sizeof(buf) - _len2);
strlcat(buf, "_joypad_index", sizeof(buf)); CONFIG_GET_INT_BASE(conf, settings, uints.input_mouse_index[i], buf);
strlcpy(buf + _len2, "_joypad_index", sizeof(buf) - _len2);
CONFIG_GET_INT_BASE(conf, settings, uints.input_joypad_index[i], buf); CONFIG_GET_INT_BASE(conf, settings, uints.input_joypad_index[i], buf);
strlcpy(buf, prefix, sizeof(buf)); strlcpy(buf + _len2, "_analog_dpad_mode", sizeof(buf) - _len2);
strlcat(buf, "_mouse_index", sizeof(buf)); CONFIG_GET_INT_BASE(conf, settings, uints.input_analog_dpad_mode[i], buf);
CONFIG_GET_INT_BASE(conf, settings, uints.input_mouse_index[i], buf);
} }
} }
@ -4559,30 +4558,31 @@ static void video_driver_save_settings(global_t *global, config_file_t *conf)
static void save_keybind_hat(config_file_t *conf, const char *key, static void save_keybind_hat(config_file_t *conf, const char *key,
const struct retro_keybind *bind) const struct retro_keybind *bind)
{ {
size_t _len;
char config[16]; char config[16];
unsigned hat = (unsigned)GET_HAT(bind->joykey); unsigned hat = (unsigned)GET_HAT(bind->joykey);
config[0] = 'h'; config[0] = 'h';
config[1] = '\0'; config[1] = '\0';
snprintf(config + 1, sizeof(config) - 1, "%u", hat); _len = snprintf(config + 1, sizeof(config) - 1, "%u", hat);
switch (GET_HAT_DIR(bind->joykey)) switch (GET_HAT_DIR(bind->joykey))
{ {
case HAT_UP_MASK: case HAT_UP_MASK:
strlcat(config, "up", sizeof(config)); strlcpy(config + _len, "up", sizeof(config) - _len);
break; break;
case HAT_DOWN_MASK: case HAT_DOWN_MASK:
strlcat(config, "down", sizeof(config)); strlcpy(config + _len, "down", sizeof(config) - _len);
break; break;
case HAT_LEFT_MASK: case HAT_LEFT_MASK:
strlcat(config, "left", sizeof(config)); strlcpy(config, "left", sizeof(config) - _len);
break; break;
case HAT_RIGHT_MASK: case HAT_RIGHT_MASK:
strlcat(config, "right", sizeof(config)); strlcpy(config, "right", sizeof(config) - _len);
break; break;
default: default:
@ -5430,8 +5430,8 @@ int8_t config_save_overrides(enum override_type type, void *data, bool remove)
if (settings->uints.input_device[i] if (settings->uints.input_device[i]
!= overrides->uints.input_device[i]) != overrides->uints.input_device[i])
{ {
strlcpy(cfg, "input_device_p", sizeof(cfg)); size_t _len = strlcpy(cfg, "input_device_p", sizeof(cfg));
strlcat(cfg, formatted_number, sizeof(cfg)); strlcpy(cfg + _len, formatted_number, sizeof(cfg) - _len);
config_set_int(conf, cfg, overrides->uints.input_device[i]); config_set_int(conf, cfg, overrides->uints.input_device[i]);
RARCH_DBG("[Overrides]: %s = \"%u\"\n", cfg, overrides->uints.input_device[i]); RARCH_DBG("[Overrides]: %s = \"%u\"\n", cfg, overrides->uints.input_device[i]);
} }
@ -5652,8 +5652,8 @@ bool input_remapping_load_file(void *data, const char *path)
char formatted_number[4]; char formatted_number[4];
formatted_number[0] = '\0'; formatted_number[0] = '\0';
snprintf(formatted_number, sizeof(formatted_number), "%u", i + 1); snprintf(formatted_number, sizeof(formatted_number), "%u", i + 1);
strlcpy(prefix, "input_player", sizeof(prefix)); _len = strlcpy(prefix, "input_player", sizeof(prefix));
strlcat(prefix, formatted_number, sizeof(prefix)); strlcpy(prefix + _len, formatted_number, sizeof(prefix) - _len);
_len = strlcpy(s1, prefix, sizeof(s1)); _len = strlcpy(s1, prefix, sizeof(s1));
s1[_len ] = '_'; s1[_len ] = '_';
s1[_len+1] = 'b'; s1[_len+1] = 'b';
@ -5734,16 +5734,16 @@ bool input_remapping_load_file(void *data, const char *path)
} }
} }
strlcpy(s1, prefix, sizeof(s1)); _len = strlcpy(s1, prefix, sizeof(s1));
strlcat(s1, "_analog_dpad_mode", sizeof(s1)); strlcpy(s1 + _len, "_analog_dpad_mode", sizeof(s1) - _len);
CONFIG_GET_INT_BASE(conf, settings, uints.input_analog_dpad_mode[i], s1); CONFIG_GET_INT_BASE(conf, settings, uints.input_analog_dpad_mode[i], s1);
strlcpy(s1, "input_libretro_device_p", sizeof(s1)); _len = strlcpy(s1, "input_libretro_device_p", sizeof(s1));
strlcat(s1, formatted_number, sizeof(s1)); strlcpy(s1 + _len, formatted_number, sizeof(s1) - _len);
CONFIG_GET_INT_BASE(conf, settings, uints.input_libretro_device[i], s1); CONFIG_GET_INT_BASE(conf, settings, uints.input_libretro_device[i], s1);
strlcpy(s1, "input_remap_port_p", sizeof(s1)); _len = strlcpy(s1, "input_remap_port_p", sizeof(s1));
strlcat(s1, formatted_number, sizeof(s1)); strlcpy(s1 + _len, formatted_number, sizeof(s1) - _len);
CONFIG_GET_INT_BASE(conf, settings, uints.input_remap_ports[i], s1); CONFIG_GET_INT_BASE(conf, settings, uints.input_remap_ports[i], s1);
} }
@ -5830,8 +5830,8 @@ bool input_remapping_save_file(const char *path)
continue; continue;
snprintf(formatted_number, sizeof(formatted_number), "%u", i + 1); snprintf(formatted_number, sizeof(formatted_number), "%u", i + 1);
strlcpy(prefix, "input_player", sizeof(prefix)); _len = strlcpy(prefix, "input_player", sizeof(prefix));
strlcat(prefix, formatted_number, sizeof(prefix)); strlcpy(prefix + _len, formatted_number, sizeof(prefix) - _len);
_len = strlcpy(s1, prefix, sizeof(s1)); _len = strlcpy(s1, prefix, sizeof(s1));
s1[_len ] = '_'; s1[_len ] = '_';
s1[_len+1] = 'b'; s1[_len+1] = 'b';
@ -5917,16 +5917,16 @@ bool input_remapping_save_file(const char *path)
settings->uints.input_keymapper_ids[i][j]); settings->uints.input_keymapper_ids[i][j]);
} }
strlcpy(s1, "input_libretro_device_p", sizeof(s1)); _len = strlcpy(s1, "input_libretro_device_p", sizeof(s1));
strlcat(s1, formatted_number, sizeof(s1)); strlcpy(s1 + _len, formatted_number, sizeof(s1) - _len);
config_set_int(conf, s1, input_config_get_device(i)); config_set_int(conf, s1, input_config_get_device(i));
strlcpy(s1, prefix, sizeof(s1)); _len = strlcpy(s1, prefix, sizeof(s1));
strlcat(s1, "_analog_dpad_mode", sizeof(s1)); strlcpy(s1 + _len, "_analog_dpad_mode", sizeof(s1) - _len);
config_set_int(conf, s1, settings->uints.input_analog_dpad_mode[i]); config_set_int(conf, s1, settings->uints.input_analog_dpad_mode[i]);
strlcpy(s1, "input_remap_port_p", sizeof(s1)); _len = strlcpy(s1, "input_remap_port_p", sizeof(s1));
strlcat(s1, formatted_number, sizeof(s1)); strlcpy(s1 + _len, formatted_number, sizeof(s1) - _len);
config_set_int(conf, s1, settings->uints.input_remap_ports[i]); config_set_int(conf, s1, settings->uints.input_remap_ports[i]);
} }

36
core_info.c
View File

@ -1340,7 +1340,7 @@ static void core_info_path_list_free(core_path_list_t *path_list)
static core_path_list_t *core_info_path_list_new(const char *core_dir, static core_path_list_t *core_info_path_list_new(const char *core_dir,
const char *core_exts, bool show_hidden_files) const char *core_exts, bool show_hidden_files)
{ {
size_t i; size_t i, _len;
char exts[32]; char exts[32];
core_path_list_t *path_list = NULL; core_path_list_t *path_list = NULL;
struct string_list *core_ext_list = NULL; struct string_list *core_ext_list = NULL;
@ -1375,11 +1375,12 @@ static core_path_list_t *core_info_path_list_new(const char *core_dir,
/* Get list of file extensions to include /* Get list of file extensions to include
* > core + lock */ * > core + lock */
strlcpy(exts, core_exts, sizeof(exts)); _len = strlcpy(exts, core_exts, sizeof(exts));
strlcat(exts, "|lck", sizeof(exts));
#if defined(HAVE_DYNAMIC) #if defined(HAVE_DYNAMIC)
/* > 'standalone exempt' */ /* > 'standalone exempt' */
strlcat(exts, "|lsae", sizeof(exts)); strlcpy(exts + _len, "|lck|lsae", sizeof(exts) - _len);
#else
strlcpy(exts + _len, "|lck", sizeof(exts) - _len);
#endif #endif
/* Fetch core directory listing */ /* Fetch core directory listing */
@ -1617,21 +1618,21 @@ static void core_info_resolve_firmware(
for (i = 0; i < firmware_count; i++) for (i = 0; i < firmware_count; i++)
{ {
char path_key[64]; size_t _len2;
char desc_key[64]; char key[64];
char opt_key[64];
struct config_entry_list *entry = NULL; struct config_entry_list *entry = NULL;
bool tmp_bool = false; bool tmp_bool = false;
snprintf(prefix + _len, sizeof(prefix) - _len, "%u_", i); snprintf(prefix + _len, sizeof(prefix) - _len, "%u_", i);
strlcpy(path_key, prefix, sizeof(path_key)); _len2 = strlcpy(key, prefix, sizeof(key));
strlcat(path_key, "path", sizeof(path_key)); strlcpy(key + _len2, "opt", sizeof(key) - _len2);
strlcpy(desc_key, prefix, sizeof(desc_key));
strlcat(desc_key, "desc", sizeof(desc_key));
strlcpy(opt_key, prefix, sizeof(opt_key));
strlcat(opt_key, "opt", sizeof(opt_key));
entry = config_get_entry(conf, path_key); if (config_get_bool(conf, key, &tmp_bool))
firmware[i].optional = tmp_bool;
strlcpy(key + _len2, "path", sizeof(key) - _len2);
entry = config_get_entry(conf, key);
if (entry && !string_is_empty(entry->value)) if (entry && !string_is_empty(entry->value))
{ {
@ -1639,16 +1640,15 @@ static void core_info_resolve_firmware(
entry->value = NULL; entry->value = NULL;
} }
entry = config_get_entry(conf, desc_key); strlcpy(key + _len2, "desc", sizeof(key) - _len2);
entry = config_get_entry(conf, key);
if (entry && !string_is_empty(entry->value)) if (entry && !string_is_empty(entry->value))
{ {
firmware[i].desc = entry->value; firmware[i].desc = entry->value;
entry->value = NULL; entry->value = NULL;
} }
if (config_get_bool(conf, opt_key , &tmp_bool))
firmware[i].optional = tmp_bool;
} }
info->firmware_count = firmware_count; info->firmware_count = firmware_count;

4
frontend/drivers/platform_win32.c
View File

@ -366,9 +366,9 @@ static void frontend_win32_get_os(char *s, size_t len, int *major, int *minor)
case 2: case 2:
if (server) if (server)
{ {
strlcpy(s, "Windows Server 2003", len); size_t _len = strlcpy(s, "Windows Server 2003", len);
if (GetSystemMetrics(SM_SERVERR2)) if (GetSystemMetrics(SM_SERVERR2))
strlcat(s, " R2", len); strlcpy(s + _len, " R2", len - _len);
} }
else else
{ {

16
gfx/drivers/d3d10.c
View File

@ -1351,24 +1351,22 @@ static bool d3d10_gfx_set_shader(void* data,
{ "TEXCOORD", 1, DXGI_FORMAT_R32G32_FLOAT, 0, offsetof(d3d10_vertex_t, texcoord), { "TEXCOORD", 1, DXGI_FORMAT_R32G32_FLOAT, 0, offsetof(d3d10_vertex_t, texcoord),
D3D10_INPUT_PER_VERTEX_DATA, 0 }, D3D10_INPUT_PER_VERTEX_DATA, 0 },
}; };
char vs_path[PATH_MAX_LENGTH]; char _path[PATH_MAX_LENGTH];
char ps_path[PATH_MAX_LENGTH];
const char *slang_path = d3d10->shader_preset->pass[i].source.path; const char *slang_path = d3d10->shader_preset->pass[i].source.path;
const char *vs_src = d3d10->shader_preset->pass[i].source.string.vertex; const char *vs_src = d3d10->shader_preset->pass[i].source.string.vertex;
const char *ps_src = d3d10->shader_preset->pass[i].source.string.fragment; const char *ps_src = d3d10->shader_preset->pass[i].source.string.fragment;
size_t _len = strlcpy(_path, slang_path, sizeof(_path));
strlcpy(vs_path, slang_path, sizeof(vs_path)); strlcpy(_path + _len, ".vs.hlsl", sizeof(_path) - _len);
strlcpy(ps_path, slang_path, sizeof(ps_path));
strlcat(vs_path, ".vs.hlsl", sizeof(vs_path));
strlcat(ps_path, ".ps.hlsl", sizeof(ps_path));
if (!d3d10_init_shader( if (!d3d10_init_shader(
d3d10->device, vs_src, 0, vs_path, "main", d3d10->device, vs_src, 0, _path, "main",
NULL, NULL, desc, countof(desc), NULL, NULL, desc, countof(desc),
&d3d10->pass[i].shader)) { } &d3d10->pass[i].shader)) { }
strlcpy(_path + _len, ".ps.hlsl", sizeof(_path) - _len);
if (!d3d10_init_shader( if (!d3d10_init_shader(
d3d10->device, ps_src, 0, ps_path, NULL, "main", d3d10->device, ps_src, 0, _path, NULL, "main",
NULL, NULL, 0, NULL, NULL, 0,
&d3d10->pass[i].shader)) { } &d3d10->pass[i].shader)) { }

16
gfx/drivers/d3d11.c
View File

@ -1550,25 +1550,23 @@ static bool d3d11_gfx_set_shader(void* data, enum rarch_shader_type type, const
{ "TEXCOORD", 1, DXGI_FORMAT_R32G32_FLOAT, 0, offsetof(d3d11_vertex_t, texcoord), { "TEXCOORD", 1, DXGI_FORMAT_R32G32_FLOAT, 0, offsetof(d3d11_vertex_t, texcoord),
D3D11_INPUT_PER_VERTEX_DATA, 0 }, D3D11_INPUT_PER_VERTEX_DATA, 0 },
}; };
char vs_path[PATH_MAX_LENGTH]; char _path[PATH_MAX_LENGTH];
char ps_path[PATH_MAX_LENGTH];
const char *slang_path = d3d11->shader_preset->pass[i].source.path; const char *slang_path = d3d11->shader_preset->pass[i].source.path;
const char *vs_src = d3d11->shader_preset->pass[i].source.string.vertex; const char *vs_src = d3d11->shader_preset->pass[i].source.string.vertex;
const char *ps_src = d3d11->shader_preset->pass[i].source.string.fragment; const char *ps_src = d3d11->shader_preset->pass[i].source.string.fragment;
size_t _len = strlcpy(_path, slang_path, sizeof(_path));
strlcpy(vs_path, slang_path, sizeof(vs_path)); strlcpy(_path + _len, ".vs.hlsl", sizeof(_path) - _len);
strlcpy(ps_path, slang_path, sizeof(ps_path));
strlcat(vs_path, ".vs.hlsl", sizeof(vs_path));
strlcat(ps_path, ".ps.hlsl", sizeof(ps_path));
if (!d3d11_init_shader( if (!d3d11_init_shader(
d3d11->device, vs_src, 0, vs_path, "main", NULL, NULL, desc, countof(desc), d3d11->device, vs_src, 0, _path, "main", NULL, NULL, desc, countof(desc),
&d3d11->pass[i].shader, &d3d11->pass[i].shader,
feat_level_hint feat_level_hint
)) { } )) { }
strlcpy(_path + _len, ".ps.hlsl", sizeof(_path) - _len);
if (!d3d11_init_shader( if (!d3d11_init_shader(
d3d11->device, ps_src, 0, ps_path, NULL, "main", NULL, NULL, 0, d3d11->device, ps_src, 0, _path, NULL, "main", NULL, NULL, 0,
&d3d11->pass[i].shader, &d3d11->pass[i].shader,
feat_level_hint feat_level_hint
)) { } )) { }

14
gfx/drivers/d3d12.c
View File

@ -1714,18 +1714,16 @@ static bool d3d12_gfx_set_shader(void* data, enum rarch_shader_type type, const
{ "TEXCOORD", 1, DXGI_FORMAT_R32G32_FLOAT, 0, offsetof(d3d12_vertex_t, texcoord), { "TEXCOORD", 1, DXGI_FORMAT_R32G32_FLOAT, 0, offsetof(d3d12_vertex_t, texcoord),
D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
}; };
char vs_path[PATH_MAX_LENGTH]; char _path[PATH_MAX_LENGTH];
char ps_path[PATH_MAX_LENGTH];
const char *slang_path = d3d12->shader_preset->pass[i].source.path; const char *slang_path = d3d12->shader_preset->pass[i].source.path;
const char *vs_src = d3d12->shader_preset->pass[i].source.string.vertex; const char *vs_src = d3d12->shader_preset->pass[i].source.string.vertex;
const char *ps_src = d3d12->shader_preset->pass[i].source.string.fragment; const char *ps_src = d3d12->shader_preset->pass[i].source.string.fragment;
strlcpy(vs_path, slang_path, sizeof(vs_path)); size_t _len = strlcpy(_path, slang_path, sizeof(_path));
strlcpy(ps_path, slang_path, sizeof(ps_path)); strlcpy(_path + _len, ".vs.hlsl", sizeof(_path) - _len);
strlcat(vs_path, ".vs.hlsl", sizeof(vs_path)); if (!d3d_compile(vs_src, 0, _path, "main", "vs_5_0", &vs_code)){ }
strlcat(ps_path, ".ps.hlsl", sizeof(ps_path));
if (!d3d_compile(vs_src, 0, vs_path, "main", "vs_5_0", &vs_code)){ } strlcpy(_path + _len, ".ps.hlsl", sizeof(_path) - _len);
if (!d3d_compile(ps_src, 0, ps_path, "main", "ps_5_0", &ps_code)){ } if (!d3d_compile(ps_src, 0, _path, "main", "ps_5_0", &ps_code)){ }
desc.BlendState.RenderTarget[0].RenderTargetWriteMask = D3D12_COLOR_WRITE_ENABLE_ALL; desc.BlendState.RenderTarget[0].RenderTargetWriteMask = D3D12_COLOR_WRITE_ENABLE_ALL;
if (i == d3d12->shader_preset->passes - 1) if (i == d3d12->shader_preset->passes - 1)

22
gfx/drivers_shader/slang_reflection.cpp
View File

@ -373,15 +373,15 @@ bool slang_reflect(
/* Validate use of unexpected types. */ /* Validate use of unexpected types. */
if ( if (
!vertex.sampled_images.empty() || !vertex.sampled_images.empty()
!vertex.storage_buffers.empty() || || !vertex.storage_buffers.empty()
!vertex.subpass_inputs.empty() || || !vertex.subpass_inputs.empty()
!vertex.storage_images.empty() || || !vertex.storage_images.empty()
!vertex.atomic_counters.empty() || || !vertex.atomic_counters.empty()
!fragment.storage_buffers.empty() || || !fragment.storage_buffers.empty()
!fragment.subpass_inputs.empty() || || !fragment.subpass_inputs.empty()
!fragment.storage_images.empty() || || !fragment.storage_images.empty()
!fragment.atomic_counters.empty()) || !fragment.atomic_counters.empty())
{ {
RARCH_ERR("[slang]: Invalid resource type detected.\n"); RARCH_ERR("[slang]: Invalid resource type detected.\n");
return false; return false;
@ -687,8 +687,8 @@ bool slang_reflect(
{ {
char buf[64]; char buf[64];
strlcpy(buf, "[slang]:\n", sizeof(buf)); size_t _len = strlcpy(buf, "[slang]:\n", sizeof(buf));
strlcat(buf, FILE_PATH_LOG_INFO, sizeof(buf)); strlcpy(buf + _len, FILE_PATH_LOG_INFO, sizeof(buf) - _len);
strlcat(buf, " [slang]: Parameters:\n", sizeof(buf)); strlcat(buf, " [slang]: Parameters:\n", sizeof(buf));
RARCH_LOG(buf); RARCH_LOG(buf);
} }

30
gfx/video_driver.c
View File

@ -3427,24 +3427,26 @@ void video_driver_frame(const void *data, unsigned width,
if ((video_st->frame_count % fps_update_interval) == 0) if ((video_st->frame_count % fps_update_interval) == 0)
{ {
size_t new_len;
last_fps = TIME_TO_FPS(curr_time, new_time, last_fps = TIME_TO_FPS(curr_time, new_time,
fps_update_interval); fps_update_interval);
video_st->window_title_len = strlcpy(video_st->window_title, new_len = strlcpy(video_st->window_title, video_st->title_buf,
video_st->title_buf, sizeof(video_st->window_title)); sizeof(video_st->window_title));
if (!string_is_empty(status_text)) if (!string_is_empty(status_text))
{ {
video_st->window_title[video_st->window_title_len ] = ' '; video_st->window_title[new_len ] = ' ';
video_st->window_title[video_st->window_title_len+1] = '|'; video_st->window_title[new_len + 1] = '|';
video_st->window_title[video_st->window_title_len+2] = '|'; video_st->window_title[new_len + 2] = '|';
video_st->window_title[video_st->window_title_len+3] = ' '; video_st->window_title[new_len + 3] = ' ';
video_st->window_title[video_st->window_title_len+4] = '\0'; video_st->window_title[new_len + 4] = '\0';
video_st->window_title_len = strlcat(video_st->window_title, new_len = strlcat(video_st->window_title,
status_text, sizeof(video_st->window_title)); status_text, sizeof(video_st->window_title));
} }
curr_time = new_time; curr_time = new_time;
video_st->window_title_len = new_len;
video_st->flags |= VIDEO_FLAG_WINDOW_TITLE_UPDATE; video_st->flags |= VIDEO_FLAG_WINDOW_TITLE_UPDATE;
} }
} }
@ -3496,10 +3498,10 @@ void video_driver_frame(const void *data, unsigned width,
if (!string_is_empty(status_text)) if (!string_is_empty(status_text))
{ {
status_text[buf_pos ] = ' '; status_text[buf_pos ] = ' ';
status_text[buf_pos+1] = '|'; status_text[buf_pos + 1] = '|';
status_text[buf_pos+2] = '|'; status_text[buf_pos + 2] = '|';
status_text[buf_pos+3] = ' '; status_text[buf_pos + 3] = ' ';
status_text[buf_pos+4] = '\0'; status_text[buf_pos + 4] = '\0';
buf_pos = strlcat(status_text, buf_pos = strlcat(status_text,
runloop_st->core_status_msg.str, runloop_st->core_status_msg.str,
sizeof(status_text)); sizeof(status_text));
@ -3699,8 +3701,8 @@ void video_driver_frame(const void *data, unsigned width,
if (len) if (len)
{ {
/* TODO/FIXME - localize */ /* TODO/FIXME - localize */
strlcpy(latency_stats, "LATENCY\n", sizeof(latency_stats)); size_t _len = strlcpy(latency_stats, "LATENCY\n", sizeof(latency_stats));
strlcat(latency_stats, tmp, sizeof(latency_stats)); strlcpy(latency_stats + _len, tmp, sizeof(latency_stats) - _len);
} }
/* TODO/FIXME - localize */ /* TODO/FIXME - localize */

238
gfx/video_shader_parse.c
View File

@ -514,16 +514,8 @@ static enum gfx_wrap_type video_shader_wrap_str_to_mode(const char *wrap_mode)
static bool video_shader_parse_pass(config_file_t *conf, static bool video_shader_parse_pass(config_file_t *conf,
struct video_shader_pass *pass, unsigned i) struct video_shader_pass *pass, unsigned i)
{ {
char shader_name[64]; size_t _len;
char filter_name_buf[64]; char shader_var[64];
char wrap_name_buf[64];
char frame_count_mod_buf[64];
char srgb_output_buf[64];
char fp_fbo_buf[64];
char mipmap_buf[64];
char alias_buf[64];
char scale_name_buf[64];
char attr_name_buf[64];
char scale_type[64]; char scale_type[64];
char scale_type_x[64]; char scale_type_x[64];
char scale_type_y[64]; char scale_type_y[64];
@ -533,21 +525,18 @@ static bool video_shader_parse_pass(config_file_t *conf,
bool tmp_bool = false; bool tmp_bool = false;
struct config_entry_list *entry = NULL; struct config_entry_list *entry = NULL;
fp_fbo_buf[0] = mipmap_buf[0] = alias_buf[0] = scale_type[0] = scale_type_x[0] =
scale_name_buf[0] = attr_name_buf[0] = scale_type[0] = scale_type_y[0] = '\0';
scale_type_x[0] = scale_type_y[0] = formatted_num[0] = shader_var[0] = '\0';
shader_name[0] = filter_name_buf[0] = wrap_name_buf[0] =
frame_count_mod_buf[0] = srgb_output_buf[0] = '\0';
formatted_num[0] = '\0';
snprintf(formatted_num, sizeof(formatted_num), "%u", i); snprintf(formatted_num, sizeof(formatted_num), "%u", i);
/* Source */ /* Source */
strlcpy(shader_name, "shader", sizeof(shader_name)); _len = strlcpy(shader_var, "shader", sizeof(shader_var));
strlcat(shader_name, formatted_num, sizeof(shader_name)); strlcpy(shader_var + _len, formatted_num, sizeof(shader_var) - _len);
if (!config_get_path(conf, shader_name, tmp_path, sizeof(tmp_path))) if (!config_get_path(conf, shader_var, tmp_path, sizeof(tmp_path)))
{ {
RARCH_ERR("[Shaders]: Couldn't parse shader source \"%s\".\n", shader_name); RARCH_ERR("[Shaders]: Couldn't parse shader source \"%s\".\n", shader_var);
return false; return false;
} }
@ -556,10 +545,10 @@ static bool video_shader_parse_pass(config_file_t *conf,
video_shader_replace_wildcards(pass->source.path, PATH_MAX_LENGTH, conf->path); video_shader_replace_wildcards(pass->source.path, PATH_MAX_LENGTH, conf->path);
/* Smooth */ /* Smooth */
strlcpy(filter_name_buf, "filter_linear", sizeof(filter_name_buf)); _len = strlcpy(shader_var, "filter_linear", sizeof(shader_var));
strlcat(filter_name_buf, formatted_num, sizeof(filter_name_buf)); strlcpy(shader_var + _len, formatted_num, sizeof(shader_var) - _len);
if (config_get_bool(conf, filter_name_buf, &tmp_bool)) if (config_get_bool(conf, shader_var, &tmp_bool))
{ {
bool smooth = tmp_bool; bool smooth = tmp_bool;
pass->filter = smooth ? RARCH_FILTER_LINEAR : RARCH_FILTER_NEAREST; pass->filter = smooth ? RARCH_FILTER_LINEAR : RARCH_FILTER_NEAREST;
@ -568,25 +557,25 @@ static bool video_shader_parse_pass(config_file_t *conf,
pass->filter = RARCH_FILTER_UNSPEC; pass->filter = RARCH_FILTER_UNSPEC;
/* Wrapping mode */ /* Wrapping mode */
strlcpy(wrap_name_buf, "wrap_mode", sizeof(wrap_name_buf)); _len = strlcpy(shader_var, "wrap_mode", sizeof(shader_var));
strlcat(wrap_name_buf, formatted_num, sizeof(wrap_name_buf)); strlcpy(shader_var + _len, formatted_num, sizeof(shader_var) - _len);
if ((entry = config_get_entry(conf, wrap_name_buf)) if ((entry = config_get_entry(conf, shader_var))
&& !string_is_empty(entry->value)) && !string_is_empty(entry->value))
pass->wrap = video_shader_wrap_str_to_mode(entry->value); pass->wrap = video_shader_wrap_str_to_mode(entry->value);
entry = NULL; entry = NULL;
/* Frame count mod */ /* Frame count mod */
strlcpy(frame_count_mod_buf, "frame_count_mod", sizeof(frame_count_mod_buf)); _len = strlcpy(shader_var, "frame_count_mod", sizeof(shader_var));
strlcat(frame_count_mod_buf, formatted_num, sizeof(frame_count_mod_buf)); strlcpy(shader_var + _len, formatted_num, sizeof(shader_var) - _len);
if ((entry = config_get_entry(conf, frame_count_mod_buf)) if ((entry = config_get_entry(conf, shader_var))
&& !string_is_empty(entry->value)) && !string_is_empty(entry->value))
pass->frame_count_mod = (unsigned)strtoul(entry->value, NULL, 0); pass->frame_count_mod = (unsigned)strtoul(entry->value, NULL, 0);
entry = NULL; entry = NULL;
/* FBO types and mipmapping */ /* FBO types and mipmapping */
strlcpy(srgb_output_buf, "srgb_framebuffer", sizeof(srgb_output_buf)); _len = strlcpy(shader_var, "srgb_framebuffer", sizeof(shader_var));
strlcat(srgb_output_buf, formatted_num, sizeof(srgb_output_buf)); strlcpy(shader_var + _len, formatted_num, sizeof(shader_var) - _len);
if (config_get_bool(conf, srgb_output_buf, &tmp_bool)) if (config_get_bool(conf, shader_var, &tmp_bool))
{ {
if (tmp_bool) if (tmp_bool)
pass->fbo.flags |= FBO_SCALE_FLAG_SRGB_FBO; pass->fbo.flags |= FBO_SCALE_FLAG_SRGB_FBO;
@ -594,9 +583,9 @@ static bool video_shader_parse_pass(config_file_t *conf,
pass->fbo.flags &= ~FBO_SCALE_FLAG_SRGB_FBO; pass->fbo.flags &= ~FBO_SCALE_FLAG_SRGB_FBO;
} }
strlcpy(fp_fbo_buf, "float_framebuffer", sizeof(fp_fbo_buf)); _len = strlcpy(shader_var, "float_framebuffer", sizeof(shader_var));
strlcat(fp_fbo_buf, formatted_num, sizeof(fp_fbo_buf)); strlcpy(shader_var + _len, formatted_num, sizeof(shader_var) - _len);
if (config_get_bool(conf, fp_fbo_buf, &tmp_bool)) if (config_get_bool(conf, shader_var, &tmp_bool))
{ {
if (tmp_bool) if (tmp_bool)
pass->fbo.flags |= FBO_SCALE_FLAG_FP_FBO; pass->fbo.flags |= FBO_SCALE_FLAG_FP_FBO;
@ -604,29 +593,29 @@ static bool video_shader_parse_pass(config_file_t *conf,
pass->fbo.flags &= ~FBO_SCALE_FLAG_FP_FBO; pass->fbo.flags &= ~FBO_SCALE_FLAG_FP_FBO;
} }
strlcpy(mipmap_buf, "mipmap_input", sizeof(mipmap_buf)); _len = strlcpy(shader_var, "mipmap_input", sizeof(shader_var));
strlcat(mipmap_buf, formatted_num, sizeof(mipmap_buf)); strlcpy(shader_var + _len, formatted_num, sizeof(shader_var) - _len);
if (config_get_bool(conf, mipmap_buf, &tmp_bool)) if (config_get_bool(conf, shader_var, &tmp_bool))
pass->mipmap = tmp_bool; pass->mipmap = tmp_bool;
strlcpy(alias_buf, "alias", sizeof(alias_buf)); _len = strlcpy(shader_var, "alias", sizeof(shader_var));
strlcat(alias_buf, formatted_num, sizeof(alias_buf)); strlcpy(shader_var + _len, formatted_num, sizeof(shader_var) - _len);
if (!config_get_array(conf, alias_buf, pass->alias, sizeof(pass->alias))) if (!config_get_array(conf, shader_var, pass->alias, sizeof(pass->alias)))
*pass->alias = '\0'; *pass->alias = '\0';
/* Scale */ /* Scale */
scale = &pass->fbo; scale = &pass->fbo;
strlcpy(scale_name_buf, "scale_type", sizeof(scale_name_buf)); _len = strlcpy(shader_var, "scale_type", sizeof(shader_var));
strlcat(scale_name_buf, formatted_num, sizeof(scale_name_buf)); strlcpy(shader_var + _len, formatted_num, sizeof(shader_var) - _len);
config_get_array(conf, scale_name_buf, scale_type, sizeof(scale_type)); config_get_array(conf, shader_var, scale_type, sizeof(scale_type));
strlcpy(scale_name_buf, "scale_type_x", sizeof(scale_name_buf)); _len = strlcpy(shader_var, "scale_type_x", sizeof(shader_var));
strlcat(scale_name_buf, formatted_num, sizeof(scale_name_buf)); strlcpy(shader_var + _len, formatted_num, sizeof(shader_var) - _len);
config_get_array(conf, scale_name_buf, scale_type_x, sizeof(scale_type_x)); config_get_array(conf, shader_var, scale_type_x, sizeof(scale_type_x));
strlcpy(scale_name_buf, "scale_type_y", sizeof(scale_name_buf)); _len = strlcpy(shader_var, "scale_type_y", sizeof(shader_var));
strlcat(scale_name_buf, formatted_num, sizeof(scale_name_buf)); strlcpy(shader_var + _len, formatted_num, sizeof(shader_var) - _len);
config_get_array(conf, scale_name_buf, scale_type_y, sizeof(scale_type_y)); config_get_array(conf, shader_var, scale_type_y, sizeof(scale_type_y));
if (*scale_type) if (*scale_type)
{ {
@ -672,62 +661,62 @@ static bool video_shader_parse_pass(config_file_t *conf,
} }
} }
strlcpy(attr_name_buf, "scale", sizeof(attr_name_buf)); _len = strlcpy(shader_var, "scale", sizeof(shader_var));
strlcat(attr_name_buf, formatted_num, sizeof(attr_name_buf)); strlcpy(shader_var + _len, formatted_num, sizeof(shader_var) - _len);
if (scale->type_x == RARCH_SCALE_ABSOLUTE) if (scale->type_x == RARCH_SCALE_ABSOLUTE)
{ {
int iattr = 0; int iattr = 0;
if (config_get_int(conf, attr_name_buf, &iattr)) if (config_get_int(conf, shader_var, &iattr))
scale->abs_x = iattr; scale->abs_x = iattr;
else else
{ {
strlcpy(attr_name_buf, "scale_x", sizeof(attr_name_buf)); _len = strlcpy(shader_var, "scale_x", sizeof(shader_var));
strlcat(attr_name_buf, formatted_num, sizeof(attr_name_buf)); strlcpy(shader_var + _len, formatted_num, sizeof(shader_var) - _len);
if (config_get_int(conf, attr_name_buf, &iattr)) if (config_get_int(conf, shader_var, &iattr))
scale->abs_x = iattr; scale->abs_x = iattr;
} }
} }
else else
{ {
float fattr = 0.0f; float fattr = 0.0f;
if (config_get_float(conf, attr_name_buf, &fattr)) if (config_get_float(conf, shader_var, &fattr))
scale->scale_x = fattr; scale->scale_x = fattr;
else else
{ {
strlcpy(attr_name_buf, "scale_x", sizeof(attr_name_buf)); _len = strlcpy(shader_var, "scale_x", sizeof(shader_var));
strlcat(attr_name_buf, formatted_num, sizeof(attr_name_buf)); strlcpy(shader_var + _len, formatted_num, sizeof(shader_var) - _len);
if (config_get_float(conf, attr_name_buf, &fattr)) if (config_get_float(conf, shader_var, &fattr))
scale->scale_x = fattr; scale->scale_x = fattr;
} }
} }
strlcpy(attr_name_buf, "scale", sizeof(attr_name_buf)); _len = strlcpy(shader_var, "scale", sizeof(shader_var));
strlcat(attr_name_buf, formatted_num, sizeof(attr_name_buf)); strlcpy(shader_var + _len, formatted_num, sizeof(shader_var) - _len);
if (scale->type_y == RARCH_SCALE_ABSOLUTE) if (scale->type_y == RARCH_SCALE_ABSOLUTE)
{ {
int iattr = 0; int iattr = 0;
if (config_get_int(conf, attr_name_buf, &iattr)) if (config_get_int(conf, shader_var, &iattr))
scale->abs_y = iattr; scale->abs_y = iattr;
else else
{ {
strlcpy(attr_name_buf, "scale_y", sizeof(attr_name_buf)); _len = strlcpy(shader_var, "scale_y", sizeof(shader_var));
strlcat(attr_name_buf, formatted_num, sizeof(attr_name_buf)); strlcpy(shader_var + _len, formatted_num, sizeof(shader_var) - _len);
if (config_get_int(conf, attr_name_buf, &iattr)) if (config_get_int(conf, shader_var, &iattr))
scale->abs_y = iattr; scale->abs_y = iattr;
} }
} }
else else
{ {
float fattr = 0.0f; float fattr = 0.0f;
if (config_get_float(conf, attr_name_buf, &fattr)) if (config_get_float(conf, shader_var, &fattr))
scale->scale_y = fattr; scale->scale_y = fattr;
else else
{ {
strlcpy(attr_name_buf, "scale_y", sizeof(attr_name_buf)); _len = strlcpy(shader_var, "scale_y", sizeof(shader_var));
strlcat(attr_name_buf, formatted_num, sizeof(attr_name_buf)); strlcpy(shader_var, formatted_num, sizeof(shader_var) - _len);
if (config_get_float(conf, attr_name_buf, &fattr)) if (config_get_float(conf, shader_var, &fattr))
scale->scale_y = fattr; scale->scale_y = fattr;
} }
} }
@ -771,18 +760,16 @@ static bool video_shader_parse_textures(config_file_t *conf,
id && shader->luts < GFX_MAX_TEXTURES; id && shader->luts < GFX_MAX_TEXTURES;
shader->luts++, id = strtok_r(NULL, ";", &save)) shader->luts++, id = strtok_r(NULL, ";", &save))
{ {
char id_filter[64]; size_t _len;
char id_wrap[64]; char idx[64];
char id_mipmap[64];
bool mipmap = false; bool mipmap = false;
bool smooth = false; bool smooth = false;
struct config_entry_list struct config_entry_list *entry = NULL;
*entry = NULL;
id_filter[0] = id_wrap[0] = id_mipmap[0] = '\0'; idx[0] = '\0';
if (!(entry = config_get_entry(conf, id)) || if (!(entry = config_get_entry(conf, id))
string_is_empty(entry->value)) || string_is_empty(entry->value))
{ {
RARCH_ERR("[Shaders]: Cannot find path to texture \"%s\"..\n", RARCH_ERR("[Shaders]: Cannot find path to texture \"%s\"..\n",
id); id);
@ -796,33 +783,32 @@ static bool video_shader_parse_textures(config_file_t *conf,
fill_pathname_expanded_and_absolute(shader->lut[shader->luts].path, conf->path, texture_path); fill_pathname_expanded_and_absolute(shader->lut[shader->luts].path, conf->path, texture_path);
video_shader_replace_wildcards(shader->lut[shader->luts].path, PATH_MAX_LENGTH, conf->path); video_shader_replace_wildcards(shader->lut[shader->luts].path, PATH_MAX_LENGTH, conf->path);
entry = NULL;
strlcpy(shader->lut[shader->luts].id, id, strlcpy(shader->lut[shader->luts].id, id,
sizeof(shader->lut[shader->luts].id)); sizeof(shader->lut[shader->luts].id));
strlcpy(id_filter, id, sizeof(id_filter)); _len = strlcpy(idx, id, sizeof(idx));
strlcat(id_filter, "_linear", sizeof(id_filter));
if (config_get_bool(conf, id_filter, &smooth)) strlcpy(idx + _len, "_linear", sizeof(idx) - _len);
if (config_get_bool(conf, idx, &smooth))
shader->lut[shader->luts].filter = smooth shader->lut[shader->luts].filter = smooth
? RARCH_FILTER_LINEAR ? RARCH_FILTER_LINEAR
: RARCH_FILTER_NEAREST; : RARCH_FILTER_NEAREST;
else else
shader->lut[shader->luts].filter = RARCH_FILTER_UNSPEC; shader->lut[shader->luts].filter = RARCH_FILTER_UNSPEC;
strlcpy(id_wrap, id, sizeof(id_wrap)); strlcpy(idx + _len, "_mipmap", sizeof(idx) - _len);
strlcat(id_wrap, "_wrap_mode", sizeof(id_wrap)); if (config_get_bool(conf, idx, &mipmap))
if ((entry = config_get_entry(conf, id_wrap)) shader->lut[shader->luts].mipmap = mipmap;
else
shader->lut[shader->luts].mipmap = false;
strlcpy(idx + _len, "_wrap_mode", sizeof(idx) - _len);
entry = NULL;
if ((entry = config_get_entry(conf, idx))
&& !string_is_empty(entry->value)) && !string_is_empty(entry->value))
shader->lut[shader->luts].wrap = video_shader_wrap_str_to_mode(entry->value); shader->lut[shader->luts].wrap = video_shader_wrap_str_to_mode(entry->value);
entry = NULL; entry = NULL;
strlcpy(id_mipmap, id, sizeof(id_mipmap));
strlcat(id_mipmap, "_mipmap", sizeof(id_mipmap));
if (config_get_bool(conf, id_mipmap, &mipmap))
shader->lut[shader->luts].mipmap = mipmap;
else
shader->lut[shader->luts].mipmap = false;
} }
free(textures); free(textures);
@ -1045,15 +1031,15 @@ static void video_shader_write_scale_dim(config_file_t *conf,
{ {
char key[64]; char key[64];
char dim_str[64]; char dim_str[64];
strlcpy(dim_str, dim, sizeof(dim_str)); size_t _len = strlcpy(dim_str, dim, sizeof(dim_str));
strlcat(dim_str, formatted_num, sizeof(dim_str)); strlcpy(dim_str + _len, formatted_num, sizeof(dim_str) - _len);
strlcpy(key, "scale_type_", sizeof(key)); _len = strlcpy(key, "scale_type_", sizeof(key));
strlcat(key, dim_str, sizeof(key)); strlcpy(key + _len, dim_str, sizeof(key) - _len);
config_set_string(conf, key, video_shader_scale_type_to_str(type)); config_set_string(conf, key, video_shader_scale_type_to_str(type));
strlcpy(key, "scale_", sizeof(key)); _len = strlcpy(key, "scale_", sizeof(key));
strlcat(key, dim_str, sizeof(key)); strlcpy(key + _len, dim_str, sizeof(key) - _len);
if (type == RARCH_SCALE_ABSOLUTE) if (type == RARCH_SCALE_ABSOLUTE)
config_set_int(conf, key, absolute); config_set_int(conf, key, absolute);
else else
@ -1065,18 +1051,18 @@ static void video_shader_write_fbo(config_file_t *conf,
const struct gfx_fbo_scale *fbo) const struct gfx_fbo_scale *fbo)
{ {
char key[64]; char key[64];
strlcpy(key, "float_framebuffer", sizeof(key)); size_t _len = strlcpy(key, "float_framebuffer", sizeof(key));
strlcat(key, formatted_num, sizeof(key)); strlcpy(key + _len, formatted_num, sizeof(key) - _len);
config_set_string(conf, key, (fbo->flags & FBO_SCALE_FLAG_FP_FBO) ? "true" : "false"); config_set_string(conf, key, (fbo->flags & FBO_SCALE_FLAG_FP_FBO) ? "true" : "false");
strlcpy(key, "srgb_framebuffer", sizeof(key)); _len = strlcpy(key, "srgb_framebuffer", sizeof(key));
strlcat(key, formatted_num, sizeof(key)); strlcpy(key + _len, formatted_num, sizeof(key) - _len);
config_set_string(conf, key, (fbo->flags & FBO_SCALE_FLAG_SRGB_FBO) ? "true" : "false"); config_set_string(conf, key, (fbo->flags & FBO_SCALE_FLAG_SRGB_FBO) ? "true" : "false");
if (!(fbo->flags & FBO_SCALE_FLAG_VALID)) if (fbo->flags & FBO_SCALE_FLAG_VALID)
return; {
video_shader_write_scale_dim(conf, "x", formatted_num, fbo->type_x, fbo->scale_x, fbo->abs_x); video_shader_write_scale_dim(conf, "x", formatted_num, fbo->type_x, fbo->scale_x, fbo->abs_x);
video_shader_write_scale_dim(conf, "y", formatted_num, fbo->type_y, fbo->scale_y, fbo->abs_y); video_shader_write_scale_dim(conf, "y", formatted_num, fbo->type_y, fbo->scale_y, fbo->abs_y);
}
} }
/** /**
@ -1123,6 +1109,7 @@ static bool video_shader_write_root_preset(const struct video_shader *shader,
for (i = 0; i < shader->passes; i++) for (i = 0; i < shader->passes; i++)
{ {
size_t _len;
char formatted_num[8]; char formatted_num[8];
const struct video_shader_pass *pass = &shader->pass[i]; const struct video_shader_pass *pass = &shader->pass[i];
@ -1130,8 +1117,8 @@ static bool video_shader_write_root_preset(const struct video_shader *shader,
snprintf(formatted_num, sizeof(formatted_num), "%u", (int)i); snprintf(formatted_num, sizeof(formatted_num), "%u", (int)i);
strlcpy(key, "shader", sizeof(key)); _len = strlcpy(key, "shader", sizeof(key));
strlcat(key, formatted_num, sizeof(key)); strlcpy(key + _len, formatted_num, sizeof(key) - _len);
strlcpy(tmp, pass->source.path, PATH_MAX_LENGTH); strlcpy(tmp, pass->source.path, PATH_MAX_LENGTH);
path_relative_to(tmp_rel, tmp, tmp_base, PATH_MAX_LENGTH); path_relative_to(tmp_rel, tmp, tmp_base, PATH_MAX_LENGTH);
@ -1142,31 +1129,31 @@ static bool video_shader_write_root_preset(const struct video_shader *shader,
if (pass->filter != RARCH_FILTER_UNSPEC) if (pass->filter != RARCH_FILTER_UNSPEC)
{ {
strlcpy(key, "filter_linear", sizeof(key)); _len = strlcpy(key, "filter_linear", sizeof(key));
strlcat(key, formatted_num, sizeof(key)); strlcpy(key, formatted_num, sizeof(key) - _len);
config_set_string(conf, key, config_set_string(conf, key,
(pass->filter == RARCH_FILTER_LINEAR) (pass->filter == RARCH_FILTER_LINEAR)
? "true" ? "true"
: "false"); : "false");
} }
strlcpy(key, "wrap_mode", sizeof(key)); _len = strlcpy(key, "wrap_mode", sizeof(key));
strlcat(key, formatted_num, sizeof(key)); strlcpy(key + _len, formatted_num, sizeof(key) - _len);
config_set_string(conf, key, video_shader_wrap_mode_to_str(pass->wrap)); config_set_string(conf, key, video_shader_wrap_mode_to_str(pass->wrap));
if (pass->frame_count_mod) if (pass->frame_count_mod)
{ {
strlcpy(key, "frame_count_mod", sizeof(key)); _len = strlcpy(key, "frame_count_mod", sizeof(key));
strlcat(key, formatted_num, sizeof(key)); strlcpy(key + _len, formatted_num, sizeof(key) - _len);
config_set_int(conf, key, pass->frame_count_mod); config_set_int(conf, key, pass->frame_count_mod);
} }
strlcpy(key, "mipmap_input", sizeof(key)); _len = strlcpy(key, "mipmap_input", sizeof(key));
strlcat(key, formatted_num, sizeof(key)); strlcpy(key + _len, formatted_num, sizeof(key) - _len);
config_set_string(conf, key, pass->mipmap ? "true" : "false"); config_set_string(conf, key, pass->mipmap ? "true" : "false");
strlcpy(key, "alias", sizeof(key)); _len = strlcpy(key, "alias", sizeof(key));
strlcat(key, formatted_num, sizeof(key)); strlcpy(key + _len, formatted_num, sizeof(key) - _len);
config_set_string(conf, key, pass->alias); config_set_string(conf, key, pass->alias);
video_shader_write_fbo(conf, formatted_num, &pass->fbo); video_shader_write_fbo(conf, formatted_num, &pass->fbo);
@ -1208,8 +1195,8 @@ static bool video_shader_write_root_preset(const struct video_shader *shader,
if (shader->lut[i].filter != RARCH_FILTER_UNSPEC) if (shader->lut[i].filter != RARCH_FILTER_UNSPEC)
{ {
char k[128]; char k[128];
strlcpy(k, shader->lut[i].id, sizeof(k)); size_t _len = strlcpy(k, shader->lut[i].id, sizeof(k));
strlcat(k, "_linear", sizeof(k)); strlcpy(k + _len, "_linear", sizeof(k) - _len);
config_set_string(conf, k, config_set_string(conf, k,
(shader->lut[i].filter == RARCH_FILTER_LINEAR) (shader->lut[i].filter == RARCH_FILTER_LINEAR)
? "true" ? "true"
@ -1219,8 +1206,8 @@ static bool video_shader_write_root_preset(const struct video_shader *shader,
/* Wrap Mode */ /* Wrap Mode */
{ {
char k[128]; char k[128];
strlcpy(k, shader->lut[i].id, sizeof(k)); size_t _len = strlcpy(k, shader->lut[i].id, sizeof(k));
strlcat(k, "_wrap_mode", sizeof(k)); strlcpy(k + _len, "_wrap_mode", sizeof(k) - _len);
config_set_string(conf, k, config_set_string(conf, k,
video_shader_wrap_mode_to_str(shader->lut[i].wrap)); video_shader_wrap_mode_to_str(shader->lut[i].wrap));
} }
@ -1228,8 +1215,8 @@ static bool video_shader_write_root_preset(const struct video_shader *shader,
/* Mipmap On or Off */ /* Mipmap On or Off */
{ {
char k[128]; char k[128];
strlcpy(k, shader->lut[i].id, sizeof(k)); size_t _len = strlcpy(k, shader->lut[i].id, sizeof(k));
strlcat(k, "_mipmap", sizeof(k)); strlcpy(k + _len, "_mipmap", sizeof(k) - _len);
config_set_string(conf, k, shader->lut[i].mipmap config_set_string(conf, k, shader->lut[i].mipmap
? "true" ? "true"
: "false"); : "false");
@ -2929,9 +2916,8 @@ bool video_shader_combine_preset_and_apply(
const char *preset_ext = video_shader_get_preset_extension(type); const char *preset_ext = video_shader_get_preset_extension(type);
struct video_shader *shader_to_append = (struct video_shader*) calloc(1, sizeof(*shader_to_append)); struct video_shader *shader_to_append = (struct video_shader*) calloc(1, sizeof(*shader_to_append));
struct video_shader *combined_shader = (struct video_shader*) calloc(1, sizeof(*combined_shader)); struct video_shader *combined_shader = (struct video_shader*) calloc(1, sizeof(*combined_shader));
size_t _len = strlcpy(combined_preset_name, "retroarch", sizeof(combined_preset_name));
strlcpy(combined_preset_name, "retroarch", sizeof(combined_preset_name)); strlcpy(combined_preset_name + _len, preset_ext, sizeof(combined_preset_name) - _len);
strlcat(combined_preset_name, preset_ext, sizeof(combined_preset_name));
fill_pathname_join(combined_preset_path, temp_dir, combined_preset_name, sizeof(combined_preset_path)); fill_pathname_join(combined_preset_path, temp_dir, combined_preset_name, sizeof(combined_preset_path));
video_shader_load_preset_into_shader(preset_path, shader_to_append); video_shader_load_preset_into_shader(preset_path, shader_to_append);

6
libretro-common/file/file_path.c
View File

@ -328,14 +328,16 @@ bool path_is_compressed_file(const char* path)
size_t fill_pathname(char *out_path, const char *in_path, size_t fill_pathname(char *out_path, const char *in_path,
const char *replace, size_t size) const char *replace, size_t size)
{ {
size_t _len, _len2;
char tmp_path[PATH_MAX_LENGTH]; char tmp_path[PATH_MAX_LENGTH];
char *tok = NULL; char *tok = NULL;
strlcpy(tmp_path, in_path, sizeof(tmp_path)); strlcpy(tmp_path, in_path, sizeof(tmp_path));
if ((tok = (char*)strrchr(path_basename(tmp_path), '.'))) if ((tok = (char*)strrchr(path_basename(tmp_path), '.')))
*tok = '\0'; *tok = '\0';
strlcpy(out_path, tmp_path, size); _len = strlcpy(out_path, tmp_path, size);
return strlcat(out_path, replace, size); _len2 = strlcpy(out_path + _len, replace, size - _len);
return _len + _len2;
} }

15
libretro-common/lists/string_list.c
View File

@ -476,28 +476,27 @@ int string_list_find_elem(const struct string_list *list, const char *elem)
bool string_list_find_elem_prefix(const struct string_list *list, bool string_list_find_elem_prefix(const struct string_list *list,
const char *prefix, const char *elem) const char *prefix, const char *elem)
{ {
if (list)
{
size_t i; size_t i;
char prefixed[255]; char prefixed[255];
if (!list) size_t _len = strlcpy(prefixed, prefix, sizeof(prefixed));
return false; strlcpy(prefixed + _len, elem, sizeof(prefixed) - _len);
strlcpy(prefixed, prefix, sizeof(prefixed));
strlcat(prefixed, elem, sizeof(prefixed));
for (i = 0; i < list->size; i++) for (i = 0; i < list->size; i++)
{ {
if ( string_is_equal_noncase(list->elems[i].data, elem) if ( string_is_equal_noncase(list->elems[i].data, elem)
|| string_is_equal_noncase(list->elems[i].data, prefixed)) || string_is_equal_noncase(list->elems[i].data, prefixed))
return true; return true;
} }
}
return false; return false;
} }
struct string_list *string_list_clone(const struct string_list *src) struct string_list *string_list_clone(const struct string_list *src)
{ {
size_t i; size_t i;
struct string_list_elem struct string_list_elem *elems = NULL;
*elems = NULL; struct string_list *dest = (struct string_list*)
struct string_list
*dest = (struct string_list*)
malloc(sizeof(struct string_list)); malloc(sizeof(struct string_list));
if (!dest) if (!dest)

9
menu/cbs/menu_cbs_get_value.c
View File

@ -97,6 +97,7 @@ static void menu_action_setting_audio_mixer_stream_volume(
const char *path, const char *path,
char *s2, size_t len2) char *s2, size_t len2)
{ {
size_t _len;
unsigned offset = (type - MENU_SETTINGS_AUDIO_MIXER_STREAM_ACTIONS_VOLUME_BEGIN); unsigned offset = (type - MENU_SETTINGS_AUDIO_MIXER_STREAM_ACTIONS_VOLUME_BEGIN);
*w = 19; *w = 19;
strlcpy(s2, path, len2); strlcpy(s2, path, len2);
@ -104,8 +105,8 @@ static void menu_action_setting_audio_mixer_stream_volume(
if (offset >= AUDIO_MIXER_MAX_SYSTEM_STREAMS) if (offset >= AUDIO_MIXER_MAX_SYSTEM_STREAMS)
return; return;
snprintf(s, len, "%.2f", audio_driver_mixer_get_stream_volume(offset)); _len = snprintf(s, len, "%.2f", audio_driver_mixer_get_stream_volume(offset));
strlcat(s, " dB", len); strlcpy(s + _len, " dB", len - _len);
} }
#endif #endif
@ -908,8 +909,8 @@ static void menu_action_setting_disp_set_label_input_desc_kbd(
if (key_descriptors[key_id].key != RETROK_FIRST) if (key_descriptors[key_id].key != RETROK_FIRST)
{ {
/* TODO/FIXME - Localize */ /* TODO/FIXME - Localize */
strlcpy(s, "Keyboard ", len); size_t _len = strlcpy(s, "Keyboard ", len);
strlcat(s, key_descriptors[key_id].desc, len); strlcpy(s + _len, key_descriptors[key_id].desc, len - _len);
} }
else else
{ {

4
menu/cbs/menu_cbs_right.c
View File

@ -1163,8 +1163,8 @@ static int menu_cbs_init_bind_right_compare_label(menu_file_list_cbs_t *cbs,
size_t _len = strlcpy(lbl_setting, "input_player", sizeof(lbl_setting)); size_t _len = strlcpy(lbl_setting, "input_player", sizeof(lbl_setting));
for (i = 0; i < MAX_USERS; i++) for (i = 0; i < MAX_USERS; i++)
{ {
snprintf(lbl_setting + _len, sizeof(lbl_setting) - _len, "%d", i + 1); _len += snprintf(lbl_setting + _len, sizeof(lbl_setting) - _len, "%d", i + 1);
strlcat(lbl_setting, "_joypad_index", sizeof(lbl_setting)); strlcpy(lbl_setting + _len, "_joypad_index", sizeof(lbl_setting) - _len);
if (!string_is_equal(label, lbl_setting)) if (!string_is_equal(label, lbl_setting))
continue; continue;

65
menu/menu_displaylist.c
View File

@ -5578,8 +5578,8 @@ static int menu_displaylist_parse_input_description_kbd_list(
else else
{ {
/* TODO/FIXME: Localize 'Keyboard' */ /* TODO/FIXME: Localize 'Keyboard' */
strlcpy(input_description, "Keyboard ", sizeof(input_description)); size_t _len = strlcpy(input_description, "Keyboard ", sizeof(input_description));
strlcat(input_description, key_label, sizeof(input_description)); strlcpy(input_description + _len, key_label, sizeof(input_description) - _len);
} }
/* Add menu entry */ /* Add menu entry */
@ -11579,9 +11579,10 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
{ {
if (!string_is_empty(cd_info.title)) if (!string_is_empty(cd_info.title))
{ {
/* TODO/FIXME - localize */
char title[sizeof("Title: ") + sizeof(cd_info.title)]; /* TODO/FIXME - C89 compliance */ char title[sizeof("Title: ") + sizeof(cd_info.title)]; /* TODO/FIXME - C89 compliance */
strlcpy(title, "Title: ", sizeof(title)); size_t _len = strlcpy(title, "Title: ", sizeof(title));
strlcat(title, cd_info.title, sizeof(title)); strlcpy(title + _len, cd_info.title, sizeof(title) - _len);
if (menu_entries_append(info->list, if (menu_entries_append(info->list,
title, title,
@ -11595,8 +11596,8 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
{ {
char system[256]; char system[256];
/* TODO/FIXME - Localize */ /* TODO/FIXME - Localize */
strlcpy(system, "System: ", sizeof(system)); size_t _len = strlcpy(system, "System: ", sizeof(system));
strlcat(system, cd_info.system, sizeof(system)); strlcpy(system + _len, cd_info.system, sizeof(system) - _len);
if (menu_entries_append(info->list, if (menu_entries_append(info->list,
system, system,
@ -11627,8 +11628,8 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
{ {
char version[256]; char version[256];
/* TODO/FIXME - localize */ /* TODO/FIXME - localize */
strlcpy(version, "Version: ", sizeof(version)); size_t _len = strlcpy(version, "Version: ", sizeof(version));
strlcat(version, cd_info.version, sizeof(version)); strlcpy(version + _len, cd_info.version, sizeof(version) - _len);
if (menu_entries_append(info->list, if (menu_entries_append(info->list,
version, version,
@ -11642,10 +11643,10 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
{ {
char release_date[256]; char release_date[256];
/* TODO/FIXME - Localize */ /* TODO/FIXME - Localize */
strlcpy(release_date, "Release Date: ", size_t _len = strlcpy(release_date, "Release Date: ",
sizeof(release_date));
strlcat(release_date, cd_info.release_date,
sizeof(release_date)); sizeof(release_date));
strlcpy(release_date + _len, cd_info.release_date,
sizeof(release_date) - _len);
if (menu_entries_append(info->list, if (menu_entries_append(info->list,
release_date, release_date,
@ -12087,71 +12088,61 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
#ifdef HAVE_AUDIOMIXER #ifdef HAVE_AUDIOMIXER
{ {
char lbl_play[128]; char lbl[128];
char lbl_play_looped[128];
char lbl_play_sequential[128];
char lbl_remove[128];
char lbl_stop[128];
char lbl_volume[128];
char mixer_stream_str[128]; char mixer_stream_str[128];
unsigned id = info->type - MENU_SETTINGS_AUDIO_MIXER_STREAM_ACTIONS_BEGIN; unsigned id = info->type - MENU_SETTINGS_AUDIO_MIXER_STREAM_ACTIONS_BEGIN;
size_t _len = strlcpy(mixer_stream_str, "mixer_stream_", sizeof(mixer_stream_str)); size_t _len = strlcpy(mixer_stream_str, "mixer_stream_", sizeof(mixer_stream_str));
lbl_remove[0] = lbl_stop[0] = lbl_play[0] = lbl_play_looped[0] = '\0'; lbl[0] = '\0';
lbl_volume[0] = lbl_play_sequential[0] = '\0';
snprintf(mixer_stream_str + _len, sizeof(mixer_stream_str) - _len, "%d", id); snprintf(mixer_stream_str + _len, sizeof(mixer_stream_str) - _len, "%d", id);
strlcpy(lbl_volume, mixer_stream_str, sizeof(lbl_volume));
strlcpy(lbl_stop, mixer_stream_str, sizeof(lbl_stop));
strlcpy(lbl_remove, mixer_stream_str, sizeof(lbl_remove));
strlcpy(lbl_play, mixer_stream_str, sizeof(lbl_play));
strlcpy(lbl_play_looped, mixer_stream_str, sizeof(lbl_play_looped));
strlcpy(lbl_play_sequential, mixer_stream_str, sizeof(lbl_play_sequential));
strlcat(lbl_volume, "_action_volume", sizeof(lbl_volume));
strlcat(lbl_stop, "_action_stop", sizeof(lbl_stop));
strlcat(lbl_remove, "_action_remove", sizeof(lbl_remove));
strlcat(lbl_play, "_action_play", sizeof(lbl_play));
strlcat(lbl_play_looped, "_action_play_looped", sizeof(lbl_play_looped));
strlcat(lbl_play_sequential, "_action_play_sequential",sizeof(lbl_play_sequential));
_len = strlcpy(lbl, mixer_stream_str, sizeof(lbl));
strlcpy(lbl + _len, "_action_play", sizeof(lbl) - _len);
if (menu_entries_append(info->list, if (menu_entries_append(info->list,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_MIXER_ACTION_PLAY), msg_hash_to_str(MENU_ENUM_LABEL_VALUE_MIXER_ACTION_PLAY),
lbl_play, lbl,
MSG_UNKNOWN, MSG_UNKNOWN,
(MENU_SETTINGS_AUDIO_MIXER_STREAM_ACTIONS_PLAY_BEGIN + id), (MENU_SETTINGS_AUDIO_MIXER_STREAM_ACTIONS_PLAY_BEGIN + id),
0, 0, NULL)) 0, 0, NULL))
count++; count++;
strlcpy(lbl + _len, "_action_play_looped", sizeof(lbl) - _len);
if (menu_entries_append(info->list, if (menu_entries_append(info->list,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_MIXER_ACTION_PLAY_LOOPED), msg_hash_to_str(MENU_ENUM_LABEL_VALUE_MIXER_ACTION_PLAY_LOOPED),
lbl_play_looped, lbl,
MSG_UNKNOWN, MSG_UNKNOWN,
(MENU_SETTINGS_AUDIO_MIXER_STREAM_ACTIONS_PLAY_LOOPED_BEGIN + id), (MENU_SETTINGS_AUDIO_MIXER_STREAM_ACTIONS_PLAY_LOOPED_BEGIN + id),
0, 0, NULL)) 0, 0, NULL))
count++; count++;
strlcpy(lbl + _len, "_action_play_sequential",sizeof(lbl) - _len);
if (menu_entries_append(info->list, if (menu_entries_append(info->list,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_MIXER_ACTION_PLAY_SEQUENTIAL), msg_hash_to_str(MENU_ENUM_LABEL_VALUE_MIXER_ACTION_PLAY_SEQUENTIAL),
lbl_play_sequential, lbl,
MSG_UNKNOWN, MSG_UNKNOWN,
(MENU_SETTINGS_AUDIO_MIXER_STREAM_ACTIONS_PLAY_SEQUENTIAL_BEGIN + id), (MENU_SETTINGS_AUDIO_MIXER_STREAM_ACTIONS_PLAY_SEQUENTIAL_BEGIN + id),
0, 0, NULL)) 0, 0, NULL))
count++; count++;
strlcpy(lbl + _len, "_action_stop", sizeof(lbl) - _len);
if (menu_entries_append(info->list, if (menu_entries_append(info->list,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_MIXER_ACTION_STOP), msg_hash_to_str(MENU_ENUM_LABEL_VALUE_MIXER_ACTION_STOP),
lbl_stop, lbl,
MSG_UNKNOWN, MSG_UNKNOWN,
(MENU_SETTINGS_AUDIO_MIXER_STREAM_ACTIONS_STOP_BEGIN + id), (MENU_SETTINGS_AUDIO_MIXER_STREAM_ACTIONS_STOP_BEGIN + id),
0, 0, NULL)) 0, 0, NULL))
count++; count++;
strlcpy(lbl + _len, "_action_remove", sizeof(lbl) - _len);
if (menu_entries_append(info->list, if (menu_entries_append(info->list,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_MIXER_ACTION_REMOVE), msg_hash_to_str(MENU_ENUM_LABEL_VALUE_MIXER_ACTION_REMOVE),
lbl_remove, lbl,
MSG_UNKNOWN, MSG_UNKNOWN,
(MENU_SETTINGS_AUDIO_MIXER_STREAM_ACTIONS_REMOVE_BEGIN + id), (MENU_SETTINGS_AUDIO_MIXER_STREAM_ACTIONS_REMOVE_BEGIN + id),
0, 0, NULL)) 0, 0, NULL))
count++; count++;
strlcpy(lbl + _len, "_action_volume", sizeof(lbl) - _len);
if (menu_entries_append(info->list, if (menu_entries_append(info->list,
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_MIXER_ACTION_VOLUME), msg_hash_to_str(MENU_ENUM_LABEL_VALUE_MIXER_ACTION_VOLUME),
lbl_volume, lbl,
MSG_UNKNOWN, MSG_UNKNOWN,
(MENU_SETTINGS_AUDIO_MIXER_STREAM_ACTIONS_VOLUME_BEGIN + id), (MENU_SETTINGS_AUDIO_MIXER_STREAM_ACTIONS_VOLUME_BEGIN + id),
0, 0, NULL)) 0, 0, NULL))

8
menu/menu_setting.c
View File

@ -6552,8 +6552,8 @@ static void setting_get_string_representation_uint_autosave_interval(
if (*setting->value.target.unsigned_integer) if (*setting->value.target.unsigned_integer)
{ {
snprintf(s, len, "%u ", *setting->value.target.unsigned_integer); size_t _len = snprintf(s, len, "%u ", *setting->value.target.unsigned_integer);
strlcat(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_SECONDS), len); strlcpy(s + _len, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_SECONDS), len - _len);
} }
else else
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF), len); strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF), len);
@ -6570,8 +6570,8 @@ static void setting_get_string_representation_uint_replay_checkpoint_interval(
if (*setting->value.target.unsigned_integer) if (*setting->value.target.unsigned_integer)
{ {
snprintf(s, len, "%u ", *setting->value.target.unsigned_integer); size_t _len = snprintf(s, len, "%u ", *setting->value.target.unsigned_integer);
strlcat(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_SECONDS), len); strlcpy(s + _len, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_SECONDS), len - _len);
} }
else else
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF), len); strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF), len);

1
retroarch.c
View File

@ -6364,6 +6364,7 @@ bool retroarch_main_init(int argc, char *argv[])
if (!string_is_empty(cpu_model)) if (!string_is_empty(cpu_model))
{ {
size_t _len; size_t _len;
/* TODO/FIXME - localize */
strlcat(str_output, FILE_PATH_LOG_INFO " CPU Model Name: ", strlcat(str_output, FILE_PATH_LOG_INFO " CPU Model Name: ",
sizeof(str_output)); sizeof(str_output));
_len = strlcat(str_output, cpu_model, sizeof(str_output)); _len = strlcat(str_output, cpu_model, sizeof(str_output));

31
runtime_file.c
View File

@ -318,8 +318,8 @@ runtime_log_t *runtime_log_init(
* the name of the core itself */ * the name of the core itself */
if (supports_no_game) if (supports_no_game)
{ {
strlcpy(content_name, core_name, sizeof(content_name)); size_t _len = strlcpy(content_name, core_name, sizeof(content_name));
strlcat(content_name, ".lrtl", sizeof(content_name)); strlcpy(content_name + _len, ".lrtl", sizeof(content_name) - _len);
} }
} }
/* NOTE: TyrQuake requires a specific hack, since all /* NOTE: TyrQuake requires a specific hack, since all
@ -332,17 +332,19 @@ runtime_log_t *runtime_log_init(
size_t path_length = last_slash + 1 - content_path; size_t path_length = last_slash + 1 - content_path;
if (path_length < PATH_MAX_LENGTH) if (path_length < PATH_MAX_LENGTH)
{ {
size_t _len;
memset(tmp_buf, 0, sizeof(tmp_buf)); memset(tmp_buf, 0, sizeof(tmp_buf));
strlcpy(tmp_buf, strlcpy(tmp_buf,
content_path, path_length * sizeof(char)); content_path, path_length * sizeof(char));
strlcpy(content_name, _len = strlcpy(content_name,
path_basename(tmp_buf), sizeof(content_name)); path_basename(tmp_buf), sizeof(content_name));
strlcat(content_name, ".lrtl", sizeof(content_name)); strlcpy(content_name + _len, ".lrtl", sizeof(content_name) - _len);
} }
} }
} }
else else
{ {
size_t _len;
/* path_remove_extension() requires a char * (not const) /* path_remove_extension() requires a char * (not const)
* so have to use a temporary buffer... */ * so have to use a temporary buffer... */
char *tmp_buf_no_ext = NULL; char *tmp_buf_no_ext = NULL;
@ -353,8 +355,8 @@ runtime_log_t *runtime_log_init(
if (string_is_empty(tmp_buf_no_ext)) if (string_is_empty(tmp_buf_no_ext))
return NULL; return NULL;
strlcpy(content_name, tmp_buf_no_ext, sizeof(content_name)); _len = strlcpy(content_name, tmp_buf_no_ext, sizeof(content_name));
strlcat(content_name, ".lrtl", sizeof(content_name)); strlcpy(content_name + _len, ".lrtl", sizeof(content_name) - _len);
} }
if (string_is_empty(content_name)) if (string_is_empty(content_name))
@ -510,12 +512,13 @@ void runtime_log_get_runtime_str(runtime_log_t *runtime_log,
s[_len+1] = '\0'; s[_len+1] = '\0';
if (runtime_log) if (runtime_log)
{ {
size_t _len2;
char t[64]; char t[64];
t[0] = '\0'; t[0] = '\0';
snprintf(t, sizeof(t), "%02u:%02u:%02u", _len2 = snprintf(t, sizeof(t), "%02u:%02u:%02u",
runtime_log->runtime.hours, runtime_log->runtime.minutes, runtime_log->runtime.hours, runtime_log->runtime.minutes,
runtime_log->runtime.seconds); runtime_log->runtime.seconds);
strlcat(s, t, len); strlcpy(s + _len2, t, len - _len2);
} }
else else
{ {
@ -569,6 +572,7 @@ static void runtime_log_get_last_played_time(runtime_log_t *runtime_log,
static bool runtime_last_played_human(runtime_log_t *runtime_log, static bool runtime_last_played_human(runtime_log_t *runtime_log,
char *str, size_t len) char *str, size_t len)
{ {
size_t _len;
struct tm time_info; struct tm time_info;
time_t last_played; time_t last_played;
time_t current; time_t current;
@ -607,13 +611,14 @@ static bool runtime_last_played_human(runtime_log_t *runtime_log,
delta /= periods[i]; delta /= periods[i];
/* Generate string */ /* Generate string */
snprintf(tmp, sizeof(tmp), "%u ", (int)delta); _len = snprintf(tmp, sizeof(tmp), "%u ", (int)delta);
if (delta == 1) if (delta == 1)
strlcat(tmp, msg_hash_to_str((enum msg_hash_enums)units[i][0]), strlcpy(tmp + _len, msg_hash_to_str((enum msg_hash_enums)units[i][0]),
sizeof(tmp)); sizeof(tmp) - _len);
else else
strlcat(tmp, msg_hash_to_str((enum msg_hash_enums)units[i][1]), strlcpy(tmp + _len, msg_hash_to_str((enum msg_hash_enums)units[i][1]),
sizeof(tmp)); sizeof(tmp) - _len);
strlcat(str, tmp, len); strlcat(str, tmp, len);
strlcat(str, " ", len); strlcat(str, " ", len);
strlcat(str, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_TIME_UNIT_AGO), len); strlcat(str, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_TIME_UNIT_AGO), len);

13
tasks/task_content.c
View File

@ -1046,16 +1046,19 @@ static bool content_file_load(
else else
new_basedir[0] = '\0'; new_basedir[0] = '\0';
if (string_is_empty(new_basedir) || if ( string_is_empty (new_basedir)
!path_is_directory(new_basedir) || || !path_is_directory(new_basedir)
!is_path_accessible_using_standard_io(new_basedir)) || !is_path_accessible_using_standard_io(new_basedir))
{ {
size_t _len;
DWORD basedir_attribs; DWORD basedir_attribs;
RARCH_WARN("[Content]: Tried copying to cache directory, " RARCH_WARN("[Content]: Tried copying to cache directory, "
"but cache directory was not set or found. " "but cache directory was not set or found. "
"Setting cache directory to root of writable app directory...\n"); "Setting cache directory to root of writable app directory...\n");
strlcpy(new_basedir, uwp_dir_data, sizeof(new_basedir)); _len = strlcpy(new_basedir, uwp_dir_data, sizeof(new_basedir));
strlcat(new_basedir, "VFSCACHE\\", sizeof(new_basedir)); strlcpy(new_basedir + _len,
"VFSCACHE\\",
sizeof(new_basedir) - _len);
basedir_attribs = GetFileAttributes(new_basedir); basedir_attribs = GetFileAttributes(new_basedir);
if ( (basedir_attribs == INVALID_FILE_ATTRIBUTES) if ( (basedir_attribs == INVALID_FILE_ATTRIBUTES)
|| (!(basedir_attribs & FILE_ATTRIBUTE_DIRECTORY))) || (!(basedir_attribs & FILE_ATTRIBUTE_DIRECTORY)))

6
tasks/task_database.c
View File

@ -545,9 +545,9 @@ static enum msg_file_type extension_to_file_type(const char *ext)
string_to_lower(ext_lower); string_to_lower(ext_lower);
if ( if (
string_is_equal(ext_lower, "7z") || string_is_equal(ext_lower, "7z")
string_is_equal(ext_lower, "zip") || || string_is_equal(ext_lower, "zip")
string_is_equal(ext_lower, "apk") || string_is_equal(ext_lower, "apk")
) )
return FILE_TYPE_COMPRESSED; return FILE_TYPE_COMPRESSED;
if ( if (

4
tasks/task_http.c
View File

@ -383,8 +383,8 @@ void* task_push_http_transfer_file(const char* url, bool mute,
if (string_ends_with_size(s, ".index", if (string_ends_with_size(s, ".index",
strlen(s), STRLEN_CONST(".index"))) strlen(s), STRLEN_CONST(".index")))
strlcat(tmp, msg_hash_to_str(MSG_INDEX_FILE), sizeof(tmp)); s = msg_hash_to_str(MSG_INDEX_FILE);
else
strlcat(tmp, s, sizeof(tmp)); strlcat(tmp, s, sizeof(tmp));
t->title = strdup(tmp); t->title = strdup(tmp);

5
ui/drivers/ui_qt.cpp
View File

@ -5090,6 +5090,7 @@ void LoadCoreWindow::onCoreEnterPressed()
void LoadCoreWindow::onLoadCustomCoreClicked() void LoadCoreWindow::onLoadCustomCoreClicked()
{ {
size_t _len;
QString path; QString path;
QByteArray pathArray; QByteArray pathArray;
char core_ext[255] = {0}; char core_ext[255] = {0};
@ -5100,8 +5101,8 @@ void LoadCoreWindow::onLoadCustomCoreClicked()
frontend_driver_get_core_extension(core_ext, sizeof(core_ext)); frontend_driver_get_core_extension(core_ext, sizeof(core_ext));
strlcpy(filters, "Cores (*.", sizeof(filters)); _len = strlcpy(filters, "Cores (*.", sizeof(filters));
strlcat(filters, core_ext, sizeof(filters)); strlcpy(filters + _len, core_ext, sizeof(filters) - _len);
strlcat(filters, ");;All Files (*.*)", sizeof(filters)); strlcat(filters, ");;All Files (*.*)", sizeof(filters));
path = QFileDialog::getOpenFileName( path = QFileDialog::getOpenFileName(