fdo-mirrors/dbus
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/dbus/dbus.git synced 2026-04-23 01:40:40 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

2003-02-24 Anders Carlsson <andersca@codefactory.se>

Browse source 
* dbus/dbus-internals.c: (_dbus_type_to_string):
	* dbus/dbus-marshal.c: (_dbus_marshal_get_arg_end_pos),
	(_dbus_marshal_validate_arg):
	* dbus/dbus-message-builder.c: (_dbus_message_data_load):
	* dbus/dbus-message.c: (dbus_message_append_args_valist),
	(dbus_message_append_boolean), (dbus_message_append_boolean_array),
	(dbus_message_get_args_valist), (dbus_message_iter_get_boolean),
	(dbus_message_iter_get_int32), (dbus_message_iter_get_uint32),
	(dbus_message_iter_get_double),
	(dbus_message_iter_get_boolean_array), (message_iter_test):
	* dbus/dbus-message.h:
	* dbus/dbus-protocol.h:
	* doc/dbus-specification.sgml:
	* test/data/valid-messages/lots-of-arguments.message:
	Add support for boolean and boolean array types.
This commit is contained in:
Anders Carlsson 2003-02-24 19:04:13 +00:00
parent 2f38c95921
commit c8769e0b1d
9 changed files with 378 additions and 76 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

17
ChangeLog
View file

@ -1,3 +1,20 @@
2003-02-24 Anders Carlsson <set EMAIL_ADDRESS environment variable>
* dbus/dbus-internals.c: (_dbus_type_to_string):
* dbus/dbus-marshal.c: (_dbus_marshal_get_arg_end_pos),
(_dbus_marshal_validate_arg):
* dbus/dbus-message-builder.c: (_dbus_message_data_load):
* dbus/dbus-message.c: (dbus_message_append_args_valist),
(dbus_message_append_boolean), (dbus_message_append_boolean_array),
(dbus_message_get_args_valist), (dbus_message_iter_get_boolean),
(dbus_message_iter_get_int32), (dbus_message_iter_get_uint32),
(dbus_message_iter_get_double),
(dbus_message_iter_get_boolean_array), (message_iter_test):
* dbus/dbus-message.h:
* dbus/dbus-protocol.h:
* doc/dbus-specification.sgml:
* test/data/valid-messages/lots-of-arguments.message:
2003-02-23 Havoc Pennington <hp@pobox.com>
* dbus/dbus-keyring.c: finish most of this implementation and

4
dbus/dbus-internals.c
View file

@ -355,6 +355,8 @@ _dbus_type_to_string (int type)
return "invalid";
case DBUS_TYPE_NIL:
return "nil";
case DBUS_TYPE_BOOLEAN:
return "boolean";
case DBUS_TYPE_INT32:
return "int32";
case DBUS_TYPE_UINT32:
@ -363,6 +365,8 @@ _dbus_type_to_string (int type)
return "double";
case DBUS_TYPE_STRING:
return "string";
case DBUS_TYPE_BOOLEAN_ARRAY:
return "boolean array";
case DBUS_TYPE_INT32_ARRAY:
return "int32 array";
case DBUS_TYPE_UINT32_ARRAY:

10
dbus/dbus-marshal.c
View file

