clean the TRIQS_COMPILER macros

- from now on, C++11 compilers only.
- no ressources to maintain old stuff.

cmake/FindCompilerCheck.cmake

@@ -17,14 +17,14 @@ if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
  
  EXECUTE_PROCESS(COMMAND ${CMAKE_CXX_COMPILER} --version  
   OUTPUT_VARIABLE _compiler_output RESULT_VARIABLE returncode OUTPUT_STRIP_TRAILING_WHITESPACE)
- set(compiler_version_min "4.6.3")
+ set(compiler_version_min "4.8.1")
  set(compiler_name "gcc")
  set(compiler_group 1)
  string(REGEX REPLACE ".*([2-5]\\.[0-9]\\.[0-9]).*" "\\1" compiler_version ${_compiler_output})
 
- if(NOT compiler_version VERSION_LESS "4.8.0" )
+ #if(compiler_version VERSION_LESS "4.8.0" )
-  set(TRIQS_COMPILER_IS_C11_COMPLIANT ON)
+ # set(compiler_is_obsolete_gcc ON)
- endif()
+ #endif()
 
 elseif ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
 
@@ -33,7 +33,6 @@ elseif ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
  set(CMAKE_COMPILER_IS_CLANG TRUE )
  set(compiler_name "clang")
  set(compiler_group 1)
- set(TRIQS_COMPILER_IS_C11_COMPLIANT ON)
  IF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
   # Apple which does not has the official clang version number ... 
   string(REGEX REPLACE ".*LLVM ([2-5]\\.[0-9]).*" "\\1" compiler_version ${_compiler_output})
@@ -48,7 +47,7 @@ elseif ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Intel")
  EXECUTE_PROCESS(COMMAND ${CMAKE_CXX_COMPILER} -dumpversion  
   OUTPUT_VARIABLE compiler_version RESULT_VARIABLE returncode OUTPUT_STRIP_TRAILING_WHITESPACE)
  set(CMAKE_COMPILER_IS_ICC TRUE )
- set(compiler_version_min "13.0.0")
+ set(compiler_version_min "14.0.0")
  set(compiler_name "Intel icc")
  set(compiler_group 3)
  #string(REGEX REPLACE "[^0-9]*([0-9]+\\.[0-9]\\.[0-9]).*" "\\1" compiler_version ${_compiler_output})

cmake/TRIQSConfig.cmake.in

@@ -33,7 +33,6 @@ set(TRIQS_LIBRARY_GSL     @GSL_LIBRARIES@)
 set(TRIQS_WITH_PYTHON_SUPPORT @TRIQS_WITH_PYTHON_SUPPORT@)
 set(TRIQS_HDF5_DIFF_EXECUTABLE @TRIQS_HDF5_DIFF_EXECUTABLE@)
 set(TRIQS_PYTHON_LIB_DEST @TRIQS_PYTHON_LIB_DEST@)
-set(TRIQS_COMPILER_IS_C11_COMPLIANT @TRIQS_COMPILER_IS_C11_COMPLIANT@)
 
 # Documentation
 set(TRIQS_WITH_DOCUMENTATION @Build_Documentation@)

cmake/triqs_config.h.in

@@ -11,8 +11,6 @@
 #cmakedefine TRIQS_WORKAROUND_INTEL_COMPILER_14_BUGS
 #cmakedefine BOOST_MATH_DISABLE_STD_FPCLASSIFY
 
-#cmakedefine TRIQS_COMPILER_IS_C11_COMPLIANT
-
 #define TRIQS_GIT_HASH @GIT_HASH@
 
 #define TRIQS_HOSTNAME @TRIQS_HOSTNAME@

test/CMakeLists.txt

