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