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

/* dbus-signature.c  Routines for reading recursive type signatures

 *

 * Copyright (C) 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-signature.h"

#include "dbus-marshal-recursive.h"

#include "dbus-marshal-basic.h"

#include "dbus-internals.h"

#include "dbus-test.h"

/**

 * Implementation details of #DBusSignatureIter, all fields are private

 */

typedef struct

{ 

  const char *pos;           /**< current position in the signature string */

  unsigned int finished : 1; /**< true if we are at the end iter */

  unsigned int in_array : 1; /**< true if we are a subiterator pointing to an array's element type */

} DBusSignatureRealIter;

/** macro that checks whether a typecode is a container type */

#define TYPE_IS_CONTAINER(typecode)             \

    ((typecode) == DBUS_TYPE_STRUCT ||          \

     (typecode) == DBUS_TYPE_DICT_ENTRY ||      \

     (typecode) == DBUS_TYPE_VARIANT ||         \

     (typecode) == DBUS_TYPE_ARRAY)

/**

 * @defgroup DBusSignature Type signature parsing

 * @ingroup  DBus

 * @brief Parsing D-Bus type signatures

 * @{

 */

/**

 * Initializes a #DBusSignatureIter for reading a type signature.  This

 * function is not safe to use on invalid signatures; be sure to

 * validate potentially invalid signatures with dbus_signature_validate

 * before using this function.

 *

 * @param iter pointer to an iterator to initialize

 * @param signature the type signature

 */

#ifdef __SYMBIAN32__

EXPORT_C 

#endif

void

dbus_signature_iter_init (DBusSignatureIter *iter,

			  const char        *signature)

{

  DBusSignatureRealIter *real_iter = (DBusSignatureRealIter *) iter;

  real_iter->pos = signature;

  real_iter->finished = FALSE;

  real_iter->in_array = FALSE;

}

/**

 * Returns the current type pointed to by the iterator.

 * If the iterator is pointing at a type code such as 's', then

 * it will be returned directly.

 *

 * However, when the parser encounters a container type start

 * character such as '(' for a structure, the corresponding type for

 * the container will be returned, e.g.  DBUS_TYPE_STRUCT, not '('.

 * In this case, you should initialize a sub-iterator with

 * dbus_signature_iter_recurse() to parse the container type.

 *

 * @param iter pointer to an iterator 

 * @returns current type (e.g. #DBUS_TYPE_STRING, #DBUS_TYPE_ARRAY)

 */

#ifdef __SYMBIAN32__

EXPORT_C 

#endif

int

dbus_signature_iter_get_current_type (const DBusSignatureIter *iter)

{

  DBusSignatureRealIter *real_iter = (DBusSignatureRealIter *) iter;

  return _dbus_first_type_in_signature_c_str (real_iter->pos, 0);

}

/**

 * Returns the signature of the single complete type starting at the

 * given iterator.

 *

 * For example, if the iterator is pointing at the start of "(ii)ii"

 * (which is "a struct of two ints, followed by an int, followed by an

 * int"), then "(ii)" would be returned. If the iterator is pointing at

 * one of the "i" then just that "i" would be returned.

 *

 * @param iter pointer to an iterator 

 * @returns current signature; or #NULL if no memory.  Should be freed with dbus_free()

 */

#ifdef __SYMBIAN32__

EXPORT_C 

#endif

char *

dbus_signature_iter_get_signature (const DBusSignatureIter *iter)

{

  DBusSignatureRealIter *real_iter = (DBusSignatureRealIter *) iter;

  DBusString str;

  char *ret;

  int pos;

  if (!_dbus_string_init (&str))

    return NULL;

  pos = 0;

  _dbus_type_signature_next (real_iter->pos, &pos);

  if (!_dbus_string_append_len (&str, real_iter->pos, pos))

    return NULL;

  if (!_dbus_string_steal_data (&str, &ret))

    ret = NULL;

  _dbus_string_free (&str);

  return ret; 

}

/**

 * Convenience function for returning the element type of an array;

 * This function allows you to avoid initializing a sub-iterator and

 * getting its current type.

 *

 * Undefined behavior results if you invoke this function when the

 * current type of the iterator is not #DBUS_TYPE_ARRAY.

 *

 * @param iter pointer to an iterator 

 * @returns current array element type

 */

#ifdef __SYMBIAN32__

EXPORT_C 

#endif

int

dbus_signature_iter_get_element_type (const DBusSignatureIter *iter)

{

  DBusSignatureRealIter *real_iter = (DBusSignatureRealIter *) iter;

  _dbus_return_val_if_fail (dbus_signature_iter_get_current_type (iter) == DBUS_TYPE_ARRAY, DBUS_TYPE_INVALID);

  return _dbus_first_type_in_signature_c_str (real_iter->pos, 1);

}

