X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=headers.c;h=038ccffc89354849a1e185523648a8dc1dfd2178;hb=2ffcaa73cddc90a880868b80f0d39e9502976ae6;hp=92ae368980688a997af9bbb3e99e7e7421b795e6;hpb=ef6fd21b1ad92804db1cd9c05d078b71589a3122;p=cacao.git

diff --git a/headers.c b/headers.c
index 92ae36898..038ccffc8 100644
--- a/headers.c
+++ b/headers.c
@@ -1,469 +1,574 @@
-/* -*- mode: c; tab-width: 4; c-basic-offset: 4 -*- */
-/****************************** headers.c **************************************
+/* headers.c - functions for header generation
 
-	Copyright (c) 1997 A. Krall, R. Grafl, M. Gschwind, M. Probst
+   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
+   R. Grafl, A. Krall, C. Kruegel, C. Oates, R. Obermaisser,
+   M. Probst, S. Ring, E. Steiner, C. Thalinger, D. Thuernbeck,
+   P. Tomsich, J. Wenninger
 
-	See file COPYRIGHT for information on usage and disclaimer of warranties
+   This file is part of CACAO.
 
-	Dieser Modul ersetzt f"ur den Headerfile-Betrieb den Modul 'main',
-	und 'f"alscht' einige Verweise auf externe Module (damit nicht schon 
-	alle Module des eigentlichen Programmes fertig sein m"ussen, was ja
-	unm"oglich w"are, da die Headerfile-Tabellen ja erst hier und jetzt
-	generiert werden).
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2, or (at
+   your option) any later version.
 
-	Dieser Modul ist ein ziemlich schneller Hack und dementsprechend
-	schlecht (nicht) kommentiert.
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
 
-	Authors: Reinhard Grafl      EMAIL: cacao@complang.tuwien.ac.at
-	Changes: Mark Probst         EMAIL: cacao@complang.tuwien.ac.at
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+   02111-1307, USA.
 
-	Last Change: 1997/05/23
+   Contact: cacao@complang.tuwien.ac.at
 
-*******************************************************************************/
+   Authors: Reinhard Grafl
 
-#include "global.h"
+   Changes: Mark Probst
+            Philipp Tomsich
+            Christian Thalinger
+
+   $Id: headers.c 1368 2004-08-01 21:50:08Z stefan $
+
+*/
 
+
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include "config.h"
+#include "global.h"
 #include "tables.h"
 #include "loader.h"
+#include "options.h"
+#include "builtin.h"
+#include "mm/boehm.h"
+#include "toolbox/chain.h"
+#include "toolbox/memory.h"
+#include "toolbox/logging.h"
+#include "nat/java_lang_String.h"
+#include "nat/java_lang_Throwable.h"
 
 
-/******* verschiedene externe Funktionen "faelschen" (=durch Dummys ersetzen), 
-  damit der Linker zufrieden ist *********/
+/******* replace some external functions  *********/
  
-functionptr native_findfunction 
-  (unicode *cname, unicode *mname, unicode *desc, bool isstatic)
+functionptr native_findfunction(utf *cname, utf *mname, utf *desc, bool isstatic)
 { return NULL; }
 
-java_objectheader *literalstring_new (unicode *text)
-{ return NULL; }
+java_objectheader *javastring_new(utf *text) { return NULL; }
+java_objectheader *javastring_new_char(char *text) { return NULL; }
 
-java_objectheader *javastring_new (unicode *text)         /* schani */
+char *javastring_tochar(java_objectheader *so) { return NULL; }
+utf *javastring_toutf(java_lang_String *string, bool isclassname)
 { return NULL; }
 
