[Polly][isl++] Define dump() functions in translation unit. NFC.

[Meinersbur]

Summary

"Cleaner" version of D38198. The dump() functions are non-inline defined in isl-noexceptions.cpp such there is always a symbol for it that can be called in a debugger.

This gives up isl++ being header-only and requires support by the isl++ binding generator (not part of this patch).

There is an issue if PollyISL is linked as a static library. No symbol of isl-noexceptions.o is directly used, so the compiler does not add that file when linking. It seems to work with Visual Studio anyway, but not in gcc.

[Meinersbur]

Abandon because the alternative was committed

lib/External/CMakeLists.txt

set (ISL_FILES
     isl/isl_transitive_closure.c
     isl/isl_union_map.c
     isl/isl_val.c
     isl/isl_val_sioimath.c
     isl/isl_vec.c
     isl/isl_version.c
     isl/isl_vertices.c
     isl/print.c
+    isl/isl-noexceptions.cpp
     isl/imath/gmp_compat.c
     isl/imath/imath.c
     isl/imath/imrat.c
     )
 
   add_polly_library(PollyISL
     ${ISL_FILES}
     )

lib/External/isl/include/isl/isl-noexceptions.h

public:
   inline __isl_keep isl_aff *get() const;
   inline __isl_give isl_aff *release();
   inline bool is_null() const;
   inline __isl_keep isl_aff *keep() const;
   inline __isl_give isl_aff *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
   inline std::string to_str() const;
-  inline void dump() const;
+  void dump() const;
 
   inline isl::aff add(isl::aff aff2) const;
   inline isl::aff add_coefficient_si(isl::dim type, int pos, int v) const;
   inline isl::aff add_coefficient_val(isl::dim type, int pos, isl::val v) const;
   inline isl::aff add_constant_num_si(int v) const;
   inline isl::aff add_constant_si(int v) const;
   inline isl::aff add_constant_val(isl::val v) const;
   inline isl::aff add_dims(isl::dim type, unsigned int n) const;
public:
   inline __isl_give isl_aff_list *copy() && = delete;
   inline __isl_keep isl_aff_list *get() const;
   inline __isl_give isl_aff_list *release();
   inline bool is_null() const;
   inline __isl_keep isl_aff_list *keep() const;
   inline __isl_give isl_aff_list *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
-  inline void dump() const;
+  void dump() const;
 
 };
 
 // declarations for isl::ast_build
 inline isl::ast_build manage(__isl_take isl_ast_build *ptr);
 inline isl::ast_build give(__isl_take isl_ast_build *ptr);
 
 
public:
   inline __isl_keep isl_ast_expr *get() const;
   inline __isl_give isl_ast_expr *release();
   inline bool is_null() const;
   inline __isl_keep isl_ast_expr *keep() const;
   inline __isl_give isl_ast_expr *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
   inline std::string to_str() const;
-  inline void dump() const;
+  void dump() const;
 
   inline isl::ast_expr access(isl::ast_expr_list indices) const;
   inline isl::ast_expr add(isl::ast_expr expr2) const;
   inline isl::ast_expr address_of() const;
   inline isl::ast_expr call(isl::ast_expr_list arguments) const;
   inline isl::ast_expr div(isl::ast_expr expr2) const;
   inline isl::ast_expr eq(isl::ast_expr expr2) const;
   static inline isl::ast_expr from_id(isl::id id);
public:
   inline __isl_give isl_ast_expr_list *copy() && = delete;
   inline __isl_keep isl_ast_expr_list *get() const;
   inline __isl_give isl_ast_expr_list *release();
   inline bool is_null() const;
   inline __isl_keep isl_ast_expr_list *keep() const;
   inline __isl_give isl_ast_expr_list *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
-  inline void dump() const;
+  void dump() const;
 
 };
 
 // declarations for isl::ast_node
 inline isl::ast_node manage(__isl_take isl_ast_node *ptr);
 inline isl::ast_node give(__isl_take isl_ast_node *ptr);
 
 
public:
   inline __isl_keep isl_ast_node *get() const;
   inline __isl_give isl_ast_node *release();
   inline bool is_null() const;
   inline __isl_keep isl_ast_node *keep() const;
   inline __isl_give isl_ast_node *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
   inline std::string to_str() const;
-  inline void dump() const;
+  void dump() const;
 
   static inline isl::ast_node alloc_user(isl::ast_expr expr);
   inline isl::ast_node_list block_get_children() const;
   inline isl::ast_node for_get_body() const;
   inline isl::ast_expr for_get_cond() const;
   inline isl::ast_expr for_get_inc() const;
   inline isl::ast_expr for_get_init() const;
   inline isl::ast_expr for_get_iterator() const;
public:
   inline __isl_give isl_ast_node_list *copy() && = delete;
   inline __isl_keep isl_ast_node_list *get() const;
   inline __isl_give isl_ast_node_list *release();
   inline bool is_null() const;
   inline __isl_keep isl_ast_node_list *keep() const;
   inline __isl_give isl_ast_node_list *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
-  inline void dump() const;
+  void dump() const;
 
 };
 
 // declarations for isl::band_list
 inline isl::band_list manage(__isl_take isl_band_list *ptr);
 inline isl::band_list give(__isl_take isl_band_list *ptr);
 
 
public:
   inline __isl_give isl_band_list *copy() && = delete;
   inline __isl_keep isl_band_list *get() const;
   inline __isl_give isl_band_list *release();
   inline bool is_null() const;
   inline __isl_keep isl_band_list *keep() const;
   inline __isl_give isl_band_list *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
-  inline void dump() const;
+  void dump() const;
 
 };
 
 // declarations for isl::basic_map
 inline isl::basic_map manage(__isl_take isl_basic_map *ptr);
 inline isl::basic_map give(__isl_take isl_basic_map *ptr);
 
 
public:
   inline __isl_keep isl_basic_map *get() const;
   inline __isl_give isl_basic_map *release();
   inline bool is_null() const;
   inline __isl_keep isl_basic_map *keep() const;
   inline __isl_give isl_basic_map *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
   inline std::string to_str() const;
-  inline void dump() const;
+  void dump() const;
 
   inline isl::basic_map add_constraint(isl::constraint constraint) const;
   inline isl::basic_map add_dims(isl::dim type, unsigned int n) const;
   inline isl::basic_map affine_hull() const;
   inline isl::basic_map align_params(isl::space model) const;
   inline isl::basic_map apply_domain(isl::basic_map bmap2) const;
   inline isl::basic_map apply_range(isl::basic_map bmap2) const;
   inline isl::boolean can_curry() const;
public:
   inline __isl_give isl_basic_map_list *copy() && = delete;
   inline __isl_keep isl_basic_map_list *get() const;
   inline __isl_give isl_basic_map_list *release();
   inline bool is_null() const;
   inline __isl_keep isl_basic_map_list *keep() const;
   inline __isl_give isl_basic_map_list *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
-  inline void dump() const;
+  void dump() const;
 
 };
 
 // declarations for isl::basic_set
 inline isl::basic_set manage(__isl_take isl_basic_set *ptr);
 inline isl::basic_set give(__isl_take isl_basic_set *ptr);
 
 
public:
   inline __isl_keep isl_basic_set *get() const;
   inline __isl_give isl_basic_set *release();
   inline bool is_null() const;
   inline __isl_keep isl_basic_set *keep() const;
   inline __isl_give isl_basic_set *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
   inline std::string to_str() const;
-  inline void dump() const;
+  void dump() const;
 
   inline isl::basic_set affine_hull() const;
   inline isl::basic_set align_params(isl::space model) const;
   inline isl::basic_set apply(isl::basic_map bmap) const;
   static inline isl::basic_set box_from_points(isl::point pnt1, isl::point pnt2);
   inline isl::basic_set coefficients() const;
   inline isl::basic_set detect_equalities() const;
   inline unsigned int dim(isl::dim type) const;
public:
   inline __isl_give isl_basic_set_list *copy() && = delete;
   inline __isl_keep isl_basic_set_list *get() const;
   inline __isl_give isl_basic_set_list *release();
   inline bool is_null() const;
   inline __isl_keep isl_basic_set_list *keep() const;
   inline __isl_give isl_basic_set_list *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
