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 <cstdlib>
32#include <cstring>
33
34#include <cassert>
35#ifndef ASSERT
36#define ASSERT(condition) \
37 assert(condition);
38#endif
39#ifndef UNIMPLEMENTED
40#define UNIMPLEMENTED() (abort())
41#endif
42#ifndef DOUBLE_CONVERSION_NO_RETURN
43#ifdef _MSC_VER
44#define DOUBLE_CONVERSION_NO_RETURN __declspec(noreturn)
45#else
46#define DOUBLE_CONVERSION_NO_RETURN __attribute__((noreturn))
47#endif
48#endif
49#ifndef UNREACHABLE
50#ifdef _MSC_VER
51void DOUBLE_CONVERSION_NO_RETURN abort_noreturn();
52inline void abort_noreturn() { abort(); }
53#define UNREACHABLE() (abort_noreturn())
54#else
55#define UNREACHABLE() (abort())
56#endif
57#endif
58
59#ifndef DOUBLE_CONVERSION_UNUSED
60#ifdef __GNUC__
61#define DOUBLE_CONVERSION_UNUSED __attribute__((unused))
62#else
63#define DOUBLE_CONVERSION_UNUSED
64#endif
65#endif
66
67// Double operations detection based on target architecture.
68// Linux uses a 80bit wide floating point stack on x86. This induces double
69// rounding, which in turn leads to wrong results.
70// An easy way to test if the floating-point operations are correct is to
71// evaluate: 89255.0/1e22. If the floating-point stack is 64 bits wide then
72// the result is equal to 89255e-22.
73// The best way to test this, is to create a division-function and to compare
74// the output of the division with the expected result. (Inlining must be
75// disabled.)
76// On Linux,x86 89255e-22 != Div_double(89255.0/1e22)
77//
78// For example:
79/*
80// -- in div.c
81double Div_double(double x, double y) { return x / y; }
82
83// -- in main.c
84double Div_double(double x, double y); // Forward declaration.
85
86int main(int argc, char** argv) {
87 return Div_double(89255.0, 1e22) == 89255e-22;
88}
89*/
90// Run as follows ./main || echo "correct"
91//
92// If it prints "correct" then the architecture should be here, in the "correct" section.
93#if defined(_M_X64) || defined(__x86_64__) || \
94 defined(__ARMEL__) || defined(__avr32__) || defined(_M_ARM) || defined(_M_ARM64) || \
95 defined(__hppa__) || defined(__ia64__) || \
96 defined(__mips__) || \
97 defined(__powerpc__) || defined(__ppc__) || defined(__ppc64__) || \
98 defined(_POWER) || defined(_ARCH_PPC) || defined(_ARCH_PPC64) || \
99 defined(__sparc__) || defined(__sparc) || defined(__s390__) || \
100 defined(__SH4__) || defined(__alpha__) || \
101 defined(_MIPS_ARCH_MIPS32R2) || defined(__ARMEB__) ||\
102 defined(__AARCH64EL__) || defined(__aarch64__) || defined(__AARCH64EB__) || \
103 defined(__riscv) || \
104 defined(__or1k__) || defined(__arc__) || \
105 defined(__EMSCRIPTEN__)
106#define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1
107#elif defined(__mc68000__) || \
108 defined(__pnacl__) || defined(__native_client__)
109#undef DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS
110#elif defined(_M_IX86) || defined(__i386__) || defined(__i386)
111#if defined(_WIN32)
112// Windows uses a 64bit wide floating point stack.
113#define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1
114#else
115#undef DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS
116#endif // _WIN32
117#elif defined(__ghs)
118// Green Hills toolchain uses a 64bit wide floating point stack
119#define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1
120#else
121#error Target architecture was not detected as supported by Double-Conversion.
122#endif
123
124#if defined(_WIN32) && !defined(__MINGW32__)
125
126typedef signed char int8_t;
127typedef unsigned char uint8_t;
128typedef short int16_t; // NOLINT
129typedef unsigned short uint16_t; // NOLINT
130typedef int int32_t;
131typedef unsigned int uint32_t;
132typedef __int64 int64_t;
133typedef unsigned __int64 uint64_t;
134// intptr_t and friends are defined in crtdefs.h through stdio.h.
135
136#else
137
138#include <stdint.h>
139
140#endif
141
142typedef uint16_t uc16;
143
144// The following macro works on both 32 and 64-bit platforms.
145// Usage: instead of writing 0x1234567890123456
146// write UINT64_2PART_C(0x12345678,90123456);
147#define UINT64_2PART_C(a, b) (((static_cast<uint64_t>(a) << 32) + 0x##b##u))
148
149
150// The expression ARRAY_SIZE(a) is a compile-time constant of type
151// size_t which represents the number of elements of the given
152// array. You should only use ARRAY_SIZE on statically allocated
153// arrays.
154#ifndef ARRAY_SIZE
155#define ARRAY_SIZE(a) \
156 ((sizeof(a) / sizeof(*(a))) / \
157 static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))))
158#endif
159
160// A macro to disallow the evil copy constructor and operator= functions
161// This should be used in the private: declarations for a class
162#ifndef DC_DISALLOW_COPY_AND_ASSIGN
163#define DC_DISALLOW_COPY_AND_ASSIGN(TypeName) \
164 TypeName(const TypeName&); \
165 void operator=(const TypeName&)
166#endif
167
168// A macro to disallow all the implicit constructors, namely the
169// default constructor, copy constructor and operator= functions.
170//
171// This should be used in the private: declarations for a class
172// that wants to prevent anyone from instantiating it. This is
173// especially useful for classes containing only static methods.
174#ifndef DC_DISALLOW_IMPLICIT_CONSTRUCTORS
175#define DC_DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
176 TypeName(); \
177 DC_DISALLOW_COPY_AND_ASSIGN(TypeName)
178#endif
179
180namespace double_conversion {
181
182static const int kCharSize = sizeof(char);
183
184// Returns the maximum of the two parameters.
185template <typename T>
186static T Max(T a, T b) {
187 return a < b ? b : a;
188}
189
190
191// Returns the minimum of the two parameters.
192template <typename T>
193static T Min(T a, T b) {
194 return a < b ? a : b;
195}
196
197
198inline int StrLength(const char* string) {
199 size_t length = strlen(s: string);
200 ASSERT(length == static_cast<size_t>(static_cast<int>(length)));
201 return static_cast<int>(length);
202}
203
204// This is a simplified version of V8's Vector class.
205template <typename T>
206class Vector {
207 public:
208 Vector() : start_(NULL), length_(0) {}
209 Vector(T* data, int len) : start_(data), length_(len) {
210 ASSERT(len == 0 || (len > 0 && data != NULL));
211 }
212
213 // Returns a vector using the same backing storage as this one,
214 // spanning from and including 'from', to but not including 'to'.
215 Vector<T> SubVector(int from, int to) {
216 ASSERT(to <= length_);
217 ASSERT(from < to);
218 ASSERT(0 <= from);
219 return Vector<T>(start() + from, to - from);
220 }
221
222 // Returns the length of the vector.
223 int length() const { return length_; }
224
225 // Returns whether or not the vector is empty.
226 bool is_empty() const { return length_ == 0; }
227
228 // Returns the pointer to the start of the data in the vector.
229 T* start() const { return start_; }
230
231 // Access individual vector elements - checks bounds in debug mode.
232 T& operator[](int index) const {
233 ASSERT(0 <= index && index < length_);
234 return start_[index];
235 }
236
237 T& first() { return start_[0]; }
238
239 T& last() { return start_[length_ - 1]; }
240
241 private:
242 T* start_;
243 int length_;
244};
245
246
247// Helper class for building result strings in a character buffer. The
248// purpose of the class is to use safe operations that checks the
249// buffer bounds on all operations in debug mode.
250class StringBuilder {
251 public:
252 StringBuilder(char* buffer, int buffer_size)
253 : buffer_(buffer, buffer_size), position_(0) { }
254
255 ~StringBuilder() { if (!is_finalized()) Finalize(); }
256
257 int size() const { return buffer_.length(); }
258
259 // Get the current position in the builder.
260 int position() const {
261 ASSERT(!is_finalized());
262 return position_;
263 }
264
265 // Reset the position.
266 void Reset() { position_ = 0; }
267
268 // Add a single character to the builder. It is not allowed to add
269 // 0-characters; use the Finalize() method to terminate the string
270 // instead.
271 void AddCharacter(char c) {
272 ASSERT(c != '\0');
273 ASSERT(!is_finalized() && position_ < buffer_.length());
274 buffer_[position_++] = c;
275 }
276
277 // Add an entire string to the builder. Uses strlen() internally to
278 // compute the length of the input string.
279 void AddString(const char* s) {
280 AddSubstring(s, n: StrLength(string: s));
281 }
282
283 // Add the first 'n' characters of the given string 's' to the
284 // builder. The input string must have enough characters.
285 void AddSubstring(const char* s, int n) {
286 ASSERT(!is_finalized() && position_ + n < buffer_.length());
287 ASSERT(static_cast<size_t>(n) <= strlen(s));
288 memmove(dest: &buffer_[position_], src: s, n: n * kCharSize);
289 position_ += n;
290 }
291
292
293 // Add character padding to the builder. If count is non-positive,
294 // nothing is added to the builder.
295 void AddPadding(char c, int count) {
296 for (int i = 0; i < count; i++) {
297 AddCharacter(c);
298 }
299 }
300
301 // Finalize the string by 0-terminating it and returning the buffer.
302 char* Finalize() {
303 ASSERT(!is_finalized() && position_ < buffer_.length());
304 buffer_[position_] = '\0';
305 // Make sure nobody managed to add a 0-character to the
306 // buffer while building the string.
307 ASSERT(strlen(buffer_.start()) == static_cast<size_t>(position_));
308 position_ = -1;
309 ASSERT(is_finalized());
310 return buffer_.start();
311 }
312
313 private:
314 Vector<char> buffer_;
315 int position_;
316
317 bool is_finalized() const { return position_ < 0; }
318
319 DC_DISALLOW_IMPLICIT_CONSTRUCTORS(StringBuilder);
320};
321
322// The type-based aliasing rule allows the compiler to assume that pointers of
323// different types (for some definition of different) never alias each other.
324// Thus the following code does not work:
325//
326// float f = foo();
327// int fbits = *(int*)(&f);
328//
329// The compiler 'knows' that the int pointer can't refer to f since the types
330// don't match, so the compiler may cache f in a register, leaving random data
331// in fbits. Using C++ style casts makes no difference, however a pointer to
332// char data is assumed to alias any other pointer. This is the 'memcpy
333// exception'.
334//
335// Bit_cast uses the memcpy exception to move the bits from a variable of one
336// type of a variable of another type. Of course the end result is likely to
337// be implementation dependent. Most compilers (gcc-4.2 and MSVC 2005)
338// will completely optimize BitCast away.
339//
340// There is an additional use for BitCast.
341// Recent gccs will warn when they see casts that may result in breakage due to
342// the type-based aliasing rule. If you have checked that there is no breakage
343// you can use BitCast to cast one pointer type to another. This confuses gcc
344// enough that it can no longer see that you have cast one pointer type to
345// another thus avoiding the warning.
346template <class Dest, class Source>
347inline Dest BitCast(const Source& source) {
348 // Compile time assertion: sizeof(Dest) == sizeof(Source)
349 // A compile error here means your Dest and Source have different sizes.
350#if __cplusplus >= 201103L
351 static_assert(sizeof(Dest) == sizeof(Source),
352 "source and destination size mismatch");
353#else
354 DOUBLE_CONVERSION_UNUSED
355 typedef char VerifySizesAreEqual[sizeof(Dest) == sizeof(Source) ? 1 : -1];
356#endif
357
358 Dest dest;
359 memmove(&dest, &source, sizeof(dest));
360 return dest;
361}
362
363template <class Dest, class Source>
364inline Dest BitCast(Source* source) {
365 return BitCast<Dest>(reinterpret_cast<uintptr_t>(source));
366}
367
368} // namespace double_conversion
369
370#endif // DOUBLE_CONVERSION_UTILS_H_
371

source code of qtbase/src/3rdparty/double-conversion/include/double-conversion/utils.h