kernel32: Do not load 16-bit krnl386.exe by default.
[wine] / dlls / jscript / jsutils.c
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('0' <= c && c <= '9')
300         return c-'0';
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 == '0' && 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++ - '0');
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++ - '0');
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++ - '0');
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',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 + '0';
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     DispatchEx *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 = (IDispatch*)_IDispatchEx_(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 = (IDispatch*)_IDispatchEx_(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             DispatchEx *obj;
621
622             hres = create_object(ctx, NULL, &obj);
623             if(FAILED(hres))
624                 return hres;
625
626             *disp = (IDispatch*)_IDispatchEx_(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 = (IDispatch*)_IDispatchEx_(dispex);
635         break;
636     default:
637         FIXME("unsupported vt %d\n", V_VT(v));
638         return E_NOTIMPL;
639     }
640
641     return S_OK;
642 }