Changeset 1cce47 in git

Timestamp:

Sep 29, 2010, 3:14:38 PM (14 years ago)

Author:

Mohamed Barakat <mohamed.barakat@…>

Branches:

(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', '38077648e7239f98078663eb941c3c979511150a')

Children:

a9f5845397ce9720c65552912884a25952f7e724

Parents:

7f7b2ae08d4ef302906c949966fc7a88fe8d895f

git-author:

Mohamed Barakat <mohamed.barakat@rwth-aachen.de>2010-09-29 15:14:38+02:00

git-committer:

Mohamed Barakat <mohamed.barakat@rwth-aachen.de>2011-11-09 11:55:29+01:00

Message:

non-atomic: nField -> nCoeff
error handling for initializing coeff

Location:

coeffs

Files:

• coeffs.h (modified) (1 diff)
• ffields.cc (modified) (3 diffs)
• ffields.h (modified) (1 diff)
• gnumpc.cc (modified) (2 diffs)
• gnumpc.h (modified) (1 diff)
• gnumpfl.cc (modified) (2 diffs)
• gnumpfl.h (modified) (1 diff)
• longrat.cc (modified) (2 diffs)
• longrat.h (modified) (1 diff)
• modulop.cc (modified) (3 diffs)
• modulop.h (modified) (1 diff)
• mpr_complex.cc (modified) (3 diffs)
• mpr_complex.h (modified) (1 diff)
• numbers.cc (modified) (2 diffs)
• numbers.h (modified) (1 diff)
• rintegers.cc (modified) (2 diffs)
• rintegers.h (modified) (1 diff)
• rmodulo2m.cc (modified) (3 diffs)
• rmodulo2m.h (modified) (1 diff)
• rmodulon.cc (modified) (4 diffs)
• rmodulon.h (modified) (1 diff)
• shortfl.cc (modified) (2 diffs)
• shortfl.h (modified) (1 diff)

coeffs/coeffs.h

@@ -227 +227 @@
 
 /// one-time initialisations for new coeffs
+/// in case of an error return NULL
 coeffs nInitChar(n_coeffType t, void * parameter);
 /// undo all initialisations

coeffs/ffields.cc

@@ -736 +736 @@
 nMapFunc nfSetMap(const coeffs src, const coeffs dst)
 {
-  if (nField_is_GF(src,src->m_nfCharQ))
+  if (nCoeff_is_GF(src,src->m_nfCharQ))
   {
     return ndCopyMap;   /* GF(p,n) -> GF(p,n) */
   }
-  if (nField_is_GF(src))
+  if (nCoeff_is_GF(src))
   {
     const coeffs r = dst;
@@ -774 +774 @@
     }
   }
-  if (nField_is_Zp(src,src->m_nfCharP))
+  if (nCoeff_is_Zp(src,src->m_nfCharP))
   {
     return nfMapP;    /* Z/p -> GF(p,n) */
@@ -781 +781 @@
 }
 
-void nfInitChar(coeffs r,  void * parameter)
+BOOLEAN nfInitChar(coeffs r,  void * parameter)
 {
 

coeffs/ffields.h

@@ -19 +19 @@
 
 
-void nfInitChar(coeffs r, void*);
+BOOLEAN nfInitChar(coeffs r, void*);
 
 //static BOOLEAN nfCoeffsEqual(const coeffs r, n_coeffType n, void* parameter);

coeffs/gnumpc.cc

@@ -382 +382 @@
 }
 
-void ngcInitChar(coeffs n, void*)
+BOOLEAN ngcInitChar(coeffs n, void*)
 {
   assume( getCoeffType(n) == ID );
@@ -563 +563 @@
   assume( getCoeffType(dst) == ID );
 
-  if (nField_is_Q(src))
+  if (nCoeff_is_Q(src))
   {
     return ngcMapQ;
   }
-  if (nField_is_long_R(src))
+  if (nCoeff_is_long_R(src))
   {
     return ngcMapLongR;
   }
-  if (nField_is_long_C(src))
+  if (nCoeff_is_long_C(src))
   {
     return ngcCopyMap;
   }
-  if (nField_is_R(src))
+  if (nCoeff_is_R(src))
   {
     return ngcMapR;
   }
-  if (nField_is_Zp(src))
+  if (nCoeff_is_Zp(src))
   {
     return ngcMapP;

coeffs/gnumpc.h

@@ -14 +14 @@
 
 /// Initialize r
-void ngcInitChar(coeffs r, void*);
+BOOLEAN ngcInitChar(coeffs r, void*);
 
 

coeffs/gnumpfl.cc

@@ -389 +389 @@
 }
 
-void ngfInitChar(coeffs n, void *)
+BOOLEAN ngfInitChar(coeffs n, void *)
 {
   assume( getCoeffType(n) == ID );
@@ -461 +461 @@
   assume( getCoeffType(dst) == ID );
   
-  if (nField_is_Q(src))
+  if (nCoeff_is_Q(src))
   {
     return ngfMapQ;
   }
-  if (nField_is_long_R(src))
+  if (nCoeff_is_long_R(src))
   {
     return ngfCopyMap;
   }
-  if (nField_is_R(src))
+  if (nCoeff_is_R(src))
   {
     return ngfMapR;
   }
-  if (nField_is_long_C(src))
+  if (nCoeff_is_long_C(src))
   {
     return ngfMapC;
   }
-  if (nField_is_Zp(src))
+  if (nCoeff_is_Zp(src))
   {
     return ngfMapP;

coeffs/gnumpfl.h

@@ -14 +14 @@
 
 /// Initialize r
-void ngfInitChar(coeffs r, void *);
+BOOLEAN ngfInitChar(coeffs r, void *);
 
 const char *   ngfRead (const char *s, number *a, const coeffs r);

coeffs/longrat.cc

@@ -1920 +1920 @@
 //  assume( getCoeffType(src) == ID );
   
-  if (nField_is_Q(src))
+  if (nCoeff_is_Q(src))
   {
     return nlCopyMap;
   }
-  if (nField_is_Zp(src))
+  if (nCoeff_is_Zp(src))
   {
     return nlMapP;
   }
-  if (nField_is_R(src))
+  if (nCoeff_is_R(src))
   {
     return nlMapR;
   }
-  if (nField_is_long_R(src))
+  if (nCoeff_is_long_R(src))
   {
     return nlMapLongR; /* long R -> Q */
   }
 #ifdef HAVE_RINGS
-  if (nField_is_Ring_Z(src) || nField_is_Ring_PtoM(src) || nField_is_Ring_ModN(src))
+  if (nCoeff_is_Ring_Z(src) || nCoeff_is_Ring_PtoM(src) || nCoeff_is_Ring_ModN(src))
   {
     return nlMapGMP;
   }
-  if (nField_is_Ring_2toM(src))
+  if (nCoeff_is_Ring_2toM(src))
   {
     return nlMapMachineInt;
@@ -2462 +2462 @@
 }
 
-void nlInitChar(coeffs r, void* p)
+BOOLEAN nlInitChar(coeffs r, void* p)
 {
   const int ch = (int)(long)(p);

coeffs/longrat.h

@@ -58 +58 @@
 LINLINE number   nlMult(number a, number b, const coeffs r);
 
-void     nlInitChar(coeffs r, void*);
+BOOLEAN nlInitChar(coeffs r, void*);
 
 number   nlInit2 (int i, int j, const coeffs r);

coeffs/modulop.cc

@@ -322 +322 @@
 }
 
-void npInitChar(coeffs r, void* p)
+BOOLEAN npInitChar(coeffs r, void* p)
 {
   const int c = (int) (long) p;
@@ -587 +587 @@
 {
 #ifdef HAVE_RINGS
-  if (nField_is_Ring_2toM(src))
+  if (nCoeff_is_Ring_2toM(src))
   {
     return npMapMachineInt;
   }
-  if (nField_is_Ring_Z(src) || nField_is_Ring_PtoM(src) || nField_is_Ring_ModN(src))
+  if (nCoeff_is_Ring_Z(src) || nCoeff_is_Ring_PtoM(src) || nCoeff_is_Ring_ModN(src))
   {
     return npMapGMP;
   }
 #endif
-  if (nField_is_Q(src))
+  if (nCoeff_is_Q(src))
   {
     return npMap0;
   }
-  if ( nField_is_Zp(src) )
+  if ( nCoeff_is_Zp(src) )
   {
     if (n_GetChar(src) == n_GetChar(dst))
@@ -611 +611 @@
     }
   }
-  if (nField_is_long_R(src))
+  if (nCoeff_is_long_R(src))
   {
     return npMapLongR;
   }
 #ifdef HAVE_FACTORY
-  if (nField_is_CF (src))
+  if (nCoeff_is_CF (src))
   {
     return npMapCanonicalForm;

coeffs/modulop.h

@@ -24 +24 @@
 extern int npGen;
 
-void npInitChar(coeffs r, void* p);
+BOOLEAN npInitChar(coeffs r, void* p);
 
 BOOLEAN npGreaterZero (number k, const coeffs r);

coeffs/mpr_complex.cc

@@ -375 +375 @@
   gmp_float r;
 
-  if ( nField_is_Q(src) )
+  if ( nCoeff_is_Q(src) )
   {
     if ( num != NULL )
@@ -412 +412 @@
     }
   }
-  else if (nField_is_long_R(src) || nField_is_long_C(src))
+  else if (nCoeff_is_long_R(src) || nCoeff_is_long_C(src))
   {
     r= *(gmp_float*)num;
   }
-  else if ( nField_is_R(src) )
+  else if ( nCoeff_is_R(src) )
   {
     // Add some code here :-)
@@ -717 +717 @@
     in_imag=floatToStr( abs(c.imag()), oprec );    // get imaginary part
 
-    if (nField_is_long_C(src))
+    if (nCoeff_is_long_C(src))
     {
       int len=(strlen(in_real)+strlen(in_imag)+7+strlen(src->parameter[0]))*sizeof(char);

coeffs/mpr_complex.h

@@ -314 +314 @@
 inline gmp_complex numberToComplex( number num, const coeffs r )
 {
-  if (nField_is_long_C(r))
+  if (nCoeff_is_long_C(r))
   {
     return *(gmp_complex*)num;

coeffs/numbers.cc

@@ -92 +92 @@
 {
   assume( getCoeffType(r) == getCoeffType(aRing) );
-  assume( nField_has_simple_Alloc(r) && nField_has_simple_Alloc(aRing) );
+  assume( nCoeff_has_simple_Alloc(r) && nCoeff_has_simple_Alloc(aRing) );
   
   return a;
@@ -190 +190 @@
   #endif
     cf_root=n;
+    
+    BOOLEAN nOK=TRUE;
     // init
     if ((nInitCharTable!=NULL) && (t<=nLastCoeffs))
-       (nInitCharTable[t])(n,parameter);
-     else
+      nOK = (nInitCharTable[t])(n,parameter);
+    else
        Werror("coeff init missing for %d",(int)t);
-    
+    if (nOK)
+      {
+        omFreeSize(n,sizeof(*n));
+        return NULL;
+      }
+    cf_root=n;
     // post init settings:
     if (n->cfRePart==NULL) n->cfRePart=n->cfCopy;

coeffs/numbers.h

@@ -41 +41 @@
 
 // Tests:
-static inline BOOLEAN nField_is_Ring_2toM(const coeffs r)
+static inline BOOLEAN nCoeff_is_Ring_2toM(const coeffs r)
 { return (r->ringtype == 1); }
 
-static inline BOOLEAN nField_is_Ring_ModN(const coeffs r)
+static inline BOOLEAN nCoeff_is_Ring_ModN(const coeffs r)
 { return (r->ringtype == 2); }
 
-static inline BOOLEAN nField_is_Ring_PtoM(const coeffs r)
+static inline BOOLEAN nCoeff_is_Ring_PtoM(const coeffs r)
 { return (r->ringtype == 3); }
 
-static inline BOOLEAN nField_is_Ring_Z(const coeffs r)
+static inline BOOLEAN nCoeff_is_Ring_Z(const coeffs r)
 { return (r->ringtype == 4); }
 
-static inline BOOLEAN nField_is_Ring(const coeffs r)
+static inline BOOLEAN nCoeff_is_Ring(const coeffs r)
 { return (r->ringtype != 0); }
 
-static inline BOOLEAN nField_is_Domain(const coeffs r)
+static inline BOOLEAN nCoeff_is_Domain(const coeffs r)
 { return (r->ringtype == 4 || r->ringtype == 0); }
 
-static inline BOOLEAN nField_has_Units(const coeffs r)
+static inline BOOLEAN nCoeff_has_Units(const coeffs r)
 { return ((r->ringtype == 1) || (r->ringtype == 2) || (r->ringtype == 3)); }
 
-static inline BOOLEAN nField_is_Zp(const coeffs r)
+static inline BOOLEAN nCoeff_is_Zp(const coeffs r)
 { return getCoeffType(r)==n_Zp; }
 
-static inline BOOLEAN nField_is_Zp(const coeffs r, int p)
+static inline BOOLEAN nCoeff_is_Zp(const coeffs r, int p)
 { return (getCoeffType(r)  && (r->ch == ABS(p))); }
 
-static inline BOOLEAN nField_is_Q(const coeffs r)
+static inline BOOLEAN nCoeff_is_Q(const coeffs r)
 { return getCoeffType(r)==n_Q; }
 
-static inline BOOLEAN nField_is_numeric(const coeffs r) /* R, long R, long C */
+static inline BOOLEAN nCoeff_is_numeric(const coeffs r) /* R, long R, long C */
 {  return (getCoeffType(r)==n_R) || (getCoeffType(r)==n_long_R) || (getCoeffType(r)==n_long_C); }
 
-static inline BOOLEAN nField_is_R(const coeffs r)
+static inline BOOLEAN nCoeff_is_R(const coeffs r)
 { return getCoeffType(r)==n_R; }
 
-static inline BOOLEAN nField_is_GF(const coeffs r)
+static inline BOOLEAN nCoeff_is_GF(const coeffs r)
 { return getCoeffType(r)==n_GF; }
 
-static inline BOOLEAN nField_is_GF(const coeffs r, int q)
+static inline BOOLEAN nCoeff_is_GF(const coeffs r, int q)
 { return (getCoeffType(r)==n_GF) && (r->ch == q); }
 
-static inline BOOLEAN nField_is_Zp_a(const coeffs r)
+static inline BOOLEAN nCoeff_is_Zp_a(const coeffs r)
 { return (r->ringtype == 0) && (r->ch < -1); }
 
-static inline BOOLEAN nField_is_Zp_a(const coeffs r, int p)
+static inline BOOLEAN nCoeff_is_Zp_a(const coeffs r, int p)
 { return (r->ringtype == 0) && (r->ch < -1 ) && (-(r->ch) == ABS(p)); }
 
-static inline BOOLEAN nField_is_Q_a(const coeffs r)
+static inline BOOLEAN nCoeff_is_Q_a(const coeffs r)
 { return (r->ringtype == 0) && (r->ch == 1); }
 
-static inline BOOLEAN nField_is_long_R(const coeffs r)
+static inline BOOLEAN nCoeff_is_long_R(const coeffs r)
 { return getCoeffType(r)==n_long_R; }
 
-static inline BOOLEAN nField_is_long_C(const coeffs r)
+static inline BOOLEAN nCoeff_is_long_C(const coeffs r)
 { return getCoeffType(r)==n_long_C; }
 
-static inline BOOLEAN nField_is_CF(const coeffs r)
+static inline BOOLEAN nCoeff_is_CF(const coeffs r)
 { return getCoeffType(r)==n_CF; }
 
-static inline BOOLEAN nField_has_simple_inverse(const coeffs r)
+static inline BOOLEAN nCoeff_has_simple_inverse(const coeffs r)
 { return r->has_simple_Inverse; }
 /* Z/2^n, Z/p, GF(p,n), R, long_R, long_C*/
 
-static inline BOOLEAN nField_has_simple_Alloc(const coeffs r)
+static inline BOOLEAN nCoeff_has_simple_Alloc(const coeffs r)
 { return r->has_simple_Alloc; }
 /* Z/p, GF(p,n), R, Ring_2toM: nCopy, nNew, nDelete are dummies*/
 
-static inline BOOLEAN nField_is_Extension(const coeffs r)
-{ return (nField_is_Q_a(r)) || (nField_is_Zp_a(r)); } /* Z/p(a) and Q(a)*/
+static inline BOOLEAN nCoeff_is_Extension(const coeffs r)
+{ return (nCoeff_is_Q_a(r)) || (nCoeff_is_Zp_a(r)); } /* Z/p(a) and Q(a)*/
 
-typedef void (*cfInitCharProc)(coeffs, void *);
+/// initialize an object of type coeff, return FALSE in case of success
+typedef BOOLEAN (*cfInitCharProc)(coeffs, void *);
 n_coeffType nRegister(n_coeffType n, cfInitCharProc p);
 

coeffs/rintegers.cc

@@ -279 +279 @@
 {
   /* dst = currRing */
-  if (nField_is_Ring_Z(src) || nField_is_Ring_ModN(src) || nField_is_Ring_PtoM(src))
+  if (nCoeff_is_Ring_Z(src) || nCoeff_is_Ring_ModN(src) || nCoeff_is_Ring_PtoM(src))
   {
     return nrzCopyMap;
   }
-  if (nField_is_Ring_2toM(src))
+  if (nCoeff_is_Ring_2toM(src))
   {
     return nrzMapMachineInt;
   }
-  if (nField_is_Zp(src))
+  if (nCoeff_is_Zp(src))
   {
     return nrzMapZp;
   }
-  if (nField_is_Q(src))
+  if (nCoeff_is_Q(src))
   {
     return nrzMapQ;
@@ -373 +373 @@
 }
 
-void nrzInitChar(coeffs r,  void * parameter)
+BOOLEAN nrzInitChar(coeffs r,  void * parameter)
 {
   r->cfSetChar= NULL;

coeffs/rintegers.h

@@ -14 +14 @@
 extern NATNUMBER nrzModul;
 
-void    nrzInitChar    (coeffs r,  void * parameter);
+BOOLEAN nrzInitChar    (coeffs r,  void * parameter);
 number  nrzCopy        (number a, const coeffs r);
 int     nrzSize        (number a, const coeffs r);

coeffs/rmodulo2m.cc

@@ -29 +29 @@
 
 /* for initializing function pointers */
-void nr2mInitChar (coeffs r, void* p)
+BOOLEAN nr2mInitChar (coeffs r, void* p)
 {
   
@@ -563 +563 @@
 nMapFunc nr2mSetMap(const coeffs src, const coeffs dst)
 {
-  if (nField_is_Ring_2toM(src)
+  if (nCoeff_is_Ring_2toM(src)
      && (src->ringflagb == dst->ringflagb))
   {
     return ndCopyMap;
   }
-  if (nField_is_Ring_2toM(src)
+  if (nCoeff_is_Ring_2toM(src)
      && (src->ringflagb < dst->ringflagb))
   { /* i.e. map an integer mod 2^s into Z mod 2^t, where t < s */
     return nr2mMapMachineInt;
   }
-  if (nField_is_Ring_2toM(src)
+  if (nCoeff_is_Ring_2toM(src)
      && (src->ringflagb > dst->ringflagb))
   { /* i.e. map an integer mod 2^s into Z mod 2^t, where t > s */
     // to be done
   }
-  if (nField_is_Ring_Z(src))
+  if (nCoeff_is_Ring_Z(src))
   {
     return nr2mMapGMP;
   }
-  if (nField_is_Q(src))
+  if (nCoeff_is_Q(src))
   {
     return nr2mMapQ;
   }
-  if (nField_is_Zp(src)
+  if (nCoeff_is_Zp(src)
      && (src->ch == 2)
      && (dst->ringflagb == 1))
@@ -592 +592 @@
     return nr2mMapZp;
   }
-  if (nField_is_Ring_PtoM(src) || nField_is_Ring_ModN(src))
+  if (nCoeff_is_Ring_PtoM(src) || nCoeff_is_Ring_ModN(src))
   {
     // Computing the n of Z/n

coeffs/rmodulo2m.h

@@ -17 +17 @@
 
 
-void    nr2mInitChar    (coeffs r, void*);
+BOOLEAN nr2mInitChar    (coeffs r, void*);
 
 extern int nr2mExp;

coeffs/rmodulon.cc

@@ -30 +30 @@
 
 /* for initializing function pointers */
-void nrnInitChar (coeffs r, void* p)
+BOOLEAN nrnInitChar (coeffs r, void* p)
 {
   
@@ -458 +458 @@
 {
   /* dst = currRing->cf */
-  if (nField_is_Ring_Z(src))
+  if (nCoeff_is_Ring_Z(src))
   {
     return nrnMapGMP;
   }
-  if (nField_is_Q(src))
+  if (nCoeff_is_Q(src))
   {
     return nrnMapQ;
   }
   // Some type of Z/n ring / field
-  if (nField_is_Ring_ModN(src) || nField_is_Ring_PtoM(src) || nField_is_Ring_2toM(src) || nField_is_Zp(src))
+  if (nCoeff_is_Ring_ModN(src) || nCoeff_is_Ring_PtoM(src) || nCoeff_is_Ring_2toM(src) || nCoeff_is_Zp(src))
   {
     if (   (src->ringtype > 0)
@@ -476 +476 @@
       int_number nrnMapModul = (int_number) omAllocBin(gmp_nrz_bin);
       // Computing the n of Z/n
-      if (nField_is_Zp(src))
+      if (nCoeff_is_Zp(src))
       {
         mpz_init_set_si(nrnMapModul, src->ch);
@@ -521 +521 @@
       }
       nrnDelete((number*) &nrnMapModul, dst);
-      if (nField_is_Ring_2toM(src))
+      if (nCoeff_is_Ring_2toM(src))
         return nrnMap2toM;
-      else if (nField_is_Zp(src))
+      else if (nCoeff_is_Zp(src))
         return nrnMapZp;
       else

coeffs/rmodulon.h

@@ -16 +16 @@
 #endif
 
-void    nrnInitChar    (coeffs r, void*);
+BOOLEAN nrnInitChar    (coeffs r, void*);
 number  nrnCopy        (number a, const coeffs r);
 int     nrnSize        (number a, const coeffs r);

coeffs/shortfl.cc

@@ -511 +511 @@
   assume( getCoeffType(dst) == ID );
 
-  if (nField_is_Q(src))
+  if (nCoeff_is_Q(src))
   {
     return nrMapQ;
   }
-  if (nField_is_long_R(src))
+  if (nCoeff_is_long_R(src))
   {
     return nrMapLongR;
   }
-  if (nField_is_R(src))
+  if (nCoeff_is_R(src))
   {
     return ndCopyMap;
   }
-  if(nField_is_Zp(src))
+  if(nCoeff_is_Zp(src))
   {
     return nrMapP;
   }
-  if (nField_is_long_C(src))
+  if (nCoeff_is_long_C(src))
   {
     return nrMapC;
@@ -547 +547 @@
 
 
-void nrInitChar(coeffs n, void*)
+BOOLEAN nrInitChar(coeffs n, void*)
 {
   assume( getCoeffType(n) == ID );

coeffs/shortfl.h

@@ -15 +15 @@
 
 /// Initialize r
-void nrInitChar(coeffs r, void*);
+BOOLEAN nrInitChar(coeffs r, void*);
 
 // Private interface should be hidden!!!