Common.h File Reference

#include <sstream>
#include <stdint.h>
#include <set>
#include <unordered_set>
#include <vector>
#include <map>
#include <unordered_map>
#include <list>
#include <algorithm>
#include <string>
#include <cstdio>
#include <cassert>
#include "PoolAlloc.h"

Include dependency graph for Common.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	std::hash< glslang::TString >
class	glslang::TVector< T >
class	glslang::TList< T >
class	glslang::TMap< K, D, CMP >
class	glslang::TUnorderedMap< K, D, HASH, PRED >
struct	glslang::TSourceLoc
class	glslang::TPragmaTable

Namespaces
	std
	glslang

Macros
#define	safe_vsprintf(buf, max, format, args)   vsnprintf((buf), (max), (format), (args))
#define	UINT_PTR   uintptr_t
#define	POOL_ALLOCATOR_NEW_DELETE(A)

Typedefs
typedef pool_allocator< char >	glslang::TStringAllocator
typedef std::basic_string< char, std::char_traits< char >, TStringAllocator >	glslang::TString
typedef std::basic_string< char >	glslang::TPersistString

Functions
template<typename T >
std::string	std::to_string (const T &val)
TString *	glslang::NewPoolTString (const char *s)
template<class T >
T *	glslang::NewPoolObject (T *)
template<class T >
T *	glslang::NewPoolObject (T, int instances)
template<class T >
T	glslang::Min (const T a, const T b)
template<class T >
T	glslang::Max (const T a, const T b)
const TString	glslang::String (const int i, const int=10)
template<class T >
bool	glslang::IsPow2 (T powerOf2)
template<class T >
void	glslang::RoundToPow2 (T &number, int powerOf2)
template<class T >
bool	glslang::IsMultipleOfPow2 (T number, int powerOf2)

Variables
const int	glslang::MaxTokenLength = 1024

Macro Definition Documentation

POOL_ALLOCATOR_NEW_DELETE

#define POOL_ALLOCATOR_NEW_DELETE

(

A

)

Value:

void* operator new(size_t s) { return (A).allocate(s); }          \
    void* operator new(size_t, void *_Where) { return (_Where); }     \
    void operator delete(void*) { }                                   \
    void operator delete(void *, void *) { }                          \
    void* operator new[](size_t s) { return (A).allocate(s); }        \
    void* operator new[](size_t, void *_Where) { return (_Where); }   \
    void operator delete[](void*) { }                                 \
    void operator delete[](void *, void *) { }

safe_vsprintf

#define safe_vsprintf	(		buf,
			max,
			format,
			args
	)		vsnprintf((buf), (max), (format), (args))

UINT_PTR

#define UINT_PTR   uintptr_t