basictypes.h - mozsearch

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* vim: set ts=8 sts=2 et sw=2 tw=80: */

// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.

// Use of this source code is governed by a BSD-style license that can be

// found in the LICENSE file.

#ifndef BASE_BASICTYPES_H_

#define BASE_BASICTYPES_H_

#include <limits.h>  // So we can set the bounds of our types

#include <stddef.h>  // For size_t

#include <string.h>  // for memcpy

#include "base/port.h"  // Types that only need exist on certain systems

#include "mozilla/Assertions.h"

#include "mozilla/IntegerPrintfMacros.h"

// A type to represent a Unicode code-point value. As of Unicode 4.0,

// such values require up to 21 bits.

// (For type-checking on pointers, make this explicitly signed,

// and it should always be the signed version of whatever int32_t is.)

typedef signed int char32;

const uint8_t kuint8max = ((uint8_t)0xFF);

const uint16_t kuint16max = ((uint16_t)0xFFFF);

const uint32_t kuint32max = ((uint32_t)0xFFFFFFFF);

const uint64_t kuint64max = ((uint64_t)GG_LONGLONG(0xFFFFFFFFFFFFFFFF));

const int8_t kint8min = ((int8_t)0x80);

const int8_t kint8max = ((int8_t)0x7F);

const int16_t kint16min = ((int16_t)0x8000);

const int16_t kint16max = ((int16_t)0x7FFF);

const int32_t kint32min = ((int32_t)0x80000000);

const int32_t kint32max = ((int32_t)0x7FFFFFFF);

const int64_t kint64min = ((int64_t)GG_LONGLONG(0x8000000000000000));

const int64_t kint64max = ((int64_t)GG_LONGLONG(0x7FFFFFFFFFFFFFFF));

// Platform- and hardware-dependent printf specifiers

#if defined(XP_UNIX)

#  define PRId64L "I64d"

#  define PRIu64L "I64u"

#  define PRIx64L "I64x"

#else

#  define PRId64L L"I64d"

#  define PRIu64L L"I64u"

#  define PRIx64L L"I64x"

#endif

// A macro to disallow the copy constructor and operator= functions

// This should be used in the private: declarations for a class

#undef DISALLOW_COPY_AND_ASSIGN

#define DISALLOW_COPY_AND_ASSIGN(TypeName) \

  TypeName(const TypeName&);               \

  void operator=(const TypeName&)

// An older, deprecated, politically incorrect name for the above.

#undef DISALLOW_EVIL_CONSTRUCTORS

#define DISALLOW_EVIL_CONSTRUCTORS(TypeName) DISALLOW_COPY_AND_ASSIGN(TypeName)

// A macro to disallow all the implicit constructors, namely the

// default constructor, copy constructor and operator= functions.

//

// This should be used in the private: declarations for a class

// that wants to prevent anyone from instantiating it. This is

// especially useful for classes containing only static methods.

#undef DISALLOW_IMPLICIT_CONSTRUCTORS

#define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \

  TypeName();                                    \

  DISALLOW_COPY_AND_ASSIGN(TypeName)

// The arraysize(arr) macro returns the # of elements in an array arr.

// The expression is a compile-time constant, and therefore can be

// used in defining new arrays, for example.  If you use arraysize on

// a pointer by mistake, you will get a compile-time error.

//

// One caveat is that arraysize() doesn't accept any array of an

// anonymous type or a type defined inside a function.  In these rare

// cases, you have to use the unsafe ARRAYSIZE_UNSAFE() macro below.  This is

// due to a limitation in C++'s template system.  The limitation might

// eventually be removed, but it hasn't happened yet.

// This template function declaration is used in defining arraysize.

// Note that the function doesn't need an implementation, as we only

// use its type.

template <typename T, size_t N>

char (&ArraySizeHelper(T (&array)[N]))[N];

// That gcc wants both of these prototypes seems mysterious. VC, for

// its part, can't decide which to use (another mystery). Matching of

// template overloads: the final frontier.

#ifndef _MSC_VER

template <typename T, size_t N>

char (&ArraySizeHelper(const T (&array)[N]))[N];

#endif

#define arraysize(array) (sizeof(ArraySizeHelper(array)))

// ARRAYSIZE_UNSAFE performs essentially the same calculation as arraysize,

// but can be used on anonymous types or types defined inside

// functions.  It's less safe than arraysize as it accepts some

// (although not all) pointers.  Therefore, you should use arraysize

// whenever possible.

//

// The expression ARRAYSIZE_UNSAFE(a) is a compile-time constant of type

// size_t.

//

// ARRAYSIZE_UNSAFE catches a few type errors.  If you see a compiler error

//

//   "warning: division by zero in ..."

//

// when using ARRAYSIZE_UNSAFE, you are (wrongfully) giving it a pointer.

// You should only use ARRAYSIZE_UNSAFE on statically allocated arrays.

//

// The following comments are on the implementation details, and can

// be ignored by the users.

//

// ARRAYSIZE_UNSAFE(arr) works by inspecting sizeof(arr) (the # of bytes in

// the array) and sizeof(*(arr)) (the # of bytes in one array

// element).  If the former is divisible by the latter, perhaps arr is

// indeed an array, in which case the division result is the # of

// elements in the array.  Otherwise, arr cannot possibly be an array,

// and we generate a compiler error to prevent the code from

// compiling.

//

