// prims.cc - Code for core of runtime environment.
-/* Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation
+/* Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation
This file is part of libgcj.
details. */
#include <config.h>
-
-#ifdef USE_WIN32_SIGNALLING
-#include <windows.h>
-#endif /* USE_WIN32_SIGNALLING */
-
-#ifdef USE_WINSOCK
-#undef __INSIDE_CYGWIN__
-#include <winsock.h>
-#endif /* USE_WINSOCK */
+#include <platform.h>
#include <stdlib.h>
#include <stdarg.h>
#include <java/lang/ArrayIndexOutOfBoundsException.h>
#include <java/lang/ArithmeticException.h>
#include <java/lang/ClassFormatError.h>
+#include <java/lang/InternalError.h>
#include <java/lang/NegativeArraySizeException.h>
#include <java/lang/NullPointerException.h>
#include <java/lang/OutOfMemoryError.h>
#include <java/lang/System.h>
+#include <java/lang/VMThrowable.h>
#include <java/lang/reflect/Modifier.h>
#include <java/io/PrintStream.h>
#include <java/lang/UnsatisfiedLinkError.h>
// if there really is an interesting finalizer.
// Unfortunately, we still have to the dynamic test, since there may
// be cni calls to this routine.
- // Nore that on IA64 get_finalizer() returns the starting address of the
+ // Note that on IA64 get_finalizer() returns the starting address of the
// function, not a function pointer. Thus this still works.
if (klass->vtable->get_finalizer ()
!= java::lang::Object::class$.vtable->get_finalizer ())
size_t size = (size_t) elements (obj);
size += count * sizeof (jobject);
- // FIXME: second argument should be "current loader"
- jclass klass = _Jv_GetArrayClass (elementClass, 0);
+ jclass klass = _Jv_GetArrayClass (elementClass,
+ elementClass->getClassLoaderInternal());
obj = (jobjectArray) _Jv_AllocArray (size, klass);
// Cast away const.
case 10: return JvNewIntArray (size);
case 11: return JvNewLongArray (size);
}
- JvFail ("newarray - bad type code");
- return NULL; // Placate compiler.
+ throw new java::lang::InternalError
+ (JvNewStringLatin1 ("invalid type code in _Jv_NewArray"));
}
// Allocate a possibly multi-dimensional array but don't check that
\f
+// Ensure 8-byte alignment, for hash synchronization.
#define DECLARE_PRIM_TYPE(NAME) \
_Jv_ArrayVTable _Jv_##NAME##VTable; \
- java::lang::Class _Jv_##NAME##Class;
-
-DECLARE_PRIM_TYPE(byte);
-DECLARE_PRIM_TYPE(short);
-DECLARE_PRIM_TYPE(int);
-DECLARE_PRIM_TYPE(long);
-DECLARE_PRIM_TYPE(boolean);
-DECLARE_PRIM_TYPE(char);
-DECLARE_PRIM_TYPE(float);
-DECLARE_PRIM_TYPE(double);
-DECLARE_PRIM_TYPE(void);
+ java::lang::Class _Jv_##NAME##Class __attribute__ ((aligned (8)));
+
+DECLARE_PRIM_TYPE(byte)
+DECLARE_PRIM_TYPE(short)
+DECLARE_PRIM_TYPE(int)
+DECLARE_PRIM_TYPE(long)
+DECLARE_PRIM_TYPE(boolean)
+DECLARE_PRIM_TYPE(char)
+DECLARE_PRIM_TYPE(float)
+DECLARE_PRIM_TYPE(double)
+DECLARE_PRIM_TYPE(void)
void
_Jv_InitPrimClass (jclass cl, char *cname, char sig, int len,
{
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, except for fields that
- // are initialized to NULL.
+ _Jv_InitNewClassFields (cl);
+
+ // We must set the vtable for the class; the Java constructor
+ // doesn't do this.
+ (*(_Jv_VTable **) cl) = java::lang::Class::class$.vtable;
+
+ // Initialize the fields we care about. We do this in the same
+ // order they are declared in Class.h.
cl->name = _Jv_makeUtf8Const ((char *) cname, -1);
cl->accflags = Modifier::PUBLIC | Modifier::FINAL | Modifier::ABSTRACT;
cl->method_count = sig;
;
_Jv_Utf8Const *name = _Jv_makeUtf8Const (&sig[1], i - 1);
return _Jv_FindClass (name, loader);
-
}
case '[':
{
}
}
-#ifdef USE_WIN32_SIGNALLING
-
-extern "C" int* win32_get_restart_frame (void *);
-
-LONG CALLBACK
-win32_exception_handler (LPEXCEPTION_POINTERS e)
-{
- int* setjmp_buf;
- if (e->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION)
- setjmp_buf = win32_get_restart_frame (nullp);
- else if (e->ExceptionRecord->ExceptionCode == EXCEPTION_INT_DIVIDE_BY_ZERO)
- setjmp_buf = win32_get_restart_frame (arithexception);
- else
- return EXCEPTION_CONTINUE_SEARCH;
-
- e->ContextRecord->Ebp = setjmp_buf[0];
- // FIXME: Why does i386-signal.h increment the PC here, do we need to do it?
- e->ContextRecord->Eip = setjmp_buf[1];
- // FIXME: Is this the stack pointer? Do we need it?
- e->ContextRecord->Esp = setjmp_buf[2];
-
- return EXCEPTION_CONTINUE_EXECUTION;
-}
-
-#endif
-
#ifndef DISABLE_GETENV_PROPERTIES
static char *
_Jv_InitPrimClass (&_Jv_voidClass, "void", 'V', 0, &_Jv_voidVTable);
// Turn stack trace generation off while creating exception objects.
- _Jv_InitClass (&java::lang::Throwable::class$);
- java::lang::Throwable::trace_enabled = 0;
+ _Jv_InitClass (&java::lang::VMThrowable::class$);
+ java::lang::VMThrowable::trace_enabled = 0;
INIT_SEGV;
#ifdef HANDLE_FPE
arithexception = new java::lang::ArithmeticException
(JvNewStringLatin1 ("/ by zero"));
#endif
-
+
no_memory = new java::lang::OutOfMemoryError;
-
- java::lang::Throwable::trace_enabled = 1;
-
+
+ java::lang::VMThrowable::trace_enabled = 1;
+
#ifdef USE_LTDL
LTDL_SET_PRELOADED_SYMBOLS ();
#endif
-#ifdef USE_WINSOCK
- // Initialise winsock for networking
- WSADATA data;
- if (WSAStartup (MAKEWORD (1, 1), &data))
- MessageBox (NULL, "Error initialising winsock library.", "Error", MB_OK | MB_ICONEXCLAMATION);
-#endif /* USE_WINSOCK */
-
-#ifdef USE_WIN32_SIGNALLING
- // Install exception handler
- SetUnhandledExceptionFilter (win32_exception_handler);
-#elif defined(HAVE_SIGACTION)
- // We only want this on POSIX systems.
- struct sigaction act;
- act.sa_handler = SIG_IGN;
- sigemptyset (&act.sa_mask);
- act.sa_flags = 0;
- sigaction (SIGPIPE, &act, NULL);
-#else
- signal (SIGPIPE, SIG_IGN);
-#endif
+ _Jv_platform_initialize ();
_Jv_JNI_Init ();
java::lang::Runtime *runtime = NULL;
+
+#ifdef DISABLE_MAIN_ARGS
+ _Jv_ThisExecutable ("[Embedded App]");
+#else
#ifdef HAVE_PROC_SELF_EXE
char exec_name[20];
sprintf (exec_name, "/proc/%d/exe", getpid ());
_Jv_ThisExecutable (exec_name);
#else
_Jv_ThisExecutable (argv[0]);
-#endif
+#endif /* HAVE_PROC_SELF_EXE */
+#endif /* DISABLE_MAIN_ARGS */
try
{
// for `main'; that way it will be set up if `main' is a JNI method.
runtime = java::lang::Runtime::getRuntime ();
+#ifdef DISABLE_MAIN_ARGS
+ arg_vec = JvConvertArgv (0, 0);
+#else
arg_vec = JvConvertArgv (argc - 1, argv + 1);
+#endif
using namespace gnu::gcj::runtime;
if (klass)