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     size += exp_size;
 210     do {
 211         str[--size] = '0'+dec_point%10;
 212         dec_point /= 10;
 213     }while(dec_point>0);
 214     size += exp_size;
 215     str[size] = 0;
 216
 217     *out = str;
 218 }
 219
 220 /* ECMA-262 3rd Edition    15.7.4.2 */
 221 static HRESULT Number_toString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 222         jsval_t *r, jsexcept_t *ei)
 223 {
 224     NumberInstance *number;
 225     INT radix = 10;
 226     DOUBLE val;
 227     BSTR str;
 228     HRESULT hres;
 229
 230     TRACE("\n");
 231
 232     if(!(number = number_this(jsthis)))
 233         return throw_type_error(ctx, ei, JS_E_NUMBER_EXPECTED, NULL);
 234
 235     if(argc) {
 236         hres = to_int32(ctx, argv[0], ei, &radix);
 237         if(FAILED(hres))
 238             return hres;
 239
 240         if(radix<2 || radix>36)
 241             return throw_type_error(ctx, ei, JS_E_INVALIDARG, NULL);
 242     }
 243
 244     val = number->value;
 245
 246     if(radix==10 || isnan(val) || isinf(val)) {
 247         VARIANT v;
 248
 249         num_set_val(&v, val);
 250         hres = to_string(ctx, &v, ei, &str);
 251         if(FAILED(hres))
 252             return hres;
 253     }else {
 254         INT idx = 0;
 255         DOUBLE integ, frac, log_radix = 0;
 256         WCHAR buf[NUMBER_TOSTRING_BUF_SIZE+16];
 257         BOOL exp = FALSE;
 258
 259         if(val<0) {
 260             val = -val;
 261             buf[idx++] = '-';
 262         }
 263
 264         while(1) {
 265             integ = floor(val);
 266             frac = val-integ;
 267
 268             if(integ == 0)
 269                 buf[idx++] = '0';
 270             while(integ>=1 && idx<NUMBER_TOSTRING_BUF_SIZE) {
 271                 buf[idx] = fmod(integ, radix);
 272                 if(buf[idx]<10) buf[idx] += '0';
 273                 else buf[idx] += 'a'-10;
 274                 integ /= radix;
 275                 idx++;
 276             }
 277
 278             if(idx<NUMBER_TOSTRING_BUF_SIZE) {
 279                 INT beg = buf[0]=='-'?1:0;
 280                 INT end = idx-1;
 281                 WCHAR wch;
 282
 283                 while(end > beg) {
 284                     wch = buf[beg];
 285                     buf[beg++] = buf[end];
 286                     buf[end--] = wch;
 287                 }
 288             }
 289
 290             if(idx != NUMBER_TOSTRING_BUF_SIZE) buf[idx++] = '.';
 291
 292             while(frac>0 && idx<NUMBER_TOSTRING_BUF_SIZE) {
 293                 frac *= radix;
 294                 buf[idx] = fmod(frac, radix);
 295                 frac -= buf[idx];
 296                 if(buf[idx]<10) buf[idx] += '0';
 297                 else buf[idx] += 'a'-10;
 298                 idx++;
 299             }
 300
 301             if(idx==NUMBER_TOSTRING_BUF_SIZE && !exp) {
 302                 exp = TRUE;
 303                 idx = (buf[0]=='-') ? 1 : 0;
 304                 log_radix = floor(log(val)/log(radix));
 305                 val *= pow(radix, -log_radix);
 306                 continue;
 307             }
 308
 309             break;
 310         }
 311
 312         while(buf[idx-1] == '0') idx--;
 313         if(buf[idx-1] == '.') idx--;
 314
 315         if(exp) {
 316             if(log_radix==0)
 317                 buf[idx] = 0;
 318             else {
 319                 static const WCHAR formatW[] = {'(','e','%','c','%','d',')',0};
 320                 WCHAR ch;
 321
 322                 if(log_radix<0) {
 323                     log_radix = -log_radix;
 324                     ch = '-';
 325                 }
 326                 else ch = '+';
 327                 sprintfW(&buf[idx], formatW, ch, (int)log_radix);
 328             }
 329         }
 330         else buf[idx] = '\0';
 331
 332         str = SysAllocString(buf);
 333         if(!str)
 334             return E_OUTOFMEMORY;
 335     }
 336
 337     if(r)
 338         *r = jsval_string(str);
 339     else
 340         SysFreeString(str);
 341     return S_OK;
 342 }
 343
 344 static HRESULT Number_toLocaleString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 345         jsval_t *r, jsexcept_t *ei)
 346 {
 347     FIXME("\n");
 348     return E_NOTIMPL;
 349 }
 350
 351 static HRESULT Number_toFixed(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 352         jsval_t *r, jsexcept_t *ei)
 353 {
 354     NumberInstance *number;
 355     DOUBLE val;
 356     INT prec = 0;
 357     BSTR str;
 358     HRESULT hres;
 359
 360     TRACE("\n");
 361
 362     if(!(number = number_this(jsthis)))
 363         return throw_type_error(ctx, ei, JS_E_NUMBER_EXPECTED, NULL);
 364
 365     if(argc) {
 366         hres = to_int32(ctx, argv[0], ei, &prec);
 367         if(FAILED(hres))
 368             return hres;
 369
 370         if(prec<0 || prec>20)
 371             return throw_range_error(ctx, ei, JS_E_FRACTION_DIGITS_OUT_OF_RANGE, NULL);
 372     }
 373
 374     val = number->value;
 375     if(isinf(val) || isnan(val)) {
 376         VARIANT v;
 377
 378         num_set_val(&v, val);
 379         hres = to_string(ctx, &v, ei, &str);
 380         if(FAILED(hres))
 381             return hres;
 382     }else {
 383         number_to_fixed(val, prec, &str);
 384     }
 385
 386     if(r)
 387         *r = jsval_string(str);
 388     else
 389         SysFreeString(str);
 390     return S_OK;
 391 }
 392
 393 static HRESULT Number_toExponential(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 394         jsval_t *r, jsexcept_t *ei)
 395 {
 396     NumberInstance *number;
 397     DOUBLE val;
 398     INT prec = 0;
 399     BSTR str;
 400     HRESULT hres;
 401
 402     TRACE("\n");
 403
 404     if(!(number = number_this(jsthis)))
 405         return throw_type_error(ctx, ei, JS_E_NUMBER_EXPECTED, NULL);
 406
 407     if(argc) {
 408         hres = to_int32(ctx, argv[0], ei, &prec);
 409         if(FAILED(hres))
 410             return hres;
 411
 412         if(prec<0 || prec>20)
 413             return throw_range_error(ctx, ei, JS_E_FRACTION_DIGITS_OUT_OF_RANGE, NULL);
 414     }
 415
 416     val = number->value;
 417     if(isinf(val) || isnan(val)) {
 418         VARIANT v;
 419
 420         num_set_val(&v, val);
 421         hres = to_string(ctx, &v, ei, &str);
 422         if(FAILED(hres))
 423             return hres;
 424     }else {
 425         if(!prec)
 426             prec--;
 427         number_to_exponential(val, prec, &str);
 428     }
 429
 430     if(r)
 431         *r = jsval_string(str);
 432     else
 433         SysFreeString(str);
 434     return S_OK;
 435 }
 436
 437 static HRESULT Number_toPrecision(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 438         jsval_t *r, jsexcept_t *ei)
 439 {
 440     NumberInstance *number;
 441     INT prec = 0, size;
 442     DOUBLE val;
 443     BSTR str;
 444     HRESULT hres;
 445
 446     if(!(number = number_this(jsthis)))
 447         return throw_type_error(ctx, ei, JS_E_NUMBER_EXPECTED, NULL);
 448
 449     if(argc) {
 450         hres = to_int32(ctx, argv[0], ei, &prec);
 451         if(FAILED(hres))
 452             return hres;
 453
 454         if(prec<1 || prec>21)
 455             return throw_range_error(ctx, ei, JS_E_PRECISION_OUT_OF_RANGE, NULL);
 456     }
 457
 458     val = number->value;
 459     if(isinf(val) || isnan(val) || !prec) {
 460         VARIANT v;
 461
 462         num_set_val(&v, val);
 463         hres = to_string(ctx, &v, ei, &str);
 464         if(FAILED(hres))
 465             return hres;
 466     }else {
 467         if(val != 0)
 468             size = floor(log10(val>0 ? val : -val)) + 1;
 469         else
 470             size = 1;
 471
 472         if(size > prec)
 473             number_to_exponential(val, prec-1, &str);
 474         else
 475             number_to_fixed(val, prec-size, &str);
 476     }
 477
 478     if(r)
 479         *r = jsval_string(str);
 480     else
 481         SysFreeString(str);
 482     return S_OK;
 483 }
 484
 485 static HRESULT Number_valueOf(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 486         jsval_t *r, jsexcept_t *ei)
 487 {
 488     NumberInstance *number;
 489
 490     TRACE("\n");
 491
 492     if(!(number = number_this(jsthis)))
 493         return throw_type_error(ctx, ei, JS_E_NUMBER_EXPECTED, NULL);
 494
 495     if(r)
 496         *r = jsval_number(number->value);
 497     return S_OK;
 498 }
 499
 500 static HRESULT Number_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 501         jsval_t *r, jsexcept_t *ei)
 502 {
 503     NumberInstance *number = number_from_vdisp(jsthis);
 504
 505     switch(flags) {
 506     case INVOKE_FUNC:
 507         return throw_type_error(ctx, ei, JS_E_FUNCTION_EXPECTED, NULL);
 508     case DISPATCH_PROPERTYGET:
 509         *r = jsval_number(number->value);
 510         break;
 511
 512     default:
 513         FIXME("flags %x\n", flags);
 514         return E_NOTIMPL;
 515     }
 516
 517     return S_OK;
 518 }
 519
 520 static const builtin_prop_t Number_props[] = {
 521     {toExponentialW,         Number_toExponential,         PROPF_METHOD|1},
 522     {toFixedW,               Number_toFixed,               PROPF_METHOD},
 523     {toLocaleStringW,        Number_toLocaleString,        PROPF_METHOD},
 524     {toPrecisionW,           Number_toPrecision,           PROPF_METHOD|1},
 525     {toStringW,              Number_toString,              PROPF_METHOD|1},
 526     {valueOfW,               Number_valueOf,               PROPF_METHOD}
 527 };
 528
 529 static const builtin_info_t Number_info = {
 530     JSCLASS_NUMBER,
 531     {NULL, Number_value, 0},
 532     sizeof(Number_props)/sizeof(*Number_props),
 533     Number_props,
 534     NULL,
 535     NULL
 536 };
 537
 538 static const builtin_info_t NumberInst_info = {
 539     JSCLASS_NUMBER,
 540     {NULL, Number_value, 0},
 541     0, NULL,
 542     NULL,
 543     NULL
 544 };
 545
 546 static HRESULT NumberConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
 547         jsval_t *r, jsexcept_t *ei)
 548 {
 549     double n;
 550     HRESULT hres;
 551
 552     TRACE("\n");
 553
 554     switch(flags) {
 555     case INVOKE_FUNC:
 556         if(!argc) {
 557             if(r)
 558                 *r = jsval_number(0);
 559             return S_OK;
 560         }
 561
 562         hres = to_number_jsval(ctx, argv[0], ei, &n);
 563         if(FAILED(hres))
 564             return hres;
 565
 566         if(r)
 567             *r = jsval_number(n);
 568         break;
 569
 570     case DISPATCH_CONSTRUCT: {
 571         jsdisp_t *obj;
 572
 573         if(argc) {
 574             hres = to_number_jsval(ctx, argv[0], ei, &n);
 575             if(FAILED(hres))
 576                 return hres;
 577         }else {
 578             n = 0;
 579         }
 580
 581         hres = create_number(ctx, n, &obj);
 582         if(FAILED(hres))
 583             return hres;
 584
 585         *r = jsval_obj(obj);
 586         break;
 587     }
 588     default:
 589         FIXME("unimplemented flags %x\n", flags);
 590         return E_NOTIMPL;
 591     }
 592
 593     return S_OK;
 594 }
 595
 596 static HRESULT alloc_number(script_ctx_t *ctx, jsdisp_t *object_prototype, NumberInstance **ret)
 597 {
 598     NumberInstance *number;
 599     HRESULT hres;
 600
 601     number = heap_alloc_zero(sizeof(NumberInstance));
 602     if(!number)
 603         return E_OUTOFMEMORY;
 604
 605     if(object_prototype)
 606         hres = init_dispex(&number->dispex, ctx, &Number_info, object_prototype);
 607     else
 608         hres = init_dispex_from_constr(&number->dispex, ctx, &NumberInst_info, ctx->number_constr);
 609     if(FAILED(hres))
 610         return hres;
 611
 612     *ret = number;
 613     return S_OK;
 614 }
 615
 616 HRESULT create_number_constr(script_ctx_t *ctx, jsdisp_t *object_prototype, jsdisp_t **ret)
 617 {
 618     NumberInstance *number;
 619     HRESULT hres;
 620
 621     static const WCHAR NumberW[] = {'N','u','m','b','e','r',0};
 622
 623     hres = alloc_number(ctx, object_prototype, &number);
 624     if(FAILED(hres))
 625         return hres;
 626
 627     number->value = 0;
 628     hres = create_builtin_constructor(ctx, NumberConstr_value, NumberW, NULL,
 629             PROPF_CONSTR|1, &number->dispex, ret);
 630
 631     jsdisp_release(&number->dispex);
 632     return hres;
 633 }
 634
 635 HRESULT create_number(script_ctx_t *ctx, double value, jsdisp_t **ret)
 636 {
 637     NumberInstance *number;
 638     HRESULT hres;
 639
 640     hres = alloc_number(ctx, NULL, &number);
 641     if(FAILED(hres))
 642         return hres;
 643
 644     number->value = value;
 645
 646     *ret = &number->dispex;
 647     return S_OK;
 648 }