-  inline void dump() const;
+  void dump() const;
 
 };
 
 // declarations for isl::constraint
 inline isl::constraint manage(__isl_take isl_constraint *ptr);
 inline isl::constraint give(__isl_take isl_constraint *ptr);
 
 
public:
   inline __isl_give isl_constraint *copy() && = delete;
   inline __isl_keep isl_constraint *get() const;
   inline __isl_give isl_constraint *release();
   inline bool is_null() const;
   inline __isl_keep isl_constraint *keep() const;
   inline __isl_give isl_constraint *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
-  inline void dump() const;
+  void dump() const;
 
   static inline isl::constraint alloc_equality(isl::local_space ls);
   static inline isl::constraint alloc_inequality(isl::local_space ls);
   inline int cmp_last_non_zero(const isl::constraint &c2) const;
   inline isl::aff get_aff() const;
   inline isl::aff get_bound(isl::dim type, int pos) const;
   inline isl::val get_coefficient_val(isl::dim type, int pos) const;
   inline isl::val get_constant_val() const;
public:
   inline __isl_give isl_constraint_list *copy() && = delete;
   inline __isl_keep isl_constraint_list *get() const;
   inline __isl_give isl_constraint_list *release();
   inline bool is_null() const;
   inline __isl_keep isl_constraint_list *keep() const;
   inline __isl_give isl_constraint_list *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
-  inline void dump() const;
+  void dump() const;
 
 };
 
 // declarations for isl::id
 inline isl::id manage(__isl_take isl_id *ptr);
 inline isl::id give(__isl_take isl_id *ptr);
 
 
public:
   inline __isl_keep isl_id *get() const;
   inline __isl_give isl_id *release();
   inline bool is_null() const;
   inline __isl_keep isl_id *keep() const;
   inline __isl_give isl_id *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
   inline std::string to_str() const;
-  inline void dump() const;
+  void dump() const;
 
   static inline isl::id alloc(isl::ctx ctx, const std::string &name, void * user);
   inline uint32_t get_hash() const;
   inline std::string get_name() const;
   inline void * get_user() const;
 };
 
 // declarations for isl::id_list
public:
   inline __isl_give isl_id_list *copy() && = delete;
   inline __isl_keep isl_id_list *get() const;
   inline __isl_give isl_id_list *release();
   inline bool is_null() const;
   inline __isl_keep isl_id_list *keep() const;
   inline __isl_give isl_id_list *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
-  inline void dump() const;
+  void dump() const;
 
 };
 
 // declarations for isl::id_to_ast_expr
 inline isl::id_to_ast_expr manage(__isl_take isl_id_to_ast_expr *ptr);
 inline isl::id_to_ast_expr give(__isl_take isl_id_to_ast_expr *ptr);
 
 
public:
   inline __isl_give isl_id_to_ast_expr *copy() && = delete;
   inline __isl_keep isl_id_to_ast_expr *get() const;
   inline __isl_give isl_id_to_ast_expr *release();
   inline bool is_null() const;
   inline __isl_keep isl_id_to_ast_expr *keep() const;
   inline __isl_give isl_id_to_ast_expr *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
-  inline void dump() const;
+  void dump() const;
 
   static inline isl::id_to_ast_expr alloc(isl::ctx ctx, int min_size);
   inline isl::id_to_ast_expr drop(isl::id key) const;
   inline isl::stat foreach(const std::function<isl::stat(isl::id, isl::ast_expr)> &fn) const;
   inline isl::ast_expr get(isl::id key) const;
   inline isl::boolean has(const isl::id &key) const;
   inline isl::id_to_ast_expr set(isl::id key, isl::ast_expr val) const;
 };
public:
   inline __isl_give isl_local_space *copy() && = delete;
   inline __isl_keep isl_local_space *get() const;
   inline __isl_give isl_local_space *release();
   inline bool is_null() const;
   inline __isl_keep isl_local_space *keep() const;
   inline __isl_give isl_local_space *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
-  inline void dump() const;
+  void dump() const;
 
   inline isl::local_space add_dims(isl::dim type, unsigned int n) const;
   inline int dim(isl::dim type) const;
   inline isl::local_space domain() const;
   inline isl::local_space drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline int find_dim_by_name(isl::dim type, const std::string &name) const;
   inline isl::local_space flatten_domain() const;
   inline isl::local_space flatten_range() const;
public:
   inline __isl_keep isl_map *get() const;
   inline __isl_give isl_map *release();
   inline bool is_null() const;
   inline __isl_keep isl_map *keep() const;
   inline __isl_give isl_map *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
   inline std::string to_str() const;
-  inline void dump() const;
+  void dump() const;
 
   inline isl::map add_constraint(isl::constraint constraint) const;
   inline isl::map add_dims(isl::dim type, unsigned int n) const;
   inline isl::basic_map affine_hull() const;
   inline isl::map align_params(isl::space model) const;
   inline isl::map apply_domain(isl::map map2) const;
   inline isl::map apply_range(isl::map map2) const;
   inline isl::boolean can_curry() const;
public:
   inline __isl_give isl_map_list *copy() && = delete;
   inline __isl_keep isl_map_list *get() const;
   inline __isl_give isl_map_list *release();
   inline bool is_null() const;
   inline __isl_keep isl_map_list *keep() const;
   inline __isl_give isl_map_list *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
-  inline void dump() const;
+  void dump() const;
 
 };
 
 // declarations for isl::multi_aff
 inline isl::multi_aff manage(__isl_take isl_multi_aff *ptr);
 inline isl::multi_aff give(__isl_take isl_multi_aff *ptr);
 
 
public:
   inline __isl_keep isl_multi_aff *get() const;
   inline __isl_give isl_multi_aff *release();
   inline bool is_null() const;
   inline __isl_keep isl_multi_aff *keep() const;
   inline __isl_give isl_multi_aff *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
   inline std::string to_str() const;
-  inline void dump() const;
+  void dump() const;
 
   inline isl::multi_aff add(isl::multi_aff multi2) const;
   inline isl::multi_aff add_dims(isl::dim type, unsigned int n) const;
   inline isl::multi_aff align_params(isl::space model) const;
   inline unsigned int dim(isl::dim type) const;
   static inline isl::multi_aff domain_map(isl::space space);
   inline isl::multi_aff drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::multi_aff factor_range() const;
public:
   inline __isl_keep isl_multi_pw_aff *get() const;
   inline __isl_give isl_multi_pw_aff *release();
   inline bool is_null() const;
   inline __isl_keep isl_multi_pw_aff *keep() const;
   inline __isl_give isl_multi_pw_aff *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
   inline std::string to_str() const;
-  inline void dump() const;
+  void dump() const;
 
   inline isl::multi_pw_aff add(isl::multi_pw_aff multi2) const;
   inline isl::multi_pw_aff add_dims(isl::dim type, unsigned int n) const;
   inline isl::multi_pw_aff align_params(isl::space model) const;
   inline isl::multi_pw_aff coalesce() const;
   inline unsigned int dim(isl::dim type) const;
   inline isl::set domain() const;
   inline isl::multi_pw_aff drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
public:
   inline __isl_keep isl_multi_union_pw_aff *get() const;
   inline __isl_give isl_multi_union_pw_aff *release();
   inline bool is_null() const;
   inline __isl_keep isl_multi_union_pw_aff *keep() const;
   inline __isl_give isl_multi_union_pw_aff *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
   inline std::string to_str() const;
-  inline void dump() const;
+  void dump() const;
 
   inline isl::multi_union_pw_aff add(isl::multi_union_pw_aff multi2) const;
   inline isl::multi_union_pw_aff align_params(isl::space model) const;
   inline isl::union_pw_aff apply_aff(isl::aff aff) const;
   inline isl::union_pw_aff apply_pw_aff(isl::pw_aff pa) const;
   inline isl::multi_union_pw_aff apply_pw_multi_aff(isl::pw_multi_aff pma) const;
   inline isl::multi_union_pw_aff coalesce() const;
   inline unsigned int dim(isl::dim type) const;
