X-Git-Url: https://ginac.de/CLN/cln.git//cln.git?a=blobdiff_plain;f=src%2Fbase%2Fring%2Fcl_no_ring.cc;h=d15be0fd3187b061114381afff5df9a45aa26704;hb=8169a19b38c42588b39b21dae5bdb964e2f6b8c6;hp=1331da0e224d6ac01c0e1b10aa947492ec334b9d;hpb=850abfde7f0d985ba01526c346bcd0d733562943;p=cln.git

diff --git a/src/base/ring/cl_no_ring.cc b/src/base/ring/cl_no_ring.cc
index 1331da0..d15be0f 100644
--- a/src/base/ring/cl_no_ring.cc
+++ b/src/base/ring/cl_no_ring.cc
@@ -1,9 +1,7 @@
 // Dummy ring.
 
 // General includes.
-#include "cl_sysdep.h"
-
-CL_PROVIDE(cl_no_ring)
+#include "base/cl_sysdep.h"
 
 // Specification.
 #include "cln/ring.h"
@@ -11,71 +9,85 @@ CL_PROVIDE(cl_no_ring)
 
 // Implementation.
 
+#include <sstream>
 #include "cln/io.h"
-#include "cln/abort.h"
 
 namespace cln {
 
-nonreturning_function(static, uninitialized_ring, (void));
-static void uninitialized_ring ()
+uninitialized_ring_exception::uninitialized_ring_exception ()
+	: runtime_exception("Uninitialized ring operation called.")
+{}
+
+static inline const std::string
+uninitialized_error_msg (const _cl_ring_element& obj)
 {
-	fprint(stderr, "Uninitialized ring operation called\n");
-	cl_abort();
+	std::ostringstream buf;
+	fprint(buf, "Uninitialized ring element @0x");
+	fprinthexadecimal(buf, (unsigned long)(void*)&obj);
+	fprint(buf, ": 0x");
+        fprinthexadecimal(buf, (unsigned long)obj.rep.word);
+	return buf.str();
 }
 
-nonreturning_function(static, uninitialized_error, (const _cl_ring_element&));
-static void uninitialized_error (const _cl_ring_element& obj)
+static inline const std::string
+uninitialized_error_msg (const _cl_ring_element& obj_x, const _cl_ring_element& obj_y)
 {
-	fprint(stderr, "Uninitialized ring element @0x");
-	fprinthexadecimal(stderr, (unsigned long)(void*)&obj);
-	fprint(stderr, ": 0x");
-        fprinthexadecimal(stderr, (unsigned long)obj.rep.word);
-	fprint(stderr, "\n");
-	cl_abort();
+	std::ostringstream buf;
+	fprint(buf, "Uninitialized ring elements @0x");
+	fprinthexadecimal(buf, (unsigned long)(void*)&obj_x);
+	fprint(buf, ": 0x");
+        fprinthexadecimal(buf, (unsigned long)obj_x.rep.word);
+	fprint(buf, ", @0x");
+	fprinthexadecimal(buf, (unsigned long)(void*)&obj_y);
+	fprint(buf, ": 0x");
+        fprinthexadecimal(buf, (unsigned long)obj_y.rep.word);
+	return buf.str();
 }
 
-#if (defined(__sparc__) && !defined(__GNUC__))
-  // avoid Sun C++ 4.1 compiler bug
-  #define RETDUMMY  return *(_cl_ring_element*)R
-#else
-  #define RETDUMMY  return *(_cl_ring_element*)0
-#endif
+uninitialized_exception::uninitialized_exception (const _cl_ring_element& obj)
+	: runtime_exception(uninitialized_error_msg(obj))
+{}
+
+uninitialized_exception::uninitialized_exception (const _cl_ring_element& obj_x, const _cl_ring_element& obj_y)
+	: runtime_exception(uninitialized_error_msg(obj_x, obj_y))
+{}
+
 
 static const _cl_ring_element dummy_op0 (cl_heap_ring* R)
 {
 	unused R;
-	uninitialized_ring(); RETDUMMY;
+	throw uninitialized_ring_exception();
 }
 
 static const _cl_ring_element dummy_op1 (cl_heap_ring* R, const _cl_ring_element& x)
 {
 	unused R;
-	uninitialized_error(x); RETDUMMY;
+	throw uninitialized_exception(x);
 }
 
 static const _cl_ring_element dummy_op2 (cl_heap_ring* R, const _cl_ring_element& x, const _cl_ring_element& y)
 {
 	unused R;
-	uninitialized_error(x); uninitialized_error(y); RETDUMMY;
+	throw uninitialized_exception(x, y);
 }
 
-static void dummy_fprint (cl_heap_ring* R, cl_ostream stream, const _cl_ring_element& x)
+static void dummy_fprint (cl_heap_ring* R, std::ostream& stream, const _cl_ring_element& x)
 {
 	unused R;
 	unused stream;
-	uninitialized_error(x);
+	throw uninitialized_exception(x);
 }
-static cl_boolean dummy_equal (cl_heap_ring* R, const _cl_ring_element& x, const _cl_ring_element& y)
+static bool dummy_equal (cl_heap_ring* R, const _cl_ring_element& x, const _cl_ring_element& y)
 {
 	unused R;
-	uninitialized_error(x); uninitialized_error(y); return cl_false;
+	throw uninitialized_exception(x, y);
 }
 
 #define dummy_zero dummy_op0
-static cl_boolean dummy_zerop (cl_heap_ring* R, const _cl_ring_element& x)
+static bool dummy_zerop (cl_heap_ring* R, const _cl_ring_element& x)
 {
 	unused R;
-	uninitialized_error(x); return cl_false;
+	throw uninitialized_exception(x);
 }
 #define dummy_plus dummy_op2
 #define dummy_minus dummy_op2
@@ -86,7 +98,7 @@ static const _cl_ring_element dummy_canonhom (cl_heap_ring* R, const cl_I& x)
 {
 	unused R;
 	(void)&x; // unused x;
-	uninitialized_ring(); RETDUMMY;
+	throw uninitialized_ring_exception();
 }
 #define dummy_mul dummy_op2
 #define dummy_square dummy_op1
@@ -94,7 +106,7 @@ static const _cl_ring_element dummy_expt_pos (cl_heap_ring* R, const _cl_ring_el
 {
 	unused R;
 	(void)&y; // unused y;
-	uninitialized_error(x); RETDUMMY;
+	throw uninitialized_exception(x);
 }
 
 static cl_ring_setops dummy_setops = {
@@ -138,14 +150,32 @@ static void cl_no_ring_dprint (cl_heap* pointer)
 	fprint(cl_debugout, "(cl_ring) cl_no_ring");
 }
 
-cl_class cl_class_no_ring = {
-	cl_no_ring_destructor,
-	0,
-	cl_no_ring_dprint
-};
+cl_class cl_class_no_ring;
+
+static cl_heap_no_ring* cl_heap_no_ring_instance;
+// const cl_ring cl_no_ring = cl_ring (new cl_heap_no_ring());
+const cl_ring cl_no_ring = cl_no_ring;
+
 
-const cl_ring cl_no_ring = cl_ring (new cl_heap_no_ring());
+int cl_no_ring_init_helper::count = 0;
+
+cl_no_ring_init_helper::cl_no_ring_init_helper()
+{
+	if (count++ == 0) {
+		cl_class_no_ring.destruct = cl_no_ring_destructor;
+		cl_class_no_ring.flags = 0;
+		cl_class_no_ring.dprint = cl_no_ring_dprint;
+
+		cl_heap_no_ring_instance = new cl_heap_no_ring();
+		new((void*)&cl_no_ring) cl_ring(cl_heap_no_ring_instance);
+	}
+}
+
+cl_no_ring_init_helper::~cl_no_ring_init_helper()
+{
+	if (--count == 0)
+		delete cl_heap_no_ring_instance;
+}
 
 }  // namespace cln
 
-CL_PROVIDE_END(cl_no_ring)