/**

 * Skip to the next value on this "level". e.g. the next field in a

 * struct, the next value in an array. Returns #FALSE at the end of the

 * current container.

 *

 * @param iter the iterator

 * @returns FALSE if nothing more to read at or below this level

 */

#ifdef __SYMBIAN32__

EXPORT_C 

#endif

dbus_bool_t

dbus_signature_iter_next (DBusSignatureIter *iter)

{

  DBusSignatureRealIter *real_iter = (DBusSignatureRealIter *) iter;

  if (real_iter->finished)

    return FALSE;

  else

    {

      int pos;

      if (real_iter->in_array)

	{

	  real_iter->finished = TRUE;

	  return FALSE;

	}

      pos = 0;

      _dbus_type_signature_next (real_iter->pos, &pos);

      real_iter->pos += pos;

      if (*real_iter->pos == DBUS_STRUCT_END_CHAR

	  || *real_iter->pos == DBUS_DICT_ENTRY_END_CHAR)

	{

	  real_iter->finished = TRUE;

	  return FALSE;

	}

      return *real_iter->pos != DBUS_TYPE_INVALID;

    }

}

/**

 * Initialize a new iterator pointing to the first type in the current

 * container.

 * 

 * The results are undefined when calling this if the current type is

 * a non-container (i.e. if dbus_type_is_container() returns #FALSE

 * for the result of dbus_signature_iter_get_current_type()).

 *

 * @param iter the current interator

 * @param subiter an iterator to initialize pointing to the first child

 */

#ifdef __SYMBIAN32__

EXPORT_C 

#endif

void

dbus_signature_iter_recurse (const DBusSignatureIter *iter,

			     DBusSignatureIter       *subiter)

{

  DBusSignatureRealIter *real_iter = (DBusSignatureRealIter *) iter;

  DBusSignatureRealIter *real_sub_iter = (DBusSignatureRealIter *) subiter;

  _dbus_return_if_fail (dbus_type_is_container (dbus_signature_iter_get_current_type (iter)));

  *real_sub_iter = *real_iter;

  real_sub_iter->in_array = FALSE;

  real_sub_iter->pos++;

  if (dbus_signature_iter_get_current_type (iter) == DBUS_TYPE_ARRAY)

    real_sub_iter->in_array = TRUE;

}

/**

 * Check a type signature for validity. Remember that #NULL can always

 * be passed instead of a DBusError*, if you don't care about having

 * an error name and message.

 *

 * @param signature a potentially invalid type signature

 * @param error error return

 * @returns #TRUE if signature is valid or #FALSE if an error is set

 */

#ifdef __SYMBIAN32__

EXPORT_C 

#endif

dbus_bool_t

dbus_signature_validate (const char       *signature,

			 DBusError        *error)

{

  DBusString str;

  _dbus_string_init_const (&str, signature);

  if (_dbus_validate_signature (&str, 0, _dbus_string_get_length (&str)))

    return TRUE;

  dbus_set_error (error, DBUS_ERROR_INVALID_SIGNATURE, "Corrupt type signature");

  return FALSE;

}

/**

 * Check that a type signature is both valid and contains exactly one

 * complete type. "One complete type" means a single basic type,

 * array, struct, or dictionary, though the struct or array may be

 * arbitrarily recursive and complex. More than one complete type

 * would mean for example "ii" or two integers in sequence.

 *

 * @param signature a potentially invalid type signature

 * @param error error return

 * @returns #TRUE if signature is valid and has exactly one complete type

 */

#ifdef __SYMBIAN32__

EXPORT_C 

#endif

dbus_bool_t

dbus_signature_validate_single (const char       *signature,

				DBusError        *error)

{

  DBusSignatureIter iter;

  if (!dbus_signature_validate (signature, error))

    return FALSE;

  dbus_signature_iter_init (&iter, signature);

  if (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_INVALID)

    goto lose;

  if (!dbus_signature_iter_next (&iter))

    return TRUE;

 lose:

  dbus_set_error (error, DBUS_ERROR_INVALID_SIGNATURE, "Exactly one complete type required in signature");

  return FALSE;

}

/**

 * A "container type" can contain basic types, or nested

 * container types. #DBUS_TYPE_INVALID is not a container type.

 *

 * This function will crash if passed a typecode that isn't

 * in dbus-protocol.h

 *

 * @returns #TRUE if type is a container

 */

#ifdef __SYMBIAN32__

EXPORT_C 

#endif

dbus_bool_t

dbus_type_is_container (int typecode)

{

  /* only reasonable (non-line-noise) typecodes are allowed */

  _dbus_return_val_if_fail (_dbus_type_is_valid (typecode) || typecode == DBUS_TYPE_INVALID,

			    FALSE);

  return TYPE_IS_CONTAINER (typecode);

}

/**

 * A "basic type" is a somewhat arbitrary concept, but the intent is

 * to include those types that are fully-specified by a single

 * typecode, with no additional type information or nested values. So

 * all numbers and strings are basic types and structs, arrays, and

 * variants are not basic types.  #DBUS_TYPE_INVALID is not a basic

 * type.

 *

 * This function will crash if passed a typecode that isn't

 * in dbus-protocol.h 

 *

 * @returns #TRUE if type is basic

 */

#ifdef __SYMBIAN32__

EXPORT_C 

#endif

dbus_bool_t

dbus_type_is_basic (int typecode)

{

  /* only reasonable (non-line-noise) typecodes are allowed */

  _dbus_return_val_if_fail (_dbus_type_is_valid (typecode) || typecode == DBUS_TYPE_INVALID,

			    FALSE);

  /* everything that isn't invalid or a container */

  return !(typecode == DBUS_TYPE_INVALID || TYPE_IS_CONTAINER (typecode));

}

/**

 * Tells you whether values of this type can change length if you set

 * them to some other value. For this purpose, you assume that the

 * first byte of the old and new value would be in the same location,

 * so alignment padding is not a factor.

 *

 * This function is useful to determine whether

 * dbus_message_iter_get_fixed_array() may be used.

 *

 * Some structs are fixed-size (if they contain only fixed-size types)

 * but struct is not considered a fixed type for purposes of this

 * function.

 *

 * This function will crash if passed a typecode that isn't

 * in dbus-protocol.h

 * 

 * @returns #FALSE if the type can occupy different lengths

 */

#ifdef __SYMBIAN32__

EXPORT_C 

#endif

dbus_bool_t

dbus_type_is_fixed (int typecode)

{

  /* only reasonable (non-line-noise) typecodes are allowed */

  _dbus_return_val_if_fail (_dbus_type_is_valid (typecode) || typecode == DBUS_TYPE_INVALID,

			    FALSE);

  switch (typecode)

    {

    case DBUS_TYPE_BYTE:

    case DBUS_TYPE_BOOLEAN:

    case DBUS_TYPE_INT16:

    case DBUS_TYPE_UINT16:

    case DBUS_TYPE_INT32:

    case DBUS_TYPE_UINT32:

    case DBUS_TYPE_INT64:

    case DBUS_TYPE_UINT64:

    case DBUS_TYPE_DOUBLE:

      return TRUE;

    default:

      return FALSE;

    }

}

/** @} */ /* end of DBusSignature group */

#ifdef DBUS_BUILD_TESTS

/**

 * @ingroup DBusSignatureInternals

 * Unit test for DBusSignature.

 *

 * @returns #TRUE on success.

 */

#ifdef __SYMBIAN32__

EXPORT_C

#endif

dbus_bool_t

_dbus_signature_test (void)

