X-Git-Url: https://ginac.de/CLN/cln.git//cln.git?a=blobdiff_plain;f=include%2Fcln%2Fnumber.h;h=67f68899a6926eca49722f012d0a20d159162c57;hb=HEAD;hp=aff318b5517ca8158223587f9a70a774eb979754;hpb=8eec07ec86ee8b5b3461a1c78211b995dfc4d1a0;p=cln.git

diff --git a/include/cln/number.h b/include/cln/number.h
index aff318b..67f6889 100644
--- 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: