src/polynomial/elem/cl_UP_no_ring.cc

   1 // Dummy ring.
   2
   3 // General includes.
   4 #include "cl_sysdep.h"
   5
   6 CL_PROVIDE(cl_UP_no_ring)
   7
   8 // Specification.
   9 #include "cln/univpoly.h"
  10
  11
  12 // Implementation.
  13
  14 #include "cln/io.h"
  15 #include "cln/abort.h"
  16
  17 namespace cln {
  18
  19 nonreturning_function(static, uninitialized_ring, (void));
  20 static void uninitialized_ring ()
  21 {
  22         fprint(std::cerr, "Uninitialized ring operation called\n");
  23         cl_abort();
  24 }
  25
  26 nonreturning_function(static, uninitialized_error, (const _cl_UP&));
  27 static void uninitialized_error (const _cl_UP& obj)
  28 {
  29         fprint(std::cerr, "Uninitialized ring element @0x");
  30         fprinthexadecimal(std::cerr, (unsigned long)(void*)&obj);
  31         fprint(std::cerr, ": 0x");
  32         fprinthexadecimal(std::cerr, (unsigned long)obj.rep.word);
  33         fprint(std::cerr, "\n");
  34         cl_abort();
  35 }
  36
  37 #if ((defined(__sparc__) || defined(__sparc64__)) && !defined(__GNUC__))
  38   // avoid Sun C++ 4.1 compiler bug
  39   #define RETDUMMY  return *(_cl_UP*)R
  40 #else
  41   #define RETDUMMY  return *(_cl_UP*)0
  42 #endif
  43
  44 static const _cl_UP dummy_op0 (cl_heap_univpoly_ring* R)
  45 {
  46         unused R;
  47         uninitialized_ring(); RETDUMMY;
  48 }
  49
  50 static const _cl_UP dummy_op1 (cl_heap_univpoly_ring* R, const _cl_UP& x)
  51 {
  52         unused R;
  53         uninitialized_error(x); RETDUMMY;
  54 }
  55
  56 static const _cl_UP dummy_op2 (cl_heap_univpoly_ring* R, const _cl_UP& x, const _cl_UP& y)
  57 {
  58         unused R;
  59         uninitialized_error(x); uninitialized_error(y); RETDUMMY;
  60 }
  61
  62 static void dummy_fprint (cl_heap_univpoly_ring* R, std::ostream& stream, const _cl_UP& x)
  63 {
  64         unused R;
  65         unused stream;
  66         uninitialized_error(x);
  67 }
  68 static cl_boolean dummy_equal (cl_heap_univpoly_ring* R, const _cl_UP& x, const _cl_UP& y)
  69 {
  70         unused R;
  71         uninitialized_error(x); uninitialized_error(y); return cl_false;
  72 }
  73
  74 #define dummy_zero dummy_op0
  75 static cl_boolean dummy_zerop (cl_heap_univpoly_ring* R, const _cl_UP& x)
  76 {
  77         unused R;
  78         uninitialized_error(x); return cl_false;
  79 }
  80 #define dummy_plus dummy_op2
  81 #define dummy_minus dummy_op2
  82 #define dummy_uminus dummy_op1
  83
  84 #define dummy_one dummy_op0
  85 static const _cl_UP dummy_canonhom (cl_heap_univpoly_ring* R, const cl_I& x)
  86 {
  87         unused R;
  88         (void)&x; // unused x;
  89         uninitialized_ring(); RETDUMMY;
  90 }
  91 #define dummy_mul dummy_op2
  92 #define dummy_square dummy_op1
  93 static const _cl_UP dummy_expt_pos (cl_heap_univpoly_ring* R, const _cl_UP& x, const cl_I& y)
  94 {
  95         unused R;
  96         (void)&y; // unused y;
  97         uninitialized_error(x); RETDUMMY;
  98 }
  99
 100 static const _cl_UP dummy_scalmul (cl_heap_univpoly_ring* R, const cl_ring_element& x, const _cl_UP& y)
 101 {
 102         unused R;
 103         unused x;
 104         uninitialized_error(y); RETDUMMY;
 105 }
 106
 107 static sintL dummy_degree (cl_heap_univpoly_ring* R, const _cl_UP& x)
 108 {
 109         unused R;
 110         uninitialized_error(x); return 0;
 111 }
 112 static sintL dummy_ldegree (cl_heap_univpoly_ring* R, const _cl_UP& x)
 113 {
 114         unused R;
 115         uninitialized_error(x); return 0;
 116 }
 117 static const _cl_UP dummy_monomial (cl_heap_univpoly_ring* R, const cl_ring_element& x, uintL e)
 118 {
 119         unused R;
 120         unused x;
 121         unused e;
 122         uninitialized_ring(); RETDUMMY;
 123 }
 124 static const cl_ring_element dummy_coeff (cl_heap_univpoly_ring* R, const _cl_UP& x, uintL index)
 125 {
 126         unused R;
 127         unused index;
 128         uninitialized_error(x); return *(cl_ring_element*)0;
 129 }
 130 static const _cl_UP dummy_create (cl_heap_univpoly_ring* R, sintL deg)
 131 {
 132         unused R;
 133         unused deg;
 134         uninitialized_ring(); RETDUMMY;
 135 }
 136 static void dummy_set_coeff (cl_heap_univpoly_ring* R, _cl_UP& x, uintL index, const cl_ring_element& y)
 137 {
 138         unused R;
 139         unused index;
 140         unused y;
 141         uninitialized_error(x);
 142 }
 143 static void dummy_finalize (cl_heap_univpoly_ring* R, _cl_UP& x)
 144 {
 145         unused R;
 146         uninitialized_error(x);
 147 }
 148 static const cl_ring_element dummy_eval (cl_heap_univpoly_ring* R, const _cl_UP& x, const cl_ring_element& y)
 149 {
 150         unused R;
 151         unused y;
 152         uninitialized_error(x); return *(cl_ring_element*)0;
 153 }
 154
 155 static cl_univpoly_setops dummy_setops = {
 156         dummy_fprint,
 157         dummy_equal
 158 };
 159 static cl_univpoly_addops dummy_addops = {
 160         dummy_zero,
 161         dummy_zerop,
 162         dummy_plus,
 163         dummy_minus,
 164         dummy_uminus
 165 };
 166 static cl_univpoly_mulops dummy_mulops = {
 167         dummy_one,
 168         dummy_canonhom,
 169         dummy_mul,
 170         dummy_square,
 171         dummy_expt_pos
 172 };
 173 static cl_univpoly_modulops dummy_modulops = {
 174         dummy_scalmul
 175 };
 176 static cl_univpoly_polyops dummy_polyops = {
 177         dummy_degree,
 178         dummy_ldegree,
 179         dummy_monomial,
 180         dummy_coeff,
 181         dummy_create,
 182         dummy_set_coeff,
 183         dummy_finalize,
 184         dummy_eval
 185 };
 186
 187 class cl_heap_no_univpoly_ring : public cl_heap_univpoly_ring {
 188         SUBCLASS_cl_heap_univpoly_ring()
 189 public:
 190         // Constructor.
 191         cl_heap_no_univpoly_ring ()
 192                 : cl_heap_univpoly_ring (cl_no_ring,&dummy_setops,&dummy_addops,&dummy_mulops,&dummy_modulops,&dummy_polyops)
 193                 { type = &cl_class_no_univpoly_ring; }
 194         // Destructor.
 195         ~cl_heap_no_univpoly_ring () {}
 196 };
 197
 198 static void cl_no_univpoly_ring_destructor (cl_heap* pointer)
 199 {
 200         (*(cl_heap_no_univpoly_ring*)pointer).~cl_heap_no_univpoly_ring();
 201 }
 202
 203 cl_class cl_class_no_univpoly_ring = {
 204         cl_no_univpoly_ring_destructor,
 205         0
 206 };
 207
 208 const cl_univpoly_ring cl_no_univpoly_ring = cl_univpoly_ring (new cl_heap_no_univpoly_ring());
 209
 210 }  // namespace cln
 211
 212 CL_PROVIDE_END(cl_UP_no_ring)