+
+java_objectheader *native_new_and_init(classinfo *c) { return NULL; }
+java_objectheader *native_new_and_init_string(classinfo *c, java_lang_String *s) { return NULL; }
+java_objectheader *native_new_and_init_int(classinfo *c, s4 i) { return NULL; }
+java_objectheader *native_new_and_init_throwable(classinfo *c, java_lang_Throwable *t) { return NULL; }
+
+java_objectheader *literalstring_new(utf *u) { return NULL; }  
+
+
+void literalstring_free(java_objectheader *o) {}
+void stringtable_update() { }
 void synchronize_caches() { }
-void asm_call_jit_compiler () { }
-void asm_calljavamethod () { }
-void asm_dumpregistersandcall () { }
+void asm_call_jit_compiler() { }
+void asm_calljavafunction() { }
+s4 asm_builtin_checkcast(java_objectheader *obj, classinfo *class) { return 0; }
 
-s4 new_builtin_idiv (s4 a, s4 b) {return 0;}
-s4 new_builtin_irem (s4 a, s4 b) {return 0;}
-s8 new_builtin_ldiv (s8 a, s8 b) {return 0;}
-s8 new_builtin_lrem (s8 a, s8 b) {return 0;}
+s4 asm_builtin_idiv(s4 a, s4 b) {return 0;}
+s4 asm_builtin_irem(s4 a, s4 b) {return 0;}
+s8 asm_builtin_ldiv(s8 a, s8 b) {return 0;}
+s8 asm_builtin_lrem(s8 a, s8 b) {return 0;}
 
+s4 asm_builtin_f2i(float a) { return 0; }
+s8 asm_builtin_f2l(float a) { return 0; }
+s4 asm_builtin_d2i(double a) { return 0; }
+s8 asm_builtin_d2l(double a) { return 0; }
 
-void new_builtin_monitorenter (java_objectheader *o) {}
-void new_builtin_monitorexit (java_objectheader *o) {}
+void use_class_as_object() {}
+void asm_builtin_monitorenter(java_objectheader *o) {}
+void *asm_builtin_monitorexit(java_objectheader *o) {}
 
-s4 new_builtin_checkcast(java_objectheader *o, classinfo *c)
-                        {return 0;}
-s4 new_builtin_checkclasscast(java_objectheader *o, classinfo *c)
-                        {return 0;}
-s4 new_builtin_checkintercast(java_objectheader *o, classinfo *c)
-                        {return 0;}
-s4 new_builtin_checkarraycast
-	(java_objectheader *o, constant_arraydescriptor *d)
-	{return 0;}
+s4 asm_builtin_checkarraycast(java_objectheader *obj, vftbl_t *target) {return 0;}
 
-void new_builtin_aastore (java_objectarray *a, s4 index, java_objectheader *o) {}
+#if defined(__MIPS__)
+long compare_and_swap(long *p, long oldval, long newval)
+{
+	if (*p == oldval) {
+		*p = newval;
+		return oldval;
+	} else
+		return *p;
+}
+#endif
 
-u1 *createcompilerstub (methodinfo *m) {return NULL;}
-u1 *createnativestub (functionptr f, methodinfo *m) {return NULL;}
-u1 *ncreatenativestub (functionptr f, methodinfo *m) {return NULL;}
 
-void removecompilerstub (u1 *stub) {}
-void removenativestub (u1 *stub) {}
+#if defined(__I386__)
+s4 asm_builtin_arrayinstanceof(java_objectheader *obj, classinfo *class) { return 0; }
+void asm_builtin_newarray(s4 size, vftbl_t *arrayvftbl) {}
+#endif
 
-void perform_alpha_threadswitch (u1 **from, u1 **to) {}
-u1* initialize_thread_stack (void *func, u1 *stack) { return NULL; }
-void asm_switchstackandcall () { }
+void asm_builtin_aastore(java_objectarray *a, s4 index, java_objectheader *o) {}
 
-java_objectheader *native_new_and_init (void *p) { return NULL; }
+u1 *createcompilerstub(methodinfo *m) {return NULL;}
+u1 *createnativestub(functionptr f, methodinfo *m) {return NULL;}
+u1 *oldcreatenativestub(functionptr f, methodinfo *m) {return NULL;}
 
