compilerplugins/clang/salbool.cxx | 2
cppu/Library_cppu.mk | 1
cppu/source/uno/check.cxx | 290 ++++++++++++++++++++++++++++++++++++++
cppu/source/uno/data.cxx | 254 ---------------------------------
4 files changed, 292 insertions(+), 255 deletions(-)
New commits:
commit ea5bc30fbbfc5f3695290701cda9033f28bf5fe8
Author: Stephan Bergmann <sberg...@redhat.com>
Date: Tue Mar 8 21:31:31 2016 +0100
Extract static_asserts out of OSL_DEBUG_LEVEL > 0
Change-Id: I604b41a5063728833d57e2589e6d3ec39eb67166
diff --git a/cppu/source/uno/check.cxx b/cppu/source/uno/check.cxx
index 7adfe36..9dd892b 100644
--- a/cppu/source/uno/check.cxx
+++ b/cppu/source/uno/check.cxx
@@ -26,17 +26,8 @@
#include <sal/types.h>
#include <uno/any2.h>
-#if OSL_DEBUG_LEVEL > 0
-
-namespace {
-
-#if defined( SAL_W32)
-#pragma pack(push, 8)
-#endif
-
// Why hardcode like this instead of using the (generated)
// <sal/typesizes.h> ?
-
#if (defined(INTEL) \
&& (defined(__GNUC__) && (defined(LINUX) || defined(FREEBSD) || \
defined(NETBSD) || defined(OPENBSD) || \
@@ -46,15 +37,11 @@ namespace {
#define MAX_ALIGNMENT_4
#endif
-#define OFFSET_OF( s, m ) reinterpret_cast< size_t >(reinterpret_cast<char
*>(&reinterpret_cast<s *>(16)->m) -16)
+namespace {
-#define BINTEST_VERIFYOFFSET( s, m, n ) \
- if (OFFSET_OF(s, m) != static_cast<size_t>(n)) \
- { \
- fprintf(stderr, "### OFFSET_OF(" #s ", " #m ") = %" SAL_PRI_SIZET "u
instead of expected %" SAL_PRI_SIZET "u!!!\n", \
- OFFSET_OF(s, m), static_cast<size_t>(n)); \
- abort(); \
- }
+#if defined( SAL_W32)
+#pragma pack(push, 8)
+#endif
struct C1
{
@@ -166,117 +153,138 @@ enum Enum
v = SAL_MAX_ENUM
};
+#ifdef SAL_W32
+# pragma pack(pop)
+#endif
-class BinaryCompatible_Impl
-{
-public:
- BinaryCompatible_Impl();
-};
-BinaryCompatible_Impl::BinaryCompatible_Impl()
-{
- static_assert( static_cast<sal_Bool>(true) == sal_True,
- "must be binary compatible" );
- static_assert( static_cast<sal_Bool>(false) == sal_False,
- "must be binary compatible" );
+static_assert( static_cast<sal_Bool>(true) == sal_True,
+ "must be binary compatible" );
+static_assert( static_cast<sal_Bool>(false) == sal_False,
+ "must be binary compatible" );
#ifdef MAX_ALIGNMENT_4
- // max alignment is 4
- static_assert(offsetof(AlignSize_Impl, dDouble) == 4,
"offsetof(AlignSize_Impl, dDouble) != 4");
- static_assert(sizeof(AlignSize_Impl) == 12, "sizeof(AlignSize_Impl) !=
12");
+// max alignment is 4
+static_assert(offsetof(AlignSize_Impl, dDouble) == 4,
"offsetof(AlignSize_Impl, dDouble) != 4");
+static_assert(sizeof(AlignSize_Impl) == 12, "sizeof(AlignSize_Impl) != 12");
#else
- // max alignment is 8
- static_assert(offsetof(AlignSize_Impl, dDouble) == 8,
"offsetof(AlignSize_Impl, dDouble) != 8");
- static_assert(sizeof(AlignSize_Impl) == 16, "sizeof(AlignSize_Impl) !=
16");
+// max alignment is 8
+static_assert(offsetof(AlignSize_Impl, dDouble) == 8,
"offsetof(AlignSize_Impl, dDouble) != 8");
+static_assert(sizeof(AlignSize_Impl) == 16, "sizeof(AlignSize_Impl) != 16");
#endif
- // sequence
- static_assert((SAL_SEQUENCE_HEADER_SIZE % 8) == 0, "binary compatibility
test failed: (SAL_SEQUENCE_HEADER_SIZE % 8) == 0!!!");
- // enum
- static_assert(sizeof(Enum) == sizeof(sal_Int32), "binary compatibility
test failed: (sizeof(Enum) == sizeof(sal_Int32))");
- // any
- static_assert(sizeof(void *) >= sizeof(sal_Int32), "binary compatibility
test failed: (sizeof(void *) >= sizeof(sal_Int32))");
- static_assert(sizeof(uno_Any) == sizeof(void *) * 3, "binary compatibility
test failed: (sizeof(uno_Any) == sizeof(void *) * 3");
- static_assert(offsetof(uno_Any, pType) == 0, "offsetof(uno_Any, pType) !=
0");
- static_assert(offsetof(uno_Any, pData) == 1 * sizeof(void *),
"offsetof(uno_Any, pTData) != (1 * sizeof(void *))");
- static_assert(offsetof(uno_Any, pReserved) == 2 * sizeof(void *),
"offsetof(uno_Any, pReserved) != (2 * sizeof(void *))");
- // string
- static_assert(sizeof(OUString) == sizeof(rtl_uString *), "binary
compatibility test failed: sizeof(OUString) != sizeof(rtl_uString *)");
- // struct
- static_assert(sizeof(M) == 8, "sizeof(M) != 8");
- static_assert(offsetof(M, o) == 4, "offsetof(M, o) != 4");
- static_assert(sizeof(N) == 12, "sizeof(N) != 12");
- BINTEST_VERIFYOFFSET(N, p, 8);
- static_assert(sizeof(N2) == 12, "sizeof(N2) != 12");
+// sequence
+static_assert((SAL_SEQUENCE_HEADER_SIZE % 8) == 0, "binary compatibility test
failed: (SAL_SEQUENCE_HEADER_SIZE % 8) == 0!!!");
+// enum
+static_assert(sizeof(Enum) == sizeof(sal_Int32), "binary compatibility test
failed: (sizeof(Enum) == sizeof(sal_Int32))");
+// any
+static_assert(sizeof(void *) >= sizeof(sal_Int32), "binary compatibility test
failed: (sizeof(void *) >= sizeof(sal_Int32))");
+static_assert(sizeof(uno_Any) == sizeof(void *) * 3, "binary compatibility
test failed: (sizeof(uno_Any) == sizeof(void *) * 3");
+static_assert(offsetof(uno_Any, pType) == 0, "offsetof(uno_Any, pType) != 0");
+static_assert(offsetof(uno_Any, pData) == 1 * sizeof(void *),
"offsetof(uno_Any, pTData) != (1 * sizeof(void *))");
+static_assert(offsetof(uno_Any, pReserved) == 2 * sizeof(void *),
"offsetof(uno_Any, pReserved) != (2 * sizeof(void *))");
+// string
+static_assert(sizeof(OUString) == sizeof(rtl_uString *), "binary compatibility
test failed: sizeof(OUString) != sizeof(rtl_uString *)");
+// struct
+static_assert(sizeof(M) == 8, "sizeof(M) != 8");
+static_assert(offsetof(M, o) == 4, "offsetof(M, o) != 4");
+static_assert(sizeof(N) == 12, "sizeof(N) != 12");
+
+static_assert(sizeof(N2) == 12, "sizeof(N2) != 12");
+
+static_assert(offsetof(N2, p) == 8, "offsetof(N2, p) != 8");
+#ifdef MAX_ALIGNMENT_4
+static_assert(sizeof(O) == 20, "sizeof(O) != 20");
+#else
+static_assert(sizeof(O) == 24, "sizeof(O) != 24");
+#endif
+static_assert(sizeof(D) == 8, "sizeof(D) != 8");
+static_assert(offsetof(D, e) == 4, "offsetof(D, e) != 4");
+static_assert(offsetof(E, d) == 4, "offsetof(E, d) != 4");
+static_assert(offsetof(E, e) == 8, "offsetof(E, e) != 8");
+
+static_assert(sizeof(C1) == 2, "sizeof(C1) != 2");
+static_assert(sizeof(C2) == 8, "sizeof(C2) != 8");
+
+#ifdef MAX_ALIGNMENT_4
+static_assert(sizeof(C3) == 20, "sizeof(C3) != 20");
+static_assert(sizeof(C4) == 32, "sizeof(C4) != 32");
+static_assert(sizeof(C5) == 44, "sizeof(C5) != 44");
+static_assert(sizeof(C6) == 52, "sizeof(C6) != 52");
+
+static_assert(sizeof(O2) == 24, "sizeof(O2) != 24");
+#else
+static_assert(sizeof(C3) == 24, "sizeof(C3) != 24");
+static_assert(sizeof(C4) == 40, "sizeof(C4) != 40");
+static_assert(sizeof(C5) == 56, "sizeof(C5) != 56");
+static_assert(sizeof(C6) == 72, "sizeof(C6) != 72");
+
+static_assert(sizeof(O2) == 32, "sizeof(O2) != 32");
+#endif
+
+static_assert(sizeof(Char3) == 3, "sizeof(Char3) != 3");
- static_assert(offsetof(N2, p) == 8, "offsetof(N2, p) != 8");
#ifdef MAX_ALIGNMENT_4
- static_assert(sizeof(O) == 20, "sizeof(O) != 20");
+// max alignment is 4
+static_assert(sizeof(P) == 20, "sizeof(P) != 20");
#else
- static_assert(sizeof(O) == 24, "sizeof(O) != 24");
+// alignment of P is 8, because of P[] ...
+static_assert(sizeof(P) == 24, "sizeof(P) != 24");
+static_assert(sizeof(second) == sizeof(int), "sizeof(second) != sizeof(int)");
#endif
- static_assert(sizeof(D) == 8, "sizeof(D) != 8");
- static_assert(offsetof(D, e) == 4, "offsetof(D, e) != 4");
- static_assert(offsetof(E, d) == 4, "offsetof(E, d) != 4");
- static_assert(offsetof(E, e) == 8, "offsetof(E, e) != 8");
- static_assert(sizeof(C1) == 2, "sizeof(C1) != 2");
- static_assert(sizeof(C2) == 8, "sizeof(C2) != 8");
+#if OSL_DEBUG_LEVEL > 0
+
+#define OFFSET_OF( s, m ) reinterpret_cast< size_t >(reinterpret_cast<char
*>(&reinterpret_cast<s *>(16)->m) -16)
+
+#define BINTEST_VERIFYOFFSET( s, m, n ) \
+ if (OFFSET_OF(s, m) != static_cast<size_t>(n)) \
+ { \
+ fprintf(stderr, "### OFFSET_OF(" #s ", " #m ") = %" SAL_PRI_SIZET "u
instead of expected %" SAL_PRI_SIZET "u!!!\n", \
+ OFFSET_OF(s, m), static_cast<size_t>(n)); \
+ abort(); \
+ }
+
+class BinaryCompatible_Impl
+{
+public:
+ BinaryCompatible_Impl();
+};
+BinaryCompatible_Impl::BinaryCompatible_Impl()
+{
+ BINTEST_VERIFYOFFSET(N, p, 8);
+
BINTEST_VERIFYOFFSET(C2, n2, 4);
#ifdef MAX_ALIGNMENT_4
- static_assert(sizeof(C3) == 20, "sizeof(C3) != 20");
BINTEST_VERIFYOFFSET(C3, d3, 8);
BINTEST_VERIFYOFFSET(C3, n3, 16);
- static_assert(sizeof(C4) == 32, "sizeof(C4) != 32");
BINTEST_VERIFYOFFSET(C4, n4, 20);
BINTEST_VERIFYOFFSET(C4, d4, 24);
- static_assert(sizeof(C5) == 44, "sizeof(C5) != 44");
BINTEST_VERIFYOFFSET(C5, n5, 32);
BINTEST_VERIFYOFFSET(C5, b5, 40);
- static_assert(sizeof(C6) == 52, "sizeof(C6) != 52");
BINTEST_VERIFYOFFSET(C6, c6, 4);
BINTEST_VERIFYOFFSET(C6, b6, 48);
- static_assert(sizeof(O2) == 24, "sizeof(O2) != 24");
BINTEST_VERIFYOFFSET(O2, p2, 20);
#else
- static_assert(sizeof(C3) == 24, "sizeof(C3) != 24");
BINTEST_VERIFYOFFSET(C3, d3, 8);
BINTEST_VERIFYOFFSET(C3, n3, 16);
- static_assert(sizeof(C4) == 40, "sizeof(C4) != 40");
BINTEST_VERIFYOFFSET(C4, n4, 24);
BINTEST_VERIFYOFFSET(C4, d4, 32);
- static_assert(sizeof(C5) == 56, "sizeof(C5) != 56");
BINTEST_VERIFYOFFSET(C5, n5, 40);
BINTEST_VERIFYOFFSET(C5, b5, 48);
- static_assert(sizeof(C6) == 72, "sizeof(C6) != 72");
BINTEST_VERIFYOFFSET(C6, c6, 8);
BINTEST_VERIFYOFFSET(C6, b6, 64);
- static_assert(sizeof(O2) == 32, "sizeof(O2) != 32");
BINTEST_VERIFYOFFSET(O2, p2, 24);
#endif
- static_assert(sizeof(Char3) == 3, "sizeof(Char3) != 3");
BINTEST_VERIFYOFFSET( Char4, c, 3 );
-
-#ifdef MAX_ALIGNMENT_4
- // max alignment is 4
- static_assert(sizeof(P) == 20, "sizeof(P) != 20");
-#else
- // alignment of P is 8, because of P[] ...
- static_assert(sizeof(P) == 24, "sizeof(P) != 24");
- static_assert(sizeof(second) == sizeof(int), "sizeof(second) !=
sizeof(int)");
-#endif
}
-#ifdef SAL_W32
-# pragma pack(pop)
-#endif
-
static BinaryCompatible_Impl aTest;
-}
-
#endif
+}
+
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
commit 4f56db98af686bab0ec90b4342428b7fd42b2f7b
Author: Stephan Bergmann <sberg...@redhat.com>
Date: Tue Mar 8 21:23:41 2016 +0100
Clean up namespace
Change-Id: I8207f7906cb8914b6c272efaf8f136a1bce7e4b0
diff --git a/cppu/source/uno/check.cxx b/cppu/source/uno/check.cxx
index dfc8d84..7adfe36 100644
--- a/cppu/source/uno/check.cxx
+++ b/cppu/source/uno/check.cxx
@@ -28,7 +28,7 @@
#if OSL_DEBUG_LEVEL > 0
-namespace cppu {
+namespace {
#if defined( SAL_W32)
#pragma pack(push, 8)
commit 7024c86b17f80b9ebcf58f44ab0e3f1bfdb9d16e
Author: Stephan Bergmann <sberg...@redhat.com>
Date: Tue Mar 8 21:22:34 2016 +0100
Extract checking code to its own check.cxx
Change-Id: I9d5b14c374ce62ac7b970faa30c38a5a76568ed4
diff --git a/compilerplugins/clang/salbool.cxx
b/compilerplugins/clang/salbool.cxx
index 7712033..0cea0eb 100644
--- a/compilerplugins/clang/salbool.cxx
+++ b/compilerplugins/clang/salbool.cxx
@@ -584,7 +584,7 @@ bool SalBool::isInSpecialMainFile(SourceLocation
spellingLocation) const {
}
auto f = compiler.getSourceManager().getFilename(spellingLocation);
return f == SRCDIR "/cppu/qa/test_any.cxx"
- || f == SRCDIR "/cppu/source/uno/data.cxx"; // TODO: the offset checks
+ || f == SRCDIR "/cppu/source/uno/check.cxx"; // TODO: the offset checks
}
bool SalBool::rewrite(SourceLocation location) {
diff --git a/cppu/Library_cppu.mk b/cppu/Library_cppu.mk
index 437cd42..c070060 100644
--- a/cppu/Library_cppu.mk
+++ b/cppu/Library_cppu.mk
@@ -42,6 +42,7 @@ $(eval $(call gb_Library_add_exception_objects,cppu,\
cppu/source/typelib/typelib \
cppu/source/uno/any \
cppu/source/uno/cascade_mapping \
+ cppu/source/uno/check \
cppu/source/uno/data \
cppu/source/uno/EnvStack \
cppu/source/uno/IdentityMapping \
diff --git a/cppu/source/uno/check.cxx b/cppu/source/uno/check.cxx
new file mode 100644
index 0000000..dfc8d84
--- /dev/null
+++ b/cppu/source/uno/check.cxx
@@ -0,0 +1,282 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sal/config.h>
+
+#include <stdio.h>
+
+#include <cppu/macros.hxx>
+#include <rtl/ustring.hxx>
+#include <sal/types.h>
+#include <uno/any2.h>
+
+#if OSL_DEBUG_LEVEL > 0
+
+namespace cppu {
+
+#if defined( SAL_W32)
+#pragma pack(push, 8)
+#endif
+
+// Why hardcode like this instead of using the (generated)
+// <sal/typesizes.h> ?
+
+#if (defined(INTEL) \
+ && (defined(__GNUC__) && (defined(LINUX) || defined(FREEBSD) || \
+ defined(NETBSD) || defined(OPENBSD) || \
+ defined(DRAGONFLY) || defined(SOLARIS)) \
+ || defined(MACOSX) )) \
+ || defined(IOS)
+#define MAX_ALIGNMENT_4
+#endif
+
+#define OFFSET_OF( s, m ) reinterpret_cast< size_t >(reinterpret_cast<char
*>(&reinterpret_cast<s *>(16)->m) -16)
+
+#define BINTEST_VERIFYOFFSET( s, m, n ) \
+ if (OFFSET_OF(s, m) != static_cast<size_t>(n)) \
+ { \
+ fprintf(stderr, "### OFFSET_OF(" #s ", " #m ") = %" SAL_PRI_SIZET "u
instead of expected %" SAL_PRI_SIZET "u!!!\n", \
+ OFFSET_OF(s, m), static_cast<size_t>(n)); \
+ abort(); \
+ }
+
+struct C1
+{
+ sal_Int16 n1;
+};
+struct C2 : public C1
+{
+ sal_Int32 n2 CPPU_GCC3_ALIGN( C1 );
+};
+struct C3 : public C2
+{
+ double d3;
+ sal_Int32 n3;
+};
+struct C4 : public C3
+{
+ sal_Int32 n4 CPPU_GCC3_ALIGN( C3 );
+ double d4;
+};
+struct C5 : public C4
+{
+ sal_Int64 n5;
+ sal_Bool b5;
+};
+struct C6 : public C1
+{
+ C5 c6 CPPU_GCC3_ALIGN( C1 );
+ sal_Bool b6;
+};
+
+struct D
+{
+ sal_Int16 d;
+ sal_Int32 e;
+};
+struct E
+{
+ sal_Bool a;
+ sal_Bool b;
+ sal_Bool c;
+ sal_Int16 d;
+ sal_Int32 e;
+};
+
+struct M
+{
+ sal_Int32 n;
+ sal_Int16 o;
+};
+
+struct N : public M
+{
+ sal_Int16 p CPPU_GCC3_ALIGN( M );
+};
+struct N2
+{
+ M m;
+ sal_Int16 p;
+};
+
+struct O : public M
+{
+ double p;
+ sal_Int16 q;
+};
+struct O2 : public O
+{
+ sal_Int16 p2 CPPU_GCC3_ALIGN( O );
+};
+
+struct P : public N
+{
+ double p2;
+};
+
+struct empty
+{
+};
+struct second : public empty
+{
+ int a;
+};
+
+struct AlignSize_Impl
+{
+ sal_Int16 nInt16;
+ double dDouble;
+};
+
+struct Char1
+{
+ char c1;
+};
+struct Char2 : public Char1
+{
+ char c2 CPPU_GCC3_ALIGN( Char1 );
+};
+struct Char3 : public Char2
+{
+ char c3 CPPU_GCC3_ALIGN( Char2 );
+};
+struct Char4
+{
+ Char3 chars;
+ char c;
+};
+enum Enum
+{
+ v = SAL_MAX_ENUM
+};
+
+
+class BinaryCompatible_Impl
+{
+public:
+ BinaryCompatible_Impl();
+};
+BinaryCompatible_Impl::BinaryCompatible_Impl()
+{
+ static_assert( static_cast<sal_Bool>(true) == sal_True,
+ "must be binary compatible" );
+ static_assert( static_cast<sal_Bool>(false) == sal_False,
+ "must be binary compatible" );
+#ifdef MAX_ALIGNMENT_4
+ // max alignment is 4
+ static_assert(offsetof(AlignSize_Impl, dDouble) == 4,
"offsetof(AlignSize_Impl, dDouble) != 4");
+ static_assert(sizeof(AlignSize_Impl) == 12, "sizeof(AlignSize_Impl) !=
12");
+#else
+ // max alignment is 8
+ static_assert(offsetof(AlignSize_Impl, dDouble) == 8,
"offsetof(AlignSize_Impl, dDouble) != 8");
+ static_assert(sizeof(AlignSize_Impl) == 16, "sizeof(AlignSize_Impl) !=
16");
+#endif
+
+ // sequence
+ static_assert((SAL_SEQUENCE_HEADER_SIZE % 8) == 0, "binary compatibility
test failed: (SAL_SEQUENCE_HEADER_SIZE % 8) == 0!!!");
+ // enum
+ static_assert(sizeof(Enum) == sizeof(sal_Int32), "binary compatibility
test failed: (sizeof(Enum) == sizeof(sal_Int32))");
+ // any
+ static_assert(sizeof(void *) >= sizeof(sal_Int32), "binary compatibility
test failed: (sizeof(void *) >= sizeof(sal_Int32))");
+ static_assert(sizeof(uno_Any) == sizeof(void *) * 3, "binary compatibility
test failed: (sizeof(uno_Any) == sizeof(void *) * 3");
+ static_assert(offsetof(uno_Any, pType) == 0, "offsetof(uno_Any, pType) !=
0");
+ static_assert(offsetof(uno_Any, pData) == 1 * sizeof(void *),
"offsetof(uno_Any, pTData) != (1 * sizeof(void *))");
+ static_assert(offsetof(uno_Any, pReserved) == 2 * sizeof(void *),
"offsetof(uno_Any, pReserved) != (2 * sizeof(void *))");
+ // string
+ static_assert(sizeof(OUString) == sizeof(rtl_uString *), "binary
compatibility test failed: sizeof(OUString) != sizeof(rtl_uString *)");
+ // struct
+ static_assert(sizeof(M) == 8, "sizeof(M) != 8");
+ static_assert(offsetof(M, o) == 4, "offsetof(M, o) != 4");
+ static_assert(sizeof(N) == 12, "sizeof(N) != 12");
+ BINTEST_VERIFYOFFSET(N, p, 8);
+ static_assert(sizeof(N2) == 12, "sizeof(N2) != 12");
+
+ static_assert(offsetof(N2, p) == 8, "offsetof(N2, p) != 8");
+#ifdef MAX_ALIGNMENT_4
+ static_assert(sizeof(O) == 20, "sizeof(O) != 20");
+#else
+ static_assert(sizeof(O) == 24, "sizeof(O) != 24");
+#endif
+ static_assert(sizeof(D) == 8, "sizeof(D) != 8");
+ static_assert(offsetof(D, e) == 4, "offsetof(D, e) != 4");
+ static_assert(offsetof(E, d) == 4, "offsetof(E, d) != 4");
+ static_assert(offsetof(E, e) == 8, "offsetof(E, e) != 8");
+
+ static_assert(sizeof(C1) == 2, "sizeof(C1) != 2");
+ static_assert(sizeof(C2) == 8, "sizeof(C2) != 8");
+ BINTEST_VERIFYOFFSET(C2, n2, 4);
+
+#ifdef MAX_ALIGNMENT_4
+ static_assert(sizeof(C3) == 20, "sizeof(C3) != 20");
+ BINTEST_VERIFYOFFSET(C3, d3, 8);
+ BINTEST_VERIFYOFFSET(C3, n3, 16);
+ static_assert(sizeof(C4) == 32, "sizeof(C4) != 32");
+ BINTEST_VERIFYOFFSET(C4, n4, 20);
+ BINTEST_VERIFYOFFSET(C4, d4, 24);
+ static_assert(sizeof(C5) == 44, "sizeof(C5) != 44");
+ BINTEST_VERIFYOFFSET(C5, n5, 32);
+ BINTEST_VERIFYOFFSET(C5, b5, 40);
+ static_assert(sizeof(C6) == 52, "sizeof(C6) != 52");
+ BINTEST_VERIFYOFFSET(C6, c6, 4);
+ BINTEST_VERIFYOFFSET(C6, b6, 48);
+
+ static_assert(sizeof(O2) == 24, "sizeof(O2) != 24");
+ BINTEST_VERIFYOFFSET(O2, p2, 20);
+#else
+ static_assert(sizeof(C3) == 24, "sizeof(C3) != 24");
+ BINTEST_VERIFYOFFSET(C3, d3, 8);
+ BINTEST_VERIFYOFFSET(C3, n3, 16);
+ static_assert(sizeof(C4) == 40, "sizeof(C4) != 40");
+ BINTEST_VERIFYOFFSET(C4, n4, 24);
+ BINTEST_VERIFYOFFSET(C4, d4, 32);
+ static_assert(sizeof(C5) == 56, "sizeof(C5) != 56");
+ BINTEST_VERIFYOFFSET(C5, n5, 40);
+ BINTEST_VERIFYOFFSET(C5, b5, 48);
+ static_assert(sizeof(C6) == 72, "sizeof(C6) != 72");
+ BINTEST_VERIFYOFFSET(C6, c6, 8);
+ BINTEST_VERIFYOFFSET(C6, b6, 64);
+
+ static_assert(sizeof(O2) == 32, "sizeof(O2) != 32");
+ BINTEST_VERIFYOFFSET(O2, p2, 24);
+#endif
+
+ static_assert(sizeof(Char3) == 3, "sizeof(Char3) != 3");
+ BINTEST_VERIFYOFFSET( Char4, c, 3 );
+
+#ifdef MAX_ALIGNMENT_4
+ // max alignment is 4
+ static_assert(sizeof(P) == 20, "sizeof(P) != 20");
+#else
+ // alignment of P is 8, because of P[] ...
+ static_assert(sizeof(P) == 24, "sizeof(P) != 24");
+ static_assert(sizeof(second) == sizeof(int), "sizeof(second) !=
sizeof(int)");
+#endif
+}
+
+#ifdef SAL_W32
+# pragma pack(pop)
+#endif
+
+static BinaryCompatible_Impl aTest;
+
+}
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cppu/source/uno/data.cxx b/cppu/source/uno/data.cxx
index d0d22f6..2104280 100644
--- a/cppu/source/uno/data.cxx
+++ b/cppu/source/uno/data.cxx
@@ -19,9 +19,7 @@
#include <cstddef>
-#include <stdio.h>
-#include "cppu/macros.hxx"
#include "osl/mutex.hxx"
#include "sal/log.hxx"
#include "uno/data.h"
@@ -321,256 +319,4 @@ sal_Bool SAL_CALL uno_type_isAssignableFromData(
}
-#if OSL_DEBUG_LEVEL > 0
-namespace cppu {
-
-#if defined( SAL_W32)
-#pragma pack(push, 8)
-#endif
-
-// Why hardcode like this instead of using the (generated)
-// <sal/typesizes.h> ?
-
-#if (defined(INTEL) \
- && (defined(__GNUC__) && (defined(LINUX) || defined(FREEBSD) || \
- defined(NETBSD) || defined(OPENBSD) || \
- defined(DRAGONFLY) || defined(SOLARIS)) \
- || defined(MACOSX) )) \
- || defined(IOS)
-#define MAX_ALIGNMENT_4
-#endif
-
-#define OFFSET_OF( s, m ) reinterpret_cast< size_t >(reinterpret_cast<char
*>(&reinterpret_cast<s *>(16)->m) -16)
-
-#define BINTEST_VERIFYOFFSET( s, m, n ) \
- if (OFFSET_OF(s, m) != static_cast<size_t>(n)) \
- { \
- fprintf(stderr, "### OFFSET_OF(" #s ", " #m ") = %" SAL_PRI_SIZET "u
instead of expected %" SAL_PRI_SIZET "u!!!\n", \
- OFFSET_OF(s, m), static_cast<size_t>(n)); \
- abort(); \
- }
-
-struct C1
-{
- sal_Int16 n1;
-};
-struct C2 : public C1
-{
- sal_Int32 n2 CPPU_GCC3_ALIGN( C1 );
-};
-struct C3 : public C2
-{
- double d3;
- sal_Int32 n3;
-};
-struct C4 : public C3
-{
- sal_Int32 n4 CPPU_GCC3_ALIGN( C3 );
- double d4;
-};
-struct C5 : public C4
-{
- sal_Int64 n5;
- sal_Bool b5;
-};
-struct C6 : public C1
-{
- C5 c6 CPPU_GCC3_ALIGN( C1 );
- sal_Bool b6;
-};
-
-struct D
-{
- sal_Int16 d;
- sal_Int32 e;
-};
-struct E
-{
- sal_Bool a;
- sal_Bool b;
- sal_Bool c;
- sal_Int16 d;
- sal_Int32 e;
-};
-
-struct M
-{
- sal_Int32 n;
- sal_Int16 o;
-};
-
-struct N : public M
-{
- sal_Int16 p CPPU_GCC3_ALIGN( M );
-};
-struct N2
-{
- M m;
- sal_Int16 p;
-};
-
-struct O : public M
-{
- double p;
- sal_Int16 q;
-};
-struct O2 : public O
-{
- sal_Int16 p2 CPPU_GCC3_ALIGN( O );
-};
-
-struct P : public N
-{
- double p2;
-};
-
-struct empty
-{
-};
-struct second : public empty
-{
- int a;
-};
-
-struct AlignSize_Impl
-{
- sal_Int16 nInt16;
- double dDouble;
-};
-
-struct Char1
-{
- char c1;
-};
-struct Char2 : public Char1
-{
- char c2 CPPU_GCC3_ALIGN( Char1 );
-};
-struct Char3 : public Char2
-{
- char c3 CPPU_GCC3_ALIGN( Char2 );
-};
-struct Char4
-{
- Char3 chars;
- char c;
-};
-enum Enum
-{
- v = SAL_MAX_ENUM
-};
-
-
-class BinaryCompatible_Impl
-{
-public:
- BinaryCompatible_Impl();
-};
-BinaryCompatible_Impl::BinaryCompatible_Impl()
-{
- static_assert( static_cast<sal_Bool>(true) == sal_True,
- "must be binary compatible" );
- static_assert( static_cast<sal_Bool>(false) == sal_False,
- "must be binary compatible" );
-#ifdef MAX_ALIGNMENT_4
- // max alignment is 4
- static_assert(offsetof(AlignSize_Impl, dDouble) == 4,
"offsetof(AlignSize_Impl, dDouble) != 4");
- static_assert(sizeof(AlignSize_Impl) == 12, "sizeof(AlignSize_Impl) !=
12");
-#else
- // max alignment is 8
- static_assert(offsetof(AlignSize_Impl, dDouble) == 8,
"offsetof(AlignSize_Impl, dDouble) != 8");
- static_assert(sizeof(AlignSize_Impl) == 16, "sizeof(AlignSize_Impl) !=
16");
-#endif
-
- // sequence
- static_assert((SAL_SEQUENCE_HEADER_SIZE % 8) == 0, "binary compatibility
test failed: (SAL_SEQUENCE_HEADER_SIZE % 8) == 0!!!");
- // enum
- static_assert(sizeof(Enum) == sizeof(sal_Int32), "binary compatibility
test failed: (sizeof(Enum) == sizeof(sal_Int32))");
- // any
- static_assert(sizeof(void *) >= sizeof(sal_Int32), "binary compatibility
test failed: (sizeof(void *) >= sizeof(sal_Int32))");
- static_assert(sizeof(uno_Any) == sizeof(void *) * 3, "binary compatibility
test failed: (sizeof(uno_Any) == sizeof(void *) * 3");
- static_assert(offsetof(uno_Any, pType) == 0, "offsetof(uno_Any, pType) !=
0");
- static_assert(offsetof(uno_Any, pData) == 1 * sizeof(void *),
"offsetof(uno_Any, pTData) != (1 * sizeof(void *))");
- static_assert(offsetof(uno_Any, pReserved) == 2 * sizeof(void *),
"offsetof(uno_Any, pReserved) != (2 * sizeof(void *))");
- // string
- static_assert(sizeof(OUString) == sizeof(rtl_uString *), "binary
compatibility test failed: sizeof(OUString) != sizeof(rtl_uString *)");
- // struct
- static_assert(sizeof(M) == 8, "sizeof(M) != 8");
- static_assert(offsetof(M, o) == 4, "offsetof(M, o) != 4");
- static_assert(sizeof(N) == 12, "sizeof(N) != 12");
- BINTEST_VERIFYOFFSET(N, p, 8);
- static_assert(sizeof(N2) == 12, "sizeof(N2) != 12");
-
- static_assert(offsetof(N2, p) == 8, "offsetof(N2, p) != 8");
-#ifdef MAX_ALIGNMENT_4
- static_assert(sizeof(O) == 20, "sizeof(O) != 20");
-#else
- static_assert(sizeof(O) == 24, "sizeof(O) != 24");
-#endif
- static_assert(sizeof(D) == 8, "sizeof(D) != 8");
- static_assert(offsetof(D, e) == 4, "offsetof(D, e) != 4");
- static_assert(offsetof(E, d) == 4, "offsetof(E, d) != 4");
- static_assert(offsetof(E, e) == 8, "offsetof(E, e) != 8");
-
- static_assert(sizeof(C1) == 2, "sizeof(C1) != 2");
- static_assert(sizeof(C2) == 8, "sizeof(C2) != 8");
- BINTEST_VERIFYOFFSET(C2, n2, 4);
-
-#ifdef MAX_ALIGNMENT_4
- static_assert(sizeof(C3) == 20, "sizeof(C3) != 20");
- BINTEST_VERIFYOFFSET(C3, d3, 8);
- BINTEST_VERIFYOFFSET(C3, n3, 16);
- static_assert(sizeof(C4) == 32, "sizeof(C4) != 32");
- BINTEST_VERIFYOFFSET(C4, n4, 20);
- BINTEST_VERIFYOFFSET(C4, d4, 24);
- static_assert(sizeof(C5) == 44, "sizeof(C5) != 44");
- BINTEST_VERIFYOFFSET(C5, n5, 32);
- BINTEST_VERIFYOFFSET(C5, b5, 40);
- static_assert(sizeof(C6) == 52, "sizeof(C6) != 52");
- BINTEST_VERIFYOFFSET(C6, c6, 4);
- BINTEST_VERIFYOFFSET(C6, b6, 48);
-
- static_assert(sizeof(O2) == 24, "sizeof(O2) != 24");
- BINTEST_VERIFYOFFSET(O2, p2, 20);
-#else
- static_assert(sizeof(C3) == 24, "sizeof(C3) != 24");
- BINTEST_VERIFYOFFSET(C3, d3, 8);
- BINTEST_VERIFYOFFSET(C3, n3, 16);
- static_assert(sizeof(C4) == 40, "sizeof(C4) != 40");
- BINTEST_VERIFYOFFSET(C4, n4, 24);
- BINTEST_VERIFYOFFSET(C4, d4, 32);
- static_assert(sizeof(C5) == 56, "sizeof(C5) != 56");
- BINTEST_VERIFYOFFSET(C5, n5, 40);
- BINTEST_VERIFYOFFSET(C5, b5, 48);
- static_assert(sizeof(C6) == 72, "sizeof(C6) != 72");
- BINTEST_VERIFYOFFSET(C6, c6, 8);
- BINTEST_VERIFYOFFSET(C6, b6, 64);
-
- static_assert(sizeof(O2) == 32, "sizeof(O2) != 32");
- BINTEST_VERIFYOFFSET(O2, p2, 24);
-#endif
-
- static_assert(sizeof(Char3) == 3, "sizeof(Char3) != 3");
- BINTEST_VERIFYOFFSET( Char4, c, 3 );
-
-#ifdef MAX_ALIGNMENT_4
- // max alignment is 4
- static_assert(sizeof(P) == 20, "sizeof(P) != 20");
-#else
- // alignment of P is 8, because of P[] ...
- static_assert(sizeof(P) == 24, "sizeof(P) != 24");
- static_assert(sizeof(second) == sizeof(int), "sizeof(second) !=
sizeof(int)");
-#endif
-}
-
-#ifdef SAL_W32
-# pragma pack(pop)
-#endif
-
-static BinaryCompatible_Impl aTest;
-
-}
-
-#endif
-
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
_______________________________________________
Libreoffice-commits mailing list
libreoffice-comm...@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/libreoffice-commits
