libjava/jni/classpath/primlib.c

   1 /* primlib.c
   2    Copyright (C) 1998 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38 #include <jnilink.h>
  39 #include <primlib.h>
  40 #include <jcl.h>
  41
  42 static jclass nativeWrapClass[PRIMLIB_NUMTYPES] = {NULL,NULL,NULL, NULL,NULL,NULL,
  43                                                 NULL,NULL,NULL, NULL,NULL,NULL};
  44
  45 static jclass nativeTypeClass[PRIMLIB_NUMTYPES] = {NULL,NULL,NULL, NULL,NULL,NULL,
  46                                                 NULL,NULL,NULL, NULL,NULL,NULL};
  47
  48 static jmethodID nativeWrapClassConstructor[PRIMLIB_NUMTYPES] = {NULL,NULL,NULL, NULL,NULL,NULL,
  49                                                 NULL,NULL,NULL, NULL,NULL,NULL};
  50
  51 static jmethodID nativeWrapClassAccessor[PRIMLIB_NUMTYPES] = {NULL,NULL,NULL, NULL,NULL,NULL,
  52                                                 NULL,NULL,NULL, NULL,NULL,NULL};
  53
  54 static char * nativeWrapClassName[PRIMLIB_NUMTYPES] = {
  55                                                         NULL,
  56                                                         NULL,
  57                                                         "java/lang/Boolean",
  58                                                         "java/lang/Byte",
  59                                                         "java/lang/Character",
  60                                                         "java/lang/Short",
  61                                                         "java/lang/Integer",
  62                                                         "java/lang/Long",
  63                                                         "java/lang/Float",
  64                                                         "java/lang/Double",
  65                                                         "java/lang/Void",
  66                                                         NULL
  67                                                         };
  68
  69 static char * nativeWrapClassConstructorSig[PRIMLIB_NUMTYPES] = {
  70                                                         NULL,
  71                                                         NULL,
  72                                                         "(Z)V",
  73                                                         "(B)V",
  74                                                         "(C)V",
  75                                                         "(S)V",
  76                                                         "(I)V",
  77                                                         "(J)V",
  78                                                         "(F)V",
  79                                                         "(D)V",
  80                                                         "()V",
  81                                                         NULL
  82                                                         };
  83
  84 static char * nativeWrapClassAccessorName[PRIMLIB_NUMTYPES] = {
  85                                                         NULL,
  86                                                         NULL,
  87                                                         "booleanValue",
  88                                                         "byteValue",
  89                                                         "charValue",
  90                                                         "shortValue",
  91                                                         "intValue",
  92                                                         "longValue",
  93                                                         "floatValue",
  94                                                         "doubleValue",
  95                                                         NULL,
  96                                                         NULL
  97 };
  98
  99 static char * nativeWrapClassAccessorSig[PRIMLIB_NUMTYPES] = {
 100                                                         NULL,
 101                                                         NULL,
 102                                                         "()Z",
 103                                                         "()B",
 104                                                         "()C",
 105                                                         "()S",
 106                                                         "()I",
 107                                                         "()J",
 108                                                         "()F",
 109                                                         "()D",
 110                                                         NULL,
 111                                                         NULL
 112 };
 113
 114
 115 JNIEXPORT jclass JNICALL PRIMLIB_GetNativeWrapClass(JNIEnv * env, int reflectType) {
 116         return LINK_LinkClass(env,nativeWrapClass[reflectType],nativeWrapClassName[reflectType]);
 117 }
 118
 119 static jclass ActuallyGetNativeTypeClass(JNIEnv * env, int reflectType) {
 120         jclass wrapClass;
 121         jfieldID typeField;
 122
 123         wrapClass = PRIMLIB_GetNativeWrapClass(env, reflectType);
 124         if(wrapClass == NULL)
 125                 return NULL;
 126         typeField = (*env)->GetStaticFieldID(env, wrapClass, "TYPE", "Ljava/lang/Class");
 127         if(typeField == NULL)
 128                 return NULL;
 129         return (*env)->GetStaticObjectField(env, wrapClass, typeField);
 130 }
 131
 132 JNIEXPORT jclass JNICALL PRIMLIB_GetNativeTypeClass(JNIEnv * env, int reflectType) {
 133         return LINK_LinkKnownClass(env, nativeTypeClass[reflectType], ActuallyGetNativeTypeClass(env,reflectType));
 134 }
 135
 136 JNIEXPORT jmethodID JNICALL PRIMLIB_GetNativeWrapClassConstructor(JNIEnv * env, int reflectType) {
 137         PRIMLIB_GetNativeWrapClass(env,reflectType);
 138         return LINK_LinkConstructor(env, nativeWrapClassConstructor[reflectType], nativeWrapClass[reflectType], nativeWrapClassConstructorSig[reflectType]);
 139 }
 140
 141 JNIEXPORT jmethodID JNICALL PRIMLIB_GetNativeWrapClassAccessor(JNIEnv * env, int reflectType) {
 142         PRIMLIB_GetNativeWrapClass(env,reflectType);
 143         return LINK_LinkMethod(env, nativeWrapClassAccessor[reflectType], nativeWrapClass[reflectType], nativeWrapClassAccessorName[reflectType], nativeWrapClassAccessorSig[reflectType]);
 144 }
 145
 146
 147
 148 JNIEXPORT jobject JNICALL PRIMLIB_WrapBoolean(JNIEnv * env, jboolean b) {
 149         jmethodID construct = PRIMLIB_GetNativeWrapClassConstructor(env, PRIMLIB_BOOLEAN);
 150         JCL_RETHROW_EXCEPTION(env);
 151         return (*env)->NewObject(env, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_BOOLEAN), construct, b);
 152 }
 153
 154 JNIEXPORT jobject JNICALL PRIMLIB_WrapByte   (JNIEnv * env, jbyte b) {
 155         jmethodID construct = PRIMLIB_GetNativeWrapClassConstructor(env, PRIMLIB_BYTE);
 156         JCL_RETHROW_EXCEPTION(env);
 157         return (*env)->NewObject(env, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_BYTE), construct, b);
 158 }
 159
 160 JNIEXPORT jobject JNICALL PRIMLIB_WrapChar   (JNIEnv * env, jchar c) {
 161         jmethodID construct = PRIMLIB_GetNativeWrapClassConstructor(env, PRIMLIB_CHAR);
 162         JCL_RETHROW_EXCEPTION(env);
 163         return (*env)->NewObject(env, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_CHAR), construct, c);
 164 }
 165
 166 JNIEXPORT jobject JNICALL PRIMLIB_WrapShort  (JNIEnv * env, jshort s) {
 167         jmethodID construct = PRIMLIB_GetNativeWrapClassConstructor(env, PRIMLIB_SHORT);
 168         JCL_RETHROW_EXCEPTION(env);
 169         return (*env)->NewObject(env, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_SHORT), construct, s);
 170 }
 171
 172 JNIEXPORT jobject JNICALL PRIMLIB_WrapInt    (JNIEnv * env, jint i) {
 173         jmethodID construct = PRIMLIB_GetNativeWrapClassConstructor(env, PRIMLIB_INT);
 174         JCL_RETHROW_EXCEPTION(env);
 175         return (*env)->NewObject(env, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_INT), construct, i);
 176 }
 177
 178 JNIEXPORT jobject JNICALL PRIMLIB_WrapLong   (JNIEnv * env, jlong l) {
 179         jmethodID construct = PRIMLIB_GetNativeWrapClassConstructor(env, PRIMLIB_LONG);
 180         JCL_RETHROW_EXCEPTION(env);
 181         return (*env)->NewObject(env, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_LONG), construct, l);
 182 }
 183
 184 JNIEXPORT jobject JNICALL PRIMLIB_WrapFloat  (JNIEnv * env, jfloat f) {
 185         jmethodID construct = PRIMLIB_GetNativeWrapClassConstructor(env, PRIMLIB_FLOAT);
 186         JCL_RETHROW_EXCEPTION(env);
 187         return (*env)->NewObject(env, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_FLOAT), construct, f);
 188 }
 189
 190 JNIEXPORT jobject JNICALL PRIMLIB_WrapDouble (JNIEnv * env, jdouble d) {
 191         jmethodID construct = PRIMLIB_GetNativeWrapClassConstructor(env, PRIMLIB_DOUBLE);
 192         JCL_RETHROW_EXCEPTION(env);
 193         return (*env)->NewObject(env, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_DOUBLE), construct, d);
 194 }
 195
 196
 197 JNIEXPORT jboolean JNICALL PRIMLIB_UnwrapBoolean(JNIEnv * env, jobject obj) {
 198         if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_BOOLEAN))) {
 199                 return PRIMLIB_GetBooleanObjectValue(env, obj);
 200         } else {
 201                 JCL_ThrowException(env, "java/lang/IllegalArgumentException", "Argument not of correct type.");
 202                 return JNI_FALSE;
 203         }
 204 }
 205
 206 JNIEXPORT jbyte JNICALL PRIMLIB_UnwrapByte(JNIEnv * env, jobject obj) {
 207         if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_BYTE))) {
 208                 return PRIMLIB_GetByteObjectValue(env, obj);
 209         } else {
 210                 JCL_ThrowException(env, "java/lang/IllegalArgumentException", "Argument not of correct type.");
 211                 return 0;
 212         }
 213 }
 214
 215 JNIEXPORT jshort JNICALL PRIMLIB_UnwrapShort(JNIEnv * env, jobject obj) {
 216         if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_SHORT))) {
 217                 return PRIMLIB_GetShortObjectValue(env, obj);
 218         } else if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_BYTE))) {
 219                 return (jshort)PRIMLIB_GetByteObjectValue(env, obj);
 220         } else {
 221                 JCL_ThrowException(env, "java/lang/IllegalArgumentException", "Argument not of correct type.");
 222                 return 0;
 223         }
 224 }
 225
 226 JNIEXPORT jchar JNICALL PRIMLIB_UnwrapChar(JNIEnv * env, jobject obj) {
 227         if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_CHAR))) {
 228                 return PRIMLIB_GetCharObjectValue(env, obj);
 229         } else {
 230                 JCL_ThrowException(env, "java/lang/IllegalArgumentException", "Argument not of correct type.");
 231                 return 0;
 232         }
 233 }
 234
 235 JNIEXPORT jint JNICALL PRIMLIB_UnwrapInt(JNIEnv * env, jobject obj) {
 236         if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_INT))) {
 237                 return PRIMLIB_GetIntObjectValue(env, obj);
 238         } else if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_SHORT))) {
 239                 return (jint)PRIMLIB_GetShortObjectValue(env, obj);
 240         } else if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_CHAR))) {
 241                 return (jint)PRIMLIB_GetCharObjectValue(env, obj);
 242         } else if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_BYTE))) {
 243                 return (jint)PRIMLIB_GetByteObjectValue(env, obj);
 244         } else {
 245                 JCL_ThrowException(env, "java/lang/IllegalArgumentException", "Argument not of correct type.");
 246                 return 0;
 247         }
 248 }
 249
 250 JNIEXPORT jlong JNICALL PRIMLIB_UnwrapLong(JNIEnv * env, jobject obj) {
 251         if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_LONG))) {
 252                 return PRIMLIB_GetLongObjectValue(env, obj);
 253         } else if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_INT))) {
 254                 return (jlong)PRIMLIB_GetIntObjectValue(env, obj);
 255         } else if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_SHORT))) {
 256                 return (jlong)PRIMLIB_GetShortObjectValue(env, obj);
 257         } else if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_CHAR))) {
 258                 return (jlong)PRIMLIB_GetCharObjectValue(env, obj);
 259         } else if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_BYTE))) {
 260                 return (jlong)PRIMLIB_GetByteObjectValue(env, obj);
 261         } else {
 262                 JCL_ThrowException(env, "java/lang/IllegalArgumentException", "Argument not of correct type.");
 263                 return 0;
 264         }
 265 }
 266
 267 JNIEXPORT jfloat JNICALL PRIMLIB_UnwrapFloat(JNIEnv * env, jobject obj) {
 268         if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_FLOAT))) {
 269                 return PRIMLIB_GetFloatObjectValue(env, obj);
 270         } else if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_LONG))) {
 271                 return (jfloat)PRIMLIB_GetLongObjectValue(env, obj);
 272         } else if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_INT))) {
 273                 return (jfloat)PRIMLIB_GetIntObjectValue(env, obj);
 274         } else if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_SHORT))) {
 275                 return (jfloat)PRIMLIB_GetShortObjectValue(env, obj);
 276         } else if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_CHAR))) {
 277                 return (jfloat)PRIMLIB_GetCharObjectValue(env, obj);
 278         } else if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_BYTE))) {
 279                 return (jfloat)PRIMLIB_GetByteObjectValue(env, obj);
 280         } else {
 281                 JCL_ThrowException(env, "java/lang/IllegalArgumentException", "Argument not of correct type.");
 282                 return 0;
 283         }
 284 }
 285
 286 JNIEXPORT jdouble JNICALL PRIMLIB_UnwrapDouble(JNIEnv * env, jobject obj) {
 287         if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_DOUBLE))) {
 288                 return PRIMLIB_GetDoubleObjectValue(env, obj);
 289         } else if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_FLOAT))) {
 290                 return (jdouble)PRIMLIB_GetFloatObjectValue(env, obj);
 291         } else if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_LONG))) {
 292                 return (jdouble)PRIMLIB_GetLongObjectValue(env, obj);
 293         } else if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_INT))) {
 294                 return (jdouble)PRIMLIB_GetIntObjectValue(env, obj);
 295         } else if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_SHORT))) {
 296                 return (jdouble)PRIMLIB_GetShortObjectValue(env, obj);
 297         } else if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_CHAR))) {
 298                 return (jdouble)PRIMLIB_GetCharObjectValue(env, obj);
 299         } else if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_BYTE))) {
 300                 return (jdouble)PRIMLIB_GetByteObjectValue(env, obj);
 301         } else {
 302                 JCL_ThrowException(env, "java/lang/IllegalArgumentException", "Argument not of correct type.");
 303                 return 0;
 304         }
 305 }
 306
 307 JNIEXPORT jint JNICALL PRIMLIB_GetReflectiveWrapperType(JNIEnv * env, jobject obj) {
 308         jclass typeClass;
 309         if(obj == NULL) {
 310                 return PRIMLIB_NULL;
 311         }
 312
 313         typeClass = PRIMLIB_GetNativeWrapClass(env, PRIMLIB_DOUBLE);
 314         if((*env)->IsInstanceOf(env, obj, typeClass)) {
 315                 return PRIMLIB_DOUBLE;
 316         }
 317         typeClass = PRIMLIB_GetNativeWrapClass(env, PRIMLIB_FLOAT);
 318         if((*env)->IsInstanceOf(env, obj, typeClass)) {
 319                 return PRIMLIB_FLOAT;
 320         }
 321         typeClass = PRIMLIB_GetNativeWrapClass(env, PRIMLIB_LONG);
 322         if((*env)->IsInstanceOf(env, obj, typeClass)) {
 323                 return PRIMLIB_LONG;
 324         }
 325         typeClass = PRIMLIB_GetNativeWrapClass(env, PRIMLIB_INT);
 326         if((*env)->IsInstanceOf(env, obj, typeClass)) {
 327                 return PRIMLIB_INT;
 328         }
 329         typeClass = PRIMLIB_GetNativeWrapClass(env, PRIMLIB_CHAR);
 330         if((*env)->IsInstanceOf(env, obj, typeClass)) {
 331                 return PRIMLIB_CHAR;
 332         }
 333         typeClass = PRIMLIB_GetNativeWrapClass(env, PRIMLIB_SHORT);
 334         if((*env)->IsInstanceOf(env, obj, typeClass)) {
 335                 return PRIMLIB_SHORT;
 336         }
 337         typeClass = PRIMLIB_GetNativeWrapClass(env, PRIMLIB_BYTE);
 338         if((*env)->IsInstanceOf(env, obj, typeClass)) {
 339                 return PRIMLIB_BYTE;
 340         }
 341         typeClass = PRIMLIB_GetNativeWrapClass(env, PRIMLIB_BOOLEAN);
 342         if((*env)->IsInstanceOf(env, obj, typeClass)) {
 343                 return PRIMLIB_BOOLEAN;
 344         }
 345         typeClass = PRIMLIB_GetNativeWrapClass(env, PRIMLIB_VOID);
 346         if((*env)->IsInstanceOf(env, obj, typeClass)) {
 347                 return PRIMLIB_VOID;
 348         }
 349         return PRIMLIB_OBJECT;
 350 }
 351
 352 JNIEXPORT jint JNICALL PRIMLIB_GetReflectiveType(JNIEnv * env, jclass returnType) {
 353         jclass typeClass = PRIMLIB_GetNativeTypeClass(env, PRIMLIB_DOUBLE);
 354         if((*env)->IsAssignableFrom(env, returnType, typeClass)) {
 355                 return PRIMLIB_DOUBLE;
 356         }
 357         typeClass = PRIMLIB_GetNativeTypeClass(env, PRIMLIB_FLOAT);
 358         if((*env)->IsAssignableFrom(env, returnType, typeClass)) {
 359                 return PRIMLIB_FLOAT;
 360         }
 361         typeClass = PRIMLIB_GetNativeTypeClass(env, PRIMLIB_LONG);
 362         if((*env)->IsAssignableFrom(env, returnType, typeClass)) {
 363                 return PRIMLIB_LONG;
 364         }
 365         typeClass = PRIMLIB_GetNativeTypeClass(env, PRIMLIB_INT);
 366         if((*env)->IsAssignableFrom(env, returnType, typeClass)) {
 367                 return PRIMLIB_INT;
 368         }
 369         typeClass = PRIMLIB_GetNativeTypeClass(env, PRIMLIB_CHAR);
 370         if((*env)->IsAssignableFrom(env, returnType, typeClass)) {
 371                 return PRIMLIB_CHAR;
 372         }
 373         typeClass = PRIMLIB_GetNativeTypeClass(env, PRIMLIB_SHORT);
 374         if((*env)->IsAssignableFrom(env, returnType, typeClass)) {
 375                 return PRIMLIB_SHORT;
 376         }
 377         typeClass = PRIMLIB_GetNativeTypeClass(env, PRIMLIB_BYTE);
 378         if((*env)->IsAssignableFrom(env, returnType, typeClass)) {
 379                 return PRIMLIB_BYTE;
 380         }
 381         typeClass = PRIMLIB_GetNativeTypeClass(env, PRIMLIB_BOOLEAN);
 382         if((*env)->IsAssignableFrom(env, returnType, typeClass)) {
 383                 return PRIMLIB_BOOLEAN;
 384         }
 385         typeClass = PRIMLIB_GetNativeTypeClass(env, PRIMLIB_VOID);
 386         if((*env)->IsAssignableFrom(env, returnType, typeClass)) {
 387                 return PRIMLIB_VOID;
 388         }
 389         return PRIMLIB_OBJECT;
 390 }
 391
 392
 393 JNIEXPORT jboolean JNICALL PRIMLIB_GetBooleanObjectValue(JNIEnv * env, jobject obj) {
 394         jmethodID acc = PRIMLIB_GetNativeWrapClassAccessor(env, PRIMLIB_BOOLEAN);
 395         return (*env)->CallBooleanMethod(env, obj, acc);
 396 }
 397
 398 JNIEXPORT jbyte JNICALL PRIMLIB_GetByteObjectValue(JNIEnv * env, jobject obj) {
 399         jmethodID acc = PRIMLIB_GetNativeWrapClassAccessor(env, PRIMLIB_BYTE);
 400         return (*env)->CallByteMethod(env, obj, acc);
 401 }
 402
 403 JNIEXPORT jshort JNICALL PRIMLIB_GetShortObjectValue(JNIEnv * env, jobject obj) {
 404         jmethodID acc = PRIMLIB_GetNativeWrapClassAccessor(env, PRIMLIB_SHORT);
 405         return (*env)->CallShortMethod(env, obj, acc);
 406 }
 407
 408 JNIEXPORT jchar JNICALL PRIMLIB_GetCharObjectValue(JNIEnv * env, jobject obj) {
 409         jmethodID acc = PRIMLIB_GetNativeWrapClassAccessor(env, PRIMLIB_CHAR);
 410         return (*env)->CallCharMethod(env, obj, acc);
 411 }
 412
 413 JNIEXPORT jint JNICALL PRIMLIB_GetIntObjectValue(JNIEnv * env, jobject obj) {
 414         jmethodID acc = PRIMLIB_GetNativeWrapClassAccessor(env, PRIMLIB_INT);
 415         return (*env)->CallIntMethod(env, obj, acc);
 416 }
 417
 418 JNIEXPORT jlong JNICALL PRIMLIB_GetLongObjectValue(JNIEnv * env, jobject obj) {
 419         jmethodID acc = PRIMLIB_GetNativeWrapClassAccessor(env, PRIMLIB_LONG);
 420         return (*env)->CallLongMethod(env, obj, acc);
 421 }
 422
 423 JNIEXPORT jfloat JNICALL PRIMLIB_GetFloatObjectValue(JNIEnv * env, jobject obj) {
 424         jmethodID acc = PRIMLIB_GetNativeWrapClassAccessor(env, PRIMLIB_FLOAT);
 425         return (*env)->CallFloatMethod(env, obj, acc);
 426 }
 427
 428 JNIEXPORT jdouble JNICALL PRIMLIB_GetDoubleObjectValue(JNIEnv * env, jobject obj) {
 429         jmethodID acc = PRIMLIB_GetNativeWrapClassAccessor(env, PRIMLIB_DOUBLE);
 430         return (*env)->CallDoubleMethod(env, obj, acc);
 431 }
 432
 433
 434
 435 JNIEXPORT jvalue JNICALL PRIMLIB_UnwrapJValue(JNIEnv* env, jobject obj, jclass classType) {
 436         jvalue retval;
 437         jint objType = PRIMLIB_GetReflectiveType(env, classType);
 438         if(objType == PRIMLIB_BOOLEAN) {
 439                 retval.z = PRIMLIB_UnwrapBoolean(env,obj);
 440         } else if(objType == PRIMLIB_BYTE) {
 441                 retval.b = PRIMLIB_UnwrapByte(env,obj);
 442         } else if(objType == PRIMLIB_CHAR) {
 443                 retval.c = PRIMLIB_UnwrapChar(env,obj);
 444         } else if(objType == PRIMLIB_SHORT) {
 445                 retval.s = PRIMLIB_UnwrapShort(env,obj);
 446         } else if(objType == PRIMLIB_INT) {
 447                 retval.i = PRIMLIB_UnwrapInt(env,obj);
 448         } else if(objType == PRIMLIB_LONG) {
 449                 retval.j = PRIMLIB_UnwrapLong(env,obj);
 450         } else if(objType == PRIMLIB_FLOAT) {
 451                 retval.f = PRIMLIB_UnwrapFloat(env,obj);
 452         } else if(objType == PRIMLIB_DOUBLE) {
 453                 retval.d = PRIMLIB_UnwrapDouble(env,obj);
 454         } else {
 455                 if(obj != NULL && !(*env)->IsInstanceOf(env, obj, classType)) {
 456                         JCL_ThrowException(env, "java/lang/IllegalArgumentException", "Argument not of correct object type.");
 457                         return retval;
 458                 }
 459                 retval.l = obj;
 460         }
 461         return retval;
 462 }
 463