Commit b47d5062 authored by Simon McVittie's avatar Simon McVittie

Remove support for platforms with no 64-bit integer type

This has been a soft requirement since 1.5.0; anyone on such platforms
would have had to configure --without-64-bit, provoking a warning that
instructed them to report a D-Bus bug with details of their platform.
Nobody has done so, so if anyone still lacks a 64-bit integer type,
they're on their own.

(Also, I tried the build with --without-64-bit and it's full of
fatal compiler warnings, so it's not clear that we're actually
losing anything by removing this "feature".)

Bug: https://bugs.freedesktop.org/show_bug.cgi?id=65429Reviewed-by: default avatarChengwei Yang <chengwei.yang@intel.com>
parent a61cfccf
......@@ -51,25 +51,23 @@ check_type_size("__int64" SIZEOF___INT64)
# DBUS_INT64_TYPE
if(SIZEOF_INT EQUAL 8)
set (DBUS_HAVE_INT64 1)
set (DBUS_INT64_TYPE "int")
set (DBUS_INT64_CONSTANT "(val)")
set (DBUS_UINT64_CONSTANT "(val##U)")
elseif(SIZEOF_LONG EQUAL 8)
set (DBUS_HAVE_INT64 1)
set (DBUS_INT64_TYPE "long")
set (DBUS_INT64_CONSTANT "(val##L)")
set (DBUS_UINT64_CONSTANT "(val##UL)")
elseif(SIZEOF_LONG_LONG EQUAL 8)
set (DBUS_HAVE_INT64 1)
set (DBUS_INT64_TYPE "long long")
set (DBUS_INT64_CONSTANT "(val##LL)")
set (DBUS_UINT64_CONSTANT "(val##ULL)")
elseif(SIZEOF___INT64 EQUAL 8)
set (DBUS_HAVE_INT64 1)
set (DBUS_INT64_TYPE "__int64")
set (DBUS_INT64_CONSTANT "(val##i64)")
set (DBUS_UINT64_CONSTANT "(val##ui64)")
else(SIZEOF_INT EQUAL 8)
message (FATAL_ERROR "Could not find a 64-bit integer type")
endif(SIZEOF_INT EQUAL 8)
# DBUS_INT32_TYPE
......
......@@ -355,12 +355,6 @@ AC_CHECK_SIZEOF(void *)
AC_CHECK_SIZEOF(long long)
AC_CHECK_SIZEOF(__int64)
AC_ARG_WITH([64-bit],
[AS_HELP_STRING([--without-64-bit],
[If you have to use this option, please report it as a bug])],
[],
[with_64_bit=yes])
### See what our 64 bit type is called
AC_MSG_CHECKING([64-bit integer type])
......@@ -399,33 +393,17 @@ $ac_cv_sizeof___int64)
esac
AS_IF(
[test "x$with_64_bit" = xno],
[
DBUS_INT64_TYPE="no_int64_type_detected"
DBUS_HAVE_INT64=0
DBUS_INT64_CONSTANT=
DBUS_UINT64_CONSTANT=
AC_MSG_RESULT([disabled via --without-64-bit])
],
dnl else if
[test -z "$dbusint64"],
[AC_MSG_RESULT([not found])
AC_MSG_ERROR([Could not find a 64-bit integer type.
Please report a bug here with details of your platform and compiler:
http://bugs.freedesktop.org/enter_bug.cgi?product=DBus&component=core
To compile D-Bus with all 64-bit integer types removed (not recommended), use
the option "--without-64-bit".
This option is likely to be removed in future, unless you report that your
platform needs it.])
http://bugs.freedesktop.org/enter_bug.cgi?product=DBus&component=core])
],
dnl else
[
DBUS_INT64_TYPE="$dbusint64"
DBUS_HAVE_INT64=1
DBUS_INT64_CONSTANT="$dbusint64_constant"
DBUS_UINT64_CONSTANT="$dbusuint64_constant"
if test x"$dbusint64_printf_modifier" != x; then
......@@ -437,7 +415,6 @@ platform needs it.])
AC_SUBST(DBUS_INT64_TYPE)
AC_SUBST(DBUS_INT64_CONSTANT)
AC_SUBST(DBUS_UINT64_CONSTANT)
AC_SUBST(DBUS_HAVE_INT64)
### see what 32-bit int is called
AC_MSG_CHECKING([32-bit integer type])
......@@ -1895,16 +1872,3 @@ fi
if test x$enable_checks = xno; then
echo "NOTE: building without checks for arguments passed to public API makes it harder to debug apps using D-Bus, but will slightly decrease D-Bus library size and _very_ slightly improve performance."
fi
if test "x$DBUS_HAVE_INT64" = x0; then
AC_MSG_WARN([You have disabled 64-bit integers via --without-64-bit.
This removes parts of the standard D-Bus API and ABI (the 't' and 'x'
typecodes, the dbus_int64_t and dbus_uint64_t types, etc.) and should only be
used if your compiler lacks support for 64-bit integers. Please report a bug
with details of your platform and compiler.
This option is likely to be removed in future, unless the D-Bus developers
receive reports that it is still needed.
])
fi
......@@ -31,7 +31,7 @@
DBUS_BEGIN_DECLS
#if @DBUS_HAVE_INT64@
/* D-Bus no longer supports platforms with no 64-bit integer type. */
#define DBUS_HAVE_INT64 1
_DBUS_GNUC_EXTENSION typedef @DBUS_INT64_TYPE@ dbus_int64_t;
_DBUS_GNUC_EXTENSION typedef unsigned @DBUS_INT64_TYPE@ dbus_uint64_t;
......@@ -39,12 +39,6 @@ _DBUS_GNUC_EXTENSION typedef unsigned @DBUS_INT64_TYPE@ dbus_uint64_t;
#define DBUS_INT64_CONSTANT(val) (_DBUS_GNUC_EXTENSION @DBUS_INT64_CONSTANT@)
#define DBUS_UINT64_CONSTANT(val) (_DBUS_GNUC_EXTENSION @DBUS_UINT64_CONSTANT@)
#else
#undef DBUS_HAVE_INT64
#undef DBUS_INT64_CONSTANT
#undef DBUS_UINT64_CONSTANT
#endif
typedef @DBUS_INT32_TYPE@ dbus_int32_t;
typedef unsigned @DBUS_INT32_TYPE@ dbus_uint32_t;
......
......@@ -230,10 +230,8 @@ char** _dbus_dup_string_array (const char **array);
#define _DBUS_INT_MIN _DBUS_INT32_MIN
#define _DBUS_INT_MAX _DBUS_INT32_MAX
#define _DBUS_UINT_MAX _DBUS_UINT32_MAX
#ifdef DBUS_HAVE_INT64
#define _DBUS_INT64_MAX DBUS_INT64_CONSTANT (0x7fffffffffffffff)
#define _DBUS_UINT64_MAX DBUS_UINT64_CONSTANT (0xffffffffffffffff)
#endif
#define _DBUS_ONE_KILOBYTE 1024
#define _DBUS_ONE_MEGABYTE 1024 * _DBUS_ONE_KILOBYTE
#define _DBUS_ONE_HOUR_IN_MILLISECONDS (1000 * 60 * 60)
......
......@@ -58,12 +58,10 @@ _DBUS_ASSERT_ALIGNMENT (dbus_bool_t, <=, 4);
_DBUS_STATIC_ASSERT (sizeof (double) == 8);
_DBUS_ASSERT_ALIGNMENT (double, <=, 8);
#ifdef DBUS_HAVE_INT64
_DBUS_STATIC_ASSERT (sizeof (dbus_int64_t) == 8);
_DBUS_ASSERT_ALIGNMENT (dbus_int64_t, <=, 8);
_DBUS_STATIC_ASSERT (sizeof (dbus_uint64_t) == 8);
_DBUS_ASSERT_ALIGNMENT (dbus_uint64_t, <=, 8);
#endif
_DBUS_STATIC_ASSERT (sizeof (DBusBasicValue) >= 8);
/* The alignment of a DBusBasicValue might conceivably be > 8 because of the
......@@ -120,15 +118,10 @@ pack_8_octets (DBusBasicValue value,
{
_dbus_assert (_DBUS_ALIGN_ADDRESS (data, 8) == data);
#ifdef DBUS_HAVE_INT64
if ((byte_order) == DBUS_LITTLE_ENDIAN)
*((dbus_uint64_t*)(data)) = DBUS_UINT64_TO_LE (value.u64);
else
*((dbus_uint64_t*)(data)) = DBUS_UINT64_TO_BE (value.u64);
#else
*(DBus8ByteStruct*)data = value.eight;
swap_8_octets ((DBusBasicValue*)data, byte_order);
#endif
}
/**
......@@ -146,65 +139,16 @@ _dbus_pack_uint32 (dbus_uint32_t value,
pack_4_octets (value, byte_order, data);
}
#ifndef DBUS_HAVE_INT64
/* from ORBit */
static void
swap_bytes (unsigned char *data,
unsigned int len)
{
unsigned char *p1 = data;
unsigned char *p2 = data + len - 1;
while (p1 < p2)
{
unsigned char tmp = *p1;
*p1 = *p2;
*p2 = tmp;
--p2;
++p1;
}
}
#endif /* !DBUS_HAVE_INT64 */
static void
swap_8_octets (DBusBasicValue *value,
int byte_order)
{
if (byte_order != DBUS_COMPILER_BYTE_ORDER)
{
#ifdef DBUS_HAVE_INT64
value->u64 = DBUS_UINT64_SWAP_LE_BE (value->u64);
#else
swap_bytes (&value->bytes, 8);
#endif
}
}
#if 0
static DBusBasicValue
unpack_8_octets (int byte_order,
const unsigned char *data)
{
DBusBasicValue r;
_dbus_assert (_DBUS_ALIGN_ADDRESS (data, 8) == data);
_dbus_assert (sizeof (r) == 8);
#ifdef DBUS_HAVE_INT64
if (byte_order == DBUS_LITTLE_ENDIAN)
r.u64 = DBUS_UINT64_FROM_LE (*(dbus_uint64_t*)data);
else
r.u64 = DBUS_UINT64_FROM_BE (*(dbus_uint64_t*)data);
#else
r.eight = *(DBus8ByteStruct*)data;
swap_8_octets (&r, byte_order);
#endif
return r;
}
#endif
#ifndef _dbus_unpack_uint16
/**
* Unpacks a 16 bit unsigned integer from a data pointer
......@@ -601,15 +545,10 @@ _dbus_marshal_read_basic (const DBusString *str,
{
volatile dbus_uint64_t *vp = value;
pos = _DBUS_ALIGN_VALUE (pos, 8);
#ifdef DBUS_HAVE_INT64
if (byte_order != DBUS_COMPILER_BYTE_ORDER)
*vp = DBUS_UINT64_SWAP_LE_BE (*(dbus_uint64_t*)(str_data + pos));
else
*vp = *(dbus_uint64_t*)(str_data + pos);
#else
*vp = *(DBus8ByteStruct*) (str_data + pos);
swap_8_octets (vp, byte_order);
#endif
pos += 8;
}
break;
......@@ -965,11 +904,7 @@ _dbus_swap_array (unsigned char *data,
{
while (d != end)
{
#ifdef DBUS_HAVE_INT64
*((dbus_uint64_t*)d) = DBUS_UINT64_SWAP_LE_BE (*((dbus_uint64_t*)d));
#else
swap_8_bytes ((DBusBasicValue*) d);
#endif
d += 8;
}
}
......@@ -1674,12 +1609,10 @@ _dbus_marshal_test (void)
unsigned char array1[5] = { 3, 4, 0, 1, 9 };
dbus_int16_t array2[3] = { 124, 457, 780 };
dbus_int32_t array4[3] = { 123, 456, 789 };
#ifdef DBUS_HAVE_INT64
dbus_int64_t array8[3] = { DBUS_INT64_CONSTANT (0x123ffffffff),
DBUS_INT64_CONSTANT (0x456ffffffff),
DBUS_INT64_CONSTANT (0x789ffffffff) };
dbus_int64_t *v_ARRAY_INT64;
#endif
unsigned char *v_ARRAY_BYTE;
dbus_int16_t *v_ARRAY_INT16;
dbus_uint16_t *v_ARRAY_UINT16;
......@@ -1735,7 +1668,6 @@ _dbus_marshal_test (void)
MARSHAL_TEST (UINT32, DBUS_BIG_ENDIAN, 0x12345678);
MARSHAL_TEST (UINT32, DBUS_LITTLE_ENDIAN, 0x12345678);
#ifdef DBUS_HAVE_INT64
/* Marshal signed integers */
MARSHAL_TEST (INT64, DBUS_BIG_ENDIAN, DBUS_INT64_CONSTANT (-0x123456789abc7));
MARSHAL_TEST (INT64, DBUS_LITTLE_ENDIAN, DBUS_INT64_CONSTANT (-0x123456789abc7));
......@@ -1743,7 +1675,6 @@ _dbus_marshal_test (void)
/* Marshal unsigned integers */
MARSHAL_TEST (UINT64, DBUS_BIG_ENDIAN, DBUS_UINT64_CONSTANT (0x123456789abc7));
MARSHAL_TEST (UINT64, DBUS_LITTLE_ENDIAN, DBUS_UINT64_CONSTANT (0x123456789abc7));
#endif /* DBUS_HAVE_INT64 */
/* Marshal byte */
MARSHAL_TEST (BYTE, DBUS_BIG_ENDIAN, 5);
......@@ -1785,10 +1716,8 @@ _dbus_marshal_test (void)
MARSHAL_TEST_FIXED_ARRAY (BYTE, DBUS_BIG_ENDIAN, array1);
MARSHAL_TEST_FIXED_ARRAY (BYTE, DBUS_LITTLE_ENDIAN, array1);
#ifdef DBUS_HAVE_INT64
MARSHAL_TEST_FIXED_ARRAY (INT64, DBUS_BIG_ENDIAN, array8);
MARSHAL_TEST_FIXED_ARRAY (INT64, DBUS_LITTLE_ENDIAN, array8);
#endif
#if 0
......@@ -1796,7 +1725,6 @@ _dbus_marshal_test (void)
* FIXME restore the set/pack tests
*/
#ifdef DBUS_HAVE_INT64
/* set/pack 64-bit integers */
_dbus_string_set_length (&str, 8);
......@@ -1867,7 +1795,6 @@ _dbus_marshal_test (void)
_dbus_assert (DBUS_UINT64_CONSTANT (0x123456789abc7) ==
_dbus_unpack_uint64 (DBUS_BIG_ENDIAN,
_dbus_string_get_const_data (&str)));
#endif /* DBUS_HAVE_INT64 */
/* set/pack 32-bit integers */
_dbus_string_set_length (&str, 4);
......
......@@ -57,8 +57,6 @@
#endif /* HAVE_BYTESWAP_H */
#ifdef DBUS_HAVE_INT64
#ifdef HAVE_BYTESWAP_H
#define DBUS_UINT64_SWAP_LE_BE_CONSTANT(val) bswap_64(val)
#else /* HAVE_BYTESWAP_H */
......@@ -80,7 +78,6 @@
(dbus_uint64_t) DBUS_UINT64_CONSTANT (0x00ff000000000000)) >> 40) | \
(((dbus_uint64_t) (val) & \
(dbus_uint64_t) DBUS_UINT64_CONSTANT (0xff00000000000000)) >> 56)))
#endif /* DBUS_HAVE_INT64 */
#endif /* HAVE_BYTESWAP_H */
......@@ -90,10 +87,8 @@
#define DBUS_UINT32_SWAP_LE_BE(val) (DBUS_UINT32_SWAP_LE_BE_CONSTANT (val))
#define DBUS_INT32_SWAP_LE_BE(val) ((dbus_int32_t)DBUS_UINT32_SWAP_LE_BE_CONSTANT (val))
#ifdef DBUS_HAVE_INT64
# define DBUS_UINT64_SWAP_LE_BE(val) (DBUS_UINT64_SWAP_LE_BE_CONSTANT (val))
# define DBUS_INT64_SWAP_LE_BE(val) ((dbus_int64_t)DBUS_UINT64_SWAP_LE_BE_CONSTANT (val))
#endif /* DBUS_HAVE_INT64 */
#define DBUS_UINT64_SWAP_LE_BE(val) (DBUS_UINT64_SWAP_LE_BE_CONSTANT (val))
#define DBUS_INT64_SWAP_LE_BE(val) ((dbus_int64_t)DBUS_UINT64_SWAP_LE_BE_CONSTANT (val))
#ifdef WORDS_BIGENDIAN
......@@ -105,12 +100,10 @@
# define DBUS_UINT32_TO_BE(val) ((dbus_uint32_t) (val))
# define DBUS_INT32_TO_LE(val) (DBUS_INT32_SWAP_LE_BE (val))
# define DBUS_UINT32_TO_LE(val) (DBUS_UINT32_SWAP_LE_BE (val))
# ifdef DBUS_HAVE_INT64
# define DBUS_INT64_TO_BE(val) ((dbus_int64_t) (val))
# define DBUS_UINT64_TO_BE(val) ((dbus_uint64_t) (val))
# define DBUS_INT64_TO_LE(val) (DBUS_INT64_SWAP_LE_BE (val))
# define DBUS_UINT64_TO_LE(val) (DBUS_UINT64_SWAP_LE_BE (val))
# endif /* DBUS_HAVE_INT64 */
#else /* WORDS_BIGENDIAN */
......@@ -122,12 +115,10 @@
# define DBUS_UINT32_TO_LE(val) ((dbus_uint32_t) (val))
# define DBUS_INT32_TO_BE(val) ((dbus_int32_t) DBUS_UINT32_SWAP_LE_BE (val))
# define DBUS_UINT32_TO_BE(val) (DBUS_UINT32_SWAP_LE_BE (val))
# ifdef DBUS_HAVE_INT64
# define DBUS_INT64_TO_LE(val) ((dbus_int64_t) (val))
# define DBUS_UINT64_TO_LE(val) ((dbus_uint64_t) (val))
# define DBUS_INT64_TO_BE(val) ((dbus_int64_t) DBUS_UINT64_SWAP_LE_BE (val))
# define DBUS_UINT64_TO_BE(val) (DBUS_UINT64_SWAP_LE_BE (val))
# endif /* DBUS_HAVE_INT64 */
#endif
/* The transformation is symmetric, so the FROM just maps to the TO. */
......@@ -139,12 +130,10 @@
#define DBUS_UINT32_FROM_LE(val) (DBUS_UINT32_TO_LE (val))
#define DBUS_INT32_FROM_BE(val) (DBUS_INT32_TO_BE (val))
#define DBUS_UINT32_FROM_BE(val) (DBUS_UINT32_TO_BE (val))
#ifdef DBUS_HAVE_INT64
# define DBUS_INT64_FROM_LE(val) (DBUS_INT64_TO_LE (val))
# define DBUS_UINT64_FROM_LE(val) (DBUS_UINT64_TO_LE (val))
# define DBUS_INT64_FROM_BE(val) (DBUS_INT64_TO_BE (val))
# define DBUS_UINT64_FROM_BE(val) (DBUS_UINT64_TO_BE (val))
#endif /* DBUS_HAVE_INT64 */
#define DBUS_INT64_FROM_LE(val) (DBUS_INT64_TO_LE (val))
#define DBUS_UINT64_FROM_LE(val) (DBUS_UINT64_TO_LE (val))
#define DBUS_INT64_FROM_BE(val) (DBUS_INT64_TO_BE (val))
#define DBUS_UINT64_FROM_BE(val) (DBUS_UINT64_TO_BE (val))
#ifdef DBUS_DISABLE_ASSERT
#define _dbus_unpack_uint16(byte_order, data) \
......
......@@ -73,11 +73,7 @@ byteswap_body_helper (DBusTypeReader *reader,
case DBUS_TYPE_DOUBLE:
{
p = _DBUS_ALIGN_ADDRESS (p, 8);
#ifdef DBUS_HAVE_INT64
*((dbus_uint64_t*)p) = DBUS_UINT64_SWAP_LE_BE (*((dbus_uint64_t*)p));
#else
_dbus_swap_array (p, 1, 8);
#endif
p += 8;
}
break;
......
......@@ -34,13 +34,7 @@
static void
basic_value_zero (DBusBasicValue *value)
{
#ifdef DBUS_HAVE_INT64
value->u64 = 0;
#else
value->eight.first32 = 0;
value->eight.second32 = 0;
#endif
}
static dbus_bool_t
......@@ -56,12 +50,7 @@ basic_value_equal (int type,
}
else
{
#ifdef DBUS_HAVE_INT64
return lhs->u64 == rhs->u64;
#else
return lhs->eight.first32 == rhs->eight.first32 &&
lhs->eight.second32 == rhs->eight.second32;
#endif
}
}
......@@ -2337,7 +2326,6 @@ int32_read_multi (TestTypeNode *node,
return TRUE;
}
#ifdef DBUS_HAVE_INT64
static dbus_int64_t
int64_from_seed (int seed)
{
......@@ -2351,7 +2339,6 @@ int64_from_seed (int seed)
return v;
}
#endif
static dbus_bool_t
int64_write_value (TestTypeNode *node,
......@@ -2359,7 +2346,6 @@ int64_write_value (TestTypeNode *node,
DBusTypeWriter *writer,
int seed)
{
#ifdef DBUS_HAVE_INT64
/* also used for uint64 */
dbus_int64_t v;
......@@ -2368,9 +2354,6 @@ int64_write_value (TestTypeNode *node,
return _dbus_type_writer_write_basic (writer,
node->klass->typecode,
&v);
#else
return TRUE;
#endif
}
static dbus_bool_t
......@@ -2378,7 +2361,6 @@ int64_read_value (TestTypeNode *node,
DBusTypeReader *reader,
int seed)
{
#ifdef DBUS_HAVE_INT64
/* also used for uint64 */
dbus_int64_t v;
......@@ -2390,9 +2372,6 @@ int64_read_value (TestTypeNode *node,
_dbus_assert (v == int64_from_seed (seed));
return TRUE;
#else
return TRUE;
#endif
}
static dbus_bool_t
......@@ -2401,7 +2380,6 @@ int64_set_value (TestTypeNode *node,
DBusTypeReader *realign_root,
int seed)
{
#ifdef DBUS_HAVE_INT64
/* also used for uint64 */
dbus_int64_t v;
......@@ -2410,9 +2388,6 @@ int64_set_value (TestTypeNode *node,
return _dbus_type_reader_set_basic (reader,
&v,
realign_root);
#else
return TRUE;
#endif
}
#define MAX_SAMPLE_STRING_LEN 10
......
......@@ -754,10 +754,8 @@ message_iter_test (DBusMessage *message)
dbus_uint16_t v_UINT16;
dbus_int32_t v_INT32;
dbus_uint32_t v_UINT32;
#ifdef DBUS_HAVE_INT64
dbus_int64_t v_INT64;
dbus_uint64_t v_UINT64;
#endif
unsigned char v_BYTE;
dbus_bool_t v_BOOLEAN;
......@@ -830,14 +828,12 @@ verify_test_message (DBusMessage *message)
int our_uint32_array_len;
dbus_int32_t *our_int32_array = (void*)0xdeadbeef;
int our_int32_array_len;
#ifdef DBUS_HAVE_INT64
dbus_int64_t our_int64;
dbus_uint64_t our_uint64;
dbus_int64_t *our_uint64_array = (void*)0xdeadbeef;
int our_uint64_array_len;
const dbus_int64_t *our_int64_array = (void*)0xdeadbeef;
int our_int64_array_len;
#endif
const double *our_double_array = (void*)0xdeadbeef;
int our_double_array_len;
const unsigned char *our_byte_array = (void*)0xdeadbeef;
......@@ -854,10 +850,8 @@ verify_test_message (DBusMessage *message)
DBUS_TYPE_UINT16, &our_uint16,
DBUS_TYPE_INT32, &our_int,
DBUS_TYPE_UINT32, &our_uint,
#ifdef DBUS_HAVE_INT64
DBUS_TYPE_INT64, &our_int64,
DBUS_TYPE_UINT64, &our_uint64,
#endif
DBUS_TYPE_STRING, &our_str,
DBUS_TYPE_DOUBLE, &our_double,
DBUS_TYPE_BOOLEAN, &our_bool,
......@@ -867,12 +861,10 @@ verify_test_message (DBusMessage *message)
&our_uint32_array, &our_uint32_array_len,
DBUS_TYPE_ARRAY, DBUS_TYPE_INT32,
&our_int32_array, &our_int32_array_len,
#ifdef DBUS_HAVE_INT64
DBUS_TYPE_ARRAY, DBUS_TYPE_UINT64,
&our_uint64_array, &our_uint64_array_len,
DBUS_TYPE_ARRAY, DBUS_TYPE_INT64,
&our_int64_array, &our_int64_array_len,
#endif
DBUS_TYPE_ARRAY, DBUS_TYPE_DOUBLE,
&our_double_array, &our_double_array_len,
DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
......@@ -900,12 +892,10 @@ verify_test_message (DBusMessage *message)
if (our_uint != 0x12300042)
_dbus_assert_not_reached ("uints differ!");
#ifdef DBUS_HAVE_INT64
if (our_int64 != DBUS_INT64_CONSTANT (-0x123456789abcd))
_dbus_assert_not_reached ("64-bit integers differ!");
if (our_uint64 != DBUS_UINT64_CONSTANT (0x123456789abcd))
_dbus_assert_not_reached ("64-bit unsigned integers differ!");
#endif
v_DOUBLE = 3.14159;
if (! _DBUS_DOUBLES_BITWISE_EQUAL (our_double, v_DOUBLE))
......@@ -937,7 +927,6 @@ verify_test_message (DBusMessage *message)
our_int32_array[3] != -0x45678123)
_dbus_assert_not_reached ("int array differs");
#ifdef DBUS_HAVE_INT64
if (our_uint64_array_len != 4 ||
our_uint64_array[0] != 0x12345678 ||
our_uint64_array[1] != 0x23456781 ||
......@@ -951,7 +940,6 @@ verify_test_message (DBusMessage *message)
our_int64_array[2] != 0x34567812 ||
our_int64_array[3] != -0x45678123)
_dbus_assert_not_reached ("int64 array differs");
#endif /* DBUS_HAVE_INT64 */
if (our_double_array_len != 3)
_dbus_assert_not_reached ("double array had wrong length");
......@@ -1025,14 +1013,12 @@ _dbus_message_test (const char *test_data_dir)
{ 0x12345678, -0x23456781, 0x34567812, -0x45678123 };
const dbus_uint32_t *v_ARRAY_UINT32 = our_uint32_array;
const dbus_int32_t *v_ARRAY_INT32 = our_int32_array;
#ifdef DBUS_HAVE_INT64
const dbus_uint64_t our_uint64_array[] =
{ 0x12345678, 0x23456781, 0x34567812, 0x45678123 };
const dbus_int64_t our_int64_array[] =
{ 0x12345678, -0x23456781, 0x34567812, -0x45678123 };
const dbus_uint64_t *v_ARRAY_UINT64 = our_uint64_array;
const dbus_int64_t *v_ARRAY_INT64 = our_int64_array;
#endif
const char *our_string_array[] = { "Foo", "bar", "", "woo woo woo woo" };
const char **v_ARRAY_STRING = our_string_array;
const double our_double_array[] = { 0.1234, 9876.54321, -300.0 };
......@@ -1049,10 +1035,8 @@ _dbus_message_test (const char *test_data_dir)
dbus_uint16_t v_UINT16;
dbus_int32_t v_INT32;
dbus_uint32_t v_UINT32;
#ifdef DBUS_HAVE_INT64
dbus_int64_t v_INT64;
dbus_uint64_t v_UINT64;
#endif
unsigned char v_BYTE;
unsigned char v2_BYTE;
dbus_bool_t v_BOOLEAN;
......@@ -1201,10 +1185,8 @@ _dbus_message_test (const char *test_data_dir)
v_UINT16 = 0x123;
v_INT32 = -0x12345678;
v_UINT32 = 0x12300042;
#ifdef DBUS_HAVE_INT64
v_INT64 = DBUS_INT64_CONSTANT (-0x123456789abcd);
v_UINT64 = DBUS_UINT64_CONSTANT (0x123456789abcd);
#endif
v_STRING = "Test string";
v_DOUBLE = 3.14159;
v_BOOLEAN = TRUE;
......@@ -1219,10 +1201,8 @@ _dbus_message_test (const char *test_data_dir)
DBUS_TYPE_UINT16, &v_UINT16,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_UINT32, &v_UINT32,
#ifdef DBUS_HAVE_INT64
DBUS_TYPE_INT64, &v_INT64,
DBUS_TYPE_UINT64, &v_UINT64,
#endif
DBUS_TYPE_STRING, &v_STRING,
DBUS_TYPE_DOUBLE, &v_DOUBLE,
DBUS_TYPE_BOOLEAN, &v_BOOLEAN,
......@@ -1232,12 +1212,10 @@ _dbus_message_test (const char *test_data_dir)
_DBUS_N_ELEMENTS (our_uint32_array),
DBUS_TYPE_ARRAY, DBUS_TYPE_INT32, &v_ARRAY_INT32,
_DBUS_N_ELEMENTS (our_int32_array),
#ifdef DBUS_HAVE_INT64
DBUS_TYPE_ARRAY, DBUS_TYPE_UINT64, &v_ARRAY_UINT64,
_DBUS_N_ELEMENTS (our_uint64_array),
DBUS_TYPE_ARRAY, DBUS_TYPE_INT64, &v_ARRAY_INT64,
_DBUS_N_ELEMENTS (our_int64_array),
#endif
DBUS_TYPE_ARRAY, DBUS_TYPE_DOUBLE, &v_ARRAY_DOUBLE,
_DBUS_N_ELEMENTS (our_double_array),
DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &v_ARRAY_BYTE,
......@@ -1254,10 +1232,8 @@ _dbus_message_test (const char *test_data_dir)
sig[i++] = DBUS_TYPE_UINT16;
sig[i++] = DBUS_TYPE_INT32;
sig[i++] = DBUS_TYPE_UINT32;
#ifdef DBUS_HAVE_INT64
sig[i++] = DBUS_TYPE_INT64;
sig[i++] = DBUS_TYPE_UINT64;
#endif
sig[i++] = DBUS_TYPE_STRING;
sig[i++] = DBUS_TYPE_DOUBLE;
sig[i++] = DBUS_TYPE_BOOLEAN;
......@@ -1267,12 +1243,10 @@ _dbus_message_test (const char *test_data_dir)
sig[i++] = DBUS_TYPE_UINT32;
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_INT32;
#ifdef DBUS_HAVE_INT64
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_UINT64;
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_INT64;
#endif
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_DOUBLE;
sig[i++] = DBUS_TYPE_ARRAY;
......
......@@ -938,29 +938,9 @@ _dbus_string_append (DBusString *str,
#define ASSIGN_4_OCTETS(p, octets) \
*((dbus_uint32_t*)(p)) = *((dbus_uint32_t*)(octets));
#ifdef DBUS_HAVE_INT64
/** assign 8 bytes from one string to another */
#define ASSIGN_8_OCTETS(p, octets) \
*((dbus_uint64_t*)(p)) = *((dbus_uint64_t*)(octets));
#else
/** assign 8 bytes from one string to another */
#define ASSIGN_8_OCTETS(p, octets) \
do { \
unsigned char *b; \
\
b = p; \
\
*b++ = octets[0]; \
*b++ = octets[1]; \
*b++ = octets[2]; \
*b++ = octets[3]; \
*b++ = octets[4]; \
*b++ = octets[5]; \
*b++ = octets[6]; \
*b++ = octets[7]; \
_dbus_assert (b == p + 8); \
} while (0)
#endif /* DBUS_HAVE_INT64 */
/**
* Inserts 2 bytes aligned on a 2 byte boundary
......
......@@ -79,43 +79,23 @@ typedef dbus_uint32_t dbus_bool_t;
/**
* @typedef dbus_uint64_t
*
* A 64-bit unsigned integer on all platforms that support it.
* If supported, #DBUS_HAVE_INT64 will be defined.
*
* C99 requires a 64-bit type and most likely all interesting
* compilers support one. GLib for example flat-out requires
* a 64-bit type.
*
* You probably want to just assume #DBUS_HAVE_INT64 is always defined.
* A 64-bit unsigned integer.
*/
/**
* @typedef dbus_int64_t
*
* A 64-bit signed integer on all platforms that support it.
* If supported, #DBUS_HAVE_INT64 will be defined.
*
* C99 requires a 64-bit type and most likely all interesting
* compilers support one. GLib for example flat-out requires
* a 64-bit type.
*
* You probably want to just assume #DBUS_HAVE_INT64 is always defined.
* A 64-bit signed integer.
*/
/**
* @def DBUS_HAVE_INT64
*
* Defined if 64-bit integers are available. Will be defined
* on any platform you care about, unless you care about
* some truly ancient UNIX, or some bizarre embedded platform.
*
* C99 requires a 64-bit type and most likely all interesting
* compilers support one. GLib for example flat-out requires
* a 64-bit type.
*
* You should feel comfortable ignoring this macro and just using
* int64 unconditionally.
* Always defined.
*
* In older libdbus versions, this would be undefined if there was no
* 64-bit integer type on that platform. libdbus no longer supports
* such platforms.
*/
/**
......@@ -136,7 +116,7 @@ typedef dbus_uint32_t dbus_bool_t;
/**
* An 8-byte struct you could use to access int64 without having
* int64 support
* int64 support. Use #dbus_int64_t or #dbus_uint64_t instead.
*/
typedef struct
{
......@@ -162,10 +142,8 @@ typedef union
dbus_int32_t i32; /**< as int32 */
dbus_uint32_t u32; /**< as int32 */
dbus_bool_t bool_val; /**< as boolean */
#ifdef DBUS_HAVE_INT64
dbus_int64_t i64; /**< as int64 */
dbus_uint64_t u64; /**< as int64 */
#endif
DBus8ByteStruct eight; /**< as 8-byte struct */
double dbl; /**< as double */
unsigned char byt; /**< as byte */
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment