| /* | |
| * Copyright 2008 Jacek Caban for CodeWeavers | |
| * | |
| * This library is free software; you can redistribute it and/or | |
| * modify it under the terms of the GNU Lesser General Public | |
| * License as published by the Free Software Foundation; either | |
| * version 2.1 of the License, or (at your option) any later version. | |
| * | |
| * This library is distributed in the hope that it will be useful, | |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| * Lesser General Public License for more details. | |
| * | |
| * You should have received a copy of the GNU Lesser General Public | |
| * License along with this library; if not, write to the Free Software | |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA | |
| */ | |
| #include <math.h> | |
| #include <assert.h> | |
| #include "jscript.h" | |
| #include "wine/debug.h" | |
| WINE_DEFAULT_DEBUG_CHANNEL(jscript); | |
| typedef struct { | |
| jsdisp_t dispex; | |
| double value; | |
| } NumberInstance; | |
| static const WCHAR toStringW[] = {'t','o','S','t','r','i','n','g',0}; | |
| static const WCHAR toLocaleStringW[] = {'t','o','L','o','c','a','l','e','S','t','r','i','n','g',0}; | |
| static const WCHAR toFixedW[] = {'t','o','F','i','x','e','d',0}; | |
| static const WCHAR toExponentialW[] = {'t','o','E','x','p','o','n','e','n','t','i','a','l',0}; | |
| static const WCHAR toPrecisionW[] = {'t','o','P','r','e','c','i','s','i','o','n',0}; | |
| static const WCHAR valueOfW[] = {'v','a','l','u','e','O','f',0}; | |
| #define NUMBER_TOSTRING_BUF_SIZE 64 | |
| #define NUMBER_DTOA_SIZE 18 | |
| static inline NumberInstance *number_from_jsdisp(jsdisp_t *jsdisp) | |
| { | |
| return CONTAINING_RECORD(jsdisp, NumberInstance, dispex); | |
| } | |
| static inline NumberInstance *number_from_vdisp(vdisp_t *vdisp) | |
| { | |
| return number_from_jsdisp(vdisp->u.jsdisp); | |
| } | |
| static inline NumberInstance *number_this(vdisp_t *jsthis) | |
| { | |
| return is_vclass(jsthis, JSCLASS_NUMBER) ? number_from_vdisp(jsthis) : NULL; | |
| } | |
| static inline void number_to_str(double d, WCHAR *buf, int size, int *dec_point) | |
| { | |
| ULONGLONG l; | |
| int i; | |
| /* TODO: this function should print doubles with bigger precision */ | |
| assert(size>=2 && size<=NUMBER_DTOA_SIZE && d>=0); | |
| if(d == 0) | |
| *dec_point = 0; | |
| else | |
| *dec_point = floor(log10(d)); | |
| l = d*pow(10, size-*dec_point-1); | |
| if(l%10 >= 5) | |
| l = l/10+1; | |
| else | |
| l /= 10; | |
| buf[size-1] = 0; | |
| for(i=size-2; i>=0; i--) { | |
| buf[i] = '0'+l%10; | |
| l /= 10; | |
| } | |
| /* log10 was wrong by 1 or rounding changed number of digits */ | |
| if(l) { | |
| (*dec_point)++; | |
| memmove(buf+1, buf, size-2); | |
| buf[0] = '0'+l; | |
| }else if(buf[0]=='0' && buf[1]>='1' && buf[1]<='9') { | |
| (*dec_point)--; | |
| memmove(buf, buf+1, size-2); | |
| buf[size-2] = '0'; | |
| } | |
| } | |
| static inline jsstr_t *number_to_fixed(double val, int prec) | |
| { | |
| WCHAR buf[NUMBER_DTOA_SIZE]; | |
| int dec_point, size, buf_size, buf_pos; | |
| BOOL neg = FALSE; | |
| jsstr_t *ret; | |
| WCHAR *str; | |
| TRACE("%lf %d\n", val, prec); | |
| if(val < 0) { | |
| neg = TRUE; | |
| val = -val; | |
| } | |
| if(val >= 1) | |
| buf_size = log10(val)+prec+2; | |
| else | |
| buf_size = prec ? prec+1 : 2; | |
| if(buf_size > NUMBER_DTOA_SIZE) | |
| buf_size = NUMBER_DTOA_SIZE; | |
| number_to_str(val, buf, buf_size, &dec_point); | |
| dec_point++; | |
| size = 0; | |
| if(neg) | |
| size++; | |
| if(dec_point > 0) | |
| size += dec_point; | |
| else | |
| size++; | |
| if(prec) | |
| size += prec+1; | |
| ret = jsstr_alloc_buf(size, &str); | |
| if(!ret) | |
| return NULL; | |
| size = buf_pos = 0; | |
| if(neg) | |
| str[size++] = '-'; | |
| if(dec_point > 0) { | |
| for(;buf_pos<buf_size-1 && dec_point; dec_point--) | |
| str[size++] = buf[buf_pos++]; | |
| }else { | |
| str[size++] = '0'; | |
| } | |
| for(; dec_point>0; dec_point--) | |
| str[size++] = '0'; | |
| if(prec) { | |
| str[size++] = '.'; | |
| for(; dec_point<0 && prec; dec_point++, prec--) | |
| str[size++] = '0'; | |
| for(; buf_pos<buf_size-1 && prec; prec--) | |
| str[size++] = buf[buf_pos++]; | |
| for(; prec; prec--) { | |
| str[size++] = '0'; | |
| } | |
| } | |
| str[size++] = 0; | |
| return ret; | |
| } | |
| static inline jsstr_t *number_to_exponential(double val, int prec) | |
| { | |
| WCHAR buf[NUMBER_DTOA_SIZE], *pbuf; | |
| int dec_point, size, buf_size, exp_size = 1; | |
| BOOL neg = FALSE; | |
| jsstr_t *ret; | |
| WCHAR *str; | |
| if(val < 0) { | |
| neg = TRUE; | |
| val = -val; | |
| } | |
| buf_size = prec+2; | |
| if(buf_size<2 || buf_size>NUMBER_DTOA_SIZE) | |
| buf_size = NUMBER_DTOA_SIZE; | |
| number_to_str(val, buf, buf_size, &dec_point); | |
| buf_size--; | |
| if(prec == -1) | |
| for(; buf_size>1 && buf[buf_size-1]=='0'; buf_size--) | |
| buf[buf_size-1] = 0; | |
| size = 10; | |
| while(dec_point>=size || dec_point<=-size) { | |
| size *= 10; | |
| exp_size++; | |
| } | |
| if(buf_size == 1) | |
| size = buf_size+2+exp_size; /* 2 = strlen(e+) */ | |
| else if(prec == -1) | |
| size = buf_size+3+exp_size; /* 3 = strlen(.e+) */ | |
| else | |
| size = prec+4+exp_size; /* 4 = strlen(0.e+) */ | |
| if(neg) | |
| size++; | |
| ret = jsstr_alloc_buf(size, &str); | |
| if(!ret) | |
| return NULL; | |
| size = 0; | |
| pbuf = buf; | |
| if(neg) | |
| str[size++] = '-'; | |
| str[size++] = *pbuf++; | |
| if(buf_size != 1) { | |
| str[size++] = '.'; | |
| while(*pbuf) | |
| str[size++] = *pbuf++; | |
| for(; prec>buf_size-1; prec--) | |
| str[size++] = '0'; | |
| } | |
| str[size++] = 'e'; | |
| if(dec_point >= 0) { | |
| str[size++] = '+'; | |
| }else { | |
| str[size++] = '-'; | |
| dec_point = -dec_point; | |
| } | |
| size += exp_size; | |
| do { | |
| str[--size] = '0'+dec_point%10; | |
| dec_point /= 10; | |
| }while(dec_point>0); | |
| size += exp_size; | |
| str[size] = 0; | |
| return ret; | |
| } | |
| /* ECMA-262 3rd Edition 15.7.4.2 */ | |
| static HRESULT Number_toString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, | |
| jsval_t *r) | |
| { | |
| NumberInstance *number; | |
| INT radix = 10; | |
| DOUBLE val; | |
| jsstr_t *str; | |
| HRESULT hres; | |
| TRACE("\n"); | |
| if(!(number = number_this(jsthis))) | |
| return throw_type_error(ctx, JS_E_NUMBER_EXPECTED, NULL); | |
| if(argc) { | |
| hres = to_int32(ctx, argv[0], &radix); | |
| if(FAILED(hres)) | |
| return hres; | |
| if(radix<2 || radix>36) | |
| return throw_type_error(ctx, JS_E_INVALIDARG, NULL); | |
| } | |
| val = number->value; | |
| if(radix==10 || !is_finite(val)) { | |
| hres = to_string(ctx, jsval_number(val), &str); | |
| if(FAILED(hres)) | |
| return hres; | |
| }else { | |
| INT idx = 0; | |
| DOUBLE integ, frac, log_radix = 0; | |
| WCHAR buf[NUMBER_TOSTRING_BUF_SIZE+16]; | |
| BOOL exp = FALSE; | |
| if(val<0) { | |
| val = -val; | |
| buf[idx++] = '-'; | |
| } | |
| while(1) { | |
| integ = floor(val); | |
| frac = val-integ; | |
| if(integ == 0) | |
| buf[idx++] = '0'; | |
| while(integ>=1 && idx<NUMBER_TOSTRING_BUF_SIZE) { | |
| buf[idx] = fmod(integ, radix); | |
| if(buf[idx]<10) buf[idx] += '0'; | |
| else buf[idx] += 'a'-10; | |
| integ /= radix; | |
| idx++; | |
| } | |
| if(idx<NUMBER_TOSTRING_BUF_SIZE) { | |
| INT beg = buf[0]=='-'?1:0; | |
| INT end = idx-1; | |
| WCHAR wch; | |
| while(end > beg) { | |
| wch = buf[beg]; | |
| buf[beg++] = buf[end]; | |
| buf[end--] = wch; | |
| } | |
| } | |
| if(idx != NUMBER_TOSTRING_BUF_SIZE) buf[idx++] = '.'; | |
| while(frac>0 && idx<NUMBER_TOSTRING_BUF_SIZE) { | |
| frac *= radix; | |
| buf[idx] = fmod(frac, radix); | |
| frac -= buf[idx]; | |
| if(buf[idx]<10) buf[idx] += '0'; | |
| else buf[idx] += 'a'-10; | |
| idx++; | |
| } | |
| if(idx==NUMBER_TOSTRING_BUF_SIZE && !exp) { | |
| exp = TRUE; | |
| idx = (buf[0]=='-') ? 1 : 0; | |
| log_radix = floor(log(val)/log(radix)); | |
| val *= pow(radix, -log_radix); | |
| continue; | |
| } | |
| break; | |
| } | |
| while(buf[idx-1] == '0') idx--; | |
| if(buf[idx-1] == '.') idx--; | |
| if(exp) { | |
| if(log_radix==0) | |
| buf[idx] = 0; | |
| else { | |
| static const WCHAR formatW[] = {'(','e','%','c','%','d',')',0}; | |
| WCHAR ch; | |
| if(log_radix<0) { | |
| log_radix = -log_radix; | |
| ch = '-'; | |
| } | |
| else ch = '+'; | |
| sprintfW(&buf[idx], formatW, ch, (int)log_radix); | |
| } | |
| } | |
| else buf[idx] = '\0'; | |
| str = jsstr_alloc(buf); | |
| if(!str) | |
| return E_OUTOFMEMORY; | |
| } | |
| if(r) | |
| *r = jsval_string(str); | |
| else | |
| jsstr_release(str); | |
| return S_OK; | |
| } | |
| static HRESULT Number_toLocaleString(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, | |
| jsval_t *r) | |
| { | |
| FIXME("\n"); | |
| return E_NOTIMPL; | |
| } | |
| static HRESULT Number_toFixed(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, | |
| jsval_t *r) | |
| { | |
| NumberInstance *number; | |
| DOUBLE val; | |
| INT prec = 0; | |
| jsstr_t *str; | |
| HRESULT hres; | |
| TRACE("\n"); | |
| if(!(number = number_this(jsthis))) | |
| return throw_type_error(ctx, JS_E_NUMBER_EXPECTED, NULL); | |
| if(argc) { | |
| hres = to_int32(ctx, argv[0], &prec); | |
| if(FAILED(hres)) | |
| return hres; | |
| if(prec<0 || prec>20) | |
| return throw_range_error(ctx, JS_E_FRACTION_DIGITS_OUT_OF_RANGE, NULL); | |
| } | |
| val = number->value; | |
| if(!is_finite(val)) { | |
| hres = to_string(ctx, jsval_number(val), &str); | |
| if(FAILED(hres)) | |
| return hres; | |
| }else { | |
| str = number_to_fixed(val, prec); | |
| if(!str) | |
| return E_OUTOFMEMORY; | |
| } | |
| if(r) | |
| *r = jsval_string(str); | |
| else | |
| jsstr_release(str); | |
| return S_OK; | |
| } | |
| static HRESULT Number_toExponential(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, | |
| jsval_t *r) | |
| { | |
| NumberInstance *number; | |
| DOUBLE val; | |
| INT prec = 0; | |
| jsstr_t *str; | |
| HRESULT hres; | |
| TRACE("\n"); | |
| if(!(number = number_this(jsthis))) | |
| return throw_type_error(ctx, JS_E_NUMBER_EXPECTED, NULL); | |
| if(argc) { | |
| hres = to_int32(ctx, argv[0], &prec); | |
| if(FAILED(hres)) | |
| return hres; | |
| if(prec<0 || prec>20) | |
| return throw_range_error(ctx, JS_E_FRACTION_DIGITS_OUT_OF_RANGE, NULL); | |
| } | |
| val = number->value; | |
| if(!is_finite(val)) { | |
| hres = to_string(ctx, jsval_number(val), &str); | |
| if(FAILED(hres)) | |
| return hres; | |
| }else { | |
| if(!prec) | |
| prec--; | |
| str = number_to_exponential(val, prec); | |
| if(!str) | |
| return E_OUTOFMEMORY; | |
| } | |
| if(r) | |
| *r = jsval_string(str); | |
| else | |
| jsstr_release(str); | |
| return S_OK; | |
| } | |
| static HRESULT Number_toPrecision(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, | |
| jsval_t *r) | |
| { | |
| NumberInstance *number; | |
| INT prec = 0, size; | |
| jsstr_t *str; | |
| DOUBLE val; | |
| HRESULT hres; | |
| if(!(number = number_this(jsthis))) | |
| return throw_type_error(ctx, JS_E_NUMBER_EXPECTED, NULL); | |
| if(argc) { | |
| hres = to_int32(ctx, argv[0], &prec); | |
| if(FAILED(hres)) | |
| return hres; | |
| if(prec<1 || prec>21) | |
| return throw_range_error(ctx, JS_E_PRECISION_OUT_OF_RANGE, NULL); | |
| } | |
| val = number->value; | |
| if(!is_finite(val) || !prec) { | |
| hres = to_string(ctx, jsval_number(val), &str); | |
| if(FAILED(hres)) | |
| return hres; | |
| }else { | |
| if(val != 0) | |
| size = floor(log10(val>0 ? val : -val)) + 1; | |
| else | |
| size = 1; | |
| if(size > prec) | |
| str = number_to_exponential(val, prec-1); | |
| else | |
| str = number_to_fixed(val, prec-size); | |
| if(!str) | |
| return E_OUTOFMEMORY; | |
| } | |
| if(r) | |
| *r = jsval_string(str); | |
| else | |
| jsstr_release(str); | |
| return S_OK; | |
| } | |
| static HRESULT Number_valueOf(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, | |
| jsval_t *r) | |
| { | |
| NumberInstance *number; | |
| TRACE("\n"); | |
| if(!(number = number_this(jsthis))) | |
| return throw_type_error(ctx, JS_E_NUMBER_EXPECTED, NULL); | |
| if(r) | |
| *r = jsval_number(number->value); | |
| return S_OK; | |
| } | |
| static HRESULT Number_get_value(script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r) | |
| { | |
| NumberInstance *number = number_from_jsdisp(jsthis); | |
| TRACE("(%p)\n", number); | |
| *r = jsval_number(number->value); | |
| return S_OK; | |
| } | |
| static const builtin_prop_t Number_props[] = { | |
| {toExponentialW, Number_toExponential, PROPF_METHOD|1}, | |
| {toFixedW, Number_toFixed, PROPF_METHOD}, | |
| {toLocaleStringW, Number_toLocaleString, PROPF_METHOD}, | |
| {toPrecisionW, Number_toPrecision, PROPF_METHOD|1}, | |
| {toStringW, Number_toString, PROPF_METHOD|1}, | |
| {valueOfW, Number_valueOf, PROPF_METHOD} | |
| }; | |
| static const builtin_info_t Number_info = { | |
| JSCLASS_NUMBER, | |
| {NULL, NULL,0, Number_get_value}, | |
| sizeof(Number_props)/sizeof(*Number_props), | |
| Number_props, | |
| NULL, | |
| NULL | |
| }; | |
| static const builtin_info_t NumberInst_info = { | |
| JSCLASS_NUMBER, | |
| {NULL, NULL,0, Number_get_value}, | |
| 0, NULL, | |
| NULL, | |
| NULL | |
| }; | |
| static HRESULT NumberConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv, | |
| jsval_t *r) | |
| { | |
| double n; | |
| HRESULT hres; | |
| TRACE("\n"); | |
| switch(flags) { | |
| case INVOKE_FUNC: | |
| if(!argc) { | |
| if(r) | |
| *r = jsval_number(0); | |
| return S_OK; | |
| } | |
| hres = to_number(ctx, argv[0], &n); | |
| if(FAILED(hres)) | |
| return hres; | |
| if(r) | |
| *r = jsval_number(n); | |
| break; | |
| case DISPATCH_CONSTRUCT: { | |
| jsdisp_t *obj; | |
| if(argc) { | |
| hres = to_number(ctx, argv[0], &n); | |
| if(FAILED(hres)) | |
| return hres; | |
| }else { | |
| n = 0; | |
| } | |
| hres = create_number(ctx, n, &obj); | |
| if(FAILED(hres)) | |
| return hres; | |
| *r = jsval_obj(obj); | |
| break; | |
| } | |
| default: | |
| FIXME("unimplemented flags %x\n", flags); | |
| return E_NOTIMPL; | |
| } | |
| return S_OK; | |
| } | |
| static HRESULT alloc_number(script_ctx_t *ctx, jsdisp_t *object_prototype, NumberInstance **ret) | |
| { | |
| NumberInstance *number; | |
| HRESULT hres; | |
| number = heap_alloc_zero(sizeof(NumberInstance)); | |
| if(!number) | |
| return E_OUTOFMEMORY; | |
| if(object_prototype) | |
| hres = init_dispex(&number->dispex, ctx, &Number_info, object_prototype); | |
| else | |
| hres = init_dispex_from_constr(&number->dispex, ctx, &NumberInst_info, ctx->number_constr); | |
| if(FAILED(hres)) { | |
| heap_free(number); | |
| return hres; | |
| } | |
| *ret = number; | |
| return S_OK; | |
| } | |
| HRESULT create_number_constr(script_ctx_t *ctx, jsdisp_t *object_prototype, jsdisp_t **ret) | |
| { | |
| NumberInstance *number; | |
| HRESULT hres; | |
| static const WCHAR NumberW[] = {'N','u','m','b','e','r',0}; | |
| hres = alloc_number(ctx, object_prototype, &number); | |
| if(FAILED(hres)) | |
| return hres; | |
| number->value = 0; | |
| hres = create_builtin_constructor(ctx, NumberConstr_value, NumberW, NULL, | |
| PROPF_CONSTR|1, &number->dispex, ret); | |
| jsdisp_release(&number->dispex); | |
| return hres; | |
| } | |
| HRESULT create_number(script_ctx_t *ctx, double value, jsdisp_t **ret) | |
| { | |
| NumberInstance *number; | |
| HRESULT hres; | |
| hres = alloc_number(ctx, NULL, &number); | |
| if(FAILED(hres)) | |
| return hres; | |
| number->value = value; | |
| *ret = &number->dispex; | |
| return S_OK; | |
| } |