[Polly][Isl] Replacing isl method `to_str()` with `stringFromIslObj()`. NFC.

[patacca]

Summary

This is part of an effort to reduce the differences between the custom C++ bindings used right now by polly in lib/External/isl/include/isl/isl-noxceptions.h and the official isl C++ interface.

Changes made:

• Removing method to_str() from all the classes in the isl C++ bindings.
• Overload method stringFromIslObj() so it accepts isl C++ objects.
• To keep backward compatibility stringFromIslObj() now accepts a value that is returned if the isl C object is null or doesn't have a string representation (by default it's an empty string). In some cases it's better to have the string "null" instead of an empty string.
• isl-noexceptions.h has been generated by this https://github.com/patacca/isl/commit/d33ec3a3bbaf971b254a853e6d8200ff9f5a1385

[Meinersbur]

LGTM with one nitpick.

If the forward-declaration is indeed needed for some reason I did not see, commit with it.

polly/include/polly/Support/GICHelper.h

154–159

Why forward declaring something that is defined on the next line?

polly/lib/Analysis/ScopInfo.cpp

1239–1244

That was one way to make things complicated ;-)

[patacca]

Removing useless function declaration.

[patacca]

Rebase to main

polly/include/polly/Support/GICHelper.h

 ///
 /// @return The APInt value corresponding to @p Val.
 inline llvm::APInt APIntFromVal(isl::val V) {
   return APIntFromVal(V.release());
 }
 
 /// Get c++ string from Isl objects.
 //@{
-std::string stringFromIslObj(__isl_keep isl_map *map);
-std::string stringFromIslObj(__isl_keep isl_union_map *umap);
-std::string stringFromIslObj(__isl_keep isl_set *set);
-std::string stringFromIslObj(__isl_keep isl_union_set *uset);
-std::string stringFromIslObj(__isl_keep isl_schedule *schedule);
-std::string stringFromIslObj(__isl_keep isl_multi_aff *maff);
-std::string stringFromIslObj(__isl_keep isl_pw_multi_aff *pma);
-std::string stringFromIslObj(__isl_keep isl_multi_pw_aff *mpa);
-std::string stringFromIslObj(__isl_keep isl_union_pw_multi_aff *upma);
-std::string stringFromIslObj(__isl_keep isl_aff *aff);
-std::string stringFromIslObj(__isl_keep isl_pw_aff *pwaff);
-std::string stringFromIslObj(__isl_keep isl_space *space);
+#define ISL_CPP_OBJECT_TO_STRING(name)                                         \
+  inline std::string stringFromIslObj(const name &Obj,                         \
+                                      std::string DefaultValue = "") {         \
+    return stringFromIslObj(Obj.get(), DefaultValue);                          \
+  }
+
+#define ISL_OBJECT_TO_STRING(name)                                             \
+  std::string stringFromIslObj(__isl_keep isl_##name *Obj,                     \
+                               std::string DefaultValue = "");                 \
+  ISL_CPP_OBJECT_TO_STRING(isl::name)
+
+ISL_OBJECT_TO_STRING(aff)
+ISL_OBJECT_TO_STRING(ast_expr)
+ISL_OBJECT_TO_STRING(ast_node)
+ISL_OBJECT_TO_STRING(basic_map)
+ISL_OBJECT_TO_STRING(basic_set)
+ISL_OBJECT_TO_STRING(map)
+ISL_OBJECT_TO_STRING(set)
+ISL_OBJECT_TO_STRING(id)
+ISL_OBJECT_TO_STRING(multi_aff)
+ISL_OBJECT_TO_STRING(multi_pw_aff)
+ISL_OBJECT_TO_STRING(multi_union_pw_aff)
+ISL_OBJECT_TO_STRING(point)
+ISL_OBJECT_TO_STRING(pw_aff)
+ISL_OBJECT_TO_STRING(pw_multi_aff)
+ISL_OBJECT_TO_STRING(schedule)
+ISL_OBJECT_TO_STRING(schedule_node)
+ISL_OBJECT_TO_STRING(space)
+ISL_OBJECT_TO_STRING(union_access_info)
+ISL_OBJECT_TO_STRING(union_flow)
+ISL_OBJECT_TO_STRING(union_set)
+ISL_OBJECT_TO_STRING(union_map)
+ISL_OBJECT_TO_STRING(union_pw_aff)
+ISL_OBJECT_TO_STRING(union_pw_multi_aff)
 //@}
 
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                                      __isl_keep isl_union_map *Map) {
-  OS << polly::stringFromIslObj(Map);
+  OS << polly::stringFromIslObj(Map, "null");
   return OS;
 }
 
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                                      __isl_keep isl_map *Map) {
-  OS << polly::stringFromIslObj(Map);
+  OS << polly::stringFromIslObj(Map, "null");
   return OS;
 }
 
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                                      __isl_keep isl_set *Set) {
-  OS << polly::stringFromIslObj(Set);
+  OS << polly::stringFromIslObj(Set, "null");
   return OS;
 }
 
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                                      __isl_keep isl_pw_aff *Map) {
-  OS << polly::stringFromIslObj(Map);
+  OS << polly::stringFromIslObj(Map, "null");
   return OS;
 }
 
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                                      __isl_keep isl_pw_multi_aff *PMA) {
-  OS << polly::stringFromIslObj(PMA);
+  OS << polly::stringFromIslObj(PMA, "null");
   return OS;
 }
 
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                                      __isl_keep isl_multi_aff *MA) {
-  OS << polly::stringFromIslObj(MA);
+  OS << polly::stringFromIslObj(MA, "null");
   return OS;
 }
 
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                                      __isl_keep isl_union_pw_multi_aff *UPMA) {
-  OS << polly::stringFromIslObj(UPMA);
+  OS << polly::stringFromIslObj(UPMA, "null");
   return OS;
 }
 
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                                      __isl_keep isl_schedule *Schedule) {
-  OS << polly::stringFromIslObj(Schedule);
+  OS << polly::stringFromIslObj(Schedule, "null");
   return OS;
 }
 
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                                      __isl_keep isl_space *Space) {
-  OS << polly::stringFromIslObj(Space);
+  OS << polly::stringFromIslObj(Space, "null");
   return OS;
 }
 
 /// Combine Prefix, Val (or Number) and Suffix to an isl-compatible name.
 ///
 /// In case @p UseInstructionNames is set, this function returns:
 ///
 /// @p Prefix + "_" + @p Val->getName() + @p Suffix

 
 std::string getIslCompatibleName(const std::string &Prefix,
                                  const std::string &Middle,
                                  const std::string &Suffix);
 
 inline llvm::DiagnosticInfoOptimizationBase &
 operator<<(llvm::DiagnosticInfoOptimizationBase &OS,
            const isl::union_map &Obj) {
-  OS << Obj.to_str();
+  OS << stringFromIslObj(Obj);
   return OS;
 }
 
 /// Scope guard for code that allows arbitrary isl function to return an error
 /// if the max-operations quota exceeds.
 ///
 /// This allows to opt-in code sections that have known long executions times.
 /// code not in a hot path can continue to assume that no unexpected error

polly/include/polly/Support/ISLOStream.h

 //===------ IslOstream.h ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // raw_ostream printers for isl C++ objects.
 //
 //===----------------------------------------------------------------------===//
 
+#include "polly/Support/GICHelper.h"
 #include "llvm/Support/raw_ostream.h"
 #include "isl/isl-noexceptions.h"
 namespace polly {
 
 #define ADD_OSTREAM_PRINTER(name)                                              \
   inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,                  \
                                        const name &Obj) {                      \
-    OS << Obj.to_str();                                                        \
+    OS << stringFromIslObj(Obj);                                               \
     return OS;                                                                 \
   }
 
 ADD_OSTREAM_PRINTER(isl::aff)
 ADD_OSTREAM_PRINTER(isl::ast_expr)
 ADD_OSTREAM_PRINTER(isl::ast_node)
 ADD_OSTREAM_PRINTER(isl::basic_map)
 ADD_OSTREAM_PRINTER(isl::basic_set)

polly/lib/Analysis/PolyhedralInfo.cpp

if (!D.hasValidDependences())
     return false;
   LLVM_DEBUG(dbgs() << "Loop :\t" << L->getHeader()->getName() << ":\n");
 
   isl_union_map *Deps =
       D.getDependences(Dependences::TYPE_RAW | Dependences::TYPE_WAW |
                        Dependences::TYPE_WAR | Dependences::TYPE_RED)
           .release();
 
-  LLVM_DEBUG(dbgs() << "Dependences :\t" << stringFromIslObj(Deps) << "\n");
+  LLVM_DEBUG(dbgs() << "Dependences :\t" << stringFromIslObj(Deps, "null")
+                    << "\n");
 
   isl_union_map *Schedule = getScheduleForLoop(S, L);
-  LLVM_DEBUG(dbgs() << "Schedule: \t" << stringFromIslObj(Schedule) << "\n");
+  LLVM_DEBUG(dbgs() << "Schedule: \t" << stringFromIslObj(Schedule, "null")
+                    << "\n");
 
   IsParallel = D.isParallel(Schedule, Deps, MinDepDistPtr);
   isl_union_map_free(Schedule);
   return IsParallel;
 }
 
 bool PolyhedralInfo::isParallel(Loop *L) const { return checkParallel(L); }
 

polly/lib/Analysis/ScopBuilder.cpp

if (!NewParams.empty()) {
         if (!NewParams.count(Param))
           continue;
 
         AssumptionCtx =
             isl_set_project_out(AssumptionCtx, isl_dim_param, u--, 1);
       }
     }
     ORE.emit(OptimizationRemarkAnalysis(DEBUG_TYPE, "UserAssumption", CI)
-             << "Use user assumption: " << stringFromIslObj(AssumptionCtx));
+             << "Use user assumption: "
+             << stringFromIslObj(AssumptionCtx, "null"));
     isl::set newContext =
         scop->getContext().intersect(isl::manage(AssumptionCtx));
     scop->setContext(newContext);
   }
 }
 
 bool ScopBuilder::buildAccessMultiDimFixed(MemAccInst Inst, ScopStmt *Stmt) {
   Value *Val = Inst.getValueOperand();

 
 void ScopBuilder::addUserContext() {
   if (UserContextStr.empty())
     return;
 
   isl::set UserContext = isl::set(scop->getIslCtx(), UserContextStr.c_str());
   isl::space Space = scop->getParamSpace();
   if (Space.dim(isl::dim::param) != UserContext.dim(isl::dim::param)) {
-    std::string SpaceStr = Space.to_str();
+    std::string SpaceStr = stringFromIslObj(Space, "null");
     errs() << "Error: the context provided in -polly-context has not the same "
            << "number of dimensions than the computed context. Due to this "
            << "mismatch, the -polly-context option is ignored. Please provide "
            << "the context in the parameter space: " << SpaceStr << ".\n";
     return;
   }
 
   for (auto i : seq<isl_size>(0, Space.dim(isl::dim::param))) {
     std::string NameContext =
         scop->getContext().get_dim_name(isl::dim::param, i);
     std::string NameUserContext = UserContext.get_dim_name(isl::dim::param, i);
 
     if (NameContext != NameUserContext) {
-      std::string SpaceStr = Space.to_str();
+      std::string SpaceStr = stringFromIslObj(Space, "null");
       errs() << "Error: the name of dimension " << i
              << " provided in -polly-context "
              << "is '" << NameUserContext << "', but the name in the computed "
              << "context is '" << NameContext
              << "'. Due to this name mismatch, "
              << "the -polly-context option is ignored. Please provide "
              << "the context in the parameter space: " << SpaceStr << ".\n";
       return;

polly/lib/Analysis/ScopInfo.cpp

MemoryAccess::applyScheduleToAccessRelation(isl::union_map USchedule) const {
   return isl::pw_multi_aff::from_map(ScheduledAccRel);
 }
 
 isl::map MemoryAccess::getOriginalAccessRelation() const {
   return AccessRelation;
 }
 
 std::string MemoryAccess::getOriginalAccessRelationStr() const {
-  return AccessRelation.to_str();
+  return stringFromIslObj(AccessRelation);
 }
 
 isl::space MemoryAccess::getOriginalAccessRelationSpace() const {
   return AccessRelation.get_space();
 }
 
 isl::map MemoryAccess::getNewAccessRelation() const {
   return NewAccessRelation;
 }
 
 std::string MemoryAccess::getNewAccessRelationStr() const {
-  return NewAccessRelation.to_str();
+  return stringFromIslObj(NewAccessRelation);
 }
 
 std::string MemoryAccess::getAccessRelationStr() const {
-  return getAccessRelation().to_str();
+  return stringFromIslObj(getAccessRelation());
 }
 
 isl::basic_map MemoryAccess::createBasicAccessMap(ScopStmt *Statement) {
   isl::space Space = isl::space(Statement->getIslCtx(), 0, 1);
   Space = Space.align_params(Statement->getDomainSpace());
 
   return isl::basic_map::from_domain_and_range(
       isl::basic_set::universe(Statement->getDomainSpace()),
ScopStmt::ScopStmt(Scop &parent, isl::map SourceRel, isl::map TargetRel,
   SourceRel = SourceRel.set_tuple_id(isl::dim::in, Id);
   Access = new MemoryAccess(this, MemoryAccess::AccessType::READ, SourceRel);
   parent.addAccessFunction(Access);
   addAccess(Access);
 }
 
 ScopStmt::~ScopStmt() = default;
 
-std::string ScopStmt::getDomainStr() const { return Domain.to_str(); }
+std::string ScopStmt::getDomainStr() const { return stringFromIslObj(Domain); }
 
 std::string ScopStmt::getScheduleStr() const {
-  auto *S = getSchedule().release();
-  if (!S)
-    return {};
-  auto Str = stringFromIslObj(S);
-  isl_map_free(S);
-  return Str;
+  return stringFromIslObj(getSchedule());
 }
 
 void ScopStmt::setInvalidDomain(isl::set ID) { InvalidDomain = ID; }
 
 BasicBlock *ScopStmt::getEntryBlock() const {
   if (isBlockStmt())
     return getBasicBlock();
   return getRegion()->getEntry();

 }
 
 ScopArrayInfo *Scop::getScopArrayInfo(Value *BasePtr, MemoryKind Kind) {
   auto *SAI = getScopArrayInfoOrNull(BasePtr, Kind);
   assert(SAI && "No ScopArrayInfo available for this base pointer");
   return SAI;
 }
 
-std::string Scop::getContextStr() const { return getContext().to_str(); }
+std::string Scop::getContextStr() const {
+  return stringFromIslObj(getContext());
+}
 
 std::string Scop::getAssumedContextStr() const {
   assert(!AssumedContext.is_null() && "Assumed context not yet built");
-  return AssumedContext.to_str();
+  return stringFromIslObj(AssumedContext);
 }
 
 std::string Scop::getInvalidContextStr() const {
-  return InvalidContext.to_str();
+  return stringFromIslObj(InvalidContext);
 }
 
 std::string Scop::getNameStr() const {
   std::string ExitName, EntryName;
   std::tie(EntryName, ExitName) = getEntryExitStr();
   return EntryName + "---" + ExitName;
 }
 
case INVARIANTLOAD:
     AssumptionsInvariantLoad++;
     break;
   case DELINEARIZATION:
     AssumptionsDelinearization++;
     break;
   }
 
   auto Suffix = Sign == AS_ASSUMPTION ? " assumption:\t" : " restriction:\t";
-  std::string Msg = toString(Kind) + Suffix + Set.to_str();
+  std::string Msg = toString(Kind) + Suffix + stringFromIslObj(Set);
   if (BB)
     ORE.emit(OptimizationRemarkAnalysis(DEBUG_TYPE, "AssumpRestrict", Loc, BB)
              << Msg);
   else
     ORE.emit(OptimizationRemarkAnalysis(DEBUG_TYPE, "AssumpRestrict", Loc,
                                         R.getEntry())
              << Msg);
   return true;

polly/lib/CodeGen/IslAst.cpp

void IslAstInfo::print(raw_ostream &OS) {
   P = isl_printer_set_output_format(P, ISL_FORMAT_C);
   P = isl_printer_print_ast_expr(P, RunCondition.get());
   RtCStr = isl_printer_get_str(P);
   P = isl_printer_flush(P);
   P = isl_printer_indent(P, 4);
   P = isl_ast_node_print(RootNode.get(), P, Options);
   AstStr = isl_printer_get_str(P);
 
-  auto *Schedule = S.getScheduleTree().release();
-
   LLVM_DEBUG({
     dbgs() << S.getContextStr() << "\n";
-    dbgs() << stringFromIslObj(Schedule);
+    dbgs() << stringFromIslObj(S.getScheduleTree(), "null");
   });
   OS << "\nif (" << RtCStr << ")\n\n";
   OS << AstStr << "\n";
   OS << "else\n";
   OS << "    {  /* original code */ }\n\n";
 
   free(RtCStr);
   free(AstStr);
 
-  isl_schedule_free(Schedule);
   isl_printer_free(P);
 }
 
 AnalysisKey IslAstAnalysis::Key;
 PreservedAnalyses IslAstPrinterPass::run(Scop &S, ScopAnalysisManager &SAM,
                                          ScopStandardAnalysisResults &SAR,
                                          SPMUpdater &U) {
   auto &Ast = SAM.getResult<IslAstAnalysis>(S, SAR);

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

public:
   inline aff &operator=(aff obj);
   inline ~aff();
   inline __isl_give isl_aff *copy() const &;
   inline __isl_give isl_aff *copy() && = delete;
   inline __isl_keep isl_aff *get() const;
   inline __isl_give isl_aff *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline aff add(aff aff2) const;
   inline aff add_coefficient_si(isl::dim type, int pos, int v) const;
   inline aff add_coefficient_val(isl::dim type, int pos, val v) const;
   inline aff add_constant(val v) const;
   inline aff add_constant_num_si(int v) const;
   inline aff add_constant_si(int v) const;
public:
   inline aff_list &operator=(aff_list obj);
   inline ~aff_list();
   inline __isl_give isl_aff_list *copy() const &;
   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 ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline aff_list add(aff el) const;
   static inline aff_list alloc(ctx ctx, int n);
   inline aff_list clear() const;
   inline aff_list concat(aff_list list2) const;
   inline aff_list drop(unsigned int first, unsigned int n) const;
   inline stat foreach(const std::function<stat(aff)> &fn) const;
public:
   inline ast_expr &operator=(ast_expr obj);
   inline ~ast_expr();
   inline __isl_give isl_ast_expr *copy() const &;
   inline __isl_give isl_ast_expr *copy() && = delete;
   inline __isl_keep isl_ast_expr *get() const;
   inline __isl_give isl_ast_expr *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline ast_expr access(ast_expr_list indices) const;
   inline ast_expr add(ast_expr expr2) const;
   inline ast_expr address_of() const;
   inline ast_expr call(ast_expr_list arguments) const;
   inline ast_expr div(ast_expr expr2) const;
   inline ast_expr eq(ast_expr expr2) const;
public:
   inline ast_expr_list &operator=(ast_expr_list obj);
   inline ~ast_expr_list();
   inline __isl_give isl_ast_expr_list *copy() const &;
   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 ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline ast_expr_list add(ast_expr el) const;
   static inline ast_expr_list alloc(ctx ctx, int n);
   inline ast_expr_list clear() const;
   inline ast_expr_list concat(ast_expr_list list2) const;
   inline ast_expr_list drop(unsigned int first, unsigned int n) const;
   inline stat foreach(const std::function<stat(ast_expr)> &fn) const;
public:
   inline ast_node &operator=(ast_node obj);
   inline ~ast_node();
   inline __isl_give isl_ast_node *copy() const &;
   inline __isl_give isl_ast_node *copy() && = delete;
   inline __isl_keep isl_ast_node *get() const;
   inline __isl_give isl_ast_node *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   static inline ast_node alloc_user(ast_expr expr);
   inline ast_node_list block_get_children() const;
   inline ast_node for_get_body() const;
   inline ast_expr for_get_cond() const;
   inline ast_expr for_get_inc() const;
   inline ast_expr for_get_init() const;
public:
   inline ast_node_list &operator=(ast_node_list obj);
   inline ~ast_node_list();
   inline __isl_give isl_ast_node_list *copy() const &;
   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 ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline ast_node_list add(ast_node el) const;
   static inline ast_node_list alloc(ctx ctx, int n);
   inline ast_node_list clear() const;
   inline ast_node_list concat(ast_node_list list2) const;
   inline ast_node_list drop(unsigned int first, unsigned int n) const;
   inline stat foreach(const std::function<stat(ast_node)> &fn) const;
public:
   inline basic_map &operator=(basic_map obj);
   inline ~basic_map();
   inline __isl_give isl_basic_map *copy() const &;
   inline __isl_give isl_basic_map *copy() && = delete;
   inline __isl_keep isl_basic_map *get() const;
   inline __isl_give isl_basic_map *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline basic_map add_constraint(constraint constraint) const;
   inline basic_map add_dims(isl::dim type, unsigned int n) const;
   inline basic_map affine_hull() const;
   inline basic_map align_params(space model) const;
   inline basic_map apply_domain(basic_map bmap2) const;
   inline basic_map apply_range(basic_map bmap2) const;
public:
   inline basic_map_list &operator=(basic_map_list obj);
   inline ~basic_map_list();
   inline __isl_give isl_basic_map_list *copy() const &;
   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 ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline basic_map_list add(basic_map el) const;
   static inline basic_map_list alloc(ctx ctx, int n);
   inline basic_map_list clear() const;
   inline basic_map_list concat(basic_map_list list2) const;
   inline basic_map_list drop(unsigned int first, unsigned int n) const;
   inline stat foreach(const std::function<stat(basic_map)> &fn) const;
public:
   inline basic_set &operator=(basic_set obj);
   inline ~basic_set();
   inline __isl_give isl_basic_set *copy() const &;
   inline __isl_give isl_basic_set *copy() && = delete;
   inline __isl_keep isl_basic_set *get() const;
   inline __isl_give isl_basic_set *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline basic_set affine_hull() const;
   inline basic_set align_params(space model) const;
   inline basic_set apply(basic_map bmap) const;
   static inline basic_set box_from_points(point pnt1, point pnt2);
   inline basic_set coefficients() const;
   inline basic_set detect_equalities() const;
public:
   inline basic_set_list &operator=(basic_set_list obj);
   inline ~basic_set_list();
   inline __isl_give isl_basic_set_list *copy() const &;
   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 ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline basic_set_list add(basic_set el) const;
   static inline basic_set_list alloc(ctx ctx, int n);
   inline basic_set_list clear() const;
   inline basic_set_list coefficients() const;
   inline basic_set_list concat(basic_set_list list2) const;
   inline basic_set_list drop(unsigned int first, unsigned int n) const;
public:
   inline constraint_list &operator=(constraint_list obj);
   inline ~constraint_list();
   inline __isl_give isl_constraint_list *copy() const &;
   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 ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline constraint_list add(constraint el) const;
   static inline constraint_list alloc(ctx ctx, int n);
   inline constraint_list clear() const;
   inline constraint_list concat(constraint_list list2) const;
   inline constraint_list drop(unsigned int first, unsigned int n) const;
   inline stat foreach(const std::function<stat(constraint)> &fn) const;
public:
   inline fixed_box &operator=(fixed_box obj);
   inline ~fixed_box();
   inline __isl_give isl_fixed_box *copy() const &;
   inline __isl_give isl_fixed_box *copy() && = delete;
   inline __isl_keep isl_fixed_box *get() const;
   inline __isl_give isl_fixed_box *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline multi_aff get_offset() const;
   inline multi_val get_size() const;
   inline space get_space() const;
   inline boolean is_valid() const;
 };
 
public:
   inline id &operator=(id obj);
   inline ~id();
   inline __isl_give isl_id *copy() const &;
   inline __isl_give isl_id *copy() && = delete;
   inline __isl_keep isl_id *get() const;
   inline __isl_give isl_id *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   static inline id alloc(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;
 };
 
public:
   inline id_list &operator=(id_list obj);
   inline ~id_list();
   inline __isl_give isl_id_list *copy() const &;
   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 ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline id_list add(id el) const;
   static inline id_list alloc(ctx ctx, int n);
   inline id_list clear() const;
   inline id_list concat(id_list list2) const;
   inline id_list drop(unsigned int first, unsigned int n) const;
   inline stat foreach(const std::function<stat(id)> &fn) const;
public:
   inline map &operator=(map obj);
   inline ~map();
   inline __isl_give isl_map *copy() const &;
   inline __isl_give isl_map *copy() && = delete;
   inline __isl_keep isl_map *get() const;
   inline __isl_give isl_map *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline map add_constraint(constraint constraint) const;
   inline map add_dims(isl::dim type, unsigned int n) const;
   inline basic_map affine_hull() const;
   inline map align_params(space model) const;
   inline map apply_domain(map map2) const;
   inline map apply_range(map map2) const;
public:
   inline map_list &operator=(map_list obj);
   inline ~map_list();
   inline __isl_give isl_map_list *copy() const &;
   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 ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline map_list add(map el) const;
   static inline map_list alloc(ctx ctx, int n);
   inline map_list clear() const;
   inline map_list concat(map_list list2) const;
   inline map_list drop(unsigned int first, unsigned int n) const;
   inline stat foreach(const std::function<stat(map)> &fn) const;
public:
   inline multi_aff &operator=(multi_aff obj);
   inline ~multi_aff();
   inline __isl_give isl_multi_aff *copy() const &;
   inline __isl_give isl_multi_aff *copy() && = delete;
   inline __isl_keep isl_multi_aff *get() const;
   inline __isl_give isl_multi_aff *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline multi_aff add(multi_aff multi2) const;
   inline multi_aff add_constant(multi_val mv) const;
   inline multi_aff add_constant(val v) const;
   inline multi_aff add_dims(isl::dim type, unsigned int n) const;
   inline multi_aff align_params(space model) const;
   inline basic_set bind(multi_id tuple) const;
public:
   inline multi_id &operator=(multi_id obj);
   inline ~multi_id();
   inline __isl_give isl_multi_id *copy() const &;
   inline __isl_give isl_multi_id *copy() && = delete;
   inline __isl_keep isl_multi_id *get() const;
   inline __isl_give isl_multi_id *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline multi_id align_params(space model) const;
   inline multi_id factor_range() const;
   inline multi_id flat_range_product(multi_id multi2) const;
   inline multi_id flatten_range() const;
   inline multi_id from_range() const;
   inline id get_at(int pos) const;
public:
   inline multi_pw_aff &operator=(multi_pw_aff obj);
   inline ~multi_pw_aff();
   inline __isl_give isl_multi_pw_aff *copy() const &;
   inline __isl_give isl_multi_pw_aff *copy() && = delete;
   inline __isl_keep isl_multi_pw_aff *get() const;
   inline __isl_give isl_multi_pw_aff *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline multi_pw_aff add(multi_pw_aff multi2) const;
   inline multi_pw_aff add_constant(multi_val mv) const;
   inline multi_pw_aff add_constant(val v) const;
   inline multi_pw_aff add_dims(isl::dim type, unsigned int n) const;
   inline multi_pw_aff align_params(space model) const;
   inline set bind(multi_id tuple) const;
public:
   inline multi_union_pw_aff &operator=(multi_union_pw_aff obj);
   inline ~multi_union_pw_aff();
   inline __isl_give isl_multi_union_pw_aff *copy() const &;
   inline __isl_give isl_multi_union_pw_aff *copy() && = delete;
   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 ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline multi_union_pw_aff add(multi_union_pw_aff multi2) const;
   inline multi_union_pw_aff align_params(space model) const;
   inline union_pw_aff apply_aff(aff aff) const;
   inline union_pw_aff apply_pw_aff(pw_aff pa) const;
   inline multi_union_pw_aff apply_pw_multi_aff(pw_multi_aff pma) const;
   inline union_set bind(multi_id tuple) const;
public:
   inline multi_val &operator=(multi_val obj);
   inline ~multi_val();
   inline __isl_give isl_multi_val *copy() const &;
   inline __isl_give isl_multi_val *copy() && = delete;
   inline __isl_keep isl_multi_val *get() const;
   inline __isl_give isl_multi_val *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline multi_val add(multi_val multi2) const;
   inline multi_val add(val v) const;
   inline multi_val add_dims(isl::dim type, unsigned int n) const;
   inline multi_val align_params(space model) const;
   inline isl_size dim(isl::dim type) const;
   inline multi_val drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
public:
   inline point &operator=(point obj);
   inline ~point();
   inline __isl_give isl_point *copy() const &;
   inline __isl_give isl_point *copy() && = delete;
   inline __isl_keep isl_point *get() const;
   inline __isl_give isl_point *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline point add_ui(isl::dim type, int pos, unsigned int val) const;
   inline val get_coordinate_val(isl::dim type, int pos) const;
   inline multi_val get_multi_val() const;
   inline space get_space() const;
   inline point set_coordinate_val(isl::dim type, int pos, val v) const;
   inline point sub_ui(isl::dim type, int pos, unsigned int val) const;
public:
   inline pw_aff &operator=(pw_aff obj);
   inline ~pw_aff();
   inline __isl_give isl_pw_aff *copy() const &;
   inline __isl_give isl_pw_aff *copy() && = delete;
   inline __isl_keep isl_pw_aff *get() const;
   inline __isl_give isl_pw_aff *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline pw_aff add(pw_aff pwaff2) const;
   inline pw_aff add_constant(val v) const;
   inline pw_aff add_dims(isl::dim type, unsigned int n) const;
   inline pw_aff align_params(space model) const;
   static inline pw_aff alloc(set set, aff aff);
   inline aff as_aff() const;
public:
   inline pw_aff_list &operator=(pw_aff_list obj);
   inline ~pw_aff_list();
   inline __isl_give isl_pw_aff_list *copy() const &;
   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 ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline pw_aff_list add(pw_aff el) const;
   static inline pw_aff_list alloc(ctx ctx, int n);
   inline pw_aff_list clear() const;
   inline pw_aff_list concat(pw_aff_list list2) const;
   inline pw_aff_list drop(unsigned int first, unsigned int n) const;
   inline set eq_set(pw_aff_list list2) const;
public:
   inline pw_multi_aff &operator=(pw_multi_aff obj);
   inline ~pw_multi_aff();
   inline __isl_give isl_pw_multi_aff *copy() const &;
   inline __isl_give isl_pw_multi_aff *copy() && = delete;
   inline __isl_keep isl_pw_multi_aff *get() const;
   inline __isl_give isl_pw_multi_aff *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline pw_multi_aff add(pw_multi_aff pma2) const;
   inline pw_multi_aff add_constant(multi_val mv) const;
   inline pw_multi_aff add_constant(val v) const;
   inline pw_multi_aff align_params(space model) const;
   static inline pw_multi_aff alloc(set set, multi_aff maff);
   inline multi_aff as_multi_aff() const;
public:
   inline pw_multi_aff_list &operator=(pw_multi_aff_list obj);
   inline ~pw_multi_aff_list();
   inline __isl_give isl_pw_multi_aff_list *copy() const &;
   inline __isl_give isl_pw_multi_aff_list *copy() && = delete;
   inline __isl_keep isl_pw_multi_aff_list *get() const;
   inline __isl_give isl_pw_multi_aff_list *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline pw_multi_aff_list add(pw_multi_aff el) const;
   static inline pw_multi_aff_list alloc(ctx ctx, int n);
   inline pw_multi_aff_list clear() const;
   inline pw_multi_aff_list concat(pw_multi_aff_list list2) const;
   inline pw_multi_aff_list drop(unsigned int first, unsigned int n) const;
   inline stat foreach(const std::function<stat(pw_multi_aff)> &fn) const;
public:
   inline pw_qpolynomial &operator=(pw_qpolynomial obj);
   inline ~pw_qpolynomial();
   inline __isl_give isl_pw_qpolynomial *copy() const &;
   inline __isl_give isl_pw_qpolynomial *copy() && = delete;
   inline __isl_keep isl_pw_qpolynomial *get() const;
   inline __isl_give isl_pw_qpolynomial *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline pw_qpolynomial add(pw_qpolynomial pwqp2) const;
   inline pw_qpolynomial add_dims(isl::dim type, unsigned int n) const;
   static inline pw_qpolynomial alloc(set set, qpolynomial qp);
   inline qpolynomial as_qpolynomial() const;
   inline pw_qpolynomial coalesce() const;
   inline isl_size dim(isl::dim type) const;
public:
   inline pw_qpolynomial_fold_list &operator=(pw_qpolynomial_fold_list obj);
   inline ~pw_qpolynomial_fold_list();
   inline __isl_give isl_pw_qpolynomial_fold_list *copy() const &;
   inline __isl_give isl_pw_qpolynomial_fold_list *copy() && = delete;
   inline __isl_keep isl_pw_qpolynomial_fold_list *get() const;
   inline __isl_give isl_pw_qpolynomial_fold_list *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
 };
 
 // declarations for isl::pw_qpolynomial_list
 inline pw_qpolynomial_list manage(__isl_take isl_pw_qpolynomial_list *ptr);
 inline pw_qpolynomial_list manage_copy(__isl_keep isl_pw_qpolynomial_list *ptr);
 
public:
   inline pw_qpolynomial_list &operator=(pw_qpolynomial_list obj);
   inline ~pw_qpolynomial_list();
   inline __isl_give isl_pw_qpolynomial_list *copy() const &;
   inline __isl_give isl_pw_qpolynomial_list *copy() && = delete;
   inline __isl_keep isl_pw_qpolynomial_list *get() const;
   inline __isl_give isl_pw_qpolynomial_list *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline pw_qpolynomial_list add(pw_qpolynomial el) const;
   static inline pw_qpolynomial_list alloc(ctx ctx, int n);
   inline pw_qpolynomial_list clear() const;
   inline pw_qpolynomial_list concat(pw_qpolynomial_list list2) const;
   inline pw_qpolynomial_list drop(unsigned int first, unsigned int n) const;
   inline stat foreach(const std::function<stat(pw_qpolynomial)> &fn) const;
public:
   inline qpolynomial_list &operator=(qpolynomial_list obj);
   inline ~qpolynomial_list();
   inline __isl_give isl_qpolynomial_list *copy() const &;
   inline __isl_give isl_qpolynomial_list *copy() && = delete;
   inline __isl_keep isl_qpolynomial_list *get() const;
   inline __isl_give isl_qpolynomial_list *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline qpolynomial_list add(qpolynomial el) const;
   static inline qpolynomial_list alloc(ctx ctx, int n);
   inline qpolynomial_list clear() const;
   inline qpolynomial_list concat(qpolynomial_list list2) const;
   inline qpolynomial_list drop(unsigned int first, unsigned int n) const;
   inline stat foreach(const std::function<stat(qpolynomial)> &fn) const;
public:
   inline schedule &operator=(schedule obj);
   inline ~schedule();
   inline __isl_give isl_schedule *copy() const &;
   inline __isl_give isl_schedule *copy() && = delete;
   inline __isl_keep isl_schedule *get() const;
   inline __isl_give isl_schedule *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline schedule align_params(space space) const;
   static inline schedule empty(space space);
   static inline schedule from_domain(union_set domain);
   inline union_set get_domain() const;
   inline union_map get_map() const;
   inline schedule_node get_root() const;
public:
   inline schedule_constraints &operator=(schedule_constraints obj);
   inline ~schedule_constraints();
   inline __isl_give isl_schedule_constraints *copy() const &;
   inline __isl_give isl_schedule_constraints *copy() && = delete;
   inline __isl_keep isl_schedule_constraints *get() const;
   inline __isl_give isl_schedule_constraints *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline schedule_constraints apply(union_map umap) const;
   inline schedule compute_schedule() const;
   inline union_map get_coincidence() const;
   inline union_map get_conditional_validity() const;
   inline union_map get_conditional_validity_condition() const;
   inline set get_context() const;
public:
   inline schedule_node &operator=(schedule_node obj);
   inline ~schedule_node();
   inline __isl_give isl_schedule_node *copy() const &;
   inline __isl_give isl_schedule_node *copy() && = delete;
   inline __isl_keep isl_schedule_node *get() const;
   inline __isl_give isl_schedule_node *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline schedule_node align_params(space space) const;
   inline schedule_node ancestor(int generation) const;
   inline boolean band_member_get_coincident(int pos) const;
   inline schedule_node band_member_set_coincident(int pos, int coincident) const;
   inline schedule_node band_set_ast_build_options(union_set options) const;
   inline schedule_node child(int pos) const;
public:
   inline set &operator=(set obj);
   inline ~set();
   inline __isl_give isl_set *copy() const &;
   inline __isl_give isl_set *copy() && = delete;
   inline __isl_keep isl_set *get() const;
   inline __isl_give isl_set *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline set add_constraint(constraint constraint) const;
   inline set add_dims(isl::dim type, unsigned int n) const;
   inline basic_set affine_hull() const;
   inline set align_params(space model) const;
   inline set apply(map map) const;
   inline set bind(multi_id tuple) const;
public:
   inline set_list &operator=(set_list obj);
   inline ~set_list();
   inline __isl_give isl_set_list *copy() const &;
   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 ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline set_list add(set el) const;
   static inline set_list alloc(ctx ctx, int n);
   inline set_list clear() const;
   inline set_list concat(set_list list2) const;
   inline set_list drop(unsigned int first, unsigned int n) const;
   inline stat foreach(const std::function<stat(set)> &fn) const;
public:
   inline space &operator=(space obj);
   inline ~space();
   inline __isl_give isl_space *copy() const &;
   inline __isl_give isl_space *copy() && = delete;
   inline __isl_keep isl_space *get() const;
   inline __isl_give isl_space *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline space add_dims(isl::dim type, unsigned int n) const;
   inline space add_named_tuple(id tuple_id, unsigned int dim) const;
   inline space add_param_id(id id) const;
   inline space add_unnamed_tuple(unsigned int dim) const;
   inline space align_params(space space2) const;
   inline boolean can_curry() const;
public:
   inline union_access_info &operator=(union_access_info obj);
   inline ~union_access_info();
   inline __isl_give isl_union_access_info *copy() const &;
   inline __isl_give isl_union_access_info *copy() && = delete;
   inline __isl_keep isl_union_access_info *get() const;
   inline __isl_give isl_union_access_info *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
-  inline std::string to_str() const;
 
   inline union_flow compute_flow() const;
   inline union_access_info set_kill(union_map kill) const;
   inline union_access_info set_may_source(union_map may_source) const;
   inline union_access_info set_must_source(union_map must_source) const;
   inline union_access_info set_schedule(schedule schedule) const;
   inline union_access_info set_schedule_map(union_map schedule_map) const;
 };
public:
   inline union_flow &operator=(union_flow obj);
   inline ~union_flow();
   inline __isl_give isl_union_flow *copy() const &;
   inline __isl_give isl_union_flow *copy() && = delete;
   inline __isl_keep isl_union_flow *get() const;
   inline __isl_give isl_union_flow *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
-  inline std::string to_str() const;
 
   inline union_map get_full_may_dependence() const;
   inline union_map get_full_must_dependence() const;
   inline union_map get_may_dependence() const;
   inline union_map get_may_no_source() const;
   inline union_map get_must_dependence() const;
   inline union_map get_must_no_source() const;
 };
public:
   inline union_map &operator=(union_map obj);
   inline ~union_map();
   inline __isl_give isl_union_map *copy() const &;
   inline __isl_give isl_union_map *copy() && = delete;
   inline __isl_keep isl_union_map *get() const;
   inline __isl_give isl_union_map *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline union_map add_map(map map) const;
   inline union_map affine_hull() const;
   inline union_map align_params(space model) const;
   inline union_map apply_domain(union_map umap2) const;
   inline union_map apply_range(union_map umap2) const;
   inline union_set bind_range(multi_id tuple) const;
public:
   inline union_map_list &operator=(union_map_list obj);
   inline ~union_map_list();
   inline __isl_give isl_union_map_list *copy() const &;
   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 ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline union_map_list add(union_map el) const;
   static inline union_map_list alloc(ctx ctx, int n);
   inline union_map_list clear() const;
   inline union_map_list concat(union_map_list list2) const;
   inline union_map_list drop(unsigned int first, unsigned int n) const;
   inline stat foreach(const std::function<stat(union_map)> &fn) const;
public:
   inline union_pw_aff &operator=(union_pw_aff obj);
   inline ~union_pw_aff();
   inline __isl_give isl_union_pw_aff *copy() const &;
   inline __isl_give isl_union_pw_aff *copy() && = delete;
   inline __isl_keep isl_union_pw_aff *get() const;
   inline __isl_give isl_union_pw_aff *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline union_pw_aff add(union_pw_aff upa2) const;
   inline union_pw_aff add_pw_aff(pw_aff pa) const;
   static inline union_pw_aff aff_on_domain(union_set domain, aff aff);
   inline union_pw_aff align_params(space model) const;
   inline union_set bind(id id) const;
   inline union_pw_aff coalesce() const;
public:
   inline union_pw_aff_list &operator=(union_pw_aff_list obj);
   inline ~union_pw_aff_list();
   inline __isl_give isl_union_pw_aff_list *copy() const &;
   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 ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline union_pw_aff_list add(union_pw_aff el) const;
   static inline union_pw_aff_list alloc(ctx ctx, int n);
   inline union_pw_aff_list clear() const;
   inline union_pw_aff_list concat(union_pw_aff_list list2) const;
   inline union_pw_aff_list drop(unsigned int first, unsigned int n) const;
   inline stat foreach(const std::function<stat(union_pw_aff)> &fn) const;
public:
   inline union_pw_multi_aff &operator=(union_pw_multi_aff obj);
   inline ~union_pw_multi_aff();
   inline __isl_give isl_union_pw_multi_aff *copy() const &;
   inline __isl_give isl_union_pw_multi_aff *copy() && = delete;
   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 ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline union_pw_multi_aff add(union_pw_multi_aff upma2) const;
   inline union_pw_multi_aff add_pw_multi_aff(pw_multi_aff pma) const;
   inline union_pw_multi_aff align_params(space model) const;
   inline union_pw_multi_aff apply(union_pw_multi_aff upma2) const;
   inline pw_multi_aff as_pw_multi_aff() const;
   inline union_pw_multi_aff coalesce() const;
public:
   inline union_pw_multi_aff_list &operator=(union_pw_multi_aff_list obj);
   inline ~union_pw_multi_aff_list();
   inline __isl_give isl_union_pw_multi_aff_list *copy() const &;
   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 ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline union_pw_multi_aff_list add(union_pw_multi_aff el) const;
   static inline union_pw_multi_aff_list alloc(ctx ctx, int n);
   inline union_pw_multi_aff_list clear() const;
   inline union_pw_multi_aff_list concat(union_pw_multi_aff_list list2) const;
   inline union_pw_multi_aff_list drop(unsigned int first, unsigned int n) const;
   inline stat foreach(const std::function<stat(union_pw_multi_aff)> &fn) const;
public:
   inline union_pw_qpolynomial &operator=(union_pw_qpolynomial obj);
   inline ~union_pw_qpolynomial();
   inline __isl_give isl_union_pw_qpolynomial *copy() const &;
   inline __isl_give isl_union_pw_qpolynomial *copy() && = delete;
   inline __isl_keep isl_union_pw_qpolynomial *get() const;
   inline __isl_give isl_union_pw_qpolynomial *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
-  inline std::string to_str() const;
 
   inline union_pw_qpolynomial add(union_pw_qpolynomial upwqp2) const;
   inline union_pw_qpolynomial add_pw_qpolynomial(pw_qpolynomial pwqp) const;
   inline union_pw_qpolynomial align_params(space model) const;
   inline union_pw_qpolynomial coalesce() const;
   inline isl_size dim(isl::dim type) const;
   inline union_set domain() const;
   inline union_pw_qpolynomial drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
public:
   inline union_set &operator=(union_set obj);
   inline ~union_set();
   inline __isl_give isl_union_set *copy() const &;
   inline __isl_give isl_union_set *copy() && = delete;
   inline __isl_keep isl_union_set *get() const;
   inline __isl_give isl_union_set *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline union_set add_set(set set) const;
   inline union_set affine_hull() const;
   inline union_set align_params(space model) const;
   inline union_set apply(union_map umap) const;
   inline union_set coalesce() const;
   inline union_set coefficients() const;
public:
   inline union_set_list &operator=(union_set_list obj);
   inline ~union_set_list();
   inline __isl_give isl_union_set_list *copy() const &;
   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 ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline union_set_list add(union_set el) const;
   static inline union_set_list alloc(ctx ctx, int n);
   inline union_set_list clear() const;
   inline union_set_list concat(union_set_list list2) const;
   inline union_set_list drop(unsigned int first, unsigned int n) const;
   inline stat foreach(const std::function<stat(union_set)> &fn) const;
public:
   inline val &operator=(val obj);
   inline ~val();
   inline __isl_give isl_val *copy() const &;
   inline __isl_give isl_val *copy() && = delete;
   inline __isl_keep isl_val *get() const;
   inline __isl_give isl_val *release();
   inline bool is_null() const;
   inline ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline val abs() const;
   inline boolean abs_eq(const val &v2) const;
   inline val add(val v2) const;
   inline val add_ui(unsigned long v2) const;
   inline val ceil() const;
   inline int cmp_si(long i) const;
public:
   inline val_list &operator=(val_list obj);
   inline ~val_list();
   inline __isl_give isl_val_list *copy() const &;
   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 ctx get_ctx() const;
-  inline std::string to_str() const;
   inline void dump() const;
 
   inline val_list add(val el) const;
   static inline val_list alloc(ctx ctx, int n);
   inline val_list clear() const;
   inline val_list concat(val_list list2) const;
   inline val_list drop(unsigned int first, unsigned int n) const;
   inline stat foreach(const std::function<stat(val)> &fn) const;

 bool aff::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx aff::get_ctx() const {
   return ctx(isl_aff_get_ctx(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());
 }
 
 
 aff aff::add(aff aff2) const
 {

 bool aff_list::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx aff_list::get_ctx() const {
   return ctx(isl_aff_list_get_ctx(ptr));
 }
-std::string aff_list::to_str() const {
-  char *Tmp = isl_aff_list_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void aff_list::dump() const {
   isl_aff_list_dump(get());
 }
 
 
 aff_list aff_list::add(aff el) const
 {

 bool ast_expr::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx ast_expr::get_ctx() const {
   return ctx(isl_ast_expr_get_ctx(ptr));
 }
-std::string ast_expr::to_str() const {
-  char *Tmp = isl_ast_expr_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void ast_expr::dump() const {
   isl_ast_expr_dump(get());
 }
 
 
 ast_expr ast_expr::access(ast_expr_list indices) const
 {

 bool ast_expr_list::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx ast_expr_list::get_ctx() const {
   return ctx(isl_ast_expr_list_get_ctx(ptr));
 }
-std::string ast_expr_list::to_str() const {
-  char *Tmp = isl_ast_expr_list_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void ast_expr_list::dump() const {
   isl_ast_expr_list_dump(get());
 }
 
 
 ast_expr_list ast_expr_list::add(ast_expr el) const
 {

 bool ast_node::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx ast_node::get_ctx() const {
   return ctx(isl_ast_node_get_ctx(ptr));
 }
-std::string ast_node::to_str() const {
-  char *Tmp = isl_ast_node_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void ast_node::dump() const {
   isl_ast_node_dump(get());
 }
 
 
 ast_node ast_node::alloc_user(ast_expr expr)
 {

 bool ast_node_list::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx ast_node_list::get_ctx() const {
   return ctx(isl_ast_node_list_get_ctx(ptr));
 }
-std::string ast_node_list::to_str() const {
-  char *Tmp = isl_ast_node_list_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void ast_node_list::dump() const {
   isl_ast_node_list_dump(get());
 }
 
 
 ast_node_list ast_node_list::add(ast_node el) const
 {

 bool basic_map::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx basic_map::get_ctx() const {
   return ctx(isl_basic_map_get_ctx(ptr));
 }
-std::string basic_map::to_str() const {
-  char *Tmp = isl_basic_map_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void basic_map::dump() const {
   isl_basic_map_dump(get());
 }
 
 
 basic_map basic_map::add_constraint(constraint constraint) const
 {

 bool basic_map_list::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx basic_map_list::get_ctx() const {
   return ctx(isl_basic_map_list_get_ctx(ptr));
 }
-std::string basic_map_list::to_str() const {
-  char *Tmp = isl_basic_map_list_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void basic_map_list::dump() const {
   isl_basic_map_list_dump(get());
 }
 
 
 basic_map_list basic_map_list::add(basic_map el) const
 {

 bool basic_set::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx basic_set::get_ctx() const {
   return ctx(isl_basic_set_get_ctx(ptr));
 }
-std::string basic_set::to_str() const {
-  char *Tmp = isl_basic_set_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void basic_set::dump() const {
   isl_basic_set_dump(get());
 }
 
 
 basic_set basic_set::affine_hull() const
 {

 bool basic_set_list::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx basic_set_list::get_ctx() const {
   return ctx(isl_basic_set_list_get_ctx(ptr));
 }
-std::string basic_set_list::to_str() const {
-  char *Tmp = isl_basic_set_list_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void basic_set_list::dump() const {
   isl_basic_set_list_dump(get());
 }
 
 
 basic_set_list basic_set_list::add(basic_set el) const
 {

 bool constraint_list::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx constraint_list::get_ctx() const {
   return ctx(isl_constraint_list_get_ctx(ptr));
 }
-std::string constraint_list::to_str() const {
-  char *Tmp = isl_constraint_list_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void constraint_list::dump() const {
   isl_constraint_list_dump(get());
 }
 
 
 constraint_list constraint_list::add(constraint el) const
 {

 bool fixed_box::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx fixed_box::get_ctx() const {
   return ctx(isl_fixed_box_get_ctx(ptr));
 }
-std::string fixed_box::to_str() const {
-  char *Tmp = isl_fixed_box_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void fixed_box::dump() const {
   isl_fixed_box_dump(get());
 }
 
 
 multi_aff fixed_box::get_offset() const
 {

 bool id::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx id::get_ctx() const {
   return ctx(isl_id_get_ctx(ptr));
 }
-std::string id::to_str() const {
-  char *Tmp = isl_id_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void id::dump() const {
   isl_id_dump(get());
 }
 
 
 id id::alloc(ctx ctx, const std::string &name, void * user)
 {

 bool id_list::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx id_list::get_ctx() const {
   return ctx(isl_id_list_get_ctx(ptr));
 }
-std::string id_list::to_str() const {
-  char *Tmp = isl_id_list_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void id_list::dump() const {
   isl_id_list_dump(get());
 }
 
 
 id_list id_list::add(id el) const
 {

 bool map::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx map::get_ctx() const {
   return ctx(isl_map_get_ctx(ptr));
 }
-std::string map::to_str() const {
-  char *Tmp = isl_map_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void map::dump() const {
   isl_map_dump(get());
 }
 
 
 map map::add_constraint(constraint constraint) const
 {

 bool map_list::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx map_list::get_ctx() const {
   return ctx(isl_map_list_get_ctx(ptr));
 }
-std::string map_list::to_str() const {
-  char *Tmp = isl_map_list_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void map_list::dump() const {
   isl_map_list_dump(get());
 }
 
 
 map_list map_list::add(map el) const
 {

 bool multi_aff::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx multi_aff::get_ctx() const {
   return ctx(isl_multi_aff_get_ctx(ptr));
 }
-std::string multi_aff::to_str() const {
-  char *Tmp = isl_multi_aff_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void multi_aff::dump() const {
   isl_multi_aff_dump(get());
 }
 
 
 multi_aff multi_aff::add(multi_aff multi2) const
 {

 bool multi_id::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx multi_id::get_ctx() const {
   return ctx(isl_multi_id_get_ctx(ptr));
 }
-std::string multi_id::to_str() const {
-  char *Tmp = isl_multi_id_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void multi_id::dump() const {
   isl_multi_id_dump(get());
 }
 
 
 multi_id multi_id::align_params(space model) const
 {

 bool multi_pw_aff::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx multi_pw_aff::get_ctx() const {
   return ctx(isl_multi_pw_aff_get_ctx(ptr));
 }
-std::string multi_pw_aff::to_str() const {
-  char *Tmp = isl_multi_pw_aff_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void multi_pw_aff::dump() const {
   isl_multi_pw_aff_dump(get());
 }
 
 
 multi_pw_aff multi_pw_aff::add(multi_pw_aff multi2) const
 {

 bool multi_union_pw_aff::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx multi_union_pw_aff::get_ctx() const {
   return ctx(isl_multi_union_pw_aff_get_ctx(ptr));
 }
-std::string multi_union_pw_aff::to_str() const {
-  char *Tmp = isl_multi_union_pw_aff_to_str(get());
-  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());
 }
 
 
 multi_union_pw_aff multi_union_pw_aff::add(multi_union_pw_aff multi2) const
 {

 bool multi_val::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx multi_val::get_ctx() const {
   return ctx(isl_multi_val_get_ctx(ptr));
 }
-std::string multi_val::to_str() const {
-  char *Tmp = isl_multi_val_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void multi_val::dump() const {
   isl_multi_val_dump(get());
 }
 
 
 multi_val multi_val::add(multi_val multi2) const
 {

 bool point::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx point::get_ctx() const {
   return ctx(isl_point_get_ctx(ptr));
 }
-std::string point::to_str() const {
-  char *Tmp = isl_point_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void point::dump() const {
   isl_point_dump(get());
 }
 
 
 point point::add_ui(isl::dim type, int pos, unsigned int val) const
 {

 bool pw_aff::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx pw_aff::get_ctx() const {
   return ctx(isl_pw_aff_get_ctx(ptr));
 }
-std::string pw_aff::to_str() const {
-  char *Tmp = isl_pw_aff_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void pw_aff::dump() const {
   isl_pw_aff_dump(get());
 }
 
 
 pw_aff pw_aff::add(pw_aff pwaff2) const
 {

 bool pw_aff_list::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx pw_aff_list::get_ctx() const {
   return ctx(isl_pw_aff_list_get_ctx(ptr));
 }
-std::string pw_aff_list::to_str() const {
-  char *Tmp = isl_pw_aff_list_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void pw_aff_list::dump() const {
   isl_pw_aff_list_dump(get());
 }
 
 
 pw_aff_list pw_aff_list::add(pw_aff el) const
 {

 bool pw_multi_aff::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx pw_multi_aff::get_ctx() const {
   return ctx(isl_pw_multi_aff_get_ctx(ptr));
 }
-std::string pw_multi_aff::to_str() const {
-  char *Tmp = isl_pw_multi_aff_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void pw_multi_aff::dump() const {
   isl_pw_multi_aff_dump(get());
 }
 
 
 pw_multi_aff pw_multi_aff::add(pw_multi_aff pma2) const
 {

 bool pw_multi_aff_list::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx pw_multi_aff_list::get_ctx() const {
   return ctx(isl_pw_multi_aff_list_get_ctx(ptr));
 }
-std::string pw_multi_aff_list::to_str() const {
-  char *Tmp = isl_pw_multi_aff_list_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void pw_multi_aff_list::dump() const {
   isl_pw_multi_aff_list_dump(get());
 }
 
 
 pw_multi_aff_list pw_multi_aff_list::add(pw_multi_aff el) const
 {

 bool pw_qpolynomial::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx pw_qpolynomial::get_ctx() const {
   return ctx(isl_pw_qpolynomial_get_ctx(ptr));
 }
-std::string pw_qpolynomial::to_str() const {
-  char *Tmp = isl_pw_qpolynomial_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void pw_qpolynomial::dump() const {
   isl_pw_qpolynomial_dump(get());
 }
 
 
 pw_qpolynomial pw_qpolynomial::add(pw_qpolynomial pwqp2) const
 {

 bool pw_qpolynomial_fold_list::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx pw_qpolynomial_fold_list::get_ctx() const {
   return ctx(isl_pw_qpolynomial_fold_list_get_ctx(ptr));
 }
-std::string pw_qpolynomial_fold_list::to_str() const {
-  char *Tmp = isl_pw_qpolynomial_fold_list_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void pw_qpolynomial_fold_list::dump() const {
   isl_pw_qpolynomial_fold_list_dump(get());
 }
 
 
 
 // implementations for isl::pw_qpolynomial_list

 bool pw_qpolynomial_list::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx pw_qpolynomial_list::get_ctx() const {
   return ctx(isl_pw_qpolynomial_list_get_ctx(ptr));
 }
-std::string pw_qpolynomial_list::to_str() const {
-  char *Tmp = isl_pw_qpolynomial_list_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void pw_qpolynomial_list::dump() const {
   isl_pw_qpolynomial_list_dump(get());
 }
 
 
 pw_qpolynomial_list pw_qpolynomial_list::add(pw_qpolynomial el) const
 {

 bool qpolynomial_list::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx qpolynomial_list::get_ctx() const {
   return ctx(isl_qpolynomial_list_get_ctx(ptr));
 }
-std::string qpolynomial_list::to_str() const {
-  char *Tmp = isl_qpolynomial_list_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void qpolynomial_list::dump() const {
   isl_qpolynomial_list_dump(get());
 }
 
 
 qpolynomial_list qpolynomial_list::add(qpolynomial el) const
 {

 bool schedule::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx schedule::get_ctx() const {
   return ctx(isl_schedule_get_ctx(ptr));
 }
-std::string schedule::to_str() const {
-  char *Tmp = isl_schedule_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void schedule::dump() const {
   isl_schedule_dump(get());
 }
 
 
 schedule schedule::align_params(space space) const
 {

 bool schedule_constraints::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx schedule_constraints::get_ctx() const {
   return ctx(isl_schedule_constraints_get_ctx(ptr));
 }
-std::string schedule_constraints::to_str() const {
-  char *Tmp = isl_schedule_constraints_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void schedule_constraints::dump() const {
   isl_schedule_constraints_dump(get());
 }
 
 
 schedule_constraints schedule_constraints::apply(union_map umap) const
 {

 bool schedule_node::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx schedule_node::get_ctx() const {
   return ctx(isl_schedule_node_get_ctx(ptr));
 }
-std::string schedule_node::to_str() const {
-  char *Tmp = isl_schedule_node_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void schedule_node::dump() const {
   isl_schedule_node_dump(get());
 }
 
 
 schedule_node schedule_node::align_params(space space) const
 {

 bool set::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx set::get_ctx() const {
   return ctx(isl_set_get_ctx(ptr));
 }
-std::string set::to_str() const {
-  char *Tmp = isl_set_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void set::dump() const {
   isl_set_dump(get());
 }
 
 
 set set::add_constraint(constraint constraint) const
 {

 bool set_list::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx set_list::get_ctx() const {
   return ctx(isl_set_list_get_ctx(ptr));
 }
-std::string set_list::to_str() const {
-  char *Tmp = isl_set_list_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void set_list::dump() const {
   isl_set_list_dump(get());
 }
 
 
 set_list set_list::add(set el) const
 {

 bool space::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx space::get_ctx() const {
   return ctx(isl_space_get_ctx(ptr));
 }
-std::string space::to_str() const {
-  char *Tmp = isl_space_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void space::dump() const {
   isl_space_dump(get());
 }
 
 
 space space::add_dims(isl::dim type, unsigned int n) const
 {

 bool union_access_info::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx union_access_info::get_ctx() const {
   return ctx(isl_union_access_info_get_ctx(ptr));
 }
-std::string union_access_info::to_str() const {
-  char *Tmp = isl_union_access_info_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 
 union_flow union_access_info::compute_flow() const
 {
   auto res = isl_union_access_info_compute_flow(copy());
   return manage(res);
 }
 

 bool union_flow::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx union_flow::get_ctx() const {
   return ctx(isl_union_flow_get_ctx(ptr));
 }
-std::string union_flow::to_str() const {
-  char *Tmp = isl_union_flow_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 
 union_map union_flow::get_full_may_dependence() const
 {
   auto res = isl_union_flow_get_full_may_dependence(get());
   return manage(res);
 }
 

 bool union_map::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx union_map::get_ctx() const {
   return ctx(isl_union_map_get_ctx(ptr));
 }
-std::string union_map::to_str() const {
-  char *Tmp = isl_union_map_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void union_map::dump() const {
   isl_union_map_dump(get());
 }
 
 
 union_map union_map::add_map(map map) const
 {

 bool union_map_list::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx union_map_list::get_ctx() const {
   return ctx(isl_union_map_list_get_ctx(ptr));
 }
-std::string union_map_list::to_str() const {
-  char *Tmp = isl_union_map_list_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void union_map_list::dump() const {
   isl_union_map_list_dump(get());
 }
 
 
 union_map_list union_map_list::add(union_map el) const
 {

 bool union_pw_aff::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx union_pw_aff::get_ctx() const {
   return ctx(isl_union_pw_aff_get_ctx(ptr));
 }
-std::string union_pw_aff::to_str() const {
-  char *Tmp = isl_union_pw_aff_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void union_pw_aff::dump() const {
   isl_union_pw_aff_dump(get());
 }
 
 
 union_pw_aff union_pw_aff::add(union_pw_aff upa2) const
 {

 bool union_pw_aff_list::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx union_pw_aff_list::get_ctx() const {
   return ctx(isl_union_pw_aff_list_get_ctx(ptr));
 }
-std::string union_pw_aff_list::to_str() const {
-  char *Tmp = isl_union_pw_aff_list_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void union_pw_aff_list::dump() const {
   isl_union_pw_aff_list_dump(get());
 }
 
 
 union_pw_aff_list union_pw_aff_list::add(union_pw_aff el) const
 {

 bool union_pw_multi_aff::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx union_pw_multi_aff::get_ctx() const {
   return ctx(isl_union_pw_multi_aff_get_ctx(ptr));
 }
-std::string union_pw_multi_aff::to_str() const {
-  char *Tmp = isl_union_pw_multi_aff_to_str(get());
-  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());
 }
 
 
 union_pw_multi_aff union_pw_multi_aff::add(union_pw_multi_aff upma2) const
 {

 bool union_pw_multi_aff_list::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx union_pw_multi_aff_list::get_ctx() const {
   return ctx(isl_union_pw_multi_aff_list_get_ctx(ptr));
 }
-std::string union_pw_multi_aff_list::to_str() const {
-  char *Tmp = isl_union_pw_multi_aff_list_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void union_pw_multi_aff_list::dump() const {
   isl_union_pw_multi_aff_list_dump(get());
 }
 
 
 union_pw_multi_aff_list union_pw_multi_aff_list::add(union_pw_multi_aff el) const
 {

 bool union_pw_qpolynomial::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx union_pw_qpolynomial::get_ctx() const {
   return ctx(isl_union_pw_qpolynomial_get_ctx(ptr));
 }
-std::string union_pw_qpolynomial::to_str() const {
-  char *Tmp = isl_union_pw_qpolynomial_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 
 union_pw_qpolynomial union_pw_qpolynomial::add(union_pw_qpolynomial upwqp2) const
 {
   auto res = isl_union_pw_qpolynomial_add(copy(), upwqp2.release());
   return manage(res);
 }
 

 bool union_set::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx union_set::get_ctx() const {
   return ctx(isl_union_set_get_ctx(ptr));
 }
-std::string union_set::to_str() const {
-  char *Tmp = isl_union_set_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void union_set::dump() const {
   isl_union_set_dump(get());
 }
 
 
 union_set union_set::add_set(set set) const
 {

 bool union_set_list::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx union_set_list::get_ctx() const {
   return ctx(isl_union_set_list_get_ctx(ptr));
 }
-std::string union_set_list::to_str() const {
-  char *Tmp = isl_union_set_list_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void union_set_list::dump() const {
   isl_union_set_list_dump(get());
 }
 
 
 union_set_list union_set_list::add(union_set el) const
 {

 bool val::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx val::get_ctx() const {
   return ctx(isl_val_get_ctx(ptr));
 }
-std::string val::to_str() const {
-  char *Tmp = isl_val_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void val::dump() const {
   isl_val_dump(get());
 }
 
 
 val val::abs() const
 {

 bool val_list::is_null() const {
   return ptr == nullptr;
 }
 
 
 ctx val_list::get_ctx() const {
   return ctx(isl_val_list_get_ctx(ptr));
 }
-std::string val_list::to_str() const {
-  char *Tmp = isl_val_list_to_str(get());
-  if (!Tmp)
-    return "";
-  std::string S(Tmp);
-  free(Tmp);
-  return S;
-}
-
 
 void val_list::dump() const {
   isl_val_list_dump(get());
 }
 
 
 val_list val_list::add(val el) const
 {

polly/lib/Support/GICHelper.cpp

APInt polly::APIntFromVal(__isl_take isl_val *Val) {
   free(Data);
   isl_val_free(Val);
   return A;
 }
 
 template <typename ISLTy, typename ISL_CTX_GETTER, typename ISL_PRINTER>
 static inline std::string stringFromIslObjInternal(__isl_keep ISLTy *isl_obj,
                                                    ISL_CTX_GETTER ctx_getter_fn,
-                                                   ISL_PRINTER printer_fn) {
+                                                   ISL_PRINTER printer_fn,
+                                                   std::string DefaultValue) {
   if (!isl_obj)
-    return "null";
+    return DefaultValue;
   isl_ctx *ctx = ctx_getter_fn(isl_obj);
   isl_printer *p = isl_printer_to_str(ctx);
   p = printer_fn(p, isl_obj);
   char *char_str = isl_printer_get_str(p);
   std::string string;
   if (char_str)
     string = char_str;
   else
-    string = "null";
+    string = DefaultValue;
   free(char_str);
   isl_printer_free(p);
   return string;
 }
 
-std::string polly::stringFromIslObj(__isl_keep isl_map *map) {
-  return stringFromIslObjInternal(map, isl_map_get_ctx, isl_printer_print_map);
-}
-
-std::string polly::stringFromIslObj(__isl_keep isl_set *set) {
-  return stringFromIslObjInternal(set, isl_set_get_ctx, isl_printer_print_set);
-}
-
-std::string polly::stringFromIslObj(__isl_keep isl_union_map *umap) {
-  return stringFromIslObjInternal(umap, isl_union_map_get_ctx,
-                                  isl_printer_print_union_map);
-}
-
-std::string polly::stringFromIslObj(__isl_keep isl_union_set *uset) {
-  return stringFromIslObjInternal(uset, isl_union_set_get_ctx,
-                                  isl_printer_print_union_set);
-}
-
-std::string polly::stringFromIslObj(__isl_keep isl_schedule *schedule) {
-  return stringFromIslObjInternal(schedule, isl_schedule_get_ctx,
-                                  isl_printer_print_schedule);
-}
-
-std::string polly::stringFromIslObj(__isl_keep isl_multi_aff *maff) {
-  return stringFromIslObjInternal(maff, isl_multi_aff_get_ctx,
-                                  isl_printer_print_multi_aff);
-}
-
-std::string polly::stringFromIslObj(__isl_keep isl_pw_multi_aff *pma) {
-  return stringFromIslObjInternal(pma, isl_pw_multi_aff_get_ctx,
-                                  isl_printer_print_pw_multi_aff);
-}
-
-std::string polly::stringFromIslObj(__isl_keep isl_multi_pw_aff *mpa) {
-  return stringFromIslObjInternal(mpa, isl_multi_pw_aff_get_ctx,
-                                  isl_printer_print_multi_pw_aff);
-}
-
-std::string polly::stringFromIslObj(__isl_keep isl_union_pw_multi_aff *upma) {
-  return stringFromIslObjInternal(upma, isl_union_pw_multi_aff_get_ctx,
-                                  isl_printer_print_union_pw_multi_aff);
-}
-
-std::string polly::stringFromIslObj(__isl_keep isl_aff *aff) {
-  return stringFromIslObjInternal(aff, isl_aff_get_ctx, isl_printer_print_aff);
-}
-
-std::string polly::stringFromIslObj(__isl_keep isl_pw_aff *pwaff) {
-  return stringFromIslObjInternal(pwaff, isl_pw_aff_get_ctx,
-                                  isl_printer_print_pw_aff);
-}
-
-std::string polly::stringFromIslObj(__isl_keep isl_space *space) {
-  return stringFromIslObjInternal(space, isl_space_get_ctx,
-                                  isl_printer_print_space);
-}
+#define ISL_C_OBJECT_TO_STRING(name)                                           \
+  std::string polly::stringFromIslObj(__isl_keep isl_##name *Obj,              \
+                                      std::string DefaultValue) {              \
+    return stringFromIslObjInternal(Obj, isl_##name##_get_ctx,                 \
+                                    isl_printer_print_##name, DefaultValue);   \
+  }
+
+ISL_C_OBJECT_TO_STRING(aff)
+ISL_C_OBJECT_TO_STRING(ast_expr)
+ISL_C_OBJECT_TO_STRING(ast_node)
+ISL_C_OBJECT_TO_STRING(basic_map)
+ISL_C_OBJECT_TO_STRING(basic_set)
+ISL_C_OBJECT_TO_STRING(map)
+ISL_C_OBJECT_TO_STRING(set)
+ISL_C_OBJECT_TO_STRING(id)
+ISL_C_OBJECT_TO_STRING(multi_aff)
+ISL_C_OBJECT_TO_STRING(multi_pw_aff)
+ISL_C_OBJECT_TO_STRING(multi_union_pw_aff)
+ISL_C_OBJECT_TO_STRING(point)
+ISL_C_OBJECT_TO_STRING(pw_aff)
+ISL_C_OBJECT_TO_STRING(pw_multi_aff)
+ISL_C_OBJECT_TO_STRING(schedule)
+ISL_C_OBJECT_TO_STRING(schedule_node)
+ISL_C_OBJECT_TO_STRING(space)
+ISL_C_OBJECT_TO_STRING(union_access_info)
+ISL_C_OBJECT_TO_STRING(union_flow)
+ISL_C_OBJECT_TO_STRING(union_set)
+ISL_C_OBJECT_TO_STRING(union_map)
+ISL_C_OBJECT_TO_STRING(union_pw_aff)
+ISL_C_OBJECT_TO_STRING(union_pw_multi_aff)
 
 static void replace(std::string &str, const std::string &find,
                     const std::string &replace) {
   size_t pos = 0;
   while ((pos = str.find(find, pos)) != std::string::npos) {
     str.replace(pos, find.length(), replace);
     pos += replace.length();
   }

polly/lib/Support/ISLTools.cpp

 //===------ ISLTools.cpp ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Tools, utilities, helpers and extensions useful in conjunction with the
 // Integer Set Library (isl).
 //
 //===----------------------------------------------------------------------===//
 
 #include "polly/Support/ISLTools.h"
+#include "polly/Support/GICHelper.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <vector>
 
 using namespace polly;
 
 namespace {
 /// Create a map that shifts one dimension by an offset.
static void printSortedPolyhedra(isl::union_set USet, llvm::raw_ostream &OS,
   // Sort the polyhedra.
   llvm::sort(BSets, orderComparer);
 
   // Print the polyhedra.
   bool First = true;
   for (const isl::basic_set &BSet : BSets) {
     std::string Str;
     if (IsMap)
-      Str = isl::map(BSet.unwrap()).to_str();
+      Str = stringFromIslObj(isl::map(BSet.unwrap()));
     else
-      Str = isl::set(BSet).to_str();
+      Str = stringFromIslObj(isl::set(BSet));
     size_t OpenPos = Str.find_first_of('{');
     assert(OpenPos != std::string::npos);
     size_t ClosePos = Str.find_last_of('}');
     assert(ClosePos != std::string::npos);
 
     if (First)
       OS << llvm::StringRef(Str).substr(0, OpenPos + 1) << "\n ";
     else