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

/* dbus-gparser.c parse DBus description files

 *

 * Copyright (C) 2003, 2005  Red Hat, Inc.

 * Portion Copyright © 2008 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

 * 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 "dbus/dbus-glib-lowlevel.h"

#include "dbus-gidl.h"

#include "dbus-gobject.h"

#include "dbus/dbus-signature.h"

#include <string.h>

#ifndef __SYMBIAN32__

#include <libintl.h>

#define _(x) gettext ((x))

#define N_(x) x

#else

#define _(x) x

#define N_(x) x

#endif

#ifndef DOXYGEN_SHOULD_SKIP_THIS

#define ELEMENT_IS(name) (strcmp (element_name, (name)) == 0)

typedef struct

{

  const char  *name;

  const char **retloc;

} LocateAttr;

static gboolean

locate_attributes (const char  *element_name,

                   const char **attribute_names,

                   const char **attribute_values,

                   GError     **error,

                   const char  *first_attribute_name,

                   const char **first_attribute_retloc,

                   ...)

{

  va_list args;

  const char *name;

  const char **retloc;

  int n_attrs;

#define MAX_ATTRS 24

  LocateAttr attrs[MAX_ATTRS];

  gboolean retval;

  int i;

  g_return_val_if_fail (first_attribute_name != NULL, FALSE);

  g_return_val_if_fail (first_attribute_retloc != NULL, FALSE);

  retval = TRUE;

  n_attrs = 1;

  attrs[0].name = first_attribute_name;

  attrs[0].retloc = first_attribute_retloc;

  *first_attribute_retloc = NULL;

  va_start (args, first_attribute_retloc);

  name = va_arg (args, const char*);

  retloc = va_arg (args, const char**);

  while (name != NULL)

    {

      g_return_val_if_fail (retloc != NULL, FALSE);

      g_assert (n_attrs < MAX_ATTRS);

      attrs[n_attrs].name = name;

      attrs[n_attrs].retloc = retloc;

      n_attrs += 1;

      *retloc = NULL;      

      name = va_arg (args, const char*);

      retloc = va_arg (args, const char**);

    }

  va_end (args);

  if (!retval)

    return retval;

  i = 0;

  while (attribute_names[i])

    {

      int j;

      gboolean found;

      found = FALSE;

      j = 0;

      while (j < n_attrs)

        {

          if (strcmp (attrs[j].name, attribute_names[i]) == 0)

            {

              retloc = attrs[j].retloc;

              if (*retloc != NULL)

                {

                  g_set_error (error,

                               G_MARKUP_ERROR,

                               G_MARKUP_ERROR_PARSE,

                               _("Attribute \"%s\" repeated twice on the same <%s> element"),

                               attrs[j].name, element_name);

                  retval = FALSE;

                  goto out;

                }

              *retloc = attribute_values[i];

              found = TRUE;

            }

          ++j;

        }

      if (!found)

        {

          g_set_error (error,

                       G_MARKUP_ERROR,

                       G_MARKUP_ERROR_PARSE,

                       _("Attribute \"%s\" is invalid on <%s> element in this context"),

                       attribute_names[i], element_name);

          retval = FALSE;

          goto out;

        }

      ++i;

    }

 out:

  return retval;

}

#if 0

static gboolean

check_no_attributes (const char  *element_name,

                     const char **attribute_names,

                     const char **attribute_values,

                     GError     **error)

{

  if (attribute_names[0] != NULL)

    {

      g_set_error (error,

                   G_MARKUP_ERROR,

                   G_MARKUP_ERROR_PARSE,

                   _("Attribute \"%s\" is invalid on <%s> element in this context"),

                   attribute_names[0], element_name);

      return FALSE;

    }

  return TRUE;

}

#endif

struct Parser

{

  int refcount;

  NodeInfo *result; /* Filled in when we pop the last node */

  GSList *node_stack;

  InterfaceInfo *interface;

  MethodInfo *method;

  SignalInfo *signal;

  PropertyInfo *property;

  ArgInfo *arg;

  gboolean in_annotation;

};

Parser*

parser_new (void)

{

  Parser *parser;

  parser = g_new0 (Parser, 1);

  parser->refcount = 1;

  return parser;

}

