Finalize CLN 1.3.7 release.

[cln.git] / include / cln / number.h

diff --git a/include/cln/number.h b/include/cln/number.h
index aff318b5517ca8158223587f9a70a774eb979754..67f68899a6926eca49722f012d0a20d159162c57 100644 (file)
--- a/include/cln/number.h
+++ b/include/cln/number.h
@@ -25,6 +25,18 @@
 
 // Constructors and assignment operators from C numeric types.
 
+#ifdef _MSC_VER
+// Workaround to force MSVC to tag the symbol with the cln:: namespace
+// When declaring inside an inlined function the symbol is placed in the 
+// global namespace!
+namespace cln {
+extern cl_private_thing cl_I_constructor_from_L (sint32 wert);
+extern cl_private_thing cl_I_constructor_from_UL (uint32 wert);
+extern cl_private_thing cl_I_constructor_from_Q (sint64 wert);
+extern cl_private_thing cl_I_constructor_from_UQ (uint64 wert);
+}
+#endif
+
 #define CL_DEFINE_INT_CONSTRUCTOR(_class_,_type_)  \
 inline _class_::_class_ (const _type_ wert)                            \
 {                                                                      \
@@ -109,40 +121,67 @@ inline _class_& _class_::operator= (const unsigned long wert)             \
 }
 #endif
 
+#if (long_long_bitsize==64)
+// `long' == `sintQ', `unsigned long' == `uintQ'.
+#define CL_DEFINE_LONGLONG_CONSTRUCTORS(_class_)  \
+inline _class_::_class_ (const long long wert)                         \
+{                                                                      \
+       extern cl_private_thing cl_I_constructor_from_Q (sint64 wert);  \
+       pointer = cl_I_constructor_from_Q(wert);                        \
+}                                                                      \
+inline _class_::_class_ (const unsigned long long wert)                        \
+{                                                                      \
+       extern cl_private_thing cl_I_constructor_from_UQ (uint64 wert); \
+       pointer = cl_I_constructor_from_UQ(wert);                       \
+}
+#define CL_DEFINE_LONGLONG_ASSIGNMENT_OPERATORS(_class_)                       \
+inline _class_& _class_::operator= (const long long wert)              \
+{                                                                      \
+       extern cl_private_thing cl_I_constructor_from_Q (sint64 wert);  \
+       cl_dec_refcount(*this);                                         \
+       pointer = cl_I_constructor_from_Q(wert);                        \
+       return *this;                                                   \
+}                                                                      \
+inline _class_& _class_::operator= (const unsigned long long wert)     \
+{                                                                      \
+       extern cl_private_thing cl_I_constructor_from_UQ (uint64 wert); \
+       cl_dec_refcount(*this);                                         \
+       pointer = cl_I_constructor_from_UQ(wert);                       \
+       return *this;                                                   \
+}
+#endif
 
 namespace cln {
 
 // Constructors and assignment operators from C numeric types.
 
 // from `float':
-union ffloatjanus;
-extern cl_private_thing cl_float_to_FF_pointer (const union ffloatjanus& val);
+extern cl_private_thing cl_float_to_FF_pointer (const float val);
 
 #define CL_DEFINE_FLOAT_CONSTRUCTOR(_class_)                           \
 inline _class_ :: _class_ (const float x)                              \
 {                                                                      \
-       pointer = cl_float_to_FF_pointer(*(const union ffloatjanus *)&x); \
+       pointer = cl_float_to_FF_pointer(x);                            \
 }                                                                      \
 inline _class_& _class_::operator= (const float x)                     \
 {                                                                      \
        cl_dec_refcount(*this);                                         \
-       pointer = cl_float_to_FF_pointer(*(const union ffloatjanus *)&x); \
+       pointer = cl_float_to_FF_pointer(x);                            \
        return *this;                                                   \
 }
 
 // from `double':
-union dfloatjanus;
-extern struct cl_heap_dfloat * cl_double_to_DF_pointer (const union dfloatjanus& val);
+extern struct cl_heap_dfloat * cl_double_to_DF_pointer (const double val);
 
 #define CL_DEFINE_DOUBLE_CONSTRUCTOR(_class_)                          \
 inline _class_::_class_ (const double x)                               \
 {                                                                      \
-       pointer = cl_double_to_DF_pointer(*(const union dfloatjanus *)&x); \
+       pointer = cl_double_to_DF_pointer(x);                           \
 }                                                                      \
 inline _class_& _class_::operator= (const double x)                    \
 {                                                                      \
        cl_dec_refcount(*this);                                         \
-       pointer = cl_double_to_DF_pointer(*(const union dfloatjanus *)&x); \
+       pointer = cl_double_to_DF_pointer(x);                           \
        return *this;                                                   \
 }
 
@@ -164,6 +203,8 @@ public:
        cl_number (const unsigned int); // argument must be < 2^29
        cl_number (const long);
        cl_number (const unsigned long);
+       cl_number (const long long);
+       cl_number (const unsigned long long);
        cl_number (const float);
        cl_number (const double);
        cl_number& operator= (const int);       // |argument| must be < 2^29
@@ -172,6 +213,8 @@ public:
        cl_number& operator= (const unsigned long);
        cl_number& operator= (const float);
        cl_number& operator= (const double);
+       cl_number& operator= (const long long);
+       cl_number& operator= (const unsigned long long);
 // Other constructors.
 //     cl_number (const char *);
 // Private pointer manipulations.
@@ -192,6 +235,8 @@ CL_DEFINE_INT_CONSTRUCTORS(cl_number)
 CL_DEFINE_INT_ASSIGNMENT_OPERATORS(cl_number)
 CL_DEFINE_LONG_CONSTRUCTORS(cl_number)
 CL_DEFINE_LONG_ASSIGNMENT_OPERATORS(cl_number)
+CL_DEFINE_LONGLONG_CONSTRUCTORS(cl_number)
+CL_DEFINE_LONGLONG_ASSIGNMENT_OPERATORS(cl_number)
 CL_DEFINE_FLOAT_CONSTRUCTOR(cl_number)
 CL_DEFINE_DOUBLE_CONSTRUCTOR(cl_number)
 
@@ -204,7 +249,8 @@ template<class type>
 inline const type& the(const cl_number& x)
 {
        // check that sizeof(type)==sizeof(cl_number)
-       typedef int assertion1 [1 - 2 * (sizeof(type) != sizeof(cl_number))];
+       static_assert(sizeof(type)==sizeof(cl_number),
+                     "sizeof(type)!=sizeof(cl_number)");
        return *(const type *) &x;
 }
 // Conversions to subtypes without checking, macro version: