src/native/jni.c

   1 /* jni.c - implementation of JNI functions
   2
   3    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
   4    R. Grafl, A. Krall, C. Kruegel, C. Oates, R. Obermaisser,
   5    M. Probst, S. Ring, E. Steiner, C. Thalinger, D. Thuernbeck,
   6    P. Tomsich, J. Wenninger
   7
   8    This file is part of CACAO.
   9
  10    This program is free software; you can redistribute it and/or
  11    modify it under the terms of the GNU General Public License as
  12    published by the Free Software Foundation; either version 2, or (at
  13    your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful, but
  16    WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18    General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  23    02111-1307, USA.
  24
  25    Contact: cacao@complang.tuwien.ac.at
  26
  27    Authors: ?
  28
  29    $Id: jni.c 669 2003-11-23 14:04:20Z edwin $
  30
  31 */
  32
  33
  34 #include "types.h"
  35 #include "toolbox/memory.h"
  36
  37
  38 #define JNI_VERSION       0x00010002
  39
  40 #include <jit/jit.h>
  41
  42 /********************* accessing instance-fields **********************************/
  43
  44 #define setField(obj,typ,var,val) *((typ*) ((long int) obj + (long int) var->offset))=val;
  45 #define getField(obj,typ,var)     *((typ*) ((long int) obj + (long int) var->offset))
  46 #define setfield_critical(clazz,obj,name,sig,jdatatype,val) setField(obj,jdatatype,getFieldID_critical(env,clazz,name,sig),val);
  47
  48
  49
  50 u4 get_parametercount(methodinfo *m)
  51 {
  52     utf  *descr    =  m->descriptor;    /* method-descriptor */
  53     char *utf_ptr  =  descr->text;      /* current position in utf-text */
  54     char *desc_end =  utf_end(descr);   /* points behind utf string     */
  55     java_objectarray* result;
  56     int parametercount = 0;
  57    int i;
  58
  59     /* skip '(' */
  60     utf_nextu2(&utf_ptr);
  61
  62     /* determine number of parameters */
  63     while ( *utf_ptr != ')' ) {
  64         get_type(&utf_ptr,desc_end,true);
  65         parametercount++;
  66     }
  67
  68     return parametercount;
  69 }
  70
  71
  72
  73 void fill_callblock(void *obj,utf *descr,jni_callblock blk[], va_list data, char ret) {
  74     char *utf__ptr  =  descr->text;      /* current position in utf-text */
  75     char **utf_ptr  =  &utf__ptr;
  76     char *desc_end =  utf_end(descr);   /* points behind utf string     */
  77
  78     int cnt;
  79
  80     jdouble d;
  81     jlong l;
  82     u4 dummy;
  83     char c;
  84         /*
  85     log_text("fill_callblock");
  86     utf_display(descr);
  87     log_text("====");
  88         */
  89     /* skip '(' */
  90     utf_nextu2(utf_ptr);
  91
  92     /* determine number of parameters */
  93    if (obj) {
  94            blk[0].itemtype=TYPE_ADR;
  95            blk[0].item=(u8)(u4)obj;
  96            cnt=1;
  97    } else cnt=0;
  98    while ( **utf_ptr != ')' ) {
  99         if (*utf_ptr>=desc_end)
 100                 panic("illegal method descriptor");
 101
 102         switch (utf_nextu2(utf_ptr)) {
 103         /* primitive types */
 104               case 'B' :
 105               case 'C' :
 106               case 'S' :
 107               case 'Z' :
 108                          blk[cnt].itemtype=TYPE_INT;
 109                          blk[cnt].item=(u8) va_arg(data,int);
 110                          break;
 111               case 'I' :
 112                          blk[cnt].itemtype=TYPE_INT;
 113                          dummy=va_arg(data,u4);
 114                          /*printf("fill_callblock: pos:%d, value:%d\n",cnt,dummy);*/
 115                          blk[cnt].item=(u8)dummy;
 116
 117                          break;
 118
 119               case 'J' :
 120                          blk[cnt].itemtype=TYPE_LNG;
 121                          blk[cnt].item=(u8)va_arg(data,jlong);
 122                          break;
 123               case 'F' :
 124                          blk[cnt].itemtype=TYPE_FLT;
 125                          *((jfloat*)(&blk[cnt].item))=((jfloat)va_arg(data,jdouble));
 126                          break;
 127
 128               case 'D' :
 129                          blk[cnt].itemtype=TYPE_DBL;
 130                          *((jdouble*)(&blk[cnt].item))=(jdouble)va_arg(data,jdouble);
 131                          break;
 132               case 'V' : panic ("V not allowed as function parameter");
 133                          break;
 134               case 'L' : {
 135                             char *start = *utf_ptr;
 136                             while (utf_nextu2(utf_ptr)!=';')
 137
 138                             blk[cnt].itemtype=TYPE_ADR;
 139                             blk[cnt].item=(u8)(u4)va_arg(data,void*);
 140                             break;
 141                          }
 142               case '[' : {
 143                           /* XXX need arrayclass change? */
 144                             /* arrayclass */
 145                             char *start = *utf_ptr;
 146                             char ch;
 147                             while ((ch = utf_nextu2(utf_ptr))=='[')
 148                             if (ch == 'L') {
 149                                 while (utf_nextu2(utf_ptr)!=';') {}
 150                                     }
 151
 152                              ch=utf_nextu2(utf_ptr);
 153                             blk[cnt].itemtype=TYPE_ADR;
 154                             blk[cnt].item=(u8)(u4)va_arg(data,void*);
 155                             break;
 156                          }
 157         }
 158         cnt++;
 159    }
 160
 161    /*the standard doesn't say anything about return value checking, but it appears to be usefull*/
 162    c=utf_nextu2(utf_ptr);
 163    c=utf_nextu2(utf_ptr);
 164    /*printf("%c  %c\n",ret,c);*/
 165    if (ret=='O') {
 166         if (!((c=='L') || (c=='['))) log_text("\n====\nWarning call*Method called for function with wrong return type\n====");
 167    } else if (ret != c) log_text("\n====\nWarning call*Method called for function with wrong return type\n====");
 168
 169 }
 170
 171
 172
 173 jmethodID get_virtual(jobject obj,jmethodID methodID) {
 174         if (obj->vftbl->class==methodID->class) return methodID;
 175         return class_resolvemethod (obj->vftbl->class, methodID->name, methodID->descriptor);
 176 }
 177
 178 jmethodID get_nonvirtual(jclass clazz,jmethodID methodID) {
 179         if (clazz==methodID->class) return methodID;
 180         return class_resolvemethod (clazz, methodID->name, methodID->descriptor);
 181 }
 182
 183 jobject callObjectMethod (jobject obj, jmethodID methodID, va_list args)
 184 {
 185         int argcount;
 186         int i;
 187         jni_callblock *blk;
 188         jobject ret;
 189
 190         /*
 191         log_text("JNI-Call: CallObjectMethodV");
 192         utf_display(methodID->name);
 193         utf_display(methodID->descriptor);
 194         printf("\nParmaeter count: %d\n",argcount);
 195         utf_display(obj->vftbl->class->name);
 196         printf("\n");
 197         */
 198
 199         if (methodID==0) {
 200                 exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
 201                 return 0;
 202         }
 203         argcount=get_parametercount(methodID);
 204
 205         if (!( ((methodID->flags & ACC_STATIC) && (obj==0)) ||
 206                 ((!(methodID->flags & ACC_STATIC)) && (obj!=0)) )) {
 207                 exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
 208                 return 0;
 209         }
 210
 211         if (obj && (! builtin_instanceof(obj,methodID->class))) {
 212                 exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
 213                 return 0;
 214         }
 215
 216         if  (argcount>3) {
 217                 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
 218                 log_text("Too many arguments. CallObjectMethod does not support that");
 219                 return 0;
 220         }
 221
 222         blk = MNEW(jni_callblock, 4 /*argcount+2*/);
 223
 224         fill_callblock(obj,methodID->descriptor,blk,args,'O');
 225
 226         /*      printf("parameter: obj: %p",blk[0].item); */
 227         ret=asm_calljavafunction2(methodID,argcount+1,(argcount+1)*sizeof(jni_callblock),blk);
 228         MFREE(blk,jni_callblock,argcount+1);
 229         /*      printf("(CallObjectMethodV)-->%p\n",ret); */
 230         return ret;
 231 }
 232
 233
 234 /*core function for integer class methods (bool,byte,short,integer
 235   This is basically needed for i386*/
 236 jint callIntegerMethod (jobject obj, jmethodID methodID, char retType, va_list args) {
 237         int argcount;
 238         int i;
 239         jni_callblock *blk;
 240         jint ret;
 241
 242 /*      printf("%p,     %c\n",retType,methodID,retType);*/
 243
 244         /*
 245         log_text("JNI-Call: CallObjectMethodV");
 246         utf_display(methodID->name);
 247         utf_display(methodID->descriptor);
 248         printf("\nParmaeter count: %d\n",argcount);
 249         utf_display(obj->vftbl->class->name);
 250         printf("\n");
 251         */
 252         if (methodID==0) {
 253                 exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
 254                 return 0;
 255         }
 256
 257         argcount=get_parametercount(methodID);
 258
 259         if (!( ((methodID->flags & ACC_STATIC) && (obj==0)) ||
 260                 ((!(methodID->flags & ACC_STATIC)) && (obj!=0)) )) {
 261                 exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
 262                 return 0;
 263         }
 264
 265         if (obj && (! builtin_instanceof(obj,methodID->class))) {
 266                 exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
 267                 return 0;
 268         }
 269
 270
 271         if  (argcount>3) {
 272                 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
 273                 log_text("Too many arguments. CallObjectMethod does not support that");
 274                 return 0;
 275         }
 276
 277         blk = MNEW(jni_callblock, 4 /*argcount+2*/);
 278
 279         fill_callblock(obj,methodID->descriptor,blk,args,retType);
 280
 281         /*      printf("parameter: obj: %p",blk[0].item); */
 282         ret=(jint)asm_calljavafunction2(methodID,argcount+1,(argcount+1)*sizeof(jni_callblock),blk);
 283         MFREE(blk,jni_callblock,argcount+1);
 284         /*      printf("(CallObjectMethodV)-->%p\n",ret); */
 285         return ret;
 286
 287 }
 288
 289
 290 /*core function for long class functions*/
 291 jlong callLongMethod (jobject obj, jmethodID methodID, va_list args) {
 292         int argcount;
 293         int i;
 294         jni_callblock *blk;
 295         jlong ret;
 296
 297         /*
 298         log_text("JNI-Call: CallObjectMethodV");
 299         utf_display(methodID->name);
 300         utf_display(methodID->descriptor);
 301         printf("\nParmaeter count: %d\n",argcount);
 302         utf_display(obj->vftbl->class->name);
 303         printf("\n");
 304         */
 305         if (methodID==0) {
 306                 exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
 307                 return 0;
 308         }
 309         argcount=get_parametercount(methodID);
 310
 311         if (!( ((methodID->flags & ACC_STATIC) && (obj==0)) ||
 312                 ((!(methodID->flags & ACC_STATIC)) && (obj!=0)) )) {
 313                 exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
 314                 return 0;
 315         }
 316
 317         if (obj && (! builtin_instanceof(obj,methodID->class))) {
 318                 exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
 319                 return 0;
 320         }
 321
 322
 323         if  (argcount>3) {
 324                 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
 325                 log_text("Too many arguments. CallObjectMethod does not support that");
 326                 return 0;
 327         }
 328
 329         blk = MNEW(jni_callblock, 4 /*argcount+2*/);
 330
 331         fill_callblock(obj,methodID->descriptor,blk,args,'L');
 332
 333         /*      printf("parameter: obj: %p",blk[0].item); */
 334         ret=asm_calljavafunction2long(methodID,argcount+1,(argcount+1)*sizeof(jni_callblock),blk);
 335         MFREE(blk,jni_callblock,argcount+1);
 336         /*      printf("(CallObjectMethodV)-->%p\n",ret); */
 337         return ret;
 338
 339 }
 340
 341
 342 /*core function for float class methods (float,double)*/
 343 jdouble callFloatMethod (jobject obj, jmethodID methodID, va_list args,char retType) {
 344         int argcount=get_parametercount(methodID);
 345         int i;
 346         jni_callblock *blk;
 347         jdouble ret;
 348
 349         /*
 350         log_text("JNI-Call: CallObjectMethodV");
 351         utf_display(methodID->name);
 352         utf_display(methodID->descriptor);
 353         printf("\nParmaeter count: %d\n",argcount);
 354         utf_display(obj->vftbl->class->name);
 355         printf("\n");
 356         */
 357         if  (argcount>3) {
 358                 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
 359                 log_text("Too many arguments. CallObjectMethod does not support that");
 360                 return 0;
 361         }
 362
 363         blk = MNEW(jni_callblock, 4 /*argcount+2*/);
 364
 365         fill_callblock(obj,methodID->descriptor,blk,args,retType);
 366
 367         /*      printf("parameter: obj: %p",blk[0].item); */
 368         ret=asm_calljavafunction2double(methodID,argcount+1,(argcount+1)*sizeof(jni_callblock),blk);
 369         MFREE(blk,jni_callblock,argcount+1);
 370         /*      printf("(CallObjectMethodV)-->%p\n",ret); */
 371         return ret;
 372
 373 }
 374
 375
 376 /*************************** function: jclass_findfield ****************************
 377
 378         searches for field with specified name and type in a 'classinfo'-structur
 379         if no such field is found NULL is returned
 380
 381 ************************************************************************************/
 382
 383 fieldinfo *jclass_findfield (classinfo *c, utf *name, utf *desc)
 384 {
 385         s4 i;
 386 /*      printf(" FieldCount: %d\n",c->fieldscount);
 387         utf_display(c->name); */
 388                 for (i = 0; i < c->fieldscount; i++) {
 389 /*              utf_display(c->fields[i].name);
 390                 printf("\n");
 391                 utf_display(c->fields[i].descriptor);
 392                 printf("\n");*/
 393                 if ((c->fields[i].name == name) && (c->fields[i].descriptor == desc))
 394                         return &(c->fields[i]);
 395                 }
 396
 397         return NULL;
 398 }
 399
 400 /********************* returns version of native method interface *****************/
 401
 402 jint GetVersion (JNIEnv* env)
 403 {
 404         return JNI_VERSION;
 405 }
 406
 407 /****************** loads a class from a buffer of raw class data *****************/
 408
 409 jclass DefineClass(JNIEnv* env, const char *name, jobject loader, const jbyte *buf, jsize len)
 410 {
 411         jclass clazz;
 412
 413         /* change suck-mode, so subsequent class_load will read from memory-buffer */
 414         classload_buffer( (u1*) buf,len);
 415
 416         clazz = loader_load(utf_new_char ((char *) name));
 417
 418         /* restore old suck-mode */
 419         classload_buffer(NULL,0);
 420
 421         return clazz;
 422 }
 423
 424
 425 /*************** loads locally defined class with the specified name **************/
 426
 427 jclass FindClass (JNIEnv* env, const char *name)
 428 {
 429         classinfo *c;
 430
 431         if (strcmp(name,"[B")==0) {
 432                 c = loader_load(utf_new_char("The_Array_Class"));
 433         }
 434         else
 435                 c = loader_load(utf_new_char_classname ((char *) name));
 436
 437         if (!c) exceptionptr = native_new_and_init(class_java_lang_ClassFormatError);
 438
 439         return c;
 440 }
 441
 442
 443 /***********************************************************************************
 444
 445         converts java.lang.reflect.Method or
 446         java.lang.reflect.Constructor object to a method ID
 447
 448  **********************************************************************************/
 449
 450 jmethodID FromReflectedMethod (JNIEnv* env, jobject method)
 451 {
 452         /* log_text("JNI-Call: FromReflectedMethod"); */
 453 }
 454
 455
 456 /*************** return superclass of the class represented by sub ****************/
 457
 458 jclass GetSuperclass (JNIEnv* env, jclass sub)
 459 {
 460         classinfo *c;
 461
 462         c = ((classinfo*) sub) -> super;
 463
 464         if (!c) return NULL;
 465         use_class_as_object (c);
 466         return c;
 467 }
 468
 469
 470 /*********************** check whether sub can be cast to sup  ********************/
 471
 472 jboolean IsAssignableForm (JNIEnv* env, jclass sub, jclass sup)
 473 {
 474         return builtin_isanysubclass(sub,sup);
 475 }
 476
 477
 478 /***** converts a field ID derived from cls to a java.lang.reflect.Field object ***/
 479
 480 jobject ToReflectedField (JNIEnv* env, jclass cls, jfieldID fieldID, jboolean isStatic)
 481 {
 482         /* log_text("JNI-Call: ToReflectedField"); */
 483 }
 484
 485
 486 /***************** throw java.lang.Throwable object  ******************************/
 487
 488 jint Throw (JNIEnv* env, jthrowable obj)
 489 {
 490         exceptionptr = (java_objectheader*) obj;
 491         return 0;
 492 }
 493
 494
 495 /***********************************************************************************
 496
 497         create exception object from the class clazz with the
 498         specified message and cause it to be thrown
 499
 500  **********************************************************************************/
 501
 502
 503 jint ThrowNew (JNIEnv* env, jclass clazz, const char *msg)
 504 {
 505         java_lang_Throwable *o;
 506
 507         /* instantiate exception object */
 508         o = (java_lang_Throwable *) native_new_and_init ((classinfo*) clazz);
 509
 510         if (!o) return (-1);
 511
 512         o->detailMessage = (java_lang_String*) javastring_new_char((char *) msg);
 513
 514         exceptionptr = (java_objectheader*) o;
 515         return 0;
 516 }
 517
 518 /************************* check if exception occured *****************************/
 519
 520 jthrowable ExceptionOccurred (JNIEnv* env)
 521 {
 522         return (jthrowable) exceptionptr;
 523 }
 524
 525 /********** print exception and a backtrace of the stack (for debugging) **********/
 526
 527 void ExceptionDescribe (JNIEnv* env)
 528 {
 529         utf_display(exceptionptr->vftbl->class->name);
 530         printf ("\n");
 531         fflush (stdout);
 532 }
 533
 534
 535 /******************* clear any exception currently being thrown *******************/
 536
 537 void ExceptionClear (JNIEnv* env)
 538 {
 539         exceptionptr = NULL;
 540 }
 541
 542
 543 /********** raises a fatal error and does not expect the VM to recover ************/
 544
 545 void FatalError (JNIEnv* env, const char *msg)
 546 {
 547         panic((char *) msg);
 548 }
 549
 550 /******************* creates a new local reference frame **************************/
 551
 552 jint PushLocalFrame (JNIEnv* env, jint capacity)
 553 {
 554         /* empty */
 555 }
 556
 557 /**************** Pops off the current local reference frame **********************/
 558
 559 jobject PopLocalFrame (JNIEnv* env, jobject result)
 560 {
 561         /* empty */
 562 }
 563
 564
 565 /** Creates a new global reference to the object referred to by the obj argument **/
 566
 567 jobject NewGlobalRef (JNIEnv* env, jobject lobj)
 568 {
 569         heap_addreference ( (void**) &lobj);
 570         return lobj;
 571 }
 572
 573 /*************  Deletes the global reference pointed to by globalRef **************/
 574
 575 void DeleteGlobalRef (JNIEnv* env, jobject gref)
 576 {
 577         /* empty */
 578 }
 579
 580
 581 /*************** Deletes the local reference pointed to by localRef ***************/
 582
 583 void DeleteLocalRef (JNIEnv* env, jobject localRef)
 584 {
 585         /* empty */
 586 }
 587
 588 /********** Tests whether two references refer to the same Java object ************/
 589
 590 jboolean IsSameObject (JNIEnv* env, jobject obj1, jobject obj2)
 591 {
 592         return (obj1==obj2);
 593 }
 594
 595 /***** Creates a new local reference that refers to the same object as ref  *******/
 596
 597 jobject NewLocalRef (JNIEnv* env, jobject ref)
 598 {
 599         return ref;
 600 }
 601
 602 /***********************************************************************************
 603
 604         Ensures that at least a given number of local references can
 605         be created in the current thread
 606
 607  **********************************************************************************/
 608
 609 jint EnsureLocalCapacity (JNIEnv* env, jint capacity)
 610 {
 611         return 0; /* return 0 on success */
 612 }
 613
 614
 615 /********* Allocates a new Java object without invoking a constructor *************/
 616
 617 jobject AllocObject (JNIEnv* env, jclass clazz)
 618 {
 619         java_objectheader *o = builtin_new(clazz);
 620         return o;
 621 }
 622
 623
 624 /***********************************************************************************
 625
 626         Constructs a new Java object
 627         arguments that are to be passed to the constructor are placed after methodID
 628
 629 ***********************************************************************************/
 630
 631 jobject NewObject (JNIEnv* env, jclass clazz, jmethodID methodID, ...)
 632 {
 633         java_objectheader *o;
 634         void* args[3];
 635         int argcount=get_parametercount(methodID);
 636         int i;
 637         va_list vaargs;
 638
 639         /* log_text("JNI-Call: NewObject"); */
 640
 641         if  (argcount>3) {
 642                 exceptionptr=native_new_and_init(loader_load(utf_new_char("java/lang/IllegalArgumentException")));
 643                 log_text("Too many arguments. NewObject does not support that");
 644                 return 0;
 645         }
 646
 647
 648         o = builtin_new (clazz);         /*          create object */
 649
 650         if (!o) return NULL;
 651
 652         va_start(vaargs,methodID);
 653         for (i=0;i<argcount;i++) {
 654                 args[i]=va_arg(vaargs,void*);
 655         }
 656         va_end(vaargs);
 657         exceptionptr=asm_calljavamethod(methodID,o,args[0],args[1],args[2]);
 658
 659         return o;
 660
 661 }
 662
 663 /***********************************************************************************
 664
 665        Constructs a new Java object
 666        arguments that are to be passed to the constructor are placed in va_list args
 667
 668 ***********************************************************************************/
 669
 670 jobject NewObjectV (JNIEnv* env, jclass clazz, jmethodID methodID, va_list args)
 671 {
 672         /* log_text("JNI-Call: NewObjectV"); */
 673 }
 674
 675 /***********************************************************************************
 676
 677         Constructs a new Java object
 678         arguments that are to be passed to the constructor are placed in
 679         args array of jvalues
 680
 681 ***********************************************************************************/
 682
 683 jobject NewObjectA (JNIEnv* env, jclass clazz, jmethodID methodID, jvalue *args)
 684 {
 685         /* log_text("JNI-Call: NewObjectA"); */
 686 }
 687
 688
 689 /************************ returns the class of an object **************************/
 690
 691 jclass GetObjectClass (JNIEnv* env, jobject obj)
 692 {
 693         classinfo *c = obj->vftbl -> class;
 694         use_class_as_object (c);
 695         return c;
 696 }
 697
 698 /************* tests whether an object is an instance of a class ******************/
 699
 700 jboolean IsInstanceOf (JNIEnv* env, jobject obj, jclass clazz)
 701 {
 702         return builtin_instanceof(obj,clazz);
 703 }
 704
 705
 706 /***************** converts a java.lang.reflect.Field to a field ID ***************/
 707
 708 jfieldID FromReflectedField (JNIEnv* env, jobject field)
 709 {
 710         log_text("JNI-Call: FromReflectedField");
 711 }
 712
 713 /**********************************************************************************
 714
 715         converts a method ID to a java.lang.reflect.Method or
 716         java.lang.reflect.Constructor object
 717
 718 **********************************************************************************/
 719
 720 jobject ToReflectedMethod (JNIEnv* env, jclass cls, jmethodID methodID, jboolean isStatic)
 721 {
 722         log_text("JNI-Call: ToReflectedMethod");
 723 }
 724
 725 /**************** returns the method ID for an instance method ********************/
 726
 727 jmethodID GetMethodID (JNIEnv* env, jclass clazz, const char *name, const char *sig)
 728 {
 729         jmethodID m;
 730
 731         m = class_resolvemethod (
 732                 clazz,
 733                 utf_new_char ((char*) name),
 734                 utf_new_char ((char*) sig)
 735         );
 736
 737         if (!m) exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
 738
 739         return m;
 740 }
 741
 742 /******************** JNI-functions for calling instance methods ******************/
 743 jobject CallObjectMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
 744 {
 745         jobject ret;
 746         va_list vaargs;
 747
 748 /*      log_text("JNI-Call: CallObjectMethod");*/
 749
 750         va_start(vaargs,methodID);
 751         ret = callObjectMethod(obj,methodID,vaargs);
 752         va_end(vaargs);
 753         return ret;
 754 }
 755
 756
 757 jobject CallObjectMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
 758 {
 759         return callObjectMethod(obj,methodID,args);
 760 }
 761
 762
 763 jobject CallObjectMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
 764 {
 765
 766
 767         log_text("JNI-Call: CallObjectMethodA");
 768
 769         return NULL;
 770 }
 771
 772
 773
 774
 775 jboolean CallBooleanMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
 776 {
 777         jboolean ret;
 778         va_list vaargs;
 779
 780 /*      log_text("JNI-Call: CallBooleanMethod");*/
 781
 782         va_start(vaargs,methodID);
 783         ret = (jboolean)callIntegerMethod(obj,get_virtual(obj,methodID),'Z',vaargs);
 784         va_end(vaargs);
 785         return ret;
 786
 787 }
 788
 789 jboolean CallBooleanMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
 790 {
 791         return (jboolean)callIntegerMethod(obj,get_virtual(obj,methodID),'Z',args);
 792
 793 }
 794
 795 jboolean CallBooleanMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
 796 {
 797         log_text("JNI-Call: CallBooleanMethodA");
 798
 799         return 0;
 800 }
 801
 802 jbyte CallByteMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
 803 {
 804         jbyte ret;
 805         va_list vaargs;
 806
 807 /*      log_text("JNI-Call: CallVyteMethod");*/
 808
 809         va_start(vaargs,methodID);
 810         ret = callIntegerMethod(obj,get_virtual(obj,methodID),'B',vaargs);
 811         va_end(vaargs);
 812         return ret;
 813
 814 }
 815
 816 jbyte CallByteMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
 817 {
 818 /*      log_text("JNI-Call: CallByteMethodV");*/
 819         return callIntegerMethod(obj,methodID,'B',args);
 820 }
 821
 822
 823 jbyte CallByteMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
 824 {
 825         log_text("JNI-Call: CallByteMethodA");
 826 }
 827
 828
 829 jchar CallCharMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
 830 {
 831         jchar ret;
 832         va_list vaargs;
 833
 834 /*      log_text("JNI-Call: CallCharMethod");*/
 835
 836         va_start(vaargs,methodID);
 837         ret = callIntegerMethod(obj,get_virtual(obj,methodID),'C',vaargs);
 838         va_end(vaargs);
 839         return ret;
 840
 841 }
 842
 843 jchar CallCharMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
 844 {
 845 /*      log_text("JNI-Call: CallCharMethodV");*/
 846         return callIntegerMethod(obj,get_virtual(obj,methodID),'C',args);
 847 }
 848
 849
 850 jchar CallCharMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
 851 {
 852         log_text("JNI-Call: CallCharMethodA");
 853
 854         return 0;
 855 }
 856
 857
 858 jshort CallShortMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
 859 {
 860         jshort ret;
 861         va_list vaargs;
 862
 863 /*      log_text("JNI-Call: CallShortMethod");*/
 864
 865         va_start(vaargs,methodID);
 866         ret = callIntegerMethod(obj,get_virtual(obj,methodID),'S',vaargs);
 867         va_end(vaargs);
 868         return ret;
 869
 870 }
 871
 872
 873 jshort CallShortMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
 874 {
 875         return callIntegerMethod(obj,get_virtual(obj,methodID),'S',args);
 876 }
 877
 878
 879 jshort CallShortMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
 880 {
 881         log_text("JNI-Call: CallShortMethodA");
 882
 883         return 0;
 884 }
 885
 886
 887
 888 jint CallIntMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
 889 {
 890         jint ret;
 891         va_list vaargs;
 892
 893         va_start(vaargs,methodID);
 894         ret = callIntegerMethod(obj,get_virtual(obj,methodID),'I',vaargs);
 895         va_end(vaargs);
 896         return ret;
 897 }
 898
 899
 900 jint CallIntMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
 901 {
 902         return callIntegerMethod(obj,get_virtual(obj,methodID),'I',args);
 903 }
 904
 905
 906 jint CallIntMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
 907 {
 908         log_text("JNI-Call: CallIntMethodA");
 909
 910         return 0;
 911 }
 912
 913
 914
 915 jlong CallLongMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
 916 {
 917         log_text("JNI-Call: CallLongMethod");
 918
 919         return 0;
 920 }
 921
 922
 923 jlong CallLongMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
 924 {
 925         log_text("JNI-Call: CallLongMethodV");
 926
 927         return 0;
 928 }
 929
 930
 931 jlong CallLongMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
 932 {
 933         log_text("JNI-Call: CallLongMethodA");
 934
 935         return 0;
 936 }
 937
 938
 939
 940 jfloat CallFloatMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
 941 {
 942         jfloat ret;
 943         va_list vaargs;
 944
 945 /*      log_text("JNI-Call: CallFloatMethod");*/
 946
 947         va_start(vaargs,methodID);
 948         ret = callFloatMethod(obj,get_virtual(obj,methodID),vaargs,'F');
 949         va_end(vaargs);
 950         return ret;
 951 }
 952
 953
 954 jfloat CallFloatMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
 955 {
 956         log_text("JNI-Call: CallFloatMethodV");
 957         return callFloatMethod(obj,get_virtual(obj,methodID),args,'F');
 958 }
 959
 960
 961 jfloat CallFloatMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
 962 {
 963         log_text("JNI-Call: CallFloatMethodA");
 964
 965         return 0;
 966 }
 967
 968
 969
 970 jdouble CallDoubleMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
 971 {
 972         jdouble ret;
 973         va_list vaargs;
 974
 975 /*      log_text("JNI-Call: CallDoubleMethod");*/
 976
 977         va_start(vaargs,methodID);
 978         ret = callFloatMethod(obj,get_virtual(obj,methodID),vaargs,'D');
 979         va_end(vaargs);
 980         return ret;
 981 }
 982
 983
 984 jdouble CallDoubleMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
 985 {
 986         log_text("JNI-Call: CallDoubleMethodV");
 987         return callFloatMethod(obj,get_virtual(obj,methodID),args,'D');
 988 }
 989
 990
 991 jdouble CallDoubleMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
 992 {
 993         log_text("JNI-Call: CallDoubleMethodA");
 994         return 0;
 995 }
 996
 997
 998
 999 void CallVoidMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
