/* -*- 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,