Fix bugs related to setting reflected floating point DOM attributes
[WebKit-https.git] / Source / WTF / wtf / dtoa / utils.h
1 // Copyright 2010 the V8 project authors. All rights reserved.
2 // Redistribution and use in source and binary forms, with or without
3 // modification, are permitted provided that the following conditions are
4 // met:
5 //
6 //     * Redistributions of source code must retain the above copyright
7 //       notice, this list of conditions and the following disclaimer.
8 //     * Redistributions in binary form must reproduce the above
9 //       copyright notice, this list of conditions and the following
10 //       disclaimer in the documentation and/or other materials provided
11 //       with the distribution.
12 //     * Neither the name of Google Inc. nor the names of its
13 //       contributors may be used to endorse or promote products derived
14 //       from this software without specific prior written permission.
15 //
16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
28 #ifndef DOUBLE_CONVERSION_UTILS_H_
29 #define DOUBLE_CONVERSION_UTILS_H_
30
31 #include <wtf/Assertions.h>
32 #include <stdlib.h>
33 #include <string.h>
34
35 #define UNIMPLEMENTED ASSERT_NOT_REACHED
36 #define UNREACHABLE ASSERT_NOT_REACHED
37
38 // Double operations detection based on target architecture.
39 // Linux uses a 80bit wide floating point stack on x86. This induces double
40 // rounding, which in turn leads to wrong results.
41 // An easy way to test if the floating-point operations are correct is to
42 // evaluate: 89255.0/1e22. If the floating-point stack is 64 bits wide then
43 // the result is equal to 89255e-22.
44 // The best way to test this, is to create a division-function and to compare
45 // the output of the division with the expected result. (Inlining must be
46 // disabled.)
47 // On Linux,x86 89255e-22 != Div_double(89255.0/1e22)
48 #if defined(_M_X64) || defined(__x86_64__) || \
49 defined(__ARMEL__) || \
50 defined(_MIPS_ARCH_MIPS32R2)
51 #define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1
52 #elif CPU(MIPS) || CPU(MIPS64) || CPU(PPC) || CPU(PPC64) || CPU(PPC64LE) || CPU(SH4) || CPU(S390) || CPU(S390X) || CPU(IA64) || CPU(ALPHA) || CPU(ARM64) || CPU(HPPA)
53 #define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1
54 #elif defined(_M_IX86) || defined(__i386__)
55 #if defined(_WIN32)
56 // Windows uses a 64bit wide floating point stack.
57 #define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1
58 #else
59 #undef DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS
60 #endif  // _WIN32
61 #else
62 #error Target architecture was not detected as supported by Double-Conversion.
63 #endif
64
65
66 #if defined(_WIN32) && !defined(__MINGW32__)
67
68 typedef signed char int8_t;
69 typedef unsigned char uint8_t;
70 typedef short int16_t;  // NOLINT
71 typedef unsigned short uint16_t;  // NOLINT
72 typedef int int32_t;
73 typedef unsigned int uint32_t;
74 typedef __int64 int64_t;
75 typedef unsigned __int64 uint64_t;
76 // intptr_t and friends are defined in crtdefs.h through stdio.h.
77
78 #else
79
80 #include <stdint.h>
81
82 #endif
83
84 // The following macro works on both 32 and 64-bit platforms.
85 // Usage: instead of writing 0x1234567890123456
86 //      write UINT64_2PART_C(0x12345678,90123456);
87 #define UINT64_2PART_C(a, b) (((static_cast<uint64_t>(a) << 32) + 0x##b##u))
88
89
90 // The expression ARRAY_SIZE(a) is a compile-time constant of type
91 // size_t which represents the number of elements of the given
92 // array. You should only use ARRAY_SIZE on statically allocated
93 // arrays.
94 #define ARRAY_SIZE(a)                                   \
95 ((sizeof(a) / sizeof(*(a))) /                         \
96 static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))))
97
98 // A macro to disallow the evil copy constructor and operator= functions
99 // This should be used in the private: declarations for a class
100 #define DISALLOW_COPY_AND_ASSIGN(TypeName)      \
101 TypeName(const TypeName&);                    \
102 void operator=(const TypeName&)
103
104 // A macro to disallow all the implicit constructors, namely the
105 // default constructor, copy constructor and operator= functions.
106 //
107 // This should be used in the private: declarations for a class
108 // that wants to prevent anyone from instantiating it. This is
109 // especially useful for classes containing only static methods.
110 #define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
111 TypeName();                                    \
112 DISALLOW_COPY_AND_ASSIGN(TypeName)
113
114 namespace WTF {
115
116 namespace double_conversion {
117     
118     static const int kCharSize = sizeof(char);
119     
120     // Returns the maximum of the two parameters.
121     template <typename T>
122     static T Max(T a, T b) {
123         return a < b ? b : a;
124     }
125     
126     
127     // Returns the minimum of the two parameters.
128     template <typename T>
129     static T Min(T a, T b) {
130         return a < b ? a : b;
131     }
132     
133     
134     inline int StrLength(const char* string) {
135         size_t length = strlen(string);
136         ASSERT(length == static_cast<size_t>(static_cast<int>(length)));
137         return static_cast<int>(length);
138     }
139
140     // BufferReference abstract a memory buffer. It provides a pointer
141     // to the beginning of the buffer, and the available length. 
142     template <typename T>
143     class BufferReference {
144     public:
145         BufferReference() : start_(NULL), length_(0) {}
146         BufferReference(T* data, int length) : start_(data), length_(length) {
147             ASSERT(length == 0 || (length > 0 && data != NULL));
148         }
149         
150         // Returns a vector using the same backing storage as this one,
151         // spanning from and including 'from', to but not including 'to'.
152         BufferReference<T> SubBufferReference(int from, int to) {
153             ASSERT(to <= length_);
154             ASSERT_WITH_SECURITY_IMPLICATION(from < to);
155             ASSERT(0 <= from);
156             return BufferReference<T>(start() + from, to - from);
157         }
158         
159         // Returns the length of the vector.
160         int length() const { return length_; }
161         
162         // Returns whether or not the vector is empty.
163         bool is_empty() const { return length_ == 0; }
164         
165         // Returns the pointer to the start of the data in the vector.
166         T* start() const { return start_; }
167         
168         // Access individual vector elements - checks bounds in debug mode.
169         T& operator[](int index) const {
170             ASSERT(0 <= index && index < length_);
171             return start_[index];
172         }
173         
174         T& first() { return start_[0]; }
175         
176         T& last() { return start_[length_ - 1]; }
177         
178     private:
179         T* start_;
180         int length_;
181     };
182     
183     
184     // Helper class for building result strings in a character buffer. The
185     // purpose of the class is to use safe operations that checks the
186     // buffer bounds on all operations in debug mode.
187     class StringBuilder {
188     public:
189         StringBuilder(char* buffer, int size)
190         : buffer_(buffer, size), position_(0) { }
191         
192         ~StringBuilder() { if (!is_finalized()) Finalize(); }
193         
194         int size() const { return buffer_.length(); }
195         
196         // Get the current position in the builder.
197         int position() const {
198             ASSERT(!is_finalized());
199             return position_;
200         }
201          
202         // Set the current position in the builder.
203         void SetPosition(int position)
204         {
205             ASSERT(!is_finalized());
206             ASSERT_WITH_SECURITY_IMPLICATION(position < size());
207             position_ = position;
208         }
209         
210         // Reset the position.
211         void Reset() { position_ = 0; }
212         
213         // Add a single character to the builder. It is not allowed to add
214         // 0-characters; use the Finalize() method to terminate the string
215         // instead.
216         void AddCharacter(char c) {
217             ASSERT(c != '\0');
218             ASSERT(!is_finalized() && position_ < buffer_.length());
219             buffer_[position_++] = c;
220         }
221         
222         // Add an entire string to the builder. Uses strlen() internally to
223         // compute the length of the input string.
224         void AddString(const char* s) {
225             AddSubstring(s, StrLength(s));
226         }
227         
228         // Add the first 'n' characters of the given string 's' to the
229         // builder. The input string must have enough characters.
230         void AddSubstring(const char* s, int n) {
231             ASSERT(!is_finalized() && position_ + n < buffer_.length());
232             ASSERT_WITH_SECURITY_IMPLICATION(static_cast<size_t>(n) <= strlen(s));
233             memcpy(&buffer_[position_], s, n * kCharSize);
234             position_ += n;
235         }
236         
237         
238         // Add character padding to the builder. If count is non-positive,
239         // nothing is added to the builder.
240         void AddPadding(char c, int count) {
241             for (int i = 0; i < count; i++) {
242                 AddCharacter(c);
243             }
244         }
245         
246         void RemoveCharacters(int start, int end)
247         {
248             ASSERT(start >= 0);
249             ASSERT(end >= 0);
250             ASSERT(start <= end);
251             ASSERT(end <= position_);
252             std::memmove(&buffer_[start], &buffer_[end], position_ - end);
253             position_ -= end - start;
254         }
255
256         // Finalize the string by 0-terminating it and returning the buffer.
257         char* Finalize() {
258             ASSERT(!is_finalized() && position_ < buffer_.length());
259             buffer_[position_] = '\0';
260             // Make sure nobody managed to add a 0-character to the
261             // buffer while building the string.
262             ASSERT(strlen(buffer_.start()) == static_cast<size_t>(position_));
263             position_ = -1;
264             ASSERT(is_finalized());
265             return buffer_.start();
266         }
267         
268     private:
269         BufferReference<char> buffer_;
270         int position_;
271         
272         bool is_finalized() const { return position_ < 0; }
273         
274         DISALLOW_IMPLICIT_CONSTRUCTORS(StringBuilder);
275     };
276     
277     // The type-based aliasing rule allows the compiler to assume that pointers of
278     // different types (for some definition of different) never alias each other.
279     // Thus the following code does not work:
280     //
281     // float f = foo();
282     // int fbits = *(int*)(&f);
283     //
284     // The compiler 'knows' that the int pointer can't refer to f since the types
285     // don't match, so the compiler may cache f in a register, leaving random data
286     // in fbits.  Using C++ style casts makes no difference, however a pointer to
287     // char data is assumed to alias any other pointer.  This is the 'memcpy
288     // exception'.
289     //
290     // Bit_cast uses the memcpy exception to move the bits from a variable of one
291     // type of a variable of another type.  Of course the end result is likely to
292     // be implementation dependent.  Most compilers (gcc-4.2 and MSVC 2005)
293     // will completely optimize BitCast away.
294     //
295     // There is an additional use for BitCast.
296     // Recent gccs will warn when they see casts that may result in breakage due to
297     // the type-based aliasing rule.  If you have checked that there is no breakage
298     // you can use BitCast to cast one pointer type to another.  This confuses gcc
299     // enough that it can no longer see that you have cast one pointer type to
300     // another thus avoiding the warning.
301     template <class Dest, class Source>
302     inline Dest BitCast(const Source& source) {
303         // Compile time assertion: sizeof(Dest) == sizeof(Source)
304         // A compile error here means your Dest and Source have different sizes.
305         static_assert(sizeof(Dest) == sizeof(Source), "Source and destination sizes must be equal");
306         
307         Dest dest;
308         memcpy(&dest, &source, sizeof(dest));
309         return dest;
310     }
311     
312     template <class Dest, class Source>
313     inline Dest BitCast(Source* source) {
314         return BitCast<Dest>(reinterpret_cast<uintptr_t>(source));
315     }
316     
317 }  // namespace double_conversion
318
319 } // namespace WTF
320
321 #endif  // DOUBLE_CONVERSION_UTILS_H_