1c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Copyright (c) 2010 The Chromium Authors. All rights reserved. 2c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// Use of this source code is governed by a BSD-style license that can be 3c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// found in the LICENSE file. 4c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 5c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott#ifndef BASE_BASICTYPES_H_ 6c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott#define BASE_BASICTYPES_H_ 73345a6884c488ff3a535c2c9acdd33d74b37e311Iain Merrick#pragma once 8c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 9c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott#include <limits.h> // So we can set the bounds of our types 10c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott#include <stddef.h> // For size_t 11c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott#include <string.h> // for memcpy 12c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 13c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott#include "base/port.h" // Types that only need exist on certain systems 14c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 15c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott#ifndef COMPILER_MSVC 16c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// stdint.h is part of C99 but MSVC doesn't have it. 17c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott#include <stdint.h> // For intptr_t. 18c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott#endif 19c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 20c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scotttypedef signed char schar; 21c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scotttypedef signed char int8; 22c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scotttypedef short int16; 23c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// TODO: Remove these type guards. These are to avoid conflicts with 24c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// obsolete/protypes.h in the Gecko SDK. 25c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott#ifndef _INT32 26c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott#define _INT32 27c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scotttypedef int int32; 28c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott#endif 29c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 30ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen// The NSPR system headers define 64-bit as |long| when possible, except on 31ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen// Mac OS X. In order to not have typedef mismatches, we do the same on LP64. 32ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen// 33ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen// On Mac OS X, |long long| is used for 64-bit types for compatibility with 34ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen// <inttypes.h> format macros even in the LP64 model. 35ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen#if defined(__LP64__) && !defined(OS_MACOSX) 36c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scotttypedef long int64; 37c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott#else 38c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scotttypedef long long int64; 39c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott#endif 40c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 41c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// NOTE: unsigned types are DANGEROUS in loops and other arithmetical 42c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// places. Use the signed types unless your variable represents a bit 43c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// pattern (eg a hash value) or you really need the extra bit. Do NOT 44c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// use 'unsigned' to express "this value should always be positive"; 45c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// use assertions for this. 46c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 47c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scotttypedef unsigned char uint8; 48c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scotttypedef unsigned short uint16; 49c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// TODO: Remove these type guards. These are to avoid conflicts with 50c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// obsolete/protypes.h in the Gecko SDK. 51c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott#ifndef _UINT32 52c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott#define _UINT32 53c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scotttypedef unsigned int uint32; 54c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott#endif 55c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 56c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// See the comment above about NSPR and 64-bit. 57ddb351dbec246cf1fab5ec20d2d5520909041de1Kristian Monsen#if defined(__LP64__) && !defined(OS_MACOSX) 58c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scotttypedef unsigned long uint64; 59c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott#else 60c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scotttypedef unsigned long long uint64; 61c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott#endif 62c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 63c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// A type to represent a Unicode code-point value. As of Unicode 4.0, 64c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// such values require up to 21 bits. 65c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// (For type-checking on pointers, make this explicitly signed, 66c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// and it should always be the signed version of whatever int32 is.) 67c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scotttypedef signed int char32; 68c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 69c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scottconst uint8 kuint8max = (( uint8) 0xFF); 70c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scottconst uint16 kuint16max = ((uint16) 0xFFFF); 71c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scottconst uint32 kuint32max = ((uint32) 0xFFFFFFFF); 72c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scottconst uint64 kuint64max = ((uint64) GG_LONGLONG(0xFFFFFFFFFFFFFFFF)); 73c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scottconst int8 kint8min = (( int8) 0x80); 74c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scottconst int8 kint8max = (( int8) 0x7F); 75c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scottconst int16 kint16min = (( int16) 0x8000); 76c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scottconst int16 kint16max = (( int16) 0x7FFF); 77c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scottconst int32 kint32min = (( int32) 0x80000000); 78c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scottconst int32 kint32max = (( int32) 0x7FFFFFFF); 79c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scottconst int64 kint64min = (( int64) GG_LONGLONG(0x8000000000000000)); 80c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scottconst int64 kint64max = (( int64) GG_LONGLONG(0x7FFFFFFFFFFFFFFF)); 81c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 82c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// A macro to disallow the copy constructor and operator= functions 83c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// This should be used in the private: declarations for a class 84c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott#define DISALLOW_COPY_AND_ASSIGN(TypeName) \ 85c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott TypeName(const TypeName&); \ 86c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott void operator=(const TypeName&) 87c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 88c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// An older, deprecated, politically incorrect name for the above. 89c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// NOTE: The usage of this macro was baned from our code base, but some 90c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// third_party libraries are yet using it. 91c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// TODO(tfarina): Figure out how to fix the usage of this macro in the 92c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// third_party libraries and get rid of it. 93c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott#define DISALLOW_EVIL_CONSTRUCTORS(TypeName) DISALLOW_COPY_AND_ASSIGN(TypeName) 94c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 95c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// A macro to disallow all the implicit constructors, namely the 96c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// default constructor, copy constructor and operator= functions. 97c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 98c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// This should be used in the private: declarations for a class 99c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// that wants to prevent anyone from instantiating it. This is 100c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// especially useful for classes containing only static methods. 101c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott#define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \ 102c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott TypeName(); \ 103c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott DISALLOW_COPY_AND_ASSIGN(TypeName) 104c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 105c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// The arraysize(arr) macro returns the # of elements in an array arr. 106c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// The expression is a compile-time constant, and therefore can be 107c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// used in defining new arrays, for example. If you use arraysize on 108c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// a pointer by mistake, you will get a compile-time error. 109c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 110c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// One caveat is that arraysize() doesn't accept any array of an 111c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// anonymous type or a type defined inside a function. In these rare 112c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// cases, you have to use the unsafe ARRAYSIZE_UNSAFE() macro below. This is 113c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// due to a limitation in C++'s template system. The limitation might 114c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// eventually be removed, but it hasn't happened yet. 115c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 116c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// This template function declaration is used in defining arraysize. 117c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// Note that the function doesn't need an implementation, as we only 118c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// use its type. 119c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scotttemplate <typename T, size_t N> 120c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scottchar (&ArraySizeHelper(T (&array)[N]))[N]; 121c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 122c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// That gcc wants both of these prototypes seems mysterious. VC, for 123c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// its part, can't decide which to use (another mystery). Matching of 124c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// template overloads: the final frontier. 125c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott#ifndef _MSC_VER 126c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scotttemplate <typename T, size_t N> 127c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scottchar (&ArraySizeHelper(const T (&array)[N]))[N]; 128c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott#endif 129c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 130c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott#define arraysize(array) (sizeof(ArraySizeHelper(array))) 131c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 132c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// ARRAYSIZE_UNSAFE performs essentially the same calculation as arraysize, 133c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// but can be used on anonymous types or types defined inside 134c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// functions. It's less safe than arraysize as it accepts some 135c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// (although not all) pointers. Therefore, you should use arraysize 136c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// whenever possible. 137c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 138c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// The expression ARRAYSIZE_UNSAFE(a) is a compile-time constant of type 139c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// size_t. 140c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 141c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// ARRAYSIZE_UNSAFE catches a few type errors. If you see a compiler error 142c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 143c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// "warning: division by zero in ..." 144c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 145c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// when using ARRAYSIZE_UNSAFE, you are (wrongfully) giving it a pointer. 146c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// You should only use ARRAYSIZE_UNSAFE on statically allocated arrays. 147c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 148c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// The following comments are on the implementation details, and can 149c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// be ignored by the users. 150c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 151c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// ARRAYSIZE_UNSAFE(arr) works by inspecting sizeof(arr) (the # of bytes in 152c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// the array) and sizeof(*(arr)) (the # of bytes in one array 153c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// element). If the former is divisible by the latter, perhaps arr is 154c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// indeed an array, in which case the division result is the # of 155c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// elements in the array. Otherwise, arr cannot possibly be an array, 156c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// and we generate a compiler error to prevent the code from 157c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// compiling. 158c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 159c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// Since the size of bool is implementation-defined, we need to cast 160c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// !(sizeof(a) & sizeof(*(a))) to size_t in order to ensure the final 161c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// result has type size_t. 162c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 163c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// This macro is not perfect as it wrongfully accepts certain 164c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// pointers, namely where the pointer size is divisible by the pointee 165c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// size. Since all our code has to go through a 32-bit compiler, 166c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// where a pointer is 4 bytes, this means all pointers to a type whose 167c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// size is 3 or greater than 4 will be (righteously) rejected. 168c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 169c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott#define ARRAYSIZE_UNSAFE(a) \ 170c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott ((sizeof(a) / sizeof(*(a))) / \ 171c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott static_cast<size_t>(!(sizeof(a) % sizeof(*(a))))) 172c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 173c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 174c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// Use implicit_cast as a safe version of static_cast or const_cast 175c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// for upcasting in the type hierarchy (i.e. casting a pointer to Foo 176c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// to a pointer to SuperclassOfFoo or casting a pointer to Foo to 177c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// a const pointer to Foo). 178c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// When you use implicit_cast, the compiler checks that the cast is safe. 179c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// Such explicit implicit_casts are necessary in surprisingly many 180c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// situations where C++ demands an exact type match instead of an 181c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// argument type convertable to a target type. 182c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 183c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// The From type can be inferred, so the preferred syntax for using 184c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// implicit_cast is the same as for static_cast etc.: 185c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 186c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// implicit_cast<ToType>(expr) 187c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 188c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// implicit_cast would have been part of the C++ standard library, 189c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// but the proposal was submitted too late. It will probably make 190c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// its way into the language in the future. 191c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scotttemplate<typename To, typename From> 192c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scottinline To implicit_cast(From const &f) { 193c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott return f; 194c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott} 195c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 196c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// The COMPILE_ASSERT macro can be used to verify that a compile time 197c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// expression is true. For example, you could use it to verify the 198c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// size of a static array: 199c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 200c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// COMPILE_ASSERT(ARRAYSIZE_UNSAFE(content_type_names) == CONTENT_NUM_TYPES, 201c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// content_type_names_incorrect_size); 202c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 203c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// or to make sure a struct is smaller than a certain size: 204c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 205c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// COMPILE_ASSERT(sizeof(foo) < 128, foo_too_large); 206c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 207c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// The second argument to the macro is the name of the variable. If 208c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// the expression is false, most compilers will issue a warning/error 209c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// containing the name of the variable. 210c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 211c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scotttemplate <bool> 212c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scottstruct CompileAssert { 213c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott}; 214c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 215c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott#undef COMPILE_ASSERT 216c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott#define COMPILE_ASSERT(expr, msg) \ 217c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott typedef CompileAssert<(bool(expr))> msg[bool(expr) ? 1 : -1] 218c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 219c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// Implementation details of COMPILE_ASSERT: 220c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 221c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// - COMPILE_ASSERT works by defining an array type that has -1 222c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// elements (and thus is invalid) when the expression is false. 223c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 224c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// - The simpler definition 225c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 226c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// #define COMPILE_ASSERT(expr, msg) typedef char msg[(expr) ? 1 : -1] 227c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 228c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// does not work, as gcc supports variable-length arrays whose sizes 229c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// are determined at run-time (this is gcc's extension and not part 230c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// of the C++ standard). As a result, gcc fails to reject the 231c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// following code with the simple definition: 232c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 233c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// int foo; 234c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// COMPILE_ASSERT(foo, msg); // not supposed to compile as foo is 235c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// // not a compile-time constant. 236c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 237c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// - By using the type CompileAssert<(bool(expr))>, we ensures that 238c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// expr is a compile-time constant. (Template arguments must be 239c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// determined at compile-time.) 240c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 241c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// - The outter parentheses in CompileAssert<(bool(expr))> are necessary 242c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// to work around a bug in gcc 3.4.4 and 4.0.1. If we had written 243c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 244c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// CompileAssert<bool(expr)> 245c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 246c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// instead, these compilers will refuse to compile 247c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 248c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// COMPILE_ASSERT(5 > 0, some_message); 249c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 250c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// (They seem to think the ">" in "5 > 0" marks the end of the 251c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// template argument list.) 252c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 253c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// - The array size is (bool(expr) ? 1 : -1), instead of simply 254c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 255c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// ((expr) ? 1 : -1). 256c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 257c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// This is to avoid running into a bug in MS VC 7.1, which 258c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1. 259c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 260c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 261c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// MetatagId refers to metatag-id that we assign to 262c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// each metatag <name, value> pair.. 263c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scotttypedef uint32 MetatagId; 264c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 265c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// Argument type used in interfaces that can optionally take ownership 266c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// of a passed in argument. If TAKE_OWNERSHIP is passed, the called 267c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// object takes ownership of the argument. Otherwise it does not. 268c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scottenum Ownership { 269c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott DO_NOT_TAKE_OWNERSHIP, 270c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott TAKE_OWNERSHIP 271c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott}; 272c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 273c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// bit_cast<Dest,Source> is a template function that implements the 274c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// equivalent of "*reinterpret_cast<Dest*>(&source)". We need this in 275c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// very low-level functions like the protobuf library and fast math 276c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// support. 277c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 278c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// float f = 3.14159265358979; 279c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// int i = bit_cast<int32>(f); 280c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// // i = 0x40490fdb 281c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 282c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// The classical address-casting method is: 283c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 284c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// // WRONG 285c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// float f = 3.14159265358979; // WRONG 286c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// int i = * reinterpret_cast<int*>(&f); // WRONG 287c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 288c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// The address-casting method actually produces undefined behavior 289c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// according to ISO C++ specification section 3.10 -15 -. Roughly, this 290c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// section says: if an object in memory has one type, and a program 291c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// accesses it with a different type, then the result is undefined 292c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// behavior for most values of "different type". 293c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 294c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// This is true for any cast syntax, either *(int*)&f or 295c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// *reinterpret_cast<int*>(&f). And it is particularly true for 296c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// conversions betweeen integral lvalues and floating-point lvalues. 297c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 298c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// The purpose of 3.10 -15- is to allow optimizing compilers to assume 299c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// that expressions with different types refer to different memory. gcc 300c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 4.0.1 has an optimizer that takes advantage of this. So a 301c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// non-conforming program quietly produces wildly incorrect output. 302c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 303c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// The problem is not the use of reinterpret_cast. The problem is type 304c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// punning: holding an object in memory of one type and reading its bits 305c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// back using a different type. 306c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 307c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// The C++ standard is more subtle and complex than this, but that 308c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// is the basic idea. 309c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 310c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// Anyways ... 311c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 312c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// bit_cast<> calls memcpy() which is blessed by the standard, 313c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// especially by the example in section 3.9 . Also, of course, 314c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// bit_cast<> wraps up the nasty logic in one place. 315c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 316c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// Fortunately memcpy() is very fast. In optimized mode, with a 317c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// constant size, gcc 2.95.3, gcc 4.0.1, and msvc 7.1 produce inline 318c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// code with the minimal amount of data movement. On a 32-bit system, 319c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// memcpy(d,s,4) compiles to one load and one store, and memcpy(d,s,8) 320c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// compiles to two loads and two stores. 321c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 322c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// I tested this code with gcc 2.95.3, gcc 4.0.1, icc 8.1, and msvc 7.1. 323c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// 324c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// WARNING: if Dest or Source is a non-POD type, the result of the memcpy 325c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// is likely to surprise you. 326c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 327c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scotttemplate <class Dest, class Source> 328c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scottinline Dest bit_cast(const Source& source) { 329c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott // Compile time assertion: sizeof(Dest) == sizeof(Source) 330c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott // A compile error here means your Dest and Source have different sizes. 331c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott typedef char VerifySizesAreEqual [sizeof(Dest) == sizeof(Source) ? 1 : -1]; 332c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 333c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott Dest dest; 334c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott memcpy(&dest, &source, sizeof(dest)); 335c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott return dest; 336c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott} 337c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 338c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// Used to explicitly mark the return value of a function as unused. If you are 339c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// really sure you don't want to do anything with the return value of a function 340c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// that has been marked WARN_UNUSED_RESULT, wrap it with this. Example: 341c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// 342c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// scoped_ptr<MyType> my_var = ...; 343c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// if (TakeOwnership(my_var.get()) == SUCCESS) 344c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// ignore_result(my_var.release()); 345c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch// 346c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochtemplate<typename T> 347c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdochinline void ignore_result(const T& ignored) { 348c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch} 349c407dc5cd9bdc5668497f21b26b09d988ab439deBen Murdoch 350c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// The following enum should be used only as a constructor argument to indicate 351c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// that the variable has static storage class, and that the constructor should 352c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// do nothing to its state. It indicates to the reader that it is legal to 353c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// declare a static instance of the class, provided the constructor is given 354c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// the base::LINKER_INITIALIZED argument. Normally, it is unsafe to declare a 355c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// static variable that has a constructor or a destructor because invocation 356c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// order is undefined. However, IF the type can be initialized by filling with 357c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// zeroes (which the loader does for static variables), AND the destructor also 358c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// does nothing to the storage, AND there are no virtual methods, then a 359c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// constructor declared as 360c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// explicit MyClass(base::LinkerInitialized x) {} 361c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// and invoked as 362c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott// static MyClass my_variable_name(base::LINKER_INITIALIZED); 363c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scottnamespace base { 364c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scottenum LinkerInitialized { LINKER_INITIALIZED }; 365c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott} // base 366c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott 367c7f5f8508d98d5952d42ed7648c2a8f30a4da156Patrick Scott#endif // BASE_BASICTYPES_H_ 368