OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libjava/] [jni.cc] - Blame information for rev 757

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 753 jeremybenn
// jni.cc - JNI implementation, including the jump table.
2
 
3
/* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
4
   Free Software Foundation
5
 
6
   This file is part of libgcj.
7
 
8
This software is copyrighted work licensed under the terms of the
9
Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
10
details.  */
11
 
12
#include <config.h>
13
 
14
#include <stdio.h>
15
#include <stddef.h>
16
#include <string.h>
17
 
18
#include <gcj/cni.h>
19
#include <jvm.h>
20
#include <java-assert.h>
21
#include <jni.h>
22
#ifdef ENABLE_JVMPI
23
#include <jvmpi.h>
24
#endif
25
#ifdef INTERPRETER
26
#include <jvmti.h>
27
#include "jvmti-int.h"
28
#endif
29
#include <java/lang/Class.h>
30
#include <java/lang/ClassLoader.h>
31
#include <java/lang/Throwable.h>
32
#include <java/lang/ArrayIndexOutOfBoundsException.h>
33
#include <java/lang/StringIndexOutOfBoundsException.h>
34
#include <java/lang/StringBuffer.h>
35
#include <java/lang/UnsatisfiedLinkError.h>
36
#include <java/lang/InstantiationException.h>
37
#include <java/lang/NoSuchFieldError.h>
38
#include <java/lang/NoSuchMethodError.h>
39
#include <java/lang/reflect/Constructor.h>
40
#include <java/lang/reflect/Method.h>
41
#include <java/lang/reflect/Modifier.h>
42
#include <java/lang/OutOfMemoryError.h>
43
#include <java/lang/Integer.h>
44
#include <java/lang/ThreadGroup.h>
45
#include <java/lang/Thread.h>
46
#include <java/lang/IllegalAccessError.h>
47
#include <java/nio/Buffer.h>
48
#include <java/nio/DirectByteBufferImpl.h>
49
#include <java/nio/DirectByteBufferImpl$ReadWrite.h>
50
#include <java/util/IdentityHashMap.h>
51
#include <gnu/gcj/RawData.h>
52
#include <java/lang/ClassNotFoundException.h>
53
 
54
#include <gcj/method.h>
55
#include <gcj/field.h>
56
 
57
#include <java-interp.h>
58
#include <java-threads.h>
59
 
60
using namespace gcj;
61
 
62
// This enum is used to select different template instantiations in
63
// the invocation code.
64
enum invocation_type
65
{
66
  normal,
67
  nonvirtual,
68
  static_type,
69
  constructor
70
};
71
 
72
// Forward declarations.
73
extern struct JNINativeInterface_ _Jv_JNIFunctions;
74
extern struct JNIInvokeInterface_ _Jv_JNI_InvokeFunctions;
75
 
76
// Number of slots in the default frame.  The VM must allow at least
77
// 16.
78
#define FRAME_SIZE 16
79
 
80
// Mark value indicating this is an overflow frame.
81
#define MARK_NONE    0
82
// Mark value indicating this is a user frame.
83
#define MARK_USER    1
84
// Mark value indicating this is a system frame.
85
#define MARK_SYSTEM  2
86
 
87
// This structure is used to keep track of local references.
88
struct _Jv_JNI_LocalFrame
89
{
90
  // This is one of the MARK_ constants.
91
  unsigned char marker;
92
 
93
  // Flag to indicate some locals were allocated.
94
  bool allocated_p;
95
 
96
  // Number of elements in frame.
97
  int size;
98
 
99
  // The class loader of the JNI method that allocated this frame.
100
  ::java::lang::ClassLoader *loader;
101
 
102
  // Next frame in chain.
103
  _Jv_JNI_LocalFrame *next;
104
 
105
  // The elements.  These are allocated using the C "struct hack".
106
  jobject vec[0];
107
};
108
 
109
// This holds a reference count for all local references.
110
static java::util::IdentityHashMap *local_ref_table;
111
// This holds a reference count for all global references.
112
static java::util::IdentityHashMap *global_ref_table;
113
 
114
// The only VM.
115
JavaVM *_Jv_the_vm;
116
 
117
#ifdef ENABLE_JVMPI
118
// The only JVMPI interface description.
119
static JVMPI_Interface _Jv_JVMPI_Interface;
120
 
121
static jint
122
jvmpiEnableEvent (jint event_type, void *)
123
{
124
  switch (event_type)
125
    {
126
    case JVMPI_EVENT_OBJECT_ALLOC:
127
      _Jv_JVMPI_Notify_OBJECT_ALLOC = _Jv_JVMPI_Interface.NotifyEvent;
128
      break;
129
 
130
    case JVMPI_EVENT_THREAD_START:
131
      _Jv_JVMPI_Notify_THREAD_START = _Jv_JVMPI_Interface.NotifyEvent;
132
      break;
133
 
134
    case JVMPI_EVENT_THREAD_END:
135
      _Jv_JVMPI_Notify_THREAD_END = _Jv_JVMPI_Interface.NotifyEvent;
136
      break;
137
 
138
    default:
139
      return JVMPI_NOT_AVAILABLE;
140
    }
141
 
142
  return JVMPI_SUCCESS;
143
}
144
 
145
static jint
146
jvmpiDisableEvent (jint event_type, void *)
147
{
148
  switch (event_type)
149
    {
150
    case JVMPI_EVENT_OBJECT_ALLOC:
151
      _Jv_JVMPI_Notify_OBJECT_ALLOC = NULL;
152
      break;
153
 
154
    default:
155
      return JVMPI_NOT_AVAILABLE;
156
    }
157
 
158
  return JVMPI_SUCCESS;
159
}
160
#endif
161
 
162
 
163
 
164
void
165
_Jv_JNI_Init (void)
166
{
167
  local_ref_table = new java::util::IdentityHashMap;
168
  global_ref_table = new java::util::IdentityHashMap;
169
 
170
#ifdef ENABLE_JVMPI
171
  _Jv_JVMPI_Interface.version = 1;
172
  _Jv_JVMPI_Interface.EnableEvent = &jvmpiEnableEvent;
173
  _Jv_JVMPI_Interface.DisableEvent = &jvmpiDisableEvent;
174
  _Jv_JVMPI_Interface.EnableGC = &_Jv_EnableGC;
175
  _Jv_JVMPI_Interface.DisableGC = &_Jv_DisableGC;
176
  _Jv_JVMPI_Interface.RunGC = &_Jv_RunGC;
177
#endif
178
}
179
 
180
// Tell the GC that a certain pointer is live.
181
static void
182
mark_for_gc (jobject obj, java::util::IdentityHashMap *ref_table)
183
{
184
  JvSynchronize sync (ref_table);
185
 
186
  using namespace java::lang;
187
  Integer *refcount = (Integer *) ref_table->get (obj);
188
  jint val = (refcount == NULL) ? 0 : refcount->intValue ();
189
  // FIXME: what about out of memory error?
190
  ref_table->put (obj, new Integer (val + 1));
191
}
192
 
193
// Unmark a pointer.
194
static void
195
unmark_for_gc (jobject obj, java::util::IdentityHashMap *ref_table)
196
{
197
  JvSynchronize sync (ref_table);
198
 
199
  using namespace java::lang;
200
  Integer *refcount = (Integer *) ref_table->get (obj);
201
  JvAssert (refcount);
202
  jint val = refcount->intValue () - 1;
203
  JvAssert (val >= 0);
204
  if (val == 0)
205
    ref_table->remove (obj);
206
  else
207
    // FIXME: what about out of memory error?
208
    ref_table->put (obj, new Integer (val));
209
}
210
 
211
// "Unwrap" some random non-reference type.  This exists to simplify
212
// other template functions.
213
template<typename T>
214
static T
215
unwrap (T val)
216
{
217
  return val;
218
}
219
 
220
// Unwrap a weak reference, if required.
221
template<typename T>
222
static T *
223
unwrap (T *obj)
224
{
225
  using namespace gnu::gcj::runtime;
226
  // We can compare the class directly because JNIWeakRef is `final'.
227
  // Doing it this way is much faster.
228
  if (obj == NULL || obj->getClass () != &JNIWeakRef::class$)
229
    return obj;
230
  JNIWeakRef *wr = reinterpret_cast<JNIWeakRef *> (obj);
231
  return reinterpret_cast<T *> (wr->get ());
232
}
233
 
234
jobject
235
_Jv_UnwrapJNIweakReference (jobject obj)
236
{
237
  return unwrap (obj);
238
}
239
 
240
 
241
 
242
static jobject JNICALL
243
_Jv_JNI_NewGlobalRef (JNIEnv *, jobject obj)
244
{
245
  // This seems weird but I think it is correct.
246
  obj = unwrap (obj);
247
  mark_for_gc (obj, global_ref_table);
248
  return obj;
249
}
250
 
251
static void JNICALL
252
_Jv_JNI_DeleteGlobalRef (JNIEnv *, jobject obj)
253
{
254
  // This seems weird but I think it is correct.
255
  obj = unwrap (obj);
256
 
257
  // NULL is ok here -- the JNI specification doesn't say so, but this
258
  // is a no-op.
259
  if (! obj)
260
    return;
261
 
262
  unmark_for_gc (obj, global_ref_table);
263
}
264
 
265
static void JNICALL
266
_Jv_JNI_DeleteLocalRef (JNIEnv *env, jobject obj)
267
{
268
  _Jv_JNI_LocalFrame *frame;
269
 
270
  // This seems weird but I think it is correct.
271
  obj = unwrap (obj);
272
 
273
  // NULL is ok here -- the JNI specification doesn't say so, but this
274
  // is a no-op.
275
  if (! obj)
276
    return;
277
 
278
  for (frame = env->locals; frame != NULL; frame = frame->next)
279
    {
280
      for (int i = 0; i < frame->size; ++i)
281
        {
282
          if (frame->vec[i] == obj)
283
            {
284
              frame->vec[i] = NULL;
285
              unmark_for_gc (obj, local_ref_table);
286
              return;
287
            }
288
        }
289
 
290
      // Don't go past a marked frame.
291
      JvAssert (frame->marker == MARK_NONE);
292
    }
293
 
294
  JvAssert (0);
295
}
296
 
297
static jint JNICALL
298
_Jv_JNI_EnsureLocalCapacity (JNIEnv *env, jint size)
299
{
300
  // It is easier to just always allocate a new frame of the requested
301
  // size.  This isn't the most efficient thing, but for now we don't
302
  // care.  Note that _Jv_JNI_PushLocalFrame relies on this right now.
303
 
304
  _Jv_JNI_LocalFrame *frame;
305
  try
306
    {
307
      frame = (_Jv_JNI_LocalFrame *) _Jv_Malloc (sizeof (_Jv_JNI_LocalFrame)
308
                                                 + size * sizeof (jobject));
309
    }
310
  catch (jthrowable t)
311
    {
312
      env->ex = t;
313
      return JNI_ERR;
314
    }
315
 
316
  frame->marker = MARK_NONE;
317
  frame->size = size;
318
  frame->allocated_p = false;
319
  memset (&frame->vec[0], 0, size * sizeof (jobject));
320
  frame->loader = env->locals->loader;
321
  frame->next = env->locals;
322
  env->locals = frame;
323
 
324
  return 0;
325
}
326
 
327
static jint JNICALL
328
_Jv_JNI_PushLocalFrame (JNIEnv *env, jint size)
329
{
330
  jint r = _Jv_JNI_EnsureLocalCapacity (env, size);
331
  if (r < 0)
332
    return r;
333
 
334
  // The new frame is on top.
335
  env->locals->marker = MARK_USER;
336
 
337
  return 0;
338
}
339
 
340
static jobject JNICALL
341
_Jv_JNI_NewLocalRef (JNIEnv *env, jobject obj)
342
{
343
  // This seems weird but I think it is correct.
344
  obj = unwrap (obj);
345
 
346
  // Try to find an open slot somewhere in the topmost frame.
347
  _Jv_JNI_LocalFrame *frame = env->locals;
348
  bool done = false, set = false;
349
  for (; frame != NULL && ! done; frame = frame->next)
350
    {
351
      for (int i = 0; i < frame->size; ++i)
352
        {
353
          if (frame->vec[i] == NULL)
354
            {
355
              set = true;
356
              done = true;
357
              frame->vec[i] = obj;
358
              frame->allocated_p = true;
359
              break;
360
            }
361
        }
362
 
363
      // If we found a slot, or if the frame we just searched is the
364
      // mark frame, then we are done.
365
      if (done || frame == NULL || frame->marker != MARK_NONE)
366
        break;
367
    }
368
 
369
  if (! set)
370
    {
371
      // No slots, so we allocate a new frame.  According to the spec
372
      // we could just die here.  FIXME: return value.
373
      _Jv_JNI_EnsureLocalCapacity (env, 16);
374
      // We know the first element of the new frame will be ok.
375
      env->locals->vec[0] = obj;
376
      env->locals->allocated_p = true;
377
    }
378
 
379
  mark_for_gc (obj, local_ref_table);
380
  return obj;
381
}
382
 
383
static jobject JNICALL
384
_Jv_JNI_PopLocalFrame (JNIEnv *env, jobject result, int stop)
385
{
386
  _Jv_JNI_LocalFrame *rf = env->locals;
387
 
388
  bool done = false;
389
  while (rf != NULL && ! done)
390
    {
391
      for (int i = 0; i < rf->size; ++i)
392
        if (rf->vec[i] != NULL)
393
          unmark_for_gc (rf->vec[i], local_ref_table);
394
 
395
      // If the frame we just freed is the marker frame, we are done.
396
      done = (rf->marker == stop);
397
 
398
      _Jv_JNI_LocalFrame *n = rf->next;
399
      // When N==NULL, we've reached the reusable bottom_locals, and we must
400
      // not free it.  However, we must be sure to clear all its elements.
401
      if (n == NULL)
402
        {
403
          if (rf->allocated_p)
404
            memset (&rf->vec[0], 0, rf->size * sizeof (jobject));
405
          rf->allocated_p = false;
406
          rf = NULL;
407
          break;
408
        }
409
 
410
      _Jv_Free (rf);
411
      rf = n;
412
    }
413
 
414
  // Update the local frame information.
415
  env->locals = rf;
416
 
417
  return result == NULL ? NULL : _Jv_JNI_NewLocalRef (env, result);
418
}
419
 
420
static jobject JNICALL
421
_Jv_JNI_PopLocalFrame (JNIEnv *env, jobject result)
422
{
423
  return _Jv_JNI_PopLocalFrame (env, result, MARK_USER);
424
}
425
 
426
// Make sure an array's type is compatible with the type of the
427
// destination.
428
template<typename T>
429
static bool
430
_Jv_JNI_check_types (JNIEnv *env, JArray<T> *array, jclass K)
431
{
432
  jclass klass = array->getClass()->getComponentType();
433
  if (__builtin_expect (klass != K, false))
434
    {
435
      env->ex = new java::lang::IllegalAccessError ();
436
      return false;
437
    }
438
  else
439
    return true;
440
}
441
 
