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

    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);

   116 JNU_ThrowNumberFormatException(JNIEnv *env, const char *msg)

   117 {

   118     JNU_ThrowByName(env, "java/lang/NumberFormatException", msg);

   119 }

   120 

   121 JNIEXPORT void JNICALL

   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);

   848 JNIEXPORT jstring

   849 NewStringPlatform(JNIEnv *env, const char *str)

   850 {

   851     return JNU_NewStringPlatform(env, str);

   852 }

   853 

  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 

  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 

  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 }

  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 }