[pcsx_rearmed.git] / deps / libretro-common / lists / file_list.c

/* Copyright  (C) 2010-2020 The RetroArch team
 *
 * ---------------------------------------------------------------------------------------
 * The following license statement only applies to this file (file_list.c).
 * ---------------------------------------------------------------------------------------
 *
 * Permission is hereby granted, free of charge,
 * to any person obtaining a copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
 * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <retro_common.h>
#include <lists/file_list.h>
#include <string/stdstring.h>
#include <compat/strcasestr.h>

static bool file_list_deinitialize_internal(file_list_t *list)
{
   size_t i;
   for (i = 0; i < list->size; i++)
   {
      file_list_free_userdata(list, i);
      file_list_free_actiondata(list, i);

      if (list->list[i].path)
         free(list->list[i].path);
      list->list[i].path = NULL;

      if (list->list[i].label)
         free(list->list[i].label);
      list->list[i].label = NULL;

      if (list->list[i].alt)
         free(list->list[i].alt);
      list->list[i].alt = NULL;
   }
   if (list->list)
      free(list->list);
   list->list = NULL;
   return true;
}

bool file_list_reserve(file_list_t *list, size_t nitems)
{
   const size_t item_size = sizeof(struct item_file);
   struct item_file *new_data;

   if (nitems < list->capacity || nitems > (size_t)-1/item_size)
      return false;

   if (!(new_data = (struct item_file*)realloc(list->list, nitems * item_size)))
      return false;

   memset(&new_data[list->capacity], 0, item_size * (nitems - list->capacity));

   list->list     = new_data;
   list->capacity = nitems;

   return true;
}

bool file_list_insert(file_list_t *list,
      const char *path, const char *label,
      unsigned type, size_t directory_ptr,
      size_t entry_idx,
      size_t idx)
{
   int i;

   /* Expand file list if needed */
   if (list->size >= list->capacity)
      if (!file_list_reserve(list, list->capacity * 2 + 1))
         return false;

   for (i = (unsigned)list->size; i > (int)idx; i--)
   {
      struct item_file *copy = (struct item_file*)
         malloc(sizeof(struct item_file));

      copy->path             = NULL;
      copy->label            = NULL;
      copy->alt              = NULL;
      copy->type             = 0;
      copy->directory_ptr    = 0;
      copy->entry_idx        = 0;
      copy->userdata         = NULL;
      copy->actiondata       = NULL;

      memcpy(copy, &list->list[i-1], sizeof(struct item_file));

      memcpy(&list->list[i-1], &list->list[i], sizeof(struct item_file));
      memcpy(&list->list[i],             copy, sizeof(struct item_file));

      free(copy);
   }

   list->list[idx].path          = NULL;
   list->list[idx].label         = NULL;
   list->list[idx].alt           = NULL;
   list->list[idx].type          = type;
   list->list[idx].directory_ptr = directory_ptr;
   list->list[idx].entry_idx     = entry_idx;
   list->list[idx].userdata      = NULL;
   list->list[idx].actiondata    = NULL;

   if (label)
      list->list[idx].label      = strdup(label);
   if (path)
      list->list[idx].path       = strdup(path);

   list->size++;

   return true;
}

bool file_list_append(file_list_t *list,
      const char *path, const char *label,
      unsigned type, size_t directory_ptr,
      size_t entry_idx)
{
   unsigned idx = (unsigned)list->size;
   /* Expand file list if needed */
   if (idx >= list->capacity)
      if (!file_list_reserve(list, list->capacity * 2 + 1))
         return false;

   list->list[idx].path          = NULL;
   list->list[idx].label         = NULL;
   list->list[idx].alt           = NULL;
   list->list[idx].type          = type;
   list->list[idx].directory_ptr = directory_ptr;
   list->list[idx].entry_idx     = entry_idx;
   list->list[idx].userdata      = NULL;
   list->list[idx].actiondata    = NULL;

   if (label)
      list->list[idx].label      = strdup(label);
   if (path)
      list->list[idx].path       = strdup(path);

   list->size++;

   return true;
}

void file_list_pop(file_list_t *list, size_t *directory_ptr)
{
   if (!list)
      return;

   if (list->size != 0)
   {
      --list->size;
      if (list->list[list->size].path)
         free(list->list[list->size].path);
      list->list[list->size].path = NULL;

      if (list->list[list->size].label)
         free(list->list[list->size].label);
      list->list[list->size].label = NULL;
   }

   if (directory_ptr)
      *directory_ptr = list->list[list->size].directory_ptr;
}

void file_list_free(file_list_t *list)
{
   if (!list)
      return;
   file_list_deinitialize_internal(list);
   free(list);
}