442
// Pop a `system' frame from the stack.  This is `extern "C"' as it is
443
// used by the compiler.
444
extern "C" void
445
_Jv_JNI_PopSystemFrame (JNIEnv *env)
446
{
447
  // Only enter slow path when we're not at the bottom, or there have been
448
  // allocations. Usually this is false and we can just null out the locals
449
  // field.
450
 
451
  if (__builtin_expect ((env->locals->next
452
                         || env->locals->allocated_p), false))
453
    _Jv_JNI_PopLocalFrame (env, NULL, MARK_SYSTEM);
454
  else
455
    env->locals = NULL;
456
 
457
#ifdef INTERPRETER
458
  if (__builtin_expect (env->ex != NULL, false))
459
    {
460
      jthrowable t = env->ex;
461
      env->ex = NULL;
462
      if (JVMTI_REQUESTED_EVENT (Exception))
463
        _Jv_ReportJVMTIExceptionThrow (t);
464
      throw t;
465
    }
466
#endif
467
}
468
 
469
template<typename T> T extract_from_jvalue(jvalue const & t);
470
template<> jboolean extract_from_jvalue(jvalue const & jv) { return jv.z; }
471
template<> jbyte    extract_from_jvalue(jvalue const & jv) { return jv.b; }
472
template<> jchar    extract_from_jvalue(jvalue const & jv) { return jv.c; }
473
template<> jshort   extract_from_jvalue(jvalue const & jv) { return jv.s; }
474
template<> jint     extract_from_jvalue(jvalue const & jv) { return jv.i; }
475
template<> jlong    extract_from_jvalue(jvalue const & jv) { return jv.j; }
476
template<> jfloat   extract_from_jvalue(jvalue const & jv) { return jv.f; }
477
template<> jdouble  extract_from_jvalue(jvalue const & jv) { return jv.d; }
478
template<> jobject  extract_from_jvalue(jvalue const & jv) { return jv.l; }
479
 
480
 
481
// This function is used from other template functions.  It wraps the
482
// return value appropriately; we specialize it so that object returns
483
// are turned into local references.
484
template<typename T>
485
static T
486
wrap_value (JNIEnv *, T value)
487
{
488
  return value;
489
}
490
 
491
// This specialization is used for jobject, jclass, jstring, jarray,
492
// etc.
493
template<typename R, typename T>
494
static T *
495
wrap_value (JNIEnv *env, T *value)
496
{
497
  return (value == NULL
498
          ? value
499
          : (T *) _Jv_JNI_NewLocalRef (env, (jobject) value));
500
}
501
 
502
 
503
 
504
static jint JNICALL
505
_Jv_JNI_GetVersion (JNIEnv *)
506
{
507
  return JNI_VERSION_1_4;
508
}
509
 
510
static jclass JNICALL
511
_Jv_JNI_DefineClass (JNIEnv *env, const char *name, jobject loader,
512
                     const jbyte *buf, jsize bufLen)
513
{
514
  try
515
    {
516
      loader = unwrap (loader);
517
 
518
      jstring sname = JvNewStringUTF (name);
519
      jbyteArray bytes = JvNewByteArray (bufLen);
520
 
521
      jbyte *elts = elements (bytes);
522
      memcpy (elts, buf, bufLen * sizeof (jbyte));
523
 
524
      java::lang::ClassLoader *l
525
        = reinterpret_cast<java::lang::ClassLoader *> (loader);
526
 
527
      jclass result = l->defineClass (sname, bytes, 0, bufLen);
528
      return (jclass) wrap_value (env, result);
529
    }
530
  catch (jthrowable t)
531
    {
532
      env->ex = t;
533
      return NULL;
534
    }
535
}
536
 
537
static jclass JNICALL
538
_Jv_JNI_FindClass (JNIEnv *env, const char *name)
539
{
540
  // FIXME: assume that NAME isn't too long.
541
  int len = strlen (name);
542
  char s[len + 1];
543
  for (int i = 0; i <= len; ++i)
544
    s[i] = (name[i] == '/') ? '.' : name[i];
545
 
546
  jclass r = NULL;
547
  try
548
    {
549
      // This might throw an out of memory exception.
550
      jstring n = JvNewStringUTF (s);
551
 
552
      java::lang::ClassLoader *loader = NULL;
553
      if (env->locals->loader != NULL)
554
        loader = env->locals->loader;
555
 
556
      if (loader == NULL)
557
        {
558
          // FIXME: should use getBaseClassLoader, but we don't have that
559
          // yet.
560
          loader = java::lang::ClassLoader::getSystemClassLoader ();
561
        }
562
 
563
      r = loader->loadClass (n);
564
      _Jv_InitClass (r);
565
    }
566
  catch (jthrowable t)
567
    {
568
      env->ex = t;
569
    }
570
 
571
  return (jclass) wrap_value (env, r);
572
}
573
 
574
static jclass JNICALL
575
_Jv_JNI_GetSuperclass (JNIEnv *env, jclass clazz)
576
{
577
  return (jclass) wrap_value (env, unwrap (clazz)->getSuperclass ());
578
}
579
 
580
static jboolean JNICALL
581
_Jv_JNI_IsAssignableFrom (JNIEnv *, jclass clazz1, jclass clazz2)
582
{
583
  return unwrap (clazz2)->isAssignableFrom (unwrap (clazz1));
584
}
585
 
586
static jint JNICALL
587
_Jv_JNI_Throw (JNIEnv *env, jthrowable obj)
588
{
589
  // We check in case the user did some funky cast.
590
  obj = unwrap (obj);
591
  JvAssert (obj != NULL && java::lang::Throwable::class$.isInstance (obj));
592
  env->ex = obj;
593
  return 0;
594
}
595
 
596
static jint JNICALL
597
_Jv_JNI_ThrowNew (JNIEnv *env, jclass clazz, const char *message)
598
{
599
  using namespace java::lang::reflect;
600
 
601
  clazz = unwrap (clazz);
602
  JvAssert (java::lang::Throwable::class$.isAssignableFrom (clazz));
603
 
604
  int r = JNI_OK;
605
  try
606
    {
607
      JArray<jclass> *argtypes
608
        = (JArray<jclass> *) JvNewObjectArray (1, &java::lang::Class::class$,
609
                                               NULL);
610
 
611
      jclass *elts = elements (argtypes);
612
      elts[0] = &java::lang::String::class$;
613
 
614
      Constructor *cons = clazz->getConstructor (argtypes);
615
 
616
      jobjectArray values = JvNewObjectArray (1, &java::lang::String::class$,
617
                                              NULL);
618
      jobject *velts = elements (values);
619
      velts[0] = JvNewStringUTF (message);
620
 
621
      jobject obj = cons->newInstance (values);
622
 
623
      env->ex = reinterpret_cast<jthrowable> (obj);
624
    }
625
  catch (jthrowable t)
626
    {
627
      env->ex = t;
628
      r = JNI_ERR;
629
    }
630
 
631
  return r;
632
}
633
 
634
static jthrowable JNICALL
635
_Jv_JNI_ExceptionOccurred (JNIEnv *env)
636
{
637
  return (jthrowable) wrap_value (env, env->ex);
638
}
639
 
640
static void JNICALL
641
_Jv_JNI_ExceptionDescribe (JNIEnv *env)
642
{
643
  if (env->ex != NULL)
644
    env->ex->printStackTrace();
645
}
646
 
647
static void JNICALL
648
_Jv_JNI_ExceptionClear (JNIEnv *env)
649
{
650
  env->ex = NULL;
651
}
652
 
653
static jboolean JNICALL
654
_Jv_JNI_ExceptionCheck (JNIEnv *env)
655
{
656
  return env->ex != NULL;
657
}
658
 
659
static void JNICALL
660
_Jv_JNI_FatalError (JNIEnv *, const char *message)
661
{
662
  JvFail (message);
663
}
664
 
665
 
666
 
667
static jboolean JNICALL
668
_Jv_JNI_IsSameObject (JNIEnv *, jobject obj1, jobject obj2)
669
{
670
  return unwrap (obj1) == unwrap (obj2);
671
}
672
 
673
static jobject JNICALL
674
_Jv_JNI_AllocObject (JNIEnv *env, jclass clazz)
675
{
676
  jobject obj = NULL;
677
  using namespace java::lang::reflect;
678
 
679
  try
680
    {
681
      clazz = unwrap (clazz);
682
      JvAssert (clazz && ! clazz->isArray ());
683
      if (clazz->isInterface() || Modifier::isAbstract(clazz->getModifiers()))
684
        env->ex = new java::lang::InstantiationException ();
685
      else
686
        obj = _Jv_AllocObject (clazz);
687
    }
688
  catch (jthrowable t)
689
    {
690
      env->ex = t;
691
    }
692
 
693
  return wrap_value (env, obj);
694
}
695
 
696
static jclass JNICALL
697
_Jv_JNI_GetObjectClass (JNIEnv *env, jobject obj)
698
{
699
  obj = unwrap (obj);
700
  JvAssert (obj);
701
  return (jclass) wrap_value (env, obj->getClass());
702
}
703
 
704
static jboolean JNICALL
705
_Jv_JNI_IsInstanceOf (JNIEnv *, jobject obj, jclass clazz)
706
{
707
  return unwrap (clazz)->isInstance(unwrap (obj));
708
}
709
 
710
 
711
 
712
//
713
// This section concerns method invocation.
714
//
715
 
716
template<jboolean is_static>
717
static jmethodID JNICALL
718
_Jv_JNI_GetAnyMethodID (JNIEnv *env, jclass clazz,
719
                        const char *name, const char *sig)
720
{
721
  try
722
    {
723
      clazz = unwrap (clazz);
724
      _Jv_InitClass (clazz);
725
 
726
      _Jv_Utf8Const *name_u = _Jv_makeUtf8Const ((char *) name, -1);
727
 
728
      // FIXME: assume that SIG isn't too long.
729
      int len = strlen (sig);
730
      char s[len + 1];
731
      for (int i = 0; i <= len; ++i)
732
        s[i] = (sig[i] == '/') ? '.' : sig[i];
733
      _Jv_Utf8Const *sig_u = _Jv_makeUtf8Const ((char *) s, -1);
734
 
735
      JvAssert (! clazz->isPrimitive());
736
 
737
      using namespace java::lang::reflect;
738
 
739
      while (clazz != NULL)
740
        {
741
          jint count = JvNumMethods (clazz);
742
          jmethodID meth = JvGetFirstMethod (clazz);
743
 
744
          for (jint i = 0; i < count; ++i)
745
            {
746
              if (((is_static && Modifier::isStatic (meth->accflags))
747
                   || (! is_static && ! Modifier::isStatic (meth->accflags)))
748
                  && _Jv_equalUtf8Consts (meth->name, name_u)
749
                  && _Jv_equalUtf8Consts (meth->signature, sig_u))
750
                return meth;
751
 
752
              meth = meth->getNextMethod();
753
            }
754
 
755
          clazz = clazz->getSuperclass ();
756
        }
757
 
758
      java::lang::StringBuffer *name_sig =
759
        new java::lang::StringBuffer (JvNewStringUTF (name));
760
      name_sig->append ((jchar) ' ');
761
      name_sig->append (JvNewStringUTF (s));
762
      env->ex = new java::lang::NoSuchMethodError (name_sig->toString ());
763
    }
764
  catch (jthrowable t)
765
    {
766
      env->ex = t;
767
    }
768
 
769
  return NULL;
770
}
771
 
772
// This is a helper function which turns a va_list into an array of
773
// `jvalue's.  It needs signature information in order to do its work.
774
// The array of values must already be allocated.
775
static void
776
array_from_valist (jvalue *values, JArray<jclass> *arg_types, va_list vargs)
777
{
778
  jclass *arg_elts = elements (arg_types);
779
  for (int i = 0; i < arg_types->length; ++i)
780
    {
781
      // Here we assume that sizeof(int) >= sizeof(jint), because we
782
      // use `int' when decoding the varargs.  Likewise for
783
      // float, and double.  Also we assume that sizeof(jlong) >=
784
      // sizeof(int), i.e. that jlong values are not further
785
      // promoted.
786
      JvAssert (sizeof (int) >= sizeof (jint));
787
      JvAssert (sizeof (jlong) >= sizeof (int));
788
      JvAssert (sizeof (double) >= sizeof (jfloat));
789
      JvAssert (sizeof (double) >= sizeof (jdouble));
790
      if (arg_elts[i] == JvPrimClass (byte))
791
        values[i].b = (jbyte) va_arg (vargs, int);
792
      else if (arg_elts[i] == JvPrimClass (short))
793
        values[i].s = (jshort) va_arg (vargs, int);
794
      else if (arg_elts[i] == JvPrimClass (int))
795
        values[i].i = (jint) va_arg (vargs, int);
796
      else if (arg_elts[i] == JvPrimClass (long))
797
        values[i].j = (jlong) va_arg (vargs, jlong);
798
      else if (arg_elts[i] == JvPrimClass (float))
799
        values[i].f = (jfloat) va_arg (vargs, double);
800
      else if (arg_elts[i] == JvPrimClass (double))
801
        values[i].d = (jdouble) va_arg (vargs, double);
802
      else if (arg_elts[i] == JvPrimClass (boolean))
803
        values[i].z = (jboolean) va_arg (vargs, int);
804
      else if (arg_elts[i] == JvPrimClass (char))
805
        values[i].c = (jchar) va_arg (vargs, int);
806
      else
807
        {
808
          // An object.
809
          values[i].l = unwrap (va_arg (vargs, jobject));
810
        }
811
    }
812
}
813
 
814
// This can call any sort of method: virtual, "nonvirtual", static, or
815
// constructor.
816
template<typename T, invocation_type style>
817
static T JNICALL
818
_Jv_JNI_CallAnyMethodV (JNIEnv *env, jobject obj, jclass klass,
819
                        jmethodID id, va_list vargs)
820
{
821
  obj = unwrap (obj);
822
  klass = unwrap (klass);
823
 
824
  jclass decl_class = klass ? klass : obj->getClass ();
825
  JvAssert (decl_class != NULL);
826
 
827
  jclass return_type;
828
  JArray<jclass> *arg_types;
829
 
830
  try
831
    {
832
      _Jv_GetTypesFromSignature (id, decl_class,
833
                                 &arg_types, &return_type);
834
 
835
      jvalue args[arg_types->length];
836
      array_from_valist (args, arg_types, vargs);
837
 
838
      // For constructors we need to pass the Class we are instantiating.
839
      if (style == constructor)
840
        return_type = klass;
841
 
842
      jvalue result;
843
      _Jv_CallAnyMethodA (obj, return_type, id,
844
                          style == constructor,
845
                          style == normal,
846
                          arg_types, args, &result);
847
 
848
      return wrap_value (env, extract_from_jvalue<T>(result));
849
    }
850
  catch (jthrowable t)
851
    {
852
      env->ex = t;
853
    }
854
 
855
  return wrap_value (env, (T) 0);
856
}
857
 