-/************************ globale Variablen **********************/
+void removecompilerstub(u1 *stub) {}
+void removenativestub(u1 *stub) {}
 
-java_objectheader *exceptionptr;                       /* schani */
-int  newcompiler = true;
-bool verbose =  false;
+void asm_perform_threadswitch(u1 **from, u1 **to, u1 **stackTop) {}
+u1* asm_initialize_thread_stack(void *func, u1 *stack) { return NULL; }
+void thread_restartcriticalsection() {}
+void asm_switchstackandcall() {}
+void asm_handle_builtin_exception(classinfo *c) {}
+void asm_getclassvalues_atomic() {}
 
-static chain *nativechain;
-static FILE *file = NULL;
+#if defined(__DARWIN__)
+int cacao_catch_Handler() {}
+#endif
 
-static void printIDpart (int c) 
-{
-		if (     (c>='a' && c<='z')
-		      || (c>='A' && c<='Z')
-		      || (c>='0' && c<='9')
-		      || (c=='_') )          
-		           putc (c,file);
-        else       putc ('_',file);
+#if defined(USE_THREADS) && defined(NATIVE_THREADS)
+threadcritnode asm_criticalsections;
+#endif
+
+
+/************************ global variables **********************/
+
+THREADSPECIFIC java_objectheader *_exceptionptr;
+
+chain *nativemethod_chain;              /* chain with native methods          */
+chain *nativeclass_chain;               /* chain with processed classes       */
+static chain *ident_chain; /* chain with method and field names in current class */
+FILE *file = NULL;
+static u4 outputsize;
+static bool dopadding;
 
+
+static void printIDpart(int c) 
+{
+	if ((c >= 'a' && c <= 'z')
+		|| (c >= 'A' && c <= 'Z')
+		|| (c >= '0' && c <= '9')
+		|| (c == '_'))
+		putc(c, file);
+	else
+		putc('_', file);
 }
 
-static void printID (unicode *name)
+
+static void printID(utf *u)
 {
+	char *utf_ptr = u->text;
 	int i;
-	for (i=0; i<name->length; i++) {
-		printIDpart (name->text[i]);
-    	}
-}
 
+	for (i = 0; i < utf_strlen(u); i++) 
+		printIDpart(utf_nextu2(&utf_ptr));
+}
 
-u4 outputsize;
-bool dopadding;
 
 static void addoutputsize (int len)
 {
 	u4 newsize,i;
 	if (!dopadding) return;
 
-	newsize = ALIGN (outputsize, len);
+	newsize = ALIGN(outputsize, len);
 	
-	for (i=outputsize; i<newsize; i++) fprintf (file, "   u1 pad%d\n",(int) i);
+	for (i = outputsize; i < newsize; i++) fprintf(file, "   u1 pad%d\n", (int) i);
 	outputsize = newsize;
 }
 
