| 1 |
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ |
| 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 Communicator client code, released |
| 16 |
* March 31, 1998. |
| 17 |
* |
| 18 |
* The Initial Developer of the Original Code is |
| 19 |
* Netscape Communications Corporation. |
| 20 |
* Portions created by the Initial Developer are Copyright (C) 1998 |
| 21 |
* the Initial Developer. All Rights Reserved. |
| 22 |
* |
| 23 |
* Contributor(s): |
| 24 |
* IBM Corp. |
| 25 |
* |
| 26 |
* Alternatively, the contents of this file may be used under the terms of |
| 27 |
* either of the GNU General Public License Version 2 or later (the "GPL"), |
| 28 |
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), |
| 29 |
* in which case the provisions of the GPL or the LGPL are applicable instead |
| 30 |
* of those above. If you wish to allow use of your version of this file only |
| 31 |
* under the terms of either the GPL or the LGPL, and not to allow others to |
| 32 |
* use your version of this file under the terms of the MPL, indicate your |
| 33 |
* decision by deleting the provisions above and replace them with the notice |
| 34 |
* and other provisions required by the GPL or the LGPL. If you do not delete |
| 35 |
* the provisions above, a recipient may use your version of this file under |
| 36 |
* the terms of any one of the MPL, the GPL or the LGPL. |
| 37 |
* |
| 38 |
* ***** END LICENSE BLOCK ***** */ |
| 39 |
|
| 40 |
/* |
| 41 |
** File: jstypes.h |
| 42 |
** Description: Definitions of NSPR's basic types |
| 43 |
** |
| 44 |
** Prototypes and macros used to make up for deficiencies in ANSI environments |
| 45 |
** that we have found. |
| 46 |
** |
| 47 |
** Since we do not wrap <stdlib.h> and all the other standard headers, authors |
| 48 |
** of portable code will not know in general that they need these definitions. |
| 49 |
** Instead of requiring these authors to find the dependent uses in their code |
| 50 |
** and take the following steps only in those C files, we take steps once here |
| 51 |
** for all C files. |
| 52 |
**/ |
| 53 |
|
| 54 |
#ifndef jstypes_h___ |
| 55 |
#define jstypes_h___ |
| 56 |
|
| 57 |
#include <stddef.h> |
| 58 |
#include "jsstdint.h" |
| 59 |
|
| 60 |
/*********************************************************************** |
| 61 |
** MACROS: JS_EXTERN_API |
| 62 |
** JS_EXPORT_API |
| 63 |
** DESCRIPTION: |
| 64 |
** These are only for externally visible routines and globals. For |
| 65 |
** internal routines, just use "extern" for type checking and that |
| 66 |
** will not export internal cross-file or forward-declared symbols. |
| 67 |
** Define a macro for declaring procedures return types. We use this to |
| 68 |
** deal with windoze specific type hackery for DLL definitions. Use |
| 69 |
** JS_EXTERN_API when the prototype for the method is declared. Use |
| 70 |
** JS_EXPORT_API for the implementation of the method. |
| 71 |
** |
| 72 |
** Example: |
| 73 |
** in dowhim.h |
| 74 |
** JS_EXTERN_API( void ) DoWhatIMean( void ); |
| 75 |
** in dowhim.c |
| 76 |
** JS_EXPORT_API( void ) DoWhatIMean( void ) { return; } |
| 77 |
** |
| 78 |
** |
| 79 |
***********************************************************************/ |
| 80 |
#ifdef WIN32 |
| 81 |
|
| 82 |
/* These also work for __MWERKS__ */ |
| 83 |
# define JS_EXTERN_API(__type) extern __declspec(dllexport) __type |
| 84 |
# define JS_EXPORT_API(__type) __declspec(dllexport) __type |
| 85 |
# define JS_EXTERN_DATA(__type) extern __declspec(dllexport) __type |
| 86 |
# define JS_EXPORT_DATA(__type) __declspec(dllexport) __type |
| 87 |
|
| 88 |
#elif defined(XP_OS2) && defined(__declspec) |
| 89 |
|
| 90 |
# define JS_EXTERN_API(__type) extern __declspec(dllexport) __type |
| 91 |
# define JS_EXPORT_API(__type) __declspec(dllexport) __type |
| 92 |
# define JS_EXTERN_DATA(__type) extern __declspec(dllexport) __type |
| 93 |
# define JS_EXPORT_DATA(__type) __declspec(dllexport) __type |
| 94 |
|
| 95 |
#else /* Unix */ |
| 96 |
|
| 97 |
# ifdef HAVE_VISIBILITY_ATTRIBUTE |
| 98 |
# define JS_EXTERNAL_VIS __attribute__((visibility ("default"))) |
| 99 |
# elif defined(__SUNPRO_C) || defined(__SUNPRO_CC) |
| 100 |
# define JS_EXTERNAL_VIS __global |
| 101 |
# else |
| 102 |
# define JS_EXTERNAL_VIS |
| 103 |
# endif |
| 104 |
|
| 105 |
# define JS_EXTERN_API(__type) extern JS_EXTERNAL_VIS __type |
| 106 |
# define JS_EXPORT_API(__type) JS_EXTERNAL_VIS __type |
| 107 |
# define JS_EXTERN_DATA(__type) extern JS_EXTERNAL_VIS __type |
| 108 |
# define JS_EXPORT_DATA(__type) JS_EXTERNAL_VIS __type |
| 109 |
|
| 110 |
#endif |
| 111 |
|
| 112 |
#ifdef _WIN32 |
| 113 |
# if defined(__MWERKS__) || defined(__GNUC__) |
| 114 |
# define JS_IMPORT_API(__x) __x |
| 115 |
# else |
| 116 |
# define JS_IMPORT_API(__x) __declspec(dllimport) __x |
| 117 |
# endif |
| 118 |
#elif defined(XP_OS2) && defined(__declspec) |
| 119 |
# define JS_IMPORT_API(__x) __declspec(dllimport) __x |
| 120 |
#else |
| 121 |
# define JS_IMPORT_API(__x) JS_EXPORT_API (__x) |
| 122 |
#endif |
| 123 |
|
| 124 |
#if defined(_WIN32) && !defined(__MWERKS__) |
| 125 |
# define JS_IMPORT_DATA(__x) __declspec(dllimport) __x |
| 126 |
#elif defined(XP_OS2) && defined(__declspec) |
| 127 |
# define JS_IMPORT_DATA(__x) __declspec(dllimport) __x |
| 128 |
#else |
| 129 |
# define JS_IMPORT_DATA(__x) JS_EXPORT_DATA (__x) |
| 130 |
#endif |
| 131 |
|
| 132 |
/* |
| 133 |
* The linkage of JS API functions differs depending on whether the file is |
| 134 |
* used within the JS library or not. Any source file within the JS |
| 135 |
* interpreter should define EXPORT_JS_API whereas any client of the library |
| 136 |
* should not. STATIC_JS_API is used to build JS as a static library. |
| 137 |
*/ |
| 138 |
#if defined(STATIC_JS_API) |
| 139 |
|
| 140 |
# define JS_PUBLIC_API(t) t |
| 141 |
# define JS_PUBLIC_DATA(t) t |
| 142 |
|
| 143 |
#elif defined(EXPORT_JS_API) |
| 144 |
|
| 145 |
# define JS_PUBLIC_API(t) JS_EXPORT_API(t) |
| 146 |
# define JS_PUBLIC_DATA(t) JS_EXPORT_DATA(t) |
| 147 |
|
| 148 |
#else |
| 149 |
|
| 150 |
# define JS_PUBLIC_API(t) JS_IMPORT_API(t) |
| 151 |
# define JS_PUBLIC_DATA(t) JS_IMPORT_DATA(t) |
| 152 |
|
| 153 |
#endif |
| 154 |
|
| 155 |
#define JS_FRIEND_API(t) JS_PUBLIC_API(t) |
| 156 |
#define JS_FRIEND_DATA(t) JS_PUBLIC_DATA(t) |
| 157 |
|
| 158 |
#if defined(_MSC_VER) && defined(_M_IX86) |
| 159 |
#define JS_FASTCALL __fastcall |
| 160 |
#elif defined(__GNUC__) && defined(__i386__) && \ |
| 161 |
((__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) |
| 162 |
#define JS_FASTCALL __attribute__((fastcall)) |
| 163 |
#else |
| 164 |
#define JS_FASTCALL |
| 165 |
#define JS_NO_FASTCALL |
| 166 |
#endif |
| 167 |
|
| 168 |
#ifndef JS_INLINE |
| 169 |
# if defined __cplusplus |
| 170 |
# define JS_INLINE inline |
| 171 |
# elif defined _MSC_VER |
| 172 |
# define JS_INLINE __inline |
| 173 |
# elif defined __GNUC__ |
| 174 |
# define JS_INLINE __inline__ |
| 175 |
# else |
| 176 |
# define JS_INLINE inline |
| 177 |
# endif |
| 178 |
#endif |
| 179 |
|
| 180 |
#ifndef JS_ALWAYS_INLINE |
| 181 |
# if defined DEBUG |
| 182 |
# define JS_ALWAYS_INLINE JS_INLINE |
| 183 |
# elif defined _MSC_VER |
| 184 |
# define JS_ALWAYS_INLINE __forceinline |
| 185 |
# elif defined __GNUC__ |
| 186 |
# define JS_ALWAYS_INLINE __attribute__((always_inline)) JS_INLINE |
| 187 |
# else |
| 188 |
# define JS_ALWAYS_INLINE JS_INLINE |
| 189 |
# endif |
| 190 |
#endif |
| 191 |
|
| 192 |
#ifdef NS_STATIC_CHECKING |
| 193 |
/* |
| 194 |
* Attributes for static analysis. Functions declared with JS_REQUIRES_STACK |
| 195 |
* always have a valid cx->fp and can access it freely. Other functions can |
| 196 |
* access cx->fp only after calling a function that "forces" the stack |
| 197 |
* (i.e. lazily instantiates it as needed). |
| 198 |
*/ |
| 199 |
# define JS_REQUIRES_STACK __attribute__((user("JS_REQUIRES_STACK"))) |
| 200 |
# define JS_FORCES_STACK __attribute__((user("JS_FORCES_STACK"))) |
| 201 |
#else |
| 202 |
# define JS_REQUIRES_STACK |
| 203 |
# define JS_FORCES_STACK |
| 204 |
#endif |
| 205 |
|
| 206 |
/*********************************************************************** |
| 207 |
** MACROS: JS_BEGIN_MACRO |
| 208 |
** JS_END_MACRO |
| 209 |
** DESCRIPTION: |
| 210 |
** Macro body brackets so that macros with compound statement definitions |
| 211 |
** behave syntactically more like functions when called. |
| 212 |
***********************************************************************/ |
| 213 |
#define JS_BEGIN_MACRO do { |
| 214 |
|
| 215 |
#if defined(_MSC_VER) && _MSC_VER >= 1400 |
| 216 |
# define JS_END_MACRO \ |
| 217 |
} __pragma(warning(push)) __pragma(warning(disable:4127)) \ |
| 218 |
while (0) __pragma(warning(pop)) |
| 219 |
#else |
| 220 |
# define JS_END_MACRO } while (0) |
| 221 |
#endif |
| 222 |
|
| 223 |
/*********************************************************************** |
| 224 |
** MACROS: JS_BEGIN_EXTERN_C |
| 225 |
** JS_END_EXTERN_C |
| 226 |
** DESCRIPTION: |
| 227 |
** Macro shorthands for conditional C++ extern block delimiters. |
| 228 |
***********************************************************************/ |
| 229 |
#ifdef __cplusplus |
| 230 |
|
| 231 |
# define JS_BEGIN_EXTERN_C extern "C" { |
| 232 |
# define JS_END_EXTERN_C } |
| 233 |
|
| 234 |
#else |
| 235 |
|
| 236 |
# define JS_BEGIN_EXTERN_C |
| 237 |
# define JS_END_EXTERN_C |
| 238 |
|
| 239 |
#endif |
| 240 |
|
| 241 |
/*********************************************************************** |
| 242 |
** MACROS: JS_BIT |
| 243 |
** JS_BITMASK |
| 244 |
** DESCRIPTION: |
| 245 |
** Bit masking macros. XXX n must be <= 31 to be portable |
| 246 |
***********************************************************************/ |
| 247 |
#define JS_BIT(n) ((JSUint32)1 << (n)) |
| 248 |
#define JS_BITMASK(n) (JS_BIT(n) - 1) |
| 249 |
|
| 250 |
/*********************************************************************** |
| 251 |
** MACROS: JS_PTR_TO_INT32 |
| 252 |
** JS_PTR_TO_UINT32 |
| 253 |
** JS_INT32_TO_PTR |
| 254 |
** JS_UINT32_TO_PTR |
| 255 |
** DESCRIPTION: |
| 256 |
** Integer to pointer and pointer to integer conversion macros. |
| 257 |
***********************************************************************/ |
| 258 |
#define JS_PTR_TO_INT32(x) ((jsint)((char *)(x) - (char *)0)) |
| 259 |
#define JS_PTR_TO_UINT32(x) ((jsuint)((char *)(x) - (char *)0)) |
| 260 |
#define JS_INT32_TO_PTR(x) ((void *)((char *)0 + (jsint)(x))) |
| 261 |
#define JS_UINT32_TO_PTR(x) ((void *)((char *)0 + (jsuint)(x))) |
| 262 |
|
| 263 |
/*********************************************************************** |
| 264 |
** MACROS: JS_HOWMANY |
| 265 |
** JS_ROUNDUP |
| 266 |
** JS_MIN |
| 267 |
** JS_MAX |
| 268 |
** DESCRIPTION: |
| 269 |
** Commonly used macros for operations on compatible types. |
| 270 |
***********************************************************************/ |
| 271 |
#define JS_HOWMANY(x,y) (((x)+(y)-1)/(y)) |
| 272 |
#define JS_ROUNDUP(x,y) (JS_HOWMANY(x,y)*(y)) |
| 273 |
#define JS_MIN(x,y) ((x)<(y)?(x):(y)) |
| 274 |
#define JS_MAX(x,y) ((x)>(y)?(x):(y)) |
| 275 |
|
| 276 |
#ifdef _MSC_VER |
| 277 |
# include "jscpucfg.h" /* We can't auto-detect MSVC configuration */ |
| 278 |
#else |
| 279 |
# include "jsautocfg.h" /* Use auto-detected configuration */ |
| 280 |
#endif |
| 281 |
|
| 282 |
JS_BEGIN_EXTERN_C |
| 283 |
|
| 284 |
/************************************************************************ |
| 285 |
** TYPES: JSUint8 |
| 286 |
** JSInt8 |
| 287 |
** DESCRIPTION: |
| 288 |
** The int8 types are known to be 8 bits each. There is no type that |
| 289 |
** is equivalent to a plain "char". |
| 290 |
************************************************************************/ |
| 291 |
|
| 292 |
typedef uint8_t JSUint8; |
| 293 |
typedef int8_t JSInt8; |
| 294 |
|
| 295 |
/************************************************************************ |
| 296 |
** TYPES: JSUint16 |
| 297 |
** JSInt16 |
| 298 |
** DESCRIPTION: |
| 299 |
** The int16 types are known to be 16 bits each. |
| 300 |
************************************************************************/ |
| 301 |
|
| 302 |
typedef uint16_t JSUint16; |
| 303 |
typedef int16_t JSInt16; |
| 304 |
|
| 305 |
/************************************************************************ |
| 306 |
** TYPES: JSUint32 |
| 307 |
** JSInt32 |
| 308 |
** DESCRIPTION: |
| 309 |
** The int32 types are known to be 32 bits each. |
| 310 |
************************************************************************/ |
| 311 |
|
| 312 |
typedef uint32_t JSUint32; |
| 313 |
typedef int32_t JSInt32; |
| 314 |
|
| 315 |
/************************************************************************ |
| 316 |
** TYPES: JSUint64 |
| 317 |
** JSInt64 |
| 318 |
** DESCRIPTION: |
| 319 |
** The int64 types are known to be 64 bits each. Care must be used when |
| 320 |
** declaring variables of type JSUint64 or JSInt64. Different hardware |
| 321 |
** architectures and even different compilers have varying support for |
| 322 |
** 64 bit values. The only guaranteed portability requires the use of |
| 323 |
** the JSLL_ macros (see jslong.h). |
| 324 |
************************************************************************/ |
| 325 |
|
| 326 |
typedef uint64_t JSUint64; |
| 327 |
typedef int64_t JSInt64; |
| 328 |
|
| 329 |
/************************************************************************ |
| 330 |
** TYPES: JSUintn |
| 331 |
** JSIntn |
| 332 |
** DESCRIPTION: |
| 333 |
** The JSIntn types are most appropriate for automatic variables. They are |
| 334 |
** guaranteed to be at least 16 bits, though various architectures may |
| 335 |
** define them to be wider (e.g., 32 or even 64 bits). These types are |
| 336 |
** never valid for fields of a structure. |
| 337 |
************************************************************************/ |
| 338 |
|
| 339 |
typedef int JSIntn; |
| 340 |
typedef unsigned int JSUintn; |
| 341 |
|
| 342 |
/************************************************************************ |
| 343 |
** TYPES: JSFloat64 |
| 344 |
** DESCRIPTION: |
| 345 |
** NSPR's floating point type is always 64 bits. |
| 346 |
************************************************************************/ |
| 347 |
typedef double JSFloat64; |
| 348 |
|
| 349 |
/************************************************************************ |
| 350 |
** TYPES: JSSize |
| 351 |
** DESCRIPTION: |
| 352 |
** A type for representing the size of objects. |
| 353 |
************************************************************************/ |
| 354 |
typedef size_t JSSize; |
| 355 |
|
| 356 |
/************************************************************************ |
| 357 |
** TYPES: JSPtrDiff |
| 358 |
** DESCRIPTION: |
| 359 |
** A type for pointer difference. Variables of this type are suitable |
| 360 |
** for storing a pointer or pointer sutraction. |
| 361 |
************************************************************************/ |
| 362 |
typedef ptrdiff_t JSPtrdiff; |
| 363 |
|
| 364 |
/************************************************************************ |
| 365 |
** TYPES: JSUptrdiff |
| 366 |
** DESCRIPTION: |
| 367 |
** A type for pointer difference. Variables of this type are suitable |
| 368 |
** for storing a pointer or pointer sutraction. |
| 369 |
************************************************************************/ |
| 370 |
typedef uintptr_t JSUptrdiff; |
| 371 |
|
| 372 |
/************************************************************************ |
| 373 |
** TYPES: JSBool |
| 374 |
** DESCRIPTION: |
| 375 |
** Use JSBool for variables and parameter types. Use JS_FALSE and JS_TRUE |
| 376 |
** for clarity of target type in assignments and actual arguments. Use |
| 377 |
** 'if (bool)', 'while (!bool)', '(bool) ? x : y' etc., to test booleans |
| 378 |
** just as you would C int-valued conditions. |
| 379 |
************************************************************************/ |
| 380 |
typedef JSIntn JSBool; |
| 381 |
#define JS_TRUE (JSIntn)1 |
| 382 |
#define JS_FALSE (JSIntn)0 |
| 383 |
|
| 384 |
/************************************************************************ |
| 385 |
** TYPES: JSPackedBool |
| 386 |
** DESCRIPTION: |
| 387 |
** Use JSPackedBool within structs where bitfields are not desireable |
| 388 |
** but minimum and consistent overhead matters. |
| 389 |
************************************************************************/ |
| 390 |
typedef JSUint8 JSPackedBool; |
| 391 |
|
| 392 |
/* |
| 393 |
** A JSWord is an integer that is the same size as a void* |
| 394 |
*/ |
| 395 |
typedef intptr_t JSWord; |
| 396 |
typedef uintptr_t JSUword; |
| 397 |
|
| 398 |
#include "jsotypes.h" |
| 399 |
|
| 400 |
/*********************************************************************** |
| 401 |
** MACROS: JS_LIKELY |
| 402 |
** JS_UNLIKELY |
| 403 |
** DESCRIPTION: |
| 404 |
** These macros allow you to give a hint to the compiler about branch |
| 405 |
** probability so that it can better optimize. Use them like this: |
| 406 |
** |
| 407 |
** if (JS_LIKELY(v == 1)) { |
| 408 |
** ... expected code path ... |
| 409 |
** } |
| 410 |
** |
| 411 |
** if (JS_UNLIKELY(v == 0)) { |
| 412 |
** ... non-expected code path ... |
| 413 |
** } |
| 414 |
** |
| 415 |
***********************************************************************/ |
| 416 |
#if defined(__GNUC__) && (__GNUC__ > 2) |
| 417 |
|
| 418 |
# define JS_LIKELY(x) (__builtin_expect((x), 1)) |
| 419 |
# define JS_UNLIKELY(x) (__builtin_expect((x), 0)) |
| 420 |
|
| 421 |
#else |
| 422 |
|
| 423 |
# define JS_LIKELY(x) (x) |
| 424 |
# define JS_UNLIKELY(x) (x) |
| 425 |
|
| 426 |
#endif |
| 427 |
|
| 428 |
/*********************************************************************** |
| 429 |
** MACROS: JS_ARRAY_LENGTH |
| 430 |
** JS_ARRAY_END |
| 431 |
** DESCRIPTION: |
| 432 |
** Macros to get the number of elements and the pointer to one past the |
| 433 |
** last element of a C array. Use them like this: |
| 434 |
** |
| 435 |
** jschar buf[10], *s; |
| 436 |
** JSString *str; |
| 437 |
** ... |
| 438 |
** for (s = buf; s != JS_ARRAY_END(buf); ++s) *s = ...; |
| 439 |
** ... |
| 440 |
** str = JS_NewStringCopyN(cx, buf, JS_ARRAY_LENGTH(buf)); |
| 441 |
** ... |
| 442 |
** |
| 443 |
***********************************************************************/ |
| 444 |
|
| 445 |
#define JS_ARRAY_LENGTH(array) (sizeof (array) / sizeof (array)[0]) |
| 446 |
#define JS_ARRAY_END(array) ((array) + JS_ARRAY_LENGTH(array)) |
| 447 |
|
| 448 |
#define JS_BITS_PER_BYTE 8 |
| 449 |
#define JS_BITS_PER_BYTE_LOG2 3 |
| 450 |
|
| 451 |
#define JS_BITS_PER_WORD (JS_BITS_PER_BYTE * JS_BYTES_PER_WORD) |
| 452 |
#define JS_BITS_PER_DOUBLE (JS_BITS_PER_BYTE * JS_BYTES_PER_DOUBLE) |
| 453 |
|
| 454 |
/*********************************************************************** |
| 455 |
** MACROS: JS_FUNC_TO_DATA_PTR |
| 456 |
** JS_DATA_TO_FUNC_PTR |
| 457 |
** DESCRIPTION: |
| 458 |
** Macros to convert between function and data pointers assuming that |
| 459 |
** they have the same size. Use them like this: |
| 460 |
** |
| 461 |
** JSPropertyOp nativeGetter; |
| 462 |
** JSObject *scriptedGetter; |
| 463 |
** ... |
| 464 |
** scriptedGetter = JS_FUNC_TO_DATA_PTR(JSObject *, nativeGetter); |
| 465 |
** ... |
| 466 |
** nativeGetter = JS_DATA_TO_FUNC_PTR(JSPropertyOp, scriptedGetter); |
| 467 |
** |
| 468 |
***********************************************************************/ |
| 469 |
|
| 470 |
#ifdef __GNUC__ |
| 471 |
# define JS_FUNC_TO_DATA_PTR(type, fun) (__extension__ (type) (fun)) |
| 472 |
# define JS_DATA_TO_FUNC_PTR(type, ptr) (__extension__ (type) (ptr)) |
| 473 |
#else |
| 474 |
/* Use an extra (void *) cast for MSVC. */ |
| 475 |
# define JS_FUNC_TO_DATA_PTR(type, fun) ((type) (void *) (fun)) |
| 476 |
# define JS_DATA_TO_FUNC_PTR(type, ptr) ((type) (void *) (ptr)) |
| 477 |
#endif |
| 478 |
|
| 479 |
JS_END_EXTERN_C |
| 480 |
|
| 481 |
#endif /* jstypes_h___ */ |
Parent Directory
| 
Revision Log