jri__md_8h-source.html

jri_md.h

00001 /* -*- Mode: C; tab-width: 4; -*- */
00002 /*******************************************************************************
00003  * Java Runtime Interface - Machine Dependent Types
00004  * Copyright (c) 1996 Netscape Communications Corporation. All rights reserved.
00005  ******************************************************************************/
00006  
00007 #ifndef JRI_MD_H
00008 #define JRI_MD_H
00009 
00010 #include <assert.h>
00011 
00012 #ifdef __cplusplus
00013 extern "C" {
00014 #endif
00015 
00016 /*******************************************************************************
00017  * WHAT'S UP WITH THIS FILE?
00018  * 
00019  * This is where we define the mystical JRI_PUBLIC_API macro that works on all
00020  * platforms. If you're running with Visual C++, Symantec C, or Borland's 
00021  * development environment on the PC, you're all set. Or if you're on the Mac
00022  * with Metrowerks, Symantec or MPW with SC you're ok too. For UNIX it shouldn't
00023  * matter.
00024  *
00025  * On UNIX though you probably care about a couple of other symbols though:
00026  *      IS_LITTLE_ENDIAN must be defined for little-endian systems
00027  *      HAVE_LONG_LONG must be defined on systems that have 'long long' integers
00028  *      HAVE_ALIGNED_LONGLONGS must be defined if long-longs must be 8 byte aligned
00029  *      HAVE_ALIGNED_DOUBLES must be defined if doubles must be 8 byte aligned
00030  *      IS_64 must be defined on 64-bit machines (like Dec Alpha)
00031  ******************************************************************************/
00032 
00033 /* DLL Entry modifiers... */
00034 
00035 /* PC */
00036 #if defined(XP_PC) || defined(_WINDOWS) || defined(WIN32) || defined(_WIN32)
00037 #       include <windows.h>
00038 #       if defined(_MSC_VER)
00039 #               if defined(WIN32) || defined(_WIN32)
00040 #                       define JRI_PUBLIC_API(ResultType)       _declspec(dllexport) ResultType
00041 #                       define JRI_CALLBACK
00042 #               else /* !_WIN32 */
00043 #                   if defined(_WINDLL)
00044 #                       define JRI_PUBLIC_API(ResultType)       ResultType __cdecl __export __loadds 
00045 #                       define JRI_CALLBACK                     __loadds
00046 #                   else /* !WINDLL */
00047 #                       define JRI_PUBLIC_API(ResultType)       ResultType __cdecl __export
00048 #                       define JRI_CALLBACK                     __export
00049 #                   endif /* !WINDLL */
00050 #               endif /* !_WIN32 */
00051 #       elif defined(__BORLANDC__)
00052 #               if defined(WIN32) || defined(_WIN32)
00053 #                       define JRI_PUBLIC_API(ResultType)       __export ResultType
00054 #                       define JRI_CALLBACK
00055 #               else /* !_WIN32 */
00056 #                       define JRI_PUBLIC_API(ResultType)       ResultType _cdecl _export _loadds 
00057 #                       define JRI_CALLBACK                                     _loadds
00058 #               endif
00059 #       else
00060 #               error Unsupported PC development environment.   
00061 #       endif
00062 #       ifndef IS_LITTLE_ENDIAN
00063 #               define IS_LITTLE_ENDIAN
00064 #       endif
00065 
00066 /* Mac */
00067 #elif macintosh || Macintosh || THINK_C
00068 #       if defined(__MWERKS__)                          /* Metrowerks */
00069 #               if !__option(enumsalwaysint)
00070 #                       error You need to define 'Enums Always Int' for your project.
00071 #               endif
00072 #               if defined(GENERATING68K) && !GENERATINGCFM 
00073 #                       if !__option(fourbyteints) 
00074 #                               error You need to define 'Struct Alignment: 68k' for your project.
00075 #                       endif
00076 #               endif /* !GENERATINGCFM */
00077 #       elif defined(__SC__)                            /* Symantec */
00078 #               error What are the Symantec defines? (warren@netscape.com)
00079 #       elif macintosh && applec                        /* MPW */
00080 #               error Please upgrade to the latest MPW compiler (SC).
00081 #       else
00082 #               error Unsupported Mac development environment.
00083 #       endif
00084 #       define JRI_PUBLIC_API(ResultType)               ResultType
00085 #       define JRI_CALLBACK
00086 
00087 /* Unix or else */
00088 #else
00089 #       define JRI_PUBLIC_API(ResultType)               ResultType
00090 #       define JRI_CALLBACK
00091 #endif
00092 
00093 #ifndef FAR             /* for non-Win16 */
00094 #define FAR
00095 #endif
00096 
00097 /******************************************************************************/
00098 
00099 /* Java Scalar Types */
00100 
00101 typedef unsigned char   jbool;
00102 typedef char                    jbyte;
00103 typedef short                   jchar;
00104 typedef short                   jshort;
00105 #ifdef IS_64 /* XXX ok for alpha, but not right on all 64-bit architectures */
00106 typedef unsigned int    juint;
00107 typedef int                             jint;
00108 #else
00109 typedef unsigned long   juint;
00110 typedef long                    jint;
00111 #endif
00112 typedef float                   jfloat;
00113 typedef double                  jdouble;
00114 
00115 typedef juint                   jsize;
00116 
00117 /*******************************************************************************
00118  * jlong : long long (64-bit signed integer type) support.
00119  ******************************************************************************/
00120 
00121 /*
00122 ** Bit masking macros.  (n must be <= 31 to be portable)
00123 */
00124 #define JRI_BIT(n)                      ((juint)1 << (n))
00125 #define JRI_BITMASK(n)          (JRI_BIT(n) - 1)
00126 
00127 #ifdef HAVE_LONG_LONG
00128 
00129 #if !(defined(WIN32) || defined(_WIN32))
00130 typedef long long                       jlong;
00131 typedef unsigned long long      julong;
00132 
00133 #define jlong_MAXINT            0x7fffffffffffffffLL
00134 #define jlong_MININT            0x8000000000000000LL
00135 #define jlong_ZERO                      0x0LL
00136 
00137 #else
00138 typedef LONGLONG                        jlong;
00139 typedef DWORDLONG                       julong;
00140 
00141 #define jlong_MAXINT            0x7fffffffffffffffi64
00142 #define jlong_MININT            0x8000000000000000i64
00143 #define jlong_ZERO                      0x0i64
00144 
00145 #endif
00146 
00147 #define jlong_IS_ZERO(a)        ((a) == 0)
00148 #define jlong_EQ(a, b)          ((a) == (b))
00149 #define jlong_NE(a, b)          ((a) != (b))
00150 #define jlong_GE_ZERO(a)        ((a) >= 0)
00151 #define jlong_CMP(a, op, b)     ((a) op (b))
00152 
00153 #define jlong_AND(r, a, b)      ((r) = (a) & (b))
00154 #define jlong_OR(r, a, b)       ((r) = (a) | (b))
00155 #define jlong_XOR(r, a, b)      ((r) = (a) ^ (b))
00156 #define jlong_OR2(r, a)         ((r) = (r) | (a))
00157 #define jlong_NOT(r, a)         ((r) = ~(a))
00158 
00159 #define jlong_NEG(r, a)         ((r) = -(a))
00160 #define jlong_ADD(r, a, b)      ((r) = (a) + (b))
00161 #define jlong_SUB(r, a, b)      ((r) = (a) - (b))
00162 
00163 #define jlong_MUL(r, a, b)      ((r) = (a) * (b))
00164 #define jlong_DIV(r, a, b)      ((r) = (a) / (b))
00165 #define jlong_MOD(r, a, b)      ((r) = (a) % (b))
00166 
00167 #define jlong_SHL(r, a, b)      ((r) = (a) << (b))
00168 #define jlong_SHR(r, a, b)      ((r) = (a) >> (b))
00169 #define jlong_USHR(r, a, b)     ((r) = (julong)(a) >> (b))
00170 #define jlong_ISHL(r, a, b)     ((r) = ((jlong)(a)) << (b))
00171 
00172 #define jlong_L2I(i, l)         ((i) = (int)(l))
00173 #define jlong_L2UI(ui, l)       ((ui) =(unsigned int)(l))
00174 #define jlong_L2F(f, l)         ((f) = (l))
00175 #define jlong_L2D(d, l)         ((d) = (l))
00176 
00177 #define jlong_I2L(l, i)         ((l) = (i))
00178 #define jlong_UI2L(l, ui)       ((l) = (ui))
00179 #define jlong_F2L(l, f)         ((l) = (f))
00180 #define jlong_D2L(l, d)         ((l) = (d))
00181 
00182 #define jlong_UDIVMOD(qp, rp, a, b)  \
00183     (*(qp) = ((julong)(a) / (b)), \
00184      *(rp) = ((julong)(a) % (b)))
00185 
00186 #else  /* !HAVE_LONG_LONG */
00187 
00188 typedef struct {
00189 #ifdef IS_LITTLE_ENDIAN
00190     juint lo, hi;
00191 #else
00192     juint hi, lo;
00193 #endif
00194 } jlong;
00195 typedef jlong                           julong;
00196 
00197 extern jlong jlong_MAXINT, jlong_MININT, jlong_ZERO;
00198 
00199 #define jlong_IS_ZERO(a)        (((a).hi == 0) && ((a).lo == 0))
00200 #define jlong_EQ(a, b)          (((a).hi == (b).hi) && ((a).lo == (b).lo))
00201 #define jlong_NE(a, b)          (((a).hi != (b).hi) || ((a).lo != (b).lo))
00202 #define jlong_GE_ZERO(a)        (((a).hi >> 31) == 0)
00203 
00204 /*
00205  * NB: jlong_CMP and jlong_UCMP work only for strict relationals (<, >).
00206  */
00207 #define jlong_CMP(a, op, b)     (((int32)(a).hi op (int32)(b).hi) ||          \
00208                                  (((a).hi == (b).hi) && ((a).lo op (b).lo)))
00209 #define jlong_UCMP(a, op, b)    (((a).hi op (b).hi) ||                    \
00210                                  (((a).hi == (b).hi) && ((a).lo op (b).lo)))
00211 
00212 #define jlong_AND(r, a, b)      ((r).lo = (a).lo & (b).lo,                    \
00213                                  (r).hi = (a).hi & (b).hi)
00214 #define jlong_OR(r, a, b)       ((r).lo = (a).lo | (b).lo,                    \
00215                                  (r).hi = (a).hi | (b).hi)
00216 #define jlong_XOR(r, a, b)      ((r).lo = (a).lo ^ (b).lo,                    \
00217                                  (r).hi = (a).hi ^ (b).hi)
00218 #define jlong_OR2(r, a)         ((r).lo = (r).lo | (a).lo,                    \
00219                                  (r).hi = (r).hi | (a).hi)
00220 #define jlong_NOT(r, a)         ((r).lo = ~(a).lo,                                \
00221                                  (r).hi = ~(a).hi)
00222 
00223 #define jlong_NEG(r, a)         ((r).lo = -(int32)(a).lo,                     \
00224                                  (r).hi = -(int32)(a).hi - ((r).lo != 0))
00225 #define jlong_ADD(r, a, b) {                                              \
00226     jlong _a, _b;                                                         \
00227     _a = a; _b = b;                                                       \
00228     (r).lo = _a.lo + _b.lo;                                               \
00229     (r).hi = _a.hi + _b.hi + ((r).lo < _b.lo);                            \
00230 }
00231 
00232 #define jlong_SUB(r, a, b) {                                              \
00233     jlong _a, _b;                                                         \
00234     _a = a; _b = b;                                                       \
00235     (r).lo = _a.lo - _b.lo;                                               \
00236     (r).hi = _a.hi - _b.hi - (_a.lo < _b.lo);                             \
00237 }                                                                         \
00238 
00239 /*
00240  * Multiply 64-bit operands a and b to get 64-bit result r.
00241  * First multiply the low 32 bits of a and b to get a 64-bit result in r.
00242  * Then add the outer and inner products to r.hi.
00243  */
00244 #define jlong_MUL(r, a, b) {                                              \
00245     jlong _a, _b;                                                         \
00246     _a = a; _b = b;                                                       \
00247     jlong_MUL32(r, _a.lo, _b.lo);                                         \
00248     (r).hi += _a.hi * _b.lo + _a.lo * _b.hi;                              \
00249 }
00250 
00251 /* XXX _jlong_lo16(a) = ((a) << 16 >> 16) is better on some archs (not on mips) */
00252 #define _jlong_lo16(a)          ((a) & JRI_BITMASK(16))
00253 #define _jlong_hi16(a)          ((a) >> 16)
00254 
00255 /*
00256  * Multiply 32-bit operands a and b to get 64-bit result r.
00257  * Use polynomial expansion based on primitive field element (1 << 16).
00258  */
00259 #define jlong_MUL32(r, a, b) {                                            \
00260      juint _a1, _a0, _b1, _b0, _y0, _y1, _y2, _y3;                        \
00261      _a1 = _jlong_hi16(a), _a0 = _jlong_lo16(a);                          \
00262      _b1 = _jlong_hi16(b), _b0 = _jlong_lo16(b);                          \
00263      _y0 = _a0 * _b0;                                                     \
00264      _y1 = _a0 * _b1;                                                     \
00265      _y2 = _a1 * _b0;                                                     \
00266      _y3 = _a1 * _b1;                                                     \
00267      _y1 += _jlong_hi16(_y0);                   /* can't carry */         \
00268      _y1 += _y2;                                /* might carry */         \
00269      if (_y1 < _y2) _y3 += 1 << 16;             /* propagate */           \
00270      (r).lo = (_jlong_lo16(_y1) << 16) + _jlong_lo16(_y0);                \
00271      (r).hi = _y3 + _jlong_hi16(_y1);                                     \
00272 }
00273 
00274 /*
00275  * Divide 64-bit unsigned operand a by 64-bit unsigned operand b, setting *qp
00276  * to the 64-bit unsigned quotient, and *rp to the 64-bit unsigned remainder.
00277  * Minimize effort if one of qp and rp is null.
00278  */
00279 #define jlong_UDIVMOD(qp, rp, a, b)     jlong_udivmod(qp, rp, a, b)
00280 
00281 extern JRI_PUBLIC_API(void)
00282 jlong_udivmod(julong *qp, julong *rp, julong a, julong b);
00283 
00284 #define jlong_DIV(r, a, b) {                                              \
00285     jlong _a, _b;                                                         \
00286     juint _negative = (int32)(a).hi < 0;                                  \
00287     if (_negative) {                                                      \
00288         jlong_NEG(_a, a);                                                     \
00289     } else {                                                              \
00290         _a = a;                                                               \
00291     }                                                                     \
00292     if ((int32)(b).hi < 0) {                                              \
00293         _negative ^= 1;                                                       \
00294         jlong_NEG(_b, b);                                                     \
00295     } else {                                                              \
00296         _b = b;                                                               \
00297     }                                                                     \
00298     jlong_UDIVMOD(&(r), 0, _a, _b);                                       \
00299     if (_negative)                                                        \
00300         jlong_NEG(r, r);                                                      \
00301 }
00302 
00303 #define jlong_MOD(r, a, b) {                                              \
00304     jlong _a, _b;                                                         \
00305     juint _negative = (int32)(a).hi < 0;                                  \
00306     if (_negative) {                                                      \
00307         jlong_NEG(_a, a);                                                     \
00308     } else {                                                              \
00309         _a = a;                                                               \
00310     }                                                                     \
00311     if ((int32)(b).hi < 0) {                                              \
00312         jlong_NEG(_b, b);                                                     \
00313     } else {                                                              \
00314         _b = b;                                                               \
00315     }                                                                     \
00316     jlong_UDIVMOD(0, &(r), _a, _b);                                       \
00317     if (_negative)                                                        \
00318         jlong_NEG(r, r);                                                      \
00319 }
00320 
00321 /*
00322  * NB: b is a juint, not jlong or julong, for the shift ops.
00323  */
00324 #define jlong_SHL(r, a, b) {                                              \
00325     if (b) {                                                              \
00326         jlong _a;                                                             \
00327         _a = a;                                                           \
00328         if ((b) < 32) {                                                   \
00329             (r).lo = _a.lo << (b);                                            \
00330             (r).hi = (_a.hi << (b)) | (_a.lo >> (32 - (b)));                  \
00331         } else {                                                              \
00332             (r).lo = 0;                                                       \
00333             (r).hi = _a.lo << ((b) & 31);                                     \
00334         }                                                                     \
00335     } else {                                                              \
00336         (r) = (a);                                                            \
00337     }                                                                     \
00338 }
00339 
00340 /* a is an int32, b is int32, r is jlong */
00341 #define jlong_ISHL(r, a, b) {                                             \
00342     if (b) {                                                              \
00343         jlong _a;                                                             \
00344         _a.lo = (a);                                                          \
00345         _a.hi = 0;                                                            \
00346         if ((b) < 32) {                                                   \
00347             (r).lo = (a) << (b);                                              \
00348             (r).hi = ((a) >> (32 - (b)));                                     \
00349         } else {                                                              \
00350             (r).lo = 0;                                                       \
00351             (r).hi = (a) << ((b) & 31);                                       \
00352         }                                                                     \
00353     } else {                                                              \
00354         (r).lo = (a);                                                         \
00355         (r).hi = 0;                                                           \
00356     }                                                                     \
00357 }
00358 
00359 #define jlong_SHR(r, a, b) {                                              \
00360     if (b) {                                                              \
00361         jlong _a;                                                             \
00362         _a = a;                                                           \
00363         if ((b) < 32) {                                                       \
00364             (r).lo = (_a.hi << (32 - (b))) | (_a.lo >> (b));                  \
00365             (r).hi = (int32)_a.hi >> (b);                                     \
00366         } else {                                                              \
00367             (r).lo = (int32)_a.hi >> ((b) & 31);                              \
00368             (r).hi = (int32)_a.hi >> 31;                                      \
00369         }                                                                     \
00370     } else {                                                              \
00371         (r) = (a);                                                            \
00372     }                                                                     \
00373 }
00374 
00375 #define jlong_USHR(r, a, b) {                                             \
00376     if (b) {                                                              \
00377         jlong _a;                                                             \
00378         _a = a;                                                           \
00379         if ((b) < 32) {                                                       \
00380             (r).lo = (_a.hi << (32 - (b))) | (_a.lo >> (b));                  \
00381             (r).hi = _a.hi >> (b);                                            \
00382         } else {                                                              \
00383             (r).lo = _a.hi >> ((b) & 31);                                     \
00384             (r).hi = 0;                                                       \
00385         }                                                                     \
00386     } else {                                                              \
00387         (r) = (a);                                                            \
00388     }                                                                     \
00389 }
00390 
00391 #define jlong_L2I(i, l)         ((i) = (l).lo)
00392 #define jlong_L2UI(ui, l)       ((ui) = (l).lo)
00393 #define jlong_L2F(f, l)         { double _d; jlong_L2D(_d, l); (f) = (float) _d; }
00394 
00395 #define jlong_L2D(d, l) {                                                 \
00396     int32 _negative;                                                      \
00397     jlong _absval;                                                        \
00398                                                                           \
00399     _negative = (l).hi >> 31;                                             \
00400     if (_negative) {                                                      \
00401         jlong_NEG(_absval, l);                                                \
00402     } else {                                                              \
00403         _absval = l;                                                          \
00404     }                                                                     \
00405     (d) = (double)_absval.hi * 4.294967296e9 + _absval.lo;                \
00406     if (_negative)                                                        \
00407         (d) = -(d);                                                           \
00408 }
00409 
00410 #define jlong_I2L(l, i)         ((l).hi = (i) >> 31, (l).lo = (i))
00411 #define jlong_UI2L(l, ui)       ((l).hi = 0, (l).lo = (ui))
00412 #define jlong_F2L(l, f)         { double _d = (double) f; jlong_D2L(l, _d); }
00413 
00414 #define jlong_D2L(l, d) {                                                 \
00415     int _negative;                                                        \
00416     double _absval, _d_hi;                                                \
00417     jlong _lo_d;                                                          \
00418                                                                           \
00419     _negative = ((d) < 0);                                                \
00420     _absval = _negative ? -(d) : (d);                                     \
00421                                                                           \
00422     (l).hi = (juint)(_absval / 4.294967296e9);                            \
00423     (l).lo = 0;                                                           \
00424     jlong_L2D(_d_hi, l);                                                  \
00425     _absval -= _d_hi;                                                     \
00426     _lo_d.hi = 0;                                                         \
00427     if (_absval < 0) {                                                    \
00428         _lo_d.lo = (juint) -_absval;                                          \
00429         jlong_SUB(l, l, _lo_d);                                               \
00430     } else {                                                              \
00431         _lo_d.lo = (juint) _absval;                                           \
00432         jlong_ADD(l, l, _lo_d);                                               \
00433     }                                                                     \
00434                                                                           \
00435     if (_negative)                                                        \
00436         jlong_NEG(l, l);                                                      \
00437 }
00438 
00439 #endif /* !HAVE_LONG_LONG */
00440 
00441 /******************************************************************************/
00442 /*
00443 ** JDK Stuff -- This stuff is still needed while we're using the JDK
00444 ** dynamic linking strategy to call native methods.
00445 */
00446 
00447 typedef union JRI_JDK_stack_item {
00448     /* Non pointer items */
00449     jint           i;
00450     jfloat         f;
00451     jint           o;
00452     /* Pointer items */
00453     void          *h;
00454     void          *p;
00455     unsigned char *addr;
00456 #ifdef IS_64
00457     double         d;
00458     long           l;           /* == 64bits! */
00459 #endif
00460 } JRI_JDK_stack_item;
00461 
00462 typedef union JRI_JDK_Java8Str {
00463     jint x[2];
00464     jdouble d;
00465     jlong l;
00466     void *p;
00467     float f;
00468 } JRI_JDK_Java8;
00469 
00470 #ifdef HAVE_ALIGNED_LONGLONGS
00471 #define JRI_GET_INT64(_t,_addr) ( ((_t).x[0] = ((jint*)(_addr))[0]), \
00472                               ((_t).x[1] = ((jint*)(_addr))[1]),      \
00473                               (_t).l )
00474 #define JRI_SET_INT64(_t, _addr, _v) ( (_t).l = (_v),                \
00475                                    ((jint*)(_addr))[0] = (_t).x[0], \
00476                                    ((jint*)(_addr))[1] = (_t).x[1] )
00477 #else
00478 #define JRI_GET_INT64(_t,_addr) (*(jlong*)(_addr))
00479 #define JRI_SET_INT64(_t, _addr, _v) (*(jlong*)(_addr) = (_v))
00480 #endif
00481 
00482 /* If double's must be aligned on doubleword boundaries then define this */
00483 #ifdef HAVE_ALIGNED_DOUBLES
00484 #define JRI_GET_DOUBLE(_t,_addr) ( ((_t).x[0] = ((jint*)(_addr))[0]), \
00485                                ((_t).x[1] = ((jint*)(_addr))[1]),      \
00486                                (_t).d )
00487 #define JRI_SET_DOUBLE(_t, _addr, _v) ( (_t).d = (_v),                \
00488                                     ((jint*)(_addr))[0] = (_t).x[0], \
00489                                     ((jint*)(_addr))[1] = (_t).x[1] )
00490 #else
00491 #define JRI_GET_DOUBLE(_t,_addr) (*(jdouble*)(_addr))
00492 #define JRI_SET_DOUBLE(_t, _addr, _v) (*(jdouble*)(_addr) = (_v))
00493 #endif
00494 
00495 /******************************************************************************/
00496 #ifdef __cplusplus
00497 }
00498 #endif
00499 #endif /* JRI_MD_H */
00500 /******************************************************************************/

Generated on Thu Nov 25 15:42:53 2004 for iARS(internetAudioRenderingSystem) by  doxygen 1.3.9.1