Parser *

parser_ref (Parser *parser)

{

  parser->refcount += 1;

  return parser;

}

void

parser_unref (Parser *parser)

{

  parser->refcount -= 1;

  if (parser->refcount == 0)

    {

      if (parser->result)

        node_info_unref (parser->result);

      g_free (parser);

    }

}

gboolean

parser_check_doctype (Parser      *parser,

                      const char  *doctype,

                      GError     **error)

{

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

  if (strcmp (doctype, "node") != 0)

    {

      g_set_error (error,

                   G_MARKUP_ERROR,

                   G_MARKUP_ERROR_PARSE,

                   "D-BUS description file has the wrong document type %s, use node or interface",

                   doctype);

      return FALSE;

    }

  else

    return TRUE;

}

static gboolean

parse_node (Parser      *parser,

            const char  *element_name,

            const char **attribute_names,

            const char **attribute_values,

            GError     **error)

{

  const char *name;

  NodeInfo *node;

  if (parser->interface ||

      parser->method ||

      parser->signal ||

      parser->property ||

      parser->arg ||

      parser->in_annotation)

    {

      g_set_error (error, G_MARKUP_ERROR,

                   G_MARKUP_ERROR_PARSE,

                   _("Can't put <%s> element here"),

                   element_name);

      return FALSE;      

    }

  name = NULL;

  if (!locate_attributes (element_name, attribute_names,

                          attribute_values, error,

                          "name", &name,

                          NULL))

    return FALSE;

  /* Only the root node can have no name */

  if (parser->node_stack != NULL && name == NULL)

    {

      g_set_error (error, G_MARKUP_ERROR,

                   G_MARKUP_ERROR_PARSE,

                   _("\"%s\" attribute required on <%s> element "),

                   "name", element_name);

      return FALSE;

    }

  /* Root element name must be absolute */

  if (parser->node_stack == NULL && name && *name != '/')

    {

      g_set_error (error, G_MARKUP_ERROR,

                   G_MARKUP_ERROR_PARSE,

                   _("\"%s\" attribute on <%s> element must be an absolute object path, \"%s\" not OK"),

                   "name", element_name, name);

      return FALSE;

    }

  /* Other element names must not be absolute */

  if (parser->node_stack != NULL && name && *name == '/')

    {

      g_set_error (error, G_MARKUP_ERROR,

                   G_MARKUP_ERROR_PARSE,

                   _("\"%s\" attribute on <%s> element must not be an absolute object path, \"%s\" starts with /"),

                   "name", element_name, name);

      return FALSE;

    }

  node = node_info_new (name);

  if (parser->node_stack != NULL)

    {

      node_info_add_node (parser->node_stack->data,

                          node);

    }

  parser->node_stack = g_slist_prepend (parser->node_stack,

                                        node);

  return TRUE;

}

static gboolean

parse_interface (Parser      *parser,

                 const char  *element_name,

                 const char **attribute_names,

                 const char **attribute_values,

                 GError     **error)

{

  const char *name;

  InterfaceInfo *iface;

  NodeInfo *top;

  if (parser->interface ||

      parser->method ||

      parser->signal ||

      parser->property ||

      parser->arg ||

      parser->in_annotation ||

      (parser->node_stack == NULL))

    {

      g_set_error (error, G_MARKUP_ERROR,

                   G_MARKUP_ERROR_PARSE,

                   _("Can't put <%s> element here"),

                   element_name);

      return FALSE;      

    }

  name = NULL;

  if (!locate_attributes (element_name, attribute_names,

                          attribute_values, error,

                          "name", &name,

                          NULL))

    return FALSE;

  if (name == NULL)

    {

      g_set_error (error, G_MARKUP_ERROR,

                   G_MARKUP_ERROR_PARSE,

                   _("\"%s\" attribute required on <%s> element "),

                   "name", element_name);

      return FALSE;

    }

  top = parser->node_stack->data;

  iface = interface_info_new (name);

  node_info_add_interface (top, iface);

  interface_info_unref (iface);

  parser->interface = iface;

  return TRUE;

}

static gboolean

parse_method (Parser      *parser,

              const char  *element_name,

              const char **attribute_names,

              const char **attribute_values,

              GError     **error)

