/* gtkbuilderparser.c

 * Copyright (C) 2006-2007 Async Open Source,

 *                         Johan Dahlin <jdahlin@async.com.br>

 *

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

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library 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

 * Library General Public License for more details.

 *

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

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

#include "config.h"

#include <string.h>

#include <gmodule.h>

#include "gtktypeutils.h"

#include "gtkbuilderprivate.h"

#include "gtkbuilder.h"

#include "gtkbuildable.h"

#include "gtkdebug.h"

#include "gtkversion.h"

#include "gtktypeutils.h"

#include "gtkintl.h"

#include "gtkalias.h"

static void free_property_info (PropertyInfo *info);

static void free_object_info (ObjectInfo *info);

static inline void

state_push (ParserData *data, gpointer info)

{

  data->stack = g_slist_prepend (data->stack, info);

}

static inline gpointer

state_peek (ParserData *data)

{

  if (!data->stack)

    return NULL;

  return data->stack->data;

}

static inline gpointer

state_pop (ParserData *data)

{

  gpointer old = NULL;

  if (!data->stack)

    return NULL;

  old = data->stack->data;

  data->stack = g_slist_delete_link (data->stack, data->stack);

  return old;

}

#define state_peek_info(data, st) ((st*)state_peek(data))

#define state_pop_info(data, st) ((st*)state_pop(data))

static void

error_missing_attribute (ParserData *data,

                         const gchar *tag,

                         const gchar *attribute,

                         GError **error)

{

  gint line_number, char_number;

  g_markup_parse_context_get_position (data->ctx,

                                       &line_number,

                                       &char_number);

  g_set_error (error,

               GTK_BUILDER_ERROR,

               GTK_BUILDER_ERROR_MISSING_ATTRIBUTE,

               "%s:%d:%d <%s> requires attribute \"%s\"",

               data->filename,

               line_number, char_number, tag, attribute);

}

static void

error_invalid_attribute (ParserData *data,

                         const gchar *tag,

                         const gchar *attribute,

                         GError **error)

{

  gint line_number, char_number;

  g_markup_parse_context_get_position (data->ctx,

                                       &line_number,

                                       &char_number);

  g_set_error (error,

               GTK_BUILDER_ERROR,

               GTK_BUILDER_ERROR_INVALID_ATTRIBUTE,

               "%s:%d:%d '%s' is not a valid attribute of <%s>",

               data->filename,

               line_number, char_number, attribute, tag);

}

static void

error_invalid_tag (ParserData *data,

		   const gchar *tag,

		   const gchar *expected,

		   GError **error)

{

  gint line_number, char_number;

  g_markup_parse_context_get_position (data->ctx,

                                       &line_number,

                                       &char_number);

  if (expected)

    g_set_error (error,

		 GTK_BUILDER_ERROR,

		 GTK_BUILDER_ERROR_INVALID_TAG,

		 "%s:%d:%d '%s' is not a valid tag here, expected a '%s' tag",

		 data->filename,

		 line_number, char_number, tag, expected);

  else

    g_set_error (error,

		 GTK_BUILDER_ERROR,

		 GTK_BUILDER_ERROR_INVALID_TAG,

		 "%s:%d:%d '%s' is not a valid tag here",

		 data->filename,

		 line_number, char_number, tag);

}

gboolean

_gtk_builder_boolean_from_string (const gchar  *string,

				  gboolean     *value,

				  GError      **error)

{

  gboolean retval = TRUE;

  int length;

  g_assert (string != NULL);

  length = strlen (string);

  if (length == 0)

    retval = FALSE;

  else if (length == 1)

    {

      gchar c = g_ascii_tolower (string[0]);

      if (c == 'y' || c == 't' || c == '1')

	*value = TRUE;

      else if (c == 'n' || c == 'f' || c == '0')

	*value = FALSE;

      else

	retval = FALSE;

    }

  else

    {

      gchar *lower = g_ascii_strdown (string, length);

      if (strcmp (lower, "yes") == 0 || strcmp (lower, "true") == 0)

	*value = TRUE;

      else if (strcmp (lower, "no") == 0 || strcmp (lower, "false") == 0)

	*value = FALSE;

      else

	retval = FALSE;

      g_free (lower);

    }

  if (!retval)

    g_set_error (error,

		 GTK_BUILDER_ERROR,

		 GTK_BUILDER_ERROR_INVALID_VALUE,

		 "could not parse boolean `%s'",

		 string);

  return retval;

}

static GObject *

builder_construct (ParserData  *data,

                   ObjectInfo  *object_info,

		   GError     **error)

{

  GObject *object;

  g_assert (object_info != NULL);

  if (object_info->object)

    return object_info->object;

  object_info->properties = g_slist_reverse (object_info->properties);

  object = _gtk_builder_construct (data->builder, object_info, error);

  if (!object)

    return NULL;

  g_assert (G_IS_OBJECT (object));

  object_info->object = object;

  return object;

}

static gchar *

_get_type_by_symbol (const gchar* symbol)

{

  static GModule *module = NULL;

  GTypeGetFunc func;

  GType type;

  if (!module)

    module = g_module_open (NULL, 0);

  if (!g_module_symbol (module, symbol, (gpointer)&func))

    return NULL;

  type = func ();

  if (type == G_TYPE_INVALID)

    return NULL;

  return g_strdup (g_type_name (type));

}

static void

parse_requires (ParserData   *data,

		const gchar  *element_name,

		const gchar **names,

		const gchar **values,

		GError      **error)

{

  RequiresInfo *req_info;

  const gchar  *library = NULL;

  const gchar  *version = NULL;

  gchar       **split;

  gint          i, version_major = 0, version_minor = 0;

  gint          line_number, char_number;

  g_markup_parse_context_get_position (data->ctx,

                                       &line_number,

                                       &char_number);

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

    {

      if (strcmp (names[i], "lib") == 0)

        library = values[i];

      else if (strcmp (names[i], "version") == 0)

	version = values[i];

      else

	error_invalid_attribute (data, element_name, names[i], error);

    }

  if (!library || !version)

    {

      error_missing_attribute (data, element_name, 

			       version ? "lib" : "version", error);

      return;

    }

  if (!(split = g_strsplit (version, ".", 2)) || !split[0] || !split[1])

    {

      g_set_error (error,

		   GTK_BUILDER_ERROR,

		   GTK_BUILDER_ERROR_INVALID_VALUE,

		   "%s:%d:%d <%s> attribute has malformed value \"%s\"",

		   data->filename,

		   line_number, char_number, "version", version);

      return;

    }

  version_major = g_ascii_strtoll (split[0], NULL, 10);

  version_minor = g_ascii_strtoll (split[1], NULL, 10);

  g_strfreev (split);

  req_info = g_slice_new0 (RequiresInfo);

  req_info->library = g_strdup (library);

  req_info->major   = version_major;

  req_info->minor   = version_minor;

  state_push (data, req_info);

  req_info->tag.name = element_name;

}

static gboolean

is_requested_object (const gchar *object,

                     ParserData  *data)

{

  GSList *l;

  for (l = data->requested_objects; l; l = l->next)

    {

      if (strcmp (l->data, object) == 0)

        return TRUE;

    }

  return FALSE;

}

static void

parse_object (GMarkupParseContext  *context,

              ParserData           *data,

              const gchar          *element_name,

              const gchar         **names,

              const gchar         **values,

              GError              **error)

{

  ObjectInfo *object_info;

  ChildInfo* child_info;

  int i;

  gchar *object_class = NULL;

  gchar *object_id = NULL;

  gchar *constructor = NULL;

  gint line, line2;

  child_info = state_peek_info (data, ChildInfo);

  if (child_info && strcmp (child_info->tag.name, "object") == 0)

    {

      error_invalid_tag (data, element_name, NULL, error);

      return;

    }

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

    {

      if (strcmp (names[i], "class") == 0)

        object_class = g_strdup (values[i]);

      else if (strcmp (names[i], "id") == 0)

        object_id = g_strdup (values[i]);

      else if (strcmp (names[i], "constructor") == 0)

        constructor = g_strdup (values[i]);

      else if (strcmp (names[i], "type-func") == 0)

        {

	  /* Call the GType function, and return the name of the GType,

	   * it's guaranteed afterwards that g_type_from_name on the name

	   * will return our GType

	   */

          object_class = _get_type_by_symbol (values[i]);

          if (!object_class)

            {

              g_markup_parse_context_get_position (context, &line, NULL);

              g_set_error (error, GTK_BUILDER_ERROR,

                           GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION,

                           _("Invalid type function on line %d: '%s'"),

                           line, values[i]);

              return;

            }

        }

      else

	{

	  error_invalid_attribute (data, element_name, names[i], error);

	  return;

	}

    }

  if (!object_class)

    {

      error_missing_attribute (data, element_name, "class", error);

      return;

    }

  if (!object_id)

    {

      error_missing_attribute (data, element_name, "id", error);

      return;

    }

  ++data->cur_object_level;

  /* check if we reached a requested object (if it is specified) */

  if (data->requested_objects && !data->inside_requested_object)

    {

      if (is_requested_object (object_id, data))

        {

          data->requested_object_level = data->cur_object_level;

          GTK_NOTE (BUILDER, g_print ("requested object \"%s\" found at level %d\n",

                                      object_id,

                                      data->requested_object_level));

          data->inside_requested_object = TRUE;

        }

      else

        {

          g_free (object_class);

          g_free (object_id);

          g_free (constructor);

          return;

        }

    }

  object_info = g_slice_new0 (ObjectInfo);

  object_info->class_name = object_class;

  object_info->id = object_id;

  object_info->constructor = constructor;

  state_push (data, object_info);

  object_info->tag.name = element_name;

  if (child_info)

    object_info->parent = (CommonInfo*)child_info;

  g_markup_parse_context_get_position (context, &line, NULL);

  line2 = GPOINTER_TO_INT (g_hash_table_lookup (data->object_ids, object_id));

  if (line2 != 0)

    {

      g_set_error (error, GTK_BUILDER_ERROR,

                   GTK_BUILDER_ERROR_DUPLICATE_ID,

                   _("Duplicate object ID '%s' on line %d (previously on line %d)"),

                   object_id, line, line2);

      return;

    }

  g_hash_table_insert (data->object_ids, g_strdup (object_id), GINT_TO_POINTER (line));

}

