Robust/src/Runtime/jni/jni-stuff.c

   1 #include<jni.h>
   2 #include<jni-private.h>
   3 #include<stdlib.h>
   4 #include<stdio.h>
   5
   6 #ifndef MAC
   7 __thread struct jnireferences * jnirefs;
   8
   9 struct __jobject * getwrapper(void * objptr) {
  10   if ((jnirefs->index)>=MAXJNIREFS)
  11     printf("OVERFLOW IN JOBJECT\n");
  12   struct __jobject *ptr=&jnirefs->array[jnirefs->index++];
  13   ptr->ref=objptr;
  14   return ptr;
  15 }
  16
  17 void jnipushframe() {
  18   struct jnireferences *ptr=calloc(1, sizeof(struct jnireferences));
  19   ptr->next=jnirefs;
  20   jnirefs=ptr;
  21 }
  22
  23 void jnipopframe() {
  24   struct jnireferences *ptr=jnirefs;
  25   jnirefs=ptr->next;
  26   free(ptr);
  27 }
  28 #endif
  29
  30 jint RC_GetVersion(JNIEnv * env) {
  31   return JNI_VERSION_1_1;
  32 }
  33
  34 jclass RC_DefineClass(JNIEnv * env, const char * c,
  35                       jobject loader, const jbyte * buf,
  36                       jsize bufLen) {
  37   printf("MISSING FEATURE IN %d\n",__LINE__);
  38   return NULL;
  39 }
  40
  41 //should return jclass object corresponding to classname
  42 jclass RC_FindClass(JNIEnv * env, const char *classname) {
  43   printf("MISSING FEATURE IN %d\n",__LINE__);
  44   return NULL;
  45 }
  46
  47 jmethodID RC_FromReflectedMethod(JNIEnv * env, jobject mthdobj) {
  48   printf("MISSING FEATURE IN %d\n",__LINE__);
  49   return NULL;
  50 }
  51
  52 jfieldID RC_FromReflectedField(JNIEnv * env, jobject fldobj) {
  53   printf("MISSING FEATURE IN %d\n",__LINE__);
  54   return NULL;
  55 }
  56
  57 jobject RC_ToReflectedMethod(JNIEnv * env, jclass classobj, jmethodID methodobj, jboolean flag) {
  58   printf("MISSING FEATURE IN %d\n",__LINE__);
  59   return 0;
  60 }
  61
  62 jclass RC_GetSuperclass(JNIEnv * env, jclass classobj) {
  63   printf("MISSING FEATURE IN %d\n",__LINE__);
  64   return 0;
  65 }
  66
  67 jboolean RC_IsAssignableFrom(JNIEnv * env, jclass obj1, jclass obj2) {
  68   printf("MISSING FEATURE IN %d\n",__LINE__);
  69   return 0;
  70 }
  71
  72 jobject RC_ToReflectedField(JNIEnv * env, jclass obj1, jfieldID fld, jboolean flag) {
  73   printf("MISSING FEATURE IN %d\n",__LINE__);
  74   return NULL;
  75 }
  76
  77 jint RC_Throw(JNIEnv * env, jthrowable obj) {
  78   printf("MISSING FEATURE IN %d\n",__LINE__);
  79   return 0;
  80 }
  81
  82 jint RC_ThrowNew(JNIEnv * env, jclass cls, const char * str) {
  83   printf("MISSING FEATURE IN %d\n",__LINE__);
  84 }
  85
  86 jthrowable RC_ExceptionOccurred(JNIEnv * env) {
  87   printf("MISSING FEATURE IN %d\n",__LINE__);
  88   return NULL;
  89 }
  90
  91 void RC_ExceptionDescribe(JNIEnv * env) {
  92   printf("MISSING FEATURE IN %d\n",__LINE__);
  93 }
  94
  95 void RC_ExceptionClear(JNIEnv * env) {
  96   printf("MISSING FEATURE IN %d\n",__LINE__);
  97 }
  98
  99 void RC_FatalError(JNIEnv * env, const char * str) {
 100   printf("MISSING FEATURE IN %d\n",__LINE__);
 101 }
 102
 103 jint RC_PushLocalFrame(JNIEnv * env, jint n) {
 104   printf("MISSING FEATURE IN %d\n",__LINE__);
 105   return 0;
 106 }
 107
 108 jobject RC_PopLocalFrame(JNIEnv * env, jobject obj) {
 109   printf("MISSING FEATURE IN %d\n",__LINE__);
 110   return NULL;
 111 }
 112
 113 jobject RC_NewGlobalRef(JNIEnv * env, jobject obj) {
 114   printf("MISSING FEATURE IN %d\n",__LINE__);
 115   return NULL;
 116 }
 117
 118 void RC_DeleteGlobalRef(JNIEnv * env, jobject obj) {
 119   printf("MISSING FEATURE IN %d\n",__LINE__);
 120 }
 121
 122 void RC_DeleteLocalRef(JNIEnv * env, jobject obj) {
 123   printf("MISSING FEATURE IN %d\n",__LINE__);
 124 }
 125
 126 jboolean RC_IsSameObject(JNIEnv * env, jobject obj1, jobject jobj2) {
 127   printf("MISSING FEATURE IN %d\n",__LINE__);
 128   return 0;
 129 }
 130
 131 jobject RC_NewLocalRef(JNIEnv * env, jobject obj) {
 132   printf("MISSING FEATURE IN %d\n",__LINE__);
 133   return NULL;
 134 }
 135
 136 jint RC_EnsureLocalCapacity(JNIEnv * env, jint capacity) {
 137   printf("MISSING FEATURE IN %d\n",__LINE__);
 138   return 0;
 139 }
 140
 141 jobject RC_AllocObject(JNIEnv * env, jclass cls) {
 142   printf("MISSING FEATURE IN %d\n",__LINE__);
 143   return 0;
 144 }
 145
 146 jobject RC_NewObject(JNIEnv * env, jclass cls, jmethodID mid, ...) {
 147   va_list va;
 148   va_start(va, mid);
 149   return RC_NewObjectV(env, cls, mid, va);
 150 }
 151
 152 jobject RC_NewObjectV(JNIEnv * env, jclass cls, jmethodID mid, va_list va) {
 153   printf("MISSING FEATURE IN %d\n",__LINE__);
 154   return NULL;
 155 }
 156
 157 jobject RC_NewObjectA(JNIEnv * env, jclass cls, jmethodID mid, const jvalue * vals) {
 158   printf("MISSING FEATURE IN %d\n",__LINE__);
 159   return NULL;
 160 }
 161
 162 jobject RC_GetObjectArrayElement(JNIEnv * env, jobjectArray array, jsize size) {
 163   printf("MISSING FEATURE IN %d\n",__LINE__);
 164   return NULL;
 165 }
 166
 167 void RC_SetObjectArrayElement(JNIEnv * env, jobjectArray array, jsize size, jobject obj) {
 168   printf("MISSING FEATURE IN %d\n",__LINE__);
 169 }
 170
 171 jclass RC_GetObjectClass(JNIEnv * env, jobject obj) {
 172   printf("MISSING FEATURE IN %d\n",__LINE__);
 173   return NULL;
 174 }
 175
 176 jboolean RC_IsInstanceOf(JNIEnv * env, jobject obj, jclass cls) {
 177   printf("MISSING FEATURE IN %d\n",__LINE__);
 178   return 0;
 179 }
 180
 181 jmethodID RC_GetMethodID(JNIEnv * env, jclass cls, const char * str1, const char * str2) {
 182   printf("MISSING FEATURE IN %d\n",__LINE__);
 183   return NULL;
 184 }
 185
 186 #define CALLMETHOD(R, T) R RC_Call ## T ## Method(JNIEnv *env, jobject obj, jmethodID mid, ...) { \
 187     va_list va;                                                         \
 188     va_start(va, mid);                                                  \
 189     return RC_Call ## T ## MethodV(env, obj, mid, va);                  \
 190   }
 191
 192 #define CALLMETHODV(R, T) R RC_Call ## T ## MethodV(JNIEnv * env, jobject obj, jmethodID mid, va_list va) { \
 193     printf("MISSING FEATURE IN %d\n",__LINE__);                         \
 194     return (R)0;                                                        \
 195   }
 196
 197 #define CALLMETHODA(R, T) R RC_Call ## T ## MethodA(JNIEnv * env, jobject obj, jmethodID mid, const jvalue * valarray) { \
 198     printf("MISSING FEATURE IN %d\n",__LINE__);                         \
 199     return (R)0;                                                        \
 200   }
 201
 202 #define CALLNVMETHOD(R, T) R RC_CallNonvirtual ## T ## Method(JNIEnv *env, jobject obj, jclass cls, jmethodID mid, ...) { \
 203     va_list va;                                                         \
 204     va_start(va, mid);                                                  \
 205     return RC_CallNonvirtual ## T ## MethodV(env, obj, cls, mid, va);   \
 206   }
 207
 208 #define CALLNVMETHODV(R, T) R RC_CallNonvirtual ## T ## MethodV(JNIEnv * env, jobject obj, jclass cls, jmethodID mid, va_list va) { \
 209     printf("MISSING FEATURE IN %d\n",__LINE__);                         \
 210     return (R)0;                                                        \
 211   }
 212
 213 #define CALLNVMETHODA(R, T) R RC_CallNonvirtual ## T ## MethodA(JNIEnv * env, jobject obj, jclass cls, jmethodID mid, const jvalue * valarray) { \
 214     printf("MISSING FEATURE IN %d\n",__LINE__);                         \
 215     return (R)0;                                                        \
 216   }
 217
 218 #define GETFIELD(R, T) R RC_Get ## T ## Field(JNIEnv *env, jobject obj, jfieldID fld) { \
 219     printf("MISSING FEATURE IN %d\n",__LINE__);                         \
 220     return (R)0;                                                        \
 221   }
 222
 223 #define SETFIELD(R, T) void RC_Set ## T ## Field(JNIEnv *env, jobject obj, jfieldID fld, R src) { \
 224     printf("MISSING FEATURE IN %d\n",__LINE__);                         \
 225   }
 226
 227 #define CALLSTMETHOD(R, T) R RC_CallStatic ## T ## Method(JNIEnv *env, jobject obj, jmethodID mid, ...) { \
 228     va_list va;                                                         \
 229     va_start(va, mid);                                                  \
 230     return RC_CallStatic ## T ## MethodV(env, obj, mid, va);            \
 231   }
 232
 233 #define CALLSTMETHODV(R, T) R RC_CallStatic ## T ## MethodV(JNIEnv * env, jobject obj, jmethodID mid, va_list va) { \
 234     printf("MISSING FEATURE IN %d\n",__LINE__);                         \
 235     return (R)0;                                                        \
 236   }
 237
 238 #define CALLSTMETHODA(R, T) R RC_CallStatic ## T ## MethodA(JNIEnv * env, jobject obj, jmethodID mid, const jvalue * valarray) { \
 239     printf("MISSING FEATURE IN %d\n",__LINE__);                         \
 240     return (R)0;                                                        \
 241   }
 242
 243 #define GETSTFIELD(R, T) R RC_GetStatic ## T ## Field(JNIEnv *env, jclass cls, jfieldID fld) { \
 244     printf("MISSING FEATURE IN %d\n",__LINE__);                         \
 245     return (R)0;                                                        \
 246   }
 247
 248 #define SETSTFIELD(R, T) void RC_SetStatic ## T ## Field(JNIEnv *env, jclass cls, jfieldID fld, R src) { \
 249     printf("MISSING FEATURE IN %d\n",__LINE__);                         \
 250   }
 251
 252 #define NEWARRAY(R, T) R ## Array RC_New ## T ## Array(JNIEnv *env, jsize size) { \
 253     printf("MISSING FEATURE IN %d\n",__LINE__);                         \
 254     return NULL;                                                        \
 255   }
 256
 257 #define GETARRAY(R, T) R * RC_Get ## T ## ArrayElements(JNIEnv *env, R ## Array array, jboolean * b) { \
 258     printf("MISSING FEATURE IN %d\n",__LINE__);                         \
 259     return (R *)0;                                                      \
 260   }
 261
 262 #define RELEASEARRAY(R, T) void RC_Release ## T ## ArrayElements(JNIEnv *env, R ## Array array, R * ptr, jint num) { \
 263     printf("MISSING FEATURE IN %d\n",__LINE__);                         \
 264   }
 265
 266 #define GETARRAYREGION(R, T) void RC_Get ## T ## ArrayRegion(JNIEnv *env, R ## Array array, jsize size1, jsize size2, R * ptr) { \
 267     printf("MISSING FEATURE IN %d\n",__LINE__);                         \
 268   }
 269
 270 #define SETARRAYREGION(R, T) void RC_Set ## T ## ArrayRegion(JNIEnv *env, R ## Array array, jsize size1, jsize size2, const R * ptr) { \
 271     printf("MISSING FEATURE IN %d\n",__LINE__);                         \
 272   }
 273
 274 #define CALLSET(R, T)                           \
 275   CALLMETHODV(R, T)                             \
 276   CALLMETHOD(R, T)                              \
 277   CALLMETHODA(R, T)                             \
 278   CALLNVMETHODV(R, T)                           \
 279   CALLNVMETHOD(R, T)                            \
 280   CALLNVMETHODA(R, T)                           \
 281   GETFIELD(R, T)                                \
 282   SETFIELD(R, T)                                \
 283   CALLSTMETHODV(R, T)                           \
 284   CALLSTMETHOD(R, T)                            \
 285   CALLSTMETHODA(R, T)                           \
 286   GETSTFIELD(R, T)                              \
 287   SETSTFIELD(R, T)                              \
 288   NEWARRAY(R, T)                                \
 289   GETARRAY(R, T)                                \
 290   RELEASEARRAY(R, T)                            \
 291   GETARRAYREGION(R, T)                          \
 292   SETARRAYREGION(R, T)
 293
 294 jobjectArray RC_NewObjectArray(JNIEnv *env, jsize size, jclass cls, jobject obj) {
 295   printf("MISSING FEATURE IN %d\n",__LINE__);
 296   return NULL;
 297 }
 298
 299 CALLMETHODV(jobject, Object)
 300 CALLMETHOD(jobject, Object)
 301 CALLMETHODA(jobject, Object)
 302 CALLNVMETHODV(jobject, Object)
 303 CALLNVMETHOD(jobject, Object)
 304 CALLNVMETHODA(jobject, Object)
 305 GETFIELD(jobject, Object)
 306 SETFIELD(jobject, Object)
 307 CALLSTMETHODV(jobject, Object)
 308 CALLSTMETHOD(jobject, Object)
 309 CALLSTMETHODA(jobject, Object)
 310 GETSTFIELD(jobject, Object)
 311 SETSTFIELD(jobject, Object)
 312 GETARRAY(jobject, Object)
 313 RELEASEARRAY(jobject, Object)
 314 GETARRAYREGION(jobject, Object)
 315 SETARRAYREGION(jobject, Object)
 316
 317 CALLSET(jboolean, Boolean);
 318 CALLSET(jbyte, Byte);
 319 CALLSET(jchar, Char);
 320 CALLSET(jshort, Short);
 321 CALLSET(jint, Int);
 322 CALLSET(jlong, Long);
 323 CALLSET(jfloat, Float);
 324 CALLSET(jdouble, Double);
 325
 326 void RC_CallVoidMethodV(JNIEnv * env, jobject obj, jmethodID mid, va_list va) {
 327   printf("MISSING FEATURE IN %d\n",__LINE__);
 328 }
 329
 330 void RC_CallVoidMethod(JNIEnv *env, jobject obj, jmethodID mid, ...) {
 331   va_list va;
 332   va_start(va, mid);
 333   RC_CallVoidMethodV(env, obj, mid, va);
 334 }
 335
 336 void RC_CallVoidMethodA(JNIEnv * env, jobject obj, jmethodID mid, const jvalue * valarray) {
 337   printf("MISSING FEATURE IN %d\n",__LINE__);
 338 }
 339
 340 void RC_CallNonvirtualVoidMethod(JNIEnv *env, jobject obj, jclass cls, jmethodID mid, ...) {
 341   va_list va;
 342   va_start(va, mid);
 343   RC_CallNonvirtualVoidMethodV(env, obj, cls, mid, va);
 344 }
 345
 346 void RC_CallNonvirtualVoidMethodV(JNIEnv * env, jobject obj, jclass cls, jmethodID mid, va_list va) {
 347   printf("MISSING FEATURE IN %d\n",__LINE__);
 348 }
 349
 350 void RC_CallNonvirtualVoidMethodA(JNIEnv * env, jobject obj, jclass cls, jmethodID mid, const jvalue * valarray) {
 351   printf("MISSING FEATURE IN %d\n",__LINE__);
 352 }
 353
 354 void RC_CallStaticVoidMethodV(JNIEnv * env, jclass cls, jmethodID mid, va_list va) {
 355   printf("MISSING FEATURE IN %d\n",__LINE__);
 356 }
 357
 358 void RC_CallStaticVoidMethod(JNIEnv *env, jclass cls, jmethodID mid, ...) {
 359   va_list va;
 360   va_start(va, mid);
 361   RC_CallStaticVoidMethodV(env, cls, mid, va);
 362 }
 363
 364 void RC_CallStaticVoidMethodA(JNIEnv * env, jclass cls, jmethodID mid, const jvalue * valarray) {
 365   printf("MISSING FEATURE IN %d\n",__LINE__);
 366 }
 367
 368 jfieldID RC_GetFieldID(JNIEnv * env, jclass cls, const char * str1, const char * str2) {
 369   printf("MISSING FEATURE IN %d\n",__LINE__);
 370   return NULL;
 371 }
 372
 373 jmethodID RC_GetStaticMethodID(JNIEnv * env, jclass cls, const char * str1, const char * str2) {
 374   printf("MISSING FEATURE IN %d\n",__LINE__);
 375   return NULL;
 376 }
 377
 378 jfieldID RC_GetStaticFieldID(JNIEnv * env, jclass cls, const char * str1, const char * str2) {
 379   printf("MISSING FEATURE IN %d\n",__LINE__);
 380   return NULL;
 381 }
 382
 383 jint RC_RegisterNatives(JNIEnv * env, jclass cls, const JNINativeMethod * mid, jint num) {
 384   printf("MISSING FEATURE IN %d\n",__LINE__);
 385   return 0;
 386 }
 387
 388 jint RC_UnregisterNatives(JNIEnv * env, jclass cls) {
 389   printf("MISSING FEATURE IN %d\n",__LINE__);
 390   return 0;
 391 }
 392
 393 jint RC_MonitorEnter(JNIEnv * env, jobject obj) {
 394   printf("MISSING FEATURE IN %d\n",__LINE__);
 395   return 0;
 396 }
 397
 398 jint RC_MonitorExit(JNIEnv * env, jobject obj) {
 399   printf("MISSING FEATURE IN %d\n",__LINE__);
 400   return 0;
 401 }
 402
 403 jint RC_GetJavaVM(JNIEnv * env, JavaVM ** jvm) {
 404   printf("MISSING FEATURE IN %d\n",__LINE__);
 405   return 0;
 406 }
 407
 408 jstring  RC_NewString(JNIEnv * env, const jchar * str, jsize size) {
 409   printf("MISSING FEATURE IN %d\n",__LINE__);
 410   return NULL;
 411 }
 412
 413 jsize RC_GetStringLength(JNIEnv *env, jstring str) {
 414   printf("MISSING FEATURE IN %d\n",__LINE__);
 415   return 0;
 416 }
 417
 418 const jchar * RC_GetStringChars(JNIEnv * env, jstring str, jboolean * flag) {
 419   printf("MISSING FEATURE IN %d\n",__LINE__);
 420   return NULL;
 421 }
 422
 423 void RC_ReleaseStringChars(JNIEnv * env, jstring str, const jchar * str2) {
 424   printf("MISSING FEATURE IN %d\n",__LINE__);
 425 }
 426
 427 jstring RC_NewStringUTF(JNIEnv * env, const char *str) {
 428   printf("MISSING FEATURE IN %d\n",__LINE__);
 429   return NULL;
 430 }
 431
 432 jsize RC_GetStringUTFLength(JNIEnv * env, jstring str) {
 433   printf("MISSING FEATURE IN %d\n",__LINE__);
 434   return 0;
 435 }
 436
 437 const char * RC_GetStringUTFChars(JNIEnv * env, jstring str, jboolean * flag) {
 438   printf("MISSING FEATURE IN %d\n",__LINE__);
 439   return NULL;
 440 }
 441
 442 void RC_ReleaseStringUTFChars(JNIEnv * env, jstring str, const char * str2) {
 443   printf("MISSING FEATURE IN %d\n",__LINE__);
 444 }
 445
 446 jsize RC_GetArrayLength(JNIEnv * env, jarray array) {
 447   printf("MISSING FEATURE IN %d\n",__LINE__);
 448   return 0;
 449 }