[kaffe] CVS kaffe (robilad): Warning fix for Biginteger
Kaffe CVS
cvs-commits at kaffe.org
Thu Aug 11 15:22:38 PDT 2005
PatchSet 6813
Date: 2005/08/11 22:07:49
Author: robilad
Branch: HEAD
Tag: (none)
Log:
Warning fix for Biginteger
2005-08-11 Andreas Tobler <a.tobler at schweiz.ch>
* libraries/clib/math/BigInteger.c
(Java_java_math_BigInteger_assignString0): Add return value to fix
compiler warnings.
Members:
ChangeLog:1.4338->1.4339
libraries/clib/math/BigInteger.c:INITIAL->1.26
po/de.po:1.2->1.3
po/fr.po:1.17->1.18
po/kaffe.pot:1.14->1.15
po/zh_CN.po:1.4->1.5
po/zh_TW.po:1.20->1.21
Index: kaffe/ChangeLog
diff -u kaffe/ChangeLog:1.4338 kaffe/ChangeLog:1.4339
--- kaffe/ChangeLog:1.4338 Thu Aug 11 01:18:40 2005
+++ kaffe/ChangeLog Thu Aug 11 22:07:49 2005
@@ -1,3 +1,9 @@
+2005-08-11 Andreas Tobler <a.tobler at schweiz.ch>
+
+ * libraries/clib/math/BigInteger.c
+ (Java_java_math_BigInteger_assignString0): Add return value to fix
+ compiler warnings.
+
2005-08-10 Dalibor Topic <robilad at kaffe.org>
Resynced with GNU Classpath.
===================================================================
Checking out kaffe/libraries/clib/math/BigInteger.c
RCS: /home/cvs/kaffe/kaffe/libraries/clib/math/BigInteger.c,v
VERS: 1.26
***************
--- /dev/null Sun Aug 4 19:57:58 2002
+++ kaffe/libraries/clib/math/BigInteger.c Thu Aug 11 22:22:37 2005
@@ -0,0 +1,783 @@
+/*
+ * java.math.BigInteger.c
+ *
+ * Copyright (c) 1996, 1997, 1998
+ * Transvirtual Technologies, Inc. All rights reserved.
+ *
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file.
+ */
+
+#include <stdio.h>
+
+#include "config.h"
+#include "java_math_BigInteger.h"
+
+#if defined(HAVE_GMP_H) && defined(USE_GMP)
+
+#include <gmp.h>
+#include <stdlib.h>
+
+#include "kaffe/jmalloc.h"
+
+static jfieldID number;
+
+static void *
+bi_alloc(size_t size)
+{
+ void *p = KMALLOC(size);
+ return (p);
+}
+
+static void *
+/* ARGUSED */
+bi_realloc(void *ptr, size_t UNUSED old_size, size_t new_size)
+{
+ void *p = KREALLOC(ptr, new_size);
+ return (p);
+}
+
+static void
+/* ARGUSED */
+bi_free(void *ptr, size_t UNUSED size)
+{
+ KFREE(ptr);
+}
+
+void
+Java_java_math_BigInteger_initialize0(JNIEnv* env, jclass cls)
+{
+ number = (*env)->GetFieldID(env, cls, "number", "kaffe.util.Ptr");
+ mp_set_memory_functions (bi_alloc, bi_realloc, bi_free);
+}
+
+void
+Java_java_math_BigInteger_init0(JNIEnv* env, jobject r)
+{
+ mpz_ptr res;
+
+ res = (mpz_ptr)bi_alloc(sizeof(mpz_t));
+ mpz_init(res);
+
+ (*env)->SetObjectField(env, r, number, (jobject)res);
+}
+
+void
+Java_java_math_BigInteger_finalize0(JNIEnv* env, jobject r)
+{
+ mpz_ptr res;
+
+ res = (*env)->GetObjectField(env, r, number);
+
+ mpz_clear(res);
+ bi_free(res, sizeof(mpz_t));
+}
+
+void
+Java_java_math_BigInteger_assignLong0(JNIEnv* env, jobject r, jlong v)
+{
+ mpz_ptr res;
+ int negative = v < 0 ? -1 : 0;
+
+ res = (*env)->GetObjectField(env, r, number);
+
+ if (negative)
+ v = -v;
+ /* Note that v will remain negative if it's LONG_LONG_MIN.
+ This is not a problem because any sign copying in the right
+ shift will be stripped with the cast to jint, and the
+ number will be considered positive. Furthermore, in this
+ case, (jint)v will be zero, so the addition will be a
+ do-nothing operation. At last, the number will be made
+ negative, as appropriate. */
+ mpz_set_ui(res, (unsigned long)(jint)(v >> 32));
+ mpz_mul_2exp(res, res, 32);
+ mpz_add_ui(res, res, (unsigned long)(jint)v);
+ if (negative)
+ mpz_neg(res, res);
+}
+
+void
+Java_java_math_BigInteger_assignBytes0(JNIEnv* env, jobject r, jint sign, jbyteArray magnitude)
+{
+ mpz_ptr res;
+ jbyte* data;
+ int i;
+ int len;
+
+ res = (*env)->GetObjectField(env, r, number);
+
+ len = (*env)->GetArrayLength(env, magnitude);
+ data = (*env)->GetByteArrayElements(env, magnitude, NULL);
+
+ /* clear mpz by setting it to zero; do not use mpz_clear here
+ * cause that would free its storage which is wrong.
+ */
+ mpz_set_ui(res, 0);
+ for (i = 0; i < len; i++) {
+ mpz_mul_ui(res, res, (unsigned long)256);
+ mpz_add_ui(res, res, (unsigned long)(data[i] & 0xFF));
+ }
+
+ (*env)->ReleaseByteArrayElements(env, magnitude, data, JNI_ABORT);
+
+ if (sign == -1) {
+ mpz_neg(res, res);
+ }
+}
+
+/**
+ * Parse a string with given radix and assign its value to a BigInteger object.
+ *
+ * @param env JNI environment
+ * @param r this BigInteger object
+ * @param val Java string value to assign
+ * @param radix radix of string value
+ *
+ * @return 0 if the string can be parsed and assigned. If anything fails, return -1.
+ */
+jint
+Java_java_math_BigInteger_assignString0(JNIEnv* env, jobject r, jstring val, jint radix)
+{
+ mpz_ptr res;
+ const jbyte* str;
+ int rc;
+
+ res = (*env)->GetObjectField(env, r, number);
+ str = (*env)->GetStringUTFChars(env, val, NULL);
+
+ rc = mpz_set_str(res, (char*)str, (int)radix);
+
+ (*env)->ReleaseStringUTFChars(env, val, str);
+
+ return rc;
+}
+
+void
+Java_java_math_BigInteger_add0(JNIEnv* env, jobject r, jobject s1, jobject s2)
+{
+ mpz_ptr res;
+ mpz_srcptr src1;
+ mpz_srcptr src2;
+
+ src1 = (mpz_srcptr)(*env)->GetObjectField(env, s1, number);
+ src2 = (mpz_srcptr)(*env)->GetObjectField(env, s2, number);
+ res = (mpz_ptr)(*env)->GetObjectField(env, r, number);
+
+ mpz_add(res, src1, src2);
+}
+
+void
+Java_java_math_BigInteger_sub0(JNIEnv* env, jobject r, jobject s1, jobject s2)
+{
+ mpz_ptr res;
+ mpz_srcptr src1;
+ mpz_srcptr src2;
+
+ src1 = (mpz_srcptr)(*env)->GetObjectField(env, s1, number);
+ src2 = (mpz_srcptr)(*env)->GetObjectField(env, s2, number);
+ res = (mpz_ptr)(*env)->GetObjectField(env, r, number);
+
+ mpz_sub(res, src1, src2);
+}
+
+void
+Java_java_math_BigInteger_mul0(JNIEnv* env, jobject r, jobject s1, jobject s2)
+{
+ mpz_ptr res;
+ mpz_srcptr src1;
+ mpz_srcptr src2;
+
+ src1 = (mpz_srcptr)(*env)->GetObjectField(env, s1, number);
+ src2 = (mpz_srcptr)(*env)->GetObjectField(env, s2, number);
+ res = (mpz_ptr)(*env)->GetObjectField(env, r, number);
+
+ mpz_mul(res, src1, src2);
+}
+
+void
+Java_java_math_BigInteger_div0(JNIEnv* env, jobject r, jobject s1, jobject s2)
+{
+ mpz_ptr res;
+ mpz_srcptr src1;
+ mpz_srcptr src2;
+
+ src1 = (mpz_srcptr)(*env)->GetObjectField(env, s1, number);
+ src2 = (mpz_srcptr)(*env)->GetObjectField(env, s2, number);
+ res = (mpz_ptr)(*env)->GetObjectField(env, r, number);
+
+ mpz_tdiv_q(res, src1, src2);
+}
+
+void
+Java_java_math_BigInteger_rem0(JNIEnv* env, jobject r, jobject s1, jobject s2)
+{
+ mpz_ptr res;
+ mpz_srcptr src1;
+ mpz_srcptr src2;
+
+ src1 = (mpz_srcptr)(*env)->GetObjectField(env, s1, number);
+ src2 = (mpz_srcptr)(*env)->GetObjectField(env, s2, number);
+ res = (mpz_ptr)(*env)->GetObjectField(env, r, number);
+
+ mpz_tdiv_r(res, src1, src2);
+}
+
+void
+Java_java_math_BigInteger_divrem0(JNIEnv* env, jclass UNUSED cls, jobject r1, jobject r2, jobject s1, jobject s2)
+{
+ mpz_ptr res1;
+ mpz_ptr res2;
+ mpz_srcptr src1;
+ mpz_srcptr src2;
+
+ src1 = (mpz_srcptr)(*env)->GetObjectField(env, s1, number);
+ src2 = (mpz_srcptr)(*env)->GetObjectField(env, s2, number);
+ res1 = (mpz_ptr)(*env)->GetObjectField(env, r1, number);
+ res2 = (mpz_ptr)(*env)->GetObjectField(env, r2, number);
+
+ mpz_tdiv_qr(res1, res2, src1, src2);
+}
+
+void
+Java_java_math_BigInteger_abs0(JNIEnv* env, jobject r, jobject s)
+{
+ mpz_ptr res;
+ mpz_srcptr src;
+
+ src = (mpz_srcptr)(*env)->GetObjectField(env, s, number);
+ res = (mpz_ptr)(*env)->GetObjectField(env, r, number);
+
+ mpz_abs(res, src);
+}
+
+void
+Java_java_math_BigInteger_neg0(JNIEnv* env, jobject r, jobject s)
+{
+ mpz_ptr res;
+ mpz_srcptr src;
+
+ src = (mpz_srcptr)(*env)->GetObjectField(env, s, number);
+ res = (mpz_ptr)(*env)->GetObjectField(env, r, number);
+
+ mpz_neg(res, src);
+}
+
+void
+Java_java_math_BigInteger_pow0(JNIEnv* env, jobject r, jobject s, jint power)
+{
+ mpz_ptr res;
+ mpz_srcptr src;
+
+ src = (mpz_srcptr)(*env)->GetObjectField(env, s, number);
+ res = (mpz_ptr)(*env)->GetObjectField(env, r, number);
+
+ mpz_pow_ui(res, src, (unsigned long)power);
+}
+
+void
+Java_java_math_BigInteger_gcd0(JNIEnv* env, jobject r, jobject s1, jobject s2)
+{
+ mpz_ptr res;
+ mpz_srcptr src1;
+ mpz_srcptr src2;
+
+ src1 = (mpz_srcptr)(*env)->GetObjectField(env, s1, number);
+ src2 = (mpz_srcptr)(*env)->GetObjectField(env, s2, number);
+ res = (mpz_ptr)(*env)->GetObjectField(env, r, number);
+
+ mpz_gcd(res, src1, src2);
+}
+
+void
+Java_java_math_BigInteger_mod0(JNIEnv* env, jobject r, jobject s1, jobject s2)
+{
+ mpz_ptr res;
+ mpz_srcptr src1;
+ mpz_srcptr src2;
+
+ src1 = (mpz_srcptr)(*env)->GetObjectField(env, s1, number);
+ src2 = (mpz_srcptr)(*env)->GetObjectField(env, s2, number);
+ res = (mpz_ptr)(*env)->GetObjectField(env, r, number);
+
+ mpz_mod(res, src1, src2);
+}
+
+/*
+ * r = s1^s2 % s3
+ */
+void
+Java_java_math_BigInteger_modpow0(JNIEnv* env, jobject r, jobject s1, jobject s2, jobject s3)
+{
+ mpz_ptr res;
+ mpz_srcptr src1;
+ mpz_srcptr src2;
+ mpz_srcptr src3;
+
+ src1 = (mpz_srcptr)(*env)->GetObjectField(env, s1, number);
+ src2 = (mpz_srcptr)(*env)->GetObjectField(env, s2, number);
+ src3 = (mpz_srcptr)(*env)->GetObjectField(env, s3, number);
+ res = (mpz_ptr)(*env)->GetObjectField(env, r, number);
+
+ if (mpz_sgn (src2) == -1) {
+ mpz_t tmp;
+ int rc;
+
+ mpz_init (tmp);
+ mpz_neg (tmp, src2);
+ mpz_powm (tmp, src1, tmp, src3);
+ rc = mpz_invert (res, tmp, src3);
+ mpz_clear (tmp);
+ if (rc == 0) {
+ jclass arexc = (*env)->FindClass(env,
+ "java.lang.ArithmeticException");
+ (*env)->ThrowNew(env, arexc, "Inverse does not exist");
+ }
+ if (mpz_sgn (res) == -1)
+ mpz_add (res, src3, res);
+ }
+ else {
+ mpz_powm (res, src1, src2, src3);
+ }
+
+}
+
+/*
+ * r = s1^(-1) mod s2
+ */
+void
+Java_java_math_BigInteger_modinv0(JNIEnv* env, jobject r, jobject s1, jobject s2)
+{
+ mpz_ptr res;
+ mpz_srcptr src1;
+ mpz_srcptr src2;
+ int rc;
+
+ src1 = (mpz_srcptr)(*env)->GetObjectField(env, s1, number);
+ src2 = (mpz_srcptr)(*env)->GetObjectField(env, s2, number);
+ res = (mpz_ptr)(*env)->GetObjectField(env, r, number);
+
+ /*
+ * mpz_invert (rop, op1, op2)
+ * Compute the inverse of op1 modulo op2 and put the result
+ * in rop. Return non-zero if an inverse exist, zero otherwise.
+ * When the function returns zero, do not assume anything about
+ * the value in rop.
+ */
+ rc = mpz_invert (res, src1, src2);
+ if (rc == 0) {
+ jclass arexc = (*env)->FindClass(env,
+ "java.lang.ArithmeticException");
+ (*env)->ThrowNew(env, arexc, "Inverse does not exist");
+ }
+ /* java doesn't allow negative results */
+ if (mpz_sgn(res) == -1)
+ mpz_add (res, src2, res);
+}
+
+void
+Java_java_math_BigInteger_and0(JNIEnv* env, jobject r, jobject s1, jobject s2)
+{
+ mpz_ptr res;
+ mpz_srcptr src1;
+ mpz_srcptr src2;
+
+ src1 = (mpz_srcptr)(*env)->GetObjectField(env, s1, number);
+ src2 = (mpz_srcptr)(*env)->GetObjectField(env, s2, number);
+ res = (mpz_ptr)(*env)->GetObjectField(env, r, number);
+
+ mpz_and(res, src1, src2);
+}
+
+void
+Java_java_math_BigInteger_or0(JNIEnv* env, jobject r, jobject s1, jobject s2)
+{
+ mpz_ptr res;
+ mpz_srcptr src1;
+ mpz_srcptr src2;
+
+ src1 = (mpz_srcptr)(*env)->GetObjectField(env, s1, number);
+ src2 = (mpz_srcptr)(*env)->GetObjectField(env, s2, number);
+ res = (mpz_ptr)(*env)->GetObjectField(env, r, number);
+
+ mpz_ior(res, src1, src2);
+}
+
+void
+Java_java_math_BigInteger_xor0(JNIEnv* env, jobject r, jobject s1, jobject s2)
+{
+ mpz_ptr res;
+ mpz_srcptr src1;
+ mpz_srcptr src2;
+ mpz_t tmp;
+
+ src1 = (mpz_srcptr)(*env)->GetObjectField(env, s1, number);
+ src2 = (mpz_srcptr)(*env)->GetObjectField(env, s2, number);
+ res = (mpz_ptr)(*env)->GetObjectField(env, r, number);
+
+ mpz_init(tmp);
+ mpz_and(res, src1, src2);
+ mpz_com(res, res);
+ mpz_ior(tmp, src1, src2);
+ mpz_and(res, res, tmp);
+
+ mpz_clear(tmp);
+}
+
+void
+Java_java_math_BigInteger_not0(JNIEnv* env, jobject r, jobject s)
+{
+ mpz_ptr res;
+ mpz_srcptr src;
+
+ src = (mpz_srcptr)(*env)->GetObjectField(env, s, number);
+ res = (mpz_ptr)(*env)->GetObjectField(env, r, number);
+
+ mpz_com(res, src);
+}
+
+void
+Java_java_math_BigInteger_setbit0(JNIEnv* env, jobject r, jobject s, jint n)
+{
+ mpz_ptr res;
+ mpz_srcptr src;
+
+ src = (mpz_srcptr)(*env)->GetObjectField(env, s, number);
+ res = (mpz_ptr)(*env)->GetObjectField(env, r, number);
+
+ mpz_set(res, src);
+ mpz_setbit(res, (unsigned long)n);
+}
+
+void
+Java_java_math_BigInteger_clrbit0(JNIEnv* env, jobject r, jobject s, jint n)
+{
+ mpz_ptr res;
+ mpz_srcptr src;
+
+ src = (mpz_srcptr)(*env)->GetObjectField(env, s, number);
+ res = (mpz_ptr)(*env)->GetObjectField(env, r, number);
+
+ mpz_set(res, src);
+ mpz_clrbit(res, (unsigned long)n);
+}
+
+jint
+Java_java_math_BigInteger_scansetbit0(JNIEnv* env, jobject s)
+{
+ mpz_srcptr src;
+
+ src = (mpz_srcptr)(*env)->GetObjectField(env, s, number);
+
+ return ((jint)mpz_scan1(src, 0));
+}
+
+
+jint
+Java_java_math_BigInteger_cmp0(JNIEnv* env, jclass UNUSED cls, jobject s1, jobject s2)
+{
+ mpz_srcptr src1;
+ mpz_srcptr src2;
+
+ src1 = (mpz_srcptr)(*env)->GetObjectField(env, s1, number);
+ src2 = (mpz_srcptr)(*env)->GetObjectField(env, s2, number);
+
+ return (mpz_cmp(src1, src2));
+}
+
+jstring
+Java_java_math_BigInteger_toString0(JNIEnv* env, jobject s, jint base)
+{
+ char* res;
+ mpz_srcptr src;
+ jstring str;
+
+ src = (mpz_srcptr)(*env)->GetObjectField(env, s, number);
+
+ res = mpz_get_str(NULL, (int)base, src);
+ str = (*env)->NewStringUTF(env, res);
+ bi_free(res, 0 /* is ignored */);
+
+ return (str);
+}
+
+jdouble
+Java_java_math_BigInteger_toDouble0(JNIEnv* env, jobject s)
+{
+ mpz_srcptr src;
+
+ src = (mpz_srcptr)(*env)->GetObjectField(env, s, number);
+
+ return ((jdouble)mpz_get_d(src));
+}
+
+
+jint
+Java_java_math_BigInteger_toInt0(JNIEnv* env, jobject s)
+{
+ mpz_srcptr src;
+
+ src = (mpz_srcptr)(*env)->GetObjectField(env, s, number);
+
+ return ((jint)mpz_get_ui(src));
+}
+
+jint
+Java_java_math_BigInteger_probablyPrime0(JNIEnv* env, jobject s, jint prop)
+{
+ mpz_srcptr src;
+
+ src = (mpz_srcptr)(*env)->GetObjectField(env, s, number);
+
+ return (mpz_probab_prime_p(src, (int)prop));
+}
+
+jint
+Java_java_math_BigInteger_bitLength0(JNIEnv* env, jobject s)
+{
+ mpz_srcptr src;
+
+ src = (mpz_srcptr)(*env)->GetObjectField(env, s, number);
+
+ return (mpz_sizeinbase(src, 2));
+}
+
+jint
+Java_java_math_BigInteger_hamDist0(JNIEnv* env, jobject s1, jobject s2)
+{
+ mpz_srcptr src1, src2;
+
+ src1 = (mpz_srcptr)(*env)->GetObjectField(env, s1, number);
+ src2 = (mpz_srcptr)(*env)->GetObjectField(env, s2, number);
+
+ return (mpz_hamdist(src1, src2));
+}
+
+#else /* !defined(HAVE_GMP_H) || !defined(USE_GMP) */
+
+/* throw a kaffe.util.SupportDisabled exception */
+static void
+gmp_not_found(JNIEnv* env)
+{
+ jclass sd = (*env)->FindClass(env, "kaffe.util.SupportDisabled");
+ (*env)->ThrowNew(env, sd, "GNU gmp was not found by Kaffe configure script");
+}
+
+/* We should put some dummies in here */
+void
+Java_java_math_BigInteger_initialize0(JNIEnv* env, jclass cls)
+{
+ gmp_not_found(env);
+}
+
+void
+Java_java_math_BigInteger_init0(JNIEnv* env, jobject r)
+{
+ gmp_not_found(env);
+}
+
+void
+Java_java_math_BigInteger_finalize0(JNIEnv* env, jobject r)
+{
+ gmp_not_found(env);
+}
+
+void
+Java_java_math_BigInteger_assignLong0(JNIEnv* env, jobject r, jlong v)
+{
+ gmp_not_found(env);
+}
+
+void
+Java_java_math_BigInteger_assignBytes0(JNIEnv* env, jobject r, jint sign, jbyteArray magnitude)
+{
+ gmp_not_found(env);
+}
+
+jint
+Java_java_math_BigInteger_assignString0(JNIEnv* env, jobject r, jstring val, jint radix)
+{
+ gmp_not_found(env);
+
+ return 0;
+}
+
+void
+Java_java_math_BigInteger_add0(JNIEnv* env, jobject r, jobject s1, jobject s2)
+{
+ gmp_not_found(env);
+}
+
+void
+Java_java_math_BigInteger_sub0(JNIEnv* env, jobject r, jobject s1, jobject s2)
+{
+ gmp_not_found(env);
+}
+
+void
+Java_java_math_BigInteger_mul0(JNIEnv* env, jobject r, jobject s1, jobject s2)
+{
+ gmp_not_found(env);
+}
+
+void
+Java_java_math_BigInteger_div0(JNIEnv* env, jobject r, jobject s1, jobject s2)
+{
+ gmp_not_found(env);
+}
+
+void
+Java_java_math_BigInteger_rem0(JNIEnv* env, jobject r, jobject s1, jobject s2)
+{
+ gmp_not_found(env);
+}
+
+void
+Java_java_math_BigInteger_divrem0(JNIEnv* env, jclass cls, jobject r1, jobject r2, jobject s1, jobject s2)
+{
+ gmp_not_found(env);
+}
+
+void
+Java_java_math_BigInteger_abs0(JNIEnv* env, jobject r, jobject s)
+{
+ gmp_not_found(env);
+}
+
+void
+Java_java_math_BigInteger_neg0(JNIEnv* env, jobject r, jobject s)
+{
+ gmp_not_found(env);
+}
+
+void
+Java_java_math_BigInteger_pow0(JNIEnv* env, jobject r, jobject s, jint power)
+{
+ gmp_not_found(env);
+}
+
+void
+Java_java_math_BigInteger_gcd0(JNIEnv* env, jobject r, jobject s1, jobject s2)
+{
+ gmp_not_found(env);
+}
+
+void
+Java_java_math_BigInteger_mod0(JNIEnv* env, jobject r, jobject s1, jobject s2)
+{
+ gmp_not_found(env);
+}
+
+void
+Java_java_math_BigInteger_modpow0(JNIEnv* env, jobject r, jobject s1, jobject s2, jobject s3)
+{
+ gmp_not_found(env);
+}
+
+void
+Java_java_math_BigInteger_modinv0(JNIEnv* env, jobject r, jobject s1, jobject s2)
+{
+ gmp_not_found(env);
+}
+
+void
+Java_java_math_BigInteger_and0(JNIEnv* env, jobject r, jobject s1, jobject s2)
+{
+ gmp_not_found(env);
+}
+
+void
+Java_java_math_BigInteger_or0(JNIEnv* env, jobject r, jobject s1, jobject s2)
+{
+ gmp_not_found(env);
+}
+
+void
+Java_java_math_BigInteger_xor0(JNIEnv* env, jobject r, jobject s1, jobject s2)
+{
+ gmp_not_found(env);
+}
+
+void
+Java_java_math_BigInteger_not0(JNIEnv* env, jobject r, jobject s)
+{
+ gmp_not_found(env);
+}
+
+void
+Java_java_math_BigInteger_setbit0(JNIEnv* env, jobject r, jobject s, jint n)
+{
+ gmp_not_found(env);
+}
+
+void
+Java_java_math_BigInteger_clrbit0(JNIEnv* env, jobject r, jobject s, jint n)
+{
+ gmp_not_found(env);
+}
+
+jint
+Java_java_math_BigInteger_scansetbit0(JNIEnv* env, jobject s)
+{
+ gmp_not_found(env);
+
+ return 0;
+}
+
+jint
+Java_java_math_BigInteger_cmp0(JNIEnv* env, jclass cls, jobject s1, jobject s2)
+{
+ gmp_not_found(env);
+
+ return 0;
+}
+
+jstring
+Java_java_math_BigInteger_toString0(JNIEnv* env, jobject s, jint base)
+{
+ gmp_not_found(env);
+
+ return NULL;
+}
+
+jdouble
+Java_java_math_BigInteger_toDouble0(JNIEnv* env, jobject s)
+{
+ gmp_not_found(env);
+
+ return 0.0;
+}
+
+jint
+Java_java_math_BigInteger_toInt0(JNIEnv* env, jobject s)
+{
+ gmp_not_found(env);
+
+ return 0;
+}
+
+jint
+Java_java_math_BigInteger_probablyPrime0(JNIEnv* env, jobject s, jint prop)
+{
+ gmp_not_found(env);
+
+ return 0;
+}
+
+jint
+Java_java_math_BigInteger_bitLength0(JNIEnv* env, jobject s)
+{
+ gmp_not_found(env);
+
+ return 0;
+}
+
+jint
+Java_java_math_BigInteger_hamDist0(JNIEnv* env, jobject s1, jobject s2)
+{
+ gmp_not_found(env);
+
+ return 0;
+}
+
+#endif /* defined(HAVE_GMP_H) && defined(USE_GMP) */
Index: kaffe/po/de.po
diff -u kaffe/po/de.po:1.2 kaffe/po/de.po:1.3
--- kaffe/po/de.po:1.2 Mon Aug 8 15:39:22 2005
+++ kaffe/po/de.po Thu Aug 11 22:07:53 2005
@@ -8,7 +8,7 @@
msgstr ""
"Project-Id-Version: de\n"
"Report-Msgid-Bugs-To: kaffe at kaffe.org\n"
-"POT-Creation-Date: 2005-08-07 21:33-0500\n"
+"POT-Creation-Date: 2005-08-10 19:56-0500\n"
"PO-Revision-Date: 2005-07-18 23:27+0200\n"
"Last-Translator: \n"
"Language-Team: <de at li.org>\n"
@@ -17,102 +17,102 @@
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: KBabel 1.9.1\n"
-#: kaffe/kaffe/main.c:385 kaffe/kaffe/main.c:475 kaffe/kaffe/main.c:538
-#: kaffe/kaffe/main.c:565 kaffe/kaffe/main.c:590 kaffe/kaffe/main.c:612
-#: kaffe/kaffe/main.c:723
+#: kaffe/kaffe/main.c:388 kaffe/kaffe/main.c:478 kaffe/kaffe/main.c:541
+#: kaffe/kaffe/main.c:568 kaffe/kaffe/main.c:593 kaffe/kaffe/main.c:615
+#: kaffe/kaffe/main.c:726
#, c-format
msgid "Error: out of memory.\n"
msgstr "Fehler: Nicht genügend Speicher.\n"
-#: kaffe/kaffe/main.c:627
+#: kaffe/kaffe/main.c:630
#, c-format
msgid "Error: No stack size found for -ss option.\n"
msgstr "Fehler: Keine Stack Angabe für -ss Option gefunden.\n"
-#: kaffe/kaffe/main.c:635
+#: kaffe/kaffe/main.c:638
#, c-format
msgid "Warning: Attempt to set stack size smaller than %d - ignored.\n"
msgstr ""
"Warnung: Versuch die Größe des Stacks kleiner als %d zu setzen ignoriert.\n"
-#: kaffe/kaffe/main.c:646
+#: kaffe/kaffe/main.c:649
#, c-format
msgid "Error: No heap size found for -mx option.\n"
msgstr "Fehler: Keine Heap-Größenangabe für -mx Option gefunden.\n"
-#: kaffe/kaffe/main.c:665
+#: kaffe/kaffe/main.c:668
#, c-format
msgid "Error: No heap size found for -ms option.\n"
msgstr "Fehler: Keine Heap-Größenangabe für -ms Option gefunden.\n"
-#: kaffe/kaffe/main.c:677
+#: kaffe/kaffe/main.c:680
#, c-format
msgid "Error: No heap size found for -as option.\n"
msgstr "Fehler: Keine Heap-Größenangabe für -as Option gefunden.\n"
-#: kaffe/kaffe/main.c:775
+#: kaffe/kaffe/main.c:778
#, c-format
msgid "Error: -Xxprof_syms option requires a file name.\n"
msgstr "Fehler: -Xxprof_syms Option benötigt einen Dateinamen.\n"
-#: kaffe/kaffe/main.c:781
+#: kaffe/kaffe/main.c:784
#, c-format
msgid "Unable to create profiler symbol file %s.\n"
msgstr "Kann die Profiler Symboldatei %s nicht erstellen.\n"
-#: kaffe/kaffe/main.c:790
+#: kaffe/kaffe/main.c:793
#, c-format
msgid "Error: -Xxprof_gmon option requires a file name.\n"
msgstr "Fehler: -Xxprof_gmon Option benötigt einen Dateinamen.\n"
-#: kaffe/kaffe/main.c:796
+#: kaffe/kaffe/main.c:799
#, c-format
msgid "Unable to create gmon file %s.\n"
msgstr "Kann die gmon Datei %s nicht erstellen.\n"
-#: kaffe/kaffe/main.c:810
+#: kaffe/kaffe/main.c:813
#, c-format
msgid "Error: -Xxdebug_file option requires a file name.\n"
msgstr "Fehler: -Xxdebug_file Option benötigt einen Dateinamen.\n"
-#: kaffe/kaffe/main.c:824
+#: kaffe/kaffe/main.c:827
#, c-format
msgid "Error: -Xfeedback option requires a file name.\n"
msgstr "Fehler: -Xfeedback Option benötigt einen Dateinamen.\n"
-#: kaffe/kaffe/main.c:842
+#: kaffe/kaffe/main.c:845
#, c-format
msgid "Error: -vmstats option requires a second arg.\n"
msgstr "Fehler: -vmstats Option benötigt ein zweites Argument.\n"
-#: kaffe/kaffe/main.c:854
+#: kaffe/kaffe/main.c:857
#, c-format
msgid "Error: -vmdebug option requires a debug flag. Use `list' for a list.\n"
msgstr ""
"Fehler: -vmdebug Option benötigt ein Debug-Flag. Verwende `list' für eine "
"Liste.\n"
-#: kaffe/kaffe/main.c:867
+#: kaffe/kaffe/main.c:870
#, c-format
msgid "Error: -debug-fd an open descriptor.\n"
msgstr "Fehler: -debug-fd ist ein offener Deskriptor.\n"
-#: kaffe/kaffe/main.c:873
+#: kaffe/kaffe/main.c:876
#, c-format
msgid "Error: -debug-fd requires an integer.\n"
msgstr "Fehler: -debug-fd benötigt eine Ganzzahl.\n"
-#: kaffe/kaffe/main.c:885
+#: kaffe/kaffe/main.c:888
#, c-format
msgid "Error: Unrecognized JVM specific option `%s'.\n"
msgstr "Fehler: Unbekannte JVM spezifische Option %s'.\n"
-#: kaffe/kaffe/main.c:900
+#: kaffe/kaffe/main.c:903
#, c-format
msgid "Unknown flag: %s\n"
msgstr "Unbekanntes Flag: %s\n"
-#: kaffe/kaffe/main.c:916
+#: kaffe/kaffe/main.c:919
#, c-format
msgid ""
"usage: kaffe [-options] class\n"
@@ -127,12 +127,12 @@
"\t-version\t\t Ausgabe der Versionsnummer\n"
"\t-fullversion\t\t Ausgabe ausführlicher Versionsinformationen\n"
-#: kaffe/kaffe/main.c:922
+#: kaffe/kaffe/main.c:925
#, c-format
msgid "\t-ia32\t\t\t Execute the ia32 version of Kaffe\n"
msgstr "\t-ia32\t\t\t Ausführung der ia32 Version von Kaffe\n"
-#: kaffe/kaffe/main.c:924
+#: kaffe/kaffe/main.c:927
#, c-format
msgid ""
"\t-ss <size>\t\t Maximum native stack size\n"
@@ -175,12 +175,12 @@
"\t-verbosecall\t\t Ausgabe detaillierter Informationen zum Aufrufverlauf\n"
"\t-nodeadlock\t\t Abschalten der Deadlock Erkennung\n"
-#: kaffe/kaffe/main.c:944
+#: kaffe/kaffe/main.c:947
#, c-format
msgid "\t-prof\t\t\t Enable profiling of Java methods\n"
msgstr "\t-prof\t\t\t Aktiviere Profiling von Java Methoden\n"
-#: kaffe/kaffe/main.c:947
+#: kaffe/kaffe/main.c:950
#, c-format
msgid ""
"\t-Xxprof\t\t\t Enable cross language profiling\n"
@@ -193,17 +193,17 @@
"jit-symbols.s]\n"
"\t-Xxprof_gmon <file>\t Basisname für gmon Dateien [Standard: xgmon.out]\n"
-#: kaffe/kaffe/main.c:952
*** Patch too long, truncated ***
More information about the kaffe
mailing list