Index: coeffs/modulop.cc
===================================================================
--- coeffs/modulop.cc	(revision a0ce49c7c05b8b409237dc853e846599cae23aea)
+++ coeffs/modulop.cc	(revision bec902b0ffacb3e2e367c56db0c72b92c58d06d5)
@@ -318,6 +318,7 @@
 }
 
-void npInitChar(coeffs r, int c)
-{
+void npInitChar(coeffs r, void* p)
+{
+  int c= (int) (long) p;
   int i, w;
 
Index: coeffs/modulop.h
===================================================================
--- coeffs/modulop.h	(revision a0ce49c7c05b8b409237dc853e846599cae23aea)
+++ coeffs/modulop.h	(revision bec902b0ffacb3e2e367c56db0c72b92c58d06d5)
@@ -24,5 +24,5 @@
 extern int npGen;
 
-void npInitChar(coeffs r, int ch);
+void npInitChar(coeffs r, void* p);
 
 BOOLEAN npGreaterZero (number k, const coeffs r);
Index: coeffs/rintegers.cc
===================================================================
--- coeffs/rintegers.cc	(revision a0ce49c7c05b8b409237dc853e846599cae23aea)
+++ coeffs/rintegers.cc	(revision bec902b0ffacb3e2e367c56db0c72b92c58d06d5)
@@ -28,5 +28,5 @@
  * Multiply two numbers
  */
-number nrzMult (number a, number b)
+number nrzMult (number a, number b, const coeffs r)
 {
   int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
@@ -63,5 +63,5 @@
  * a solution and r, s, s.t. k = s*a + t*b
  */
-number  nrzExtGcd (number a, number b, number *s, number *t)
+number  nrzExtGcd (number a, number b, number *s, number *t, const coeffs r)
 {
   int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
@@ -77,5 +77,5 @@
 }
 
-void nrzPower (number a, int i, number * result)
+void nrzPower (number a, int i, number * result, const coeffs r)
 {
   int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
@@ -129,5 +129,5 @@
 }
 
-number nrzAdd (number a, number b)
+number nrzAdd (number a, number b, const coeffs r)
 {
   int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
@@ -137,5 +137,5 @@
 }
 
-number nrzSub (number a, number b)
+number nrzSub (number a, number b, const coeffs r)
 {
   int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
@@ -150,56 +150,56 @@
 }
 
-BOOLEAN nrzIsUnit (number a)
+BOOLEAN nrzIsUnit (number a, const coeffs r)
 {
   return 0 == mpz_cmpabs_ui((int_number) a, 1);
 }
 
-BOOLEAN nrzIsZero (number  a)
+BOOLEAN nrzIsZero (number  a, const coeffs r)
 {
   return 0 == mpz_cmpabs_ui((int_number) a, 0);
 }
 
-BOOLEAN nrzIsOne (number a)
+BOOLEAN nrzIsOne (number a, const coeffs r)
 {
   return (a!=NULL) && (0 == mpz_cmp_si((int_number) a, 1));
 }
 
-BOOLEAN nrzIsMOne (number a)
+BOOLEAN nrzIsMOne (number a, const coeffs r)
 {
   return (a!=NULL) && (0 == mpz_cmp_si((int_number) a, -1));
 }
 
-BOOLEAN nrzEqual (number a,number b)
+BOOLEAN nrzEqual (number a,number b, const coeffs r)
 {
   return 0 == mpz_cmp((int_number) a, (int_number) b);
 }
 
-BOOLEAN nrzGreater (number a,number b)
+BOOLEAN nrzGreater (number a,number b, const coeffs r)
 {
   return 0 < mpz_cmp((int_number) a, (int_number) b);
 }
 
-BOOLEAN nrzGreaterZero (number k)
+BOOLEAN nrzGreaterZero (number k, const coeffs r)
 {
   return 0 < mpz_cmp_si((int_number) k, 0);
 }
 
-int nrzDivComp(number a, number b)
-{
-  if (nrzDivBy(a, b))
-  {
-    if (nrzDivBy(b, a)) return 2;
+int nrzDivComp(number a, number b, const coeffs r)
+{
+  if (nrzDivBy(a, b, r))
+  {
+    if (nrzDivBy(b, a, r)) return 2;
     return -1;
   }
-  if (nrzDivBy(b, a)) return 1;
+  if (nrzDivBy(b, a, r)) return 1;
   return 0;
 }
 
-BOOLEAN nrzDivBy (number a,number b)
+BOOLEAN nrzDivBy (number a,number b, const coeffs r)
 {
   return mpz_divisible_p((int_number) a, (int_number) b) != 0;
 }
 
-number nrzDiv (number a,number b)
+number nrzDiv (number a,number b, const coeffs R)
 {
   int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
@@ -208,5 +208,5 @@
   mpz_init(r);
   mpz_tdiv_qr(erg, r, (int_number) a, (int_number) b);
-  if (!nrzIsZero((number) r))
+  if (!nrzIsZero((number) r, R))
   {
     WerrorS("Division by non divisible element.");
@@ -218,5 +218,5 @@
 }
 
-number nrzIntDiv (number a,number b)
+number nrzIntDiv (number a,number b, const coeffs r)
 {
   int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
@@ -226,5 +226,5 @@
 }
 
-number nrzIntMod (number a,number b)
+number nrzIntMod (number a,number b, const coeffs R)
 {
   int_number erg = (int_number) omAllocBin(gmp_nrz_bin);
@@ -239,5 +239,5 @@
 number  nrzInvers (number c, const coeffs r)
 {
-  if (!nrzIsUnit((number) c))
+  if (!nrzIsUnit((number) c, r))
   {
     WerrorS("Non invertible element.");
@@ -247,5 +247,5 @@
 }
 
-number nrzNeg (number c)
+number nrzNeg (number c, const coeffs r)
 {
 // nNeg inplace !!!
Index: coeffs/rintegers.h
===================================================================
--- coeffs/rintegers.h	(revision a0ce49c7c05b8b409237dc853e846599cae23aea)
+++ coeffs/rintegers.h	(revision bec902b0ffacb3e2e367c56db0c72b92c58d06d5)
@@ -17,28 +17,28 @@
 int     nrzSize        (number a);
 void    nrzDelete      (number *a, const coeffs r);
-BOOLEAN nrzGreaterZero (number k);
-number  nrzMult        (number a, number b);
+BOOLEAN nrzGreaterZero (number k, const coeffs r);
+number  nrzMult        (number a, number b, const coeffs r);
 number  nrzInit        (int i, const coeffs r);
 int     nrzInt         (number &n, const coeffs r);
-number  nrzAdd         (number a, number b);
-number  nrzSub         (number a, number b);
-void    nrzPower       (number a, int i, number * result);
-BOOLEAN nrzIsZero      (number a);
-BOOLEAN nrzIsOne       (number a);
-BOOLEAN nrzIsMOne      (number a);
-BOOLEAN nrzIsUnit      (number a);
-number  nrzGetUnit     (number a);
-number  nrzDiv         (number a, number b);
-number  nrzIntDiv      (number a, number b);
-number  nrzIntMod      (number a, number b);
-number  nrzNeg         (number c);
-number  nrzInvers      (number c);
-BOOLEAN nrzGreater     (number a, number b);
-BOOLEAN nrzDivBy       (number a, number b);
-int     nrzDivComp     (number a, number b);
-BOOLEAN nrzEqual       (number a, number b);
-number  nrzLcm         (number a,number b, coeffs r);
-number  nrzGcd         (number a,number b,coeffs r);
-number  nrzExtGcd      (number a, number b, number *s, number *t);
+number  nrzAdd         (number a, number b, const coeffs r);
+number  nrzSub         (number a, number b, const coeffs r);
+void    nrzPower       (number a, int i, number * result, const coeffs r);
+BOOLEAN nrzIsZero      (number a, const coeffs r);
+BOOLEAN nrzIsOne       (number a, const coeffs r);
+BOOLEAN nrzIsMOne      (number a, const coeffs r);
+BOOLEAN nrzIsUnit      (number a, const coeffs r);
+number  nrzGetUnit     (number a, const coeffs r);
+number  nrzDiv         (number a, number b, const coeffs r);
+number  nrzIntDiv      (number a, number b, const coeffs r);
+number  nrzIntMod      (number a, number b, const coeffs r);
+number  nrzNeg         (number c, const coeffs r);
+number  nrzInvers      (number c, const coeffs r);
+BOOLEAN nrzGreater     (number a, number b, const coeffs r);
+BOOLEAN nrzDivBy       (number a, number b, const coeffs r);
+int     nrzDivComp     (number a, number b, const coeffs r);
+BOOLEAN nrzEqual       (number a, number b, const coeffs r);
+number  nrzLcm         (number a,number b, const coeffs r);
+number  nrzGcd         (number a,number b, const coeffs r);
+number  nrzExtGcd      (number a, number b, number *s, number *t, const coeffs r);
 nMapFunc nrzSetMap     (const coeffs src, const coeffs dst);
 void    nrzWrite       (number &a, const coeffs r);
Index: coeffs/test.cc
===================================================================
--- coeffs/test.cc	(revision a0ce49c7c05b8b409237dc853e846599cae23aea)
+++ coeffs/test.cc	(revision bec902b0ffacb3e2e367c56db0c72b92c58d06d5)
@@ -13,5 +13,5 @@
 #include <shortfl.h>
 #include <ffields.h>
-
+#include <modulop.h>
 #include <rmodulon.h>
 #include <rmodulo2m.h>
@@ -125,5 +125,5 @@
   n_coeffType type;
 
-  // TODO: n_Zp, n_GF, n_Zp_a, n_Q_a ?
+  // rings needed for: n_Zp_a, n_Q_a ?
   
   type = nRegister( n_Q, nlInitChar); assume( type == n_Q );
@@ -143,4 +143,8 @@
     c ++;
 
+  type = nRegister( n_Zp, npInitChar); assume( type == n_Zp );
+  if( Test(type) )
+    c ++;
+
 #ifdef HAVE_RINGS
   type = nRegister( n_Z2m, nr2mInitChar); assume( type == n_Z2m );
@@ -153,5 +157,4 @@
 
 //  n_Z, // TODO?
-//  n_Zpn, // no longer exists?
 #endif
 
