/[jscoverage]/trunk/js/jsnum.cpp
ViewVC logotype

Diff of /trunk/js/jsnum.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 506 by siliconforks, Sat Sep 26 23:15:22 2009 UTC revision 507 by siliconforks, Sun Jan 10 07:23:34 2010 UTC
# Line 1  Line 1 
1  /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-  /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
2   *   *
3   * ***** BEGIN LICENSE BLOCK *****   * ***** BEGIN LICENSE BLOCK *****
4   * Version: MPL 1.1/GPL 2.0/LGPL 2.1   * Version: MPL 1.1/GPL 2.0/LGPL 2.1
# Line 38  Line 38 
38   *   *
39   * ***** END LICENSE BLOCK ***** */   * ***** END LICENSE BLOCK ***** */
40    
41    #define __STDC_LIMIT_MACROS
42    
43  /*  /*
44   * JS number type and wrapper class.   * JS number type and wrapper class.
45   */   */
 #include "jsstddef.h"  
 #if defined(XP_WIN) || defined(XP_OS2)  
 #include <float.h>  
 #endif  
46  #ifdef XP_OS2  #ifdef XP_OS2
47  #define _PC_53  PC_53  #define _PC_53  PC_53
48  #define _MCW_EM MCW_EM  #define _MCW_EM MCW_EM
# Line 56  Line 54 
54  #include <stdlib.h>  #include <stdlib.h>
55  #include <string.h>  #include <string.h>
56  #include "jstypes.h"  #include "jstypes.h"
57    #include "jsstdint.h"
58  #include "jsutil.h" /* Added by JSIFY */  #include "jsutil.h" /* Added by JSIFY */
59  #include "jsapi.h"  #include "jsapi.h"
60  #include "jsatom.h"  #include "jsatom.h"
# Line 71  Line 70 
70  #include "jsprf.h"  #include "jsprf.h"
71  #include "jsscope.h"  #include "jsscope.h"
72  #include "jsstr.h"  #include "jsstr.h"
73    #include "jsstrinlines.h"
74    #include "jsvector.h"
75    
76    
77    #ifndef JS_HAVE_STDINT_H /* Native support is innocent until proven guilty. */
78    
79    JS_STATIC_ASSERT(uint8_t(-1) == UINT8_MAX);
80    JS_STATIC_ASSERT(uint16_t(-1) == UINT16_MAX);
81    JS_STATIC_ASSERT(uint32_t(-1) == UINT32_MAX);
82    JS_STATIC_ASSERT(uint64_t(-1) == UINT64_MAX);
83    
84    JS_STATIC_ASSERT(INT8_MAX > INT8_MIN);
85    JS_STATIC_ASSERT(uint8_t(INT8_MAX) + uint8_t(1) == uint8_t(INT8_MIN));
86    JS_STATIC_ASSERT(INT16_MAX > INT16_MIN);
87    JS_STATIC_ASSERT(uint16_t(INT16_MAX) + uint16_t(1) == uint16_t(INT16_MIN));
88    JS_STATIC_ASSERT(INT32_MAX > INT32_MIN);
89    JS_STATIC_ASSERT(uint32_t(INT32_MAX) + uint32_t(1) == uint32_t(INT32_MIN));
90    JS_STATIC_ASSERT(INT64_MAX > INT64_MIN);
91    JS_STATIC_ASSERT(uint64_t(INT64_MAX) + uint64_t(1) == uint64_t(INT64_MIN));
92    
93    JS_STATIC_ASSERT(INTPTR_MAX > INTPTR_MIN);
94    JS_STATIC_ASSERT(uintptr_t(INTPTR_MAX) + uintptr_t(1) == uintptr_t(INTPTR_MIN));
95    JS_STATIC_ASSERT(uintptr_t(-1) == UINTPTR_MAX);
96    JS_STATIC_ASSERT(size_t(-1) == SIZE_MAX);
97    JS_STATIC_ASSERT(PTRDIFF_MAX > PTRDIFF_MIN);
98    JS_STATIC_ASSERT(ptrdiff_t(PTRDIFF_MAX) == PTRDIFF_MAX);
99    JS_STATIC_ASSERT(ptrdiff_t(PTRDIFF_MIN) == PTRDIFF_MIN);
100    JS_STATIC_ASSERT(uintptr_t(PTRDIFF_MAX) + uintptr_t(1) == uintptr_t(PTRDIFF_MIN));
101    
102    #endif /* JS_HAVE_STDINT_H */
103    
104  static JSBool  static JSBool
105  num_isNaN(JSContext *cx, uintN argc, jsval *vp)  num_isNaN(JSContext *cx, uintN argc, jsval *vp)
# Line 118  Line 147 
147      str = js_ValueToString(cx, vp[2]);      str = js_ValueToString(cx, vp[2]);
148      if (!str)      if (!str)
149          return JS_FALSE;          return JS_FALSE;
150      JSSTRING_CHARS_AND_END(str, bp, end);      str->getCharsAndEnd(bp, end);
151      if (!js_strtod(cx, bp, end, &ep, &d))      if (!js_strtod(cx, bp, end, &ep, &d))
152          return JS_FALSE;          return JS_FALSE;
153      if (ep == bp) {      if (ep == bp) {
# Line 137  Line 166 
166      const jschar* ep;      const jschar* ep;
167      jsdouble d;      jsdouble d;
168    
169      JSSTRING_CHARS_AND_END(str, bp, end);      str->getCharsAndEnd(bp, end);
170      if (!js_strtod(cx, bp, end, &ep, &d) || ep == bp)      if (!js_strtod(cx, bp, end, &ep, &d) || ep == bp)
171          return js_NaN;          return js_NaN;
172      return d;      return d;
# Line 177  Line 206 
206      str = js_ValueToString(cx, vp[2]);      str = js_ValueToString(cx, vp[2]);
207      if (!str)      if (!str)
208          return JS_FALSE;          return JS_FALSE;
209      JSSTRING_CHARS_AND_END(str, bp, end);      str->getCharsAndEnd(bp, end);
210      if (!js_strtointeger(cx, bp, end, &ep, radix, &d))      if (!js_strtointeger(cx, bp, end, &ep, radix, &d))
211          return JS_FALSE;          return JS_FALSE;
212      if (ep == bp) {      if (ep == bp) {
# Line 196  Line 225 
225      const jschar* ep;      const jschar* ep;
226      jsdouble d;      jsdouble d;
227    
228      JSSTRING_CHARS_AND_END(str, bp, end);      str->getCharsAndEnd(bp, end);
229      if (!js_strtointeger(cx, bp, end, &ep, 0, &d) || ep == bp)      if (!js_strtointeger(cx, bp, end, &ep, 0, &d) || ep == bp)
230          return js_NaN;          return js_NaN;
231      return d;      return d;
# Line 207  Line 236 
236  {  {
237      if (!JSDOUBLE_IS_FINITE(d))      if (!JSDOUBLE_IS_FINITE(d))
238          return js_NaN;          return js_NaN;
239      return floor(d);      if (d > 0)
240            return floor(d);
241        if (d < 0)
242            return -floor(-d);
243        return 0;
244  }  }
245  #endif  #endif
246    
# Line 232  Line 265 
265  static JSFunctionSpec number_functions[] = {  static JSFunctionSpec number_functions[] = {
266      JS_FN(js_isNaN_str,         num_isNaN,           1,0),      JS_FN(js_isNaN_str,         num_isNaN,           1,0),
267      JS_FN(js_isFinite_str,      num_isFinite,        1,0),      JS_FN(js_isFinite_str,      num_isFinite,        1,0),
268      JS_TN(js_parseFloat_str,    num_parseFloat,      1,0, num_parseFloat_trcinfo),      JS_TN(js_parseFloat_str,    num_parseFloat,      1,0, &num_parseFloat_trcinfo),
269      JS_TN(js_parseInt_str,      num_parseInt,        2,0, num_parseInt_trcinfo),      JS_TN(js_parseInt_str,      num_parseInt,        2,0, &num_parseInt_trcinfo),
270      JS_FS_END      JS_FS_END
271  };  };
272    
273  JSClass js_NumberClass = {  JSClass js_NumberClass = {
274      js_Number_str,      js_Number_str,
275      JSCLASS_HAS_PRIVATE | JSCLASS_HAS_CACHED_PROTO(JSProto_Number),      JSCLASS_HAS_RESERVED_SLOTS(1) | JSCLASS_HAS_CACHED_PROTO(JSProto_Number),
276      JS_PropertyStub,  JS_PropertyStub,  JS_PropertyStub,  JS_PropertyStub,      JS_PropertyStub,  JS_PropertyStub,  JS_PropertyStub,  JS_PropertyStub,
277      JS_EnumerateStub, JS_ResolveStub,   JS_ConvertStub,   JS_FinalizeStub,      JS_EnumerateStub, JS_ResolveStub,   JS_ConvertStub,   NULL,
278      JSCLASS_NO_OPTIONAL_MEMBERS      JSCLASS_NO_OPTIONAL_MEMBERS
279  };  };
280    
# Line 266  Line 299 
299      } else {      } else {
300          v = JSVAL_ZERO;          v = JSVAL_ZERO;
301      }      }
302      if (!JS_IsConstructing(cx)) {      if (!JS_IsConstructing(cx))
303          *rval = v;          *rval = v;
304          return JS_TRUE;      else
305      }          obj->fslots[JSSLOT_PRIMITIVE_THIS] = v;
306      STOBJ_SET_SLOT(obj, JSSLOT_PRIVATE, v);      return true;
     return JS_TRUE;  
307  }  }
308    
309  #if JS_HAS_TOSOURCE  #if JS_HAS_TOSOURCE
# Line 383  Line 415 
415              return JS_FALSE;              return JS_FALSE;
416          }          }
417          str = JS_NewStringCopyZ(cx, dStr);          str = JS_NewStringCopyZ(cx, dStr);
418          free(dStr);          js_free(dStr);
419      }      }
420      if (!str)      if (!str)
421          return JS_FALSE;          return JS_FALSE;
# Line 459  Line 491 
491      }      }
492      tmpGroup--;      tmpGroup--;
493    
494      buf = (char *)JS_malloc(cx, size + 1);      buf = (char *)cx->malloc(size + 1);
495      if (!buf)      if (!buf)
496          return JS_FALSE;          return JS_FALSE;
497    
# Line 491  Line 523 
523    
524      str = JS_NewString(cx, buf, size);      str = JS_NewString(cx, buf, size);
525      if (!str) {      if (!str) {
526          JS_free(cx, buf);          cx->free(buf);
527          return JS_FALSE;          return JS_FALSE;
528      }      }
529    
# Line 513  Line 545 
545      obj = JS_THIS_OBJECT(cx, vp);      obj = JS_THIS_OBJECT(cx, vp);
546      if (!JS_InstanceOf(cx, obj, &js_NumberClass, vp + 2))      if (!JS_InstanceOf(cx, obj, &js_NumberClass, vp + 2))
547          return JS_FALSE;          return JS_FALSE;
548      *vp = OBJ_GET_SLOT(cx, obj, JSSLOT_PRIVATE);      *vp = obj->fslots[JSSLOT_PRIMITIVE_THIS];
549      return JS_TRUE;      return JS_TRUE;
550  }  }
551    
# Line 597  Line 629 
629    
630  #ifdef JS_TRACER  #ifdef JS_TRACER
631    
632  JS_DEFINE_TRCINFO_2(num_toString,  JS_DEFINE_TRCINFO_1(num_toString,
633      (3, (static, STRING, NumberToStringWithBase, CONTEXT, THIS_DOUBLE, INT32, 1, 1)),      (2, (extern, STRING_RETRY, js_NumberToString,      CONTEXT, THIS_DOUBLE,        1, 1)))
     (2, (extern, STRING, js_NumberToString,      CONTEXT, THIS_DOUBLE,        1, 1)))  
