Index: libpolys/coeffs/gnumpc.cc
===================================================================
--- libpolys/coeffs/gnumpc.cc	(revision 7af488ec51790060979537b35a03fb345e053f90)
+++ libpolys/coeffs/gnumpc.cc	(revision 9bb545791780a99344a26d6177decb3870f6da87)
@@ -30,5 +30,5 @@
 #ifdef LDEBUG
 // not yet implemented
-BOOLEAN ngcDBTest(number a, const char *f, const int l, const coeffs r)
+BOOLEAN ngcDBTest(number, const char *, const int, const coeffs r)
 {
   assume( getCoeffType(r) == ID );
@@ -54,7 +54,7 @@
 {
   assume( getCoeffType(r) == ID );
-  
+
   gmp_complex* n= new gmp_complex( (long)i, (long)0 );
-  
+
   return (number)n;
 }
@@ -66,5 +66,5 @@
 {
   assume( getCoeffType(r) == ID );
-  
+
   return (int)((gmp_complex*)i)->real();
 }
@@ -105,5 +105,5 @@
 {
   assume( getCoeffType(r) == ID );
-  
+
   gmp_complex* b= new gmp_complex( *(gmp_complex*)a );
   return (number)b;
@@ -170,5 +170,5 @@
 {
   assume( getCoeffType(R) == ID );
-  
+
   gmp_complex* r= new gmp_complex( (*(gmp_complex*)a) * (*(gmp_complex*)b) );
   return (number)r;
@@ -414,6 +414,6 @@
 
 
-  
-/*  
+
+/*
   //r->cfInitChar=nlInitChar;
   r->cfKillChar=NULL;
@@ -484,5 +484,5 @@
   else
     n->complex_parameter = omStrDup( (char*) p );
-    
+
   return FALSE;
 }
@@ -553,8 +553,8 @@
 
   if ( from !=  NULL )
-  { 
+  {
     b = new gmp_complex( *(gmp_complex*)from );
   }
-  return (number)b;  
+  return (number)b;
 }
 
Index: libpolys/coeffs/longrat.cc
===================================================================
--- libpolys/coeffs/longrat.cc	(revision 7af488ec51790060979537b35a03fb345e053f90)
+++ libpolys/coeffs/longrat.cc	(revision 9bb545791780a99344a26d6177decb3870f6da87)
@@ -151,5 +151,5 @@
   assume( getCoeffType(dst) == ID );
   assume( getCoeffType(src) == n_Zp );
-  
+
   number to;
   to = nlInit(npInt(from,src), dst);
@@ -164,5 +164,5 @@
 * convert from a GMP integer
 */
-number nlMapGMP(number from, const coeffs src, const coeffs dst)
+number nlMapGMP(number from, const coeffs /*src*/, const coeffs /*dst*/)
 {
   number z=ALLOC_RNUMBER();
@@ -180,5 +180,5 @@
 * convert from an machine long
 */
-number nlMapMachineInt(number from, const coeffs src, const coeffs dst)
+number nlMapMachineInt(number from, const coeffs /*src*/, const coeffs /*dst*/)
 {
   number z=ALLOC_RNUMBER();
@@ -195,5 +195,5 @@
 
 #ifdef LDEBUG
-BOOLEAN nlDBTest(number a, const char *f,const int l, const coeffs r)
+BOOLEAN nlDBTest(number a, const char *f,const int l, const coeffs /*r*/)
 {
   if (a==NULL)
@@ -284,5 +284,5 @@
 
 #ifdef HAVE_FACTORY
-CanonicalForm nlConvSingNFactoryN( number n, BOOLEAN setChar, const coeffs r )
+CanonicalForm nlConvSingNFactoryN( number n, BOOLEAN setChar, const coeffs /*r*/ )
 {
   if (setChar) setCharacteristic( 0 );
@@ -345,5 +345,5 @@
   assume( getCoeffType(dst) == ID );
   assume( getCoeffType(src) == n_R );
-  
+
   double f=nrFloat(from);
   if (f==0.0) return INT_TO_SR(0);
@@ -372,9 +372,9 @@
 }
 
-static number nlMapLongR(number from, const coeffs src, const coeffs dst) 
+static number nlMapLongR(number from, const coeffs src, const coeffs dst)
 {
   assume( getCoeffType(dst) == ID );
   assume( getCoeffType(src) == n_long_R );
-  
+
   gmp_float *ff=(gmp_float*)from;
   mpf_t *f=ff->_mpfp();
@@ -522,5 +522,5 @@
      return 1; /* immidiate int */
   int s=a->z[0]._mp_alloc;
-//  while ((s>0) &&(a->z._mp_d[s]==0L)) s--; 
+//  while ((s>0) &&(a->z._mp_d[s]==0L)) s--;
 //#if SIZEOF_LONG == 8
 //  if (a->z._mp_d[s] < (unsigned long)0x100000000L) s=s*2-1;
@@ -531,5 +531,5 @@
   {
     int d=a->n[0]._mp_alloc;
-//    while ((d>0) && (a->n._mp_d[d]==0L)) d--; 
+//    while ((d>0) && (a->n._mp_d[d]==0L)) d--;
 //#if SIZEOF_LONG == 8
 //    if (a->n._mp_d[d] < (unsigned long)0x100000000L) d=d*2-1;
@@ -1971,5 +1971,5 @@
   assume( getCoeffType(dst) == ID );
   assume( getCoeffType(src) == ID );
-  
+
   if ((SR_HDL(a) & SR_INT)||(a==NULL))
   {
@@ -1983,5 +1983,5 @@
   assume( getCoeffType(dst) == ID );
 //  assume( getCoeffType(src) == ID );
-  
+
   if (nCoeff_is_Q(src))
   {
@@ -2364,10 +2364,10 @@
     nlTest(u, R);
     return u;
-    
+
   }
   number u = _nlMult_aNoImm_OR_bNoImm(a, b);
   nlTest(u, R);
   return u;
-  
+
 }
 
@@ -2391,5 +2391,5 @@
   nlTest(u, r);
   return u;
-  
+
 }
 
@@ -2539,14 +2539,14 @@
 }
 
-void    nlCoeffWrite  (const coeffs r)
+void    nlCoeffWrite  (const coeffs)
 {
   PrintS("//   characteristic : 0\n");
 }
 
-BOOLEAN nlInitChar(coeffs r, void* p)
+BOOLEAN nlInitChar(coeffs r, void*)
 {
   assume( getCoeffType(r) == ID );
   //const int ch = (int)(long)(p);
-  
+
   r->cfKillChar=NULL;
   r->cfSetChar=NULL;
@@ -2609,5 +2609,5 @@
   r->has_simple_Alloc=FALSE;
   r->has_simple_Inverse=FALSE;
-  
+
   // variables for this type of coeffs:
   // (none)
Index: libpolys/coeffs/numbers.cc
===================================================================
--- libpolys/coeffs/numbers.cc	(revision 7af488ec51790060979537b35a03fb345e053f90)
+++ libpolys/coeffs/numbers.cc	(revision 9bb545791780a99344a26d6177decb3870f6da87)
@@ -52,5 +52,5 @@
 
 void   nNew(number* d) { *d=NULL; }
-void   ndDelete(number* d, const coeffs r) { *d=NULL; }
+void   ndDelete(number* d, const coeffs) { *d=NULL; }
 void   ndInpMult(number &a, number b, const coeffs r)
 {
@@ -67,6 +67,6 @@
 
 #ifdef LDEBUG
-void   nDBDummy1(number* d,char *f, int l) { *d=NULL; }
-BOOLEAN ndDBTest(number a, const char *f, const int l, const coeffs r)
+void   nDBDummy1(number* d,char *, int) { *d=NULL; }
+BOOLEAN ndDBTest(number, const char *, const int, const coeffs)
 {
   return TRUE;
@@ -90,13 +90,13 @@
 }
 
-void   ndNormalize(number& d, const coeffs r) { }
-
-char * ndName(number n, const coeffs r) { return NULL; }
-
-number ndPar(int i, const coeffs r) { return n_Init(0,r); }
-
-number ndReturn0(number n, const coeffs r) { return n_Init(0,r); }
-
-int    ndParDeg(number n, const coeffs r) { return 0; }
+void   ndNormalize(number&, const coeffs) { }
+
+char * ndName(number, const coeffs) { return NULL; }
+
+number ndPar(int, const coeffs r) { return n_Init(0,r); }
+
+number ndReturn0(number, const coeffs r) { return n_Init(0,r); }
+
+int    ndParDeg(number, const coeffs) { return 0; }
 
 number ndGcd(number, number, const coeffs r) { return n_Init(1,r); }
@@ -122,12 +122,12 @@
 
 #ifdef HAVE_RINGS
-BOOLEAN ndDivBy(number a, number b, const coeffs r) { return TRUE; } // assume a,b !=0
-int ndDivComp(number a, number b, const coeffs r) { return 2; }
+BOOLEAN ndDivBy(number, number, const coeffs) { return TRUE; } // assume a,b !=0
+int ndDivComp(number, number, const coeffs) { return 2; }
 BOOLEAN ndIsUnit(number a, const coeffs r) { return !n_IsZero(a,r); }
-number  ndExtGcd (number a, number b, number *s, number *t, const coeffs r) { return n_Init(1,r); }
+number  ndExtGcd (number, number, number *, number *, const coeffs r) { return n_Init(1,r); }
 #endif
 
 #ifdef HAVE_FACTORY
-CanonicalForm ndConvSingNFactoryN( number n, BOOLEAN setChar, const coeffs r )
+CanonicalForm ndConvSingNFactoryN( number, BOOLEAN /*setChar*/, const coeffs)
 {
   CanonicalForm term(0);
@@ -136,5 +136,5 @@
 }
 
-number ndConvFactoryNSingN( const CanonicalForm n, const coeffs r)
+number ndConvFactoryNSingN( const CanonicalForm, const coeffs)
 {
   Werror("no conversion from factory");
Index: libpolys/coeffs/rintegers.cc
===================================================================
--- libpolys/coeffs/rintegers.cc	(revision 7af488ec51790060979537b35a03fb345e053f90)
+++ libpolys/coeffs/rintegers.cc	(revision 9bb545791780a99344a26d6177decb3870f6da87)
@@ -30,5 +30,5 @@
  * Multiply two numbers
  */
-number nrzMult (number a, number b, const coeffs r)
+number nrzMult (number a, number b, const coeffs)
 {
   int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
@@ -41,5 +41,5 @@
  * Give the smallest non unit k, such that a * x = k = b * y has a solution
  */
-number nrzLcm (number a,number b,const coeffs r)
+number nrzLcm (number a,number b,const coeffs)
 {
   int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
@@ -53,5 +53,5 @@
  * a solution.
  */
-number nrzGcd (number a,number b,const coeffs r)
+number nrzGcd (number a,number b,const coeffs)
 {
   int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
@@ -65,5 +65,5 @@
  * a solution and r, s, s.t. k = s*a + t*b
  */
-number  nrzExtGcd (number a, number b, number *s, number *t, const coeffs r)
+number  nrzExtGcd (number a, number b, number *s, number *t, const coeffs)
 {
   int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
@@ -79,5 +79,5 @@
 }
 
-void nrzPower (number a, int i, number * result, const coeffs r)
+void nrzPower (number a, int i, number * result, const coeffs)
 {
   int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
@@ -90,5 +90,5 @@
  * create a number from int
  */
-number nrzInit (int i, const coeffs r)
+number nrzInit (int i, const coeffs)
 {
   int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
@@ -97,5 +97,5 @@
 }
 
-void nrzDelete(number *a, const coeffs r)
+void nrzDelete(number *a, const coeffs)
 {
   if (*a == NULL) return;
@@ -105,5 +105,5 @@
 }
 
-number nrzCopy(number a, const coeffs r)
+number nrzCopy(number a, const coeffs)
 {
   int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
@@ -112,10 +112,10 @@
 }
 
-number nrzCopyMap(number a, const coeffs src, const coeffs dst)
+number nrzCopyMap(number a, const coeffs /*src*/, const coeffs dst)
 {
   return nrzCopy(a,dst);
 }
 
-int nrzSize(number a, const coeffs r)
+int nrzSize(number a, const coeffs)
 {
   if (a == NULL) return 0;
@@ -126,10 +126,10 @@
  * convert a number to int
  */
-int nrzInt(number &n, const coeffs r)
+int nrzInt(number &n, const coeffs)
 {
   return (int) mpz_get_si( (int_number)n);
 }
 
-number nrzAdd (number a, number b, const coeffs r)
+number nrzAdd (number a, number b, const coeffs)
 {
   int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
@@ -139,5 +139,5 @@
 }
 
-number nrzSub (number a, number b, const coeffs r)
+number nrzSub (number a, number b, const coeffs)
 {
   int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
@@ -147,40 +147,40 @@
 }
 
-number  nrzGetUnit (number a, const coeffs r)
+number  nrzGetUnit (number, const coeffs r)
 {
   return nrzInit(1, r);
 }
 
-BOOLEAN nrzIsUnit (number a, const coeffs r)
+BOOLEAN nrzIsUnit (number a, const coeffs)
 {
   return 0 == mpz_cmpabs_ui((int_number) a, 1);
 }
 
-BOOLEAN nrzIsZero (number  a, const coeffs r)
+BOOLEAN nrzIsZero (number  a, const coeffs)
 {
   return 0 == mpz_cmpabs_ui((int_number) a, 0);
 }
 
-BOOLEAN nrzIsOne (number a, const coeffs r)
+BOOLEAN nrzIsOne (number a, const coeffs)
 {
   return (a!=NULL) && (0 == mpz_cmp_si((int_number) a, 1));
 }
 
-BOOLEAN nrzIsMOne (number a, const coeffs r)
+BOOLEAN nrzIsMOne (number a, const coeffs)
 {
   return (a!=NULL) && (0 == mpz_cmp_si((int_number) a, -1));
 }
 
-BOOLEAN nrzEqual (number a,number b, const coeffs r)
+BOOLEAN nrzEqual (number a,number b, const coeffs)
 {
   return 0 == mpz_cmp((int_number) a, (int_number) b);
 }
 
-BOOLEAN nrzGreater (number a,number b, const coeffs r)
+BOOLEAN nrzGreater (number a,number b, const coeffs)
 {
   return 0 < mpz_cmp((int_number) a, (int_number) b);
 }
 
-BOOLEAN nrzGreaterZero (number k, const coeffs r)
+BOOLEAN nrzGreaterZero (number k, const coeffs)
 {
   return 0 < mpz_cmp_si((int_number) k, 0);
@@ -198,5 +198,5 @@
 }
 
-BOOLEAN nrzDivBy (number a,number b, const coeffs r)
+BOOLEAN nrzDivBy (number a,number b, const coeffs)
 {
   return mpz_divisible_p((int_number) a, (int_number) b) != 0;
@@ -220,5 +220,5 @@
 }
 
-number nrzIntDiv (number a,number b, const coeffs r)
+number nrzIntDiv (number a,number b, const coeffs)
 {
   int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
@@ -228,5 +228,5 @@
 }
 
-number nrzIntMod (number a,number b, const coeffs R)
+number nrzIntMod (number a,number b, const coeffs)
 {
   int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
@@ -249,5 +249,5 @@
 }
 
-number nrzNeg (number c, const coeffs r)
+number nrzNeg (number c, const coeffs)
 {
 // nNeg inplace !!!
@@ -256,5 +256,5 @@
 }
 
-number nrzMapMachineInt(number from, const coeffs src, const coeffs dst)
+number nrzMapMachineInt(number from, const coeffs /*src*/, const coeffs /*dst*/)
 {
   int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
@@ -263,5 +263,5 @@
 }
 
-number nrzMapZp(number from, const coeffs src, const coeffs dst)
+number nrzMapZp(number from, const coeffs /*src*/, const coeffs /*dst*/)
 {
   int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
@@ -270,5 +270,5 @@
 }
 
-number nrzMapQ(number from, const coeffs src, const coeffs dst)
+number nrzMapQ(number from, const coeffs src, const coeffs /*dst*/)
 {
   int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
@@ -305,14 +305,14 @@
  */
 
-void nrzSetExp(int m, coeffs r)
-{
-}
-
-void nrzInitExp(int m, coeffs r)
+void nrzSetExp(int, coeffs)
+{
+}
+
+void nrzInitExp(int, coeffs)
 {
 }
 
 #ifdef LDEBUG
-BOOLEAN nrzDBTest (number a, const char *f, const int l, const coeffs r)
+BOOLEAN nrzDBTest (number, const char *, const int, const coeffs)
 {
   return TRUE;//TODO
@@ -320,5 +320,5 @@
 #endif
 
-void nrzWrite (number &a, const coeffs r)
+void nrzWrite (number &a, const coeffs)
 {
   char *s,*z;
@@ -364,5 +364,5 @@
 }
 
-const char * nrzRead (const char *s, number *a, const coeffs r)
+const char * nrzRead (const char *s, number *a, const coeffs)
 {
   int_number z = (int_number) omAllocBin(gmp_nrz_bin);
@@ -375,5 +375,5 @@
 }
 
-void    nrzCoeffWrite  (const coeffs r)
+void    nrzCoeffWrite  (const coeffs)
 {
   PrintS("//   characteristic : 0 (Integers)\n");
@@ -381,5 +381,5 @@
 
 
-BOOLEAN nrzInitChar(coeffs r,  void * parameter)
+BOOLEAN nrzInitChar(coeffs r,  void *)
 {
   assume( getCoeffType(r) == ID );
@@ -426,10 +426,10 @@
   r->cfDBTest=nrzDBTest;
 #endif
- 
+
   r->nNULL = 0;
   r->ch = 0;
   r->ringtype = 4;
   r->has_simple_Alloc=FALSE;
-  r->has_simple_Inverse=FALSE; 
+  r->has_simple_Inverse=FALSE;
   return FALSE;
 }
Index: libpolys/coeffs/rmodulo2m.cc
===================================================================
--- libpolys/coeffs/rmodulo2m.cc	(revision 7af488ec51790060979537b35a03fb345e053f90)
+++ libpolys/coeffs/rmodulo2m.cc	(revision 9bb545791780a99344a26d6177decb3870f6da87)
@@ -53,5 +53,5 @@
 
   r->ringtype = 1;
-  
+
   /* next cast may yield an overflow as mod2mMask is an unsigned long */
   r->ch = (int)r->mod2mMask + 1;
@@ -110,5 +110,5 @@
  * Give the smallest k, such that a * x = k = b * y has a solution
  */
-number nr2mLcm(number a, number b, const coeffs r)
+number nr2mLcm(number a, number b, const coeffs)
 {
   NATNUMBER res = 0;
@@ -133,5 +133,5 @@
  * a solution.
  */
-number nr2mGcd(number a, number b, const coeffs r)
+number nr2mGcd(number a, number b, const coeffs)
 {
   NATNUMBER res = 0;
@@ -240,10 +240,10 @@
 }
 
-BOOLEAN nr2mIsUnit(number a, const coeffs r)
+BOOLEAN nr2mIsUnit(number a, const coeffs)
 {
   return ((NATNUMBER)a % 2 == 1);
 }
 
-number nr2mGetUnit(number k, const coeffs r)
+number nr2mGetUnit(number k, const coeffs)
 {
   if (k == NULL) return (number)1;
@@ -253,10 +253,10 @@
 }
 
-BOOLEAN nr2mIsZero(number a, const coeffs r)
+BOOLEAN nr2mIsZero(number a, const coeffs)
 {
   return 0 == (NATNUMBER)a;
 }
 
-BOOLEAN nr2mIsOne(number a, const coeffs r)
+BOOLEAN nr2mIsOne(number a, const coeffs)
 {
   return 1 == (NATNUMBER)a;
@@ -268,5 +268,5 @@
 }
 
-BOOLEAN nr2mEqual(number a, number b, const coeffs r)
+BOOLEAN nr2mEqual(number a, number b, const coeffs)
 {
   return (a == b);
@@ -310,5 +310,5 @@
 }
 
-int nr2mDivComp(number as, number bs, const coeffs r)
+int nr2mDivComp(number as, number bs, const coeffs)
 {
   NATNUMBER a = (NATNUMBER)as;
@@ -474,5 +474,5 @@
   NATNUMBER g = 1;
   NATNUMBER b_div = (NATNUMBER)b;
-  if (b_div < 0) b_div = -b_div; // b_div now represents |b|
+  if (b_div < 0) b_div = -b_div; // b_div now represents |b|, BUT b_div is unsigned!
   NATNUMBER rr = 0;
   while ((g < r->mod2mMask ) && (b_div > 0) && (b_div % 2 == 0))
@@ -532,5 +532,5 @@
 }
 
-number nr2mMapMachineInt(number from, const coeffs src, const coeffs dst)
+number nr2mMapMachineInt(number from, const coeffs /*src*/, const coeffs dst)
 {
   NATNUMBER i = ((NATNUMBER)from) % dst->mod2mMask ;
@@ -538,5 +538,5 @@
 }
 
-number nr2mMapZp(number from, const coeffs src, const coeffs dst)
+number nr2mMapZp(number from, const coeffs /*src*/, const coeffs dst)
 {
   NATNUMBER j = (NATNUMBER)1;
@@ -549,5 +549,5 @@
 }
 
-number nr2mMapQ(number from, const coeffs src, const coeffs dst)
+number nr2mMapQ(number from, const coeffs /*src*/, const coeffs dst)
 {
   int_number erg = (int_number)omAllocBin(gmp_nrz_bin);
@@ -566,5 +566,5 @@
 }
 
-number nr2mMapGMP(number from, const coeffs src, const coeffs dst)
+number nr2mMapGMP(number from, const coeffs /*src*/, const coeffs dst)
 {
   int_number erg = (int_number)omAllocBin(gmp_nrz_bin);
@@ -659,7 +659,7 @@
 
 #ifdef LDEBUG
-BOOLEAN nr2mDBTest (number a, const char *f, const int l, const coeffs r)
-{
-  if ((NATNUMBER)a < 0) return FALSE;
+BOOLEAN nr2mDBTest (number a, const char *, const int, const coeffs r)
+{
+  //if ((NATNUMBER)a < 0) return FALSE; // is unsigned!
   if (((NATNUMBER)a & r->mod2mMask) != (NATNUMBER)a) return FALSE;
   return TRUE;
Index: libpolys/coeffs/rmodulon.cc
===================================================================
--- libpolys/coeffs/rmodulon.cc	(revision 7af488ec51790060979537b35a03fb345e053f90)
+++ libpolys/coeffs/rmodulon.cc	(revision 9bb545791780a99344a26d6177decb3870f6da87)
@@ -51,5 +51,5 @@
   nrnInitExp((int)(long)(p), r);
   r->ringtype = 2;
-  
+
   /* next computation may yield wrong characteristic as r->modNumber
      is a GMP number */
@@ -108,5 +108,5 @@
 }
 
-void nrnDelete(number *a, const coeffs r)
+void nrnDelete(number *a, const coeffs)
 {
   if (*a == NULL) return;
@@ -116,5 +116,5 @@
 }
 
-number nrnCopy(number a, const coeffs r)
+number nrnCopy(number a, const coeffs)
 {
   int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
@@ -123,5 +123,5 @@
 }
 
-int nrnSize(number a, const coeffs r)
+int nrnSize(number a, const coeffs)
 {
   if (a == NULL) return 0;
@@ -132,5 +132,5 @@
  * convert a number to int
  */
-int nrnInt(number &n, const coeffs r)
+int nrnInt(number &n, const coeffs)
 {
   return (int)mpz_get_si((int_number) n);
@@ -179,5 +179,5 @@
   if( !nrnIsZero(c, r) )
     // Attention: This method operates in-place.
-    mpz_sub((int_number)c, r->modNumber, (int_number)c);  
+    mpz_sub((int_number)c, r->modNumber, (int_number)c);
   return c;
 }
@@ -253,5 +253,5 @@
 }
 
-BOOLEAN nrnIsZero(number a, const coeffs r)
+BOOLEAN nrnIsZero(number a, const coeffs)
 {
 #ifdef LDEBUG
@@ -261,5 +261,5 @@
 }
 
-BOOLEAN nrnIsOne(number a, const coeffs r)
+BOOLEAN nrnIsOne(number a, const coeffs)
 {
 #ifdef LDEBUG
@@ -281,15 +281,15 @@
 }
 
-BOOLEAN nrnEqual(number a, number b, const coeffs r)
+BOOLEAN nrnEqual(number a, number b, const coeffs)
 {
   return 0 == mpz_cmp((int_number)a, (int_number)b);
 }
 
-BOOLEAN nrnGreater(number a, number b, const coeffs r)
+BOOLEAN nrnGreater(number a, number b, const coeffs)
 {
   return 0 < mpz_cmp((int_number)a, (int_number)b);
 }
 
-BOOLEAN nrnGreaterZero(number k, const coeffs r)
+BOOLEAN nrnGreaterZero(number k, const coeffs)
 {
   return 0 < mpz_cmp_si((int_number)k, 0);
@@ -443,10 +443,10 @@
 int_number nrnMapCoef = NULL;
 
-number nrnMapModN(number from, const coeffs src, const coeffs dst)
+number nrnMapModN(number from, const coeffs /*src*/, const coeffs dst)
 {
   return nrnMult(from, (number) nrnMapCoef, dst);
 }
 
-number nrnMap2toM(number from, const coeffs src, const coeffs dst)
+number nrnMap2toM(number from, const coeffs /*src*/, const coeffs dst)
 {
   int_number erg = (int_number)omAllocBin(gmp_nrz_bin);
@@ -457,5 +457,5 @@
 }
 
-number nrnMapZp(number from, const coeffs src, const coeffs dst)
+number nrnMapZp(number from, const coeffs /*src*/, const coeffs dst)
 {
   int_number erg = (int_number)omAllocBin(gmp_nrz_bin);
@@ -467,5 +467,5 @@
 }
 
-number nrnMapGMP(number from, const coeffs src, const coeffs dst)
+number nrnMapGMP(number from, const coeffs /*src*/, const coeffs dst)
 {
   int_number erg = (int_number)omAllocBin(gmp_nrz_bin);
@@ -475,5 +475,5 @@
 }
 
-number nrnMapQ(number from, const coeffs src, const coeffs dst)
+number nrnMapQ(number from, const coeffs src, const coeffs /*dst*/)
 {
   int_number erg = (int_number)omAllocBin(gmp_nrz_bin);
@@ -590,5 +590,5 @@
 
 #ifdef LDEBUG
-BOOLEAN nrnDBTest (number a, const char *f, const int l, const coeffs r)
+BOOLEAN nrnDBTest (number a, const char *, const int, const coeffs r)
 {
   if (a==NULL) return TRUE;
