Replace unused macro with cl_unused.

[cln.git] / src / polynomial / elem / cl_UP_gen.h

diff --git a/src/polynomial/elem/cl_UP_gen.h b/src/polynomial/elem/cl_UP_gen.h
index 9c11643d517f154c5815747c889d5d625f891aec..dc88ed1bc04658069a8c3624186e02ee402da515 100644 (file)
--- a/src/polynomial/elem/cl_UP_gen.h
+++ b/src/polynomial/elem/cl_UP_gen.h
@@ -2,7 +2,7 @@
 
 #include "cln/SV_ringelt.h"
 #include "cln/integer.h"
-#include "cln/abort.h"
+#include "cln/exception.h"
 
 namespace cln {
 
@@ -32,7 +32,7 @@ static void gen_fprint (cl_heap_univpoly_ring* UPR, std::ostream& stream, const
 {{
        DeclarePoly(cl_SV_ringelt,x);
        var cl_heap_ring* R = TheRing(UPR->basering());
-       var sintL xlen = x.length();
+       var sintL xlen = x.size();
        if (xlen == 0)
                fprint(stream, "0");
        else {
@@ -56,19 +56,19 @@ static void gen_fprint (cl_heap_univpoly_ring* UPR, std::ostream& stream, const
        }
 }}
 
-static cl_boolean gen_equal (cl_heap_univpoly_ring* UPR, const _cl_UP& x, const _cl_UP& y)
+static bool gen_equal (cl_heap_univpoly_ring* UPR, const _cl_UP& x, const _cl_UP& y)
 {{
        DeclarePoly(cl_SV_ringelt,x);
        DeclarePoly(cl_SV_ringelt,y);
        var cl_heap_ring* R = TheRing(UPR->basering());
-       var sintL xlen = x.length();
-       var sintL ylen = y.length();
+       var sintL xlen = x.size();
+       var sintL ylen = y.size();
        if (!(xlen == ylen))
-               return cl_false;
+               return false;
        for (var sintL i = xlen-1; i >= 0; i--)
                if (!R->_equal(x[i],y[i]))
-                       return cl_false;
-       return cl_true;
+                       return false;
+       return true;
 }}
 
 static const _cl_UP gen_zero (cl_heap_univpoly_ring* UPR)
@@ -76,15 +76,15 @@ static const _cl_UP gen_zero (cl_heap_univpoly_ring* UPR)
        return _cl_UP(UPR, cl_null_SV_ringelt);
 }
 
-static cl_boolean gen_zerop (cl_heap_univpoly_ring* UPR, const _cl_UP& x)
+static bool gen_zerop (cl_heap_univpoly_ring* UPR, const _cl_UP& x)
 {
-       unused UPR;
+       cl_unused UPR;
  {     DeclarePoly(cl_SV_ringelt,x);
-       var sintL xlen = x.length();
+       var sintL xlen = x.size();
        if (xlen == 0)
-               return cl_true;
+               return true;
        else
-               return cl_false;
+               return false;
 }}
 
 static const _cl_UP gen_plus (cl_heap_univpoly_ring* UPR, const _cl_UP& x, const _cl_UP& y)
@@ -92,8 +92,8 @@ static const _cl_UP gen_plus (cl_heap_univpoly_ring* UPR, const _cl_UP& x, const
        DeclarePoly(cl_SV_ringelt,x);
        DeclarePoly(cl_SV_ringelt,y);
        var cl_heap_ring* R = TheRing(UPR->basering());
-       var sintL xlen = x.length();
-       var sintL ylen = y.length();
+       var sintL xlen = x.size();
+       var sintL ylen = y.size();
        if (xlen == 0)
                return _cl_UP(UPR, y);
        if (ylen == 0)
@@ -135,14 +135,14 @@ static const _cl_UP gen_uminus (cl_heap_univpoly_ring* UPR, const _cl_UP& x)
 {{
        DeclarePoly(cl_SV_ringelt,x);
        var cl_heap_ring* R = TheRing(UPR->basering());
-       var sintL xlen = x.length();
+       var sintL xlen = x.size();
        if (xlen == 0)
                return _cl_UP(UPR, x);
        // Now xlen > 0.
        // Negate. No normalization necessary, since the degree doesn't change.
        var sintL i = xlen-1;
        var _cl_ring_element hicoeff = R->_uminus(x[i]);
-       if (R->_zerop(hicoeff)) cl_abort();
+       if (R->_zerop(hicoeff)) throw runtime_exception();
        var cl_SV_ringelt result = cl_SV_ringelt(cl_make_heap_SV_ringelt_uninit(xlen));
        init1(_cl_ring_element, result[i]) (hicoeff);
        for (i-- ; i >= 0; i--)
@@ -155,8 +155,8 @@ static const _cl_UP gen_minus (cl_heap_univpoly_ring* UPR, const _cl_UP& x, cons
        DeclarePoly(cl_SV_ringelt,x);
        DeclarePoly(cl_SV_ringelt,y);
        var cl_heap_ring* R = TheRing(UPR->basering());
-       var sintL xlen = x.length();
-       var sintL ylen = y.length();
+       var sintL xlen = x.size();
+       var sintL ylen = y.size();
        if (ylen == 0)
                return _cl_UP(UPR, x);
        if (xlen == 0)
@@ -215,8 +215,8 @@ static const _cl_UP gen_mul (cl_heap_univpoly_ring* UPR, const _cl_UP& x, const
        DeclarePoly(cl_SV_ringelt,x);
        DeclarePoly(cl_SV_ringelt,y);
        var cl_heap_ring* R = TheRing(UPR->basering());
-       var sintL xlen = x.length();
-       var sintL ylen = y.length();
+       var sintL xlen = x.size();
+       var sintL ylen = y.size();
        if (xlen == 0)
                return _cl_UP(UPR, x);
        if (ylen == 0)
@@ -253,7 +253,7 @@ static const _cl_UP gen_mul (cl_heap_univpoly_ring* UPR, const _cl_UP& x, const
        }
        // Normalize (not necessary in integral domains).
        //gen_normalize(R,result,len);
-       if (R->_zerop(result[len-1])) cl_abort();
+       if (R->_zerop(result[len-1])) throw runtime_exception();
        return _cl_UP(UPR, result);
 }}
 
@@ -261,7 +261,7 @@ static const _cl_UP gen_square (cl_heap_univpoly_ring* UPR, const _cl_UP& x)
 {{
        DeclarePoly(cl_SV_ringelt,x);
        var cl_heap_ring* R = TheRing(UPR->basering());
-       var sintL xlen = x.length();
+       var sintL xlen = x.size();
        if (xlen == 0)
                return cl_UP(UPR, x);
        var sintL len = 2*xlen-1;
@@ -292,7 +292,7 @@ static const _cl_UP gen_square (cl_heap_univpoly_ring* UPR, const _cl_UP& x)
        init1(_cl_ring_element, result[0]) (R->_square(x[0]));
        // Normalize (not necessary in integral domains).
        //gen_normalize(R,result,len);
-       if (R->_zerop(result[len-1])) cl_abort();
+       if (R->_zerop(result[len-1])) throw runtime_exception();
        return _cl_UP(UPR, result);
 }}
 
@@ -312,11 +312,11 @@ static const _cl_UP gen_exptpos (cl_heap_univpoly_ring* UPR, const _cl_UP& x, co
 
 static const _cl_UP gen_scalmul (cl_heap_univpoly_ring* UPR, const cl_ring_element& x, const _cl_UP& y)
 {
-       if (!(UPR->basering() == x.ring())) cl_abort();
+       if (!(UPR->basering() == x.ring())) throw runtime_exception();
  {
        DeclarePoly(cl_SV_ringelt,y);
        var cl_heap_ring* R = TheRing(UPR->basering());
-       var sintL ylen = y.length();
+       var sintL ylen = y.size();
        if (ylen == 0)
                return _cl_UP(UPR, y);
        if (R->zerop(x))
@@ -326,21 +326,21 @@ static const _cl_UP gen_scalmul (cl_heap_univpoly_ring* UPR, const cl_ring_eleme
                init1(_cl_ring_element, result[i]) (R->_mul(x,y[i]));
        // Normalize (not necessary in integral domains).
        //gen_normalize(R,result,ylen);
-       if (R->_zerop(result[ylen-1])) cl_abort();
+       if (R->_zerop(result[ylen-1])) throw runtime_exception();
        return _cl_UP(UPR, result);
 }}
 
 static sintL gen_degree (cl_heap_univpoly_ring* UPR, const _cl_UP& x)
 {
-       unused UPR;
+       cl_unused UPR;
  {     DeclarePoly(cl_SV_ringelt,x);
-       return (sintL) x.length() - 1;
+       return (sintL) x.size() - 1;
 }}
 
 static sintL gen_ldegree (cl_heap_univpoly_ring* UPR, const _cl_UP& x)
 {{     DeclarePoly(cl_SV_ringelt,x);
        var cl_heap_ring* R = TheRing(UPR->basering());
-       var sintL xlen = x.length();
+       var sintL xlen = x.size();
        for (sintL i = 0; i < xlen; i++) {
                if (!R->_zerop(x[i]))
                        return i;
@@ -350,7 +350,7 @@ static sintL gen_ldegree (cl_heap_univpoly_ring* UPR, const _cl_UP& x)
 
 static const _cl_UP gen_monomial (cl_heap_univpoly_ring* UPR, const cl_ring_element& x, uintL e)
 {
-       if (!(UPR->basering() == x.ring())) cl_abort();
+       if (!(UPR->basering() == x.ring())) throw runtime_exception();
        var cl_heap_ring* R = TheRing(UPR->basering());
        if (R->_zerop(x))
                return _cl_UP(UPR, cl_null_SV_ringelt);
@@ -366,7 +366,7 @@ static const cl_ring_element gen_coeff (cl_heap_univpoly_ring* UPR, const _cl_UP
 {{
        DeclarePoly(cl_SV_ringelt,x);
        var cl_heap_ring* R = TheRing(UPR->basering());
-       if (index < x.length())
+       if (index < x.size())
                return cl_ring_element(R, x[index]);
        else
                return R->zero();
@@ -385,8 +385,8 @@ static const _cl_UP gen_create (cl_heap_univpoly_ring* UPR, sintL deg)
 static void gen_set_coeff (cl_heap_univpoly_ring* UPR, _cl_UP& x, uintL index, const cl_ring_element& y)
 {{
        DeclareMutablePoly(cl_SV_ringelt,x);
-       if (!(UPR->basering() == y.ring())) cl_abort();
-       if (!(index < x.length())) cl_abort();
+       if (!(UPR->basering() == y.ring())) throw runtime_exception();
+       if (!(index < x.size())) throw runtime_exception();
        x[index] = y;
 }}
 
@@ -394,7 +394,7 @@ static void gen_finalize (cl_heap_univpoly_ring* UPR, _cl_UP& x)
 {{
        DeclareMutablePoly(cl_SV_ringelt,x); // NB: x is modified by reference!
        var cl_heap_ring* R = TheRing(UPR->basering());
-       var uintL len = x.length();
+       var uintL len = x.size();
        if (len > 0)
                gen_normalize(R,x,len);
 }}
@@ -407,8 +407,8 @@ static const cl_ring_element gen_eval (cl_heap_univpoly_ring* UPR, const _cl_UP&
        // Else compute (...(x[len-1]*y+x[len-2])*y ...)*y + x[0].
        DeclarePoly(cl_SV_ringelt,x);
        var cl_heap_ring* R = TheRing(UPR->basering());
-       if (!(y.ring() == R)) cl_abort();
-       var uintL len = x.length();
+       if (!(y.ring() == R)) throw runtime_exception();
+       var uintL len = x.size();
        if (len==0)
                return R->zero();
        if (R->_zerop(y))