858
template<typename T, invocation_type style>
859
static T JNICALL
860
_Jv_JNI_CallAnyMethod (JNIEnv *env, jobject obj, jclass klass,
861
                       jmethodID method, ...)
862
{
863
  va_list args;
864
  T result;
865
 
866
  va_start (args, method);
867
  result = _Jv_JNI_CallAnyMethodV<T, style> (env, obj, klass, method, args);
868
  va_end (args);
869
 
870
  return result;
871
}
872
 
873
template<typename T, invocation_type style>
874
static T JNICALL
875
_Jv_JNI_CallAnyMethodA (JNIEnv *env, jobject obj, jclass klass,
876
                        jmethodID id, const jvalue *args)
877
{
878
  obj = unwrap (obj);
879
  klass = unwrap (klass);
880
 
881
  jclass decl_class = klass ? klass : obj->getClass ();
882
  JvAssert (decl_class != NULL);
883
 
884
  jclass return_type;
885
  JArray<jclass> *arg_types;
886
  try
887
    {
888
      _Jv_GetTypesFromSignature (id, decl_class,
889
                                 &arg_types, &return_type);
890
 
891
      // For constructors we need to pass the Class we are instantiating.
892
      if (style == constructor)
893
        return_type = klass;
894
 
895
      // Unwrap arguments as required.  Eww.
896
      jclass *type_elts = elements (arg_types);
897
      jvalue arg_copy[arg_types->length];
898
      for (int i = 0; i < arg_types->length; ++i)
899
        {
900
          if (type_elts[i]->isPrimitive ())
901
            arg_copy[i] = args[i];
902
          else
903
            arg_copy[i].l = unwrap (args[i].l);
904
        }
905
 
906
      jvalue result;
907
      _Jv_CallAnyMethodA (obj, return_type, id,
908
                          style == constructor,
909
                          style == normal,
910
                          arg_types, arg_copy, &result);
911
 
912
      return wrap_value (env, extract_from_jvalue<T>(result));
913
    }
914
  catch (jthrowable t)
915
    {
916
      env->ex = t;
917
    }
918
 
919
  return wrap_value (env, (T) 0);
920
}
921
 
922
template<invocation_type style>
923
static void JNICALL
924
_Jv_JNI_CallAnyVoidMethodV (JNIEnv *env, jobject obj, jclass klass,
925
                            jmethodID id, va_list vargs)
926
{
927
  obj = unwrap (obj);
928
  klass = unwrap (klass);
929
 
930
  jclass decl_class = klass ? klass : obj->getClass ();
931
  JvAssert (decl_class != NULL);
932
 
933
  jclass return_type;
934
  JArray<jclass> *arg_types;
935
  try
936
    {
937
      _Jv_GetTypesFromSignature (id, decl_class,
938
                                 &arg_types, &return_type);
939
 
940
      jvalue args[arg_types->length];
941
      array_from_valist (args, arg_types, vargs);
942
 
943
      // For constructors we need to pass the Class we are instantiating.
944
      if (style == constructor)
945
        return_type = klass;
946
 
947
      _Jv_CallAnyMethodA (obj, return_type, id,
948
                          style == constructor,
949
                          style == normal,
950
                          arg_types, args, NULL);
951
    }
952
  catch (jthrowable t)
953
    {
954
      env->ex = t;
955
    }
956
}
957
 
958
template<invocation_type style>
959
static void JNICALL
960
_Jv_JNI_CallAnyVoidMethod (JNIEnv *env, jobject obj, jclass klass,
961
                           jmethodID method, ...)
962
{
963
  va_list args;
964
 
965
  va_start (args, method);
966
  _Jv_JNI_CallAnyVoidMethodV<style> (env, obj, klass, method, args);
967
  va_end (args);
968
}
969
 
970
template<invocation_type style>
971
static void JNICALL
972
_Jv_JNI_CallAnyVoidMethodA (JNIEnv *env, jobject obj, jclass klass,
973
                            jmethodID id, const jvalue *args)
974
{
975
  jclass decl_class = klass ? klass : obj->getClass ();
976
  JvAssert (decl_class != NULL);
977
 
978
  jclass return_type;
979
  JArray<jclass> *arg_types;
980
  try
981
    {
982
      _Jv_GetTypesFromSignature (id, decl_class,
983
                                 &arg_types, &return_type);
984
 
985
      // Unwrap arguments as required.  Eww.
986
      jclass *type_elts = elements (arg_types);
987
      jvalue arg_copy[arg_types->length];
988
      for (int i = 0; i < arg_types->length; ++i)
989
        {
990
          if (type_elts[i]->isPrimitive ())
991
            arg_copy[i] = args[i];
992
          else
993
            arg_copy[i].l = unwrap (args[i].l);
994
        }
995
 
996
      _Jv_CallAnyMethodA (obj, return_type, id,
997
                          style == constructor,
998
                          style == normal,
999
                          arg_types, args, NULL);
1000
    }
1001
  catch (jthrowable t)
1002
    {
1003
      env->ex = t;
1004
    }
1005
}
1006
 
1007
// Functions with this signature are used to implement functions in
1008
// the CallMethod family.
1009
template<typename T>
1010
static T JNICALL
1011
_Jv_JNI_CallMethodV (JNIEnv *env, jobject obj,
1012
                     jmethodID id, va_list args)
1013
{
1014
  return _Jv_JNI_CallAnyMethodV<T, normal> (env, obj, NULL, id, args);
1015
}
1016
 
1017
// Functions with this signature are used to implement functions in
1018
// the CallMethod family.
1019
template<typename T>
1020
static T JNICALL
1021
_Jv_JNI_CallMethod (JNIEnv *env, jobject obj, jmethodID id, ...)
1022
{
1023
  va_list args;
1024
  T result;
1025
 
1026
  va_start (args, id);
1027
  result = _Jv_JNI_CallAnyMethodV<T, normal> (env, obj, NULL, id, args);
1028
  va_end (args);
1029
 
1030
  return result;
1031
}
1032
 
1033
// Functions with this signature are used to implement functions in
1034
// the CallMethod family.
1035
template<typename T>
1036
static T JNICALL
1037
_Jv_JNI_CallMethodA (JNIEnv *env, jobject obj,
1038
                     jmethodID id, const jvalue *args)
1039
{
1040
  return _Jv_JNI_CallAnyMethodA<T, normal> (env, obj, NULL, id, args);
1041
}
1042
 
1043
static void JNICALL
1044
_Jv_JNI_CallVoidMethodV (JNIEnv *env, jobject obj,
1045
                         jmethodID id, va_list args)
1046
{
1047
  _Jv_JNI_CallAnyVoidMethodV<normal> (env, obj, NULL, id, args);
1048
}
1049
 
1050
static void JNICALL
1051
_Jv_JNI_CallVoidMethod (JNIEnv *env, jobject obj, jmethodID id, ...)
1052
{
1053
  va_list args;
1054
 
1055
  va_start (args, id);
1056
  _Jv_JNI_CallAnyVoidMethodV<normal> (env, obj, NULL, id, args);
1057
  va_end (args);
1058
}
1059
 
1060
static void JNICALL
1061
_Jv_JNI_CallVoidMethodA (JNIEnv *env, jobject obj,
1062
                         jmethodID id, const jvalue *args)
1063
{
1064
  _Jv_JNI_CallAnyVoidMethodA<normal> (env, obj, NULL, id, args);
1065
}
1066
 
1067
// Functions with this signature are used to implement functions in
1068
// the CallStaticMethod family.
1069
template<typename T>
1070
static T JNICALL
1071
_Jv_JNI_CallStaticMethodV (JNIEnv *env, jclass klass,
1072
                           jmethodID id, va_list args)
1073
{
1074
  JvAssert (((id->accflags) & java::lang::reflect::Modifier::STATIC));
1075
  JvAssert (java::lang::Class::class$.isInstance (unwrap (klass)));
1076
 
1077
  return _Jv_JNI_CallAnyMethodV<T, static_type> (env, NULL, klass, id, args);
1078
}
1079
 
1080
// Functions with this signature are used to implement functions in
1081
// the CallStaticMethod family.
1082
template<typename T>
1083
static T JNICALL
1084
_Jv_JNI_CallStaticMethod (JNIEnv *env, jclass klass,
1085
                          jmethodID id, ...)
1086
{
1087
  va_list args;
1088
  T result;
1089
 
1090
  JvAssert (((id->accflags) & java::lang::reflect::Modifier::STATIC));
1091
  JvAssert (java::lang::Class::class$.isInstance (unwrap (klass)));
1092
 
1093
  va_start (args, id);
1094
  result = _Jv_JNI_CallAnyMethodV<T, static_type> (env, NULL, klass,
1095
                                                   id, args);
1096
  va_end (args);
1097
 
1098
  return result;
1099
}
1100
 
1101
// Functions with this signature are used to implement functions in
1102
// the CallStaticMethod family.
1103
template<typename T>
1104
static T JNICALL
1105
_Jv_JNI_CallStaticMethodA (JNIEnv *env, jclass klass, jmethodID id,
1106
                           const jvalue *args)
1107
{
1108
  JvAssert (((id->accflags) & java::lang::reflect::Modifier::STATIC));
1109
  JvAssert (java::lang::Class::class$.isInstance (unwrap (klass)));
1110
 
1111
  return _Jv_JNI_CallAnyMethodA<T, static_type> (env, NULL, klass, id, args);
1112
}
1113
 
1114
static void JNICALL
1115
_Jv_JNI_CallStaticVoidMethodV (JNIEnv *env, jclass klass,
1116
                               jmethodID id, va_list args)
1117
{
1118
  _Jv_JNI_CallAnyVoidMethodV<static_type> (env, NULL, klass, id, args);
1119
}
1120
 
1121
static void JNICALL
1122
_Jv_JNI_CallStaticVoidMethod (JNIEnv *env, jclass klass,
1123
                              jmethodID id, ...)
1124
{
1125
  va_list args;
1126
 
1127
  va_start (args, id);
1128
  _Jv_JNI_CallAnyVoidMethodV<static_type> (env, NULL, klass, id, args);
1129
  va_end (args);
1130
}
1131
 
1132
static void JNICALL
1133
_Jv_JNI_CallStaticVoidMethodA (JNIEnv *env, jclass klass,
1134
                               jmethodID id, const jvalue *args)
1135
{
1136
  _Jv_JNI_CallAnyVoidMethodA<static_type> (env, NULL, klass, id, args);
1137
}
1138
 
1139
static jobject JNICALL
1140
_Jv_JNI_NewObjectV (JNIEnv *env, jclass klass,
1141
                    jmethodID id, va_list args)
1142
{
1143
  JvAssert (klass && ! klass->isArray ());
1144
  JvAssert (! strcmp (id->name->chars(), "<init>")
1145
            && id->signature->len() > 2
1146
            && id->signature->chars()[0] == '('
1147
            && ! strcmp (&id->signature->chars()[id->signature->len() - 2],
1148
                         ")V"));
1149
 
1150
  return _Jv_JNI_CallAnyMethodV<jobject, constructor> (env, NULL, klass,
1151
                                                       id, args);
1152
}
1153
 
1154
static jobject JNICALL
1155
_Jv_JNI_NewObject (JNIEnv *env, jclass klass, jmethodID id, ...)
1156
{
1157
  JvAssert (klass && ! klass->isArray ());
1158
  JvAssert (! strcmp (id->name->chars(), "<init>")
1159
            && id->signature->len() > 2
1160
            && id->signature->chars()[0] == '('
1161
            && ! strcmp (&id->signature->chars()[id->signature->len() - 2],
1162
                         ")V"));
1163
 
1164
  va_list args;
1165
  jobject result;
1166
 
1167
  va_start (args, id);
1168
  result = _Jv_JNI_CallAnyMethodV<jobject, constructor> (env, NULL, klass,
1169
                                                         id, args);
1170
  va_end (args);
1171
 
1172
  return result;
1173
}
1174
 
1175
static jobject JNICALL
1176
_Jv_JNI_NewObjectA (JNIEnv *env, jclass klass, jmethodID id,
1177
                    const jvalue *args)
1178
{
1179
  JvAssert (klass && ! klass->isArray ());
1180
  JvAssert (! strcmp (id->name->chars(), "<init>")
1181
            && id->signature->len() > 2
1182
            && id->signature->chars()[0] == '('
1183
            && ! strcmp (&id->signature->chars()[id->signature->len() - 2],
1184
                         ")V"));
1185
 
1186
  return _Jv_JNI_CallAnyMethodA<jobject, constructor> (env, NULL, klass,
1187
                                                       id, args);
1188
}
1189
 
1190
 
1191
 
1192
template<typename T>
1193
static T JNICALL
1194
_Jv_JNI_GetField (JNIEnv *env, jobject obj, jfieldID field)
1195
{
1196
  obj = unwrap (obj);
1197
  JvAssert (obj);
1198
  T *ptr = (T *) ((char *) obj + field->getOffset ());
1199
  return wrap_value (env, *ptr);
1200
}
1201
 
1202
template<typename T>
1203
static void JNICALL
1204
_Jv_JNI_SetField (JNIEnv *, jobject obj, jfieldID field, T value)
1205
{
1206
  obj = unwrap (obj);
1207
  value = unwrap (value);
1208
 
1209
  JvAssert (obj);
1210
  T *ptr = (T *) ((char *) obj + field->getOffset ());
1211
  *ptr = value;
1212
}
1213
 
1214
template<jboolean is_static>
1215
static jfieldID JNICALL
1216
_Jv_JNI_GetAnyFieldID (JNIEnv *env, jclass clazz,
1217
                       const char *name, const char *sig)
