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 <[EMAIL PROTECTED]> * 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 <[EMAIL PROTECTED]> + + * libraries/clib/math/BigInteger.c + (Java_java_math_BigInteger_assignString0): Add return value to fix + compiler warnings. + 2005-08-10 Dalibor Topic <[EMAIL PROTECTED]> 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: [EMAIL PROTECTED]" -"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: <[EMAIL PROTECTED]>\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 *** _______________________________________________ kaffe mailing list kaffe@kaffe.org http://kaffe.org/cgi-bin/mailman/listinfo/kaffe