1// Copyright (c) 2010 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#ifndef I18N_PHONENUMBERS_BASE_BASICTYPES_H_ 6#define I18N_PHONENUMBERS_BASE_BASICTYPES_H_ 7 8#include <limits.h> // So we can set the bounds of our types 9#include <stddef.h> // For size_t 10#include <string.h> // for memcpy 11 12#if !defined(_WIN32) 13// stdint.h is part of C99 but MSVC doesn't have it. 14#include <stdint.h> // For intptr_t. 15#endif 16 17namespace i18n { 18namespace phonenumbers { 19 20#ifdef INT64_MAX 21 22// INT64_MAX is defined if C99 stdint.h is included; use the 23// native types if available. 24typedef int8_t int8; 25typedef int16_t int16; 26typedef int32_t int32; 27typedef int64_t int64; 28typedef uint8_t uint8; 29typedef uint16_t uint16; 30typedef uint32_t uint32; 31typedef uint64_t uint64; 32 33const uint8 kuint8max = UINT8_MAX; 34const uint16 kuint16max = UINT16_MAX; 35const uint32 kuint32max = UINT32_MAX; 36const uint64 kuint64max = UINT64_MAX; 37const int8 kint8min = INT8_MIN; 38const int8 kint8max = INT8_MAX; 39const int16 kint16min = INT16_MIN; 40const int16 kint16max = INT16_MAX; 41const int32 kint32min = INT32_MIN; 42const int32 kint32max = INT32_MAX; 43const int64 kint64min = INT64_MIN; 44const int64 kint64max = INT64_MAX; 45 46#else // !INT64_MAX 47 48typedef signed char int8; 49typedef short int16; 50// TODO: Remove these type guards. These are to avoid conflicts with 51// obsolete/protypes.h in the Gecko SDK. 52#ifndef _INT32 53#define _INT32 54typedef int int32; 55#endif 56 57// The NSPR system headers define 64-bit as |long| when possible. In order to 58// not have typedef mismatches, we do the same on LP64. 59#if __LP64__ 60typedef long int64; 61#else 62typedef long long int64; 63#endif 64 65// NOTE: unsigned types are DANGEROUS in loops and other arithmetical 66// places. Use the signed types unless your variable represents a bit 67// pattern (eg a hash value) or you really need the extra bit. Do NOT 68// use 'unsigned' to express "this value should always be positive"; 69// use assertions for this. 70 71typedef unsigned char uint8; 72typedef unsigned short uint16; 73// TODO: Remove these type guards. These are to avoid conflicts with 74// obsolete/protypes.h in the Gecko SDK. 75#ifndef _UINT32 76#define _UINT32 77typedef unsigned int uint32; 78#endif 79 80// See the comment above about NSPR and 64-bit. 81#if __LP64__ 82typedef unsigned long uint64; 83#else 84typedef unsigned long long uint64; 85#endif 86 87#endif // !INT64_MAX 88 89typedef signed char schar; 90 91// A type to represent a Unicode code-point value. As of Unicode 4.0, 92// such values require up to 21 bits. 93// (For type-checking on pointers, make this explicitly signed, 94// and it should always be the signed version of whatever int32 is.) 95typedef signed int char32; 96 97// A macro to disallow the copy constructor and operator= functions 98// This should be used in the private: declarations for a class 99#if !defined(DISALLOW_COPY_AND_ASSIGN) 100#define DISALLOW_COPY_AND_ASSIGN(TypeName) \ 101 TypeName(const TypeName&); \ 102 void operator=(const TypeName&) 103#endif 104 105// The arraysize(arr) macro returns the # of elements in an array arr. 106// The expression is a compile-time constant, and therefore can be 107// used in defining new arrays, for example. If you use arraysize on 108// a pointer by mistake, you will get a compile-time error. 109// 110// One caveat is that arraysize() doesn't accept any array of an 111// anonymous type or a type defined inside a function. In these rare 112// cases, you have to use the unsafe ARRAYSIZE_UNSAFE() macro below. This is 113// due to a limitation in C++'s template system. The limitation might 114// eventually be removed, but it hasn't happened yet. 115 116// This template function declaration is used in defining arraysize. 117// Note that the function doesn't need an implementation, as we only 118// use its type. 119template <typename T, size_t N> 120char (&ArraySizeHelper(T (&array)[N]))[N]; 121 122// That gcc wants both of these prototypes seems mysterious. VC, for 123// its part, can't decide which to use (another mystery). Matching of 124// template overloads: the final frontier. 125#ifndef _MSC_VER 126template <typename T, size_t N> 127char (&ArraySizeHelper(const T (&array)[N]))[N]; 128#endif 129 130#if !defined(arraysize) 131#define arraysize(array) (sizeof(ArraySizeHelper(array))) 132#endif 133 134// ARRAYSIZE_UNSAFE performs essentially the same calculation as arraysize, 135// but can be used on anonymous types or types defined inside 136// functions. It's less safe than arraysize as it accepts some 137// (although not all) pointers. Therefore, you should use arraysize 138// whenever possible. 139// 140// The expression ARRAYSIZE_UNSAFE(a) is a compile-time constant of type 141// size_t. 142// 143// ARRAYSIZE_UNSAFE catches a few type errors. If you see a compiler error 144// 145// "warning: division by zero in ..." 146// 147// when using ARRAYSIZE_UNSAFE, you are (wrongfully) giving it a pointer. 148// You should only use ARRAYSIZE_UNSAFE on statically allocated arrays. 149// 150// The following comments are on the implementation details, and can 151// be ignored by the users. 152// 153// ARRAYSIZE_UNSAFE(arr) works by inspecting sizeof(arr) (the # of bytes in 154// the array) and sizeof(*(arr)) (the # of bytes in one array 155// element). If the former is divisible by the latter, perhaps arr is 156// indeed an array, in which case the division result is the # of 157// elements in the array. Otherwise, arr cannot possibly be an array, 158// and we generate a compiler error to prevent the code from 159// compiling. 160// 161// Since the size of bool is implementation-defined, we need to cast 162// !(sizeof(a) & sizeof(*(a))) to size_t in order to ensure the final 163// result has type size_t. 164// 165// This macro is not perfect as it wrongfully accepts certain 166// pointers, namely where the pointer size is divisible by the pointee 167// size. Since all our code has to go through a 32-bit compiler, 168// where a pointer is 4 bytes, this means all pointers to a type whose 169// size is 3 or greater than 4 will be (righteously) rejected. 170 171#if !defined(ARRAYSIZE_UNSAFE) 172#define ARRAYSIZE_UNSAFE(a) \ 173 ((sizeof(a) / sizeof(*(a))) / \ 174 static_cast<size_t>(!(sizeof(a) % sizeof(*(a))))) 175#endif 176 177// The COMPILE_ASSERT macro can be used to verify that a compile time 178// expression is true. For example, you could use it to verify the 179// size of a static array: 180// 181// COMPILE_ASSERT(ARRAYSIZE_UNSAFE(content_type_names) == CONTENT_NUM_TYPES, 182// content_type_names_incorrect_size); 183// 184// or to make sure a struct is smaller than a certain size: 185// 186// COMPILE_ASSERT(sizeof(foo) < 128, foo_too_large); 187// 188// The second argument to the macro is the name of the variable. If 189// the expression is false, most compilers will issue a warning/error 190// containing the name of the variable. 191 192template <bool> 193struct CompileAssert { 194}; 195 196#if !defined(COMPILE_ASSERT) 197#define COMPILE_ASSERT(expr, msg) \ 198 typedef CompileAssert<(bool(expr))> msg[bool(expr) ? 1 : -1] 199#endif 200 201} // namespace phonenumbers 202} // namespace i18n 203 204#endif // I18N_PHONENUMBERS_BASE_BASICTYPES_H_ 205