自学教程：C++ string_is_equal函数代码示例

static int iso_get_serial(database_state_handle_t *db_state,                          database_info_handle_t *db, const char *name, char* serial){    int32_t offset          = 0;    const char* system_name = NULL;    int                 rv  = detect_system(name, offset, &system_name);    if (rv < 0)        return rv;    if (string_is_equal(system_name, "psp"))    {        if (detect_psp_game(name, serial) == 0)            return 0;        RARCH_LOG("%s '%s'/n", msg_hash_to_str(MSG_FOUND_DISK_LABEL), serial);    }    else if (string_is_equal(system_name, "ps1"))    {        if (detect_ps1_game(name, serial) == 0)            return 0;        RARCH_LOG("%s '%s'/n", msg_hash_to_str(MSG_FOUND_DISK_LABEL), serial);    }    return 0;}

static int iso_get_serial(database_state_handle_t *db_state,      database_info_handle_t *db, const char *name, char* serial){   int rv;   int32_t offset = 0;   const char* system_name = NULL;   if ((rv = detect_system(name, offset, &system_name)) < 0)      return rv;   if (string_is_equal(system_name, "psp"))   {      if (detect_psp_game(name, serial) == 0)         return 0;      RARCH_LOG("Found disk label '%s'/n", serial);   }   else if (string_is_equal(system_name, "ps1"))   {      if (detect_ps1_game(name, serial) == 0)         return 0;      RARCH_LOG("Found disk label '%s'/n", serial);   }   return 0;}

static bool menu_display_check_compatibility(      enum menu_display_driver_type type){   const char *video_driver = menu_video_get_ident();   switch (type)   {      case MENU_VIDEO_DRIVER_GENERIC:         return true;      case MENU_VIDEO_DRIVER_OPENGL:         if (string_is_equal(video_driver, "gl"))            return true;         break;      case MENU_VIDEO_DRIVER_VULKAN:         if (string_is_equal(video_driver, "vulkan"))            return true;         break;      case MENU_VIDEO_DRIVER_DIRECT3D:         if (string_is_equal(video_driver, "d3d"))            return true;         break;   }   return false;}

/* Registry callbacks. */static void registry_handle_global(void *data, struct wl_registry *reg,      uint32_t id, const char *interface, uint32_t version){   struct wl_output *output   = NULL;   gfx_ctx_wayland_data_t *wl = (gfx_ctx_wayland_data_t*)data;   (void)version;   if (string_is_equal(interface, "wl_compositor"))      wl->compositor = (struct wl_compositor*)wl_registry_bind(reg,            id, &wl_compositor_interface, 3);   else if (string_is_equal(interface, "wl_output"))   {      output = (struct wl_output*)wl_registry_bind(reg,            id, &wl_output_interface, 2);      wl_output_add_listener(output, &output_listener, wl);      wl_display_roundtrip(wl->input.dpy);   }   else if (string_is_equal(interface, "wl_shell"))      wl->shell = (struct wl_shell*)         wl_registry_bind(reg, id, &wl_shell_interface, 1);   else if (string_is_equal(interface, "wl_shm"))      wl->shm = (struct wl_shm*)wl_registry_bind(reg, id, &wl_shm_interface, 1);   else if (string_is_equal(interface, "wl_seat"))   {      wl->seat = (struct wl_seat*)wl_registry_bind(reg, id, &wl_seat_interface, 4);      wl_seat_add_listener(wl->seat, &seat_listener, wl);   }}

