mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-01-28 06:35:23 +00:00
Code Issues Packages Projects Releases Wiki Activity

(libretro-common) Style nits/cleanups

Browse Source
This commit is contained in:
libretroadmin 2022-07-10 18:13:25 +02:00
parent 79fc6d3b50
commit 0e85113eb3
11 changed files with 211 additions and 327 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
gfx/display_servers/dispserv_win32.c
View File

@ -373,10 +373,8 @@ static void *win32_display_server_get_resolution_list(
}
*len = count;
conf = (struct video_display_config*)
calloc(*len, sizeof(struct video_display_config));
if (!conf)
if (!(conf = (struct video_display_config*)
calloc(*len, sizeof(struct video_display_config))))
return NULL;
for (i = 0, j = 0; win32_get_video_output(&dm, i, sizeof(dm)); i++)

46
gfx/gfx_thumbnail.c
View File

@ -364,16 +364,12 @@ void gfx_thumbnail_request_file(
thumbnail->status = GFX_THUMBNAIL_STATUS_MISSING;
/* Check if file path is valid */
if (string_is_empty(file_path))
return;
if (!path_is_valid(file_path))
if ( string_is_empty(file_path)
|| !path_is_valid(file_path))
return;
/* Load thumbnail */
thumbnail_tag = (gfx_thumbnail_tag_t*)malloc(sizeof(gfx_thumbnail_tag_t));
if (!thumbnail_tag)
if (!(thumbnail_tag = (gfx_thumbnail_tag_t*)malloc(sizeof(gfx_thumbnail_tag_t))))
return;
/* Configure user data */
@ -788,17 +784,22 @@ void gfx_thumbnail_get_draw_dimensions(
unsigned width, unsigned height, float scale_factor,
float *draw_width, float *draw_height)
{
video_driver_state_t *video_st = video_state_get_ptr();
float core_aspect;
float display_aspect;
float thumbnail_aspect;
float core_aspect;
video_driver_state_t *video_st = video_state_get_ptr();
/* Sanity check */
if (!thumbnail || (width < 1) || (height < 1))
goto error;
if ((thumbnail->width < 1) || (thumbnail->height < 1))
goto error;
if ( !thumbnail
|| (width < 1)
|| (height < 1)
|| (thumbnail->width < 1)
|| (thumbnail->height < 1))
{
*draw_width = 0.0f;
*draw_height = 0.0f;
return;
}
/* Account for display/thumbnail/core aspect ratio
* differences */
@ -842,11 +843,6 @@ void gfx_thumbnail_get_draw_dimensions(
* without scaling manually... */
*draw_width *= scale_factor;
*draw_height *= scale_factor;
return;
error:
*draw_width = 0.0f;
*draw_height = 0.0f;
}
/* Draws specified thumbnail with specified alignment
@ -872,10 +868,14 @@ void gfx_thumbnail_draw(
gfx_display_t *p_disp = disp_get_ptr();
gfx_display_ctx_driver_t *dispctx = p_disp->dispctx;
/* Sanity check */
if (!thumbnail ||
(width < 1) || (height < 1) || (alpha <= 0.0f) || (scale_factor <= 0.0f))
return;
if (!dispctx)
if (
!thumbnail
|| !dispctx
|| (width < 1)
|| (height < 1)
|| (alpha <= 0.0f)
|| (scale_factor <= 0.0f)
)
return;
/* Only draw thumbnail if it is available... */

106
libretro-common/encodings/encoding_utf.c
View File

@ -255,10 +255,9 @@ static bool utf16_to_char(uint8_t **utf_data,
utf16_conv_utf8(NULL, dest_len, in, len);
*dest_len += 1;
*utf_data = (uint8_t*)malloc(*dest_len);
if (*utf_data == 0)
return false;
return utf16_conv_utf8(*utf_data, dest_len, in, len);
if (*utf_data != 0)
return utf16_conv_utf8(*utf_data, dest_len, in, len);
return false;
}
bool utf16_to_char_string(const uint16_t *in, char *s, size_t len)
@ -300,10 +299,8 @@ static char *mb_to_mb_string_alloc(const char *str,
if (!path_buf_wide_len)
return strdup(str);
path_buf_wide = (wchar_t*)
calloc(path_buf_wide_len + sizeof(wchar_t), sizeof(wchar_t));
if (path_buf_wide)
if ((path_buf_wide = (wchar_t*)
calloc(path_buf_wide_len + sizeof(wchar_t), sizeof(wchar_t))))
{
MultiByteToWideChar(cp_in, 0,
str, -1, path_buf_wide, path_buf_wide_len);
@ -350,31 +347,29 @@ static char *mb_to_mb_string_alloc(const char *str,
/* Returned pointer MUST be freed by the caller if non-NULL. */
char* utf8_to_local_string_alloc(const char *str)
{
if (str && *str)
{
#if defined(_WIN32) && !defined(_XBOX) && !defined(UNICODE)
if (str && *str)
return mb_to_mb_string_alloc(str, CODEPAGE_UTF8, CODEPAGE_LOCAL);
#else
/* assume string needs no modification if not on Windows */
/* Assume string needs no modification if not on Windows */
if (str && *str)
return strdup(str);
#endif
}
return NULL;
}
/* Returned pointer MUST be freed by the caller if non-NULL. */
char* local_to_utf8_string_alloc(const char *str)
{
if (str && *str)
{
#if defined(_WIN32) && !defined(_XBOX) && !defined(UNICODE)
return mb_to_mb_string_alloc(str, CODEPAGE_LOCAL, CODEPAGE_UTF8);
if (str && *str)
return mb_to_mb_string_alloc(str, CODEPAGE_LOCAL, CODEPAGE_UTF8);
#else
/* assume string needs no modification if not on Windows */
/* Assume string needs no modification if not on Windows */
if (str && *str)
return strdup(str);
#endif
}
return NULL;
return NULL;
}
/* Returned pointer MUST be freed by the caller if non-NULL. */
@ -382,10 +377,8 @@ wchar_t* utf8_to_utf16_string_alloc(const char *str)
{
#ifdef _WIN32
int len = 0;
int out_len = 0;
#else
size_t len = 0;
size_t out_len = 0;
#endif
wchar_t *buf = NULL;
@ -393,56 +386,44 @@ wchar_t* utf8_to_utf16_string_alloc(const char *str)
return NULL;
#ifdef _WIN32
len = MultiByteToWideChar(CP_UTF8, 0, str, -1, NULL, 0);
if (len)
if ((len = MultiByteToWideChar(CP_UTF8, 0, str, -1, NULL, 0)))
{
buf = (wchar_t*)calloc(len, sizeof(wchar_t));
if (!buf)
if (!(buf = (wchar_t*)calloc(len, sizeof(wchar_t))))
return NULL;
out_len = MultiByteToWideChar(CP_UTF8, 0, str, -1, buf, len);
if ((MultiByteToWideChar(CP_UTF8, 0, str, -1, buf, len)) < 0)
{
free(buf);
return NULL;
}
}
else
{
/* fallback to ANSI codepage instead */
len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
if (len)
/* Fallback to ANSI codepage instead */
if ((len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0)))
{
buf = (wchar_t*)calloc(len, sizeof(wchar_t));
if (!buf)
if (!(buf = (wchar_t*)calloc(len, sizeof(wchar_t))))
return NULL;
out_len = MultiByteToWideChar(CP_ACP, 0, str, -1, buf, len);
if ((MultiByteToWideChar(CP_ACP, 0, str, -1, buf, len)) < 0)
{
free(buf);
return NULL;
}
}
}
if (out_len < 0)
{
free(buf);
return NULL;
}
#else
/* NOTE: For now, assume non-Windows platforms' locale is already UTF-8. */
len = mbstowcs(NULL, str, 0) + 1;
if (len)
if ((len = mbstowcs(NULL, str, 0) + 1))
{
buf = (wchar_t*)calloc(len, sizeof(wchar_t));
if (!buf)
if (!(buf = (wchar_t*)calloc(len, sizeof(wchar_t))))
return NULL;
out_len = mbstowcs(buf, str, len);
}
if (out_len == (size_t)-1)
{
free(buf);
return NULL;
if ((mbstowcs(buf, str, len)) == (size_t)-1)
{
free(buf);
return NULL;
}
}
#endif
@ -465,20 +446,17 @@ char* utf16_to_utf8_string_alloc(const wchar_t *str)
#ifdef _WIN32
{
UINT code_page = CP_UTF8;
len = WideCharToMultiByte(code_page,
0, str, -1, NULL, 0, NULL, NULL);
/* fallback to ANSI codepage instead */
if (!len)
if (!(len = WideCharToMultiByte(code_page,
0, str, -1, NULL, 0, NULL, NULL)))
{
code_page = CP_ACP;
len = WideCharToMultiByte(code_page,
0, str, -1, NULL, 0, NULL, NULL);
}
buf = (char*)calloc(len, sizeof(char));
if (!buf)
if (!(buf = (char*)calloc(len, sizeof(char))))
return NULL;
if (WideCharToMultiByte(code_page,
@ -491,13 +469,9 @@ char* utf16_to_utf8_string_alloc(const wchar_t *str)
#else
/* NOTE: For now, assume non-Windows platforms'
* locale is already UTF-8. */
len = wcstombs(NULL, str, 0) + 1;
if (len)
if ((len = wcstombs(NULL, str, 0) + 1))
{
buf = (char*)calloc(len, sizeof(char));
if (!buf)
if (!(buf = (char*)calloc(len, sizeof(char))))
return NULL;
if (wcstombs(buf, str, len) == (size_t)-1)

86
libretro-common/file/config_file.c
View File

@ -521,17 +521,16 @@ static bool config_file_parse_line(config_file_t *conf,
if (comment)
{
config_file_t sub_conf;
bool include_found = false;
bool reference_found = false;
char real_path[PATH_MAX_LENGTH];
char *path = NULL;
char *include_line = NULL;
char *reference_line = NULL;
include_found = string_starts_with_size(comment, "include ",
STRLEN_CONST("include "));
reference_found = string_starts_with_size(comment, "reference ",
STRLEN_CONST("reference "));
bool include_found = string_starts_with_size(comment,
"include ",
STRLEN_CONST("include "));
bool reference_found = string_starts_with_size(comment,
"reference ",
STRLEN_CONST("reference "));
/* All comments except those starting with the include or
* reference directive are ignored */
@ -547,9 +546,7 @@ static bool config_file_parse_line(config_file_t *conf,
if (string_is_empty(include_line))
return false;
path = config_file_extract_value(include_line, false);
if (!path)
if (!(path = config_file_extract_value(include_line, false)))
return false;
if ( string_is_empty(path)
@ -590,9 +587,7 @@ static bool config_file_parse_line(config_file_t *conf,
if (string_is_empty(reference_line))
return false;
path = config_file_extract_value(reference_line, false);
if (!path)
if (!(path = config_file_extract_value(reference_line, false)))
return false;
config_file_add_reference(conf, path);
@ -610,8 +605,7 @@ static bool config_file_parse_line(config_file_t *conf,
line++;
/* Allocate storage for key */
key = (char*)malloc(cur_size + 1);
if (!key)
if (!(key = (char*)malloc(cur_size + 1)))
return false;
/* Copy line contents into key until we
@ -623,15 +617,13 @@ static bool config_file_parse_line(config_file_t *conf,
if (idx == cur_size)
{
cur_size *= 2;
key_tmp = (char*)realloc(key, cur_size + 1);
if (!key_tmp)
if (!(key_tmp = (char*)realloc(key, cur_size + 1)))
{
free(key);
return false;
}
key = key_tmp;
key = key_tmp;
}
key[idx++] = *line++;
@ -640,10 +632,9 @@ static bool config_file_parse_line(config_file_t *conf,
/* Add key and value entries to list */
list->key = key;
list->value = config_file_extract_value(line, true);
/* An entry without a value is invalid */
if (!list->value)
if (!(list->value = config_file_extract_value(line, true)))
{
list->key = NULL;
free(key);
@ -768,9 +759,8 @@ bool config_file_deinitialize(config_file_t *conf)
void config_file_free(config_file_t *conf)
{
if (!config_file_deinitialize(conf))
return;
free(conf);
if (config_file_deinitialize(conf))
free(conf);
}
bool config_append_file(config_file_t *conf, const char *path)
@ -812,27 +802,24 @@ config_file_t *config_file_new_from_string(char *from_string,
const char *path)
{
struct config_file *conf = config_file_new_alloc();
if (!conf)
return NULL;
if (config_file_from_string_internal(conf, from_string, path) == -1)
{
if ( conf
&& config_file_from_string_internal(
conf, from_string, path) != -1)
return conf;
if (conf)
config_file_free(conf);
return NULL;
}
return conf;
return NULL;
}
config_file_t *config_file_new_from_path_to_string(const char *path)
{
int64_t length = 0;
uint8_t *ret_buf = NULL;
config_file_t *conf = NULL;
if (path_is_valid(path))
{
uint8_t *ret_buf = NULL;
int64_t length = 0;
if (filestream_read_file(path, (void**)&ret_buf, &length))
{
config_file_t *conf = NULL;
/* Note: 'ret_buf' is not used outside this
* function - we do not care that it will be
* modified by config_file_new_from_string() */
@ -841,10 +828,12 @@ config_file_t *config_file_new_from_path_to_string(const char *path)
if ((void*)ret_buf)
free((void*)ret_buf);
return conf;
}
}
return conf;
return NULL;
}
config_file_t *config_file_new_with_callback(
@ -854,8 +843,7 @@ config_file_t *config_file_new_with_callback(
struct config_file *conf = config_file_new_alloc();
if (!path || !*path)
return conf;
ret = config_file_load_internal(conf, path, 0, cb);
if (ret == -1)
if ((ret = config_file_load_internal(conf, path, 0, cb)) == -1)
{
config_file_free(conf);
return NULL;
@ -874,8 +862,7 @@ config_file_t *config_file_new(const char *path)
struct config_file *conf = config_file_new_alloc();
if (!path || !*path)
return conf;
ret = config_file_load_internal(conf, path, 0, NULL);
if (ret == -1)
if ((ret = config_file_load_internal(conf, path, 0, NULL)) == -1)
{
config_file_free(conf);
return NULL;
@ -918,16 +905,14 @@ static struct config_entry_list *config_get_entry_internal(
const config_file_t *conf,
const char *key, struct config_entry_list **prev)
{
struct config_entry_list *entry = NULL;
struct config_entry_list *previous = prev ? *prev : NULL;
entry = RHMAP_GET_STR(conf->entries_map, key);
struct config_entry_list *entry = RHMAP_GET_STR(conf->entries_map, key);
if (entry)
return entry;
if (prev)
{
struct config_entry_list *previous = *prev;
for (entry = conf->entries; entry; entry = entry->next)
previous = entry;
@ -1090,9 +1075,9 @@ bool config_get_string(config_file_t *conf, const char *key, char **str)
bool config_get_config_path(config_file_t *conf, char *s, size_t len)
{
if (!conf)
return false;
return strlcpy(s, conf->path, len);
if (conf)
return strlcpy(s, conf->path, len);
return false;
}
bool config_get_array(config_file_t *conf, const char *key,
@ -1226,9 +1211,8 @@ void config_unset(config_file_t *conf, const char *key)
return;
last = conf->entries;
entry = config_get_entry_internal(conf, key, &last);
if (!entry)
if (!(entry = config_get_entry_internal(conf, key, &last)))
return;
(void)RHMAP_DEL_STR(conf->entries_map, entry->key);
@ -1332,7 +1316,7 @@ bool config_file_write(config_file_t *conf, const char *path, bool sort)
if (!file)
return false;
buf = calloc(1, 0x4000);
buf = calloc(1, 0x4000);
setvbuf(file, (char*)buf, _IOFBF, 0x4000);
config_file_dump(conf, file, sort);

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

@ -254,10 +254,9 @@ bool path_is_compressed_file(const char* path)
{
const char *ext = path_get_extension(path);
if (!string_is_empty(ext))
if ( string_is_equal_noncase(ext, "zip") ||
string_is_equal_noncase(ext, "apk") ||
string_is_equal_noncase(ext, "7z"))
return true;
return ( string_is_equal_noncase(ext, "zip")
|| string_is_equal_noncase(ext, "apk")
|| string_is_equal_noncase(ext, "7z"));
return false;
}
@ -457,7 +456,6 @@ void fill_pathname_basedir_noext(char *out_dir,
bool fill_pathname_parent_dir_name(char *out_dir,
const char *in_dir, size_t size)
{
bool success = false;
char *temp = strdup(in_dir);
char *last = find_last_slash(temp);
@ -473,26 +471,24 @@ bool fill_pathname_parent_dir_name(char *out_dir,
*last = '\0';
/* Point in_dir to the address of the last slash. */
in_dir = find_last_slash(temp);
/* If find_last_slash returns NULL, it means there was no slash in temp,
so use temp as-is. */
if (!in_dir)
if (!(in_dir = find_last_slash(temp)))
in_dir = temp;
success = in_dir && in_dir[1];
if (success)
if (in_dir && in_dir[1])
{
/* If path starts with an slash, eliminate it. */
if (path_is_absolute(in_dir))
strlcpy(out_dir, in_dir + 1, size);
else
strlcpy(out_dir, in_dir, size);
free(temp);
return true;
}
free(temp);
return success;
return false;
}
/**
@ -591,9 +587,7 @@ void path_basedir(char *path)
if (strlen(path) < 2)
return;
last = find_last_slash(path);
if (last)
if ((last = find_last_slash(path)))
last[1] = '\0';
else
strlcpy(path, "." PATH_DEFAULT_SLASH(), 3);
@ -690,15 +684,13 @@ bool path_is_absolute(const char *path)
#if defined(_WIN32)
/* Many roads lead to Rome...
* Note: Drive letter can only be 1 character long */
if (string_starts_with_size(path, "\\\\", STRLEN_CONST("\\\\")) ||
string_starts_with_size(path + 1, ":/", STRLEN_CONST(":/")) ||
string_starts_with_size(path + 1, ":\\", STRLEN_CONST(":\\")))
return true;
return ( string_starts_with_size(path, "\\\\", STRLEN_CONST("\\\\"))
|| string_starts_with_size(path + 1, ":/", STRLEN_CONST(":/"))
|| string_starts_with_size(path + 1, ":\\", STRLEN_CONST(":\\")));
#elif defined(__wiiu__) || defined(VITA)
{
const char *seperator = strchr(path, ':');
if (seperator && (seperator[1] == '/'))
return true;
return (seperator && (seperator[1] == '/'));
}
#endif
@ -804,8 +796,7 @@ char *path_resolve_realpath(char *buf, size_t size, bool resolve_symlinks)
* if there are no slashes, they point relative to where one would be */
do
{
next = strchr(p, '/');
if (!next)
if (!(next = strchr(p, '/')))
next = buf_end;
if ((next - p == 2 && p[0] == '.' && p[1] == '.'))

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

@ -118,10 +118,8 @@ bool path_mkdir(const char *dir)
/* Use heap. Real chance of stack
* overflow if we recurse too hard. */
basedir = strdup(dir);
if (!basedir)
return false;
if (!(basedir = strdup(dir)))
return false;
path_parent_dir(basedir);

7
libretro-common/lists/file_list.c
View File

@ -75,9 +75,7 @@ bool file_list_reserve(file_list_t *list, size_t nitems)
if (nitems < list->capacity || nitems > (size_t)-1/item_size)
return false;
new_data = (struct item_file*)realloc(list->list, nitems * item_size);
if (!new_data)
if (!(new_data = (struct item_file*)realloc(list->list, nitems * item_size)))
return false;
memset(&new_data[list->capacity], 0, item_size * (nitems - list->capacity));
@ -430,8 +428,7 @@ bool file_list_search(const file_list_t *list, const char *needle, size_t *idx)
continue;
}
str = (const char *)strcasestr(alt, needle);
if (str == alt)
if ((str = (const char *)strcasestr(alt, needle)) == alt)
{
/* Found match with first chars, best possible match. */
*idx = i;

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

@ -182,8 +182,7 @@ bool string_list_append(struct string_list *list, const char *elem,
(list->cap > 0) ? (list->cap * 2) : 32))
return false;
data_dup = strdup(elem);
if (!data_dup)
if (!(data_dup = strdup(elem)))
return false;
list->elems[list->size].data = data_dup;
@ -213,9 +212,7 @@ bool string_list_append_n(struct string_list *list, const char *elem,
!string_list_capacity(list, list->cap * 2))
return false;
data_dup = (char*)malloc(length + 1);
if (!data_dup)
if (!(data_dup = (char*)malloc(length + 1)))
return false;
strlcpy(data_dup, elem, length + 1);
@ -298,8 +295,7 @@ struct string_list *string_split(const char *str, const char *delim)
if (!list)
return NULL;
copy = strdup(str);
if (!copy)
if (!(copy = strdup(str)))
goto error;
tmp = strtok_r(copy, delim, &save);
@ -334,8 +330,7 @@ bool string_split_noalloc(struct string_list *list,
if (!list)
return false;
copy = strdup(str);
if (!copy)
if (!(copy = strdup(str)))
return false;
tmp = strtok_r(copy, delim, &save);
@ -377,15 +372,13 @@ struct string_list *string_separate(char *str, const char *delim)
/* Sanity check */
if (!str || string_is_empty(delim))
goto error;
return NULL;
if (!(list = string_list_new()))
return NULL;
str_ptr = &str;
list = string_list_new();
token = string_tokenize(str_ptr, delim);
if (!list)
goto error;
token = string_tokenize(str_ptr, delim);
while (token)
{
union string_list_elem_attr attr;
@ -393,22 +386,17 @@ struct string_list *string_separate(char *str, const char *delim)
attr.i = 0;
if (!string_list_append(list, token, attr))
goto error;
{
free(token);
string_list_free(list);
return NULL;
}
free(token);
token = NULL;
token = string_tokenize(str_ptr, delim);
}
return list;
error:
if (token)
free(token);
if (list)
string_list_free(list);
return NULL;
}
bool string_separate_noalloc(
@ -455,15 +443,14 @@ bool string_separate_noalloc(
*/
int string_list_find_elem(const struct string_list *list, const char *elem)
{
size_t i;
if (!list)
return false;
for (i = 0; i < list->size; i++)
if (list)
{
if (string_is_equal_noncase(list->elems[i].data, elem))
return (int)(i + 1);
size_t i;
for (i = 0; i < list->size; i++)
{
if (string_is_equal_noncase(list->elems[i].data, elem))
return (int)(i + 1);
}
}
return false;
@ -496,16 +483,15 @@ bool string_list_find_elem_prefix(const struct string_list *list,
for (i = 0; i < list->size; i++)
{
if (string_is_equal_noncase(list->elems[i].data, elem) ||
string_is_equal_noncase(list->elems[i].data, prefixed))
if ( string_is_equal_noncase(list->elems[i].data, elem)
|| string_is_equal_noncase(list->elems[i].data, prefixed))
return true;
}
return false;
}
struct string_list *string_list_clone(
const struct string_list *src)
struct string_list *string_list_clone(const struct string_list *src)
{
unsigned i;
struct string_list_elem
@ -519,14 +505,13 @@ struct string_list *string_list_clone(
dest->elems = NULL;
dest->size = src->size;
dest->cap = src->cap;
if (dest->cap < dest->size)
if (src->cap < dest->size)
dest->cap = dest->size;
else
dest->cap = src->cap;
elems = (struct string_list_elem*)
calloc(dest->cap, sizeof(struct string_list_elem));
if (!elems)
if (!(elems = (struct string_list_elem*)
calloc(dest->cap, sizeof(struct string_list_elem))))
{
free(dest);
return NULL;
@ -536,11 +521,11 @@ struct string_list *string_list_clone(
for (i = 0; i < src->size; i++)
{
const char *_src = src->elems[i].data;
size_t len = _src ? strlen(_src) : 0;
const char *_src = src->elems[i].data;
size_t len = _src ? strlen(_src) : 0;
dest->elems[i].data = NULL;
dest->elems[i].attr = src->elems[i].attr;
dest->elems[i].data = NULL;
dest->elems[i].attr = src->elems[i].attr;
if (len != 0)
{

13
libretro-common/queues/task_queue.c
View File

@ -323,17 +323,15 @@ static struct retro_task_impl impl_regular = {
static void task_queue_remove(task_queue_t *queue, retro_task_t *task)
{
retro_task_t *t = NULL;
retro_task_t *front = NULL;
front = queue->front;
retro_task_t *front = queue->front;
/* Remove first element if needed */
if (task == front)
{
queue->front = task->next;
queue->front = task->next;
if (queue->back == task) /* if only element, also update back */
queue->back = NULL;
task->next = NULL;
queue->back = NULL;
task->next = NULL;
return;
}
@ -485,8 +483,7 @@ static void threaded_worker(void *userdata)
slock_lock(running_lock);
/* Get first task to run */
task = tasks_running.front;
if (!task)
if (!(task = tasks_running.front))
{
scond_wait(worker_cond, running_lock);
slock_unlock(running_lock);

97
libretro-common/rthreads/rthreads.c
View File

@ -193,9 +193,11 @@ sthread_t *sthread_create_with_priority(void (*thread_func)(void*), void *userda
if (!thread)
return NULL;
data = (struct thread_data*)malloc(sizeof(*data));
if (!data)
goto error;
if (!(data = (struct thread_data*)malloc(sizeof(*data))))
{
free(thread);
return NULL;
}
data->func = thread_func;
data->userdata = userdata;
@ -242,10 +244,7 @@ sthread_t *sthread_create_with_priority(void (*thread_func)(void*), void *userda
if (thread_created)
return thread;
error:
if (data)
free(data);
free(data);
free(thread);
return NULL;
}
@ -307,14 +306,10 @@ void sthread_join(sthread_t *thread)
*/
bool sthread_isself(sthread_t *thread)
{
/* This thread can't possibly be a null thread */
if (!thread)
return false;
#ifdef USE_WIN32_THREADS
return GetCurrentThreadId() == thread->id;
return thread ? GetCurrentThreadId() == thread->id : false;
#else
return pthread_equal(pthread_self(),thread->id);
return thread ? pthread_equal(pthread_self(), thread->id) : false;
#endif
}
#endif
@ -329,27 +324,19 @@ bool sthread_isself(sthread_t *thread)
**/
slock_t *slock_new(void)
{
bool mutex_created = false;
slock_t *lock = (slock_t*)calloc(1, sizeof(*lock));
if (!lock)
return NULL;
#ifdef USE_WIN32_THREADS
InitializeCriticalSection(&lock->lock);
mutex_created = true;
#else
mutex_created = (pthread_mutex_init(&lock->lock, NULL) == 0);
if (pthread_mutex_init(&lock->lock, NULL) != 0)
{
free(lock);
return NULL;
}
#endif
if (!mutex_created)
goto error;
return lock;
error:
free(lock);
return NULL;
}
/**
@ -399,12 +386,10 @@ void slock_lock(slock_t *lock)
**/
bool slock_try_lock(slock_t *lock)
{
if (!lock)
return false;
#ifdef USE_WIN32_THREADS
return TryEnterCriticalSection(&lock->lock);
return lock && TryEnterCriticalSection(&lock->lock);
#else
return pthread_mutex_trylock(&lock->lock)==0;
return lock && (pthread_mutex_trylock(&lock->lock) == 0);
#endif
}
@ -467,11 +452,9 @@ scond_t *scond_new(void)
*
* Note: We might could simplify this using vista+ condition variables,
* but we wanted an XP compatible solution. */
cond->event = CreateEvent(NULL, FALSE, FALSE, NULL);
if (!cond->event)
if (!(cond->event = CreateEvent(NULL, FALSE, FALSE, NULL)))
goto error;
cond->hot_potato = CreateEvent(NULL, FALSE, FALSE, NULL);
if (!cond->hot_potato)
if (!(cond->hot_potato = CreateEvent(NULL, FALSE, FALSE, NULL)))
{
CloseHandle(cond->event);
goto error;
@ -525,7 +508,6 @@ static bool _scond_wait_win32(scond_t *cond, slock_t *lock, DWORD dwMilliseconds
static bool beginPeriod = false;
DWORD tsBegin;
#endif
DWORD waitResult;
DWORD dwFinalTimeout = dwMilliseconds; /* Careful! in case we begin in the head,
we don't do the hot potato stuff,
@ -545,9 +527,7 @@ static bool _scond_wait_win32(scond_t *cond, slock_t *lock, DWORD dwMilliseconds
}
if (performanceCounterFrequency.QuadPart == 0)
{
QueryPerformanceFrequency(&performanceCounterFrequency);
}
#else
if (!beginPeriod)
{
@ -570,9 +550,9 @@ static bool _scond_wait_win32(scond_t *cond, slock_t *lock, DWORD dwMilliseconds
/* walk to the end of the linked list */
while (*ptr)
ptr = &((*ptr)->next);
ptr = &((*ptr)->next);
*ptr = &myentry;
*ptr = &myentry;
myentry.next = NULL;
cond->waiters++;
@ -746,18 +726,17 @@ void scond_wait(scond_t *cond, slock_t *lock)
int scond_broadcast(scond_t *cond)
{
#ifdef USE_WIN32_THREADS
/* remember: we currently have mutex */
if (cond->waiters == 0)
return 0;
/* awaken everything which is currently queued up */
if (cond->wakens == 0)
SetEvent(cond->event);
cond->wakens = cond->waiters;
/* Since there is now at least one pending waken, the potato must be in play */
SetEvent(cond->hot_potato);
/* Remember, we currently have mutex */
if (cond->waiters != 0)
{
/* Awaken everything which is currently queued up */
if (cond->wakens == 0)
SetEvent(cond->event);
cond->wakens = cond->waiters;
/* Since there is now at least one pending waken, the potato must be in play */
SetEvent(cond->hot_potato);
}
return 0;
#else
return pthread_cond_broadcast(&cond->cond);
@ -830,11 +809,6 @@ bool scond_wait_timeout(scond_t *cond, slock_t *lock, int64_t timeout_us)
* Someone asking for a 0 timeout clearly wants immediate timeout.
* Someone asking for a 1 timeout clearly wants an actual timeout
* of the minimum length */
/* Someone asking for 1000 or 1001 timeout shouldn't
* accidentally get 2ms. */
DWORD dwMilliseconds = timeout_us/1000;
/* The implementation of a 0 timeout here with pthreads is sketchy.
* It isn't clear what happens if pthread_cond_timedwait is called with NOW.
* Moreover, it is possible that this thread gets pre-empted after the
@ -845,9 +819,10 @@ bool scond_wait_timeout(scond_t *cond, slock_t *lock, int64_t timeout_us)
if (timeout_us == 0)
return false;
else if (timeout_us < 1000)
dwMilliseconds = 1;
return _scond_wait_win32(cond,lock,dwMilliseconds);
return _scond_wait_win32(cond, lock, 1);
/* Someone asking for 1000 or 1001 timeout shouldn't
* accidentally get 2ms. */
return _scond_wait_win32(cond, lock, timeout_us / 1000);
#else
int ret;
int64_t seconds, remainder;
@ -944,9 +919,9 @@ bool sthread_tls_set(sthread_tls_t *tls, const void *data)
uintptr_t sthread_get_thread_id(sthread_t *thread)
{
if (!thread)
return 0;
return (uintptr_t)thread->id;
if (thread)
return (uintptr_t)thread->id;
return 0;
}
uintptr_t sthread_get_current_thread_id(void)

55
libretro-common/string/stdstring.c
View File

@ -114,9 +114,8 @@ char *string_replace_substring(const char *in,
}
outlen = strlen(in) - pattern_len*numhits + replacement_len*numhits;
out = (char *)malloc(outlen+1);
if (!out)
if (!(out = (char *)malloc(outlen+1)))
return NULL;
outat = out;
@ -305,9 +304,7 @@ void word_wrap_wideglyph(char *dst, size_t dst_size, const char *src, int line_w
while (*src != '\0')
{
unsigned char_len;
char_len = (unsigned)(utf8skip(src, 1) - src);
unsigned char_len = (unsigned)(utf8skip(src, 1) - src);
counter_normalized += 100;
/* Prevent buffer overflow */
@ -315,7 +312,7 @@ void word_wrap_wideglyph(char *dst, size_t dst_size, const char *src, int line_w
break;
if (*src == ' ')
lastspace = dst; /* Remember the location of the whitespace */
lastspace = dst; /* Remember the location of the whitespace */
else if (*src == '\n')
{
/* If newlines embedded in the input,
@ -419,25 +416,20 @@ char* string_tokenize(char **str, const char *delim)
if (!str || string_is_empty(delim))
return NULL;
str_ptr = *str;
/* Note: we don't check string_is_empty() here,
* empty strings are valid */
if (!str_ptr)
if (!(str_ptr = *str))
return NULL;
/* Search for delimiter */
delim_ptr = strstr(str_ptr, delim);
if (delim_ptr)
if ((delim_ptr = strstr(str_ptr, delim)))
token_len = delim_ptr - str_ptr;
else
token_len = strlen(str_ptr);
/* Allocate token string */
token = (char *)malloc((token_len + 1) * sizeof(char));
if (!token)
if (!(token = (char *)malloc((token_len + 1) * sizeof(char))))
return NULL;
/* Copy token */
@ -475,13 +467,13 @@ void string_remove_all_chars(char *str, char c)
* with character 'replace' */
void string_replace_all_chars(char *str, char find, char replace)
{
char *str_ptr = str;
if (!string_is_empty(str))
{
char *str_ptr = str;
while ((str_ptr = strchr(str_ptr, find)))
*str_ptr++ = replace;
}
if (string_is_empty(str))
return;
while ((str_ptr = strchr(str_ptr, find)))
*str_ptr++ = replace;
}
/* Converts string to unsigned integer.
@ -515,9 +507,7 @@ unsigned string_hex_to_unsigned(const char *str)
return 0;
/* Remove leading '0x', if required */
len = strlen(str);
if (len >= 2)
if ((len = strlen(str)) >= 2)
if ((str[0] == '0') &&
((str[1] == 'x') || (str[1] == 'X')))
hex_str = str + 2;
@ -543,7 +533,8 @@ int string_count_occurrences_single_character(char *str, char t)
int ctr = 0;
int i;
for (i = 0; str[i] != '\0'; ++i) {
for (i = 0; str[i] != '\0'; ++i)
{
if (t == str[i])
++ctr;
}
@ -556,8 +547,8 @@ int string_count_occurrences_single_character(char *str, char t)
*/
void string_replace_whitespace_with_single_character(char *str, char t)
{
while (*str) {
while (*str)
{
if (isspace(*str))
*str = t;
str++;
@ -604,10 +595,9 @@ void string_remove_all_whitespace(char* str_trimmed, const char* str_untrimmed)
*/
int string_index_last_occurance(char *str, char t)
{
const char * ret = strrchr(str, t);
const char *ret = strrchr(str, t);
if (ret)
return ret-str;
return -1;
}
@ -616,16 +606,11 @@ int string_index_last_occurance(char *str, char t)
*/
int string_find_index_substring_string(const char* str1, const char* str2)
{
int index;
if (str1[0] != '\0')
{
const char *pfound = strstr(str1, str2);
if (pfound != NULL)
{
index = (pfound - str1);
return index;
}
if (pfound)
return (pfound - str1);
}
return -1;