1218
{
1219
  try
1220
    {
1221
      clazz = unwrap (clazz);
1222
 
1223
      _Jv_InitClass (clazz);
1224
 
1225
      _Jv_Utf8Const *a_name = _Jv_makeUtf8Const ((char *) name, -1);
1226
 
1227
      // FIXME: assume that SIG isn't too long.
1228
      int len = strlen (sig);
1229
      char s[len + 1];
1230
      for (int i = 0; i <= len; ++i)
1231
        s[i] = (sig[i] == '/') ? '.' : sig[i];
1232
      java::lang::ClassLoader *loader = clazz->getClassLoaderInternal ();
1233
      jclass field_class = _Jv_FindClassFromSignature ((char *) s, loader);
1234
      if (! field_class)
1235
        throw new java::lang::ClassNotFoundException(JvNewStringUTF(s));
1236
 
1237
      while (clazz != NULL)
1238
        {
1239
          // We acquire the class lock so that fields aren't resolved
1240
          // while we are running.
1241
          JvSynchronize sync (clazz);
1242
 
1243
          jint count = (is_static
1244
                        ? JvNumStaticFields (clazz)
1245
                        : JvNumInstanceFields (clazz));
1246
          jfieldID field = (is_static
1247
                            ? JvGetFirstStaticField (clazz)
1248
                            : JvGetFirstInstanceField (clazz));
1249
          for (jint i = 0; i < count; ++i)
1250
            {
1251
              _Jv_Utf8Const *f_name = field->getNameUtf8Const(clazz);
1252
 
1253
              // The field might be resolved or it might not be.  It
1254
              // is much simpler to always resolve it.
1255
              _Jv_Linker::resolve_field (field, loader);
1256
              if (_Jv_equalUtf8Consts (f_name, a_name)
1257
                  && field->getClass() == field_class)
1258
                return field;
1259
 
1260
              field = field->getNextField ();
1261
            }
1262
 
1263
          clazz = clazz->getSuperclass ();
1264
        }
1265
 
1266
      env->ex = new java::lang::NoSuchFieldError ();
1267
    }
1268
  catch (jthrowable t)
1269
    {
1270
      env->ex = t;
1271
    }
1272
  return NULL;
1273
}
1274
 
1275
template<typename T>
1276
static T JNICALL
1277
_Jv_JNI_GetStaticField (JNIEnv *env, jclass, jfieldID field)
1278
{
1279
  T *ptr = (T *) field->u.addr;
1280
  return wrap_value (env, *ptr);
1281
}
1282
 
1283
template<typename T>
1284
static void JNICALL
1285
_Jv_JNI_SetStaticField (JNIEnv *, jclass, jfieldID field, T value)
1286
{
1287
  value = unwrap (value);
1288
  T *ptr = (T *) field->u.addr;
1289
  *ptr = value;
1290
}
1291
 
1292
static jstring JNICALL
1293
_Jv_JNI_NewString (JNIEnv *env, const jchar *unichars, jsize len)
1294
{
1295
  try
1296
    {
1297
      jstring r = _Jv_NewString (unichars, len);
1298
      return (jstring) wrap_value (env, r);
1299
    }
1300
  catch (jthrowable t)
1301
    {
1302
      env->ex = t;
1303
      return NULL;
1304
    }
1305
}
1306
 
1307
static jsize JNICALL
1308
_Jv_JNI_GetStringLength (JNIEnv *, jstring string)
1309
{
1310
  return unwrap (string)->length();
1311
}
1312
 
1313
static const jchar * JNICALL
1314
_Jv_JNI_GetStringChars (JNIEnv *, jstring string, jboolean *isCopy)
1315
{
1316
  string = unwrap (string);
1317
  jchar *result = _Jv_GetStringChars (string);
1318
  mark_for_gc (string, global_ref_table);
1319
  if (isCopy)
1320
    *isCopy = false;
1321
  return (const jchar *) result;
1322
}
1323
 
1324
static void JNICALL
1325
_Jv_JNI_ReleaseStringChars (JNIEnv *, jstring string, const jchar *)
1326
{
1327
  unmark_for_gc (unwrap (string), global_ref_table);
1328
}
1329
 
1330
static jstring JNICALL
1331
_Jv_JNI_NewStringUTF (JNIEnv *env, const char *bytes)
1332
{
1333
  try
1334
    {
1335
      // For compatibility with the JDK.
1336
      if (!bytes)
1337
        return NULL;
1338
      jstring result = JvNewStringUTF (bytes);
1339
      return (jstring) wrap_value (env, result);
1340
    }
1341
  catch (jthrowable t)
1342
    {
1343
      env->ex = t;
1344
      return NULL;
1345
    }
1346
}
1347
 
1348
static jsize JNICALL
1349
_Jv_JNI_GetStringUTFLength (JNIEnv *, jstring string)
1350
{
1351
  return JvGetStringUTFLength (unwrap (string));
1352
}
1353
 
1354
static const char * JNICALL
1355
_Jv_JNI_GetStringUTFChars (JNIEnv *env, jstring string,
1356
                           jboolean *isCopy)
1357
{
1358
  try
1359
    {
1360
      string = unwrap (string);
1361
      if (string == NULL)
1362
        return NULL;
1363
      jsize len = JvGetStringUTFLength (string);
1364
      char *r = (char *) _Jv_Malloc (len + 1);
1365
      JvGetStringUTFRegion (string, 0, string->length(), r);
1366
      r[len] = '\0';
1367
 
1368
      if (isCopy)
1369
        *isCopy = true;
1370
 
1371
      return (const char *) r;
1372
    }
1373
  catch (jthrowable t)
1374
    {
1375
      env->ex = t;
1376
      return NULL;
1377
    }
1378
}
1379
 
1380
static void JNICALL
1381
_Jv_JNI_ReleaseStringUTFChars (JNIEnv *, jstring, const char *utf)
1382
{
1383
  _Jv_Free ((void *) utf);
1384
}
1385
 
1386
static void JNICALL
1387
_Jv_JNI_GetStringRegion (JNIEnv *env, jstring string, jsize start,
1388
                         jsize len, jchar *buf)
1389
{
1390
  string = unwrap (string);
1391
  jchar *result = _Jv_GetStringChars (string);
1392
  if (start < 0 || start > string->length ()
1393
      || len < 0 || start + len > string->length ())
1394
    {
1395
      try
1396
        {
1397
          env->ex = new java::lang::StringIndexOutOfBoundsException ();
1398
        }
1399
      catch (jthrowable t)
1400
        {
1401
          env->ex = t;
1402
        }
1403
    }
1404
  else
1405
    memcpy (buf, &result[start], len * sizeof (jchar));
1406
}
1407
 
1408
static void JNICALL
1409
_Jv_JNI_GetStringUTFRegion (JNIEnv *env, jstring str, jsize start,
1410
                            jsize len, char *buf)
1411
{
1412
  str = unwrap (str);
1413
 
1414
  if (start < 0 || start > str->length ()
1415
      || len < 0 || start + len > str->length ())
1416
    {
1417
      try
1418
        {
1419
          env->ex = new java::lang::StringIndexOutOfBoundsException ();
1420
        }
1421
      catch (jthrowable t)
1422
        {
1423
          env->ex = t;
1424
        }
1425
    }
1426
  else
1427
    _Jv_GetStringUTFRegion (str, start, len, buf);
1428
}
1429
 
1430
static const jchar * JNICALL
1431
_Jv_JNI_GetStringCritical (JNIEnv *, jstring str, jboolean *isCopy)
1432
{
1433
  jchar *result = _Jv_GetStringChars (unwrap (str));
1434
  if (isCopy)
1435
    *isCopy = false;
1436
  return result;
1437
}
1438
 
1439
static void JNICALL
1440
_Jv_JNI_ReleaseStringCritical (JNIEnv *, jstring, const jchar *)
1441
{
1442
  // Nothing.
1443
}
1444
 
1445
static jsize JNICALL
1446
_Jv_JNI_GetArrayLength (JNIEnv *, jarray array)
1447
{
1448
  return unwrap (array)->length;
1449
}
1450
 
1451
static jobjectArray JNICALL
1452
_Jv_JNI_NewObjectArray (JNIEnv *env, jsize length,
1453
                        jclass elementClass, jobject init)
1454
{
1455
  try
1456
    {
1457
      elementClass = unwrap (elementClass);
1458
      init = unwrap (init);
1459
 
1460
      _Jv_CheckCast (elementClass, init);
1461
      jarray result = JvNewObjectArray (length, elementClass, init);
1462
      return (jobjectArray) wrap_value (env, result);
1463
    }
1464
  catch (jthrowable t)
1465
    {
1466
      env->ex = t;
1467
      return NULL;
1468
    }
1469
}
1470
 
1471
static jobject JNICALL
1472
_Jv_JNI_GetObjectArrayElement (JNIEnv *env, jobjectArray array,
1473
                               jsize index)
1474
{
1475
  if ((unsigned) index >= (unsigned) array->length)
1476
    _Jv_ThrowBadArrayIndex (index);
1477
  jobject *elts = elements (unwrap (array));
1478
  return wrap_value (env, elts[index]);
1479
}
1480
 
1481
static void JNICALL
1482
_Jv_JNI_SetObjectArrayElement (JNIEnv *env, jobjectArray array,
1483
                               jsize index, jobject value)
1484
{
1485
  try
1486
    {
1487
      array = unwrap (array);
1488
      value = unwrap (value);
1489
 
1490
      _Jv_CheckArrayStore (array, value);
1491
      if ((unsigned) index >= (unsigned) array->length)
1492
        _Jv_ThrowBadArrayIndex (index);
1493
      jobject *elts = elements (array);
1494
      elts[index] = value;
1495
    }
1496
  catch (jthrowable t)
1497
    {
1498
      env->ex = t;
1499
    }
1500
}
1501
 
1502
template<typename T, jclass K>
1503
static JArray<T> * JNICALL
1504
_Jv_JNI_NewPrimitiveArray (JNIEnv *env, jsize length)
1505
{
1506
  try
1507
    {
1508
      return (JArray<T> *) wrap_value (env, _Jv_NewPrimArray (K, length));
1509
    }
1510
  catch (jthrowable t)
1511
    {
1512
      env->ex = t;
1513
      return NULL;
1514
    }
1515
}
1516
 
1517
template<typename T, jclass K>
1518
static T * JNICALL
1519
_Jv_JNI_GetPrimitiveArrayElements (JNIEnv *env, JArray<T> *array,
1520
                                   jboolean *isCopy)
1521
{
1522
  array = unwrap (array);
1523
  if (! _Jv_JNI_check_types (env, array, K))
1524
    return NULL;
1525
  T *elts = elements (array);
1526
  if (isCopy)
1527
    {
1528
      // We elect never to copy.
1529
      *isCopy = false;
1530
    }
1531
  mark_for_gc (array, global_ref_table);
1532
  return elts;
1533
}
1534
 
1535
template<typename T, jclass K>
1536
static void JNICALL
1537
_Jv_JNI_ReleasePrimitiveArrayElements (JNIEnv *env, JArray<T> *array,
1538
                                       T *, jint /* mode */)
1539
{
1540
  array = unwrap (array);
1541
  _Jv_JNI_check_types (env, array, K);
1542
  // Note that we ignore MODE.  We can do this because we never copy
1543
  // the array elements.  My reading of the JNI documentation is that
1544
  // this is an option for the implementor.
1545
  unmark_for_gc (array, global_ref_table);
1546
}
1547
 
1548
template<typename T, jclass K>
1549
static void JNICALL
1550
_Jv_JNI_GetPrimitiveArrayRegion (JNIEnv *env, JArray<T> *array,
1551
                                 jsize start, jsize len,
1552
                                 T *buf)
1553
{
1554
  array = unwrap (array);
1555
  if (! _Jv_JNI_check_types (env, array, K))
1556
    return;
1557
 
1558
  // The cast to unsigned lets us save a comparison.
1559
  if (start < 0 || len < 0
1560
      || (unsigned long) (start + len) > (unsigned long) array->length)
1561
    {
1562
      try
1563
        {
1564
          // FIXME: index.
1565
          env->ex = new java::lang::ArrayIndexOutOfBoundsException ();
1566
        }
1567
      catch (jthrowable t)
1568
        {
1569
          // Could have thown out of memory error.
1570
          env->ex = t;
1571
        }
1572
    }
1573
  else
1574
    {
1575
      T *elts = elements (array) + start;
1576
      memcpy (buf, elts, len * sizeof (T));
1577
    }
1578
}
1579
 
1580
template<typename T, jclass K>
1581
static void JNICALL
1582
_Jv_JNI_SetPrimitiveArrayRegion (JNIEnv *env, JArray<T> *array,
1583
                                 jsize start, jsize len, const T *buf)
1584
{
1585
  array = unwrap (array);
1586
  if (! _Jv_JNI_check_types (env, array, K))
1587
    return;
1588
 
1589
  // The cast to unsigned lets us save a comparison.
1590
  if (start < 0 || len < 0
1591
      || (unsigned long) (start + len) > (unsigned long) array->length)
1592
    {
1593
      try
1594
        {
1595
          // FIXME: index.
1596
          env->ex = new java::lang::ArrayIndexOutOfBoundsException ();
1597
        }
1598
      catch (jthrowable t)
1599
        {
1600
          env->ex = t;
1601
        }
1602
    }
1603
  else
1604
    {
1605
      T *elts = elements (array) + start;
1606
      memcpy (elts, buf, len * sizeof (T));
1607
    }
1608
}
1609
 
1610
static void * JNICALL
1611
_Jv_JNI_GetPrimitiveArrayCritical (JNIEnv *, jarray array,
1612
                                   jboolean *isCopy)
1613
{
1614
  array = unwrap (array);
1615
  // FIXME: does this work?
1616
  jclass klass = array->getClass()->getComponentType();
1617
  JvAssert (klass->isPrimitive ());
1618
  char *r = _Jv_GetArrayElementFromElementType (array, klass);
1619
  if (isCopy)
1620
    *isCopy = false;
1621
  return r;
1622
}
1623
 
1624
static void JNICALL
1625
_Jv_JNI_ReleasePrimitiveArrayCritical (JNIEnv *, jarray, void *, jint)
1626
{
1627
  // Nothing.
1628
}
1629
 
1630
static jint JNICALL
1631
_Jv_JNI_MonitorEnter (JNIEnv *env, jobject obj)
1632
{
1633
  try
1634
    {
1635
      _Jv_MonitorEnter (unwrap (obj));
1636
      return 0;
1637
    }
1638
  catch (jthrowable t)
1639
    {
1640
      env->ex = t;
1641
    }
1642
  return JNI_ERR;
1643
}
1644
 
1645
static jint JNICALL
1646
_Jv_JNI_MonitorExit (JNIEnv *env, jobject obj)
1647
{
1648
  try
1649
    {
1650
      _Jv_MonitorExit (unwrap (obj));
1651
      return 0;
1652
    }
1653
  catch (jthrowable t)
1654
    {
1655
      env->ex = t;
1656
    }
1657
  return JNI_ERR;
1658
}
1659
 
1660
// JDK 1.2
1661
jobject JNICALL
1662
_Jv_JNI_ToReflectedField (JNIEnv *env, jclass cls, jfieldID fieldID,
1663
                          jboolean)
1664
{
1665
  try
1666
    {
1667
      cls = unwrap (cls);
1668
      java::lang::reflect::Field *field = new java::lang::reflect::Field();
1669
      field->declaringClass = cls;
1670
      field->offset = (char*) fieldID - (char *) cls->fields;
1671
      field->name = _Jv_NewStringUtf8Const (fieldID->getNameUtf8Const (cls));
1672
      return wrap_value (env, field);
1673
    }
1674
  catch (jthrowable t)
1675
    {
1676
      env->ex = t;
1677
    }
1678
  return NULL;
1679
}
1680
 