static void menu_action_setting_disp_set_label_playlist_associations(file_list_t* list,      unsigned *w, unsigned type, unsigned i,      const char *label,      char *s, size_t len,      const char *entry_label,      const char *path,      char *s2, size_t len2){   char playlist_name_with_ext[255];   bool found_matching_core_association         = false;   settings_t         *settings                 = config_get_ptr();   struct string_list *str_list                 = string_split(settings->arrays.playlist_names, ";");   struct string_list *str_list2                = string_split(settings->arrays.playlist_cores, ";");   strlcpy(s2, path, len2);   playlist_name_with_ext[0] = '/0';   *s = '/0';   *w = 19;   fill_pathname_noext(playlist_name_with_ext, path,         file_path_str(FILE_PATH_LPL_EXTENSION),         sizeof(playlist_name_with_ext));   for (i = 0; i < str_list->size; i++)   {      if (string_is_equal(str_list->elems[i].data, playlist_name_with_ext))      {         if (str_list->size != str_list2->size)            break;         if (!str_list2->elems[i].data)            break;         found_matching_core_association = true;         strlcpy(s, str_list2->elems[i].data, len);      }   }   string_list_free(str_list);   string_list_free(str_list2);   if (string_is_equal(s, file_path_str(FILE_PATH_DETECT)) || !found_matching_core_association)      strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NOT_AVAILABLE), len);   else   {      char buf[PATH_MAX_LENGTH];      core_info_list_t *list = NULL;      core_info_get_list(&list);      if (core_info_list_get_display_name(list, s, buf, sizeof(buf)))         strlcpy(s, buf, len);   }   strlcpy(s2, path, len2);}

static void menu_action_setting_disp_set_label_playlist_associations(file_list_t* list,      unsigned *w, unsigned type, unsigned i,      const char *label,      char *s, size_t len,      const char *entry_label,      const char *path,      char *s2, size_t len2){   char playlist_name_with_ext[PATH_MAX_LENGTH] = {0};   bool found_matching_core_association         = false;   settings_t         *settings                 = config_get_ptr();   struct string_list *str_list                 = string_split(settings->playlist_names, ";");   struct string_list *str_list2                = string_split(settings->playlist_cores, ";");   strlcpy(s2, path, len2);   *s = '/0';   *w = 19;   strlcpy(playlist_name_with_ext, path, sizeof(playlist_name_with_ext));   strlcat(playlist_name_with_ext, ".lpl", sizeof(playlist_name_with_ext));   for (i = 0; i < str_list->size; i++)   {      if (string_is_equal(str_list->elems[i].data, playlist_name_with_ext))      {         if (str_list->size != str_list2->size)            break;         if (str_list2->elems[i].data == NULL)            break;         found_matching_core_association = true;         strlcpy(s, str_list2->elems[i].data, len);      }   }   string_list_free(str_list);   string_list_free(str_list2);   if (string_is_equal(s, "DETECT") || !found_matching_core_association)      strlcpy(s, "N/A", len);   else   {      char buf[PATH_MAX_LENGTH];      core_info_list_t *list = NULL;      core_info_get_list(&list);      if (core_info_list_get_display_name(list, s, buf, sizeof(buf)))         strlcpy(s, buf, len);   }   strlcpy(s2, path, len2);}

static inline host_htable_index cache_host_trans_ht_index(string_t *top_label){    if (string_is_equal(top_label, &tld_com)) {        return host_ht_com;    } else if (string_is_equal(top_label, &tld_cn)) {        return host_ht_cn;    } else if (string_is_equal(top_label, &tld_com_cn)) {        return host_ht_com_cn;    } else {        return host_ht_max;    }}

