git.oblomov.eu Git - wine/blob - dlls/jscript/number.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 #include <assert.h>
  24
  25 #include "jscript.h"
  26
  27 #include "wine/debug.h"
  28
  29 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
  30
  31 typedef struct {
  32     jsdisp_t dispex;
  33
  34     double value;
  35 } NumberInstance;
  36
  37 static const WCHAR toStringW[] = {'t','o','S','t','r','i','n','g',0};
  38 static const WCHAR toLocaleStringW[] = {'t','o','L','o','c','a','l','e','S','t','r','i','n','g',0};
  39 static const WCHAR toFixedW[] = {'t','o','F','i','x','e','d',0};
  40 static const WCHAR toExponentialW[] = {'t','o','E','x','p','o','n','e','n','t','i','a','l',0};
  41 static const WCHAR toPrecisionW[] = {'t','o','P','r','e','c','i','s','i','o','n',0};
  42 static const WCHAR valueOfW[] = {'v','a','l','u','e','O','f',0};
  43
  44 #define NUMBER_TOSTRING_BUF_SIZE 64
  45 #define NUMBER_DTOA_SIZE 18
  46
  47 static inline NumberInstance *number_from_vdisp(vdisp_t *vdisp)
  48 {
  49     return (NumberInstance*)vdisp->u.jsdisp;
  50 }
  51
  52 static inline NumberInstance *number_this(vdisp_t *jsthis)
  53 {
  54     return is_vclass(jsthis, JSCLASS_NUMBER) ? number_from_vdisp(jsthis) : NULL;
  55 }
  56
  57 static inline void dtoa(double d, WCHAR *buf, int size, int *dec_point)
  58 {
  59     ULONGLONG l;
  60     int i;
  61
  62     /* TODO: this function should print doubles with bigger precision */
  63     assert(size>=2 && size<=NUMBER_DTOA_SIZE && d>=0);
  64
  65     if(d == 0)
  66         *dec_point = 0;
  67     else
  68         *dec_point = floor(log10(d));
  69     l = d*pow(10, size-*dec_point-1);
  70
  71     if(l%10 >= 5)
  72         l = l/10+1;
  73     else
  74         l /= 10;
  75
  76     buf[size-1] = 0;
  77     for(i=size-2; i>=0; i--) {
  78         buf[i] = '0'+l%10;
  79         l /= 10;
  80     }
  81
  82     /* log10 was wrong by 1 or rounding changed number of digits */
  83     if(l) {
  84         (*dec_point)++;
  85         memmove(buf+1, buf, size-2);
  86         buf[0] = '0'+l;
  87     }else if(buf[0]=='0' && buf[1]>='1' && buf[1]<='9') {
  88         (*dec_point)--;
  89         memmove(buf, buf+1, size-2);
  90         buf[size-2] = '0';
  91     }
  92 }
  93
  94 static inline void number_to_fixed(double val, int prec, BSTR *out)
  95 {
  96     WCHAR buf[NUMBER_DTOA_SIZE];
  97     int dec_point, size, buf_size, buf_pos;
  98     BOOL neg = FALSE;
  99     BSTR str;
 100
 101     if(val < 0) {
 102         neg = TRUE;
 103         val = -val;
 104     }
 105
 106     if(val<=-1 || val>=1)
 107         buf_size = log10(val)+prec+2;
 108     else
 109         buf_size = prec+1;
 110     if(buf_size > NUMBER_DTOA_SIZE)
 111         buf_size = NUMBER_DTOA_SIZE;
 112
 113     dtoa(val, buf, buf_size, &dec_point);
 114     dec_point++;
 115     size = 0;
 116     if(neg)
 117         size++;
 118     if(dec_point > 0)
 119         size += dec_point;
 120     else
 121         size++;
 122     if(prec)
 123         size += prec+1;
 124
 125     str = SysAllocStringLen(NULL, size);
 126     size = buf_pos = 0;
 127     if(neg)
 128         str[size++] = '-';
 129     if(dec_point > 0) {
 130         for(;buf_pos<buf_size-1 && dec_point; dec_point--)
 131             str[size++] = buf[buf_pos++];
 132     }else {
 133         str[size++] = '0';
 134     }
 135     for(; dec_point>0; dec_point--)
 136         str[size++] = '0';
 137     if(prec) {
 138         str[size++] = '.';
 139
 140         for(; dec_point<0 && prec; dec_point++, prec--)
 141             str[size++] = '0';
 142         for(; buf_pos<buf_size-1 && prec; prec--)
 143             str[size++] = buf[buf_pos++];
 144         for(; prec; prec--) {
 145             str[size++] = '0';
 146         }
 147     }
 148     str[size++] = 0;
 149
 150     *out = str;
 151 }
 152
 153 static inline void number_to_exponential(double val, int prec, BSTR *out)
 154 {
 155     WCHAR buf[NUMBER_DTOA_SIZE], *pbuf;
 156     int dec_point, size, buf_size, exp_size = 1;
 157     BOOL neg = FALSE;
 158     BSTR str;
 159
 160     if(val < 0) {
 161         neg = TRUE;
 162         val = -val;
 163     }
 164
 165     buf_size = prec+2;
 166     if(buf_size<2 || buf_size>NUMBER_DTOA_SIZE)
 167         buf_size = NUMBER_DTOA_SIZE;
 168     dtoa(val, buf, buf_size, &dec_point);
 169     buf_size--;
 170     if(prec == -1)
 171         for(; buf_size>1 && buf[buf_size-1]=='0'; buf_size--)
 172             buf[buf_size-1] = 0;
 173
 174     size = 10;
 175     while(dec_point>=size || dec_point<=-size) {
 176         size *= 10;
 177         exp_size++;
 178     }
 179
 180     if(buf_size == 1)
 181         size = buf_size+2+exp_size; /* 2 = strlen(e+) */
 182     else if(prec == -1)
 183         size = buf_size+3+exp_size; /* 3 = strlen(.e+) */
 184     else
 185         size = prec+4+exp_size; /* 4 = strlen(0.e+) */
 186     if(neg)
 187         size++;
 188     str = SysAllocStringLen(NULL, size);
 189
 190     size = 0;
 191     pbuf = buf;
 192     if(neg)
 193         str[size++] = '-';
 194     str[size++] = *pbuf++;
 195     if(buf_size != 1) {
 196         str[size++] = '.';
 197         while(*pbuf)
 198             str[size++] = *pbuf++;
 199         for(; prec>buf_size-1; prec--)
 200             str[size++] = '0';
 201     }
 202     str[size++] = 'e';
 203     if(dec_point >= 0) {
 204         str[size++] = '+';
 205     }else {
 206         str[size++] = '-';
 207         dec_point = -dec_point;
 208     }
 209     for(str[size]='0', size+=exp_size-1; dec_point>0; dec_point/=10)
 210         str[size--] = '0'+dec_point%10;
 211     size += exp_size+1;
 212     str[size] = 0;
 213
 214     *out = str;
 215 }
 216
 217 /* ECMA-262 3rd Edition    15.7.4.2 */
 218 static HRESULT Number_toString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
 219         VARIANT *retv, jsexcept_t *ei)
 220 {
 221     NumberInstance *number;
 222     INT radix = 10;
 223     DOUBLE val;
 224     BSTR str;
 225     HRESULT hres;
 226
 227     TRACE("\n");
 228
 229     if(!(number = number_this(jsthis)))
 230         return throw_type_error(ctx, ei, JS_E_NUMBER_EXPECTED, NULL);
 231
 232     if(arg_cnt(dp)) {
 233         hres = to_int32(ctx, get_arg(dp, 0), ei, &radix);
 234         if(FAILED(hres))
 235             return hres;
 236
 237         if(radix<2 || radix>36)
 238             return throw_type_error(ctx, ei, JS_E_INVALIDARG, NULL);
 239     }
 240
 241     val = number->value;
 242
 243     if(radix==10 || isnan(val) || isinf(val)) {
 244         VARIANT v;
 245
 246         num_set_val(&v, val);
 247         hres = to_string(ctx, &v, ei, &str);
 248         if(FAILED(hres))
 249             return hres;
 250     }else {
 251         INT idx = 0;
 252         DOUBLE integ, frac, log_radix = 0;
 253         WCHAR buf[NUMBER_TOSTRING_BUF_SIZE+16];
 254         BOOL exp = FALSE;
 255
 256         if(val<0) {
 257             val = -val;
 258             buf[idx++] = '-';
 259         }
 260
 261         while(1) {
 262             integ = floor(val);
 263             frac = val-integ;
 264
 265             if(integ == 0)
 266                 buf[idx++] = '0';
 267             while(integ>=1 && idx<NUMBER_TOSTRING_BUF_SIZE) {
 268                 buf[idx] = fmod(integ, radix);
 269                 if(buf[idx]<10) buf[idx] += '0';
 270                 else buf[idx] += 'a'-10;
 271                 integ /= radix;
 272                 idx++;
 273             }
 274
 275             if(idx<NUMBER_TOSTRING_BUF_SIZE) {
 276                 INT beg = buf[0]=='-'?1:0;
 277                 INT end = idx-1;
 278                 WCHAR wch;
 279
 280                 while(end > beg) {
 281                     wch = buf[beg];
 282                     buf[beg++] = buf[end];
 283                     buf[end--] = wch;
 284                 }
 285             }
 286
 287             if(idx != NUMBER_TOSTRING_BUF_SIZE) buf[idx++] = '.';
 288
 289             while(frac>0 && idx<NUMBER_TOSTRING_BUF_SIZE) {
 290                 frac *= radix;
 291                 buf[idx] = fmod(frac, radix);
 292                 frac -= buf[idx];
 293                 if(buf[idx]<10) buf[idx] += '0';
 294                 else buf[idx] += 'a'-10;
 295                 idx++;
 296             }
 297
 298             if(idx==NUMBER_TOSTRING_BUF_SIZE && !exp) {
 299                 exp = TRUE;
 300                 idx = (buf[0]=='-') ? 1 : 0;
 301                 log_radix = floor(log(val)/log(radix));
 302                 val *= pow(radix, -log_radix);
 303                 continue;
 304             }
 305
 306             break;
 307         }
 308
 309         while(buf[idx-1] == '0') idx--;
 310         if(buf[idx-1] == '.') idx--;
 311
 312         if(exp) {
 313             if(log_radix==0)
 314                 buf[idx] = 0;
 315             else {
 316                 static const WCHAR formatW[] = {'(','e','%','c','%','d',')',0};
 317                 WCHAR ch;
 318
 319                 if(log_radix<0) {
 320                     log_radix = -log_radix;
 321                     ch = '-';
 322                 }
 323                 else ch = '+';
 324                 sprintfW(&buf[idx], formatW, ch, (int)log_radix);
 325             }
 326         }
 327         else buf[idx] = '\0';
 328
 329         str = SysAllocString(buf);
 330         if(!str)
 331             return E_OUTOFMEMORY;
 332     }
 333
 334     if(retv) {
 335         V_VT(retv) = VT_BSTR;
 336         V_BSTR(retv) = str;
 337     }else {
 338         SysFreeString(str);
 339     }
 340     return S_OK;
 341 }
 342
 343 static HRESULT Number_toLocaleString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
 344         VARIANT *retv, jsexcept_t *ei)
 345 {
 346     FIXME("\n");
 347     return E_NOTIMPL;
 348 }
 349
 350 static HRESULT Number_toFixed(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
 351         VARIANT *retv, jsexcept_t *ei)
 352 {
 353     NumberInstance *number;
 354     DOUBLE val;
 355     INT prec = 0;
 356     BSTR str;
 357     HRESULT hres;
 358
 359     TRACE("\n");
 360
 361     if(!(number = number_this(jsthis)))
 362         return throw_type_error(ctx, ei, JS_E_NUMBER_EXPECTED, NULL);
 363
 364     if(arg_cnt(dp)) {
 365         hres = to_int32(ctx, get_arg(dp, 0), ei, &prec);
 366         if(FAILED(hres))
 367             return hres;
 368
 369         if(prec<0 || prec>20)
 370             return throw_range_error(ctx, ei, JS_E_FRACTION_DIGITS_OUT_OF_RANGE, NULL);
 371     }
 372
 373     val = number->value;
 374     if(isinf(val) || isnan(val)) {
 375         VARIANT v;
 376
 377         num_set_val(&v, val);
 378         hres = to_string(ctx, &v, ei, &str);
 379         if(FAILED(hres))
 380             return hres;
 381     }else {
 382         number_to_fixed(val, prec, &str);
 383     }
 384
 385     if(retv) {
 386         V_VT(retv) = VT_BSTR;
 387         V_BSTR(retv) = str;
 388     }else {
 389         SysFreeString(str);
 390     }
 391     return S_OK;
 392 }
 393
 394 static HRESULT Number_toExponential(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
 395         VARIANT *retv, jsexcept_t *ei)
 396 {
 397     NumberInstance *number;
 398     DOUBLE val;
 399     INT prec = 0;
 400     BSTR str;
 401     HRESULT hres;
 402
 403     TRACE("\n");
 404
 405     if(!(number = number_this(jsthis)))
 406         return throw_type_error(ctx, ei, JS_E_NUMBER_EXPECTED, NULL);
 407
 408     if(arg_cnt(dp)) {
 409         hres = to_int32(ctx, get_arg(dp, 0), ei, &prec);
 410         if(FAILED(hres))
 411             return hres;
 412
 413         if(prec<0 || prec>20)
 414             return throw_range_error(ctx, ei, JS_E_FRACTION_DIGITS_OUT_OF_RANGE, NULL);
 415     }
 416
 417     val = number->value;
 418     if(isinf(val) || isnan(val)) {
 419         VARIANT v;
 420
 421         num_set_val(&v, val);
 422         hres = to_string(ctx, &v, ei, &str);
 423         if(FAILED(hres))
 424             return hres;
 425     }else {
 426         if(!prec)
 427             prec--;
 428         number_to_exponential(val, prec, &str);
 429     }
 430
 431     if(retv) {
 432         V_VT(retv) = VT_BSTR;
 433         V_BSTR(retv) = str;
 434     }else {
 435         SysFreeString(str);
 436     }
 437     return S_OK;
 438 }
 439
 440 static HRESULT Number_toPrecision(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
 441         VARIANT *retv, jsexcept_t *ei)
 442 {
 443     NumberInstance *number;
 444     INT prec = 0, size;
 445     DOUBLE val;
 446     BSTR str;
 447     HRESULT hres;
 448
 449     if(!(number = number_this(jsthis)))
 450         return throw_type_error(ctx, ei, JS_E_NUMBER_EXPECTED, NULL);
 451
 452     if(arg_cnt(dp)) {
 453         hres = to_int32(ctx, get_arg(dp, 0), ei, &prec);
 454         if(FAILED(hres))
 455             return hres;
 456
 457         if(prec<1 || prec>21)
 458             return throw_range_error(ctx, ei, JS_E_PRECISION_OUT_OF_RANGE, NULL);
 459     }
 460
 461     val = number->value;
 462     if(isinf(val) || isnan(val) || !prec) {
 463         VARIANT v;
 464
 465         num_set_val(&v, val);
 466         hres = to_string(ctx, &v, ei, &str);
 467         if(FAILED(hres))
 468             return hres;
 469     }else {
 470         if(val != 0)
 471             size = floor(log10(val>0 ? val : -val)) + 1;
 472         else
 473             size = 1;
 474
 475         if(size > prec)
 476             number_to_exponential(val, prec-1, &str);
 477         else
 478             number_to_fixed(val, prec-size, &str);
 479     }
 480
 481     if(retv) {
 482         V_VT(retv) = VT_BSTR;
 483         V_BSTR(retv) = str;
 484     }else {
 485         SysFreeString(str);
 486     }
 487     return S_OK;
 488 }
 489
 490 static HRESULT Number_valueOf(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
 491         VARIANT *retv, jsexcept_t *ei)
 492 {
 493     NumberInstance *number;
 494
 495     TRACE("\n");
 496
 497     if(!(number = number_this(jsthis)))
 498         return throw_type_error(ctx, ei, JS_E_NUMBER_EXPECTED, NULL);
 499
 500     if(retv)
 501         num_set_val(retv, number->value);
 502     return S_OK;
 503 }
 504
 505 static HRESULT Number_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
 506         VARIANT *retv, jsexcept_t *ei)
 507 {
 508     NumberInstance *number = number_from_vdisp(jsthis);
 509
 510     switch(flags) {
 511     case INVOKE_FUNC:
 512         return throw_type_error(ctx, ei, JS_E_FUNCTION_EXPECTED, NULL);
 513     case DISPATCH_PROPERTYGET:
 514         num_set_val(retv, number->value);
 515         break;
 516
 517     default:
 518         FIXME("flags %x\n", flags);
 519         return E_NOTIMPL;
 520     }
 521
 522     return S_OK;
 523 }
 524
 525 static const builtin_prop_t Number_props[] = {
 526     {toExponentialW,         Number_toExponential,         PROPF_METHOD|1},
 527     {toFixedW,               Number_toFixed,               PROPF_METHOD},
 528     {toLocaleStringW,        Number_toLocaleString,        PROPF_METHOD},
 529     {toPrecisionW,           Number_toPrecision,           PROPF_METHOD|1},
 530     {toStringW,              Number_toString,              PROPF_METHOD|1},
 531     {valueOfW,               Number_valueOf,               PROPF_METHOD}
 532 };
 533
 534 static const builtin_info_t Number_info = {
 535     JSCLASS_NUMBER,
 536     {NULL, Number_value, 0},
 537     sizeof(Number_props)/sizeof(*Number_props),
 538     Number_props,
 539     NULL,
 540     NULL
 541 };
 542
 543 static HRESULT NumberConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
 544         VARIANT *retv, jsexcept_t *ei)
 545 {
 546     double n;
 547     HRESULT hres;
 548
 549     TRACE("\n");
 550
 551     switch(flags) {
 552     case INVOKE_FUNC:
 553         if(!arg_cnt(dp)) {
 554             if(retv) {
 555                 V_VT(retv) = VT_I4;
 556                 V_I4(retv) = 0;
 557             }
 558             return S_OK;
 559         }
 560
 561         hres = to_number(ctx, get_arg(dp, 0), ei, &n);
 562         if(FAILED(hres))
 563             return hres;
 564
 565         if(retv)
 566             num_set_val(retv, n);
 567         break;
 568
 569     case DISPATCH_CONSTRUCT: {
 570         jsdisp_t *obj;
 571
 572         if(arg_cnt(dp)) {
 573             hres = to_number(ctx, get_arg(dp, 0), ei, &n);
 574             if(FAILED(hres))
 575                 return hres;
 576         }else {
 577             n = 0;
 578         }
 579
 580         hres = create_number(ctx, n, &obj);
 581         if(FAILED(hres))
 582             return hres;
 583
 584         var_set_jsdisp(retv, obj);
 585         break;
 586     }
 587     default:
 588         FIXME("unimplemented flags %x\n", flags);
 589         return E_NOTIMPL;
 590     }
 591
 592     return S_OK;
 593 }
 594
 595 static HRESULT alloc_number(script_ctx_t *ctx, jsdisp_t *object_prototype, NumberInstance **ret)
 596 {
 597     NumberInstance *number;
 598     HRESULT hres;
 599
 600     number = heap_alloc_zero(sizeof(NumberInstance));
 601     if(!number)
 602         return E_OUTOFMEMORY;
 603
 604     if(object_prototype)
 605         hres = init_dispex(&number->dispex, ctx, &Number_info, object_prototype);
 606     else
 607         hres = init_dispex_from_constr(&number->dispex, ctx, &Number_info, ctx->number_constr);
 608     if(FAILED(hres))
 609         return hres;
 610
 611     *ret = number;
 612     return S_OK;
 613 }
 614
 615 HRESULT create_number_constr(script_ctx_t *ctx, jsdisp_t *object_prototype, jsdisp_t **ret)
 616 {
 617     NumberInstance *number;
 618     HRESULT hres;
 619
 620     static const WCHAR NumberW[] = {'N','u','m','b','e','r',0};
 621
 622     hres = alloc_number(ctx, object_prototype, &number);
 623     if(FAILED(hres))
 624         return hres;
 625
 626     number->value = 0;
 627     hres = create_builtin_function(ctx, NumberConstr_value, NumberW, NULL,
 628             PROPF_CONSTR|1, &number->dispex, ret);
 629
 630     jsdisp_release(&number->dispex);
 631     return hres;
 632 }
 633
 634 HRESULT create_number(script_ctx_t *ctx, double value, jsdisp_t **ret)
 635 {
 636     NumberInstance *number;
 637     HRESULT hres;
 638
 639     hres = alloc_number(ctx, NULL, &number);
 640     if(FAILED(hres))
 641         return hres;
 642
 643     number->value = value;
 644
 645     *ret = &number->dispex;
 646     return S_OK;
 647 }