1000 {
1001         va_list vaargs;
1002
1003 /*      log_text("JNI-Call: CallVoidMethod");*/
1004
1005         va_start(vaargs,methodID);
1006         (void)callIntegerMethod(obj,get_virtual(obj,methodID),'V',vaargs);
1007         va_end(vaargs);
1008
1009
1010 }
1011
1012
1013 void CallVoidMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
1014 {
1015         log_text("JNI-Call: CallVoidMethodV");
1016         (void)callIntegerMethod(obj,get_virtual(obj,methodID),'V',args);
1017
1018 }
1019
1020
1021 void CallVoidMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
1022 {
1023         log_text("JNI-Call: CallVoidMethodA");
1024
1025 }
1026
1027
1028
1029 jobject CallNonvirtualObjectMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1030 {
1031         log_text("JNI-Call: CallNonvirtualObjectMethod");
1032
1033         return NULL;
1034 }
1035
1036
1037 jobject CallNonvirtualObjectMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1038 {
1039         log_text("JNI-Call: CallNonvirtualObjectMethodV");
1040
1041         return NULL;
1042 }
1043
1044
1045 jobject CallNonvirtualObjectMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
1046 {
1047         log_text("JNI-Call: CallNonvirtualObjectMethodA");
1048
1049         return NULL;
1050 }
1051
1052
1053
1054 jboolean CallNonvirtualBooleanMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1055 {
1056         jboolean ret;
1057         va_list vaargs;
1058
1059 /*      log_text("JNI-Call: CallNonvirtualBooleanMethod");*/
1060
1061         va_start(vaargs,methodID);
1062         ret = (jboolean)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'Z',vaargs);
1063         va_end(vaargs);
1064         return ret;
1065
1066 }
1067
1068
1069 jboolean CallNonvirtualBooleanMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1070 {
1071 /*      log_text("JNI-Call: CallNonvirtualBooleanMethodV");*/
1072         return (jboolean)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'Z',args);
1073 }
1074
1075
1076 jboolean CallNonvirtualBooleanMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
1077 {
1078         log_text("JNI-Call: CallNonvirtualBooleanMethodA");
1079
1080         return 0;
1081 }
1082
1083
1084
1085 jbyte CallNonvirtualByteMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1086 {
1087         jbyte ret;
1088         va_list vaargs;
1089
1090 /*      log_text("JNI-Call: CallNonvirutalByteMethod");*/
1091
1092         va_start(vaargs,methodID);
1093         ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'B',vaargs);
1094         va_end(vaargs);
1095         return ret;
1096 }
1097
1098
1099 jbyte CallNonvirtualByteMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1100 {
1101         /*log_text("JNI-Call: CallNonvirtualByteMethodV"); */
1102         return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'B',args);
1103
1104 }
1105
1106
1107 jbyte CallNonvirtualByteMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1108 {
1109         log_text("JNI-Call: CallNonvirtualByteMethodA");
1110
1111         return 0;
1112 }
1113
1114
1115
1116 jchar CallNonvirtualCharMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1117 {
1118         jchar ret;
1119         va_list vaargs;
1120
1121 /*      log_text("JNI-Call: CallNonVirtualCharMethod");*/
1122
1123         va_start(vaargs,methodID);
1124         ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'C',vaargs);
1125         va_end(vaargs);
1126         return ret;
1127 }
1128
1129
1130 jchar CallNonvirtualCharMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1131 {
1132         /*log_text("JNI-Call: CallNonvirtualCharMethodV");*/
1133         return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'C',args);
1134 }
1135
1136
1137 jchar CallNonvirtualCharMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1138 {
1139         log_text("JNI-Call: CallNonvirtualCharMethodA");
1140
1141         return 0;
1142 }
1143
1144
1145
1146 jshort CallNonvirtualShortMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1147 {
1148         jshort ret;
1149         va_list vaargs;
1150
1151         /*log_text("JNI-Call: CallNonvirtualShortMethod");*/
1152
1153         va_start(vaargs,methodID);
1154         ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'S',vaargs);
1155         va_end(vaargs);
1156         return ret;
1157 }
1158
1159
1160 jshort CallNonvirtualShortMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1161 {
1162         /*log_text("JNI-Call: CallNonvirtualShortMethodV");*/
1163         return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'S',args);
1164 }
1165
1166
1167 jshort CallNonvirtualShortMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1168 {
1169         log_text("JNI-Call: CallNonvirtualShortMethodA");
1170
1171         return 0;
1172 }
1173
1174
1175
1176 jint CallNonvirtualIntMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1177 {
1178
1179         jint ret;
1180         va_list vaargs;
1181
1182         /*log_text("JNI-Call: CallNonvirtualIntMethod");*/
1183
1184         va_start(vaargs,methodID);
1185         ret = callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'I',vaargs);
1186         va_end(vaargs);
1187         return ret;
1188 }
1189
1190
1191 jint CallNonvirtualIntMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1192 {
1193         /*log_text("JNI-Call: CallNonvirtualIntMethodV");*/
1194         return callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'I',args);
1195 }
1196
1197
1198 jint CallNonvirtualIntMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1199 {
1200         log_text("JNI-Call: CallNonvirtualIntMethodA");
1201
1202         return 0;
1203 }
1204
1205
1206
1207 jlong CallNonvirtualLongMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1208 {
1209         log_text("JNI-Call: CallNonvirtualLongMethod");
1210
1211         return 0;
1212 }
1213
1214
1215 jlong CallNonvirtualLongMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1216 {
1217         log_text("JNI-Call: CallNonvirtualLongMethodV");
1218
1219         return 0;
1220 }
1221
1222
1223 jlong CallNonvirtualLongMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1224 {
1225         log_text("JNI-Call: CallNonvirtualLongMethodA");
1226
1227         return 0;
1228 }
1229
1230
1231
1232 jfloat CallNonvirtualFloatMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1233 {
1234         jfloat ret;
1235         va_list vaargs;
1236
1237         /*log_text("JNI-Call: CallNonvirtualFloatMethod");*/
1238
1239
1240         va_start(vaargs,methodID);
1241         ret = callFloatMethod(obj,get_nonvirtual(clazz,methodID),vaargs,'F');
1242         va_end(vaargs);
1243         return ret;
1244
1245 }
1246
1247
1248 jfloat CallNonvirtualFloatMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1249 {
1250         log_text("JNI-Call: CallNonvirtualFloatMethodV");
1251         return callFloatMethod(obj,get_nonvirtual(clazz,methodID),args,'F');
1252 }
1253
1254
1255 jfloat CallNonvirtualFloatMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1256 {
1257         log_text("JNI-Call: CallNonvirtualFloatMethodA");
1258
1259         return 0;
1260 }
1261
1262
1263
1264 jdouble CallNonvirtualDoubleMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1265 {
1266         jdouble ret;
1267         va_list vaargs;
1268         log_text("JNI-Call: CallNonvirtualDoubleMethod");
1269
1270         va_start(vaargs,methodID);
1271         ret = callFloatMethod(obj,get_nonvirtual(clazz,methodID),vaargs,'D');
1272         va_end(vaargs);
1273         return ret;
1274
1275 }
1276
1277
1278 jdouble CallNonvirtualDoubleMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1279 {
1280 /*      log_text("JNI-Call: CallNonvirtualDoubleMethodV");*/
1281         return callFloatMethod(obj,get_nonvirtual(clazz,methodID),args,'D');
1282 }
1283
1284
1285 jdouble CallNonvirtualDoubleMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
1286 {
1287         log_text("JNI-Call: CallNonvirtualDoubleMethodA");
1288
1289         return 0;
1290 }
1291
1292
1293
1294 void CallNonvirtualVoidMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
1295 {
1296         va_list vaargs;
1297
1298 /*      log_text("JNI-Call: CallNonvirtualVoidMethod");*/
1299
1300         va_start(vaargs,methodID);
1301         (void)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'V',vaargs);
1302         va_end(vaargs);
1303
1304 }
1305
1306
1307 void CallNonvirtualVoidMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
1308 {
1309 /*      log_text("JNI-Call: CallNonvirtualVoidMethodV");*/
1310
1311         (void)callIntegerMethod(obj,get_nonvirtual(clazz,methodID),'V',args);
1312
1313 }
1314
1315
1316 void CallNonvirtualVoidMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
1317 {
1318         log_text("JNI-Call: CallNonvirtualVoidMethodA");
1319 }
1320
1321 /************************* JNI-functions for accessing fields ************************/
1322
1323 jfieldID GetFieldID (JNIEnv *env, jclass clazz, const char *name, const char *sig)
1324 {
1325         jfieldID f;
1326
1327         f = jclass_findfield(clazz,
1328                             utf_new_char ((char*) name),
1329                             utf_new_char ((char*) sig)
1330                             );
1331
1332         if (!f) exceptionptr =  native_new_and_init(class_java_lang_NoSuchFieldError);
1333
1334         return f;
1335 }
1336
1337 /*************************** retrieve fieldid, abort on error ************************/
1338
1339 jfieldID getFieldID_critical(JNIEnv *env,jclass clazz,const char *name,const char *sig)
1340 {
1341     jfieldID id = GetFieldID(env,clazz,name,sig);
1342     if (!id) panic("setfield_critical failed");
1343     return id;
1344 }
1345
1346 jobject GetObjectField (JNIEnv *env, jobject obj, jfieldID fieldID)
1347 {
1348         return getField(obj,jobject,fieldID);
1349 }
1350
1351 jboolean GetBooleanField (JNIEnv *env, jobject obj, jfieldID fieldID)
1352 {
1353         return getField(obj,jboolean,fieldID);
1354 }
1355
1356
1357 jbyte GetByteField (JNIEnv *env, jobject obj, jfieldID fieldID)
1358 {
1359         return getField(obj,jbyte,fieldID);
1360 }
1361
1362
1363 jchar GetCharField (JNIEnv *env, jobject obj, jfieldID fieldID)
1364 {
1365         return getField(obj,jchar,fieldID);
1366 }
1367
1368
1369 jshort GetShortField (JNIEnv *env, jobject obj, jfieldID fieldID)
1370 {
1371         return getField(obj,jshort,fieldID);
1372 }
1373
1374
1375 jint GetIntField (JNIEnv *env, jobject obj, jfieldID fieldID)
1376 {
1377         return getField(obj,jint,fieldID);
1378 }
1379
1380
1381 jlong GetLongField (JNIEnv *env, jobject obj, jfieldID fieldID)
1382 {
1383         return getField(obj,jlong,fieldID);
1384 }
1385
1386
1387 jfloat GetFloatField (JNIEnv *env, jobject obj, jfieldID fieldID)
1388 {
1389         return getField(obj,jfloat,fieldID);
1390 }
1391
1392
1393 jdouble GetDoubleField (JNIEnv *env, jobject obj, jfieldID fieldID)
1394 {
1395         return getField(obj,jdouble,fieldID);
1396 }
1397
1398 void SetObjectField (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val)
1399 {
1400         setField(obj,jobject,fieldID,val);
1401 }
1402
1403
1404 void SetBooleanField (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val)
1405 {
1406         setField(obj,jboolean,fieldID,val);
1407 }
1408
1409
1410 void SetByteField (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val)
1411 {
1412         setField(obj,jbyte,fieldID,val);
1413 }
1414
1415
1416 void SetCharField (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val)
1417 {
1418         setField(obj,jchar,fieldID,val);
1419 }
1420
1421
1422 void SetShortField (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val)
1423 {
1424         setField(obj,jshort,fieldID,val);
1425 }
1426
1427
1428 void SetIntField (JNIEnv *env, jobject obj, jfieldID fieldID, jint val)
1429 {
1430         setField(obj,jint,fieldID,val);
1431 }
1432
1433
1434 void SetLongField (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val)
1435 {
1436         setField(obj,jlong,fieldID,val);
1437 }
1438
1439
1440 void SetFloatField (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val)
1441 {
1442         setField(obj,jfloat,fieldID,val);
1443 }
1444
1445
1446 void SetDoubleField (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val)
1447 {
1448         setField(obj,jdouble,fieldID,val);
1449 }
1450
1451 /**************** JNI-functions for calling static methods **********************/
1452
1453 jmethodID GetStaticMethodID (JNIEnv *env, jclass clazz, const char *name, const char *sig)
1454 {
1455         jmethodID m;
1456
1457         m = class_resolvemethod (
1458                 clazz,
1459                 utf_new_char ((char*) name),
1460                 utf_new_char ((char*) sig)
1461         );
1462
1463         if (!m) exceptionptr =  native_new_and_init(class_java_lang_NoSuchMethodError);
1464
1465         return m;
1466 }
1467
1468 jobject CallStaticObjectMethod (JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1469 {
1470         log_text("JNI-Call: CallStaticObjectMethod");
1471
1472         return NULL;
1473 }
1474
1475
1476 jobject CallStaticObjectMethodV (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1477 {
1478         log_text("JNI-Call: CallStaticObjectMethodV");
1479
1480         return NULL;
1481 }
1482
1483
1484 jobject CallStaticObjectMethodA (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1485 {
1486         log_text("JNI-Call: CallStaticObjectMethodA");
1487
1488         return NULL;
1489 }
1490
1491
1492 jboolean CallStaticBooleanMethod (JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1493 {
1494         jboolean ret;
1495         va_list vaargs;
1496
1497 /*      log_text("JNI-Call: CallStaticBooleanMethod");*/
1498
1499         va_start(vaargs,methodID);
1500         ret = (jboolean)callIntegerMethod(0,methodID,'Z',vaargs);
1501         va_end(vaargs);
1502         return ret;
1503
1504 }
1505
1506
1507 jboolean CallStaticBooleanMethodV (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1508 {
1509         return (jboolean)callIntegerMethod(0,methodID,'Z',args);
1510 }
1511
1512 jboolean CallStaticBooleanMethodA (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1513 {
1514         log_text("JNI-Call: CallStaticBooleanMethodA");
1515
1516         return 0;
1517 }
1518
1519
1520 jbyte CallStaticByteMethod (JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1521 {
1522         jobject ret;
1523         va_list vaargs;
1524
1525 /*      log_text("JNI-Call: CallStaticByteMethod");*/
1526
1527         va_start(vaargs,methodID);
1528         ret = (jbyte)callIntegerMethod(0,methodID,'B',vaargs);
1529         va_end(vaargs);
1530         return ret;
1531
1532 }
1533
1534
1535 jbyte CallStaticByteMethodV (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1536 {
1537         return (jbyte)callIntegerMethod(0,methodID,'B',args);
1538 }
1539
1540
1541 jbyte CallStaticByteMethodA (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1542 {
1543         log_text("JNI-Call: CallStaticByteMethodA");
1544
1545         return 0;
1546 }
1547
1548 jchar CallStaticCharMethod (JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1549 {
1550         jchar ret;
1551         va_list vaargs;
1552
1553 /*      log_text("JNI-Call: CallStaticByteMethod");*/
1554
1555         va_start(vaargs,methodID);
1556         ret = (jchar)callIntegerMethod(0,methodID,'C',vaargs);
1557         va_end(vaargs);
1558         return ret;
1559
1560 }
1561
1562
1563 jchar CallStaticCharMethodV (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1564 {
1565         return (jchar)callIntegerMethod(0,methodID,'C',args);
1566 }
1567
1568
1569 jchar CallStaticCharMethodA (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1570 {
1571         log_text("JNI-Call: CallStaticCharMethodA");
1572
1573         return 0;
1574 }
1575
1576
1577
1578 jshort CallStaticShortMethod (JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1579 {
1580         jshort ret;
1581         va_list vaargs;
1582
1583 /*      log_text("JNI-Call: CallStaticByteMethod");*/
1584
1585         va_start(vaargs,methodID);
1586         ret = (jshort)callIntegerMethod(0,methodID,'S',vaargs);
1587         va_end(vaargs);
1588         return ret;
1589 }
1590
1591
1592 jshort CallStaticShortMethodV (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1593 {
1594         /*log_text("JNI-Call: CallStaticShortMethodV");*/
1595         return (jshort)callIntegerMethod(0,methodID,'S',args);
1596 }
1597
1598
1599 jshort CallStaticShortMethodA (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1600 {
1601         log_text("JNI-Call: CallStaticShortMethodA");
1602
1603         return 0;
1604 }
1605
1606
1607
1608 jint CallStaticIntMethod (JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1609 {
1610         jobject ret;
1611         va_list vaargs;
1612
1613 /*      log_text("JNI-Call: CallStaticIntMethod");*/
1614
1615         va_start(vaargs,methodID);
1616         ret = callIntegerMethod(0,methodID,'I',vaargs);
1617         va_end(vaargs);
1618         return ret;
1619
1620 }
1621
1622
1623 jint CallStaticIntMethodV (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1624 {
1625         log_text("JNI-Call: CallStaticIntMethodV");
1626
1627         return callIntegerMethod(0,methodID,'I',args);
1628 }
1629
1630
1631 jint CallStaticIntMethodA (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1632 {
1633         log_text("JNI-Call: CallStaticIntMethodA");
1634
1635         return 0;
1636 }
1637
1638
1639
1640 jlong CallStaticLongMethod (JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1641 {
1642         jobject ret;
1643         va_list vaargs;
1644
1645 /*      log_text("JNI-Call: CallStaticLongMethod");*/
1646
1647         va_start(vaargs,methodID);
1648         ret = callLongMethod(0,methodID,vaargs);
1649         va_end(vaargs);
1650         return ret;
1651
1652 }
1653
1654 jlong CallStaticLongMethodV (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1655 {
1656         log_text("JNI-Call: CallStaticLongMethodV");
1657
1658         return callLongMethod(0,methodID,args);
1659 }
1660
1661
1662 jlong CallStaticLongMethodA (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1663 {
1664         log_text("JNI-Call: CallStaticLongMethodA");
1665
1666         return 0;
1667 }
1668
1669
1670
1671 jfloat CallStaticFloatMethod (JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1672 {
1673         jfloat ret;
1674         va_list vaargs;
1675
1676 /*      log_text("JNI-Call: CallStaticLongMethod");*/
1677
1678         va_start(vaargs,methodID);
1679         ret = callFloatMethod(0,methodID,vaargs,'F');
1680         va_end(vaargs);
1681         return ret;
1682
1683 }
1684
1685
1686 jfloat CallStaticFloatMethodV (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1687 {
1688
1689         return callFloatMethod(0,methodID,args,'F');
1690
1691 }
1692
1693
1694 jfloat CallStaticFloatMethodA (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1695 {
1696         log_text("JNI-Call: CallStaticFloatMethodA");
1697
1698 }
1699
1700
1701
1702 jdouble CallStaticDoubleMethod (JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1703 {
1704
1705         jdouble ret;
1706         va_list vaargs;
1707
1708 /*      log_text("JNI-Call: CallStaticDoubleMethod");*/
1709
1710         va_start(vaargs,methodID);
1711         ret = callFloatMethod(0,methodID,vaargs,'D');
1712         va_end(vaargs);
1713         return ret;
1714
1715 }
1716
1717
1718 jdouble CallStaticDoubleMethodV (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1719 {
1720         log_text("JNI-Call: CallStaticDoubleMethodV");
1721
1722         return callFloatMethod(0,methodID,args,'D');
1723 }
1724
1725
1726 jdouble CallStaticDoubleMethodA (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1727 {
1728         log_text("JNI-Call: CallStaticDoubleMethodA");
1729
1730         return 0;
1731 }
1732
1733
1734
1735 void CallStaticVoidMethod (JNIEnv *env, jclass cls, jmethodID methodID, ...)
1736 {
1737         va_list vaargs;
1738
1739 /*      log_text("JNI-Call: CallStaticVoidMethod");*/
1740
1741         va_start(vaargs,methodID);
1742         (void)callIntegerMethod(0,methodID,'V',vaargs);
1743         va_end(vaargs);
1744
1745 }
1746
1747
1748 void CallStaticVoidMethodV (JNIEnv *env, jclass cls, jmethodID methodID, va_list args)
1749 {
1750         log_text("JNI-Call: CallStaticVoidMethodV");
1751         (void)callIntegerMethod(0,methodID,'V',args);
1752
1753 }
1754
1755
1756 void CallStaticVoidMethodA (JNIEnv *env, jclass cls, jmethodID methodID, jvalue * args)
1757 {
1758         log_text("JNI-Call: CallStaticVoidMethodA");
1759
1760 }
1761
1762 /****************** JNI-functions for accessing static fields ********************/
1763
1764 jfieldID GetStaticFieldID (JNIEnv *env, jclass clazz, const char *name, const char *sig)
1765 {
1766         jfieldID f;
1767
1768         f = jclass_findfield(clazz,
1769                             utf_new_char ((char*) name),
1770                             utf_new_char ((char*) sig)
1771                             );
1772
1773         if (!f) exceptionptr =  native_new_and_init(class_java_lang_NoSuchFieldError);
1774
1775         return f;
1776 }
1777
1778
1779 jobject GetStaticObjectField (JNIEnv *env, jclass clazz, jfieldID fieldID)
1780 {
1781         class_init(clazz);
1782         return fieldID->value.a;
1783 }
1784
1785
1786 jboolean GetStaticBooleanField (JNIEnv *env, jclass clazz, jfieldID fieldID)
1787 {
1788         class_init(clazz);
1789         return fieldID->value.i;
1790 }
1791
1792
1793 jbyte GetStaticByteField (JNIEnv *env, jclass clazz, jfieldID fieldID)
1794 {
1795         class_init(clazz);
1796         return fieldID->value.i;
1797 }
1798
1799
1800 jchar GetStaticCharField (JNIEnv *env, jclass clazz, jfieldID fieldID)
1801 {
1802         class_init(clazz);
1803         return fieldID->value.i;
1804 }
1805
1806
1807 jshort GetStaticShortField (JNIEnv *env, jclass clazz, jfieldID fieldID)
1808 {
1809         class_init(clazz);
1810         return fieldID->value.i;
1811 }
1812
1813
1814 jint GetStaticIntField (JNIEnv *env, jclass clazz, jfieldID fieldID)
1815 {
1816         class_init(clazz);
1817         return fieldID->value.i;
1818 }
1819
1820
1821 jlong GetStaticLongField (JNIEnv *env, jclass clazz, jfieldID fieldID)
1822 {
1823         class_init(clazz);
1824         return fieldID->value.l;
1825 }
1826
1827
1828 jfloat GetStaticFloatField (JNIEnv *env, jclass clazz, jfieldID fieldID)
1829 {
1830         class_init(clazz);
1831         return fieldID->value.f;
1832 }
1833
1834
1835 jdouble GetStaticDoubleField (JNIEnv *env, jclass clazz, jfieldID fieldID)
1836 {
1837         class_init(clazz);
1838         return fieldID->value.d;
1839 }
1840
1841
1842
1843 void SetStaticObjectField (JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value)
1844 {
1845         class_init(clazz);
1846         fieldID->value.a = value;
1847 }
1848
1849
1850 void SetStaticBooleanField (JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value)
1851 {
1852         class_init(clazz);
1853         fieldID->value.i = value;
1854 }
1855
1856
1857 void SetStaticByteField (JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value)
1858 {
1859         class_init(clazz);
1860         fieldID->value.i = value;
1861 }
1862
1863
1864 void SetStaticCharField (JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value)
1865 {
1866         class_init(clazz);
1867         fieldID->value.i = value;
1868 }
1869
1870
1871 void SetStaticShortField (JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value)
1872 {
1873         class_init(clazz);
1874         fieldID->value.i = value;
1875 }
1876
1877
1878 void SetStaticIntField (JNIEnv *env, jclass clazz, jfieldID fieldID, jint value)
1879 {
1880         class_init(clazz);
1881         fieldID->value.i = value;
1882 }
1883
1884
1885 void SetStaticLongField (JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value)
1886 {
1887         class_init(clazz);
1888         fieldID->value.l = value;
1889 }
1890
1891
1892 void SetStaticFloatField (JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value)
1893 {
1894         class_init(clazz);
1895         fieldID->value.f = value;
1896 }
1897
1898
1899 void SetStaticDoubleField (JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value)
1900 {
1901         class_init(clazz);
1902         fieldID->value.d = value;
1903 }
1904
1905
1906 /*****  create new java.lang.String object from an array of Unicode characters ****/
1907
1908 jstring NewString (JNIEnv *env, const jchar *buf, jsize len)
1909 {
1910         u4 i;
1911         java_lang_String *s;
1912         java_chararray *a;
1913
1914         s = (java_lang_String*) builtin_new (class_java_lang_String);
1915         a = builtin_newarray_char (len);
1916
1917         /* javastring or characterarray could not be created */
1918         if ( (!a) || (!s) ) return NULL;
1919
1920         /* copy text */
1921         for (i=0; i<len; i++) a->data[i] = buf[i];
1922         s -> value = a;
1923         s -> offset = 0;
1924         s -> count = len;
1925
1926         return (jstring) s;
1927 }
1928
1929 /******************* returns the length of a Java string ***************************/
1930
1931 jsize GetStringLength (JNIEnv *env, jstring str)
1932 {
1933         return ((java_lang_String*) str)->count;
1934 }
1935
1936
1937 /********************  convertes javastring to u2-array ****************************/
1938
1939 u2 *javastring_tou2 (jstring so)
1940 {
1941         java_lang_String *s = (java_lang_String*) so;
1942         java_chararray *a;
1943         u4 i;
1944         u2 *stringbuffer;
1945
1946         if (!s) return NULL;
1947
1948         a = s->value;
1949         if (!a) return NULL;
1950
1951         /* allocate memory */
1952         stringbuffer = MNEW( u2 , s->count + 1 );
1953
1954         /* copy text */
1955         for (i=0; i<s->count; i++) stringbuffer[i] = a->data[s->offset+i];
1956
1957         /* terminate string */
1958         stringbuffer[i] = '\0';
1959
1960         return stringbuffer;
1961 }
1962
1963 /********* returns a pointer to an array of Unicode characters of the string *******/
1964
1965 const jchar *GetStringChars (JNIEnv *env, jstring str, jboolean *isCopy)
1966 {
1967         return javastring_tou2(str);
1968 }
1969
1970 /**************** native code no longer needs access to chars **********************/
1971
1972 void ReleaseStringChars (JNIEnv *env, jstring str, const jchar *chars)
1973 {
1974         MFREE(((jchar*) chars),jchar,((java_lang_String*) str)->count);
1975 }
1976
1977 /************ create new java.lang.String object from utf8-characterarray **********/
1978
1979 jstring NewStringUTF (JNIEnv *env, const char *utf)
1980 {
1981 /*    log_text("NewStringUTF called");*/
1982     return javastring_new(utf_new_char(utf));
1983 }
1984
1985 /****************** returns the utf8 length in bytes of a string *******************/
1986
1987 jsize GetStringUTFLength (JNIEnv *env, jstring string)
1988 {
1989     java_lang_String *s = (java_lang_String*) string;
1990
1991     return (jsize) u2_utflength(s->value->data, s->count);
1992 }
1993
1994 /************ converts a Javastring to an array of UTF-8 characters ****************/
1995
1996 const char* GetStringUTFChars (JNIEnv *env, jstring string, jboolean *isCopy)
1997 {
1998     if (verbose) log_text("GetStringUTFChars:");
1999
2000     return javastring_toutf((java_lang_String*) string,false)->text;
2001
2002 }
2003
2004 /***************** native code no longer needs access to utf ***********************/
2005
2006 void ReleaseStringUTFChars (JNIEnv *env, jstring str, const char* chars)
2007 {
2008         /*
2009     log_text("JNI-Call: ReleaseStringUTFChars");
2010     utf_display(utf_new_char(chars));
2011         */
2012 }
2013
2014 /************************** array operations ***************************************/
2015
2016 jsize GetArrayLength (JNIEnv *env, jarray array)
2017 {
2018     return array->size;
2019 }
2020
2021 jobjectArray NewObjectArray (JNIEnv *env, jsize len, jclass clazz, jobject init)
2022 {
2023     java_objectarray *j = builtin_anewarray (len, clazz);
2024     if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
2025     return j;
2026 }
2027
2028 jobject GetObjectArrayElement (JNIEnv *env, jobjectArray array, jsize index)
2029 {
2030     jobject j = NULL;
2031
2032     if (index<array->header.size)
2033         j = array->data[index];
2034     else
2035         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2036
2037     return j;
2038 }
2039
2040 void SetObjectArrayElement (JNIEnv *env, jobjectArray array, jsize index, jobject val)
2041 {
2042     if (index>=array->header.size)
2043         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2044     else {
2045
2046         /* check if the class of value is a subclass of the element class of the array */
2047
2048                 if (!builtin_canstore((java_objectarray*)array,(java_objectheader*)val))
2049                         exceptionptr = proto_java_lang_ArrayStoreException;
2050                 else
2051                         array->data[index] = val;
2052     }
2053 }
2054
2055
2056
2057 jbooleanArray NewBooleanArray (JNIEnv *env, jsize len)
2058 {
2059     java_booleanarray *j = builtin_newarray_boolean(len);
2060     if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
2061     return j;
2062 }
2063
2064
2065 jbyteArray NewByteArray (JNIEnv *env, jsize len)
2066 {
2067     java_bytearray *j = builtin_newarray_byte(len);
2068     if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
2069     return j;
2070 }
2071
2072
2073 jcharArray NewCharArray (JNIEnv *env, jsize len)
2074 {
2075     java_chararray *j = builtin_newarray_char(len);
2076     if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
2077     return j;
2078 }
2079
2080
2081 jshortArray NewShortArray (JNIEnv *env, jsize len)
2082 {
2083     java_shortarray *j = builtin_newarray_short(len);
2084     if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
2085     return j;
2086 }
2087
2088
2089 jintArray NewIntArray (JNIEnv *env, jsize len)
2090 {
2091     java_intarray *j = builtin_newarray_int(len);
2092     if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
2093     return j;
2094 }
2095
2096
2097 jlongArray NewLongArray (JNIEnv *env, jsize len)
2098 {
2099     java_longarray *j = builtin_newarray_long(len);
2100     if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
2101     return j;
2102 }
2103
2104
2105 jfloatArray NewFloatArray (JNIEnv *env, jsize len)
2106 {
2107     java_floatarray *j = builtin_newarray_float(len);
2108     if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
2109     return j;
2110 }
2111
2112
2113 jdoubleArray NewDoubleArray (JNIEnv *env, jsize len)
2114 {
2115     java_doublearray *j = builtin_newarray_double(len);
2116     if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
2117     return j;
2118 }
2119
2120
2121 jboolean * GetBooleanArrayElements (JNIEnv *env, jbooleanArray array, jboolean *isCopy)
2122 {
2123     if (isCopy) *isCopy = JNI_FALSE;
2124     return array->data;
2125 }
2126
2127
2128 jbyte * GetByteArrayElements (JNIEnv *env, jbyteArray array, jboolean *isCopy)
2129 {
2130     if (isCopy) *isCopy = JNI_FALSE;
2131     return array->data;
2132 }
2133
2134
2135 jchar * GetCharArrayElements (JNIEnv *env, jcharArray array, jboolean *isCopy)
2136 {
2137     if (isCopy) *isCopy = JNI_FALSE;
2138     return array->data;
2139 }
2140
2141
2142 jshort * GetShortArrayElements (JNIEnv *env, jshortArray array, jboolean *isCopy)
2143 {
2144     if (isCopy) *isCopy = JNI_FALSE;
2145     return array->data;
2146 }
2147
2148
2149 jint * GetIntArrayElements (JNIEnv *env, jintArray array, jboolean *isCopy)
2150 {
2151     if (isCopy) *isCopy = JNI_FALSE;
2152     return array->data;
2153 }
2154
2155
2156 jlong * GetLongArrayElements (JNIEnv *env, jlongArray array, jboolean *isCopy)
2157 {
2158     if (isCopy) *isCopy = JNI_FALSE;
2159     return array->data;
2160 }
2161
2162
2163 jfloat * GetFloatArrayElements (JNIEnv *env, jfloatArray array, jboolean *isCopy)
2164 {
2165     if (isCopy) *isCopy = JNI_FALSE;
2166     return array->data;
2167 }
2168
2169
2170 jdouble * GetDoubleArrayElements (JNIEnv *env, jdoubleArray array, jboolean *isCopy)
2171 {
2172     if (isCopy) *isCopy = JNI_FALSE;
2173     return array->data;
2174 }
2175
2176
2177
2178 void ReleaseBooleanArrayElements (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode)
2179 {
2180     /* empty */
2181 }
2182
2183
2184 void ReleaseByteArrayElements (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode)
2185 {
2186     /* empty */
2187 }
2188
2189
2190 void ReleaseCharArrayElements (JNIEnv *env, jcharArray array, jchar *elems, jint mode)
2191 {
2192     /* empty */
2193 }
2194
2195
2196 void ReleaseShortArrayElements (JNIEnv *env, jshortArray array, jshort *elems, jint mode)
2197 {
2198     /* empty */
2199 }
2200
2201
2202 void ReleaseIntArrayElements (JNIEnv *env, jintArray array, jint *elems, jint mode)
2203 {
2204     /* empty */
2205 }
2206
2207
2208 void ReleaseLongArrayElements (JNIEnv *env, jlongArray array, jlong *elems, jint mode)
2209 {
2210     /* empty */
2211 }
2212
2213
2214 void ReleaseFloatArrayElements (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode)
2215 {
2216     /* empty */
2217 }
2218
2219
2220 void ReleaseDoubleArrayElements (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode)
2221 {
2222     /* empty */
2223 }
2224
2225 void GetBooleanArrayRegion (JNIEnv* env, jbooleanArray array, jsize start, jsize len, jboolean *buf)
2226 {
2227     if (start<0 || len<0 || start+len>array->header.size)
2228         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2229     else
2230         memcpy(buf,&array->data[start],len*sizeof(array->data[0]));
2231 }
2232
2233
2234 void GetByteArrayRegion (JNIEnv* env, jbyteArray array, jsize start, jsize len, jbyte *buf)
2235 {
2236     if (start<0 || len<0 || start+len>array->header.size)
2237         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2238     else
2239         memcpy(buf,&array->data[start],len*sizeof(array->data[0]));
2240 }
2241
2242
2243 void GetCharArrayRegion (JNIEnv* env, jcharArray array, jsize start, jsize len, jchar *buf)
2244 {
2245     if (start<0 || len<0 || start+len>array->header.size)
2246         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2247     else
2248         memcpy(buf,&array->data[start],len*sizeof(array->data[0]));
2249 }
2250
2251
2252 void GetShortArrayRegion (JNIEnv* env, jshortArray array, jsize start, jsize len, jshort *buf)
2253 {
2254     if (start<0 || len<0 || start+len>array->header.size)
2255         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2256     else
2257         memcpy(buf,&array->data[start],len*sizeof(array->data[0]));
2258 }
2259
2260
2261 void GetIntArrayRegion (JNIEnv* env, jintArray array, jsize start, jsize len, jint *buf)
2262 {
2263     if (start<0 || len<0 || start+len>array->header.size)
2264         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2265     else
2266         memcpy(buf,&array->data[start],len*sizeof(array->data[0]));
2267 }
2268
2269
2270 void GetLongArrayRegion (JNIEnv* env, jlongArray array, jsize start, jsize len, jlong *buf)
2271 {
2272     if (start<0 || len<0 || start+len>array->header.size)
2273         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2274     else
2275         memcpy(buf,&array->data[start],len*sizeof(array->data[0]));
2276 }
2277
2278
2279 void GetFloatArrayRegion (JNIEnv* env, jfloatArray array, jsize start, jsize len, jfloat *buf)
2280 {
2281     if (start<0 || len<0 || start+len>array->header.size)
2282         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2283     else
2284         memcpy(buf,&array->data[start],len*sizeof(array->data[0]));
2285 }
2286
2287
2288 void GetDoubleArrayRegion (JNIEnv* env, jdoubleArray array, jsize start, jsize len, jdouble *buf)
2289 {
2290     if (start<0 || len<0 || start+len>array->header.size)
2291         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2292     else
2293         memcpy(buf,&array->data[start],len*sizeof(array->data[0]));
2294 }
2295
2296
2297 void SetBooleanArrayRegion (JNIEnv* env, jbooleanArray array, jsize start, jsize len, jboolean *buf)
2298 {
2299     if (start<0 || len<0 || start+len>array->header.size)
2300         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2301     else
2302         memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
2303 }
2304
2305
2306 void SetByteArrayRegion (JNIEnv* env, jbyteArray array, jsize start, jsize len, jbyte *buf)
2307 {
2308     if (start<0 || len<0 || start+len>array->header.size)
2309         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2310     else
2311         memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
2312 }
2313
2314
2315 void SetCharArrayRegion (JNIEnv* env, jcharArray array, jsize start, jsize len, jchar *buf)
2316 {
2317     if (start<0 || len<0 || start+len>array->header.size)
2318         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2319     else
2320         memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
2321
2322 }
2323
2324
2325 void SetShortArrayRegion (JNIEnv* env, jshortArray array, jsize start, jsize len, jshort *buf)
2326 {
2327     if (start<0 || len<0 || start+len>array->header.size)
2328         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2329     else
2330         memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
2331 }
2332
2333
2334 void SetIntArrayRegion (JNIEnv* env, jintArray array, jsize start, jsize len, jint *buf)
2335 {
2336     if (start<0 || len<0 || start+len>array->header.size)
2337         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2338     else
2339         memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
2340
2341 }
2342
2343 void SetLongArrayRegion (JNIEnv* env, jlongArray array, jsize start, jsize len, jlong *buf)
2344 {
2345     if (start<0 || len<0 || start+len>array->header.size)
2346         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2347     else
2348         memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
2349
2350 }
2351
2352 void SetFloatArrayRegion (JNIEnv* env, jfloatArray array, jsize start, jsize len, jfloat *buf)
2353 {
2354     if (start<0 || len<0 || start+len>array->header.size)
2355         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2356     else
2357         memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
2358
2359 }
2360
2361 void SetDoubleArrayRegion (JNIEnv* env, jdoubleArray array, jsize start, jsize len, jdouble *buf)
2362 {
2363     if (start<0 || len<0 || start+len>array->header.size)
2364         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
2365     else
2366         memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
2367 }
2368
2369 jint RegisterNatives (JNIEnv* env, jclass clazz, const JNINativeMethod *methods, jint nMethods)
2370 {
2371     log_text("JNI-Call: RegisterNatives");
2372     return 0;
2373 }
2374
2375
2376 jint UnregisterNatives (JNIEnv* env, jclass clazz)
2377 {
2378     log_text("JNI-Call: UnregisterNatives");
2379     return 0;
2380 }
2381
2382 /******************************* monitor operations ********************************/
2383
2384 jint MonitorEnter (JNIEnv* env, jobject obj)
2385 {
2386     builtin_monitorenter(obj);
2387     return 0;
2388 }
2389
2390
2391 jint MonitorExit (JNIEnv* env, jobject obj)
2392 {
2393     builtin_monitorexit(obj);
2394     return 0;
2395 }
2396
2397
2398 /************************************* JavaVM interface ****************************/
2399 #ifdef __cplusplus
2400 #error CPP mode not supported yet
2401 #else
2402 jint GetJavaVM (JNIEnv* env, JavaVM **vm)
2403 {
2404     log_text("JNI-Call: GetJavaVM");
2405     *vm=&javaVM;
2406     return 0;
2407 }
2408 #endif /*__cplusplus*/
2409
2410 void GetStringRegion (JNIEnv* env, jstring str, jsize start, jsize len, jchar *buf)
2411 {
2412     log_text("JNI-Call: GetStringRegion");
2413
2414 }
2415
2416 void GetStringUTFRegion (JNIEnv* env, jstring str, jsize start, jsize len, char *buf)
2417 {
2418     log_text("JNI-Call: GetStringUTFRegion");
2419
2420 }
2421
2422 /****************** obtain direct pointer to array elements ***********************/
2423
2424 void * GetPrimitiveArrayCritical (JNIEnv* env, jarray array, jboolean *isCopy)
2425 {
2426         java_objectheader *s = (java_objectheader*) array;
2427         arraydescriptor *desc = s->vftbl->arraydesc;
2428
2429         if (!desc) return NULL;
2430
2431         return ((u1*)s) + desc->dataoffset;
2432 }
2433
2434
2435 void ReleasePrimitiveArrayCritical (JNIEnv* env, jarray array, void *carray, jint mode)
2436 {
2437         log_text("JNI-Call: ReleasePrimitiveArrayCritical");
2438
2439         /* empty */
2440 }
2441
2442 /********* returns a pointer to an array of Unicode characters of the string *******/
2443
2444 const jchar * GetStringCritical (JNIEnv* env, jstring string, jboolean *isCopy)
2445 {
2446         log_text("JNI-Call: GetStringCritical");
2447
2448         return GetStringChars(env,string,isCopy);
2449 }
2450
2451 /**************** native code no longer needs access to chars **********************/
2452
2453 void ReleaseStringCritical (JNIEnv* env, jstring string, const jchar *cstring)
2454 {
2455         log_text("JNI-Call: ReleaseStringCritical");
2456
2457         ReleaseStringChars(env,string,cstring);
2458 }
2459
2460
2461 jweak NewWeakGlobalRef (JNIEnv* env, jobject obj)
2462 {
2463         log_text("JNI-Call: NewWeakGlobalRef");
2464
2465         return obj;
2466 }
2467
2468
2469 void DeleteWeakGlobalRef (JNIEnv* env, jweak ref)
2470 {
2471         log_text("JNI-Call: DeleteWeakGlobalRef");
2472
2473         /* empty */
2474 }
2475
2476
2477 /******************************* check for pending exception ***********************/
2478
2479
2480 jboolean ExceptionCheck (JNIEnv* env)
2481 {
2482         log_text("JNI-Call: ExceptionCheck");
2483
2484         return exceptionptr ? JNI_TRUE : JNI_FALSE;
2485 }
2486
2487
2488
2489
2490
2491
2492 jint DestroyJavaVM (JavaVM *vm) {
2493         log_text("DestroyJavaVM called");
2494 }
2495
2496 jint AttachCurrentThread(JavaVM *vm, void **par1, void *par2) {
2497         log_text("AttachCurrentThread called");
2498 }
2499
2500 jint DetachCurrentThread (JavaVM *vm) {
2501         log_text("DetachCurrentThread called");
2502 }
2503
2504 jint GetEnv (JavaVM *vm, void **environment, jint jniversion) {
2505         *environment=&env;
2506         return 0;
2507 }
2508
2509 jint AttachCurrentThreadAsDaemon (JavaVM *vm, void **par1, void *par2) {
2510         log_text("AttachCurrentThreadAsDaemon called");
2511 }
2512
2513
2514
2515
2516
2517
2518
2519
2520
2521
2522
2523 /********************************* JNI invocation table ******************************/
2524
2525 struct _JavaVM javaVMTable={
2526    NULL,
2527    NULL,
2528    NULL,
2529    &DestroyJavaVM,
2530    &AttachCurrentThread,
2531    &DetachCurrentThread,
2532    &GetEnv,
2533    &AttachCurrentThreadAsDaemon
2534
2535 };
2536
2537 JavaVM javaVM=&javaVMTable;
2538
2539 /********************************* JNI function table ******************************/
2540
2541 struct JNI_Table envTable =
2542    {
2543     NULL,
2544     NULL,
2545     NULL,
2546     NULL,
2547     &GetVersion,
2548     &DefineClass,
2549     &FindClass,
2550     &FromReflectedMethod,
2551     &FromReflectedField,
2552     &ToReflectedMethod,
2553     &GetSuperclass,
2554     &IsAssignableForm,
2555     &ToReflectedField,
2556     &Throw,
2557     &ThrowNew,
2558     &ExceptionOccurred,
2559     &ExceptionDescribe,
2560     &ExceptionClear,
2561     &FatalError,
2562     &PushLocalFrame,
2563     &PopLocalFrame,
2564     &NewGlobalRef,
2565     &DeleteGlobalRef,
2566     &DeleteLocalRef,
2567     &IsSameObject,
2568     &NewLocalRef,
2569     &EnsureLocalCapacity,
2570     &AllocObject,
2571     &NewObject,
2572     &NewObjectV,
2573     &NewObjectA,
2574     &GetObjectClass,
2575     &IsInstanceOf,
2576     &GetMethodID,
2577     &CallObjectMethod,
2578     &CallObjectMethodV,
2579     &CallObjectMethodA,
2580     &CallBooleanMethod,
2581     &CallBooleanMethodV,
2582     &CallBooleanMethodA,
2583     &CallByteMethod,
2584     &CallByteMethodV,
2585     &CallByteMethodA,
2586     &CallCharMethod,
2587     &CallCharMethodV,
2588     &CallCharMethodA,
2589     &CallShortMethod,
2590     &CallShortMethodV,
2591     &CallShortMethodA,
2592     &CallIntMethod,
2593     &CallIntMethodV,
2594     &CallIntMethodA,
2595     &CallLongMethod,
2596     &CallLongMethodV,
2597     &CallLongMethodA,
2598     &CallFloatMethod,
2599     &CallFloatMethodV,
2600     &CallFloatMethodA,
2601     &CallDoubleMethod,
2602     &CallDoubleMethodV,
2603     &CallDoubleMethodA,
2604     &CallVoidMethod,
2605     &CallVoidMethodV,
2606     &CallVoidMethodA,
2607     &CallNonvirtualObjectMethod,
2608     &CallNonvirtualObjectMethodV,
2609     &CallNonvirtualObjectMethodA,
2610     &CallNonvirtualBooleanMethod,
2611     &CallNonvirtualBooleanMethodV,
2612     &CallNonvirtualBooleanMethodA,
2613     &CallNonvirtualByteMethod,
2614     &CallNonvirtualByteMethodV,
2615     &CallNonvirtualByteMethodA,
2616     &CallNonvirtualCharMethod,
2617     &CallNonvirtualCharMethodV,
2618     &CallNonvirtualCharMethodA,
2619     &CallNonvirtualShortMethod,
2620     &CallNonvirtualShortMethodV,
2621     &CallNonvirtualShortMethodA,
2622     &CallNonvirtualIntMethod,
2623     &CallNonvirtualIntMethodV,
2624     &CallNonvirtualIntMethodA,
2625     &CallNonvirtualLongMethod,
2626     &CallNonvirtualLongMethodV,
2627     &CallNonvirtualLongMethodA,
2628     &CallNonvirtualFloatMethod,
2629     &CallNonvirtualFloatMethodV,
2630     &CallNonvirtualFloatMethodA,
2631     &CallNonvirtualDoubleMethod,
2632     &CallNonvirtualDoubleMethodV,
2633     &CallNonvirtualDoubleMethodA,
2634     &CallNonvirtualVoidMethod,
2635     &CallNonvirtualVoidMethodV,
2636     &CallNonvirtualVoidMethodA,
2637     &GetFieldID,
2638     &GetObjectField,
2639     &GetBooleanField,
2640     &GetByteField,
2641     &GetCharField,
2642     &GetShortField,
2643     &GetIntField,
2644     &GetLongField,
2645     &GetFloatField,
2646     &GetDoubleField,
2647     &SetObjectField,
2648     &SetBooleanField,
2649     &SetByteField,
2650     &SetCharField,
2651     &SetShortField,
2652     &SetIntField,
2653     &SetLongField,
2654     &SetFloatField,
2655     &SetDoubleField,
2656     &GetStaticMethodID,
2657     &CallStaticObjectMethod,
2658     &CallStaticObjectMethodV,
2659     &CallStaticObjectMethodA,
2660     &CallStaticBooleanMethod,
2661     &CallStaticBooleanMethodV,
2662     &CallStaticBooleanMethodA,
2663     &CallStaticByteMethod,
2664     &CallStaticByteMethodV,
2665     &CallStaticByteMethodA,
2666     &CallStaticCharMethod,
2667     &CallStaticCharMethodV,
2668     &CallStaticCharMethodA,
2669     &CallStaticShortMethod,
2670     &CallStaticShortMethodV,
2671     &CallStaticShortMethodA,
2672     &CallStaticIntMethod,
2673     &CallStaticIntMethodV,
2674     &CallStaticIntMethodA,
2675     &CallStaticLongMethod,
2676     &CallStaticLongMethodV,
2677     &CallStaticLongMethodA,
2678     &CallStaticFloatMethod,
2679     &CallStaticFloatMethodV,
2680     &CallStaticFloatMethodA,
2681     &CallStaticDoubleMethod,
2682     &CallStaticDoubleMethodV,
2683     &CallStaticDoubleMethodA,
2684     &CallStaticVoidMethod,
2685     &CallStaticVoidMethodV,
2686     &CallStaticVoidMethodA,
2687     &GetStaticFieldID,
2688     &GetStaticObjectField,
2689     &GetStaticBooleanField,
2690     &GetStaticByteField,
2691     &GetStaticCharField,
2692     &GetStaticShortField,
2693     &GetStaticIntField,
2694     &GetStaticLongField,
2695     &GetStaticFloatField,
2696     &GetStaticDoubleField,
2697     &SetStaticObjectField,
2698     &SetStaticBooleanField,
2699     &SetStaticByteField,
2700     &SetStaticCharField,
2701     &SetStaticShortField,
2702     &SetStaticIntField,
2703     &SetStaticLongField,
2704     &SetStaticFloatField,
2705     &SetStaticDoubleField,
2706     &NewString,
2707     &GetStringLength,
2708     &GetStringChars,
2709     &ReleaseStringChars,
2710     &NewStringUTF,
2711     &GetStringUTFLength,
2712     &GetStringUTFChars,
2713     &ReleaseStringUTFChars,
2714     &GetArrayLength,
2715     &NewObjectArray,
2716     &GetObjectArrayElement,
2717     &SetObjectArrayElement,
2718     &NewBooleanArray,
2719     &NewByteArray,
2720     &NewCharArray,
2721     &NewShortArray,
2722     &NewIntArray,
2723     &NewLongArray,
2724     &NewFloatArray,
2725     &NewDoubleArray,
2726     &GetBooleanArrayElements,
2727     &GetByteArrayElements,
2728     &GetCharArrayElements,
2729     &GetShortArrayElements,
2730     &GetIntArrayElements,
2731     &GetLongArrayElements,
2732     &GetFloatArrayElements,
2733     &GetDoubleArrayElements,
2734     &ReleaseBooleanArrayElements,
2735     &ReleaseByteArrayElements,
2736     &ReleaseCharArrayElements,
2737     &ReleaseShortArrayElements,
2738     &ReleaseIntArrayElements,
2739     &ReleaseLongArrayElements,
2740     &ReleaseFloatArrayElements,
2741     &ReleaseDoubleArrayElements,
2742     &GetBooleanArrayRegion,
2743     &GetByteArrayRegion,
2744     &GetCharArrayRegion,
2745     &GetShortArrayRegion,
2746     &GetIntArrayRegion,
2747     &GetLongArrayRegion,
2748     &GetFloatArrayRegion,
2749     &GetDoubleArrayRegion,
2750     &SetBooleanArrayRegion,
2751     &SetByteArrayRegion,
2752     &SetCharArrayRegion,
2753     &SetShortArrayRegion,
2754     &SetIntArrayRegion,
2755     &SetLongArrayRegion,
2756     &SetFloatArrayRegion,
2757     &SetDoubleArrayRegion,
2758     &RegisterNatives,
2759     &UnregisterNatives,
2760     &MonitorEnter,
2761     &MonitorExit,
2762     &GetJavaVM,
2763     &GetStringRegion,
2764     &GetStringUTFRegion,
2765     &GetPrimitiveArrayCritical,
2766     &ReleasePrimitiveArrayCritical,
2767     &GetStringCritical,
2768     &ReleaseStringCritical,
2769     &NewWeakGlobalRef,
2770     &DeleteWeakGlobalRef,
2771     &ExceptionCheck
2772     };
2773
2774
2775 JNIEnv env=&envTable;
2776
2777
2778 /*
2779  * These are local overrides for various environment variables in Emacs.
2780  * Please do not remove this and leave it at the end of the file, where
2781  * Emacs will automagically detect them.
2782  * ---------------------------------------------------------------------
2783  * Local variables:
2784  * mode: c
2785  * indent-tabs-mode: t
2786  * c-basic-offset: 4
2787  * tab-width: 4
2788  * End:
2789  */