{

  const char *name;

  MethodInfo *method;

  if (parser->interface == NULL ||

      parser->node_stack == NULL ||

      parser->method ||

      parser->signal ||

      parser->property ||

      parser->in_annotation ||

      parser->arg)

    {

      g_set_error (error, G_MARKUP_ERROR,

                   G_MARKUP_ERROR_PARSE,

                   _("Can't put <%s> element here"),

                   element_name);

      return FALSE;      

    }

  name = NULL;

  if (!locate_attributes (element_name, attribute_names,

                          attribute_values, error,

                          "name", &name,

                          NULL))

    return FALSE;

  if (name == NULL)

    {

      g_set_error (error, G_MARKUP_ERROR,

                   G_MARKUP_ERROR_PARSE,

                   _("\"%s\" attribute required on <%s> element "),

                   "name", element_name);

      return FALSE;

    }

  method = method_info_new (name);

  interface_info_add_method (parser->interface, method);

  method_info_unref (method);

  parser->method = method;

  return TRUE;

}

static gboolean

parse_signal (Parser      *parser,

              const char  *element_name,

              const char **attribute_names,

              const char **attribute_values,

              GError     **error)

{

  const char *name;

  SignalInfo *signal;

  if (parser->interface == NULL ||

      parser->node_stack == NULL ||

      parser->signal ||

      parser->method ||

      parser->property ||

      parser->in_annotation ||

      parser->arg)

    {

      g_set_error (error, G_MARKUP_ERROR,

                   G_MARKUP_ERROR_PARSE,

                   _("Can't put <%s> element here"),

                   element_name);

      return FALSE;      

    }

  name = NULL;

  if (!locate_attributes (element_name, attribute_names,

                          attribute_values, error,

                          "name", &name,

                          NULL))

    return FALSE;

  if (name == NULL)

    {

      g_set_error (error, G_MARKUP_ERROR,

                   G_MARKUP_ERROR_PARSE,

                   _("\"%s\" attribute required on <%s> element "),

                   "name", element_name);

      return FALSE;

    }

  signal = signal_info_new (name);

  interface_info_add_signal (parser->interface, signal);

  signal_info_unref (signal);

  parser->signal = signal;

  return TRUE;

}

static gboolean

validate_signature (const char *str,

		    const char *element_name,

		    GError    **error)

{

  DBusError derror;

  dbus_error_init (&derror);

  if (!dbus_signature_validate (str, &derror))

    {

      dbus_set_g_error (error, &derror);

      return FALSE;

    }

  return TRUE;

}

static gboolean

parse_property (Parser      *parser,

                const char  *element_name,

                const char **attribute_names,

                const char **attribute_values,

                GError     **error)

{

  const char *name;

  const char *access;

  const char *type;

  PropertyInfo *property;

  PropertyAccessFlags access_flags;

  if (parser->interface == NULL ||

      parser->node_stack == NULL ||

      parser->signal ||

      parser->method ||

      parser->property ||

      parser->in_annotation ||

      parser->arg)

    {

      g_set_error (error, G_MARKUP_ERROR,

                   G_MARKUP_ERROR_PARSE,

                   _("Can't put <%s> element here"),

                   element_name);

      return FALSE;      

    }

  name = NULL;

  if (!locate_attributes (element_name, attribute_names,

                          attribute_values, error,

                          "name", &name,

                          "access", &access,

                          "type", &type,

                          NULL))

    return FALSE;

  if (name == NULL)

    {

      g_set_error (error, G_MARKUP_ERROR,

                   G_MARKUP_ERROR_PARSE,

                   _("\"%s\" attribute required on <%s> element "),

                   "name", element_name);

      return FALSE;

    }

  if (access == NULL)

    {

      g_set_error (error, G_MARKUP_ERROR,

                   G_MARKUP_ERROR_PARSE,

                   _("\"%s\" attribute required on <%s> element "),

                   "access", element_name);

      return FALSE;

    }

  if (type == NULL)

    {

      g_set_error (error, G_MARKUP_ERROR,

                   G_MARKUP_ERROR_PARSE,

                   _("\"%s\" attribute required on <%s> element "),

                   "type", element_name);

      return FALSE;

    }

  if (!validate_signature (type, element_name, error))

    return FALSE;

  access_flags = 0;

  if (strcmp (access, "readwrite") == 0)

    access_flags = PROPERTY_READ | PROPERTY_WRITE;

  else if (strcmp (access, "read") == 0)

    access_flags = PROPERTY_READ;

  else if (strcmp (access, "write") == 0)

    access_flags = PROPERTY_WRITE;

  else

    {

      g_set_error (error, G_MARKUP_ERROR,

                   G_MARKUP_ERROR_PARSE,

                   _("access=\"%s\" must have value readwrite, read, or write on %s\n"),

                   access, element_name);

      return FALSE;

    }

  property = property_info_new (name, type, access_flags);

  interface_info_add_property (parser->interface, property);

  property_info_unref (property);

  parser->property = property;

  return TRUE;

}