bool file_list_deinitialize(file_list_t *list)
{
   if (!list)
      return false;
   if (!file_list_deinitialize_internal(list))
      return false;
   list->capacity = 0;
   list->size     = 0;
   return true;
}

void file_list_clear(file_list_t *list)
{
   size_t i;

   if (!list)
      return;

   for (i = 0; i < list->size; i++)
   {
      if (list->list[i].path)
         free(list->list[i].path);
      list->list[i].path = NULL;

      if (list->list[i].label)
         free(list->list[i].label);
      list->list[i].label = NULL;

      if (list->list[i].alt)
         free(list->list[i].alt);
      list->list[i].alt = NULL;
   }

   list->size = 0;
}

static void file_list_get_label_at_offset(const file_list_t *list, size_t idx,
      const char **label)
{
   if (!label || !list)
      return;

   *label = list->list[idx].path;
   if (list->list[idx].label)
      *label = list->list[idx].label;
}

void file_list_set_alt_at_offset(file_list_t *list, size_t idx,
      const char *alt)
{
   if (!list || !alt)
      return;

   if (list->list[idx].alt)
      free(list->list[idx].alt);
   list->list[idx].alt      = NULL;

   if (alt)
      list->list[idx].alt   = strdup(alt);
}

static int file_list_alt_cmp(const void *a_, const void *b_)
{
   const struct item_file *a = (const struct item_file*)a_;
   const struct item_file *b = (const struct item_file*)b_;
   const char *cmp_a         = a->alt ? a->alt : a->path;
   const char *cmp_b         = b->alt ? b->alt : b->path;
   return strcasecmp(cmp_a, cmp_b);
}

static int file_list_type_cmp(const void *a_, const void *b_)
{
   const struct item_file *a = (const struct item_file*)a_;
   const struct item_file *b = (const struct item_file*)b_;
   if (a->type < b->type)
      return -1;
   if (a->type == b->type)
      return 0;

   return 1;
}

void file_list_sort_on_alt(file_list_t *list)
{
   qsort(list->list, list->size, sizeof(list->list[0]), file_list_alt_cmp);
}

void file_list_sort_on_type(file_list_t *list)
{
   qsort(list->list, list->size, sizeof(list->list[0]), file_list_type_cmp);
}

void *file_list_get_userdata_at_offset(const file_list_t *list, size_t idx)
{
   if (!list)
      return NULL;
   return list->list[idx].userdata;
}

void *file_list_get_actiondata_at_offset(const file_list_t *list, size_t idx)
{
   if (!list)
      return NULL;
   return list->list[idx].actiondata;
}

void file_list_free_actiondata(const file_list_t *list, size_t idx)
{
   if (!list)
      return;
   if (list->list[idx].actiondata)
       free(list->list[idx].actiondata);
   list->list[idx].actiondata = NULL;
}

void file_list_free_userdata(const file_list_t *list, size_t idx)
{
   if (!list)
      return;
   if (list->list[idx].userdata)
       free(list->list[idx].userdata);
   list->list[idx].userdata = NULL;
}