public:
   inline __isl_keep isl_multi_val *get() const;
   inline __isl_give isl_multi_val *release();
   inline bool is_null() const;
   inline __isl_keep isl_multi_val *keep() const;
   inline __isl_give isl_multi_val *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
   inline std::string to_str() const;
-  inline void dump() const;
+  void dump() const;
 
   inline isl::multi_val add(isl::multi_val multi2) const;
   inline isl::multi_val add_dims(isl::dim type, unsigned int n) const;
   inline isl::multi_val add_val(isl::val v) const;
   inline isl::multi_val align_params(isl::space model) const;
   inline unsigned int dim(isl::dim type) const;
   inline isl::multi_val drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::multi_val factor_range() const;
public:
   inline __isl_keep isl_point *get() const;
   inline __isl_give isl_point *release();
   inline bool is_null() const;
   inline __isl_keep isl_point *keep() const;
   inline __isl_give isl_point *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
   inline std::string to_str() const;
-  inline void dump() const;
+  void dump() const;
 
   inline isl::point add_ui(isl::dim type, int pos, unsigned int val) const;
   inline isl::val get_coordinate_val(isl::dim type, int pos) const;
   inline isl::space get_space() const;
   inline isl::point set_coordinate_val(isl::dim type, int pos, isl::val v) const;
   inline isl::point sub_ui(isl::dim type, int pos, unsigned int val) const;
 };
 
public:
   inline __isl_keep isl_pw_aff *get() const;
   inline __isl_give isl_pw_aff *release();
   inline bool is_null() const;
   inline __isl_keep isl_pw_aff *keep() const;
   inline __isl_give isl_pw_aff *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
   inline std::string to_str() const;
-  inline void dump() const;
+  void dump() const;
 
   inline isl::pw_aff add(isl::pw_aff pwaff2) const;
   inline isl::pw_aff add_dims(isl::dim type, unsigned int n) const;
   inline isl::pw_aff align_params(isl::space model) const;
   static inline isl::pw_aff alloc(isl::set set, isl::aff aff);
   inline isl::pw_aff ceil() const;
   inline isl::pw_aff coalesce() const;
   inline isl::pw_aff cond(isl::pw_aff pwaff_true, isl::pw_aff pwaff_false) const;
public:
   inline __isl_give isl_pw_aff_list *copy() && = delete;
   inline __isl_keep isl_pw_aff_list *get() const;
   inline __isl_give isl_pw_aff_list *release();
   inline bool is_null() const;
   inline __isl_keep isl_pw_aff_list *keep() const;
   inline __isl_give isl_pw_aff_list *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
-  inline void dump() const;
+  void dump() const;
 
 };
 
 // declarations for isl::pw_multi_aff
 inline isl::pw_multi_aff manage(__isl_take isl_pw_multi_aff *ptr);
 inline isl::pw_multi_aff give(__isl_take isl_pw_multi_aff *ptr);
 
 
public:
   inline __isl_keep isl_pw_multi_aff *get() const;
   inline __isl_give isl_pw_multi_aff *release();
   inline bool is_null() const;
   inline __isl_keep isl_pw_multi_aff *keep() const;
   inline __isl_give isl_pw_multi_aff *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
   inline std::string to_str() const;
-  inline void dump() const;
+  void dump() const;
 
   inline isl::pw_multi_aff add(isl::pw_multi_aff pma2) const;
   inline isl::pw_multi_aff align_params(isl::space model) const;
   static inline isl::pw_multi_aff alloc(isl::set set, isl::multi_aff maff);
   inline isl::pw_multi_aff coalesce() const;
   inline unsigned int dim(isl::dim type) const;
   inline isl::set domain() const;
   inline isl::pw_multi_aff drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
public:
   inline __isl_keep isl_pw_qpolynomial *get() const;
   inline __isl_give isl_pw_qpolynomial *release();
   inline bool is_null() const;
   inline __isl_keep isl_pw_qpolynomial *keep() const;
   inline __isl_give isl_pw_qpolynomial *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
   inline std::string to_str() const;
-  inline void dump() const;
+  void dump() const;
 
   inline isl::pw_qpolynomial add(isl::pw_qpolynomial pwqp2) const;
   inline isl::pw_qpolynomial add_dims(isl::dim type, unsigned int n) const;
   static inline isl::pw_qpolynomial alloc(isl::set set, isl::qpolynomial qp);
   inline isl::pw_qpolynomial coalesce() const;
   inline unsigned int dim(isl::dim type) const;
   inline isl::set domain() const;
   inline isl::pw_qpolynomial drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
public:
   inline __isl_give isl_qpolynomial *copy() && = delete;
   inline __isl_keep isl_qpolynomial *get() const;
   inline __isl_give isl_qpolynomial *release();
   inline bool is_null() const;
   inline __isl_keep isl_qpolynomial *keep() const;
   inline __isl_give isl_qpolynomial *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
-  inline void dump() const;
+  void dump() const;
 
   inline isl::qpolynomial add(isl::qpolynomial qp2) const;
   inline isl::qpolynomial add_dims(isl::dim type, unsigned int n) const;
   inline isl::qpolynomial align_params(isl::space model) const;
   inline isl::stat as_polynomial_on_domain(const isl::basic_set &bset, const std::function<isl::stat(isl::basic_set, isl::qpolynomial)> &fn) const;
   inline unsigned int dim(isl::dim type) const;
   inline isl::qpolynomial drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::val eval(isl::point pnt) const;
public:
   inline __isl_keep isl_schedule *get() const;
   inline __isl_give isl_schedule *release();
   inline bool is_null() const;
   inline __isl_keep isl_schedule *keep() const;
   inline __isl_give isl_schedule *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
   inline std::string to_str() const;
-  inline void dump() const;
+  void dump() const;
 
   inline isl::schedule align_params(isl::space space) const;
   static inline isl::schedule empty(isl::space space);
   static inline isl::schedule from_domain(isl::union_set domain);
   inline isl::union_set get_domain() const;
   inline isl::union_map get_map() const;
   inline isl::schedule_node get_root() const;
   inline isl::schedule gist_domain_params(isl::set context) const;
public:
   inline __isl_keep isl_schedule_constraints *get() const;
   inline __isl_give isl_schedule_constraints *release();
   inline bool is_null() const;
   inline __isl_keep isl_schedule_constraints *keep() const;
   inline __isl_give isl_schedule_constraints *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
   inline std::string to_str() const;
-  inline void dump() const;
+  void dump() const;
 
   inline isl::schedule_constraints apply(isl::union_map umap) const;
   inline isl::schedule compute_schedule() const;
   inline isl::union_map get_coincidence() const;
   inline isl::union_map get_conditional_validity() const;
   inline isl::union_map get_conditional_validity_condition() const;
   inline isl::set get_context() const;
   inline isl::union_set get_domain() const;
public:
   inline __isl_keep isl_schedule_node *get() const;
   inline __isl_give isl_schedule_node *release();
   inline bool is_null() const;
   inline __isl_keep isl_schedule_node *keep() const;
   inline __isl_give isl_schedule_node *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
   inline std::string to_str() const;
-  inline void dump() const;
+  void dump() const;
 
   inline isl::schedule_node align_params(isl::space space) const;
   inline isl::schedule_node ancestor(int generation) const;
   inline isl::boolean band_member_get_coincident(int pos) const;
   inline isl::schedule_node band_member_set_coincident(int pos, int coincident) const;
   inline isl::schedule_node band_set_ast_build_options(isl::union_set options) const;
   inline isl::schedule_node child(int pos) const;
   inline isl::set context_get_context() const;
public:
   inline __isl_keep isl_set *get() const;
   inline __isl_give isl_set *release();
   inline bool is_null() const;
   inline __isl_keep isl_set *keep() const;
   inline __isl_give isl_set *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
   inline std::string to_str() const;
