home *** CD-ROM | disk | FTP | other *** search
/ PC World 1998 October / PCWorld_1998-10_cd.bin / software / prehled / inprise / JRUNTIME.Z / interpreter.h < prev    next >
C/C++ Source or Header  |  1998-05-08  |  21KB  |  644 lines
  1. // $Header: z:/admin/jb20_jdk116x.English/javasrc/src/share/java/include/rcs/interpreter.h 1.1 1998/04/17 23:02:52 bstone Exp $ 
  2. /*
  3.  * @(#)interpreter.h    1.119 98/02/10
  4.  * 
  5.  * Copyright (c) 1995, 1996 Sun Microsystems, Inc. All Rights Reserved.
  6.  * 
  7.  * This software is the confidential and proprietary information of Sun
  8.  * Microsystems, Inc. ("Confidential Information").  You shall not
  9.  * disclose such Confidential Information and shall use it only in
  10.  * accordance with the terms of the license agreement you entered into
  11.  * with Sun.
  12.  * 
  13.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  14.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  15.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  16.  * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
  17.  * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
  18.  * THIS SOFTWARE OR ITS DERIVATIVES.
  19.  * 
  20.  * CopyrightVersion 1.1_beta
  21.  * 
  22.  */
  23.  
  24. /*
  25.  * Definitions for the interperter    6/27/91
  26.  */
  27.  
  28. #ifndef _INTERPRETER_H_
  29. #define _INTERPRETER_H_
  30.  
  31. #include <stdio.h>
  32. #include <stdlib.h>
  33. #include <string.h>
  34.  
  35. #include "bool.h"
  36. #include "config.h"
  37. #include "jni.h"
  38. #include "alloc_cache.h"
  39.  
  40. extern char *progname;
  41. extern bool_t debugging;
  42. extern bool_t verbose;
  43. extern bool_t verbosegc;
  44. extern bool_t noasyncgc;
  45. extern bool_t classgc;
  46.  
  47. extern ClassClass *classJavaLangClass;       /* class java/lang/Class */
  48. extern ClassClass *classJavaLangObject;       /* class java/lang/Object */
  49. extern ClassClass *classJavaLangString;       /* class java/lang/String */
  50.  
  51. extern ClassClass *classJavaLangThrowable;
  52. extern ClassClass *classJavaLangException;
  53. extern ClassClass *classJavaLangError;
  54. extern ClassClass *classJavaLangRuntimeException;
  55. extern ClassClass *classJavaLangThreadDeath;
  56.  
  57. extern ClassClass *interfaceJavaLangCloneable; /* class java/lang/Cloneable */
  58. extern ClassClass *interfaceJavaIoSerializable; /* class java/io/Serializable */
  59.  
  60. enum { VERIFY_NONE, VERIFY_REMOTE, VERIFY_ALL };
  61.  
  62. extern int verifyclasses;
  63.  
  64. #define FINALIZER_METHOD_NAME "finalize"
  65. #define FINALIZER_METHOD_SIGNATURE "()V"
  66.  
  67. #ifdef TRACING
  68.   extern int trace;
  69.   extern int tracem;
  70.   extern void trace_method(struct execenv*, struct methodblock*, int, int);
  71.   enum { TRACE_METHOD_ENTER, TRACE_METHOD_RETURN, TRACE_METHOD_NATIVE_RETURN };
  72. # define TRACE_METHOD(ee, mb, args_size, type) \
  73.       if (tracem) trace_method(ee, mb, args_size, type); else
  74.  
  75. #else
  76. # define trace  0
  77. # define tracem 0
  78. # define TRACE_METHOD(ee, mb, args_size, type) 
  79. #endif
  80.  
  81. extern char * const opnames[];
  82.  
  83. /* Get a constant pool index, from a pc */
  84. #define GET_INDEX(ptr) (((int)((ptr)[0]) << 8) | (ptr)[1])
  85.  
  86. extern char *Object2CString(JHandle *);
  87.  
  88. #define METHOD_FLAG_BITS 5
  89. #define FLAG_MASK       ((1<<METHOD_FLAG_BITS)-1)  /* valid flag bits */
  90. #define METHOD_MASK     (~FLAG_MASK)  /* valid mtable ptr bits */
  91. #define LENGTH_MASK     METHOD_MASK
  92.  
  93. #define obj_flags(o) \
  94.     (((unsigned long) (o)->methods) & FLAG_MASK)
  95. #define obj_length(o)   \
  96.     (((unsigned long) (o)->methods) >> METHOD_FLAG_BITS)
  97.  
  98. #define mkatype(t,l) ((struct methodtable *) (((l) << METHOD_FLAG_BITS)|(t)))
  99. #define atype(m) ((m) & FLAG_MASK)
  100.  
  101.  
  102. #define obj_methodtable(obj) ((obj)->methods)
  103. #define obj_classblock(obj) ((obj)->methods->classdescriptor)
  104.  
  105. #define obj_array_methodtable(obj) \
  106.     ((obj_flags((obj)) == T_NORMAL_OBJECT) ? obj_methodtable((obj))      \
  107.                                            : cbMethodTable(classJavaLangObject))
  108. #define obj_array_classblock(obj) \
  109.     ((obj_flags((obj)) == T_NORMAL_OBJECT) ? (obj)->methods->classdescriptor \
  110.                                            : classJavaLangObject)
  111.  
  112. #define mt_slot(methodtable, slot) (methodtable)->methods[slot]
  113.  
  114. #define uobj_getslot(o, slot) (o)[slot]
  115. #define uobj_setslot(o, slot, v) (uobj_getslot(o, slot) = (v))
  116.  
  117. #define obj_getslot(o, slot) uobj_getslot(unhand(o), slot)
  118. #define obj_setslot(o, slot, v) (obj_getslot(o, slot) = (v))
  119.  
  120. #define obj_monitor(handlep) ((int) handlep)
  121.  
  122.  
  123. struct arrayinfo {
  124.     int index;
  125.     char sig;      /* type signature. */
  126.     char *name;
  127.     int factor;
  128. };
  129.  
  130. typedef union stack_item {
  131.     /* Non pointer items */
  132.     int            i;
  133.     float          f;
  134.     OBJECT         o;
  135.     /* Pointer items */
  136.     JHandle       *h;
  137.     void          *p;
  138.     unsigned char *addr;
  139. } stack_item;
  140.  
  141. struct execenv {
  142.     struct javastack  *initial_stack;
  143.     struct javaframe  *current_frame; 
  144.     JHandle           *thread;        /* vague type to avoid include files */
  145.     char              exceptionKind;
  146.     union {
  147.     JHandle          *exc;        /* holds exception object */
  148.     unsigned char *addr;        /* holds pc for stack overflow */
  149.     } exception;
  150.  
  151.     /* Stuff for the JNI: */
  152.     struct JNIEnv_    nativeInterface;
  153.  
  154.     /* Detecting class circularities */
  155.     struct seenclass {
  156.     ClassClass    *cb;
  157.     struct seenclass *next;
  158.     } seenclasses;
  159.  
  160.     /* Per-thread allocation cache */
  161.     struct alloc_cache alloc_cache;
  162. };
  163.  
  164. typedef struct execenv ExecEnv;
  165.  
  166. #define PRIVILEGED_EE ((ExecEnv*)-1)
  167.  
  168. #define JAVASTACK_CHUNK_SIZE 2000
  169. struct javastack {
  170.     struct execenv  *execenv;        /* execenv we belong to */
  171.     struct javastack *prev;          /* previous stack of this execenv */
  172.     struct javastack *next;          /* next stack of this execenv */
  173.     stack_item      *end_data;      /* address of end of data */
  174.     unsigned int     stack_so_far;  /* total space used by this chunk and
  175.                      * all previous chunks. */
  176.     stack_item       data[JAVASTACK_CHUNK_SIZE];    /* actual data */
  177.  
  178. };
  179.  
  180. typedef struct javastack JavaStack;
  181.  
  182.  
  183. struct javaframe {
  184.     /* DANGER DANGER DANGER DANGER DANGER DANGER DANGER DANGER DANGER DANGER 
  185.      * N. B.the first two items in structure shouldn't be needed by function
  186.      * return or by the Garbage Collector, since they may be overwritten by
  187.      * dreturn, lreturn, etc.
  188.      */
  189.     cp_item_type       *constant_pool; /* constant_pool of this method */
  190.     unsigned char      *returnpc;      /* pc of next instruction */
  191.     /* REGNAD REGNAD REGNAD REGNAD REGNAD REGNAD REGNAD REGNAD REGNAD REGNAD */
  192.  
  193.     stack_item         *optop;           /* current top of stack */
  194.     stack_item         *vars;           /* pointer to this frame's vars */
  195.     struct javaframe   *prev;          /* previous java frame. */
  196.     struct javastack   *javastack;                      
  197.     unsigned char      *lastpc;           /* pc of last executed instruction */
  198.     struct methodblock *current_method;/* method currently executing */
  199.     JHandle            *monitor;       /* object locked by this method */
  200.     int                    mon_starttime; /* time this method began */
  201.     stack_item ostack[1];           /* start of this frame's stack */
  202. };
  203.  
  204. typedef struct javaframe JavaFrame; 
  205.  
  206.  
  207. /*
  208.  * Javaframe.exceptionKind is used to signal why the interpreter
  209.  * loop was exited.
  210.  */
  211. #define EXCKIND_NONE            0               /* return */
  212. #define EXCKIND_THROW        1        /* throw */
  213. #define EXCKIND_STKOVRFLW       2               /* stack overflow */
  214.  
  215. /*
  216.  * Be sure to use these macros to access the exception structure.  Do
  217.  * not access the fields directly.
  218.  */
  219. #define exceptionClear(ee)            \
  220.     ((ee)->exceptionKind = EXCKIND_NONE);
  221.  
  222. #define exceptionOccurred(ee)            \
  223.     ((ee)->exceptionKind != EXCKIND_NONE)
  224.  
  225. #define exceptionThrow(ee, obj)            \
  226.     (ee)->exceptionKind = EXCKIND_THROW;    \
  227.     (ee)->exception.exc = (obj);
  228.  
  229. /* Macro for handling specific kinds of exceptions */
  230. #define exceptionThrowSpecial(ee, obj, kind)    \
  231.     (ee)->exceptionKind = kind;            \
  232.     (ee)->exception.exc = (obj);
  233.  
  234.  
  235. extern long nbinclasses, sizebinclasses;
  236. extern ClassClass **binclasses;
  237.  
  238. /* stuff for dealing with handles */
  239. #define unhand(o) ((o)->obj)
  240.  
  241.  
  242. /* globals.c */
  243.  
  244. ClassClass** get_binclasses(void);
  245. ClassClass* get_classClass(void);
  246. ClassClass* get_classObject(void);
  247. long get_nbinclasses(void);
  248.  
  249. /* gc.c */
  250.  
  251. bool_t InitializeAlloc(long max, long min);
  252. HObject *AllocHandle(struct methodtable *, ClassObject *);
  253. extern struct arrayinfo const arrayinfo[];
  254. extern int64_t TotalObjectMemory(void);
  255. extern int64_t FreeObjectMemory(void);
  256. extern int64_t TotalHandleMemory(void);
  257. extern int64_t FreeHandleMemory(void);
  258. extern int tracegc;
  259.  
  260. extern void gc(int async, unsigned int spaceRequested);
  261.  
  262.  
  263. /* interpreter.c */
  264.  
  265. /* SignalError() -- Instantiate an object of the specified class. 
  266.  * Indicate that that error occurred.
  267.  */
  268. extern bool_t UseLosslessQuickOpcodes;
  269. void SignalError(struct execenv *, char *, char *);
  270.  
  271. JavaStack *CreateNewJavaStack(ExecEnv *ee, JavaStack *previous_stack);
  272.  
  273. void InitializeExecEnv(ExecEnv *ee, JHandle *thread);
  274. void DeleteExecEnv(ExecEnv *ee);
  275. extern ExecEnv *DefaultExecEnv;
  276.  
  277.  
  278. HObject *execute_java_constructor(ExecEnv *,
  279.                  char *classname,
  280.                  ClassClass *cb,
  281.                  char *signature, ...);
  282. long execute_java_static_method(ExecEnv *, ClassClass *cb,
  283.                    char *method_name, char *signature, ...);
  284. long execute_java_dynamic_method(ExecEnv *, HObject *obj,
  285.                 char *method_name, char *signature, ...);
  286.      
  287. long do_execute_java_method(ExecEnv *ee, void *obj, 
  288.                char *method_name, char *signature, 
  289.                struct methodblock *mb,
  290.                bool_t isStaticCall, ...);
  291.  
  292. long do_execute_java_method_vararg(ExecEnv *ee, void *obj, 
  293.                    char *method_name, char *signature, 
  294.                    struct methodblock *mb,
  295.                    bool_t isStaticCall, va_list args, 
  296.                    long *highBits, bool_t shortFloats);
  297.  
  298. long now(void);
  299. bool_t isSpecialSuperCall(ClassClass *current_class, struct methodblock *mb);
  300.  
  301. void InitializeInterpreter(void);
  302. bool_t is_instance_of(JHandle * h, ClassClass *dcb, ExecEnv *ee);
  303. bool_t is_subclass_of(ClassClass *cb, ClassClass *dcb, ExecEnv *ee);
  304. bool_t array_is_instance_of_array_type(JHandle * h, ClassClass *cb, 
  305.                        ExecEnv *ee);
  306. bool_t ImplementsInterface(ClassClass *cb, ClassClass *icb, ExecEnv *ee);
  307. HObject *MultiArrayAlloc(int dimensions, ClassClass *, stack_item *sizes);
  308. bool_t ExecuteJava(unsigned char  *, ExecEnv *ee);
  309.  
  310. /*
  311.  * Called from ExecuteJava.
  312.  *    -1:   rewrite signalled an error
  313.  *     0:   rewrite went okay
  314.  *    +1:   opcode changed underneath us.  Redo
  315.  */
  316.  
  317. int quickFieldAccess( int opcode, unsigned char * pc, struct fieldblock *fb,
  318.             ExecEnv *ee );
  319. int quickStaticAccess( int opcode, unsigned char * pc, struct fieldblock *fb,
  320.             ExecEnv *ee );
  321. int quickInvocation( int opcode, unsigned char * pc, struct methodblock *mb,
  322.             ExecEnv *ee );
  323. void FixupQuickInvocation(unsigned char *pc, 
  324.               struct methodblock *currentMethod,
  325.               struct methodblock *targetMethod);
  326.  
  327. bool_t
  328. invokeInterfaceError(ExecEnv *ee, unsigned char *pc, 
  329.              ClassClass *cb, ClassClass *intf);
  330.  
  331. unsigned char *
  332. ProcedureFindThrowTag(ExecEnv *ee, 
  333.               JavaFrame *frame, JHandle *object, unsigned char *pc);
  334.  
  335. void *
  336. ResolveClassConstantFromPC(unsigned char *pc, unsigned char opcode, 
  337.                    cp_item_type *, struct execenv *ee, unsigned mask);
  338.  
  339.  
  340.  
  341. struct stat;
  342.  
  343. bool_t dynoLink(struct methodblock *);
  344. bool_t dynoLinkJNI(struct methodblock *);
  345. char *str2rd(char *);
  346. char *unicode2rd(unicode *, long);
  347.  
  348. /* classruntime.c */
  349. HArrayOfChar *MakeString(char *, long);
  350.  
  351. ClassClass *FindClass(struct execenv *, char *, bool_t resolve);
  352. ClassClass *FindStickySystemClass(struct execenv *, char *, bool_t resolve);
  353. ClassClass *FindClassFromClass(struct execenv *, char *, bool_t resolve, ClassClass *from);
  354. bool_t RunStaticInitializers(ClassClass *cb);
  355. void InitializeInvoker(ClassClass *cb);
  356.  
  357. bool_t
  358. invokeJavaMethod(JHandle *o, struct methodblock *mb, int args_size, ExecEnv *ee);
  359. bool_t invokeSynchronizedJavaMethod(JHandle *o, struct methodblock *mb, 
  360.                     int args_size, ExecEnv *ee);
  361. bool_t invokeNativeMethod(JHandle *o, struct methodblock *mb, int args_size, 
  362.               ExecEnv *ee);
  363. bool_t invokeSynchronizedNativeMethod(JHandle *o, struct methodblock *mb, 
  364.                       int args_size, ExecEnv *ee);
  365. bool_t invokeJNINativeMethod(JHandle *o, struct methodblock *mb, int args_size, 
  366.                  ExecEnv *ee);
  367. bool_t invokeJNISynchronizedNativeMethod(JHandle *o, struct methodblock *mb, 
  368.                      int args_size, ExecEnv *ee);
  369. bool_t invokeLazyNativeMethod(JHandle *o, struct methodblock *mb, int args_size, 
  370.                   ExecEnv *ee);
  371. bool_t invokeAbstractMethod(JHandle *o, struct methodblock *mb, int args_size, 
  372.                 ExecEnv *ee);
  373. bool_t invokeCompiledMethod(JHandle *o, struct methodblock *mb, int args_size, 
  374.                 ExecEnv *ee);
  375.  
  376.  
  377. void LoadClassConstants(ClassClass *cb);
  378. bool_t ResolveClassStringConstant(ClassClass *, unsigned, struct execenv *);
  379. bool_t ResolveClassConstant(cp_item_type *, unsigned index, struct execenv *ee,
  380.                 unsigned mask);
  381. bool_t ResolveClassConstantFromClass(ClassClass *, unsigned index, 
  382.                      struct execenv *ee, unsigned mask);
  383.  
  384. void InitializeClassConstantResolver();
  385.  
  386. bool_t VerifyClassAccess(ClassClass *, ClassClass *, bool_t);
  387. bool_t VerifyFieldAccess(ClassClass *, ClassClass *, int, bool_t);
  388. bool_t IsSameClassPackage(ClassClass *class1, ClassClass *class2); 
  389.  
  390. char *GetClassConstantClassName(cp_item_type *constant_pool, int index);
  391. unsigned NameAndTypeToHash(char *name, char *type);
  392. HObject *newobject(ClassClass *cb, unsigned char *pc, struct execenv *ee);
  393.  
  394.  
  395. char *pc2string(unsigned char *pc, struct methodblock *mb, char *buf, char *limit);
  396.  
  397. JHandle *ArrayAlloc(int, int);
  398. JHandle *ObjAlloc(ClassClass *, long);
  399. int sizearray(int, int);
  400. extern char *remote_classname(JHandle *);
  401. extern JHandle *remote_clone(struct execenv *);
  402. extern long remote_cast(JHandle *, ClassClass *);
  403. int pc2lineno(struct methodblock *, unsigned int);
  404.  
  405. /* From verify_class.c */
  406. bool_t VerifyClass(ClassClass *cb);
  407. bool_t IsLegalClassname(char *name, bool_t allowArrayClass);
  408.  
  409. /* From verify_code.c */
  410. bool_t verify_class_codes(ClassClass *cb);
  411.  
  412.  
  413. /* from profiler.c */
  414. extern int java_monitor;
  415. void javamon(int i);
  416. void java_mon(struct methodblock *caller, struct methodblock *callee, int time);
  417. void java_mon_dump(void);
  418.  
  419. #ifdef JCOV
  420. #include "jcov.h"
  421. #endif /* JCOV */
  422.  
  423. /* from classloader.c */
  424. void FreeClass(ClassClass *cb);
  425. void AddBinClass(ClassClass * cb);
  426. void DelBinClass(ClassClass * cb);
  427. ClassClass *LoadClassLocally(char *name);
  428. bool_t createInternalClass(unsigned char *bytes, unsigned char *limit,
  429.                            ClassClass *cb, struct Hjava_lang_ClassLoader *,
  430.                             char *utfname, char **detail);
  431. ClassClass *createFakeArrayClass(char *name, int base_type, int depth, 
  432.                  ClassClass *inner_cb, 
  433.                  struct Hjava_lang_ClassLoader *);
  434. ClassClass *createPrimitiveClass(char *name, char sig, unsigned char typecode,
  435.     unsigned char slotsize, unsigned char elementsize);
  436. unsigned Signature2ArgsSize(char *method_signature);
  437.  
  438. /* from classresolver.c */
  439. char *LinkClass(ClassClass *cb, char **detail);
  440. char *InitializeClass(ClassClass * cb, char **detail);
  441. char *ResolveClass(ClassClass * cb, char **detail);
  442. ClassClass *FindClass(struct execenv *ee, char *name, bool_t resolve);
  443. ClassClass *FindClassFromClass(struct execenv *ee, char *name, 
  444.                    bool_t resolve, ClassClass *from);
  445. ClassClass *ClassLoaderFindClass(ExecEnv *ee, 
  446.                  struct Hjava_lang_ClassLoader *loader, 
  447.                  char *name, bool_t resolve);
  448.  
  449. int  makeslottable(ClassClass * clb);
  450. void lock_classes(void);
  451. void unlock_classes(void);
  452.  
  453. extern ClassClass *class_void;
  454. extern ClassClass *class_boolean;
  455. extern ClassClass *class_byte;
  456. extern ClassClass *class_char;
  457. extern ClassClass *class_short;
  458. extern ClassClass *class_int;
  459. extern ClassClass *class_long;
  460. extern ClassClass *class_float;
  461. extern ClassClass *class_double;
  462.  
  463. extern ClassClass *FindPrimitiveClass(char *);
  464.  
  465. /* from path_md.c */
  466. char **CLASSPATH(void);
  467.  
  468. /* from threadruntime.c */
  469. struct Hjava_lang_Thread *InitializeClassThread(ExecEnv *ee, char **errmsg);
  470. void InitializeMainThread(void);
  471. long *getclassvariable(ClassClass *cb, char *fname);
  472. struct Hjava_lang_Thread;
  473. char *thread_name(struct Hjava_lang_Thread *tid); 
  474.  
  475. void setThreadName(struct Hjava_lang_Thread *ht, HArrayOfChar *newName);
  476. HArrayOfChar *getThreadName(void);
  477.  
  478. /* from exception.c */
  479. struct Hjava_lang_Throwable;
  480. void fillInStackTrace(struct Hjava_lang_Throwable *handle, ExecEnv *ee);
  481.  
  482. /* from CompSupport.c */
  483. long CallInterpreted(register struct methodblock * mb, void *obj,...);
  484.  
  485. /* used to indicate of an object or remote or local */
  486. extern struct methodtable *remote_methodtable;
  487.  
  488. void unicode2str(unicode *, char *, long);
  489. unicode *str2unicode(char *, unicode *, long);
  490.  
  491. enum {
  492.     MangleMethodName_JDK_1,
  493.     MangleMethodName_JNI_SHORT,
  494.     MangleMethodName_JNI_LONG
  495. };
  496. void mangleMethodName(struct methodblock *mb, char *buffer, int buflen,
  497.               int mangleType);
  498.  
  499. enum { 
  500.     MangleUTF_Class, 
  501.     MangleUTF_Field, 
  502.     MangleUTF_FieldStub, 
  503.     MangleUTF_Signature,
  504.     MangleUTF_JNI
  505. };
  506. int mangleUTFString(char *name, char *buffer, int buflen, int mangleType);
  507.  
  508. /* string hash support */
  509. struct StrIDhash;
  510. unsigned short Str2ID(struct StrIDhash **, char *, void ***, int);
  511. char *ID2Str(struct StrIDhash *, unsigned short, void ***);
  512. void Str2IDFree(struct StrIDhash **);
  513. void Str2IDCallback(struct StrIDhash **hash_ptr, void (*)(char *, void *));
  514. ExecEnv *EE(void);
  515.  
  516. /* Miscellaneous functions in util.c */
  517. char *unicode2rd(unicode *s, long len);
  518. void out_of_memory(void);
  519. void prints(char *s);
  520. void printus(unicode *str, long len);
  521. int jio_snprintf(char *str, size_t count, const char *fmt, ...);
  522. int jio_vsnprintf(char *str, size_t count, const char *fmt, va_list args);
  523.  
  524. int jio_printf(const char *fmt, ...);
  525. int jio_fprintf(FILE *, const char *fmt, ...);
  526. int jio_vfprintf(FILE *, const char *fmt, va_list args);
  527.  
  528.  
  529. /* allows you to override panic & oom "functionality" */
  530. typedef void (*PanicHook)(const char* panicString);
  531. typedef void (*OutOfMemoryHook) ();
  532.  
  533. extern PanicHook panic_hook;
  534. extern OutOfMemoryHook out_of_memory_hook;
  535.  
  536. /* Stuff from compiler.c */
  537.  
  538. void InitializeForCompiler(ClassClass *cb);
  539. void CompilerFreeClass(ClassClass *cb);
  540. void CompilerCompileClass(ClassClass *cb);
  541. void ReadInCompiledCode(void *context, struct methodblock *mb, 
  542.             int attribute_length, 
  543.             unsigned long (*get1byte)(),
  544.             unsigned long (*get2bytes)(), 
  545.             unsigned long (*get4bytes)(), 
  546.             void (*getNbytes)());
  547.  
  548. bool_t PCinCompiledCode(unsigned char *pc, struct methodblock *mb);
  549. unsigned char *CompiledCodePC(JavaFrame *frame, struct methodblock *mb);
  550. JavaFrame *CompiledFramePrev(JavaFrame *frame, JavaFrame *buf);
  551. //>>> Borland (MJH)
  552. bool_t CompilerUnregisterNatives(ClassClass *cb);
  553. //<<<
  554.  
  555.  
  556. /* Stuff from simplify.c */
  557. bool_t MethodCallInline(unsigned char *pc, struct methodblock *sourceMethod,
  558.             struct methodblock *mb, unsigned char *result);
  559.  
  560. #define KEEP_POINTER_ALIVE(p) if ((p) == 0) EE()
  561. /* 
  562.  * BEGIN JNI STUFF: 
  563.  * Only the stuff used by the JNI implementation, but not by JNI 
  564.  * programmers. jni.h contains the types and function prototypes
  565.  * used by JNI programmers
  566.  */
  567.  
  568. int InitializeJNI();
  569.  
  570. void InitializeJNIRootFrame(ExecEnv *ee);
  571. void DeleteJNIRootFrame(ExecEnv *ee);
  572.  
  573. /*
  574.  * Reference tables
  575.  */
  576.  
  577. #define JNI_REF_COUNT_MASK 0x1fffffff
  578.  
  579. #define JNI_REF_TAG_MASK 0x60000000
  580.  
  581. #define JNI_REF_HANDLE_TAG 0x00000000
  582.  
  583. #define JNI_REF_FB_TAG 0x20000000
  584.  
  585. #define JNI_REF_MB_TAG 0x40000000
  586.  
  587. typedef struct JNIRefCell {
  588.     uint32_t refCount;
  589.     void *content;
  590. } JNIRefCell;
  591.  
  592. typedef struct JNIRefTable {
  593.     JNIRefCell *elements;
  594.     int base;
  595.     int top;
  596.     int size;
  597. } JNIRefTable;
  598.  
  599. extern jref jni_AddRefCell(JNIRefTable *table, void *entry, int kind);
  600. extern JNIRefTable globalRefTable;
  601.  
  602. /*
  603.  * JNIEnv <-> ExecEnv conversion
  604.  */
  605.  
  606. #define JNIEnv2EE(env) \
  607.     ((ExecEnv*)((char*)(env) - offsetof(ExecEnv, nativeInterface)))
  608.  
  609. #define EE2JNIEnv(ee) ((JNIEnv *)(&(ee)->nativeInterface))
  610.  
  611. /*
  612.  * References
  613.  * The local reference table is stored in field reserved1.
  614.  */
  615.  
  616. #define JNIEnvGetLocalRefs(env) \
  617.     ((JNIRefTable *)(((struct JNIEnv_ *)(env))->reserved1))
  618.  
  619. #define MkRefLocal(env, jobj, tag) \
  620.     ((jref)(jni_AddRefCell(JNIEnvGetLocalRefs(env), (void *)(jobj), tag)))
  621.  
  622. #define DeRef(env, ref) \
  623.     ((int)(ref) > 0 ? \
  624.          JNIEnvGetLocalRefs(env)->elements[(int)(ref) - 1].content \
  625.        : ((ref) ? \
  626.               globalRefTable.elements[-((int)(ref)) - 1].content \
  627.             : 0))
  628.  
  629. /* 
  630.  * JavaVM <-> main EE conversion
  631.  * The main EE is stored in field reserved0.
  632.  */
  633. #define JavaVMGetEE(vm) ((ExecEnv *)(((struct JavaVM_ *)vm)->reserved0))
  634.  
  635. /* used in java_main */
  636. struct methodblock *
  637. JNI_FindMainMethod(ClassClass *cb, char **error_message_p);
  638. /*
  639.  * END JNI STUFF
  640.  */
  641.  
  642. #endif /* ! _INTERPRETER_H_ */
  643.  
  644.