* java/util/TreeMap.java (nil): Made non-final.

[pf3gnuchains/gcc-fork.git] / libjava / prims.cc

diff --git a/libjava/prims.cc b/libjava/prims.cc
index 22fa4b6..85264bb 100644 (file)
--- a/libjava/prims.cc
+++ b/libjava/prims.cc
@@ -1,6 +1,6 @@
 // prims.cc - Code for core of runtime environment.
 
-/* Copyright (C) 1998, 1999, 2000  Free Software Foundation
+/* Copyright (C) 1998, 1999, 2000, 2001  Free Software Foundation
 
    This file is part of libgcj.
 
@@ -67,9 +67,6 @@ details.  */
 #include <ltdl.h>
 #endif
 
-// We use placement new.
-#include <new>
-
 // We allocate a single OutOfMemoryError exception which we keep
 // around for use if we run out of memory.
 static java::lang::OutOfMemoryError *no_memory;
@@ -397,30 +394,25 @@ _Jv_NewObjectArray (jsize count, jclass elementClass, jobject init)
 
   JvAssert (! elementClass->isPrimitive ());
 
+  // Ensure that elements pointer is properly aligned.
   jobjectArray obj = NULL;
-  size_t size = (size_t) _Jv_GetArrayElementFromElementType (obj,
-                                                            elementClass);
-
-  // Check for overflow.
-  if (__builtin_expect ((size_t) count > 
-                       (SIZE_T_MAX - size) / sizeof (jobject), false))
-    JvThrow (no_memory);
-
+  size_t size = (size_t) elements (obj);
   size += count * sizeof (jobject);
 
-  // FIXME: second argument should be "current loader" //
-  jclass klass = _Jv_FindArrayClass (elementClass, 0);
+  // FIXME: second argument should be "current loader"
+  jclass klass = _Jv_GetArrayClass (elementClass, 0);
 
   obj = (jobjectArray) _Jv_AllocArray (size, klass);
   if (__builtin_expect (! obj, false))
     JvThrow (no_memory);
-  // Use placement new to initialize length field.
-  new (obj) __JArray (count);
-  jobject *ptr = elements(obj);
+  // Cast away const.
+  jsize *lp = const_cast<jsize *> (&obj->length);
+  *lp = count;
   // We know the allocator returns zeroed memory.  So don't bother
   // zeroing it again.
   if (init)
     {
+      jobject *ptr = elements(obj);
       while (--count >= 0)
        *ptr++ = init;
     }
@@ -445,13 +437,14 @@ _Jv_NewPrimArray (jclass eltype, jint count)
                        (SIZE_T_MAX - size) / elsize, false))
     JvThrow (no_memory);
 
-  jclass klass = _Jv_FindArrayClass (eltype, 0);
+  jclass klass = _Jv_GetArrayClass (eltype, 0);
 
   __JArray *arr = (__JArray*) _Jv_AllocObj (size + elsize * count, klass);
   if (__builtin_expect (! arr, false))
     JvThrow (no_memory);
-  // Use placement new to initialize length field.
-  new (arr) __JArray (count);
+  // Cast away const.
+  jsize *lp = const_cast<jsize *> (&arr->length);
+  *lp = count;
   // Note that we assume we are given zeroed memory by the allocator.
 
   return arr;
@@ -517,52 +510,11 @@ _Jv_NewMultiArray (jclass array_type, jint dimensions, ...)
 
 \f
 
-class _Jv_PrimClass : public java::lang::Class
-{
-public:
-  // FIXME: calling convention is weird.  If we use the natural types
-  // then the compiler will complain because they aren't Java types.
-  _Jv_PrimClass (jobject cname, jbyte sig, jint len, jobject array_vtable)
-    {
-      using namespace java::lang::reflect;
-
-      // We must initialize every field of the class.  We do this in
-      // the same order they are declared in Class.h.
-      next = NULL;
-      name = _Jv_makeUtf8Const ((char *) cname, -1);
-      accflags = Modifier::PUBLIC | Modifier::FINAL;
-      superclass = NULL;
-      constants.size = 0;
-      constants.tags = NULL;
-      constants.data = NULL;
-      methods = NULL;
-      method_count = sig;
-      vtable_method_count = 0;
-      fields = NULL;
-      size_in_bytes = len;
-      field_count = 0;
-      static_field_count = 0;
-      vtable = JV_PRIMITIVE_VTABLE;
-      interfaces = NULL;
-      loader = NULL;
-      interface_count = 0;
-      state = JV_STATE_DONE;
-      thread = NULL;
-
-      // Note that we have to set `methods' to NULL.
-      if (sig != 'V')
-       _Jv_FindArrayClass (this, NULL, (_Jv_VTable *) array_vtable);
-    }
-};
-
-// We use this to define both primitive classes and the vtables for
-// arrays of primitive classes.  The latter are given names so that we
-// can refer to them from the compiler, allowing us to construct
-// arrays of primitives statically.
-#define DECLARE_PRIM_TYPE(NAME, SIG, LEN) \
-  _Jv_ArrayVTable _Jv_##NAME##VTable; \
-  _Jv_PrimClass _Jv_##NAME##Class((jobject) #NAME, (jbyte) SIG, (jint) LEN, \
-                                  (jobject) &_Jv_##NAME##VTable)
+#define DECLARE_PRIM_TYPE(NAME, SIG, LEN)                              \
+  _Jv_ArrayVTable _Jv_##NAME##VTable;                                  \
+  java::lang::Class _Jv_##NAME##Class ((jobject) #NAME,                        \
+                                      (jbyte) SIG, (jint) LEN,         \
+                                      (jobject) &_Jv_##NAME##VTable);
 
 DECLARE_PRIM_TYPE(byte, 'B', 1);
 DECLARE_PRIM_TYPE(short, 'S', 2);
@@ -607,8 +559,8 @@ _Jv_FindClassFromSignature (char *sig, java::lang::ClassLoader *loader)
 
       }
     case '[':
-      return _Jv_FindArrayClass (_Jv_FindClassFromSignature (&sig[1], loader),
-                                loader);
+      return _Jv_GetArrayClass (_Jv_FindClassFromSignature (&sig[1], loader),
+                               loader);
     }
   JvFail ("couldn't understand class signature");
   return NULL;                 // Placate compiler.
@@ -688,6 +640,10 @@ win32_exception_handler (LPEXCEPTION_POINTERS e)
 static void
 main_init ()
 {
+  // Turn stack trace generation off while creating exception objects.
+  _Jv_InitClass (&java::lang::Throwable::class$);
+  java::lang::Throwable::trace_enabled = 0;
+  
   INIT_SEGV;
 #ifdef HANDLE_FPE
   INIT_FPE;
@@ -698,6 +654,8 @@ main_init ()
 
   no_memory = new java::lang::OutOfMemoryError;
 
+  java::lang::Throwable::trace_enabled = 1;
+
 #ifdef USE_LTDL
   LTDL_SET_PRELOADED_SYMBOLS ();
 #endif