+static void printOverloadPart(utf *desc)
+{
+	char *utf_ptr=desc->text;
+	u2 c;
 
-static u2 *printtype (u2 *desc)
+	fprintf(file,"__");
+	while ((c=utf_nextu2(&utf_ptr))!=')') {
+		switch (c) {
+			case 'I':
+			case 'S':
+			case 'B':
+			case 'C':
+			case 'Z':
+			case 'J':
+			case 'F':
+			case 'D': 
+				fprintf (file, "%c",(char)c);
+				break;
+			case '[':
+				fprintf(file,"_3");
+                           	break;
+			case 'L':
+				putc('L',file);
+				while ( (c=utf_nextu2(&utf_ptr)) != ';')
+					printIDpart (c);
+				fprintf(file,"_2");
+				break;
+			case '(':
+				break;
+			default: panic ("invalid method descriptor");
+		}
+	}
+}
+
+static char *printtype(char *utf_ptr)
 {
 	u2 c;
 
-	switch (*(desc++)) {
-		case 'V': fprintf (file, "void");
-		          break;
-		case 'I':
-		case 'S':
-		case 'B':
-		case 'C':
-		case 'Z': addoutputsize (4);
-                  fprintf (file, "s4");
-                  break;
-		case 'J': addoutputsize (8);
-                  fprintf (file, "s8");
-                  break;
-		case 'F': addoutputsize (4);
-                  fprintf (file, "float");
-                  break;
-		case 'D': addoutputsize (8);
-                  fprintf (file, "double");
-                  break;
-		case '[':
-			addoutputsize ( sizeof(java_arrayheader*) ); 
-			switch (*(desc++)) {
-				case 'I':  fprintf (file, "java_intarray*"); break;
-				case 'J':  fprintf (file, "java_longarray*"); break;
-				case 'Z':  fprintf (file, "java_booleanarray*"); break;
-				case 'B':  fprintf (file, "java_bytearray*"); break;
-				case 'S':  fprintf (file, "java_shortarray*"); break;
-				case 'C':  fprintf (file, "java_chararray*"); break;
-				case 'F':  fprintf (file, "java_floatarray*"); break;
-				case 'D':  fprintf (file, "java_doublearray*"); break;
+	switch (utf_nextu2(&utf_ptr)) {
+	case 'V': fprintf (file, "void");
+		break;
+	case 'I':
+	case 'S':
+	case 'B':
+	case 'C':
+	case 'Z': addoutputsize (4);
+		fprintf (file, "s4");
+		break;
+	case 'J': addoutputsize (8);
+		fprintf (file, "s8");
+		break;
+	case 'F': addoutputsize (4);
+		fprintf (file, "float");
+		break;
+	case 'D': addoutputsize (8);
+		fprintf (file, "double");
+		break;
+	case '[':
+		addoutputsize ( sizeof(java_arrayheader*) ); 
+		switch (utf_nextu2(&utf_ptr)) {
+		case 'I':  fprintf (file, "java_intarray*"); break;
+		case 'J':  fprintf (file, "java_longarray*"); break;
+		case 'Z':  fprintf (file, "java_booleanarray*"); break;
+		case 'B':  fprintf (file, "java_bytearray*"); break;
+		case 'S':  fprintf (file, "java_shortarray*"); break;
+		case 'C':  fprintf (file, "java_chararray*"); break;
+		case 'F':  fprintf (file, "java_floatarray*"); break;
+		case 'D':  fprintf (file, "java_doublearray*"); break;
 				
-				case '[':  fprintf (file, "java_arrayarray*");
-				           while ((*desc) == '[') desc++;
-				           if ((*desc)!='L') desc++;
-				           else while (*(desc++) != ';');
-                           break;
+		case '[':  fprintf (file, "java_objectarray*");					       
+			while ((c = utf_nextu2(&utf_ptr)) == '[') ;
+			if (c=='L') 
+				while (utf_nextu2(&utf_ptr) != ';');
+			break;
                            
-				case 'L':  fprintf (file, "java_objectarray*");
-				           while ( *(desc++) != ';');
-				           break;
-				default: panic ("invalid type descriptor");
-				}
+		case 'L':  fprintf (file, "java_objectarray*");
+			while ( utf_nextu2(&utf_ptr) != ';');
 			break;
+		default: panic ("invalid type descriptor");
+		}
+		break;
 		
-		case 'L': 
-			addoutputsize ( sizeof(java_objectheader*));
-            fprintf (file, "struct ");
-            while ( (c = *(desc++)) != ';' ) printIDpart (c);   	 
-            fprintf (file, "*");
-			break;
+	case 'L': 
+		addoutputsize ( sizeof(java_objectheader*));
+		fprintf (file, "struct ");
+		while ( (c = utf_nextu2(&utf_ptr)) != ';' ) printIDpart (c);   	 
+		fprintf (file, "*");
+		break;
 					
-		default:  panic ("Unknown type in field descriptor");
+	default:  panic ("Unknown type in field descriptor");
 	}
 	
-	return (desc);
+	return utf_ptr;
 }
 
 
+/***** determine the number of entries of a utf string in the ident chain *****/
 
-static void printfields (classinfo *c)
+static int searchidentchain_utf(utf *ident) 
+{
+	utf *u = chain_first(ident_chain);     /* first element of list */
+	int count = 0;
+
+	while (u) {
+		if (u==ident) count++;         /* string found */
+		u = chain_next(ident_chain);   /* next element in list */ 
+	}
+
+	return count;
+}
+
+
+/************** print structure for direct access to objects ******************/
+
+static void printfields(classinfo *c)
 {
 	u4 i;
 	fieldinfo *f;
+	int ident_count;
 	
 	if (!c) {
-		addoutputsize ( sizeof(java_objectheader) );
-		fprintf (file, "   java_objectheader header;\n");
+		addoutputsize(sizeof(java_objectheader));
+		fprintf(file, "   java_objectheader header;\n");
 		return;
-		}
+	}
 		
-	printfields (c->super);
+	printfields(c->super);
 	
-	for (i=0; i<c->fieldscount; i++) {
+	for (i = 0; i < c->fieldscount; i++) {
 		f = &(c->fields[i]);
 		
-		if (! (f->flags & ACC_STATIC) ) {
-			fprintf (file,"   ");
-			printtype (f->descriptor->text);
-			fprintf (file, " ");
-			unicode_fprint (file, f->name);
-			fprintf (file, ";\n");
-			}
-		}
-}
-
-
-
-
-static void remembermethods (classinfo *c)
-{
-	u2 i;
-	methodinfo *m;
-
-	for (i=0; i<c->methodscount; i++) {
-		m = &(c->methods[i]);
-
-		if (m->flags & ACC_NATIVE) {
-			chain_addlast (nativechain, m);
-			}
-					
+		if (!(f->flags & ACC_STATIC)) {
+			fprintf(file, "   ");
+			printtype(f->descriptor->text);
+			fprintf(file, " ");
+			utf_fprint(file, f->name);
+
+			/* rename multiple fieldnames */
+			if ((ident_count = searchidentchain_utf(f->name)))
+				fprintf(file, "%d", ident_count - 1);
+			chain_addlast(ident_chain, f->name);	
+
+			fprintf(file, ";\n");
 		}
+	}
 }
 
 
+/***************** store prototype for native method in file ******************/
 
-
-static void printmethod (methodinfo *m)
+void printmethod(methodinfo *m)
 {
-	u2 *d;
-	u2 paramnum=1;
+	char *utf_ptr;
+	u2 paramnum = 1;
+	u2 ident_count;
+
+	/* search for return-type in descriptor */	
+	utf_ptr = m->descriptor->text;
+	while (utf_nextu2(&utf_ptr) != ')');
+
+	/* create remarks */
+	fprintf(file, "\n/*\n * Class:     ");
+	utf_fprint(file, m->class->name);
+	fprintf(file, "\n * Method:    ");
+	utf_fprint(file, m->name);
+	fprintf(file, "\n * Signature: ");
+	utf_fprint(file, m->descriptor);
+	fprintf(file, "\n */\n");	
+
+	/* create prototype */ 			
+	fprintf(file, "JNIEXPORT ");				
+	printtype(utf_ptr);
+	fprintf(file, " JNICALL Java_");
+	printID(m->class->name);           
+
+	chain_addlast(ident_chain, m->name);	
+
+	fprintf(file, "_");
+	printID(m->name);
+	if (m->nativelyoverloaded) printOverloadPart(m->descriptor);
+	fprintf(file, "(JNIEnv *env");
 	
-	d = m->descriptor->text;
-	while (*(d++) != ')');
-				
-	printtype (d);
-	fprintf (file," ");
-	printID (m->class->name);
-	fprintf (file,"_");
-	printID (m->name);
-	fprintf (file," (");
-					
-	d = m->descriptor->text+1;
-			
-	if (! (m->flags & ACC_STATIC) ) {
-		fprintf (file, "struct ");
-		printID (m->class->name);
-		fprintf (file, "* this");
-		if ((*d)!=')') fprintf (file, ", ");
-		}
-			
-	while ((*d)!=')') {
-		d = printtype (d);
-		fprintf (file, " par%d", paramnum++);
-		if ((*d)!=')') fprintf (file, ", ");
-		}
+	utf_ptr = m->descriptor->text + 1;
 			
-	fprintf (file, ");\n");
-}
-
+	if (!(m->flags & ACC_STATIC)) {
+		fprintf(file, ", struct ");
+		printID(m->class->name);
+		fprintf(file, "* this");
 
-static void headers_generate (classinfo *c)
-{
-	fprintf (file, "/* Structure information for class: ");
-	unicode_fprint (file, c->name);
-	fprintf (file, " */\n\n");
-
-	fprintf (file, "typedef struct ");
-	printID (c->name);
-	fprintf (file, " {\n");
-	
-	outputsize=0;
-	dopadding=true;
-	printfields (c);
-
-	fprintf (file, "} ");
-	printID (c->name);
-	fprintf (file, ";\n\n");
-
-	remembermethods (c);
-	
+	} else {
+		fprintf(file, ", jclass clazz");
+	}
 
-	fprintf (file, "\n\n");
+	if ((*utf_ptr) != ')') fprintf(file, ", ");
+			
+	while ((*utf_ptr) != ')') {
+		utf_ptr = printtype(utf_ptr);
+		fprintf(file, " par%d", paramnum++);
+		if ((*utf_ptr)!=')') fprintf(file, ", ");
+	}
+			
+	fprintf(file, ");\n\n");
 }
 
 
+/******* remove package-name in fully-qualified classname *********************/
 
-static void printnativetableentry (methodinfo *m)
+void gen_header_filename(char *buffer, utf *u)
 {
-	fprintf (file, "   { \"");
-	unicode_fprint (file, m->class->name);
-	fprintf (file, "\",\n     \"");
-	unicode_fprint (file, m->name);
-	fprintf (file, "\",\n     \"");
-	unicode_fprint (file, m->descriptor);
-	fprintf (file, "\",\n     ");
-	if ( (m->flags & ACC_STATIC) !=0)  fprintf (file, "true");
-	                              else fprintf (file, "false");
-	fprintf (file, ",\n     ");
-	fprintf (file, "(functionptr) ");
-	printID (m->class->name);
-	fprintf (file,"_");
-	printID (m->name);
-	fprintf (file,"\n   },\n");
+	s4 i;
+  
+	for (i = 0; i < utf_strlen(u); i++) {
+		if ((u->text[i] == '/') || (u->text[i] == '$')) {
+			buffer[i] = '_';  /* convert '$' and '/' to '_' */
+
+		} else {
+			buffer[i] = u->text[i];
+		}
+	}
+	buffer[utf_strlen(u)] = '\0';
 }
 
 
+/* create headerfile for classes and store native methods in chain ************/
 
-
-
-static void headers_start ()
+void headerfile_generate(classinfo *c)
 {
-	file = fopen ("nativetypes.hh", "w");
-	if (!file) panic ("Can not open file 'native.h' to store header information");
+	char header_filename[1024] = "";
+	char classname[1024]; 
+	char uclassname[1024];
+	u2 i;
+	methodinfo *m;	      		
+	u2 i2;
+	methodinfo *m2;
+	u2 nativelyoverloaded;	      		
+		      
+	/* store class in chain */		      
+	chain_addlast(nativeclass_chain, c);
+			    	
+	/* open headerfile for class */
+	gen_header_filename(classname, c->name);
+
+	/* create chain for renaming fields */
+	ident_chain = chain_new();
 	
-	fprintf (file, "/* Headerfile for native methods: nativetypes.hh */\n");
-	fprintf (file, "/* This file is machine generated, don't edit it !*/\n\n"); 
-
-	nativechain = chain_new ();
-}
+	sprintf(header_filename, "nat/%s.h", classname);
+   	file = fopen(header_filename, "w");
+   	if (!file) panic("Can not open file to store header information");
 
+   	fprintf(file, "/* This file is machine generated, don't edit it !*/\n\n");
 
-static void headers_finish ()
-{
-	methodinfo *m;
-	
-	fprintf (file, "\n/* Prototypes for native methods */\n\n");
-	
-	m = chain_first (nativechain);
-	while (m) {
-		dopadding=false;		
-		printmethod (m);
-		
-		m = chain_next (nativechain);
-		}
+	/* convert to uppercase */
+	for (i = 0; classname[i]; i++) {
+		uclassname[i] = toupper(classname[i]);
+	}
+	uclassname[i] = '\0';
 
+	fprintf(file, "#ifndef _%s_H\n#define _%s_H\n\n", uclassname, uclassname);
 
-	file = fopen ("nativetable.hh", "w");
-	if (!file) panic ("Can not open file 'nativetable' to store native-link-table");
+	/* create structure for direct access to objects */	
+	fprintf(file, "/* Structure information for class: ");
+	utf_fprint(file, c->name);
+	fprintf(file, " */\n\n");
+	fprintf(file, "typedef struct ");
+	printID(c->name);							
+	fprintf(file, " {\n");
+	outputsize = 0;
+	dopadding = true;
 
-	fprintf (file, "/* Table of native methods: nativetables.hh */\n");
-	fprintf (file, "/* This file is machine generated, don't edit it !*/\n\n"); 
+	printfields(c);
 
-	while ( (m = chain_first (nativechain)) != NULL) {
-		chain_remove (nativechain);
-		
-		printnativetableentry (m);
-		
-		}
-		
-	chain_free (nativechain);
-	fclose (file);
-}
+	fprintf(file, "} ");
+	printID(c->name);
+	fprintf(file, ";\n\n");
 
+	/* create chain for renaming overloaded methods */
+	chain_free(ident_chain);
+	ident_chain = chain_new();
 
+	/* create method-prototypes */
+		      		
+	/* find overloaded methods */
+	for (i = 0; i < c->methodscount; i++) {
 
+		m = &(c->methods[i]);
 
+		if (!(m->flags & ACC_NATIVE)) continue;
+		if (!m->nativelyoverloaded) {
+			nativelyoverloaded=false;
+			for (i2=i+1;i2<c->methodscount; i2++) {
+				m2 = &(c->methods[i2]);
+				if (!(m2->flags & ACC_NATIVE)) continue;
+				if (m->name==m2->name) {
+					m2->nativelyoverloaded=true;
+					nativelyoverloaded=true;
+				}
+			}
+			m->nativelyoverloaded=nativelyoverloaded;
+		}
 
-/******************** interne Funktion: print_usage ************************
+	}
 
-Gibt die richtige Aufrufsyntax des JAVA-Header-Generators auf stdout aus.
+	for (i = 0; i < c->methodscount; i++) {
 
-***************************************************************************/
+		m = &(c->methods[i]);
 
-static void print_usage()
-{
-	printf ("USAGE: jch class [class..]\n");
-}   
+		if (m->flags & ACC_NATIVE) {
+			chain_addlast(nativemethod_chain, m);
+			printmethod(m);
+		}
+	}
 
+	chain_free(ident_chain);
 
+	fprintf(file, "#endif\n\n");
 
+   	fclose(file);
+}
 
