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 jsdisp_t *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, JS_E_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 if(isnan(V_R8(&num))) {
455 V_VT(ret) = VT_I4;
456 V_I4(ret) = 0;
457 }else {
458 num_set_val(ret, V_R8(&num) >= 0.0 ? floor(V_R8(&num)) : -floor(-V_R8(&num)));
459 }
460
461 return S_OK;
462 }
463
464 /* ECMA-262 3rd Edition 9.5 */
465 HRESULT to_int32(script_ctx_t *ctx, VARIANT *v, jsexcept_t *ei, INT *ret)
466 {
467 VARIANT num;
468 HRESULT hres;
469
470 hres = to_number(ctx, v, ei, &num);
471 if(FAILED(hres))
472 return hres;
473
474 if(V_VT(&num) == VT_I4)
475 *ret = V_I4(&num);
476 else
477 *ret = isnan(V_R8(&num)) || isinf(V_R8(&num)) ? 0 : (INT)V_R8(&num);
478 return S_OK;
479 }
480
481 /* ECMA-262 3rd Edition 9.6 */
482 HRESULT to_uint32(script_ctx_t *ctx, VARIANT *v, jsexcept_t *ei, DWORD *ret)
483 {
484 VARIANT num;
485 HRESULT hres;
486
487 hres = to_number(ctx, v, ei, &num);
488 if(FAILED(hres))
489 return hres;
490
491 if(V_VT(&num) == VT_I4)
492 *ret = V_I4(&num);
493 else
494 *ret = isnan(V_R8(&num)) || isinf(V_R8(&num)) ? 0 : (DWORD)V_R8(&num);
495 return S_OK;
496 }
497
498 static BSTR int_to_bstr(INT i)
499 {
500 WCHAR buf[12], *p;
501 BOOL neg = FALSE;
502
503 if(!i) {
504 static const WCHAR zeroW[] = {'',0};
505 return SysAllocString(zeroW);
506 }
507
508 if(i < 0) {
509 neg = TRUE;
510 i = -i;
511 }
512
513 p = buf + sizeof(buf)/sizeof(*buf)-1;
514 *p-- = 0;
515 while(i) {
516 *p-- = i%10 + '';
517 i /= 10;
518 }
519
520 if(neg)
521 *p = '-';
522 else
523 p++;
524
525 return SysAllocString(p);
526 }
527
528 /* ECMA-262 3rd Edition 9.8 */
529 HRESULT to_string(script_ctx_t *ctx, VARIANT *v, jsexcept_t *ei, BSTR *str)
530 {
531 const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',0};
532 const WCHAR nullW[] = {'n','u','l','l',0};
533 const WCHAR trueW[] = {'t','r','u','e',0};
534 const WCHAR falseW[] = {'f','a','l','s','e',0};
535 const WCHAR NaNW[] = {'N','a','N',0};
536 const WCHAR InfinityW[] = {'-','I','n','f','i','n','i','t','y',0};
537
538 switch(V_VT(v)) {
539 case VT_EMPTY:
540 *str = SysAllocString(undefinedW);
541 break;
542 case VT_NULL:
543 *str = SysAllocString(nullW);
544 break;
545 case VT_I4:
546 *str = int_to_bstr(V_I4(v));
547 break;
548 case VT_R8: {
549 if(isnan(V_R8(v)))
550 *str = SysAllocString(NaNW);
551 else if(isinf(V_R8(v)))
552 *str = SysAllocString(V_R8(v)<0 ? InfinityW : InfinityW+1);
553 else {
554 VARIANT strv;
555 HRESULT hres;
556
557 V_VT(&strv) = VT_EMPTY;
558 hres = VariantChangeTypeEx(&strv, v, MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT), 0, VT_BSTR);
559 if(FAILED(hres))
560 return hres;
561
562 *str = V_BSTR(&strv);
563 return S_OK;
564 }
565 break;
566 }
567 case VT_BSTR:
568 *str = SysAllocString(V_BSTR(v));
569 break;
570 case VT_DISPATCH: {
571 VARIANT prim;
572 HRESULT hres;
573
574 hres = to_primitive(ctx, v, ei, &prim, HINT_STRING);
575 if(FAILED(hres))
576 return hres;
577
578 hres = to_string(ctx, &prim, ei, str);
579 VariantClear(&prim);
580 return hres;
581 }
582 case VT_BOOL:
583 *str = SysAllocString(V_BOOL(v) ? trueW : falseW);
584 break;
585 default:
586 FIXME("unsupported vt %d\n", V_VT(v));
587 return E_NOTIMPL;
588 }
589
590 return *str ? S_OK : E_OUTOFMEMORY;
591 }
592
593 /* ECMA-262 3rd Edition 9.9 */
594 HRESULT to_object(script_ctx_t *ctx, VARIANT *v, IDispatch **disp)
595 {
596 jsdisp_t *dispex;
597 HRESULT hres;
598
599 switch(V_VT(v)) {
600 case VT_BSTR:
601 hres = create_string(ctx, V_BSTR(v), SysStringLen(V_BSTR(v)), &dispex);
602 if(FAILED(hres))
603 return hres;
604
605 *disp = to_disp(dispex);
606 break;
607 case VT_I4:
608 case VT_R8:
609 hres = create_number(ctx, v, &dispex);
610 if(FAILED(hres))
611 return hres;
612
613 *disp = to_disp(dispex);
614 break;
615 case VT_DISPATCH:
616 if(V_DISPATCH(v)) {
617 IDispatch_AddRef(V_DISPATCH(v));
618 *disp = V_DISPATCH(v);
619 }else {
620 jsdisp_t *obj;
621
622 hres = create_object(ctx, NULL, &obj);
623 if(FAILED(hres))
624 return hres;
625
626 *disp = to_disp(obj);
627 }
628 break;
629 case VT_BOOL:
630 hres = create_bool(ctx, V_BOOL(v), &dispex);
631 if(FAILED(hres))
632 return hres;
633
634 *disp = to_disp(dispex);
635 break;
636 case VT_ARRAY|VT_VARIANT:
637 hres = create_vbarray(ctx, V_ARRAY(v), &dispex);
638 if(FAILED(hres))
639 return hres;
640
641 *disp = to_disp(dispex);
642 break;
643 default:
644 FIXME("unsupported vt %d\n", V_VT(v));
645 return E_NOTIMPL;
646 }
647
648 return S_OK;
649 }
650
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.