1 /* 2 * Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 #include <stdlib.h> 27 #include <string.h> 28 29 #include "jvm.h" 30 #include "jni.h" 31 #include "jni_util.h" 32 33 /* Due to a bug in the win32 C runtime library strings 34 * such as "z:" need to be appended with a "." so we 35 * must allocate at least 4 bytes to allow room for 36 * this expansion. See 4235353 for details. 37 */ 38 #define MALLOC_MIN4(len) ((char *)malloc((len) + 1 < 4 ? 4 : (len) + 1)) 39 40 /** 41 * Throw a Java exception by name. Similar to SignalError. 42 */ 43 JNIEXPORT void JNICALL 44 JNU_ThrowByName(JNIEnv *env, const char *name, const char *msg) 45 { 46 jclass cls = (*env)->FindClass(env, name); 47 48 if (cls != 0) /* Otherwise an exception has already been thrown */ 49 (*env)->ThrowNew(env, cls, msg); 50 } 51 52 /* JNU_Throw common exceptions */ 53 54 JNIEXPORT void JNICALL 55 JNU_ThrowNullPointerException(JNIEnv *env, const char *msg) 56 { 57 JNU_ThrowByName(env, "java/lang/NullPointerException", msg); 58 } 59 60 JNIEXPORT void JNICALL 61 JNU_ThrowArrayIndexOutOfBoundsException(JNIEnv *env, const char *msg) 62 { 63 JNU_ThrowByName(env, "java/lang/ArrayIndexOutOfBoundsException", msg); 64 } 65 66 JNIEXPORT void JNICALL 67 JNU_ThrowOutOfMemoryError(JNIEnv *env, const char *msg) 68 { 69 JNU_ThrowByName(env, "java/lang/OutOfMemoryError", msg); 70 } 71 72 JNIEXPORT void JNICALL 73 JNU_ThrowIllegalArgumentException(JNIEnv *env, const char *msg) 74 { 75 JNU_ThrowByName(env, "java/lang/IllegalArgumentException", msg); 76 } 77 78 JNIEXPORT void JNICALL 79 JNU_ThrowIllegalAccessError(JNIEnv *env, const char *msg) 80 { 81 JNU_ThrowByName(env, "java/lang/IllegalAccessError", msg); 82 } 83 84 JNIEXPORT void JNICALL 85 JNU_ThrowIllegalAccessException(JNIEnv *env, const char *msg) 86 { 87 JNU_ThrowByName(env, "java/lang/IllegalAccessException", msg); 88 } 89 90 JNIEXPORT void JNICALL 91 JNU_ThrowInternalError(JNIEnv *env, const char *msg) 92 { 93 JNU_ThrowByName(env, "java/lang/InternalError", msg); 94 } 95 96 JNIEXPORT void JNICALL 97 JNU_ThrowNoSuchFieldException(JNIEnv *env, const char *msg) 98 { 99 JNU_ThrowByName(env, "java/lang/NoSuchFieldException", msg); 100 } 101 102 JNIEXPORT void JNICALL 103 JNU_ThrowNoSuchMethodException(JNIEnv *env, const char *msg) 104 { 105 JNU_ThrowByName(env, "java/lang/NoSuchMethodException", msg); 106 } 107 108 JNIEXPORT void JNICALL 109 JNU_ThrowClassNotFoundException(JNIEnv *env, const char *msg) 110 { 111 JNU_ThrowByName(env, "java/lang/ClassNotFoundException", msg); 112 } 113 114 JNIEXPORT void JNICALL 115 JNU_ThrowNumberFormatException(JNIEnv *env, const char *msg) 116 { 117 JNU_ThrowByName(env, "java/lang/NumberFormatException", msg); 118 } 119 120 JNIEXPORT void JNICALL 121 JNU_ThrowIOException(JNIEnv *env, const char *msg) 122 { 123 JNU_ThrowByName(env, "java/io/IOException", msg); 124 } 125 126 JNIEXPORT void JNICALL 127 JNU_ThrowNoSuchFieldError(JNIEnv *env, const char *msg) 128 { 129 JNU_ThrowByName(env, "java/lang/NoSuchFieldError", msg); 130 } 131 132 JNIEXPORT void JNICALL 133 JNU_ThrowNoSuchMethodError(JNIEnv *env, const char *msg) 134 { 135 JNU_ThrowByName(env, "java/lang/NoSuchMethodError", msg); 136 } 137 138 JNIEXPORT void JNICALL 139 JNU_ThrowStringIndexOutOfBoundsException(JNIEnv *env, const char *msg) 140 { 141 JNU_ThrowByName(env, "java/lang/StringIndexOutOfBoundsException", msg); 142 } 143 144 JNIEXPORT void JNICALL 145 JNU_ThrowInstantiationException(JNIEnv *env, const char *msg) 146 { 147 JNU_ThrowByName(env, "java/lang/InstantiationException", msg); 148 } 149 150 /* 151 * Throw an exception by name, using the string returned by 152 * getLastErrorString for the detail string. If the last-error 153 * string is NULL, use the given default detail string. 154 */ 155 JNIEXPORT void JNICALL 156 JNU_ThrowByNameWithLastError(JNIEnv *env, const char *name, 157 const char *defaultDetail) 158 { 159 char buf[256]; 160 size_t n = getLastErrorString(buf, sizeof(buf)); 161 162 if (n > 0) { 163 jstring s = JNU_NewStringPlatform(env, buf); 164 if (s != NULL) { 165 jobject x = JNU_NewObjectByName(env, name, 166 "(Ljava/lang/String;)V", s); 167 if (x != NULL) { 168 (*env)->Throw(env, x); 169 } 170 } 171 } 172 if (!(*env)->ExceptionOccurred(env)) { 173 JNU_ThrowByName(env, name, defaultDetail); 174 } 175 } 176 177 /* 178 * Throw an exception by name, using a given message and the string 179 * returned by getLastErrorString to construct the detail string. 180 */ 181 JNIEXPORT void JNICALL 182 JNU_ThrowByNameWithMessageAndLastError 183 (JNIEnv *env, const char *name, const char *message) 184 { 185 char buf[256]; 186 size_t n = getLastErrorString(buf, sizeof(buf)); 187 size_t messagelen = message == NULL ? 0 : strlen(message); 188 189 if (n > 0) { 190 jstring s = JNU_NewStringPlatform(env, buf); 191 if (s != NULL) { 192 jobject x = NULL; 193 if (messagelen) { 194 jstring s2 = NULL; 195 size_t messageextlen = messagelen + 4; 196 char *str1 = (char *)malloc((messageextlen) * sizeof(char)); 197 if (str1 == 0) { 198 JNU_ThrowOutOfMemoryError(env, 0); 199 return; 200 } 201 jio_snprintf(str1, messageextlen, " (%s)", message); 202 s2 = (*env)->NewStringUTF(env, str1); 203 free(str1); 204 JNU_CHECK_EXCEPTION(env); 205 if (s2 != NULL) { 206 jstring s3 = JNU_CallMethodByName( 207 env, NULL, s, "concat", 208 "(Ljava/lang/String;)Ljava/lang/String;", 209 s2).l; 210 (*env)->DeleteLocalRef(env, s2); 211 JNU_CHECK_EXCEPTION(env); 212 if (s3 != NULL) { 213 (*env)->DeleteLocalRef(env, s); 214 s = s3; 215 } 216 } 217 } 218 x = JNU_NewObjectByName(env, name, "(Ljava/lang/String;)V", s); 219 if (x != NULL) { 220 (*env)->Throw(env, x); 221 } 222 } 223 } 224 225 if (!(*env)->ExceptionOccurred(env)) { 226 if (messagelen) { 227 JNU_ThrowByName(env, name, message); 228 } else { 229 JNU_ThrowByName(env, name, "no further information"); 230 } 231 } 232 } 233 234 /* 235 * Convenience method. 236 * Call JNU_ThrowByNameWithLastError for java.io.IOException. 237 */ 238 JNIEXPORT void JNICALL 239 JNU_ThrowIOExceptionWithLastError(JNIEnv *env, const char *defaultDetail) 240 { 241 JNU_ThrowByNameWithLastError(env, "java/io/IOException", defaultDetail); 242 } 243 244 245 JNIEXPORT jvalue JNICALL 246 JNU_CallStaticMethodByName(JNIEnv *env, 247 jboolean *hasException, 248 const char *class_name, 249 const char *name, 250 const char *signature, 251 ...) 252 { 253 jclass clazz; 254 jmethodID mid; 255 va_list args; 256 jvalue result; 257 const char *p = signature; 258 259 /* find out the return type */ 260 while (*p && *p != ')') 261 p++; 262 p++; 263 264 result.i = 0; 265 266 if ((*env)->EnsureLocalCapacity(env, 3) < 0) 267 goto done2; 268 269 clazz = (*env)->FindClass(env, class_name); 270 if (clazz == 0) 271 goto done2; 272 mid = (*env)->GetStaticMethodID(env, clazz, name, signature); 273 if (mid == 0) 274 goto done1; 275 va_start(args, signature); 276 switch (*p) { 277 case 'V': 278 (*env)->CallStaticVoidMethodV(env, clazz, mid, args); 279 break; 280 case '[': 281 case 'L': 282 result.l = (*env)->CallStaticObjectMethodV(env, clazz, mid, args); 283 break; 284 case 'Z': 285 result.z = (*env)->CallStaticBooleanMethodV(env, clazz, mid, args); 286 break; 287 case 'B': 288 result.b = (*env)->CallStaticByteMethodV(env, clazz, mid, args); 289 break; 290 case 'C': 291 result.c = (*env)->CallStaticCharMethodV(env, clazz, mid, args); 292 break; 293 case 'S': 294 result.s = (*env)->CallStaticShortMethodV(env, clazz, mid, args); 295 break; 296 case 'I': 297 result.i = (*env)->CallStaticIntMethodV(env, clazz, mid, args); 298 break; 299 case 'J': 300 result.j = (*env)->CallStaticLongMethodV(env, clazz, mid, args); 301 break; 302 case 'F': 303 result.f = (*env)->CallStaticFloatMethodV(env, clazz, mid, args); 304 break; 305 case 'D': 306 result.d = (*env)->CallStaticDoubleMethodV(env, clazz, mid, args); 307 break; 308 default: 309 (*env)->FatalError(env, "JNU_CallStaticMethodByName: illegal signature"); 310 } 311 va_end(args); 312 313 done1: 314 (*env)->DeleteLocalRef(env, clazz); 315 done2: 316 if (hasException) { 317 *hasException = (*env)->ExceptionCheck(env); 318 } 319 return result; 320 } 321 322 JNIEXPORT jvalue JNICALL 323 JNU_CallMethodByName(JNIEnv *env, 324 jboolean *hasException, 325 jobject obj, 326 const char *name, 327 const char *signature, 328 ...) 329 { 330 jvalue result; 331 va_list args; 332 333 va_start(args, signature); 334 result = JNU_CallMethodByNameV(env, hasException, obj, name, signature, 335 args); 336 va_end(args); 337 338 return result; 339 } 340 341 342 JNIEXPORT jvalue JNICALL 343 JNU_CallMethodByNameV(JNIEnv *env, 344 jboolean *hasException, 345 jobject obj, 346 const char *name, 347 const char *signature, 348 va_list args) 349 { 350 jclass clazz; 351 jmethodID mid; 352 jvalue result; 353 const char *p = signature; 354 355 /* find out the return type */ 356 while (*p && *p != ')') 357 p++; 358 p++; 359 360 result.i = 0; 361 362 if ((*env)->EnsureLocalCapacity(env, 3) < 0) 363 goto done2; 364 365 clazz = (*env)->GetObjectClass(env, obj); 366 mid = (*env)->GetMethodID(env, clazz, name, signature); 367 if (mid == 0) 368 goto done1; 369 370 switch (*p) { 371 case 'V': 372 (*env)->CallVoidMethodV(env, obj, mid, args); 373 break; 374 case '[': 375 case 'L': 376 result.l = (*env)->CallObjectMethodV(env, obj, mid, args); 377 break; 378 case 'Z': 379 result.z = (*env)->CallBooleanMethodV(env, obj, mid, args); 380 break; 381 case 'B': 382 result.b = (*env)->CallByteMethodV(env, obj, mid, args); 383 break; 384 case 'C': 385 result.c = (*env)->CallCharMethodV(env, obj, mid, args); 386 break; 387 case 'S': 388 result.s = (*env)->CallShortMethodV(env, obj, mid, args); 389 break; 390 case 'I': 391 result.i = (*env)->CallIntMethodV(env, obj, mid, args); 392 break; 393 case 'J': 394 result.j = (*env)->CallLongMethodV(env, obj, mid, args); 395 break; 396 case 'F': 397 result.f = (*env)->CallFloatMethodV(env, obj, mid, args); 398 break; 399 case 'D': 400 result.d = (*env)->CallDoubleMethodV(env, obj, mid, args); 401 break; 402 default: 403 (*env)->FatalError(env, "JNU_CallMethodByNameV: illegal signature"); 404 } 405 done1: 406 (*env)->DeleteLocalRef(env, clazz); 407 done2: 408 if (hasException) { 409 *hasException = (*env)->ExceptionCheck(env); 410 } 411 return result; 412 } 413 414 JNIEXPORT jobject JNICALL 415 JNU_NewObjectByName(JNIEnv *env, const char *class_name, 416 const char *constructor_sig, ...) 417 { 418 jobject obj = NULL; 419 420 jclass cls = 0; 421 jmethodID cls_initMID; 422 va_list args; 423 424 if ((*env)->EnsureLocalCapacity(env, 2) < 0) 425 goto done; 426 427 cls = (*env)->FindClass(env, class_name); 428 if (cls == 0) { 429 goto done; 430 } 431 cls_initMID = (*env)->GetMethodID(env, cls, 432 "<init>", constructor_sig); 433 if (cls_initMID == NULL) { 434 goto done; 435 } 436 va_start(args, constructor_sig); 437 obj = (*env)->NewObjectV(env, cls, cls_initMID, args); 438 va_end(args); 439 440 done: 441 (*env)->DeleteLocalRef(env, cls); 442 return obj; 443 } 444 445 /* Optimized for charset ISO_8559_1 */ 446 static jstring 447 newSizedString8859_1(JNIEnv *env, const char *str, const int len) 448 { 449 jchar buf[512]; 450 jchar *str1; 451 jstring result; 452 int i; 453 454 if (len > 512) { 455 str1 = (jchar *)malloc(len * sizeof(jchar)); 456 if (str1 == 0) { 457 JNU_ThrowOutOfMemoryError(env, 0); 458 return 0; 459 } 460 } else 461 str1 = buf; 462 463 for (i=0;i<len;i++) 464 str1[i] = (unsigned char)str[i]; 465 result = (*env)->NewString(env, str1, len); 466 if (str1 != buf) 467 free(str1); 468 return result; 469 } 470 471 static jstring 472 newString8859_1(JNIEnv *env, const char *str) 473 { 474 int len = (int)strlen(str); 475 return newSizedString8859_1(env, str, len); 476 } 477 478 static const jbyte LATIN1 = 0; 479 static const jbyte UTF16 = 1; 480 481 static const char* 482 getString8859_1Chars(JNIEnv *env, jstring jstr) 483 { 484 int i; 485 char *result; 486 jint len = (*env)->GetStringLength(env, jstr); 487 const jchar *str = (*env)->GetStringCritical(env, jstr, 0); 488 if (str == 0) { 489 return 0; 490 } 491 492 result = MALLOC_MIN4(len); 493 if (result == 0) { 494 (*env)->ReleaseStringCritical(env, jstr, str); 495 JNU_ThrowOutOfMemoryError(env, 0); 496 return 0; 497 } 498 499 for (i=0; i<len; i++) { 500 jchar unicode = str[i]; 501 if (unicode <= 0x00ff) 502 result[i] = (char)unicode; 503 else 504 result[i] = '?'; 505 } 506 507 result[len] = 0; 508 (*env)->ReleaseStringCritical(env, jstr, str); 509 return result; 510 } 511 512 513 /* Optimized for charset ISO646-US (us-ascii) */ 514 static jstring 515 newString646_US(JNIEnv *env, const char *str) 516 { 517 int len = (int)strlen(str); 518 jchar buf[512]; 519 jchar *str1; 520 jstring result; 521 int i; 522 523 if (len > 512) { 524 str1 = (jchar *)malloc(len * sizeof(jchar)); 525 if (str1 == 0) { 526 JNU_ThrowOutOfMemoryError(env, 0); 527 return 0; 528 } 529 } else 530 str1 = buf; 531 532 for (i=0; i<len; i++) { 533 unsigned char c = (unsigned char)str[i]; 534 if (c <= 0x7f) 535 str1[i] = c; 536 else 537 str1[i] = '?'; 538 } 539 540 result = (*env)->NewString(env, str1, len); 541 if (str1 != buf) 542 free(str1); 543 return result; 544 } 545 546 static const char* 547 getString646_USChars(JNIEnv *env, jstring jstr) 548 { 549 int i; 550 char *result; 551 jint len = (*env)->GetStringLength(env, jstr); 552 const jchar *str = (*env)->GetStringCritical(env, jstr, 0); 553 if (str == 0) { 554 return 0; 555 } 556 557 result = MALLOC_MIN4(len); 558 if (result == 0) { 559 (*env)->ReleaseStringCritical(env, jstr, str); 560 JNU_ThrowOutOfMemoryError(env, 0); 561 return 0; 562 } 563 564 for (i=0; i<len; i++) { 565 jchar unicode = str[i]; 566 if (unicode <= 0x007f ) 567 result[i] = (char)unicode; 568 else 569 result[i] = '?'; 570 } 571 572 result[len] = 0; 573 (*env)->ReleaseStringCritical(env, jstr, str); 574 return result; 575 } 576 577 /* enumeration of c1 row from Cp1252 */ 578 static int cp1252c1chars[32] = { 579 0x20AC,0xFFFD,0x201A,0x0192,0x201E,0x2026,0x2020,0x2021, 580 0x02C6,0x2030,0x0160,0x2039,0x0152,0xFFFD,0x017D,0xFFFD, 581 0xFFFD,0x2018,0x2019,0x201C,0x201D,0x2022,0x2013,0x2014, 582 0x02Dc,0x2122,0x0161,0x203A,0x0153,0xFFFD,0x017E,0x0178 583 }; 584 585 /* Optimized for charset Cp1252 */ 586 static jstring 587 newStringCp1252(JNIEnv *env, const char *str) 588 { 589 int len = (int) strlen(str); 590 jchar buf[512]; 591 jchar *str1; 592 jstring result; 593 int i; 594 if (len > 512) { 595 str1 = (jchar *)malloc(len * sizeof(jchar)); 596 if (str1 == 0) { 597 JNU_ThrowOutOfMemoryError(env, 0); 598 return 0; 599 } 600 } else 601 str1 = buf; 602 603 for (i=0; i<len; i++) { 604 unsigned char c = (unsigned char)str[i]; 605 if ((c >= 0x80) && (c <= 0x9f)) 606 str1[i] = cp1252c1chars[c-128]; 607 else 608 str1[i] = c; 609 } 610 611 result = (*env)->NewString(env, str1, len); 612 if (str1 != buf) 613 free(str1); 614 return result; 615 } 616 617 static const char* 618 getStringCp1252Chars(JNIEnv *env, jstring jstr) 619 { 620 int i; 621 char *result; 622 jint len = (*env)->GetStringLength(env, jstr); 623 const jchar *str = (*env)->GetStringCritical(env, jstr, 0); 624 if (str == 0) { 625 return 0; 626 } 627 628 result = MALLOC_MIN4(len); 629 if (result == 0) { 630 (*env)->ReleaseStringCritical(env, jstr, str); 631 JNU_ThrowOutOfMemoryError(env, 0); 632 return 0; 633 } 634 635 for (i=0; i<len; i++) { 636 jchar c = str[i]; 637 if (c < 256) 638 result[i] = (char)c; 639 else switch(c) { 640 case 0x20AC: result[i] = (char)0x80; break; 641 case 0x201A: result[i] = (char)0x82; break; 642 case 0x0192: result[i] = (char)0x83; break; 643 case 0x201E: result[i] = (char)0x84; break; 644 case 0x2026: result[i] = (char)0x85; break; 645 case 0x2020: result[i] = (char)0x86; break; 646 case 0x2021: result[i] = (char)0x87; break; 647 case 0x02C6: result[i] = (char)0x88; break; 648 case 0x2030: result[i] = (char)0x89; break; 649 case 0x0160: result[i] = (char)0x8A; break; 650 case 0x2039: result[i] = (char)0x8B; break; 651 case 0x0152: result[i] = (char)0x8C; break; 652 case 0x017D: result[i] = (char)0x8E; break; 653 case 0x2018: result[i] = (char)0x91; break; 654 case 0x2019: result[i] = (char)0x92; break; 655 case 0x201C: result[i] = (char)0x93; break; 656 case 0x201D: result[i] = (char)0x94; break; 657 case 0x2022: result[i] = (char)0x95; break; 658 case 0x2013: result[i] = (char)0x96; break; 659 case 0x2014: result[i] = (char)0x97; break; 660 case 0x02DC: result[i] = (char)0x98; break; 661 case 0x2122: result[i] = (char)0x99; break; 662 case 0x0161: result[i] = (char)0x9A; break; 663 case 0x203A: result[i] = (char)0x9B; break; 664 case 0x0153: result[i] = (char)0x9C; break; 665 case 0x017E: result[i] = (char)0x9E; break; 666 case 0x0178: result[i] = (char)0x9F; break; 667 default: result[i] = '?'; break; 668 } 669 } 670 671 result[len] = 0; 672 (*env)->ReleaseStringCritical(env, jstr, str); 673 return result; 674 } 675 676 static int fastEncoding = NO_ENCODING_YET; 677 static jstring jnuEncoding = NULL; 678 679 /* Cached method IDs */ 680 static jmethodID String_init_ID; /* String(byte[], enc) */ 681 static jmethodID String_getBytes_ID; /* String.getBytes(enc) */ 682 683 /* Cached field IDs */ 684 static jfieldID String_coder_ID; /* String.coder */ 685 static jfieldID String_value_ID; /* String.value */ 686 687 static jboolean isJNUEncodingSupported = JNI_FALSE; 688 static jboolean jnuEncodingSupported(JNIEnv *env) { 689 jboolean exe; 690 if (isJNUEncodingSupported == JNI_TRUE) { 691 return JNI_TRUE; 692 } 693 isJNUEncodingSupported = (jboolean) JNU_CallStaticMethodByName ( 694 env, &exe, 695 "java/nio/charset/Charset", 696 "isSupported", 697 "(Ljava/lang/String;)Z", 698 jnuEncoding).z; 699 return isJNUEncodingSupported; 700 } 701 702 /* Create a new string by converting str to a heap-allocated byte array and 703 * calling the appropriate String constructor. 704 */ 705 static jstring 706 newSizedStringJava(JNIEnv *env, const char *str, const int len) 707 { 708 jstring result = NULL; 709 jbyteArray bytes = 0; 710 711 if ((*env)->EnsureLocalCapacity(env, 2) < 0) 712 return NULL; 713 714 bytes = (*env)->NewByteArray(env, len); 715 if (bytes != NULL) { 716 jclass strClazz = JNU_ClassString(env); 717 CHECK_NULL_RETURN(strClazz, 0); 718 (*env)->SetByteArrayRegion(env, bytes, 0, len, (jbyte *)str); 719 if (jnuEncodingSupported(env)) { 720 result = (*env)->NewObject(env, strClazz, 721 String_init_ID, bytes, jnuEncoding); 722 } else { 723 /*If the encoding specified in sun.jnu.encoding is not endorsed 724 by "Charset.isSupported" we have to fall back to use String(byte[]) 725 explicitly here without specifying the encoding name, in which the 726 StringCoding class will pickup the iso-8859-1 as the fallback 727 converter for us. 728 */ 729 jmethodID mid = (*env)->GetMethodID(env, strClazz, 730 "<init>", "([B)V"); 731 if (mid != NULL) { 732 result = (*env)->NewObject(env, strClazz, mid, bytes); 733 } 734 } 735 (*env)->DeleteLocalRef(env, bytes); 736 return result; 737 } 738 return NULL; 739 } 740 741 static jstring 742 newStringJava(JNIEnv *env, const char *str) 743 { 744 int len = (int)strlen(str); 745 return newSizedStringJava(env, str, len); 746 } 747 748 /* Optimized for charset UTF-8 */ 749 static jstring 750 newStringUTF8(JNIEnv *env, const char *str) 751 { 752 int len; 753 const unsigned char *p; 754 unsigned char asciiCheck; 755 for (asciiCheck = 0, p = (const unsigned char*)str; *p != '\0'; p++) { 756 asciiCheck |= *p; 757 } 758 len = (int)((const char*)p - str); 759 760 if (asciiCheck < 0x80) { 761 // ascii fast-path 762 return newSizedString8859_1(env, str, len); 763 } 764 765 return newSizedStringJava(env, str, len); 766 } 767 768 /* Initialize the fast encoding. If the "sun.jnu.encoding" property 769 * has not yet been set, we leave fastEncoding == NO_ENCODING_YET. 770 */ 771 void 772 initializeEncoding(JNIEnv *env) 773 { 774 jstring propname = 0; 775 jstring enc = 0; 776 jclass strClazz = NULL; 777 778 if ((*env)->EnsureLocalCapacity(env, 3) < 0) 779 return; 780 781 strClazz = JNU_ClassString(env); 782 CHECK_NULL(strClazz); 783 784 propname = (*env)->NewStringUTF(env, "sun.jnu.encoding"); 785 if (propname) { 786 jboolean exc; 787 enc = JNU_CallStaticMethodByName 788 (env, 789 &exc, 790 "java/lang/System", 791 "getProperty", 792 "(Ljava/lang/String;)Ljava/lang/String;", 793 propname).l; 794 if (!exc) { 795 if (enc) { 796 const char* encname = (*env)->GetStringUTFChars(env, enc, 0); 797 if (encname) { 798 /* 799 * On Solaris with nl_langinfo() called in GetJavaProperties(): 800 * 801 * locale undefined -> NULL -> hardcoded default 802 * "C" locale -> "" -> hardcoded default (on 2.6) 803 * "C" locale -> "ISO646-US" (on Sol 7/8) 804 * "en_US" locale -> "ISO8859-1" 805 * "en_GB" locale -> "ISO8859-1" (on Sol 7/8) 806 * "en_UK" locale -> "ISO8859-1" (on 2.6) 807 */ 808 if ((strcmp(encname, "8859_1") == 0) || 809 (strcmp(encname, "ISO8859-1") == 0) || 810 (strcmp(encname, "ISO8859_1") == 0) || 811 (strcmp(encname, "ISO-8859-1") == 0)) { 812 fastEncoding = FAST_8859_1; 813 } else if (strcmp(encname, "UTF-8") == 0) { 814 fastEncoding = FAST_UTF_8; 815 jnuEncoding = (jstring)(*env)->NewGlobalRef(env, enc); 816 } else if (strcmp(encname, "ISO646-US") == 0) { 817 fastEncoding = FAST_646_US; 818 } else if (strcmp(encname, "Cp1252") == 0 || 819 /* This is a temporary fix until we move */ 820 /* to wide character versions of all Windows */ 821 /* calls. */ 822 strcmp(encname, "utf-16le") == 0) { 823 fastEncoding = FAST_CP1252; 824 } else { 825 fastEncoding = NO_FAST_ENCODING; 826 jnuEncoding = (jstring)(*env)->NewGlobalRef(env, enc); 827 } 828 (*env)->ReleaseStringUTFChars(env, enc, encname); 829 } 830 } 831 } else { 832 (*env)->ExceptionClear(env); 833 } 834 } else { 835 (*env)->ExceptionClear(env); 836 } 837 (*env)->DeleteLocalRef(env, propname); 838 (*env)->DeleteLocalRef(env, enc); 839 840 /* Initialize method-id cache */ 841 String_getBytes_ID = (*env)->GetMethodID(env, strClazz, 842 "getBytes", "(Ljava/lang/String;)[B"); 843 CHECK_NULL(String_getBytes_ID); 844 String_init_ID = (*env)->GetMethodID(env, strClazz, 845 "<init>", "([BLjava/lang/String;)V"); 846 String_coder_ID = (*env)->GetFieldID(env, strClazz, "coder", "B"); 847 String_value_ID = (*env)->GetFieldID(env, strClazz, "value", "[B"); 848 } 849 850 JNIEXPORT jstring 851 NewStringPlatform(JNIEnv *env, const char *str) 852 { 853 return JNU_NewStringPlatform(env, str); 854 } 855 856 JNIEXPORT jstring JNICALL 857 JNU_NewStringPlatform(JNIEnv *env, const char *str) 858 { 859 if (fastEncoding == NO_ENCODING_YET) { 860 initializeEncoding(env); 861 JNU_CHECK_EXCEPTION_RETURN(env, NULL); 862 } 863 864 if ((fastEncoding == FAST_8859_1) || (fastEncoding == NO_ENCODING_YET)) 865 return newString8859_1(env, str); 866 if (fastEncoding == FAST_646_US) 867 return newString646_US(env, str); 868 if (fastEncoding == FAST_CP1252) 869 return newStringCp1252(env, str); 870 if (fastEncoding == FAST_UTF_8) 871 return newStringUTF8(env, str); 872 return newStringJava(env, str); 873 } 874 875 JNIEXPORT const char * 876 GetStringPlatformChars(JNIEnv *env, jstring jstr, jboolean *isCopy) 877 { 878 return JNU_GetStringPlatformChars(env, jstr, isCopy); 879 } 880 881 static const char* getStringBytes(JNIEnv *env, jstring jstr) { 882 char *result = NULL; 883 jbyteArray hab = 0; 884 885 if ((*env)->EnsureLocalCapacity(env, 2) < 0) 886 return 0; 887 888 if (jnuEncodingSupported(env)) { 889 hab = (*env)->CallObjectMethod(env, jstr, String_getBytes_ID, jnuEncoding); 890 } else { 891 jmethodID mid; 892 jclass strClazz = JNU_ClassString(env); 893 CHECK_NULL_RETURN(strClazz, 0); 894 mid = (*env)->GetMethodID(env, strClazz, 895 "getBytes", "()[B"); 896 if (mid != NULL) { 897 hab = (*env)->CallObjectMethod(env, jstr, mid); 898 } 899 } 900 901 if (!(*env)->ExceptionCheck(env)) { 902 jint len = (*env)->GetArrayLength(env, hab); 903 result = MALLOC_MIN4(len); 904 if (result == 0) { 905 JNU_ThrowOutOfMemoryError(env, 0); 906 (*env)->DeleteLocalRef(env, hab); 907 return 0; 908 } 909 (*env)->GetByteArrayRegion(env, hab, 0, len, (jbyte *)result); 910 result[len] = 0; /* NULL-terminate */ 911 } 912 913 (*env)->DeleteLocalRef(env, hab); 914 return result; 915 } 916 917 static const char* 918 getStringUTF8(JNIEnv *env, jstring jstr) 919 { 920 int i; 921 char *result; 922 jarray value; 923 jint len; 924 const jbyte *str; 925 jint rlen; 926 int ri; 927 jbyte coder = (*env)->GetByteField(env, jstr, String_coder_ID); 928 if (coder != LATIN1) { 929 return getStringBytes(env, jstr); 930 } 931 value = (jarray)(*env)->GetObjectField(env, jstr, String_value_ID); 932 len = (*env)->GetArrayLength(env, value); 933 str = (jbyte*)(*env)->GetPrimitiveArrayCritical(env, value, NULL); 934 935 if (str == NULL) { 936 return NULL; 937 } 938 939 rlen = len; 940 // we need two bytes for each latin-1 char above 127 (negative jbytes) 941 for (i = 0; i < len; i++) { 942 if (str[i] < 0) { 943 rlen++; 944 } 945 } 946 947 result = MALLOC_MIN4(rlen); 948 if (result == NULL) { 949 (*env)->ReleasePrimitiveArrayCritical(env, jstr, (void *)str, 0); 950 JNU_ThrowOutOfMemoryError(env, 0); 951 return NULL; 952 } 953 954 for (ri = 0, i = 0; i < len; i++) { 955 jbyte c = str[i]; 956 if (c < 0) { 957 result[ri++] = (char)(0xc0 | ((c & 0xff) >> 6)); 958 result[ri++] = (char)(0x80 | (c & 0x3f)); 959 } else { 960 result[ri++] = c; 961 } 962 } 963 result[rlen] = '\0'; 964 (*env)->ReleasePrimitiveArrayCritical(env, jstr, (void *)str, 0); 965 return result; 966 } 967 968 JNIEXPORT const char * JNICALL 969 JNU_GetStringPlatformChars(JNIEnv *env, jstring jstr, jboolean *isCopy) 970 { 971 972 if (isCopy) 973 *isCopy = JNI_TRUE; 974 975 if (fastEncoding == NO_ENCODING_YET) { 976 initializeEncoding(env); 977 JNU_CHECK_EXCEPTION_RETURN(env, 0); 978 } 979 980 if ((fastEncoding == FAST_8859_1) || (fastEncoding == NO_ENCODING_YET)) 981 return getString8859_1Chars(env, jstr); 982 if (fastEncoding == FAST_646_US) 983 return getString646_USChars(env, jstr); 984 if (fastEncoding == FAST_CP1252) 985 return getStringCp1252Chars(env, jstr); 986 if (fastEncoding == FAST_UTF_8) 987 return getStringUTF8(env, jstr); 988 else 989 return getStringBytes(env, jstr); 990 } 991 JNIEXPORT void JNICALL 992 JNU_ReleaseStringPlatformChars(JNIEnv *env, jstring jstr, const char *str) 993 { 994 free((void *)str); 995 } 996 997 /* 998 * Export the platform dependent path canonicalization so that 999 * VM can find it when loading system classes. 1000 * This function is also used by the instrumentation agent. 1001 */ 1002 extern int canonicalize(char *path, const char *out, int len); 1003 1004 JNIEXPORT int 1005 Canonicalize(JNIEnv *unused, char *orig, char *out, int len) 1006 { 1007 /* canonicalize an already natived path */ 1008 return canonicalize(orig, out, len); 1009 } 1010 1011 JNIEXPORT jclass JNICALL 1012 JNU_ClassString(JNIEnv *env) 1013 { 1014 static jclass cls = 0; 1015 if (cls == 0) { 1016 jclass c; 1017 if ((*env)->EnsureLocalCapacity(env, 1) < 0) 1018 return 0; 1019 c = (*env)->FindClass(env, "java/lang/String"); 1020 CHECK_NULL_RETURN(c, NULL); 1021 cls = (*env)->NewGlobalRef(env, c); 1022 (*env)->DeleteLocalRef(env, c); 1023 } 1024 return cls; 1025 } 1026 1027 JNIEXPORT jclass JNICALL 1028 JNU_ClassClass(JNIEnv *env) 1029 { 1030 static jclass cls = 0; 1031 if (cls == 0) { 1032 jclass c; 1033 if ((*env)->EnsureLocalCapacity(env, 1) < 0) 1034 return 0; 1035 c = (*env)->FindClass(env, "java/lang/Class"); 1036 CHECK_NULL_RETURN(c, NULL); 1037 cls = (*env)->NewGlobalRef(env, c); 1038 (*env)->DeleteLocalRef(env, c); 1039 } 1040 return cls; 1041 } 1042 1043 JNIEXPORT jclass JNICALL 1044 JNU_ClassObject(JNIEnv *env) 1045 { 1046 static jclass cls = 0; 1047 if (cls == 0) { 1048 jclass c; 1049 if ((*env)->EnsureLocalCapacity(env, 1) < 0) 1050 return 0; 1051 c = (*env)->FindClass(env, "java/lang/Object"); 1052 CHECK_NULL_RETURN(c, NULL); 1053 cls = (*env)->NewGlobalRef(env, c); 1054 (*env)->DeleteLocalRef(env, c); 1055 } 1056 return cls; 1057 } 1058 1059 JNIEXPORT jclass JNICALL 1060 JNU_ClassThrowable(JNIEnv *env) 1061 { 1062 static jclass cls = 0; 1063 if (cls == 0) { 1064 jclass c; 1065 if ((*env)->EnsureLocalCapacity(env, 1) < 0) 1066 return 0; 1067 c = (*env)->FindClass(env, "java/lang/Throwable"); 1068 CHECK_NULL_RETURN(c, NULL); 1069 cls = (*env)->NewGlobalRef(env, c); 1070 (*env)->DeleteLocalRef(env, c); 1071 } 1072 return cls; 1073 } 1074 1075 JNIEXPORT jint JNICALL 1076 JNU_CopyObjectArray(JNIEnv *env, jobjectArray dst, jobjectArray src, 1077 jint count) 1078 { 1079 int i; 1080 if ((*env)->EnsureLocalCapacity(env, 1) < 0) 1081 return -1; 1082 for (i=0; i<count; i++) { 1083 jstring p = (*env)->GetObjectArrayElement(env, src, i); 1084 (*env)->SetObjectArrayElement(env, dst, i, p); 1085 (*env)->DeleteLocalRef(env, p); 1086 } 1087 return 0; 1088 } 1089 1090 JNIEXPORT void * JNICALL 1091 JNU_GetEnv(JavaVM *vm, jint version) 1092 { 1093 void *env; 1094 (*vm)->GetEnv(vm, &env, version); 1095 return env; 1096 } 1097 1098 JNIEXPORT jint JNICALL 1099 JNU_IsInstanceOfByName(JNIEnv *env, jobject object, char* classname) 1100 { 1101 jclass cls; 1102 if ((*env)->EnsureLocalCapacity(env, 1) < 0) 1103 return JNI_ERR; 1104 cls = (*env)->FindClass(env, classname); 1105 if (cls != NULL) { 1106 jint result = (*env)->IsInstanceOf(env, object, cls); 1107 (*env)->DeleteLocalRef(env, cls); 1108 return result; 1109 } 1110 return JNI_ERR; 1111 } 1112 1113 JNIEXPORT jboolean JNICALL 1114 JNU_Equals(JNIEnv *env, jobject object1, jobject object2) 1115 { 1116 static jmethodID mid = NULL; 1117 if (mid == NULL) { 1118 jclass objClazz = JNU_ClassObject(env); 1119 CHECK_NULL_RETURN(objClazz, JNI_FALSE); 1120 mid = (*env)->GetMethodID(env, objClazz, "equals", 1121 "(Ljava/lang/Object;)Z"); 1122 CHECK_NULL_RETURN(mid, JNI_FALSE); 1123 } 1124 return (*env)->CallBooleanMethod(env, object1, mid, object2); 1125 } 1126 1127 1128 /************************************************************************ 1129 * Thread calls 1130 */ 1131 1132 static jmethodID Object_waitMID; 1133 static jmethodID Object_notifyMID; 1134 static jmethodID Object_notifyAllMID; 1135 1136 JNIEXPORT void JNICALL 1137 JNU_MonitorWait(JNIEnv *env, jobject object, jlong timeout) 1138 { 1139 if (object == NULL) { 1140 JNU_ThrowNullPointerException(env, "JNU_MonitorWait argument"); 1141 return; 1142 } 1143 if (Object_waitMID == NULL) { 1144 jclass cls = JNU_ClassObject(env); 1145 if (cls == NULL) { 1146 return; 1147 } 1148 Object_waitMID = (*env)->GetMethodID(env, cls, "wait", "(J)V"); 1149 if (Object_waitMID == NULL) { 1150 return; 1151 } 1152 } 1153 (*env)->CallVoidMethod(env, object, Object_waitMID, timeout); 1154 } 1155 1156 JNIEXPORT void JNICALL 1157 JNU_Notify(JNIEnv *env, jobject object) 1158 { 1159 if (object == NULL) { 1160 JNU_ThrowNullPointerException(env, "JNU_Notify argument"); 1161 return; 1162 } 1163 if (Object_notifyMID == NULL) { 1164 jclass cls = JNU_ClassObject(env); 1165 if (cls == NULL) { 1166 return; 1167 } 1168 Object_notifyMID = (*env)->GetMethodID(env, cls, "notify", "()V"); 1169 if (Object_notifyMID == NULL) { 1170 return; 1171 } 1172 } 1173 (*env)->CallVoidMethod(env, object, Object_notifyMID); 1174 } 1175 1176 JNIEXPORT void JNICALL 1177 JNU_NotifyAll(JNIEnv *env, jobject object) 1178 { 1179 if (object == NULL) { 1180 JNU_ThrowNullPointerException(env, "JNU_NotifyAll argument"); 1181 return; 1182 } 1183 if (Object_notifyAllMID == NULL) { 1184 jclass cls = JNU_ClassObject(env); 1185 if (cls == NULL) { 1186 return; 1187 } 1188 Object_notifyAllMID = (*env)->GetMethodID(env, cls,"notifyAll", "()V"); 1189 if (Object_notifyAllMID == NULL) { 1190 return; 1191 } 1192 } 1193 (*env)->CallVoidMethod(env, object, Object_notifyAllMID); 1194 } 1195 1196 1197 /************************************************************************ 1198 * Debugging utilities 1199 */ 1200 1201 JNIEXPORT void JNICALL 1202 JNU_PrintString(JNIEnv *env, char *hdr, jstring string) 1203 { 1204 if (string == NULL) { 1205 fprintf(stderr, "%s: is NULL\n", hdr); 1206 } else { 1207 const char *stringPtr = JNU_GetStringPlatformChars(env, string, 0); 1208 if (stringPtr == 0) 1209 return; 1210 fprintf(stderr, "%s: %s\n", hdr, stringPtr); 1211 JNU_ReleaseStringPlatformChars(env, string, stringPtr); 1212 } 1213 } 1214 1215 JNIEXPORT void JNICALL 1216 JNU_PrintClass(JNIEnv *env, char* hdr, jobject object) 1217 { 1218 if (object == NULL) { 1219 fprintf(stderr, "%s: object is NULL\n", hdr); 1220 return; 1221 } else { 1222 jclass cls = (*env)->GetObjectClass(env, object); 1223 jstring clsName = JNU_ToString(env, cls); 1224 if (clsName == NULL) { 1225 JNU_PrintString(env, hdr, clsName); 1226 } 1227 (*env)->DeleteLocalRef(env, cls); 1228 (*env)->DeleteLocalRef(env, clsName); 1229 } 1230 } 1231 1232 JNIEXPORT jstring JNICALL 1233 JNU_ToString(JNIEnv *env, jobject object) 1234 { 1235 if (object == NULL) { 1236 return (*env)->NewStringUTF(env, "NULL"); 1237 } else { 1238 return (jstring)JNU_CallMethodByName(env, 1239 NULL, 1240 object, 1241 "toString", 1242 "()Ljava/lang/String;").l; 1243 } 1244 } 1245 1246 JNIEXPORT jvalue JNICALL 1247 JNU_GetFieldByName(JNIEnv *env, 1248 jboolean *hasException, 1249 jobject obj, 1250 const char *name, 1251 const char *signature) 1252 { 1253 jclass cls; 1254 jfieldID fid; 1255 jvalue result; 1256 1257 result.i = 0; 1258 1259 if ((*env)->EnsureLocalCapacity(env, 3) < 0) 1260 goto done2; 1261 1262 cls = (*env)->GetObjectClass(env, obj); 1263 fid = (*env)->GetFieldID(env, cls, name, signature); 1264 if (fid == 0) 1265 goto done1; 1266 1267 switch (*signature) { 1268 case '[': 1269 case 'L': 1270 result.l = (*env)->GetObjectField(env, obj, fid); 1271 break; 1272 case 'Z': 1273 result.z = (*env)->GetBooleanField(env, obj, fid); 1274 break; 1275 case 'B': 1276 result.b = (*env)->GetByteField(env, obj, fid); 1277 break; 1278 case 'C': 1279 result.c = (*env)->GetCharField(env, obj, fid); 1280 break; 1281 case 'S': 1282 result.s = (*env)->GetShortField(env, obj, fid); 1283 break; 1284 case 'I': 1285 result.i = (*env)->GetIntField(env, obj, fid); 1286 break; 1287 case 'J': 1288 result.j = (*env)->GetLongField(env, obj, fid); 1289 break; 1290 case 'F': 1291 result.f = (*env)->GetFloatField(env, obj, fid); 1292 break; 1293 case 'D': 1294 result.d = (*env)->GetDoubleField(env, obj, fid); 1295 break; 1296 1297 default: 1298 (*env)->FatalError(env, "JNU_GetFieldByName: illegal signature"); 1299 } 1300 1301 done1: 1302 (*env)->DeleteLocalRef(env, cls); 1303 done2: 1304 if (hasException) { 1305 *hasException = (*env)->ExceptionCheck(env); 1306 } 1307 return result; 1308 } 1309 1310 JNIEXPORT void JNICALL 1311 JNU_SetFieldByName(JNIEnv *env, 1312 jboolean *hasException, 1313 jobject obj, 1314 const char *name, 1315 const char *signature, 1316 ...) 1317 { 1318 jclass cls; 1319 jfieldID fid; 1320 va_list args; 1321 1322 if ((*env)->EnsureLocalCapacity(env, 3) < 0) 1323 goto done2; 1324 1325 cls = (*env)->GetObjectClass(env, obj); 1326 fid = (*env)->GetFieldID(env, cls, name, signature); 1327 if (fid == 0) 1328 goto done1; 1329 1330 va_start(args, signature); 1331 switch (*signature) { 1332 case '[': 1333 case 'L': 1334 (*env)->SetObjectField(env, obj, fid, va_arg(args, jobject)); 1335 break; 1336 case 'Z': 1337 (*env)->SetBooleanField(env, obj, fid, (jboolean)va_arg(args, int)); 1338 break; 1339 case 'B': 1340 (*env)->SetByteField(env, obj, fid, (jbyte)va_arg(args, int)); 1341 break; 1342 case 'C': 1343 (*env)->SetCharField(env, obj, fid, (jchar)va_arg(args, int)); 1344 break; 1345 case 'S': 1346 (*env)->SetShortField(env, obj, fid, (jshort)va_arg(args, int)); 1347 break; 1348 case 'I': 1349 (*env)->SetIntField(env, obj, fid, va_arg(args, jint)); 1350 break; 1351 case 'J': 1352 (*env)->SetLongField(env, obj, fid, va_arg(args, jlong)); 1353 break; 1354 case 'F': 1355 (*env)->SetFloatField(env, obj, fid, (jfloat)va_arg(args, jdouble)); 1356 break; 1357 case 'D': 1358 (*env)->SetDoubleField(env, obj, fid, va_arg(args, jdouble)); 1359 break; 1360 1361 default: 1362 (*env)->FatalError(env, "JNU_SetFieldByName: illegal signature"); 1363 } 1364 va_end(args); 1365 1366 done1: 1367 (*env)->DeleteLocalRef(env, cls); 1368 done2: 1369 if (hasException) { 1370 *hasException = (*env)->ExceptionCheck(env); 1371 } 1372 } 1373 1374 JNIEXPORT jvalue JNICALL 1375 JNU_GetStaticFieldByName(JNIEnv *env, 1376 jboolean *hasException, 1377 const char *classname, 1378 const char *name, 1379 const char *signature) 1380 { 1381 jclass cls; 1382 jfieldID fid; 1383 jvalue result; 1384 1385 result.i = 0; 1386 1387 if ((*env)->EnsureLocalCapacity(env, 3) < 0) 1388 goto done2; 1389 1390 cls = (*env)->FindClass(env, classname); 1391 if (cls == 0) 1392 goto done2; 1393 1394 fid = (*env)->GetStaticFieldID(env, cls, name, signature); 1395 if (fid == 0) 1396 goto done1; 1397 1398 switch (*signature) { 1399 case '[': 1400 case 'L': 1401 result.l = (*env)->GetStaticObjectField(env, cls, fid); 1402 break; 1403 case 'Z': 1404 result.z = (*env)->GetStaticBooleanField(env, cls, fid); 1405 break; 1406 case 'B': 1407 result.b = (*env)->GetStaticByteField(env, cls, fid); 1408 break; 1409 case 'C': 1410 result.c = (*env)->GetStaticCharField(env, cls, fid); 1411 break; 1412 case 'S': 1413 result.s = (*env)->GetStaticShortField(env, cls, fid); 1414 break; 1415 case 'I': 1416 result.i = (*env)->GetStaticIntField(env, cls, fid); 1417 break; 1418 case 'J': 1419 result.j = (*env)->GetStaticLongField(env, cls, fid); 1420 break; 1421 case 'F': 1422 result.f = (*env)->GetStaticFloatField(env, cls, fid); 1423 break; 1424 case 'D': 1425 result.d = (*env)->GetStaticDoubleField(env, cls, fid); 1426 break; 1427 1428 default: 1429 (*env)->FatalError(env, "JNU_GetStaticFieldByName: illegal signature"); 1430 } 1431 1432 done1: 1433 (*env)->DeleteLocalRef(env, cls); 1434 done2: 1435 if (hasException) { 1436 *hasException = (*env)->ExceptionCheck(env); 1437 } 1438 return result; 1439 } 1440 1441 JNIEXPORT void JNICALL 1442 JNU_SetStaticFieldByName(JNIEnv *env, 1443 jboolean *hasException, 1444 const char *classname, 1445 const char *name, 1446 const char *signature, 1447 ...) 1448 { 1449 jclass cls; 1450 jfieldID fid; 1451 va_list args; 1452 1453 if ((*env)->EnsureLocalCapacity(env, 3) < 0) 1454 goto done2; 1455 1456 cls = (*env)->FindClass(env, classname); 1457 if (cls == 0) 1458 goto done2; 1459 1460 fid = (*env)->GetStaticFieldID(env, cls, name, signature); 1461 if (fid == 0) 1462 goto done1; 1463 1464 va_start(args, signature); 1465 switch (*signature) { 1466 case '[': 1467 case 'L': 1468 (*env)->SetStaticObjectField(env, cls, fid, va_arg(args, jobject)); 1469 break; 1470 case 'Z': 1471 (*env)->SetStaticBooleanField(env, cls, fid, (jboolean)va_arg(args, int)); 1472 break; 1473 case 'B': 1474 (*env)->SetStaticByteField(env, cls, fid, (jbyte)va_arg(args, int)); 1475 break; 1476 case 'C': 1477 (*env)->SetStaticCharField(env, cls, fid, (jchar)va_arg(args, int)); 1478 break; 1479 case 'S': 1480 (*env)->SetStaticShortField(env, cls, fid, (jshort)va_arg(args, int)); 1481 break; 1482 case 'I': 1483 (*env)->SetStaticIntField(env, cls, fid, va_arg(args, jint)); 1484 break; 1485 case 'J': 1486 (*env)->SetStaticLongField(env, cls, fid, va_arg(args, jlong)); 1487 break; 1488 case 'F': 1489 (*env)->SetStaticFloatField(env, cls, fid, (jfloat)va_arg(args, jdouble)); 1490 break; 1491 case 'D': 1492 (*env)->SetStaticDoubleField(env, cls, fid, va_arg(args, jdouble)); 1493 break; 1494 1495 default: 1496 (*env)->FatalError(env, "JNU_SetStaticFieldByName: illegal signature"); 1497 } 1498 va_end(args); 1499 1500 done1: 1501 (*env)->DeleteLocalRef(env, cls); 1502 done2: 1503 if (hasException) { 1504 *hasException = (*env)->ExceptionCheck(env); 1505 } 1506 }