X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=src%2Fnative%2Fnative.h;h=07dc02ab2d451246cb4eac082fe6e080004c4377;hb=522064a81ec9c9dab4f15963c00d91ff71713ed0;hp=f60b6972191e6c3a1031cfa5f9c9be0be53c9b0c;hpb=5bc68e8c5cb6809f0fe7cd1c7cf2a647605d56d1;p=cacao.git diff --git a/src/native/native.h b/src/native/native.h index f60b69721..07dc02ab2 100644 --- a/src/native/native.h +++ b/src/native/native.h @@ -1,90 +1,225 @@ -/****************************** native.h *************************************** +/* src/native/native.h - table of native functions - Copyright (c) 1997 A. Krall, R. Grafl, M. Gschwind, M. Probst + Copyright (C) 1996-2005 R. Grafl, A. Krall, C. Kruegel, C. Oates, + R. Obermaisser, M. Platter, M. Probst, S. Ring, E. Steiner, + C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich, J. Wenninger, + Institut f. Computersprachen - TU Wien - See file COPYRIGHT for information on usage and disclaimer of warranties + This file is part of CACAO. - Contains the codegenerator for an Alpha processor. - This module generates Alpha machine code for a sequence of - pseudo commands (PCMDs). + 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. - Authors: Reinhard Grafl EMAIL: cacao@complang.tuwien.ac.at + 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. - Last Change: 1997/03/12 + 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. -*******************************************************************************/ + Contact: cacao@complang.tuwien.ac.at -/* Java Native Interface */ -#include "jni.h" + Authors: Reinhard Grafl -/* structure for class java.lang.String */ -struct java_lang_String; + Changes: Christian Thalinger -/* for raising exceptions from native methods */ -extern java_objectheader* exceptionptr; + $Id: native.h 2707 2005-06-15 13:40:36Z twisti $ -/* javastring-hashtable */ -extern hashtable string_hash; +*/ -/* load classes required for native methods */ -void native_loadclasses (); -/* set searchpath for classfiles */ -void native_setclasspath (char *path); +#ifndef _NATIVE_H +#define _NATIVE_H + +#if !defined(STATIC_CLASSPATH) +# include "libltdl/ltdl.h" +#endif + +#include "vm/class.h" +#include "vm/global.h" +#include "vm/method.h" +#include "vm/utf8.h" +#include "native/jni.h" +#include "native/include/java_lang_String.h" +#include "native/include/java_lang_ClassLoader.h" +#include "native/include/java_lang_Throwable.h" + + +/* table for locating native methods */ + +typedef struct nativeref nativeref; +typedef struct nativecompref nativecompref; + + +#if !defined(STATIC_CLASSPATH) +typedef struct library_hash_loader_entry library_hash_loader_entry; +typedef struct library_hash_name_entry library_hash_name_entry; + +/* library_hash_loader_entry **************************************************/ + +struct library_hash_loader_entry { + java_objectheader *loader; /* class loader */ + library_hash_name_entry *namelink;/* libraries loaded by this loader */ + library_hash_loader_entry *hashlink;/* link for external chaining */ +}; -/* find native function */ -functionptr native_findfunction (utf *cname, utf *mname, - utf *desc, bool isstatic); -/* creates a new object of type java/lang/String from a utf-text */ -java_objectheader *javastring_new (utf *text); +/* library_hash_name_entry ****************************************************/ -/* creates a new object of type java/lang/String from a c-string */ -java_objectheader *javastring_new_char (char *text); +struct library_hash_name_entry { + utf *name; /* library name */ + lt_dlhandle handle; /* libtool library handle */ + library_hash_name_entry *hashlink; /* link for external chaining */ +}; +#endif + + +struct nativeref { + char *classname; + char *methodname; + char *descriptor; + bool isstatic; + functionptr func; +}; + +/* table for fast string comparison */ + +struct nativecompref { + utf *classname; + utf *methodname; + utf *descriptor; + bool isstatic; + functionptr func; +}; + + +void use_class_as_object(classinfo *c); + +/* initialize native subsystem */ +bool native_init(void); + +/* find native function */ +functionptr native_findfunction(utf *cname, utf *mname, + utf *desc, bool isstatic); -/* make c-string from a javastring (debugging) */ -char *javastring_tochar (java_objectheader *s); +#if !defined(STATIC_CLASSPATH) +/* add a library to the library hash */ +void native_library_hash_add(utf *filename, java_objectheader *loader, + lt_dlhandle handle); + +/* resolve native function */ +functionptr native_resolve_function(methodinfo *m); +#endif /* create new object on the heap and call the initializer */ -java_objectheader *native_new_and_init (classinfo *c); +java_objectheader *native_new_and_init(classinfo *c); + +/* create new object on the heap and call the initializer + mainly used for exceptions with a message */ +java_objectheader *native_new_and_init_string(classinfo *c, java_lang_String *s); + +/* create new object on the heap and call the initializer + mainly used for exceptions with an index */ +java_objectheader *native_new_and_init_int(classinfo *c, s4 i); -/* add property to system-property vector */ -void attach_property(char *name, char *value); +/* create new object on the heap and call the initializer + mainly used for exceptions with cause */ +java_objectheader *native_new_and_init_throwable(classinfo *c, java_lang_Throwable *t); + +/* add property to temporary property list -- located in nat/VMRuntime.c */ +void create_property(char *key, char *value); /* correct vftbl-entries of javastring-hash */ void stringtable_update(); -/* throw classnotfoundexcetion */ -void throw_classnotfoundexception(); -/* make utf symbol from javastring */ -utf *javastring_toutf(struct java_lang_String *string, bool isclassname); +/* search 'classinfo'-structure for a field with the specified name */ +fieldinfo *class_findfield_approx(classinfo *c, utf *name); +s4 class_findfield_index_approx(classinfo *c, utf *name); -/* make utf symbol from u2 array */ -utf *utf_new_u2(u2 *unicodedata, u4 unicodelength, bool isclassname); +void copy_vftbl(vftbl_t **dest, vftbl_t *src); -/* determine utf length in bytes of a u2 array */ -u4 u2_utflength(u2 *text, u4 u2_length); +utf *create_methodsig(java_objectarray* types, char *retType); +classinfo *get_type(char **utf_ptr,char *desc_end, bool skip); +java_objectarray* get_parametertypes(methodinfo *m); +java_objectarray* get_exceptiontypes(methodinfo *m); +classinfo *get_returntype(methodinfo *m); -/* create systemclassloader object and initialize its instance fields */ -void init_systemclassloader(); -/* search 'classinfo'-structure for a field with the specified name */ -fieldinfo *class_findfield_approx (classinfo *c, utf *name); +/*----- For Static Analysis of Natives by parseRT -----*/ + +/*---------- global variables ---------------------------*/ +typedef struct classMeth classMeth; +typedef struct nativeCall nativeCall; +typedef struct methodCall methodCall; +typedef struct nativeMethod nativeMethod; + +typedef struct nativeCompCall nativeCompCall; +typedef struct methodCompCall methodCompCall; +typedef struct nativeCompMethod nativeCompMethod; + +/*---------- Define Constants ---------------------------*/ +#define MAXCALLS 30 + +struct classMeth { + int i_class; + int j_method; + int methCnt; +}; + +struct methodCall{ + char *classname; + char *methodname; + char *descriptor; +}; + +struct nativeMethod { + char *methodname; + char *descriptor; + struct methodCall methodCalls[MAXCALLS]; +}; + + +struct nativeCall { + char *classname; + struct nativeMethod methods[MAXCALLS]; + int methCnt; + int callCnt[MAXCALLS]; +}; + + +struct methodCompCall { + utf *classname; + utf *methodname; + utf *descriptor; +}; + + +struct nativeCompMethod { + utf *methodname; + utf *descriptor; + struct methodCompCall methodCalls[MAXCALLS]; +}; -/* creates a new javastring with the text of the utf-symbol */ -java_objectheader *literalstring_new (utf *u); -/* creates a new javastring with the text of the u2-array */ -java_objectheader *literalstring_u2 (java_chararray *a, u4 length, bool copymode); +struct nativeCompCall { + utf *classname; + struct nativeCompMethod methods[MAXCALLS]; + int methCnt; + int callCnt[MAXCALLS]; +}; -/* dispose a javastring */ -void literalstring_free (java_objectheader*); -void systemclassloader_addlibname(java_objectheader *o); -void systemclassloader_addlibrary(java_objectheader *o); +bool natcall2utf(bool); +void printNativeCall(nativeCall); +void markNativeMethodsRT(utf *, utf* , utf* ); -void copy_vftbl(vftbl **dest, vftbl *src); +#endif /* _NATIVE_H */ /*