includes: Fix alignment for 64-bits
[wine/wine64.git] / dlls / jscript / jsutils.c
blobdefddd4b0cd9731a2be71a97c662c7b6c1c39353
1 /*
2 * Copyright 2008 Jacek Caban for CodeWeavers
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.
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.
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
19 #include "config.h"
20 #include "wine/port.h"
22 #include <math.h>
24 #include "jscript.h"
25 #include "engine.h"
27 #include "wine/debug.h"
29 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
31 const char *debugstr_variant(const VARIANT *v)
33 switch(V_VT(v)) {
34 case VT_EMPTY:
35 return wine_dbg_sprintf("{VT_EMPTY}");
36 case VT_NULL:
37 return wine_dbg_sprintf("{VT_NULL}");
38 case VT_I4:
39 return wine_dbg_sprintf("{VT_I4: %d}", V_I4(v));
40 case VT_R8:
41 return wine_dbg_sprintf("{VT_R8: %lf}", V_R8(v));
42 case VT_BSTR:
43 return wine_dbg_sprintf("{VT_BSTR: %s}", debugstr_w(V_BSTR(v)));
44 case VT_DISPATCH:
45 return wine_dbg_sprintf("{VT_DISPATCH: %p}", V_DISPATCH(v));
46 case VT_BOOL:
47 return wine_dbg_sprintf("{VT_BOOL: %x}", V_BOOL(v));
48 default:
49 return wine_dbg_sprintf("{vt %d}", V_VT(v));
53 #define MIN_BLOCK_SIZE 128
55 static inline DWORD block_size(DWORD block)
57 return MIN_BLOCK_SIZE << block;
60 void jsheap_init(jsheap_t *heap)
62 memset(heap, 0, sizeof(*heap));
63 list_init(&heap->custom_blocks);
66 void *jsheap_alloc(jsheap_t *heap, DWORD size)
68 struct list *list;
69 void *tmp;
71 if(!heap->block_cnt) {
72 if(!heap->blocks) {
73 heap->blocks = heap_alloc(sizeof(void*));
74 if(!heap->blocks)
75 return NULL;
78 tmp = heap_alloc(block_size(0));
79 if(!tmp)
80 return NULL;
82 heap->blocks[0] = tmp;
83 heap->block_cnt = 1;
86 if(heap->offset + size < block_size(heap->last_block)) {
87 tmp = ((BYTE*)heap->blocks[heap->last_block])+heap->offset;
88 heap->offset += size;
89 return tmp;
92 if(size < block_size(heap->last_block+1)) {
93 if(heap->last_block+1 == heap->block_cnt) {
94 tmp = heap_realloc(heap->blocks, (heap->block_cnt+1)*sizeof(void*));
95 if(!tmp)
96 return NULL;
97 heap->blocks = tmp;
100 tmp = heap_alloc(block_size(heap->block_cnt+1));
101 if(!tmp)
102 return NULL;
104 heap->blocks[heap->block_cnt++] = tmp;
106 heap->last_block++;
107 heap->offset = size;
108 return heap->blocks[heap->last_block];
111 list = heap_alloc(size + sizeof(struct list));
112 if(!list)
113 return NULL;
115 list_add_head(&heap->custom_blocks, list);
116 return list+1;
119 void *jsheap_grow(jsheap_t *heap, void *mem, DWORD size, DWORD inc)
121 if(mem == (BYTE*)heap->blocks[heap->last_block] + heap->offset-size
122 && heap->offset+inc < block_size(heap->last_block)) {
123 heap->offset += inc;
124 return mem;
127 return jsheap_alloc(heap, size+inc);
130 void jsheap_clear(jsheap_t *heap)
132 struct list *tmp;
134 if(!heap)
135 return;
137 while((tmp = list_next(&heap->custom_blocks, &heap->custom_blocks))) {
138 list_remove(tmp);
139 heap_free(tmp);
142 heap->last_block = heap->offset = 0;
145 void jsheap_free(jsheap_t *heap)
147 DWORD i;
149 jsheap_clear(heap);
151 for(i=0; i < heap->block_cnt; i++)
152 heap_free(heap->blocks[i]);
153 heap_free(heap->blocks);
155 jsheap_init(heap);
158 jsheap_t *jsheap_mark(jsheap_t *heap)
160 if(heap->mark)
161 return NULL;
163 heap->mark = TRUE;
164 return heap;
167 /* ECMA-262 3rd Edition 9.1 */
168 HRESULT to_primitive(script_ctx_t *ctx, VARIANT *v, jsexcept_t *ei, VARIANT *ret)
170 switch(V_VT(v)) {
171 case VT_EMPTY:
172 case VT_NULL:
173 case VT_BOOL:
174 case VT_I4:
175 case VT_R8:
176 *ret = *v;
177 break;
178 case VT_BSTR:
179 V_VT(ret) = VT_BSTR;
180 V_BSTR(ret) = SysAllocString(V_BSTR(v));
181 break;
182 case VT_DISPATCH:
183 return disp_propget(V_DISPATCH(v), DISPID_VALUE, ctx->lcid, ret, ei, NULL /*FIXME*/);
184 default:
185 FIXME("Unimplemented for vt %d\n", V_VT(v));
186 return E_NOTIMPL;
189 return S_OK;
192 /* ECMA-262 3rd Edition 9.2 */
193 HRESULT to_boolean(VARIANT *v, VARIANT_BOOL *b)
195 switch(V_VT(v)) {
196 case VT_EMPTY:
197 case VT_NULL:
198 *b = VARIANT_FALSE;
199 break;
200 case VT_I4:
201 *b = V_I4(v) ? VARIANT_TRUE : VARIANT_FALSE;
202 break;
203 case VT_R8:
204 *b = V_R8(v) ? VARIANT_TRUE : VARIANT_FALSE;
205 break;
206 case VT_BSTR:
207 *b = V_BSTR(v) && *V_BSTR(v) ? VARIANT_TRUE : VARIANT_FALSE;
208 break;
209 case VT_DISPATCH:
210 *b = V_DISPATCH(v) ? VARIANT_TRUE : VARIANT_FALSE;
211 break;
212 case VT_BOOL:
213 *b = V_BOOL(v);
214 break;
215 default:
216 FIXME("unimplemented for vt %d\n", V_VT(v));
217 return E_NOTIMPL;
220 return S_OK;
223 static int hex_to_int(WCHAR c)
225 if('0' <= c && c <= '9')
226 return c-'0';
228 if('a' <= c && c <= 'f')
229 return c-'a'+10;
231 if('A' <= c && c <= 'F')
232 return c-'A'+10;
234 return -1;
237 /* ECMA-262 3rd Edition 9.3.1 */
238 static HRESULT str_to_number(BSTR str, VARIANT *ret)
240 const WCHAR *ptr = str;
241 BOOL neg = FALSE;
242 DOUBLE d = 0.0;
244 static const WCHAR infinityW[] = {'I','n','f','i','n','i','t','y'};
246 while(isspaceW(*ptr))
247 ptr++;
249 if(*ptr == '-') {
250 neg = TRUE;
251 ptr++;
252 }else if(*ptr == '+') {
253 ptr++;
256 if(!strncmpW(ptr, infinityW, sizeof(infinityW)/sizeof(WCHAR))) {
257 ptr += sizeof(infinityW)/sizeof(WCHAR);
258 while(*ptr && isspaceW(*ptr))
259 ptr++;
261 if(*ptr)
262 num_set_nan(ret);
263 else
264 num_set_inf(ret, !neg);
265 return S_OK;
268 if(*ptr == '0' && ptr[1] == 'x') {
269 DWORD l = 0;
271 ptr += 2;
272 while((l = hex_to_int(*ptr)) != -1) {
273 d = d*16 + l;
274 ptr++;
277 num_set_val(ret, d);
278 return S_OK;
281 while(isdigitW(*ptr))
282 d = d*10 + (*ptr++ - '0');
284 if(*ptr == 'e' || *ptr == 'E') {
285 BOOL eneg = FALSE;
286 LONG l = 0;
288 ptr++;
289 if(*ptr == '-') {
290 ptr++;
291 eneg = TRUE;
292 }else if(*ptr == '+') {
293 ptr++;
296 while(isdigitW(*ptr))
297 l = l*10 + (*ptr++ - '0');
298 if(eneg)
299 l = -l;
301 d *= pow(10, l);
302 }else if(*ptr == '.') {
303 DOUBLE dec = 0.1;
305 ptr++;
306 while(isdigitW(*ptr)) {
307 d += dec * (*ptr++ - '0');
308 dec *= 0.1;
312 while(isspaceW(*ptr))
313 ptr++;
315 if(*ptr) {
316 num_set_nan(ret);
317 return S_OK;
320 if(neg)
321 d = -d;
323 num_set_val(ret, d);
324 return S_OK;
327 /* ECMA-262 3rd Edition 9.3 */
328 HRESULT to_number(script_ctx_t *ctx, VARIANT *v, jsexcept_t *ei, VARIANT *ret)
330 switch(V_VT(v)) {
331 case VT_EMPTY:
332 num_set_nan(ret);
333 break;
334 case VT_NULL:
335 V_VT(ret) = VT_I4;
336 V_I4(ret) = 0;
337 break;
338 case VT_I4:
339 case VT_R8:
340 *ret = *v;
341 break;
342 case VT_BSTR:
343 return str_to_number(V_BSTR(v), ret);
344 case VT_DISPATCH: {
345 VARIANT prim;
346 HRESULT hres;
348 hres = to_primitive(ctx, v, ei, &prim);
349 if(FAILED(hres))
350 return hres;
352 hres = to_number(ctx, &prim, ei, ret);
353 VariantClear(&prim);
354 return hres;
356 case VT_BOOL:
357 V_VT(ret) = VT_I4;
358 V_I4(ret) = V_BOOL(v) ? 1 : 0;
359 break;
360 default:
361 FIXME("unimplemented for vt %d\n", V_VT(v));
362 return E_NOTIMPL;
365 return S_OK;
368 /* ECMA-262 3rd Edition 9.4 */
369 HRESULT to_integer(script_ctx_t *ctx, VARIANT *v, jsexcept_t *ei, VARIANT *ret)
371 VARIANT num;
372 HRESULT hres;
374 hres = to_number(ctx, v, ei, &num);
375 if(FAILED(hres))
376 return hres;
378 if(V_VT(&num) == VT_I4)
379 *ret = num;
380 else
381 num_set_val(ret, V_R8(&num) >= 0.0 ? floor(V_R8(&num)) : -floor(-V_R8(&num)));
383 return S_OK;
386 /* ECMA-262 3rd Edition 9.5 */
387 HRESULT to_int32(script_ctx_t *ctx, VARIANT *v, jsexcept_t *ei, INT *ret)
389 VARIANT num;
390 HRESULT hres;
392 hres = to_number(ctx, v, ei, &num);
393 if(FAILED(hres))
394 return hres;
396 *ret = V_VT(&num) == VT_I4 ? V_I4(&num) : (INT)V_R8(&num);
397 return S_OK;
400 /* ECMA-262 3rd Edition 9.6 */
401 HRESULT to_uint32(script_ctx_t *ctx, VARIANT *v, jsexcept_t *ei, DWORD *ret)
403 VARIANT num;
404 HRESULT hres;
406 hres = to_number(ctx, v, ei, &num);
407 if(FAILED(hres))
408 return hres;
410 *ret = V_VT(&num) == VT_I4 ? V_I4(&num) : (DWORD)V_R8(&num);
411 return S_OK;
414 static BSTR int_to_bstr(INT i)
416 WCHAR buf[12], *p;
417 BOOL neg = FALSE;
419 if(!i) {
420 static const WCHAR zeroW[] = {'0',0};
421 return SysAllocString(zeroW);
424 if(i < 0) {
425 neg = TRUE;
426 i = -i;
429 p = buf + sizeof(buf)/sizeof(*buf)-1;
430 *p-- = 0;
431 while(i) {
432 *p-- = i%10 + '0';
433 i /= 10;
436 if(neg)
437 *p = '-';
438 else
439 p++;
441 return SysAllocString(p);
444 /* ECMA-262 3rd Edition 9.8 */
445 HRESULT to_string(script_ctx_t *ctx, VARIANT *v, jsexcept_t *ei, BSTR *str)
447 const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',0};
448 const WCHAR nullW[] = {'n','u','l','l',0};
449 const WCHAR trueW[] = {'t','r','u','e',0};
450 const WCHAR falseW[] = {'f','a','l','s','e',0};
452 switch(V_VT(v)) {
453 case VT_EMPTY:
454 *str = SysAllocString(undefinedW);
455 break;
456 case VT_NULL:
457 *str = SysAllocString(nullW);
458 break;
459 case VT_I4:
460 *str = int_to_bstr(V_I4(v));
461 break;
462 case VT_R8: {
463 VARIANT strv;
464 HRESULT hres;
466 V_VT(&strv) = VT_EMPTY;
467 hres = VariantChangeTypeEx(&strv, v, MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT), 0, VT_BSTR);
468 if(FAILED(hres))
469 return hres;
471 *str = V_BSTR(&strv);
472 return S_OK;
474 case VT_BSTR:
475 *str = SysAllocString(V_BSTR(v));
476 break;
477 case VT_DISPATCH: {
478 VARIANT prim;
479 HRESULT hres;
481 hres = to_primitive(ctx, v, ei, &prim);
482 if(FAILED(hres))
483 return hres;
485 hres = to_string(ctx, &prim, ei, str);
486 VariantClear(&prim);
487 return hres;
489 case VT_BOOL:
490 *str = SysAllocString(V_BOOL(v) ? trueW : falseW);
491 break;
492 default:
493 FIXME("unsupported vt %d\n", V_VT(v));
494 return E_NOTIMPL;
497 return *str ? S_OK : E_OUTOFMEMORY;
500 /* ECMA-262 3rd Edition 9.9 */
501 HRESULT to_object(exec_ctx_t *ctx, VARIANT *v, IDispatch **disp)
503 DispatchEx *dispex;
504 HRESULT hres;
506 switch(V_VT(v)) {
507 case VT_BSTR:
508 hres = create_string(ctx->parser->script, V_BSTR(v), SysStringLen(V_BSTR(v)), &dispex);
509 if(FAILED(hres))
510 return hres;
512 *disp = (IDispatch*)_IDispatchEx_(dispex);
513 break;
514 case VT_I4:
515 case VT_R8:
516 hres = create_number(ctx->parser->script, v, &dispex);
517 if(FAILED(hres))
518 return hres;
520 *disp = (IDispatch*)_IDispatchEx_(dispex);
521 break;
522 case VT_DISPATCH:
523 IDispatch_AddRef(V_DISPATCH(v));
524 *disp = V_DISPATCH(v);
525 break;
526 case VT_BOOL:
527 hres = create_bool(ctx->parser->script, V_BOOL(v), &dispex);
528 if(FAILED(hres))
529 return hres;
531 *disp = (IDispatch*)_IDispatchEx_(dispex);
532 break;
533 default:
534 FIXME("unsupported vt %d\n", V_VT(v));
535 return E_NOTIMPL;
538 return S_OK;