static void

free_object_info (ObjectInfo *info)

{

  /* Do not free the signal items, which GtkBuilder takes ownership of */

  g_slist_free (info->signals);

  g_slist_foreach (info->properties,

                   (GFunc)free_property_info, NULL);

  g_slist_free (info->properties);

  g_free (info->constructor);

  g_free (info->class_name);

  g_free (info->id);

  g_slice_free (ObjectInfo, info);

}

static void

parse_child (ParserData   *data,

             const gchar  *element_name,

             const gchar **names,

             const gchar **values,

             GError      **error)

{

  ObjectInfo* object_info;

  ChildInfo *child_info;

  guint i;

  object_info = state_peek_info (data, ObjectInfo);

  if (!object_info || strcmp (object_info->tag.name, "object") != 0)

    {

      error_invalid_tag (data, element_name, NULL, error);

      return;

    }

  child_info = g_slice_new0 (ChildInfo);

  state_push (data, child_info);

  child_info->tag.name = element_name;

  for (i = 0; names[i]; i++)

    {

      if (strcmp (names[i], "type") == 0)

        child_info->type = g_strdup (values[i]);

      else if (strcmp (names[i], "internal-child") == 0)

        child_info->internal_child = g_strdup (values[i]);

      else

	error_invalid_attribute (data, element_name, names[i], error);

    }

  child_info->parent = (CommonInfo*)object_info;

  object_info->object = builder_construct (data, object_info, error);

}

