1 /*
2 * Copyright 2008 Jacek Caban for CodeWeavers
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #include "config.h"
20 #include "wine/port.h"
21
22 #include <math.h>
23
24 #include "jscript.h"
25 #include "engine.h"
26
27 #include "wine/debug.h"
28
29 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
30 WINE_DECLARE_DEBUG_CHANNEL(heap);
31
32 const char *debugstr_variant(const VARIANT *v)
33 {
34 if(!v)
35 return "(null)";
36
37 switch(V_VT(v)) {
38 case VT_EMPTY:
39 return "{VT_EMPTY}";
40 case VT_NULL:
41 return "{VT_NULL}";
42 case VT_I4:
43 return wine_dbg_sprintf("{VT_I4: %d}", V_I4(v));
44 case VT_R8:
45 return wine_dbg_sprintf("{VT_R8: %lf}", V_R8(v));
46 case VT_BSTR:
47 return wine_dbg_sprintf("{VT_BSTR: %s}", debugstr_w(V_BSTR(v)));
48 case VT_DISPATCH:
49 return wine_dbg_sprintf("{VT_DISPATCH: %p}", V_DISPATCH(v));
50 case VT_BOOL:
51 return wine_dbg_sprintf("{VT_BOOL: %x}", V_BOOL(v));
52 default:
53 return wine_dbg_sprintf("{vt %d}", V_VT(v));
54 }
55 }
56
57 #define MIN_BLOCK_SIZE 128
58 #define ARENA_FREE_FILLER 0xaa
59
60 static inline DWORD block_size(DWORD block)
61 {
62 return MIN_BLOCK_SIZE << block;
63 }
64
65 void jsheap_init(jsheap_t *heap)
66 {
67 memset(heap, 0, sizeof(*heap));
68 list_init(&heap->custom_blocks);
69 }
70
71 void *jsheap_alloc(jsheap_t *heap, DWORD size)
72 {
73 struct list *list;
74 void *tmp;
75
76 if(!heap->block_cnt) {
77 if(!heap->blocks) {
78 heap->blocks = heap_alloc(sizeof(void*));
79 if(!heap->blocks)
80 return NULL;
81 }
82
83 tmp = heap_alloc(block_size(0));
84 if(!tmp)
85 return NULL;
86
87 heap->blocks[0] = tmp;
88 heap->block_cnt = 1;
89 }
90
91 if(heap->offset + size <= block_size(heap->last_block)) {
92 tmp = ((BYTE*)heap->blocks[heap->last_block])+heap->offset;
93 heap->offset += size;
94 return tmp;
95 }
96
97 if(size <= block_size(heap->last_block+1)) {
98 if(heap->last_block+1 == heap->block_cnt) {
99 tmp = heap_realloc(heap->blocks, (heap->block_cnt+1)*sizeof(void*));
100 if(!tmp)
101 return NULL;
102
103 heap->blocks = tmp;
104 heap->blocks[heap->block_cnt] = heap_alloc(block_size(heap->block_cnt));
105 if(!heap->blocks[heap->block_cnt])
106 return NULL;
107
108 heap->block_cnt++;
109 }
110
111 heap->last_block++;
112 heap->offset = size;
113 return heap->blocks[heap->last_block];
114 }
115
116 list = heap_alloc(size + sizeof(struct list));
117 if(!list)
118 return NULL;
119
120 list_add_head(&heap->custom_blocks, list);
121 return list+1;
122 }
123
124 void *jsheap_grow(jsheap_t *heap, void *mem, DWORD size, DWORD inc)
125 {
126 if(mem == (BYTE*)heap->blocks[heap->last_block] + heap->offset-size
127 && heap->offset+inc < block_size(heap->last_block)) {
128 heap->offset += inc;
129 return mem;
130 }
131
132 return jsheap_alloc(heap, size+inc);
133 }
134
135 void jsheap_clear(jsheap_t *heap)
136 {
137 struct list *tmp;
138
139 if(!heap)
140 return;
141
142 while((tmp = list_next(&heap->custom_blocks, &heap->custom_blocks))) {
143 list_remove(tmp);
144 heap_free(tmp);
145 }
146
147 if(WARN_ON(heap)) {
148 DWORD i;
149
150 for(i=0; i < heap->block_cnt; i++)
151 memset(heap->blocks[i], ARENA_FREE_FILLER, block_size(i));
152 }
153
154 heap->last_block = heap->offset = 0;
155 heap->mark = FALSE;
156 }
157
158 void jsheap_free(jsheap_t *heap)
159 {
160 DWORD i;
161
162 jsheap_clear(heap);
163
164 for(i=0; i < heap->block_cnt; i++)
165 heap_free(heap->blocks[i]);
166 heap_free(heap->blocks);
167
168 jsheap_init(heap);
169 }
170
171 jsheap_t *jsheap_mark(jsheap_t *heap)
172 {
173 if(heap->mark)
174 return NULL;
175
176 heap->mark = TRUE;
177 return heap;
178 }
179
180 /* ECMA-262 3rd Edition 9.1 */
181 HRESULT to_primitive(script_ctx_t *ctx, VARIANT *v, jsexcept_t *ei, VARIANT *ret, hint_t hint)
182 {
183 switch(V_VT(v)) {
184 case VT_EMPTY:
185 case VT_NULL:
186 case VT_BOOL:
187 case VT_I4:
188 case VT_R8:
189 *ret = *v;
190 break;
191 case VT_BSTR:
192 V_VT(ret) = VT_BSTR;
193 V_BSTR(ret) = SysAllocString(V_BSTR(v));
194 break;
195 case VT_DISPATCH: {
196 DispatchEx *jsdisp;
197 DISPID id;
198 DISPPARAMS dp = {NULL, NULL, 0, 0};
199 HRESULT hres;
200
201 static const WCHAR toStringW[] = {'t','o','S','t','r','i','n','g',0};
202 static const WCHAR valueOfW[] = {'v','a','l','u','e','O','f',0};
203
204 if(!V_DISPATCH(v)) {
205 V_VT(ret) = VT_NULL;
206 break;
207 }
208
209 jsdisp = iface_to_jsdisp((IUnknown*)V_DISPATCH(v));
210 if(!jsdisp) {
211 V_VT(ret) = VT_EMPTY;
212 return disp_propget(ctx, V_DISPATCH(v), DISPID_VALUE, ret, ei, NULL /*FIXME*/);
213 }
214
215 if(hint == NO_HINT)
216 hint = is_class(jsdisp, JSCLASS_DATE) ? HINT_STRING : HINT_NUMBER;
217
218 /* Native implementation doesn't throw TypeErrors, returns strange values */
219
220 hres = jsdisp_get_id(jsdisp, hint == HINT_STRING ? toStringW : valueOfW, 0, &id);
221 if(SUCCEEDED(hres)) {
222 hres = jsdisp_call(jsdisp, id, DISPATCH_METHOD, &dp, ret, ei, NULL /*FIXME*/);
223 if(FAILED(hres)) {
224 WARN("call error - forwarding exception\n");
225 jsdisp_release(jsdisp);
226 return hres;
227 }
228 else if(V_VT(ret) != VT_DISPATCH) {
229 jsdisp_release(jsdisp);
230 return S_OK;
231 }
232 else
233 IDispatch_Release(V_DISPATCH(ret));
234 }
235
236 hres = jsdisp_get_id(jsdisp, hint == HINT_STRING ? valueOfW : toStringW, 0, &id);
237 if(SUCCEEDED(hres)) {
238 hres = jsdisp_call(jsdisp, id, DISPATCH_METHOD, &dp, ret, ei, NULL /*FIXME*/);
239 if(FAILED(hres)) {
240 WARN("call error - forwarding exception\n");
241 jsdisp_release(jsdisp);
242 return hres;
243 }
244 else if(V_VT(ret) != VT_DISPATCH) {
245 jsdisp_release(jsdisp);
246 return S_OK;
247 }
248 else
249 IDispatch_Release(V_DISPATCH(ret));
250 }
251
252 jsdisp_release(jsdisp);
253
254 WARN("failed\n");
255 return throw_type_error(ctx, ei, IDS_TO_PRIMITIVE, NULL);
256 }
257 default:
258 FIXME("Unimplemented for vt %d\n", V_VT(v));
259 return E_NOTIMPL;
260 }
261
262 return S_OK;
263 }
264
265 /* ECMA-262 3rd Edition 9.2 */
266 HRESULT to_boolean(VARIANT *v, VARIANT_BOOL *b)
267 {
268 switch(V_VT(v)) {
269 case VT_EMPTY:
270 case VT_NULL:
271 *b = VARIANT_FALSE;
272 break;
273 case VT_I4:
274 *b = V_I4(v) ? VARIANT_TRUE : VARIANT_FALSE;
275 break;
276 case VT_R8:
277 if(isnan(V_R8(v))) *b = VARIANT_FALSE;
278 else *b = V_R8(v) ? VARIANT_TRUE : VARIANT_FALSE;
279 break;
280 case VT_BSTR:
281 *b = V_BSTR(v) && *V_BSTR(v) ? VARIANT_TRUE : VARIANT_FALSE;
282 break;
283 case VT_DISPATCH:
284 *b = V_DISPATCH(v) ? VARIANT_TRUE : VARIANT_FALSE;
285 break;
286 case VT_BOOL:
287 *b = V_BOOL(v);
288 break;
289 default:
290 FIXME("unimplemented for vt %d\n", V_VT(v));
291 return E_NOTIMPL;
292 }
293
294 return S_OK;
295 }
296
297 static int hex_to_int(WCHAR c)
298 {
299 if('' <= c && c <= '9')
300 return c-'';
301
302 if('a' <= c && c <= 'f')
303 return c-'a'+10;
304
305 if('A' <= c && c <= 'F')
306 return c-'A'+10;
307
308 return -1;
309 }
310
311 /* ECMA-262 3rd Edition 9.3.1 */
312 static HRESULT str_to_number(BSTR str, VARIANT *ret)
313 {
314 const WCHAR *ptr = str;
315 BOOL neg = FALSE;
316 DOUBLE d = 0.0;
317
318 static const WCHAR infinityW[] = {'I','n','f','i','n','i','t','y'};
319
320 while(isspaceW(*ptr))
321 ptr++;
322
323 if(*ptr == '-') {
324 neg = TRUE;
325 ptr++;
326 }else if(*ptr == '+') {
327 ptr++;
328 }
329
330 if(!strncmpW(ptr, infinityW, sizeof(infinityW)/sizeof(WCHAR))) {
331 ptr += sizeof(infinityW)/sizeof(WCHAR);
332 while(*ptr && isspaceW(*ptr))
333 ptr++;
334
335 if(*ptr)
336 num_set_nan(ret);
337 else
338 num_set_inf(ret, !neg);
339 return S_OK;
340 }
341
342 if(*ptr == '' && ptr[1] == 'x') {
343 DWORD l = 0;
344
345 ptr += 2;
346 while((l = hex_to_int(*ptr)) != -1) {
347 d = d*16 + l;
348 ptr++;
349 }
350
351 num_set_val(ret, d);
352 return S_OK;
353 }
354
355 while(isdigitW(*ptr))
356 d = d*10 + (*ptr++ - '');
357
358 if(*ptr == 'e' || *ptr == 'E') {
359 BOOL eneg = FALSE;
360 LONG l = 0;
361
362 ptr++;
363 if(*ptr == '-') {
364 ptr++;
365 eneg = TRUE;
366 }else if(*ptr == '+') {
367 ptr++;
368 }
369
370 while(isdigitW(*ptr))
371 l = l*10 + (*ptr++ - '');
372 if(eneg)
373 l = -l;
374
375 d *= pow(10, l);
376 }else if(*ptr == '.') {
377 DOUBLE dec = 0.1;
378
379 ptr++;
380 while(isdigitW(*ptr)) {
381 d += dec * (*ptr++ - '');
382 dec *= 0.1;
383 }
384 }
385
386 while(isspaceW(*ptr))
387 ptr++;
388
389 if(*ptr) {
390 num_set_nan(ret);
391 return S_OK;
392 }
393
394 if(neg)
395 d = -d;
396
397 num_set_val(ret, d);
398 return S_OK;
399 }
400
401 /* ECMA-262 3rd Edition 9.3 */
402 HRESULT to_number(script_ctx_t *ctx, VARIANT *v, jsexcept_t *ei, VARIANT *ret)
403 {
404 switch(V_VT(v)) {
405 case VT_EMPTY:
406 num_set_nan(ret);
407 break;
408 case VT_NULL:
409 V_VT(ret) = VT_I4;
410 V_I4(ret) = 0;
411 break;
412 case VT_I4:
413 case VT_R8:
414 *ret = *v;
415 break;
416 case VT_BSTR:
417 return str_to_number(V_BSTR(v), ret);
418 case VT_DISPATCH: {
419 VARIANT prim;
420 HRESULT hres;
421
422 hres = to_primitive(ctx, v, ei, &prim, HINT_NUMBER);
423 if(FAILED(hres))
424 return hres;
425
426 hres = to_number(ctx, &prim, ei, ret);
427 VariantClear(&prim);
428 return hres;
429 }
430 case VT_BOOL:
431 V_VT(ret) = VT_I4;
432 V_I4(ret) = V_BOOL(v) ? 1 : 0;
433 break;
434 default:
435 FIXME("unimplemented for vt %d\n", V_VT(v));
436 return E_NOTIMPL;
437 }
438
439 return S_OK;
440 }
441
442 /* ECMA-262 3rd Edition 9.4 */
443 HRESULT to_integer(script_ctx_t *ctx, VARIANT *v, jsexcept_t *ei, VARIANT *ret)
444 {
445 VARIANT num;
446 HRESULT hres;
447
448 hres = to_number(ctx, v, ei, &num);
449 if(FAILED(hres))
450 return hres;
451
452 if(V_VT(&num) == VT_I4)
453 *ret = num;
454 else
455 num_set_val(ret, V_R8(&num) >= 0.0 ? floor(V_R8(&num)) : -floor(-V_R8(&num)));
456
457 return S_OK;
458 }
459
460 /* ECMA-262 3rd Edition 9.5 */
461 HRESULT to_int32(script_ctx_t *ctx, VARIANT *v, jsexcept_t *ei, INT *ret)
462 {
463 VARIANT num;
464 HRESULT hres;
465
466 hres = to_number(ctx, v, ei, &num);
467 if(FAILED(hres))
468 return hres;
469
470 *ret = V_VT(&num) == VT_I4 ? V_I4(&num) : (INT)V_R8(&num);
471 return S_OK;
472 }
473
474 /* ECMA-262 3rd Edition 9.6 */
475 HRESULT to_uint32(script_ctx_t *ctx, VARIANT *v, jsexcept_t *ei, DWORD *ret)
476 {
477 VARIANT num;
478 HRESULT hres;
479
480 hres = to_number(ctx, v, ei, &num);
481 if(FAILED(hres))
482 return hres;
483
484 *ret = V_VT(&num) == VT_I4 ? V_I4(&num) : (DWORD)V_R8(&num);
485 return S_OK;
486 }
487
488 static BSTR int_to_bstr(INT i)
489 {
490 WCHAR buf[12], *p;
491 BOOL neg = FALSE;
492
493 if(!i) {
494 static const WCHAR zeroW[] = {'',0};
495 return SysAllocString(zeroW);
496 }
497
498 if(i < 0) {
499 neg = TRUE;
500 i = -i;
501 }
502
503 p = buf + sizeof(buf)/sizeof(*buf)-1;
504 *p-- = 0;
505 while(i) {
506 *p-- = i%10 + '';
507 i /= 10;
508 }
509
510 if(neg)
511 *p = '-';
512 else
513 p++;
514
515 return SysAllocString(p);
516 }
517
518 /* ECMA-262 3rd Edition 9.8 */
519 HRESULT to_string(script_ctx_t *ctx, VARIANT *v, jsexcept_t *ei, BSTR *str)
520 {
521 const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',0};
522 const WCHAR nullW[] = {'n','u','l','l',0};
523 const WCHAR trueW[] = {'t','r','u','e',0};
524 const WCHAR falseW[] = {'f','a','l','s','e',0};
525 const WCHAR NaNW[] = {'N','a','N',0};
526 const WCHAR InfinityW[] = {'-','I','n','f','i','n','i','t','y',0};
527
528 switch(V_VT(v)) {
529 case VT_EMPTY:
530 *str = SysAllocString(undefinedW);
531 break;
532 case VT_NULL:
533 *str = SysAllocString(nullW);
534 break;
535 case VT_I4:
536 *str = int_to_bstr(V_I4(v));
537 break;
538 case VT_R8: {
539 if(isnan(V_R8(v)))
540 *str = SysAllocString(NaNW);
541 else if(isinf(V_R8(v)))
542 *str = SysAllocString(V_R8(v)<0 ? InfinityW : InfinityW+1);
543 else {
544 VARIANT strv;
545 HRESULT hres;
546
547 V_VT(&strv) = VT_EMPTY;
548 hres = VariantChangeTypeEx(&strv, v, MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT), 0, VT_BSTR);
549 if(FAILED(hres))
550 return hres;
551
552 *str = V_BSTR(&strv);
553 return S_OK;
554 }
555 break;
556 }
557 case VT_BSTR:
558 *str = SysAllocString(V_BSTR(v));
559 break;
560 case VT_DISPATCH: {
561 VARIANT prim;
562 HRESULT hres;
563
564 hres = to_primitive(ctx, v, ei, &prim, HINT_STRING);
565 if(FAILED(hres))
566 return hres;
567
568 hres = to_string(ctx, &prim, ei, str);
569 VariantClear(&prim);
570 return hres;
571 }
572 case VT_BOOL:
573 *str = SysAllocString(V_BOOL(v) ? trueW : falseW);
574 break;
575 default:
576 FIXME("unsupported vt %d\n", V_VT(v));
577 return E_NOTIMPL;
578 }
579
580 return *str ? S_OK : E_OUTOFMEMORY;
581 }
582
583 /* ECMA-262 3rd Edition 9.9 */
584 HRESULT to_object(script_ctx_t *ctx, VARIANT *v, IDispatch **disp)
585 {
586 DispatchEx *dispex;
587 HRESULT hres;
588
589 switch(V_VT(v)) {
590 case VT_BSTR:
591 hres = create_string(ctx, V_BSTR(v), SysStringLen(V_BSTR(v)), &dispex);
592 if(FAILED(hres))
593 return hres;
594
595 *disp = (IDispatch*)_IDispatchEx_(dispex);
596 break;
597 case VT_I4:
598 case VT_R8:
599 hres = create_number(ctx, v, &dispex);
600 if(FAILED(hres))
601 return hres;
602
603 *disp = (IDispatch*)_IDispatchEx_(dispex);
604 break;
605 case VT_DISPATCH:
606 if(V_DISPATCH(v)) {
607 IDispatch_AddRef(V_DISPATCH(v));
608 *disp = V_DISPATCH(v);
609 }else {
610 DispatchEx *obj;
611
612 hres = create_object(ctx, NULL, &obj);
613 if(FAILED(hres))
614 return hres;
615
616 *disp = (IDispatch*)_IDispatchEx_(obj);
617 }
618 break;
619 case VT_BOOL:
620 hres = create_bool(ctx, V_BOOL(v), &dispex);
621 if(FAILED(hres))
622 return hres;
623
624 *disp = (IDispatch*)_IDispatchEx_(dispex);
625 break;
626 default:
627 FIXME("unsupported vt %d\n", V_VT(v));
628 return E_NOTIMPL;
629 }
630
631 return S_OK;
632 }
633
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.