libretro/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch.git synced 2024-10-07 06:13:22 +00:00
Code Issues Actions 24 Packages Projects Releases Wiki Activity

Remove core_info_ctl

Browse Source
This commit is contained in:
twinaphex 2016-05-09 18:11:17 +02:00
parent 7ca75d46f8
commit 7ba97e8703
15 changed files with 409 additions and 406 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
command_event.c
View File

@ -1026,7 +1026,7 @@ bool event_cmd_ctl(enum event_command cmd, void *data)
#endif
info_find.path = settings->path.libretro;
if (!core_info_ctl(CORE_INFO_CTL_LOAD, &info_find))
if (!core_info_load(&info_find))
return false;
}
#endif
@ -1302,13 +1302,13 @@ bool event_cmd_ctl(enum event_command cmd, void *data)
settings->content_history_size);
break;
case EVENT_CMD_CORE_INFO_DEINIT:
core_info_ctl(CORE_INFO_CTL_LIST_DEINIT, NULL);
core_info_deinit_list();
break;
case EVENT_CMD_CORE_INFO_INIT:
event_cmd_ctl(EVENT_CMD_CORE_INFO_DEINIT, NULL);
if (*settings->directory.libretro)
core_info_ctl(CORE_INFO_CTL_LIST_INIT, NULL);
core_info_init_list();
break;
case EVENT_CMD_CORE_DEINIT:
{

733
core_info.c
View File

@ -31,8 +31,10 @@
#include "config.h"
#endif
static const char *core_info_tmp_path = NULL;
static const char *core_info_tmp_path = NULL;
static const struct string_list *core_info_tmp_list = NULL;
static core_info_t *core_info_current = NULL;
static core_info_list_t *core_info_curr_list = NULL;
static void core_info_list_resolve_all_extensions(
core_info_list_t *core_info_list)
@ -188,57 +190,6 @@ static config_file_t *core_info_list_iterate(
return config_file_new(info_path);
}
void core_info_get_name(const char *path, char *s, size_t len)
{
size_t i;
core_info_t *core_info = NULL;
core_info_list_t *core_info_list = NULL;
struct string_list *contents = dir_list_new_special(
NULL, DIR_LIST_CORES, NULL);
if (!contents)
return;
core_info_list = (core_info_list_t*)calloc(1, sizeof(*core_info_list));
if (!core_info_list)
goto error;
core_info = (core_info_t*)calloc(contents->size, sizeof(*core_info));
if (!core_info)
goto error;
core_info_list->list = core_info;
core_info_list->count = contents->size;
for (i = 0; i < contents->size; i++)
{
config_file_t *conf = NULL;
if (!string_is_equal(contents->elems[i].data, path))
continue;
conf = core_info_list_iterate(contents, i);
if (conf)
{
config_get_string(conf, "corename",
&core_info[i].core_name);
core_info[i].config_data = (void*)conf;
}
core_info[i].path = strdup(contents->elems[i].data);
strlcpy(s, core_info[i].core_name, len);
}
error:
if (contents)
dir_list_free(contents);
contents = NULL;
core_info_list_free(core_info_list);
}
static core_info_list_t *core_info_list_new(void)
{
size_t i;
@ -346,6 +297,370 @@ error:
return NULL;
}
/* Shallow-copies internal state.
*
* Data in *info is invalidated when the
* core_info_list is freed. */
static bool core_info_list_get_info(core_info_list_t *core_info_list,
core_info_t *out_info, const char *path)
{
size_t i;
if (!core_info_list || !out_info)
return false;
memset(out_info, 0, sizeof(*out_info));
for (i = 0; i < core_info_list->count; i++)
{
const core_info_t *info = &core_info_list->list[i];
if (string_is_equal(path_basename(info->path),
path_basename(path)))
{
*out_info = *info;
return true;
}
}
return false;
}
static bool core_info_does_support_any_file(const core_info_t *core,
const struct string_list *list)
{
size_t i;
if (!list || !core || !core->supported_extensions_list)
return false;
for (i = 0; i < list->size; i++)
if (string_list_find_elem_prefix(core->supported_extensions_list,
".", path_get_extension(list->elems[i].data)))
return true;
return false;
}
static bool core_info_does_support_file(
const core_info_t *core, const char *path)
{
if (!path || !core || !core->supported_extensions_list)
return false;
return string_list_find_elem_prefix(
core->supported_extensions_list, ".", path_get_extension(path));
}
/* qsort_r() is not in standard C, sadly. */
static int core_info_qsort_cmp(const void *a_, const void *b_)
{
const core_info_t *a = (const core_info_t*)a_;
const core_info_t *b = (const core_info_t*)b_;
int support_a =
core_info_does_support_any_file(a, core_info_tmp_list)
|| core_info_does_support_file(a, core_info_tmp_path);
int support_b =
core_info_does_support_any_file(b, core_info_tmp_list)
|| core_info_does_support_file(b, core_info_tmp_path);
if (support_a != support_b)
return support_b - support_a;
return strcasecmp(a->display_name, b->display_name);
}
static core_info_t *core_info_find_internal(
core_info_list_t *list,
const char *core)
{
size_t i;
for (i = 0; i < list->count; i++)
{
core_info_t *info = core_info_get(list, i);
if (!info)
continue;
if (string_is_equal(info->path, core))
return info;
}
return NULL;
}
static bool core_info_list_update_missing_firmware_internal(
core_info_list_t *core_info_list,
const char *core,
const char *systemdir)
{
size_t i;
char path[PATH_MAX_LENGTH] = {0};
core_info_t *info = NULL;
if (!core_info_list || !core)
return false;
info = core_info_find_internal(core_info_list, core);
if (!info)
return false;
for (i = 0; i < info->firmware_count; i++)
{
if (!info->firmware[i].path)
continue;
fill_pathname_join(path, systemdir,
info->firmware[i].path, sizeof(path));
info->firmware[i].missing = !path_file_exists(path);
}
return true;
}
#if 0
static int core_info_firmware_cmp(const void *a_, const void *b_)
{
const core_info_firmware_t *a = (const core_info_firmware_t*)a_;
const core_info_firmware_t *b = (const core_info_firmware_t*)b_;
int order = b->missing - a->missing;
if (order)
return order;
return strcasecmp(a->path, b->path);
}
/* Non-reentrant, does not allocate. Returns pointer to internal state. */
static void core_info_list_get_missing_firmware(
core_info_list_t *core_info_list,
const char *core, const char *systemdir,
const core_info_firmware_t **firmware, size_t *num_firmware)
{
size_t i;
char path[PATH_MAX_LENGTH] = {0};
core_info_t *info = NULL;
if (!core_info_list || !core)
return;
*firmware = NULL;
*num_firmware = 0;
if (!(info = core_info_find_internal(core_info_list, core)))
return;
*firmware = info->firmware;
for (i = 1; i < info->firmware_count; i++)
{
fill_pathname_join(path, systemdir,
info->firmware[i].path, sizeof(path));
info->firmware[i].missing = !path_file_exists(path);
*num_firmware += info->firmware[i].missing;
}
qsort(info->firmware, info->firmware_count, sizeof(*info->firmware),
core_info_firmware_cmp);
}
#endif
void core_info_free_current_core(void)
{
if (core_info_current)
free(core_info_current);
core_info_current = NULL;
}
bool core_info_init_current_core(void)
{
core_info_current = (core_info_t*)calloc(1, sizeof(core_info_t));
if (!core_info_current)
return false;
return true;
}
bool core_info_get_current_core(core_info_t **core)
{
if (!core)
return false;
*core = core_info_current;
return true;
}
void core_info_deinit_list(void)
{
if (core_info_curr_list)
core_info_list_free(core_info_curr_list);
core_info_curr_list = NULL;
}
bool core_info_init_list(void)
{
core_info_curr_list = core_info_list_new();
if (!core_info_curr_list)
return false;
return true;
}
bool core_info_get_list(core_info_list_t **core)
{
if (!core)
return false;
*core = core_info_curr_list;
return true;
}
bool core_info_list_update_missing_firmware(core_info_ctx_firmware_t *info)
{
if (!info)
return false;
return core_info_list_update_missing_firmware_internal(
core_info_curr_list,
info->path, info->directory.system);
}
bool core_info_load(core_info_ctx_find_t *info)
{
core_info_t *core_info = NULL;
if (!info)
return false;
core_info_get_current_core(&core_info);
if (!core_info_curr_list)
return false;
if (!core_info_list_get_info(core_info_curr_list,
core_info, info->path))
return false;
return true;
}
bool core_info_find(core_info_ctx_find_t *info)
{
if (!info || !core_info_curr_list)
return false;
info->inf = core_info_find_internal(core_info_curr_list, info->path);
if (!info->inf)
return false;
return true;
}
core_info_t *core_info_get(core_info_list_t *list, size_t i)
{
core_info_t *info = NULL;
if (!list)
return NULL;
info = (core_info_t*)&list->list[i];
if (!info || !info->path)
return NULL;
return info;
}
void core_info_list_get_supported_cores(core_info_list_t *core_info_list,
const char *path, const core_info_t **infos, size_t *num_infos)
{
#ifdef HAVE_ZLIB
struct string_list *list = NULL;
#endif
size_t supported = 0, i;
if (!core_info_list)
return;
core_info_tmp_path = path;
#ifdef HAVE_ZLIB
if (string_is_equal_noncase(path_get_extension(path), "zip"))
list = file_archive_get_file_list(path, NULL);
core_info_tmp_list = list;
#endif
/* Let supported core come first in list so we can return
* a pointer to them. */
qsort(core_info_list->list, core_info_list->count,
sizeof(core_info_t), core_info_qsort_cmp);
for (i = 0; i < core_info_list->count; i++, supported++)
{
const core_info_t *core = &core_info_list->list[i];
if (!core)
continue;
if (core_info_does_support_file(core, path))
continue;
#ifdef HAVE_ZLIB
if (core_info_does_support_any_file(core, list))
continue;
#endif
break;
}
#ifdef HAVE_ZLIB
if (list)
string_list_free(list);
#endif
*infos = core_info_list->list;
*num_infos = supported;
}
void core_info_get_name(const char *path, char *s, size_t len)
{
size_t i;
core_info_t *core_info = NULL;
core_info_list_t *core_info_list = NULL;
struct string_list *contents = dir_list_new_special(
NULL, DIR_LIST_CORES, NULL);
if (!contents)
return;
core_info_list = (core_info_list_t*)calloc(1, sizeof(*core_info_list));
if (!core_info_list)
goto error;
core_info = (core_info_t*)calloc(contents->size, sizeof(*core_info));
if (!core_info)
goto error;
core_info_list->list = core_info;
core_info_list->count = contents->size;
for (i = 0; i < contents->size; i++)
{
config_file_t *conf = NULL;
if (!string_is_equal(contents->elems[i].data, path))
continue;
conf = core_info_list_iterate(contents, i);
if (conf)
{
config_get_string(conf, "corename",
&core_info[i].core_name);
core_info[i].config_data = (void*)conf;
}
core_info[i].path = strdup(contents->elems[i].data);
strlcpy(s, core_info[i].core_name, len);
}
error:
if (contents)
dir_list_free(contents);
contents = NULL;
core_info_list_free(core_info_list);
}
size_t core_info_list_num_info_files(core_info_list_t *core_info_list)
{
@ -425,317 +740,3 @@ error:
free(core_name);
return false;
}
/* Shallow-copies internal state.
*
* Data in *info is invalidated when the
* core_info_list is freed. */
static bool core_info_list_get_info(core_info_list_t *core_info_list,
core_info_t *out_info, const char *path)
{
size_t i;
if (!core_info_list || !out_info)
return false;
memset(out_info, 0, sizeof(*out_info));
for (i = 0; i < core_info_list->count; i++)
{
const core_info_t *info = &core_info_list->list[i];
if (string_is_equal(path_basename(info->path),
path_basename(path)))
{
*out_info = *info;
return true;
}
}
return false;
}
static bool core_info_does_support_any_file(const core_info_t *core,
const struct string_list *list)
{
size_t i;
if (!list || !core || !core->supported_extensions_list)
return false;
for (i = 0; i < list->size; i++)
if (string_list_find_elem_prefix(core->supported_extensions_list,
".", path_get_extension(list->elems[i].data)))
return true;
return false;
}
static bool core_info_does_support_file(
const core_info_t *core, const char *path)
{
if (!path || !core || !core->supported_extensions_list)
return false;
return string_list_find_elem_prefix(
core->supported_extensions_list, ".", path_get_extension(path));
}
/* qsort_r() is not in standard C, sadly. */
static int core_info_qsort_cmp(const void *a_, const void *b_)
{
const core_info_t *a = (const core_info_t*)a_;
const core_info_t *b = (const core_info_t*)b_;
int support_a =
core_info_does_support_any_file(a, core_info_tmp_list)
|| core_info_does_support_file(a, core_info_tmp_path);
int support_b =
core_info_does_support_any_file(b, core_info_tmp_list)
|| core_info_does_support_file(b, core_info_tmp_path);
if (support_a != support_b)
return support_b - support_a;
return strcasecmp(a->display_name, b->display_name);
}
void core_info_list_get_supported_cores(core_info_list_t *core_info_list,
const char *path, const core_info_t **infos, size_t *num_infos)
{
#ifdef HAVE_ZLIB
struct string_list *list = NULL;
#endif
size_t supported = 0, i;
if (!core_info_list)
return;
core_info_tmp_path = path;
#ifdef HAVE_ZLIB
if (string_is_equal_noncase(path_get_extension(path), "zip"))
list = file_archive_get_file_list(path, NULL);
core_info_tmp_list = list;
#endif
/* Let supported core come first in list so we can return
* a pointer to them. */
qsort(core_info_list->list, core_info_list->count,
sizeof(core_info_t), core_info_qsort_cmp);
for (i = 0; i < core_info_list->count; i++, supported++)
{
const core_info_t *core = &core_info_list->list[i];
if (!core)
continue;
if (core_info_does_support_file(core, path))
continue;
#ifdef HAVE_ZLIB
if (core_info_does_support_any_file(core, list))
continue;
#endif
break;
}
#ifdef HAVE_ZLIB
if (list)
string_list_free(list);
#endif
*infos = core_info_list->list;
*num_infos = supported;
}
core_info_t *core_info_get(core_info_list_t *list, size_t i)
{
core_info_t *info = NULL;
if (!list)
return NULL;
info = (core_info_t*)&list->list[i];
if (!info || !info->path)
return NULL;
return info;
}
static core_info_t *core_info_find(core_info_list_t *list,
const char *core)
{
size_t i;
for (i = 0; i < list->count; i++)
{
core_info_t *info = core_info_get(list, i);
if (!info)
continue;
if (string_is_equal(info->path, core))
return info;
}
return NULL;
}
static bool core_info_list_update_missing_firmware(
core_info_list_t *core_info_list,
const char *core, const char *systemdir)
{
size_t i;
char path[PATH_MAX_LENGTH] = {0};
core_info_t *info = NULL;
if (!core_info_list || !core)
return false;
info = core_info_find(core_info_list, core);
if (!info)
return false;
for (i = 0; i < info->firmware_count; i++)
{
if (!info->firmware[i].path)
continue;
fill_pathname_join(path, systemdir,
info->firmware[i].path, sizeof(path));
info->firmware[i].missing = !path_file_exists(path);
}
return true;
}
#if 0
static int core_info_firmware_cmp(const void *a_, const void *b_)
{
const core_info_firmware_t *a = (const core_info_firmware_t*)a_;
const core_info_firmware_t *b = (const core_info_firmware_t*)b_;
int order = b->missing - a->missing;
if (order)
return order;
return strcasecmp(a->path, b->path);
}
/* Non-reentrant, does not allocate. Returns pointer to internal state. */
static void core_info_list_get_missing_firmware(
core_info_list_t *core_info_list,
const char *core, const char *systemdir,
const core_info_firmware_t **firmware, size_t *num_firmware)
{
size_t i;
char path[PATH_MAX_LENGTH] = {0};
core_info_t *info = NULL;
if (!core_info_list || !core)
return;
*firmware = NULL;
*num_firmware = 0;
if (!(info = core_info_find(core_info_list, core)))
return;
*firmware = info->firmware;
for (i = 1; i < info->firmware_count; i++)
{
fill_pathname_join(path, systemdir,
info->firmware[i].path, sizeof(path));
info->firmware[i].missing = !path_file_exists(path);
*num_firmware += info->firmware[i].missing;
}
qsort(info->firmware, info->firmware_count, sizeof(*info->firmware),
core_info_firmware_cmp);
}
#endif
bool core_info_ctl(enum core_info_state state, void *data)
{
static core_info_t *core_info_current = NULL;
static core_info_list_t *core_info_curr_list = NULL;
switch (state)
{
case CORE_INFO_CTL_CURRENT_CORE_FREE:
if (core_info_current)
free(core_info_current);
core_info_current = NULL;
break;
case CORE_INFO_CTL_CURRENT_CORE_INIT:
core_info_current = (core_info_t*)calloc(1, sizeof(core_info_t));
if (!core_info_current)
return false;
break;
case CORE_INFO_CTL_CURRENT_CORE_GET:
{
core_info_t **core = (core_info_t**)data;
if (!core)
return false;
*core = core_info_current;
}
break;
case CORE_INFO_CTL_LIST_DEINIT:
if (core_info_curr_list)
core_info_list_free(core_info_curr_list);
core_info_curr_list = NULL;
break;
case CORE_INFO_CTL_LIST_INIT:
core_info_curr_list = core_info_list_new();
break;
case CORE_INFO_CTL_LIST_GET:
{
core_info_list_t **core = (core_info_list_t**)data;
if (!core)
return false;
*core = core_info_curr_list;
}
break;
case CORE_INFO_CTL_LIST_UPDATE_MISSING_FIRMWARE:
{
core_info_ctx_firmware_t *info = (core_info_ctx_firmware_t*)data;
if (!info)
return false;
return core_info_list_update_missing_firmware(core_info_curr_list,
info->path, info->directory.system);
}
case CORE_INFO_CTL_FIND:
{
core_info_ctx_find_t *info = (core_info_ctx_find_t*)data;
if (!info || !core_info_curr_list)
return false;
info->inf = core_info_find(core_info_curr_list, info->path);
if (!info->inf)
return false;
}
break;
case CORE_INFO_CTL_LOAD:
{
core_info_t *core_info = NULL;
core_info_ctx_find_t *info = (core_info_ctx_find_t*)data;
if (!info)
return false;
core_info_ctl(CORE_INFO_CTL_CURRENT_CORE_GET, &core_info);
if (!core_info_curr_list)
return false;
if (!core_info_list_get_info(core_info_curr_list,
core_info, info->path))
return false;
}
break;
case CORE_INFO_CTL_NONE:
default:
break;
}
return true;
}

32
core_info.h
View File

@ -26,20 +26,6 @@
extern "C" {
#endif
enum core_info_state
{
CORE_INFO_CTL_NONE = 0,
CORE_INFO_CTL_LIST_DEINIT,
CORE_INFO_CTL_LIST_INIT,
CORE_INFO_CTL_LIST_GET,
CORE_INFO_CTL_LIST_UPDATE_MISSING_FIRMWARE,
CORE_INFO_CTL_CURRENT_CORE_FREE,
CORE_INFO_CTL_CURRENT_CORE_INIT,
CORE_INFO_CTL_CURRENT_CORE_GET,
CORE_INFO_CTL_LOAD,
CORE_INFO_CTL_FIND
};
typedef struct
{
char *path;
@ -116,7 +102,23 @@ void core_info_get_name(const char *path, char *s, size_t len);
core_info_t *core_info_get(core_info_list_t *list, size_t i);
bool core_info_ctl(enum core_info_state action, void *data);
void core_info_free_current_core(void);
bool core_info_init_current_core(void);
bool core_info_get_current_core(core_info_t **core);
void core_info_deinit_list(void);
bool core_info_init_list(void);
bool core_info_get_list(core_info_list_t **core);
bool core_info_list_update_missing_firmware(core_info_ctx_firmware_t *info);
bool core_info_find(core_info_ctx_find_t *info);
bool core_info_load(core_info_ctx_find_t *info);
#ifdef __cplusplus
}

6
list_special.c
View File

@ -73,7 +73,7 @@ struct string_list *dir_list_new_special(const char *input_dir,
case DIR_LIST_CORE_INFO:
{
core_info_list_t *list = NULL;
core_info_ctl(CORE_INFO_CTL_LIST_GET, &list);
core_info_get_list(&list);
dir = input_dir;
exts = list->all_ext;
@ -225,7 +225,7 @@ struct string_list *string_list_new_special(enum string_list_type type,
}
break;
case STRING_LIST_SUPPORTED_CORES_PATHS:
core_info_ctl(CORE_INFO_CTL_LIST_GET, &core_info_list);
core_info_get_list(&core_info_list);
core_info_list_get_supported_cores(core_info_list,
(const char*)data, &core_info, list_size);
@ -247,7 +247,7 @@ struct string_list *string_list_new_special(enum string_list_type type,
}
break;
case STRING_LIST_SUPPORTED_CORES_NAMES:
core_info_ctl(CORE_INFO_CTL_LIST_GET, &core_info_list);
core_info_get_list(&core_info_list);
core_info_list_get_supported_cores(core_info_list,
(const char*)data, &core_info, list_size);

2
menu/cbs/menu_cbs_deferred_push.c
View File

@ -342,7 +342,7 @@ static int general_push(menu_displaylist_info_t *info,
if (!menu_driver_ctl(RARCH_MENU_CTL_DRIVER_DATA_GET, &menu))
return menu_cbs_exit();
core_info_ctl(CORE_INFO_CTL_LIST_GET, &list);
core_info_get_list(&list);
menu_driver_ctl(RARCH_MENU_CTL_SYSTEM_INFO_GET, &system_menu);
runloop_ctl(RUNLOOP_CTL_SYSTEM_INFO_GET, &system);

2
menu/cbs/menu_cbs_get_value.c
View File

@ -1245,7 +1245,7 @@ static void menu_action_setting_disp_set_label(file_list_t* list,
char buf[PATH_MAX_LENGTH];
core_info_list_t *list = NULL;
core_info_ctl(CORE_INFO_CTL_LIST_GET, &list);
core_info_get_list(&list);
if (core_info_list_get_display_name(list, s, buf, sizeof(buf)))
strlcpy(s, buf, len);

2
menu/cbs/menu_cbs_left.c
View File

@ -317,7 +317,7 @@ static int playlist_association_left(unsigned type, const char *label,
const char *path = path_basename(label);
core_info_list_t *list = NULL;
core_info_ctl(CORE_INFO_CTL_LIST_GET, &list);
core_info_get_list(&list);
if (!list)
return menu_cbs_exit();

6
menu/cbs/menu_cbs_ok.c
View File

@ -482,7 +482,7 @@ static int file_load_with_detect_core_wrapper(size_t idx, size_t entry_idx,
fill_pathname_join(menu_path_new, menu->scratch2_buf, menu->scratch_buf,
sizeof(menu_path_new));
core_info_ctl(CORE_INFO_CTL_LIST_GET, &list);
core_info_get_list(&list);
def_info.data = list;
def_info.dir = menu_path_new;
@ -641,7 +641,7 @@ static int action_ok_playlist_entry(const char *path,
core_info.inf = NULL;
core_info.path = new_core_path;
if (!core_info_ctl(CORE_INFO_CTL_FIND, &core_info))
if (!core_info_find(&core_info))
found_associated_core = false;
if (!found_associated_core)
@ -2135,7 +2135,7 @@ static int action_ok_load_archive_detect_core(const char *path,
menu_path = menu->scratch2_buf;
content_path = menu->scratch_buf;
core_info_ctl(CORE_INFO_CTL_LIST_GET, &list);
core_info_get_list(&list);
def_info.data = list;
def_info.dir = menu_path;

2
menu/cbs/menu_cbs_right.c
View File

@ -339,7 +339,7 @@ static int playlist_association_right(unsigned type, const char *label,
const char *path = path_basename(label);
core_info_list_t *list = NULL;
core_info_ctl(CORE_INFO_CTL_LIST_GET, &list);
core_info_get_list(&list);
if (!list)
return menu_cbs_exit();

2
menu/cbs/menu_cbs_start.c
View File

@ -274,7 +274,7 @@ static int action_start_playlist_association(unsigned type, const char *label)
settings_t *settings = config_get_ptr();
const char *path = path_basename(label);
core_info_ctl(CORE_INFO_CTL_LIST_GET, &list);
core_info_get_list(&list);
if (!list)
return -1;

2
menu/drivers/materialui.c
View File

@ -1373,7 +1373,7 @@ static int mui_list_push(void *data, void *userdata,
menu_hash_to_str(MENU_LABEL_LOAD_CONTENT),
MENU_SETTING_ACTION, 0, 0);
core_info_ctl(CORE_INFO_CTL_LIST_GET, &list);
core_info_get_list(&list);
if (core_info_list_num_info_files(list))
{
menu_entries_add(info->list,

4
menu/drivers/zarch.c
View File

@ -604,7 +604,7 @@ static int zarch_zui_render_lay_root_load(zui_t *zui,
if (!zui->load_dlist)
{
core_info_t *core_info = NULL;
core_info_ctl(CORE_INFO_CTL_CURRENT_CORE_GET, &core_info);
core_info_get_current_core(&core_info);
zui->load_dlist = dir_list_new(zui->load_cwd,
core_info->supported_extensions, true, true);
@ -686,7 +686,7 @@ static int zarch_zui_render_lay_root_load(zui_t *zui,
strlcpy(zui->pick_content,
path, sizeof(zui->pick_content));
core_info_ctl(CORE_INFO_CTL_LIST_GET, &list);
core_info_get_list(&list);
core_info_list_get_supported_cores(list, path,
&zui->pick_cores, &zui->pick_supported);

2
menu/menu_content.c
View File

@ -259,7 +259,7 @@ static bool menu_content_find_first_core(void *data)
* going to use the current core to load this. */
if (menu_label_hash == MENU_LABEL_LOAD_CONTENT)
{
core_info_ctl(CORE_INFO_CTL_CURRENT_CORE_GET, (void*)&info);
core_info_get_current_core((void*)&info);
if (info)
{
RARCH_LOG("Use the current core (%s) to load this content...\n",

8
menu/menu_displaylist.c
View File

@ -286,7 +286,7 @@ static int menu_displaylist_parse_core_info(menu_displaylist_info_t *info)
settings_t *settings = config_get_ptr();
core_info_t *core_info = NULL;
core_info_ctl(CORE_INFO_CTL_CURRENT_CORE_GET, &core_info);
core_info_get_current_core(&core_info);
if (!core_info || !core_info->config_data)
{
@ -401,7 +401,7 @@ static int menu_displaylist_parse_core_info(menu_displaylist_info_t *info)
firmware_info.path = core_info->path;
firmware_info.directory.system = settings->directory.system;
if (core_info_ctl(CORE_INFO_CTL_LIST_UPDATE_MISSING_FIRMWARE, &firmware_info))
if (core_info_list_update_missing_firmware(&firmware_info))
{
strlcpy(tmp, menu_hash_to_str(MENU_LABEL_VALUE_CORE_INFO_FIRMWARE),
sizeof(tmp));
@ -2589,7 +2589,7 @@ static int menu_displaylist_parse_generic(
settings_t *settings = config_get_ptr();
uint32_t hash_label = menu_hash_calculate(info->label);
core_info_ctl(CORE_INFO_CTL_LIST_GET, &list);
core_info_get_list(&list);
if (!*info->path)
{
@ -3115,7 +3115,7 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type, void *data)
settings = config_get_ptr();
core_info_ctl(CORE_INFO_CTL_LIST_GET, &list);
core_info_get_list(&list);
disp_list.info = info;
disp_list.type = type;

6
menu/menu_driver.c
View File

@ -148,7 +148,7 @@ static bool menu_init(menu_handle_t *menu_data)
if (!menu_entries_ctl(MENU_ENTRIES_CTL_INIT, NULL))
return false;
if (!core_info_ctl(CORE_INFO_CTL_CURRENT_CORE_INIT, NULL))
if (!core_info_init_current_core())
return false;
if (!menu_driver_ctl(RARCH_MENU_CTL_SHADER_INIT, NULL))
@ -567,8 +567,8 @@ bool menu_driver_ctl(enum rarch_menu_ctl_state state, void *data)
event_cmd_ctl(EVENT_CMD_HISTORY_DEINIT, NULL);
core_info_ctl(CORE_INFO_CTL_LIST_DEINIT, NULL);
core_info_ctl(CORE_INFO_CTL_CURRENT_CORE_FREE, NULL);
core_info_deinit_list();
core_info_free_current_core();
free(menu_driver_data);
}