home *** CD-ROM | disk | FTP | other *** search
/ Netscape Plug-Ins Developer's Kit / Netscape_Plug-Ins_Developers_Kit.iso / source / Chap05 / zero / INCLUDE / JRI_MD.H next >
Encoding:
C/C++ Source or Header  |  1996-04-30  |  19.6 KB  |  440 lines
  1. /* -*- Mode: C; tab-width: 4; -*- */
  2. /*******************************************************************************
  3.  * Java Runtime Interface - Machine Dependent Types
  4.  * Copyright (c) 1996 Netscape Communications Corporation. All rights reserved.
  5.  ******************************************************************************/
  6.  
  7. #ifndef JRI_MD_H
  8. #define JRI_MD_H
  9.  
  10. #ifdef __cplusplus
  11. extern "C" {
  12. #endif
  13.  
  14. /******************************************************************************/
  15.  
  16. /* DLL Entry modifiers... */
  17.  
  18. #if defined(XP_PC)
  19. #define EXPORTED                        extern __declspec(dllexport)
  20. #if defined(_WIN32)
  21. #define JRI_PUBLIC_API(ResultType)        _declspec(dllexport) ResultType
  22. #define JRI_CALLBACK
  23. #else /* !_WIN32 */
  24. #define JRI_PUBLIC_API(ResultType)        ResultType _cdecl _export _loadds 
  25. #define JRI_CALLBACK                    _loadds
  26. #endif
  27. #else /* !XP_PC */
  28. #define JRI_PUBLIC_API(ResultType)        ResultType
  29. #define JRI_CALLBACK
  30. #endif /* XP_PC */
  31.  
  32. #ifndef FAR        /* for non-Win16 */
  33. #define FAR
  34. #endif
  35.  
  36. /******************************************************************************/
  37.  
  38. /* Java Scalar Types */
  39.  
  40. typedef unsigned char    jbool;
  41. typedef char            jbyte;
  42. typedef short            jchar;
  43. typedef short            jshort;
  44. #ifdef IS_64 /* XXX ok for alpha, but not right on all 64-bit architectures */
  45. typedef unsigned int    juint;
  46. typedef int                jint;
  47. #else
  48. typedef unsigned long    juint;
  49. typedef long            jint;
  50. #endif
  51. typedef float            jfloat;
  52. typedef double            jdouble;
  53.  
  54. typedef juint            jsize;
  55.  
  56. /*******************************************************************************
  57.  * jlong : long long (64-bit signed integer type) support.
  58.  ******************************************************************************/
  59.  
  60. /*
  61. ** Bit masking macros.  (n must be <= 31 to be portable)
  62. */
  63. #define JRI_BIT(n)            ((juint)1 << (n))
  64. #define JRI_BITMASK(n)        (JRI_BIT(n) - 1)
  65.  
  66. #ifdef HAVE_LONG_LONG
  67.  
  68. #ifndef _WIN32
  69. typedef long long            jlong;
  70. typedef unsigned long long    julong;
  71.  
  72. #define jlong_MAXINT        0x7fffffffffffffffLL
  73. #define jlong_MININT        0x8000000000000000LL
  74. #define jlong_ZERO            0x0LL
  75.  
  76. #else
  77. typedef LONGLONG            jlong;
  78. typedef DWORDLONG            julong;
  79.  
  80. #define jlong_MAXINT        0x7fffffffffffffffi64
  81. #define jlong_MININT        0x8000000000000000i64
  82. #define jlong_ZERO            0x0i64
  83.  
  84. #endif
  85.  
  86. #define jlong_IS_ZERO(a)    ((a) == 0)
  87. #define jlong_EQ(a, b)        ((a) == (b))
  88. #define jlong_NE(a, b)        ((a) != (b))
  89. #define jlong_GE_ZERO(a)    ((a) >= 0)
  90. #define jlong_CMP(a, op, b)    ((a) op (b))
  91.  
  92. #define jlong_AND(r, a, b)    ((r) = (a) & (b))
  93. #define jlong_OR(r, a, b)    ((r) = (a) | (b))
  94. #define jlong_XOR(r, a, b)    ((r) = (a) ^ (b))
  95. #define jlong_OR2(r, a)        ((r) = (r) | (a))
  96. #define jlong_NOT(r, a)        ((r) = ~(a))
  97.  
  98. #define jlong_NEG(r, a)        ((r) = -(a))
  99. #define jlong_ADD(r, a, b)    ((r) = (a) + (b))
  100. #define jlong_SUB(r, a, b)    ((r) = (a) - (b))
  101.  
  102. #define jlong_MUL(r, a, b)    ((r) = (a) * (b))
  103. #define jlong_DIV(r, a, b)    ((r) = (a) / (b))
  104. #define jlong_MOD(r, a, b)    ((r) = (a) % (b))
  105.  
  106. #define jlong_SHL(r, a, b)    ((r) = (a) << (b))
  107. #define jlong_SHR(r, a, b)    ((r) = (a) >> (b))
  108. #define jlong_USHR(r, a, b)    ((r) = (julong)(a) >> (b))
  109. #define jlong_ISHL(r, a, b)    ((r) = ((jlong)(a)) << (b))
  110.  
  111. #define jlong_L2I(i, l)        ((i) = (int)(l))
  112. #define jlong_L2UI(ui, l)    ((ui) =(unsigned int)(l))
  113. #define jlong_L2F(f, l)        ((f) = (l))
  114. #define jlong_L2D(d, l)        ((d) = (l))
  115.  
  116. #define jlong_I2L(l, i)        ((l) = (i))
  117. #define jlong_UI2L(l, ui)    ((l) = (ui))
  118. #define jlong_F2L(l, f)        ((l) = (f))
  119. #define jlong_D2L(l, d)        ((l) = (d))
  120.  
  121. #define jlong_UDIVMOD(qp, rp, a, b)  \
  122.     (*(qp) = ((julong)(a) / (b)), \
  123.      *(rp) = ((julong)(a) % (b)))
  124.  
  125. #else  /* !HAVE_LONG_LONG */
  126.  
  127. typedef struct {
  128. #ifdef IS_LITTLE_ENDIAN
  129.     juint lo, hi;
  130. #else
  131.     juint hi, lo;
  132. #endif
  133. } jlong;
  134. typedef jlong                julong;
  135.  
  136. extern jlong jlong_MAXINT, jlong_MININT, jlong_ZERO;
  137.  
  138. #define jlong_IS_ZERO(a)    (((a).hi == 0) && ((a).lo == 0))
  139. #define jlong_EQ(a, b)        (((a).hi == (b).hi) && ((a).lo == (b).lo))
  140. #define jlong_NE(a, b)        (((a).hi != (b).hi) || ((a).lo != (b).lo))
  141. #define jlong_GE_ZERO(a)    (((a).hi >> 31) == 0)
  142.  
  143. /*
  144.  * NB: jlong_CMP and jlong_UCMP work only for strict relationals (<, >).
  145.  */
  146. #define jlong_CMP(a, op, b)    (((int32)(a).hi op (int32)(b).hi) ||          \
  147.                  (((a).hi == (b).hi) && ((a).lo op (b).lo)))
  148. #define jlong_UCMP(a, op, b)    (((a).hi op (b).hi) ||                    \
  149.                  (((a).hi == (b).hi) && ((a).lo op (b).lo)))
  150.  
  151. #define jlong_AND(r, a, b)    ((r).lo = (a).lo & (b).lo,                    \
  152.                  (r).hi = (a).hi & (b).hi)
  153. #define jlong_OR(r, a, b)    ((r).lo = (a).lo | (b).lo,                    \
  154.                  (r).hi = (a).hi | (b).hi)
  155. #define jlong_XOR(r, a, b)    ((r).lo = (a).lo ^ (b).lo,                    \
  156.                  (r).hi = (a).hi ^ (b).hi)
  157. #define jlong_OR2(r, a)        ((r).lo = (r).lo | (a).lo,                    \
  158.                  (r).hi = (r).hi | (a).hi)
  159. #define jlong_NOT(r, a)        ((r).lo = ~(a).lo,                              \
  160.                  (r).hi = ~(a).hi)
  161.  
  162. #define jlong_NEG(r, a)        ((r).lo = -(int32)(a).lo,                     \
  163.                  (r).hi = -(int32)(a).hi - ((r).lo != 0))
  164. #define jlong_ADD(r, a, b) {                                              \
  165.     jlong _a, _b;                                                         \
  166.     _a = a; _b = b;                                                       \
  167.     (r).lo = _a.lo + _b.lo;                                               \
  168.     (r).hi = _a.hi + _b.hi + ((r).lo < _b.lo);                            \
  169. }
  170.  
  171. #define jlong_SUB(r, a, b) {                                              \
  172.     jlong _a, _b;                                                         \
  173.     _a = a; _b = b;                                                       \
  174.     (r).lo = _a.lo - _b.lo;                                               \
  175.     (r).hi = _a.hi - _b.hi - (_a.lo < _b.lo);                             \
  176. }                                                                         \
  177.  
  178. /*
  179.  * Multiply 64-bit operands a and b to get 64-bit result r.
  180.  * First multiply the low 32 bits of a and b to get a 64-bit result in r.
  181.  * Then add the outer and inner products to r.hi.
  182.  */
  183. #define jlong_MUL(r, a, b) {                                              \
  184.     jlong _a, _b;                                                         \
  185.     _a = a; _b = b;                                                       \
  186.     jlong_MUL32(r, _a.lo, _b.lo);                                         \
  187.     (r).hi += _a.hi * _b.lo + _a.lo * _b.hi;                              \
  188. }
  189.  
  190. /* XXX _jlong_lo16(a) = ((a) << 16 >> 16) is better on some archs (not on mips) */
  191. #define _jlong_lo16(a)        ((a) & JRI_BITMASK(16))
  192. #define _jlong_hi16(a)        ((a) >> 16)
  193.  
  194. /*
  195.  * Multiply 32-bit operands a and b to get 64-bit result r.
  196.  * Use polynomial expansion based on primitive field element (1 << 16).
  197.  */
  198. #define jlong_MUL32(r, a, b) {                                            \
  199.      juint _a1, _a0, _b1, _b0, _y0, _y1, _y2, _y3;                        \
  200.      _a1 = _jlong_hi16(a), _a0 = _jlong_lo16(a);                          \
  201.      _b1 = _jlong_hi16(b), _b0 = _jlong_lo16(b);                          \
  202.      _y0 = _a0 * _b0;                                                     \
  203.      _y1 = _a0 * _b1;                                                     \
  204.      _y2 = _a1 * _b0;                                                     \
  205.      _y3 = _a1 * _b1;                                                     \
  206.      _y1 += _jlong_hi16(_y0);                   /* can't carry */         \
  207.      _y1 += _y2;                                /* might carry */         \
  208.      if (_y1 < _y2) _y3 += 1 << 16;             /* propagate */           \
  209.      (r).lo = (_jlong_lo16(_y1) << 16) + _jlong_lo16(_y0);                \
  210.      (r).hi = _y3 + _jlong_hi16(_y1);                                     \
  211. }
  212.  
  213. /*
  214.  * Divide 64-bit unsigned operand a by 64-bit unsigned operand b, setting *qp
  215.  * to the 64-bit unsigned quotient, and *rp to the 64-bit unsigned remainder.
  216.  * Minimize effort if one of qp and rp is null.
  217.  */
  218. #define jlong_UDIVMOD(qp, rp, a, b)    jlong_udivmod(qp, rp, a, b)
  219.  
  220. extern JRI_PUBLIC_API(void)
  221. jlong_udivmod(julong *qp, julong *rp, julong a, julong b);
  222.  
  223. #define jlong_DIV(r, a, b) {                                              \
  224.     jlong _a, _b;                                                         \
  225.     juint _negative = (int32)(a).hi < 0;                                  \
  226.     if (_negative) {                                                      \
  227.     jlong_NEG(_a, a);                                                     \
  228.     } else {                                                              \
  229.     _a = a;                                                               \
  230.     }                                                                     \
  231.     if ((int32)(b).hi < 0) {                                              \
  232.     _negative ^= 1;                                                       \
  233.     jlong_NEG(_b, b);                                                     \
  234.     } else {                                                              \
  235.     _b = b;                                                               \
  236.     }                                                                     \
  237.     jlong_UDIVMOD(&(r), 0, _a, _b);                                       \
  238.     if (_negative)                                                        \
  239.     jlong_NEG(r, r);                                                      \
  240. }
  241.  
  242. #define jlong_MOD(r, a, b) {                                              \
  243.     jlong _a, _b;                                                         \
  244.     juint _negative = (int32)(a).hi < 0;                                  \
  245.     if (_negative) {                                                      \
  246.     jlong_NEG(_a, a);                                                     \
  247.     } else {                                                              \
  248.     _a = a;                                                               \
  249.     }                                                                     \
  250.     if ((int32)(b).hi < 0) {                                              \
  251.     jlong_NEG(_b, b);                                                     \
  252.     } else {                                                              \
  253.     _b = b;                                                               \
  254.     }                                                                     \
  255.     jlong_UDIVMOD(0, &(r), _a, _b);                                       \
  256.     if (_negative)                                                        \
  257.     jlong_NEG(r, r);                                                      \
  258. }
  259.  
  260. /*
  261.  * NB: b is a juint, not jlong or julong, for the shift ops.
  262.  */
  263. #define jlong_SHL(r, a, b) {                                              \
  264.     if (b) {                                                              \
  265.     jlong _a;                                                             \
  266.         _a = a;                                                           \
  267.         if ((b) < 32) {                                                   \
  268.         (r).lo = _a.lo << (b);                                            \
  269.         (r).hi = (_a.hi << (b)) | (_a.lo >> (32 - (b)));                  \
  270.     } else {                                                              \
  271.         (r).lo = 0;                                                       \
  272.         (r).hi = _a.lo << ((b) & 31);                                     \
  273.     }                                                                     \
  274.     } else {                                                              \
  275.     (r) = (a);                                                            \
  276.     }                                                                     \
  277. }
  278.  
  279. /* a is an int32, b is int32, r is jlong */
  280. #define jlong_ISHL(r, a, b) {                                             \
  281.     if (b) {                                                              \
  282.     jlong _a;                                                             \
  283.     _a.lo = (a);                                                          \
  284.     _a.hi = 0;                                                            \
  285.         if ((b) < 32) {                                                   \
  286.         (r).lo = (a) << (b);                                              \
  287.         (r).hi = ((a) >> (32 - (b)));                                     \
  288.     } else {                                                              \
  289.         (r).lo = 0;                                                       \
  290.         (r).hi = (a) << ((b) & 31);                                       \
  291.     }                                                                     \
  292.     } else {                                                              \
  293.     (r).lo = (a);                                                         \
  294.     (r).hi = 0;                                                           \
  295.     }                                                                     \
  296. }
  297.  
  298. #define jlong_SHR(r, a, b) {                                              \
  299.     if (b) {                                                              \
  300.     jlong _a;                                                             \
  301.         _a = a;                                                           \
  302.     if ((b) < 32) {                                                       \
  303.         (r).lo = (_a.hi << (32 - (b))) | (_a.lo >> (b));                  \
  304.         (r).hi = (int32)_a.hi >> (b);                                     \
  305.     } else {                                                              \
  306.         (r).lo = (int32)_a.hi >> ((b) & 31);                              \
  307.         (r).hi = (int32)_a.hi >> 31;                                      \
  308.     }                                                                     \
  309.     } else {                                                              \
  310.     (r) = (a);                                                            \
  311.     }                                                                     \
  312. }
  313.  
  314. #define jlong_USHR(r, a, b) {                                             \
  315.     if (b) {                                                              \
  316.     jlong _a;                                                             \
  317.         _a = a;                                                           \
  318.     if ((b) < 32) {                                                       \
  319.         (r).lo = (_a.hi << (32 - (b))) | (_a.lo >> (b));                  \
  320.         (r).hi = _a.hi >> (b);                                            \
  321.     } else {                                                              \
  322.         (r).lo = _a.hi >> ((b) & 31);                                     \
  323.         (r).hi = 0;                                                       \
  324.     }                                                                     \
  325.     } else {                                                              \
  326.     (r) = (a);                                                            \
  327.     }                                                                     \
  328. }
  329.  
  330. #define jlong_L2I(i, l)        ((i) = (l).lo)
  331. #define jlong_L2UI(ui, l)    ((ui) = (l).lo)
  332. #define jlong_L2F(f, l)        { double _d; jlong_L2D(_d, l); (f) = (float) _d; }
  333.  
  334. #define jlong_L2D(d, l) {                                                 \
  335.     int32 _negative;                                                      \
  336.     jlong _absval;                                                        \
  337.                                                                           \
  338.     _negative = (l).hi >> 31;                                             \
  339.     if (_negative) {                                                      \
  340.     jlong_NEG(_absval, l);                                                \
  341.     } else {                                                              \
  342.     _absval = l;                                                          \
  343.     }                                                                     \
  344.     (d) = (double)_absval.hi * 4.294967296e9 + _absval.lo;                \
  345.     if (_negative)                                                        \
  346.     (d) = -(d);                                                           \
  347. }
  348.  
  349. #define jlong_I2L(l, i)        ((l).hi = (i) >> 31, (l).lo = (i))
  350. #define jlong_UI2L(l, ui)    ((l).hi = 0, (l).lo = (ui))
  351. #define jlong_F2L(l, f)        { double _d = (double) f; jlong_D2L(l, _d); }
  352.  
  353. #define jlong_D2L(l, d) {                                                 \
  354.     int _negative;                                                        \
  355.     double _absval, _d_hi;                                                \
  356.     jlong _lo_d;                                                          \
  357.                                                                           \
  358.     _negative = ((d) < 0);                                                \
  359.     _absval = _negative ? -(d) : (d);                                     \
  360.                                                                           \
  361.     (l).hi = (juint)(_absval / 4.294967296e9);                            \
  362.     (l).lo = 0;                                                           \
  363.     jlong_L2D(_d_hi, l);                                                  \
  364.     _absval -= _d_hi;                                                     \
  365.     _lo_d.hi = 0;                                                         \
  366.     if (_absval < 0) {                                                    \
  367.     _lo_d.lo = (juint) -_absval;                                          \
  368.     jlong_SUB(l, l, _lo_d);                                               \
  369.     } else {                                                              \
  370.     _lo_d.lo = (juint) _absval;                                           \
  371.     jlong_ADD(l, l, _lo_d);                                               \
  372.     }                                                                     \
  373.                                                                           \
  374.     if (_negative)                                                        \
  375.     jlong_NEG(l, l);                                                      \
  376. }
  377.  
  378. #endif /* !HAVE_LONG_LONG */
  379.  
  380. /******************************************************************************/
  381. /*
  382. ** JDK Stuff -- This stuff is still needed while we're using the JDK
  383. ** dynamic linking strategy to call native methods.
  384. */
  385.  
  386. typedef union JRI_JDK_stack_item {
  387.     /* Non pointer items */
  388.     jint           i;
  389.     jfloat         f;
  390.     jint           o;
  391.     /* Pointer items */
  392.     void          *h;
  393.     void          *p;
  394.     unsigned char *addr;
  395. #ifdef OSF1
  396.     double         d;
  397.     long           l;        /* == 64bits! */
  398. #endif
  399. } JRI_JDK_stack_item;
  400.  
  401. typedef union JRI_JDK_Java8Str {
  402.     jint x[2];
  403.     jdouble d;
  404.     jlong l;
  405.     void *p;
  406.     float f;
  407. } JRI_JDK_Java8;
  408.  
  409. #ifdef HAVE_ALIGNED_LONGLONGS
  410. #define JRI_GET_INT64(_t,_addr) ( ((_t).x[0] = ((jint*)(_addr))[0]), \
  411.                               ((_t).x[1] = ((jint*)(_addr))[1]),      \
  412.                               (_t).l )
  413. #define JRI_SET_INT64(_t, _addr, _v) ( (_t).l = (_v),                \
  414.                                    ((jint*)(_addr))[0] = (_t).x[0], \
  415.                                    ((jint*)(_addr))[1] = (_t).x[1] )
  416. #else
  417. #define JRI_GET_INT64(_t,_addr) (*(jlong*)(_addr))
  418. #define JRI_SET_INT64(_t, _addr, _v) (*(jlong*)(_addr) = (_v))
  419. #endif
  420.  
  421. /* If double's must be aligned on doubleword boundaries then define this */
  422. #ifdef HAVE_ALIGNED_DOUBLES
  423. #define JRI_GET_DOUBLE(_t,_addr) ( ((_t).x[0] = ((jint*)(_addr))[0]), \
  424.                                ((_t).x[1] = ((jint*)(_addr))[1]),      \
  425.                                (_t).d )
  426. #define JRI_SET_DOUBLE(_t, _addr, _v) ( (_t).d = (_v),                \
  427.                                     ((jint*)(_addr))[0] = (_t).x[0], \
  428.                                     ((jint*)(_addr))[1] = (_t).x[1] )
  429. #else
  430. #define JRI_GET_DOUBLE(_t,_addr) (*(jdouble*)(_addr))
  431. #define JRI_SET_DOUBLE(_t, _addr, _v) (*(jdouble*)(_addr) = (_v))
  432. #endif
  433.  
  434. /******************************************************************************/
  435. #ifdef __cplusplus
  436. }
  437. #endif
  438. #endif /* JRI_MD_H */
  439. /******************************************************************************/
  440.