{

  DBusSignatureIter iter;

  DBusSignatureIter subiter;

  DBusSignatureIter subsubiter;

  DBusSignatureIter subsubsubiter;

  const char *sig;

  dbus_bool_t boolres;

  _dbus_assert (sizeof (DBusSignatureIter) >= sizeof (DBusSignatureRealIter));

  sig = "";

  _dbus_assert (dbus_signature_validate (sig, NULL));

  _dbus_assert (!dbus_signature_validate_single (sig, NULL));

  dbus_signature_iter_init (&iter, sig);

  _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_INVALID);

  sig = DBUS_TYPE_STRING_AS_STRING;

  _dbus_assert (dbus_signature_validate (sig, NULL));

  _dbus_assert (dbus_signature_validate_single (sig, NULL));

  dbus_signature_iter_init (&iter, sig);

  _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_STRING);

  sig = DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_BYTE_AS_STRING;

  _dbus_assert (dbus_signature_validate (sig, NULL));

  dbus_signature_iter_init (&iter, sig);

  _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_STRING);

  boolres = dbus_signature_iter_next (&iter);

  _dbus_assert (boolres);

  _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_BYTE);

  sig = DBUS_TYPE_UINT16_AS_STRING

    DBUS_STRUCT_BEGIN_CHAR_AS_STRING

    DBUS_TYPE_STRING_AS_STRING

    DBUS_TYPE_UINT32_AS_STRING

    DBUS_TYPE_VARIANT_AS_STRING

    DBUS_TYPE_DOUBLE_AS_STRING

    DBUS_STRUCT_END_CHAR_AS_STRING;

  _dbus_assert (dbus_signature_validate (sig, NULL));

  dbus_signature_iter_init (&iter, sig);

  _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_UINT16);

  boolres = dbus_signature_iter_next (&iter);

  _dbus_assert (boolres);

  _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_STRUCT);

  dbus_signature_iter_recurse (&iter, &subiter);

  _dbus_assert (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_STRING);

  boolres = dbus_signature_iter_next (&subiter);

  _dbus_assert (boolres);

  _dbus_assert (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_UINT32);

  boolres = dbus_signature_iter_next (&subiter);

  _dbus_assert (boolres);

  _dbus_assert (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_VARIANT);

  boolres = dbus_signature_iter_next (&subiter);

  _dbus_assert (boolres);

  _dbus_assert (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_DOUBLE);

  sig = DBUS_TYPE_UINT16_AS_STRING

    DBUS_STRUCT_BEGIN_CHAR_AS_STRING

    DBUS_TYPE_UINT32_AS_STRING

    DBUS_TYPE_BYTE_AS_STRING

    DBUS_TYPE_ARRAY_AS_STRING

    DBUS_TYPE_ARRAY_AS_STRING

    DBUS_TYPE_DOUBLE_AS_STRING

    DBUS_STRUCT_BEGIN_CHAR_AS_STRING

    DBUS_TYPE_BYTE_AS_STRING

    DBUS_STRUCT_END_CHAR_AS_STRING

    DBUS_STRUCT_END_CHAR_AS_STRING;

  _dbus_assert (dbus_signature_validate (sig, NULL));

  dbus_signature_iter_init (&iter, sig);

  _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_UINT16);

  boolres = dbus_signature_iter_next (&iter);

  _dbus_assert (boolres);

  _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_STRUCT);

  dbus_signature_iter_recurse (&iter, &subiter);

  _dbus_assert (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_UINT32);

  boolres = dbus_signature_iter_next (&subiter);

  _dbus_assert (boolres);

  _dbus_assert (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_BYTE);

  boolres = dbus_signature_iter_next (&subiter);

  _dbus_assert (boolres);

  _dbus_assert (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_ARRAY);

  _dbus_assert (dbus_signature_iter_get_element_type (&subiter) == DBUS_TYPE_ARRAY);

  dbus_signature_iter_recurse (&subiter, &subsubiter);

  _dbus_assert (dbus_signature_iter_get_current_type (&subsubiter) == DBUS_TYPE_ARRAY);

  _dbus_assert (dbus_signature_iter_get_element_type (&subsubiter) == DBUS_TYPE_DOUBLE);

  dbus_signature_iter_recurse (&subsubiter, &subsubsubiter);

  _dbus_assert (dbus_signature_iter_get_current_type (&subsubsubiter) == DBUS_TYPE_DOUBLE);

  boolres = dbus_signature_iter_next (&subiter);

  _dbus_assert (boolres);

  _dbus_assert (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_STRUCT);

  dbus_signature_iter_recurse (&subiter, &subsubiter);

  _dbus_assert (dbus_signature_iter_get_current_type (&subsubiter) == DBUS_TYPE_BYTE);

  sig = DBUS_TYPE_ARRAY_AS_STRING

    DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING

    DBUS_TYPE_INT16_AS_STRING

    DBUS_TYPE_STRING_AS_STRING

    DBUS_DICT_ENTRY_END_CHAR_AS_STRING

    DBUS_TYPE_VARIANT_AS_STRING;

  _dbus_assert (dbus_signature_validate (sig, NULL));

  _dbus_assert (!dbus_signature_validate_single (sig, NULL));

  dbus_signature_iter_init (&iter, sig);

  _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_ARRAY);

  _dbus_assert (dbus_signature_iter_get_element_type (&iter) == DBUS_TYPE_DICT_ENTRY);

  dbus_signature_iter_recurse (&iter, &subiter);

  dbus_signature_iter_recurse (&subiter, &subsubiter);

  _dbus_assert (dbus_signature_iter_get_current_type (&subsubiter) == DBUS_TYPE_INT16);

  boolres = dbus_signature_iter_next (&subsubiter);

  _dbus_assert (boolres);

  _dbus_assert (dbus_signature_iter_get_current_type (&subsubiter) == DBUS_TYPE_STRING);

  boolres = dbus_signature_iter_next (&subsubiter);

  _dbus_assert (!boolres);

  boolres = dbus_signature_iter_next (&iter);

  _dbus_assert (boolres);

  _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_VARIANT);

  boolres = dbus_signature_iter_next (&iter);

  _dbus_assert (!boolres);

  sig = DBUS_TYPE_DICT_ENTRY_AS_STRING;

  _dbus_assert (!dbus_signature_validate (sig, NULL));