← Back to branch summary

~ubuntu-branches/ubuntu/karmic/webkit/karmic-proposed

« back to all changes in this revision

Viewing changes to JavaScriptCore/runtime/JSNumberCell.h

  • Committer: Bazaar Package Importer
  • Author(s): Gustavo Noronha Silva
  • Date: 2009-05-15 18:30:58 UTC
  • mfrom: (1.1.8 upstream)
  • Revision ID: james.westby@ubuntu.com-20090515183058-50q5exjo9b1kxy9s
Tags: 1.1.7-1
http://bugs.debian.org/526683
* New upstream release
* debian/libwebkit-1.0-2.symbols:
- updated with the new symbols in 1.1.7
* debian/libwebkit-dev.install, debian/libwebkit-dev.links,
  debian/rules:
- Build, and ship gtk-doc documentation (Closes: #526683)
* debian/copyright:
- updated.

Show diffs side-by-side

added added

removed removed

Lines of Context:
JavaScriptCore/runtime/JSNumberCell.h
35
35
    extern const double NaN;
36
36
    extern const double Inf;
37
37
 
38
 
    JSValuePtr jsNumberCell(ExecState*, double);
 
38
    JSValue jsNumberCell(ExecState*, double);
 
39
    JSValue jsAPIMangledNumber(ExecState*, double);
39
40
 
40
41
#if !USE(ALTERNATE_JSIMMEDIATE)
41
42
 
50
51
 
51
52
    class JSNumberCell : public JSCell {
52
53
        friend class JIT;
53
 
        friend JSValuePtr jsNumberCell(JSGlobalData*, double);
54
 
        friend JSValuePtr jsNumberCell(ExecState*, double);
 
54
        friend JSValue jsNumberCell(JSGlobalData*, double);
 
55
        friend JSValue jsNumberCell(ExecState*, double);
 
56
        friend JSValue jsAPIMangledNumber(ExecState*, double);
55
57
    public:
56
58
        double value() const { return m_value; }
57
59
 
58
 
        virtual JSValuePtr toPrimitive(ExecState*, PreferredPrimitiveType) const;
59
 
        virtual bool getPrimitiveNumber(ExecState*, double& number, JSValuePtr& value);
 
60
        virtual JSValue toPrimitive(ExecState*, PreferredPrimitiveType) const;
 
61
        virtual bool getPrimitiveNumber(ExecState*, double& number, JSValue& value);
60
62
        virtual bool toBoolean(ExecState*) const;
61
63
        virtual double toNumber(ExecState*) const;
62
64
        virtual UString toString(ExecState*) const;
64
66
 
65
67
        virtual UString toThisString(ExecState*) const;
66
68
        virtual JSObject* toThisObject(ExecState*) const;
67
 
        virtual JSValuePtr getJSNumber();
 
69
        virtual JSValue getJSNumber();
 
70
 
 
71
        static const uintptr_t JSAPIMangledMagicNumber = 0xbbadbeef;
 
72
        bool isAPIMangledNumber() const { return m_structure == reinterpret_cast<Structure*>(JSAPIMangledMagicNumber); }
68
73
 
69
74
        void* operator new(size_t size, ExecState* exec)
70
75
        {
84
89
    #endif
85
90
        }
86
91
 
87
 
        static PassRefPtr<Structure> createStructure(JSValuePtr proto) { return Structure::create(proto, TypeInfo(NumberType, NeedsThisConversion)); }
 
92
        static PassRefPtr<Structure> createStructure(JSValue proto) { return Structure::create(proto, TypeInfo(NumberType, NeedsThisConversion)); }
88
93
 
89
94
    private:
90
95
        JSNumberCell(JSGlobalData* globalData, double value)
99
104
        {
100
105
        }
101
106
 
 
107
        enum APIMangledTag { APIMangled };
 
108
        JSNumberCell(APIMangledTag, double value)
 
109
            : JSCell(reinterpret_cast<Structure*>(JSAPIMangledMagicNumber))
 
110
            , m_value(value)
 
111
        {
 
112
        }
 
113
 
102
114
        virtual bool getUInt32(uint32_t&) const;
103
115
        virtual bool getTruncatedInt32(int32_t&) const;
104
116
        virtual bool getTruncatedUInt32(uint32_t&) const;
106
118
        double m_value;
107
119
    };
108
120
 
109
 
    JSValuePtr jsNumberCell(JSGlobalData*, double);
 
121
    JSValue jsNumberCell(JSGlobalData*, double);
110
122
 
111
 
    inline bool isNumberCell(JSValuePtr v)
 
123
    inline bool isNumberCell(JSValue v)
112
124
    {
113
125
        return v.isCell() && v.asCell()->isNumber();
114
126
    }
115
127
 
116
 
    inline JSNumberCell* asNumberCell(JSValuePtr v)
 
128
    inline JSNumberCell* asNumberCell(JSValue v)
117
129
    {
118
130
        ASSERT(isNumberCell(v));
119
131
        return static_cast<JSNumberCell*>(v.asCell());
120
132
    }
121
133
 
122
 
    ALWAYS_INLINE JSValuePtr jsNumber(ExecState* exec, double d)
123
 
    {
124
 
        JSValuePtr v = JSImmediate::from(d);
125
 
        return v ? v : jsNumberCell(exec, d);
126
 
    }
127
 
 
128
 
    ALWAYS_INLINE JSValuePtr jsNumber(ExecState* exec, int i)
129
 
    {
130
 
        JSValuePtr v = JSImmediate::from(i);
131
 
        return v ? v : jsNumberCell(exec, i);
132
 
    }
133
 
 
134
 
    ALWAYS_INLINE JSValuePtr jsNumber(ExecState* exec, unsigned i)
135
 
    {
136
 
        JSValuePtr v = JSImmediate::from(i);
137
 
        return v ? v : jsNumberCell(exec, i);
138
 
    }
139
 
 
140
 
    ALWAYS_INLINE JSValuePtr jsNumber(ExecState* exec, long i)
141
 
    {
142
 
        JSValuePtr v = JSImmediate::from(i);
143
 
        return v ? v : jsNumberCell(exec, i);
144
 
    }
145
 
 
146
 
    ALWAYS_INLINE JSValuePtr jsNumber(ExecState* exec, unsigned long i)
147
 
    {
148
 
        JSValuePtr v = JSImmediate::from(i);
149
 
        return v ? v : jsNumberCell(exec, i);
150
 
    }
151
 
 
152
 
    ALWAYS_INLINE JSValuePtr jsNumber(ExecState* exec, long long i)
153
 
    {
154
 
        JSValuePtr v = JSImmediate::from(i);
155
 
        return v ? v : jsNumberCell(exec, static_cast<double>(i));
156
 
    }
157
 
 
158
 
    ALWAYS_INLINE JSValuePtr jsNumber(ExecState* exec, unsigned long long i)
159
 
    {
160
 
        JSValuePtr v = JSImmediate::from(i);
161
 
        return v ? v : jsNumberCell(exec, static_cast<double>(i));
162
 
    }
163
 
 
164
 
    ALWAYS_INLINE JSValuePtr jsNumber(JSGlobalData* globalData, double d)
165
 
    {
166
 
        JSValuePtr v = JSImmediate::from(d);
167
 
        return v ? v : jsNumberCell(globalData, d);
168
 
    }
169
 
 
170
 
    ALWAYS_INLINE JSValuePtr jsNumber(JSGlobalData* globalData, int i)
171
 
    {
172
 
        JSValuePtr v = JSImmediate::from(i);
173
 
        return v ? v : jsNumberCell(globalData, i);
174
 
    }
175
 
 
176
 
    ALWAYS_INLINE JSValuePtr jsNumber(JSGlobalData* globalData, unsigned i)
177
 
    {
178
 
        JSValuePtr v = JSImmediate::from(i);
179
 
        return v ? v : jsNumberCell(globalData, i);
180
 
    }
181
 
 
182
 
    ALWAYS_INLINE JSValuePtr jsNumber(JSGlobalData* globalData, long i)
183
 
    {
184
 
        JSValuePtr v = JSImmediate::from(i);
185
 
        return v ? v : jsNumberCell(globalData, i);
186
 
    }
187
 
 
188
 
    ALWAYS_INLINE JSValuePtr jsNumber(JSGlobalData* globalData, unsigned long i)
189
 
    {
190
 
        JSValuePtr v = JSImmediate::from(i);
191
 
        return v ? v : jsNumberCell(globalData, i);
192
 
    }
193
 
 
194
 
    ALWAYS_INLINE JSValuePtr jsNumber(JSGlobalData* globalData, long long i)
195
 
    {
196
 
        JSValuePtr v = JSImmediate::from(i);
197
 
        return v ? v : jsNumberCell(globalData, static_cast<double>(i));
198
 
    }
199
 
 
200
 
    ALWAYS_INLINE JSValuePtr jsNumber(JSGlobalData* globalData, unsigned long long i)
201
 
    {
202
 
        JSValuePtr v = JSImmediate::from(i);
203
 
        return v ? v : jsNumberCell(globalData, static_cast<double>(i));
204
 
    }
205
 
 
206
 
    inline bool JSValuePtr::isDoubleNumber() const
 
134
 
 
135
    inline JSValue::JSValue(ExecState* exec, double d)
 
136
    {
 
137
        JSValue v = JSImmediate::from(d);
 
138
        *this = v ? v : jsNumberCell(exec, d);
 
139
    }
 
140
 
 
141
    inline JSValue::JSValue(ExecState* exec, int i)
 
142
    {
 
143
        JSValue v = JSImmediate::from(i);
 
144
        *this = v ? v : jsNumberCell(exec, i);
 
145
    }
 
146
 
 
147
    inline JSValue::JSValue(ExecState* exec, unsigned i)
 
148
    {
 
149
        JSValue v = JSImmediate::from(i);
 
150
        *this = v ? v : jsNumberCell(exec, i);
 
151
    }
 
152
 
 
153
    inline JSValue::JSValue(ExecState* exec, long i)
 
154
    {
 
155
        JSValue v = JSImmediate::from(i);
 
156
        *this = v ? v : jsNumberCell(exec, i);
 
157
    }
 
158
 
 
159
    inline JSValue::JSValue(ExecState* exec, unsigned long i)
 
160
    {
 
161
        JSValue v = JSImmediate::from(i);
 
162
        *this = v ? v : jsNumberCell(exec, i);
 
163
    }
 
164
 
 
165
    inline JSValue::JSValue(ExecState* exec, long long i)
 
166
    {
 
167
        JSValue v = JSImmediate::from(i);
 
168
        *this = v ? v : jsNumberCell(exec, static_cast<double>(i));
 
169
    }
 
170
 
 
171
    inline JSValue::JSValue(ExecState* exec, unsigned long long i)
 
172
    {
 
173
        JSValue v = JSImmediate::from(i);
 
174
        *this = v ? v : jsNumberCell(exec, static_cast<double>(i));
 
175
    }
 
176
 
 
177
    inline JSValue::JSValue(JSGlobalData* globalData, double d)
 
178
    {
 
179
        JSValue v = JSImmediate::from(d);
 
180
        *this = v ? v : jsNumberCell(globalData, d);
 
181
    }
 
182
 
 
183
    inline JSValue::JSValue(JSGlobalData* globalData, int i)
 
184
    {
 
185
        JSValue v = JSImmediate::from(i);
 
186
        *this = v ? v : jsNumberCell(globalData, i);
 
187
    }
 
188
 
 
189
    inline JSValue::JSValue(JSGlobalData* globalData, unsigned i)
 
190
    {
 
191
        JSValue v = JSImmediate::from(i);
 
192
        *this = v ? v : jsNumberCell(globalData, i);
 
193
    }
 
194
 
 
195
    inline JSValue::JSValue(JSGlobalData* globalData, long i)
 
196
    {
 
197
        JSValue v = JSImmediate::from(i);
 
198
        *this = v ? v : jsNumberCell(globalData, i);
 
199
    }
 
200
 
 
201
    inline JSValue::JSValue(JSGlobalData* globalData, unsigned long i)
 
202
    {
 
203
        JSValue v = JSImmediate::from(i);
 
204
        *this = v ? v : jsNumberCell(globalData, i);
 
205
    }
 
206
 
 
207
    inline JSValue::JSValue(JSGlobalData* globalData, long long i)
 
208
    {
 
209
        JSValue v = JSImmediate::from(i);
 
210
        *this = v ? v : jsNumberCell(globalData, static_cast<double>(i));
 
211
    }
 
212
 
 
213
    inline JSValue::JSValue(JSGlobalData* globalData, unsigned long long i)
 
214
    {
 
215
        JSValue v = JSImmediate::from(i);
 
216
        *this = v ? v : jsNumberCell(globalData, static_cast<double>(i));
 
217
    }
 
218
 
 
219
    inline bool JSValue::isDoubleNumber() const
207
220
    {
208
221
        return isNumberCell(asValue());
209
222
    }
210
223
 
211
 
    inline double JSValuePtr::getDoubleNumber() const
 
224
    inline double JSValue::getDoubleNumber() const
212
225
    {
213
226
        return asNumberCell(asValue())->value();
214
227
    }
215
228
 
216
 
    inline bool JSValuePtr::isNumber() const
 
229
    inline bool JSValue::isNumber() const
217
230
    {
218
231
        return JSImmediate::isNumber(asValue()) || isDoubleNumber();
219
232
    }
220
233
 
221
 
    inline double JSValuePtr::uncheckedGetNumber() const
 
234
    inline double JSValue::uncheckedGetNumber() const
222
235
    {
223
236
        ASSERT(isNumber());
224
237
        return JSImmediate::isImmediate(asValue()) ? JSImmediate::toDouble(asValue()) : getDoubleNumber();
225
238
    }
226
239
 
 
240
    inline bool JSValue::isAPIMangledNumber()
 
241
    {
 
242
        ASSERT(isNumber());
 
243
        return JSImmediate::isImmediate(asValue()) ? false : asNumberCell(asValue())->isAPIMangledNumber();
 
244
    }
 
245
 
227
246
#else
228
247
 
229
 
    ALWAYS_INLINE JSValuePtr jsNumber(ExecState*, double d)
230
 
    {
231
 
        JSValuePtr v = JSImmediate::from(d);
232
 
        ASSERT(v);
233
 
        return v;
234
 
    }
235
 
 
236
 
    ALWAYS_INLINE JSValuePtr jsNumber(ExecState*, int i)
237
 
    {
238
 
        JSValuePtr v = JSImmediate::from(i);
239
 
        ASSERT(v);
240
 
        return v;
241
 
    }
242
 
 
243
 
    ALWAYS_INLINE JSValuePtr jsNumber(ExecState*, unsigned i)
244
 
    {
245
 
        JSValuePtr v = JSImmediate::from(i);
246
 
        ASSERT(v);
247
 
        return v;
248
 
    }
249
 
 
250
 
    ALWAYS_INLINE JSValuePtr jsNumber(ExecState*, long i)
251
 
    {
252
 
        JSValuePtr v = JSImmediate::from(i);
253
 
        ASSERT(v);
254
 
        return v;
255
 
    }
256
 
 
257
 
    ALWAYS_INLINE JSValuePtr jsNumber(ExecState*, unsigned long i)
258
 
    {
259
 
        JSValuePtr v = JSImmediate::from(i);
260
 
        ASSERT(v);
261
 
        return v;
262
 
    }
263
 
 
264
 
    ALWAYS_INLINE JSValuePtr jsNumber(ExecState*, long long i)
265
 
    {
266
 
        JSValuePtr v = JSImmediate::from(static_cast<double>(i));
267
 
        ASSERT(v);
268
 
        return v;
269
 
    }
270
 
 
271
 
    ALWAYS_INLINE JSValuePtr jsNumber(ExecState*, unsigned long long i)
272
 
    {
273
 
        JSValuePtr v = JSImmediate::from(static_cast<double>(i));
274
 
        ASSERT(v);
275
 
        return v;
276
 
    }
277
 
 
278
 
    ALWAYS_INLINE JSValuePtr jsNumber(JSGlobalData*, double d)
279
 
    {
280
 
        JSValuePtr v = JSImmediate::from(d);
281
 
        ASSERT(v);
282
 
        return v;
283
 
    }
284
 
 
285
 
    ALWAYS_INLINE JSValuePtr jsNumber(JSGlobalData*, int i)
286
 
    {
287
 
        JSValuePtr v = JSImmediate::from(i);
288
 
        ASSERT(v);
289
 
        return v;
290
 
    }
291
 
 
292
 
    ALWAYS_INLINE JSValuePtr jsNumber(JSGlobalData*, unsigned i)
293
 
    {
294
 
        JSValuePtr v = JSImmediate::from(i);
295
 
        ASSERT(v);
296
 
        return v;
297
 
    }
298
 
 
299
 
    ALWAYS_INLINE JSValuePtr jsNumber(JSGlobalData*, long i)
300
 
    {
301
 
        JSValuePtr v = JSImmediate::from(i);
302
 
        ASSERT(v);
303
 
        return v;
304
 
    }
305
 
 
306
 
    ALWAYS_INLINE JSValuePtr jsNumber(JSGlobalData*, unsigned long i)
307
 
    {
308
 
        JSValuePtr v = JSImmediate::from(i);
309
 
        ASSERT(v);
310
 
        return v;
311
 
    }
312
 
 
313
 
    ALWAYS_INLINE JSValuePtr jsNumber(JSGlobalData*, long long i)
314
 
    {
315
 
        JSValuePtr v = JSImmediate::from(static_cast<double>(i));
316
 
        ASSERT(v);
317
 
        return v;
318
 
    }
319
 
 
320
 
    ALWAYS_INLINE JSValuePtr jsNumber(JSGlobalData*, unsigned long long i)
321
 
    {
322
 
        JSValuePtr v = JSImmediate::from(static_cast<double>(i));
323
 
        ASSERT(v);
324
 
        return v;
325
 
    }
326
 
 
327
 
    inline bool JSValuePtr::isDoubleNumber() const
 
248
    inline JSValue::JSValue(ExecState*, double d)
 
249
    {
 
250
        JSValue v = JSImmediate::from(d);
 
251
        ASSERT(v);
 
252
        *this = v;
 
253
    }
 
254
 
 
255
    inline JSValue::JSValue(ExecState*, int i)
 
256
    {
 
257
        JSValue v = JSImmediate::from(i);
 
258
        ASSERT(v);
 
259
        *this = v;
 
260
    }
 
261
 
 
262
    inline JSValue::JSValue(ExecState*, unsigned i)
 
263
    {
 
264
        JSValue v = JSImmediate::from(i);
 
265
        ASSERT(v);
 
266
        *this = v;
 
267
    }
 
268
 
 
269
    inline JSValue::JSValue(ExecState*, long i)
 
270
    {
 
271
        JSValue v = JSImmediate::from(i);
 
272
        ASSERT(v);
 
273
        *this = v;
 
274
    }
 
275
 
 
276
    inline JSValue::JSValue(ExecState*, unsigned long i)
 
277
    {
 
278
        JSValue v = JSImmediate::from(i);
 
279
        ASSERT(v);
 
280
        *this = v;
 
281
    }
 
282
 
 
283
    inline JSValue::JSValue(ExecState*, long long i)
 
284
    {
 
285
        JSValue v = JSImmediate::from(static_cast<double>(i));
 
286
        ASSERT(v);
 
287
        *this = v;
 
288
    }
 
289
 
 
290
    inline JSValue::JSValue(ExecState*, unsigned long long i)
 
291
    {
 
292
        JSValue v = JSImmediate::from(static_cast<double>(i));
 
293
        ASSERT(v);
 
294
        *this = v;
 
295
    }
 
296
 
 
297
    inline JSValue::JSValue(JSGlobalData*, double d)
 
298
    {
 
299
        JSValue v = JSImmediate::from(d);
 
300
        ASSERT(v);
 
301
        *this = v;
 
302
    }
 
303
 
 
304
    inline JSValue::JSValue(JSGlobalData*, int i)
 
305
    {
 
306
        JSValue v = JSImmediate::from(i);
 
307
        ASSERT(v);
 
308
        *this = v;
 
309
    }
 
310
 
 
311
    inline JSValue::JSValue(JSGlobalData*, unsigned i)
 
312
    {
 
313
        JSValue v = JSImmediate::from(i);
 
314
        ASSERT(v);
 
315
        *this = v;
 
316
    }
 
317
 
 
318
    inline JSValue::JSValue(JSGlobalData*, long i)
 
319
    {
 
320
        JSValue v = JSImmediate::from(i);
 
321
        ASSERT(v);
 
322
        *this = v;
 
323
    }
 
324
 
 
325
    inline JSValue::JSValue(JSGlobalData*, unsigned long i)
 
326
    {
 
327
        JSValue v = JSImmediate::from(i);
 
328
        ASSERT(v);
 
329
        *this = v;
 
330
    }
 
331
 
 
332
    inline JSValue::JSValue(JSGlobalData*, long long i)
 
333
    {
 
334
        JSValue v = JSImmediate::from(static_cast<double>(i));
 
335
        ASSERT(v);
 
336
        *this = v;
 
337
    }
 
338
 
 
339
    inline JSValue::JSValue(JSGlobalData*, unsigned long long i)
 
340
    {
 
341
        JSValue v = JSImmediate::from(static_cast<double>(i));
 
342
        ASSERT(v);
 
343
        *this = v;
 
344
    }
 
345
 
 
346
    inline bool JSValue::isDoubleNumber() const
328
347
    {
329
348
        return JSImmediate::isDoubleNumber(asValue());
330
349
    }
331
350
 
332
 
    inline double JSValuePtr::getDoubleNumber() const
 
351
    inline double JSValue::getDoubleNumber() const
333
352
    {
334
353
        return JSImmediate::doubleValue(asValue());
335
354
    }
336
355
 
337
 
    inline bool JSValuePtr::isNumber() const
 
356
    inline bool JSValue::isNumber() const
338
357
    {
339
358
        return JSImmediate::isNumber(asValue());
340
359
    }
341
360
 
342
 
    inline double JSValuePtr::uncheckedGetNumber() const
 
361
    inline double JSValue::uncheckedGetNumber() const
343
362
    {
344
363
        ASSERT(isNumber());
345
364
        return JSImmediate::toDouble(asValue());
347
366
 
348
367
#endif
349
368
 
350
 
    ALWAYS_INLINE JSValuePtr jsNumber(ExecState*, char i)
351
 
    {
352
 
        ASSERT(JSImmediate::from(i));
353
 
        return JSImmediate::from(i);
354
 
    }
355
 
 
356
 
    ALWAYS_INLINE JSValuePtr jsNumber(ExecState*, unsigned char i)
357
 
    {
358
 
        ASSERT(JSImmediate::from(i));
359
 
        return JSImmediate::from(i);
360
 
    }
361
 
 
362
 
    ALWAYS_INLINE JSValuePtr jsNumber(ExecState*, short i)
363
 
    {
364
 
        ASSERT(JSImmediate::from(i));
365
 
        return JSImmediate::from(i);
366
 
    }
367
 
 
368
 
    ALWAYS_INLINE JSValuePtr jsNumber(ExecState*, unsigned short i)
369
 
    {
370
 
        ASSERT(JSImmediate::from(i));
371
 
        return JSImmediate::from(i);
372
 
    }
373
 
 
374
 
    ALWAYS_INLINE JSValuePtr jsNumber(JSGlobalData*, short i)
375
 
    {
376
 
        ASSERT(JSImmediate::from(i));
377
 
        return JSImmediate::from(i);
378
 
    }
379
 
 
380
 
    ALWAYS_INLINE JSValuePtr jsNumber(JSGlobalData*, unsigned short i)
381
 
    {
382
 
        ASSERT(JSImmediate::from(i));
383
 
        return JSImmediate::from(i);
384
 
    }
385
 
 
386
 
    inline JSValuePtr jsNaN(ExecState* exec)
 
369
    inline JSValue::JSValue(ExecState*, char i)
 
370
    {
 
371
        ASSERT(JSImmediate::from(i));
 
372
        *this = JSImmediate::from(i);
 
373
    }
 
374
 
 
375
    inline JSValue::JSValue(ExecState*, unsigned char i)
 
376
    {
 
377
        ASSERT(JSImmediate::from(i));
 
378
        *this = JSImmediate::from(i);
 
379
    }
 
380
 
 
381
    inline JSValue::JSValue(ExecState*, short i)
 
382
    {
 
383
        ASSERT(JSImmediate::from(i));
 
384
        *this = JSImmediate::from(i);
 
385
    }
 
386
 
 
387
    inline JSValue::JSValue(ExecState*, unsigned short i)
 
388
    {
 
389
        ASSERT(JSImmediate::from(i));
 
390
        *this = JSImmediate::from(i);
 
391
    }
 
392
 
 
393
    inline JSValue::JSValue(JSGlobalData*, char i)
 
394
    {
 
395
        ASSERT(JSImmediate::from(i));
 
396
        *this = JSImmediate::from(i);
 
397
    }
 
398
 
 
399
    inline JSValue::JSValue(JSGlobalData*, unsigned char i)
 
400
    {
 
401
        ASSERT(JSImmediate::from(i));
 
402
        *this = JSImmediate::from(i);
 
403
    }
 
404
 
 
405
    inline JSValue::JSValue(JSGlobalData*, short i)
 
406
    {
 
407
        ASSERT(JSImmediate::from(i));
 
408
        *this = JSImmediate::from(i);
 
409
    }
 
410
 
 
411
    inline JSValue::JSValue(JSGlobalData*, unsigned short i)
 
412
    {
 
413
        ASSERT(JSImmediate::from(i));
 
414
        *this = JSImmediate::from(i);
 
415
    }
 
416
 
 
417
    inline JSValue jsNaN(ExecState* exec)
387
418
    {
388
419
        return jsNumber(exec, NaN);
389
420
    }
390
421
 
391
 
    inline JSValuePtr jsNaN(JSGlobalData* globalData)
 
422
    inline JSValue jsNaN(JSGlobalData* globalData)
392
423
    {
393
424
        return jsNumber(globalData, NaN);
394
425
    }
395
426
 
396
427
    // --- JSValue inlines ----------------------------
397
428
 
398
 
    ALWAYS_INLINE JSValuePtr JSValuePtr::toJSNumber(ExecState* exec) const
 
429
    ALWAYS_INLINE JSValue JSValue::toJSNumber(ExecState* exec) const
399
430
    {
400
431
        return isNumber() ? asValue() : jsNumber(exec, this->toNumber(exec));
401
432
    }
402
433
 
403
 
    inline bool JSValuePtr::getNumber(double &result) const
 
434
    inline bool JSValue::getNumber(double &result) const
404
435
    {
405
436
        if (isInt32Fast())
406
437
            result = getInt32Fast();
413
444
        return true;
414
445
    }
415
446
 
416
 
    inline bool JSValuePtr::numberToInt32(int32_t& arg)
 
447
    inline bool JSValue::numberToInt32(int32_t& arg)
417
448
    {
418
449
        if (isInt32Fast())
419
450
            arg = getInt32Fast();
426
457
        return true;
427
458
    }
428
459
 
429
 
    inline bool JSValuePtr::numberToUInt32(uint32_t& arg)
 
460
    inline bool JSValue::numberToUInt32(uint32_t& arg)
430
461
    {
431
462
        if (isUInt32Fast())
432
463
            arg = getUInt32Fast();