1681
// JDK 1.2
1682
static jfieldID JNICALL
1683
_Jv_JNI_FromReflectedField (JNIEnv *, jobject f)
1684
{
1685
  using namespace java::lang::reflect;
1686
 
1687
  f = unwrap (f);
1688
  Field *field = reinterpret_cast<Field *> (f);
1689
  return _Jv_FromReflectedField (field);
1690
}
1691
 
1692
jobject JNICALL
1693
_Jv_JNI_ToReflectedMethod (JNIEnv *env, jclass klass, jmethodID id,
1694
                           jboolean)
1695
{
1696
  using namespace java::lang::reflect;
1697
 
1698
  jobject result = NULL;
1699
  klass = unwrap (klass);
1700
 
1701
  try
1702
    {
1703
      if (_Jv_equalUtf8Consts (id->name, init_name))
1704
        {
1705
          // A constructor.
1706
          Constructor *cons = new Constructor ();
1707
          cons->offset = (char *) id - (char *) &klass->methods;
1708
          cons->declaringClass = klass;
1709
          result = cons;
1710
        }
1711
      else
1712
        {
1713
          Method *meth = new Method ();
1714
          meth->offset = (char *) id - (char *) &klass->methods;
1715
          meth->declaringClass = klass;
1716
          result = meth;
1717
        }
1718
    }
1719
  catch (jthrowable t)
1720
    {
1721
      env->ex = t;
1722
    }
1723
 
1724
  return wrap_value (env, result);
1725
}
1726
 
1727
static jmethodID JNICALL
1728
_Jv_JNI_FromReflectedMethod (JNIEnv *, jobject method)
1729
{
1730
  using namespace java::lang::reflect;
1731
  method = unwrap (method);
1732
  if (Method::class$.isInstance (method))
1733
    return _Jv_FromReflectedMethod (reinterpret_cast<Method *> (method));
1734
  return
1735
    _Jv_FromReflectedConstructor (reinterpret_cast<Constructor *> (method));
1736
}
1737
 
1738
// JDK 1.2.
1739
jweak JNICALL
1740
_Jv_JNI_NewWeakGlobalRef (JNIEnv *env, jobject obj)
1741
{
1742
  using namespace gnu::gcj::runtime;
1743
  JNIWeakRef *ref = NULL;
1744
 
1745
  try
1746
    {
1747
      // This seems weird but I think it is correct.
1748
      obj = unwrap (obj);
1749
      ref = new JNIWeakRef (obj);
1750
      mark_for_gc (ref, global_ref_table);
1751
    }
1752
  catch (jthrowable t)
1753
    {
1754
      env->ex = t;
1755
    }
1756
 
1757
  return reinterpret_cast<jweak> (ref);
1758
}
1759
 
1760
void JNICALL
1761
_Jv_JNI_DeleteWeakGlobalRef (JNIEnv *, jweak obj)
1762
{
1763
  // JDK compatibility.
1764
  if (obj == NULL)
1765
    return;
1766
 
1767
  using namespace gnu::gcj::runtime;
1768
  JNIWeakRef *ref = reinterpret_cast<JNIWeakRef *> (obj);
1769
  unmark_for_gc (ref, global_ref_table);
1770
  ref->clear ();
1771
}
1772
 
1773
 
1774
 
1775
// Direct byte buffers.
1776
 
1777
static jobject JNICALL
1778
_Jv_JNI_NewDirectByteBuffer (JNIEnv *, void *address, jlong length)
1779
{
1780
  using namespace gnu::gcj;
1781
  using namespace java::nio;
1782
  return new DirectByteBufferImpl$ReadWrite
1783
    (reinterpret_cast<RawData *> (address), length);
1784
}
1785
 
1786
static void * JNICALL
1787
_Jv_JNI_GetDirectBufferAddress (JNIEnv *, jobject buffer)
1788
{
1789
  using namespace java::nio;
1790
  if (! _Jv_IsInstanceOf (buffer, &Buffer::class$))
1791
    return NULL;
1792
  Buffer *tmp = static_cast<Buffer *> (buffer);
1793
  return reinterpret_cast<void *> (tmp->address);
1794
}
1795
 
1796
static jlong JNICALL
1797
_Jv_JNI_GetDirectBufferCapacity (JNIEnv *, jobject buffer)
1798
{
1799
  using namespace java::nio;
1800
  if (! _Jv_IsInstanceOf (buffer, &Buffer::class$))
1801
    return -1;
1802
  Buffer *tmp = static_cast<Buffer *> (buffer);
1803
  if (tmp->address == NULL)
1804
    return -1;
1805
  return tmp->capacity();
1806
}
1807
 
1808
static jobjectRefType JNICALL
1809
_Jv_JNI_GetObjectRefType (JNIEnv *, MAYBE_UNUSED jobject object)
1810
{
1811
  JvFail("GetObjectRefType not implemented");
1812
  return JNIInvalidRefType;
1813
}
1814
 
1815
 
1816
 
1817
struct NativeMethodCacheEntry : public JNINativeMethod
1818
{
1819
  char *className;
1820
};
1821
 
1822
// Hash table of native methods.
1823
static NativeMethodCacheEntry *nathash;
1824
// Number of slots used.
1825
static int nathash_count = 0;
1826
// Number of slots available.  Must be power of 2.
1827
static int nathash_size = 0;
1828
 
1829
#define DELETED_ENTRY ((char *) (~0))
1830
 
1831
// Compute a hash value for a native method descriptor.
1832
static int
1833
hash (const NativeMethodCacheEntry *method)
1834
{
1835
  char *ptr;
1836
  int hash = 0;
1837
 
1838
  ptr = method->className;
1839
  while (*ptr)
1840
    hash = (31 * hash) + *ptr++;
1841
 
1842
  ptr = method->name;
1843
  while (*ptr)
1844
    hash = (31 * hash) + *ptr++;
1845
 
1846
  ptr = method->signature;
1847
  while (*ptr)
1848
    hash = (31 * hash) + *ptr++;
1849
 
1850
  return hash;
1851
}
1852
 
1853
// Find the slot where a native method goes.
1854
static NativeMethodCacheEntry *
1855
nathash_find_slot (const NativeMethodCacheEntry *method)
1856
{
1857
  jint h = hash (method);
1858
  int step = (h ^ (h >> 16)) | 1;
1859
  int w = h & (nathash_size - 1);
1860
  int del = -1;
1861
 
1862
  for (;;)
1863
    {
1864
      NativeMethodCacheEntry *slotp = &nathash[w];
1865
      if (slotp->name == NULL)
1866
        {
1867
          if (del >= 0)
1868
            return &nathash[del];
1869
          else
1870
            return slotp;
1871
        }
1872
      else if (slotp->name == DELETED_ENTRY)
1873
        del = w;
1874
      else if (! strcmp (slotp->name, method->name)
1875
               && ! strcmp (slotp->signature, method->signature)
1876
               && ! strcmp (slotp->className, method->className))
1877
        return slotp;
1878
      w = (w + step) & (nathash_size - 1);
1879
    }
1880
}
1881
 
1882
// Find a method.  Return NULL if it isn't in the hash table.
1883
static void *
1884
nathash_find (NativeMethodCacheEntry *method)
1885
{
1886
  if (nathash == NULL)
1887
    return NULL;
1888
  NativeMethodCacheEntry *slot = nathash_find_slot (method);
1889
  if (slot->name == NULL || slot->name == DELETED_ENTRY)
1890
    return NULL;
1891
  return slot->fnPtr;
1892
}
1893
 
1894
static void
1895
natrehash ()
1896
{
1897
  if (nathash == NULL)
1898
    {
1899
      nathash_size = 1024;
1900
      nathash =
1901
        (NativeMethodCacheEntry *) _Jv_AllocBytes (nathash_size
1902
                                                   * sizeof (NativeMethodCacheEntry));
1903
    }
1904
  else
1905
    {
1906
      int savesize = nathash_size;
1907
      NativeMethodCacheEntry *savehash = nathash;
1908
      nathash_size *= 2;
1909
      nathash =
1910
        (NativeMethodCacheEntry *) _Jv_AllocBytes (nathash_size
1911
                                                   * sizeof (NativeMethodCacheEntry));
1912
 
1913
      for (int i = 0; i < savesize; ++i)
1914
        {
1915
          if (savehash[i].name != NULL && savehash[i].name != DELETED_ENTRY)
1916
            {
1917
              NativeMethodCacheEntry *slot = nathash_find_slot (&savehash[i]);
1918
              *slot = savehash[i];
1919
            }
1920
        }
1921
    }
1922
}
1923
 
1924
static void
1925
nathash_add (const NativeMethodCacheEntry *method)
1926
{
1927
  if (3 * nathash_count >= 2 * nathash_size)
1928
    natrehash ();
1929
  NativeMethodCacheEntry *slot = nathash_find_slot (method);
1930
  // If the slot has a real entry in it, then there is no work to do.
1931
  if (slot->name != NULL && slot->name != DELETED_ENTRY)
1932
    return;
1933
  // FIXME: memory leak?
1934
  slot->name = strdup (method->name);
1935
  slot->className = strdup (method->className);
1936
  // This was already strduped in _Jv_JNI_RegisterNatives.
1937
  slot->signature = method->signature;
1938
  slot->fnPtr = method->fnPtr;
1939
}
1940
 
1941
static jint JNICALL
1942
_Jv_JNI_RegisterNatives (JNIEnv *env, jclass klass,
1943
                         const JNINativeMethod *methods,
1944
                         jint nMethods)
1945
{
1946
  // Synchronize while we do the work.  This must match
1947
  // synchronization in some other functions that manipulate or use
1948
  // the nathash table.
1949
  JvSynchronize sync (global_ref_table);
1950
 
1951
  NativeMethodCacheEntry dottedMethod;
1952
 
1953
  // Look at each descriptor given us, and find the corresponding
1954
  // method in the class.
1955
  for (int j = 0; j < nMethods; ++j)
1956
    {
1957
      bool found = false;
1958
 
1959
      _Jv_Method *imeths = JvGetFirstMethod (klass);
1960
      for (int i = 0; i < JvNumMethods (klass); ++i)
1961
        {
1962
          _Jv_Method *self = &imeths[i];
1963
 
1964
          // Copy this JNINativeMethod and do a slash to dot
1965
          // conversion on the signature.
1966
          dottedMethod.name = methods[j].name;
1967
          // FIXME: we leak a little memory here if the method
1968
          // is not found.
1969
          dottedMethod.signature = strdup (methods[j].signature);
1970
          dottedMethod.fnPtr = methods[j].fnPtr;
1971
          dottedMethod.className = _Jv_GetClassNameUtf8 (klass)->chars();
1972
          char *c = dottedMethod.signature;
1973
          while (*c)
1974
            {
1975
              if (*c == '/')
1976
                *c = '.';
1977
              c++;
1978
            }
1979
 
1980
          if (! strcmp (self->name->chars (), dottedMethod.name)
1981
              && ! strcmp (self->signature->chars (), dottedMethod.signature))
1982
            {
1983
              if (! (self->accflags & java::lang::reflect::Modifier::NATIVE))
1984
                break;
1985
 
1986
              // Found a match that is native.
1987
              found = true;
1988
              nathash_add (&dottedMethod);
1989
 
1990
              break;
1991
            }
1992
        }
1993
 
1994
      if (! found)
1995
        {
1996
          jstring m = JvNewStringUTF (methods[j].name);
1997
          try
1998
            {
1999
              env->ex = new java::lang::NoSuchMethodError (m);
2000
            }
2001
          catch (jthrowable t)
2002
            {
2003
              env->ex = t;
2004
            }
2005
          return JNI_ERR;
2006
        }
2007
    }
2008
 
2009
  return JNI_OK;
2010
}
2011
 
2012
static jint JNICALL
2013
_Jv_JNI_UnregisterNatives (JNIEnv *, jclass)
2014
{
2015
  // FIXME -- we could implement this.
2016
  return JNI_ERR;
2017
}
2018
 
2019
 
2020
 
2021
// Add a character to the buffer, encoding properly.
2022
static void
2023
add_char (char *buf, jchar c, int *here)
2024
{
2025
  if (c == '_')
2026
    {
2027
      buf[(*here)++] = '_';
2028
      buf[(*here)++] = '1';
2029
    }
2030
  else if (c == ';')
2031
    {
2032
      buf[(*here)++] = '_';
2033
      buf[(*here)++] = '2';
2034
    }
2035
  else if (c == '[')
2036
    {
2037
      buf[(*here)++] = '_';
2038
      buf[(*here)++] = '3';
2039
    }
2040
 
2041
  // Also check for `.' here because we might be passed an internal
2042
  // qualified class name like `foo.bar'.
2043
  else if (c == '/' || c == '.')
2044
    buf[(*here)++] = '_';
2045
  else if ((c >= '0' && c <= '9')
2046
           || (c >= 'a' && c <= 'z')
2047
           || (c >= 'A' && c <= 'Z'))
2048
    buf[(*here)++] = (char) c;
2049
  else
2050
    {
2051
      // "Unicode" character.
2052
      buf[(*here)++] = '_';
2053
      buf[(*here)++] = '0';
2054
      for (int i = 0; i < 4; ++i)
2055
        {
2056
          int val = c & 0x0f;
2057
          buf[(*here) + 3 - i] = (val > 10) ? ('a' + val - 10) : ('0' + val);
2058
          c >>= 4;
2059
        }
2060
      *here += 4;
2061
    }
2062
}
2063
 
2064
// Compute a mangled name for a native function.  This computes the
2065
// long name, and also returns an index which indicates where a NUL
2066
// can be placed to create the short name.  This function assumes that
2067
// the buffer is large enough for its results.
2068
static void
2069
mangled_name (jclass klass, _Jv_Utf8Const *func_name,
2070
              _Jv_Utf8Const *signature, char *buf, int *long_start)
2071
{
2072
  strcpy (buf, "Java_");
2073
  int here = 5;
2074
 
2075
  // Add fully qualified class name.
2076
  jchar *chars = _Jv_GetStringChars (klass->getName ());
2077
  jint len = klass->getName ()->length ();
2078
  for (int i = 0; i < len; ++i)
2079
    add_char (buf, chars[i], &here);
2080
 
2081
  // Don't use add_char because we need a literal `_'.
2082
  buf[here++] = '_';
2083
 
2084
  const unsigned char *fn = (const unsigned char *) func_name->chars ();
2085
  const unsigned char *limit = fn + func_name->len ();
2086
  for (int i = 0; ; ++i)
2087
    {
2088
      int ch = UTF8_GET (fn, limit);
2089
      if (ch < 0)
2090
        break;
2091
      add_char (buf, ch, &here);
2092
    }
2093
 
2094
  // This is where the long signature begins.
2095
  *long_start = here;
2096
  buf[here++] = '_';
2097
  buf[here++] = '_';
2098
 
2099
  const unsigned char *sig = (const unsigned char *) signature->chars ();
2100
  limit = sig + signature->len ();
2101
  JvAssert (sig[0] == '(');
2102
  ++sig;
2103
  while (1)
2104
    {
2105
      int ch = UTF8_GET (sig, limit);
2106
      if (ch == ')' || ch < 0)
2107
        break;
2108
      add_char (buf, ch, &here);
2109
    }
2110
 
2111
  buf[here] = '\0';
2112
}
2113
 
