dlls/jscript/math.c

   1 /*
   2  * Copyright 2008 Jacek Caban for CodeWeavers
   3  * Copyright 2009 Piotr Caban
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include "config.h"
  21 #include "wine/port.h"
  22
  23 #include <math.h>
  24 #include <limits.h>
  25
  26 #include "jscript.h"
  27 #include "ntsecapi.h"
  28
  29 #include "wine/debug.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(jscript);
  32
  33 static const WCHAR EW[] = {'E',0};
  34 static const WCHAR LOG2EW[] = {'L','O','G','2','E',0};
  35 static const WCHAR LOG10EW[] = {'L','O','G','1','0','E',0};
  36 static const WCHAR LN2W[] = {'L','N','2',0};
  37 static const WCHAR LN10W[] = {'L','N','1','0',0};
  38 static const WCHAR PIW[] = {'P','I',0};
  39 static const WCHAR SQRT2W[] = {'S','Q','R','T','2',0};
  40 static const WCHAR SQRT1_2W[] = {'S','Q','R','T','1','_','2',0};
  41 static const WCHAR absW[] = {'a','b','s',0};
  42 static const WCHAR acosW[] = {'a','c','o','s',0};
  43 static const WCHAR asinW[] = {'a','s','i','n',0};
  44 static const WCHAR atanW[] = {'a','t','a','n',0};
  45 static const WCHAR atan2W[] = {'a','t','a','n','2',0};
  46 static const WCHAR ceilW[] = {'c','e','i','l',0};
  47 static const WCHAR cosW[] = {'c','o','s',0};
  48 static const WCHAR expW[] = {'e','x','p',0};
  49 static const WCHAR floorW[] = {'f','l','o','o','r',0};
  50 static const WCHAR logW[] = {'l','o','g',0};
  51 static const WCHAR maxW[] = {'m','a','x',0};
  52 static const WCHAR minW[] = {'m','i','n',0};
  53 static const WCHAR powW[] = {'p','o','w',0};
  54 static const WCHAR randomW[] = {'r','a','n','d','o','m',0};
  55 static const WCHAR roundW[] = {'r','o','u','n','d',0};
  56 static const WCHAR sinW[] = {'s','i','n',0};
  57 static const WCHAR sqrtW[] = {'s','q','r','t',0};
  58 static const WCHAR tanW[] = {'t','a','n',0};
  59
  60 /* ECMA-262 3rd Edition    15.8.2.12 */
  61 static HRESULT Math_abs(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
  62         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
  63 {
  64     VARIANT v;
  65     DOUBLE d;
  66     HRESULT hres;
  67
  68     TRACE("\n");
  69
  70     if(!arg_cnt(dp)) {
  71         if(retv)
  72             num_set_nan(retv);
  73         return S_OK;
  74     }
  75
  76     hres = to_number(ctx, get_arg(dp, 0), ei, &v);
  77     if(FAILED(hres))
  78         return hres;
  79
  80     d = num_val(&v);
  81     if(retv)
  82         num_set_val(retv, d < 0.0 ? -d : d);
  83     return S_OK;
  84 }
  85
  86 static HRESULT Math_acos(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
  87         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
  88 {
  89     VARIANT v;
  90     HRESULT hres;
  91
  92     TRACE("\n");
  93
  94     if(!arg_cnt(dp)) {
  95         if(retv) num_set_nan(retv);
  96         return S_OK;
  97     }
  98
  99     hres = to_number(ctx, get_arg(dp, 0), ei, &v);
 100     if(FAILED(hres))
 101         return hres;
 102
 103     if(retv) num_set_val(retv, acos(num_val(&v)));
 104     return S_OK;
 105 }
 106
 107 static HRESULT Math_asin(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
 108         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 109 {
 110     VARIANT v;
 111     HRESULT hres;
 112
 113     TRACE("\n");
 114
 115     if(!arg_cnt(dp)) {
 116         if(retv) num_set_nan(retv);
 117         return S_OK;
 118     }
 119
 120     hres = to_number(ctx, get_arg(dp, 0), ei, &v);
 121     if(FAILED(hres))
 122         return hres;
 123
 124     if(retv) num_set_val(retv, asin(num_val(&v)));
 125     return S_OK;
 126 }
 127
 128 static HRESULT Math_atan(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
 129         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 130 {
 131     VARIANT v;
 132     HRESULT hres;
 133
 134     TRACE("\n");
 135
 136     if(!arg_cnt(dp)) {
 137         if(retv) num_set_nan(retv);
 138         return S_OK;
 139     }
 140
 141     hres = to_number(ctx, get_arg(dp, 0), ei, &v);
 142     if(FAILED(hres))
 143         return hres;
 144
 145     if(retv) num_set_val(retv, atan(num_val(&v)));
 146     return S_OK;
 147 }
 148
 149 static HRESULT Math_atan2(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
 150         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 151 {
 152     VARIANT v1, v2;
 153     HRESULT hres;
 154
 155     TRACE("\n");
 156
 157     if(arg_cnt(dp)<2) {
 158         if(retv) num_set_nan(retv);
 159         return S_OK;
 160     }
 161
 162     hres = to_number(ctx, get_arg(dp, 0), ei, &v1);
 163     if(FAILED(hres))
 164         return hres;
 165
 166     hres = to_number(ctx, get_arg(dp, 1), ei, &v2);
 167     if(FAILED(hres))
 168         return hres;
 169
 170     if(retv) num_set_val(retv, atan2(num_val(&v1), num_val(&v2)));
 171     return S_OK;
 172 }
 173
 174 /* ECMA-262 3rd Edition    15.8.2.6 */
 175 static HRESULT Math_ceil(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
 176         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 177 {
 178     VARIANT v;
 179     HRESULT hres;
 180
 181     TRACE("\n");
 182
 183     if(!arg_cnt(dp)) {
 184         if(retv)
 185             num_set_nan(retv);
 186         return S_OK;
 187     }
 188
 189     hres = to_number(ctx, get_arg(dp, 0), ei, &v);
 190     if(FAILED(hres))
 191         return hres;
 192
 193     if(retv)
 194         num_set_val(retv, ceil(num_val(&v)));
 195     return S_OK;
 196 }
 197
 198 static HRESULT Math_cos(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
 199         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 200 {
 201     VARIANT v;
 202     HRESULT hres;
 203
 204     TRACE("\n");
 205
 206     if(!arg_cnt(dp)) {
 207         if(retv) num_set_nan(retv);
 208         return S_OK;
 209     }
 210
 211     hres = to_number(ctx, get_arg(dp, 0), ei, &v);
 212     if(FAILED(hres))
 213         return hres;
 214
 215     if(retv) num_set_val(retv, cos(num_val(&v)));
 216     return S_OK;
 217 }
 218
 219 static HRESULT Math_exp(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
 220         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 221 {
 222     VARIANT v;
 223     HRESULT hres;
 224
 225     TRACE("\n");
 226
 227     if(!arg_cnt(dp)) {
 228         if(retv) num_set_nan(retv);
 229         return S_OK;
 230     }
 231
 232     hres = to_number(ctx, get_arg(dp, 0), ei, &v);
 233     if(FAILED(hres))
 234         return hres;
 235
 236     if(retv) num_set_val(retv, exp(num_val(&v)));
 237     return S_OK;
 238 }
 239
 240 static HRESULT Math_floor(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
 241         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 242 {
 243     VARIANT v;
 244     HRESULT hres;
 245
 246     TRACE("\n");
 247
 248     if(!arg_cnt(dp)) {
 249         if(retv)
 250             num_set_nan(retv);
 251         return S_OK;
 252     }
 253
 254     hres = to_number(ctx, get_arg(dp, 0), ei, &v);
 255     if(FAILED(hres))
 256         return hres;
 257
 258     if(retv)
 259         num_set_val(retv, floor(num_val(&v)));
 260     return S_OK;
 261 }
 262
 263 static HRESULT Math_log(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
 264         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 265 {
 266     VARIANT v;
 267     HRESULT hres;
 268
 269     TRACE("\n");
 270
 271     if(!arg_cnt(dp)) {
 272         if(retv)
 273             num_set_nan(retv);
 274         return S_OK;
 275     }
 276
 277     hres = to_number(ctx, get_arg(dp, 0), ei, &v);
 278     if(FAILED(hres))
 279         return hres;
 280
 281     if(retv)
 282         num_set_val(retv, log(num_val(&v)));
 283     return S_OK;
 284 }
 285
 286 /* ECMA-262 3rd Edition    15.8.2.11 */
 287 static HRESULT Math_max(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
 288         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 289 {
 290     DOUBLE max, d;
 291     VARIANT v;
 292     DWORD i;
 293     HRESULT hres;
 294
 295     TRACE("\n");
 296
 297     if(!arg_cnt(dp)) {
 298         if(retv)
 299             num_set_inf(retv, FALSE);
 300         return S_OK;
 301     }
 302
 303     hres = to_number(ctx, get_arg(dp, 0), ei, &v);
 304     if(FAILED(hres))
 305         return hres;
 306
 307     max = num_val(&v);
 308     for(i=1; i < arg_cnt(dp); i++) {
 309         hres = to_number(ctx, get_arg(dp, i), ei, &v);
 310         if(FAILED(hres))
 311             return hres;
 312
 313         d = num_val(&v);
 314         if(d > max || isnan(d))
 315             max = d;
 316     }
 317
 318     if(retv)
 319         num_set_val(retv, max);
 320     return S_OK;
 321 }
 322
 323 /* ECMA-262 3rd Edition    15.8.2.12 */
 324 static HRESULT Math_min(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
 325         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 326 {
 327     DOUBLE min, d;
 328     VARIANT v;
 329     DWORD i;
 330     HRESULT hres;
 331
 332     TRACE("\n");
 333
 334     if(!arg_cnt(dp)) {
 335         if(retv)
 336             num_set_inf(retv, TRUE);
 337         return S_OK;
 338     }
 339
 340     hres = to_number(ctx, get_arg(dp, 0), ei, &v);
 341     if(FAILED(hres))
 342         return hres;
 343
 344     min = num_val(&v);
 345     for(i=1; i < arg_cnt(dp); i++) {
 346         hres = to_number(ctx, get_arg(dp, i), ei, &v);
 347         if(FAILED(hres))
 348             return hres;
 349
 350         d = num_val(&v);
 351         if(d < min || isnan(d))
 352             min = d;
 353     }
 354
 355     if(retv)
 356         num_set_val(retv, min);
 357     return S_OK;
 358 }
 359
 360 /* ECMA-262 3rd Edition    15.8.2.13 */
 361 static HRESULT Math_pow(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
 362         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 363 {
 364     VARIANT x, y;
 365     HRESULT hres;
 366
 367     TRACE("\n");
 368
 369     if(arg_cnt(dp) < 2) {
 370         if(retv) num_set_nan(retv);
 371         return S_OK;
 372     }
 373
 374     hres = to_number(ctx, get_arg(dp, 0), ei, &x);
 375     if(FAILED(hres))
 376         return hres;
 377
 378     hres = to_number(ctx, get_arg(dp, 1), ei, &y);
 379     if(FAILED(hres))
 380         return hres;
 381
 382     if(retv)
 383         num_set_val(retv, pow(num_val(&x), num_val(&y)));
 384     return S_OK;
 385 }
 386
 387 /* ECMA-262 3rd Edition    15.8.2.14 */
 388 static HRESULT Math_random(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
 389         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 390 {
 391     UINT r;
 392
 393     TRACE("\n");
 394
 395     if(!RtlGenRandom(&r, sizeof(r)))
 396         return E_UNEXPECTED;
 397
 398     if(retv)
 399         num_set_val(retv, (DOUBLE)r/(DOUBLE)UINT_MAX);
 400
 401     return S_OK;
 402 }
 403
 404 /* ECMA-262 3rd Edition    15.8.2.15 */
 405 static HRESULT Math_round(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
 406         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 407 {
 408     VARIANT v;
 409     HRESULT hres;
 410
 411     TRACE("\n");
 412
 413     if(!arg_cnt(dp)) {
 414         num_set_nan(retv);
 415         return S_OK;
 416     }
 417
 418     hres = to_number(ctx, get_arg(dp, 0), ei, &v);
 419     if(FAILED(hres))
 420         return hres;
 421
 422     if(retv)
 423         num_set_val(retv, floor(num_val(&v)+0.5));
 424     return S_OK;
 425 }
 426
 427 static HRESULT Math_sin(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
 428         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 429 {
 430     VARIANT v;
 431     HRESULT hres;
 432
 433     TRACE("\n");
 434
 435     if(!arg_cnt(dp)) {
 436         if(retv) num_set_nan(retv);
 437         return S_OK;
 438     }
 439
 440     hres = to_number(ctx, get_arg(dp, 0), ei, &v);
 441     if(FAILED(hres))
 442         return hres;
 443
 444     if(retv) num_set_val(retv, sin(num_val(&v)));
 445     return S_OK;
 446 }
 447
 448 static HRESULT Math_sqrt(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
 449         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 450 {
 451     VARIANT v;
 452     HRESULT hres;
 453
 454     TRACE("\n");
 455
 456     if(!arg_cnt(dp)) {
 457         if(retv) num_set_nan(retv);
 458         return S_OK;
 459     }
 460
 461     hres = to_number(ctx, get_arg(dp, 0), ei, &v);
 462     if(FAILED(hres))
 463         return hres;
 464
 465     if(retv) num_set_val(retv, sqrt(num_val(&v)));
 466     return S_OK;
 467 }
 468
 469 static HRESULT Math_tan(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
 470         VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
 471 {
 472     VARIANT v;
 473     HRESULT hres;
 474
 475     TRACE("\n");
 476
 477     if(!arg_cnt(dp)) {
 478         if(retv) num_set_nan(retv);
 479         return S_OK;
 480     }
 481
 482     hres = to_number(ctx, get_arg(dp, 0), ei, &v);
 483     if(FAILED(hres))
 484         return hres;
 485
 486     if(retv) num_set_val(retv, tan(num_val(&v)));
 487     return S_OK;
 488 }
 489
 490 static const builtin_prop_t Math_props[] = {
 491     {absW,      Math_abs,      PROPF_METHOD|1},
 492     {acosW,     Math_acos,     PROPF_METHOD|1},
 493     {asinW,     Math_asin,     PROPF_METHOD|1},
 494     {atanW,     Math_atan,     PROPF_METHOD|1},
 495     {atan2W,    Math_atan2,    PROPF_METHOD|2},
 496     {ceilW,     Math_ceil,     PROPF_METHOD|1},
 497     {cosW,      Math_cos,      PROPF_METHOD|1},
 498     {expW,      Math_exp,      PROPF_METHOD|1},
 499     {floorW,    Math_floor,    PROPF_METHOD|1},
 500     {logW,      Math_log,      PROPF_METHOD|1},
 501     {maxW,      Math_max,      PROPF_METHOD|2},
 502     {minW,      Math_min,      PROPF_METHOD|2},
 503     {powW,      Math_pow,      PROPF_METHOD|2},
 504     {randomW,   Math_random,   PROPF_METHOD},
 505     {roundW,    Math_round,    PROPF_METHOD|1},
 506     {sinW,      Math_sin,      PROPF_METHOD|1},
 507     {sqrtW,     Math_sqrt,     PROPF_METHOD|1},
 508     {tanW,      Math_tan,      PROPF_METHOD|1}
 509 };
 510
 511 static const builtin_info_t Math_info = {
 512     JSCLASS_MATH,
 513     {NULL, NULL, 0},
 514     sizeof(Math_props)/sizeof(*Math_props),
 515     Math_props,
 516     NULL,
 517     NULL
 518 };
 519
 520 HRESULT create_math(script_ctx_t *ctx, DispatchEx **ret)
 521 {
 522     DispatchEx *math;
 523     unsigned i;
 524     VARIANT v;
 525     HRESULT hres;
 526
 527     struct {
 528         const WCHAR *name;
 529         DOUBLE val;
 530     }constants[] = {
 531         {EW,        M_E},        /* ECMA-262 3rd Edition    15.8.1.1 */
 532         {LN10W,     M_LN10},     /* ECMA-262 3rd Edition    15.8.1.2 */
 533         {LN2W,      M_LN2},      /* ECMA-262 3rd Edition    15.8.1.3 */
 534         {LOG2EW,    M_LOG2E},    /* ECMA-262 3rd Edition    15.8.1.4 */
 535         {LOG10EW,   M_LOG10E},   /* ECMA-262 3rd Edition    15.8.1.5 */
 536         {PIW,       M_PI},       /* ECMA-262 3rd Edition    15.8.1.6 */
 537         {SQRT1_2W,  M_SQRT1_2},  /* ECMA-262 3rd Edition    15.8.1.7 */
 538         {SQRT2W,    M_SQRT2},    /* ECMA-262 3rd Edition    15.8.1.8 */
 539     };
 540
 541     math = heap_alloc_zero(sizeof(DispatchEx));
 542     if(!math)
 543         return E_OUTOFMEMORY;
 544
 545     hres = init_dispex_from_constr(math, ctx, &Math_info, ctx->object_constr);
 546     if(FAILED(hres)) {
 547         heap_free(math);
 548         return hres;
 549     }
 550
 551     V_VT(&v) = VT_R8;
 552     for(i=0; i < sizeof(constants)/sizeof(*constants); i++) {
 553         V_R8(&v) = constants[i].val;
 554         hres = jsdisp_propput_const(math, constants[i].name, &v);
 555         if(FAILED(hres)) {
 556             jsdisp_release(math);
 557             return hres;
 558         }
 559     }
 560
 561     *ret = math;
 562     return S_OK;
 563 }