[pcsx_rearmed.git] / deps / libretro-common / formats / xml / rxml.c

/* Copyright  (C) 2010-2020 The RetroArch team
 *
 * ---------------------------------------------------------------------------------------
 * The following license statement only applies to this file (rxml.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 <boolean.h>
#include <streams/file_stream.h>
#include <compat/posix_string.h>
#include <string/stdstring.h>

#include <formats/rxml.h>

#include "../../deps/yxml/yxml.h"

#define BUFSIZE 4096

struct rxml_parse_buffer
{
   rxml_node_t *stack[32];
   char xml[BUFSIZE];
   char val[BUFSIZE];
};

struct rxml_document
{
   struct rxml_node *root_node;
};

struct rxml_node *rxml_root_node(rxml_document_t *doc)
{
   if (doc)
      return doc->root_node;
   return NULL;
}

static void rxml_free_node(struct rxml_node *node)
{
   struct rxml_node *head = NULL;
   struct rxml_attrib_node *attrib_node_head = NULL;

   if (!node)
      return;

   for (head = node->children; head; )
   {
      struct rxml_node *next_node = (struct rxml_node*)head->next;
      rxml_free_node(head);
      head = next_node;
   }

   for (attrib_node_head = node->attrib; attrib_node_head; )
   {
      struct rxml_attrib_node *next_attrib =
            (struct rxml_attrib_node*)attrib_node_head->next;

      if (attrib_node_head->attrib)
         free(attrib_node_head->attrib);
      if (attrib_node_head->value)
         free(attrib_node_head->value);
      if (attrib_node_head)
         free(attrib_node_head);

      attrib_node_head = next_attrib;
   }

   if (node->name)
      free(node->name);
   if (node->data)
      free(node->data);
   if (node)
      free(node);
}

rxml_document_t *rxml_load_document(const char *path)
{
   rxml_document_t *doc    = NULL;
   char *memory_buffer     = NULL;
   int64_t len             = 0;
   RFILE *file             = filestream_open(path,
         RETRO_VFS_FILE_ACCESS_READ,
         RETRO_VFS_FILE_ACCESS_HINT_NONE);
   if (!file)
      return NULL;

   len                     = filestream_get_size(file);
   memory_buffer           = (char*)malloc((size_t)(len + 1));
   if (!memory_buffer)
      goto error;

   memory_buffer[len]      = '\0';
   if (filestream_read(file, memory_buffer, len) != len)
      goto error;

   filestream_close(file);
   file                    = NULL;

   doc                     = rxml_load_document_string(memory_buffer);

   free(memory_buffer);
   return doc;

error:
   free(memory_buffer);
   if (file)
      filestream_close(file);
   return NULL;
}

rxml_document_t *rxml_load_document_string(const char *str)
{
   yxml_t x;
   rxml_document_t *doc          = NULL;
   size_t stack_i                = 0;
   size_t level                  = 0;
   int i                         = 0;
   char *valptr                  = NULL;
   rxml_node_t *node             = NULL;
   struct rxml_attrib_node *attr = NULL;
   struct rxml_parse_buffer *buf = (struct rxml_parse_buffer*)
      malloc(sizeof(*buf));
   if (!buf)
      return NULL;

   valptr                        = buf->val;
   doc                           = (rxml_document_t*)malloc(sizeof(*doc));
   if (!doc)
      goto error;

   yxml_init(&x, buf->xml, BUFSIZE);

   for (; *str; ++str)
   {
      yxml_ret_t r = yxml_parse(&x, *str);

      if (r < 0)
         goto error;

      switch (r)
      {

         case YXML_ELEMSTART:
            if (node)
            {
               if (level > stack_i)
               {
                  buf->stack[stack_i]      = node;
                  ++stack_i;

                  node->children           = (rxml_node_t*)
                     malloc(sizeof(*node));

                  node->children->name     = NULL;
                  node->children->data     = NULL;
                  node->children->attrib   = NULL;
                  node->children->children = NULL;
                  node->children->next     = NULL;

                  node                     = node->children;
               }
               else
               {
                  node->next               = (rxml_node_t*)
                     malloc(sizeof(*node));

                  node->next->name         = NULL;
                  node->next->data         = NULL;
                  node->next->attrib       = NULL;
                  node->next->children     = NULL;
                  node->next->next         = NULL;

                  node                     = node->next;
               }
            }
            else
               node = doc->root_node       = (rxml_node_t*)
                  calloc(1, sizeof(*node));

            if (node->name)
               free(node->name);
            node->name                     = strdup(x.elem);

            attr                           = NULL;
            valptr                         = buf->val;

            ++level;
            break;

         case YXML_ELEMEND:
            --level;

            if (valptr > buf->val)
            {
               *valptr = '\0';

               /* Original code was broken here:
                * > If an element ended on two successive
                *   iterations, on the second iteration
                *   the 'data' for the *previous* node would
                *   get overwritten
                * > This effectively erased the data for the
                *   previous node, *and* caused a memory leak
                *   (due to the double strdup())
                * It seems the correct thing to do here is
                * only copy the data if the current 'level'
                * and 'stack index' are the same... */
               if (level == stack_i)
               {
                  if (node->data)
                     free(node->data);
                  node->data = strdup(buf->val);
               }

               valptr = buf->val;
            }

            if (level < stack_i)
            {
               --stack_i;
               node = buf->stack[stack_i];
            }
            break;

         case YXML_CONTENT:
            for (i = 0; i < (int)sizeof(x.data) && x.data[i]; i++)
            {
               *valptr = x.data[i];
               ++valptr;
            }
            break;

         case YXML_ATTRSTART:
            if (attr)
               attr = attr->next   = (struct rxml_attrib_node*)
                     calloc(1, sizeof(*attr));
            else
               attr = node->attrib = (struct rxml_attrib_node*)calloc(1, sizeof(*attr));

            if (attr->attrib)
               free(attr->attrib);
            attr->attrib = strdup(x.attr);

            valptr       = buf->val;
            break;

         case YXML_ATTRVAL:
            for (i = 0; i < (int)sizeof(x.data) && x.data[i]; i++)
            {
               *valptr = x.data[i];
               ++valptr;
            }
            break;

         case YXML_ATTREND:
            if (valptr > buf->val)
            {
               *valptr = '\0';

               if (attr)
               {
                  if (attr->value)
                     free(attr->value);
                  attr->value = strdup(buf->val);
               }

               valptr      = buf->val;
            }
            break;

         default:
            break;
      }
   }

   free(buf);
   return doc;