634    
635  #endif /* JS_TRACER */  #endif /* JS_TRACER */
636    
# Line 607  Line 638 
638  #if JS_HAS_TOSOURCE  #if JS_HAS_TOSOURCE
639      JS_FN(js_toSource_str,       num_toSource,          0,JSFUN_THISP_NUMBER),      JS_FN(js_toSource_str,       num_toSource,          0,JSFUN_THISP_NUMBER),
640  #endif  #endif
641      JS_TN(js_toString_str,       num_toString,          1,JSFUN_THISP_NUMBER,      JS_TN(js_toString_str,       num_toString,          1,JSFUN_THISP_NUMBER, &num_toString_trcinfo),
           num_toString_trcinfo),  
642      JS_FN(js_toLocaleString_str, num_toLocaleString,    0,JSFUN_THISP_NUMBER),      JS_FN(js_toLocaleString_str, num_toLocaleString,    0,JSFUN_THISP_NUMBER),
643      JS_FN(js_valueOf_str,        num_valueOf,           0,JSFUN_THISP_NUMBER),      JS_FN(js_valueOf_str,        num_valueOf,           0,JSFUN_THISP_NUMBER),
644      JS_FN(js_toJSON_str,         num_valueOf,           0,JSFUN_THISP_NUMBER),      JS_FN(js_toJSON_str,         num_valueOf,           0,JSFUN_THISP_NUMBER),
# Line 644  Line 674 
674    
675  jsdouble js_NaN;  jsdouble js_NaN;
676    
677  #if (defined XP_WIN || defined XP_OS2) &&                                     \  
678      !defined WINCE &&                                                         \  #if (defined __GNUC__ && defined __i386__)
     !defined __MWERKS__ &&                                                    \  
     (defined _M_IX86 ||                                                       \  
      (defined __GNUC__ && !defined __MINGW32__))  
