1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
* vim: set ts=8 sts=4 et sw=4 tw=99:
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/*
** File: jstypes.h
** Description: Definitions of NSPR's basic types
**
** Prototypes and macros used to make up for deficiencies in ANSI environments
** that we have found.
**
** Since we do not wrap <stdlib.h> and all the other standard headers, authors
** of portable code will not know in general that they need these definitions.
** Instead of requiring these authors to find the dependent uses in their code
** and take the following steps only in those C files, we take steps once here
** for all C files.
**/
#ifndef jstypes_h
#define jstypes_h
#include "mozilla/Attributes.h"
#include "mozilla/Casting.h"
#include "mozilla/Types.h"
// jstypes.h is (or should be!) included by every file in SpiderMonkey.
// js-config.h and jsversion.h also should be included by every file.
// So include them here.
// XXX: including them in js/RequiredDefines.h should be a better option, since
// that is by definition the header file that should be included in all
// SpiderMonkey code. However, Gecko doesn't do this! See bug 909576.
#include "js-config.h"
#include "jsversion.h"
/***********************************************************************
** MACROS: JS_EXTERN_API
** JS_EXPORT_API
** DESCRIPTION:
** These are only for externally visible routines and globals. For
** internal routines, just use "extern" for type checking and that
** will not export internal cross-file or forward-declared symbols.
** Define a macro for declaring procedures return types. We use this to
** deal with windoze specific type hackery for DLL definitions. Use
** JS_EXTERN_API when the prototype for the method is declared. Use
** JS_EXPORT_API for the implementation of the method.
**
** Example:
** in dowhim.h
** JS_EXTERN_API( void ) DoWhatIMean( void );
** in dowhim.c
** JS_EXPORT_API( void ) DoWhatIMean( void ) { return; }
**
**
***********************************************************************/
#define JS_EXTERN_API(type) extern MOZ_EXPORT type
#define JS_EXPORT_API(type) MOZ_EXPORT type
#define JS_EXPORT_DATA(type) MOZ_EXPORT type
#define JS_IMPORT_API(type) MOZ_IMPORT_API type
#define JS_IMPORT_DATA(type) MOZ_IMPORT_DATA type
/*
* The linkage of JS API functions differs depending on whether the file is
* used within the JS library or not. Any source file within the JS
* interpreter should define EXPORT_JS_API whereas any client of the library
* should not. STATIC_JS_API is used to build JS as a static library.
*/
#if defined(STATIC_JS_API)
# define JS_PUBLIC_API(t) t
# define JS_PUBLIC_DATA(t) t
# define JS_FRIEND_API(t) t
# define JS_FRIEND_DATA(t) t
#elif defined(EXPORT_JS_API) || defined(STATIC_EXPORTABLE_JS_API)
# define JS_PUBLIC_API(t) MOZ_EXPORT t
# define JS_PUBLIC_DATA(t) MOZ_EXPORT t
# define JS_FRIEND_API(t) MOZ_EXPORT t
# define JS_FRIEND_DATA(t) MOZ_EXPORT t
#else
# define JS_PUBLIC_API(t) MOZ_IMPORT_API t
# define JS_PUBLIC_DATA(t) MOZ_IMPORT_DATA t
# define JS_FRIEND_API(t) MOZ_IMPORT_API t
# define JS_FRIEND_DATA(t) MOZ_IMPORT_DATA t
#endif
#if defined(_MSC_VER) && defined(_M_IX86)
#define JS_FASTCALL __fastcall
#elif defined(__GNUC__) && defined(__i386__)
#define JS_FASTCALL __attribute__((fastcall))
#else
#define JS_FASTCALL
#define JS_NO_FASTCALL
#endif
// gcc is buggy and warns on our attempts to JS_PUBLIC_API our
// forward-declarations or explicit template instantiations. See
// <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=50044>. Add a way to detect
// that so we can locally disable that warning.
#if !defined(__clang__) && defined(__GNUC__) && (__GNUC__ < 6 || (__GNUC__ == 6 && __GNUC_MINOR__ <= 4))
#define JS_BROKEN_GCC_ATTRIBUTE_WARNING
#endif
/***********************************************************************
** MACROS: JS_BEGIN_MACRO
** JS_END_MACRO
** DESCRIPTION:
** Macro body brackets so that macros with compound statement definitions
** behave syntactically more like functions when called.
***********************************************************************/
#define JS_BEGIN_MACRO do {
#if defined(_MSC_VER)
# define JS_END_MACRO \
} __pragma(warning(push)) __pragma(warning(disable:4127)) \
while (0) __pragma(warning(pop))
#else
# define JS_END_MACRO } while (0)
#endif
/***********************************************************************
** MACROS: JS_BIT
** JS_BITMASK
** DESCRIPTION:
** Bit masking macros. XXX n must be <= 31 to be portable
***********************************************************************/
#define JS_BIT(n) ((uint32_t)1 << (n))
#define JS_BITMASK(n) (JS_BIT(n) - 1)
/***********************************************************************
** MACROS: JS_HOWMANY
** JS_ROUNDUP
** DESCRIPTION:
** Commonly used macros for operations on compatible types.
***********************************************************************/
#define JS_HOWMANY(x,y) (((x)+(y)-1)/(y))
#define JS_ROUNDUP(x,y) (JS_HOWMANY(x,y)*(y))
#include "jscpucfg.h"
/*
* Define JS_64BIT iff we are building in an environment with 64-bit
* addresses.
*/
#ifdef _MSC_VER
# if defined(_M_X64) || defined(_M_AMD64)
# define JS_64BIT
# endif
#elif defined(__GNUC__)
# if defined(__x86_64__) || defined(__LP64__)
# define JS_64BIT
# endif
#elif defined(__xlc__) || defined(__xlC__) /* IBM XL C/C++ */
# if defined(__64BIT__)
# define JS_64BIT
# endif
#else
# error "Implement me"
#endif
/***********************************************************************
** MACROS: JS_ARRAY_LENGTH
** JS_ARRAY_END
** DESCRIPTION:
** Macros to get the number of elements and the pointer to one past the
** last element of a C array. Use them like this:
**
** char16_t buf[10];
** JSString* str;
** ...
** for (char16_t* s = buf; s != JS_ARRAY_END(buf); ++s) *s = ...;
** ...
** str = JS_NewStringCopyN(cx, buf, JS_ARRAY_LENGTH(buf));
** ...
**
***********************************************************************/
#define JS_ARRAY_LENGTH(array) (sizeof (array) / sizeof (array)[0])
#define JS_ARRAY_END(array) ((array) + JS_ARRAY_LENGTH(array))
#define JS_BITS_PER_BYTE 8
#define JS_BITS_PER_BYTE_LOG2 3
#if defined(JS_64BIT)
# define JS_BITS_PER_WORD 64
#else
# define JS_BITS_PER_WORD 32
#endif
/***********************************************************************
** MACROS: JS_FUNC_TO_DATA_PTR
** JS_DATA_TO_FUNC_PTR
** DESCRIPTION:
** Macros to convert between function and data pointers of the same
** size. Use them like this:
**
** JSGetterOp nativeGetter;
** JSObject* scriptedGetter;
** ...
** scriptedGetter = JS_FUNC_TO_DATA_PTR(JSObject*, nativeGetter);
** ...
** nativeGetter = JS_DATA_TO_FUNC_PTR(JSGetterOp, scriptedGetter);
**
***********************************************************************/
#define JS_FUNC_TO_DATA_PTR(type, fun) (mozilla::BitwiseCast<type>(fun))
#define JS_DATA_TO_FUNC_PTR(type, ptr) (mozilla::BitwiseCast<type>(ptr))
#ifdef __GNUC__
# define JS_EXTENSION __extension__
# define JS_EXTENSION_(s) __extension__ ({ s; })
#else
# define JS_EXTENSION
# define JS_EXTENSION_(s) s
#endif
#endif /* jstypes_h */
|