-/************************** Funktion: main *******************************
 
-   Das Hauptprogramm.
-   Wird vom System zu Programstart aufgerufen (eh klar).
-   
-**************************************************************************/
+/******** print classname, '$' used to seperate inner-class name ***********/
 
-int main(int argc, char **argv)
+void print_classname(classinfo *clazz)
 {
-	s4 i,a;
-	char *cp;
-	classinfo *topclass;
-	void *dummy;
-		
-
-   /********** interne (nur fuer main relevante Optionen) **************/
-   
-	char classpath[500] = "";
-	u4 heapsize = 100000;
-
-   /*********** Optionen, damit wirklich nur headers generiert werden ***/
-   
-   makeinitializations=false;
-   
+	utf *u = clazz->name;
+    char *endpos  = u->text + u->blength;
+    char *utf_ptr = u->text; 
+	u2 c;
 
-   /************ Infos aus der Environment lesen ************************/
+    while (utf_ptr < endpos) {
+		if ((c = utf_nextu2(&utf_ptr)) == '_') {
+			putc('$', file);
 
-	cp = getenv ("CLASSPATH");
-	if (cp) {
-		strcpy (classpath + strlen(classpath), ":");
-		strcpy (classpath + strlen(classpath), cp);
+		} else {
+			putc(c, file);
 		}
+	}
+} 
 
-	if (argc < 2) {
-   		print_usage ();
-   		exit(10);
-   		}
-
-
-   /**************************** Programmstart *****************************/
-
-	log_init (NULL);
-	log_text ("Java - header-generator started");
-	
-	
-	suck_init (classpath);
-	
-	unicode_init ();
-	heap_init (heapsize, heapsize, &dummy);
-	loader_init ();
-
-
-   /*********************** JAVA-Klassen laden  ***************************/
-   
-	headers_start ();
-
-	
-	for (a=1; a<argc; a++) {   
-   		cp = argv[a];
-   		for (i=strlen(cp)-1; i>=0; i--) {     /* Punkte im Klassennamen */
- 	  		if (cp[i]=='.') cp[i]='/';        /* auf slashes umbauen */
-  	 		}
-
-		topclass = loader_load ( unicode_new_char (cp) );
-		
-		headers_generate (topclass);
-		}
-	
 
-	headers_finish ();
+/*************** create table for locating native functions ****************/
 
+void printnativetableentry(methodinfo *m)
+{
+	fprintf(file, "   { \"");
+	print_classname(m->class);
+	fprintf(file, "\",\n     \"");
+	utf_fprint(file, m->name);
+	fprintf(file, "\",\n     \"");
+	utf_fprint(file, m->descriptor);
+	fprintf(file, "\",\n     ");
+
+	if ((m->flags & ACC_STATIC) != 0)
+		fprintf(file, "true");
+	else
+		fprintf(file, "false");
+
+	fprintf(file, ",\n     ");
+	fprintf(file, "(functionptr) Java_");
+	printID(m->class->name);
+	fprintf(file,"_");
+	printID(m->name);
+	if (m->nativelyoverloaded) printOverloadPart(m->descriptor);
+	fprintf(file,"\n   },\n");
+}
 
-   /************************ Freigeben aller Resourcen *******************/
 
-	loader_close ();
-	heap_close ();
-	unicode_close (NULL);
-	
+void setVMClassField(classinfo *c)
+{
+}
 
-   /* Endemeldung ausgeben und mit entsprechendem exit-Status terminieren */
 
-	log_text ("Java - header-generator stopped");
-	log_cputime ();
-	mem_usagelog(1);
-	
+void *Java_java_lang_VMObject_clone(void *env, void *clazz, void * this) {
 	return 0;
 }
 
 
+/*
+ * These are local overrides for various environment variables in Emacs.
+ * Please do not remove this and leave it at the end of the file, where
+ * Emacs will automagically detect them.
+ * ---------------------------------------------------------------------
+ * Local variables:
+ * mode: c
+ * indent-tabs-mode: t
+ * c-basic-offset: 4
+ * tab-width: 4
+ * End:
+ */