static gboolean

parse_arg (Parser      *parser,

           const char  *element_name,

           const char **attribute_names,

           const char **attribute_values,

           GError     **error)

{

  const char *name;

  const char *type;

  const char *direction;

  ArgDirection dir;

  ArgInfo *arg;

  char *generated_name;

  if (!(parser->method || parser->signal) ||

      parser->node_stack == NULL ||

      parser->property ||

      parser->in_annotation ||

      parser->arg)

    {

      g_set_error (error, G_MARKUP_ERROR,

                   G_MARKUP_ERROR_PARSE,

                   _("Can't put <%s> element here"),

                   element_name);

      return FALSE;      

    }

  name = NULL;

  if (!locate_attributes (element_name, attribute_names,

                          attribute_values, error,

                          "name", &name,

                          "type", &type,

                          "direction", &direction,

                          NULL))

    return FALSE;

  /* name can be null for args */

  if (type == NULL)

    {

      g_set_error (error, G_MARKUP_ERROR,

                   G_MARKUP_ERROR_PARSE,

                   _("\"%s\" attribute required on <%s> element "),

                   "type", element_name);

      return FALSE;

    }

  if (direction == NULL)

    {

      /* methods default to in, signal to out */

      if (parser->method)

        direction = "in";

      else if (parser->signal)

        direction = "out";

      else

        g_assert_not_reached ();

    }

  dir = ARG_INVALID;

  if (strcmp (direction, "in") == 0)

    dir = ARG_IN;

  else if (strcmp (direction, "out") == 0)

    dir = ARG_OUT;

  if (dir == ARG_INVALID ||

      (parser->signal && dir == ARG_IN))

    {

      if (parser->signal)

        g_set_error (error, G_MARKUP_ERROR,

                     G_MARKUP_ERROR_PARSE,

                     _("Signals must have direction=\"out\" (just omit the direction attribute)"));

      else

        g_set_error (error, G_MARKUP_ERROR,

                     G_MARKUP_ERROR_PARSE,

                     _("\"%s\" attribute on <%s> has value \"in\" or \"out\""),

                     "direction", element_name);

      return FALSE;

    }

  if (!validate_signature (type, element_name, error))

    return FALSE;

  generated_name = NULL;

  if (name == NULL)

    generated_name = g_strdup_printf ("arg%d",

                                      parser->method ?

                                      method_info_get_n_args (parser->method) :

                                      signal_info_get_n_args (parser->signal));

  arg = arg_info_new (name ? name : generated_name, dir, type);

  if (parser->method)

    method_info_add_arg (parser->method, arg);

  else if (parser->signal)

    signal_info_add_arg (parser->signal, arg);

  else

    g_assert_not_reached ();

  g_free (generated_name);

  arg_info_unref (arg);

  parser->arg = arg;

  return TRUE;

}

static gboolean

parse_annotation (Parser      *parser,

		  const char  *element_name,

		  const char **attribute_names,

		  const char **attribute_values,

		  GError     **error)

