home *** CD-ROM | disk | FTP | other *** search
/ Chip: Shareware for Win 95 / Chip-Shareware-Win95.bin / ostatni / powerj / java.z / interpreter.h < prev    next >
Encoding:
C/C++ Source or Header  |  1996-05-03  |  14.4 KB  |  443 lines
  1. /*
  2.  * @(#)interpreter.h    1.70 96/04/02  
  3.  *
  4.  * Copyright (c) 1994 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * Permission to use, copy, modify, and distribute this software
  7.  * and its documentation for NON-COMMERCIAL purposes and without
  8.  * fee is hereby granted provided that this copyright notice
  9.  * appears in all copies. Please refer to the file "copyright.html"
  10.  * for further important copyright and licensing information.
  11.  *
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
  13.  * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  14.  * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  15.  * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
  16.  * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
  17.  * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
  18.  */
  19.  
  20. /*
  21.  * Definitions for the interperter    6/27/91
  22.  */
  23.  
  24. #ifndef _INTERPRETER_H_
  25. #define _INTERPRETER_H_
  26.  
  27. #include <stdio.h>
  28. #include <stdlib.h>
  29. #include <string.h>
  30.  
  31. #include "bool.h"
  32. #include "config.h"
  33. #include "standardlib.h"
  34.  
  35. extern char *progname;
  36. extern int verbose;
  37. extern int verbosegc;
  38. extern int noasyncgc;
  39. extern int debugagent;
  40.  
  41. extern ClassClass *classJavaLangClass;       /* class java/lang/Class */
  42. extern ClassClass *classJavaLangObject;       /* class java/lang/Object */
  43. extern ClassClass *classJavaLangString;       /* class java/lang/Object */
  44.  
  45. extern ClassClass *classJavaLangThrowable;
  46. extern ClassClass *classJavaLangException;
  47. extern ClassClass *classJavaLangRuntimeException;
  48. extern ClassClass *classJavaLangThreadDeath;
  49.  
  50. extern ClassClass *interfaceJavaLangCloneable; /* class java/lang/Object */
  51.  
  52. enum { VERIFY_NONE, VERIFY_REMOTE, VERIFY_ALL };
  53.  
  54. extern int verifyclasses;
  55.  
  56. #define FINALIZER_METHOD_NAME "finalize"
  57. #define FINALIZER_METHOD_SIGNATURE "()V"
  58.  
  59. #ifdef TRACING
  60.   extern int trace;
  61.   extern int tracem;
  62.   extern char *opnames[256];
  63.   extern void trace_method(struct execenv*, struct methodblock*, int, int);
  64.   enum { TRACE_METHOD_ENTER, TRACE_METHOD_RETURN, TRACE_METHOD_NATIVE_RETURN };
  65. # define TRACE_METHOD(ee, mb, args_size, type) \
  66.       if (tracem) trace_method(ee, mb, args_size, type); else
  67.  
  68. #else
  69. # define trace  0
  70. # define tracem 0
  71. # define TRACE_METHOD(ee, mb, args_size, type) 
  72. #endif
  73.  
  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.  
  123. typedef union stack_item {
  124.     /* Non pointer items */
  125.     int            i;
  126.     float          f;
  127.     OBJECT         o;
  128.     /* Pointer items */
  129.     JHandle       *h;
  130.     void          *p;
  131.     unsigned char *addr;
  132. } stack_item;
  133.  
  134. struct execenv {
  135.     struct javastack  *initial_stack;
  136.     struct javaframe  *current_frame; 
  137.     JHandle           *thread;        /* vague type to avoid include files */
  138.     char              exceptionKind;
  139.     union {
  140.     JHandle          *exc;        /* holds exception object */
  141.     unsigned char *addr;        /* holds pc for stack overflow */
  142.     } exception;
  143. };
  144.  
  145. typedef struct execenv ExecEnv;
  146.  
  147. #define PRIVILEGED_EE ((ExecEnv*)-1)
  148.  
  149. #define JAVASTACK_CHUNK_SIZE 2000
  150. struct javastack {
  151.     struct execenv  *execenv;        /* execenv we belong to */
  152.     struct javastack *prev;          /* previous stack of this execenv */
  153.     struct javastack *next;          /* next stack of this execenv */
  154.     stack_item      *end_data;      /* address of end of data */
  155.     unsigned int     stack_so_far;  /* total space used by this chunk and
  156.                      * all previous chunks. */
  157.     stack_item       data[JAVASTACK_CHUNK_SIZE];    /* actual data */
  158.  
  159. };
  160.  
  161. typedef struct javastack JavaStack;
  162.  
  163.  
  164. struct javaframe {
  165.     /* DANGER DANGER DANGER DANGER DANGER DANGER DANGER DANGER DANGER DANGER 
  166.      * N. B.the first two items in structure shouldn't be needed by function
  167.      * return or by the Garbage Collector, since they may be overwritten by
  168.      * dreturn, lreturn, etc.
  169.      */
  170.     cp_item_type       *constant_pool; /* constant_pool of this method */
  171.     unsigned char      *returnpc;      /* pc of next instruction */
  172.     /* REGNAD REGNAD REGNAD REGNAD REGNAD REGNAD REGNAD REGNAD REGNAD REGNAD */
  173.  
  174.     stack_item         *optop;           /* current top of stack */
  175.     stack_item         *vars;           /* pointer to this frame's vars */
  176.     struct javaframe   *prev;          /* previous java frame. */
  177.     struct javastack   *javastack;                      
  178.     unsigned char      *lastpc;           /* pc of last executed instruction */
  179.     struct methodblock *current_method;/* method currently executing */
  180.     JHandle            *monitor;       /* object locked by this method */
  181.     int                    mon_starttime; /* time this method began */
  182.     stack_item ostack[1];           /* start of this frame's stack */
  183. };
  184.  
  185. typedef struct javaframe JavaFrame; 
  186.  
  187.  
  188. /*
  189.  * Javaframe.exceptionKind is used to signal why the interpreter
  190.  * loop was exited.
  191.  */
  192. #define EXCKIND_YIELD        -1        /* yield the cpu */
  193. #define EXCKIND_NONE            0               /* return */
  194. #define EXCKIND_THROW        1        /* throw */
  195. #define EXCKIND_STKOVRFLW       2               /* stack overflow */
  196.  
  197.  
  198. #define exceptionClear(ee)    \
  199.     ((ee)->exceptionKind = EXCKIND_NONE);
  200.  
  201. #define exceptionOccurred(ee)    \
  202.     ((ee)->exceptionKind > EXCKIND_NONE)
  203.  
  204. #define exceptionThrow(ee, obj)    \
  205.     (ee)->exceptionKind = EXCKIND_THROW;            \
  206.     (ee)->exception.exc = (obj);
  207.  
  208.  
  209. extern long nbinclasses, sizebinclasses;
  210. extern ClassClass **binclasses;
  211.  
  212. /* stuff for dealing with handles */
  213. #define unhand(o) ((o)->obj)
  214.  
  215.  
  216. /* globals.c */
  217.  
  218. ClassClass** get_binclasses(void);
  219. ClassClass* get_classClass(void);
  220. ClassClass* get_classObject(void);
  221. long get_nbinclasses(void);
  222.  
  223. /* gc.c */
  224.  
  225. void InitializeAlloc(long max, long min);
  226. HObject *AllocHandle(struct methodtable *, ClassObject *);
  227. extern struct arrayinfo arrayinfo[];
  228. extern int64_t TotalObjectMemory(void);
  229. extern int64_t FreeObjectMemory(void);
  230. extern int64_t TotalHandleMemory(void);
  231. extern int64_t FreeHandleMemory(void);
  232. extern int tracegc;
  233.  
  234. extern void gc(int async, unsigned int spaceRequested);
  235.  
  236.  
  237. /* interpreter.c */
  238.  
  239. /* SignalError() -- Instantiate an object of the specified class. 
  240.  * Indicate that that error occurred.
  241.  */
  242. extern bool_t UseLosslessQuickOpcodes;
  243. void SignalError(struct execenv *, char *, char *);
  244.  
  245. JavaStack *CreateNewJavaStack(ExecEnv *ee, JavaStack *previous_stack);
  246.  
  247. void InitializeExecEnv(ExecEnv *ee, JHandle *thread);
  248. void DeleteExecEnv(ExecEnv *ee, JHandle *thread);
  249. extern ExecEnv *DefaultExecEnv;
  250.  
  251.  
  252. HObject *execute_java_constructor(ExecEnv *,
  253.                  char *classname,
  254.                  ClassClass *cb,
  255.                  char *signature, ...);
  256. long execute_java_static_method(ExecEnv *, ClassClass *cb,
  257.                    char *method_name, char *signature, ...);
  258. long execute_java_dynamic_method(ExecEnv *, HObject *obj,
  259.                 char *method_name, char *signature, ...);
  260.      
  261. long do_execute_java_method(ExecEnv *ee, void *obj, 
  262.                char *method_name, char *signature, 
  263.                struct methodblock *mb,
  264.                bool_t isStaticCall, ...);
  265.  
  266. long do_execute_java_method_vararg(ExecEnv *ee, void *obj, 
  267.                    char *method_name, char *signature, 
  268.                    struct methodblock *mb,
  269.                    bool_t isStaticCall, va_list args, 
  270.                    long *highBits, bool_t shortFloats);
  271.  
  272. long now(void);
  273. bool_t isSpecialSuperCall(ClassClass *current_class, struct methodblock *mb);
  274.  
  275. void InitializeInterpreter(void);
  276. bool_t is_instance_of(JHandle * h, ClassClass *dcb, ExecEnv *ee);
  277. bool_t is_subclass_of(ClassClass *cb, ClassClass *dcb, ExecEnv *ee);
  278. bool_t array_is_instance_of_array_type(JHandle * h, ClassClass *cb, 
  279.                        ExecEnv *ee);
  280. bool_t ImplementsInterface(ClassClass *cb, ClassClass *icb, ExecEnv *ee);
  281. HObject *MultiArrayAlloc(int dimensions, ClassClass *, stack_item *sizes);
  282. bool_t ExecuteJava(unsigned char  *, ExecEnv *ee);
  283.  
  284.  
  285. struct stat;
  286.  
  287. bool_t dynoLink(struct methodblock *);
  288. char *str2rd(char *);
  289. char *unicode2rd(unicode *, long);
  290.  
  291. /* classruntime.c */
  292. HArrayOfChar *MakeString(char *, long);
  293. extern int ImportAcceptable;
  294.  
  295. ClassClass *FindClass(struct execenv *, char *, bool_t resolve);
  296. ClassClass *FindClassFromClass(struct execenv *, char *, bool_t resolve, ClassClass *from);
  297. void RunStaticInitializers(ClassClass *cb);
  298. void InitializeInvoker(ClassClass *cb);
  299.  
  300. bool_t
  301. invokeJavaMethod(JHandle *o, struct methodblock *mb, int args_size, ExecEnv *ee);
  302. bool_t invokeSynchronizedJavaMethod(JHandle *o, struct methodblock *mb, 
  303.                     int args_size, ExecEnv *ee);
  304. bool_t invokeNativeMethod(JHandle *o, struct methodblock *mb, int args_size, 
  305.               ExecEnv *ee);
  306. bool_t invokeSynchronizedNativeMethod(JHandle *o, struct methodblock *mb, 
  307.                       int args_size, ExecEnv *ee);
  308. bool_t invokeLazyNativeMethod(JHandle *o, struct methodblock *mb, int args_size, 
  309.                   ExecEnv *ee);
  310. bool_t invokeAbstractMethod(JHandle *o, struct methodblock *mb, int args_size, 
  311.                 ExecEnv *ee);
  312. bool_t invokeCompiledMethod(JHandle *o, struct methodblock *mb, int args_size, 
  313.                 ExecEnv *ee);
  314.  
  315.  
  316. void LoadClassConstants(ClassClass *cb);
  317. bool_t ResolveClassStringConstant(ClassClass *, unsigned, struct execenv *);
  318. bool_t ResolveClassConstant(cp_item_type *, unsigned index, struct execenv *ee,
  319.                 unsigned mask);
  320. bool_t ResolveClassConstantFromClass(ClassClass *, unsigned index, 
  321.                      struct execenv *ee, unsigned mask);
  322.  
  323. bool_t VerifyClassAccess(ClassClass *, ClassClass *, bool_t);
  324. bool_t VerifyFieldAccess(ClassClass *, ClassClass *, int, bool_t);
  325. bool_t IsSameClassPackage(ClassClass *class1, ClassClass *class2); 
  326.  
  327. char *GetClassConstantClassName(cp_item_type *constant_pool, int index);
  328. unsigned NameAndTypeToHash(char *name, char *type);
  329. HObject *newobject(ClassClass *cb, unsigned char *pc, struct execenv *ee);
  330.  
  331.  
  332. char *pc2string(unsigned char *pc, struct methodblock *mb, char *buf, char *limit);
  333.  
  334. extern int InhibitExecute;
  335. JHandle *ArrayAlloc(int, int);
  336. JHandle *ObjAlloc(ClassClass *, long);
  337. int sizearray(int, int);
  338. extern char *remote_classname(JHandle *);
  339. extern JHandle *remote_clone(struct execenv *);
  340. extern long remote_cast(JHandle *, ClassClass *);
  341. int pc2lineno(struct methodblock *, unsigned int);
  342.  
  343. /* From verify_code.c */
  344. bool_t verify_class_codes(ClassClass *cb);
  345.  
  346.  
  347. /* from profiler.c */
  348. extern int java_monitor;
  349. void javamon(int i);
  350. void java_mon(struct methodblock *caller, struct methodblock *callee, int time);
  351. void java_mon_dump(void);
  352.  
  353. /* from classloader.c */
  354. void AddBinClass(ClassClass * cb);
  355. void DelBinClass(ClassClass * cb);
  356. int LoadFile(char *fn, char *dir, char *SourceHint);
  357. int DoImport(char *name, char *SourceHint);
  358. ClassClass* createFakeArrayClass(char *name);
  359.  
  360. unsigned Signature2ArgsSize(char *method_signature);
  361.  
  362. /* from classresolver.c */
  363. char *InitializeClass(ClassClass * cb, char **detail);
  364. char *ResolveClass(ClassClass * cb, char **detail);
  365. ClassClass *FindClass(struct execenv *ee, char *name, bool_t resolve);
  366. ClassClass *FindClassFromClass(struct execenv *ee, char *name, 
  367.                    bool_t resolve, ClassClass *from);
  368. void makeslottable(ClassClass * clb);
  369. void lock_classes(void);
  370. void unlock_classes(void);
  371.  
  372. /* from path_md.c */
  373. char **CLASSPATH(void);
  374.  
  375. /* from threadruntime.c */
  376. struct Hjava_lang_Thread *InitializeClassThread(ExecEnv *ee, char **errmsg);
  377. void InitializeMainThread(void);
  378. long *getclassvariable(struct ClassClass *cb, char *fname);
  379. struct Hjava_lang_Thread;
  380. char *thread_name(struct Hjava_lang_Thread *tid); 
  381.  
  382. void setThreadName(struct Hjava_lang_Thread *ht, HArrayOfChar *newName);
  383. HArrayOfChar *getThreadName(void);
  384.  
  385. /* from exception.c */
  386. struct Hjava_lang_Throwable;
  387. void fillInStackTrace(struct Hjava_lang_Throwable *handle, ExecEnv *ee);
  388.  
  389. /* from CompSupport.c */
  390. long CallInterpreted(register struct methodblock * mb, void *obj,...);
  391.  
  392. /* used to indicate of an object or remote or local */
  393. extern struct methodtable *remote_methodtable;
  394.  
  395. void unicode2str(unicode *, char *, long);
  396. unicode *str2unicode(char *, unicode *, long);
  397. void mangleMethodName(struct methodblock *mb, char *buffer, int buflen,
  398.               char *suffix);
  399.  
  400. enum { MangleUTF_Class, MangleUTF_Field, MangleUTF_FieldStub };
  401. int mangleUTFString(char *name, char *buffer, int buflen, int mangleType);
  402.  
  403. /* string hash support */
  404. struct StrIDhash;
  405. unsigned short Str2ID(struct StrIDhash **, char *, void ***, int);
  406. char *ID2Str(struct StrIDhash *, unsigned short, void ***);
  407. void Str2IDFree(struct StrIDhash **);
  408. ExecEnv *EE(void);
  409.  
  410. /* Miscellaneous functions in util.c */
  411. char *unicode2rd(unicode *s, long len);
  412. void out_of_memory(void);
  413. void prints(char *s);
  414. void printus(unicode *str, long len);
  415. int jio_snprintf(char *str, size_t count, const char *fmt, ...);
  416. int jio_vsnprintf(char *str, size_t count, const char *fmt, va_list args);
  417.  
  418. /* allows you to override panic & oom "functionality" */
  419. typedef void (*PanicHook)(const char* panicString);
  420. typedef void (*OutOfMemoryHook) ();
  421.  
  422. extern PanicHook panic_hook;
  423. extern OutOfMemoryHook out_of_memory_hook;
  424.  
  425. /* Stuff from compiler.c */
  426.  
  427. void InitializeForCompiler(ClassClass *cb);
  428. void CompilerFreeClass(ClassClass *cb);
  429. void CompilerCompileClass(ClassClass *cb);
  430. void ReadInCompiledCode(void *context, struct methodblock *mb, 
  431.             int attribute_length, 
  432.             unsigned long (*get1byte)(),
  433.             unsigned long (*get2bytes)(), 
  434.             unsigned long (*get4bytes)(), 
  435.             void (*getNbytes)());
  436.  
  437. bool_t PCinCompiledCode(unsigned char *pc, struct methodblock *mb);
  438. unsigned char *CompiledCodePC(JavaFrame *frame, struct methodblock *mb);
  439.  
  440.  
  441. #endif /* ! _INTERPRETER_H_ */
  442.  
  443.