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