{

  const char *name;

  const char *value;

  if (!(parser->method || parser->interface || parser->arg) || 

      parser->node_stack == NULL ||

      parser->signal ||

      parser->property ||

      parser->in_annotation)

    {

      g_set_error (error, G_MARKUP_ERROR,

                   G_MARKUP_ERROR_PARSE,

                   _("Can't put <%s> element here"),

                   element_name);

      return FALSE;      

    }

  name = NULL;

  if (!locate_attributes (element_name, attribute_names,

                          attribute_values, error,

                          "name", &name,

                          "value", &value,

                          NULL))

    return FALSE;

  if (name == NULL)

    {

      g_set_error (error, G_MARKUP_ERROR,

                   G_MARKUP_ERROR_PARSE,

                   _("\"%s\" attribute required on <%s> element "),

                   "name", element_name);

      return FALSE;

    }

  if (value == NULL)

    {

      g_set_error (error, G_MARKUP_ERROR,

                   G_MARKUP_ERROR_PARSE,

                   _("\"%s\" attribute required on <%s> element "),

                   "value", element_name);

      return FALSE;

    }

  if (parser->arg)

    arg_info_add_annotation (parser->arg, name, value);

  else if (parser->method)

    method_info_add_annotation (parser->method, name, value);

  else if (parser->interface)

    interface_info_add_annotation (parser->interface, name, value);

  else

    g_assert_not_reached ();

  parser->in_annotation = TRUE;

  return TRUE;

}

gboolean

parser_start_element (Parser      *parser,

                      const char  *element_name,

                      const char **attribute_names,

                      const char **attribute_values,

                      GError     **error)

{

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

  if (ELEMENT_IS ("node"))

    {

      if (!parse_node (parser, element_name, attribute_names,

                       attribute_values, error))

        return FALSE;

    }

  else if (ELEMENT_IS ("interface"))

    {

      if (!parse_interface (parser, element_name, attribute_names,

                            attribute_values, error))

        return FALSE;

    }

  else if (ELEMENT_IS ("method"))

    {

      if (!parse_method (parser, element_name, attribute_names,

                         attribute_values, error))

        return FALSE;

    }

  else if (ELEMENT_IS ("signal"))

    {

      if (!parse_signal (parser, element_name, attribute_names,

                         attribute_values, error))

        return FALSE;

    }

  else if (ELEMENT_IS ("property"))

    {

      if (!parse_property (parser, element_name, attribute_names,

                           attribute_values, error))

        return FALSE;

    }

  else if (ELEMENT_IS ("arg"))

    {

      if (!parse_arg (parser, element_name, attribute_names,

                      attribute_values, error))

        return FALSE;

    }

  else if (ELEMENT_IS ("annotation"))

    {

      if (!parse_annotation (parser, element_name, attribute_names,

			     attribute_values, error))

        return FALSE;

    }

  else

    {

      g_set_error (error, G_MARKUP_ERROR,

                   G_MARKUP_ERROR_PARSE,

                   _("Element <%s> not recognized"),

                   element_name);

    }

  return TRUE;

}

gboolean

parser_end_element (Parser      *parser,

                    const char  *element_name,

                    GError     **error)

{

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

  if (ELEMENT_IS ("interface"))

    {

      parser->interface = NULL;

    }

  else if (ELEMENT_IS ("method"))

    {

      parser->method = NULL;

    }

  else if (ELEMENT_IS ("signal"))

    {

      parser->signal = NULL;

    }

  else if (ELEMENT_IS ("property"))

    {

      parser->property = NULL;

    }

  else if (ELEMENT_IS ("arg"))

    {

      parser->arg = NULL;

    }

  else if (ELEMENT_IS ("annotation"))

    {

      parser->in_annotation = FALSE;

    }

  else if (ELEMENT_IS ("node"))

    {

      NodeInfo *top;

      g_assert (parser->node_stack != NULL);

      top = parser->node_stack->data;

      parser->node_stack = g_slist_remove (parser->node_stack,

                                           top);

      if (parser->node_stack == NULL)

        parser->result = top; /* We are done, store the result */      

    }

  else

    g_assert_not_reached (); /* should have had an error on start_element */

  return TRUE;

}

gboolean

parser_content (Parser      *parser,

                const char  *content,

                int          len,

                GError     **error)

{

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

  /* FIXME check that it's all whitespace */

  return TRUE;

}

gboolean

parser_finished (Parser      *parser,

                 GError     **error)

{

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

  return TRUE;

}

NodeInfo*

parser_get_nodes (Parser *parser)

{

  return parser->result;

}

#endif /* DOXYGEN_SHOULD_SKIP_THIS */