utils.h File Reference

#include <cstdlib>
#include <cstring>
#include <cassert>
#include <stdint.h>

Go to the source code of this file.

Classes
class	double_conversion::Vector< T >
class	double_conversion::StringBuilder

Namespaces
namespace	double_conversion

Macros
#define	DOUBLE_CONVERSION_NULLPTR   NULL
#define	DOUBLE_CONVERSION_ASSERT(condition)    assert(condition)
#define	DOUBLE_CONVERSION_UNIMPLEMENTED()   (abort())
#define	DOUBLE_CONVERSION_NO_RETURN   __attribute__((noreturn))
#define	DOUBLE_CONVERSION_UNREACHABLE()   (abort())
#define	DOUBLE_CONVERSION_HAS_ATTRIBUTE(x)   0
#define	DOUBLE_CONVERSION_UNUSED
#define	DOUBLE_CONVERSION_STACK_UNINITIALIZED
#define	DOUBLE_CONVERSION_UINT64_2PART_C(a, b)   (((static_cast<uint64_t>(a) << 32) + 0x##b##u))
#define	DOUBLE_CONVERSION_ARRAY_SIZE(a)
#define	DOUBLE_CONVERSION_DISALLOW_COPY_AND_ASSIGN(TypeName)
#define	DOUBLE_CONVERSION_DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName)

Typedefs
typedef uint16_t	uc16

Functions
int	double_conversion::StrLength (const char *string)
template<class Dest , class Source >
Dest	double_conversion::BitCast (const Source &source)
template<class Dest , class Source >
Dest	double_conversion::BitCast (Source *source)

Macro Definition Documentation

DOUBLE_CONVERSION_ARRAY_SIZE

#define DOUBLE_CONVERSION_ARRAY_SIZE

(

a

)

Value:

  ((sizeof(a) / sizeof(*(a))) /                         \
  static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))))

Definition at line 205 of file utils.h.

                            {
 
inline int StrLength(const char* string) {
  size_t length = strlen(string);
  DOUBLE_CONVERSION_ASSERT(length == static_cast<size_t>(static_cast<int>(length)));
  return static_cast<int>(length);
}
 
// This is a simplified version of V8's Vector class.
template <typename T>
class Vector {
 public:
  Vector() : start_(DOUBLE_CONVERSION_NULLPTR), length_(0) {}
  Vector(T* data, int len) : start_(data), length_(len) {
    DOUBLE_CONVERSION_ASSERT(len == 0 || (len > 0 && data != DOUBLE_CONVERSION_NULLPTR));
  }
 
  // Returns a vector using the same backing storage as this one,
  // spanning from and including 'from', to but not including 'to'.
  Vector<T> SubVector(int from, int to) {
    DOUBLE_CONVERSION_ASSERT(to <= length_);
    DOUBLE_CONVERSION_ASSERT(from < to);
    DOUBLE_CONVERSION_ASSERT(0 <= from);
    return Vector<T>(start() + from, to - from);
  }
 
  // Returns the length of the vector.
  int length() const { return length_; }
 
  // Returns whether or not the vector is empty.
  bool is_empty() const { return length_ == 0; }
 
  // Returns the pointer to the start of the data in the vector.
  T* start() const { return start_; }
 
  // Access individual vector elements - checks bounds in debug mode.
  T& operator[](int index) const {
    DOUBLE_CONVERSION_ASSERT(0 <= index && index < length_);
    return start_[index];
  }
 
  T& first() { return start_[0]; }
 
  T& last() { return start_[length_ - 1]; }
 
  void pop_back() {
    DOUBLE_CONVERSION_ASSERT(!is_empty());
    --length_;
  }
 
 private:
  T* start_;
  int length_;
};
 
 
// Helper class for building result strings in a character buffer. The
// purpose of the class is to use safe operations that checks the
// buffer bounds on all operations in debug mode.
class StringBuilder {
 public:
  StringBuilder(char* buffer, int buffer_size)
      : buffer_(buffer, buffer_size), position_(0) { }
 
  ~StringBuilder() { if (!is_finalized()) Finalize(); }
 
  int size() const { return buffer_.length(); }
 
  // Get the current position in the builder.
  int position() const {
    DOUBLE_CONVERSION_ASSERT(!is_finalized());
    return position_;
  }
 
  // Reset the position.
  void Reset() { position_ = 0; }
 
  // Add a single character to the builder. It is not allowed to add
  // 0-characters; use the Finalize() method to terminate the string
  // instead.
  void AddCharacter(char c) {
    DOUBLE_CONVERSION_ASSERT(c != '\0');
    DOUBLE_CONVERSION_ASSERT(!is_finalized() && position_ < buffer_.length());
    buffer_[position_++] = c;
  }
 
  // Add an entire string to the builder. Uses strlen() internally to
  // compute the length of the input string.
  void AddString(const char* s) {
    AddSubstring(s, StrLength(s));
  }
 
  // Add the first 'n' characters of the given string 's' to the
  // builder. The input string must have enough characters.
  void AddSubstring(const char* s, int n) {
    DOUBLE_CONVERSION_ASSERT(!is_finalized() && position_ + n < buffer_.length());
    DOUBLE_CONVERSION_ASSERT(static_cast<size_t>(n) <= strlen(s));
    memmove(&buffer_[position_], s, static_cast<size_t>(n));
    position_ += n;
  }
 
 
  // Add character padding to the builder. If count is non-positive,
  // nothing is added to the builder.
  void AddPadding(char c, int count) {
    for (int i = 0; i < count; i++) {
      AddCharacter(c);
    }
  }
 
  // Finalize the string by 0-terminating it and returning the buffer.
  char* Finalize() {
    DOUBLE_CONVERSION_ASSERT(!is_finalized() && position_ < buffer_.length());
    buffer_[position_] = '\0';
    // Make sure nobody managed to add a 0-character to the
    // buffer while building the string.
    DOUBLE_CONVERSION_ASSERT(strlen(buffer_.start()) == static_cast<size_t>(position_));
    position_ = -1;
    DOUBLE_CONVERSION_ASSERT(is_finalized());
    return buffer_.start();
  }
 
 private:
  Vector<char> buffer_;
  int position_;
 
  bool is_finalized() const { return position_ < 0; }
 
  DOUBLE_CONVERSION_DISALLOW_IMPLICIT_CONSTRUCTORS(StringBuilder);
};
 
// The type-based aliasing rule allows the compiler to assume that pointers of
// different types (for some definition of different) never alias each other.
// Thus the following code does not work:
//
// float f = foo();
// int fbits = *(int*)(&f);
//
// The compiler 'knows' that the int pointer can't refer to f since the types
// don't match, so the compiler may cache f in a register, leaving random data
// in fbits.  Using C++ style casts makes no difference, however a pointer to
// char data is assumed to alias any other pointer.  This is the 'memcpy
// exception'.
//
// Bit_cast uses the memcpy exception to move the bits from a variable of one
// type of a variable of another type.  Of course the end result is likely to
// be implementation dependent.  Most compilers (gcc-4.2 and MSVC 2005)
// will completely optimize BitCast away.
//
// There is an additional use for BitCast.
// Recent gccs will warn when they see casts that may result in breakage due to
// the type-based aliasing rule.  If you have checked that there is no breakage
// you can use BitCast to cast one pointer type to another.  This confuses gcc
// enough that it can no longer see that you have cast one pointer type to
// another thus avoiding the warning.
template <class Dest, class Source>
Dest BitCast(const Source& source) {
  // Compile time assertion: sizeof(Dest) == sizeof(Source)
  // A compile error here means your Dest and Source have different sizes.
#if __cplusplus >= 201103L
  static_assert(sizeof(Dest) == sizeof(Source),
                "source and destination size mismatch");
#else
  DOUBLE_CONVERSION_UNUSED
  typedef char VerifySizesAreEqual[sizeof(Dest) == sizeof(Source) ? 1 : -1];
#endif
 
  Dest dest;
  memmove(&dest, &source, sizeof(dest));
  return dest;
}
 
template <class Dest, class Source>
Dest BitCast(Source* source) {
  return BitCast<Dest>(reinterpret_cast<uintptr_t>(source));
}
 
}  // namespace double_conversion
 