2114
JNIEnv *
2115
_Jv_GetJNIEnvNewFrameWithLoader (::java::lang::ClassLoader *loader)
2116
{
2117
  JNIEnv *env = _Jv_GetCurrentJNIEnv ();
2118
  if (__builtin_expect (env == NULL, false))
2119
    {
2120
      env = (JNIEnv *) _Jv_MallocUnchecked (sizeof (JNIEnv));
2121
      env->functions = &_Jv_JNIFunctions;
2122
      env->locals = NULL;
2123
      // We set env->ex below.
2124
 
2125
      // Set up the bottom, reusable frame.
2126
      env->bottom_locals = (_Jv_JNI_LocalFrame *)
2127
        _Jv_MallocUnchecked (sizeof (_Jv_JNI_LocalFrame)
2128
                             + (FRAME_SIZE
2129
                                * sizeof (jobject)));
2130
 
2131
      env->bottom_locals->marker = MARK_SYSTEM;
2132
      env->bottom_locals->size = FRAME_SIZE;
2133
      env->bottom_locals->next = NULL;
2134
      env->bottom_locals->allocated_p = false;
2135
      // We set the klass field below.
2136
      memset (&env->bottom_locals->vec[0], 0,
2137
              env->bottom_locals->size * sizeof (jobject));
2138
 
2139
      _Jv_SetCurrentJNIEnv (env);
2140
    }
2141
 
2142
  // If we're in a simple JNI call (non-nested), we can just reuse the
2143
  // locals frame we allocated many calls ago, back when the env was first
2144
  // built, above.
2145
 
2146
  if (__builtin_expect (env->locals == NULL, true))
2147
    {
2148
      env->locals = env->bottom_locals;
2149
      env->locals->loader = loader;
2150
    }
2151
  else
2152
    {
2153
      // Alternatively, we might be re-entering JNI, in which case we can't
2154
      // reuse the bottom_locals frame, because it is already underneath
2155
      // us. So we need to make a new one.
2156
      _Jv_JNI_LocalFrame *frame
2157
        = (_Jv_JNI_LocalFrame *) _Jv_MallocUnchecked (sizeof (_Jv_JNI_LocalFrame)
2158
                                                      + (FRAME_SIZE
2159
                                                         * sizeof (jobject)));
2160
 
2161
      frame->marker = MARK_SYSTEM;
2162
      frame->size = FRAME_SIZE;
2163
      frame->allocated_p = false;
2164
      frame->next = env->locals;
2165
      frame->loader = loader;
2166
 
2167
      memset (&frame->vec[0], 0,
2168
              frame->size * sizeof (jobject));
2169
 
2170
      env->locals = frame;
2171
    }
2172
 
2173
  env->ex = NULL;
2174
 
2175
  return env;
2176
}
2177
 
2178
// Return the current thread's JNIEnv; if one does not exist, create
2179
// it.  Also create a new system frame for use.  This is `extern "C"'
2180
// because the compiler calls it.
2181
extern "C" JNIEnv *
2182
_Jv_GetJNIEnvNewFrame (jclass klass)
2183
{
2184
  return _Jv_GetJNIEnvNewFrameWithLoader (klass->getClassLoaderInternal());
2185
}
2186
 
2187
// Destroy the env's reusable resources. This is called from the thread
2188
// destructor "finalize_native" in natThread.cc
2189
void
2190
_Jv_FreeJNIEnv (_Jv_JNIEnv *env)
2191
{
2192
  if (env == NULL)
2193
    return;
2194
 
2195
  if (env->bottom_locals != NULL)
2196
    _Jv_Free (env->bottom_locals);
2197
 
2198
  _Jv_Free (env);
2199
}
2200
 
2201
// Return the function which implements a particular JNI method.  If
2202
// we can't find the function, we throw the appropriate exception.
2203
// This is `extern "C"' because the compiler uses it.
2204
extern "C" void *
2205
_Jv_LookupJNIMethod (jclass klass, _Jv_Utf8Const *name,
2206
                     _Jv_Utf8Const *signature, MAYBE_UNUSED int args_size)
2207
{
2208
  int name_length = name->len();
2209
  int sig_length = signature->len();
2210
  char buf[10 + 6 * (name_length + sig_length) + 12];
2211
  int long_start;
2212
  void *function;
2213
 
2214
  // Synchronize on something convenient.  Right now we use the hash.
2215
  JvSynchronize sync (global_ref_table);
2216
 
2217
  // First see if we have an override in the hash table.
2218
  strncpy (buf, name->chars (), name_length);
2219
  buf[name_length] = '\0';
2220
  strncpy (buf + name_length + 1, signature->chars (), sig_length);
2221
  buf[name_length + sig_length + 1] = '\0';
2222
  NativeMethodCacheEntry meth;
2223
  meth.name = buf;
2224
  meth.signature = buf + name_length + 1;
2225
  meth.className = _Jv_GetClassNameUtf8(klass)->chars();
2226
  function = nathash_find (&meth);
2227
  if (function != NULL)
2228
    return function;
2229
 
2230
  // If there was no override, then look in the symbol table.
2231
  buf[0] = '_';
2232
  mangled_name (klass, name, signature, buf + 1, &long_start);
2233
  char c = buf[long_start + 1];
2234
  buf[long_start + 1] = '\0';
2235
 
2236
  function = _Jv_FindSymbolInExecutable (buf + 1);
2237
#ifdef WIN32
2238
  // On Win32, we use the "stdcall" calling convention (see JNICALL
2239
  // in jni.h).
2240
  // 
2241
  // For a function named 'fooBar' that takes 'nn' bytes as arguments,
2242
  // by default, MinGW GCC exports it as 'fooBar@nn', MSVC exports it
2243
  // as '_fooBar@nn' and Borland C exports it as 'fooBar'. We try to
2244
  // take care of all these variations here.
2245
 
2246
  char asz_buf[12];    /* '@' + '2147483647' (32-bit INT_MAX) + '\0' */
2247
  char long_nm_sv[11]; /* Ditto, except for the '\0'. */
2248
 
2249
  if (function == NULL)
2250
    {
2251
      // We have tried searching for the 'fooBar' form (BCC) - now
2252
      // try the others.
2253
 
2254
      // First, save the part of the long name that will be damaged
2255
      // by appending '@nn'.
2256
      memcpy (long_nm_sv, (buf + long_start + 1 + 1), sizeof (long_nm_sv));
2257
 
2258
      sprintf (asz_buf, "@%d", args_size);
2259
      strcat (buf, asz_buf);
2260
 
2261
      // Search for the '_fooBar@nn' form (MSVC).
2262
      function = _Jv_FindSymbolInExecutable (buf);
2263
 
2264
      if (function == NULL)
2265
        {
2266
          // Search for the 'fooBar@nn' form (MinGW GCC).
2267
          function = _Jv_FindSymbolInExecutable (buf + 1);
2268
        }
2269
    }
2270
#endif /* WIN32 */
2271
 
2272
  if (function == NULL)
2273
    {
2274
      buf[long_start + 1] = c;
2275
#ifdef WIN32
2276
      // Restore the part of the long name that was damaged by 
2277
      // appending the '@nn'.
2278
      memcpy ((buf + long_start + 1 + 1), long_nm_sv, sizeof (long_nm_sv));
2279
#endif /* WIN32 */
2280
      function = _Jv_FindSymbolInExecutable (buf + 1);
2281
      if (function == NULL)
2282
        {
2283
#ifdef WIN32
2284
          strcat (buf, asz_buf);
2285
          function = _Jv_FindSymbolInExecutable (buf);
2286
          if (function == NULL)
2287
            function = _Jv_FindSymbolInExecutable (buf + 1);
2288
 
2289
          if (function == NULL)
2290
#endif /* WIN32 */
2291
            {
2292
              jstring str = JvNewStringUTF (name->chars ());
2293
              throw new java::lang::UnsatisfiedLinkError (str);
2294
            }
2295
        }
2296
    }
2297
 
2298
  return function;
2299
}
2300
 
2301
#ifdef INTERPRETER
2302
 
2303
// This function is the stub which is used to turn an ordinary (CNI)
2304
// method call into a JNI call.
2305
void
2306
_Jv_JNIMethod::call (ffi_cif *, void *ret, INTERP_FFI_RAW_TYPE *args,
2307
                     void *__this)
2308
{
2309
  _Jv_JNIMethod* _this = (_Jv_JNIMethod *) __this;
2310
 
2311
  JNIEnv *env = _Jv_GetJNIEnvNewFrame (_this->defining_class);
2312
 
2313
  // FIXME: we should mark every reference parameter as a local.  For
2314
  // now we assume a conservative GC, and we assume that the
2315
  // references are on the stack somewhere.
2316
 
2317
  // We cache the value that we find, of course, but if we don't find
2318
  // a value we don't cache that fact -- we might subsequently load a
2319
  // library which finds the function in question.
2320
  {
2321
    // Synchronize on a convenient object to ensure sanity in case two
2322
    // threads reach this point for the same function at the same
2323
    // time.
2324
    JvSynchronize sync (global_ref_table);
2325
    if (_this->function == NULL)
2326
      {
2327
        int args_size = sizeof (JNIEnv *) + _this->args_raw_size;
2328
 
2329
        if (_this->self->accflags & java::lang::reflect::Modifier::STATIC)
2330
          args_size += sizeof (_this->defining_class);
2331
 
2332
        _this->function = _Jv_LookupJNIMethod (_this->defining_class,
2333
                                               _this->self->name,
2334
                                               _this->self->signature,
2335
                                               args_size);
2336
      }
2337
  }
2338
 
2339
  JvAssert (_this->args_raw_size % sizeof (INTERP_FFI_RAW_TYPE) == 0);
2340
  INTERP_FFI_RAW_TYPE
2341
      real_args[2 + _this->args_raw_size / sizeof (INTERP_FFI_RAW_TYPE)];
2342
  int offset = 0;
2343
 
2344
  // First argument is always the environment pointer.
2345
  real_args[offset++].ptr = env;
2346
 
2347
  // For a static method, we pass in the Class.  For non-static
2348
  // methods, the `this' argument is already handled.
2349
  if ((_this->self->accflags & java::lang::reflect::Modifier::STATIC))
2350
    real_args[offset++].ptr = _this->defining_class;
2351
 
2352
  // In libgcj, the callee synchronizes.
2353
  jobject sync = NULL;
2354
  if ((_this->self->accflags & java::lang::reflect::Modifier::SYNCHRONIZED))
2355
    {
2356
      if ((_this->self->accflags & java::lang::reflect::Modifier::STATIC))
2357
        sync = _this->defining_class;
2358
      else
2359
        sync = (jobject) args[0].ptr;
2360
      _Jv_MonitorEnter (sync);
2361
    }
2362
 
2363
  // Copy over passed-in arguments.
2364
  memcpy (&real_args[offset], args, _this->args_raw_size);
2365
 
2366
  // Add a frame to the composite (interpreted + JNI) call stack
2367
  java::lang::Thread *thread = java::lang::Thread::currentThread();
2368
  _Jv_NativeFrame nat_frame (_this, thread);
2369
 
2370
  // The actual call to the JNI function.
2371
#if FFI_NATIVE_RAW_API
2372
  ffi_raw_call (&_this->jni_cif, (void (*)()) _this->function,
2373
                ret, real_args);
2374
#else
2375
  ffi_java_raw_call (&_this->jni_cif, (void (*)()) _this->function,
2376
                     ret, real_args);
2377
#endif
2378
 
2379
  // We might need to unwrap a JNI weak reference here.
2380
  if (_this->jni_cif.rtype == &ffi_type_pointer)
2381
    {
2382
      _Jv_value *val = (_Jv_value *) ret;
2383
      val->object_value = unwrap (val->object_value);
2384
    }
2385
 
2386
  if (sync != NULL)
2387
    _Jv_MonitorExit (sync);
2388
 
2389
  _Jv_JNI_PopSystemFrame (env);
2390
}
2391
 
2392
#endif /* INTERPRETER */
2393
 
2394
 
2395
 
2396
//
2397
// Invocation API.
2398
//
2399
 
2400
// An internal helper function.
2401
static jint
2402
_Jv_JNI_AttachCurrentThread (JavaVM *, jstring name, void **penv,
2403
                             void *args, jboolean is_daemon)
2404
{
2405
  JavaVMAttachArgs *attach = reinterpret_cast<JavaVMAttachArgs *> (args);
2406
  java::lang::ThreadGroup *group = NULL;
2407
 
2408
  if (attach)
2409
    {
2410
      // FIXME: do we really want to support 1.1?
2411
      if (attach->version != JNI_VERSION_1_4
2412
          && attach->version != JNI_VERSION_1_2
2413
          && attach->version != JNI_VERSION_1_1)
2414
        return JNI_EVERSION;
2415
 
2416
      JvAssert (java::lang::ThreadGroup::class$.isInstance (attach->group));
2417
      group = reinterpret_cast<java::lang::ThreadGroup *> (attach->group);
2418
    }
2419
 
2420
  // Attaching an already-attached thread is a no-op.
2421
  JNIEnv *env = _Jv_GetCurrentJNIEnv ();
2422
  if (env != NULL)
2423
    {
2424
      *penv = reinterpret_cast<void *> (env);
2425
      return 0;
2426
    }
2427
 
2428
  env = (JNIEnv *) _Jv_MallocUnchecked (sizeof (JNIEnv));
2429
  if (env == NULL)
2430
    return JNI_ERR;
2431
  env->functions = &_Jv_JNIFunctions;
2432
  env->ex = NULL;
2433
  env->bottom_locals
2434
    = (_Jv_JNI_LocalFrame *) _Jv_MallocUnchecked (sizeof (_Jv_JNI_LocalFrame)
2435
                                                  + (FRAME_SIZE
2436
                                                     * sizeof (jobject)));
2437
  env->locals = env->bottom_locals;
2438
  if (env->locals == NULL)
2439
    {
2440
      _Jv_Free (env);
2441
      return JNI_ERR;
2442
    }
2443
 
2444
  env->locals->allocated_p = false;
2445
  env->locals->marker = MARK_SYSTEM;
2446
  env->locals->size = FRAME_SIZE;
2447
  env->locals->loader = NULL;
2448
  env->locals->next = NULL;
2449
 
2450
  for (int i = 0; i < env->locals->size; ++i)
2451
    env->locals->vec[i] = NULL;
2452
 
2453
  *penv = reinterpret_cast<void *> (env);
2454
 
2455
  // This thread might already be a Java thread -- this function might
2456
  // have been called simply to set the new JNIEnv.
2457
  if (_Jv_ThreadCurrent () == NULL)
2458
    {
2459
      try
2460
        {
2461
          if (is_daemon)
2462
            _Jv_AttachCurrentThreadAsDaemon (name, group);
2463
          else
2464
            _Jv_AttachCurrentThread (name, group);
2465
        }
2466
      catch (jthrowable t)
2467
        {
2468
          return JNI_ERR;
2469
        }
2470
    }
2471
  _Jv_SetCurrentJNIEnv (env);
2472
 
2473
  return 0;
2474
}
2475
 
