2008-02-28 Andrew John Hughes <gnu_andrew@member.fsf.org>

        PR classpath/28664
	* include/Makefile.am:
	Add generation of header file java_math_VMBigInteger.h
	* java/math/BigInteger.java: Separate NativeMPI into
	VMBigInteger.
	* native/jni/Makefile.am: Add java-math.
	* native/jni/java-math/java_math_VMBigInteger.c:
	Renamed from java_math_BigInteger.c.
	* vm/reference/java/math/VMBigInteger.java:
	Former NativeMPI class from java.math.BigInteger.

2006-11-28  Raif S. Naffah  <classpath@naffah-raif.name>
            Jeroen Frijters <jeroen@sumatra.nl>

        PR classpath/28664
        * configure.ac: Add support for configuring GNU MP.
        * native/jni/Makefile.am: Include java-math directory if required.
        * native/jni/java-math/.cvsignore: New file.
        * native/jni/java-math/Makefile.am: Likewise.
        * native/jni/java-math/java_math_BigInteger.c: Likewise.
        * java/math/BigInteger.java: Added support for native methods.
        * gnu/classpath/Configuration.java.in (WANT_NATIVE_BIG_INTEGER): New field.

4 files changed, 1415 insertions, 1 deletions

diff --git a/native/jni/Makefile.am b/native/jni/Makefile.am
index f37e73864..dde5eda6a 100644
--- a/native/jni/Makefile.am
+++ b/native/jni/Makefile.am
@@ -1,7 +1,7 @@
 ## Input file for automake to generate the Makefile.in used by configure
 
 if CREATE_CORE_JNI_LIBRARIES
-  JNIDIRS = native-lib java-io java-lang java-net java-nio java-util
+  JNIDIRS = native-lib java-io java-lang java-math java-net java-nio java-util
 endif
 
 if CREATE_ALSA_LIBRARIES