-  inline void dump() const;
+  void dump() const;
 
   inline isl::set add_constraint(isl::constraint constraint) const;
   inline isl::set add_dims(isl::dim type, unsigned int n) const;
   inline isl::basic_set affine_hull() const;
   inline isl::set align_params(isl::space model) const;
   inline isl::set apply(isl::map map) const;
   inline isl::basic_set bounded_simple_hull() const;
   static inline isl::set box_from_points(isl::point pnt1, isl::point pnt2);
public:
   inline __isl_give isl_set_list *copy() && = delete;
   inline __isl_keep isl_set_list *get() const;
   inline __isl_give isl_set_list *release();
   inline bool is_null() const;
   inline __isl_keep isl_set_list *keep() const;
   inline __isl_give isl_set_list *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
-  inline void dump() const;
+  void dump() const;
 
 };
 
 // declarations for isl::space
 inline isl::space manage(__isl_take isl_space *ptr);
 inline isl::space give(__isl_take isl_space *ptr);
 
 
public:
   inline __isl_keep isl_space *get() const;
   inline __isl_give isl_space *release();
   inline bool is_null() const;
   inline __isl_keep isl_space *keep() const;
   inline __isl_give isl_space *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
   inline std::string to_str() const;
-  inline void dump() const;
+  void dump() const;
 
   inline isl::space add_dims(isl::dim type, unsigned int n) const;
   inline isl::space align_params(isl::space dim2) const;
   inline isl::boolean can_curry() const;
   inline isl::boolean can_range_curry() const;
   inline isl::boolean can_uncurry() const;
   inline isl::boolean can_zip() const;
   inline isl::space curry() const;
public:
   inline __isl_keep isl_union_map *get() const;
   inline __isl_give isl_union_map *release();
   inline bool is_null() const;
   inline __isl_keep isl_union_map *keep() const;
   inline __isl_give isl_union_map *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
   inline std::string to_str() const;
-  inline void dump() const;
+  void dump() const;
 
   inline isl::union_map add_map(isl::map map) const;
   inline isl::union_map affine_hull() const;
   inline isl::union_map align_params(isl::space model) const;
   inline isl::union_map apply_domain(isl::union_map umap2) const;
   inline isl::union_map apply_range(isl::union_map umap2) const;
   inline isl::union_map coalesce() const;
   inline isl::boolean contains(const isl::space &space) const;
public:
   inline __isl_give isl_union_map_list *copy() && = delete;
   inline __isl_keep isl_union_map_list *get() const;
   inline __isl_give isl_union_map_list *release();
   inline bool is_null() const;
   inline __isl_keep isl_union_map_list *keep() const;
   inline __isl_give isl_union_map_list *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
-  inline void dump() const;
+  void dump() const;
 
 };
 
 // declarations for isl::union_pw_aff
 inline isl::union_pw_aff manage(__isl_take isl_union_pw_aff *ptr);
 inline isl::union_pw_aff give(__isl_take isl_union_pw_aff *ptr);
 
 
public:
   inline __isl_keep isl_union_pw_aff *get() const;
   inline __isl_give isl_union_pw_aff *release();
   inline bool is_null() const;
   inline __isl_keep isl_union_pw_aff *keep() const;
   inline __isl_give isl_union_pw_aff *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
   inline std::string to_str() const;
-  inline void dump() const;
+  void dump() const;
 
   inline isl::union_pw_aff add(isl::union_pw_aff upa2) const;
   inline isl::union_pw_aff add_pw_aff(isl::pw_aff pa) const;
   static inline isl::union_pw_aff aff_on_domain(isl::union_set domain, isl::aff aff);
   inline isl::union_pw_aff align_params(isl::space model) const;
   inline isl::union_pw_aff coalesce() const;
   inline unsigned int dim(isl::dim type) const;
   inline isl::union_set domain() const;
public:
   inline __isl_give isl_union_pw_aff_list *copy() && = delete;
   inline __isl_keep isl_union_pw_aff_list *get() const;
   inline __isl_give isl_union_pw_aff_list *release();
   inline bool is_null() const;
   inline __isl_keep isl_union_pw_aff_list *keep() const;
   inline __isl_give isl_union_pw_aff_list *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
-  inline void dump() const;
+  void dump() const;
 
 };
 
 // declarations for isl::union_pw_multi_aff
 inline isl::union_pw_multi_aff manage(__isl_take isl_union_pw_multi_aff *ptr);
 inline isl::union_pw_multi_aff give(__isl_take isl_union_pw_multi_aff *ptr);
 
 
public:
   inline __isl_keep isl_union_pw_multi_aff *get() const;
   inline __isl_give isl_union_pw_multi_aff *release();
   inline bool is_null() const;
   inline __isl_keep isl_union_pw_multi_aff *keep() const;
   inline __isl_give isl_union_pw_multi_aff *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
   inline std::string to_str() const;
-  inline void dump() const;
+  void dump() const;
 
   inline isl::union_pw_multi_aff add(isl::union_pw_multi_aff upma2) const;
   inline isl::union_pw_multi_aff add_pw_multi_aff(isl::pw_multi_aff pma) const;
   inline isl::union_pw_multi_aff align_params(isl::space model) const;
   inline isl::union_pw_multi_aff coalesce() const;
   inline unsigned int dim(isl::dim type) const;
   inline isl::union_set domain() const;
   inline isl::union_pw_multi_aff drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
public:
   inline __isl_give isl_union_pw_multi_aff_list *copy() && = delete;
   inline __isl_keep isl_union_pw_multi_aff_list *get() const;
   inline __isl_give isl_union_pw_multi_aff_list *release();
   inline bool is_null() const;
   inline __isl_keep isl_union_pw_multi_aff_list *keep() const;
   inline __isl_give isl_union_pw_multi_aff_list *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
-  inline void dump() const;
+  void dump() const;
 
 };
 
 // declarations for isl::union_pw_qpolynomial
 inline isl::union_pw_qpolynomial manage(__isl_take isl_union_pw_qpolynomial *ptr);
 inline isl::union_pw_qpolynomial give(__isl_take isl_union_pw_qpolynomial *ptr);
 
 
public:
   inline __isl_keep isl_union_set *get() const;
   inline __isl_give isl_union_set *release();
   inline bool is_null() const;
   inline __isl_keep isl_union_set *keep() const;
   inline __isl_give isl_union_set *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
   inline std::string to_str() const;
-  inline void dump() const;
+  void dump() const;
 
   inline isl::union_set add_set(isl::set set) const;
   inline isl::union_set affine_hull() const;
   inline isl::union_set align_params(isl::space model) const;
   inline isl::union_set apply(isl::union_map umap) const;
   inline isl::union_set coalesce() const;
   inline isl::union_set coefficients() const;
   inline isl::schedule compute_schedule(isl::union_map validity, isl::union_map proximity) const;
public:
   inline __isl_give isl_union_set_list *copy() && = delete;
   inline __isl_keep isl_union_set_list *get() const;
   inline __isl_give isl_union_set_list *release();
   inline bool is_null() const;
   inline __isl_keep isl_union_set_list *keep() const;
   inline __isl_give isl_union_set_list *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
-  inline void dump() const;
+  void dump() const;
 
 };
 
 // declarations for isl::val
 inline isl::val manage(__isl_take isl_val *ptr);
 inline isl::val give(__isl_take isl_val *ptr);
 
 
public:
   inline __isl_keep isl_val *get() const;
   inline __isl_give isl_val *release();
   inline bool is_null() const;
   inline __isl_keep isl_val *keep() const;
   inline __isl_give isl_val *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
   inline std::string to_str() const;
-  inline void dump() const;
+  void dump() const;
 
   inline isl::val two_exp() const;
   inline isl::val abs() const;
   inline isl::boolean abs_eq(const isl::val &v2) const;
   inline isl::val add(isl::val v2) const;
   inline isl::val add_ui(unsigned long v2) const;
   inline isl::val ceil() const;
   inline int cmp_si(long i) const;