@ -878,6 +878,10 @@ _dbus_marshal_get_arg_end_pos (const DBusString *str,
case DBUS_TYPE_NIL:
*end_pos = pos + 1;
break;
case DBUS_TYPE_BOOLEAN:
*end_pos = pos + 2;
break;
case DBUS_TYPE_INT32:
*end_pos = _DBUS_ALIGN_VALUE (pos + 1, sizeof (dbus_int32_t)) + sizeof (dbus_int32_t);
@ -905,6 +909,7 @@ _dbus_marshal_get_arg_end_pos (const DBusString *str,
}
break;
case DBUS_TYPE_BOOLEAN_ARRAY:
case DBUS_TYPE_BYTE_ARRAY:
{
int len;
@ -1102,6 +1107,10 @@ _dbus_marshal_validate_arg (const DBusString *str,
case DBUS_TYPE_NIL:
*end_pos = pos + 1;
break;
case DBUS_TYPE_BOOLEAN:
*end_pos = pos + 2;
break;
case DBUS_TYPE_INT32:
case DBUS_TYPE_UINT32:
@ -1152,6 +1161,7 @@ _dbus_marshal_validate_arg (const DBusString *str,
}
break;
case DBUS_TYPE_BOOLEAN_ARRAY:
case DBUS_TYPE_BYTE_ARRAY:
{
int len;

107
dbus/dbus-message-builder.c
View file

@ -597,6 +597,8 @@ _dbus_message_data_load (DBusString *dest,
code = DBUS_TYPE_INVALID;
else if (_dbus_string_starts_with_c_str (&line, "NIL"))
code = DBUS_TYPE_NIL;
else if (_dbus_string_starts_with_c_str (&line, "BOOLEAN_ARRAY"))
code = DBUS_TYPE_BOOLEAN_ARRAY;
else if (_dbus_string_starts_with_c_str (&line, "INT32_ARRAY"))
code = DBUS_TYPE_INT32_ARRAY;
else if (_dbus_string_starts_with_c_str (&line, "UINT32_ARRAY"))
@ -607,6 +609,8 @@ _dbus_message_data_load (DBusString *dest,
code = DBUS_TYPE_BYTE_ARRAY;
else if (_dbus_string_starts_with_c_str (&line, "STRING_ARRAY"))
code = DBUS_TYPE_STRING_ARRAY;
else if (_dbus_string_starts_with_c_str (&line, "BOOLEAN"))
code = DBUS_TYPE_BOOLEAN;
else if (_dbus_string_starts_with_c_str (&line, "INT32"))
code = DBUS_TYPE_INT32;
else if (_dbus_string_starts_with_c_str (&line, "UINT32"))
@ -629,6 +633,86 @@ _dbus_message_data_load (DBusString *dest,
goto parse_failed;
}
}
else if (_dbus_string_starts_with_c_str (&line,
"BOOLEAN_ARRAY"))
{
SAVE_FOR_UNALIGN (dest, 4);
int i, len, allocated;
unsigned char *values;
unsigned char b, val;
allocated = 4;
values = dbus_new (unsigned char, allocated);
if (!values)
{
_dbus_warn ("could not allocate memory for BOOLEAN_ARRAY\n");
goto parse_failed;
}
len = 0;
_dbus_string_delete_first_word (&line);
_dbus_string_skip_blank (&line, 0, &i);
b = _dbus_string_get_byte (&line, i++);
if (b != '{')
goto parse_failed;
while (i < _dbus_string_get_length (&line))
{
_dbus_string_skip_blank (&line, i, &i);
printf ("i is: %d\n", i);
if (_dbus_string_find_to (&line, i, i + 5,
"false", NULL))
{
i += 5;
val = TRUE;
}
else if (_dbus_string_find_to (&line, i, i + 4,
"true", NULL))
{
i += 4;
val = FALSE;
}
else
{
_dbus_warn ("could not parse BOOLEAN_ARRAY\n");
goto parse_failed;
}
values[len++] = val;
if (len == allocated)
{
allocated *= 2;
values = dbus_realloc (values, allocated * sizeof (unsigned char));
if (!values)
{
_dbus_warn ("could not allocate memory for BOOLEAN_ARRAY\n");
goto parse_failed;
}
}
_dbus_string_skip_blank (&line, i, &i);
b = _dbus_string_get_byte (&line, i++);
if (b == '}')
break;
else if (b != ',')
goto parse_failed;
}
if (!_dbus_marshal_int32 (dest, endian, len) ||
!_dbus_string_append_len (dest, values, len))
{
_dbus_warn ("failed to append BOOLEAN_ARRAY\n");
goto parse_failed;
}
dbus_free (values);
PERFORM_UNALIGN (dest);
}
else if (_dbus_string_starts_with_c_str (&line,
"INT32_ARRAY"))
{
@ -912,6 +996,29 @@ _dbus_message_data_load (DBusString *dest,
PERFORM_UNALIGN (dest);
}
else if (_dbus_string_starts_with_c_str (&line,
"BOOLEAN"))
{
unsigned char val;
_dbus_string_delete_first_word (&line);
if (_dbus_string_starts_with_c_str (&line, "true"))
val = TRUE;
else if (_dbus_string_starts_with_c_str (&line, "false"))
val = FALSE;
else
{
_dbus_warn ("could not parse BOOLEAN\n");
goto parse_failed;
}
if (!_dbus_string_append_byte (dest, val))
{
_dbus_warn ("failed to append BOOLEAN\n");
goto parse_failed;
}
}
else if (_dbus_string_starts_with_c_str (&line,
"INT32"))
{

156
dbus/dbus-message.c
View file

@ -1049,6 +1049,9 @@ dbus_message_append_args_valist (DBusMessage *message,
case DBUS_TYPE_NIL:
if (!dbus_message_append_nil (message))
goto enomem;
case DBUS_TYPE_BOOLEAN:
if (!dbus_message_append_boolean (message, va_arg (var_args, dbus_bool_t)))
goto enomem;
case DBUS_TYPE_INT32:
if (!dbus_message_append_int32 (message, va_arg (var_args, dbus_int32_t)))
goto enomem;
@ -1065,6 +1068,18 @@ dbus_message_append_args_valist (DBusMessage *message,
if (!dbus_message_append_string (message, va_arg (var_args, const char *)))
goto enomem;
break;
case DBUS_TYPE_BOOLEAN_ARRAY:
{
int len;
unsigned char *data;
data = va_arg (var_args, unsigned char *);
len = va_arg (var_args, int);
if (!dbus_message_append_boolean_array (message, data, len))
goto enomem;
}
break;
case DBUS_TYPE_INT32_ARRAY:
{
int len;
@ -1156,6 +1171,31 @@ dbus_message_append_nil (DBusMessage *message)
return TRUE;
}
/**
* Appends a boolean value to the message
*
* @param message the message
* @param value the boolean value
* @returns #TRUE on success
*/
dbus_bool_t
dbus_message_append_boolean (DBusMessage *message,
unsigned char value)
{
_dbus_assert (!message->locked);
if (!_dbus_string_append_byte (&message->body, DBUS_TYPE_BOOLEAN))
return FALSE;
if (!_dbus_string_append_byte (&message->body, (value != FALSE)))
{
_dbus_string_shorten (&message->body, 1);
return FALSE;
}
return TRUE;
}
/**
* Appends a 32 bit signed integer to the message.
*
@ -1256,6 +1296,33 @@ dbus_message_append_string (DBusMessage *message,
return TRUE;
}
/**
* Appends a boolean array to the message.
*
* @param message the message
* @param value the array
* @param len the length of the array
* @returns #TRUE on success
*/
dbus_bool_t
dbus_message_append_boolean_array (DBusMessage *message,
unsigned char *value,
int len)
{
_dbus_assert (!message->locked);
if (!_dbus_string_append_byte (&message->body, DBUS_TYPE_BOOLEAN_ARRAY))
return FALSE;
if (!_dbus_marshal_byte_array (&message->body, message->byte_order, value, len))
{
_dbus_string_shorten (&message->body, 1);
return FALSE;
}
return TRUE;
}
/**
* Appends a 32 bit signed integer array to the message.
*
@ -1472,6 +1539,17 @@ dbus_message_get_args_valist (DBusMessage *message,
switch (spec_type)
{
case DBUS_TYPE_NIL:
break;
case DBUS_TYPE_BOOLEAN:
{
unsigned char *ptr;
ptr = va_arg (var_args, unsigned char *);
*ptr = dbus_message_iter_get_boolean (iter);
break;
}
case DBUS_TYPE_INT32:
{
dbus_int32_t *ptr;
@ -1515,6 +1593,20 @@ dbus_message_get_args_valist (DBusMessage *message,
break;
}
case DBUS_TYPE_BOOLEAN_ARRAY:
{
unsigned char **ptr;
int *len;
ptr = va_arg (var_args, unsigned char **);
len = va_arg (var_args, int *);
if (!dbus_message_iter_get_boolean_array (iter, ptr, len))
return DBUS_RESULT_NO_MEMORY;
break;
}
case DBUS_TYPE_INT32_ARRAY:
{
dbus_int32_t **ptr;
@ -1740,7 +1832,7 @@ dbus_message_iter_get_arg_type (DBusMessageIter *iter)
* Note that you need to check that the iterator points to
* a string value before using this function.
*
* @see dbus_message_iter_get_field_type
* @see dbus_message_iter_get_arg_type
* @param iter the message iter
* @returns the string
*/
@ -1753,18 +1845,42 @@ dbus_message_iter_get_string (DBusMessageIter *iter)
iter->pos + 1, NULL);
}
/**
* Returns the boolean value that an iterator may point to.
* Note that you need to check that the iterator points to
* a boolean value before using this function.
*
* @see dbus_message_iter_get_arg_type
* @param iter the message iter
* @returns the string
*/
unsigned char
dbus_message_iter_get_boolean (DBusMessageIter *iter)
{
unsigned char value;
_dbus_assert (dbus_message_iter_get_arg_type (iter) == DBUS_TYPE_BOOLEAN);
value = _dbus_string_get_byte (&iter->message->body, iter->pos + 1);
iter->pos += 2;
return value;
}
/**
* Returns the 32 bit signed integer value that an iterator may point to.
* Note that you need to check that the iterator points to
* an integer value before using this function.
*
* @see dbus_message_iter_get_field_type
* @see dbus_message_iter_get_arg_type
* @param iter the message iter
* @returns the integer
*/
int
dbus_message_iter_get_int32 (DBusMessageIter *iter)
{
_dbus_assert (dbus_message_iter_get_arg_type (iter) == DBUS_TYPE_INT32);
return _dbus_demarshal_int32 (&iter->message->body, iter->message->byte_order,
iter->pos + 1, NULL);
}
@ -1774,13 +1890,15 @@ dbus_message_iter_get_int32 (DBusMessageIter *iter)
* Note that you need to check that the iterator points to
* an unsigned integer value before using this function.
*
* @see dbus_message_iter_get_field_type
* @see dbus_message_iter_get_arg_type
* @param iter the message iter
* @returns the integer
*/
int
dbus_message_iter_get_uint32 (DBusMessageIter *iter)
{
_dbus_assert (dbus_message_iter_get_arg_type (iter) == DBUS_TYPE_UINT32);
return _dbus_demarshal_uint32 (&iter->message->body, iter->message->byte_order,
iter->pos + 1, NULL);
}
@ -1790,17 +1908,45 @@ dbus_message_iter_get_uint32 (DBusMessageIter *iter)
* Note that you need to check that the iterator points to
* a string value before using this function.
*
* @see dbus_message_iter_get_field_type
* @see dbus_message_iter_get_arg_type
* @param iter the message iter
* @returns the double
*/
double
dbus_message_iter_get_double (DBusMessageIter *iter)
{
_dbus_assert (dbus_message_iter_get_arg_type (iter) == DBUS_TYPE_DOUBLE);
return _dbus_demarshal_double (&iter->message->body, iter->message->byte_order,
iter->pos + 1, NULL);
}
/**
* Returns the boolean array that the iterator may point to. Note that
* you need to check that the iterator points to an array of the
* correct type prior to using this function.
*
* @param iter the iterator
* @param value return location for the array
* @param len return location for the array length
* @returns #TRUE on success
*/
dbus_bool_t
dbus_message_iter_get_boolean_array (DBusMessageIter *iter,
unsigned char **value,
int *len)
{
_dbus_assert (dbus_message_iter_get_arg_type (iter) == DBUS_TYPE_BOOLEAN_ARRAY);
*value = _dbus_demarshal_byte_array (&iter->message->body, iter->message->byte_order,
iter->pos + 1, NULL, len);
if (!*value)
return FALSE;
else
return TRUE;
}
/**
* Returns the 32 bit signed integer array that the iterator may point
* to. Note that you need to check that the iterator points to an
@ -2668,7 +2814,7 @@ message_iter_test (DBusMessage *message)
if (dbus_message_iter_get_arg_type (iter) != DBUS_TYPE_UINT32)
_dbus_assert_not_reached ("Argument type isn't int32");
if (dbus_message_iter_get_int32 (iter) != 0xedd1e)
if (dbus_message_iter_get_uint32 (iter) != 0xedd1e)
_dbus_assert_not_reached ("Unsigned integers differ");
if (!dbus_message_iter_next (iter))

118
dbus/dbus-message.h
View file

@ -59,36 +59,42 @@ dbus_bool_t dbus_message_get_is_error (DBusMessage *message);
dbus_bool_t dbus_message_name_is (DBusMessage *message,
const char *name);
dbus_bool_t dbus_message_append_args (DBusMessage *message,
int first_arg_type,
...);
dbus_bool_t dbus_message_append_args_valist (DBusMessage *message,
int first_arg_type,
va_list var_args);
dbus_bool_t dbus_message_append_nil (DBusMessage *message);
dbus_bool_t dbus_message_append_int32 (DBusMessage *message,
dbus_int32_t value);
dbus_bool_t dbus_message_append_uint32 (DBusMessage *message,
dbus_uint32_t value);
dbus_bool_t dbus_message_append_double (DBusMessage *message,
double value);
dbus_bool_t dbus_message_append_string (DBusMessage *message,
const char *value);
dbus_bool_t dbus_message_append_int32_array (DBusMessage *message,
const dbus_int32_t *value,
int len);
dbus_bool_t dbus_message_append_uint32_array (DBusMessage *message,
const dbus_uint32_t *value,
int len);
dbus_bool_t dbus_message_append_double_array (DBusMessage *message,
const double *value,
int len);
dbus_bool_t dbus_message_append_byte_array (DBusMessage *message,
unsigned const char *value,
int len);
dbus_bool_t dbus_message_append_string_array (DBusMessage *message,
const char **value,
int len);
dbus_bool_t dbus_message_append_args (DBusMessage *message,
int first_arg_type,
...);
dbus_bool_t dbus_message_append_args_valist (DBusMessage *message,
int first_arg_type,
va_list var_args);
dbus_bool_t dbus_message_append_nil (DBusMessage *message);
dbus_bool_t dbus_message_append_boolean (DBusMessage *message,
unsigned char value);
dbus_bool_t dbus_message_append_int32 (DBusMessage *message,
dbus_int32_t value);
dbus_bool_t dbus_message_append_uint32 (DBusMessage *message,
dbus_uint32_t value);
dbus_bool_t dbus_message_append_double (DBusMessage *message,
double value);
dbus_bool_t dbus_message_append_string (DBusMessage *message,
const char *value);
dbus_bool_t dbus_message_append_boolean_array (DBusMessage *message,
unsigned char *value,
int len);
dbus_bool_t dbus_message_append_int32_array (DBusMessage *message,
const dbus_int32_t *value,
int len);
dbus_bool_t dbus_message_append_uint32_array (DBusMessage *message,
const dbus_uint32_t *value,
int len);
dbus_bool_t dbus_message_append_double_array (DBusMessage *message,
const double *value,
int len);
dbus_bool_t dbus_message_append_byte_array (DBusMessage *message,
unsigned const char *value,
int len);
dbus_bool_t dbus_message_append_string_array (DBusMessage *message,
const char **value,
int len);
DBusMessageIter *dbus_message_get_args_iter (DBusMessage *message);
DBusResultCode dbus_message_get_args (DBusMessage *message,
@ -100,30 +106,34 @@ DBusResultCode dbus_message_get_args_valist (DBusMessage *message,
void dbus_message_iter_ref (DBusMessageIter *iter);
void dbus_message_iter_unref (DBusMessageIter *iter);
dbus_bool_t dbus_message_iter_has_next (DBusMessageIter *iter);
dbus_bool_t dbus_message_iter_next (DBusMessageIter *iter);
int dbus_message_iter_get_arg_type (DBusMessageIter *iter);
int dbus_message_iter_get_int32 (DBusMessageIter *iter);
int dbus_message_iter_get_uint32 (DBusMessageIter *iter);
double dbus_message_iter_get_double (DBusMessageIter *iter);
char * dbus_message_iter_get_string (DBusMessageIter *iter);
dbus_bool_t dbus_message_iter_get_int32_array (DBusMessageIter *iter,
dbus_int32_t **value,
int *len);
dbus_bool_t dbus_message_iter_get_uint32_array (DBusMessageIter *iter,
dbus_uint32_t **value,
int *len);
dbus_bool_t dbus_message_iter_get_double_array (DBusMessageIter *iter,
double **value,
int *len);
dbus_bool_t dbus_message_iter_get_byte_array (DBusMessageIter *iter,
unsigned char **value,
int *len);
dbus_bool_t dbus_message_iter_get_string_array (DBusMessageIter *iter,
char ***value,
int *len);
void dbus_message_iter_ref (DBusMessageIter *iter);
void dbus_message_iter_unref (DBusMessageIter *iter);
dbus_bool_t dbus_message_iter_has_next (DBusMessageIter *iter);
dbus_bool_t dbus_message_iter_next (DBusMessageIter *iter);
int dbus_message_iter_get_arg_type (DBusMessageIter *iter);
unsigned char dbus_message_iter_get_boolean (DBusMessageIter *iter);
int dbus_message_iter_get_int32 (DBusMessageIter *iter);
int dbus_message_iter_get_uint32 (DBusMessageIter *iter);
double dbus_message_iter_get_double (DBusMessageIter *iter);
char * dbus_message_iter_get_string (DBusMessageIter *iter);
dbus_bool_t dbus_message_iter_get_boolean_array (DBusMessageIter *iter,
unsigned char **value,
int *len);
dbus_bool_t dbus_message_iter_get_int32_array (DBusMessageIter *iter,
dbus_int32_t **value,
int *len);
dbus_bool_t dbus_message_iter_get_uint32_array (DBusMessageIter *iter,
dbus_uint32_t **value,
int *len);
dbus_bool_t dbus_message_iter_get_double_array (DBusMessageIter *iter,
double **value,
int *len);
dbus_bool_t dbus_message_iter_get_byte_array (DBusMessageIter *iter,
unsigned char **value,
int *len);
dbus_bool_t dbus_message_iter_get_string_array (DBusMessageIter *iter,
char ***value,
int *len);
DBUS_END_DECLS;

20
dbus/dbus-protocol.h
View file

@ -42,15 +42,17 @@ extern "C" {
/* Data types */
#define DBUS_TYPE_INVALID 0
#define DBUS_TYPE_NIL 1
#define DBUS_TYPE_INT32 2
#define DBUS_TYPE_UINT32 3
#define DBUS_TYPE_DOUBLE 4
#define DBUS_TYPE_STRING 5
#define DBUS_TYPE_INT32_ARRAY 6
#define DBUS_TYPE_UINT32_ARRAY 7
#define DBUS_TYPE_DOUBLE_ARRAY 8
#define DBUS_TYPE_BYTE_ARRAY 9
#define DBUS_TYPE_STRING_ARRAY 10
#define DBUS_TYPE_BOOLEAN 2
#define DBUS_TYPE_INT32 3
#define DBUS_TYPE_UINT32 4
#define DBUS_TYPE_DOUBLE 5
#define DBUS_TYPE_STRING 6
#define DBUS_TYPE_BOOLEAN_ARRAY 7
#define DBUS_TYPE_INT32_ARRAY 8
#define DBUS_TYPE_UINT32_ARRAY 9
#define DBUS_TYPE_DOUBLE_ARRAY 10
#define DBUS_TYPE_BYTE_ARRAY 11
#define DBUS_TYPE_STRING_ARRAY 12
/* Header flags */
#define DBUS_HEADER_FLAG_ERROR 0x1

20
doc/dbus-specification.sgml
View file

@ -279,10 +279,6 @@
[FIXME perhaps we should add type BYTE with the primary
advantage being that it occupies 1 byte vs. 7 for UINT32,
or perhaps space savings aren't worth the complexity]
[FIXME perhaps we should add type BOOL with the primary
advantage being better type safety vs. overloading of
UINT32]
The type codes are as follows:
<informaltable>
<tgroup cols=3>
<thead>
@ -302,22 +298,30 @@
<entry>1</entry>
<entry>Marks an "unset" or "nonexistent" argument</entry>
</row><row>
<entry>BOOLEAN</entry>
<entry>2</entry>
<entry>Boolean value, 0 is FALSE and everything else is TRUE.</entry>
</row><row>
<entry>INT32</entry>
<entry>2</entry>
<entry>3</entry>
<entry>32-bit signed integer</entry>
</row><row>
<entry>UINT32</entry>
<entry>3</entry>
<entry>4</entry>
<entry>32-bit unsigned integer</entry>
</row><row>
<entry>DOUBLE</entry>
<entry>4</entry>
<entry>5</entry>
<entry>IEEE 754 double</entry>
</row><row>
<entry>STRING</entry>
<entry>5</entry>
<entry>6</entry>
<entry>UTF-8 string (<emphasis>must</emphasis> be valid UTF-8)</entry>
</row><row>
<entry>BOOLEAN_ARRAY</entry>
<entry>7</entry>
<entry>Array of BOOLEAN</entry>
</row><row>
<entry>INT32_ARRAY</entry>
<entry>6</entry>
<entry>Array of INT32</entry>

2
test/data/valid-messages/lots-of-arguments.message
View file

@ -13,6 +13,8 @@ TYPE DOUBLE
DOUBLE 3.141592653589
TYPE STRING
STRING 'This is a string'
TYPE BOOLEAN_ARRAY
BOOLEAN_ARRAY { true, false, false, true, false }
TYPE INT32_ARRAY
INT32_ARRAY { 1, -2, 3, -4, 5, -6, 7, -8, 9, -10 }
TYPE UINT32_ARRAY