From 249bf116e8e384889bced2c675ba118a165647b1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Martin=20Ho=C5=99e=C5=88ovsk=C3=BD?=
 <martin.horenovsky@gmail.com>
Date: Tue, 1 Aug 2017 22:09:32 +0200
Subject: [PATCH] Route all T* comparisons through const void* comparisons

This should stop the evaluate machinery from instantiating all the
templates for every ptr type that is compared, instead generating it
for single one.
---
 include/internal/catch_evaluate.hpp | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/include/internal/catch_evaluate.hpp b/include/internal/catch_evaluate.hpp
index 730032fd..9d9da64c 100644
--- a/include/internal/catch_evaluate.hpp
+++ b/include/internal/catch_evaluate.hpp
@@ -91,6 +91,11 @@ namespace Internal {
         return Evaluator<T1, T2, Op>::evaluate( lhs, rhs );
     }
 
+	template<Operator Op>
+	bool compare( void const* lhs, void const* rhs ) {
+		return Evaluator<void const*, void const*, Op>::evaluate( lhs, rhs );
+	}
+
     // unsigned X to int
     template<Operator Op> bool compare( unsigned int lhs, int rhs ) {
         return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
@@ -137,18 +142,18 @@ namespace Internal {
 
     // pointer to long (when comparing against NULL)
     template<Operator Op, typename T> bool compare( long lhs, T* rhs ) {
-        return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
+        return Evaluator<void const*, void const*, Op>::evaluate( reinterpret_cast<void const*>( lhs ), rhs );
     }
     template<Operator Op, typename T> bool compare( T* lhs, long rhs ) {
-        return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
+        return Evaluator<void const*, void const*, Op>::evaluate( lhs, reinterpret_cast<void const*>( rhs ) );
     }
 
     // pointer to int (when comparing against NULL)
     template<Operator Op, typename T> bool compare( int lhs, T* rhs ) {
-        return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
+        return Evaluator<void const*, void const*, Op>::evaluate( reinterpret_cast<void const*>( lhs ), rhs );
     }
     template<Operator Op, typename T> bool compare( T* lhs, int rhs ) {
-        return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
+        return Evaluator<void const*, void const*, Op>::evaluate( lhs, reinterpret_cast<void const*>( rhs ) );
     }
 
     // long long to unsigned X
@@ -181,18 +186,18 @@ namespace Internal {
 
     // pointer to long long (when comparing against NULL)
     template<Operator Op, typename T> bool compare( long long lhs, T* rhs ) {
-        return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
+        return Evaluator<void const*, void const*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
     }
     template<Operator Op, typename T> bool compare( T* lhs, long long rhs ) {
-        return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
+        return Evaluator<void const*, void const*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
     }
 
     // pointer to nullptr_t (when comparing against nullptr)
     template<Operator Op, typename T> bool compare( std::nullptr_t, T* rhs ) {
-        return Evaluator<T*, T*, Op>::evaluate( nullptr, rhs );
+        return Evaluator<void const*, void const*, Op>::evaluate( nullptr, rhs );
     }
     template<Operator Op, typename T> bool compare( T* lhs, std::nullptr_t ) {
-        return Evaluator<T*, T*, Op>::evaluate( lhs, nullptr );
+        return Evaluator<void const*, void const*, Op>::evaluate( lhs, nullptr );
     }
 
 } // end of namespace Internal