chromium/third_party/glslang/src/glslang/Include/Common.h

//
// Copyright (C) 2002-2005  3Dlabs Inc. Ltd.
// Copyright (C) 2012-2013 LunarG, 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 3Dlabs Inc. Ltd. 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 HOLDERS 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 _COMMON_INCLUDED_
#define _COMMON_INCLUDED_

#include <algorithm>
#include <cassert>
#ifdef _MSC_VER
#include <cfloat>
#else
#include <cmath>
#endif
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <list>
#include <map>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>

#if defined(__ANDROID__)
#include <sstream>
namespace std {
template<typename T>
std::string to_string(const T& val) {
  std::ostringstream os;
  os << val;
  return os.str();
}
}
#endif

#if defined(MINGW_HAS_SECURE_API) && MINGW_HAS_SECURE_API
    #include <basetsd.h>
    #ifndef snprintf
    #define snprintf …
    #endif
    #define safe_vsprintf …
#elif defined (solaris)
    #define safe_vsprintf …
    #include <sys/int_types.h>
    #define UINT_PTR …
#else
    #define safe_vsprintf(buf,max,format,args) …
    #include <stdint.h>
    #define UINT_PTR …
#endif

#if defined(_MSC_VER)
#define strdup …
#endif

/* windows only pragma */
#ifdef _MSC_VER
    #pragma warning(disable : 4786) // Don't warn about too long identifiers
    #pragma warning(disable : 4514) // unused inline method
    #pragma warning(disable : 4201) // nameless union
#endif

// Allow compilation to WASI which does not support threads yet.
#ifdef __wasi__ 
#define DISABLE_THREAD_SUPPORT
#endif

#include "PoolAlloc.h"

//
// Put POOL_ALLOCATOR_NEW_DELETE in base classes to make them use this scheme.
//
#define POOL_ALLOCATOR_NEW_DELETE(A) …

namespace glslang {

    //
    // Pool version of string.
    //
    TStringAllocator;
    TString;

} // end namespace glslang

// Repackage the std::hash for use by unordered map/set with a TString key.
namespace std {

    template<> struct hash<glslang::TString> { … };
}

namespace glslang {

inline TString* NewPoolTString(const char* s)
{ … }

template<class T> inline T* NewPoolObject(T*)
{ … }

template<class T> inline T* NewPoolObject(T, int instances)
{ … }

inline bool StartsWith(TString const &str, const char *prefix)
{ … }

//
// Pool allocator versions of vectors, lists, and maps
//
template <class T> class TVector : public std::vector<T, pool_allocator<T> > { … };

template <class T> class TList  : public std::list<T, pool_allocator<T> > { … };

template <class K, class D, class CMP = std::less<K> >
class TMap : public std::map<K, D, CMP, pool_allocator<std::pair<K const, D> > > { … };

template <class K, class D, class HASH = std::hash<K>, class PRED = std::equal_to<K> >
class TUnorderedMap : public std::unordered_map<K, D, HASH, PRED, pool_allocator<std::pair<K const, D> > > { … };

template <class K, class CMP = std::less<K> >
class TSet : public std::set<K, CMP, pool_allocator<K> > { … };

//
// Persistent string memory.  Should only be used for strings that survive
// across compiles/links.
//
TPersistString;

//
// templatized min and max functions.
//
template <class T> T Min(const T a, const T b) { … }
template <class T> T Max(const T a, const T b) { … }

//
// Create a TString object from an integer.
//
#if defined(_MSC_VER) || (defined(MINGW_HAS_SECURE_API) && MINGW_HAS_SECURE_API)
inline const TString String(const int i, const int base = 10)
{
    char text[16];     // 32 bit ints are at most 10 digits in base 10
    _itoa_s(i, text, sizeof(text), base);
    return text;
}
#else
inline const TString String(const int i, const int /*base*/ = 10)
{ … }
#endif

struct TSourceLoc { … };

class TPragmaTable : public TMap<TString, TString> { … };

const int MaxTokenLength = …;

template <class T> bool IsPow2(T powerOf2)
{ … }

// Round number up to a multiple of the given powerOf2, which is not
// a power, just a number that must be a power of 2.
template <class T> void RoundToPow2(T& number, int powerOf2)
{ … }

template <class T> bool IsMultipleOfPow2(T number, int powerOf2)
{ … }

// Returns log2 of an integer power of 2.
// T should be integral.
template <class T> int IntLog2(T n)
{ … }

} // end namespace glslang

#endif // _COMMON_INCLUDED_