#endif  // DOUBLE_CONVERSION_UTILS_H_

DOUBLE_CONVERSION_ASSERT

#define DOUBLE_CONVERSION_ASSERT

(

condition

)

assert(condition)

Definition at line 46 of file utils.h.

DOUBLE_CONVERSION_DISALLOW_COPY_AND_ASSIGN

#define DOUBLE_CONVERSION_DISALLOW_COPY_AND_ASSIGN

(

TypeName

)

Value:

  TypeName(const TypeName&);                    \
  void operator=(const TypeName&)

Definition at line 216 of file utils.h.

DOUBLE_CONVERSION_DISALLOW_IMPLICIT_CONSTRUCTORS

#define DOUBLE_CONVERSION_DISALLOW_IMPLICIT_CONSTRUCTORS

(

TypeName

)

Value:

  TypeName();                                    \
  DOUBLE_CONVERSION_DISALLOW_COPY_AND_ASSIGN(TypeName)

Definition at line 231 of file utils.h.

DOUBLE_CONVERSION_HAS_ATTRIBUTE

#define DOUBLE_CONVERSION_HAS_ATTRIBUTE

(

x

)

0

Definition at line 89 of file utils.h.

DOUBLE_CONVERSION_NO_RETURN

#define DOUBLE_CONVERSION_NO_RETURN   __attribute__((noreturn))

Definition at line 64 of file utils.h.

DOUBLE_CONVERSION_NULLPTR

#define DOUBLE_CONVERSION_NULLPTR   NULL

Definition at line 41 of file utils.h.

DOUBLE_CONVERSION_STACK_UNINITIALIZED

#define DOUBLE_CONVERSION_STACK_UNINITIALIZED

Definition at line 106 of file utils.h.

DOUBLE_CONVERSION_UINT64_2PART_C

#define DOUBLE_CONVERSION_UINT64_2PART_C	(		a,
			b
	)		(((static_cast<uint64_t>(a) << 32) + 0x##b##u))

Definition at line 195 of file utils.h.

DOUBLE_CONVERSION_UNIMPLEMENTED

#define DOUBLE_CONVERSION_UNIMPLEMENTED

(

)

(abort())

Definition at line 54 of file utils.h.

DOUBLE_CONVERSION_UNREACHABLE

#define DOUBLE_CONVERSION_UNREACHABLE

(

)

(abort())

Definition at line 77 of file utils.h.

DOUBLE_CONVERSION_UNUSED

#define DOUBLE_CONVERSION_UNUSED

Definition at line 96 of file utils.h.

Typedef Documentation

uc16

typedef uint16_t uc16

Definition at line 190 of file utils.h.