// Since the size of bool is implementation-defined, we need to cast

// !(sizeof(a) & sizeof(*(a))) to size_t in order to ensure the final

// result has type size_t.

//

// This macro is not perfect as it wrongfully accepts certain

// pointers, namely where the pointer size is divisible by the pointee

// size.  Since all our code has to go through a 32-bit compiler,

// where a pointer is 4 bytes, this means all pointers to a type whose

// size is 3 or greater than 4 will be (righteously) rejected.

#define ARRAYSIZE_UNSAFE(a)     \

  ((sizeof(a) / sizeof(*(a))) / \

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

// Use implicit_cast as a safe version of static_cast or const_cast

// for upcasting in the type hierarchy (i.e. casting a pointer to Foo

// to a pointer to SuperclassOfFoo or casting a pointer to Foo to

// a const pointer to Foo).

// When you use implicit_cast, the compiler checks that the cast is safe.

// Such explicit implicit_casts are necessary in surprisingly many

// situations where C++ demands an exact type match instead of an

// argument type convertable to a target type.

//

// The From type can be inferred, so the preferred syntax for using

// implicit_cast is the same as for static_cast etc.:

//

//   implicit_cast<ToType>(expr)

//

// implicit_cast would have been part of the C++ standard library,

// but the proposal was submitted too late.  It will probably make

// its way into the language in the future.

template <typename To, typename From>

// The COMPILE_ASSERT macro (below) creates an otherwise-unused typedef.  This

// triggers compiler warnings with gcc 4.8 and higher, so mark the typedef

// as permissibly-unused to disable the warnings.

#if defined(__GNUC__)

#  define COMPILE_ASSERT_UNUSED_ATTRIBUTE __attribute__((unused))

#else

#  define COMPILE_ASSERT_UNUSED_ATTRIBUTE /* nothing */

#endif

// The COMPILE_ASSERT macro can be used to verify that a compile time

// expression is true. For example, you could use it to verify the

// size of a static array:

//

//   COMPILE_ASSERT(ARRAYSIZE_UNSAFE(content_type_names) == CONTENT_NUM_TYPES,

//                  content_type_names_incorrect_size);

//

// or to make sure a struct is smaller than a certain size:

//

//   COMPILE_ASSERT(sizeof(foo) < 128, foo_too_large);

//

// The second argument to the macro is the name of the variable. If

// the expression is false, most compilers will issue a warning/error

// containing the name of the variable.

// Avoid multiple definitions for webrtc

#if !defined(COMPILE_ASSERT)

template <bool>

#  define COMPILE_ASSERT(expr, msg)     \

    typedef CompileAssert<(bool(expr))> \

        msg[bool(expr) ? 1 : -1] COMPILE_ASSERT_UNUSED_ATTRIBUTE

#endif

// Implementation details of COMPILE_ASSERT:

//

// - COMPILE_ASSERT works by defining an array type that has -1

//   elements (and thus is invalid) when the expression is false.

//

// - The simpler definition

//

//     #define COMPILE_ASSERT(expr, msg) typedef char msg[(expr) ? 1 : -1]

//

//   does not work, as gcc supports variable-length arrays whose sizes

//   are determined at run-time (this is gcc's extension and not part

//   of the C++ standard).  As a result, gcc fails to reject the

//   following code with the simple definition:

//

//     int foo;

//     COMPILE_ASSERT(foo, msg); // not supposed to compile as foo is

//                               // not a compile-time constant.

//

// - By using the type CompileAssert<(bool(expr))>, we ensures that

//   expr is a compile-time constant.  (Template arguments must be

//   determined at compile-time.)

//

// - The outter parentheses in CompileAssert<(bool(expr))> are necessary

//   to work around a bug in gcc 3.4.4 and 4.0.1.  If we had written

//

//     CompileAssert<bool(expr)>

//

//   instead, these compilers will refuse to compile

//

//     COMPILE_ASSERT(5 > 0, some_message);

//

//   (They seem to think the ">" in "5 > 0" marks the end of the

//   template argument list.)

//

// - The array size is (bool(expr) ? 1 : -1), instead of simply

//

//     ((expr) ? 1 : -1).

//

//   This is to avoid running into a bug in MS VC 7.1, which

//   causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1.

// MetatagId refers to metatag-id that we assign to

// each metatag <name, value> pair..

typedef uint32_t MetatagId;

// Argument type used in interfaces that can optionally take ownership

// of a passed in argument.  If TAKE_OWNERSHIP is passed, the called

// object takes ownership of the argument.  Otherwise it does not.

// The following enum should be used only as a constructor argument to indicate

// that the variable has static storage class, and that the constructor should

// do nothing to its state.  It indicates to the reader that it is legal to

// declare a static instance of the class, provided the constructor is given

// the base::LINKER_INITIALIZED argument.  Normally, it is unsafe to declare a

// static variable that has a constructor or a destructor because invocation

// order is undefined.  However, IF the type can be initialized by filling with

// zeroes (which the loader does for static variables), AND the destructor also

// does nothing to the storage, AND there are no virtual methods, then a

// constructor declared as

//       explicit MyClass(base::LinkerInitialized x) {}

// and invoked as

//       static MyClass my_variable_name(base::LINKER_INITIALIZED);

}  // namespace base

#endif  // BASE_BASICTYPES_H_

Source code

Revision control

Copy as Markdown

Other Tools