error:
   rxml_free_document(doc);
   free(buf);
   return NULL;
}

void rxml_free_document(rxml_document_t *doc)
{
   if (!doc)
      return;

   if (doc->root_node)
      rxml_free_node(doc->root_node);

   free(doc);
}

const char *rxml_node_attrib(struct rxml_node *node, const char *attrib)
{
   struct rxml_attrib_node *attribs = NULL;
   for (attribs = node->attrib; attribs; attribs = attribs->next)
   {
      if (string_is_equal(attrib, attribs->attrib))
         return attribs->value;
   }

   return NULL;
}
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 (rxml.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 <boolean.h>
	24	#include <streams/file_stream.h>
	25	#include <compat/posix_string.h>
	26	#include <string/stdstring.h>
	27
	28	#include <formats/rxml.h>
	29
	30	#include "../../deps/yxml/yxml.h"
	31
	32	#define BUFSIZE 4096
	33
	34	struct rxml_parse_buffer
	35	{
	36	rxml_node_t *stack[32];
	37	char xml[BUFSIZE];
	38	char val[BUFSIZE];
	39	};
	40
	41	struct rxml_document
	42	{
	43	struct rxml_node *root_node;
	44	};
	45
	46	struct rxml_node rxml_root_node(rxml_document_t doc)
	47	{
	48	if (doc)
	49	return doc->root_node;
	50	return NULL;
	51	}
	52
	53	static void rxml_free_node(struct rxml_node *node)
	54	{
	55	struct rxml_node *head = NULL;
	56	struct rxml_attrib_node *attrib_node_head = NULL;
	57
	58	if (!node)
	59	return;
	60
	61	for (head = node->children; head; )
	62	{
	63	struct rxml_node next_node = (struct rxml_node)head->next;
	64	rxml_free_node(head);
65	head = next_node;
66	}
67
68	for (attrib_node_head = node->attrib; attrib_node_head; )
69	{
70	struct rxml_attrib_node *next_attrib =
71	(struct rxml_attrib_node*)attrib_node_head->next;
72
73	if (attrib_node_head->attrib)
74	free(attrib_node_head->attrib);
75	if (attrib_node_head->value)
76	free(attrib_node_head->value);
77	if (attrib_node_head)
78	free(attrib_node_head);
79
80	attrib_node_head = next_attrib;
81	}
82
83	if (node->name)
84	free(node->name);
85	if (node->data)
86	free(node->data);
87	if (node)
88	free(node);
89	}
90
91	rxml_document_t rxml_load_document(const char path)
92	{
93	rxml_document_t *doc = NULL;
94	char *memory_buffer = NULL;
95	int64_t len = 0;
96	RFILE *file = filestream_open(path,
97	RETRO_VFS_FILE_ACCESS_READ,
98	RETRO_VFS_FILE_ACCESS_HINT_NONE);
99	if (!file)
100	return NULL;
101
102	len = filestream_get_size(file);
103	memory_buffer = (char*)malloc((size_t)(len + 1));
104	if (!memory_buffer)
105	goto error;
106
107	memory_buffer[len] = '\0';
108	if (filestream_read(file, memory_buffer, len) != len)
109	goto error;
110
111	filestream_close(file);
112	file = NULL;
113
114	doc = rxml_load_document_string(memory_buffer);
115
116	free(memory_buffer);
117	return doc;
118
119	error:
120	free(memory_buffer);
121	if (file)
122	filestream_close(file);
123	return NULL;
124	}
125
126	rxml_document_t rxml_load_document_string(const char str)
127	{
128	yxml_t x;
129	rxml_document_t *doc = NULL;
130	size_t stack_i = 0;
131	size_t level = 0;
132	int i = 0;
133	char *valptr = NULL;
134	rxml_node_t *node = NULL;
135	struct rxml_attrib_node *attr = NULL;
136	struct rxml_parse_buffer buf = (struct rxml_parse_buffer)
137	malloc(sizeof(*buf));
138	if (!buf)
139	return NULL;
140
141	valptr = buf->val;
142	doc = (rxml_document_t)malloc(sizeof(doc));
143	if (!doc)
144	goto error;
145
146	yxml_init(&x, buf->xml, BUFSIZE);
147
148	for (; *str; ++str)
149	{
150	yxml_ret_t r = yxml_parse(&x, *str);
151
152	if (r < 0)
153	goto error;
154
155	switch (r)
156	{
157
158	case YXML_ELEMSTART:
159	if (node)
160	{
161	if (level > stack_i)
162	{
163	buf->stack[stack_i] = node;
164	++stack_i;
165
166	node->children = (rxml_node_t*)
167	malloc(sizeof(*node));
168
169	node->children->name = NULL;
170	node->children->data = NULL;
171	node->children->attrib = NULL;
172	node->children->children = NULL;
173	node->children->next = NULL;
174
175	node = node->children;
176	}
177	else
178	{
179	node->next = (rxml_node_t*)
180	malloc(sizeof(*node));
181
182	node->next->name = NULL;
183	node->next->data = NULL;
184	node->next->attrib = NULL;
185	node->next->children = NULL;
186	node->next->next = NULL;
187
188	node = node->next;
189	}
190	}
191	else
192	node = doc->root_node = (rxml_node_t*)
193	calloc(1, sizeof(*node));
194
195	if (node->name)
196	free(node->name);
197	node->name = strdup(x.elem);
198
199	attr = NULL;
200	valptr = buf->val;
201
202	++level;
203	break;
204
205	case YXML_ELEMEND:
206	--level;
207
208	if (valptr > buf->val)
209	{
210	*valptr = '\0';
211
212	/* Original code was broken here:
213	* > If an element ended on two successive
214	* iterations, on the second iteration
215	* the 'data' for the previous node would
216	* get overwritten
217	* > This effectively erased the data for the
218	* previous node, and caused a memory leak
219	* (due to the double strdup())
220	* It seems the correct thing to do here is
221	* only copy the data if the current 'level'
222	* and 'stack index' are the same... */
223	if (level == stack_i)
224	{
225	if (node->data)
226	free(node->data);
227	node->data = strdup(buf->val);
228	}
229
230	valptr = buf->val;
231	}
232
233	if (level < stack_i)
234	{
235	--stack_i;
236	node = buf->stack[stack_i];
237	}
238	break;
239
240	case YXML_CONTENT:
241	for (i = 0; i < (int)sizeof(x.data) && x.data[i]; i++)
242	{
243	*valptr = x.data[i];
244	++valptr;
245	}
246	break;
247
248	case YXML_ATTRSTART:
249	if (attr)
250	attr = attr->next = (struct rxml_attrib_node*)
251	calloc(1, sizeof(*attr));
252	else
253	attr = node->attrib = (struct rxml_attrib_node)calloc(1, sizeof(attr));
254
255	if (attr->attrib)
256	free(attr->attrib);
257	attr->attrib = strdup(x.attr);
258
259	valptr = buf->val;
260	break;
261
262	case YXML_ATTRVAL:
263	for (i = 0; i < (int)sizeof(x.data) && x.data[i]; i++)
264	{
265	*valptr = x.data[i];
266	++valptr;
267	}
268	break;
269
270	case YXML_ATTREND:
271	if (valptr > buf->val)
272	{
273	*valptr = '\0';
274
275	if (attr)
276	{
277	if (attr->value)
278	free(attr->value);
279	attr->value = strdup(buf->val);
280	}
281
282	valptr = buf->val;
283	}
284	break;
285
286	default:
287	break;
288	}
289	}
290
291	free(buf);
292	return doc;
293
294	error:
295	rxml_free_document(doc);
296	free(buf);
297	return NULL;
298	}
299
300	void rxml_free_document(rxml_document_t *doc)
301	{
302	if (!doc)
303	return;
304
305	if (doc->root_node)
306	rxml_free_node(doc->root_node);
307
308	free(doc);
309	}
310
311	const char rxml_node_attrib(struct rxml_node node, const char *attrib)
312	{
313	struct rxml_attrib_node *attribs = NULL;
314	for (attribs = node->attrib; attribs; attribs = attribs->next)
315	{
316	if (string_is_equal(attrib, attribs->attrib))
317	return attribs->value;
318	}
319
320	return NULL;
321	}