static void

free_child_info (ChildInfo *info)

{

  g_free (info->type);

  g_free (info->internal_child);

  g_slice_free (ChildInfo, info);

}

static void

parse_property (ParserData   *data,

                const gchar  *element_name,

                const gchar **names,

                const gchar **values,

                GError      **error)

{

  PropertyInfo *info;

  gchar *name = NULL;

  gchar *context = NULL;

  gboolean translatable = FALSE;

  ObjectInfo *object_info;

  int i;

  object_info = state_peek_info (data, ObjectInfo);

  if (!object_info || strcmp (object_info->tag.name, "object") != 0)

    {

      error_invalid_tag (data, element_name, NULL, error);

      return;

    }

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

    {

      if (strcmp (names[i], "name") == 0)

        name = g_strdelimit (g_strdup (values[i]), "_", '-');

      else if (strcmp (names[i], "translatable") == 0)

	{

	  if (!_gtk_builder_boolean_from_string (values[i], &translatable,

						 error))

	    return;

	}

      else if (strcmp (names[i], "comments") == 0)

        {

          /* do nothing, comments are for translators */

        }

      else if (strcmp (names[i], "context") == 0) 

        {

          context = g_strdup (values[i]);

        }

      else

	{

	  error_invalid_attribute (data, element_name, names[i], error);

	  return;

	}

    }

  if (!name)

    {

      error_missing_attribute (data, element_name, "name", error);

      return;

    }

  info = g_slice_new0 (PropertyInfo);

  info->name = name;

  info->translatable = translatable;

  info->context = context;

  info->text = g_string_new ("");

  state_push (data, info);

  info->tag.name = element_name;

}