bool file_list_search(const file_list_t *list, const char *needle, size_t *idx)
{
   size_t i;
   bool ret        = false;

   if (!list)
      return false;

   for (i = 0; i < list->size; i++)
   {
      const char *str = NULL;
      const char *alt = list->list[i].alt 
            ? list->list[i].alt 
            : list->list[i].path;

      if (!alt)
      {
         file_list_get_label_at_offset(list, i, &alt);
         if (!alt)
            continue;
      }

      if ((str = (const char *)strcasestr(alt, needle)) == alt)
      {
         /* Found match with first chars, best possible match. */
         *idx = i;
         ret  = true;
         break;
      }
      else if (str && !ret)
      {
         /* Found mid-string match, but try to find a match with
          * first characters before we settle. */
         *idx = i;
         ret  = true;
      }
   }

   return ret;
}
Commit	Line	Data
3719602c PC	1	/* Copyright (C) 2010-2020 The RetroArch team
	2	*
	3	* ---------------------------------------------------------------------------------------
	4	* The following license statement only applies to this file (file_list.c).
	5	* ---------------------------------------------------------------------------------------
	6	*
	7	* Permission is hereby granted, free of charge,
	8	* to any person obtaining a copy of this software and associated documentation files (the "Software"),
	9	* to deal in the Software without restriction, including without limitation the rights to
	10	* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
	11	* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
	12	*
	13	* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
	14	*
	15	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
	16	* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	17	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
	18	* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
	19	* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	20	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	21	*/
	22
	23	#include <stdio.h>
	24	#include <stdlib.h>
	25	#include <string.h>
	26
	27	#include <retro_common.h>
	28	#include <lists/file_list.h>
	29	#include <string/stdstring.h>
	30	#include <compat/strcasestr.h>
	31
	32	static bool file_list_deinitialize_internal(file_list_t *list)
	33	{
	34	size_t i;
	35	for (i = 0; i < list->size; i++)
	36	{
	37	file_list_free_userdata(list, i);
	38	file_list_free_actiondata(list, i);
	39
	40	if (list->list[i].path)
	41	free(list->list[i].path);
	42	list->list[i].path = NULL;
	43
	44	if (list->list[i].label)
	45	free(list->list[i].label);
	46	list->list[i].label = NULL;
	47
	48	if (list->list[i].alt)
	49	free(list->list[i].alt);
	50	list->list[i].alt = NULL;
	51	}
	52	if (list->list)
	53	free(list->list);
	54	list->list = NULL;
	55	return true;
	56	}
	57
	58	bool file_list_reserve(file_list_t *list, size_t nitems)
	59	{
	60	const size_t item_size = sizeof(struct item_file);
	61	struct item_file *new_data;
	62
	63	if (nitems < list->capacity \|\| nitems > (size_t)-1/item_size)
	64	return false;
65
66	if (!(new_data = (struct item_file)realloc(list->list, nitems item_size)))
67	return false;
68
69	memset(&new_data[list->capacity], 0, item_size * (nitems - list->capacity));
70
71	list->list = new_data;
72	list->capacity = nitems;
73
74	return true;
75	}
76
77	bool file_list_insert(file_list_t *list,
78	const char path, const char label,
79	unsigned type, size_t directory_ptr,
80	size_t entry_idx,
81	size_t idx)
82	{
83	int i;
84
85	/* Expand file list if needed */
86	if (list->size >= list->capacity)
87	if (!file_list_reserve(list, list->capacity * 2 + 1))
88	return false;
89
90	for (i = (unsigned)list->size; i > (int)idx; i--)
91	{
92	struct item_file copy = (struct item_file)
93	malloc(sizeof(struct item_file));
94
95	copy->path = NULL;
96	copy->label = NULL;
97	copy->alt = NULL;
98	copy->type = 0;
99	copy->directory_ptr = 0;
100	copy->entry_idx = 0;
101	copy->userdata = NULL;
102	copy->actiondata = NULL;
103
104	memcpy(copy, &list->list[i-1], sizeof(struct item_file));
105
106	memcpy(&list->list[i-1], &list->list[i], sizeof(struct item_file));
107	memcpy(&list->list[i], copy, sizeof(struct item_file));
108
109	free(copy);
110	}
111
112	list->list[idx].path = NULL;
113	list->list[idx].label = NULL;
114	list->list[idx].alt = NULL;
115	list->list[idx].type = type;
116	list->list[idx].directory_ptr = directory_ptr;
117	list->list[idx].entry_idx = entry_idx;
118	list->list[idx].userdata = NULL;
119	list->list[idx].actiondata = NULL;
120
121	if (label)
122	list->list[idx].label = strdup(label);
123	if (path)
124	list->list[idx].path = strdup(path);
125
126	list->size++;
127
128	return true;
129	}
130
131	bool file_list_append(file_list_t *list,
132	const char path, const char label,
133	unsigned type, size_t directory_ptr,
134	size_t entry_idx)
135	{
136	unsigned idx = (unsigned)list->size;
137	/* Expand file list if needed */
138	if (idx >= list->capacity)
139	if (!file_list_reserve(list, list->capacity * 2 + 1))
140	return false;
141
142	list->list[idx].path = NULL;
143	list->list[idx].label = NULL;
144	list->list[idx].alt = NULL;
145	list->list[idx].type = type;
146	list->list[idx].directory_ptr = directory_ptr;
147	list->list[idx].entry_idx = entry_idx;
148	list->list[idx].userdata = NULL;
149	list->list[idx].actiondata = NULL;
150
151	if (label)
152	list->list[idx].label = strdup(label);
153	if (path)
154	list->list[idx].path = strdup(path);
155
156	list->size++;
157
158	return true;
159	}
160
161	void file_list_pop(file_list_t list, size_t directory_ptr)
162	{
163	if (!list)
164	return;
165
166	if (list->size != 0)
167	{
168	--list->size;
169	if (list->list[list->size].path)
170	free(list->list[list->size].path);
171	list->list[list->size].path = NULL;
172
173	if (list->list[list->size].label)
174	free(list->list[list->size].label);
175	list->list[list->size].label = NULL;
176	}
177
178	if (directory_ptr)
179	*directory_ptr = list->list[list->size].directory_ptr;
180	}
181
182	void file_list_free(file_list_t *list)
183	{
184	if (!list)
185	return;
186	file_list_deinitialize_internal(list);
187	free(list);
188	}
189
190	bool file_list_deinitialize(file_list_t *list)
191	{
192	if (!list)
193	return false;
194	if (!file_list_deinitialize_internal(list))
195	return false;
196	list->capacity = 0;
197	list->size = 0;
198	return true;
199	}
200
201	void file_list_clear(file_list_t *list)
202	{
203	size_t i;
204
205	if (!list)
206	return;
207
208	for (i = 0; i < list->size; i++)
209	{
210	if (list->list[i].path)
211	free(list->list[i].path);
212	list->list[i].path = NULL;
213
214	if (list->list[i].label)
215	free(list->list[i].label);
216	list->list[i].label = NULL;
217
218	if (list->list[i].alt)
219	free(list->list[i].alt);
220	list->list[i].alt = NULL;
221	}
222
223	list->size = 0;
224	}
225
226	static void file_list_get_label_at_offset(const file_list_t *list, size_t idx,
227	const char **label)
228	{
229	if (!label \|\| !list)
230	return;
231
232	*label = list->list[idx].path;
233	if (list->list[idx].label)
234	*label = list->list[idx].label;
235	}
236
237	void file_list_set_alt_at_offset(file_list_t *list, size_t idx,
238	const char *alt)
239	{
240	if (!list \|\| !alt)
241	return;
242
243	if (list->list[idx].alt)
244	free(list->list[idx].alt);
245	list->list[idx].alt = NULL;
246
247	if (alt)
248	list->list[idx].alt = strdup(alt);
249	}
250
251	static int file_list_alt_cmp(const void a_, const void b_)
252	{
253	const struct item_file a = (const struct item_file)a_;
254	const struct item_file b = (const struct item_file)b_;
255	const char *cmp_a = a->alt ? a->alt : a->path;
256	const char *cmp_b = b->alt ? b->alt : b->path;
257	return strcasecmp(cmp_a, cmp_b);
258	}
259
260	static int file_list_type_cmp(const void a_, const void b_)
261	{
262	const struct item_file a = (const struct item_file)a_;
263	const struct item_file b = (const struct item_file)b_;
264	if (a->type < b->type)
265	return -1;
266	if (a->type == b->type)
267	return 0;
268
269	return 1;
270	}
271
272	void file_list_sort_on_alt(file_list_t *list)
273	{
274	qsort(list->list, list->size, sizeof(list->list[0]), file_list_alt_cmp);
275	}
276
277	void file_list_sort_on_type(file_list_t *list)
278	{
279	qsort(list->list, list->size, sizeof(list->list[0]), file_list_type_cmp);
280	}
281
282	void file_list_get_userdata_at_offset(const file_list_t list, size_t idx)
283	{
284	if (!list)
285	return NULL;
286	return list->list[idx].userdata;
287	}
288
289	void file_list_get_actiondata_at_offset(const file_list_t list, size_t idx)
290	{
291	if (!list)
292	return NULL;
293	return list->list[idx].actiondata;
294	}
295
296	void file_list_free_actiondata(const file_list_t *list, size_t idx)
297	{
298	if (!list)
299	return;
300	if (list->list[idx].actiondata)
301	free(list->list[idx].actiondata);
302	list->list[idx].actiondata = NULL;
303	}
304
305	void file_list_free_userdata(const file_list_t *list, size_t idx)
306	{
307	if (!list)
308	return;
309	if (list->list[idx].userdata)
310	free(list->list[idx].userdata);
311	list->list[idx].userdata = NULL;
312	}
313
314	bool file_list_search(const file_list_t list, const char needle, size_t *idx)
315	{
316	size_t i;
317	bool ret = false;
318
319	if (!list)
320	return false;
321
322	for (i = 0; i < list->size; i++)
323	{
324	const char *str = NULL;
325	const char *alt = list->list[i].alt
326	? list->list[i].alt
327	: list->list[i].path;
328
329	if (!alt)
330	{
331	file_list_get_label_at_offset(list, i, &alt);
332	if (!alt)
333	continue;
334	}
335
336	if ((str = (const char *)strcasestr(alt, needle)) == alt)
337	{
338	/* Found match with first chars, best possible match. */
339	*idx = i;
340	ret = true;
341	break;
342	}
343	else if (str && !ret)
344	{
345	/* Found mid-string match, but try to find a match with
346	* first characters before we settle. */
347	*idx = i;
348	ret = true;
349	}
350	}
351
352	return ret;
353	}