resync

Author: inactive123

include/libretro.h

@@ -2672,7 +2672,7 @@ struct retro_input_descriptor
 struct retro_system_info
 {
    /* All pointers are owned by libretro implementation, and pointers must
-    * remain valid until retro_deinit() is called. */
+    * remain valid until it is unloaded. */
 
    const char *library_name;      /* Descriptive name of library. Should not
                                    * contain any version numbers, etc. */

include/lists/file_list.h

@@ -70,6 +70,10 @@ void *file_list_get_actiondata_at_offset(const file_list_t *list,
  */
 void file_list_free(file_list_t *list);
 
+bool file_list_deinitialize(file_list_t *list);
+
+bool file_list_initialize(file_list_t *list);
+
 /**
  * @brief makes the list big enough to contain at least nitems
  *

include/lists/string_list.h

@@ -101,6 +101,10 @@ struct string_list *string_split(const char *str, const char *delim);
  */
 struct string_list *string_separate(char *str, const char *delim);
 
+bool string_list_deinitialize(struct string_list *list);
+
+bool string_list_initialize(struct string_list *list);
+
 /**
  * string_list_new:
  *

include/queues/fifo_queue.h

@@ -29,6 +29,7 @@
 
 #include <retro_common_api.h>
 #include <retro_inline.h>
+#include <boolean.h>
 
 RETRO_BEGIN_DECLS
 
@@ -54,14 +55,7 @@ void fifo_write(fifo_buffer_t *buffer, const void *in_buf, size_t size);
 
 void fifo_read(fifo_buffer_t *buffer, void *in_buf, size_t size);
 
-static INLINE void fifo_free(fifo_buffer_t *buffer)
-{
-   if (!buffer)
-      return;
-
-   free(buffer->buffer);
-   free(buffer);
-}
+void fifo_free(fifo_buffer_t *buffer);
 
 #define FIFO_READ_AVAIL(buffer) (((buffer)->end + (((buffer)->end < (buffer)->first) ? (buffer)->size : 0)) - (buffer)->first)
 

include/queues/message_queue.h

@@ -43,7 +43,23 @@ enum message_queue_category
    MESSAGE_QUEUE_CATEGORY_SUCCESS
 };
 
-typedef struct msg_queue msg_queue_t;
+typedef struct queue_elem
+{
+   char *msg;
+   char *title;
+   unsigned duration;
+   unsigned prio;
+   enum message_queue_icon icon;
+   enum message_queue_category category;
+} queue_elem_t;
+
+typedef struct msg_queue
+{
+   char *tmp_msg;
+   queue_elem_t **elems;
+   size_t ptr;
+   size_t size;
+} msg_queue_t;
 
 typedef struct
 {
@@ -66,6 +82,8 @@ typedef struct
  **/
 msg_queue_t *msg_queue_new(size_t size);
 
+bool msg_queue_initialize(msg_queue_t *queue, size_t size);
+
 /**
  * msg_queue_push:
  * @queue             : pointer to queue object
@@ -131,6 +149,8 @@ void msg_queue_clear(msg_queue_t *queue);
  **/
 void msg_queue_free(msg_queue_t *queue);
 
+bool msg_queue_deinitialize(msg_queue_t *queue);
+
 RETRO_END_DECLS
 
 #endif

lists/dir_list.c

@@ -235,9 +235,9 @@ struct string_list *dir_list_new(const char *dir,
       bool include_hidden, bool include_compressed,
       bool recursive)
 {
-   struct string_list *list       = NULL;
+   struct string_list *list       = string_list_new();
 
-   if (!(list = string_list_new()))
+   if (!list)
       return NULL;
 
    if (!dir_list_append(list, dir, ext, include_dirs,

lists/file_list.c

@@ -29,6 +29,44 @@
 #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_initialize(file_list_t *list)
+{
+   if (!list)
+      return false;
+
+   list->list     = NULL;
+   list->capacity = 0;
+   list->size     = 0;
+
+   return true;
+}
+
 bool file_list_reserve(file_list_t *list, size_t nitems)
 {
    const size_t item_size = sizeof(struct item_file);
@@ -182,34 +220,23 @@ void file_list_pop(file_list_t *list, size_t *directory_ptr)
 
 void file_list_free(file_list_t *list)
 {
-   size_t i;
-
    if (!list)
       return;
-
-   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;
+   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;

lists/string_list.c

@@ -29,20 +29,14 @@
 #include <compat/posix_string.h>
 #include <string/stdstring.h>
 
-/**
- * string_list_free
- * @list             : pointer to string list object
- *
- * Frees a string list.
- */
-void string_list_free(struct string_list *list)
+static bool string_list_deinitialize_internal(struct string_list *list)
 {
-   size_t i;
    if (!list)
-      return;
+      return false;
 
    if (list->elems)
    {
+      unsigned i;
       for (i = 0; i < list->size; i++)
       {
          if (list->elems[i].data)
@@ -57,7 +51,8 @@ void string_list_free(struct string_list *list)
    }
 
    list->elems = NULL;
-   free(list);
+
+   return true;
 }
 
 /**
@@ -85,6 +80,38 @@ static bool string_list_capacity(struct string_list *list, size_t cap)
    return true;
 }
 
+static bool string_list_initialize_internal(struct string_list *list)
+{
+   list->elems              = NULL;
+   list->size               = 0;
+   list->cap                = 0;
+
+   return string_list_capacity(list, 32);
+}
+
+/**
+ * string_list_free
+ * @list             : pointer to string list object
+ *
+ * Frees a string list.
+ */
+void string_list_free(struct string_list *list)
+{
+   if (!list)
+      return;
+
+   string_list_deinitialize_internal(list);
+
+   free(list);
+}
+
+bool string_list_deinitialize(struct string_list *list)
+{
+   if (!list)
+      return false;
+   return string_list_deinitialize_internal(list);
+}
+
 /**
  * string_list_new:
  *
@@ -100,11 +127,7 @@ struct string_list *string_list_new(void)
    if (!list)
       return NULL;
 
-   list->elems              = NULL;
-   list->size               = 0;
-   list->cap                = 0;
-
-   if (!string_list_capacity(list, 32))
+   if (!string_list_initialize_internal(list))
    {
       string_list_free(list);
       return NULL;
@@ -113,6 +136,18 @@ struct string_list *string_list_new(void)
    return list;
 }
 
+bool string_list_initialize(struct string_list *list)
+{
+   if (!list)
+      return false;
+   if (!string_list_initialize_internal(list))
+   {
+      string_list_free(list);
+      return false;
+   }
+   return true;
+}
+
 /**
  * string_list_append:
  * @list             : pointer to string list

queues/fifo_queue.c

@@ -23,29 +23,71 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include <retro_common_api.h>
+#include <retro_inline.h>
+#include <boolean.h>
+
 #include <queues/fifo_queue.h>
 
-fifo_buffer_t *fifo_new(size_t size)
+static bool fifo_initialize_internal(fifo_buffer_t *buf, size_t size)
 {
-   uint8_t    *buffer = NULL;
-   fifo_buffer_t *buf = (fifo_buffer_t*)malloc(sizeof(*buf));
+   uint8_t *buffer    = (uint8_t*)calloc(1, size + 1);
 
-   if (!buf)
-      return NULL;
+   if (!buffer)
+      return false;
 
+   buf->buffer        = buffer;
+   buf->size          = size + 1;
    buf->first         = 0;
    buf->end           = 0;
-   buffer             = (uint8_t*)calloc(1, size + 1);
 
+   return true;
+}
+
+bool fifo_initialize(fifo_buffer_t *buf, size_t size)
+{
+   if (!buf)
+      return false;
+   return fifo_initialize_internal(buf, size);
+}
+
+void fifo_free(fifo_buffer_t *buffer)
+{
+   if (!buffer)
+      return;
+
+   free(buffer->buffer);
+   free(buffer);
+}
+
+bool fifo_deinitialize(fifo_buffer_t *buffer)
+{
    if (!buffer)
+      return false;
+
+   if (buffer->buffer)
+      free(buffer->buffer);
+   buffer->buffer = NULL;
+   buffer->size   = 0;
+   buffer->first  = 0;
+   buffer->end    = 0;
+
+   return true;
+}
+
+fifo_buffer_t *fifo_new(size_t size)
+{
+   fifo_buffer_t *buf = (fifo_buffer_t*)malloc(sizeof(*buf));
+
+   if (!buf)
+      return NULL;
+
+   if (!fifo_initialize_internal(buf, size))
    {
       free(buf);
       return NULL;
    }
 
-   buf->buffer        = buffer;
-   buf->size          = size + 1;
-
    return buf;
 }