static void

free_property_info (PropertyInfo *info)

{

  g_free (info->data);

  g_free (info->name);

  g_slice_free (PropertyInfo, info);

}

static void

parse_signal (ParserData   *data,

              const gchar  *element_name,

              const gchar **names,

              const gchar **values,

              GError      **error)

{

  SignalInfo *info;

  gchar *name = NULL;

  gchar *handler = NULL;

  gchar *object = NULL;

  gboolean after = FALSE;

  gboolean swapped = FALSE;

  gboolean swapped_set = FALSE;

  ObjectInfo *object_info;

  int i;

  object_info = state_peek_info (data, ObjectInfo);

  if (!object_info || strcmp (object_info->tag.name, "object") != 0)

    {

      error_invalid_tag (data, element_name, NULL, error);

      return;

    }

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

    {

      if (strcmp (names[i], "name") == 0)

        name = g_strdup (values[i]);

      else if (strcmp (names[i], "handler") == 0)

        handler = g_strdup (values[i]);

      else if (strcmp (names[i], "after") == 0)

	{

	  if (!_gtk_builder_boolean_from_string (values[i], &after, error))

	    return;

	}

      else if (strcmp (names[i], "swapped") == 0)

	{

	  if (!_gtk_builder_boolean_from_string (values[i], &swapped, error))

	    return;

	  swapped_set = TRUE;

	}

      else if (strcmp (names[i], "object") == 0)

        object = g_strdup (values[i]);

      else if (strcmp (names[i], "last_modification_time") == 0)

	/* parse but ignore */

	;

      else

	{

	  error_invalid_attribute (data, element_name, names[i], error);

	  return;

	}

    }

  if (!name)

    {

      error_missing_attribute (data, element_name, "name", error);

      return;

    }

  else if (!handler)

    {

      error_missing_attribute (data, element_name, "handler", error);

      return;

    }

  /* Swapped defaults to FALSE except when object is set */

  if (object && !swapped_set)

    swapped = TRUE;

  info = g_slice_new0 (SignalInfo);

  info->name = name;

  info->handler = handler;

  if (after)

    info->flags |= G_CONNECT_AFTER;

  if (swapped)

    info->flags |= G_CONNECT_SWAPPED;

  info->connect_object_name = object;

  state_push (data, info);

  info->tag.name = element_name;

}

/* Called by GtkBuilder */

void

_free_signal_info (SignalInfo *info,

                   gpointer user_data)

{

  g_free (info->name);

  g_free (info->handler);

  g_free (info->connect_object_name);

  g_free (info->object_name);

  g_slice_free (SignalInfo, info);

}

void

_free_requires_info (RequiresInfo *info,

		     gpointer user_data)

{

  g_free (info->library);

  g_slice_free (RequiresInfo, info);

}

static void

parse_interface (ParserData   *data,

		 const gchar  *element_name,

		 const gchar **names,

		 const gchar **values,

		 GError      **error)

{

  int i;

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

    {

      if (strcmp (names[i], "domain") == 0)

	{

	  if (data->domain)

	    {

	      if (strcmp (data->domain, values[i]) == 0)

		continue;

	      else

		g_warning ("%s: interface domain '%s' overrides "

			   "programically set domain '%s'",

			   data->filename,

			   values[i],

			   data->domain

			   );

	      g_free (data->domain);

	    }

 	  data->domain = g_strdup (values[i]);

	  gtk_builder_set_translation_domain (data->builder, data->domain);

	}

      else

	error_invalid_attribute (data, "interface", names[i], error);

    }

}

static SubParser *

create_subparser (GObject       *object,

		  GObject       *child,

		  const gchar   *element_name,

		  GMarkupParser *parser,

		  gpointer       user_data)

{

  SubParser *subparser;

  subparser = g_slice_new0 (SubParser);

  subparser->object = object;

  subparser->child = child;

  subparser->tagname = g_strdup (element_name);

  subparser->start = element_name;

  subparser->parser = g_memdup (parser, sizeof (GMarkupParser));

  subparser->data = user_data;

  return subparser;

}

static void

free_subparser (SubParser *subparser)

{

  g_free (subparser->tagname);

  g_slice_free (SubParser, subparser);

}

static gboolean

subparser_start (GMarkupParseContext *context,

		 const gchar         *element_name,

		 const gchar        **names,

		 const gchar        **values,

		 ParserData          *data,

		 GError             **error)

