[webkit-changes] cvs commit: JavaScriptCore/kjs simple_number.h

[Geoffrey]

ggaren      05/10/14 14:03:56

  Modified:    .        ChangeLog
               kjs      simple_number.h
  Log:
          Style changes recommended by Darin.
  
          Changed to camelCase, changed ValueImp* to ValueImp *.
  
          * kjs/simple_number.h:
          (KJS::SimpleNumber::make):
          (KJS::SimpleNumber::value):
  
  Revision  Changes    Path
  1.865     +10 -0     JavaScriptCore/ChangeLog
  
  Index: ChangeLog
  ===================================================================
  RCS file: /cvs/root/JavaScriptCore/ChangeLog,v
  retrieving revision 1.864
  retrieving revision 1.865
  diff -u -r1.864 -r1.865
  --- ChangeLog	11 Oct 2005 22:26:35 -0000	1.864
  +++ ChangeLog	14 Oct 2005 21:03:53 -0000	1.865
  @@ -1,3 +1,13 @@
  +2005-10-14  Geoffrey Garen  <ggaren at apple.com>
  +
  +        Style changes recommended by Darin.
  +        
  +        Changed to camelCase, changed ValueImp* to ValueImp *.
  +
  +        * kjs/simple_number.h:
  +        (KJS::SimpleNumber::make):
  +        (KJS::SimpleNumber::value):
  +
   2005-10-11  Geoffrey Garen  <ggaren at apple.com>
   
           Added regexp_object.lut.h build phase from JavaScriptCore
  
  
  
  1.20      +19 -19    JavaScriptCore/kjs/simple_number.h
  
  Index: simple_number.h
  ===================================================================
  RCS file: /cvs/root/JavaScriptCore/kjs/simple_number.h,v
  retrieving revision 1.19
  retrieving revision 1.20
  diff -u -r1.19 -r1.20
  --- simple_number.h	6 Oct 2005 01:13:18 -0000	1.19
  +++ simple_number.h	14 Oct 2005 21:03:56 -0000	1.20
  @@ -58,41 +58,41 @@
           {
               if (sizeof(float) == sizeof(unsigned long) &&
                   sizeof(double) == sizeof(unsigned long long) &&
  -                sizeof(ValueImp*) >= sizeof(unsigned long)) {
  +                sizeof(ValueImp *) >= sizeof(unsigned long)) {
                   // 32-bit
                   union {
                       unsigned long asBits;
                       float         asFloat;
  -                } floatunion;
  -                floatunion.asFloat = d;
  +                } floatUnion;
  +                floatUnion.asFloat = d;
                   
  -                if ((floatunion.asBits & tagMask) != 0)
  +                if ((floatUnion.asBits & tagMask) != 0)
                     return 0;
                   
                   // Check for loss in conversion to float
                   union {
                       unsigned long long asBits;
                       double             asDouble;
  -                } doubleunion1, doubleunion2;
  -                doubleunion1.asDouble = floatunion.asFloat;
  -                doubleunion2.asDouble = d;
  -                if (doubleunion1.asBits != doubleunion2.asBits)
  +                } doubleUnion1, doubleUnion2;
  +                doubleUnion1.asDouble = floatUnion.asFloat;
  +                doubleUnion2.asDouble = d;
  +                if (doubleUnion1.asBits != doubleUnion2.asBits)
                       return 0;
                   
  -                return reinterpret_cast<ValueImp *>(floatunion.asBits | tag);
  +                return reinterpret_cast<ValueImp *>(floatUnion.asBits | tag);
               } else if (sizeof(double) == sizeof(unsigned long) &&
                          sizeof(ValueImp*) >= sizeof(unsigned long)) {
                   // 64-bit
                   union {
                       unsigned long asBits;
                       double        asDouble;
  -                } doubleunion;
  -                doubleunion.asDouble = d;
  +                } doubleUnion;
  +                doubleUnion.asDouble = d;
                   
  -                if ((doubleunion.asBits & tagMask) != 0)
  +                if ((doubleUnion.asBits & tagMask) != 0)
                       return 0;
   
  -                return reinterpret_cast<ValueImp *>(doubleunion.asBits | tag);
  +                return reinterpret_cast<ValueImp *>(doubleUnion.asBits | tag);
               } else {
                   // could just return 0 here, but nicer to be explicit about not supporting the platform well
                   abort();
  @@ -114,17 +114,17 @@
                   union {
                       unsigned long asBits;
                       float         asFloat;
  -                } floatunion;
  -                floatunion.asBits = reinterpret_cast<unsigned long>(imp) & ~tagMask;
  -                return floatunion.asFloat;
  +                } floatUnion;
  +                floatUnion.asBits = reinterpret_cast<unsigned long>(imp) & ~tagMask;
  +                return floatUnion.asFloat;
               } else if (sizeof(double) == sizeof(unsigned long)) {
                   // 64-bit
                   union {
                       unsigned long asBits;
                       double        asDouble;
  -                } doubleunion;
  -                doubleunion.asBits = reinterpret_cast<unsigned long>(imp) & ~tagMask;
  -                return doubleunion.asDouble;
  +                } doubleUnion;
  +                doubleUnion.asBits = reinterpret_cast<unsigned long>(imp) & ~tagMask;
  +                return doubleUnion.asDouble;
               } else {
                   // could just return 0 here, but nicer to be explicit about not supporting the platform well
                   abort();