} while (deGetFalse())
// \todo [2015-07-14 pyry] Check FUNC type by checkedCastToPtr<T>() or similar
-#define VK_NULL_FUNC_ENTRY(NAME, FUNC) { #NAME, (deFunctionPtr)FUNC }
+#define VK_NULL_FUNC_ENTRY(NAME, FUNC) { #NAME, (deFunctionPtr)FUNC } // NOLINT(FUNC)
#define VK_NULL_DEFINE_DEVICE_OBJ(NAME) \
struct NAME \
for (int configNdx = 0; configNdx < DE_LENGTH_OF_ARRAY(TEST_CASES); configNdx++) \
{ \
std::ostringstream desc; \
- const TestCaseConfig config = TEST_CASES[configNdx]; \
+ const TestCaseConfig config = (TEST_CASES)[configNdx]; \
desc << "Samples level " << config.samplerLod << " with :\n" << config.subresourceRange; \
rangeTests->addChild(new ImageViewTest(testCtx, config.name, desc.str().c_str(), viewType, \
imageFormat, config.samplerLod, componentMapping, \
ExprP<TRET> NAME (const ExprP<T0>& arg0) { return app<CLASS>(arg0); }
#define DEFINE_DERIVED1(CLASS, TRET, NAME, T0, ARG0, EXPANSION) \
-class CLASS : public DerivedFunc<Signature<TRET, T0> > \
+class CLASS : public DerivedFunc<Signature<TRET, T0> > /* NOLINT(CLASS) */ \
{ \
public: \
string getName (void) const { return #NAME; } \
ExprP<TRET> doExpand (ExpandContext&, \
const CLASS::ArgExprs& args_) const \
{ \
- const ExprP<float>& ARG0 = args_.a; \
+ const ExprP<float>& (ARG0) = args_.a; \
return EXPANSION; \
} \
}; \
}
#define DEFINE_DERIVED2(CLASS, TRET, NAME, T0, Arg0, T1, Arg1, EXPANSION) \
-class CLASS : public DerivedFunc<Signature<TRET, T0, T1> > \
+class CLASS : public DerivedFunc<Signature<TRET, T0, T1> > /* NOLINT(CLASS) */ \
{ \
public: \
string getName (void) const { return #NAME; } \
protected: \
ExprP<TRET> doExpand (ExpandContext&, const ArgExprs& args_) const \
{ \
- const ExprP<T0>& Arg0 = args_.a; \
- const ExprP<T1>& Arg1 = args_.b; \
+ const ExprP<T0>& (Arg0) = args_.a; \
+ const ExprP<T1>& (Arg1) = args_.b; \
return EXPANSION; \
} \
}; \
}
#define DEFINE_DERIVED3(CLASS, TRET, NAME, T0, ARG0, T1, ARG1, T2, ARG2, EXPANSION) \
-class CLASS : public DerivedFunc<Signature<TRET, T0, T1, T2> > \
+class CLASS : public DerivedFunc<Signature<TRET, T0, T1, T2> > /* NOLINT(CLASS) */ \
{ \
public: \
string getName (void) const { return #NAME; } \
protected: \
ExprP<TRET> doExpand (ExpandContext&, const ArgExprs& args_) const \
{ \
- const ExprP<T0>& ARG0 = args_.a; \
- const ExprP<T1>& ARG1 = args_.b; \
- const ExprP<T2>& ARG2 = args_.c; \
+ const ExprP<T0>& (ARG0) = args_.a; \
+ const ExprP<T1>& (ARG1) = args_.b; \
+ const ExprP<T2>& (ARG2) = args_.c; \
return EXPANSION; \
} \
}; \
void LocalStructTests::init (void)
{
- #define LOCAL_STRUCT_CASE(NAME, DESCRIPTION, SHADER_SRC, SET_UNIFORMS_BODY, EVAL_FUNC_BODY) \
- do { \
- struct SetUniforms_##NAME { static void setUniforms (ShaderRenderCaseInstance& instance, const tcu::Vec4&) SET_UNIFORMS_BODY }; \
- struct Eval_##NAME { static void eval (ShaderEvalContext& c) EVAL_FUNC_BODY }; \
+ #define LOCAL_STRUCT_CASE(NAME, DESCRIPTION, SHADER_SRC, SET_UNIFORMS_BODY, EVAL_FUNC_BODY) \
+ do { \
+ struct SetUniforms_##NAME { static void setUniforms (ShaderRenderCaseInstance& instance, const tcu::Vec4&) SET_UNIFORMS_BODY }; /* NOLINT(SET_UNIFORMS_BODY) */ \
+ struct Eval_##NAME { static void eval (ShaderEvalContext& c) EVAL_FUNC_BODY }; /* NOLINT(EVAL_FUNC_BODY) */ \
addChild(createStructCase(m_testCtx, #NAME "_vertex", DESCRIPTION, true, &Eval_##NAME::eval, &SetUniforms_##NAME::setUniforms, SHADER_SRC).release()); \
addChild(createStructCase(m_testCtx, #NAME "_fragment", DESCRIPTION, false, &Eval_##NAME::eval, &SetUniforms_##NAME::setUniforms, SHADER_SRC).release()); \
} while (deGetFalse())
{
#define UNIFORM_STRUCT_CASE(NAME, DESCRIPTION, SHADER_SRC, SET_UNIFORMS_BODY, EVAL_FUNC_BODY) \
do { \
- struct SetUniforms_##NAME { static void setUniforms (ShaderRenderCaseInstance& instance, const tcu::Vec4& constCoords) SET_UNIFORMS_BODY }; \
- struct Eval_##NAME { static void eval (ShaderEvalContext& c) EVAL_FUNC_BODY }; \
+ struct SetUniforms_##NAME { \
+ static void setUniforms (ShaderRenderCaseInstance& instance, const tcu::Vec4& constCoords) SET_UNIFORMS_BODY /* NOLINT(SET_UNIFORMS_BODY) */ \
+ }; \
+ struct Eval_##NAME { static void eval (ShaderEvalContext& c) EVAL_FUNC_BODY }; /* NOLINT(EVAL_FUNC_BODY) */ \
addChild(createStructCase(m_testCtx, #NAME "_vertex", DESCRIPTION, true, Eval_##NAME::eval, SetUniforms_##NAME::setUniforms, SHADER_SRC).release()); \
addChild(createStructCase(m_testCtx, #NAME "_fragment", DESCRIPTION, false, Eval_##NAME::eval, SetUniforms_##NAME::setUniforms, SHADER_SRC).release()); \
} while (deGetFalse())
#define ADD_OPATOMIC_CASE(NAME, ASSEMBLY, CALCULATE_EXPECTED, NUM_OUTPUT_ELEMENTS) \
do { \
- DE_STATIC_ASSERT(NUM_OUTPUT_ELEMENTS == 1 || NUM_OUTPUT_ELEMENTS == numElements); \
- struct calculateExpected_##NAME { static void calculateExpected(deInt32& expected, deInt32 input) CALCULATE_EXPECTED }; \
+ DE_STATIC_ASSERT((NUM_OUTPUT_ELEMENTS) == 1 || (NUM_OUTPUT_ELEMENTS) == numElements); \
+ struct calculateExpected_##NAME { static void calculateExpected(deInt32& expected, deInt32 input) CALCULATE_EXPECTED }; /* NOLINT(CALCULATE_EXPECTED) */ \
cases.push_back(OpAtomicCase(#NAME, ASSEMBLY, calculateExpected_##NAME::calculateExpected, NUM_OUTPUT_ELEMENTS)); \
} while (deGetFalse())
#define ADD_OPATOMIC_CASE_1(NAME, ASSEMBLY, CALCULATE_EXPECTED) ADD_OPATOMIC_CASE(NAME, ASSEMBLY, CALCULATE_EXPECTED, 1)
::tcu::Interval VAR##_hi_; \
\
{ \
- ::tcu::Interval& VAR = VAR##_lo_; \
+ ::tcu::Interval& (VAR) = VAR##_lo_; \
::deSetRoundingMode(DE_ROUNDINGMODE_TO_NEGATIVE_INF); \
SETLOW; \
} \
{ \
- ::tcu::Interval& VAR = VAR##_hi_; \
+ ::tcu::Interval& (VAR) = VAR##_hi_; \
::deSetRoundingMode(DE_ROUNDINGMODE_TO_POSITIVE_INF); \
SETHIGH; \
} \
else \
{ \
{ \
- const double PARAM = VAR##_arg_.lo(); \
- ::tcu::Interval& VAR = VAR##_lo_; \
+ const double (PARAM) = VAR##_arg_.lo(); \
+ ::tcu::Interval& (VAR) = VAR##_lo_; \
BODY; \
} \
{ \
- const double PARAM = VAR##_arg_.hi(); \
- ::tcu::Interval& VAR = VAR##_hi_; \
+ const double (PARAM) = VAR##_arg_.hi(); \
+ ::tcu::Interval& (VAR) = VAR##_hi_; \
BODY; \
} \
VAR##_dst_ = VAR##_lo_ | VAR##_hi_; \
/* Function pointer type. */
typedef void (*deFunctionPtr) (void);
+/* Use DE_PTR_TYPE(T) instead of T* in macros to avoid clang-tidy warning. */
+#define DE_PTR_TYPE(T) T* /* NOLINT(T) */
+
/* Debug macro. */
#if defined(DE_DEBUG)
/* Already defined from outside. */
#endif
/** Swap two values. */
-#define DE_SWAP(TYPE, A, B) do { TYPE _tmp_ = A; A = B; B = _tmp_; } while(deGetFalse())
+#define DE_SWAP(TYPE, A, B) do { TYPE _tmp_ = (A); (A) = (B); (B) = _tmp_; } while(deGetFalse())
/** Offset of a struct member. */
#define DE_OFFSET_OF(STRUCT, MEMBER) ((int)(deUintptr)(deUint8*)&(((STRUCT*)0)->MEMBER))
*//*--------------------------------------------------------------------*/
#define DE_DECLARE_POOL_ARRAY(TYPENAME, VALUETYPE) \
\
-typedef struct TYPENAME##_s \
-{ \
- deMemPool* pool; \
-\
- int elementSize; \
- int numElements; \
- int capacity; \
-\
- int pageTableCapacity; \
- VALUETYPE** pageTable; \
-} TYPENAME; \
+typedef struct TYPENAME##_s \
+{ \
+ deMemPool* pool; \
+ \
+ int elementSize; \
+ int numElements; \
+ int capacity; \
+ \
+ int pageTableCapacity; \
+ DE_PTR_TYPE(VALUETYPE)* pageTable; \
+} TYPENAME; /* NOLINT(TYPENAME) */ \
\
-DE_INLINE TYPENAME* TYPENAME##_create (deMemPool* pool); \
-DE_INLINE int TYPENAME##_getNumElements (const TYPENAME* arr) DE_UNUSED_FUNCTION; \
-DE_INLINE deBool TYPENAME##_reserve (TYPENAME* arr, int capacity) DE_UNUSED_FUNCTION; \
-DE_INLINE deBool TYPENAME##_setSize (TYPENAME* arr, int size) DE_UNUSED_FUNCTION; \
-DE_INLINE void TYPENAME##_reset (TYPENAME* arr) DE_UNUSED_FUNCTION; \
-DE_INLINE VALUETYPE TYPENAME##_get (const TYPENAME* arr, int ndx) DE_UNUSED_FUNCTION; \
-DE_INLINE void TYPENAME##_set (TYPENAME* arr, int ndx, VALUETYPE elem) DE_UNUSED_FUNCTION; \
-DE_INLINE deBool TYPENAME##_pushBack (TYPENAME* arr, VALUETYPE elem) DE_UNUSED_FUNCTION; \
-DE_INLINE VALUETYPE TYPENAME##_popBack (TYPENAME* arr) DE_UNUSED_FUNCTION; \
-DE_INLINE deBool TYPENAME##_copy (TYPENAME* dst, const TYPENAME* src) DE_UNUSED_FUNCTION; \
-DE_INLINE void TYPENAME##_swap (TYPENAME* arr, int aNdx, int bNdx) DE_UNUSED_FUNCTION; \
+DE_INLINE TYPENAME* TYPENAME##_create (deMemPool* pool); \
+DE_INLINE int TYPENAME##_getNumElements (const TYPENAME* arr) DE_UNUSED_FUNCTION; \
+DE_INLINE deBool TYPENAME##_reserve (DE_PTR_TYPE(TYPENAME) arr, int capacity) DE_UNUSED_FUNCTION; \
+DE_INLINE deBool TYPENAME##_setSize (DE_PTR_TYPE(TYPENAME) arr, int size) DE_UNUSED_FUNCTION; \
+DE_INLINE void TYPENAME##_reset (DE_PTR_TYPE(TYPENAME) arr) DE_UNUSED_FUNCTION; \
+DE_INLINE VALUETYPE TYPENAME##_get (const TYPENAME* arr, int ndx) DE_UNUSED_FUNCTION; \
+DE_INLINE void TYPENAME##_set (DE_PTR_TYPE(TYPENAME) arr, int ndx, VALUETYPE elem) DE_UNUSED_FUNCTION; \
+DE_INLINE deBool TYPENAME##_pushBack (DE_PTR_TYPE(TYPENAME) arr, VALUETYPE elem) DE_UNUSED_FUNCTION; \
+DE_INLINE VALUETYPE TYPENAME##_popBack (DE_PTR_TYPE(TYPENAME) arr) DE_UNUSED_FUNCTION; \
+DE_INLINE deBool TYPENAME##_copy (DE_PTR_TYPE(TYPENAME) dst, const TYPENAME* src) DE_UNUSED_FUNCTION; \
+DE_INLINE void TYPENAME##_swap (DE_PTR_TYPE(TYPENAME) arr, int aNdx, int bNdx) DE_UNUSED_FUNCTION; \
\
DE_INLINE TYPENAME* TYPENAME##_create (deMemPool* pool) \
{ \
return arr->numElements; \
} \
\
-DE_INLINE deBool TYPENAME##_reserve (TYPENAME* arr, int capacity) \
+DE_INLINE deBool TYPENAME##_reserve (DE_PTR_TYPE(TYPENAME) arr, int capacity) \
{ \
if (capacity > arr->capacity) \
return dePoolArray_reserve((dePoolArray*)arr, capacity); \
return DE_TRUE; \
} \
\
-DE_INLINE deBool TYPENAME##_setSize (TYPENAME* arr, int size) \
+DE_INLINE deBool TYPENAME##_setSize (DE_PTR_TYPE(TYPENAME) arr, int size) \
{ \
if (size > arr->capacity) \
return dePoolArray_setSize((dePoolArray*)arr, size); \
return DE_TRUE; \
} \
\
-DE_INLINE void TYPENAME##_reset (TYPENAME* arr) \
+DE_INLINE void TYPENAME##_reset (DE_PTR_TYPE(TYPENAME) arr) \
{ \
arr->numElements = 0; \
} \
} \
} \
\
-DE_INLINE void TYPENAME##_set (TYPENAME* arr, int ndx, VALUETYPE elem) \
+DE_INLINE void TYPENAME##_set (DE_PTR_TYPE(TYPENAME) arr, int ndx, VALUETYPE elem) \
{ \
DE_ASSERT(ndx >= 0 && ndx < arr->numElements); \
{ \
} \
} \
\
-DE_INLINE deBool TYPENAME##_pushBack (TYPENAME* arr, VALUETYPE elem) \
+DE_INLINE deBool TYPENAME##_pushBack (DE_PTR_TYPE(TYPENAME) arr, VALUETYPE elem) \
{ \
if ((arr->numElements + 1 >= arr->capacity) && !TYPENAME##_reserve(arr, arr->numElements + 1)) \
return DE_FALSE; \
return DE_TRUE; \
} \
\
-DE_INLINE VALUETYPE TYPENAME##_popBack (TYPENAME* arr) \
+DE_INLINE VALUETYPE TYPENAME##_popBack (DE_PTR_TYPE(TYPENAME) arr) \
{ \
int ndx = arr->numElements - 1; \
int pageNdx = (ndx >> DE_ARRAY_ELEMENTS_PER_PAGE_LOG2); \
return ((VALUETYPE*)arr->pageTable[pageNdx])[subNdx]; \
} \
\
-DE_INLINE deBool TYPENAME##_copy (TYPENAME* dst, const TYPENAME* src) \
+DE_INLINE deBool TYPENAME##_copy (DE_PTR_TYPE(TYPENAME) dst, const TYPENAME* src) \
{ \
DE_ASSERT(dst && src); \
{ \
return DE_TRUE; \
} \
\
-DE_INLINE void TYPENAME##_swap (TYPENAME* arr, int aNdx, int bNdx) \
+DE_INLINE void TYPENAME##_swap (DE_PTR_TYPE(TYPENAME) arr, int aNdx, int bNdx) \
{ \
VALUETYPE tmp = TYPENAME##_get(arr, aNdx); \
TYPENAME##_set(arr, aNdx, TYPENAME##_get(arr, bNdx)); \
*//*--------------------------------------------------------------------*/
#define DE_DECLARE_POOL_ARRAY_SORT(TYPENAME, VALUETYPE, SORTNAME, CMPFUNC) \
\
-DE_INLINE void TYPENAME##_##SORTNAME##ShiftDown (TYPENAME* arr, int startNdx, int endNdx) \
+DE_INLINE void TYPENAME##_##SORTNAME##ShiftDown (DE_PTR_TYPE(TYPENAME) arr, int startNdx, int endNdx) \
{ \
int rootNdx = startNdx; \
\
} \
} \
\
-DE_INLINE void TYPENAME##_##SORTNAME##Heapify (TYPENAME* arr) \
+DE_INLINE void TYPENAME##_##SORTNAME##Heapify (DE_PTR_TYPE(TYPENAME) arr) \
{ \
int startNdx = (TYPENAME##_getNumElements(arr) - 2) / 2; \
\
} \
} \
\
-DE_INLINE void TYPENAME##_##SORTNAME (TYPENAME* arr) \
+DE_INLINE void TYPENAME##_##SORTNAME (DE_PTR_TYPE(TYPENAME) arr) \
{ \
int endNdx = TYPENAME##_getNumElements(arr) - 1; \
\
int slotTableSize; \
TYPENAME##Slot** slotTable; \
TYPENAME##Slot* slotFreeList; \
-} TYPENAME; \
+} TYPENAME; /* NOLINT(TYPENAME) */ \
\
typedef struct TYPENAME##Iter_s \
{ \
int curElemIndex; \
} TYPENAME##Iter; \
\
-TYPENAME* TYPENAME##_create (deMemPool* pool); \
-void TYPENAME##_reset (TYPENAME* hash); \
-deBool TYPENAME##_reserve (TYPENAME* hash, int capacity); \
-VALUETYPE* TYPENAME##_find (const TYPENAME* hash, KEYTYPE key); \
-deBool TYPENAME##_insert (TYPENAME* hash, KEYTYPE key, VALUETYPE value); \
-void TYPENAME##_delete (TYPENAME* hash, KEYTYPE key); \
+TYPENAME* TYPENAME##_create (deMemPool* pool); \
+void TYPENAME##_reset (DE_PTR_TYPE(TYPENAME) hash); \
+deBool TYPENAME##_reserve (DE_PTR_TYPE(TYPENAME) hash, int capacity); \
+VALUETYPE* TYPENAME##_find (const TYPENAME* hash, KEYTYPE key); \
+deBool TYPENAME##_insert (DE_PTR_TYPE(TYPENAME) hash, KEYTYPE key, VALUETYPE value); \
+void TYPENAME##_delete (DE_PTR_TYPE(TYPENAME) hash, KEYTYPE key); \
\
DE_INLINE int TYPENAME##_getNumElements (const TYPENAME* hash) DE_UNUSED_FUNCTION; \
DE_INLINE void TYPENAME##Iter_init (const TYPENAME* hash, TYPENAME##Iter* iter) DE_UNUSED_FUNCTION; \
TYPENAME* TYPENAME##_create (deMemPool* pool) \
{ \
/* Alloc struct. */ \
- TYPENAME* hash = DE_POOL_NEW(pool, TYPENAME); \
+ DE_PTR_TYPE(TYPENAME) hash = DE_POOL_NEW(pool, TYPENAME); \
if (!hash) \
return DE_NULL; \
\
return hash; \
} \
\
-void TYPENAME##_reset (TYPENAME* hash) \
+void TYPENAME##_reset (DE_PTR_TYPE(TYPENAME) hash) \
{ \
int slotNdx; \
for (slotNdx = 0; slotNdx < hash->slotTableSize; slotNdx++) \
hash->numElements = 0; \
} \
\
-TYPENAME##Slot* TYPENAME##_allocSlot (TYPENAME* hash) \
+TYPENAME##Slot* TYPENAME##_allocSlot (DE_PTR_TYPE(TYPENAME) hash) \
{ \
TYPENAME##Slot* slot; \
if (hash->slotFreeList) \
return slot; \
} \
\
-deBool TYPENAME##_rehash (TYPENAME* hash, int newSlotTableSize) \
+deBool TYPENAME##_rehash (DE_PTR_TYPE(TYPENAME) hash, int newSlotTableSize) \
{ \
DE_ASSERT(deIsPowerOfTwo32(newSlotTableSize) && newSlotTableSize > 0); \
if (newSlotTableSize > hash->slotTableSize) \
return DE_NULL; \
} \
\
-deBool TYPENAME##_insert (TYPENAME* hash, KEYTYPE key, VALUETYPE value) \
+deBool TYPENAME##_insert (DE_PTR_TYPE(TYPENAME) hash, KEYTYPE key, VALUETYPE value) \
{ \
int slotNdx; \
TYPENAME##Slot* slot; \
} \
} \
\
-void TYPENAME##_delete (TYPENAME* hash, KEYTYPE key) \
+void TYPENAME##_delete (DE_PTR_TYPE(TYPENAME) hash, KEYTYPE key) \
{ \
int slotNdx; \
TYPENAME##Slot* slot; \
/* Copy-to-array templates. */
#define DE_DECLARE_POOL_HASH_TO_ARRAY(HASHTYPENAME, KEYARRAYTYPENAME, VALUEARRAYTYPENAME) \
- deBool HASHTYPENAME##_copyToArray(const HASHTYPENAME* set, KEYARRAYTYPENAME* keyArray, VALUEARRAYTYPENAME* valueArray); \
+ deBool HASHTYPENAME##_copyToArray(const HASHTYPENAME* set, DE_PTR_TYPE(KEYARRAYTYPENAME) keyArray, DE_PTR_TYPE(VALUEARRAYTYPENAME) valueArray); \
struct HASHTYPENAME##_##KEYARRAYTYPENAME##_##VALUEARRAYTYPENAME##_declare_dummy { int dummy; }
#define DE_IMPLEMENT_POOL_HASH_TO_ARRAY(HASHTYPENAME, KEYARRAYTYPENAME, VALUEARRAYTYPENAME) \
-deBool HASHTYPENAME##_copyToArray(const HASHTYPENAME* hash, KEYARRAYTYPENAME* keyArray, VALUEARRAYTYPENAME* valueArray) \
+deBool HASHTYPENAME##_copyToArray(const HASHTYPENAME* hash, DE_PTR_TYPE(KEYARRAYTYPENAME) keyArray, DE_PTR_TYPE(VALUEARRAYTYPENAME) valueArray) \
{ \
int numElements = hash->numElements; \
int arrayNdx = 0; \
{ \
TYPENAME##Hash* hash; \
TYPENAME##Array* array; \
-} TYPENAME; \
+} TYPENAME; /* NOLINT(TYPENAME) */ \
\
TYPENAME* TYPENAME##_create (deMemPool* pool); \
-deBool TYPENAME##_insert (TYPENAME* hashArray, KEYTYPE key, VALUETYPE value); \
-deBool TYPENAME##_copyToArray (const TYPENAME* hashArray, KEYARRAYTYPE* keys, VALUEARRAYTYPE* values); \
+deBool TYPENAME##_insert (DE_PTR_TYPE(TYPENAME) hashArray, KEYTYPE key, VALUETYPE value); \
+deBool TYPENAME##_copyToArray (const TYPENAME* hashArray, DE_PTR_TYPE(KEYARRAYTYPE) keys, DE_PTR_TYPE(VALUEARRAYTYPE) values); \
\
DE_INLINE int TYPENAME##_getNumElements (const TYPENAME* hashArray) DE_UNUSED_FUNCTION; \
DE_INLINE VALUETYPE* TYPENAME##_find (const TYPENAME* hashArray, KEYTYPE key) DE_UNUSED_FUNCTION; \
-DE_INLINE void TYPENAME##_reset (TYPENAME* hashArray) DE_UNUSED_FUNCTION; \
+DE_INLINE void TYPENAME##_reset (DE_PTR_TYPE(TYPENAME) hashArray) DE_UNUSED_FUNCTION; \
\
DE_INLINE int TYPENAME##_getNumElements (const TYPENAME* hashArray) \
{ \
} \
} \
\
-DE_INLINE void TYPENAME##_reset (TYPENAME* hashArray) \
+DE_INLINE void TYPENAME##_reset (DE_PTR_TYPE(TYPENAME) hashArray) \
{ \
TYPENAME##Hash_reset(hashArray->hash); \
TYPENAME##Array_reset(hashArray->array); \
\
TYPENAME* TYPENAME##_create (deMemPool* pool) \
{ \
- TYPENAME* hashArray = DE_POOL_NEW(pool, TYPENAME); \
+ DE_PTR_TYPE(TYPENAME) hashArray = DE_POOL_NEW(pool, TYPENAME); \
if (!hashArray) return DE_NULL; \
if ((hashArray->hash = TYPENAME##Hash_create(pool)) == DE_NULL) \
return DE_NULL; \
return hashArray; \
} \
\
-deBool TYPENAME##_insert (TYPENAME* hashArray, KEYTYPE key, VALUETYPE value) \
+deBool TYPENAME##_insert (DE_PTR_TYPE(TYPENAME) hashArray, KEYTYPE key, VALUETYPE value) \
{ \
int numElements = TYPENAME##Array_getNumElements(hashArray->array); \
DE_ASSERT(TYPENAME##Hash_getNumElements(hashArray->hash) == numElements); \
return DE_TRUE; \
} \
\
-deBool TYPENAME##_copyToArray (const TYPENAME* hashArray, KEYARRAYTYPE* keys, VALUEARRAYTYPE* values) \
+deBool TYPENAME##_copyToArray (const TYPENAME* hashArray, DE_PTR_TYPE(KEYARRAYTYPE) keys, DE_PTR_TYPE(VALUEARRAYTYPE) values) \
{ \
int numElements = TYPENAME##Array_getNumElements(hashArray->array); \
TYPENAME##Hash* hash = hashArray->hash; \
typedef struct TYPENAME##_s \
{ \
TYPENAME##Hash* hash; \
-} TYPENAME; \
+} TYPENAME; /* NOLINT(TYPENAME) */ \
\
DE_INLINE TYPENAME* TYPENAME##_create (deMemPool* pool); \
-DE_INLINE int TYPENAME##_getNumElements (const TYPENAME* hashSet) DE_UNUSED_FUNCTION; \
-DE_INLINE TYPENAME##Hash* TYPENAME##_getHash (const TYPENAME* hashSet) DE_UNUSED_FUNCTION; \
-DE_INLINE deBool TYPENAME##_insert (TYPENAME* hashSet, KEYTYPE key, VALUETYPE value) DE_UNUSED_FUNCTION; \
-DE_INLINE deBool TYPENAME##_safeInsert (TYPENAME* hashSet, KEYTYPE key, VALUETYPE value) DE_UNUSED_FUNCTION; \
-DE_INLINE TYPENAME##Set* TYPENAME##_find (const TYPENAME* hashSet, KEYTYPE key) DE_UNUSED_FUNCTION; \
-DE_INLINE void TYPENAME##_delete (TYPENAME* hashSet, KEYTYPE key, VALUETYPE value) DE_UNUSED_FUNCTION; \
-DE_INLINE deBool TYPENAME##_exists (const TYPENAME* hashSet, KEYTYPE key, VALUETYPE value) DE_UNUSED_FUNCTION; \
+DE_INLINE int TYPENAME##_getNumElements (const TYPENAME* hashSet) DE_UNUSED_FUNCTION; \
+DE_INLINE TYPENAME##Hash* TYPENAME##_getHash (const TYPENAME* hashSet) DE_UNUSED_FUNCTION; \
+DE_INLINE deBool TYPENAME##_insert (DE_PTR_TYPE(TYPENAME) hashSet, KEYTYPE key, VALUETYPE value) DE_UNUSED_FUNCTION; \
+DE_INLINE deBool TYPENAME##_safeInsert (DE_PTR_TYPE(TYPENAME) hashSet, KEYTYPE key, VALUETYPE value) DE_UNUSED_FUNCTION; \
+DE_INLINE TYPENAME##Set* TYPENAME##_find (const TYPENAME* hashSet, KEYTYPE key) DE_UNUSED_FUNCTION; \
+DE_INLINE void TYPENAME##_delete (DE_PTR_TYPE(TYPENAME) hashSet, KEYTYPE key, VALUETYPE value) DE_UNUSED_FUNCTION; \
+DE_INLINE deBool TYPENAME##_exists (const TYPENAME* hashSet, KEYTYPE key, VALUETYPE value) DE_UNUSED_FUNCTION; \
\
DE_INLINE TYPENAME* TYPENAME##_create (deMemPool* pool) \
{ \
- TYPENAME* hashSet = DE_POOL_NEW(pool, TYPENAME); \
+ DE_PTR_TYPE(TYPENAME) hashSet = DE_POOL_NEW(pool, TYPENAME); \
if (!hashSet) return DE_NULL; \
if ((hashSet->hash = TYPENAME##Hash_create(pool)) == DE_NULL) \
return DE_NULL; \
return hashSet->hash; \
} \
\
-DE_INLINE deBool TYPENAME##_insert (TYPENAME* hashSet, KEYTYPE key, VALUETYPE value) \
+DE_INLINE deBool TYPENAME##_insert (DE_PTR_TYPE(TYPENAME) hashSet, KEYTYPE key, VALUETYPE value) \
{ \
TYPENAME##Set** setPtr = TYPENAME##Hash_find(hashSet->hash, key); \
TYPENAME##Set* set = setPtr ? *setPtr : DE_NULL; \
} \
} \
\
-DE_INLINE deBool TYPENAME##_safeInsert (TYPENAME* hashSet, KEYTYPE key, VALUETYPE value) \
+DE_INLINE deBool TYPENAME##_safeInsert (DE_PTR_TYPE(TYPENAME) hashSet, KEYTYPE key, VALUETYPE value)\
{ \
TYPENAME##Set** setPtr = TYPENAME##Hash_find(hashSet->hash, key); \
TYPENAME##Set* set = setPtr ? *setPtr : DE_NULL; \
return setPtr ? *setPtr : DE_NULL; \
} \
\
-DE_INLINE void TYPENAME##_delete (TYPENAME* hashSet, KEYTYPE key, VALUETYPE value) \
+DE_INLINE void TYPENAME##_delete (DE_PTR_TYPE(TYPENAME) hashSet, KEYTYPE key, VALUETYPE value) \
{ \
TYPENAME##Set** setPtr = TYPENAME##Hash_find(hashSet->hash, key); \
TYPENAME##Set* set; \
typedef struct TYPENAME##_s \
{ \
TYPENAME##Array* array; \
-} TYPENAME; \
+} TYPENAME; /* NOLINT(TYPENAME) */ \
\
-DE_INLINE TYPENAME* TYPENAME##_create (deMemPool* pool); \
-DE_INLINE int TYPENAME##_getNumElements (const TYPENAME* heap) DE_UNUSED_FUNCTION; \
-DE_INLINE deBool TYPENAME##_reserve (TYPENAME* heap, int capacity) DE_UNUSED_FUNCTION; \
-DE_INLINE void TYPENAME##_reset (TYPENAME* heap) DE_UNUSED_FUNCTION; \
-DE_INLINE void TYPENAME##_moveDown (TYPENAME* heap, int ndx) DE_UNUSED_FUNCTION; \
-DE_INLINE void TYPENAME##_moveUp (TYPENAME* heap, int ndx) DE_UNUSED_FUNCTION; \
-DE_INLINE deBool TYPENAME##_push (TYPENAME* heap, VALUETYPE elem) DE_UNUSED_FUNCTION; \
-DE_INLINE VALUETYPE TYPENAME##_popMin (TYPENAME* heap) DE_UNUSED_FUNCTION; \
+DE_INLINE TYPENAME* TYPENAME##_create (deMemPool* pool); \
+DE_INLINE int TYPENAME##_getNumElements (const TYPENAME* heap) DE_UNUSED_FUNCTION; \
+DE_INLINE deBool TYPENAME##_reserve (DE_PTR_TYPE(TYPENAME) heap, int capacity) DE_UNUSED_FUNCTION; \
+DE_INLINE void TYPENAME##_reset (DE_PTR_TYPE(TYPENAME) heap) DE_UNUSED_FUNCTION; \
+DE_INLINE void TYPENAME##_moveDown (DE_PTR_TYPE(TYPENAME) heap, int ndx) DE_UNUSED_FUNCTION; \
+DE_INLINE void TYPENAME##_moveUp (DE_PTR_TYPE(TYPENAME) heap, int ndx) DE_UNUSED_FUNCTION; \
+DE_INLINE deBool TYPENAME##_push (DE_PTR_TYPE(TYPENAME) heap, VALUETYPE elem) DE_UNUSED_FUNCTION; \
+DE_INLINE VALUETYPE TYPENAME##_popMin (DE_PTR_TYPE(TYPENAME) heap) DE_UNUSED_FUNCTION; \
\
DE_INLINE TYPENAME* TYPENAME##_create (deMemPool* pool) \
{ \
- TYPENAME* heap = DE_POOL_NEW(pool, TYPENAME); \
+ DE_PTR_TYPE(TYPENAME) heap = DE_POOL_NEW(pool, TYPENAME); \
if (!heap) \
return DE_NULL; \
heap->array = TYPENAME##Array_create(pool); \
return TYPENAME##Array_getNumElements(heap->array); \
} \
\
-DE_INLINE deBool TYPENAME##_reserve (TYPENAME* heap, int capacity) \
+DE_INLINE deBool TYPENAME##_reserve (DE_PTR_TYPE(TYPENAME) heap, int capacity) \
{ \
return TYPENAME##Array_reserve(heap->array, capacity); \
} \
\
-DE_INLINE void TYPENAME##_reset (TYPENAME* heap) \
+DE_INLINE void TYPENAME##_reset (DE_PTR_TYPE(TYPENAME) heap) \
{ \
TYPENAME##Array_setSize(heap->array, 0); \
} \
\
-DE_INLINE void TYPENAME##_moveDown (TYPENAME* heap, int ndx) \
+DE_INLINE void TYPENAME##_moveDown (DE_PTR_TYPE(TYPENAME) heap, int ndx) \
{ \
TYPENAME##Array* array = heap->array; \
int numElements = TYPENAME##Array_getNumElements(array); \
} \
} \
\
-DE_INLINE void TYPENAME##_moveUp (TYPENAME* heap, int ndx) \
+DE_INLINE void TYPENAME##_moveUp (DE_PTR_TYPE(TYPENAME) heap, int ndx) \
{ \
TYPENAME##Array* array = heap->array; \
while (ndx > 0) \
} \
} \
\
-DE_INLINE deBool TYPENAME##_push (TYPENAME* heap, VALUETYPE elem) \
+DE_INLINE deBool TYPENAME##_push (DE_PTR_TYPE(TYPENAME) heap, VALUETYPE elem) \
{ \
TYPENAME##Array* array = heap->array; \
int numElements = TYPENAME##Array_getNumElements(array); \
return DE_TRUE; \
} \
\
-DE_INLINE VALUETYPE TYPENAME##_popMin (TYPENAME* heap) \
+DE_INLINE VALUETYPE TYPENAME##_popMin (DE_PTR_TYPE(TYPENAME) heap) \
{ \
TYPENAME##Array* array = heap->array; \
VALUETYPE tmp = TYPENAME##Array_get(array, 0); \
\
DE_DECLARE_POOL_HASH(TYPENAME##Hash, KEYTYPE, int); \
\
-typedef struct TYPENAME##_s \
-{ \
- deMemPool* pool; \
+typedef struct TYPENAME##_s \
+{ \
+ deMemPool* pool; \
int numElements; \
- TYPENAME##Hash* hash; \
-} TYPENAME; \
+ TYPENAME##Hash* hash; \
+} TYPENAME; /* NOLINT(TYPENAME) */ \
\
TYPENAME* TYPENAME##_create (deMemPool* pool); \
-void TYPENAME##_reset (TYPENAME* set); \
-deBool TYPENAME##_setKeyCount (TYPENAME* set, KEYTYPE key, int newCount); \
+void TYPENAME##_reset (DE_PTR_TYPE(TYPENAME) set); \
+deBool TYPENAME##_setKeyCount (DE_PTR_TYPE(TYPENAME) set, KEYTYPE key, int newCount); \
\
DE_INLINE int TYPENAME##_getNumElements (const TYPENAME* set) \
{ \
return (TYPENAME##_getKeyCount(set, key) > 0); \
} \
\
-DE_INLINE deBool TYPENAME##_insert (TYPENAME* set, KEYTYPE key) \
+DE_INLINE deBool TYPENAME##_insert (DE_PTR_TYPE(TYPENAME) set, KEYTYPE key) \
{ \
int oldCount = TYPENAME##_getKeyCount(set, key); \
return TYPENAME##_setKeyCount(set, key, oldCount + 1); \
} \
\
-DE_INLINE void TYPENAME##_delete (TYPENAME* set, KEYTYPE key) \
+DE_INLINE void TYPENAME##_delete (DE_PTR_TYPE(TYPENAME) set, KEYTYPE key) \
{ \
int oldCount = TYPENAME##_getKeyCount(set, key); \
DE_ASSERT(oldCount > 0); \
TYPENAME* TYPENAME##_create (deMemPool* pool) \
{ \
/* Alloc struct. */ \
- TYPENAME* set = DE_POOL_NEW(pool, TYPENAME); \
+ DE_PTR_TYPE(TYPENAME) set = DE_POOL_NEW(pool, TYPENAME); \
if (!set) \
return DE_NULL; \
\
return set; \
} \
\
-void TYPENAME##_reset (TYPENAME* set) \
+void TYPENAME##_reset (DE_PTR_TYPE(TYPENAME) set) \
{ \
TYPENAME##Hash_reset(set->hash); \
set->numElements = 0; \
} \
\
-deBool TYPENAME##_setKeyCount (TYPENAME* set, KEYTYPE key, int newCount) \
+deBool TYPENAME##_setKeyCount (DE_PTR_TYPE(TYPENAME) set, KEYTYPE key, int newCount) \
{ \
int* countPtr = TYPENAME##Hash_find(set->hash, key); \
int oldCount = countPtr ? *countPtr : 0; \
* void MultiSet_differenceInplace (Set* a, const Set* b);
* \endcode
*//*--------------------------------------------------------------------*/
-#define DE_DECLARE_POOL_MULTISET_SETWISE_OPERATIONS(TYPENAME) \
- deBool TYPENAME##_union (TYPENAME* to, const TYPENAME* a, const TYPENAME* b); \
- deBool TYPENAME##_unionInplace (TYPENAME* a, const TYPENAME* b); \
- deBool TYPENAME##_intersect (TYPENAME* to, const TYPENAME* a, const TYPENAME* b); \
- void TYPENAME##_intersectInplace (TYPENAME* a, const TYPENAME* b); \
- deBool TYPENAME##_sum (TYPENAME* to, const TYPENAME* a, const TYPENAME* b); \
- deBool TYPENAME##_sumInplace (TYPENAME* a, const TYPENAME* b); \
- deBool TYPENAME##_difference (TYPENAME* to, const TYPENAME* a, const TYPENAME* b); \
- void TYPENAME##_differenceInplace (TYPENAME* a, const TYPENAME* b); \
+#define DE_DECLARE_POOL_MULTISET_SETWISE_OPERATIONS(TYPENAME) \
+ deBool TYPENAME##_union (DE_PTR_TYPE(TYPENAME) to, const TYPENAME* a, const TYPENAME* b); \
+ deBool TYPENAME##_unionInplace (DE_PTR_TYPE(TYPENAME) a, const TYPENAME* b); \
+ deBool TYPENAME##_intersect (DE_PTR_TYPE(TYPENAME) to, const TYPENAME* a, const TYPENAME* b); \
+ void TYPENAME##_intersectInplace (DE_PTR_TYPE(TYPENAME) a, const TYPENAME* b); \
+ deBool TYPENAME##_sum (DE_PTR_TYPE(TYPENAME) to, const TYPENAME* a, const TYPENAME* b); \
+ deBool TYPENAME##_sumInplace (DE_PTR_TYPE(TYPENAME) a, const TYPENAME* b); \
+ deBool TYPENAME##_difference (DE_PTR_TYPE(TYPENAME) to, const TYPENAME* a, const TYPENAME* b); \
+ void TYPENAME##_differenceInplace (DE_PTR_TYPE(TYPENAME) a, const TYPENAME* b); \
struct TYPENAME##SetwiseDeclareDummy_s { int dummy; }
#define DE_IMPLEMENT_POOL_MULTISET_SETWISE_OPERATIONS(TYPENAME, KEYTYPE) \
-deBool TYPENAME##_union (TYPENAME* to, const TYPENAME* a, const TYPENAME* b) \
+deBool TYPENAME##_union (DE_PTR_TYPE(TYPENAME) to, const TYPENAME* a, const TYPENAME* b) \
{ \
TYPENAME##_reset(to); \
return TYPENAME##_unionInplace(to, a) && TYPENAME##_unionInplace(to, b); \
} \
\
-deBool TYPENAME##_unionInplace (TYPENAME* a, const TYPENAME* b) \
+deBool TYPENAME##_unionInplace (DE_PTR_TYPE(TYPENAME) a, const TYPENAME* b) \
{ \
TYPENAME##HashIter iter; \
for (TYPENAME##HashIter_init(b, &iter); \
return DE_TRUE; \
} \
\
-deBool TYPENAME##_intersect (TYPENAME* to, const TYPENAME* a, const TYPENAME* b) \
+deBool TYPENAME##_intersect (DE_PTR_TYPE(TYPENAME) to, const TYPENAME* a, const TYPENAME* b) \
{ \
TYPENAME##HashIter iter; \
TYPENAME##_reset(to); \
return DE_TRUE; \
} \
\
-void TYPENAME##_intersectInplace (TYPENAME* a, const TYPENAME* b) \
+void TYPENAME##_intersectInplace (DE_PTR_TYPE(TYPENAME) a, const TYPENAME* b) \
{ \
DE_FATAL("Not implemented."); \
} \
\
-deBool TYPENAME##_sum (TYPENAME* to, const TYPENAME* a, const TYPENAME* b) \
+deBool TYPENAME##_sum (DE_PTR_TYPE(TYPENAME) to, const TYPENAME* a, const TYPENAME* b) \
{ \
TYPENAME##_reset(to); \
return TYPENAME##_sumInplace(to, a) && TYPENAME##_sumInplace(to, b); \
} \
\
-deBool TYPENAME##_sumInplace (TYPENAME* a, const TYPENAME* b) \
+deBool TYPENAME##_sumInplace (DE_PTR_TYPE(TYPENAME) a, const TYPENAME* b) \
{ \
TYPENAME##HashIter iter; \
for (TYPENAME##HashIter_init(b, &iter); \
} \
} \
\
-deBool TYPENAME##_difference (TYPENAME* to, const TYPENAME* a, const TYPENAME* b) \
+deBool TYPENAME##_difference (DE_PTR_TYPE(TYPENAME) to, const TYPENAME* a, const TYPENAME* b) \
{ \
TYPENAME##HashIter iter; \
TYPENAME##_reset(to); \
return DE_TRUE; \
} \
\
-void TYPENAME##_differenceInplace (TYPENAME* a, const TYPENAME* b) \
+void TYPENAME##_differenceInplace (DE_PTR_TYPE(TYPENAME) a, const TYPENAME* b) \
{ \
DE_FATAL("Not implemented."); \
} \
KEYTYPE keys[DE_SET_ELEMENTS_PER_SLOT]; \
}; \
\
-typedef struct TYPENAME##_s \
-{ \
- deMemPool* pool; \
+typedef struct TYPENAME##_s \
+{ \
+ deMemPool* pool; \
int numElements; \
-\
- int slotTableSize; \
+ \
+ int slotTableSize; \
TYPENAME##Slot** slotTable; \
- TYPENAME##Slot* slotFreeList; \
-} TYPENAME; \
+ TYPENAME##Slot* slotFreeList; \
+} TYPENAME; /* NOLINT(TYPENAME) */ \
\
typedef struct TYPENAME##Iter_s \
{ \
int curElemIndex; \
} TYPENAME##Iter; \
\
-TYPENAME* TYPENAME##_create (deMemPool* pool); \
-void TYPENAME##_reset (TYPENAME* set); \
-deBool TYPENAME##_reserve (TYPENAME* set, int capacity); \
-deBool TYPENAME##_exists (const TYPENAME* set, KEYTYPE key); \
-deBool TYPENAME##_insert (TYPENAME* set, KEYTYPE key); \
-void TYPENAME##_delete (TYPENAME* set, KEYTYPE key); \
+TYPENAME* TYPENAME##_create (deMemPool* pool); \
+void TYPENAME##_reset (DE_PTR_TYPE(TYPENAME) set); \
+deBool TYPENAME##_reserve (DE_PTR_TYPE(TYPENAME) set, int capacity); \
+deBool TYPENAME##_exists (const TYPENAME* set, KEYTYPE key); \
+deBool TYPENAME##_insert (DE_PTR_TYPE(TYPENAME) set, KEYTYPE key); \
+void TYPENAME##_delete (DE_PTR_TYPE(TYPENAME) set, KEYTYPE key); \
\
DE_INLINE int TYPENAME##_getNumElements (const TYPENAME* set) DE_UNUSED_FUNCTION; \
DE_INLINE void TYPENAME##Iter_init (const TYPENAME* hash, TYPENAME##Iter* iter) DE_UNUSED_FUNCTION; \
DE_INLINE deBool TYPENAME##Iter_hasItem (const TYPENAME##Iter* iter) DE_UNUSED_FUNCTION; \
DE_INLINE void TYPENAME##Iter_next (TYPENAME##Iter* iter) DE_UNUSED_FUNCTION; \
DE_INLINE KEYTYPE TYPENAME##Iter_getKey (const TYPENAME##Iter* iter) DE_UNUSED_FUNCTION; \
-DE_INLINE deBool TYPENAME##_safeInsert (TYPENAME* set, KEYTYPE key) DE_UNUSED_FUNCTION; \
-DE_INLINE void TYPENAME##_safeDelete (TYPENAME* set, KEYTYPE key) DE_UNUSED_FUNCTION; \
+DE_INLINE deBool TYPENAME##_safeInsert (DE_PTR_TYPE(TYPENAME) set, KEYTYPE key) DE_UNUSED_FUNCTION; \
+DE_INLINE void TYPENAME##_safeDelete (DE_PTR_TYPE(TYPENAME) set, KEYTYPE key) DE_UNUSED_FUNCTION; \
\
DE_INLINE int TYPENAME##_getNumElements (const TYPENAME* set) \
{ \
return iter->curSlot->keys[iter->curElemIndex]; \
} \
\
-DE_INLINE deBool TYPENAME##_safeInsert (TYPENAME* set, KEYTYPE key) \
+DE_INLINE deBool TYPENAME##_safeInsert (DE_PTR_TYPE(TYPENAME) set, KEYTYPE key) \
{ \
DE_ASSERT(set); \
if (TYPENAME##_exists(set, key)) \
return TYPENAME##_insert(set, key); \
} \
\
-DE_INLINE void TYPENAME##_safeDelete (TYPENAME* set, KEYTYPE key) \
+DE_INLINE void TYPENAME##_safeDelete (DE_PTR_TYPE(TYPENAME) set, KEYTYPE key) \
{ \
DE_ASSERT(set); \
if (TYPENAME##_exists(set, key)) \
*//*--------------------------------------------------------------------*/
#define DE_IMPLEMENT_POOL_SET(TYPENAME, KEYTYPE, HASHFUNC, CMPFUNC) \
\
-TYPENAME* TYPENAME##_create (deMemPool* pool) \
+DE_PTR_TYPE(TYPENAME) TYPENAME##_create (deMemPool* pool) \
{ \
/* Alloc struct. */ \
- TYPENAME* set = DE_POOL_NEW(pool, TYPENAME); \
+ DE_PTR_TYPE(TYPENAME) set = DE_POOL_NEW(pool, TYPENAME); \
if (!set) \
return DE_NULL; \
\
return set; \
} \
\
-void TYPENAME##_reset (TYPENAME* set) \
+void TYPENAME##_reset (DE_PTR_TYPE(TYPENAME) set) \
{ \
int slotNdx; \
for (slotNdx = 0; slotNdx < set->slotTableSize; slotNdx++) \
set->numElements = 0; \
} \
\
-TYPENAME##Slot* TYPENAME##_allocSlot (TYPENAME* set) \
+TYPENAME##Slot* TYPENAME##_allocSlot (DE_PTR_TYPE(TYPENAME) set) \
{ \
TYPENAME##Slot* slot; \
if (set->slotFreeList) \
return slot; \
} \
\
-deBool TYPENAME##_rehash (TYPENAME* set, int newSlotTableSize) \
+deBool TYPENAME##_rehash (DE_PTR_TYPE(TYPENAME) set, int newSlotTableSize) \
{ \
DE_ASSERT(deIsPowerOfTwo32(newSlotTableSize) && newSlotTableSize > 0); \
if (newSlotTableSize > set->slotTableSize) \
return DE_FALSE; \
} \
\
-deBool TYPENAME##_insert (TYPENAME* set, KEYTYPE key) \
+deBool TYPENAME##_insert (DE_PTR_TYPE(TYPENAME) set, KEYTYPE key) \
{ \
int slotNdx; \
TYPENAME##Slot* slot; \
} \
} \
\
-void TYPENAME##_delete (TYPENAME* set, KEYTYPE key) \
+void TYPENAME##_delete (DE_PTR_TYPE(TYPENAME) set, KEYTYPE key) \
{ \
int slotNdx; \
TYPENAME##Slot* slot; \
/* Copy-to-array templates. */
#define DE_DECLARE_POOL_SET_TO_ARRAY(SETTYPENAME, ARRAYTYPENAME) \
- deBool SETTYPENAME##_copyToArray(const SETTYPENAME* set, ARRAYTYPENAME* array); \
+ deBool SETTYPENAME##_copyToArray(const SETTYPENAME* set, DE_PTR_TYPE(ARRAYTYPENAME) array); \
struct SETTYPENAME##_##ARRAYTYPENAME##_declare_dummy { int dummy; }
#define DE_IMPLEMENT_POOL_SET_TO_ARRAY(SETTYPENAME, ARRAYTYPENAME) \
- deBool SETTYPENAME##_copyToArray(const SETTYPENAME* set, ARRAYTYPENAME* array) \
+ deBool SETTYPENAME##_copyToArray(const SETTYPENAME* set, DE_PTR_TYPE(ARRAYTYPENAME) array) \
{ \
int numElements = set->numElements; \
int arrayNdx = 0; \
* void Set_differenceInplace (Set* a, const Set* b);
* \endcode
*//*--------------------------------------------------------------------*/
-#define DE_DECLARE_POOL_SET_SETWISE_OPERATIONS(TYPENAME) \
- deBool TYPENAME##_union (TYPENAME* to, const TYPENAME* a, const TYPENAME* b); \
- deBool TYPENAME##_unionInplace (TYPENAME* a, const TYPENAME* b); \
- deBool TYPENAME##_intersect (TYPENAME* to, const TYPENAME* a, const TYPENAME* b); \
- void TYPENAME##_intersectInplace (TYPENAME* a, const TYPENAME* b); \
- deBool TYPENAME##_difference (TYPENAME* to, const TYPENAME* a, const TYPENAME* b); \
- void TYPENAME##_differenceInplace (TYPENAME* a, const TYPENAME* b); \
+#define DE_DECLARE_POOL_SET_SETWISE_OPERATIONS(TYPENAME) \
+ deBool TYPENAME##_union (DE_PTR_TYPE(TYPENAME) to, const TYPENAME* a, const TYPENAME* b); \
+ deBool TYPENAME##_unionInplace (DE_PTR_TYPE(TYPENAME) a, const TYPENAME* b); \
+ deBool TYPENAME##_intersect (DE_PTR_TYPE(TYPENAME) to, const TYPENAME* a, const TYPENAME* b); \
+ void TYPENAME##_intersectInplace (DE_PTR_TYPE(TYPENAME) a, const TYPENAME* b); \
+ deBool TYPENAME##_difference (DE_PTR_TYPE(TYPENAME) to, const TYPENAME* a, const TYPENAME* b); \
+ void TYPENAME##_differenceInplace (DE_PTR_TYPE(TYPENAME) a, const TYPENAME* b); \
struct TYPENAME##SetwiseDeclareDummy_s { int dummy; }
#define DE_IMPLEMENT_POOL_SET_SETWISE_OPERATIONS(TYPENAME, KEYTYPE) \
-deBool TYPENAME##_union (TYPENAME* to, const TYPENAME* a, const TYPENAME* b) \
+deBool TYPENAME##_union (DE_PTR_TYPE(TYPENAME) to, const TYPENAME* a, const TYPENAME* b) \
{ \
TYPENAME##_reset(to); \
if (!TYPENAME##_unionInplace(to, a)) \
return DE_TRUE; \
} \
\
-deBool TYPENAME##_unionInplace (TYPENAME* a, const TYPENAME* b) \
+deBool TYPENAME##_unionInplace (DE_PTR_TYPE(TYPENAME) a, const TYPENAME* b) \
{ \
TYPENAME##Iter iter; \
for (TYPENAME##Iter_init(b, &iter); \
return DE_TRUE; \
} \
\
-deBool TYPENAME##_intersect (TYPENAME* to, const TYPENAME* a, const TYPENAME* b) \
+deBool TYPENAME##_intersect (DE_PTR_TYPE(TYPENAME) to, const TYPENAME* a, const TYPENAME* b) \
{ \
TYPENAME##Iter iter; \
TYPENAME##_reset(to); \
return DE_TRUE; \
} \
\
-void TYPENAME##_intersectInplace (TYPENAME* a, const TYPENAME* b) \
+void TYPENAME##_intersectInplace (DE_PTR_TYPE(TYPENAME) a, const TYPENAME* b) \
{ \
DE_UNREF(a && b); \
DE_FATAL("Not implemented."); \
} \
\
-deBool TYPENAME##_difference (TYPENAME* to, const TYPENAME* a, const TYPENAME* b) \
+deBool TYPENAME##_difference (DE_PTR_TYPE(TYPENAME) to, const TYPENAME* a, const TYPENAME* b) \
{ \
TYPENAME##Iter iter; \
TYPENAME##_reset(to); \
return DE_TRUE; \
} \
\
-void TYPENAME##_differenceInplace (TYPENAME* a, const TYPENAME* b) \
+void TYPENAME##_differenceInplace (DE_PTR_TYPE(TYPENAME) a, const TYPENAME* b) \
{ \
TYPENAME##Iter iter; \
for (TYPENAME##Iter_init(b, &iter); \
typedef int deSocketHandle;
typedef socklen_t NativeSocklen;
typedef size_t NativeSize;
-# define DE_INVALID_SOCKET_HANDLE -1
+# define DE_INVALID_SOCKET_HANDLE (-1)
#endif
DE_INLINE deBool deSocketHandleIsValid (deSocketHandle handle)
public: \
ApiCase_##NAME (EglTestContext& context) : ApiCase(context, #NAME, DESCRIPTION) {} \
protected: \
- void test (void) TEST_FUNC_BODY \
+ void test (void) TEST_FUNC_BODY /* NOLINT(TEST_FUNC_BODY) */ \
}; \
addChild(new ApiCase_##NAME(m_eglTestCtx)); \
} while (deGetFalse())
{
#define CHECK_EXTENSION(DPY, EXTNAME) \
- TCU_CHECK_AND_THROW(NotSupportedError, eglu::hasExtension(m_eglTestCtx.getLibrary(), DPY, EXTNAME), (string("Unsupported extension: ") + EXTNAME).c_str())
+ TCU_CHECK_AND_THROW(NotSupportedError, eglu::hasExtension(m_eglTestCtx.getLibrary(), DPY, EXTNAME), (string("Unsupported extension: ") + (EXTNAME)).c_str())
template <typename RetVal>
RetVal checkCallError (EglTestContext& eglTestCtx, const char* call, RetVal returnValue, EGLint expectError)
};
#define FOR_EACH(ITERATOR, ARRAY, BODY) \
- for (int ITERATOR = 0; ITERATOR < DE_LENGTH_OF_ARRAY(ARRAY); ITERATOR++) \
+ for (int (ITERATOR) = 0; (ITERATOR) < DE_LENGTH_OF_ARRAY(ARRAY); (ITERATOR)++) \
BODY
// 2D cases.
public: \
ApiCase_##NAME (Context& context) : ApiCase(context, #NAME, DESCRIPTION) {} \
protected: \
- void test (void) TEST_FUNC_BODY \
+ void test (void) TEST_FUNC_BODY /* NOLINT(TEST_FUNC_BODY) */ \
}; \
addChild(new ApiCase_##NAME(m_context)); \
} while (deGetFalse())
#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
{ \
- StateVerifier* verifier = VERIFIERS[_verifierNdx]; \
+ StateVerifier* verifier = (VERIFIERS)[_verifierNdx]; \
CODE_BLOCK; \
}
#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
{ \
- BufferParamVerifier* verifier = VERIFIERS[_verifierNdx]; \
+ BufferParamVerifier* verifier = (VERIFIERS)[_verifierNdx]; \
CODE_BLOCK; \
}
}; \
enum \
{ \
- COMPONENTS = COMPS \
+ COMPONENTS = (COMPS) \
}; \
typedef TYPE Type; \
\
}; \
enum \
{ \
- COMPONENTS = COMPS \
+ COMPONENTS = (COMPS) \
}; \
typedef TYPE Type; \
\
#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
{ \
- StateVerifier* verifier = VERIFIERS[_verifierNdx]; \
+ StateVerifier* verifier = (VERIFIERS)[_verifierNdx]; \
CODE_BLOCK; \
}
#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
{ \
- StateVerifier* verifier = VERIFIERS[_verifierNdx]; \
+ StateVerifier* verifier = (VERIFIERS)[_verifierNdx]; \
CODE_BLOCK; \
}
#define FOR_EACH_QUERYTYPE(QUERYTYPES, CODE_BLOCK) \
for (int _queryTypeNdx = 0; _queryTypeNdx < DE_LENGTH_OF_ARRAY(QUERYTYPES); _queryTypeNdx++) \
{ \
- const QueryType queryType = QUERYTYPES[_queryTypeNdx]; \
+ const QueryType queryType = (QUERYTYPES)[_queryTypeNdx]; \
CODE_BLOCK; \
}
#define SHADER_OP_CASE(NAME, DESCRIPTION, SHADER_OP, EVAL_FUNC_BODY) \
do { \
- struct Eval_##NAME { static void eval (ShaderEvalContext& c) EVAL_FUNC_BODY }; \
+ struct Eval_##NAME { static void eval (ShaderEvalContext& c) EVAL_FUNC_BODY }; /* NOLINT(EVAL_FUNC_BODY) */ \
addChild(createExpressionCase(m_context, #NAME "_vertex", DESCRIPTION, true, &Eval_##NAME::eval, SHADER_OP)); \
addChild(createExpressionCase(m_context, #NAME "_fragment", DESCRIPTION, false, &Eval_##NAME::eval, SHADER_OP)); \
} while (deGetFalse())
{
#define LOCAL_STRUCT_CASE(NAME, DESCRIPTION, FLAGS, SHADER_SRC, EVAL_FUNC_BODY) \
do { \
- struct Eval_##NAME { static void eval (ShaderEvalContext& c) EVAL_FUNC_BODY }; \
+ struct Eval_##NAME { static void eval (ShaderEvalContext& c) EVAL_FUNC_BODY }; /* NOLINT(EVAL_FUNC_BODY) */ \
addChild(createStructCase(m_context, #NAME "_vertex", DESCRIPTION, true, FLAGS, &Eval_##NAME::eval, DE_NULL, SHADER_SRC)); \
addChild(createStructCase(m_context, #NAME "_fragment", DESCRIPTION, false, FLAGS,&Eval_##NAME::eval, DE_NULL, SHADER_SRC)); \
} while (deGetFalse())
namespace
{
-#define CHECK_SET_UNIFORM(NAME) GLU_EXPECT_NO_ERROR(gl.getError(), (string("Failed to set ") + NAME).c_str())
+#define CHECK_SET_UNIFORM(NAME) GLU_EXPECT_NO_ERROR(gl.getError(), (string("Failed to set ") + (NAME)).c_str())
#define MAKE_SET_VEC_UNIFORM(VECTYPE, SETUNIFORM) \
void setUniform (const glw::Functions& gl, deUint32 programID, const char* name, const tcu::VECTYPE& vec) \
{
#define UNIFORM_STRUCT_CASE(NAME, DESCRIPTION, FLAGS, SHADER_SRC, SET_UNIFORMS_BODY, EVAL_FUNC_BODY) \
do { \
- struct SetUniforms_##NAME { static void setUniforms (const glw::Functions& gl, deUint32 programID, const tcu::Vec4& constCoords) SET_UNIFORMS_BODY }; \
- struct Eval_##NAME { static void eval (ShaderEvalContext& c) EVAL_FUNC_BODY }; \
+ struct SetUniforms_##NAME { \
+ static void setUniforms (const glw::Functions& gl, deUint32 programID, const tcu::Vec4& constCoords) SET_UNIFORMS_BODY /* NOLINT(SET_UNIFORMS_BODY) */ \
+ }; \
+ struct Eval_##NAME { static void eval (ShaderEvalContext& c) EVAL_FUNC_BODY }; /* NOLINT(EVAL_FUNC_BODY) */ \
addChild(createStructCase(m_context, #NAME "_vertex", DESCRIPTION, true, FLAGS, Eval_##NAME::eval, SetUniforms_##NAME::setUniforms, SHADER_SRC)); \
addChild(createStructCase(m_context, #NAME "_fragment", DESCRIPTION, false, FLAGS, Eval_##NAME::eval, SetUniforms_##NAME::setUniforms, SHADER_SRC)); \
} while (deGetFalse())
};
#define FOR_EACH(ITERATOR, ARRAY, BODY) \
- for (int ITERATOR = 0; ITERATOR < DE_LENGTH_OF_ARRAY(ARRAY); ITERATOR++) \
+ for (int (ITERATOR) = 0; (ITERATOR) < DE_LENGTH_OF_ARRAY(ARRAY); (ITERATOR)++) \
BODY
// 2D cases.
#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
{ \
- TexParamVerifier* verifier = VERIFIERS[_verifierNdx]; \
+ TexParamVerifier* verifier = (VERIFIERS)[_verifierNdx]; \
CODE_BLOCK; \
}
};
#define FOR_EACH(ITERATOR, ARRAY, BODY) \
- for (int ITERATOR = 0; ITERATOR < DE_LENGTH_OF_ARRAY(ARRAY); ITERATOR++) \
+ for (int (ITERATOR) = 0; (ITERATOR) < DE_LENGTH_OF_ARRAY(ARRAY); (ITERATOR)++) \
BODY
FOR_EACH(wrapS, wrapModes,
deUint32 result = 0;
-#define ARRAY_CHOICE(ARR) (ARR[rnd.getInt(0, DE_LENGTH_OF_ARRAY(ARR)-1)])
+#define ARRAY_CHOICE(ARR) ((ARR)[rnd.getInt(0, DE_LENGTH_OF_ARRAY(ARR)-1)])
result |= ARRAY_CHOICE(arrayUsageChoices);
result |= ARRAY_CHOICE(uniformFuncChoices);
{ \
for (int i = 0; i < valSize; i++) \
{ \
- if (unifValue.val.VAR_VALUE_MEMBER[i] != ZERO) \
+ if (unifValue.val.VAR_VALUE_MEMBER[i] != (ZERO)) \
{ \
log << TestLog::Message << "// FAILURE: uniform " << uniform.name << " has non-zero initial value" << TestLog::EndMessage; \
success = false; \
};
#define FOR_EACH(ITERATOR, ARRAY, BODY) \
- for (int ITERATOR = 0; ITERATOR < DE_LENGTH_OF_ARRAY(ARRAY); ITERATOR++) \
+ for (int (ITERATOR) = 0; (ITERATOR) < DE_LENGTH_OF_ARRAY(ARRAY); (ITERATOR)++) \
BODY
// 2D cases.
};
#define FOR_EACH(ITERATOR, ARRAY, BODY) \
- for (int ITERATOR = 0; ITERATOR < DE_LENGTH_OF_ARRAY(ARRAY); ITERATOR++) \
+ for (int (ITERATOR) = 0; (ITERATOR) < DE_LENGTH_OF_ARRAY(ARRAY); (ITERATOR)++) \
BODY
FOR_EACH(uploadFunc, uploadFunctions,
};
#define FOR_EACH(ITERATOR, ARRAY, BODY) \
- for (int ITERATOR = 0; ITERATOR < DE_LENGTH_OF_ARRAY(ARRAY); ITERATOR++) \
+ for (int (ITERATOR) = 0; (ITERATOR) < DE_LENGTH_OF_ARRAY(ARRAY); (ITERATOR)++) \
BODY
// 2D cases.
public: \
ApiCase_##NAME (Context& context) : ApiCase(context, #NAME, DESCRIPTION) {} \
protected: \
- void test (void) TEST_FUNC_BODY \
+ void test (void) TEST_FUNC_BODY /* NOLINT(TEST_FUNC_BODY) */ \
}; \
addChild(new ApiCase_##NAME(m_context)); \
} while (deGetFalse())
#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
{ \
- StateVerifier* verifier = VERIFIERS[_verifierNdx]; \
+ StateVerifier* verifier = (VERIFIERS)[_verifierNdx]; \
CODE_BLOCK; \
}
#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
{ \
- BufferParamVerifier* verifier = VERIFIERS[_verifierNdx]; \
+ BufferParamVerifier* verifier = (VERIFIERS)[_verifierNdx]; \
CODE_BLOCK; \
}
}; \
enum \
{ \
- COMPONENTS = COMPS \
+ COMPONENTS = (COMPS) \
}; \
typedef TYPE Type; \
\
}; \
enum \
{ \
- COMPONENTS = COMPS \
+ COMPONENTS = (COMPS) \
}; \
typedef TYPE Type; \
\
}; \
enum \
{ \
- COMPONENTS = COMPS \
+ COMPONENTS = (COMPS) \
}; \
typedef TYPE Type; \
\
}; \
enum \
{ \
- COMPONENTS = COMPS \
+ COMPONENTS = (COMPS) \
}; \
typedef TYPE Type; \
\
#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
{ \
- StateVerifier* verifier = VERIFIERS[_verifierNdx]; \
+ StateVerifier* verifier = (VERIFIERS)[_verifierNdx]; \
CODE_BLOCK; \
}
#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
{ \
- StateVerifier* verifier = VERIFIERS[_verifierNdx]; \
+ StateVerifier* verifier = (VERIFIERS)[_verifierNdx]; \
CODE_BLOCK; \
}
#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
{ \
- StateVerifier* verifier = VERIFIERS[_verifierNdx]; \
+ StateVerifier* verifier = (VERIFIERS)[_verifierNdx]; \
CODE_BLOCK; \
}
#define FOR_EACH_QUERYTYPE(QUERYTYPES, CODE_BLOCK) \
for (int _queryTypeNdx = 0; _queryTypeNdx < DE_LENGTH_OF_ARRAY(QUERYTYPES); _queryTypeNdx++) \
{ \
- const QueryType queryType = QUERYTYPES[_queryTypeNdx]; \
+ const QueryType queryType = (QUERYTYPES)[_queryTypeNdx]; \
CODE_BLOCK; \
}
#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
{ \
- QueryType verifier = VERIFIERS[_verifierNdx]; \
+ QueryType verifier = (VERIFIERS)[_verifierNdx]; \
CODE_BLOCK; \
}
{
#define LOCAL_STRUCT_CASE(NAME, DESCRIPTION, SHADER_SRC, EVAL_FUNC_BODY) \
do { \
- struct Eval_##NAME { static void eval (ShaderEvalContext& c) EVAL_FUNC_BODY }; \
+ struct Eval_##NAME { static void eval (ShaderEvalContext& c) EVAL_FUNC_BODY }; /* NOLINT(EVAL_FUNC_BODY) */ \
addChild(createStructCase(m_context, #NAME "_vertex", DESCRIPTION, true, false, &Eval_##NAME::eval, DE_NULL, SHADER_SRC)); \
addChild(createStructCase(m_context, #NAME "_fragment", DESCRIPTION, false, false,&Eval_##NAME::eval, DE_NULL, SHADER_SRC)); \
} while (deGetFalse())
namespace
{
-#define CHECK_SET_UNIFORM(NAME) GLU_EXPECT_NO_ERROR(gl.getError(), (string("Failed to set ") + NAME).c_str())
+#define CHECK_SET_UNIFORM(NAME) GLU_EXPECT_NO_ERROR(gl.getError(), (string("Failed to set ") + (NAME)).c_str())
#define MAKE_SET_VEC_UNIFORM(VECTYPE, SETUNIFORM) \
void setUniform (const glw::Functions& gl, deUint32 programID, const char* name, const tcu::VECTYPE& vec) \
{
#define UNIFORM_STRUCT_CASE(NAME, DESCRIPTION, TEXTURES, SHADER_SRC, SET_UNIFORMS_BODY, EVAL_FUNC_BODY) \
do { \
- struct SetUniforms_##NAME { static void setUniforms (const glw::Functions& gl, deUint32 programID, const tcu::Vec4& constCoords) SET_UNIFORMS_BODY }; \
- struct Eval_##NAME { static void eval (ShaderEvalContext& c) EVAL_FUNC_BODY }; \
+ struct SetUniforms_##NAME { \
+ static void setUniforms (const glw::Functions& gl, deUint32 programID, const tcu::Vec4& constCoords) SET_UNIFORMS_BODY /* NOLINT(SET_UNIFORMS_BODY) */ \
+ }; \
+ struct Eval_##NAME { static void eval (ShaderEvalContext& c) EVAL_FUNC_BODY }; /* NOLINT(EVAL_FUNC_BODY) */ \
addChild(createStructCase(m_context, #NAME "_vertex", DESCRIPTION, true, TEXTURES, Eval_##NAME::eval, SetUniforms_##NAME::setUniforms, SHADER_SRC)); \
addChild(createStructCase(m_context, #NAME "_fragment", DESCRIPTION, false, TEXTURES, Eval_##NAME::eval, SetUniforms_##NAME::setUniforms, SHADER_SRC)); \
} while (deGetFalse())
#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
{ \
- QueryType verifier = VERIFIERS[_verifierNdx]; \
+ QueryType verifier = (VERIFIERS)[_verifierNdx]; \
CODE_BLOCK; \
}
};
#define FOR_EACH(ITERATOR, ARRAY, BODY) \
- for (int ITERATOR = 0; ITERATOR < DE_LENGTH_OF_ARRAY(ARRAY); ITERATOR++) \
+ for (int (ITERATOR) = 0; (ITERATOR) < DE_LENGTH_OF_ARRAY(ARRAY); (ITERATOR)++) \
BODY
// RGBA8 cases.
deUint32 result = 0;
-#define ARRAY_CHOICE(ARR) (ARR[rnd.getInt(0, DE_LENGTH_OF_ARRAY(ARR)-1)])
+#define ARRAY_CHOICE(ARR) ((ARR)[rnd.getInt(0, DE_LENGTH_OF_ARRAY(ARR)-1)])
result |= ARRAY_CHOICE(arrayUsageChoices);
result |= ARRAY_CHOICE(uniformFuncChoices);
{ \
for (int i = 0; i < valSize; i++) \
{ \
- if (unifValue.val.VAR_VALUE_MEMBER[i] != ZERO) \
+ if (unifValue.val.VAR_VALUE_MEMBER[i] != (ZERO)) \
{ \
log << TestLog::Message << "// FAILURE: uniform " << uniform.name << " has non-zero initial value" << TestLog::EndMessage; \
success = false; \
};
#define FOR_EACH(ITERATOR, ARRAY, BODY) \
- for (int ITERATOR = 0; ITERATOR < DE_LENGTH_OF_ARRAY(ARRAY); ITERATOR++) \
+ for (int (ITERATOR) = 0; (ITERATOR) < DE_LENGTH_OF_ARRAY(ARRAY); (ITERATOR)++) \
BODY
// 2D cases.
#define FOR_EACH_VERIFIER(VERIFIERS, X) \
for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); ++verifierNdx) \
{ \
- const char* verifierSuffix = getVerifierSuffix(VERIFIERS[verifierNdx]); \
- const QueryType verifier = VERIFIERS[verifierNdx]; \
+ const char* verifierSuffix = getVerifierSuffix((VERIFIERS)[verifierNdx]); \
+ const QueryType verifier = (VERIFIERS)[verifierNdx]; \
this->addChild(X); \
}
#define FOR_EACH_VERIFIER(VERIFIERS, X) \
for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); ++verifierNdx) \
{ \
- const char* verifierSuffix = getVerifierSuffix(VERIFIERS[verifierNdx]); \
- const QueryType verifier = VERIFIERS[verifierNdx]; \
+ const char* verifierSuffix = getVerifierSuffix((VERIFIERS)[verifierNdx]); \
+ const QueryType verifier = (VERIFIERS)[verifierNdx]; \
targetGroup->addChild(X); \
}
#define FOR_EACH_VERIFIER(VERIFIERS, X) \
for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); ++verifierNdx) \
{ \
- const char* verifierSuffix = getVerifierSuffix(VERIFIERS[verifierNdx]); \
- const QueryType verifier = VERIFIERS[verifierNdx]; \
+ const char* verifierSuffix = getVerifierSuffix((VERIFIERS)[verifierNdx]); \
+ const QueryType verifier = (VERIFIERS)[verifierNdx]; \
targetGroup->addChild(X); \
}
ExprP<TRET> NAME (const ExprP<T0>& arg0) { return app<CLASS>(arg0); }
#define DEFINE_DERIVED1(CLASS, TRET, NAME, T0, ARG0, EXPANSION) \
-class CLASS : public DerivedFunc<Signature<TRET, T0> > \
+class CLASS : public DerivedFunc<Signature<TRET, T0> > /* NOLINT(CLASS) */ \
{ \
public: \
string getName (void) const { return #NAME; } \
ExprP<TRET> doExpand (ExpandContext&, \
const CLASS::ArgExprs& args_) const \
{ \
- const ExprP<float>& ARG0 = args_.a; \
+ const ExprP<float>& (ARG0) = args_.a; \
return EXPANSION; \
} \
}; \
}
#define DEFINE_DERIVED2(CLASS, TRET, NAME, T0, Arg0, T1, Arg1, EXPANSION) \
-class CLASS : public DerivedFunc<Signature<TRET, T0, T1> > \
+class CLASS : public DerivedFunc<Signature<TRET, T0, T1> > /* NOLINT(CLASS) */ \
{ \
public: \
string getName (void) const { return #NAME; } \
protected: \
ExprP<TRET> doExpand (ExpandContext&, const ArgExprs& args_) const \
{ \
- const ExprP<T0>& Arg0 = args_.a; \
- const ExprP<T1>& Arg1 = args_.b; \
+ const ExprP<T0>& (Arg0) = args_.a; \
+ const ExprP<T1>& (Arg1) = args_.b; \
return EXPANSION; \
} \
}; \
}
#define DEFINE_DERIVED3(CLASS, TRET, NAME, T0, ARG0, T1, ARG1, T2, ARG2, EXPANSION) \
-class CLASS : public DerivedFunc<Signature<TRET, T0, T1, T2> > \
+class CLASS : public DerivedFunc<Signature<TRET, T0, T1, T2> > /* NOLINT(CLASS) */ \
{ \
public: \
string getName (void) const { return #NAME; } \
protected: \
ExprP<TRET> doExpand (ExpandContext&, const ArgExprs& args_) const \
{ \
- const ExprP<T0>& ARG0 = args_.a; \
- const ExprP<T1>& ARG1 = args_.b; \
- const ExprP<T2>& ARG2 = args_.c; \
+ const ExprP<T0>& (ARG0) = args_.a; \
+ const ExprP<T1>& (ARG1) = args_.b; \
+ const ExprP<T2>& (ARG2) = args_.c; \
return EXPANSION; \
} \
}; \
static bool isCoreTester (TesterType tester)
{
-#define COMPARE_PURE_SETTERS(TESTER, X) (TESTER == X ## _SET_PURE_INT) || (TESTER == X ## _SET_PURE_UINT)
+#define COMPARE_PURE_SETTERS(TESTER, X) ((TESTER) == X ## _SET_PURE_INT) || ((TESTER) == X ## _SET_PURE_UINT)
return es31::isCoreTester(tester) ||
COMPARE_PURE_SETTERS(tester, TESTER_TEXTURE_SWIZZLE_R) ||
projects / platform / upstream / VK-GL-CTS.git / commitdiff