2476
// This is the one actually used by JNI.
2477
jint JNICALL
2478
_Jv_JNI_AttachCurrentThread (JavaVM *vm, void **penv, void *args)
2479
{
2480
  return _Jv_JNI_AttachCurrentThread (vm, NULL, penv, args, false);
2481
}
2482
 
2483
static jint JNICALL
2484
_Jv_JNI_AttachCurrentThreadAsDaemon (JavaVM *vm, void **penv,
2485
                                     void *args)
2486
{
2487
  return _Jv_JNI_AttachCurrentThread (vm, NULL, penv, args, true);
2488
}
2489
 
2490
static jint JNICALL
2491
_Jv_JNI_DestroyJavaVM (JavaVM *vm)
2492
{
2493
  JvAssert (_Jv_the_vm && vm == _Jv_the_vm);
2494
 
2495
  union
2496
  {
2497
    JNIEnv *env;
2498
    void *env_p;
2499
  };
2500
 
2501
  if (_Jv_ThreadCurrent () != NULL)
2502
    {
2503
      jstring main_name;
2504
      // This sucks.
2505
      try
2506
        {
2507
          main_name = JvNewStringLatin1 ("main");
2508
        }
2509
      catch (jthrowable t)
2510
        {
2511
          return JNI_ERR;
2512
        }
2513
 
2514
      jint r = _Jv_JNI_AttachCurrentThread (vm, main_name, &env_p,
2515
                                            NULL, false);
2516
      if (r < 0)
2517
        return r;
2518
    }
2519
  else
2520
    env = _Jv_GetCurrentJNIEnv ();
2521
 
2522
  _Jv_ThreadWait ();
2523
 
2524
  // Docs say that this always returns an error code.
2525
  return JNI_ERR;
2526
}
2527
 
2528
jint JNICALL
2529
_Jv_JNI_DetachCurrentThread (JavaVM *)
2530
{
2531
  jint code = _Jv_DetachCurrentThread ();
2532
  return code  ? JNI_EDETACHED : 0;
2533
}
2534
 
2535
static jint JNICALL
2536
_Jv_JNI_GetEnv (JavaVM *, void **penv, jint version)
2537
{
2538
  if (_Jv_ThreadCurrent () == NULL)
2539
    {
2540
      *penv = NULL;
2541
      return JNI_EDETACHED;
2542
    }
2543
 
2544
#ifdef ENABLE_JVMPI
2545
  // Handle JVMPI requests.
2546
  if (version == JVMPI_VERSION_1)
2547
    {
2548
      *penv = (void *) &_Jv_JVMPI_Interface;
2549
      return 0;
2550
    }
2551
#endif
2552
 
2553
#ifdef INTERPRETER
2554
  // Handle JVMTI requests
2555
  if (version == JVMTI_VERSION_1_0)
2556
    {
2557
      *penv = (void *) _Jv_GetJVMTIEnv ();
2558
      return 0;
2559
    }
2560
#endif
2561
 
2562
  // FIXME: do we really want to support 1.1?
2563
  if (version != JNI_VERSION_1_4 && version != JNI_VERSION_1_2
2564
      && version != JNI_VERSION_1_1)
2565
    {
2566
      *penv = NULL;
2567
      return JNI_EVERSION;
2568
    }
2569
 
2570
  *penv = (void *) _Jv_GetCurrentJNIEnv ();
2571
  return 0;
2572
}
2573
 
2574
JavaVM *
2575
_Jv_GetJavaVM ()
2576
{
2577
  // FIXME: synchronize
2578
  if (! _Jv_the_vm)
2579
    {
2580
      JavaVM *nvm = (JavaVM *) _Jv_MallocUnchecked (sizeof (JavaVM));
2581
      if (nvm != NULL)
2582
        nvm->functions = &_Jv_JNI_InvokeFunctions;
2583
      _Jv_the_vm = nvm;
2584
    }
2585
 
2586
  // If this is a Java thread, we want to make sure it has an
2587
  // associated JNIEnv.
2588
  if (_Jv_ThreadCurrent () != NULL)
2589
    {
2590
      void *ignore;
2591
      _Jv_JNI_AttachCurrentThread (_Jv_the_vm, &ignore, NULL);
2592
    }
2593
 
2594
  return _Jv_the_vm;
2595
}
2596
 
2597
static jint JNICALL
2598
_Jv_JNI_GetJavaVM (JNIEnv *, JavaVM **vm)
2599
{
2600
  *vm = _Jv_GetJavaVM ();
2601
  return *vm == NULL ? JNI_ERR : JNI_OK;
2602
}
2603
 
2604
 
2605
 
2606
#define RESERVED NULL
2607
 
