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