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