void RARCH_LOG_V(const char *tag, const char *fmt, va_list ap){#if TARGET_OS_IPHONE   static int asl_inited = 0;#if !TARGET_IPHONE_SIMULATORstatic aslclient asl_client;#endif#endif   if (!RARCH_LOG_VERBOSE())      return;#if TARGET_OS_IPHONE#if TARGET_IPHONE_SIMULATOR   vprintf(fmt, ap);#else   if (!asl_inited)   {      asl_client = asl_open("RetroArch", "com.apple.console", ASL_OPT_STDERR | ASL_OPT_NO_DELAY);      asl_inited = 1;   }   aslmsg msg = asl_new(ASL_TYPE_MSG);   asl_set(msg, ASL_KEY_READ_UID, "-1");   if (tag)      asl_log(asl_client, msg, ASL_LEVEL_NOTICE, "%s", tag);   asl_vlog(asl_client, msg, ASL_LEVEL_NOTICE, fmt, ap);   asl_free(msg);#endif#elif defined(_XBOX1)   /* FIXME: Using arbitrary string as fmt argument is unsafe. */   char msg_new[1024], buffer[1024];   snprintf(msg_new, sizeof(msg_new), "%s: %s %s",         PROGRAM_NAME,         tag ? tag : "",         fmt);   wvsprintf(buffer, msg_new, ap);   OutputDebugStringA(buffer);#elif defined(ANDROID)   int prio = ANDROID_LOG_INFO;   if (tag)   {      if (string_is_equal("[WARN]", tag))         prio = ANDROID_LOG_WARN;      else if (string_is_equal("[ERROR]", tag))         prio = ANDROID_LOG_ERROR;   }   __android_log_vprint(prio, PROGRAM_NAME, fmt, ap);#else   fprintf(LOG_FILE, "%s %s :: ", PROGRAM_NAME, tag ? tag : "[INFO]");   vfprintf(LOG_FILE, fmt, ap);   fflush(LOG_FILE);#endif}

static void salamander_init(char *s, size_t len){   /* normal executable loading path */   bool config_exists = config_file_exists(g_defaults.path.config);   if (config_exists)   {      char tmp_str[PATH_MAX_LENGTH] = {0};      config_file_t * conf          = (config_file_t*)         config_file_new(g_defaults.path.config);      if (conf)      {         config_get_array(conf, "libretro_path", tmp_str, sizeof(tmp_str));         config_file_free(conf);         if (!string_is_equal(tmp_str, "builtin"))            strlcpy(s, tmp_str, len);      }#ifdef GEKKO      /* stupid libfat bug or something; sometimes it says        * the file is there when it doesn't. */      else       {         config_exists = false;      }#endif   }   if (!config_exists || string_is_equal(s, ""))   {      char executable_name[PATH_MAX_LENGTH] = {0};      frontend_driver_get_core_extension(            executable_name, sizeof(executable_name));      find_and_set_first_file(s, len, executable_name);   }   else      RARCH_LOG("Start [%s] found in retroarch.cfg./n", s);   if (!config_exists)   {      config_file_t *conf = (config_file_t*)config_file_new(NULL);      if (conf)      {         config_set_string(conf, "libretro_path", s);         config_file_write(conf, g_defaults.path.config);         config_file_free(conf);      }   }}

const struct retro_subsystem_info *libretro_find_subsystem_info(      const struct retro_subsystem_info *info, unsigned num_info,      const char *ident){   unsigned i;   for (i = 0; i < num_info; i++)   {      if (string_is_equal(info[i].ident, ident))         return &info[i];      else if (string_is_equal(info[i].desc, ident))         return &info[i];   }   return NULL;}

static void *hlsl_init(void *data, const char *path){   unsigned i;   d3d_video_t *d3d = (d3d_video_t*)data;   hlsl_shader_data_t *hlsl_data = (hlsl_shader_data_t*)      calloc(1, sizeof(hlsl_shader_data_t));   if (!hlsl_data)	   return NULL;   if (path && string_is_equal(path_get_extension(path), ".cgp"))   {      if (!hlsl_load_preset(hlsl_data, d3d, path))         goto error;   }   else   {      if (!hlsl_load_plain(hlsl_data, d3d, path))         goto error;   }   for(i = 1; i <= hlsl_data->cg_shader->passes; i++)      hlsl_set_program_attributes(hlsl_data, i);   d3d_set_vertex_shader(d3d->dev, 1, hlsl_data->prg[1].vprg);   d3d->dev->SetPixelShader(hlsl_data->prg[1].fprg);   return hlsl_data;error:   if (hlsl_data)	   free(hlsl_data);   return NULL;}

static void menu_action_setting_disp_set_label_netplay_mitm_server(      file_list_t* list,      unsigned *w, unsigned type, unsigned i,      const char *label,      char *s, size_t len,      const char *entry_label,      const char *path,      char *s2, size_t len2){   unsigned j;   settings_t *settings = config_get_ptr();   *s = '/0';   *w = 19;   strlcpy(s2, path, len2);   if (!settings)      return;   if (string_is_empty(settings->arrays.netplay_mitm_server))      return;   for (j = 0; j < ARRAY_SIZE(netplay_mitm_server_list); j++)   {      if (string_is_equal(settings->arrays.netplay_mitm_server,               netplay_mitm_server_list[j].name))         strlcpy(s, netplay_mitm_server_list[j].description, len);   }}

static const char* dat_converter_get_match(      dat_converter_list_t* list,      dat_converter_match_key_t* match_key){   int i;   retro_assert(match_key);   if (list->type != DAT_CONVERTER_MAP_LIST)      return NULL;   for (i = 0; i < list->count; i++)   {      if (list->values[i].map.hash == match_key->hash)      {         retro_assert(string_is_equal(list->values[i].map.key, match_key->value));         if (match_key->next)            return dat_converter_get_match(                  list->values[i].map.value.list, match_key->next);         if ((list->values[i].map.type == DAT_CONVERTER_STRING_MAP))            return list->values[i].map.value.string;         return NULL;      }   }   return NULL;}

bool menu_content_playlist_find_associated_core(const char *path, char *s, size_t len){    unsigned j;    bool                     ret = false;    settings_t *settings         = config_get_ptr();    struct string_list *existing_core_names =        string_split(settings->playlist_names, ";");    struct string_list *existing_core_paths =        string_split(settings->playlist_cores, ";");    for (j = 0; j < existing_core_names->size; j++)    {        if (string_is_equal(path, existing_core_names->elems[j].data))        {            if (existing_core_paths)            {                const char *existing_core = existing_core_paths->elems[j].data;                if (existing_core)                {                    strlcpy(s, existing_core, len);                    ret = true;                }            }            break;        }    }    string_list_free(existing_core_names);    string_list_free(existing_core_paths);    return ret;}

static void gfx_ctx_wgl_input_driver(void *data,      const char *joypad_name,      const input_driver_t **input, void **input_data){   settings_t *settings = config_get_ptr();#if _WIN32_WINNT >= 0x0501   /* winraw only available since XP */   if (string_is_equal(settings->arrays.input_driver, "raw"))   {      *input_data = input_winraw.init(joypad_name);      if (*input_data)      {         *input     = &input_winraw;         dinput_wgl = NULL;         return;      }   }#endif#ifdef HAVE_DINPUT   dinput_wgl  = input_dinput.init(joypad_name);   *input      = dinput_wgl ? &input_dinput : NULL;   *input_data = dinput_wgl;#endif}

/* Find the index of a compatible DRM device. */static int exynos_get_device_index(void){   drmVersionPtr ver;   char buf[32]       = {0};   int index          = 0;   bool found         = false;   while (!found)   {      int fd;      snprintf(buf, sizeof(buf), "/dev/dri/card%d", index);      fd = open(buf, O_RDWR);      if (fd < 0) break;      ver = drmGetVersion(fd);      if (string_is_equal(ver->name, "exynos"))         found = true;      else         ++index;      drmFreeVersion(ver);      close(fd);   }   if (!found)      return -1;   return index;}

void input_config_get_bind_string(char *buf, const struct retro_keybind *bind,      const struct retro_keybind *auto_bind, size_t size){   char key[64]    = {0};   char keybuf[64] = {0};   (void)key;   (void)keybuf;   *buf = '/0';   if (bind->joykey != NO_BTN)      input_config_get_bind_string_joykey(buf, "", bind, size);   else if (bind->joyaxis != AXIS_NONE)      input_config_get_bind_string_joyaxis(buf, "", bind, size);   else if (auto_bind && auto_bind->joykey != NO_BTN)      input_config_get_bind_string_joykey(buf, "Auto: ", auto_bind, size);   else if (auto_bind && auto_bind->joyaxis != AXIS_NONE)      input_config_get_bind_string_joyaxis(buf, "Auto: ", auto_bind, size);#ifndef RARCH_CONSOLE   input_keymaps_translate_rk_to_str(bind->key, key, sizeof(key));   if (string_is_equal(key, "nul"))      *key = '/0';   snprintf(keybuf, sizeof(keybuf), "(Key: %s)", key);   strlcat(buf, keybuf, size);#endif}

void input_config_parse_joy_button(config_file_t *conf, const char *prefix,      const char *btn, struct retro_keybind *bind){   char str[256]      = {0};   char tmp[64]       = {0};   char key[64]       = {0};   char key_label[64] = {0};   char *tmp_a        = NULL;   fill_pathname_join_delim(str, prefix, btn, '_', sizeof(str));   fill_pathname_join_delim(key, str, "btn", '_', sizeof(key));   fill_pathname_join_delim(key_label, str, "btn_label", '_', sizeof(key_label));   if (config_get_array(conf, key, tmp, sizeof(tmp)))   {      btn = tmp;      if (string_is_equal(btn, "nul"))         bind->joykey = NO_BTN;      else      {         if (*btn == 'h')            parse_hat(bind, btn + 1);         else            bind->joykey = strtoull(tmp, NULL, 0);      }   }   if (config_get_string(conf, key_label, &tmp_a))   {      strlcpy(bind->joykey_label, tmp_a, sizeof(bind->joykey_label));      free(tmp_a);   }}

void content_playlist_get_index_by_path(content_playlist_t *playlist,      const char *search_path,      char **path, char **label,      char **core_path, char **core_name,      char **crc32,      char **db_name){   size_t i;   if (!playlist)      return;   for (i = 0; i < playlist->size; i++)   {      if (!string_is_equal(playlist->entries[i].path, search_path))         continue;      if (path)         *path      = playlist->entries[i].path;      if (label)         *label     = playlist->entries[i].label;      if (core_path)         *core_path = playlist->entries[i].core_path;      if (core_name)         *core_name = playlist->entries[i].core_name;      if (db_name)         *db_name   = playlist->entries[i].db_name;      if (crc32)         *crc32     = playlist->entries[i].crc32;      break;   }}

static int action_scan_input_desc(const char *path,      const char *label, unsigned type, size_t idx){   const char *menu_label         = NULL;   unsigned key                   = 0;   unsigned inp_desc_user         = 0;   struct retro_keybind *target   = NULL;   menu_entries_get_last_stack(NULL, &menu_label, NULL, NULL, NULL);   if (string_is_equal(menu_label, "deferred_user_binds_list"))   {      unsigned char player_no_str = atoi(&label[1]);      inp_desc_user      = (unsigned)(player_no_str - 1);      /* This hardcoded value may cause issues if any entries are added on         top of the input binds */      key                = (unsigned)(idx - 7);   }   else      key = input_config_translate_str_to_bind_id(label);   target = &input_config_binds[inp_desc_user][key];   if (target)   {      target->key     = RETROK_UNKNOWN;      target->joykey  = NO_BTN;      target->joyaxis = AXIS_NONE;      target->mbutton = NO_BTN;   }   return 0;}

/** * wrap_str_to_mode: * @type              : Wrap type in human-readable string format. * * Translates wrap mode from human-readable string to enum mode value. * * Returns: enum mode value of wrap type. **/static enum gfx_wrap_type wrap_str_to_mode(const char *wrap_mode){   if (string_is_equal(wrap_mode,      "clamp_to_border"))      return RARCH_WRAP_BORDER;   else if (string_is_equal(wrap_mode, "clamp_to_edge"))      return RARCH_WRAP_EDGE;   else if (string_is_equal(wrap_mode, "repeat"))      return RARCH_WRAP_REPEAT;   else if (string_is_equal(wrap_mode, "mirrored_repeat"))      return RARCH_WRAP_MIRRORED_REPEAT;   RARCH_WARN("Invalid wrapping type %s. Valid ones are: clamp_to_border"         " (default), clamp_to_edge, repeat and mirrored_repeat. Falling back to default./n",         wrap_mode);   return RARCH_WRAP_DEFAULT;}

/* Adds an index for devices with the same name, * so they can be identified in the GUI. */void input_autoconfigure_joypad_reindex_devices(void){   unsigned i, j, k;   for(i = 0; i < MAX_INPUT_DEVICES; i++)      input_device_name_index[i] = 0;   for(i = 0; i < MAX_INPUT_DEVICES; i++)   {      const char *tmp = input_config_get_device_name(i);      if ( !tmp || input_device_name_index[i] )         continue;      k = 2; /*Additional devices start at two*/      for(j = i+1; j < MAX_INPUT_DEVICES; j++)      {         const char *other = input_config_get_device_name(j);         if (!other)            continue;         /*another device with the same name found, for the first time*/         if (string_is_equal(tmp, other) &&               input_device_name_index[j]==0 )         {            /*Mark the first device of the set*/            input_device_name_index[i] = 1;            /*count this additional device, from two up*/            input_device_name_index[j] = k++;         }      }   }}

static INLINE CGparameter d3d9_cg_find_param_from_semantic(      CGparameter param, const char *sem){   for (; param; param = cgGetNextParameter(param))   {      const char *semantic = NULL;      if (cgGetParameterType(param) == CG_STRUCT)      {         CGparameter ret = d3d9_cg_find_param_from_semantic(               cgGetFirstStructParameter(param), sem);         if (ret)            return ret;      }      if (     cgGetParameterDirection(param)   != CG_IN            || cgGetParameterVariability(param) != CG_VARYING)         continue;      semantic = cgGetParameterSemantic(param);      if (!semantic)         continue;      if (string_is_equal(sem, semantic) &&            d3d9_cg_validate_param_name(cgGetParameterName(param)))         return param;   }   return NULL;}

void core_info_get_name(const char *path, char *s, size_t len){   size_t i;   settings_t             *settings = config_get_ptr();   struct string_list *contents     = dir_list_new_special(         settings->paths.directory_libretro,         DIR_LIST_CORES, NULL);   const char       *path_basedir   = !string_is_empty(settings->paths.path_libretro_info) ?      settings->paths.path_libretro_info : settings->paths.directory_libretro;   if (!contents)      return;   for (i = 0; i < contents->size; i++)   {      size_t path_size                = PATH_MAX_LENGTH * sizeof(char);      char *info_path                 = NULL;      config_file_t *conf             = NULL;      char *new_core_name             = NULL;      const char *current_path        = contents->elems[i].data;      if (!string_is_equal(current_path, path))         continue;      info_path                       = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));      info_path[0]                    = '/0';      if (!core_info_list_iterate(info_path,               path_size, path_basedir, contents, i)            && path_is_valid(info_path))      {         free(info_path);         continue;      }      conf = config_file_new(info_path);      if (!conf)      {         free(info_path);         continue;      }      if (config_get_string(conf, "corename",            &new_core_name))      {         strlcpy(s, new_core_name, len);         free(new_core_name);      }      config_file_free(conf);      free(info_path);      break;   }   if (contents)      dir_list_free(contents);   contents = NULL;}

static int task_database_iterate_serial_lookup(    database_state_handle_t *db_state,    database_info_handle_t *db, const char *name){    if (!db_state->list ||            (unsigned)db_state->list_index == (unsigned)db_state->list->size)        return database_info_list_iterate_end_no_match(db_state);    if (db_state->entry_index == 0)    {        char query[50];        char *serial_buf =            bin_to_hex_alloc((uint8_t*)db_state->serial, 10 * sizeof(uint8_t));        if (!serial_buf)            return 1;        query[0] = '/0';        snprintf(query, sizeof(query), "{'serial': b'%s'}", serial_buf);        database_info_list_iterate_new(db_state, query);        free(serial_buf);    }    if (db_state->info)    {        database_info_t *db_info_entry = &db_state->info->list[                                             db_state->entry_index];        if (db_info_entry && db_info_entry->serial)        {#if 0            RARCH_LOG("serial: %s , entry serial: %s (%s)./n",                      db_state->serial, db_info_entry->serial,                      db_info_entry->name);#endif            if (string_is_equal(db_state->serial, db_info_entry->serial))                return database_info_list_iterate_found_match(db_state, db, NULL);        }    }    db_state->entry_index++;    if (db_state->info)    {        if (db_state->entry_index >= db_state->info->count)            return database_info_list_iterate_next(db_state);    }    /* If we haven't reached the end of the database list yet,     * continue iterating. */    if (db_state->list_index < db_state->list->size)        return 1;    database_info_list_free(db_state->info);    free(db_state->info);    return 0;}

static int playlist_association_right(unsigned type, const char *label,      bool wraparound){   char core_path[PATH_MAX_LENGTH];   char new_playlist_cores[PATH_MAX_LENGTH];   size_t i, next, found, current   = 0;   core_info_t *info                = NULL;   struct string_list *stnames      = NULL;   struct string_list *stcores      = NULL;   core_info_list_t           *list = NULL;   settings_t *settings             = config_get_ptr();   const char *path                 = path_basename(label);   core_info_get_list(&list);   if (!list)      return menu_cbs_exit();   core_path[0] = new_playlist_cores[0] = '/0';   stnames = string_split(settings->arrays.playlist_names, ";");   stcores = string_split(settings->arrays.playlist_cores, ";");   if (!menu_content_playlist_find_associated_core(path, core_path, sizeof(core_path)))         strlcpy(core_path,               file_path_str(FILE_PATH_DETECT), sizeof(core_path));   for (i = 0; i < list->count; i++)   {      core_info_t *info = core_info_get(list, i);      if (string_is_equal(info->path, core_path))         current = i;   }   next = current + 1;   if (next >= list->count)   {      if (wraparound)         next = 0;      else         next = list->count-1;   }   info = core_info_get(list, next);   found = string_list_find_elem(stnames, path);   if (found && info)      string_list_set(stcores, (unsigned)(found-1), info->path);   string_list_join_concat(new_playlist_cores,         sizeof(new_playlist_cores), stcores, ";");   strlcpy(settings->arrays.playlist_cores,         new_playlist_cores, sizeof(settings->arrays.playlist_cores));   string_list_free(stnames);   string_list_free(stcores);   return 0;}

static uint32_t gfx_ctx_wgl_get_flags(void *data){   uint32_t          flags = 0;   BIT32_SET(flags, GFX_CTX_FLAGS_NONE);   switch (win32_api)   {      case GFX_CTX_OPENGL_API:         if (wgl_adaptive_vsync)         {            BIT32_SET(flags, GFX_CTX_FLAGS_ADAPTIVE_VSYNC);         }         if (win32_core_hw_context_enable)         {            BIT32_SET(flags, GFX_CTX_FLAGS_GL_CORE_CONTEXT);         }         if (string_is_equal(video_driver_get_ident(), "gl1")) { }         else if (string_is_equal(video_driver_get_ident(), "glcore")) { }         else         {#ifdef HAVE_CG            if (!win32_core_hw_context_enable)               BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_CG);#endif#ifdef HAVE_GLSL            BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_GLSL);#endif         }         break;      case GFX_CTX_VULKAN_API:#ifdef HAVE_SLANG         BIT32_SET(flags, GFX_CTX_FLAGS_SHADERS_SLANG);#endif         break;      case GFX_CTX_NONE:      default:         break;   }   return flags;}

static bool d3d_process_shader(d3d_video_t *d3d){#ifdef HAVE_FBO   if (string_is_equal(path_get_extension(d3d->shader_path.c_str()), "cgp"))      return d3d_init_multipass(d3d);#endif   return d3d_init_singlepass(d3d);}

int32_t pad_connection_pad_init(joypad_connection_t *joyconn,   const char* name, uint16_t vid, uint16_t pid,   void *data, send_control_t ptr){   static const struct   {      const char* name;      uint16_t vid;      uint16_t pid;      pad_connection_interface_t *iface;   } pad_map[] =   {      { "Nintendo RVL-CNT-01",         1406,  816,    &pad_connection_wii },      { "Nintendo RVL-CNT-01-UC",      1406,  816,    &pad_connection_wiiupro },      { "Wireless Controller",         1356,  1476,   &pad_connection_ps4 },      { "PLAYSTATION(R)3 Controller",  1356,  616,    &pad_connection_ps3 },      { "PLAYSTATION(R)3 Controller",  787,   8406,   &pad_connection_ps3 },      { "Generic SNES USB Controller", 2079,  58369,  &pad_connection_snesusb },      { "Generic NES USB Controller",  121,   17,     &pad_connection_nesusb },      { "Wii U GC Controller Adapter", 1406,  823,    &pad_connection_wiiugca },      { 0, 0}   };   joypad_connection_t *s = NULL;   int                pad = pad_connection_find_vacant_pad(joyconn);   if (pad == -1)      return -1;   s = &joyconn[pad];   if (s)   {      unsigned i;      for (i = 0; name && pad_map[i].name; i++)      {         const char *name_match = strstr(pad_map[i].name, name);         /* Never change, Nintendo. */         if(pad_map[i].vid == 1406 && pad_map[i].pid == 816)           {            if(!string_is_equal(pad_map[i].name, name))               continue;         }         if (name_match || (pad_map[i].vid == vid && pad_map[i].pid == pid))         {            s->iface      = pad_map[i].iface;            s->data       = s->iface->init(data, pad, ptr);            s->connected  = true;            break;         }      }   }   return pad;}