"Fossies" - the Fresh Open Source Software Archive

Member "google-gadgets-for-linux-0.11.2/third_party/npapi/jri_md.h" (15 Mar 2009, 26565 Bytes) of package /linux/misc/old/google-gadgets-for-linux-0.11.2.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file.

    1 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
    2 /* ***** BEGIN LICENSE BLOCK *****
    3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
    4  *
    5  * The contents of this file are subject to the Mozilla Public License Version
    6  * 1.1 (the "License"); you may not use this file except in compliance with
    7  * the License. You may obtain a copy of the License at
    8  * http://www.mozilla.org/MPL/
    9  *
   10  * Software distributed under the License is distributed on an "AS IS" basis,
   11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
   12  * for the specific language governing rights and limitations under the
   13  * License.
   14  *
   15  * The Original Code is mozilla.org code.
   16  *
   17  * The Initial Developer of the Original Code is
   18  * Netscape Communications Corporation.
   19  * Portions created by the Initial Developer are Copyright (C) 1998
   20  * the Initial Developer. All Rights Reserved.
   21  *
   22  * Contributor(s):
   23  *
   24  * Alternatively, the contents of this file may be used under the terms of
   25  * either the GNU General Public License Version 2 or later (the "GPL"), or
   26  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
   27  * in which case the provisions of the GPL or the LGPL are applicable instead
   28  * of those above. If you wish to allow use of your version of this file only
   29  * under the terms of either the GPL or the LGPL, and not to allow others to
   30  * use your version of this file under the terms of the MPL, indicate your
   31  * decision by deleting the provisions above and replace them with the notice
   32  * and other provisions required by the GPL or the LGPL. If you do not delete
   33  * the provisions above, a recipient may use your version of this file under
   34  * the terms of any one of the MPL, the GPL or the LGPL.
   35  *
   36  * ***** END LICENSE BLOCK ***** */
   37 
   38 /*******************************************************************************
   39  * Java Runtime Interface - Machine Dependent Types
   40  ******************************************************************************/
   41  
   42 #ifndef JRI_MD_H
   43 #define JRI_MD_H
   44 
   45 #include <assert.h>
   46 #include "prtypes.h" /* Needed for HAS_LONG_LONG ifdefs */
   47 
   48 #ifdef __cplusplus
   49 extern "C" {
   50 #endif
   51 
   52 /*******************************************************************************
   53  * WHAT'S UP WITH THIS FILE?
   54  * 
   55  * This is where we define the mystical JRI_PUBLIC_API macro that works on all
   56  * platforms. If you're running with Visual C++, Symantec C, or Borland's 
   57  * development environment on the PC, you're all set. Or if you're on the Mac
   58  * with Metrowerks, Symantec or MPW with SC you're ok too. For UNIX it shouldn't
   59  * matter.
   60  *
   61  * On UNIX though you probably care about a couple of other symbols though:
   62  *  IS_LITTLE_ENDIAN must be defined for little-endian systems
   63  *  HAVE_LONG_LONG must be defined on systems that have 'long long' integers
   64  *  HAVE_ALIGNED_LONGLONGS must be defined if long-longs must be 8 byte aligned
   65  *  HAVE_ALIGNED_DOUBLES must be defined if doubles must be 8 byte aligned
   66  *  IS_64 must be defined on 64-bit machines (like Dec Alpha)
   67  ******************************************************************************/
   68 
   69 /* DLL Entry modifiers... */
   70 
   71 /* Windows */
   72 #if defined(XP_WIN) || defined(_WINDOWS) || defined(WIN32) || defined(_WIN32)
   73 #   include <windows.h>
   74 #   if defined(_MSC_VER) || defined(__GNUC__)
   75 #       if defined(WIN32) || defined(_WIN32)
   76 #           define JRI_PUBLIC_API(ResultType)  __declspec(dllexport) ResultType
   77 #           define JRI_PUBLIC_VAR(VarType)     VarType
   78 #           define JRI_PUBLIC_VAR_EXP(VarType) __declspec(dllexport) VarType
   79 #           define JRI_PUBLIC_VAR_IMP(VarType) __declspec(dllimport) VarType
   80 #           define JRI_NATIVE_STUB(ResultType) __declspec(dllexport) ResultType
   81 #           define JRI_CALLBACK
   82 #       else /* !_WIN32 */
   83 #           if defined(_WINDLL)
   84 #           define JRI_PUBLIC_API(ResultType)   ResultType __cdecl __export __loadds 
   85 #           define JRI_PUBLIC_VAR(VarType)      VarType
   86 #           define JRI_PUBLIC_VAR_EXP(VarType)  JRI_PUBLIC_VAR(VarType)
   87 #           define JRI_PUBLIC_VAR_IMP(VarType)  JRI_PUBLIC_VAR(VarType)
   88 #           define JRI_NATIVE_STUB(ResultType)  ResultType __cdecl __loadds
   89 #           define JRI_CALLBACK         __loadds
   90 #       else /* !WINDLL */
   91 #           define JRI_PUBLIC_API(ResultType)   ResultType __cdecl __export
   92 #           define JRI_PUBLIC_VAR(VarType)      VarType
   93 #           define JRI_PUBLIC_VAR_EXP(VarType)  JRI_PUBLIC_VAR(VarType)
   94 #           define JRI_PUBLIC_VAR_IMP(VarType)  JRI_PUBLIC_VAR(VarType)
   95 #           define JRI_NATIVE_STUB(ResultType)  ResultType __cdecl __export
   96 #           define JRI_CALLBACK         __export
   97 #                   endif /* !WINDLL */
   98 #       endif /* !_WIN32 */
   99 #   elif defined(__BORLANDC__)
  100 #       if defined(WIN32) || defined(_WIN32)
  101 #           define JRI_PUBLIC_API(ResultType)   __export ResultType
  102 #           define JRI_PUBLIC_VAR(VarType)      VarType
  103 #           define JRI_PUBLIC_VAR_EXP(VarType)  __export VarType
  104 #           define JRI_PUBLIC_VAR_IMP(VarType)  __import VarType
  105 #           define JRI_NATIVE_STUB(ResultType)   __export ResultType
  106 #           define JRI_CALLBACK
  107 #       else /* !_WIN32 */
  108 #           define JRI_PUBLIC_API(ResultType)   ResultType _cdecl _export _loadds 
  109 #           define JRI_PUBLIC_VAR(VarType)      VarType
  110 #           define JRI_PUBLIC_VAR_EXP(VarType)  __cdecl __export VarType
  111 #           define JRI_PUBLIC_VAR_IMP(VarType)  __cdecl __import VarType
  112 #           define JRI_NATIVE_STUB(ResultType)  ResultType _cdecl _loadds
  113 #           define JRI_CALLBACK         _loadds
  114 #       endif
  115 #   else
  116 #       error Unsupported PC development environment.   
  117 #   endif
  118 #   ifndef IS_LITTLE_ENDIAN
  119 #       define IS_LITTLE_ENDIAN
  120 #   endif
  121 
  122 /* OS/2 */
  123 #elif defined(XP_OS2)
  124 #   ifdef XP_OS2_VACPP
  125 #       define JRI_PUBLIC_API(ResultType)   ResultType _Optlink
  126 #       define JRI_PUBLIC_VAR(VarType)      VarType
  127 #           define JRI_CALLBACK
  128 #   elif defined(__declspec)
  129 #       define JRI_PUBLIC_API(ResultType)   __declspec(dllexport) ResultType
  130 #       define JRI_PUBLIC_VAR(VarType)      VarType
  131 #       define JRI_PUBLIC_VAR_EXP(VarType)  __declspec(dllexport) VarType
  132 #       define JRI_PUBLIC_VAR_IMP(VarType)  __declspec(dllimport) VarType
  133 #       define JRI_NATIVE_STUB(ResultType)  __declspec(dllexport) ResultType
  134 #       define JRI_CALLBACK
  135 #   else
  136 #       define JRI_PUBLIC_API(ResultType)   ResultType
  137 #       define JRI_PUBLIC_VAR(VarType)      VarType
  138 #       define JRI_CALLBACK
  139 #   endif
  140 
  141 /* Mac */
  142 #elif defined (macintosh) || Macintosh || THINK_C
  143 #   if defined(__MWERKS__)              /* Metrowerks */
  144 #       if !__option(enumsalwaysint)
  145 #           error You need to define 'Enums Always Int' for your project.
  146 #       endif
  147 #       if defined(TARGET_CPU_68K) && !TARGET_RT_MAC_CFM 
  148 #           if !__option(fourbyteints) 
  149 #               error You need to define 'Struct Alignment: 68k' for your project.
  150 #           endif
  151 #       endif /* !GENERATINGCFM */
  152 #       define JRI_PUBLIC_API(ResultType)   __declspec(export) ResultType
  153 #       define JRI_PUBLIC_VAR(VarType)      JRI_PUBLIC_API(VarType)
  154 #       define JRI_PUBLIC_VAR_EXP(VarType)  JRI_PUBLIC_API(VarType)
  155 #       define JRI_PUBLIC_VAR_IMP(VarType)  JRI_PUBLIC_API(VarType)
  156 #       define JRI_NATIVE_STUB(ResultType)  JRI_PUBLIC_API(ResultType)
  157 #   elif defined(__SC__)                /* Symantec */
  158 #       error What are the Symantec defines? (warren@netscape.com)
  159 #   elif macintosh && applec            /* MPW */
  160 #       error Please upgrade to the latest MPW compiler (SC).
  161 #   else
  162 #       error Unsupported Mac development environment.
  163 #   endif
  164 #   define JRI_CALLBACK
  165 
  166 /* Unix or else */
  167 #else
  168 #   define JRI_PUBLIC_API(ResultType)       ResultType
  169 #   define JRI_PUBLIC_VAR(VarType)          VarType
  170 #   define JRI_PUBLIC_VAR_EXP(VarType)      JRI_PUBLIC_VAR(VarType)
  171 #   define JRI_PUBLIC_VAR_IMP(VarType)      JRI_PUBLIC_VAR(VarType)
  172 #   define JRI_NATIVE_STUB(ResultType)      ResultType
  173 #   define JRI_CALLBACK
  174 #endif
  175 
  176 #ifndef FAR     /* for non-Win16 */
  177 #define FAR
  178 #endif
  179 
  180 /******************************************************************************/
  181 
  182 /* Java Scalar Types */
  183 
  184 #if 0   /* now in jni.h */
  185 typedef short           jchar;
  186 typedef short           jshort;
  187 typedef float           jfloat;
  188 typedef double          jdouble;
  189 typedef juint           jsize;
  190 #endif
  191 
  192 /* moved from jni.h -- Sun's new jni.h doesn't have this anymore */
  193 #ifdef __cplusplus
  194 typedef class _jobject *jref;
  195 #else
  196 typedef struct _jobject *jref;
  197 #endif
  198 
  199 typedef unsigned char   jbool;
  200 typedef signed char jbyte;
  201 #ifdef IS_64 /* XXX ok for alpha, but not right on all 64-bit architectures */
  202 typedef unsigned int    juint;
  203 typedef int             jint;
  204 #else
  205 typedef unsigned long   juint;
  206 typedef long            jint;
  207 #endif
  208 
  209 /*******************************************************************************
  210  * jlong : long long (64-bit signed integer type) support.
  211  ******************************************************************************/
  212 
  213 /*
  214 ** Bit masking macros.  (n must be <= 31 to be portable)
  215 */
  216 #define JRI_BIT(n)          ((juint)1 << (n))
  217 #define JRI_BITMASK(n)      (JRI_BIT(n) - 1)
  218 
  219 #ifdef HAVE_LONG_LONG
  220 
  221 #ifdef OSF1
  222 
  223 /* long is default 64-bit on OSF1, -std1 does not allow long long */
  224 typedef long                  jlong;
  225 typedef unsigned long         julong;
  226 #define jlong_MAXINT          0x7fffffffffffffffL
  227 #define jlong_MININT          0x8000000000000000L
  228 #define jlong_ZERO            0x0L
  229 
  230 #elif (defined(WIN32) || defined(_WIN32))
  231 
  232 typedef LONGLONG              jlong;
  233 typedef DWORDLONG             julong;
  234 #define jlong_MAXINT          0x7fffffffffffffffi64
  235 #define jlong_MININT          0x8000000000000000i64
  236 #define jlong_ZERO            0x0i64
  237 
  238 #else
  239 
  240 typedef long long             jlong;
  241 typedef unsigned long long    julong;
  242 #define jlong_MAXINT          0x7fffffffffffffffLL
  243 #define jlong_MININT          0x8000000000000000LL
  244 #define jlong_ZERO            0x0LL
  245 
  246 #endif
  247 
  248 #define jlong_IS_ZERO(a)    ((a) == 0)
  249 #define jlong_EQ(a, b)      ((a) == (b))
  250 #define jlong_NE(a, b)      ((a) != (b))
  251 #define jlong_GE_ZERO(a)    ((a) >= 0)
  252 #define jlong_CMP(a, op, b) ((a) op (b))
  253 
  254 #define jlong_AND(r, a, b)  ((r) = (a) & (b))
  255 #define jlong_OR(r, a, b)   ((r) = (a) | (b))
  256 #define jlong_XOR(r, a, b)  ((r) = (a) ^ (b))
  257 #define jlong_OR2(r, a)     ((r) = (r) | (a))
  258 #define jlong_NOT(r, a)     ((r) = ~(a))
  259 
  260 #define jlong_NEG(r, a)     ((r) = -(a))
  261 #define jlong_ADD(r, a, b)  ((r) = (a) + (b))
  262 #define jlong_SUB(r, a, b)  ((r) = (a) - (b))
  263 
  264 #define jlong_MUL(r, a, b)  ((r) = (a) * (b))
  265 #define jlong_DIV(r, a, b)  ((r) = (a) / (b))
  266 #define jlong_MOD(r, a, b)  ((r) = (a) % (b))
  267 
  268 #define jlong_SHL(r, a, b)  ((r) = (a) << (b))
  269 #define jlong_SHR(r, a, b)  ((r) = (a) >> (b))
  270 #define jlong_USHR(r, a, b) ((r) = (julong)(a) >> (b))
  271 #define jlong_ISHL(r, a, b) ((r) = ((jlong)(a)) << (b))
  272 
  273 #define jlong_L2I(i, l)     ((i) = (int)(l))
  274 #define jlong_L2UI(ui, l)   ((ui) =(unsigned int)(l))
  275 #define jlong_L2F(f, l)     ((f) = (l))
  276 #define jlong_L2D(d, l)     ((d) = (l))
  277 
  278 #define jlong_I2L(l, i)     ((l) = (i))
  279 #define jlong_UI2L(l, ui)   ((l) = (ui))
  280 #define jlong_F2L(l, f)     ((l) = (f))
  281 #define jlong_D2L(l, d)     ((l) = (d))
  282 
  283 #define jlong_UDIVMOD(qp, rp, a, b)  \
  284     (*(qp) = ((julong)(a) / (b)), \
  285      *(rp) = ((julong)(a) % (b)))
  286 
  287 #else  /* !HAVE_LONG_LONG */
  288 
  289 typedef struct {
  290 #ifdef IS_LITTLE_ENDIAN
  291     juint lo, hi;
  292 #else
  293     juint hi, lo;
  294 #endif
  295 } jlong;
  296 typedef jlong               julong;
  297 
  298 extern jlong jlong_MAXINT, jlong_MININT, jlong_ZERO;
  299 
  300 #define jlong_IS_ZERO(a)    (((a).hi == 0) && ((a).lo == 0))
  301 #define jlong_EQ(a, b)      (((a).hi == (b).hi) && ((a).lo == (b).lo))
  302 #define jlong_NE(a, b)      (((a).hi != (b).hi) || ((a).lo != (b).lo))
  303 #define jlong_GE_ZERO(a)    (((a).hi >> 31) == 0)
  304 
  305 /*
  306  * NB: jlong_CMP and jlong_UCMP work only for strict relationals (<, >).
  307  */
  308 #define jlong_CMP(a, op, b) (((int32)(a).hi op (int32)(b).hi) ||          \
  309                  (((a).hi == (b).hi) && ((a).lo op (b).lo)))
  310 #define jlong_UCMP(a, op, b)    (((a).hi op (b).hi) ||                    \
  311                  (((a).hi == (b).hi) && ((a).lo op (b).lo)))
  312 
  313 #define jlong_AND(r, a, b)  ((r).lo = (a).lo & (b).lo,                    \
  314                  (r).hi = (a).hi & (b).hi)
  315 #define jlong_OR(r, a, b)   ((r).lo = (a).lo | (b).lo,                    \
  316                  (r).hi = (a).hi | (b).hi)
  317 #define jlong_XOR(r, a, b)  ((r).lo = (a).lo ^ (b).lo,                    \
  318                  (r).hi = (a).hi ^ (b).hi)
  319 #define jlong_OR2(r, a)     ((r).lo = (r).lo | (a).lo,                    \
  320                  (r).hi = (r).hi | (a).hi)
  321 #define jlong_NOT(r, a)     ((r).lo = ~(a).lo,                            \
  322                  (r).hi = ~(a).hi)
  323 
  324 #define jlong_NEG(r, a)     ((r).lo = -(int32)(a).lo,                     \
  325                  (r).hi = -(int32)(a).hi - ((r).lo != 0))
  326 #define jlong_ADD(r, a, b) {                                              \
  327     jlong _a, _b;                                                         \
  328     _a = a; _b = b;                                                       \
  329     (r).lo = _a.lo + _b.lo;                                               \
  330     (r).hi = _a.hi + _b.hi + ((r).lo < _b.lo);                            \
  331 }
  332 
  333 #define jlong_SUB(r, a, b) {                                              \
  334     jlong _a, _b;                                                         \
  335     _a = a; _b = b;                                                       \
  336     (r).lo = _a.lo - _b.lo;                                               \
  337     (r).hi = _a.hi - _b.hi - (_a.lo < _b.lo);                             \
  338 }                                                                         \
  339 
  340 /*
  341  * Multiply 64-bit operands a and b to get 64-bit result r.
  342  * First multiply the low 32 bits of a and b to get a 64-bit result in r.
  343  * Then add the outer and inner products to r.hi.
  344  */
  345 #define jlong_MUL(r, a, b) {                                              \
  346     jlong _a, _b;                                                         \
  347     _a = a; _b = b;                                                       \
  348     jlong_MUL32(r, _a.lo, _b.lo);                                         \
  349     (r).hi += _a.hi * _b.lo + _a.lo * _b.hi;                              \
  350 }
  351 
  352 /* XXX _jlong_lo16(a) = ((a) << 16 >> 16) is better on some archs (not on mips) */
  353 #define _jlong_lo16(a)      ((a) & JRI_BITMASK(16))
  354 #define _jlong_hi16(a)      ((a) >> 16)
  355 
  356 /*
  357  * Multiply 32-bit operands a and b to get 64-bit result r.
  358  * Use polynomial expansion based on primitive field element (1 << 16).
  359  */
  360 #define jlong_MUL32(r, a, b) {                                            \
  361      juint _a1, _a0, _b1, _b0, _y0, _y1, _y2, _y3;                        \
  362      _a1 = _jlong_hi16(a), _a0 = _jlong_lo16(a);                          \
  363      _b1 = _jlong_hi16(b), _b0 = _jlong_lo16(b);                          \
  364      _y0 = _a0 * _b0;                                                     \
  365      _y1 = _a0 * _b1;                                                     \
  366      _y2 = _a1 * _b0;                                                     \
  367      _y3 = _a1 * _b1;                                                     \
  368      _y1 += _jlong_hi16(_y0);                   /* can't carry */         \
  369      _y1 += _y2;                                /* might carry */         \
  370      if (_y1 < _y2) _y3 += 1 << 16;             /* propagate */           \
  371      (r).lo = (_jlong_lo16(_y1) << 16) + _jlong_lo16(_y0);                \
  372      (r).hi = _y3 + _jlong_hi16(_y1);                                     \
  373 }
  374 
  375 /*
  376  * Divide 64-bit unsigned operand a by 64-bit unsigned operand b, setting *qp
  377  * to the 64-bit unsigned quotient, and *rp to the 64-bit unsigned remainder.
  378  * Minimize effort if one of qp and rp is null.
  379  */
  380 #define jlong_UDIVMOD(qp, rp, a, b) jlong_udivmod(qp, rp, a, b)
  381 
  382 extern JRI_PUBLIC_API(void)
  383 jlong_udivmod(julong *qp, julong *rp, julong a, julong b);
  384 
  385 #define jlong_DIV(r, a, b) {                                              \
  386     jlong _a, _b;                                                         \
  387     juint _negative = (int32)(a).hi < 0;                                  \
  388     if (_negative) {                                                      \
  389     jlong_NEG(_a, a);                                                     \
  390     } else {                                                              \
  391     _a = a;                                                               \
  392     }                                                                     \
  393     if ((int32)(b).hi < 0) {                                              \
  394     _negative ^= 1;                                                       \
  395     jlong_NEG(_b, b);                                                     \
  396     } else {                                                              \
  397     _b = b;                                                               \
  398     }                                                                     \
  399     jlong_UDIVMOD(&(r), 0, _a, _b);                                       \
  400     if (_negative)                                                        \
  401     jlong_NEG(r, r);                                                      \
  402 }
  403 
  404 #define jlong_MOD(r, a, b) {                                              \
  405     jlong _a, _b;                                                         \
  406     juint _negative = (int32)(a).hi < 0;                                  \
  407     if (_negative) {                                                      \
  408     jlong_NEG(_a, a);                                                     \
  409     } else {                                                              \
  410     _a = a;                                                               \
  411     }                                                                     \
  412     if ((int32)(b).hi < 0) {                                              \
  413     jlong_NEG(_b, b);                                                     \
  414     } else {                                                              \
  415     _b = b;                                                               \
  416     }                                                                     \
  417     jlong_UDIVMOD(0, &(r), _a, _b);                                       \
  418     if (_negative)                                                        \
  419     jlong_NEG(r, r);                                                      \
  420 }
  421 
  422 /*
  423  * NB: b is a juint, not jlong or julong, for the shift ops.
  424  */
  425 #define jlong_SHL(r, a, b) {                                              \
  426     if (b) {                                                              \
  427     jlong _a;                                                             \
  428         _a = a;                                                           \
  429         if ((b) < 32) {                                                   \
  430         (r).lo = _a.lo << (b);                                            \
  431         (r).hi = (_a.hi << (b)) | (_a.lo >> (32 - (b)));                  \
  432     } else {                                                              \
  433         (r).lo = 0;                                                       \
  434         (r).hi = _a.lo << ((b) & 31);                                     \
  435     }                                                                     \
  436     } else {                                                              \
  437     (r) = (a);                                                            \
  438     }                                                                     \
  439 }
  440 
  441 /* a is an int32, b is int32, r is jlong */
  442 #define jlong_ISHL(r, a, b) {                                             \
  443     if (b) {                                                              \
  444     jlong _a;                                                             \
  445     _a.lo = (a);                                                          \
  446     _a.hi = 0;                                                            \
  447         if ((b) < 32) {                                                   \
  448         (r).lo = (a) << (b);                                              \
  449         (r).hi = ((a) >> (32 - (b)));                                     \
  450     } else {                                                              \
  451         (r).lo = 0;                                                       \
  452         (r).hi = (a) << ((b) & 31);                                       \
  453     }                                                                     \
  454     } else {                                                              \
  455     (r).lo = (a);                                                         \
  456     (r).hi = 0;                                                           \
  457     }                                                                     \
  458 }
  459 
  460 #define jlong_SHR(r, a, b) {                                              \
  461     if (b) {                                                              \
  462     jlong _a;                                                             \
  463         _a = a;                                                           \
  464     if ((b) < 32) {                                                       \
  465         (r).lo = (_a.hi << (32 - (b))) | (_a.lo >> (b));                  \
  466         (r).hi = (int32)_a.hi >> (b);                                     \
  467     } else {                                                              \
  468         (r).lo = (int32)_a.hi >> ((b) & 31);                              \
  469         (r).hi = (int32)_a.hi >> 31;                                      \
  470     }                                                                     \
  471     } else {                                                              \
  472     (r) = (a);                                                            \
  473     }                                                                     \
  474 }
  475 
  476 #define jlong_USHR(r, a, b) {                                             \
  477     if (b) {                                                              \
  478     jlong _a;                                                             \
  479         _a = a;                                                           \
  480     if ((b) < 32) {                                                       \
  481         (r).lo = (_a.hi << (32 - (b))) | (_a.lo >> (b));                  \
  482         (r).hi = _a.hi >> (b);                                            \
  483     } else {                                                              \
  484         (r).lo = _a.hi >> ((b) & 31);                                     \
  485         (r).hi = 0;                                                       \
  486     }                                                                     \
  487     } else {                                                              \
  488     (r) = (a);                                                            \
  489     }                                                                     \
  490 }
  491 
  492 #define jlong_L2I(i, l)     ((i) = (l).lo)
  493 #define jlong_L2UI(ui, l)   ((ui) = (l).lo)
  494 #define jlong_L2F(f, l)     { double _d; jlong_L2D(_d, l); (f) = (float) _d; }
  495 
  496 #define jlong_L2D(d, l) {                                                 \
  497     int32 _negative;                                                      \
  498     jlong _absval;                                                        \
  499                                                                           \
  500     _negative = (l).hi >> 31;                                             \
  501     if (_negative) {                                                      \
  502     jlong_NEG(_absval, l);                                                \
  503     } else {                                                              \
  504     _absval = l;                                                          \
  505     }                                                                     \
  506     (d) = (double)_absval.hi * 4.294967296e9 + _absval.lo;                \
  507     if (_negative)                                                        \
  508     (d) = -(d);                                                           \
  509 }
  510 
  511 #define jlong_I2L(l, i)     ((l).hi = (i) >> 31, (l).lo = (i))
  512 #define jlong_UI2L(l, ui)   ((l).hi = 0, (l).lo = (ui))
  513 #define jlong_F2L(l, f)     { double _d = (double) f; jlong_D2L(l, _d); }
  514 
  515 #define jlong_D2L(l, d) {                                                 \
  516     int _negative;                                                        \
  517     double _absval, _d_hi;                                                \
  518     jlong _lo_d;                                                          \
  519                                                                           \
  520     _negative = ((d) < 0);                                                \
  521     _absval = _negative ? -(d) : (d);                                     \
  522                                                                           \
  523     (l).hi = (juint)(_absval / 4.294967296e9);                            \
  524     (l).lo = 0;                                                           \
  525     jlong_L2D(_d_hi, l);                                                  \
  526     _absval -= _d_hi;                                                     \
  527     _lo_d.hi = 0;                                                         \
  528     if (_absval < 0) {                                                    \
  529     _lo_d.lo = (juint) -_absval;                                          \
  530     jlong_SUB(l, l, _lo_d);                                               \
  531     } else {                                                              \
  532     _lo_d.lo = (juint) _absval;                                           \
  533     jlong_ADD(l, l, _lo_d);                                               \
  534     }                                                                     \
  535                                                                           \
  536     if (_negative)                                                        \
  537     jlong_NEG(l, l);                                                      \
  538 }
  539 
  540 #endif /* !HAVE_LONG_LONG */
  541 
  542 /******************************************************************************/
  543 
  544 #ifdef HAVE_ALIGNED_LONGLONGS
  545 #define JRI_GET_INT64(_t,_addr) ( ((_t).x[0] = ((jint*)(_addr))[0]), \
  546                               ((_t).x[1] = ((jint*)(_addr))[1]),      \
  547                               (_t).l )
  548 #define JRI_SET_INT64(_t, _addr, _v) ( (_t).l = (_v),                \
  549                                    ((jint*)(_addr))[0] = (_t).x[0], \
  550                                    ((jint*)(_addr))[1] = (_t).x[1] )
  551 #else
  552 #define JRI_GET_INT64(_t,_addr) (*(jlong*)(_addr))
  553 #define JRI_SET_INT64(_t, _addr, _v) (*(jlong*)(_addr) = (_v))
  554 #endif
  555 
  556 /* If double's must be aligned on doubleword boundaries then define this */
  557 #ifdef HAVE_ALIGNED_DOUBLES
  558 #define JRI_GET_DOUBLE(_t,_addr) ( ((_t).x[0] = ((jint*)(_addr))[0]), \
  559                                ((_t).x[1] = ((jint*)(_addr))[1]),      \
  560                                (_t).d )
  561 #define JRI_SET_DOUBLE(_t, _addr, _v) ( (_t).d = (_v),                \
  562                                     ((jint*)(_addr))[0] = (_t).x[0], \
  563                                     ((jint*)(_addr))[1] = (_t).x[1] )
  564 #else
  565 #define JRI_GET_DOUBLE(_t,_addr) (*(jdouble*)(_addr))
  566 #define JRI_SET_DOUBLE(_t, _addr, _v) (*(jdouble*)(_addr) = (_v))
  567 #endif
  568 
  569 /******************************************************************************/
  570 #ifdef __cplusplus
  571 }
  572 #endif
  573 #endif /* JRI_MD_H */
  574 /******************************************************************************/