public:
   inline __isl_give isl_val_list *copy() && = delete;
   inline __isl_keep isl_val_list *get() const;
   inline __isl_give isl_val_list *release();
   inline bool is_null() const;
   inline __isl_keep isl_val_list *keep() const;
   inline __isl_give isl_val_list *take();
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
-  inline void dump() const;
+  void dump() const;
 
 };
 
 // implementations for isl::aff
 isl::aff manage(__isl_take isl_aff *ptr) {
   return aff(ptr);
 }
 isl::aff give(__isl_take isl_aff *ptr) {
std::string aff::to_str() const {
   char *Tmp = isl_aff_to_str(get());
   if (!Tmp)
     return "";
   std::string S(Tmp);
   free(Tmp);
   return S;
 }
 
-
-void aff::dump() const {
-  isl_aff_dump(get());
-}
-
-
 isl::aff aff::add(isl::aff aff2) const {
   auto res = isl_aff_add(copy(), aff2.release());
   return manage(res);
 }
 
 isl::aff aff::add_coefficient_si(isl::dim type, int pos, int v) const {
   auto res = isl_aff_add_coefficient_si(copy(), static_cast<enum isl_dim_type>(type), pos, v);
   return manage(res);
aff_list::operator bool() const {
   return !is_null();
 }
 
 isl::ctx aff_list::get_ctx() const {
   return isl::ctx(isl_aff_list_get_ctx(ptr));
 }
 
 
-
-void aff_list::dump() const {
-  isl_aff_list_dump(get());
-}
-
-
-
 // implementations for isl::ast_build
 isl::ast_build manage(__isl_take isl_ast_build *ptr) {
   return ast_build(ptr);
 }
 isl::ast_build give(__isl_take isl_ast_build *ptr) {
   return manage(ptr);
 }
 
std::string ast_expr::to_str() const {
   if (!Tmp)
     return "";
   std::string S(Tmp);
   free(Tmp);
   return S;
 }
 
 
-void ast_expr::dump() const {
-  isl_ast_expr_dump(get());
-}
-
-
 isl::ast_expr ast_expr::access(isl::ast_expr_list indices) const {
   auto res = isl_ast_expr_access(copy(), indices.release());
   return manage(res);
 }
 
 isl::ast_expr ast_expr::add(isl::ast_expr expr2) const {
   auto res = isl_ast_expr_add(copy(), expr2.release());
   return manage(res);
ast_expr_list::operator bool() const {
   return !is_null();
 }
 
 isl::ctx ast_expr_list::get_ctx() const {
   return isl::ctx(isl_ast_expr_list_get_ctx(ptr));
 }
 
 
-
-void ast_expr_list::dump() const {
-  isl_ast_expr_list_dump(get());
-}
-
-
-
 // implementations for isl::ast_node
 isl::ast_node manage(__isl_take isl_ast_node *ptr) {
   return ast_node(ptr);
 }
 isl::ast_node give(__isl_take isl_ast_node *ptr) {
   return manage(ptr);
 }
 
std::string ast_node::to_str() const {
   if (!Tmp)
     return "";
   std::string S(Tmp);
   free(Tmp);
   return S;
 }
 
 
-void ast_node::dump() const {
-  isl_ast_node_dump(get());
-}
-
-
 isl::ast_node ast_node::alloc_user(isl::ast_expr expr) {
   auto res = isl_ast_node_alloc_user(expr.release());
   return manage(res);
 }
 
 isl::ast_node_list ast_node::block_get_children() const {
   auto res = isl_ast_node_block_get_children(get());
   return manage(res);
ast_node_list::operator bool() const {
   return !is_null();
 }
 
 isl::ctx ast_node_list::get_ctx() const {
   return isl::ctx(isl_ast_node_list_get_ctx(ptr));
 }
 
 
-
-void ast_node_list::dump() const {
-  isl_ast_node_list_dump(get());
-}
-
-
-
 // implementations for isl::band_list
 isl::band_list manage(__isl_take isl_band_list *ptr) {
   return band_list(ptr);
 }
 isl::band_list give(__isl_take isl_band_list *ptr) {
   return manage(ptr);
 }
 
band_list::operator bool() const {
   return !is_null();
 }
 
 isl::ctx band_list::get_ctx() const {
   return isl::ctx(isl_band_list_get_ctx(ptr));
 }
 
 
-
-void band_list::dump() const {
-  isl_band_list_dump(get());
-}
-
-
-
 // implementations for isl::basic_map
 isl::basic_map manage(__isl_take isl_basic_map *ptr) {
   return basic_map(ptr);
 }
 isl::basic_map give(__isl_take isl_basic_map *ptr) {
   return manage(ptr);
 }
 
std::string basic_map::to_str() const {
   if (!Tmp)
     return "";
   std::string S(Tmp);
   free(Tmp);
   return S;
 }
 
 
-void basic_map::dump() const {
-  isl_basic_map_dump(get());
-}
-
-
 isl::basic_map basic_map::add_constraint(isl::constraint constraint) const {
   auto res = isl_basic_map_add_constraint(copy(), constraint.release());
   return manage(res);
 }
 
 isl::basic_map basic_map::add_dims(isl::dim type, unsigned int n) const {
   auto res = isl_basic_map_add_dims(copy(), static_cast<enum isl_dim_type>(type), n);
   return manage(res);
basic_map_list::operator bool() const {
   return !is_null();
 }
 
 isl::ctx basic_map_list::get_ctx() const {
   return isl::ctx(isl_basic_map_list_get_ctx(ptr));
 }
 
 
-
-void basic_map_list::dump() const {
-  isl_basic_map_list_dump(get());
-}
-
-
-
 // implementations for isl::basic_set
 isl::basic_set manage(__isl_take isl_basic_set *ptr) {
   return basic_set(ptr);
 }
 isl::basic_set give(__isl_take isl_basic_set *ptr) {
   return manage(ptr);
 }
 
std::string basic_set::to_str() const {
   if (!Tmp)
     return "";
   std::string S(Tmp);
   free(Tmp);
   return S;
 }
 
 
-void basic_set::dump() const {
-  isl_basic_set_dump(get());
-}
-
-
 isl::basic_set basic_set::affine_hull() const {
   auto res = isl_basic_set_affine_hull(copy());
   return manage(res);
 }
 
 isl::basic_set basic_set::align_params(isl::space model) const {
   auto res = isl_basic_set_align_params(copy(), model.release());
   return manage(res);
basic_set_list::operator bool() const {
   return !is_null();
 }
 
 isl::ctx basic_set_list::get_ctx() const {
   return isl::ctx(isl_basic_set_list_get_ctx(ptr));
 }
 
 
-
-void basic_set_list::dump() const {
-  isl_basic_set_list_dump(get());
-}
-
-
-
 // implementations for isl::constraint
 isl::constraint manage(__isl_take isl_constraint *ptr) {
   return constraint(ptr);
 }
 isl::constraint give(__isl_take isl_constraint *ptr) {
   return manage(ptr);
 }
 
constraint::operator bool() const {
   return !is_null();
 }
 
 isl::ctx constraint::get_ctx() const {
   return isl::ctx(isl_constraint_get_ctx(ptr));
 }
 
 
-
-void constraint::dump() const {
-  isl_constraint_dump(get());
-}
-
-
 isl::constraint constraint::alloc_equality(isl::local_space ls) {
   auto res = isl_constraint_alloc_equality(ls.release());
   return manage(res);
 }
 
 isl::constraint constraint::alloc_inequality(isl::local_space ls) {
   auto res = isl_constraint_alloc_inequality(ls.release());
   return manage(res);
constraint_list::operator bool() const {
   return !is_null();
 }
 
 isl::ctx constraint_list::get_ctx() const {
   return isl::ctx(isl_constraint_list_get_ctx(ptr));
 }
 
 
-
-void constraint_list::dump() const {
-  isl_constraint_list_dump(get());
-}
-
-
-
 // implementations for isl::id
 isl::id manage(__isl_take isl_id *ptr) {
   return id(ptr);
 }
 isl::id give(__isl_take isl_id *ptr) {
   return manage(ptr);
 }
 
std::string id::to_str() const {
   if (!Tmp)
     return "";
   std::string S(Tmp);
   free(Tmp);
   return S;
 }
 
 
-void id::dump() const {
-  isl_id_dump(get());
-}
-
-
 isl::id id::alloc(isl::ctx ctx, const std::string &name, void * user) {
   auto res = isl_id_alloc(ctx.release(), name.c_str(), user);
   return manage(res);
 }
 
 uint32_t id::get_hash() const {
   auto res = isl_id_get_hash(get());
   return res;
id_list::operator bool() const {
   return !is_null();
 }
 
 isl::ctx id_list::get_ctx() const {
   return isl::ctx(isl_id_list_get_ctx(ptr));
 }
 
 
-
-void id_list::dump() const {
-  isl_id_list_dump(get());
-}
-
-
-
 // implementations for isl::id_to_ast_expr
 isl::id_to_ast_expr manage(__isl_take isl_id_to_ast_expr *ptr) {
   return id_to_ast_expr(ptr);
 }
 isl::id_to_ast_expr give(__isl_take isl_id_to_ast_expr *ptr) {
   return manage(ptr);
 }
 
id_to_ast_expr::operator bool() const {
   return !is_null();
 }
 
 isl::ctx id_to_ast_expr::get_ctx() const {
   return isl::ctx(isl_id_to_ast_expr_get_ctx(ptr));
 }
 
 
-
-void id_to_ast_expr::dump() const {
-  isl_id_to_ast_expr_dump(get());
-}
-
-
 isl::id_to_ast_expr id_to_ast_expr::alloc(isl::ctx ctx, int min_size) {
   auto res = isl_id_to_ast_expr_alloc(ctx.release(), min_size);
   return manage(res);
 }
 
 isl::id_to_ast_expr id_to_ast_expr::drop(isl::id key) const {
   auto res = isl_id_to_ast_expr_drop(copy(), key.release());
   return manage(res);
local_space::operator bool() const {
   return !is_null();
 }
 
 isl::ctx local_space::get_ctx() const {
   return isl::ctx(isl_local_space_get_ctx(ptr));
 }
 
 
-
-void local_space::dump() const {
-  isl_local_space_dump(get());
-}
-
-
 isl::local_space local_space::add_dims(isl::dim type, unsigned int n) const {
   auto res = isl_local_space_add_dims(copy(), static_cast<enum isl_dim_type>(type), n);
   return manage(res);
 }
 
 int local_space::dim(isl::dim type) const {
   auto res = isl_local_space_dim(get(), static_cast<enum isl_dim_type>(type));
   return res;
std::string map::to_str() const {
   if (!Tmp)
     return "";
   std::string S(Tmp);
   free(Tmp);
   return S;
 }
 
 
-void map::dump() const {
-  isl_map_dump(get());
-}
-
-
 isl::map map::add_constraint(isl::constraint constraint) const {
   auto res = isl_map_add_constraint(copy(), constraint.release());
   return manage(res);
 }
 
 isl::map map::add_dims(isl::dim type, unsigned int n) const {
   auto res = isl_map_add_dims(copy(), static_cast<enum isl_dim_type>(type), n);
   return manage(res);
map_list::operator bool() const {
   return !is_null();
 }
 
 isl::ctx map_list::get_ctx() const {
   return isl::ctx(isl_map_list_get_ctx(ptr));
 }
 
 
-
-void map_list::dump() const {
-  isl_map_list_dump(get());
-}
-
-
-
 // implementations for isl::multi_aff
 isl::multi_aff manage(__isl_take isl_multi_aff *ptr) {
   return multi_aff(ptr);
 }
 isl::multi_aff give(__isl_take isl_multi_aff *ptr) {
   return manage(ptr);
 }
 
std::string multi_aff::to_str() const {
   if (!Tmp)
     return "";
   std::string S(Tmp);
   free(Tmp);
   return S;
 }
 
 
-void multi_aff::dump() const {
-  isl_multi_aff_dump(get());
-}
-
-
 isl::multi_aff multi_aff::add(isl::multi_aff multi2) const {
   auto res = isl_multi_aff_add(copy(), multi2.release());
   return manage(res);
 }
 
 isl::multi_aff multi_aff::add_dims(isl::dim type, unsigned int n) const {
   auto res = isl_multi_aff_add_dims(copy(), static_cast<enum isl_dim_type>(type), n);
   return manage(res);
std::string multi_pw_aff::to_str() const {
   if (!Tmp)
     return "";
   std::string S(Tmp);
   free(Tmp);
   return S;
 }
 
 
-void multi_pw_aff::dump() const {
-  isl_multi_pw_aff_dump(get());
-}
-
-
 isl::multi_pw_aff multi_pw_aff::add(isl::multi_pw_aff multi2) const {
   auto res = isl_multi_pw_aff_add(copy(), multi2.release());
   return manage(res);
 }
 
 isl::multi_pw_aff multi_pw_aff::add_dims(isl::dim type, unsigned int n) const {
   auto res = isl_multi_pw_aff_add_dims(copy(), static_cast<enum isl_dim_type>(type), n);
   return manage(res);
std::string multi_union_pw_aff::to_str() const {
   if (!Tmp)
     return "";
   std::string S(Tmp);
   free(Tmp);
   return S;
 }
 
 
-void multi_union_pw_aff::dump() const {
-  isl_multi_union_pw_aff_dump(get());
-}
-
-
 isl::multi_union_pw_aff multi_union_pw_aff::add(isl::multi_union_pw_aff multi2) const {
   auto res = isl_multi_union_pw_aff_add(copy(), multi2.release());
   return manage(res);
 }
 
 isl::multi_union_pw_aff multi_union_pw_aff::align_params(isl::space model) const {
   auto res = isl_multi_union_pw_aff_align_params(copy(), model.release());
   return manage(res);
std::string multi_val::to_str() const {
   if (!Tmp)
     return "";
   std::string S(Tmp);
   free(Tmp);
   return S;
 }
 
 
-void multi_val::dump() const {
-  isl_multi_val_dump(get());
-}
-
-
 isl::multi_val multi_val::add(isl::multi_val multi2) const {
   auto res = isl_multi_val_add(copy(), multi2.release());
   return manage(res);
 }
 
 isl::multi_val multi_val::add_dims(isl::dim type, unsigned int n) const {
   auto res = isl_multi_val_add_dims(copy(), static_cast<enum isl_dim_type>(type), n);
   return manage(res);
std::string point::to_str() const {
   if (!Tmp)
     return "";
   std::string S(Tmp);
   free(Tmp);
   return S;
 }
 
 
-void point::dump() const {
-  isl_point_dump(get());
-}
-
-
 isl::point point::add_ui(isl::dim type, int pos, unsigned int val) const {
   auto res = isl_point_add_ui(copy(), static_cast<enum isl_dim_type>(type), pos, val);
   return manage(res);
 }
 
 isl::val point::get_coordinate_val(isl::dim type, int pos) const {
   auto res = isl_point_get_coordinate_val(get(), static_cast<enum isl_dim_type>(type), pos);
   return manage(res);
std::string pw_aff::to_str() const {
   if (!Tmp)
     return "";
   std::string S(Tmp);
   free(Tmp);
   return S;
 }
 
 
-void pw_aff::dump() const {
-  isl_pw_aff_dump(get());
-}
-
-
 isl::pw_aff pw_aff::add(isl::pw_aff pwaff2) const {
   auto res = isl_pw_aff_add(copy(), pwaff2.release());
   return manage(res);
 }
 
 isl::pw_aff pw_aff::add_dims(isl::dim type, unsigned int n) const {
   auto res = isl_pw_aff_add_dims(copy(), static_cast<enum isl_dim_type>(type), n);
   return manage(res);
pw_aff_list::operator bool() const {
   return !is_null();
 }
 
 isl::ctx pw_aff_list::get_ctx() const {
   return isl::ctx(isl_pw_aff_list_get_ctx(ptr));
 }
 
 
-
-void pw_aff_list::dump() const {
-  isl_pw_aff_list_dump(get());
-}
-
-
-
 // implementations for isl::pw_multi_aff
 isl::pw_multi_aff manage(__isl_take isl_pw_multi_aff *ptr) {
   return pw_multi_aff(ptr);
 }
 isl::pw_multi_aff give(__isl_take isl_pw_multi_aff *ptr) {
   return manage(ptr);
 }
 
std::string pw_multi_aff::to_str() const {
   if (!Tmp)
     return "";
   std::string S(Tmp);
   free(Tmp);
   return S;
 }
 
 
-void pw_multi_aff::dump() const {
-  isl_pw_multi_aff_dump(get());
-}
-
-
 isl::pw_multi_aff pw_multi_aff::add(isl::pw_multi_aff pma2) const {
   auto res = isl_pw_multi_aff_add(copy(), pma2.release());
   return manage(res);
 }
 
 isl::pw_multi_aff pw_multi_aff::align_params(isl::space model) const {
   auto res = isl_pw_multi_aff_align_params(copy(), model.release());
   return manage(res);
std::string pw_qpolynomial::to_str() const {
   if (!Tmp)
     return "";
   std::string S(Tmp);
   free(Tmp);
   return S;
 }
 
 
-void pw_qpolynomial::dump() const {
-  isl_pw_qpolynomial_dump(get());
-}
-
-
 isl::pw_qpolynomial pw_qpolynomial::add(isl::pw_qpolynomial pwqp2) const {
   auto res = isl_pw_qpolynomial_add(copy(), pwqp2.release());
   return manage(res);
 }
 
 isl::pw_qpolynomial pw_qpolynomial::add_dims(isl::dim type, unsigned int n) const {
   auto res = isl_pw_qpolynomial_add_dims(copy(), static_cast<enum isl_dim_type>(type), n);
   return manage(res);
qpolynomial::operator bool() const {
   return !is_null();
 }
 
 isl::ctx qpolynomial::get_ctx() const {
   return isl::ctx(isl_qpolynomial_get_ctx(ptr));
 }
 
 
-
-void qpolynomial::dump() const {
-  isl_qpolynomial_dump(get());
-}
-
-
 isl::qpolynomial qpolynomial::add(isl::qpolynomial qp2) const {
   auto res = isl_qpolynomial_add(copy(), qp2.release());
   return manage(res);
 }
 
 isl::qpolynomial qpolynomial::add_dims(isl::dim type, unsigned int n) const {
   auto res = isl_qpolynomial_add_dims(copy(), static_cast<enum isl_dim_type>(type), n);
   return manage(res);
std::string schedule::to_str() const {
   if (!Tmp)
     return "";
   std::string S(Tmp);
   free(Tmp);
   return S;
 }
 
 
-void schedule::dump() const {
-  isl_schedule_dump(get());
-}
-
-
 isl::schedule schedule::align_params(isl::space space) const {
   auto res = isl_schedule_align_params(copy(), space.release());
   return manage(res);
 }
 
 isl::schedule schedule::empty(isl::space space) {
   auto res = isl_schedule_empty(space.release());
   return manage(res);
std::string schedule_constraints::to_str() const {
   if (!Tmp)
     return "";
   std::string S(Tmp);
   free(Tmp);
   return S;
 }
 
 
-void schedule_constraints::dump() const {
-  isl_schedule_constraints_dump(get());
-}
-
-
 isl::schedule_constraints schedule_constraints::apply(isl::union_map umap) const {
   auto res = isl_schedule_constraints_apply(copy(), umap.release());
   return manage(res);
 }
 
 isl::schedule schedule_constraints::compute_schedule() const {
   auto res = isl_schedule_constraints_compute_schedule(copy());
   return manage(res);
std::string schedule_node::to_str() const {
   if (!Tmp)
     return "";
   std::string S(Tmp);
   free(Tmp);
   return S;
 }
 
 
-void schedule_node::dump() const {
-  isl_schedule_node_dump(get());
-}
-
-
 isl::schedule_node schedule_node::align_params(isl::space space) const {
   auto res = isl_schedule_node_align_params(copy(), space.release());
   return manage(res);
 }
 
 isl::schedule_node schedule_node::ancestor(int generation) const {
   auto res = isl_schedule_node_ancestor(copy(), generation);
   return manage(res);
std::string set::to_str() const {
   if (!Tmp)
     return "";
   std::string S(Tmp);
   free(Tmp);
   return S;
 }
 
 
-void set::dump() const {
-  isl_set_dump(get());
-}
-
-
 isl::set set::add_constraint(isl::constraint constraint) const {
   auto res = isl_set_add_constraint(copy(), constraint.release());
   return manage(res);
 }
 
 isl::set set::add_dims(isl::dim type, unsigned int n) const {
   auto res = isl_set_add_dims(copy(), static_cast<enum isl_dim_type>(type), n);
   return manage(res);
set_list::operator bool() const {
   return !is_null();
 }
 
 isl::ctx set_list::get_ctx() const {
   return isl::ctx(isl_set_list_get_ctx(ptr));
 }
 
 
-
-void set_list::dump() const {
-  isl_set_list_dump(get());
-}
-
-
-
 // implementations for isl::space
 isl::space manage(__isl_take isl_space *ptr) {
   return space(ptr);
 }
 isl::space give(__isl_take isl_space *ptr) {
   return manage(ptr);
 }
 
std::string space::to_str() const {
   if (!Tmp)
     return "";
   std::string S(Tmp);
   free(Tmp);
   return S;
 }
 
 
-void space::dump() const {
-  isl_space_dump(get());
-}
-
-
 isl::space space::add_dims(isl::dim type, unsigned int n) const {
   auto res = isl_space_add_dims(copy(), static_cast<enum isl_dim_type>(type), n);
   return manage(res);
 }
 
 isl::space space::align_params(isl::space dim2) const {
   auto res = isl_space_align_params(copy(), dim2.release());
   return manage(res);
std::string union_map::to_str() const {
   if (!Tmp)
     return "";
   std::string S(Tmp);
   free(Tmp);
   return S;
 }
 
 
-void union_map::dump() const {
-  isl_union_map_dump(get());
-}
-
-
 isl::union_map union_map::add_map(isl::map map) const {
   auto res = isl_union_map_add_map(copy(), map.release());
   return manage(res);
 }
 
 isl::union_map union_map::affine_hull() const {
   auto res = isl_union_map_affine_hull(copy());
   return manage(res);
union_map_list::operator bool() const {
   return !is_null();
 }
 
 isl::ctx union_map_list::get_ctx() const {
   return isl::ctx(isl_union_map_list_get_ctx(ptr));
 }
 
 
-
-void union_map_list::dump() const {
-  isl_union_map_list_dump(get());
-}
-
-
-
 // implementations for isl::union_pw_aff
 isl::union_pw_aff manage(__isl_take isl_union_pw_aff *ptr) {
   return union_pw_aff(ptr);
 }
 isl::union_pw_aff give(__isl_take isl_union_pw_aff *ptr) {
   return manage(ptr);
 }
 
std::string union_pw_aff::to_str() const {
   if (!Tmp)
     return "";
   std::string S(Tmp);
   free(Tmp);
   return S;
 }
 
 
-void union_pw_aff::dump() const {
-  isl_union_pw_aff_dump(get());
-}
-
-
 isl::union_pw_aff union_pw_aff::add(isl::union_pw_aff upa2) const {
   auto res = isl_union_pw_aff_add(copy(), upa2.release());
   return manage(res);
 }
 
 isl::union_pw_aff union_pw_aff::add_pw_aff(isl::pw_aff pa) const {
   auto res = isl_union_pw_aff_add_pw_aff(copy(), pa.release());
   return manage(res);
union_pw_aff_list::operator bool() const {
   return !is_null();
 }
 
 isl::ctx union_pw_aff_list::get_ctx() const {
   return isl::ctx(isl_union_pw_aff_list_get_ctx(ptr));
 }
 
 
-
-void union_pw_aff_list::dump() const {
-  isl_union_pw_aff_list_dump(get());
-}
-
-
-
 // implementations for isl::union_pw_multi_aff
 isl::union_pw_multi_aff manage(__isl_take isl_union_pw_multi_aff *ptr) {
   return union_pw_multi_aff(ptr);
 }
 isl::union_pw_multi_aff give(__isl_take isl_union_pw_multi_aff *ptr) {
   return manage(ptr);
 }
 
std::string union_pw_multi_aff::to_str() const {
   if (!Tmp)
     return "";
   std::string S(Tmp);
   free(Tmp);
   return S;
 }
 
 
-void union_pw_multi_aff::dump() const {
-  isl_union_pw_multi_aff_dump(get());
-}
-
-
 isl::union_pw_multi_aff union_pw_multi_aff::add(isl::union_pw_multi_aff upma2) const {
   auto res = isl_union_pw_multi_aff_add(copy(), upma2.release());
   return manage(res);
 }
 
 isl::union_pw_multi_aff union_pw_multi_aff::add_pw_multi_aff(isl::pw_multi_aff pma) const {
   auto res = isl_union_pw_multi_aff_add_pw_multi_aff(copy(), pma.release());
   return manage(res);
union_pw_multi_aff_list::operator bool() const {
   return !is_null();
 }
 
 isl::ctx union_pw_multi_aff_list::get_ctx() const {
   return isl::ctx(isl_union_pw_multi_aff_list_get_ctx(ptr));
 }
 
 
-
-void union_pw_multi_aff_list::dump() const {
-  isl_union_pw_multi_aff_list_dump(get());
-}
-
-
-
 // implementations for isl::union_pw_qpolynomial
 isl::union_pw_qpolynomial manage(__isl_take isl_union_pw_qpolynomial *ptr) {
   return union_pw_qpolynomial(ptr);
 }
 isl::union_pw_qpolynomial give(__isl_take isl_union_pw_qpolynomial *ptr) {
   return manage(ptr);
 }
 
std::string union_set::to_str() const {
   if (!Tmp)
     return "";
   std::string S(Tmp);
   free(Tmp);
   return S;
 }
 
 
-void union_set::dump() const {
-  isl_union_set_dump(get());
-}
-
-
 isl::union_set union_set::add_set(isl::set set) const {
   auto res = isl_union_set_add_set(copy(), set.release());
   return manage(res);
 }
 
 isl::union_set union_set::affine_hull() const {
   auto res = isl_union_set_affine_hull(copy());
   return manage(res);
union_set_list::operator bool() const {
   return !is_null();
 }
 
 isl::ctx union_set_list::get_ctx() const {
   return isl::ctx(isl_union_set_list_get_ctx(ptr));
 }
 
 
-
-void union_set_list::dump() const {
-  isl_union_set_list_dump(get());
-}
-
-
-
 // implementations for isl::val
 isl::val manage(__isl_take isl_val *ptr) {
   return val(ptr);
 }
 isl::val give(__isl_take isl_val *ptr) {
   return manage(ptr);
 }
 
std::string val::to_str() const {
   if (!Tmp)
     return "";
   std::string S(Tmp);
   free(Tmp);
   return S;
 }
 
 
-void val::dump() const {
-  isl_val_dump(get());
-}
-
-
 isl::val val::two_exp() const {
   auto res = isl_val_2exp(copy());
   return manage(res);
 }
 
 isl::val val::abs() const {
   auto res = isl_val_abs(copy());
   return manage(res);
val_list::operator bool() const {
   return !is_null();
 }
 
 isl::ctx val_list::get_ctx() const {
   return isl::ctx(isl_val_list_get_ctx(ptr));
 }
 
 
-
-void val_list::dump() const {
-  isl_val_list_dump(get());
-}
-
-
 } // namespace noexceptions
 } // namespace isl
 
 #endif /* ISL_CPP_NOEXCEPTIONS */

lib/External/isl/isl-noexceptions.cpp

+#include <isl/isl-noexceptions.h>
+
+void isl::aff::dump() const {
+  isl_aff_dump(get());
+}
+
+void isl::aff_list::dump() const {
+  isl_aff_list_dump(get());
+}
+
+void isl::ast_expr::dump() const {
+  isl_ast_expr_dump(get());
+}
+
+void isl::ast_expr_list::dump() const {
+  isl_ast_expr_list_dump(get());
+}
+
+void isl::ast_node::dump() const {
+  isl_ast_node_dump(get());
+}
+
+void isl::ast_node_list::dump() const {
+  isl_ast_node_list_dump(get());
+}
+
+void isl::band_list::dump() const {
+  isl_band_list_dump(get());
+}
+
+void isl::basic_map::dump() const {
+  isl_basic_map_dump(get());
+}
+
+void isl::basic_map_list::dump() const {
+  isl_basic_map_list_dump(get());
+}
+
+void isl::basic_set::dump() const {
+  isl_basic_set_dump(get());
+}
+
+void isl::basic_set_list::dump() const {
+  isl_basic_set_list_dump(get());
+}
+
+void isl::constraint::dump() const {
+  isl_constraint_dump(get());
+}
+
+void isl::constraint_list::dump() const {
+  isl_constraint_list_dump(get());
+}
+
+void isl::id::dump() const {
+  isl_id_dump(get());
+}
+
+void isl::id_list::dump() const {
+  isl_id_list_dump(get());
+}
+
+void isl::id_to_ast_expr::dump() const {
+  isl_id_to_ast_expr_dump(get());
+}
+
+void isl::local_space::dump() const {
+  isl_local_space_dump(get());
+}
+
+void isl::map::dump() const {
+  isl_map_dump(get());
+}
+
+void isl::map_list::dump() const {
+  isl_map_list_dump(get());
+}
+
+void isl::multi_aff::dump() const {
+  isl_multi_aff_dump(get());
+}
+
+void isl::multi_pw_aff::dump() const {
+  isl_multi_pw_aff_dump(get());
+}
+
+void isl::multi_union_pw_aff::dump() const {
+  isl_multi_union_pw_aff_dump(get());
+}
+
+void isl::multi_val::dump() const {
+  isl_multi_val_dump(get());
+}
+
+void isl::point::dump() const {
+  isl_point_dump(get());
+}
+
+void isl::pw_aff::dump() const {
+  isl_pw_aff_dump(get());
+}
+
+void isl::pw_aff_list::dump() const {
+  isl_pw_aff_list_dump(get());
+}
+
+void isl::pw_multi_aff::dump() const {
+  isl_pw_multi_aff_dump(get());
+}
+
+void isl::pw_qpolynomial::dump() const {
+  isl_pw_qpolynomial_dump(get());
+}
+
+void isl::qpolynomial::dump() const {
+  isl_qpolynomial_dump(get());
+}
+
+void isl::schedule::dump() const {
+  isl_schedule_dump(get());
+}
+
+void isl::schedule_constraints::dump() const {
+  isl_schedule_constraints_dump(get());
+}
+
+void isl::schedule_node::dump() const {
+  isl_schedule_node_dump(get());
+}
+
+void isl::set::dump() const {
+  isl_set_dump(get());
+}
+
+void isl::set_list::dump() const {
+  isl_set_list_dump(get());
+}
+
+void isl::space::dump() const {
+  isl_space_dump(get());
+}
+
+void isl::union_map::dump() const {
+  isl_union_map_dump(get());
+}
+
+void isl::union_map_list::dump() const {
+  isl_union_map_list_dump(get());
+}
+
+void isl::union_pw_aff::dump() const {
+  isl_union_pw_aff_dump(get());
+}
+
+void isl::union_pw_aff_list::dump() const {
+  isl_union_pw_aff_list_dump(get());
+}
+
+void isl::union_pw_multi_aff::dump() const {
+  isl_union_pw_multi_aff_dump(get());
+}
+
+void isl::union_pw_multi_aff_list::dump() const {
+  isl_union_pw_multi_aff_list_dump(get());
+}
+
+void isl::union_set::dump() const {
+  isl_union_set_dump(get());
+}
+
+void isl::union_set_list::dump() const {
+  isl_union_set_list_dump(get());
+}
+
+void isl::val::dump() const {
+  isl_val_dump(get());
+}
+
+void isl::val_list::dump() const {
+  isl_val_list_dump(get());
+}
+