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