/* -*- mode: C; c-file-style: "gnu" -*- */

 /* dbus-gloader-expat.c  expat XML loader

  *

  * Copyright (C) 2003 Red Hat, Inc.

  *

  * Licensed under the Academic Free License version 2.1

  *

  * This program is free software; you can redistribute it and/or modify

  * it under the terms of the GNU General Public License as published by

  * the Free Software Foundation; either version 2 of the License, or

  * (at your option) any later version.

  *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

  *

  * You should have received a copy of the GNU General Public License

  * along with this program; if not, write to the Free Software

  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  *

  */

 #include "dbus-gparser.h"

 #include <expat.h>

 #include <string.h>

 static void*

 expat_g_malloc (size_t sz)

 {

   return g_malloc (sz);

 }

 static void*

 expat_g_realloc (void *mem, size_t sz)

 {

   return g_realloc (mem, sz);

 }

 static XML_Memory_Handling_Suite memsuite =

 {

   expat_g_malloc,

   expat_g_realloc,

   g_free

 };

 /**

  * Context for Expat parser for introspection data.

  */

 typedef struct

 {

   Parser *parser;       /**< The parser for the introspection data */

   const char *filename; /**< The filename being loaded */

   GString *content;     /**< The content of the current element */

   GError **error;       /**< Error return location */

   gboolean failed;      /**< True if parse has failed */

 } ExpatParseContext;

 static dbus_bool_t

 process_content (ExpatParseContext *context)

 {

   if (context->failed)

     return FALSE;

   if (context->content->len > 0)

     {

       if (!parser_content (context->parser,

                            context->content->str,

                            context->content->len,

                            context->error))

         {

           context->failed = TRUE;

           return FALSE;

         }

       g_string_set_size (context->content, 0);

     }

   return TRUE;

 }

 static void

 expat_StartElementHandler (void            *userData,

                            const XML_Char  *name,

                            const XML_Char **atts)

 {

   ExpatParseContext *context = userData;

   int i;

   char **names;

   char **values;

   /* Expat seems to suck and can't abort the parse if we

    * throw an error. Expat 2.0 is supposed to fix this.

    */

   if (context->failed)

     return;

   if (!process_content (context))

     return;

   /* "atts" is key, value, key, value, NULL */

   for (i = 0; atts[i] != NULL; ++i)

     ; /* nothing */

   g_assert (i % 2 == 0);

   names = g_new0 (char *, i / 2 + 1);

   values = g_new0 (char *, i / 2 + 1);

   i = 0;

   while (atts[i] != NULL)

     {

       g_assert (i % 2 == 0);

       names [i / 2] = (char*) atts[i];

       values[i / 2] = (char*) atts[i+1];

       i += 2;

     }

   if (!parser_start_element (context->parser,

                              name,

                              (const char **) names,

                              (const char **) values,

                              context->error))

     {

       g_free (names);

       g_free (values);

       context->failed = TRUE;

       return;

     }

   g_free (names);

   g_free (values);

 }

 static void

 expat_EndElementHandler (void           *userData,

                          const XML_Char *name)

 {

   ExpatParseContext *context = userData;

   if (!process_content (context))

     return;

   if (!parser_end_element (context->parser,

                            name,

                            context->error))

     {

       context->failed = TRUE;

       return;

     }

 }

 /* s is not 0 terminated. */

 static void

 expat_CharacterDataHandler (void           *userData,

                             const XML_Char *s,

                             int             len)

 {

   ExpatParseContext *context = userData;

   if (context->failed)

     return;

   g_string_append_len (context->content,

                        s, len);

 }

 NodeInfo*

 description_load_from_file (const char       *filename,

                             GError          **error)

 {

   char *contents;

   gsize len;

   NodeInfo *nodes;

   contents = NULL;

   if (!g_file_get_contents (filename, &contents, &len, error))

     return NULL;

   nodes = description_load_from_string (contents, len, error);

   g_free (contents);

   return nodes;

 }

 NodeInfo*

 description_load_from_string (const char  *str,

                               int          len,

                               GError     **error)

 {

   XML_Parser expat;

   ExpatParseContext context;

   NodeInfo *nodes;

   g_return_val_if_fail (error == NULL || *error == NULL, NULL);

   if (len < 0)

     len = strlen (str);

   expat = NULL;

   context.parser = NULL;

   context.error = error;

   context.failed = FALSE;

   expat = XML_ParserCreate_MM ("UTF-8", &memsuite, NULL);

   if (expat == NULL)

     g_error ("No memory to create XML parser\n");

   context.parser = parser_new ();

   context.content = g_string_new (NULL);

   XML_SetUserData (expat, &context);

   XML_SetElementHandler (expat,

                          expat_StartElementHandler,

                          expat_EndElementHandler);

   XML_SetCharacterDataHandler (expat,

                                expat_CharacterDataHandler);

   if (!XML_Parse (expat, str, len, TRUE))

     {

       if (context.error != NULL &&

           *context.error == NULL)

         {

             enum XML_Error e;

             e = XML_GetErrorCode (expat);

             if (e == XML_ERROR_NO_MEMORY)

               g_error ("Not enough memory to parse XML document");

             else

               g_set_error (error,

                            G_MARKUP_ERROR,

                            G_MARKUP_ERROR_PARSE,

                            "Error in D-BUS description XML, line %d, column %d: %s\n",

                            XML_GetCurrentLineNumber (expat),

                            XML_GetCurrentColumnNumber (expat),

                            XML_ErrorString (e));

         }

         goto failed;

     }

   if (context.failed)

     goto failed;

   if (!parser_finished (context.parser, error))

     goto failed;

   XML_ParserFree (expat);

   g_string_free (context.content, TRUE);

   g_return_val_if_fail (error == NULL || *error == NULL, NULL);

   nodes = parser_get_nodes (context.parser);

   node_info_ref (nodes);

   parser_unref (context.parser);

   return nodes;

  failed:

   g_return_val_if_fail (error == NULL || *error != NULL, NULL);

   g_string_free (context.content, TRUE);

   if (expat)

     XML_ParserFree (expat);

   if (context.parser)

     parser_unref (context.parser);

   return NULL;

 }