DimensionSizesPw.clear();
for (const SCEV *Expr : DimensionSizes) {
if (!Expr) {
- DimensionSizesPw.push_back(isl::pw_aff());
+ DimensionSizesPw.push_back(nullptr);
continue;
}
isl::pw_aff Size = S.getPwAffOnly(Expr);
ArrayRef<const SCEV *> Subscripts,
ArrayRef<const SCEV *> Sizes, Value *AccessValue,
MemoryKind Kind)
- : Kind(Kind), AccType(AccType), Statement(Stmt), InvalidDomain(),
+ : Kind(Kind), AccType(AccType), Statement(Stmt), InvalidDomain(nullptr),
BaseAddr(BaseAddress), ElementType(ElementType),
Sizes(Sizes.begin(), Sizes.end()), AccessInstruction(AccessInst),
AccessValue(AccessValue), IsAffine(Affine),
- Subscripts(Subscripts.begin(), Subscripts.end()), AccessRelation(),
- NewAccessRelation(), FAD(nullptr) {
+ Subscripts(Subscripts.begin(), Subscripts.end()), AccessRelation(nullptr),
+ NewAccessRelation(nullptr), FAD(nullptr) {
static const std::string TypeStrings[] = {"", "_Read", "_Write", "_MayWrite"};
const std::string Access = TypeStrings[AccType] + utostr(Stmt->size());
MemoryAccess::MemoryAccess(ScopStmt *Stmt, AccessType AccType, isl::map AccRel)
: Kind(MemoryKind::Array), AccType(AccType), Statement(Stmt),
- InvalidDomain(), AccessRelation(), NewAccessRelation(AccRel),
- FAD(nullptr) {
+ InvalidDomain(nullptr), AccessRelation(nullptr),
+ NewAccessRelation(AccRel), FAD(nullptr) {
isl::id ArrayInfoId = NewAccessRelation.get_tuple_id(isl::dim::out);
auto *SAI = ScopArrayInfo::getFromId(ArrayInfoId);
Sizes.push_back(nullptr);
return isl::map::from_aff(isl::aff(isl::local_space(getDomainSpace())));
auto Schedule = getParent()->getSchedule();
if (!Schedule)
- return {};
+ return nullptr;
Schedule = Schedule.intersect_domain(isl::union_set(Domain));
if (Schedule.is_empty())
return isl::map::from_aff(isl::aff(isl::local_space(getDomainSpace())));
ScopStmt::ScopStmt(Scop &parent, Region &R, StringRef Name,
Loop *SurroundingLoop,
std::vector<Instruction *> EntryBlockInstructions)
- : Parent(parent), InvalidDomain(), Domain(), R(&R), Build(), BaseName(Name),
- SurroundingLoop(SurroundingLoop), Instructions(EntryBlockInstructions) {}
+ : Parent(parent), InvalidDomain(nullptr), Domain(nullptr), R(&R),
+ Build(nullptr), BaseName(Name), SurroundingLoop(SurroundingLoop),
+ Instructions(EntryBlockInstructions) {}
ScopStmt::ScopStmt(Scop &parent, BasicBlock &bb, StringRef Name,
Loop *SurroundingLoop,
std::vector<Instruction *> Instructions)
- : Parent(parent), InvalidDomain(), Domain(), BB(&bb), Build(),
- BaseName(Name), SurroundingLoop(SurroundingLoop),
+ : Parent(parent), InvalidDomain(nullptr), Domain(nullptr), BB(&bb),
+ Build(nullptr), BaseName(Name), SurroundingLoop(SurroundingLoop),
Instructions(Instructions) {}
ScopStmt::ScopStmt(Scop &parent, isl::map SourceRel, isl::map TargetRel,
isl::set NewDomain)
- : Parent(parent), InvalidDomain(), Domain(NewDomain), Build() {
+ : Parent(parent), InvalidDomain(nullptr), Domain(NewDomain),
+ Build(nullptr) {
BaseName = getIslCompatibleName("CopyStmt_", "",
std::to_string(parent.getCopyStmtsNum()));
isl::id Id = isl::id::alloc(getIslCtx(), getBaseName(), this);
simplify(DefinedBehaviorContext);
if (DefinedBehaviorContext.n_basic_set() >
MaxDisjunktsInDefinedBehaviourContext)
- DefinedBehaviorContext = {};
+ DefinedBehaviorContext = nullptr;
}
}
public:
inline /* implicit */ aff();
inline /* implicit */ aff(const aff &obj);
+ inline /* implicit */ aff(std::nullptr_t);
inline explicit aff(ctx ctx, const std::string &str);
inline explicit aff(local_space ls, val val);
inline explicit aff(local_space ls);
public:
inline /* implicit */ aff_list();
inline /* implicit */ aff_list(const aff_list &obj);
+ inline /* implicit */ aff_list(std::nullptr_t);
inline aff_list &operator=(aff_list obj);
inline ~aff_list();
inline __isl_give isl_aff_list *copy() const &;
public:
inline /* implicit */ ast_build();
inline /* implicit */ ast_build(const ast_build &obj);
+ inline /* implicit */ ast_build(std::nullptr_t);
inline explicit ast_build(ctx ctx);
inline ast_build &operator=(ast_build obj);
inline ~ast_build();
public:
inline /* implicit */ ast_expr();
inline /* implicit */ ast_expr(const ast_expr &obj);
+ inline /* implicit */ ast_expr(std::nullptr_t);
inline ast_expr &operator=(ast_expr obj);
inline ~ast_expr();
inline __isl_give isl_ast_expr *copy() const &;
public:
inline /* implicit */ ast_expr_list();
inline /* implicit */ ast_expr_list(const ast_expr_list &obj);
+ inline /* implicit */ ast_expr_list(std::nullptr_t);
inline ast_expr_list &operator=(ast_expr_list obj);
inline ~ast_expr_list();
inline __isl_give isl_ast_expr_list *copy() const &;
public:
inline /* implicit */ ast_node();
inline /* implicit */ ast_node(const ast_node &obj);
+ inline /* implicit */ ast_node(std::nullptr_t);
inline ast_node &operator=(ast_node obj);
inline ~ast_node();
inline __isl_give isl_ast_node *copy() const &;
public:
inline /* implicit */ ast_node_list();
inline /* implicit */ ast_node_list(const ast_node_list &obj);
+ inline /* implicit */ ast_node_list(std::nullptr_t);
inline ast_node_list &operator=(ast_node_list obj);
inline ~ast_node_list();
inline __isl_give isl_ast_node_list *copy() const &;
public:
inline /* implicit */ basic_map();
inline /* implicit */ basic_map(const basic_map &obj);
+ inline /* implicit */ basic_map(std::nullptr_t);
inline explicit basic_map(ctx ctx, const std::string &str);
inline basic_map &operator=(basic_map obj);
inline ~basic_map();
public:
inline /* implicit */ basic_map_list();
inline /* implicit */ basic_map_list(const basic_map_list &obj);
+ inline /* implicit */ basic_map_list(std::nullptr_t);
inline basic_map_list &operator=(basic_map_list obj);
inline ~basic_map_list();
inline __isl_give isl_basic_map_list *copy() const &;
public:
inline /* implicit */ basic_set();
inline /* implicit */ basic_set(const basic_set &obj);
+ inline /* implicit */ basic_set(std::nullptr_t);
inline /* implicit */ basic_set(point pnt);
inline explicit basic_set(ctx ctx, const std::string &str);
inline basic_set &operator=(basic_set obj);
public:
inline /* implicit */ basic_set_list();
inline /* implicit */ basic_set_list(const basic_set_list &obj);
+ inline /* implicit */ basic_set_list(std::nullptr_t);
inline basic_set_list &operator=(basic_set_list obj);
inline ~basic_set_list();
inline __isl_give isl_basic_set_list *copy() const &;
public:
inline /* implicit */ constraint();
inline /* implicit */ constraint(const constraint &obj);
+ inline /* implicit */ constraint(std::nullptr_t);
inline constraint &operator=(constraint obj);
inline ~constraint();
inline __isl_give isl_constraint *copy() const &;
public:
inline /* implicit */ constraint_list();
inline /* implicit */ constraint_list(const constraint_list &obj);
+ inline /* implicit */ constraint_list(std::nullptr_t);
inline constraint_list &operator=(constraint_list obj);
inline ~constraint_list();
inline __isl_give isl_constraint_list *copy() const &;
public:
inline /* implicit */ fixed_box();
inline /* implicit */ fixed_box(const fixed_box &obj);
+ inline /* implicit */ fixed_box(std::nullptr_t);
inline fixed_box &operator=(fixed_box obj);
inline ~fixed_box();
inline __isl_give isl_fixed_box *copy() const &;
public:
inline /* implicit */ id();
inline /* implicit */ id(const id &obj);
+ inline /* implicit */ id(std::nullptr_t);
inline explicit id(ctx ctx, const std::string &str);
inline id &operator=(id obj);
inline ~id();
public:
inline /* implicit */ id_list();
inline /* implicit */ id_list(const id_list &obj);
+ inline /* implicit */ id_list(std::nullptr_t);
inline id_list &operator=(id_list obj);
inline ~id_list();
inline __isl_give isl_id_list *copy() const &;
public:
inline /* implicit */ id_to_ast_expr();
inline /* implicit */ id_to_ast_expr(const id_to_ast_expr &obj);
+ inline /* implicit */ id_to_ast_expr(std::nullptr_t);
inline id_to_ast_expr &operator=(id_to_ast_expr obj);
inline ~id_to_ast_expr();
inline __isl_give isl_id_to_ast_expr *copy() const &;
public:
inline /* implicit */ local_space();
inline /* implicit */ local_space(const local_space &obj);
+ inline /* implicit */ local_space(std::nullptr_t);
inline explicit local_space(space space);
inline local_space &operator=(local_space obj);
inline ~local_space();
public:
inline /* implicit */ map();
inline /* implicit */ map(const map &obj);
+ inline /* implicit */ map(std::nullptr_t);
inline /* implicit */ map(basic_map bmap);
inline explicit map(ctx ctx, const std::string &str);
inline map &operator=(map obj);
public:
inline /* implicit */ map_list();
inline /* implicit */ map_list(const map_list &obj);
+ inline /* implicit */ map_list(std::nullptr_t);
inline map_list &operator=(map_list obj);
inline ~map_list();
inline __isl_give isl_map_list *copy() const &;
public:
inline /* implicit */ mat();
inline /* implicit */ mat(const mat &obj);
+ inline /* implicit */ mat(std::nullptr_t);
inline mat &operator=(mat obj);
inline ~mat();
inline __isl_give isl_mat *copy() const &;
public:
inline /* implicit */ multi_aff();
inline /* implicit */ multi_aff(const multi_aff &obj);
+ inline /* implicit */ multi_aff(std::nullptr_t);
inline /* implicit */ multi_aff(aff aff);
inline explicit multi_aff(space space, aff_list list);
inline explicit multi_aff(ctx ctx, const std::string &str);
public:
inline /* implicit */ multi_id();
inline /* implicit */ multi_id(const multi_id &obj);
+ inline /* implicit */ multi_id(std::nullptr_t);
inline explicit multi_id(space space, id_list list);
inline explicit multi_id(ctx ctx, const std::string &str);
inline multi_id &operator=(multi_id obj);
public:
inline /* implicit */ multi_pw_aff();
inline /* implicit */ multi_pw_aff(const multi_pw_aff &obj);
+ inline /* implicit */ multi_pw_aff(std::nullptr_t);
inline /* implicit */ multi_pw_aff(aff aff);
inline /* implicit */ multi_pw_aff(multi_aff ma);
inline /* implicit */ multi_pw_aff(pw_aff pa);
public:
inline /* implicit */ multi_union_pw_aff();
inline /* implicit */ multi_union_pw_aff(const multi_union_pw_aff &obj);
+ inline /* implicit */ multi_union_pw_aff(std::nullptr_t);
inline /* implicit */ multi_union_pw_aff(multi_pw_aff mpa);
inline /* implicit */ multi_union_pw_aff(union_pw_aff upa);
inline explicit multi_union_pw_aff(space space, union_pw_aff_list list);
public:
inline /* implicit */ multi_val();
inline /* implicit */ multi_val(const multi_val &obj);
+ inline /* implicit */ multi_val(std::nullptr_t);
inline explicit multi_val(space space, val_list list);
inline explicit multi_val(ctx ctx, const std::string &str);
inline multi_val &operator=(multi_val obj);
public:
inline /* implicit */ point();
inline /* implicit */ point(const point &obj);
+ inline /* implicit */ point(std::nullptr_t);
inline explicit point(space dim);
inline point &operator=(point obj);
inline ~point();
public:
inline /* implicit */ pw_aff();
inline /* implicit */ pw_aff(const pw_aff &obj);
+ inline /* implicit */ pw_aff(std::nullptr_t);
inline /* implicit */ pw_aff(aff aff);
inline explicit pw_aff(ctx ctx, const std::string &str);
inline explicit pw_aff(set domain, val v);
public:
inline /* implicit */ pw_aff_list();
inline /* implicit */ pw_aff_list(const pw_aff_list &obj);
+ inline /* implicit */ pw_aff_list(std::nullptr_t);
inline pw_aff_list &operator=(pw_aff_list obj);
inline ~pw_aff_list();
inline __isl_give isl_pw_aff_list *copy() const &;
public:
inline /* implicit */ pw_multi_aff();
inline /* implicit */ pw_multi_aff(const pw_multi_aff &obj);
+ inline /* implicit */ pw_multi_aff(std::nullptr_t);
inline /* implicit */ pw_multi_aff(multi_aff ma);
inline /* implicit */ pw_multi_aff(pw_aff pa);
inline explicit pw_multi_aff(ctx ctx, const std::string &str);
public:
inline /* implicit */ pw_multi_aff_list();
inline /* implicit */ pw_multi_aff_list(const pw_multi_aff_list &obj);
+ inline /* implicit */ pw_multi_aff_list(std::nullptr_t);
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 &;
public:
inline /* implicit */ pw_qpolynomial();
inline /* implicit */ pw_qpolynomial(const pw_qpolynomial &obj);
+ inline /* implicit */ pw_qpolynomial(std::nullptr_t);
inline explicit pw_qpolynomial(ctx ctx, const std::string &str);
inline pw_qpolynomial &operator=(pw_qpolynomial obj);
inline ~pw_qpolynomial();
public:
inline /* implicit */ pw_qpolynomial_fold_list();
inline /* implicit */ pw_qpolynomial_fold_list(const pw_qpolynomial_fold_list &obj);
+ inline /* implicit */ pw_qpolynomial_fold_list(std::nullptr_t);
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 &;
public:
inline /* implicit */ pw_qpolynomial_list();
inline /* implicit */ pw_qpolynomial_list(const pw_qpolynomial_list &obj);
+ inline /* implicit */ pw_qpolynomial_list(std::nullptr_t);
inline pw_qpolynomial_list &operator=(pw_qpolynomial_list obj);
inline ~pw_qpolynomial_list();
inline __isl_give isl_pw_qpolynomial_list *copy() const &;
public:
inline /* implicit */ qpolynomial();
inline /* implicit */ qpolynomial(const qpolynomial &obj);
+ inline /* implicit */ qpolynomial(std::nullptr_t);
inline qpolynomial &operator=(qpolynomial obj);
inline ~qpolynomial();
inline __isl_give isl_qpolynomial *copy() const &;
public:
inline /* implicit */ qpolynomial_list();
inline /* implicit */ qpolynomial_list(const qpolynomial_list &obj);
+ inline /* implicit */ qpolynomial_list(std::nullptr_t);
inline qpolynomial_list &operator=(qpolynomial_list obj);
inline ~qpolynomial_list();
inline __isl_give isl_qpolynomial_list *copy() const &;
public:
inline /* implicit */ schedule();
inline /* implicit */ schedule(const schedule &obj);
+ inline /* implicit */ schedule(std::nullptr_t);
inline explicit schedule(ctx ctx, const std::string &str);
inline schedule &operator=(schedule obj);
inline ~schedule();
public:
inline /* implicit */ schedule_constraints();
inline /* implicit */ schedule_constraints(const schedule_constraints &obj);
+ inline /* implicit */ schedule_constraints(std::nullptr_t);
inline explicit schedule_constraints(ctx ctx, const std::string &str);
inline schedule_constraints &operator=(schedule_constraints obj);
inline ~schedule_constraints();
public:
inline /* implicit */ schedule_node();
inline /* implicit */ schedule_node(const schedule_node &obj);
+ inline /* implicit */ schedule_node(std::nullptr_t);
inline schedule_node &operator=(schedule_node obj);
inline ~schedule_node();
inline __isl_give isl_schedule_node *copy() const &;
public:
inline /* implicit */ set();
inline /* implicit */ set(const set &obj);
+ inline /* implicit */ set(std::nullptr_t);
inline /* implicit */ set(basic_set bset);
inline /* implicit */ set(point pnt);
inline explicit set(union_set uset);
public:
inline /* implicit */ set_list();
inline /* implicit */ set_list(const set_list &obj);
+ inline /* implicit */ set_list(std::nullptr_t);
inline set_list &operator=(set_list obj);
inline ~set_list();
inline __isl_give isl_set_list *copy() const &;
public:
inline /* implicit */ space();
inline /* implicit */ space(const space &obj);
+ inline /* implicit */ space(std::nullptr_t);
inline explicit space(ctx ctx, unsigned int nparam, unsigned int n_in, unsigned int n_out);
inline explicit space(ctx ctx, unsigned int nparam, unsigned int dim);
inline space &operator=(space obj);
public:
inline /* implicit */ term();
inline /* implicit */ term(const term &obj);
+ inline /* implicit */ term(std::nullptr_t);
inline term &operator=(term obj);
inline ~term();
inline __isl_give isl_term *copy() const &;
public:
inline /* implicit */ union_access_info();
inline /* implicit */ union_access_info(const union_access_info &obj);
+ inline /* implicit */ union_access_info(std::nullptr_t);
inline explicit union_access_info(union_map sink);
inline union_access_info &operator=(union_access_info obj);
inline ~union_access_info();
public:
inline /* implicit */ union_flow();
inline /* implicit */ union_flow(const union_flow &obj);
+ inline /* implicit */ union_flow(std::nullptr_t);
inline union_flow &operator=(union_flow obj);
inline ~union_flow();
inline __isl_give isl_union_flow *copy() const &;
public:
inline /* implicit */ union_map();
inline /* implicit */ union_map(const union_map &obj);
+ inline /* implicit */ union_map(std::nullptr_t);
inline /* implicit */ union_map(basic_map bmap);
inline /* implicit */ union_map(map map);
inline explicit union_map(union_pw_multi_aff upma);
public:
inline /* implicit */ union_map_list();
inline /* implicit */ union_map_list(const union_map_list &obj);
+ inline /* implicit */ union_map_list(std::nullptr_t);
inline union_map_list &operator=(union_map_list obj);
inline ~union_map_list();
inline __isl_give isl_union_map_list *copy() const &;
public:
inline /* implicit */ union_pw_aff();
inline /* implicit */ union_pw_aff(const union_pw_aff &obj);
+ inline /* implicit */ union_pw_aff(std::nullptr_t);
inline /* implicit */ union_pw_aff(aff aff);
inline /* implicit */ union_pw_aff(pw_aff pa);
inline explicit union_pw_aff(ctx ctx, const std::string &str);
public:
inline /* implicit */ union_pw_aff_list();
inline /* implicit */ union_pw_aff_list(const union_pw_aff_list &obj);
+ inline /* implicit */ union_pw_aff_list(std::nullptr_t);
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 &;
public:
inline /* implicit */ union_pw_multi_aff();
inline /* implicit */ union_pw_multi_aff(const union_pw_multi_aff &obj);
+ inline /* implicit */ union_pw_multi_aff(std::nullptr_t);
inline /* implicit */ union_pw_multi_aff(aff aff);
inline explicit union_pw_multi_aff(union_set uset);
inline /* implicit */ union_pw_multi_aff(multi_aff ma);
public:
inline /* implicit */ union_pw_multi_aff_list();
inline /* implicit */ union_pw_multi_aff_list(const union_pw_multi_aff_list &obj);
+ inline /* implicit */ union_pw_multi_aff_list(std::nullptr_t);
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 &;
public:
inline /* implicit */ union_pw_qpolynomial();
inline /* implicit */ union_pw_qpolynomial(const union_pw_qpolynomial &obj);
+ inline /* implicit */ union_pw_qpolynomial(std::nullptr_t);
inline explicit union_pw_qpolynomial(ctx ctx, const std::string &str);
inline union_pw_qpolynomial &operator=(union_pw_qpolynomial obj);
inline ~union_pw_qpolynomial();
public:
inline /* implicit */ union_set();
inline /* implicit */ union_set(const union_set &obj);
+ inline /* implicit */ union_set(std::nullptr_t);
inline /* implicit */ union_set(basic_set bset);
inline /* implicit */ union_set(point pnt);
inline /* implicit */ union_set(set set);
public:
inline /* implicit */ union_set_list();
inline /* implicit */ union_set_list(const union_set_list &obj);
+ inline /* implicit */ union_set_list(std::nullptr_t);
inline union_set_list &operator=(union_set_list obj);
inline ~union_set_list();
inline __isl_give isl_union_set_list *copy() const &;
public:
inline /* implicit */ val();
inline /* implicit */ val(const val &obj);
+ inline /* implicit */ val(std::nullptr_t);
inline explicit val(ctx ctx, long i);
inline explicit val(ctx ctx, const std::string &str);
inline val &operator=(val obj);
public:
inline /* implicit */ val_list();
inline /* implicit */ val_list(const val_list &obj);
+ inline /* implicit */ val_list(std::nullptr_t);
inline val_list &operator=(val_list obj);
inline ~val_list();
inline __isl_give isl_val_list *copy() const &;
public:
inline /* implicit */ vec();
inline /* implicit */ vec(const vec &obj);
+ inline /* implicit */ vec(std::nullptr_t);
inline vec &operator=(vec obj);
inline ~vec();
inline __isl_give isl_vec *copy() const &;
{
ptr = obj.copy();
}
+aff::aff(std::nullptr_t)
+ : ptr(nullptr) {}
aff::aff(__isl_take isl_aff *ptr)
{
ptr = obj.copy();
}
+aff_list::aff_list(std::nullptr_t)
+ : ptr(nullptr) {}
aff_list::aff_list(__isl_take isl_aff_list *ptr)
{
ptr = obj.copy();
}
+ast_build::ast_build(std::nullptr_t)
+ : ptr(nullptr) {}
ast_build::ast_build(__isl_take isl_ast_build *ptr)
{
ptr = obj.copy();
}
+ast_expr::ast_expr(std::nullptr_t)
+ : ptr(nullptr) {}
ast_expr::ast_expr(__isl_take isl_ast_expr *ptr)
{
ptr = obj.copy();
}
+ast_expr_list::ast_expr_list(std::nullptr_t)
+ : ptr(nullptr) {}
ast_expr_list::ast_expr_list(__isl_take isl_ast_expr_list *ptr)
{
ptr = obj.copy();
}
+ast_node::ast_node(std::nullptr_t)
+ : ptr(nullptr) {}
ast_node::ast_node(__isl_take isl_ast_node *ptr)
{
ptr = obj.copy();
}
+ast_node_list::ast_node_list(std::nullptr_t)
+ : ptr(nullptr) {}
ast_node_list::ast_node_list(__isl_take isl_ast_node_list *ptr)
{
ptr = obj.copy();
}
+basic_map::basic_map(std::nullptr_t)
+ : ptr(nullptr) {}
basic_map::basic_map(__isl_take isl_basic_map *ptr)
{
ptr = obj.copy();
}
+basic_map_list::basic_map_list(std::nullptr_t)
+ : ptr(nullptr) {}
basic_map_list::basic_map_list(__isl_take isl_basic_map_list *ptr)
{
ptr = obj.copy();
}
+basic_set::basic_set(std::nullptr_t)
+ : ptr(nullptr) {}
basic_set::basic_set(__isl_take isl_basic_set *ptr)
{
ptr = obj.copy();
}
+basic_set_list::basic_set_list(std::nullptr_t)
+ : ptr(nullptr) {}
basic_set_list::basic_set_list(__isl_take isl_basic_set_list *ptr)
{
ptr = obj.copy();
}
+constraint::constraint(std::nullptr_t)
+ : ptr(nullptr) {}
constraint::constraint(__isl_take isl_constraint *ptr)
{
ptr = obj.copy();
}
+constraint_list::constraint_list(std::nullptr_t)
+ : ptr(nullptr) {}
constraint_list::constraint_list(__isl_take isl_constraint_list *ptr)
{
ptr = obj.copy();
}
+fixed_box::fixed_box(std::nullptr_t)
+ : ptr(nullptr) {}
fixed_box::fixed_box(__isl_take isl_fixed_box *ptr)
{
ptr = obj.copy();
}
+id::id(std::nullptr_t)
+ : ptr(nullptr) {}
id::id(__isl_take isl_id *ptr)
{
ptr = obj.copy();
}
+id_list::id_list(std::nullptr_t)
+ : ptr(nullptr) {}
id_list::id_list(__isl_take isl_id_list *ptr)
{
ptr = obj.copy();
}
+id_to_ast_expr::id_to_ast_expr(std::nullptr_t)
+ : ptr(nullptr) {}
id_to_ast_expr::id_to_ast_expr(__isl_take isl_id_to_ast_expr *ptr)
{
ptr = obj.copy();
}
+local_space::local_space(std::nullptr_t)
+ : ptr(nullptr) {}
local_space::local_space(__isl_take isl_local_space *ptr)
{
ptr = obj.copy();
}
+map::map(std::nullptr_t)
+ : ptr(nullptr) {}
map::map(__isl_take isl_map *ptr)
{
ptr = obj.copy();
}
+map_list::map_list(std::nullptr_t)
+ : ptr(nullptr) {}
map_list::map_list(__isl_take isl_map_list *ptr)
{
ptr = obj.copy();
}
+mat::mat(std::nullptr_t)
+ : ptr(nullptr) {}
mat::mat(__isl_take isl_mat *ptr)
{
ptr = obj.copy();
}
+multi_aff::multi_aff(std::nullptr_t)
+ : ptr(nullptr) {}
multi_aff::multi_aff(__isl_take isl_multi_aff *ptr)
{
ptr = obj.copy();
}
+multi_id::multi_id(std::nullptr_t)
+ : ptr(nullptr) {}
multi_id::multi_id(__isl_take isl_multi_id *ptr)
{
ptr = obj.copy();
}
+multi_pw_aff::multi_pw_aff(std::nullptr_t)
+ : ptr(nullptr) {}
multi_pw_aff::multi_pw_aff(__isl_take isl_multi_pw_aff *ptr)
{
ptr = obj.copy();
}
+multi_union_pw_aff::multi_union_pw_aff(std::nullptr_t)
+ : ptr(nullptr) {}
multi_union_pw_aff::multi_union_pw_aff(__isl_take isl_multi_union_pw_aff *ptr)
{
ptr = obj.copy();
}
+multi_val::multi_val(std::nullptr_t)
+ : ptr(nullptr) {}
multi_val::multi_val(__isl_take isl_multi_val *ptr)
{
ptr = obj.copy();
}
+point::point(std::nullptr_t)
+ : ptr(nullptr) {}
point::point(__isl_take isl_point *ptr)
{
ptr = obj.copy();
}
+pw_aff::pw_aff(std::nullptr_t)
+ : ptr(nullptr) {}
pw_aff::pw_aff(__isl_take isl_pw_aff *ptr)
{
ptr = obj.copy();
}
+pw_aff_list::pw_aff_list(std::nullptr_t)
+ : ptr(nullptr) {}
pw_aff_list::pw_aff_list(__isl_take isl_pw_aff_list *ptr)
{
ptr = obj.copy();
}
+pw_multi_aff::pw_multi_aff(std::nullptr_t)
+ : ptr(nullptr) {}
pw_multi_aff::pw_multi_aff(__isl_take isl_pw_multi_aff *ptr)
{
ptr = obj.copy();
}
+pw_multi_aff_list::pw_multi_aff_list(std::nullptr_t)
+ : ptr(nullptr) {}
pw_multi_aff_list::pw_multi_aff_list(__isl_take isl_pw_multi_aff_list *ptr)
{
ptr = obj.copy();
}
+pw_qpolynomial::pw_qpolynomial(std::nullptr_t)
+ : ptr(nullptr) {}
pw_qpolynomial::pw_qpolynomial(__isl_take isl_pw_qpolynomial *ptr)
{
ptr = obj.copy();
}
+pw_qpolynomial_fold_list::pw_qpolynomial_fold_list(std::nullptr_t)
+ : ptr(nullptr) {}
pw_qpolynomial_fold_list::pw_qpolynomial_fold_list(__isl_take isl_pw_qpolynomial_fold_list *ptr)
{
ptr = obj.copy();
}
+pw_qpolynomial_list::pw_qpolynomial_list(std::nullptr_t)
+ : ptr(nullptr) {}
pw_qpolynomial_list::pw_qpolynomial_list(__isl_take isl_pw_qpolynomial_list *ptr)
{
ptr = obj.copy();
}
+qpolynomial::qpolynomial(std::nullptr_t)
+ : ptr(nullptr) {}
qpolynomial::qpolynomial(__isl_take isl_qpolynomial *ptr)
{
ptr = obj.copy();
}
+qpolynomial_list::qpolynomial_list(std::nullptr_t)
+ : ptr(nullptr) {}
qpolynomial_list::qpolynomial_list(__isl_take isl_qpolynomial_list *ptr)
{
ptr = obj.copy();
}
+schedule::schedule(std::nullptr_t)
+ : ptr(nullptr) {}
schedule::schedule(__isl_take isl_schedule *ptr)
{
ptr = obj.copy();
}
+schedule_constraints::schedule_constraints(std::nullptr_t)
+ : ptr(nullptr) {}
schedule_constraints::schedule_constraints(__isl_take isl_schedule_constraints *ptr)
{
ptr = obj.copy();
}
+schedule_node::schedule_node(std::nullptr_t)
+ : ptr(nullptr) {}
schedule_node::schedule_node(__isl_take isl_schedule_node *ptr)
{
ptr = obj.copy();
}
+set::set(std::nullptr_t)
+ : ptr(nullptr) {}
set::set(__isl_take isl_set *ptr)
{
ptr = obj.copy();
}
+set_list::set_list(std::nullptr_t)
+ : ptr(nullptr) {}
set_list::set_list(__isl_take isl_set_list *ptr)
{
ptr = obj.copy();
}
+space::space(std::nullptr_t)
+ : ptr(nullptr) {}
space::space(__isl_take isl_space *ptr)
{
ptr = obj.copy();
}
+term::term(std::nullptr_t)
+ : ptr(nullptr) {}
term::term(__isl_take isl_term *ptr)
{
ptr = obj.copy();
}
+union_access_info::union_access_info(std::nullptr_t)
+ : ptr(nullptr) {}
union_access_info::union_access_info(__isl_take isl_union_access_info *ptr)
{
ptr = obj.copy();
}
+union_flow::union_flow(std::nullptr_t)
+ : ptr(nullptr) {}
union_flow::union_flow(__isl_take isl_union_flow *ptr)
{
ptr = obj.copy();
}
+union_map::union_map(std::nullptr_t)
+ : ptr(nullptr) {}
union_map::union_map(__isl_take isl_union_map *ptr)
{
ptr = obj.copy();
}
+union_map_list::union_map_list(std::nullptr_t)
+ : ptr(nullptr) {}
union_map_list::union_map_list(__isl_take isl_union_map_list *ptr)
{
ptr = obj.copy();
}
+union_pw_aff::union_pw_aff(std::nullptr_t)
+ : ptr(nullptr) {}
union_pw_aff::union_pw_aff(__isl_take isl_union_pw_aff *ptr)
{
ptr = obj.copy();
}
+union_pw_aff_list::union_pw_aff_list(std::nullptr_t)
+ : ptr(nullptr) {}
union_pw_aff_list::union_pw_aff_list(__isl_take isl_union_pw_aff_list *ptr)
{
ptr = obj.copy();
}
+union_pw_multi_aff::union_pw_multi_aff(std::nullptr_t)
+ : ptr(nullptr) {}
union_pw_multi_aff::union_pw_multi_aff(__isl_take isl_union_pw_multi_aff *ptr)
{
ptr = obj.copy();
}
+union_pw_multi_aff_list::union_pw_multi_aff_list(std::nullptr_t)
+ : ptr(nullptr) {}
union_pw_multi_aff_list::union_pw_multi_aff_list(__isl_take isl_union_pw_multi_aff_list *ptr)
{
ptr = obj.copy();
}
+union_pw_qpolynomial::union_pw_qpolynomial(std::nullptr_t)
+ : ptr(nullptr) {}
union_pw_qpolynomial::union_pw_qpolynomial(__isl_take isl_union_pw_qpolynomial *ptr)
{
ptr = obj.copy();
}
+union_set::union_set(std::nullptr_t)
+ : ptr(nullptr) {}
union_set::union_set(__isl_take isl_union_set *ptr)
{
ptr = obj.copy();
}
+union_set_list::union_set_list(std::nullptr_t)
+ : ptr(nullptr) {}
union_set_list::union_set_list(__isl_take isl_union_set_list *ptr)
{
ptr = obj.copy();
}
+val::val(std::nullptr_t)
+ : ptr(nullptr) {}
val::val(__isl_take isl_val *ptr)
{
ptr = obj.copy();
}
+val_list::val_list(std::nullptr_t)
+ : ptr(nullptr) {}
val_list::val_list(__isl_take isl_val_list *ptr)
{
ptr = obj.copy();
}
+vec::vec(std::nullptr_t)
+ : ptr(nullptr) {}
vec::vec(__isl_take isl_vec *ptr)