home *** CD-ROM | disk | FTP | other *** search
/ PC User 2001 August / APC_Aug2001_CD2.iso / features / j2sdk / files / linux / j2sdklin.bin / jdk1.3.1 / include-old / reflect.h < prev    next >
Encoding:
C/C++ Source or Header  |  2001-05-06  |  10.5 KB  |  287 lines
  1. /*
  2.  * @(#)reflect.h    1.40 00/02/02
  3.  *
  4.  * Copyright 1996-2000 Sun Microsystems, Inc. All Rights Reserved.
  5.  * 
  6.  * This software is the proprietary information of Sun Microsystems, Inc.  
  7.  * Use is subject to license terms.
  8.  * 
  9.  */
  10.  
  11. #ifndef _JAVASOFT_REFLECT_H
  12. #define _JAVASOFT_REFLECT_H
  13.  
  14. #include "oobj.h"
  15. #include "native.h"
  16. #include "jni.h"
  17.  
  18. /*
  19.  * Keep consistent with constants in java.lang.reflect.Member
  20.  */
  21. enum { MEMBER_PUBLIC, MEMBER_DECLARED };
  22.  
  23. extern HObject *    reflect_field(ExecEnv *, ClassClass *, char *,
  24.                 int);
  25. extern HArrayOfObject *    reflect_fields(ExecEnv *, ClassClass *, int);
  26.  
  27. extern HObject *    reflect_method(ExecEnv *, ClassClass *, char *,
  28.                 HArrayOfObject *, int);
  29. extern HArrayOfObject *    reflect_methods(ExecEnv *, ClassClass *, int);
  30.  
  31. extern HObject *    reflect_constructor(ExecEnv *, ClassClass *,
  32.                 HArrayOfObject *, int);
  33. extern HArrayOfObject *    reflect_constructors(ExecEnv *, ClassClass *, int);
  34.  
  35. extern ClassClass *    reflect_find_class(char *, ClassClass *,
  36.                 char **);
  37.  
  38. extern bool_t        reflect_check_access(ExecEnv *, ClassClass *, int,
  39.                 ClassClass *, bool_t for_invoke);
  40.  
  41. extern HObject *    reflect_new_array(ExecEnv *, ClassClass *, int);
  42. extern HArrayOfObject *    reflect_new_class_array(ExecEnv *, int);
  43.  
  44. extern bool_t        reflect_is_assignable(ClassClass *, ClassClass *,
  45.                 ExecEnv *);
  46.  
  47. extern HObject *    reflect_new_method(ExecEnv *, struct methodblock *);
  48. extern HObject *    reflect_new_field(ExecEnv *, struct fieldblock *);
  49.  
  50. extern struct methodblock *    reflect_get_methodblock(HObject *obj);
  51. extern struct fieldblock *    reflect_get_fieldblock(HObject *obj);
  52.  
  53. /*
  54.  * Implementation
  55.  */
  56.  
  57. #ifdef _REFLECT_IMPL
  58.  
  59. /*
  60.  * "Generic" accessors for Field, Method, Constructor
  61.  */
  62. #define    member_class(h)        (unhand(h)->clazz)
  63. #define    member_slot(h)        (unhand(h)->slot)
  64. #define    member_name(h)        (unhand(h)->name)
  65. #define    member_type(h)        (unhand(h)->type)
  66. #define    member_returnType(h)    (unhand(h)->returnType)
  67. #define    member_parameterTypes(h)(unhand(h)->parameterTypes)
  68. #define    member_exceptionTypes(h)(unhand(h)->exceptionTypes)
  69. #define    member_modifiers(h)    (unhand(h)->modifiers)
  70. #define    member_override(h)    (unhand(h)->override)
  71.  
  72. #define    REFLECT_GET(p, pCode, v, packed)                                \
  73. {                                                                       \
  74.     switch (pCode) {                                                    \
  75.     case T_BOOLEAN:                                                     \
  76.         v.z = (packed) ? (*(jboolean *) (p)) : ((jboolean) *(jint *) (p));  \
  77.         break;                                                          \
  78.     case T_BYTE:                            \
  79.         v.b = (packed) ? (*(jbyte *) (p)) : ((jbyte) *(jint *) (p));    \
  80.         break;                                                          \
  81.     case T_CHAR:                            \
  82.         v.c = (packed) ? (*(jchar *) (p)) : ((jchar) *(jint *) (p));    \
  83.         break;                                                          \
  84.     case T_SHORT:                            \
  85.         v.s = (packed) ? (*(jshort *) (p)) : ((jshort) *(jint *) (p));  \
  86.         break;                                                          \
  87.     case T_INT:                                    \
  88.         v.i = *(jint *) (p);                                            \
  89.         break;                                                 \
  90.     case T_FLOAT:                            \
  91.         v.f = *(jfloat *) (p);                                          \
  92.         break;                                                \
  93.     case T_LONG:                                                        \
  94.         v.j = GET_INT64(v, p);                                          \
  95.         break;                                                \
  96.     case T_DOUBLE:                            \
  97.         v.d = GET_DOUBLE(v, p);                                         \
  98.         break;                                                \
  99.     default:                                    \
  100.         v.l = *(jobject *) (p);                                         \
  101.         break;                                                \
  102.     }                                                                   \
  103. }
  104.  
  105. #define    REFLECT_SET(p, pCode, v, packed)                                \
  106. {                                                                       \
  107.     switch (pCode) {                                                    \
  108.     case T_BOOLEAN:                                                     \
  109.         if (packed) {                                                   \
  110.             *(jboolean *) (p) = v.z;                                    \
  111.         } else {                                                        \
  112.             *(jint *) (p) = (jint) v.z;                                 \
  113.         }                                                               \
  114.         break;                                                          \
  115.     case T_BYTE:                            \
  116.         if (packed) {                                                   \
  117.             *(jbyte *) (p) = v.b;                                       \
  118.         } else {                                                        \
  119.             *(jint *) (p) = (jint) v.b;                                 \
  120.         }                                                               \
  121.         break;                                                          \
  122.     case T_CHAR:                            \
  123.         if (packed) {                                                   \
  124.             *(jchar *) (p) = v.c;                                       \
  125.         } else {                                                        \
  126.             *(jint *) (p) = (jint) v.c;                                 \
  127.         }                                                               \
  128.         break;                                                          \
  129.     case T_SHORT:                            \
  130.         if (packed) {                                                   \
  131.             *(jshort *) (p) = v.s;                                      \
  132.         } else {                                                        \
  133.             *(jint *) (p) = (jint) v.s;                                 \
  134.         }                                                               \
  135.         break;                                                          \
  136.     case T_INT:                                    \
  137.         *(jint *) (p) = v.i; break;                         \
  138.     case T_FLOAT:                            \
  139.         *(jfloat *) (p) = v.f; break;                        \
  140.     case T_LONG:                            \
  141.         SET_INT64(v, p, v.j); break;                        \
  142.     case T_DOUBLE:                            \
  143.         SET_DOUBLE(v, p, v.d); break;                        \
  144.     default:                                    \
  145.         *(jobject *) (p) = v.l; break;                        \
  146.     }                                                                   \
  147. }
  148.  
  149. #define    REFLECT_WIDEN(v, vCode, wCode, fail)                \
  150. {                                    \
  151.     switch(wCode) {                            \
  152.     case T_BOOLEAN:                            \
  153.     case T_BYTE:                            \
  154.     case T_CHAR:                            \
  155.     goto fail;                            \
  156.     case T_SHORT:                            \
  157.     switch (vCode) {                        \
  158.     case T_BYTE:                            \
  159.             v.s = (jshort) v.b; break;                    \
  160.     default:                            \
  161.         goto fail;                            \
  162.     }                                \
  163.     break;                                \
  164.     case T_INT:                                \
  165.     switch (vCode) {                        \
  166.     case T_BYTE:                            \
  167.             v.i = (jint) v.b; break;                                    \
  168.     case T_CHAR:                            \
  169.             v.i = (jint) v.c; break;                                    \
  170.     case T_SHORT:                            \
  171.             v.i = (jint) v.s; break;                                    \
  172.     default:                            \
  173.         goto fail;                            \
  174.     }                                \
  175.     break;                                \
  176.     case T_LONG:                            \
  177.     switch (vCode) {                        \
  178.     case T_BYTE:                            \
  179.         v.j = int2ll((jint) v.b); break;                \
  180.     case T_CHAR:                            \
  181.             v.j = int2ll((jint) v.c); break;                            \
  182.     case T_SHORT:                            \
  183.             v.j = int2ll((jint) v.s); break;                            \
  184.     case T_INT:                            \
  185.             v.j = int2ll(v.i); break;                                   \
  186.     default:                            \
  187.         goto fail;                            \
  188.     }                                \
  189.     break;                                \
  190.     case T_FLOAT:                            \
  191.     switch (vCode) {                        \
  192.     case T_BYTE:                            \
  193.             v.f = (jfloat) v.b; break;                                  \
  194.     case T_CHAR:                            \
  195.             v.f = (jfloat) v.c; break;                                  \
  196.     case T_SHORT:                            \
  197.             v.f = (jfloat) v.s; break;                                  \
  198.     case T_INT:                            \
  199.         v.f = (jfloat) v.i; break;                    \
  200.     case T_LONG:                            \
  201.         v.f = (jfloat) ll2float(v.j); break;            \
  202.     default:                            \
  203.         goto fail;                            \
  204.     }                                \
  205.     break;                                \
  206.     case T_DOUBLE:                            \
  207.     switch (vCode) {                        \
  208.     case T_BYTE:                            \
  209.             v.d = (jdouble) v.b; break;                                 \
  210.     case T_CHAR:                            \
  211.             v.d = (jdouble) v.c; break;                                 \
  212.     case T_SHORT:                            \
  213.             v.d = (jdouble) v.s; break;                                 \
  214.     case T_INT:                            \
  215.         v.d = (jdouble) v.i; break;                    \
  216.     case T_FLOAT:                            \
  217.         v.d = (jdouble) v.f; break;                    \
  218.     case T_LONG:                            \
  219.         v.d = (jdouble) ll2double(v.j); break;            \
  220.     default:                            \
  221.         goto fail;                            \
  222.     }                                \
  223.     break;                                \
  224.     default:                                \
  225.     goto fail;                            \
  226.     }                                    \
  227. }
  228.  
  229. /*
  230.  *
  231.  */
  232.  
  233. #define    ENSURE_LINKED(ee, cb)                        \
  234. if (!CCIs(cb, Linked)) {                        \
  235.     LinkClass(cb);                            \
  236.     if (exceptionOccurred(ee))                        \
  237.     return 0; /* NULL, FALSE */                    \
  238.     sysAssert(CCIs(cb, Linked));                    \
  239. } else ((void) 0)
  240.  
  241. /* We can't put:
  242.  *
  243.  *  sysAssert(CCIs(cb, Initialized));
  244.  *
  245.  * in ENSURE_INITIALIZED because the semantics of class initialization
  246.  * is such that it's perfectally legal for InitClass to return without
  247.  * initializing the class if the current thread is in the middle of 
  248.  * running <clinit>.
  249.  */
  250.  
  251. #define    ENSURE_INITIALIZED(ee, cb)                    \
  252. if (!CCIs(cb, Initialized)) {                        \
  253.     InitClass(cb);                            \
  254.     if (exceptionOccurred(ee))                        \
  255.     return 0; /* NULL, FALSE */                    \
  256. } else ((void) 0)
  257.  
  258. /*
  259.  *
  260.  */
  261.  
  262. #define    fbClass(fb)    (fb->clazz)
  263. #define    fbName(fb)    (fb->name)
  264. #define    fbSig(fb)    (fb->signature)
  265. #define    fbAccess(fb)    (fb->access)
  266. #define    fbIsArray(fb)    (fbSig(fb)[0] == SIGNATURE_ARRAY)
  267. #define    fbIsClass(fb)    (fbSig(fb)[0] == SIGNATURE_CLASS)
  268. #define    fbIsPublic(fb)    ((fbAccess(fb) & ACC_PUBLIC) != 0)
  269. #define    fbIsStatic(fb)    ((fbAccess(fb) & ACC_STATIC) != 0)
  270. #define    fbIsFinal(fb)    ((fbAccess(fb) & ACC_FINAL) != 0)
  271. #define    fbOffset(fb)    (fb->u.offset)
  272.  
  273. #define    mbFb(mb)    (&mb->fb)
  274. #define    mbClass(mb)    (mb->fb.clazz)
  275. #define    mbName(mb)    (mb->fb.name)
  276. #define    mbSig(mb)    (mb->fb.signature)
  277. #define    mbAccess(mb)    (mb->fb.access)
  278. #define    mbOffset(mb)    (mb->fb.u.offset)
  279. #define    mbArgsSize(mb)    (mb->args_size)
  280. #define    mbIsSpecial(mb)    (mbName(mb)[0] == '<')
  281. #define    mbIsPublic(mb)    ((mbAccess(mb) & ACC_PUBLIC) != 0)
  282. #define    mbIsStatic(mb)    ((mbAccess(mb) & ACC_STATIC) != 0)
  283.  
  284. #endif /* _REFLECT_IMPL */
  285.  
  286. #endif /* !_JAVASOFT_REFLECT_H */
  287.