diff --git a/native/jni/java-math/.cvsignore b/native/jni/java-math/.cvsignore
new file mode 100644
index 000000000..668a982d6
--- /dev/null
+++ b/native/jni/java-math/.cvsignore
@@ -0,0 +1,7 @@
+.deps
+.libs
+*.lo
+*.loT
+*.la
+Makefile
+Makefile.in
diff --git a/native/jni/java-math/Makefile.am b/native/jni/java-math/Makefile.am
new file mode 100644
index 000000000..a8006477f
--- /dev/null
+++ b/native/jni/java-math/Makefile.am
@@ -0,0 +1,11 @@
+nativeexeclib_LTLIBRARIES = libjavamath.la
+
+libjavamath_la_SOURCES = java_math_VMBigInteger.c
+
+libjavamath_la_LIBADD = $(top_builddir)/native/jni/classpath/jcl.lo
+
+libjavamath_la_LDFLAGS = -avoid-version
+
+AM_LDFLAGS = @CLASSPATH_MODULE@ @GMP_LIBS@
+AM_CPPFLAGS = @CLASSPATH_INCLUDES@
+AM_CFLAGS = @WARNING_CFLAGS@ @ERROR_CFLAGS@ @GMP_CFLAGS@
diff --git a/native/jni/java-math/java_math_VMBigInteger.c b/native/jni/java-math/java_math_VMBigInteger.c
new file mode 100644
index 000000000..01bbb2e03
--- /dev/null
+++ b/native/jni/java-math/java_math_VMBigInteger.c
@@ -0,0 +1,1396 @@
+/* java_math_BigInteger_NativeMPI.c -- Native MPI implemenetation over GNU MP
+   Copyright (C) 2006  Free Software Foundation, Inc.
+
+This file is a part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or (at
+your option) any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+USA
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version.  */
+
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include "java_math_VMBigInteger.h"
+#include <jcl.h>
+
+#if defined(HAVE_GMP_H)
+#include <gmp.h>
+#endif /* defined(HAVE_GMP_H) */
+
+#if defined(WITH_GNU_MP)
+#else
+#warning GNU MP not available or wanted!
+#warning Invocation of natXXX() methods will raise an exception
+#endif
+
+/*
+ * This is the implementation of the native BigInteger$NativeMPI methods which
+ * use the GNU MP (GMP) library.
+ *
+ * In all the Java non-statically declared native methods, the second argument,
+ * an instance of jobject, refers to the current NativeMPI instance; i.e.
+ * "this" in Java parlance. The corresponding allocated data structure
+ * representing the GMP's counter-part is pointed-to by the pointer stored in a
+ * transient java field named "native_ptr". The first thing these methods do is
+ * (a) access that field with a JNI GetObjectField() call to obtain the
+ * reference to the gnu.classpath.Pointer subclass instance, then (b) obtain
+ * the native GMP pointer (an mpz_ptr), in order to perform their job; e.g.
+ *
+ *   JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr))
+ *
+ * For static methods the second argument, an instance of jclass, is almost
+ * always unused --except when initializing the library, which is the only time
+ * we get hold of the native pointer field.
+ *
+ * This code was written and tested with GNU MP version 4.1.2. More recent
+ * versions of that library offer more operations; e.g. in the implementation
+ * of the method Java_java_math_BigInteger_00024NativeMPI_natFlipBit, mpz_combit()
+ * should be used with GNU MP versions later than 4.2. As a consequence, this
+ * code should be reviewed, from time to time, to use newer features of the GNU
+ * MP library.
+ */
+
+static jfieldID native_ptr;
+
+#ifdef DEBUG
+#define TRACE(msg) fprintf (stderr, "%s(%s:%d) -- %s\n", __FUNCTION__, __FILE__, __LINE__, msg)
+#else
+#define TRACE(msg)
+#endif
+
+#define throw_config_exception(env) JCL_ThrowException (env, "java/lang/Error", "GNU MP was not specified/found by configure")
+
+/*
+ * Initialize the native library. Specifically this method:
+ *
+ * a. Pass NULLs to the mp_set_memory_functions implying that GMP should use
+ *    malloc, realloc and free for memory allocation, and if they fail GMP
+ *    will print a message to the standard error output and terminates the
+ *    program.
+ * b. Find out and store the reference to the NativeMPI class's 'native_ptr'
+ *    field. This is done so later in the method invocations we can access that
+ *    field and acquire the native value associated with that Pointer instance.
+ */
+JNIEXPORT void JNICALL
+Java_java_math_VMBigInteger_natInitializeLibrary (JNIEnv *env,
+                                                               jclass nativeMPI)
+{
+#if defined(WITH_GNU_MP)
+  TRACE("Loading GMP-based BigInteger native library");
+  mp_set_memory_functions (NULL, NULL, NULL);
+  native_ptr = (*env)->GetFieldID (env, nativeMPI, "native_ptr",
+                                   "Lgnu/classpath/Pointer;");
+  TRACE("Loaded GMP-based BigInteger native library");
+#else /* !defined(WITH_GNU_MP) */
+  (void) nativeMPI;
+  throw_config_exception(env);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * Allocate and initialize the data structure for an instance of a NativeMPI.
+ *
+ * @param this  an instance of NativeMPI.
+ */
+JNIEXPORT void JNICALL
+Java_java_math_VMBigInteger_natInitialize(JNIEnv *env, jobject this)
+{
+#if defined(WITH_GNU_MP)
+  mpz_ptr _this;
+
+  TRACE("begin");
+  _this = (mpz_ptr)JCL_malloc (env, sizeof (mpz_t));
+  /* initialize --GMP sets the value to zero. */
+  mpz_init (_this);
+  /* instantiate the Pointer instance for this NativeMPI. */
+  jobject native_ptr_fld = JCL_NewRawDataObject (env, _this);
+  /* ... and assign it to the native_ptr field. */
+  (*env)->SetObjectField (env, this, native_ptr, native_ptr_fld);
+  TRACE("end");
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  throw_config_exception(env);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * Clear and free the data structure for an instance of a NativeMPI.
+ *
+ * @param this  an instance of NativeMPI.
+ */
+JNIEXPORT void JNICALL
+Java_java_math_VMBigInteger_natFinalize(JNIEnv *env, jobject this)
+{
+#if defined(WITH_GNU_MP)
+  mpz_ptr _this;
+
+  TRACE("begin");
+  _this = (mpz_ptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  if (_this != NULL)
+    {
+      mpz_clear (_this);
+      free (_this);
+      _this = NULL;
+    }
+  else
+    {
+      TRACE("WARNING: Already cleared + freed");
+    }
+  TRACE("end");
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  throw_config_exception(env);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+
+/*
+ * @param this  an instance of NativeMPI. On exit, this will have a value of n.
+ * @param n  a Java long primitive value.
+ */
+JNIEXPORT void JNICALL
+Java_java_math_VMBigInteger_natFromLong(JNIEnv *env, jobject this,
+                                                     jlong n)
+{
+#if defined(WITH_GNU_MP)
+  mpz_ptr _this;
+
+  TRACE("begin");
+  _this = (mpz_ptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  /* the size of jlong (64-bit) is either the same as a long, or that of a long long.
+   * if it's the former, we use as is. */
+  if (sizeof (jlong) == sizeof (long))
+    {
+      mpz_set_si (_this, (signed long)n);
+    }
+  else
+    {
+      /* ...otherwise, we operate on the two halves of the long long, each half
+       * being 32-bit wide.  for simplicity, we work with positive
+       * values negating, if necessary, the final outcome.
+       */
+      const int isnegative = n < 0 ? 1 : 0;
+      if (isnegative)
+        {
+          n = -n;
+        }
+      mpz_set_ui (_this, (unsigned long)(((unsigned long long)n) >> 32));
+      mpz_mul_2exp (_this, _this, 32); /* shift left by 32 bits */
+      mpz_add_ui (_this, _this, (unsigned long)n);
+      if (isnegative)
+        {
+          mpz_neg (_this, _this);
+        }
+    }
+  TRACE("end");
+#else /* !defined(WITH_GNU_MP) */
+  (void) n;
+  (void) r;
+  throw_config_exception(env);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI. On exit, this will have the same
+ *           value as x.
+ * @param x  an instance of a NativeMPI's Pointer.
+ */
+JNIEXPORT void JNICALL
+Java_java_math_VMBigInteger_natFromBI(JNIEnv *env, jobject this,
+                                                   jobject x)
+{
+#if defined(WITH_GNU_MP)
+  mpz_ptr _this;
+  mpz_srcptr _x;
+
+  TRACE("begin");
+  _this = (mpz_ptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  _x = (mpz_srcptr)JCL_GetRawData (env, x);
+  mpz_set (_this, _x);
+  TRACE("end");
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  (void) x;
+  throw_config_exception(env);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI. On exit, this will have the value
+ *           represented by the v Java byte array (in 2's complement with most
+ *           significant byte at index position 0). The sign is implied by the
+ *           value of the most significant byte.
+ * @param v  a Java byte array containing the byte representation, in 2's
+ *           complement of the signed value to assign to this.
+ */
+JNIEXPORT void JNICALL
+Java_java_math_VMBigInteger_natFromByteArray(JNIEnv *env,
+                                                          jobject this,
+                                                          jbyteArray v)
+{
+#if defined(WITH_GNU_MP)
+  mpz_ptr _this;
+  jbyte *_v;
+  unsigned long b;
+  int vlength, isnegative, i;
+
+  TRACE("begin");
+  _this = (mpz_ptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  _v = (*env)->GetByteArrayElements (env, v, NULL);
+  vlength = (*env)->GetArrayLength (env, v);
+  b = (unsigned long)(_v[0] & 0xFF);
+  isnegative = (b > 0x7F) ? 1 : 0;
+  mpz_set_ui (_this, 0);
+  for (i = 0; i < vlength; i++)
+    {
+      mpz_mul_2exp (_this, _this, 8); /* shift left 8 positions. */
+      b = (unsigned long)(_v[i] & 0xFF);
+      b = (isnegative) ? ~b : b;
+      mpz_add_ui (_this, _this, (unsigned long)(b & 0xFF));
+    }
+  (*env)->ReleaseByteArrayElements (env, v, _v, JNI_ABORT);
+  if (isnegative)
+    {
+      mpz_add_ui (_this, _this, 1);
+      mpz_neg (_this, _this);
+    }
+  TRACE("end");
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  (void) v;
+  throw_config_exception(env);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI. On exit, this will have the value
+ *           represented by the s Java string.
+ * @param s  a Java string containing, a possibly signed, value to assign to
+ *           this.
+ * @param rdx  the base in which the symbols, in s, are represented.
+ * @return  0 if the entire string is a valid number in base rdx. Otherwise it
+ *          returns -1.
+ *
+ * Implementation note:
+ * While the GMP library is more tolerant in what it accepts as parameter values
+ * for conversions from strings, the BigInteger code, which calls this method,
+ * ensures that the contract described in the RI's documentation is respected;
+ * e.g. no white spaces in the middle, limited valid radix values, etc...
+ */
+JNIEXPORT jint JNICALL
+Java_java_math_VMBigInteger_natFromString(JNIEnv *env,
+                                                       jobject this, jstring s,
+                                                       jint rdx)
+{
+#if defined(WITH_GNU_MP)
+  mpz_ptr _this;
+  const char *_s;
+  int result;
+
+  TRACE("begin");
+  _this = (mpz_ptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  _s = (*env)->GetStringUTFChars (env, s, NULL);
+  result = mpz_set_str (_this, _s, (int)rdx);
+  JCL_free_cstring (env, s, _s);
+  TRACE("end");
+  return (result);
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  (void) s;
+  (void) rdx;
+  throw_config_exception(env);
+  return (-1);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI. On exit, this will have the value
+ *           represented by the m Java byte array (most significant byte at
+ *           index position 0). It will be positive, or negative, depending on
+ *           the value of isnegative.
+ * @param m  a Java byte array containing the byte representation of the
+ *           absolute value (most significant byte being at index position 0)
+ *           to assign to this.
+ * @param isnegative  true if this should be negative and false if it should
+ *           be positive.
+ */
+JNIEXPORT void JNICALL
+Java_java_math_VMBigInteger_natFromSignedMagnitude(JNIEnv *env,
+                                                                jobject this,
+                                                                jbyteArray m,
+                                                                jboolean isnegative)
+{
+#if defined(WITH_GNU_MP)
+  mpz_ptr _this;
+  jbyte *_m;
+  int mlength, i;
+
+  TRACE("begin");
+  _this = (mpz_ptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  _m = (*env)->GetByteArrayElements (env, m, NULL);
+  mlength = (*env)->GetArrayLength (env, m);
+  mpz_set_ui (_this, 0);
+  for (i = 0; i < mlength; i++)
+    {
+      mpz_mul_2exp (_this, _this, 8);
+      mpz_add_ui (_this, _this, (unsigned long)(_m[i] & 0xFF));
+    }
+  (*env)->ReleaseByteArrayElements (env, m, _m, JNI_ABORT);
+  if (isnegative == JNI_TRUE)
+    {
+      mpz_neg (_this, _this);
+    }
+  TRACE("end");
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  (void) m;
+  (void) isnegative;
+  throw_config_exception(env);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI.
+ * @param n  the base in which to represent this.
+ * @return  the Java string representing the value of this in base n.
+ */
+JNIEXPORT jstring JNICALL
+Java_java_math_VMBigInteger_natToString(JNIEnv *env, jobject this,
+                                                     jint n)
+{
+#if defined(WITH_GNU_MP)
+  mpz_srcptr _this;
+  char *cstr;
+  jstring result;
+
+  TRACE("begin");
+  _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  cstr = mpz_get_str (NULL, (int)n, _this);
+  result  = (*env)->NewStringUTF (env, cstr);
+  free (cstr);
+  TRACE("end");
+  return (result);
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  (void) n;
+  throw_config_exception(env);
+  return (NULL);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  a non-ZERO instance of NativeMPI.
+ *
+ * output:
+ * @param r  a Java byte array which shall contain the byte representation of
+ *           this.
+ */
+JNIEXPORT void JNICALL
+Java_java_math_VMBigInteger_natToByteArray(JNIEnv *env,
+                                                        jobject this,
+                                                        jbyteArray r)
+{
+#if defined(WITH_GNU_MP)
+  mpz_srcptr _this;
+  mpz_t _w;  /* a temporary work mpi */
+  jbyte *_r;
+  int rlength, sign, i;
+  unsigned long b;
+
+  TRACE("begin");
+  _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  _r = (*env)->GetByteArrayElements (env, r, NULL);
+  rlength = (*env)->GetArrayLength (env, r);
+  mpz_init (_w);
+  /* if this is negative set w to its 2's complement otherwise use as is. */
+  sign = mpz_sgn (_this);
+  if (sign == 1)
+    {
+      mpz_set (_w, _this);
+    }
+  else
+    {
+      mpz_neg (_w, _this);
+      mpz_sub_ui (_w, _w, 1);
+    }
+  /* _w SHOULD be >= 0.
+   * start filling the array starting from the least significant byte. */
+  for (i = rlength; --i >= 0; )
+    {
+      b = mpz_tdiv_q_ui (_w, _w, 256);
+      b = (sign == -1) ? ~b : b;
+      _r[i] = (unsigned long)(b & 0xFF);
+    }
+  (*env)->ReleaseByteArrayElements (env, r, _r, JNI_COMMIT);
+  /* if _w > 0 the byte array was short. */
+  if (mpz_cmp_ui (_w, 0) > 0)
+    {
+      TRACE("WARNING: byte array is too short");
+    }
+  mpz_clear (_w);
+  TRACE("end");
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  (void) r;
+  throw_config_exception(env);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI.
+ * @return  the "int" value (least significant 32 bits) of the absolute value
+ *          of this NativeMPI. The calling code MUST handle the sign. We do
+ *          this so we can use the same method when computing the "long" value
+ *          as well.
+ */
+JNIEXPORT jint JNICALL
+Java_java_math_VMBigInteger_natAbsIntValue(JNIEnv *env,
+                                                        jobject this)
+{
+#if defined(WITH_GNU_MP)
+  mpz_srcptr _this;
+
+  TRACE("begin");
+  _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  TRACE("end");
+  return ((jint)mpz_get_ui (_this));
+#else /* !defined(WITH_GNU_MP) */
+  (void) s;
+  throw_config_exception(env);
+  return (-1);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI.
+ * @return  the, eventually truncated, double value of this NativeMPI.
+ */
+JNIEXPORT jdouble JNICALL
+Java_java_math_VMBigInteger_natDoubleValue(JNIEnv *env,
+                                                        jobject this)
+{
+#if defined(WITH_GNU_MP)
+  mpz_srcptr _this;
+
+  TRACE("begin");
+  _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  TRACE("end");
+  return ((jdouble)mpz_get_d (_this));
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  throw_config_exception(env);
+  return (0.0);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  a NativeMPI instance.
+ * @param x  an instance of NativeMPI's Pointer.
+ * @return  -1, 0, +1 if x is respectively less than, equal to, or greater
+ *          than y.
+ */
+JNIEXPORT jint JNICALL
+Java_java_math_VMBigInteger_natCompare(JNIEnv *env, jobject this,
+                                                    jobject x)
+{
+#if defined(WITH_GNU_MP)
+  mpz_ptr _this, _x;
+  int res;
+
+  TRACE("begin");
+  _this = (mpz_ptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  _x = (mpz_ptr)JCL_GetRawData (env, x);
+  res = mpz_cmp (_this, _x);
+  TRACE("end");
+  if (res == 0)
+    return ((jint)0);
+  else if (res < 0)
+    return ((jint)-1);
+  else
+    return ((jint)1);
+#else /* !defined(WITH_GNU_MP) */
+  (void) x;
+  (void) y;
+  throw_config_exception(env);
+  return (0);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI.
+ * @param x  an instance of NativeMPI's Pointer.
+ *
+ * output:
+ * @param r  a NativeMPI's Pointer such that r = this + x.
+ */
+JNIEXPORT void JNICALL
+Java_java_math_VMBigInteger_natAdd(JNIEnv *env, jobject this,
+                                                jobject x, jobject r)
+{
+#if defined(WITH_GNU_MP)
+  mpz_srcptr _this, _x;
+  mpz_ptr _r;
+
+  TRACE("begin");
+  _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  _x = (mpz_srcptr)JCL_GetRawData (env, x);
+  _r = (mpz_ptr)JCL_GetRawData (env, r);
+  mpz_add (_r, _this, _x);
+  TRACE("end");
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  (void) x;
+  (void) r;
+  throw_config_exception(env);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI.
+ * @param x  an instance of NativeMPI's Pointer.
+ *
+ * output:
+ * @param r  a NativeMPI's Pointer such that r = this - x.
+ */
+JNIEXPORT void JNICALL
+Java_java_math_VMBigInteger_natSubtract(JNIEnv *env, jobject this,
+                                                     jobject x, jobject r)
+{
+#if defined(WITH_GNU_MP)
+  mpz_srcptr _this, _x;
+  mpz_ptr _r;
+
+  TRACE("begin");
+  _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  _x = (mpz_srcptr)JCL_GetRawData (env, x);
+  _r = (mpz_ptr)JCL_GetRawData (env, r);
+  mpz_sub (_r, _this, _x);
+  TRACE("end");
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  (void) x;
+  (void) r;
+  throw_config_exception(env);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI.
+ * @param x  an instance of NativeMPI's Pointer.
+ *
+ * output:
+ * @param r  a NativeMPI's Pointer such that r = this * x.
+ */
+JNIEXPORT void JNICALL
+Java_java_math_VMBigInteger_natMultiply(JNIEnv *env, jobject this,
+                                                     jobject x, jobject r)
+{
+#if defined(WITH_GNU_MP)
+  mpz_srcptr _this, _x;
+  mpz_ptr _r;
+
+  TRACE("begin");
+  _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  _x = (mpz_srcptr)JCL_GetRawData (env, x);
+  _r = (mpz_ptr)JCL_GetRawData (env, r);
+  mpz_mul (_r, _this, _x);
+  TRACE("end");
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  (void) x;
+  (void) r;
+  throw_config_exception(env);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI.
+ * @param x  an instance of NativeMPI's Pointer.
+ *
+ * output:
+ * @param r  a NativeMPI's Pointer such that r = this div x.
+ */
+JNIEXPORT void JNICALL
+Java_java_math_VMBigInteger_natQuotient(JNIEnv *env, jobject this,
+                                                     jobject x, jobject r)
+{
+#if defined(WITH_GNU_MP)
+  mpz_srcptr _this, _x;
+  mpz_ptr _r;
+
+  TRACE("begin");
+  _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  _x = (mpz_srcptr)JCL_GetRawData (env, x);
+  _r = (mpz_ptr)JCL_GetRawData (env, r);
+  mpz_tdiv_q (_r, _this, _x);
+  TRACE("end");
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  (void) x;
+  (void) r;
+  throw_config_exception(env);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI.
+ * @param x  an instance of NativeMPI's Pointer.
+ *
+ * output:
+ * @param r  a NativeMPI's Pointer such that r = this mod x.
+ */
+JNIEXPORT void JNICALL
+Java_java_math_VMBigInteger_natRemainder(JNIEnv *env, jobject this,
+                                                      jobject x, jobject r)
+{
+#if defined(WITH_GNU_MP)
+  mpz_srcptr _this, _x;
+  mpz_ptr _r;
+
+  TRACE("begin");
+  _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  _x = (mpz_srcptr)JCL_GetRawData (env, x);
+  _r = (mpz_ptr)JCL_GetRawData (env, r);
+  mpz_tdiv_r (_r, _this, _x);
+  TRACE("end");
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  (void) x;
+  (void) r;
+  throw_config_exception(env);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI.
+ * @param x  an instance of NativeMPI's Pointer.
+ *
+ * output:
+ * @param q  a NativeMPI's Pointer such that q = this div x.
+ * @param r  a NativeMPI's Pointer such that r = this mod x.
+ */
+JNIEXPORT void JNICALL
+Java_java_math_VMBigInteger_natQuotientAndRemainder(JNIEnv *env,
+                                                                 jobject this,
+                                                                 jobject x,
+                                                                 jobject q,
+                                                                 jobject r)
+{
+#if defined(WITH_GNU_MP)
+  mpz_srcptr _this, _x;
+  mpz_ptr _q, _r;
+
+  TRACE("begin");
+  _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  _x = (mpz_srcptr)JCL_GetRawData (env, x);
+  _q = (mpz_ptr)JCL_GetRawData (env, q);
+  _r = (mpz_ptr)JCL_GetRawData (env, r);
+  mpz_tdiv_qr (_q, _r, _this, _x);
+  TRACE("end");
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  (void) x;
+  (void) q;
+  (void) r;
+  throw_config_exception(env);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI.
+ * @param x  an instance of NativeMPI's Pointer.
+ *
+ * output:
+ * @param r  a NativeMPI's Pointer such that r = this mod x.
+ */
+JNIEXPORT void JNICALL
+Java_java_math_VMBigInteger_natModulo(JNIEnv *env, jobject this,
+                                                   jobject x, jobject r)
+{
+#if defined(WITH_GNU_MP)
+  mpz_srcptr _this, _x;
+  mpz_ptr _r;
+
+  TRACE("begin");
+  _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  _x = (mpz_srcptr)JCL_GetRawData (env, x);
+  _r = (mpz_ptr)JCL_GetRawData (env, r);
+  mpz_mod (_r, _this, _x);
+  TRACE("end");
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  (void) x;
+  (void) r;
+  throw_config_exception(env);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI.
+ * @param n  a non-negative number to raise this to.
+ *
+ * output:
+ * @param r  a NativeMPI's Pointer such that r = this ** n.
+ */
+JNIEXPORT void JNICALL
+Java_java_math_VMBigInteger_natPow(JNIEnv *env, jobject this,
+                                                jint n, jobject r)
+{
+#if defined(WITH_GNU_MP)
+  mpz_srcptr _this;
+  mpz_ptr _r;
+
+  TRACE("begin");
+  _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  _r = (mpz_ptr)JCL_GetRawData (env, r);
+  mpz_pow_ui (_r, _this, (unsigned long)n);
+  TRACE("end");
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  (void) n;
+  (void) r;
+  throw_config_exception(env);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI.
+ * @param e  an instance of NativeMPI's Pointer.
+ * @param m  another instance of NativeMPI's Pointer.
+ *
+ * output:
+ * @param r  a NativeMPI's Pointer such that r = (this**e) mod m.
+ *
+ * @throws java.lang.ArithmeticException if e is negative and (1 / this) mod m
+ *         has no multiplicative inverse.
+ */
+JNIEXPORT void JNICALL
+Java_java_math_VMBigInteger_natModPow(JNIEnv *env, jobject this,
+                                                   jobject e, jobject m,
+                                                   jobject r)
+{
+#if defined(WITH_GNU_MP)
+  mpz_srcptr _this, _e, _m;
+  mpz_ptr _r;
+
+  TRACE("begin");
+  _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  _e = (mpz_srcptr)JCL_GetRawData (env, e);
+  _m = (mpz_srcptr)JCL_GetRawData (env, m);
+  _r = (mpz_ptr)JCL_GetRawData (env, r);
+  /* the documentation of mpz_powm(rop, b, e, m) states that it: "Set rop to
+   * (b raised to e) modulo m.  Negative e is supported if an inverse b^-1 mod m
+   * exists.... If an inverse doesn't exist then a divide by zero is raised."
+   * to work around this case we use the same code as in the pure java class;
+   * i.e.:
+   *     if (e.isNegative())
+   *       return this.modInverse(m).modPow(e.negate(), m); */
+  if (mpz_sgn (_e) == -1)
+    {
+      mpz_t _w;  /* a temporary work mpi */
+      const int res = mpz_invert (_r, _this, _m);
+      if (res == 0)
+        {
+          JCL_ThrowException (env, "java/lang/ArithmeticException",
+                              "No multiplicative inverse modulo the designated number exists");
+        }
+      mpz_init (_w);
+      mpz_neg (_w, _e);
+      mpz_powm (_r, _r, _w, _m);
+      mpz_clear (_w);
+    }
+  else
+    {
+      mpz_powm (_r, _this, _e, _m);
+    }
+
+  while (mpz_sgn (_r) == -1)
+    {
+      mpz_add (_r, _r, _m);
+    }
+  TRACE("end");
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  (void) e;
+  (void) m;
+  (void) r;
+  throw_config_exception(env);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI.
+ * @param m  an instance of NativeMPI's Pointer.
+ *
+ * output:
+ * @param r  a NativeMPI's Pointer such that r = (1 / this) mod m.
+ * @throws java.lang.ArithmeticException if (1 / this) mod m has no
+ *         multiplicative inverse.
+ */
+JNIEXPORT void JNICALL
+Java_java_math_VMBigInteger_natModInverse(JNIEnv *env,
+                                                       jobject this,
+                                                       jobject m, jobject r)
+{
+#if defined(WITH_GNU_MP)
+  mpz_srcptr _this, _m;
+  mpz_ptr _r;
+  int res;
+
+  TRACE("begin");
+  _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  _m = (mpz_srcptr)JCL_GetRawData (env, m);
+  _r = (mpz_ptr)JCL_GetRawData (env, r);
+  res = mpz_invert (_r, _this, _m);
+  if (res == 0)
+    {
+      JCL_ThrowException (env, "java/lang/ArithmeticException",
+                          "No multiplicative inverse modulo the designated number exists");
+    }
+
+  while (mpz_sgn (_r) == -1)
+    {
+      mpz_add (_r, _r, _m);
+    }
+  TRACE("end");
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  (void) x;
+  (void) r;
+  throw_config_exception(env);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI.
+ * @param x  an instance of NativeMPI's Pointer.
+ *
+ * output:
+ * @param r  a NativeMPI's Pointer such that r is the GCD of this and x.
+ */
+JNIEXPORT void JNICALL
+Java_java_math_VMBigInteger_natGCD(JNIEnv *env, jobject this,
+                                                jobject x, jobject r)
+{
+#if defined(WITH_GNU_MP)
+  mpz_srcptr _this, _x;
+  mpz_ptr _r;
+
+  TRACE("begin");
+  _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  _x = (mpz_srcptr)JCL_GetRawData (env, x);
+  _r = (mpz_ptr)JCL_GetRawData (env, r);
+  mpz_gcd (_r, _this, _x);
+  TRACE("end");
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  (void) x;
+  (void) r;
+  throw_config_exception(env);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI.
+ * @param n  number of Miller-Rabin tests to conduct.
+ * @return  2 if this is definitely prime. Returns 1 if this is probably prime
+ *          (without being certain). Finally, returns 0 if this is definitely
+ *          composite.
+ */
+JNIEXPORT jint JNICALL
+Java_java_math_VMBigInteger_natTestPrimality(JNIEnv *env,
+                                                          jobject this, jint n)
+{
+#if defined(WITH_GNU_MP)
+  mpz_srcptr _this;
+
+  TRACE("begin");
+  _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  TRACE("end");
+  return ((jint)mpz_probab_prime_p (_this, (int)n));
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  (void) n;
+  throw_config_exception(env);
+  return (0);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI.
+ * @param n  the non-negative number of positions to shift right this by.
+ *
+ * output:
+ * @param r  a NativeMPI's Pointer such that r = this * 2**n.
+ */
+JNIEXPORT void JNICALL
+Java_java_math_VMBigInteger_natShiftLeft(JNIEnv *env, jobject this,
+                                                      jint n, jobject r)
+{
+#if defined(WITH_GNU_MP)
+  mpz_srcptr _this;
+  mpz_ptr _r;
+
+  TRACE("begin");
+  _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  _r = (mpz_ptr)JCL_GetRawData (env, r);
+  mpz_mul_2exp (_r, _this, (unsigned long)n);
+  TRACE("end");
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  (void) n;
+  (void) r;
+  throw_config_exception(env);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI.
+ * @param n  the non-negative number of positions to shift left this by.
+ *
+ * output:
+ * @param r  a NativeMPI's Pointer such that r = floor(this / 2**n).
+ */
+JNIEXPORT void JNICALL
+Java_java_math_VMBigInteger_natShiftRight(JNIEnv *env,
+                                                       jobject this, jint n,
+                                                       jobject r)
+{
+#if defined(WITH_GNU_MP)
+  mpz_srcptr _this;
+  mpz_ptr _r;
+
+  TRACE("begin");
+  _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  _r = (mpz_ptr)JCL_GetRawData (env, r);
+  mpz_fdiv_q_2exp (_r, _this, (unsigned long)n);
+  TRACE("end");
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  (void) n;
+  (void) r;
+  throw_config_exception(env);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI.
+ * @return  the 0-based index of the lowest significant bit set (to 1) in this.
+ */
+JNIEXPORT jint JNICALL
+Java_java_math_VMBigInteger_natLowestSetBit(JNIEnv *env,
+                                                         jobject this)
+{
+#if defined(WITH_GNU_MP)
+  mpz_srcptr _this;
+
+  TRACE("begin");
+  _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  TRACE("end");
+  return ((jint)mpz_scan1 (_this, 0));
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  throw_config_exception(env);
+  return (-1);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI.
+ *
+ * output:
+ * @param r  a NativeMPI's Pointer such that r = abs(x).
+ */
+JNIEXPORT void JNICALL
+Java_java_math_VMBigInteger_natAbs(JNIEnv *env, jobject this,
+                                                jobject r)
+{
+#if defined(WITH_GNU_MP)
+  mpz_srcptr _this;
+  mpz_ptr _r;
+
+  TRACE("begin");
+  _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  _r = (mpz_ptr)JCL_GetRawData (env, r);
+  mpz_abs (_r, _this);
+  TRACE("end");
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  (void) r;
+  throw_config_exception(env);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI.
+ *
+ * output:
+ * @param r  a NativeMPI's Pointer such that r = -x.
+ */
+JNIEXPORT void JNICALL
+Java_java_math_VMBigInteger_natNegate(JNIEnv *env, jobject this,
+                                                   jobject r)
+{
+#if defined(WITH_GNU_MP)
+  mpz_srcptr _this;
+  mpz_ptr _r;
+
+  TRACE("begin");
+  _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  _r = (mpz_ptr)JCL_GetRawData (env, r);
+  mpz_neg (_r, _this);
+  TRACE("end");
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  (void) r;
+  throw_config_exception(env);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI.
+ * @return  the number of bits needed to represent this.
+ */
+JNIEXPORT jint JNICALL
+Java_java_math_VMBigInteger_natBitLength(JNIEnv *env, jobject this)
+{
+#if defined(WITH_GNU_MP)
+  mpz_srcptr _this;
+
+  TRACE("begin");
+  _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  TRACE("end");
+  return ((jint)mpz_sizeinbase (_this, 2));
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  throw_config_exception(env);
+  return (-1);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI. It MUST be >= ZERO.
+ * @return  the number of bits set (to 1) in this.
+ */
+JNIEXPORT jint JNICALL
+Java_java_math_VMBigInteger_natSetBitCount(JNIEnv *env,
+                                                        jobject this)
+{
+#if defined(WITH_GNU_MP)
+  mpz_srcptr _this;
+  mpz_ptr _bi;
+  unsigned long res;
+
+  TRACE("begin");
+  _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  switch (mpz_sgn (_this))
+    {
+      case -1:
+        /* initialize --GMP sets the value to zero. */
+        _bi = (mpz_ptr)JCL_malloc (env, sizeof (mpz_t));
+        mpz_init (_bi);
+        mpz_neg (_bi, _this);
+        res = mpz_popcount (_bi);
+        mpz_clear (_bi);
+        free (_bi);
+        break;
+      case 0:
+        res = 0;
+        break;
+      case 1:
+        res = mpz_popcount (_this);
+      default:
+        JCL_ThrowException (env, "java/lang/Error",
+                            "Unexpected sign value for a native MPI");
+    }
+  TRACE("end");
+  return ((jint)res);
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  throw_config_exception(env);
+  return (ULONG_MAX);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI.
+ * @param x  an instance of NativeMPI's Pointer.
+ *
+ * output:
+ * @param r  a NativeMPI's Pointer such that r = this ^ x.
+ */
+JNIEXPORT void JNICALL
+Java_java_math_VMBigInteger_natXor(JNIEnv *env, jobject this,
+                                                jobject x, jobject r)
+{
+#if defined(WITH_GNU_MP)
+  mpz_srcptr _this, _x;
+  mpz_ptr _r;
+
+  TRACE("begin");
+  _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  _x = (mpz_srcptr)JCL_GetRawData (env, x);
+  _r = (mpz_ptr)JCL_GetRawData (env, r);
+  mpz_xor (_r, _this, _x);
+  TRACE("end");
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  (void) x;
+  (void) r;
+  throw_config_exception(env);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI.
+ * @param x  an instance of NativeMPI's Pointer.
+ *
+ * output:
+ * @param r  a NativeMPI's Pointer such that r = this | x.
+ */
+JNIEXPORT void JNICALL
+Java_java_math_VMBigInteger_natOr(JNIEnv *env, jobject this,
+                                               jobject x, jobject r)
+{
+#if defined(WITH_GNU_MP)
+  mpz_srcptr _this, _x;
+  mpz_ptr _r;
+
+  TRACE("begin");
+  _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  _x = (mpz_srcptr)JCL_GetRawData (env, x);
+  _r = (mpz_ptr)JCL_GetRawData (env, r);
+  mpz_ior (_r, _this, _x);
+  TRACE("end");
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  (void) x;
+  (void) r;
+  throw_config_exception(env);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI.
+ * @param x  an instance of NativeMPI's Pointer.
+ *
+ * output:
+ * @param r  a NativeMPI's Pointer such that r = this & x.
+ */
+JNIEXPORT void JNICALL
+Java_java_math_VMBigInteger_natAnd(JNIEnv *env, jobject this,
+                                                jobject x, jobject r)
+{
+#if defined(WITH_GNU_MP)
+  mpz_srcptr _this, _x;
+  mpz_ptr _r;
+
+  TRACE("begin");
+  _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  _x = (mpz_srcptr)JCL_GetRawData (env, x);
+  _r = (mpz_ptr)JCL_GetRawData (env, r);
+  mpz_and (_r, _this, _x);
+  TRACE("end");
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  (void) x;
+  (void) r;
+  throw_config_exception(env);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI.
+ * @param x  an instance of NativeMPI's Pointer.
+ *
+ * output:
+ * @param r  a NativeMPI's Pointer such that r = this & ~x.
+ */
+JNIEXPORT void JNICALL
+Java_java_math_VMBigInteger_natAndNot(JNIEnv *env, jobject this,
+                                                   jobject x, jobject r)
+{
+#if defined(WITH_GNU_MP)
+  mpz_srcptr _this, _x;
+  mpz_ptr _r;
+
+  TRACE("begin");
+  _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  _x = (mpz_srcptr)JCL_GetRawData (env, x);
+  _r = (mpz_ptr)JCL_GetRawData (env, r);
+  mpz_com (_r, _x);
+  mpz_and (_r, _this, _r);
+  TRACE("end");
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  (void) x;
+  (void) r;
+  throw_config_exception(env);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI.
+ * @param n  the 0-based index position of the bit to flip in this. n MUST be
+ *           greater than, or equal to 0.
+ *
+ * output:
+ * @param r  a copy of this NativeMPI's Pointer with its n-th bit flipped.
+ */
+JNIEXPORT void JNICALL
+Java_java_math_VMBigInteger_natFlipBit(JNIEnv *env, jobject this,
+                                                    jint n, jobject r)
+{
+#if defined(WITH_GNU_MP)
+  mpz_srcptr _this;
+  mpz_ptr _r;
+
+  TRACE("begin");
+  _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  _r = (mpz_ptr)JCL_GetRawData (env, r);
+  mpz_set (_r, _this);
+  /* GNU MP versions earlier than 4.2 do not define this method:
+   *   mpz_combit (_r, (unsigned long)n); */
+  if (mpz_tstbit (_r, (unsigned long)n) == 1)
+    {
+      mpz_clrbit (_r, (unsigned long)n);
+    }
+  else
+    {
+      mpz_setbit (_r, (unsigned long)n);
+    }
+  TRACE("end");
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  (void) n;
+  (void) r;
+  throw_config_exception(env);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI.
+ * @param n  the 0-based index position of the bit to test in this. n MUST be
+ *           greater than, or equal to 0.
+ * @return  +1, or -1 depending on whether the n-th bit in this is set or not
+ *          respectively.
+ */
+JNIEXPORT jint JNICALL
+Java_java_math_VMBigInteger_natTestBit(JNIEnv *env, jobject this,
+                                                    jint n)
+{
+#if defined(WITH_GNU_MP)
+  mpz_srcptr _this;
+
+  TRACE("begin");
+  _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  TRACE("end");
+  return ((jint)mpz_tstbit (_this, (unsigned long)n));
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  (void) n;
+  throw_config_exception(env);
+  return (-1);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI.
+ * @param n  the 0-based index position of the bit to set, or clear, in this.
+ *           n MUST be greater than, or equal to 0.
+ * @param setIt  if true, then the n-th bit in this will be set, otherwise it
+ *           will be cleared.
+ *
+ * output:
+ * @param r  a copy of this NativeMPI's Pointer with its n-th bit set or cleared
+ *           as requested.
+ */
+JNIEXPORT void JNICALL
+Java_java_math_VMBigInteger_natSetBit(JNIEnv *env, jobject this,
+                                                   jint n, jboolean setIt,
+                                                   jobject r)
+{
+#if defined(WITH_GNU_MP)
+  mpz_srcptr _this;
+  mpz_ptr _r;
+
+  TRACE("begin");
+  _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  _r = (mpz_ptr)JCL_GetRawData (env, r);
+  mpz_set (_r, _this);
+  if (setIt == JNI_TRUE)
+    {
+      mpz_setbit (_r, (unsigned long)n);
+    }
+  else
+    {
+      mpz_clrbit (_r, (unsigned long)n);
+    }
+  TRACE("end");
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  (void) n;
+  (void) setIt;
+  (void) r;
+  throw_config_exception(env);
+#endif /* defined(WITH_GNU_MP) */
+}
+
+/*
+ * @param this  an instance of NativeMPI.
+ *
+ * output:
+ * @param r  a NativeMPI's Pointer such that r = ~this.
+ */
+JNIEXPORT void JNICALL
+Java_java_math_VMBigInteger_natNot(JNIEnv *env, jobject this,
+                                                jobject r)
+{
+#if defined(WITH_GNU_MP)
+  mpz_srcptr _this;
+  mpz_ptr _r;
+
+  TRACE("begin");
+  _this = (mpz_srcptr)JCL_GetRawData (env, (*env)->GetObjectField (env, this, native_ptr));
+  _r = (mpz_ptr)JCL_GetRawData (env, r);
+  mpz_com (_r, _this);
+  TRACE("end");
+#else /* !defined(WITH_GNU_MP) */
+  (void) this;
+  (void) r;
+  throw_config_exception(env);
+#endif /* defined(WITH_GNU_MP) */
+}