@@ -8,9 +8,11 @@ IF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
 ENDIF( ${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
 link_libraries( ${link_libs} triqs)
 
+if (NOT compiler_is_obsolete_gcc)
 add_subdirectory(triqs)
+add_subdirectory(speed)
+endif()
 if (PythonSupport)
  add_subdirectory(pytriqs)
 endif()
-add_subdirectory(speed)
 

test/triqs/CMakeLists.txt

@@ -15,21 +15,6 @@ macro(all_tests )
   endif()
  ENDFOREACH( TestName1  ${TestList} )
 
- FILE(GLOB TestList RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} c++11/*.cpp)
- FOREACH( TestName1  ${TestList} )
-  STRING(REPLACE ".cpp" "" TestName2 ${TestName1})
-  STRING(REPLACE "c++11/" "" TestName ${TestName2})
-  if(TRIQS_COMPILER_IS_C11_COMPLIANT)
-   add_executable( ${TestName}  ${CMAKE_CURRENT_SOURCE_DIR}/c++11/${TestName}.cpp )
-   add_test_C_simple( ${TestName})
-   if (TESTS_C_WITH_VALGRIND)
-    add_test ( ${TestName}_valgrind valgrind --error-exitcode=1 ${CMAKE_CURRENT_BINARY_DIR}/c++11/${TestName})
-   endif()
-  else()
-   MESSAGE(STATUS "WARNING: Deactivating the test ${TestName} : this obsolete compiler does not implement the C++ standard")
-  endif()
- ENDFOREACH( TestName1  ${TestList} )
-
 endmacro()
 
 add_all_subdirectories_with_cmakelist()

test/triqs/gfs/block.cpp

@@ -11,7 +11,6 @@ int main() {
   auto G2 = G1;
   auto G3 = G2;
 
-#ifndef TRIQS_COMPILER_IS_OBSOLETE
   // construct some block functions
   auto B0 = block_gf<imfreq> (3); 
   auto B1 = make_block_gf<imfreq> (3, G1); 
@@ -35,7 +34,6 @@ int main() {
   B1[0][0] = 98;
   //not implemented yet
   //B3["a"][0] = 98;
-#endif
 
   auto View =  make_block_gf_view(G1,G2,G3);
 

test/triqs/utility/tuple_tools.cpp

@@ -131,8 +131,6 @@ int main(int argc, char **argv) {
 
  }
 
-#ifdef TRIQS_COMPILER_IS_C11_COMPLIANT
-
  { // filter
   std::cout  << "  ----- filter ----"<< std::endl ;
   auto t= std::make_tuple(0,1,2,3,4,"=5");
@@ -184,7 +182,5 @@ int main(int argc, char **argv) {
   std::cout << "replace 1,3,5"<< t << triqs::tuple::replace<1,3,5>(t,s)<< std::endl; 
  }
 
-#endif
-
 }
 

triqs/arrays/array.hpp

@@ -87,11 +87,8 @@ namespace triqs { namespace arrays {
 
 #undef IMPL_TYPE
 
-// This alias is experiemental !! on modern compilers only.
-#ifndef TRIQS_COMPILER_IS_OBSOLETE
  template <typename ValueType, int Rank, ull_t Opt=0, ull_t TraversalOrder=0, bool Borrowed=false>
  using array_const_view = array_view<ValueType, Rank, Opt, TraversalOrder, Borrowed>; 
-#endif
 
  //------------------------------- array ---------------------------------------------------
 

triqs/arrays/impl/common.hpp

@@ -60,12 +60,6 @@ namespace boost { namespace serialization { class access;}}
 #define TRIQS_ARRAYS_DEBUG_CHECK(Cond,Error) 
 #endif
 
-// In particular, gcc 4.6, 4.7 do not have "rvalue for *this", which forbid the implementation 
-// of weak references. In that case, we will revert to strong view instead. 
-#ifdef TRIQS_COMPILER_IS_OBSOLETE
-#define TRIQS_ARRAYS_SLICE_DEFAUT_IS_SHARED
-#endif
-
 namespace triqs { 
 
  typedef unsigned long long ull_t;

triqs/arrays/indexmaps/cuboid/domain.hpp

@@ -64,12 +64,8 @@ namespace triqs { namespace arrays { namespace indexmaps { namespace cuboid {
    size_t number_of_elements() const { return lengths_.product_of_elements();}
    bool operator==(domain_t const & X) const { return this->lengths_ == X.lengths_;}
    bool operator!=(domain_t const & X) const { return !(*this==X);}
-#ifdef TRIQS_COMPILER_IS_C11_COMPLIANT
    n_uple const & lengths() const & { return lengths_;}
    n_uple lengths() && { return lengths_;}
-#else
-   n_uple lengths() const { return lengths_;}
-#endif
    /** Generates the value of the indices of a cuboid_domain.  */
    static constexpr ull_t iteration_order_default = permutations::identity(Rank);
    template <ull_t IterationOrder= iteration_order_default >

triqs/arrays/linalg/det_and_inverse.hpp

@@ -191,11 +191,9 @@ namespace arrays {
  }
 }
 
-#ifndef TRIQS_COMPILER_OBSOLETE_GCC
 namespace clef {
  TRIQS_CLEF_MAKE_FNT_LAZY(determinant);
 }
-#endif
 
 } // namespace triqs::arrays
 #endif

