git.oblomov.eu Git - wine/blob - 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 <math.h>
  20
  21 #include "jscript.h"
  22 #include "engine.h"
  23
  24 #include "wine/debug.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
  27
  28 const char *debugstr_variant(const VARIANT *v)
  29 {
  30     switch(V_VT(v)) {
  31     case VT_EMPTY:
  32         return wine_dbg_sprintf("{VT_EMPTY}");
  33     case VT_NULL:
  34         return wine_dbg_sprintf("{VT_NULL}");
  35     case VT_I4:
  36         return wine_dbg_sprintf("{VT_I4: %d}", V_I4(v));
  37     case VT_R8:
  38         return wine_dbg_sprintf("{VT_R8: %lf}", V_R8(v));
  39     case VT_BSTR:
  40         return wine_dbg_sprintf("{VT_BSTR: %s}", debugstr_w(V_BSTR(v)));
  41     case VT_DISPATCH:
  42         return wine_dbg_sprintf("{VT_DISPATCH: %p}", V_DISPATCH(v));
  43     case VT_BOOL:
  44         return wine_dbg_sprintf("{VT_BOOL: %x}", V_BOOL(v));
  45     default:
  46         return wine_dbg_sprintf("{vt %d}", V_VT(v));
  47     }
  48 }
  49
  50 #define MIN_BLOCK_SIZE  128
  51
  52 static inline DWORD block_size(DWORD block)
  53 {
  54     return MIN_BLOCK_SIZE << block;
  55 }
  56
  57 void jsheap_init(jsheap_t *heap)
  58 {
  59     memset(heap, 0, sizeof(*heap));
  60     list_init(&heap->custom_blocks);
  61 }
  62
  63 void *jsheap_alloc(jsheap_t *heap, DWORD size)
  64 {
  65     struct list *list;
  66     void *tmp;
  67
  68     if(!heap->block_cnt) {
  69         if(!heap->blocks) {
  70             heap->blocks = heap_alloc(sizeof(void*));
  71             if(!heap->blocks)
  72                 return NULL;
  73         }
  74
  75         tmp = heap_alloc(block_size(0));
  76         if(!tmp)
  77             return NULL;
  78
  79         heap->blocks[0] = tmp;
  80         heap->block_cnt = 1;
  81     }
  82
  83     if(heap->offset + size < block_size(heap->last_block)) {
  84         tmp = ((BYTE*)heap->blocks[heap->last_block])+heap->offset;
  85         heap->offset += size;
  86         return tmp;
  87     }
  88
  89     if(size < block_size(heap->last_block+1)) {
  90         if(heap->last_block+1 == heap->block_cnt) {
  91             tmp = heap_realloc(heap->blocks, (heap->block_cnt+1)*sizeof(void*));
  92             if(!tmp)
  93                 return NULL;
  94             heap->blocks = tmp;
  95         }
  96
  97         tmp = heap_alloc(block_size(heap->block_cnt+1));
  98         if(!tmp)
  99             return NULL;
 100
 101         heap->blocks[heap->block_cnt++] = tmp;
 102
 103         heap->last_block++;
 104         heap->offset = size;
 105         return heap->blocks[heap->last_block];
 106     }
 107
 108     list = heap_alloc(size + sizeof(struct list));
 109     if(!list)
 110         return NULL;
 111
 112     list_add_head(&heap->custom_blocks, list);
 113     return list+1;
 114 }
 115
 116 void *jsheap_grow(jsheap_t *heap, void *mem, DWORD size, DWORD inc)
 117 {
 118     if(mem == (BYTE*)heap->blocks[heap->last_block] + heap->offset-size
 119        && heap->offset+inc < block_size(heap->last_block)) {
 120         heap->offset += inc;
 121         return mem;
 122     }
 123
 124     return jsheap_alloc(heap, size+inc);
 125 }
 126
 127 void jsheap_clear(jsheap_t *heap)
 128 {
 129     struct list *tmp;
 130
 131     if(!heap)
 132         return;
 133
 134     while((tmp = list_next(&heap->custom_blocks, &heap->custom_blocks))) {
 135         list_remove(tmp);
 136         heap_free(tmp);
 137     }
 138
 139     heap->last_block = heap->offset = 0;
 140 }
 141
 142 void jsheap_free(jsheap_t *heap)
 143 {
 144     DWORD i;
 145
 146     jsheap_clear(heap);
 147
 148     for(i=0; i < heap->block_cnt; i++)
 149         heap_free(heap->blocks[i]);
 150     heap_free(heap->blocks);
 151
 152     jsheap_init(heap);
 153 }
 154
 155 jsheap_t *jsheap_mark(jsheap_t *heap)
 156 {
 157     if(heap->mark)
 158         return NULL;
 159
 160     heap->mark = TRUE;
 161     return heap;
 162 }
 163
 164 /* ECMA-262 3rd Edition    9.1 */
 165 HRESULT to_primitive(script_ctx_t *ctx, VARIANT *v, jsexcept_t *ei, VARIANT *ret)
 166 {
 167     switch(V_VT(v)) {
 168     case VT_EMPTY:
 169     case VT_NULL:
 170     case VT_BOOL:
 171     case VT_I4:
 172     case VT_R8:
 173         *ret = *v;
 174         break;
 175     case VT_BSTR:
 176         V_VT(ret) = VT_BSTR;
 177         V_BSTR(ret) = SysAllocString(V_BSTR(v));
 178         break;
 179     case VT_DISPATCH:
 180         return disp_propget(V_DISPATCH(v), DISPID_VALUE, ctx->lcid, ret, ei, NULL /*FIXME*/);
 181     default:
 182         FIXME("Unimplemented for vt %d\n", V_VT(v));
 183         return E_NOTIMPL;
 184     }
 185
 186     return S_OK;
 187 }
 188
 189 /* ECMA-262 3rd Edition    9.2 */
 190 HRESULT to_boolean(VARIANT *v, VARIANT_BOOL *b)
 191 {
 192     switch(V_VT(v)) {
 193     case VT_EMPTY:
 194     case VT_NULL:
 195         *b = VARIANT_FALSE;
 196         break;
 197     case VT_I4:
 198         *b = V_I4(v) ? VARIANT_TRUE : VARIANT_FALSE;
 199         break;
 200     case VT_R8:
 201         *b = V_R8(v) ? VARIANT_TRUE : VARIANT_FALSE;
 202         break;
 203     case VT_BSTR:
 204         *b = V_BSTR(v) && *V_BSTR(v) ? VARIANT_TRUE : VARIANT_FALSE;
 205         break;
 206     case VT_DISPATCH:
 207         *b = V_DISPATCH(v) ? VARIANT_TRUE : VARIANT_FALSE;
 208         break;
 209     case VT_BOOL:
 210         *b = V_BOOL(v);
 211         break;
 212     default:
 213         FIXME("unimplemented for vt %d\n", V_VT(v));
 214         return E_NOTIMPL;
 215     }
 216
 217     return S_OK;
 218 }
 219
 220 static int hex_to_int(WCHAR c)
 221 {
 222     if('0' <= c && c <= '9')
 223         return c-'0';
 224
 225     if('a' <= c && c <= 'f')
 226         return c-'a'+10;
 227
 228     if('A' <= c && c <= 'F')
 229         return c-'A'+10;
 230
 231     return -1;
 232 }
 233
 234 /* ECMA-262 3rd Edition    9.3.1 */
 235 static HRESULT str_to_number(BSTR str, VARIANT *ret)
 236 {
 237     const WCHAR *ptr = str;
 238     BOOL neg = FALSE;
 239     DOUBLE d = 0.0;
 240
 241     static const WCHAR infinityW[] = {'I','n','f','i','n','i','t','y'};
 242
 243     while(isspaceW(*ptr))
 244         ptr++;
 245
 246     if(!strncmpW(ptr, infinityW, sizeof(infinityW)/sizeof(WCHAR))) {
 247         ptr += sizeof(infinityW)/sizeof(WCHAR);
 248         while(*ptr && isspaceW(*ptr))
 249             ptr++;
 250
 251         if(*ptr) {
 252             FIXME("NaN\n");
 253             return E_NOTIMPL;
 254         }
 255
 256         FIXME("inf\n");
 257         return E_NOTIMPL;
 258     }
 259
 260     if(*ptr == '-') {
 261         neg = TRUE;
 262         ptr++;
 263     }else if(*ptr == '+') {
 264         ptr++;
 265     }else if(*ptr == '0' && ptr[1] == 'x') {
 266         DWORD l = 0;
 267
 268         ptr += 2;
 269         while((l = hex_to_int(*ptr)) != -1) {
 270             d = d*16 + l;
 271             ptr++;
 272         }
 273
 274         num_set_val(ret, d);
 275         return S_OK;
 276     }
 277
 278     while(isdigitW(*ptr))
 279         d = d*10 + (*ptr++ - '0');
 280
 281     if(*ptr == 'e' || *ptr == 'E') {
 282         BOOL eneg = FALSE;
 283         LONG l = 0;
 284
 285         ptr++;
 286         if(*ptr == '-') {
 287             ptr++;
 288             eneg = TRUE;
 289         }else if(*ptr == '+') {
 290             ptr++;
 291         }
 292
 293         while(isdigitW(*ptr))
 294             l = l*10 + (*ptr++ - '0');
 295         if(eneg)
 296             l = -l;
 297
 298         d *= pow(10, l);
 299     }else if(*ptr == '.') {
 300         DOUBLE dec = 0.1;
 301
 302         ptr++;
 303         while(isdigitW(*ptr)) {
 304             d += dec * (*ptr++ - '0');
 305             dec *= 0.1;
 306         }
 307     }
 308
 309     while(isspaceW(*ptr))
 310         ptr++;
 311
 312     if(*ptr) {
 313         FIXME("NaN\n");
 314         return E_NOTIMPL;
 315     }
 316
 317     if(neg)
 318         d = -d;
 319
 320     num_set_val(ret, d);
 321     return S_OK;
 322 }
 323
 324 /* ECMA-262 3rd Edition    9.3 */
 325 HRESULT to_number(script_ctx_t *ctx, VARIANT *v, jsexcept_t *ei, VARIANT *ret)
 326 {
 327     switch(V_VT(v)) {
 328     case VT_NULL:
 329         V_VT(ret) = VT_I4;
 330         V_I4(ret) = 0;
 331         break;
 332     case VT_I4:
 333     case VT_R8:
 334         *ret = *v;
 335         break;
 336     case VT_BSTR:
 337         return str_to_number(V_BSTR(v), ret);
 338     case VT_DISPATCH: {
 339         VARIANT prim;
 340         HRESULT hres;
 341
 342         hres = to_primitive(ctx, v, ei, &prim);
 343         if(FAILED(hres))
 344             return hres;
 345
 346         hres = to_number(ctx, &prim, ei, ret);
 347         VariantClear(&prim);
 348         return hres;
 349     }
 350     case VT_BOOL:
 351         V_VT(ret) = VT_I4;
 352         V_I4(ret) = V_BOOL(v) ? 1 : 0;
 353         break;
 354     default:
 355         FIXME("unimplemented for vt %d\n", V_VT(v));
 356         return E_NOTIMPL;
 357     }
 358
 359     return S_OK;
 360 }
 361
 362 /* ECMA-262 3rd Edition    9.4 */
 363 HRESULT to_integer(script_ctx_t *ctx, VARIANT *v, jsexcept_t *ei, VARIANT *ret)
 364 {
 365     VARIANT num;
 366     HRESULT hres;
 367
 368     hres = to_number(ctx, v, ei, &num);
 369     if(FAILED(hres))
 370         return hres;
 371
 372     if(V_VT(&num) == VT_I4)
 373         *ret = num;
 374     else
 375         num_set_val(ret, V_R8(&num) >= 0.0 ? floor(V_R8(&num)) : -floor(-V_R8(&num)));
 376
 377     return S_OK;
 378 }
 379
 380 /* ECMA-262 3rd Edition    9.5 */
 381 HRESULT to_int32(script_ctx_t *ctx, VARIANT *v, jsexcept_t *ei, INT *ret)
 382 {
 383     VARIANT num;
 384     HRESULT hres;
 385
 386     hres = to_number(ctx, v, ei, &num);
 387     if(FAILED(hres))
 388         return hres;
 389
 390     *ret = V_VT(&num) == VT_I4 ? V_I4(&num) : (INT)V_R8(&num);
 391     return S_OK;
 392 }
 393
 394 /* ECMA-262 3rd Edition    9.6 */
 395 HRESULT to_uint32(script_ctx_t *ctx, VARIANT *v, jsexcept_t *ei, DWORD *ret)
 396 {
 397     VARIANT num;
 398     HRESULT hres;
 399
 400     hres = to_number(ctx, v, ei, &num);
 401     if(FAILED(hres))
 402         return hres;
 403
 404     *ret = V_VT(&num) == VT_I4 ? V_I4(&num) : (DWORD)V_R8(&num);
 405     return S_OK;
 406 }
 407
 408 static BSTR int_to_bstr(INT i)
 409 {
 410     WCHAR buf[12], *p;
 411     BOOL neg = FALSE;
 412
 413     if(!i) {
 414         static const WCHAR zeroW[] = {'0',0};
 415         return SysAllocString(zeroW);
 416     }
 417
 418     if(i < 0) {
 419         neg = TRUE;
 420         i = -i;
 421     }
 422
 423     p = buf + sizeof(buf)/sizeof(*buf)-1;
 424     *p-- = 0;
 425     while(i) {
 426         *p-- = i%10 + '0';
 427         i /= 10;
 428     }
 429
 430     if(neg)
 431         *p = '-';
 432     else
 433         p++;
 434
 435     return SysAllocString(p);
 436 }
 437
 438 /* ECMA-262 3rd Edition    9.8 */
 439 HRESULT to_string(script_ctx_t *ctx, VARIANT *v, jsexcept_t *ei, BSTR *str)
 440 {
 441     const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',0};
 442     const WCHAR nullW[] = {'n','u','l','l',0};
 443     const WCHAR trueW[] = {'t','r','u','e',0};
 444     const WCHAR falseW[] = {'f','a','l','s','e',0};
 445
 446     switch(V_VT(v)) {
 447     case VT_EMPTY:
 448         *str = SysAllocString(undefinedW);
 449         break;
 450     case VT_NULL:
 451         *str = SysAllocString(nullW);
 452         break;
 453     case VT_I4:
 454         *str = int_to_bstr(V_I4(v));
 455         break;
 456     case VT_R8: {
 457         VARIANT strv;
 458         HRESULT hres;
 459
 460         V_VT(&strv) = VT_EMPTY;
 461         hres = VariantChangeType(&strv, v, 0, VT_BSTR);
 462         if(FAILED(hres))
 463             return hres;
 464
 465         *str = V_BSTR(&strv);
 466         return S_OK;
 467     }
 468     case VT_BSTR:
 469         *str = SysAllocString(V_BSTR(v));
 470         break;
 471     case VT_DISPATCH: {
 472         VARIANT prim;
 473         HRESULT hres;
 474
 475         hres = to_primitive(ctx, v, ei, &prim);
 476         if(FAILED(hres))
 477             return hres;
 478
 479         hres = to_string(ctx, &prim, ei, str);
 480         VariantClear(&prim);
 481         return hres;
 482     }
 483     case VT_BOOL:
 484         *str = SysAllocString(V_BOOL(v) ? trueW : falseW);
 485         break;
 486     default:
 487         FIXME("unsupported vt %d\n", V_VT(v));
 488         return E_NOTIMPL;
 489     }
 490
 491     return *str ? S_OK : E_OUTOFMEMORY;
 492 }
 493
 494 /* ECMA-262 3rd Edition    9.9 */
 495 HRESULT to_object(exec_ctx_t *ctx, VARIANT *v, IDispatch **disp)
 496 {
 497     DispatchEx *dispex;
 498     HRESULT hres;
 499
 500     switch(V_VT(v)) {
 501     case VT_BSTR:
 502         hres = create_string(ctx->parser->script, V_BSTR(v), SysStringLen(V_BSTR(v)), &dispex);
 503         if(FAILED(hres))
 504             return hres;
 505
 506         *disp = (IDispatch*)_IDispatchEx_(dispex);
 507         break;
 508     case VT_I4:
 509     case VT_R8:
 510         hres = create_number(ctx->parser->script, v, &dispex);
 511         if(FAILED(hres))
 512             return hres;
 513
 514         *disp = (IDispatch*)_IDispatchEx_(dispex);
 515         break;
 516     case VT_DISPATCH:
 517         IDispatch_AddRef(V_DISPATCH(v));
 518         *disp = V_DISPATCH(v);
 519         break;
 520     case VT_BOOL:
 521         hres = create_bool(ctx->parser->script, V_BOOL(v), &dispex);
 522         if(FAILED(hres))
 523             return hres;
 524
 525         *disp = (IDispatch*)_IDispatchEx_(dispex);
 526         break;
 527     default:
 528         FIXME("unsupported vt %d\n", V_VT(v));
 529         return E_NOTIMPL;
 530     }
 531
 532     return S_OK;
 533 }