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
