Finalize CLN 1.3.7 release.

[cln.git] / src / integer / ring / cl_0_ring.cc

diff --git a/src/integer/ring/cl_0_ring.cc b/src/integer/ring/cl_0_ring.cc
index 722c03876da5e882c2d72749a83647cd460bb2d6..def663d918728037fcc04fabc87cb21d3b2a0d58 100644 (file)
--- a/src/integer/ring/cl_0_ring.cc
+++ b/src/integer/ring/cl_0_ring.cc
@@ -1,9 +1,8 @@
 // Null ring.
 
 // General includes.
-#include "cl_sysdep.h"
+#include "base/cl_sysdep.h"
 
-CL_PROVIDE(cl_0_ring)
 
 // Specification.
 #include "cln/null_ring.h"
@@ -22,37 +21,37 @@ static const _cl_ring_element null_op0 (cl_heap_ring* R)
 
 static const _cl_ring_element null_op1 (cl_heap_ring* R, const _cl_ring_element& x)
 {
-       unused x;
+       cl_unused x;
        return _cl_ring_element(R, (cl_I)0);
 }
 
 static const _cl_ring_element null_op2 (cl_heap_ring* R, const _cl_ring_element& x, const _cl_ring_element& y)
 {
-       unused x;
-       unused y;
+       cl_unused x;
+       cl_unused y;
        return _cl_ring_element(R, (cl_I)0);
 }
 
 static void null_fprint (cl_heap_ring* R, std::ostream& stream, const _cl_ring_element& x)
 {
-       unused R;
-       unused x;
+       cl_unused R;
+       cl_unused x;
        fprint(stream,"0");
 }
 
 static bool null_equal (cl_heap_ring* R, const _cl_ring_element& x, const _cl_ring_element& y)
 {
-       unused R;
-       unused x;
-       unused y;
+       cl_unused R;
+       cl_unused x;
+       cl_unused y;
        return true;
 }
 
 #define null_zero null_op0
 static bool null_zerop (cl_heap_ring* R, const _cl_ring_element& x)
 {
-       unused R;
-       unused x;
+       cl_unused R;
+       cl_unused x;
        return true;
 }
 #define null_plus null_op2
@@ -62,46 +61,60 @@ static bool null_zerop (cl_heap_ring* R, const _cl_ring_element& x)
 #define null_one null_op0
 static const _cl_ring_element null_canonhom (cl_heap_ring* R, const cl_I& x)
 {
-       unused x;
+       cl_unused x;
        return _cl_ring_element(R, (cl_I)0);
 }
 #define null_mul null_op2
 #define null_square null_op1
 static const _cl_ring_element null_expt_pos (cl_heap_ring* R, const _cl_ring_element& x, const cl_I& y)
 {
-       unused x;
-       unused y;
+       cl_unused x;
+       cl_unused y;
        return _cl_ring_element(R, (cl_I)0);
 }
 
-static cl_ring_setops null_setops = {
-       null_fprint,
-       null_equal
-};
-static cl_ring_addops null_addops = {
-       null_zero,
-       null_zerop,
-       null_plus,
-       null_minus,
-       null_uminus
-};
-static cl_ring_mulops null_mulops = {
-       null_one,
-       null_canonhom,
-       null_mul,
-       null_square,
-       null_expt_pos
-};
+static cl_ring_setops& null_setops()
+{
+       static cl_ring_setops ops = {
+               null_fprint,
+               null_equal
+       };
+       return ops;
+}
+
+static cl_ring_addops& null_addops()
+{
+       static cl_ring_addops ops = {
+               null_zero,
+               null_zerop,
+               null_plus,
+               null_minus,
+               null_uminus
+       };
+       return ops;
+}
+
+static cl_ring_mulops& null_mulops()
+{
+       static cl_ring_mulops ops = {
+                null_one,
+                null_canonhom,
+                null_mul,
+                null_square,
+                null_expt_pos
+       };
+       return ops;
+}
 
-extern cl_class cl_class_null_ring;
+static const cl_class& cl_class_null_ring();
 
 class cl_heap_null_ring : public cl_heap_ring {
        SUBCLASS_cl_heap_ring()
 public:
        // Constructor.
        cl_heap_null_ring ()
-               : cl_heap_ring (&null_setops,&null_addops,&null_mulops)
-               { type = &cl_class_null_ring; }
+               : cl_heap_ring (&null_setops(),&null_addops(),&null_mulops())
+               { type = &cl_class_null_ring(); }
        // Destructor.
        ~cl_heap_null_ring () {}
 };
@@ -113,21 +126,42 @@ static void cl_null_ring_destructor (cl_heap* pointer)
 
 static void cl_null_ring_dprint (cl_heap* pointer)
 {
-       unused pointer;
+       cl_unused pointer;
        fprint(cl_debugout, "(cl_null_ring) cl_0_ring");
 }
 
-cl_class cl_class_null_ring = {
-       cl_null_ring_destructor,
-       cl_class_flags_number_ring,
-       cl_null_ring_dprint
-};
+static const cl_class& cl_class_null_ring()
+{
+       static const cl_class cl_class_null_ring_instance = {
+                cl_null_ring_destructor,
+                cl_class_flags_number_ring,
+                cl_null_ring_dprint
+       };
+       return cl_class_null_ring_instance;
+}
+
+cl_heap_null_ring* cl_heap_null_ring_instance;
+const cl_null_ring cl_0_ring = cl_0_ring;
 
 inline cl_null_ring::cl_null_ring ()
-       : cl_ring (new cl_heap_null_ring()) {}
+       : cl_ring(cl_heap_null_ring_instance) {}
+
+int cl_0_ring_init_helper::count = 0;
 
-const cl_null_ring cl_0_ring;
+cl_0_ring_init_helper::cl_0_ring_init_helper()
+{
+       if (count++ == 0) {
+               cl_heap_null_ring_instance = new cl_heap_null_ring();
+               new ((void *)&cl_0_ring) cl_null_ring();
+        }
+}
+
+cl_0_ring_init_helper::~cl_0_ring_init_helper()
+{
+       if (--count == 0) {
+                delete cl_heap_null_ring_instance;
+       }
+}
 
 }  // namespace cln
 
-CL_PROVIDE_END(cl_0_ring)