PatchSet 6450
Date: 2005/05/07 16:20:05
Author: jserv
Branch: HEAD
Tag: (none)
Log:
Corrected and clarified copyright notice.
2005-05-08 Jim Huang <[EMAIL PROTECTED]>
* kaffe/kaffeh/main.c,
kaffe/kaffeh/support.c,
kaffe/kaffevm/baseClasses.c,
kaffe/kaffevm/code.c,
kaffe/kaffevm/exception.c,
kaffe/kaffevm/gcFuncs.c,
kaffe/kaffevm/itypes.c,
kaffe/kaffevm/object.c,
kaffe/kaffevm/object.h,
kaffe/kaffevm/soft.c,
kaffe/kaffevm/stackTrace.c,
kaffe/kaffevm/stats.c,
kaffe/kaffevm/stats.h,
kaffe/kaffevm/utf8const.c,
kaffe/kaffevm/intrp/methodcalls.c,
kaffe/kaffevm/intrp/native-wrapper.c,
kaffe/kaffevm/intrp/native-wrapper.h,
kaffe/kaffevm/jit/methodcalls.c,
kaffe/kaffevm/jit/native-wrapper.c,
kaffe/kaffevm/jit/native-wrapper.h,
kaffe/kaffevm/jit3/machine.c,
kaffe/kaffevm/jit3/machine.h,
kaffe/kaffevm/jit3/native-wrapper.c,
kaffe/kaffevm/jni/jni-arrays.c,
kaffe/kaffevm/jni/jni-base.c,
kaffe/kaffevm/jni/jni-callmethod.c,
kaffe/kaffevm/jni/jni-fields.c,
kaffe/kaffevm/jni/jni-helpers.c,
kaffe/kaffevm/jni/jni-string.c,
kaffe/kaffevm/jni/jni.c,
kaffe/kaffevm/kaffe-gc/gc-incremental.c,
include/native.h:
Corrected and clarified copyright notice.
Members:
ChangeLog:1.3978->1.3979
include/native.h:INITIAL->1.19
kaffe/kaffeh/main.c:1.15->1.16
kaffe/kaffeh/support.c:INITIAL->1.49
kaffe/kaffevm/baseClasses.c:1.63->1.64
kaffe/kaffevm/code.c:INITIAL->1.20
kaffe/kaffevm/exception.c:1.98->1.99
kaffe/kaffevm/gcFuncs.c:1.72->1.73
kaffe/kaffevm/itypes.c:1.36->1.37
kaffe/kaffevm/object.c:INITIAL->1.34
kaffe/kaffevm/object.h:INITIAL->1.8
kaffe/kaffevm/soft.c:INITIAL->1.77
kaffe/kaffevm/stackTrace.c:1.46->1.47
kaffe/kaffevm/stats.c:INITIAL->1.8
kaffe/kaffevm/stats.h:INITIAL->1.3
kaffe/kaffevm/utf8const.c:1.49->1.50
kaffe/kaffevm/intrp/methodcalls.c:1.8->1.9
kaffe/kaffevm/intrp/native-wrapper.c:1.5->1.6
kaffe/kaffevm/intrp/native-wrapper.h:1.2->1.3
kaffe/kaffevm/jit/methodcalls.c:1.9->1.10
kaffe/kaffevm/jit/native-wrapper.c:1.8->1.9
kaffe/kaffevm/jit/native-wrapper.h:1.2->1.3
kaffe/kaffevm/jit3/machine.c:1.75->1.76
kaffe/kaffevm/jit3/machine.h:INITIAL->1.25
kaffe/kaffevm/jit3/native-wrapper.c:1.2->1.3
kaffe/kaffevm/jni/jni-arrays.c:1.5->1.6
kaffe/kaffevm/jni/jni-base.c:1.18->1.19
kaffe/kaffevm/jni/jni-callmethod.c:1.6->1.7
kaffe/kaffevm/jni/jni-fields.c:1.3->1.4
kaffe/kaffevm/jni/jni-helpers.c:1.5->1.6
kaffe/kaffevm/jni/jni-string.c:1.9->1.10
kaffe/kaffevm/jni/jni.c:1.25->1.26
kaffe/kaffevm/kaffe-gc/gc-incremental.c:1.28->1.29
Index: kaffe/ChangeLog
diff -u kaffe/ChangeLog:1.3978 kaffe/ChangeLog:1.3979
--- kaffe/ChangeLog:1.3978 Sat May 7 10:35:14 2005
+++ kaffe/ChangeLog Sat May 7 16:20:05 2005
@@ -1,3 +1,39 @@
+2005-05-08 Jim Huang <[EMAIL PROTECTED]>
+
+ * kaffe/kaffeh/main.c,
+ kaffe/kaffeh/support.c,
+ kaffe/kaffevm/baseClasses.c,
+ kaffe/kaffevm/code.c,
+ kaffe/kaffevm/exception.c,
+ kaffe/kaffevm/gcFuncs.c,
+ kaffe/kaffevm/itypes.c,
+ kaffe/kaffevm/object.c,
+ kaffe/kaffevm/object.h,
+ kaffe/kaffevm/soft.c,
+ kaffe/kaffevm/stackTrace.c,
+ kaffe/kaffevm/stats.c,
+ kaffe/kaffevm/stats.h,
+ kaffe/kaffevm/utf8const.c,
+ kaffe/kaffevm/intrp/methodcalls.c,
+ kaffe/kaffevm/intrp/native-wrapper.c,
+ kaffe/kaffevm/intrp/native-wrapper.h,
+ kaffe/kaffevm/jit/methodcalls.c,
+ kaffe/kaffevm/jit/native-wrapper.c,
+ kaffe/kaffevm/jit/native-wrapper.h,
+ kaffe/kaffevm/jit3/machine.c,
+ kaffe/kaffevm/jit3/machine.h,
+ kaffe/kaffevm/jit3/native-wrapper.c,
+ kaffe/kaffevm/jni/jni-arrays.c,
+ kaffe/kaffevm/jni/jni-base.c,
+ kaffe/kaffevm/jni/jni-callmethod.c,
+ kaffe/kaffevm/jni/jni-fields.c,
+ kaffe/kaffevm/jni/jni-helpers.c,
+ kaffe/kaffevm/jni/jni-string.c,
+ kaffe/kaffevm/jni/jni.c,
+ kaffe/kaffevm/kaffe-gc/gc-incremental.c,
+ include/native.h:
+ Corrected and clarified copyright notice.
+
2005-05-07 Guilhem Lavaux <[EMAIL PROTECTED]>
* kaffe/kaffevm/hashtab.c
===================================================================
Checking out kaffe/include/native.h
RCS: /home/cvs/kaffe/kaffe/include/native.h,v
VERS: 1.19
***************
--- /dev/null Sun Aug 4 19:57:58 2002
+++ kaffe/include/native.h Sat May 7 16:25:18 2005
@@ -0,0 +1,93 @@
+/*
+ * native.h
+ * Native method support.
+ *
+ * Copyright (c) 1996, 1997
+ * Transvirtual Technologies, Inc. All rights reserved.
+ *
+ * Copyright (c) 2004
+ * Kaffe.org contributors. See ChangeLog for details. All rights reserved.
+ *
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file.
+ */
+
+#ifndef __native_h
+#define __native_h
+
+#include "stddef.h"
+#include <jni.h>
+
+struct _methods;
+struct Hjava_lang_Class;
+struct Hjava_lang_ClassLoader;
+struct _strconst;
+
+#if !defined(__DEFINED_METHOD)
+#define __DEFINED_METHOD
+typedef struct _methods Method;
+#endif
+#if !defined(__DEFINED_UTF8CONST)
+#define __DEFINED_UTF8CONST
+typedef struct _strconst Utf8Const;
+#endif
+#if !defined(__DEFINED_CLASS)
+#define __DEFINED_CLASS
+typedef struct Hjava_lang_Class Hjava_lang_Class;
+#endif
+
+struct _dispatchTable;
+struct _iLock;
+
+
+
+typedef struct Hjava_lang_Object {
+ struct _dispatchTable* vtable;
+ struct _iLock* lock;
+ /* This pointer contains the VM function which should be called
+ * to handle object finalization.
+ */
+ void* finalizer_call;
+ /* Data follows on immediately */
+} Hjava_lang_Object;
+
+/* Turn a handle into the real thing */
+#define unhand(o) (o)
+
+/* Include array types */
+#include "Arrays.h"
+
+/* Get the strings */
+#include <java_lang_String.h>
+
+/* Some internal machine object conversions to "standard" types. */
+typedef Hjava_lang_Class HClass;
+typedef Hjava_lang_Object HObject;
+typedef Hjava_lang_String HString;
+
+extern char* stringJava2CBuf(const HString*, char*, int);
+extern char* stringJava2C(const HString*);
+extern HString* stringC2Java(const char*);
+
+extern int utf8ConstEqualJavaString(const Utf8Const*, const HString*);
+
+extern HObject* AllocObject(const char*, struct
Hjava_lang_ClassLoader*);
+extern HObject* AllocArray(jsize len, int type);
+extern HObject* AllocObjectArray(int, const char*, struct
Hjava_lang_ClassLoader*);
+
+/*
+ * Define KMALLOC, KFREE, etc.
+ */
+#include "kaffe/jmalloc.h"
+
+/* Pick up errorInfo, postOutOfMemory, throwError, and checkPtr */
+#include "errors.h"
+
+/*
+ * Functions needed protect calls to non-reentrant functions when a
+ * user-level threading package such as jthread is used.
+ */
+void enterUnsafeRegion(void);
+void leaveUnsafeRegion(void);
+
+#endif
Index: kaffe/kaffe/kaffeh/main.c
diff -u kaffe/kaffe/kaffeh/main.c:1.15 kaffe/kaffe/kaffeh/main.c:1.16
--- kaffe/kaffe/kaffeh/main.c:1.15 Fri Mar 26 22:58:40 2004
+++ kaffe/kaffe/kaffeh/main.c Sat May 7 16:20:08 2005
@@ -2,9 +2,12 @@
* main.c
* Generate native code stubs from .class files.
*
- * Copyright (c) 1996, 1997, 2004
+ * Copyright (c) 1996, 1997
* Transvirtual Technologies, Inc. All rights reserved.
*
+ * Copyright (c) 2004
+ * Kaffe.org contributors. See ChangeLog for details. All rights reserved.
+ *
* See the file "license.terms" for information on usage and redistribution
* of this file.
*/
===================================================================
Checking out kaffe/kaffe/kaffeh/support.c
RCS: /home/cvs/kaffe/kaffe/kaffe/kaffeh/support.c,v
VERS: 1.49
***************
--- /dev/null Sun Aug 4 19:57:58 2002
+++ kaffe/kaffe/kaffeh/support.c Sat May 7 16:25:18 2005
@@ -0,0 +1,943 @@
+/*
+ * support.c
+ *
+ * Copyright (c) 1996, 1997
+ * Transvirtual Technologies, Inc. All rights reserved.
+ *
+ * Copyright (c) 2004
+ * Kaffe.org contributors. See ChangeLog for details. All rights reserved.
+ *
+ * See the file "license.terms" for information on usage and redistribution
+ * of this file.
+ */
+
+#include "config.h"
+#include "config-std.h"
+#include "config-io.h"
+#include "debug.h"
+#include "kaffe/jni_md.h"
+#include "jsyscall.h"
+#include "gtypes.h"
+#include "gc.h"
+#include "constants.h"
+#include "file.h"
+#include "files.h"
+#include "access.h"
+#include "classMethod.h"
+#include "readClass.h"
+#include "jar.h"
+#include "kaffeh-support.h"
+#include "utf8const.h"
+
+#if defined(__WIN32__) || defined (__amigaos__)
+#define PATHSEP ';'
+#else
+#define PATHSEP ':'
+#endif
+
+extern char realClassPath[];
+extern char className[];
+extern FILE* include;
+extern FILE* jni_include;
+extern int flag_jni;
+
+static int objectDepth = -1;
+static int outputField = 1; /* Output object fields? Only skipped on
java.lang.Class and java.lang.Object */
+
+struct _Collector;
+
+static inline int
+binary_open(const char *file, int mode, int perm, int *);
+
+/* circular list containing all native methods of the class that's currently
being processed (sorted by name) */
+struct _methodRing {
+ struct _methodRing* next;
+ struct _methodRing* prev;
+
+ const char* name;
+ const char* sig;
+ u2 access_flags;
+ bool needs_mangled_sig;
+} *methodRing;
+
+static int
+kread(int fd, void *buf, size_t len, ssize_t *out)
+{
+ *out = read(fd, buf, len);
+ return (*out == -1) ? errno : 0;
+}
+
+static int
+kwrite(int fd, const void *buf, size_t len, ssize_t *out)
+{
+ *out = write(fd, buf, len);
+ return (*out == -1) ? errno : 0;
+}
+
+static int
+klseek(int fd, off_t off, int whence, off_t *out)
+{
+ *out = lseek(fd, off, whence);
+ return (*out == -1) ? errno : 0;
+}
+
+/* With Tru64, stat and fstat() are silly macros, convert them to functions.
*/
+#if defined(stat)
+static int
+kstat (const char *file_name, struct stat *buf)
+{
+ return stat (file_name, buf);
+}
+#else
+#define kstat stat
+#endif
+
+#if defined(fstat)
+static int
+kfstat (int fd, struct stat *buf)
+{
+ return fstat (fd, buf);
+}
+#else
+#define kfstat fstat
+#endif
+
+
+/*
+ * We use a very simple 'fake' threads subsystem
+ */
+
+SystemCallInterface Kaffe_SystemCallInterface =
+{
+ binary_open,
+ kread,
+ kwrite,
+ klseek,
+ close,
+ kfstat,
+ kstat,
+
+ NULL, /* truncate */
+ NULL, /* fsync */
+ NULL, /* mkdir */
+ NULL, /* rmdir */
+ NULL, /* rename */
+ NULL, /* remove */
+ NULL, /* socket */
+ NULL, /* connect */
+ NULL, /* bind */
+ NULL, /* listen */
+ NULL, /* accept */
+ NULL, /* sockread */
+ NULL, /* recvfrom */
+ NULL, /* sockwrite */
+ NULL, /* sendto */
+ NULL, /* setsockopt */
+ NULL, /* getsockopt */
+ NULL, /* getsockname */
+ NULL, /* getpeername */
+ NULL, /* sockclose */
+ NULL, /* gethostbyname */
+ NULL, /* gethostbyaddr */
+ NULL, /* select */
+ NULL, /* forkexec */
+ NULL, /* waitpid */
+ NULL, /* kill */
+ NULL, /* mmap */
+ NULL, /* munmap */
+ NULL, /* msync */
+ NULL, /* pipecreate */
+ NULL, /* piperead */
+ NULL /* pipewrite */
+};
+
+
+/*
+ * Ensure that files are opened in binary mode; the MS-Windows port
+ * depends on this.
+ */
+static inline int
+binary_open(const char *file, int mode, int perm, int *out) {
+ *out = open(file, mode | O_BINARY, perm);
+ return *out == -1 ? errno : 0;
+}
+
+/*
+ * Init include file.
+ */
+void
+initInclude(void)
+{
+ if (include == NULL) {
+ return;
+ }
+
+ fprintf(include, "/* DO NOT EDIT THIS FILE - it is machine generated
*/\n");
+ fprintf(include, "#include <native.h>\n");
+ fprintf(include, "\n");
+ fprintf(include, "#ifndef _Included_%s\n", className);
+ fprintf(include, "#define _Included_%s\n", className);
+ fprintf(include, "\n");
+ fprintf(include, "#ifdef __cplusplus\n");
+ fprintf(include, "extern \"C\" {\n");
+ fprintf(include, "#endif\n");
+}
+
+/*
+ * Start include file.
+ */
+void
+startInclude(void)
+{
+ if (include == NULL) {
+ return;
+ }
+
+ fprintf(include, "\n");
+ fprintf(include, "/* Header for class %s */\n", className);
+ fprintf(include, "\n");
+ if ((strcmp (className, "java_lang_Object") == 0) ||
+ (strcmp (className, "java_lang_Class") == 0)) {
+ outputField = 0;
+ }
+ else {
+ outputField = 1;
+ fprintf(include, "typedef struct H%s {\n", className);
+ fprintf(include, " /* Fields from java/lang/Object: */\n");
+ fprintf(include, " Hjava_lang_Object base;\n");
+ }
+}
+
+/*
+ * End include file.
+ */
+void
+endInclude(void)
+{
+ if (include == NULL) {
+ return;
+ }
+
+ fprintf(include, "\n");
+ fprintf(include, "#ifdef __cplusplus\n");
+ fprintf(include, "}\n");
+ fprintf(include, "#endif\n");
+ fprintf(include, "\n");
+ fprintf(include, "#endif\n");
+}
+
+void
+initJniInclude(void)
+{
+ if (jni_include == NULL) {
+ return;
+ }
+
+ fprintf(jni_include, "/* DO NOT EDIT THIS FILE - it is machine
generated */\n");
+ fprintf(jni_include, "#include <jni.h>\n");
+ fprintf(jni_include, "\n");
+ fprintf(jni_include, "#ifndef _Included_%s\n", className);
+ fprintf(jni_include, "#define _Included_%s\n", className);
+ fprintf(jni_include, "\n");
+ fprintf(jni_include, "#ifdef __cplusplus\n");
+ fprintf(jni_include, "extern \"C\" {\n");
+ fprintf(jni_include, "#endif\n");
+ fprintf(jni_include, "\n");
+}
+
+void
+startJniInclude(void)
+{
+}
+
+void
+endJniInclude(void)
+{
+ if (jni_include == NULL) {
+ return;
+ }
+
+ fprintf(jni_include, "\n");
+ fprintf(jni_include, "#ifdef __cplusplus\n");
+ fprintf(jni_include, "}\n");
+ fprintf(jni_include, "#endif\n");
+ fprintf(jni_include, "\n");
+ fprintf(jni_include, "#endif\n");
+}
+
+
+bool
+addSourceFile(Hjava_lang_Class* c UNUSED, int idx UNUSED, errorInfo *einfo
UNUSED)
+{
+ return true;
+}
+
+bool
+addInnerClasses(Hjava_lang_Class* c UNUSED, size_t len, classFile* fp,
+ errorInfo *einfo UNUSED)
+{
+ /* checkBufSize() done in caller. */
+ seekm(fp, len);
+ return true;
+}
+
+/*
+ * Return the JNI type
+ */
+static const char *
+jniType(const char *sig)
+{
+ switch (sig[0]) {
+ case '[':
+ switch (sig[1]) {
+ case 'Z':
+ return "jbooleanArray";
+ case 'B':
+ return "jbyteArray";
+ case 'C':
+ return "jcharArray";
+ case 'S':
+ return "jshortArray";
+ case 'I':
+ return "jintArray";
+ case 'J':
+ return "jlongArray";
+ case 'F':
+ return "jfloatArray";
+ case 'D':
+ return "jdoubleArray";
+ case 'L':
+ case '[':
+ return "jobjectArray";
+ default:
+ dprintf("bogus array type `%c'", sig[1]);
+ exit(EXIT_FAILURE);
+ }
+ case 'L':
+ if (strncmp(sig, "Ljava/lang/Class;", 17) == 0)
+ return "jclass";
+ if (strncmp(sig, "Ljava/lang/String;", 18) == 0)
+ return "jstring";
+ return "jobject";
+ case 'I':
+ return "jint";
+ case 'Z':
+ return "jboolean";
+ case 'S':
+ return "jshort";
+ case 'B':
+ return "jbyte";
+ case 'C':
+ return "jchar";
+ case 'F':
+ return "jfloat";
+ case 'J':
+ return "jlong";
+ case 'D':
+ return "jdouble";
+ case 'V':
+ return "void";
+ default:
+ dprintf("bogus signature type `%c'", sig[0]);
+ exit(EXIT_FAILURE);
+ }
+}
+
+/*
+ * Print a properly mangled method name or argument signature.
+ */
+static void
+fprintfJni (FILE *f, const char *s)
+{
+ while (*s != '\0' && *s != ')')
+ {
+ switch (*s)
+ {
+ case '/':
+ fprintf (f, "_");
+ break;
+
+ case '_':
+ fprintf (f, "_1");
+ break;
+
+ case ';':
+ fprintf (f, "_2");
+ break;
+
+ case '[':
+ fprintf (f, "_3");
+ break;
+
+ case '$':
+ fprintf (f, "_00024");
+ break;
+
+ default:
+ fprintf (f, "%c", *s);
+ break;
+ }
+ s++;
+ }
+}
+
+int
+startFields(Hjava_lang_Class* this, u2 fct, errorInfo *einfo UNUSED)
+{
+ this->fields = malloc(fct * sizeof(Field));
+ CLASS_NFIELDS(this) = 0; /* incremented by addField() */
+ return true;
+}
+
+Field*
+addField(Hjava_lang_Class* this,
+ u2 access_flags, u2 name_index, u2 signature_index,
+ struct _errorInfo* einfo UNUSED)
+{
+ Field* f;
+
+ if (CLASS_CONST_TAG(this, name_index) != CONSTANT_Utf8) {
+ dprintf("addField(): no method name.\n"); /* XXX */
+ return (NULL);
+ }
+ if (CLASS_CONST_TAG(this, signature_index) != CONSTANT_Utf8) {
+ dprintf("addField(): no signature name.\n"); /* XXX */
+ return (NULL);
+ }
+
+ DBG(CLASSFILE,
+ dprintf("addField(%s.%s)\n",
+ CLASS_CNAME(this), CLASS_CONST_UTF8(this,
name_index)->data);
+ );
+
+ f = &(this->fields[CLASS_NFIELDS(this)++]);
+
+ /*
+ * Store enough info for the field attribute "ConstantValue" handler
(setFieldValue)
+ * to print the field name/signature/access.
+ */
+ f->name = CLASS_CONST_UTF8(this, name_index);
+ f->type = (Hjava_lang_Class*)CLASS_CONST_UTF8(this, signature_index);
+ f->accflags = access_flags;
+ f->bsize = 0; /* not used by kaffeh */
+ f->info.idx = 0; /* not used by kaffeh */
+
+ if (include != NULL) {
+ /*
+ * Non-static fields are represented in the struct.
+ */
+ if ((!(access_flags & ACC_STATIC)
+ && outputField)) {
+ const char* arg;
+ int argsize = 0;
+
+ arg = translateSig(CLASS_CONST_UTF8(this,
signature_index)->data,
+ NULL, &argsize);
+ fprintf(include, " %s %s;\n",
+ arg, CLASS_CONST_UTF8(this, name_index)->data);
+ }
+ }
+
+ return f;
+}
+
+
+static void
+constValueToString(Hjava_lang_Class* this, u2 idx,
+ char *cval)
+{
+ /* XXX use snprintf() */
+
+ /* Pull the constant value for this field out of the constant pool */
+ switch (CLASS_CONST_TAG(this, idx)) {
+ case CONSTANT_Integer:
+ sprintf(cval, "%d", (int)CLASS_CONST_DATA(this, idx));
+ break;
+ case CONSTANT_Float:
+ sprintf(cval, "%.7e", *(float*)&CLASS_CONST_DATA(this,idx));
+ break;
+ case CONSTANT_Long:
+#if SIZEOF_VOID_P == 8
+ sprintf(cval, "0x%016lx", CLASS_CONST_DATA(this,idx));
+#else
+#if defined(WORDS_BIGENDIAN)
+ sprintf(cval, "0x%08x%08x", CLASS_CONST_DATA(this,idx),
CLASS_CONST_DATA(this,idx+1));
+#else
+ sprintf(cval, "0x%08x%08x", CLASS_CONST_DATA(this,idx+1),
CLASS_CONST_DATA(this,idx));
+#endif
+#endif
+ break;
+ case CONSTANT_Double:
+ {
+ union { jint i[2]; jdouble d; } u;
+ u.i[0] = CLASS_CONST_DATA(this,idx);
+ u.i[1] = CLASS_CONST_DATA(this,idx+1);
+ sprintf(cval, "%.16e", u.d);
+ break;
+ }
+ case CONSTANT_String:
+ /* Note, readConstantPool() puts the Utf8 pointer right into
the constant pool for us. */
+ sprintf(cval, "\"%s\"", CLASS_CONST_UTF8(this, idx)->data);
+ break;
+ default:
+ sprintf(cval, "?unsupported type tag %d?",
CLASS_CONST_TAG(this, idx));
+ }
+}
+
+
+void
+setFieldValue(Hjava_lang_Class* this, Field* f, u2 idx)
+{
+ assert(f != NULL);
+
+ if ((f->accflags & (ACC_STATIC|ACC_PUBLIC|ACC_FINAL)) ==
(ACC_STATIC|ACC_PUBLIC|ACC_FINAL)) {
+ char cval[512];
+
+ constValueToString(this, idx, cval);
+
+ if (cval[0] != '\0') {
+ if (include != NULL) {
+ fprintf(include, "#define %s_%s %s\n",
+ className, f->name->data, cval);
+ }
+ if (jni_include != NULL) {
+ fprintf(jni_include, "#define %s_%s %s\n",
+ className, f->name->data, cval);
+ }
+ }
+ }
+}
+
+void
+finishFields(Hjava_lang_Class* this UNUSED)
+{
+ if (include == NULL) {
+ return;
+ }
+
+ if (objectDepth == 0) {
+ if (outputField) {
+ fprintf(include, "} H%s;\n\n", className);
+ }
+ }
+}
+
+int
+startMethods(Hjava_lang_Class* this UNUSED, u2 mct UNUSED,
+ errorInfo *einfo UNUSED)
+{
+ return true;
+}
+
+Method*
+addMethod(Hjava_lang_Class* this,
+ u2 access_flags, u2 name_index, u2 signature_index,
+ struct _errorInfo* einfo)
+{
+ constants* cpool;
+ const char* name;
+ const char* sig;
+ struct _methodRing* list;
+ struct _methodRing* i;
+
+ /* If we shouldn't generate method prototypes, quit now */
+ if (objectDepth > 0) {
+ /* XXX set einfo */
+ return NULL;
+ }
+
+ assert(this != NULL);
+ assert(einfo != NULL);
+
+ cpool = CLASS_CONSTANTS(this);
+
+ if (cpool->tags[name_index] != CONSTANT_Utf8) {
+ dprintf("addMethod(): no method name.\n"); /* XXX */
+ return (NULL);
+ }
+ if (cpool->tags[signature_index] != CONSTANT_Utf8) {
+ dprintf("addMethod(): no signature name.\n"); /* XXX */
+ return (NULL);
+ }
+
+ name = WORD2UTF(cpool->data[name_index])->data;
+ sig = WORD2UTF(cpool->data[signature_index])->data;
+
+ DBG(CLASSFILE,
+ dprintf("addMethod: %s%s%s\n", name, sig,
+ (access_flags & ACC_NATIVE) ? " (native)" : "");
+ );
+
+ /* Only generate stubs for native methods */
+ if (!(access_flags & ACC_NATIVE)) {
+ /* Return "success"... */
+ return (Method*)1;
+ }
+
+ /* add the method into the list of native methods of this class */
+ list = (struct _methodRing *)malloc (sizeof (struct _methodRing));
+
+ list->name = name;
+ list->sig = sig;
+ list->access_flags = access_flags;
+ list->needs_mangled_sig = false;
+
+ if (methodRing == NULL) {
+ methodRing = list;
+
+ list->next = list->prev = list;
+ } else {
+ i = methodRing;
+
+ do {
+
+ if (!strcmp (list->name, i->name)) {
+ /* iff the names are equal, both need a mangled
sig */
+ list->needs_mangled_sig = true;
+ i->needs_mangled_sig = true;
+
+ /* insert list */
+ i->next->prev = list;
+ list->next = i->next;
+
+ i->next = list;
+ list->prev = i;
+
+ /* return success */
+ return (Method*)1;
+ }
+
+ i = i->next;
+
+ } while (i != methodRing);
+
+ /* if we didn't find a suitable place, add it at the end of the
list */
+ i->prev->next = list;
+ list->prev = i->prev;
+
+ i->prev = list;
+ list->next = i;
+ }
+
+ return (Method*)1;
+}
+
+void
+finishMethods (Hjava_lang_Class *this UNUSED)
+{
+ const char *str;
+ const char *tsig;
+ struct _methodRing* i;
+ struct _methodRing* tmp;
+
+ /* don't do anything if there aren't any methods */
+ if (methodRing == NULL) {
+ return;
+ }
+
+ i = methodRing;
+ do {
+ int args = 0;
+ char* ret;
+
+ /* Generate method prototype */
+ ret = strchr(i->sig,')');
+ ret++;
+
+ if (include != NULL) {
+ fprintf(include, "extern %s", translateSig(ret, 0, 0));
+ fprintf(include, " %s_%s(", className, i->name);
+ if (!(i->access_flags & ACC_STATIC)) {
+ fprintf(include, "struct H%s*", className);
+ if (i->sig[1] != ')') {
+ fprintf(include, ", ");
+ }
+ } else if (i->sig[1] == ')') {
+ fprintf(include, "void");
+ }
+ }
+
+ if (jni_include != NULL) {
+ fprintf(jni_include, "JNIEXPORT %s JNICALL Java_%s_",
+ jniType(ret), className);
+
+ fprintfJni(jni_include, i->name);
+
+ /* append mangled sig if necessary */
+ if (i->needs_mangled_sig) {
+ fprintf(jni_include, "__");
+
+ fprintfJni(jni_include, i->sig+1);
+ }
+
+ fprintf(jni_include, "(JNIEnv*");
+
+ if ((i->access_flags & ACC_STATIC)) {
+ fprintf(jni_include, ", jclass");
+ }
+ else {
+ fprintf(jni_include, ", jobject");
+ }
+ }
+
+ str = i->sig + 1;
+ args++;
+ while (str[0] != ')') {
+ if (jni_include != NULL)
+ fprintf(jni_include, ", %s", jniType(str));
+ tsig = translateSig(str, &str, &args);
+ if (include != NULL) {
+ fprintf(include, "%s", tsig);
+ if (str[0] != ')') {
+ fprintf(include, ", ");
+ }
+ }
+ }
+ if (include != NULL) {
+ fprintf(include, ");\n");
+ }
+ if (jni_include != NULL) {
+ fprintf(jni_include, ");\n");
+ }
+
+ /* move to next method */
+ tmp = i;
+ i = i->next;
+
+ /* free old one */
+ free (tmp);
+
+ } while (i != methodRing);
+
+ /* we don't have any methods any more */
+ methodRing = NULL;
+}
+
+bool
+addCode(Method* m, size_t len, classFile* fp, errorInfo *einfo UNUSED)
+{
+ /* Don't try dereferencing m! */
+ assert(m == (Method*)1);
+
+ /* checkBufSize() done in caller. */
+ seekm(fp, len);
+ return true;
+}
+
+bool
+addLineNumbers(Method* m, size_t len, classFile* fp, errorInfo *info UNUSED)
+{
+ /* Don't try dereferencing m! */
+ assert(m == (Method*)1);
+
+ /* checkBufSize() done in caller. */
+ seekm(fp, len);
+ return true;
+}
+
+bool
+addLocalVariables(Method* m, size_t len, classFile* fp, errorInfo *info UNUSED)
+{
+ /* Don't try dereferencing m! */
+ assert(m == (Method*)1);
+
+ /* checkBufSize() done in caller. */
+ seekm(fp, len);
+ return true;
+}
+
+bool
+addCheckedExceptions(Method* m, size_t len, classFile* fp,
*** Patch too long, truncated ***
_______________________________________________
kaffe mailing list
[email protected]
http://kaffe.org/cgi-bin/mailman/listinfo/kaffe
