src/include/base/cef_macros.h - cef - Git at Google

 // Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012
 // Google Inc. All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //    * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //    * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //    * Neither the name of Google Inc. nor the name Chromium Embedded
 // Framework nor the names of its contributors may be used to endorse
 // or promote products derived from this software without specific prior
 // written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 #ifndef CEF_INCLUDE_BASE_CEF_MACROS_H_
 #define CEF_INCLUDE_BASE_CEF_MACROS_H_
 #pragma once

 #if defined(USING_CHROMIUM_INCLUDES)
 // When building CEF include the Chromium header directly.
 #include "base/macros.h"

 #else  // !USING_CHROMIUM_INCLUDES
 // The following is substantially similar to the Chromium implementation.
 // If the Chromium implementation diverges the below implementation should be
 // updated to match.

 #include <stddef.h>                  // For size_t.
 #include "include/base/cef_build.h"  // For COMPILER_MSVC

 #if !defined(arraysize)

 // 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)))

 #endif  // !arraysize

 #if !defined(DISALLOW_COPY_AND_ASSIGN)

 // A macro to disallow the copy constructor and operator= functions
 // This should be used in the private: declarations for a class
 #define DISALLOW_COPY_AND_ASSIGN(TypeName) \
   TypeName(const TypeName&);               \
   void operator=(const TypeName&)

 #endif  // !DISALLOW_COPY_AND_ASSIGN

 #if !defined(DISALLOW_IMPLICIT_CONSTRUCTORS)

 // 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.
 #define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
   TypeName();                                    \
   DISALLOW_COPY_AND_ASSIGN(TypeName)

 #endif  // !DISALLOW_IMPLICIT_CONSTRUCTORS

 #if !defined(COMPILE_ASSERT)

 // 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.

 #if __cplusplus >= 201103L

 // Under C++11, just use static_assert.
 #define COMPILE_ASSERT(expr, msg) static_assert(expr, #msg)

 #else

 namespace cef {

 template <bool>
 struct CompileAssert {};

 }  // namespace cef

 #define COMPILE_ASSERT(expr, msg)          \
   typedef cef::CompileAssert<(bool(expr))> \
       msg[bool(expr) ? 1 : -1] ALLOW_UNUSED_TYPE

 // 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 outer 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.

 #endif  // !(__cplusplus >= 201103L)

 #endif  // !defined(COMPILE_ASSERT)

 #endif  // !USING_CHROMIUM_INCLUDES

 #if !defined(MSVC_PUSH_DISABLE_WARNING) && defined(COMPILER_MSVC)

 // MSVC_PUSH_DISABLE_WARNING pushes |n| onto a stack of warnings to be disabled.
 // The warning remains disabled until popped by MSVC_POP_WARNING.
 #define MSVC_PUSH_DISABLE_WARNING(n) \
   __pragma(warning(push)) __pragma(warning(disable : n))

 // MSVC_PUSH_WARNING_LEVEL pushes |n| as the global warning level.  The level
 // remains in effect until popped by MSVC_POP_WARNING().  Use 0 to disable all
 // warnings.
 #define MSVC_PUSH_WARNING_LEVEL(n) __pragma(warning(push, n))

 // Pop effects of innermost MSVC_PUSH_* macro.
 #define MSVC_POP_WARNING() __pragma(warning(pop))

 #endif  // !defined(MSVC_PUSH_DISABLE_WARNING) && defined(COMPILER_MSVC)

 #if !defined(ALLOW_THIS_IN_INITIALIZER_LIST)
 #if defined(COMPILER_MSVC)
 // Allows |this| to be passed as an argument in constructor initializer lists.
 // This uses push/pop instead of the seemingly simpler suppress feature to avoid
 // having the warning be disabled for more than just |code|.
 //
 // Example usage:
 // Foo::Foo() : x(NULL), ALLOW_THIS_IN_INITIALIZER_LIST(y(this)), z(3) {}
 //
 // Compiler warning C4355: 'this': used in base member initializer list:
 // http://msdn.microsoft.com/en-us/library/3c594ae3(VS.80).aspx
 #define ALLOW_THIS_IN_INITIALIZER_LIST(code) \
   MSVC_PUSH_DISABLE_WARNING(4355)            \
   code MSVC_POP_WARNING()
 #else  // !COMPILER_MSVC
 #define ALLOW_THIS_IN_INITIALIZER_LIST(code) code
 #endif  // !COMPILER_MSVC
 #endif  // !ALLOW_THIS_IN_INITIALIZER_LIST

 #endif  // CEF_INCLUDE_BASE_CEF_MACROS_H_
	// Copyright (c) 2014 Marshall A. Greenblatt. Portions copyright (c) 2012
	// Google Inc. All rights reserved.
	//
	// Redistribution and use in source and binary forms, with or without
	// modification, are permitted provided that the following conditions are
	// met:
	//
	// * Redistributions of source code must retain the above copyright
	// notice, this list of conditions and the following disclaimer.
	// * Redistributions in binary form must reproduce the above
	// copyright notice, this list of conditions and the following disclaimer
	// in the documentation and/or other materials provided with the
	// distribution.
	// * Neither the name of Google Inc. nor the name Chromium Embedded
	// Framework nor the names of its contributors may be used to endorse
	// or promote products derived from this software without specific prior
	// written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	#ifndef CEF_INCLUDE_BASE_CEF_MACROS_H_
	#define CEF_INCLUDE_BASE_CEF_MACROS_H_
	#pragma once

	#if defined(USING_CHROMIUM_INCLUDES)
	// When building CEF include the Chromium header directly.
	#include "base/macros.h"

	#else // !USING_CHROMIUM_INCLUDES
	// The following is substantially similar to the Chromium implementation.
	// If the Chromium implementation diverges the below implementation should be
	// updated to match.

	#include <stddef.h> // For size_t.
	#include "include/base/cef_build.h" // For COMPILER_MSVC

	#if !defined(arraysize)

	// 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)))

	#endif // !arraysize

	#if !defined(DISALLOW_COPY_AND_ASSIGN)

	// A macro to disallow the copy constructor and operator= functions
	// This should be used in the private: declarations for a class
	#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
	TypeName(const TypeName&); \
	void operator=(const TypeName&)

	#endif // !DISALLOW_COPY_AND_ASSIGN

	#if !defined(DISALLOW_IMPLICIT_CONSTRUCTORS)

	// 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.
	#define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
	TypeName(); \
	DISALLOW_COPY_AND_ASSIGN(TypeName)

	#endif // !DISALLOW_IMPLICIT_CONSTRUCTORS

	#if !defined(COMPILE_ASSERT)

	// 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.

	#if __cplusplus >= 201103L

	// Under C++11, just use static_assert.
	#define COMPILE_ASSERT(expr, msg) static_assert(expr, #msg)

	#else

	namespace cef {

	template <bool>
	struct CompileAssert {};

	} // namespace cef

	#define COMPILE_ASSERT(expr, msg) \
	typedef cef::CompileAssert<(bool(expr))> \
	msg[bool(expr) ? 1 : -1] ALLOW_UNUSED_TYPE

	// 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 outer 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.

	#endif // !(__cplusplus >= 201103L)

	#endif // !defined(COMPILE_ASSERT)

	#endif // !USING_CHROMIUM_INCLUDES

	#if !defined(MSVC_PUSH_DISABLE_WARNING) && defined(COMPILER_MSVC)

	// MSVC_PUSH_DISABLE_WARNING pushes \|n\| onto a stack of warnings to be disabled.
	// The warning remains disabled until popped by MSVC_POP_WARNING.
	#define MSVC_PUSH_DISABLE_WARNING(n) \
	__pragma(warning(push)) __pragma(warning(disable : n))

	// MSVC_PUSH_WARNING_LEVEL pushes \|n\| as the global warning level. The level
	// remains in effect until popped by MSVC_POP_WARNING(). Use 0 to disable all
	// warnings.
	#define MSVC_PUSH_WARNING_LEVEL(n) __pragma(warning(push, n))

	// Pop effects of innermost MSVC_PUSH_* macro.
	#define MSVC_POP_WARNING() __pragma(warning(pop))

	#endif // !defined(MSVC_PUSH_DISABLE_WARNING) && defined(COMPILER_MSVC)

	#if !defined(ALLOW_THIS_IN_INITIALIZER_LIST)
	#if defined(COMPILER_MSVC)
	// Allows \|this\| to be passed as an argument in constructor initializer lists.
	// This uses push/pop instead of the seemingly simpler suppress feature to avoid
	// having the warning be disabled for more than just \|code\|.
	//
	// Example usage:
	// Foo::Foo() : x(NULL), ALLOW_THIS_IN_INITIALIZER_LIST(y(this)), z(3) {}
	//
	// Compiler warning C4355: 'this': used in base member initializer list:
	// http://msdn.microsoft.com/en-us/library/3c594ae3(VS.80).aspx
	#define ALLOW_THIS_IN_INITIALIZER_LIST(code) \
	MSVC_PUSH_DISABLE_WARNING(4355) \
	code MSVC_POP_WARNING()
	#else // !COMPILER_MSVC
	#define ALLOW_THIS_IN_INITIALIZER_LIST(code) code
	#endif // !COMPILER_MSVC
	#endif // !ALLOW_THIS_IN_INITIALIZER_LIST

	#endif // CEF_INCLUDE_BASE_CEF_MACROS_H_