triqs/clef/clef.hpp

@@ -282,19 +282,9 @@ namespace triqs { namespace clef {
   Expr ex; // keep a copy of the expression
   make_fun_impl(Expr const & ex_) : ex(ex_) {} 
   
-  // gcc 4.6 crashes (!!!) on the first variant
-#ifndef TRIQS_COMPILER_OBSOLETE_GCC
   template<typename... Args> 
    auto operator()(Args &&... args) const 
    DECL_AND_RETURN( evaluator<Expr,pair<Is,Args>...>() ( ex, pair<Is,Args>{std::forward<Args>(args)}...));
-#else
-  template<typename... Args> struct __eval { 
-   typedef evaluator<Expr,pair<Is,Args>...> eval_t;
-   auto operator()(Expr const &ex , Args &&... args) const DECL_AND_RETURN( return eval_t() ( ex, pair<Is,Args>{std::forward<Args>(args)}...));
-  };
-  template<typename... Args> 
-   auto operator()(Args &&... args) const DECL_AND_RETURN(return __eval<Args...>() ( ex, std::forward<Args>(args)...));
-#endif
  };
 
  // values of the ph, excluding the Is ...
@@ -471,14 +461,8 @@ namespace triqs { namespace clef {
 
   ReturnType operator()(T const &... t) const { return (*_fnt_ptr)(t...);}
 
-#ifndef TRIQS_COMPILER_OBSOLETE_GCC
   template< typename... Args>
    auto operator()( Args&&... args ) const DECL_AND_RETURN(make_expr_call (*this,std::forward<Args>(args)...));
-#else
-  template< typename... Args>
-   typename _result_of::make_expr_call<function const & ,Args...>::type
-   operator()( Args&&... args ) const { return make_expr_call (*this,args...);}
-#endif
 
   template<typename RHS> friend void triqs_clef_auto_assign (function const & x, RHS rhs) {
    * (x._fnt_ptr) =  std_function_type (rhs);
@@ -501,8 +485,6 @@ namespace triqs { namespace clef {
  template< typename... A> \
  auto name( A&& ... a) DECL_AND_RETURN(make_expr_call(name##_lazy_impl(),std::forward<A>(a)...));
 
-#ifndef TRIQS_COMPILER_OBSOLETE_GCC
-
 #define TRIQS_CLEF_IMPLEMENT_LAZY_METHOD(TY,name)\
  struct __clef_lazy_method_impl_##name { \
   TY * _x;\
@@ -522,28 +504,5 @@ namespace triqs { namespace clef {
  template< typename... Args>\
  auto operator()(Args&&... args ) && DECL_AND_RETURN(make_expr_call (std::move(*this),std::forward<Args>(args)...));\
 
-#else
-
-#define TRIQS_CLEF_IMPLEMENT_LAZY_METHOD(TY,name,RETURN_TYPE)\
- struct __clef_lazy_method_impl_##name { \
-  TY * _x;\
-  template<typename... A> RETURN_TYPE operator()(A&&... a) const {return ((*_x).name(std::forward<A>(a)...));}\
-  friend std::ostream & operator<<(std::ostream & out, __clef_lazy_method_impl_##name  const & x) { return out<<BOOST_PP_STRINGIZE(TY)<<"."<<BOOST_PP_STRINGIZE(name);}\
- };\
- template< typename... A> \
- typename _result_of::make_expr_call<__clef_lazy_method_impl_##name, A...>::type\
- name( A&& ... a) {return make_expr_call(__clef_lazy_method_impl_##name{this},std::forward<A>(a)...);}
-
-#define TRIQS_CLEF_IMPLEMENT_LAZY_CALL(TY)\
- template< typename... Args>\
- typename triqs::clef::_result_of::make_expr_call<TY const &,Args...>::type\
- operator()(Args&&... args ) const {return make_expr_call (*this,std::forward<Args>(args)...);}\
- \
- template< typename... Args>\
- typename triqs::clef::_result_of::make_expr_call<TY &,Args...>::type\
- operator()(Args&&... args ) {return make_expr_call (*this,std::forward<Args>(args)...);}
-
-#endif
-
 }} //  namespace triqs::clef
 #endif 

triqs/gfs.hpp

@@ -21,18 +21,14 @@
 #ifndef TRIQS_GFS_ALL_H
 #define TRIQS_GFS_ALL_H
 
-// The basic classes
 #include <triqs/gfs/block.hpp>
 #include <triqs/gfs/imtime.hpp>
 #include <triqs/gfs/imfreq.hpp>
 #include <triqs/gfs/retime.hpp>
 #include <triqs/gfs/refreq.hpp>
 #include <triqs/gfs/legendre.hpp>
-
-#ifndef TRIQS_COMPILER_IS_OBSOLETE
 #include <triqs/gfs/product.hpp>
 #include <triqs/gfs/curry.hpp>
-#endif
 
 #endif
 

triqs/gfs/block.hpp

@@ -145,11 +145,8 @@ namespace triqs { namespace gfs {
  template<typename T> size_t n_blocks (gf<block_index,T> const & g)      { return g.mesh().size();}
  template<typename T> size_t n_blocks (gf_view<block_index,T> const & g) { return g.mesh().size();}
 
-#ifndef TRIQS_COMPILER_IS_OBSOLETE
  template<typename T> using block_gf = gf<block_index, gf<T>>;
-#endif
 
- // also experimental
  // an iterator over the block
  template<typename Target, typename Opt>
   class block_gf_iterator : 

triqs/gfs/curry.hpp

@@ -21,9 +21,6 @@
 #ifndef TRIQS_GF_CURRY_H
 #define TRIQS_GF_CURRY_H
 #include "./product.hpp"
-#ifndef TRIQS_COMPILER_IS_C11_COMPLIANT
-#error "This header requires a fully C++11 compliant compiler"
-#endif
 namespace triqs { namespace gfs { 
 
  template<typename F> struct lambda_valued {};

triqs/gfs/evaluators.hpp

@@ -65,13 +65,7 @@ namespace triqs { namespace gfs {
    public :
     static constexpr int arity = 1;
     evaluator_one_var() = default;
-#ifndef TRIQS_COMPILER_OBSOLETE_GCC    
+    template<typename G> auto operator()(G const * g, double x) const DECL_AND_RETURN(evaluator_fnt_on_mesh<Variable> (g->mesh(),x)(on_mesh(*g)));
- template<typename G> auto operator()(G const * g, double x) const DECL_AND_RETURN(evaluator_fnt_on_mesh<Variable> (g->mesh(),x)(on_mesh(*g)));
-#else
- // needed on old gcc ?
- // template<typename G> auto operator()(G const * g, double x) const DECL_AND_RETURN(evaluator_fnt_on_mesh<Variable> (g->mesh(),x)(typename G::_on_mesh_wrapper_const(*g)));
-#endif
-
     template<typename G> typename G::singularity_t const & operator()(G const * g,freq_infty const &) const {return g->singularity();}
   };
 

triqs/gfs/gf.hpp

@@ -227,8 +227,6 @@ namespace triqs { namespace gfs {
     // First, a simple () returns a view, like for an array...
     view_type operator()() const { return *this;}
 
-#ifndef TRIQS_COMPILER_OBSOLETE_GCC    
-
     /// Calls are (perfectly) forwarded to the evaluator::operator(), except mesh_point_t and when
     /// there is at least one lazy argument ...
     template<typename Arg0, typename... Args >    // match any argument list, picking out the first type : () is not permitted
@@ -262,8 +260,6 @@ namespace triqs { namespace gfs {
       return clef::make_expr_call(std::move(*this),std::forward<Arg0>(arg0), std::forward<Args>(args)...);
      }
 
-#endif
-
     /*
     // on mesh component for composite meshes
     // enable iif the first arg is a mesh_point_t for the first component of the mesh_t
@@ -293,7 +289,6 @@ namespace triqs { namespace gfs {
     template<typename ... U>
      cr_type operator[] (closest_pt_wrap<U...> const & p) const { return _data_proxy(_data, _mesh.index_to_linear( gfs_implementation::get_closest_point<Variable,Target,Opt>::invoke(this,p)));}
 
-#ifndef TRIQS_COMPILER_OBSOLETE_GCC    
     template<typename Arg>
      typename clef::_result_of::make_expr_subscript<gf_impl const &,Arg>::type
      operator[](Arg && arg) const & { return clef::make_expr_subscript(*this,std::forward<Arg>(arg));}
@@ -305,7 +300,6 @@ namespace triqs { namespace gfs {
     template<typename Arg>
      typename clef::_result_of::make_expr_subscript<gf_impl,Arg>::type
      operator[](Arg && arg) && { return clef::make_expr_subscript(std::move(*this),std::forward<Arg>(arg));}
-#endif
 
     /// A direct access to the grid point
     template<typename... Args>
@@ -314,9 +308,7 @@ namespace triqs { namespace gfs {
     template<typename... Args>
      cr_type on_mesh (Args&&... args) const { return _data_proxy(_data,_mesh.index_to_linear(mesh_index_t(std::forward<Args>(args)...)));}
 
-#ifndef TRIQS_COMPILER_OBSOLETE_GCC    
    private:
-#endif
     struct _on_mesh_wrapper_const {
      gf_impl const & f; _on_mesh_wrapper_const (gf_impl const & _f) : f(_f) {}
      template <typename... Args> cr_type operator ()(Args && ... args) const { return f.on_mesh(std::forward<Args>(args)...);}

triqs/utility/compiler_details.hpp

@@ -31,7 +31,6 @@
                                + __GNUC_PATCHLEVEL__)
 #if GCC_VERSION < 40801
 //#warning "gcc compiler" GCC_VERSION
-#define TRIQS_COMPILER_IS_OBSOLETE
 #define TRIQS_COMPILER_OBSOLETE_GCC
 // we still accept gcc 4.6 and 4.7, but only the 4.8.1 and higher is a compliant c++11
 #endif

triqs/utility/tuple_tools.hpp

@@ -282,8 +282,6 @@ namespace triqs { namespace tuple {
  template<typename F, typename T1, typename T2, typename R>
   auto fold_on_zip (F && f,T1 const & t1, T2 const & t2, R && r) DECL_AND_RETURN( fold_on_zip_impl<std::tuple_size<T1>::value-1,T1,T2>()(std::forward<F>(f),t1,t2,std::forward<R>(r)));
 
-#ifdef TRIQS_COMPILER_IS_C11_COMPLIANT
-
  /** 
   * filter<int ... I>(t) : 
   *  Given a tuple t, and integers, returns the tuple where the elements at initial position I are dropped.
@@ -431,7 +429,6 @@ namespace triqs { namespace tuple {
  template<int ...I, typename Tu, typename R>
   auto replace(Tu const & tu, R const &r) DECL_AND_RETURN ( replace_impl<0,std::tuple_size<Tu>::value-1, I...>()(tu, std::make_tuple(),r));
 
-#endif
 
  /*
   * print a tuple