home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1996 May / PCW596.iso / wtest / clico / sunsoft / java / solaris.taz / solaris / hotjava / include / interpreter.h < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-15  |  11.5 KB  |  376 lines
  1. /*
  2.  * @(#)interpreter.h    1.39 95/04/20  
  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 <standardlib.h>
  28. #include <stdio.h>
  29. #include <stdlib.h>
  30. #include <string.h>
  31. #include <bool.h>
  32. #include <config.h>
  33.  
  34. extern char *progname;
  35. extern unsigned char *codebuf;
  36. extern unsigned char **mainstktop;
  37. extern int verbose;
  38. extern int verbosegc;
  39. extern int noasyncgc;
  40. extern ClassClass *classclass;    /* class java/lang/Class */
  41. extern ClassClass *classobject;    /* class java/lang/Object */
  42.  
  43. enum { VERIFY_NONE, VERIFY_REMOTE, VERIFY_ALL };
  44.  
  45. extern int verifyclasses;
  46.  
  47. #define FINALIZER_METHOD_NAME "finalize"
  48. #define FINALIZER_METHOD_SIGNATURE "()V"
  49.  
  50. #ifdef TRACING
  51.  extern int trace;
  52.  extern int tracem;
  53.  extern char *opnames[256];
  54. #else
  55. # define trace  0
  56. # define tracem 0
  57. #endif
  58.  
  59.  
  60. /* Get a constant pool index, from a pc */
  61. #define GET_INDEX(ptr) (((int)((ptr)[0]) << 8) | (ptr)[1])
  62.  
  63. extern char *Object2CString(Handle *);
  64.  
  65. #define METHOD_FLAG_BITS 5
  66. #define FLAG_MASK       ((1<<METHOD_FLAG_BITS)-1)  /* valid flag bits */
  67. #define METHOD_MASK     (~FLAG_MASK)  /* valid mtable ptr bits */
  68. #define LENGTH_MASK     METHOD_MASK
  69.  
  70. #define obj_flags(o) \
  71.     (((unsigned long) (o)->methods) & FLAG_MASK)
  72. #define obj_length(o)   \
  73.     (((unsigned long) (o)->methods) >> METHOD_FLAG_BITS)
  74.  
  75. #define mkatype(t,l) ((struct methodtable *) (((l) << METHOD_FLAG_BITS)|(t)))
  76. #define atype(m) ((m) & FLAG_MASK)
  77.  
  78.  
  79. #define obj_methodtable(obj) ((obj)->methods)
  80. #define obj_classblock(obj) ((obj)->methods->classdescriptor)
  81.  
  82. #define obj_array_methodtable(obj) \
  83.     ((obj_flags((obj)) == T_NORMAL_OBJECT) ? obj_methodtable((obj))      \
  84.                                            : cbMethodTable(classobject))
  85. #define obj_array_classblock(obj) \
  86.     ((obj_flags((obj)) == T_NORMAL_OBJECT) ? (obj)->methods->classdescriptor \
  87.                                            : classobject)
  88.  
  89. #define mt_slot(methodtable, slot) (methodtable)->methods[slot]
  90.  
  91. #define uobj_getslot(o, slot) (o)[slot]
  92. #define uobj_setslot(o, slot, v) (uobj_getslot(o, slot) = (v))
  93.  
  94. #define obj_getslot(o, slot) uobj_getslot(unhand(o), slot)
  95. #define obj_setslot(o, slot, v) (obj_getslot(o, slot) = (v))
  96.  
  97. #define obj_monitor(handlep) ((int) handlep)
  98.  
  99.  
  100. struct arrayinfo {
  101.     int index;
  102.     char sig;      /* type signature. */
  103.     char *name;
  104.     int factor;
  105. };
  106.  
  107.  
  108. typedef union stack_item {
  109.     /* Non pointer items */
  110.     int            i;
  111.     float          f;
  112.     OBJECT         o;
  113.     /* Pointer items */
  114.     Handle        *h;
  115.     void          *p;
  116.     unsigned char *addr;
  117. } stack_item;
  118.  
  119. struct execenv {
  120.     struct javastack  *initial_stack;
  121.     struct javaframe  *current_frame; 
  122.     Handle           *thread;        /* vague type to avoid include files */
  123.     char              exceptionKind;
  124.     union {
  125.     Handle          *exc;        /* holds exception object */
  126.     unsigned char *addr;        /* holds pc for stack overflow */
  127.     } exception;
  128. };
  129.  
  130. typedef struct execenv ExecEnv;
  131.  
  132. #define JAVASTACK_CHUNK_SIZE 2000
  133. struct javastack {
  134.     struct execenv  *execenv;        /* execenv we belong to */
  135.     struct javastack *prev;          /* previous stack of this execenv */
  136.     struct javastack *next;          /* next stack of this execenv */
  137.     stack_item      *end_data;      /* address of end of data */
  138.     unsigned int     stack_so_far;  /* total space used by this chunk and
  139.                      * all previous chunks. */
  140.     stack_item       data[JAVASTACK_CHUNK_SIZE];    /* actual data */
  141.  
  142. };
  143.  
  144. typedef struct javastack JavaStack;
  145.  
  146.  
  147. struct javaframe {
  148.     /* N. B.the first two items in structure shouldn't be needed by function
  149.      * return, since they may be overwritten by dreturn/lreturn
  150.      */
  151.     stack_item         *optop;          /* current top of stack */
  152.     stack_item         *vars;           /* pointer to this frame's vars */
  153.     struct javaframe    *prev;   /* previous java frame. */
  154.     struct javastack    *javastack;                      
  155.     unsigned char      *lastpc;           /* pc of last instruction */
  156.     unsigned char      *returnpc;      /* pc of next instruction */
  157.     struct methodblock *current_method;/* method currently executing */
  158.     cp_item_type       *constant_pool; /* constant_pool of this method */
  159.     Handle             *monitor;       /* object locked by this method */
  160.     int                    mon_starttime; /* time this method began */
  161.     stack_item ostack[1];           /* start of this frame's stack */
  162. };
  163.  
  164. typedef struct javaframe JavaFrame; 
  165.  
  166.  
  167. /*
  168.  * Javaframe.exceptionKind is used to signal why the interpreter
  169.  * loop was exited.
  170.  */
  171. #define EXCKIND_NONE            0               /* return */
  172. #define EXCKIND_THROW        1        /* throw */
  173. #define EXCKIND_STKOVRFLW       2               /* stack overflow */
  174.  
  175.  
  176. #define exceptionClear(ee)    \
  177.     ((ee)->exceptionKind = EXCKIND_NONE);
  178.  
  179. #define exceptionOccurred(ee)    \
  180.     ((ee)->exceptionKind != EXCKIND_NONE)
  181.  
  182. #define exceptionThrow(ee, obj)    \
  183.     (ee)->exceptionKind = EXCKIND_THROW;            \
  184.     (ee)->exception.exc = (obj);
  185.  
  186.  
  187. extern long nbinclasses, sizebinclasses;
  188. extern ClassClass **binclasses;
  189.  
  190. /* stuff for dealing with handles */
  191. #define unhand(o) ((o)->obj)
  192.  
  193.  
  194. /* gc.c */
  195.  
  196. extern HObject *AllocHandle(struct methodtable *, ClassObject *);
  197. extern struct arrayinfo arrayinfo[];
  198.  
  199. /* interpreter.c */
  200.  
  201. /* SignalError() -- Instantiate an object of the specified class. 
  202.  * Indicate that that error occurred.
  203.  */
  204. void SignalError(struct execenv *, char *, char *);
  205.  
  206. JavaStack *CreateNewJavaStack(ExecEnv *ee, JavaStack *previous_stack);
  207.  
  208. void InitializeExecEnv(ExecEnv *ee, Handle *thread);
  209. void DeleteExecEnv(ExecEnv *ee, Handle *thread);
  210. extern ExecEnv *DefaultExecEnv;
  211.  
  212.  
  213. HObject *execute_java_constructor(ExecEnv *,
  214.                  char *classname,
  215.                  ClassClass *cb,
  216.                  char *signature, ...);
  217. long execute_java_static_method(ExecEnv *, ClassClass *cb,
  218.                    char *method_name, char *signature, ...);
  219. long execute_java_dynamic_method(ExecEnv *, HObject *obj,
  220.                 char *method_name, char *signature, ...);
  221.      
  222. long do_execute_java_method(ExecEnv *ee, void *obj, 
  223.                char *method_name, char *signature, 
  224.                struct methodblock *mb,
  225.                bool_t isStaticCall, ...);
  226.  
  227. long do_execute_java_method_vararg(ExecEnv *ee, void *obj, 
  228.                    char *method_name, char *signature, 
  229.                    struct methodblock *mb,
  230.                    bool_t isStaticCall, va_list args, 
  231.                    long *highBits, bool_t shortFloats);
  232.  
  233. long now();
  234. void InitializeInterpreter(void);
  235. bool_t IsInstanceOf(Handle * h, ClassClass *dcb, ExecEnv *ee);
  236. bool_t ImplementsInterface(ClassClass *cb, ClassClass *icb, ExecEnv *ee);
  237. HObject *MultiArrayAlloc(int dimensions, ClassClass *, stack_item *sizes);
  238.  
  239.  
  240. struct stat;
  241.  
  242. int main(int, char **);
  243. bool_t dynoLink(struct methodblock *);
  244. char *str2rd(char *);
  245. char *unicode2rd(unicode *, long);
  246.  
  247. /* classruntime.c */
  248. void ClassDefHook(ClassClass *);
  249. HArrayOfChar *MakeString(char *, long);
  250. extern int ImportAcceptable;
  251.  
  252. ClassClass *FindClass(struct execenv *, char *, bool_t resolve);
  253. ClassClass *FindClassFromClass(struct execenv *, char *, bool_t resolve, ClassClass *from);
  254. char *ResolvePrototype(struct execenv *, ClassClass *cb);
  255. void RunStaticInitializers(ClassClass *cb);
  256. void InitializeInvoker(ClassClass *cb);
  257. int MethodMatches(char *caller, struct methodblock *mb);
  258.  
  259. void LoadClassConstants(ClassClass *cb);
  260. bool_t ResolveClassStringConstant(ClassClass *, unsigned, struct execenv *);
  261. bool_t ResolveClassConstant(cp_item_type *, unsigned index, struct execenv *ee,
  262.                 unsigned mask);
  263. bool_t ResolveClassConstantFromClass(ClassClass *, unsigned index, 
  264.                      struct execenv *ee, unsigned mask);
  265.  
  266. bool_t VerifyClassAccess(ClassClass *, ClassClass *, bool_t);
  267. bool_t VerifyFieldAccess(ClassClass *, ClassClass *, int, bool_t);
  268. bool_t IsSameClassPackage(ClassClass *class1, ClassClass *class2); 
  269.  
  270. char *GetClassConstantClassName(cp_item_type *constant_pool, int index);
  271. unsigned NameAndTypeToHash(char *name, char *type);
  272. HObject *newobject(ClassClass *cb, unsigned char *pc, struct execenv *ee);
  273.  
  274.  
  275. char *pc2string(unsigned char *pc, struct methodblock *mb, char *buf, char *limit);
  276. int InstallClass(struct execenv *, ClassClass *, char *);
  277.  
  278. extern int InhibitExecute;
  279. Handle *ArrayAlloc(int, int);
  280. Handle *ObjAlloc(ClassClass *, long);
  281. int sizearray(int, int);
  282. void InitializeAlloc(long);
  283. void InitializeRPC();
  284. extern char *remote_classname(Handle *);
  285. extern Handle *remote_clone(struct execenv *);
  286. extern long remote_cast(Handle *, ClassClass *);
  287. int pc2lineno(struct methodblock *, unsigned int);
  288.  
  289. /* from profiler.c */
  290. extern int java_monitor;
  291. void javamon(int i);
  292. void java_mon(struct methodblock *caller, struct methodblock *callee, int time);
  293. void java_mon_dump();
  294.  
  295. /* from classloader.c */
  296. void AddBinClass(ClassClass * cb);
  297. void DelBinClass(ClassClass * cb);
  298. int LoadFile(char *fn, char *dir, char *SourceHint);
  299. int DoImport(char *name, char *SourceHint);
  300. ClassClass* createFakeArrayClass(char *name);
  301.  
  302.  
  303. long SeenFile(char *fn, long state);
  304. unsigned Signature2ArgsSize(char *method_signature);
  305. long SeenFile(char *, long state);
  306. /* SeenFile states: */
  307. #define sfs_query 0
  308. #define sfs_loaded 1
  309. #define sfs_compiling 2
  310. #define sfs_forget_everything -1
  311.  
  312. /* from classresolver.c */
  313. char *InitializeClass(ClassClass * cb, char **detail);
  314. char *ResolveClass(ClassClass * cb, char **detail);
  315. ClassClass *FindClass(struct execenv *ee, char *name, bool_t resolve);
  316. ClassClass *FindClassFromClass(struct execenv *ee, char *name, 
  317.                    bool_t resolve, ClassClass *from);
  318. void makeslottable(ClassClass * clb);
  319.  
  320. /* from import_md.c  */
  321. int import_md(char *name, char *hint);
  322.  
  323. /* from path_md.c */
  324. char **CLASSPATH();
  325.  
  326. /* from seenfile_md.c */
  327. extern long SeenFile_md(char *, long);
  328.  
  329. /* from threadruntime.c */
  330. long *getclassvariable(struct ClassClass *cb, char *fname);
  331. struct Hjava_lang_Thread;
  332. char *thread_name(struct Hjava_lang_Thread *tid); 
  333.  
  334. void setThreadName(struct Hjava_lang_Thread *ht, HArrayOfChar *newName);
  335. HArrayOfChar *getThreadName();
  336.  
  337. /* from threads_md.c */
  338. struct Hjava_lang_Thread;
  339. void SetCurrentThread(struct Hjava_lang_Thread * t);
  340.  
  341.  
  342. /* from CompiledClasses.c */
  343. void InstallCompiledClasses();
  344. void InstallCompiledStrings();
  345.  
  346.  
  347. /* from CompSupport.c */
  348. long CallInterpreted(register struct methodblock * mb, void *obj,...);
  349.  
  350. /* used to indicate of an object or remote or local */
  351. extern struct methodtable *remote_methodtable;
  352.  
  353. /* Default size of the memory pool */
  354. #ifndef MEMPOOLSIZE
  355. #define MEMPOOLSIZE ((int) (3 * (1024*1024)))
  356. #endif
  357.  
  358. void unicode2str(unicode *, char *, long);
  359. unicode *str2unicode(char *, unicode *, long);
  360.  
  361. /* string hash support */
  362. struct StrIDhash;
  363. unsigned short Str2ID(struct StrIDhash **, char *, void ***, int);
  364. char *ID2Str(struct StrIDhash *, unsigned short, void ***);
  365. void Str2IDFree(struct StrIDhash **);
  366. ExecEnv *EE();
  367.  
  368. /* Miscellaneous functions in util.c */
  369. char *unicode2rd(unicode *s, long len);
  370. void out_of_memory();
  371. void prints(char *s);
  372. void printus(unicode *str, long len);
  373.  
  374. #endif /* ! _INTERPRETER_H_ */
  375.  
  376.