{

  SubParser *subparser = data->subparser;

  if (!subparser->start &&

      strcmp (element_name, subparser->tagname) == 0)

    subparser->start = element_name;

  if (subparser->start)

    {

      if (subparser->parser->start_element)

	subparser->parser->start_element (context,

					  element_name, names, values,

					  subparser->data, error);

      return FALSE;

    }

  return TRUE;

}

static void

subparser_end (GMarkupParseContext *context,

	       const gchar         *element_name,

	       ParserData          *data,

	       GError             **error)

{

  if (data->subparser->parser->end_element)

    data->subparser->parser->end_element (context, element_name,

					  data->subparser->data, error);

  if (!strcmp (data->subparser->start, element_name) == 0)

    return;

  gtk_buildable_custom_tag_end (GTK_BUILDABLE (data->subparser->object),

				data->builder,

				data->subparser->child,

				element_name,

				data->subparser->data);

  g_free (data->subparser->parser);

  if (GTK_BUILDABLE_GET_IFACE (data->subparser->object)->custom_finished)

    data->custom_finalizers = g_slist_prepend (data->custom_finalizers,

					       data->subparser);

  else

    free_subparser (data->subparser);

  data->subparser = NULL;

}

static gboolean

parse_custom (GMarkupParseContext *context,

	      const gchar         *element_name,

	      const gchar        **names,

	      const gchar        **values,

	      ParserData          *data,

	      GError             **error)

{

  CommonInfo* parent_info;

  GMarkupParser parser;

  gpointer subparser_data;

  GObject *object;

  GObject *child;

  parent_info = state_peek_info (data, CommonInfo);

  if (!parent_info)

    return FALSE;

  if (strcmp (parent_info->tag.name, "object") == 0)

    {

      ObjectInfo* object_info = (ObjectInfo*)parent_info;

      if (!object_info->object)

	{

	  object_info->properties = g_slist_reverse (object_info->properties);

	  object_info->object = _gtk_builder_construct (data->builder,

							object_info,

							error);

	  if (!object_info->object)

	    return TRUE; /* A GError is already set */

	}

      g_assert (object_info->object);

      object = object_info->object;

      child = NULL;

    }

  else if (strcmp (parent_info->tag.name, "child") == 0)

    {

      ChildInfo* child_info = (ChildInfo*)parent_info;

      _gtk_builder_add (data->builder, child_info);

      object = ((ObjectInfo*)child_info->parent)->object;

      child  = child_info->object;

    }

  else

    return FALSE;

  if (!gtk_buildable_custom_tag_start (GTK_BUILDABLE (object),

				       data->builder,

				       child,

				       element_name,

				       &parser,

				       &subparser_data))

    return FALSE;

  data->subparser = create_subparser (object, child, element_name,

				      &parser, subparser_data);

  if (parser.start_element)

    parser.start_element (context,

			  element_name, names, values,

			  subparser_data, error);

  return TRUE;

}

static void

start_element (GMarkupParseContext *context,

               const gchar         *element_name,

               const gchar        **names,

               const gchar        **values,

               gpointer             user_data,

               GError             **error)

{

  ParserData *data = (ParserData*)user_data;

#ifdef GTK_ENABLE_DEBUG

  if (gtk_debug_flags & GTK_DEBUG_BUILDER)

    {

      GString *tags = g_string_new ("");

      int i;

      for (i = 0; names[i]; i++)

        g_string_append_printf (tags, "%s=\"%s\" ", names[i], values[i]);

      if (i)

        {

          g_string_insert_c (tags, 0, ' ');

          g_string_truncate (tags, tags->len - 1);

        }

      g_print ("<%s%s>\n", element_name, tags->str);

      g_string_free (tags, TRUE);

    }

#endif

  if (!data->last_element && strcmp (element_name, "interface") != 0)

    {

      g_set_error (error, GTK_BUILDER_ERROR, 

		   GTK_BUILDER_ERROR_UNHANDLED_TAG,

		   _("Invalid root element: '%s'"),

		   element_name);

      return;

    }

  data->last_element = element_name;

  if (data->subparser)

    if (!subparser_start (context, element_name, names, values,

			  data, error))

      return;

  if (strcmp (element_name, "requires") == 0)

    parse_requires (data, element_name, names, values, error);

  else if (strcmp (element_name, "object") == 0)

    parse_object (context, data, element_name, names, values, error);

  else if (data->requested_objects && !data->inside_requested_object)

    {

      /* If outside a requested object, simply ignore this tag */

      return;

    }

  else if (strcmp (element_name, "child") == 0)

    parse_child (data, element_name, names, values, error);