679    
680  /*  /*
681   * Set the exception mask to mask all exceptions and set the FPU precision   * Set the exception mask to mask all exceptions and set the FPU precision
682   * to 53 bit mantissa.   * to 53 bit mantissa (64 bit doubles).
  * On Alpha platform this is handled via Compiler option.  
683   */   */
684  #define FIX_FPU() _control87(MCW_EM | PC_53, MCW_EM | MCW_PC)  inline void FIX_FPU() {
685        short control;
686        asm("fstcw %0" : "=m" (control) : );
687        control &= ~0x300; // Lower bits 8 and 9 (precision control).
688        control |= 0x2f3;  // Raise bits 0-5 (exception masks) and 9 (64-bit precision).
689        asm("fldcw %0" : : "m" (control) );
690    }
691    
692  #else  #else
693    
# Line 730  Line 762 
762  {  {
763      JSRuntime *rt = cx->runtime;      JSRuntime *rt = cx->runtime;
764    
     js_UnlockGCThingRT(rt, rt->jsNaN);  
     js_UnlockGCThingRT(rt, rt->jsNegativeInfinity);  
     js_UnlockGCThingRT(rt, rt->jsPositiveInfinity);  
   
765      rt->jsNaN = NULL;      rt->jsNaN = NULL;
766      rt->jsNegativeInfinity = NULL;      rt->jsNegativeInfinity = NULL;
767      rt->jsPositiveInfinity = NULL;      rt->jsPositiveInfinity = NULL;
768    
769      JS_free(cx, (void *)rt->thousandsSeparator);      cx->free((void *)rt->thousandsSeparator);
770      JS_free(cx, (void *)rt->decimalSeparator);      cx->free((void *)rt->decimalSeparator);
771      JS_free(cx, (void *)rt->numGrouping);      cx->free((void *)rt->numGrouping);
772      rt->thousandsSeparator = rt->decimalSeparator = rt->numGrouping = NULL;      rt->thousandsSeparator = rt->decimalSeparator = rt->numGrouping = NULL;
773  }  }
774    
# Line 760  Line 788 
788                           NULL, number_methods, NULL, NULL);                           NULL, number_methods, NULL, NULL);
789      if (!proto || !(ctor = JS_GetConstructor(cx, proto)))      if (!proto || !(ctor = JS_GetConstructor(cx, proto)))
790          return NULL;          return NULL;
791      STOBJ_SET_SLOT(proto, JSSLOT_PRIVATE, JSVAL_ZERO);      proto->fslots[JSSLOT_PRIMITIVE_THIS] = JSVAL_ZERO;
792      if (!JS_DefineConstDoubles(cx, ctor, number_constants))      if (!JS_DefineConstDoubles(cx, ctor, number_constants))
793          return NULL;          return NULL;
794    
# Line 831  Line 859 
859      return numStr;      return numStr;
860  }  }
861    
862  static JSString * JS_FASTCALL  static JSString *
863  NumberToStringWithBase(JSContext *cx, jsdouble d, jsint base)  NumberToStringWithBase(JSContext *cx, jsdouble d, jsint base)
864  {  {
865      /*      /*
# Line 851  Line 879 
879          return NULL;          return NULL;
880      s = JS_NewStringCopyZ(cx, numStr);      s = JS_NewStringCopyZ(cx, numStr);
881      if (!(numStr >= buf && numStr < buf + sizeof buf))      if (!(numStr >= buf && numStr < buf + sizeof buf))
882          free(numStr);          js_free(numStr);
883      return s;      return s;
884  }  }
885    
886  JSString * JS_FASTCALL  JSString * JS_FASTCALL
887  js_NumberToString(JSContext *cx, jsdouble d)  js_NumberToString(JSContext *cx, jsdouble d)
888  {  {
889        jsint i;
890    
891        if (JSDOUBLE_IS_INT(d, i) && jsuint(i) < INT_STRING_LIMIT)
892            return JSString::intString(i);
893      return NumberToStringWithBase(cx, d, 10);      return NumberToStringWithBase(cx, d, 10);
894  }  }
895    
896    JSBool JS_FASTCALL
897    js_NumberValueToCharBuffer(JSContext *cx, jsval v, JSCharBuffer &cb)
898    {
899        /* Convert to C-string. */
900        static const size_t arrSize = DTOSTR_STANDARD_BUFFER_SIZE;
901        char arr[arrSize];
902        const char *cstr;
903        if (JSVAL_IS_INT(v)) {
904            cstr = IntToCString(JSVAL_TO_INT(v), 10, arr, arrSize);
905        } else {
906            JS_ASSERT(JSVAL_IS_DOUBLE(v));
907            cstr = JS_dtostr(arr, arrSize, DTOSTR_STANDARD, 0, *JSVAL_TO_DOUBLE(v));
908        }
909        if (!cstr)
910            return JS_FALSE;
911    
912        /*
913         * Inflate to jschar string.  The input C-string characters are < 127, so
914         * even if jschars are UTF-8, all chars should map to one jschar.
915         */
916        size_t cstrlen = strlen(cstr);
917        JS_ASSERT(cstrlen < arrSize);
918        size_t sizeBefore = cb.length();
919        if (!cb.growBy(cstrlen))
920            return JS_FALSE;
921        jschar *appendBegin = cb.begin() + sizeBefore;
922    #ifdef DEBUG
923        size_t oldcstrlen = cstrlen;
924        JSBool ok =
925    #endif
926            js_InflateStringToBuffer(cx, cstr, cstrlen, appendBegin, &cstrlen);
927        JS_ASSERT(ok && cstrlen == oldcstrlen);
928        return JS_TRUE;
929    }
930    
931  jsdouble  jsdouble
932  js_ValueToNumber(JSContext *cx, jsval *vp)  js_ValueToNumber(JSContext *cx, jsval *vp)
933  {  {
# Line 869  Line 936 
936      const jschar *bp, *end, *ep;      const jschar *bp, *end, *ep;
937      jsdouble d, *dp;      jsdouble d, *dp;
938      JSObject *obj;      JSObject *obj;
     JSTempValueRooter tvr;  
939    
940      v = *vp;      v = *vp;
941      for (;;) {      for (;;) {
# Line 887  Line 953 
953               * passed to js_strtointeger (which would interpret them as               * passed to js_strtointeger (which would interpret them as
954               * octal).               * octal).
955               */               */
956              JSSTRING_CHARS_AND_END(str, bp, end);              str->getCharsAndEnd(bp, end);
957    
958                /* ECMA doesn't allow signed hex numbers (bug 273467). */
959                bp = js_SkipWhiteSpace(bp, end);
960                if (bp + 2 < end && (*bp == '-' || *bp == '+') &&
961                    bp[1] == '0' && (bp[2] == 'X' || bp[2] == 'x')) {
962                    break;
963                }
964    
965              if ((!js_strtod(cx, bp, end, &ep, &d) ||              if ((!js_strtod(cx, bp, end, &ep, &d) ||
966                   js_SkipWhiteSpace(ep, end) != end) &&                   js_SkipWhiteSpace(ep, end) != end) &&
967                  (!js_strtointeger(cx, bp, end, &ep, 0, &d) ||                  (!js_strtointeger(cx, bp, end, &ep, 0, &d) ||
# Line 923  Line 997 
997    
998          /*          /*
999           * vp roots obj so we cannot use it as an extra root for           * vp roots obj so we cannot use it as an extra root for
1000           * OBJ_DEFAULT_VALUE result when calling the hook.           * obj->defaultValue result when calling the hook.
1001           */           */
1002          JS_PUSH_SINGLE_TEMP_ROOT(cx, v, &tvr);          JSAutoTempValueRooter tvr(cx, v);
1003          if (!OBJ_DEFAULT_VALUE(cx, obj, JSTYPE_NUMBER, &tvr.u.value))          if (!obj->defaultValue(cx, JSTYPE_NUMBER, tvr.addr()))
1004              obj = NULL;              obj = NULL;
1005          else          else
1006              v = *vp = tvr.u.value;              v = *vp = tvr.value();
         JS_POP_TEMP_ROOT(cx, &tvr);  
1007          if (!obj) {          if (!obj) {
1008              *vp = JSVAL_NULL;              *vp = JSVAL_NULL;
1009              return 0.0;              return 0.0;
# Line 965  Line 1038 
1038      return js_DoubleToECMAInt32(d);      return js_DoubleToECMAInt32(d);
1039  }  }
1040    
 int32  
 js_DoubleToECMAInt32(jsdouble d)  
 {  
     int32 i;  
     jsdouble two32, two31;  
   
     if (!JSDOUBLE_IS_FINITE(d))  
         return 0;  
   
     i = (int32) d;  
     if ((jsdouble) i == d)  
         return i;  
   
     two32 = 4294967296.0;  
     two31 = 2147483648.0;  
     d = fmod(d, two32);  
     d = (d >= 0) ? floor(d) : ceil(d) + two32;  
     return (int32) (d >= two31 ? d - two32 : d);  
 }  
   
1041  uint32  uint32
1042  js_ValueToECMAUint32(JSContext *cx, jsval *vp)  js_ValueToECMAUint32(JSContext *cx, jsval *vp)
1043  {  {
# Line 1098  Line 1151 
1151      return u;      return u;
1152  }  }
1153    
 jsdouble  
 js_DoubleToInteger(jsdouble d)  
 {  
     JSBool neg;  
   
     if (d == 0)  
         return d;  
     if (!JSDOUBLE_IS_FINITE(d)) {  
         if (JSDOUBLE_IS_NaN(d))  
             return 0;  
         return d;  
     }  
     neg = (d < 0);  
     d = floor(neg ? -d : d);  
     return neg ? -d : d;  
 }  
   
1154  JSBool  JSBool
1155  js_strtod(JSContext *cx, const jschar *s, const jschar *send,  js_strtod(JSContext *cx, const jschar *s, const jschar *send,
1156            const jschar **ep, jsdouble *dp)            const jschar **ep, jsdouble *dp)
# Line 1131  Line 1167 
1167    
1168      /* Use cbuf to avoid malloc */      /* Use cbuf to avoid malloc */
1169      if (length >= sizeof cbuf) {      if (length >= sizeof cbuf) {
1170          cstr = (char *) JS_malloc(cx, length + 1);          cstr = (char *) cx->malloc(length + 1);
1171          if (!cstr)          if (!cstr)
1172             return JS_FALSE;             return JS_FALSE;
1173      } else {      } else {
# Line 1148  Line 1184 
1184      istr = cstr;      istr = cstr;
1185      if ((negative = (*istr == '-')) != 0 || *istr == '+')      if ((negative = (*istr == '-')) != 0 || *istr == '+')
1186          istr++;          istr++;
1187      if (!strncmp(istr, js_Infinity_str, sizeof js_Infinity_str - 1)) {      if (*istr == 'I' && !strncmp(istr, js_Infinity_str, sizeof js_Infinity_str - 1)) {
1188          d = *(negative ? cx->runtime->jsNegativeInfinity : cx->runtime->jsPositiveInfinity);          d = *(negative ? cx->runtime->jsNegativeInfinity : cx->runtime->jsPositiveInfinity);
1189          estr = istr + 8;          estr = istr + 8;
1190      } else {      } else {
# Line 1158  Line 1194 
1194              d = *cx->runtime->jsPositiveInfinity;              d = *cx->runtime->jsPositiveInfinity;
1195          else if (d == -HUGE_VAL)          else if (d == -HUGE_VAL)
1196              d = *cx->runtime->jsNegativeInfinity;              d = *cx->runtime->jsNegativeInfinity;
 #ifdef HPUX  
         if (d == 0.0 && negative) {  
             /*  
              * "-0", "-1e-2000" come out as positive zero  
              * here on HPUX. Force a negative zero instead.  
              */  
             JSDOUBLE_HI32(d) = JSDOUBLE_HI32_SIGNBIT;  
             JSDOUBLE_LO32(d) = 0;  
         }  
 #endif  
1197      }      }
1198    
1199      i = estr - cstr;      i = estr - cstr;
1200      if (cstr != cbuf)      if (cstr != cbuf)
1201          JS_free(cx, cstr);          cx->free(cstr);
1202      *ep = i ? s1 + i : s;      *ep = i ? s1 + i : s;
1203      *dp = d;      *dp = d;
1204      return JS_TRUE;      return JS_TRUE;
# Line 1203  Line 1229 
1229              bdr->digit = c - '0';              bdr->digit = c - '0';
1230          else if ('a' <= c && c <= 'z')          else if ('a' <= c && c <= 'z')
1231              bdr->digit = c - 'a' + 10;              bdr->digit = c - 'a' + 10;
1232          else bdr->digit = c - 'A' + 10;          else
1233                bdr->digit = c - 'A' + 10;
1234          bdr->digitMask = bdr->base >> 1;          bdr->digitMask = bdr->base >> 1;
1235      }      }
1236      bit = (bdr->digit & bdr->digitMask) != 0;      bit = (bdr->digit & bdr->digitMask) != 0;
# Line 1284  Line 1311 
1311               */               */
1312              size_t i;              size_t i;
1313              size_t length = s1 - start;              size_t length = s1 - start;
1314              char *cstr = (char *) JS_malloc(cx, length + 1);              char *cstr = (char *) cx->malloc(length + 1);
1315              char *estr;              char *estr;
1316              int err=0;              int err=0;
1317    
# Line 1297  Line 1324 
1324              value = JS_strtod(cstr, &estr, &err);              value = JS_strtod(cstr, &estr, &err);
1325              if (err == JS_DTOA_ENOMEM) {              if (err == JS_DTOA_ENOMEM) {
1326                  JS_ReportOutOfMemory(cx);                  JS_ReportOutOfMemory(cx);
1327                  JS_free(cx, cstr);                  cx->free(cstr);
1328                  return JS_FALSE;                  return JS_FALSE;
1329              }              }
1330              if (err == JS_DTOA_ERANGE && value == HUGE_VAL)              if (err == JS_DTOA_ERANGE && value == HUGE_VAL)
1331                  value = *cx->runtime->jsPositiveInfinity;                  value = *cx->runtime->jsPositiveInfinity;
1332              JS_free(cx, cstr);              cx->free(cstr);
1333          } else if ((base & (base - 1)) == 0) {          } else if ((base & (base - 1)) == 0) {
1334              /*              /*
1335               * The number may also be inaccurate for power-of-two bases.  This               * The number may also be inaccurate for power-of-two bases.  This

Legend:
Removed from v.506  
changed lines
  Added in v.507

  ViewVC Help
Powered by ViewVC 1.1.24