jri_md.h
上传用户:goldcmy89
上传日期:2017-12-03
资源大小:2246k
文件大小:26k
源码类别:

PlugIns编程

开发平台:

Visual C++

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