2608
struct JNINativeInterface_ _Jv_JNIFunctions =
2609
{
2610
  RESERVED,
2611
  RESERVED,
2612
  RESERVED,
2613
  RESERVED,
2614
  _Jv_JNI_GetVersion,           // GetVersion
2615
  _Jv_JNI_DefineClass,          // DefineClass
2616
  _Jv_JNI_FindClass,            // FindClass
2617
  _Jv_JNI_FromReflectedMethod,  // FromReflectedMethod
2618
  _Jv_JNI_FromReflectedField,   // FromReflectedField
2619
  _Jv_JNI_ToReflectedMethod,    // ToReflectedMethod
2620
  _Jv_JNI_GetSuperclass,        // GetSuperclass
2621
  _Jv_JNI_IsAssignableFrom,     // IsAssignableFrom
2622
  _Jv_JNI_ToReflectedField,     // ToReflectedField
2623
  _Jv_JNI_Throw,                // Throw
2624
  _Jv_JNI_ThrowNew,             // ThrowNew
2625
  _Jv_JNI_ExceptionOccurred,    // ExceptionOccurred
2626
  _Jv_JNI_ExceptionDescribe,    // ExceptionDescribe
2627
  _Jv_JNI_ExceptionClear,       // ExceptionClear
2628
  _Jv_JNI_FatalError,           // FatalError
2629
 
2630
  _Jv_JNI_PushLocalFrame,       // PushLocalFrame
2631
  _Jv_JNI_PopLocalFrame,        // PopLocalFrame
2632
  _Jv_JNI_NewGlobalRef,         // NewGlobalRef
2633
  _Jv_JNI_DeleteGlobalRef,      // DeleteGlobalRef
2634
  _Jv_JNI_DeleteLocalRef,       // DeleteLocalRef
2635
 
2636
  _Jv_JNI_IsSameObject,         // IsSameObject
2637
 
2638
  _Jv_JNI_NewLocalRef,          // NewLocalRef
2639
  _Jv_JNI_EnsureLocalCapacity,  // EnsureLocalCapacity
2640
 
2641
  _Jv_JNI_AllocObject,              // AllocObject
2642
  _Jv_JNI_NewObject,                // NewObject
2643
  _Jv_JNI_NewObjectV,               // NewObjectV
2644
  _Jv_JNI_NewObjectA,               // NewObjectA
2645
  _Jv_JNI_GetObjectClass,           // GetObjectClass
2646
  _Jv_JNI_IsInstanceOf,             // IsInstanceOf
2647
  _Jv_JNI_GetAnyMethodID<false>,    // GetMethodID
2648
 
2649
  _Jv_JNI_CallMethod<jobject>,          // CallObjectMethod
2650
  _Jv_JNI_CallMethodV<jobject>,         // CallObjectMethodV
2651
  _Jv_JNI_CallMethodA<jobject>,         // CallObjectMethodA
2652
  _Jv_JNI_CallMethod<jboolean>,         // CallBooleanMethod
2653
  _Jv_JNI_CallMethodV<jboolean>,        // CallBooleanMethodV
2654
  _Jv_JNI_CallMethodA<jboolean>,        // CallBooleanMethodA
2655
  _Jv_JNI_CallMethod<jbyte>,            // CallByteMethod
2656
  _Jv_JNI_CallMethodV<jbyte>,           // CallByteMethodV
2657
  _Jv_JNI_CallMethodA<jbyte>,           // CallByteMethodA
2658
  _Jv_JNI_CallMethod<jchar>,            // CallCharMethod
2659
  _Jv_JNI_CallMethodV<jchar>,           // CallCharMethodV
2660
  _Jv_JNI_CallMethodA<jchar>,           // CallCharMethodA
2661
  _Jv_JNI_CallMethod<jshort>,           // CallShortMethod
2662
  _Jv_JNI_CallMethodV<jshort>,          // CallShortMethodV
2663
  _Jv_JNI_CallMethodA<jshort>,          // CallShortMethodA
2664
  _Jv_JNI_CallMethod<jint>,             // CallIntMethod
2665
  _Jv_JNI_CallMethodV<jint>,            // CallIntMethodV
2666
  _Jv_JNI_CallMethodA<jint>,            // CallIntMethodA
2667
  _Jv_JNI_CallMethod<jlong>,            // CallLongMethod
2668
  _Jv_JNI_CallMethodV<jlong>,           // CallLongMethodV
2669
  _Jv_JNI_CallMethodA<jlong>,           // CallLongMethodA
2670
  _Jv_JNI_CallMethod<jfloat>,           // CallFloatMethod
2671
  _Jv_JNI_CallMethodV<jfloat>,          // CallFloatMethodV
2672
  _Jv_JNI_CallMethodA<jfloat>,          // CallFloatMethodA
2673
  _Jv_JNI_CallMethod<jdouble>,          // CallDoubleMethod
2674
  _Jv_JNI_CallMethodV<jdouble>,         // CallDoubleMethodV
2675
  _Jv_JNI_CallMethodA<jdouble>,         // CallDoubleMethodA
2676
  _Jv_JNI_CallVoidMethod,               // CallVoidMethod
2677
  _Jv_JNI_CallVoidMethodV,              // CallVoidMethodV
2678
  _Jv_JNI_CallVoidMethodA,              // CallVoidMethodA
2679
 
2680
  // Nonvirtual method invocation functions follow.
2681
  _Jv_JNI_CallAnyMethod<jobject, nonvirtual>,   // CallNonvirtualObjectMethod
2682
  _Jv_JNI_CallAnyMethodV<jobject, nonvirtual>,  // CallNonvirtualObjectMethodV
2683
  _Jv_JNI_CallAnyMethodA<jobject, nonvirtual>,  // CallNonvirtualObjectMethodA
2684
  _Jv_JNI_CallAnyMethod<jboolean, nonvirtual>,  // CallNonvirtualBooleanMethod
2685
  _Jv_JNI_CallAnyMethodV<jboolean, nonvirtual>, // CallNonvirtualBooleanMethodV
2686
  _Jv_JNI_CallAnyMethodA<jboolean, nonvirtual>, // CallNonvirtualBooleanMethodA
2687
  _Jv_JNI_CallAnyMethod<jbyte, nonvirtual>,     // CallNonvirtualByteMethod
2688
  _Jv_JNI_CallAnyMethodV<jbyte, nonvirtual>,    // CallNonvirtualByteMethodV
2689
  _Jv_JNI_CallAnyMethodA<jbyte, nonvirtual>,    // CallNonvirtualByteMethodA
2690
  _Jv_JNI_CallAnyMethod<jchar, nonvirtual>,     // CallNonvirtualCharMethod
2691
  _Jv_JNI_CallAnyMethodV<jchar, nonvirtual>,    // CallNonvirtualCharMethodV
2692
  _Jv_JNI_CallAnyMethodA<jchar, nonvirtual>,    // CallNonvirtualCharMethodA
2693
  _Jv_JNI_CallAnyMethod<jshort, nonvirtual>,    // CallNonvirtualShortMethod
2694
  _Jv_JNI_CallAnyMethodV<jshort, nonvirtual>,   // CallNonvirtualShortMethodV
2695
  _Jv_JNI_CallAnyMethodA<jshort, nonvirtual>,   // CallNonvirtualShortMethodA
2696
  _Jv_JNI_CallAnyMethod<jint, nonvirtual>,      // CallNonvirtualIntMethod
2697
  _Jv_JNI_CallAnyMethodV<jint, nonvirtual>,     // CallNonvirtualIntMethodV
2698
  _Jv_JNI_CallAnyMethodA<jint, nonvirtual>,     // CallNonvirtualIntMethodA
2699
  _Jv_JNI_CallAnyMethod<jlong, nonvirtual>,     // CallNonvirtualLongMethod
2700
  _Jv_JNI_CallAnyMethodV<jlong, nonvirtual>,    // CallNonvirtualLongMethodV
2701
  _Jv_JNI_CallAnyMethodA<jlong, nonvirtual>,    // CallNonvirtualLongMethodA
2702
  _Jv_JNI_CallAnyMethod<jfloat, nonvirtual>,    // CallNonvirtualFloatMethod
2703
  _Jv_JNI_CallAnyMethodV<jfloat, nonvirtual>,   // CallNonvirtualFloatMethodV
2704
  _Jv_JNI_CallAnyMethodA<jfloat, nonvirtual>,   // CallNonvirtualFloatMethodA
2705
  _Jv_JNI_CallAnyMethod<jdouble, nonvirtual>,   // CallNonvirtualDoubleMethod
2706
  _Jv_JNI_CallAnyMethodV<jdouble, nonvirtual>,  // CallNonvirtualDoubleMethodV
2707
  _Jv_JNI_CallAnyMethodA<jdouble, nonvirtual>,  // CallNonvirtualDoubleMethodA
2708
  _Jv_JNI_CallAnyVoidMethod<nonvirtual>,        // CallNonvirtualVoidMethod
2709
  _Jv_JNI_CallAnyVoidMethodV<nonvirtual>,       // CallNonvirtualVoidMethodV
2710
  _Jv_JNI_CallAnyVoidMethodA<nonvirtual>,       // CallNonvirtualVoidMethodA
2711
 
2712
  _Jv_JNI_GetAnyFieldID<false>, // GetFieldID
2713
  _Jv_JNI_GetField<jobject>,    // GetObjectField
2714
  _Jv_JNI_GetField<jboolean>,   // GetBooleanField
2715
  _Jv_JNI_GetField<jbyte>,      // GetByteField
2716
  _Jv_JNI_GetField<jchar>,      // GetCharField
2717
  _Jv_JNI_GetField<jshort>,     // GetShortField
2718
  _Jv_JNI_GetField<jint>,       // GetIntField
2719
  _Jv_JNI_GetField<jlong>,      // GetLongField
2720
  _Jv_JNI_GetField<jfloat>,     // GetFloatField
2721
  _Jv_JNI_GetField<jdouble>,    // GetDoubleField
2722
  _Jv_JNI_SetField,             // SetObjectField
2723
  _Jv_JNI_SetField,             // SetBooleanField
2724
  _Jv_JNI_SetField,             // SetByteField
2725
  _Jv_JNI_SetField,             // SetCharField
2726
  _Jv_JNI_SetField,             // SetShortField
2727
  _Jv_JNI_SetField,             // SetIntField
2728
  _Jv_JNI_SetField,             // SetLongField
2729
  _Jv_JNI_SetField,             // SetFloatField
2730
  _Jv_JNI_SetField,             // SetDoubleField
2731
  _Jv_JNI_GetAnyMethodID<true>, // GetStaticMethodID
2732
 
2733
  _Jv_JNI_CallStaticMethod<jobject>,      // CallStaticObjectMethod
2734
  _Jv_JNI_CallStaticMethodV<jobject>,     // CallStaticObjectMethodV
2735
  _Jv_JNI_CallStaticMethodA<jobject>,     // CallStaticObjectMethodA
2736
  _Jv_JNI_CallStaticMethod<jboolean>,     // CallStaticBooleanMethod
2737
  _Jv_JNI_CallStaticMethodV<jboolean>,    // CallStaticBooleanMethodV
2738
  _Jv_JNI_CallStaticMethodA<jboolean>,    // CallStaticBooleanMethodA
2739
  _Jv_JNI_CallStaticMethod<jbyte>,        // CallStaticByteMethod
2740
  _Jv_JNI_CallStaticMethodV<jbyte>,       // CallStaticByteMethodV
2741
  _Jv_JNI_CallStaticMethodA<jbyte>,       // CallStaticByteMethodA
2742
  _Jv_JNI_CallStaticMethod<jchar>,        // CallStaticCharMethod
2743
  _Jv_JNI_CallStaticMethodV<jchar>,       // CallStaticCharMethodV
2744
  _Jv_JNI_CallStaticMethodA<jchar>,       // CallStaticCharMethodA
2745
  _Jv_JNI_CallStaticMethod<jshort>,       // CallStaticShortMethod
2746
  _Jv_JNI_CallStaticMethodV<jshort>,      // CallStaticShortMethodV
2747
  _Jv_JNI_CallStaticMethodA<jshort>,      // CallStaticShortMethodA
2748
  _Jv_JNI_CallStaticMethod<jint>,         // CallStaticIntMethod
2749
  _Jv_JNI_CallStaticMethodV<jint>,        // CallStaticIntMethodV
2750
  _Jv_JNI_CallStaticMethodA<jint>,        // CallStaticIntMethodA
2751
  _Jv_JNI_CallStaticMethod<jlong>,        // CallStaticLongMethod
2752
  _Jv_JNI_CallStaticMethodV<jlong>,       // CallStaticLongMethodV
2753
  _Jv_JNI_CallStaticMethodA<jlong>,       // CallStaticLongMethodA
2754
  _Jv_JNI_CallStaticMethod<jfloat>,       // CallStaticFloatMethod
2755
  _Jv_JNI_CallStaticMethodV<jfloat>,      // CallStaticFloatMethodV
2756
  _Jv_JNI_CallStaticMethodA<jfloat>,      // CallStaticFloatMethodA
2757
  _Jv_JNI_CallStaticMethod<jdouble>,      // CallStaticDoubleMethod
2758
  _Jv_JNI_CallStaticMethodV<jdouble>,     // CallStaticDoubleMethodV
2759
  _Jv_JNI_CallStaticMethodA<jdouble>,     // CallStaticDoubleMethodA
2760
  _Jv_JNI_CallStaticVoidMethod,           // CallStaticVoidMethod
2761
  _Jv_JNI_CallStaticVoidMethodV,          // CallStaticVoidMethodV
2762
  _Jv_JNI_CallStaticVoidMethodA,          // CallStaticVoidMethodA
2763
 
2764
  _Jv_JNI_GetAnyFieldID<true>,         // GetStaticFieldID
2765
  _Jv_JNI_GetStaticField<jobject>,     // GetStaticObjectField
2766
  _Jv_JNI_GetStaticField<jboolean>,    // GetStaticBooleanField
2767
  _Jv_JNI_GetStaticField<jbyte>,       // GetStaticByteField
2768
  _Jv_JNI_GetStaticField<jchar>,       // GetStaticCharField
2769
  _Jv_JNI_GetStaticField<jshort>,      // GetStaticShortField
2770
  _Jv_JNI_GetStaticField<jint>,        // GetStaticIntField
2771
  _Jv_JNI_GetStaticField<jlong>,       // GetStaticLongField
2772
  _Jv_JNI_GetStaticField<jfloat>,      // GetStaticFloatField
2773
  _Jv_JNI_GetStaticField<jdouble>,     // GetStaticDoubleField
2774
  _Jv_JNI_SetStaticField,              // SetStaticObjectField
2775
  _Jv_JNI_SetStaticField,              // SetStaticBooleanField
2776
  _Jv_JNI_SetStaticField,              // SetStaticByteField
2777
  _Jv_JNI_SetStaticField,              // SetStaticCharField
2778
  _Jv_JNI_SetStaticField,              // SetStaticShortField
2779
  _Jv_JNI_SetStaticField,              // SetStaticIntField
2780
  _Jv_JNI_SetStaticField,              // SetStaticLongField
2781
  _Jv_JNI_SetStaticField,              // SetStaticFloatField
2782
  _Jv_JNI_SetStaticField,              // SetStaticDoubleField
2783
  _Jv_JNI_NewString,                   // NewString
2784
  _Jv_JNI_GetStringLength,             // GetStringLength
2785
  _Jv_JNI_GetStringChars,              // GetStringChars
2786
  _Jv_JNI_ReleaseStringChars,          // ReleaseStringChars
2787
  _Jv_JNI_NewStringUTF,                // NewStringUTF
2788
  _Jv_JNI_GetStringUTFLength,          // GetStringUTFLength
2789
  _Jv_JNI_GetStringUTFChars,           // GetStringUTFChars
2790
  _Jv_JNI_ReleaseStringUTFChars,       // ReleaseStringUTFChars
2791
  _Jv_JNI_GetArrayLength,              // GetArrayLength
2792
  _Jv_JNI_NewObjectArray,              // NewObjectArray
2793
  _Jv_JNI_GetObjectArrayElement,       // GetObjectArrayElement
2794
  _Jv_JNI_SetObjectArrayElement,       // SetObjectArrayElement
2795
  _Jv_JNI_NewPrimitiveArray<jboolean, JvPrimClass (boolean)>,
2796
                                                            // NewBooleanArray
2797
  _Jv_JNI_NewPrimitiveArray<jbyte, JvPrimClass (byte)>,     // NewByteArray
2798
  _Jv_JNI_NewPrimitiveArray<jchar, JvPrimClass (char)>,     // NewCharArray
2799
  _Jv_JNI_NewPrimitiveArray<jshort, JvPrimClass (short)>,   // NewShortArray
2800
  _Jv_JNI_NewPrimitiveArray<jint, JvPrimClass (int)>,       // NewIntArray
2801
  _Jv_JNI_NewPrimitiveArray<jlong, JvPrimClass (long)>,     // NewLongArray
2802
  _Jv_JNI_NewPrimitiveArray<jfloat, JvPrimClass (float)>,   // NewFloatArray
2803
  _Jv_JNI_NewPrimitiveArray<jdouble, JvPrimClass (double)>, // NewDoubleArray
2804
  _Jv_JNI_GetPrimitiveArrayElements<jboolean, JvPrimClass (boolean)>,
2805
                                            // GetBooleanArrayElements
2806
  _Jv_JNI_GetPrimitiveArrayElements<jbyte, JvPrimClass (byte)>,
2807
                                            // GetByteArrayElements
2808
  _Jv_JNI_GetPrimitiveArrayElements<jchar, JvPrimClass (char)>,
2809
                                            // GetCharArrayElements
2810
  _Jv_JNI_GetPrimitiveArrayElements<jshort, JvPrimClass (short)>,
2811
                                            // GetShortArrayElements
2812
  _Jv_JNI_GetPrimitiveArrayElements<jint, JvPrimClass (int)>,
2813
                                            // GetIntArrayElements
2814
  _Jv_JNI_GetPrimitiveArrayElements<jlong, JvPrimClass (long)>,
2815
                                            // GetLongArrayElements
2816
  _Jv_JNI_GetPrimitiveArrayElements<jfloat, JvPrimClass (float)>,
2817
                                            // GetFloatArrayElements
2818
  _Jv_JNI_GetPrimitiveArrayElements<jdouble, JvPrimClass (double)>,
2819
                                            // GetDoubleArrayElements
2820
  _Jv_JNI_ReleasePrimitiveArrayElements<jboolean, JvPrimClass (boolean)>,
2821
                                            // ReleaseBooleanArrayElements
2822
  _Jv_JNI_ReleasePrimitiveArrayElements<jbyte, JvPrimClass (byte)>,
2823
                                            // ReleaseByteArrayElements
2824
  _Jv_JNI_ReleasePrimitiveArrayElements<jchar, JvPrimClass (char)>,
2825
                                            // ReleaseCharArrayElements
2826
  _Jv_JNI_ReleasePrimitiveArrayElements<jshort, JvPrimClass (short)>,
2827
                                            // ReleaseShortArrayElements
2828
  _Jv_JNI_ReleasePrimitiveArrayElements<jint, JvPrimClass (int)>,
2829
                                            // ReleaseIntArrayElements
2830
  _Jv_JNI_ReleasePrimitiveArrayElements<jlong, JvPrimClass (long)>,
2831
                                            // ReleaseLongArrayElements
2832
  _Jv_JNI_ReleasePrimitiveArrayElements<jfloat, JvPrimClass (float)>,
2833
                                            // ReleaseFloatArrayElements
2834
  _Jv_JNI_ReleasePrimitiveArrayElements<jdouble, JvPrimClass (double)>,
2835
                                            // ReleaseDoubleArrayElements
2836
  _Jv_JNI_GetPrimitiveArrayRegion<jboolean, JvPrimClass (boolean)>,
2837
                                            // GetBooleanArrayRegion
2838
  _Jv_JNI_GetPrimitiveArrayRegion<jbyte, JvPrimClass (byte)>,
2839
                                            // GetByteArrayRegion
2840
  _Jv_JNI_GetPrimitiveArrayRegion<jchar, JvPrimClass (char)>,
2841
                                            // GetCharArrayRegion
2842
  _Jv_JNI_GetPrimitiveArrayRegion<jshort, JvPrimClass (short)>,
2843
                                            // GetShortArrayRegion
2844
  _Jv_JNI_GetPrimitiveArrayRegion<jint, JvPrimClass (int)>,
2845
                                            // GetIntArrayRegion
2846
  _Jv_JNI_GetPrimitiveArrayRegion<jlong, JvPrimClass (long)>,
2847
                                            // GetLongArrayRegion
2848
  _Jv_JNI_GetPrimitiveArrayRegion<jfloat, JvPrimClass (float)>,
2849
                                            // GetFloatArrayRegion
2850
  _Jv_JNI_GetPrimitiveArrayRegion<jdouble, JvPrimClass (double)>,
2851
                                            // GetDoubleArrayRegion
2852
  _Jv_JNI_SetPrimitiveArrayRegion<jboolean, JvPrimClass (boolean)>,
2853
                                            // SetBooleanArrayRegion
2854
  _Jv_JNI_SetPrimitiveArrayRegion<jbyte, JvPrimClass (byte)>,
2855
                                            // SetByteArrayRegion
2856
  _Jv_JNI_SetPrimitiveArrayRegion<jchar, JvPrimClass (char)>,
2857
                                            // SetCharArrayRegion
2858
  _Jv_JNI_SetPrimitiveArrayRegion<jshort, JvPrimClass (short)>,
2859
                                            // SetShortArrayRegion
2860
  _Jv_JNI_SetPrimitiveArrayRegion<jint, JvPrimClass (int)>,
2861
                                            // SetIntArrayRegion
2862
  _Jv_JNI_SetPrimitiveArrayRegion<jlong, JvPrimClass (long)>,
2863
                                            // SetLongArrayRegion
2864
  _Jv_JNI_SetPrimitiveArrayRegion<jfloat, JvPrimClass (float)>,
2865
                                            // SetFloatArrayRegion
2866
  _Jv_JNI_SetPrimitiveArrayRegion<jdouble, JvPrimClass (double)>,
2867
                                            // SetDoubleArrayRegion
2868
  _Jv_JNI_RegisterNatives,                  // RegisterNatives
2869
  _Jv_JNI_UnregisterNatives,                // UnregisterNatives
2870
  _Jv_JNI_MonitorEnter,                     // MonitorEnter
2871
  _Jv_JNI_MonitorExit,                      // MonitorExit
2872
  _Jv_JNI_GetJavaVM,                        // GetJavaVM
2873
 
2874
  _Jv_JNI_GetStringRegion,                  // GetStringRegion
2875
  _Jv_JNI_GetStringUTFRegion,               // GetStringUTFRegion
2876
  _Jv_JNI_GetPrimitiveArrayCritical,        // GetPrimitiveArrayCritical
2877
  _Jv_JNI_ReleasePrimitiveArrayCritical,    // ReleasePrimitiveArrayCritical
2878
  _Jv_JNI_GetStringCritical,                // GetStringCritical
2879
  _Jv_JNI_ReleaseStringCritical,            // ReleaseStringCritical
2880
 
2881
  _Jv_JNI_NewWeakGlobalRef,                 // NewWeakGlobalRef
2882
  _Jv_JNI_DeleteWeakGlobalRef,              // DeleteWeakGlobalRef
2883
 
2884
  _Jv_JNI_ExceptionCheck,                   // ExceptionCheck
2885
 
2886
  _Jv_JNI_NewDirectByteBuffer,              // NewDirectByteBuffer
2887
  _Jv_JNI_GetDirectBufferAddress,           // GetDirectBufferAddress
2888
  _Jv_JNI_GetDirectBufferCapacity,          // GetDirectBufferCapacity
2889
 
2890
  _Jv_JNI_GetObjectRefType                  // GetObjectRefType
2891
};
2892
 
2893
struct JNIInvokeInterface_ _Jv_JNI_InvokeFunctions =
2894
{
2895
  RESERVED,
2896
  RESERVED,
2897
  RESERVED,
2898
 
2899
  _Jv_JNI_DestroyJavaVM,
2900
  _Jv_JNI_AttachCurrentThread,
2901
  _Jv_JNI_DetachCurrentThread,
2902
  _Jv_JNI_GetEnv,
2903
  _Jv_JNI_AttachCurrentThreadAsDaemon
2904
};

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.