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