mirror of
https://github.com/libretro/RetroArch.git
synced 2024-10-07 14:23:29 +00:00
Change 'rarch' to 'retro' namespace in libretro-common
This commit is contained in:
parent
6ae8af1150
commit
02a43c6b2a
@ -283,7 +283,7 @@ void find_audio_driver(void)
|
||||
driver->audio = (const audio_driver_t*)audio_driver_find_handle(0);
|
||||
|
||||
if (!driver->audio)
|
||||
rarch_fail(1, "find_audio_driver()");
|
||||
retro_fail(1, "find_audio_driver()");
|
||||
}
|
||||
}
|
||||
|
||||
@ -349,7 +349,7 @@ void init_audio(void)
|
||||
settings->slowmotion_ratio;
|
||||
|
||||
/* Used for recording even if audio isn't enabled. */
|
||||
rarch_assert(audio_data.conv_outsamples =
|
||||
retro_assert(audio_data.conv_outsamples =
|
||||
(int16_t*)malloc(outsamples_max * sizeof(int16_t)));
|
||||
|
||||
if (!audio_data.conv_outsamples)
|
||||
@ -361,7 +361,7 @@ void init_audio(void)
|
||||
|
||||
/* Needs to be able to hold full content of a full max_bufsamples
|
||||
* in addition to its own. */
|
||||
rarch_assert(audio_data.rewind_buf = (int16_t*)
|
||||
retro_assert(audio_data.rewind_buf = (int16_t*)
|
||||
malloc(max_bufsamples * sizeof(int16_t)));
|
||||
|
||||
if (!audio_data.rewind_buf)
|
||||
@ -386,7 +386,7 @@ void init_audio(void)
|
||||
driver->audio))
|
||||
{
|
||||
RARCH_ERR("Cannot open threaded audio driver ... Exiting ...\n");
|
||||
rarch_fail(1, "init_audio()");
|
||||
retro_fail(1, "init_audio()");
|
||||
}
|
||||
}
|
||||
else
|
||||
@ -433,7 +433,7 @@ void init_audio(void)
|
||||
driver->audio_active = false;
|
||||
}
|
||||
|
||||
rarch_assert(audio_data.data = (float*)
|
||||
retro_assert(audio_data.data = (float*)
|
||||
malloc(max_bufsamples * sizeof(float)));
|
||||
|
||||
if (!audio_data.data)
|
||||
@ -441,9 +441,9 @@ void init_audio(void)
|
||||
|
||||
audio_data.data_ptr = 0;
|
||||
|
||||
rarch_assert(settings->audio.out_rate <
|
||||
retro_assert(settings->audio.out_rate <
|
||||
audio_data.in_rate * AUDIO_MAX_RATIO);
|
||||
rarch_assert(audio_data.outsamples = (float*)
|
||||
retro_assert(audio_data.outsamples = (float*)
|
||||
malloc(outsamples_max * sizeof(float)));
|
||||
|
||||
if (!audio_data.outsamples)
|
||||
|
@ -288,7 +288,7 @@ void audio_convert_s16_to_float_ALLEGREX(float *out,
|
||||
/* Make sure the buffer is 16 byte aligned, this should be the
|
||||
* default behaviour of malloc in the PSPSDK.
|
||||
* Only the output buffer can be assumed to be 16-byte aligned. */
|
||||
rarch_assert(((uintptr_t)out & 0xf) == 0);
|
||||
retro_assert(((uintptr_t)out & 0xf) == 0);
|
||||
#endif
|
||||
|
||||
size_t i;
|
||||
@ -360,8 +360,8 @@ void audio_convert_float_to_s16_ALLEGREX(int16_t *out,
|
||||
/* Make sure the buffers are 16 byte aligned, this should be
|
||||
* the default behaviour of malloc in the PSPSDK.
|
||||
* Both buffers are allocated by RetroArch, so can assume alignment. */
|
||||
rarch_assert(((uintptr_t)in & 0xf) == 0);
|
||||
rarch_assert(((uintptr_t)out & 0xf) == 0);
|
||||
retro_assert(((uintptr_t)in & 0xf) == 0);
|
||||
retro_assert(((uintptr_t)out & 0xf) == 0);
|
||||
#endif
|
||||
|
||||
for (i = 0; i + 8 <= samples; i += 8)
|
||||
|
@ -137,7 +137,7 @@ void find_camera_driver(void)
|
||||
driver->camera = (const camera_driver_t*)camera_driver_find_handle(0);
|
||||
|
||||
if (!driver->camera)
|
||||
rarch_fail(1, "find_camera_driver()");
|
||||
retro_fail(1, "find_camera_driver()");
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -389,7 +389,7 @@ static bool preprocess_image(void *data)
|
||||
}
|
||||
}
|
||||
|
||||
rarch_assert(buf.index < v4l->n_buffers);
|
||||
retro_assert(buf.index < v4l->n_buffers);
|
||||
|
||||
process_image(v4l, (const uint8_t*)v4l->buffers[buf.index].start);
|
||||
|
||||
|
10
command.c
10
command.c
@ -81,7 +81,7 @@ static bool cmd_init_network(rarch_cmd_t *handle, uint16_t port)
|
||||
|
||||
|
||||
snprintf(port_buf, sizeof(port_buf), "%hu", (unsigned short)port);
|
||||
if (getaddrinfo_rarch(NULL, port_buf, &hints, &res) < 0)
|
||||
if (getaddrinfo_retro(NULL, port_buf, &hints, &res) < 0)
|
||||
goto error;
|
||||
|
||||
handle->net_fd = socket(res->ai_family,
|
||||
@ -100,12 +100,12 @@ static bool cmd_init_network(rarch_cmd_t *handle, uint16_t port)
|
||||
goto error;
|
||||
}
|
||||
|
||||
freeaddrinfo_rarch(res);
|
||||
freeaddrinfo_retro(res);
|
||||
return true;
|
||||
|
||||
error:
|
||||
if (res)
|
||||
freeaddrinfo_rarch(res);
|
||||
freeaddrinfo_retro(res);
|
||||
return false;
|
||||
}
|
||||
#endif
|
||||
@ -560,7 +560,7 @@ static bool send_udp_packet(const char *host,
|
||||
hints.ai_socktype = SOCK_DGRAM;
|
||||
|
||||
snprintf(port_buf, sizeof(port_buf), "%hu", (unsigned short)port);
|
||||
if (getaddrinfo_rarch(host, port_buf, &hints, &res) < 0)
|
||||
if (getaddrinfo_retro(host, port_buf, &hints, &res) < 0)
|
||||
return false;
|
||||
|
||||
/* Send to all possible targets.
|
||||
@ -592,7 +592,7 @@ static bool send_udp_packet(const char *host,
|
||||
}
|
||||
|
||||
end:
|
||||
freeaddrinfo_rarch(res);
|
||||
freeaddrinfo_retro(res);
|
||||
if (fd >= 0)
|
||||
socket_close(fd);
|
||||
return ret;
|
||||
|
@ -179,7 +179,7 @@ static void event_init_movie(void)
|
||||
RARCH_ERR("%s: \"%s\".\n",
|
||||
msg_hash_to_str(MSG_FAILED_TO_LOAD_MOVIE_FILE),
|
||||
global->bsv.movie_start_path);
|
||||
rarch_fail(1, "event_init_movie()");
|
||||
retro_fail(1, "event_init_movie()");
|
||||
}
|
||||
|
||||
global->bsv.movie_playback = true;
|
||||
|
@ -608,8 +608,8 @@ static void config_set_defaults(void)
|
||||
settings->input.max_users = input_max_users;
|
||||
settings->input.menu_toggle_gamepad_combo = menu_toggle_gamepad_combo;
|
||||
|
||||
rarch_assert(sizeof(settings->input.binds[0]) >= sizeof(retro_keybinds_1));
|
||||
rarch_assert(sizeof(settings->input.binds[1]) >= sizeof(retro_keybinds_rest));
|
||||
retro_assert(sizeof(settings->input.binds[0]) >= sizeof(retro_keybinds_1));
|
||||
retro_assert(sizeof(settings->input.binds[1]) >= sizeof(retro_keybinds_rest));
|
||||
|
||||
memcpy(settings->input.binds[0], retro_keybinds_1, sizeof(retro_keybinds_1));
|
||||
|
||||
@ -635,7 +635,7 @@ static void config_set_defaults(void)
|
||||
for (j = 0; j < RARCH_BIND_LIST_END; j++)
|
||||
{
|
||||
if (settings->input.binds[i][j].valid)
|
||||
rarch_assert(j == settings->input.binds[i][j].id);
|
||||
retro_assert(j == settings->input.binds[i][j].id);
|
||||
}
|
||||
|
||||
settings->input.axis_threshold = axis_threshold;
|
||||
@ -2177,7 +2177,8 @@ static void save_keybind_hat(config_file_t *conf, const char *key,
|
||||
break;
|
||||
|
||||
default:
|
||||
rarch_assert(0);
|
||||
retro_assert(0);
|
||||
break;
|
||||
}
|
||||
|
||||
snprintf(config, sizeof(config), "h%u%s", hat, dir);
|
||||
|
@ -441,7 +441,7 @@ static bool load_content_need_fullpath(
|
||||
* The following part takes care of cleanup of the unzipped files
|
||||
* after exit.
|
||||
*/
|
||||
rarch_assert(global->temporary_content != NULL);
|
||||
retro_assert(global->temporary_content != NULL);
|
||||
string_list_append(global->temporary_content,
|
||||
new_path, attributes);
|
||||
|
||||
|
26
deps/stb/stb_truetype.h
vendored
26
deps/stb/stb_truetype.h
vendored
@ -996,7 +996,7 @@ STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codep
|
||||
}
|
||||
else if (format == 2)
|
||||
{
|
||||
rarch_assert(0); /* @TODO: high-byte mapping for japanese/chinese/korean */
|
||||
retro_assert(0); /* @TODO: high-byte mapping for japanese/chinese/korean */
|
||||
return 0;
|
||||
}
|
||||
else if (format == 4)
|
||||
@ -1036,7 +1036,7 @@ STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codep
|
||||
stbtt_uint16 offset, start;
|
||||
stbtt_uint16 item = (stbtt_uint16) ((search - endCount) >> 1);
|
||||
|
||||
rarch_assert(unicode_codepoint <= ttUSHORT(data + endCount + 2*item));
|
||||
retro_assert(unicode_codepoint <= ttUSHORT(data + endCount + 2*item));
|
||||
start = ttUSHORT(data + index_map + 14 + segcount*2 + 2 + 2*item);
|
||||
if (unicode_codepoint < start)
|
||||
return 0;
|
||||
@ -1074,7 +1074,7 @@ STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codep
|
||||
return 0; /* not found */
|
||||
}
|
||||
/* @TODO */
|
||||
rarch_assert(0);
|
||||
retro_assert(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1358,7 +1358,7 @@ STBTT_DEF int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, s
|
||||
else
|
||||
{
|
||||
/* @TODO handle matching point */
|
||||
rarch_assert(0);
|
||||
retro_assert(0);
|
||||
}
|
||||
if (flags & (1<<3))
|
||||
{
|
||||
@ -1431,7 +1431,7 @@ STBTT_DEF int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, s
|
||||
else if (numberOfContours < 0)
|
||||
{
|
||||
/* @TODO other compound variations? */
|
||||
rarch_assert(0);
|
||||
retro_assert(0);
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -1787,7 +1787,7 @@ static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e,
|
||||
stbtt__active_edge * z = *step;
|
||||
if (z->ey <= scan_y) {
|
||||
*step = z->next; // delete from list
|
||||
rarch_assert(z->direction);
|
||||
retro_assert(z->direction);
|
||||
z->direction = 0;
|
||||
stbtt__hheap_free(&hh, z);
|
||||
} else {
|
||||
@ -2099,7 +2099,7 @@ static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e,
|
||||
stbtt__active_edge * z = *step;
|
||||
if (z->ey <= scan_y_top) {
|
||||
*step = z->next; /* delete from list */
|
||||
rarch_assert(z->direction);
|
||||
retro_assert(z->direction);
|
||||
z->direction = 0;
|
||||
stbtt__hheap_free(&hh, z);
|
||||
} else {
|
||||
@ -2584,8 +2584,8 @@ STBTT_DEF int stbtt_BakeFontBitmap(
|
||||
y = bottom_y, x = 1; /* advance to next row */
|
||||
if (y + gh + 1 >= ph) /* check if it fits vertically AFTER potentially moving to next row */
|
||||
return -i;
|
||||
rarch_assert(x+gw < pw);
|
||||
rarch_assert(y+gh < ph);
|
||||
retro_assert(x+gw < pw);
|
||||
retro_assert(y+gh < ph);
|
||||
stbtt_MakeGlyphBitmap(&f, pixels+x+y*pw, gw,gh,pw, scale,scale, g);
|
||||
chardata[i].x0 = (stbtt_int16) x;
|
||||
chardata[i].y0 = (stbtt_int16) y;
|
||||
@ -2748,8 +2748,8 @@ STBTT_DEF void stbtt_PackEnd (stbtt_pack_context *spc)
|
||||
STBTT_DEF void stbtt_PackSetOversampling(stbtt_pack_context *spc,
|
||||
unsigned int h_oversample, unsigned int v_oversample)
|
||||
{
|
||||
rarch_assert(h_oversample <= STBTT_MAX_OVERSAMPLE);
|
||||
rarch_assert(v_oversample <= STBTT_MAX_OVERSAMPLE);
|
||||
retro_assert(h_oversample <= STBTT_MAX_OVERSAMPLE);
|
||||
retro_assert(v_oversample <= STBTT_MAX_OVERSAMPLE);
|
||||
if (h_oversample <= STBTT_MAX_OVERSAMPLE)
|
||||
spc->h_oversample = h_oversample;
|
||||
if (v_oversample <= STBTT_MAX_OVERSAMPLE)
|
||||
@ -2808,7 +2808,7 @@ static void stbtt__h_prefilter(unsigned char *pixels, int w, int h,
|
||||
|
||||
for (; i < w; ++i)
|
||||
{
|
||||
rarch_assert(pixels[i] == 0);
|
||||
retro_assert(pixels[i] == 0);
|
||||
total -= buffer[i & STBTT__OVER_MASK];
|
||||
pixels[i] = (unsigned char) (total / kernel_width);
|
||||
}
|
||||
@ -2869,7 +2869,7 @@ static void stbtt__v_prefilter(unsigned char *pixels, int w, int h, int stride_i
|
||||
|
||||
for (; i < h; ++i)
|
||||
{
|
||||
rarch_assert(pixels[i*stride_in_bytes] == 0);
|
||||
retro_assert(pixels[i*stride_in_bytes] == 0);
|
||||
total -= buffer[i & STBTT__OVER_MASK];
|
||||
pixels[i*stride_in_bytes] = (unsigned char) (total / kernel_width);
|
||||
}
|
||||
|
10
dynamic.c
10
dynamic.c
@ -43,7 +43,7 @@
|
||||
#define SYMBOL(x) do { \
|
||||
function_t func = dylib_proc(lib_handle, #x); \
|
||||
memcpy(&core.x, &func, sizeof(func)); \
|
||||
if (core.x == NULL) { RARCH_ERR("Failed to load symbol: \"%s\"\n", #x); rarch_fail(1, "init_libretro_sym()"); } \
|
||||
if (core.x == NULL) { RARCH_ERR("Failed to load symbol: \"%s\"\n", #x); retro_fail(1, "init_libretro_sym()"); } \
|
||||
} while (0)
|
||||
|
||||
static dylib_t lib_handle;
|
||||
@ -268,13 +268,13 @@ static void load_symbols(enum rarch_core_type type)
|
||||
RARCH_ERR("Serious problem. RetroArch wants to load libretro cores dyamically, but it is already linked.\n");
|
||||
RARCH_ERR("This could happen if other modules RetroArch depends on link against libretro directly.\n");
|
||||
RARCH_ERR("Proceeding could cause a crash. Aborting ...\n");
|
||||
rarch_fail(1, "init_libretro_sym()");
|
||||
retro_fail(1, "init_libretro_sym()");
|
||||
}
|
||||
|
||||
if (!*settings->libretro)
|
||||
{
|
||||
RARCH_ERR("RetroArch is built for dynamic libretro cores, but libretro_path is not set. Cannot continue.\n");
|
||||
rarch_fail(1, "init_libretro_sym()");
|
||||
retro_fail(1, "init_libretro_sym()");
|
||||
}
|
||||
|
||||
/* Need to use absolute path for this setting. It can be
|
||||
@ -291,7 +291,7 @@ static void load_symbols(enum rarch_core_type type)
|
||||
RARCH_ERR("Failed to open libretro core: \"%s\"\n",
|
||||
settings->libretro);
|
||||
RARCH_ERR("Error(s): %s\n", dylib_error());
|
||||
rarch_fail(1, "load_dynamic()");
|
||||
retro_fail(1, "load_dynamic()");
|
||||
}
|
||||
#endif
|
||||
}
|
||||
@ -494,7 +494,7 @@ void init_libretro_sym(enum rarch_core_type type)
|
||||
{
|
||||
/* Guarantee that we can do "dirty" casting.
|
||||
* Every OS that this program supports should pass this. */
|
||||
rarch_assert(sizeof(void*) == sizeof(void (*)(void)));
|
||||
retro_assert(sizeof(void*) == sizeof(void (*)(void)));
|
||||
|
||||
load_symbols(type);
|
||||
}
|
||||
|
@ -638,8 +638,7 @@ int read_compressed_file(const char * path, void **buf,
|
||||
strlcpy(archive_path, path, sizeof(archive_path));
|
||||
|
||||
archive_found = (char*)strchr(archive_path,'#');
|
||||
|
||||
rarch_assert(archive_found != NULL);
|
||||
retro_assert(archive_found != NULL);
|
||||
|
||||
/* We assure that there is something after the '#' symbol. */
|
||||
if (strlen(archive_found) <= 1)
|
||||
|
@ -52,7 +52,7 @@ void fill_pathname_expand_special(char *out_path,
|
||||
if (home)
|
||||
{
|
||||
size_t src_size = strlcpy(out_path, home, size);
|
||||
rarch_assert(src_size < size);
|
||||
retro_assert(src_size < size);
|
||||
|
||||
out_path += src_size;
|
||||
size -= src_size;
|
||||
@ -74,7 +74,7 @@ void fill_pathname_expand_special(char *out_path,
|
||||
path_basedir(application_dir);
|
||||
|
||||
src_size = strlcpy(out_path, application_dir, size);
|
||||
rarch_assert(src_size < size);
|
||||
retro_assert(src_size < size);
|
||||
|
||||
out_path += src_size;
|
||||
size -= src_size;
|
||||
@ -82,7 +82,7 @@ void fill_pathname_expand_special(char *out_path,
|
||||
}
|
||||
#endif
|
||||
|
||||
rarch_assert(strlcpy(out_path, in_path, size) < size);
|
||||
retro_assert(strlcpy(out_path, in_path, size) < size);
|
||||
}
|
||||
|
||||
|
||||
@ -117,16 +117,17 @@ void fill_pathname_abbreviate_special(char *out_path,
|
||||
{
|
||||
if (*candidates[i] && strstr(in_path, candidates[i]) == in_path)
|
||||
{
|
||||
size_t src_size = strlcpy(out_path, notations[i], size);
|
||||
rarch_assert(src_size < size);
|
||||
size_t src_size = strlcpy(out_path, notations[i], size);
|
||||
|
||||
retro_assert(src_size < size);
|
||||
|
||||
out_path += src_size;
|
||||
size -= src_size;
|
||||
in_path += strlen(candidates[i]);
|
||||
out_path += src_size;
|
||||
size -= src_size;
|
||||
in_path += strlen(candidates[i]);
|
||||
|
||||
if (!path_char_is_slash(*in_path))
|
||||
{
|
||||
rarch_assert(strlcpy(out_path, path_default_slash(), size) < size);
|
||||
retro_assert(strlcpy(out_path, path_default_slash(), size) < size);
|
||||
out_path++;
|
||||
size--;
|
||||
}
|
||||
@ -136,7 +137,7 @@ void fill_pathname_abbreviate_special(char *out_path,
|
||||
}
|
||||
#endif
|
||||
|
||||
rarch_assert(strlcpy(out_path, in_path, size) < size);
|
||||
retro_assert(strlcpy(out_path, in_path, size) < size);
|
||||
}
|
||||
|
||||
#if !defined(RARCH_CONSOLE)
|
||||
@ -163,7 +164,7 @@ void fill_pathname_application_path(char *buf, size_t size)
|
||||
CFRelease(bundle_path);
|
||||
CFRelease(bundle_url);
|
||||
|
||||
rarch_assert(strlcat(buf, "nobin", size) < size);
|
||||
retro_assert(strlcat(buf, "nobin", size) < size);
|
||||
return;
|
||||
}
|
||||
#elif defined(__HAIKU__)
|
||||
|
@ -233,7 +233,7 @@ bool main_load_content(int argc, char **argv, void *args,
|
||||
(void)rarch_argv_ptr;
|
||||
(void)ret;
|
||||
|
||||
rarch_assert(wrap_args);
|
||||
retro_assert(wrap_args);
|
||||
|
||||
if (environ_get)
|
||||
environ_get(rarch_argc_ptr, rarch_argv_ptr, args, wrap_args);
|
||||
|
@ -140,13 +140,13 @@ static INLINE float db_to_gain(float db)
|
||||
}
|
||||
|
||||
/**
|
||||
* rarch_fail:
|
||||
* retro_fail:
|
||||
* @error_code : Error code.
|
||||
* @error : Error message to show.
|
||||
*
|
||||
* Sanely kills the program.
|
||||
**/
|
||||
static INLINE void rarch_fail(int error_code, const char *error)
|
||||
static INLINE void retro_fail(int error_code, const char *error)
|
||||
{
|
||||
global_t *global = global_get_ptr();
|
||||
|
||||
@ -156,7 +156,7 @@ static INLINE void rarch_fail(int error_code, const char *error)
|
||||
/* We cannot longjmp unless we're in rarch_main_init().
|
||||
* If not, something went very wrong, and we should
|
||||
* just exit right away. */
|
||||
rarch_assert(global->inited.error);
|
||||
retro_assert(global->inited.error);
|
||||
|
||||
strlcpy(global->error_string, error, sizeof(global->error_string));
|
||||
longjmp(global->error_sjlj_context, error_code);
|
||||
|
@ -644,7 +644,7 @@ static void psp_set_texture_frame(void *data, const void *frame, bool rgb32,
|
||||
|
||||
#ifdef DEBUG
|
||||
/* psp->menu.frame buffer size is (480 * 272)*2 Bytes */
|
||||
rarch_assert((width*height) < (480 * 272));
|
||||
retro_assert((width*height) < (480 * 272));
|
||||
#endif
|
||||
|
||||
psp_set_screen_coords(psp->menu.frame_coords, 0, 0,
|
||||
|
@ -242,6 +242,7 @@ static void sdl_gfx_set_handles(void)
|
||||
static void *sdl_gfx_init(const video_info_t *video, const input_driver_t **input, void **input_data)
|
||||
{
|
||||
unsigned full_x, full_y;
|
||||
const SDL_VideoInfo *video_info = NULL;
|
||||
sdl_video_t *vid = NULL;
|
||||
settings_t *settings = config_get_ptr();
|
||||
|
||||
@ -261,8 +262,8 @@ static void *sdl_gfx_init(const video_info_t *video, const input_driver_t **inpu
|
||||
if (!vid)
|
||||
return NULL;
|
||||
|
||||
const SDL_VideoInfo *video_info = SDL_GetVideoInfo();
|
||||
rarch_assert(video_info);
|
||||
video_info = SDL_GetVideoInfo();
|
||||
retro_assert(video_info);
|
||||
full_x = video_info->current_w;
|
||||
full_y = video_info->current_h;
|
||||
RARCH_LOG("[SDL]: Detecting desktop resolution %ux%u.\n", full_x, full_y);
|
||||
|
@ -291,7 +291,7 @@ static void vg_copy_frame(void *data, const void *frame,
|
||||
bool new_egl = gfx_ctx_image_buffer_write(vg,
|
||||
frame, width, height, pitch, (vg->mTexType == VG_sXRGB_8888), 0, &img);
|
||||
|
||||
rarch_assert(img != EGL_NO_IMAGE_KHR);
|
||||
retro_assert(img != EGL_NO_IMAGE_KHR);
|
||||
|
||||
if (new_egl)
|
||||
{
|
||||
|
@ -320,7 +320,7 @@ static gfx_ctx_proc_t android_gfx_ctx_get_proc_address(
|
||||
gfx_ctx_proc_t ret;
|
||||
void *sym__ = NULL;
|
||||
|
||||
rarch_assert(sizeof(void*) == sizeof(void (*)(void)));
|
||||
retro_assert(sizeof(void*) == sizeof(void (*)(void)));
|
||||
|
||||
sym__ = eglGetProcAddress(symbol);
|
||||
memcpy(&ret, &sym__, sizeof(void*));
|
||||
|
@ -391,7 +391,7 @@ static gfx_ctx_proc_t gfx_ctx_qnx_get_proc_address(const char *symbol)
|
||||
gfx_ctx_proc_t ret;
|
||||
void *sym__;
|
||||
|
||||
rarch_assert(sizeof(void*) == sizeof(void (*)(void)));
|
||||
retro_assert(sizeof(void*) == sizeof(void (*)(void)));
|
||||
|
||||
sym__ = eglGetProcAddress(symbol);
|
||||
memcpy(&ret, &sym__, sizeof(void*));
|
||||
|
@ -286,7 +286,7 @@ static gfx_ctx_proc_t gfx_ctx_mali_fbdev_get_proc_address(const char *symbol)
|
||||
gfx_ctx_proc_t ret;
|
||||
void *sym__ = NULL;
|
||||
|
||||
rarch_assert(sizeof(void*) == sizeof(void (*)(void)));
|
||||
retro_assert(sizeof(void*) == sizeof(void (*)(void)));
|
||||
|
||||
sym__ = eglGetProcAddress(symbol);
|
||||
memcpy(&ret, &sym__, sizeof(void*));
|
||||
|
@ -259,7 +259,7 @@ static gfx_ctx_proc_t gfx_ctx_vivante_get_proc_address(const char *symbol)
|
||||
gfx_ctx_proc_t ret;
|
||||
void *sym__;
|
||||
|
||||
rarch_assert(sizeof(void*) == sizeof(void (*)(void)));
|
||||
retro_assert(sizeof(void*) == sizeof(void (*)(void)));
|
||||
|
||||
sym__ = eglGetProcAddress(symbol);
|
||||
memcpy(&ret, &sym__, sizeof(void*));
|
||||
|
@ -165,7 +165,7 @@ static void gl_cg_reset_attrib(cg_shader_data_t *cg)
|
||||
return;
|
||||
|
||||
/* Add sanity check that we did not overflow. */
|
||||
rarch_assert(cg->cg_attrib_idx <= ARRAY_SIZE(cg->cg_attribs));
|
||||
retro_assert(cg->cg_attrib_idx <= ARRAY_SIZE(cg->cg_attribs));
|
||||
|
||||
for (i = 0; i < cg->cg_attrib_idx; i++)
|
||||
cgGLDisableClientState(cg->cg_attribs[i]);
|
||||
|
@ -490,7 +490,7 @@ static void gl_glsl_reset_attrib(glsl_shader_data_t *glsl)
|
||||
unsigned i;
|
||||
|
||||
/* Add sanity check that we did not overflow. */
|
||||
rarch_assert(glsl->gl_attrib_index <= ARRAY_SIZE(glsl->gl_attribs));
|
||||
retro_assert(glsl->gl_attrib_index <= ARRAY_SIZE(glsl->gl_attribs));
|
||||
|
||||
for (i = 0; i < glsl->gl_attrib_index; i++)
|
||||
glDisableVertexAttribArray(glsl->gl_attribs[i]);
|
||||
@ -507,7 +507,7 @@ static void gl_glsl_set_vbo(GLfloat **buffer, size_t *buffer_elems,
|
||||
{
|
||||
GLfloat *new_buffer = (GLfloat*)
|
||||
realloc(*buffer, elems * sizeof(GLfloat));
|
||||
rarch_assert(new_buffer);
|
||||
retro_assert(new_buffer);
|
||||
*buffer = new_buffer;
|
||||
}
|
||||
|
||||
|
@ -228,7 +228,7 @@ void find_video_driver(void)
|
||||
driver->video = (const video_driver_t*)video_driver_find_handle(0);
|
||||
|
||||
if (!driver->video)
|
||||
rarch_fail(1, "find_video_driver()");
|
||||
retro_fail(1, "find_video_driver()");
|
||||
}
|
||||
}
|
||||
|
||||
@ -409,7 +409,7 @@ static void init_video_input(const input_driver_t *tmp)
|
||||
/* This should never really happen as tmp (driver.input) is always
|
||||
* found before this in find_driver_input(), or we have aborted
|
||||
* in a similar fashion anyways. */
|
||||
rarch_fail(1, "init_video_input()");
|
||||
retro_fail(1, "init_video_input()");
|
||||
}
|
||||
|
||||
driver->input_data = input_driver_init();
|
||||
@ -418,7 +418,7 @@ static void init_video_input(const input_driver_t *tmp)
|
||||
return;
|
||||
|
||||
RARCH_ERR("Cannot initialize input driver. Exiting ...\n");
|
||||
rarch_fail(1, "init_video_input()");
|
||||
retro_fail(1, "init_video_input()");
|
||||
}
|
||||
|
||||
void uninit_video_input(void)
|
||||
@ -472,7 +472,7 @@ void init_video(void)
|
||||
if (!geom)
|
||||
{
|
||||
RARCH_ERR("AV geometry not initialized, cannot initialize video driver.\n");
|
||||
rarch_fail(1, "init_video()");
|
||||
retro_fail(1, "init_video()");
|
||||
}
|
||||
|
||||
max_dim = max(geom->max_width, geom->max_height);
|
||||
@ -532,7 +532,7 @@ void init_video(void)
|
||||
if (!init_video_pixel_converter(RARCH_SCALE_BASE * scale))
|
||||
{
|
||||
RARCH_ERR("Failed to initialize pixel converter.\n");
|
||||
rarch_fail(1, "init_video()");
|
||||
retro_fail(1, "init_video()");
|
||||
}
|
||||
|
||||
video.width = width;
|
||||
@ -565,7 +565,7 @@ void init_video(void)
|
||||
driver->video, &video))
|
||||
{
|
||||
RARCH_ERR("Cannot open threaded video driver ... Exiting ...\n");
|
||||
rarch_fail(1, "init_video()");
|
||||
retro_fail(1, "init_video()");
|
||||
}
|
||||
}
|
||||
else
|
||||
@ -576,7 +576,7 @@ void init_video(void)
|
||||
if (!driver->video_data)
|
||||
{
|
||||
RARCH_ERR("Cannot open video driver ... Exiting ...\n");
|
||||
rarch_fail(1, "init_video()");
|
||||
retro_fail(1, "init_video()");
|
||||
}
|
||||
|
||||
driver->video_poke = NULL;
|
||||
|
@ -165,7 +165,7 @@ void find_input_driver(void)
|
||||
driver->input = (const input_driver_t*)input_driver_find_handle(0);
|
||||
|
||||
if (!driver->input)
|
||||
rarch_fail(1, "find_input_driver()");
|
||||
retro_fail(1, "find_input_driver()");
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -609,7 +609,7 @@ void input_keymaps_translate_rk_to_str(enum retro_key key, char *buf, size_t siz
|
||||
{
|
||||
unsigned i;
|
||||
|
||||
rarch_assert(size >= 2);
|
||||
retro_assert(size >= 2);
|
||||
*buf = '\0';
|
||||
|
||||
if (key >= RETROK_a && key <= RETROK_z)
|
||||
|
@ -164,7 +164,7 @@ static void shuffle_block(char **begin, char **last, char **end)
|
||||
ptrdiff_t len = last - begin;
|
||||
const char **tmp = (const char**)calloc(len, sizeof(const char*));
|
||||
|
||||
rarch_assert(tmp);
|
||||
retro_assert(tmp);
|
||||
|
||||
memcpy(tmp, begin, len * sizeof(const char*));
|
||||
memmove(begin, last, (end - last) * sizeof(const char*));
|
||||
@ -207,7 +207,7 @@ int getopt_long(int argc, char *argv[],
|
||||
long_index = 0;
|
||||
}
|
||||
|
||||
rarch_assert(short_index == 0 || long_index == 0);
|
||||
retro_assert(short_index == 0 || long_index == 0);
|
||||
|
||||
if (short_index == 0)
|
||||
return parse_short(optstring, &argv[optind]);
|
||||
|
@ -39,7 +39,7 @@
|
||||
|
||||
#include <string.h>
|
||||
|
||||
int rarch_strcasecmp__(const char *a, const char *b)
|
||||
int retro_strcasecmp__(const char *a, const char *b)
|
||||
{
|
||||
while (*a && *b)
|
||||
{
|
||||
@ -56,7 +56,7 @@ int rarch_strcasecmp__(const char *a, const char *b)
|
||||
return tolower(*a) - tolower(*b);
|
||||
}
|
||||
|
||||
char *rarch_strdup__(const char *orig)
|
||||
char *retro_strdup__(const char *orig)
|
||||
{
|
||||
size_t len = strlen(orig) + 1;
|
||||
char *ret = (char*)malloc(len);
|
||||
@ -67,12 +67,12 @@ char *rarch_strdup__(const char *orig)
|
||||
return ret;
|
||||
}
|
||||
|
||||
int rarch_isblank__(int c)
|
||||
int retro_isblank__(int c)
|
||||
{
|
||||
return (c == ' ') || (c == '\t');
|
||||
}
|
||||
|
||||
char *rarch_strtok_r__(char *str, const char *delim, char **saveptr)
|
||||
char *retro_strtok_r__(char *str, const char *delim, char **saveptr)
|
||||
{
|
||||
char *first = NULL;
|
||||
if (!saveptr || !delim)
|
||||
|
@ -41,7 +41,7 @@ static int casencmp(const char *a, const char *b, size_t n)
|
||||
return 0;
|
||||
}
|
||||
|
||||
char *strcasestr_rarch__(const char *haystack, const char *needle)
|
||||
char *strcasestr_retro__(const char *haystack, const char *needle)
|
||||
{
|
||||
size_t i, hay_len, needle_len, search_off;
|
||||
|
||||
|
@ -218,13 +218,13 @@ void fill_pathname(char *out_path, const char *in_path,
|
||||
char tmp_path[PATH_MAX_LENGTH] = {0};
|
||||
char *tok = NULL;
|
||||
|
||||
rarch_assert(strlcpy(tmp_path, in_path,
|
||||
retro_assert(strlcpy(tmp_path, in_path,
|
||||
sizeof(tmp_path)) < sizeof(tmp_path));
|
||||
if ((tok = (char*)strrchr(path_basename(tmp_path), '.')))
|
||||
*tok = '\0';
|
||||
|
||||
rarch_assert(strlcpy(out_path, tmp_path, size) < size);
|
||||
rarch_assert(strlcat(out_path, replace, size) < size);
|
||||
retro_assert(strlcpy(out_path, tmp_path, size) < size);
|
||||
retro_assert(strlcat(out_path, replace, size) < size);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -244,8 +244,8 @@ void fill_pathname(char *out_path, const char *in_path,
|
||||
void fill_pathname_noext(char *out_path, const char *in_path,
|
||||
const char *replace, size_t size)
|
||||
{
|
||||
rarch_assert(strlcpy(out_path, in_path, size) < size);
|
||||
rarch_assert(strlcat(out_path, replace, size) < size);
|
||||
retro_assert(strlcpy(out_path, in_path, size) < size);
|
||||
retro_assert(strlcat(out_path, replace, size) < size);
|
||||
}
|
||||
|
||||
static char *find_last_slash(const char *str)
|
||||
@ -279,10 +279,10 @@ void fill_pathname_slash(char *path, size_t size)
|
||||
{
|
||||
char join_str[2];
|
||||
strlcpy(join_str, last_slash, sizeof(join_str));
|
||||
rarch_assert(strlcat(path, join_str, size) < size);
|
||||
retro_assert(strlcat(path, join_str, size) < size);
|
||||
}
|
||||
else if (!last_slash)
|
||||
rarch_assert(strlcat(path, path_default_slash(), size) < size);
|
||||
retro_assert(strlcat(path, path_default_slash(), size) < size);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -309,8 +309,8 @@ void fill_pathname_dir(char *in_dir, const char *in_basename,
|
||||
|
||||
fill_pathname_slash(in_dir, size);
|
||||
base = path_basename(in_basename);
|
||||
rarch_assert(strlcat(in_dir, base, size) < size);
|
||||
rarch_assert(strlcat(in_dir, replace, size) < size);
|
||||
retro_assert(strlcat(in_dir, base, size) < size);
|
||||
retro_assert(strlcat(in_dir, replace, size) < size);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -348,7 +348,7 @@ void fill_pathname_base(char *out, const char *in_path, size_t size)
|
||||
ptr = ptr_bak;
|
||||
#endif
|
||||
|
||||
rarch_assert(strlcpy(out, ptr, size) < size);
|
||||
retro_assert(strlcpy(out, ptr, size) < size);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -364,7 +364,7 @@ void fill_pathname_base(char *out, const char *in_path, size_t size)
|
||||
void fill_pathname_basedir(char *out_dir,
|
||||
const char *in_path, size_t size)
|
||||
{
|
||||
rarch_assert(strlcpy(out_dir, in_path, size) < size);
|
||||
retro_assert(strlcpy(out_dir, in_path, size) < size);
|
||||
path_basedir(out_dir);
|
||||
}
|
||||
|
||||
@ -380,7 +380,7 @@ void fill_pathname_basedir(char *out_dir,
|
||||
void fill_pathname_parent_dir(char *out_dir,
|
||||
const char *in_dir, size_t size)
|
||||
{
|
||||
rarch_assert(strlcpy(out_dir, in_dir, size) < size);
|
||||
retro_assert(strlcpy(out_dir, in_dir, size) < size);
|
||||
path_parent_dir(out_dir);
|
||||
}
|
||||
|
||||
@ -518,7 +518,7 @@ void path_resolve_realpath(char *buf, size_t size)
|
||||
if (!_fullpath(buf, tmp, size))
|
||||
strlcpy(buf, tmp, size);
|
||||
#else
|
||||
rarch_assert(size >= PATH_MAX_LENGTH);
|
||||
retro_assert(size >= PATH_MAX_LENGTH);
|
||||
|
||||
/* NOTE: realpath() expects at least PATH_MAX_LENGTH bytes in buf.
|
||||
* Technically, PATH_MAX_LENGTH needn't be defined, but we rely on it anyways.
|
||||
@ -547,13 +547,13 @@ void fill_pathname_resolve_relative(char *out_path,
|
||||
{
|
||||
if (path_is_absolute(in_path))
|
||||
{
|
||||
rarch_assert(strlcpy(out_path, in_path, size) < size);
|
||||
retro_assert(strlcpy(out_path, in_path, size) < size);
|
||||
return;
|
||||
}
|
||||
|
||||
rarch_assert(strlcpy(out_path, in_refpath, size) < size);
|
||||
retro_assert(strlcpy(out_path, in_refpath, size) < size);
|
||||
path_basedir(out_path);
|
||||
rarch_assert(strlcat(out_path, in_path, size) < size);
|
||||
retro_assert(strlcat(out_path, in_path, size) < size);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -570,12 +570,12 @@ void fill_pathname_resolve_relative(char *out_path,
|
||||
void fill_pathname_join(char *out_path,
|
||||
const char *dir, const char *path, size_t size)
|
||||
{
|
||||
rarch_assert(strlcpy(out_path, dir, size) < size);
|
||||
retro_assert(strlcpy(out_path, dir, size) < size);
|
||||
|
||||
if (*out_path)
|
||||
fill_pathname_slash(out_path, size);
|
||||
|
||||
rarch_assert(strlcat(out_path, path, size) < size);
|
||||
retro_assert(strlcat(out_path, path, size) < size);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -593,12 +593,12 @@ void fill_pathname_join_delim(char *out_path, const char *dir,
|
||||
const char *path, const char delim, size_t size)
|
||||
{
|
||||
size_t copied = strlcpy(out_path, dir, size);
|
||||
rarch_assert(copied < size+1);
|
||||
retro_assert(copied < size+1);
|
||||
|
||||
out_path[copied] = delim;
|
||||
out_path[copied+1] = '\0';
|
||||
|
||||
rarch_assert(strlcat(out_path, path, size) < size);
|
||||
retro_assert(strlcat(out_path, path, size) < size);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -635,7 +635,7 @@ void fill_short_pathname_representation(char* out_rep,
|
||||
* We check whether something is actually
|
||||
* after the hash to avoid going over the buffer.
|
||||
*/
|
||||
rarch_assert(strlen(last_hash) > 1);
|
||||
retro_assert(strlen(last_hash) > 1);
|
||||
strlcpy(out_rep, last_hash + 1, size);
|
||||
}
|
||||
else
|
||||
|
@ -36,7 +36,7 @@
|
||||
#else
|
||||
/* Avoid possible naming collisions during link since we
|
||||
* prefer to use the actual name. */
|
||||
#define getopt_long(argc, argv, optstring, longopts, longindex) __getopt_long_rarch(argc, argv, optstring, longopts, longindex)
|
||||
#define getopt_long(argc, argv, optstring, longopts, longindex) __getopt_long_retro(argc, argv, optstring, longopts, longindex)
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
|
@ -33,7 +33,7 @@ extern "C" {
|
||||
|
||||
#ifdef _WIN32
|
||||
#undef strtok_r
|
||||
#define strtok_r(str, delim, saveptr) rarch_strtok_r__(str, delim, saveptr)
|
||||
#define strtok_r(str, delim, saveptr) retro_strtok_r__(str, delim, saveptr)
|
||||
|
||||
char *strtok_r(char *str, const char *delim, char **saveptr);
|
||||
#endif
|
||||
@ -42,9 +42,9 @@ char *strtok_r(char *str, const char *delim, char **saveptr);
|
||||
#undef strcasecmp
|
||||
#undef strdup
|
||||
#undef isblank
|
||||
#define strcasecmp(a, b) rarch_strcasecmp__(a, b)
|
||||
#define strdup(orig) rarch_strdup__(orig)
|
||||
#define isblank(c) rarch_isblank__(c)
|
||||
#define strcasecmp(a, b) retro_strcasecmp__(a, b)
|
||||
#define strdup(orig) retro_strdup__(orig)
|
||||
#define isblank(c) retro_isblank__(c)
|
||||
int strcasecmp(const char *a, const char *b);
|
||||
char *strdup(const char *orig);
|
||||
int isblank(int c);
|
||||
|
@ -36,7 +36,7 @@ extern "C" {
|
||||
|
||||
/* Avoid possible naming collisions during link
|
||||
* since we prefer to use the actual name. */
|
||||
#define strcasestr(haystack, needle) strcasestr_rarch__(haystack, needle)
|
||||
#define strcasestr(haystack, needle) strcasestr_retro__(haystack, needle)
|
||||
|
||||
char *strcasestr(const char *haystack, const char *needle);
|
||||
|
||||
|
@ -41,9 +41,9 @@ extern "C" {
|
||||
#ifndef HAVE_STRL
|
||||
/* Avoid possible naming collisions during link since
|
||||
* we prefer to use the actual name. */
|
||||
#define strlcpy(dst, src, size) strlcpy_rarch__(dst, src, size)
|
||||
#define strlcpy(dst, src, size) strlcpy_retro__(dst, src, size)
|
||||
|
||||
#define strlcat(dst, src, size) strlcat_rarch__(dst, src, size)
|
||||
#define strlcat(dst, src, size) strlcat_retro__(dst, src, size)
|
||||
|
||||
size_t strlcpy(char *dest, const char *source, size_t size);
|
||||
size_t strlcat(char *dest, const char *source, size_t size);
|
||||
|
@ -183,7 +183,7 @@ static INLINE bool isagain(int bytes)
|
||||
#ifdef HAVE_SOCKET_LEGACY
|
||||
|
||||
#define sockaddr_storage sockaddr_in
|
||||
#define addrinfo addrinfo_rarch__
|
||||
#define addrinfo addrinfo_retro__
|
||||
|
||||
struct addrinfo
|
||||
{
|
||||
@ -205,11 +205,11 @@ struct addrinfo
|
||||
|
||||
#endif
|
||||
|
||||
int getaddrinfo_rarch(const char *node, const char *service,
|
||||
int getaddrinfo_retro(const char *node, const char *service,
|
||||
const struct addrinfo *hints,
|
||||
struct addrinfo **res);
|
||||
|
||||
void freeaddrinfo_rarch(struct addrinfo *res);
|
||||
void freeaddrinfo_retro(struct addrinfo *res);
|
||||
|
||||
bool socket_nonblock(int fd);
|
||||
|
||||
|
@ -30,11 +30,11 @@
|
||||
#endif
|
||||
|
||||
#ifdef RARCH_INTERNAL
|
||||
#define rarch_assert(cond) do { \
|
||||
#define retro_assert(cond) do { \
|
||||
if (!(cond)) { RARCH_ERR("Assertion failed at %s:%d.\n", __FILE__, __LINE__); abort(); } \
|
||||
} while(0)
|
||||
#else
|
||||
#define rarch_assert(cond) assert(cond)
|
||||
#define retro_assert(cond) assert(cond)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
@ -47,9 +47,9 @@
|
||||
extern "C"
|
||||
#endif
|
||||
|
||||
FILE *rarch_main_log_file(void);
|
||||
FILE *retro_main_log_file(void);
|
||||
|
||||
#define LOG_FILE (rarch_main_log_file())
|
||||
#define LOG_FILE (retro_main_log_file())
|
||||
|
||||
#else
|
||||
#define LOG_FILE (stderr)
|
||||
@ -70,13 +70,13 @@ FILE *rarch_main_log_file(void);
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
bool rarch_main_verbosity(void);
|
||||
bool retro_main_verbosity(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#define RARCH_LOG_VERBOSE (rarch_main_verbosity())
|
||||
#define RARCH_LOG_VERBOSE (retro_main_verbosity())
|
||||
#else
|
||||
#define RARCH_LOG_VERBOSE (true)
|
||||
#endif
|
||||
|
@ -142,7 +142,7 @@ static INLINE uint32_t prev_pow2(uint32_t v)
|
||||
typedef struct
|
||||
{
|
||||
uint32_t data[8];
|
||||
} rarch_bits_t;
|
||||
} retro_bits_t;
|
||||
|
||||
#define BIT_SET(a, bit) ((a)[(bit) >> 3] |= (1 << ((bit) & 7)))
|
||||
#define BIT_CLEAR(a, bit) ((a)[(bit) >> 3] &= ~(1 << ((bit) & 7)))
|
||||
|
@ -86,11 +86,11 @@ struct hostent *gethostbyname(const char *name)
|
||||
return &ent;
|
||||
}
|
||||
|
||||
int rarch_epoll_fd;
|
||||
int retro_epoll_fd;
|
||||
|
||||
#endif
|
||||
|
||||
int getaddrinfo_rarch(const char *node, const char *service,
|
||||
int getaddrinfo_retro(const char *node, const char *service,
|
||||
const struct addrinfo *hints,
|
||||
struct addrinfo **res)
|
||||
{
|
||||
@ -144,7 +144,7 @@ error:
|
||||
#endif
|
||||
}
|
||||
|
||||
void freeaddrinfo_rarch(struct addrinfo *res)
|
||||
void freeaddrinfo_retro(struct addrinfo *res)
|
||||
{
|
||||
#ifdef HAVE_SOCKET_LEGACY
|
||||
free(res->ai_addr);
|
||||
@ -193,10 +193,10 @@ int socket_select(int nfds, fd_set *readfs, fd_set *writefds,
|
||||
ev.events = PSP2_NET_EPOLLIN | PSP2_NET_EPOLLHUP;
|
||||
ev.data.fd = nfds;
|
||||
|
||||
if((sceNetEpollControl(rarch_epoll_fd, PSP2_NET_EPOLL_CTL_ADD, nfds, &ev)))
|
||||
if((sceNetEpollControl(retro_epoll_fd, PSP2_NET_EPOLL_CTL_ADD, nfds, &ev)))
|
||||
{
|
||||
int ret = sceNetEpollWait(rarch_epoll_fd, &ev, 1, 0);
|
||||
sceNetEpollControl(rarch_epoll_fd, PSP2_NET_EPOLL_CTL_DEL, nfds, NULL);
|
||||
int ret = sceNetEpollWait(retro_epoll_fd, &ev, 1, 0);
|
||||
sceNetEpollControl(retro_epoll_fd, PSP2_NET_EPOLL_CTL_DEL, nfds, NULL);
|
||||
return ret;
|
||||
}
|
||||
return 0;
|
||||
@ -286,8 +286,8 @@ bool network_init(void)
|
||||
//printf("Net is already initialized.\n");
|
||||
}
|
||||
|
||||
rarch_epoll_fd = sceNetEpollCreate("epoll", 0);
|
||||
//printf("Epoll %x\n",rarch_epoll_fd);
|
||||
retro_epoll_fd = sceNetEpollCreate("epoll", 0);
|
||||
//printf("Epoll %x\n",retro_epoll_fd);
|
||||
#else
|
||||
signal(SIGPIPE, SIG_IGN); /* Do not like SIGPIPE killing our app. */
|
||||
#endif
|
||||
|
@ -82,7 +82,7 @@ static int net_http_new_socket(const char *domain, int port)
|
||||
hints.ai_socktype = SOCK_STREAM;
|
||||
hints.ai_flags = 0;
|
||||
|
||||
if (getaddrinfo_rarch(domain, portstr, &hints, &addr) < 0)
|
||||
if (getaddrinfo_retro(domain, portstr, &hints, &addr) < 0)
|
||||
return -1;
|
||||
if (!addr)
|
||||
return -1;
|
||||
@ -98,12 +98,12 @@ static int net_http_new_socket(const char *domain, int port)
|
||||
#endif
|
||||
if (connect(fd, addr->ai_addr, addr->ai_addrlen) != 0)
|
||||
{
|
||||
freeaddrinfo_rarch(addr);
|
||||
freeaddrinfo_retro(addr);
|
||||
socket_close(fd);
|
||||
return -1;
|
||||
}
|
||||
|
||||
freeaddrinfo_rarch(addr);
|
||||
freeaddrinfo_retro(addr);
|
||||
|
||||
if (!socket_nonblock(fd))
|
||||
{
|
||||
|
@ -60,7 +60,7 @@ void string_list_free(struct string_list *list)
|
||||
static bool string_list_capacity(struct string_list *list, size_t cap)
|
||||
{
|
||||
struct string_list_elem *new_data = NULL;
|
||||
rarch_assert(cap > list->size);
|
||||
retro_assert(cap > list->size);
|
||||
|
||||
new_data = (struct string_list_elem*)
|
||||
realloc(list->elems, cap * sizeof(*new_data));
|
||||
@ -142,7 +142,7 @@ void string_list_set(struct string_list *list,
|
||||
unsigned idx, const char *str)
|
||||
{
|
||||
free(list->elems[idx].data);
|
||||
rarch_assert(list->elems[idx].data = strdup(str));
|
||||
retro_assert(list->elems[idx].data = strdup(str));
|
||||
}
|
||||
|
||||
/**
|
||||
@ -160,9 +160,9 @@ void string_list_join_concat(char *buffer, size_t size,
|
||||
{
|
||||
size_t i, len = strlen(buffer);
|
||||
|
||||
rarch_assert(len < size);
|
||||
retro_assert(len < size);
|
||||
buffer += len;
|
||||
size -= len;
|
||||
size -= len;
|
||||
|
||||
for (i = 0; i < list->size; i++)
|
||||
{
|
||||
|
@ -130,7 +130,7 @@ void find_location_driver(void)
|
||||
driver->location = (const location_driver_t*)location_driver_find_handle(0);
|
||||
|
||||
if (!driver->location)
|
||||
rarch_fail(1, "find_location_driver()");
|
||||
retro_fail(1, "find_location_driver()");
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -897,7 +897,7 @@ static int action_ok_core_deferred_set(const char *path,
|
||||
if (!menu_navigation_ctl(MENU_NAVIGATION_CTL_GET_SELECTION, &selection))
|
||||
return -1;
|
||||
|
||||
rarch_assert(menu->playlist != NULL);
|
||||
retro_assert(menu->playlist != NULL);
|
||||
|
||||
core_info_get_name(path, core_display_name, sizeof(core_display_name));
|
||||
|
||||
|
@ -105,7 +105,7 @@ bool menu_display_init(void)
|
||||
if (!disp)
|
||||
return false;
|
||||
|
||||
rarch_assert(disp->msg_queue = msg_queue_new(8));
|
||||
retro_assert(disp->msg_queue = msg_queue_new(8));
|
||||
|
||||
return true;
|
||||
}
|
||||
|
@ -137,7 +137,7 @@ void find_menu_driver(void)
|
||||
driver->menu_ctx = (const menu_ctx_driver_t*)menu_driver_find_handle(0);
|
||||
|
||||
if (!driver->menu_ctx)
|
||||
rarch_fail(1, "find_menu_driver()");
|
||||
retro_fail(1, "find_menu_driver()");
|
||||
}
|
||||
}
|
||||
|
||||
@ -200,11 +200,11 @@ void init_menu(void)
|
||||
}
|
||||
|
||||
if (!(driver->menu = (menu_handle_t*)menu_init(driver->menu_ctx)))
|
||||
rarch_fail(1, "init_menu()");
|
||||
retro_fail(1, "init_menu()");
|
||||
|
||||
if (driver->menu_ctx->lists_init)
|
||||
if (!driver->menu_ctx->lists_init(driver->menu))
|
||||
rarch_fail(1, "init_menu()");
|
||||
retro_fail(1, "init_menu()");
|
||||
}
|
||||
|
||||
|
||||
|
12
netplay.c
12
netplay.c
@ -709,7 +709,7 @@ static bool init_tcp_socket(netplay_t *netplay, const char *server,
|
||||
hints.ai_flags = AI_PASSIVE;
|
||||
|
||||
snprintf(port_buf, sizeof(port_buf), "%hu", (unsigned short)port);
|
||||
if (getaddrinfo_rarch(server, port_buf, &hints, &res) < 0)
|
||||
if (getaddrinfo_retro(server, port_buf, &hints, &res) < 0)
|
||||
return false;
|
||||
|
||||
if (!res)
|
||||
@ -735,7 +735,7 @@ static bool init_tcp_socket(netplay_t *netplay, const char *server,
|
||||
}
|
||||
|
||||
if (res)
|
||||
freeaddrinfo_rarch(res);
|
||||
freeaddrinfo_retro(res);
|
||||
|
||||
if (!ret)
|
||||
RARCH_ERR("Failed to set up netplay sockets.\n");
|
||||
@ -761,7 +761,7 @@ static bool init_udp_socket(netplay_t *netplay, const char *server,
|
||||
|
||||
snprintf(port_buf, sizeof(port_buf), "%hu", (unsigned short)port);
|
||||
|
||||
if (getaddrinfo_rarch(server, port_buf, &hints, &netplay->addr) < 0)
|
||||
if (getaddrinfo_retro(server, port_buf, &hints, &netplay->addr) < 0)
|
||||
return false;
|
||||
|
||||
if (!netplay->addr)
|
||||
@ -792,7 +792,7 @@ static bool init_udp_socket(netplay_t *netplay, const char *server,
|
||||
netplay->udp_fd = -1;
|
||||
}
|
||||
|
||||
freeaddrinfo_rarch(netplay->addr);
|
||||
freeaddrinfo_retro(netplay->addr);
|
||||
netplay->addr = NULL;
|
||||
}
|
||||
|
||||
@ -1340,7 +1340,7 @@ void netplay_free(netplay_t *netplay)
|
||||
}
|
||||
|
||||
if (netplay->addr)
|
||||
freeaddrinfo_rarch(netplay->addr);
|
||||
freeaddrinfo_retro(netplay->addr);
|
||||
|
||||
free(netplay);
|
||||
}
|
||||
@ -1711,7 +1711,7 @@ bool init_netplay(void)
|
||||
#include <ctype.h>
|
||||
#include <string.h>
|
||||
|
||||
#define addrinfo addrinfo_rarch__
|
||||
#define addrinfo addrinfo_retro__
|
||||
|
||||
#ifdef _XBOX
|
||||
/* TODO - implement h_length and h_addrtype */
|
||||
|
@ -133,7 +133,7 @@ void find_record_driver(void)
|
||||
driver->recording = (const record_driver_t*)record_driver_find_handle(0);
|
||||
|
||||
if (!driver->recording)
|
||||
rarch_fail(1, "find_record_driver()");
|
||||
retro_fail(1, "find_record_driver()");
|
||||
}
|
||||
}
|
||||
|
||||
|
26
retroarch.c
26
retroarch.c
@ -284,7 +284,7 @@ static void set_special_paths(char **argv, unsigned num_content)
|
||||
set_basename(argv[0]);
|
||||
|
||||
global->subsystem_fullpaths = string_list_new();
|
||||
rarch_assert(global->subsystem_fullpaths);
|
||||
retro_assert(global->subsystem_fullpaths);
|
||||
|
||||
attr.i = 0;
|
||||
|
||||
@ -637,7 +637,7 @@ static void parse_input(int argc, char *argv[])
|
||||
{
|
||||
RARCH_ERR("Connect device to a valid port.\n");
|
||||
print_help(argv[0]);
|
||||
rarch_fail(1, "parse_input()");
|
||||
retro_fail(1, "parse_input()");
|
||||
}
|
||||
settings->input.libretro_device[port - 1] = id;
|
||||
global->has_set.libretro_device[port - 1] = true;
|
||||
@ -650,7 +650,7 @@ static void parse_input(int argc, char *argv[])
|
||||
{
|
||||
RARCH_ERR("Connect dualanalog to a valid port.\n");
|
||||
print_help(argv[0]);
|
||||
rarch_fail(1, "parse_input()");
|
||||
retro_fail(1, "parse_input()");
|
||||
}
|
||||
settings->input.libretro_device[port - 1] = RETRO_DEVICE_ANALOG;
|
||||
global->has_set.libretro_device[port - 1] = true;
|
||||
@ -683,7 +683,7 @@ static void parse_input(int argc, char *argv[])
|
||||
{
|
||||
RARCH_ERR("Disconnect device from a valid port.\n");
|
||||
print_help(argv[0]);
|
||||
rarch_fail(1, "parse_input()");
|
||||
retro_fail(1, "parse_input()");
|
||||
}
|
||||
settings->input.libretro_device[port - 1] = RETRO_DEVICE_NONE;
|
||||
global->has_set.libretro_device[port - 1] = true;
|
||||
@ -741,7 +741,7 @@ static void parse_input(int argc, char *argv[])
|
||||
{
|
||||
RARCH_ERR("Invalid argument in --sram-mode.\n");
|
||||
print_help(argv[0]);
|
||||
rarch_fail(1, "parse_input()");
|
||||
retro_fail(1, "parse_input()");
|
||||
}
|
||||
break;
|
||||
|
||||
@ -823,7 +823,7 @@ static void parse_input(int argc, char *argv[])
|
||||
if (network_cmd_send(optarg))
|
||||
exit(0);
|
||||
else
|
||||
rarch_fail(1, "network_cmd_send()");
|
||||
retro_fail(1, "network_cmd_send()");
|
||||
break;
|
||||
#endif
|
||||
|
||||
@ -839,7 +839,7 @@ static void parse_input(int argc, char *argv[])
|
||||
{
|
||||
RARCH_ERR("Wrong format for --size.\n");
|
||||
print_help(argv[0]);
|
||||
rarch_fail(1, "parse_input()");
|
||||
retro_fail(1, "parse_input()");
|
||||
}
|
||||
break;
|
||||
}
|
||||
@ -880,11 +880,11 @@ static void parse_input(int argc, char *argv[])
|
||||
|
||||
case '?':
|
||||
print_help(argv[0]);
|
||||
rarch_fail(1, "parse_input()");
|
||||
retro_fail(1, "parse_input()");
|
||||
|
||||
default:
|
||||
RARCH_ERR("Error parsing arguments.\n");
|
||||
rarch_fail(1, "parse_input()");
|
||||
retro_fail(1, "parse_input()");
|
||||
}
|
||||
}
|
||||
|
||||
@ -893,7 +893,7 @@ static void parse_input(int argc, char *argv[])
|
||||
if (optind < argc)
|
||||
{
|
||||
RARCH_ERR("--menu was used, but content file was passed as well.\n");
|
||||
rarch_fail(1, "parse_input()");
|
||||
retro_fail(1, "parse_input()");
|
||||
}
|
||||
}
|
||||
else if (!*global->subsystem && optind < argc)
|
||||
@ -924,7 +924,7 @@ static void rarch_init_savefile_paths(void)
|
||||
event_command(EVENT_CMD_SAVEFILES_DEINIT);
|
||||
|
||||
global->savefiles = string_list_new();
|
||||
rarch_assert(global->savefiles);
|
||||
retro_assert(global->savefiles);
|
||||
|
||||
if (*global->subsystem)
|
||||
{
|
||||
@ -1301,7 +1301,7 @@ void rarch_main_init_wrap(const struct rarch_main_wrap *args,
|
||||
|
||||
#define FAIL_CPU(simd_type) do { \
|
||||
RARCH_ERR(simd_type " code is compiled in, but CPU does not support this feature. Cannot continue.\n"); \
|
||||
rarch_fail(1, "validate_cpu_features()"); \
|
||||
retro_fail(1, "validate_cpu_features()"); \
|
||||
} while(0)
|
||||
|
||||
bool rarch_ctl(enum rarch_ctl_state state, void *data)
|
||||
@ -1571,7 +1571,7 @@ int rarch_defer_core(core_info_list_t *core_info, const char *dir,
|
||||
{
|
||||
/* In case of a compressed archive, we have to join with a hash */
|
||||
/* We are going to write at the position of dir: */
|
||||
rarch_assert(strlen(dir) < strlen(s));
|
||||
retro_assert(strlen(dir) < strlen(s));
|
||||
s[strlen(dir)] = '#';
|
||||
}
|
||||
#endif
|
||||
|
@ -730,7 +730,7 @@ static void rarch_main_iterate_linefeed_overlay(driver_t *driver,
|
||||
}
|
||||
#endif
|
||||
|
||||
bool rarch_main_verbosity(void)
|
||||
bool retro_main_verbosity(void)
|
||||
{
|
||||
global_t *global = global_get_ptr();
|
||||
if (!global)
|
||||
@ -738,7 +738,7 @@ bool rarch_main_verbosity(void)
|
||||
return global->verbosity;
|
||||
}
|
||||
|
||||
FILE *rarch_main_log_file(void)
|
||||
FILE *retro_main_log_file(void)
|
||||
{
|
||||
global_t *global = global_get_ptr();
|
||||
if (!global)
|
||||
|
@ -347,7 +347,7 @@ void rarch_main_msg_queue_init(void);
|
||||
|
||||
bool rarch_main_verbosity(void);
|
||||
|
||||
FILE *rarch_main_log_file(void);
|
||||
FILE *retro_main_log_file(void);
|
||||
|
||||
bool rarch_main_ctl(enum rarch_main_ctl_state state, void *data);
|
||||
|
||||
|
@ -114,10 +114,10 @@ void rarch_main_msg_queue_init(void)
|
||||
return;
|
||||
|
||||
g_msg_queue = msg_queue_new(8);
|
||||
rarch_assert(g_msg_queue);
|
||||
retro_assert(g_msg_queue);
|
||||
|
||||
#ifdef HAVE_THREADS
|
||||
mq_lock = slock_new();
|
||||
rarch_assert(mq_lock);
|
||||
retro_assert(mq_lock);
|
||||
#endif
|
||||
}
|
||||
|
@ -606,7 +606,7 @@ void rarch_main_data_db_init_msg_queue(void)
|
||||
return;
|
||||
|
||||
if (!db->msg_queue)
|
||||
rarch_assert(db->msg_queue = msg_queue_new(8));
|
||||
retro_assert(db->msg_queue = msg_queue_new(8));
|
||||
}
|
||||
|
||||
msg_queue_t *rarch_main_data_db_get_msg_queue_ptr(void)
|
||||
|
@ -645,9 +645,9 @@ void rarch_main_data_nbio_init_msg_queue(void)
|
||||
return;
|
||||
|
||||
if (!nbio->msg_queue)
|
||||
rarch_assert(nbio->msg_queue = msg_queue_new(8));
|
||||
retro_assert(nbio->msg_queue = msg_queue_new(8));
|
||||
if (!nbio->image.msg_queue)
|
||||
rarch_assert(nbio->image.msg_queue = msg_queue_new(8));
|
||||
retro_assert(nbio->image.msg_queue = msg_queue_new(8));
|
||||
}
|
||||
|
||||
void rarch_main_data_nbio_uninit(void)
|
||||
|
@ -468,7 +468,7 @@ void rarch_main_data_http_init_msg_queue(void)
|
||||
return;
|
||||
|
||||
if (!http->msg_queue)
|
||||
rarch_assert(http->msg_queue = msg_queue_new(8));
|
||||
retro_assert(http->msg_queue = msg_queue_new(8));
|
||||
}
|
||||
|
||||
|
||||
|
@ -47,7 +47,7 @@ static char *g_auto_path = NULL;
|
||||
static char *g_driver = NULL;
|
||||
static unsigned g_meta_level = 0;
|
||||
|
||||
bool rarch_main_verbosity(void)
|
||||
bool retro_main_verbosity(void)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
Loading…
Reference in New Issue
Block a user