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 /* ECMA-262 3rd Edition    9.3 */
 221 HRESULT to_number(script_ctx_t *ctx, VARIANT *v, jsexcept_t *ei, VARIANT *ret)
 222 {
 223     switch(V_VT(v)) {
 224     case VT_NULL:
 225         V_VT(ret) = VT_I4;
 226         V_I4(ret) = 0;
 227         break;
 228     case VT_I4:
 229     case VT_R8:
 230         *ret = *v;
 231         break;
 232     case VT_BOOL:
 233         V_VT(ret) = VT_I4;
 234         V_I4(ret) = V_BOOL(v) ? 1 : 0;
 235         break;
 236     default:
 237         FIXME("unimplemented for vt %d\n", V_VT(v));
 238         return E_NOTIMPL;
 239     }
 240
 241     return S_OK;
 242 }
 243
 244 /* ECMA-262 3rd Edition    9.4 */
 245 HRESULT to_integer(script_ctx_t *ctx, VARIANT *v, jsexcept_t *ei, VARIANT *ret)
 246 {
 247     VARIANT num;
 248     HRESULT hres;
 249
 250     hres = to_number(ctx, v, ei, &num);
 251     if(FAILED(hres))
 252         return hres;
 253
 254     if(V_VT(&num) == VT_I4)
 255         *ret = *v;
 256     else
 257         num_set_val(ret, V_R8(&num) >= 0.0 ? floor(V_R8(&num)) : -floor(-V_R8(&num)));
 258
 259     return S_OK;
 260 }
 261
 262 /* ECMA-262 3rd Edition    9.5 */
 263 HRESULT to_int32(script_ctx_t *ctx, VARIANT *v, jsexcept_t *ei, INT *ret)
 264 {
 265     VARIANT num;
 266     HRESULT hres;
 267
 268     hres = to_number(ctx, v, ei, &num);
 269     if(FAILED(hres))
 270         return hres;
 271
 272     *ret = V_VT(&num) == VT_I4 ? V_I4(&num) : (INT)V_R8(&num);
 273     return S_OK;
 274 }
 275
 276 /* ECMA-262 3rd Edition    9.6 */
 277 HRESULT to_uint32(script_ctx_t *ctx, VARIANT *v, jsexcept_t *ei, DWORD *ret)
 278 {
 279     VARIANT num;
 280     HRESULT hres;
 281
 282     hres = to_number(ctx, v, ei, &num);
 283     if(FAILED(hres))
 284         return hres;
 285
 286     *ret = V_VT(&num) == VT_I4 ? V_I4(&num) : (DWORD)V_R8(&num);
 287     return S_OK;
 288 }
 289
 290 static BSTR int_to_bstr(INT i)
 291 {
 292     WCHAR buf[12], *p;
 293     BOOL neg = FALSE;
 294
 295     if(!i) {
 296         static const WCHAR zeroW[] = {'0',0};
 297         return SysAllocString(zeroW);
 298     }
 299
 300     if(i < 0) {
 301         neg = TRUE;
 302         i = -i;
 303     }
 304
 305     p = buf + sizeof(buf)/sizeof(*buf)-1;
 306     *p-- = 0;
 307     while(i) {
 308         *p-- = i%10 + '0';
 309         i /= 10;
 310     }
 311
 312     if(neg)
 313         *p = '-';
 314     else
 315         p++;
 316
 317     return SysAllocString(p);
 318 }
 319
 320 /* ECMA-262 3rd Edition    9.8 */
 321 HRESULT to_string(script_ctx_t *ctx, VARIANT *v, jsexcept_t *ei, BSTR *str)
 322 {
 323     const WCHAR undefinedW[] = {'u','n','d','e','f','i','n','e','d',0};
 324     const WCHAR nullW[] = {'n','u','l','l',0};
 325     const WCHAR trueW[] = {'t','r','u','e',0};
 326     const WCHAR falseW[] = {'f','a','l','s','e',0};
 327
 328     switch(V_VT(v)) {
 329     case VT_EMPTY:
 330         *str = SysAllocString(undefinedW);
 331         break;
 332     case VT_NULL:
 333         *str = SysAllocString(nullW);
 334         break;
 335     case VT_I4:
 336         *str = int_to_bstr(V_I4(v));
 337         break;
 338     case VT_BSTR:
 339         *str = SysAllocString(V_BSTR(v));
 340         break;
 341     case VT_DISPATCH: {
 342         VARIANT prim;
 343         HRESULT hres;
 344
 345         hres = to_primitive(ctx, v, ei, &prim);
 346         if(FAILED(hres))
 347             return hres;
 348
 349         hres = to_string(ctx, &prim, ei, str);
 350         VariantClear(&prim);
 351         return hres;
 352     }
 353     case VT_BOOL:
 354         *str = SysAllocString(V_BOOL(v) ? trueW : falseW);
 355         break;
 356     default:
 357         FIXME("unsupported vt %d\n", V_VT(v));
 358         return E_NOTIMPL;
 359     }
 360
 361     return *str ? S_OK : E_OUTOFMEMORY;
 362 }
 363
 364 /* ECMA-262 3rd Edition    9.9 */
 365 HRESULT to_object(exec_ctx_t *ctx, VARIANT *v, IDispatch **disp)
 366 {
 367     DispatchEx *dispex;
 368     HRESULT hres;
 369
 370     switch(V_VT(v)) {
 371     case VT_BSTR:
 372         hres = create_string(ctx->parser->script, V_BSTR(v), SysStringLen(V_BSTR(v)), &dispex);
 373         if(FAILED(hres))
 374             return hres;
 375
 376         *disp = (IDispatch*)_IDispatchEx_(dispex);
 377         break;
 378     case VT_I4:
 379     case VT_R8:
 380         hres = create_number(ctx->parser->script, v, &dispex);
 381         if(FAILED(hres))
 382             return hres;
 383
 384         *disp = (IDispatch*)_IDispatchEx_(dispex);
 385         break;
 386     case VT_DISPATCH:
 387         IDispatch_AddRef(V_DISPATCH(v));
 388         *disp = V_DISPATCH(v);
 389         break;
 390     case VT_BOOL:
 391         hres = create_bool(ctx->parser->script, V_BOOL(v), &dispex);
 392         if(FAILED(hres))
 393             return hres;
 394
 395         *disp = (IDispatch*)_IDispatchEx_(dispex);
 396         break;
 397     default:
 398         FIXME("unsupported vt %d\n", V_VT(v));
 399         return E_NOTIMPL;
 400     }
 401
 402     return S_OK;
 403 }