diff --git a/isl-0.14.tar.xz b/isl-0.14.tar.xz new file mode 100644 index 0000000..823478e Binary files /dev/null and b/isl-0.14.tar.xz differ diff --git a/isl-0.16.1.tar.xz b/isl-0.16.1.tar.xz new file mode 100644 index 0000000..92e76e6 Binary files /dev/null and b/isl-0.16.1.tar.xz differ diff --git a/isl.spec b/isl.spec new file mode 100644 index 0000000..20601b8 --- /dev/null +++ b/isl.spec @@ -0,0 +1,116 @@ +Summary: Integer point manipulation library +Name: isl +Version: 0.16.1 +License: MIT +URL: http://isl.gforge.inria.fr/ + +%global libmajor 15 +%global libversion %{libmajor}.1.1 + +%global oldversion 0.14 +%global oldlibmajor 13 +%global oldlibversion %{oldlibmajor}.1.0 + +# Please set buildid below when building a private version of this rpm to +# differentiate it from the stock rpm. +# +# % global buildid .local + +Release: 10%{?buildid}%{?dist} + +BuildRequires: gcc +BuildRequires: gmp-devel +BuildRequires: pkgconfig +Provides: isl = %{oldversion} + +Source0: http://isl.gforge.inria.fr/isl-%{version}.tar.xz + +# Current gcc requires exactly 0.14 +Source1: http://isl.gforge.inria.fr/isl-%{oldversion}.tar.xz + +# update python2 src file to python3 +Patch0: python3.patch + +%description +isl is a library for manipulating sets and relations of integer points +bounded by linear constraints. Supported operations on sets include +intersection, union, set difference, emptiness check, convex hull, +(integer) affine hull, integer projection, computing the lexicographic +minimum using parametric integer programming, coalescing and parametric +vertex enumeration. It also includes an ILP solver based on generalized +basis reduction, transitive closures on maps (which may encode infinite +graphs), dependence analysis and bounds on piecewise step-polynomials. + +%package devel +Summary: Development for building integer point manipulation library +Requires: isl%{?_isa} == %{version}-%{release} +Requires: gmp-devel%{?_isa} + +%description devel +isl is a library for manipulating sets and relations of integer points +bounded by linear constraints. Supported operations on sets include +intersection, union, set difference, emptiness check, convex hull, +(integer) affine hull, integer projection, computing the lexicographic +minimum using parametric integer programming, coalescing and parametric +vertex enumeration. It also includes an ILP solver based on generalized +basis reduction, transitive closures on maps (which may encode infinite +graphs), dependence analysis and bounds on piecewise step-polynomials. + +%prep +%global docdir isl-%{version} +%setup -a 1 -q -n isl -c +%patch0 -p1 + +%build +cd isl-%{oldversion} +%configure +make %{?_smp_mflags} V=1 +cd .. + +cd isl-%{version} +%configure +make %{?_smp_mflags} V=1 + +%install +cd isl-%{oldversion} +%make_install INSTALL="install -p" install-libLTLIBRARIES +cd .. + +cd isl-%{version} +%make_install INSTALL="install -p" +rm -f %{buildroot}/%{_libdir}/libisl.a +rm -f %{buildroot}/%{_libdir}/libisl.la +mkdir -p %{buildroot}/%{_datadir} +%global gdbprettydir %{_datadir}/gdb/auto-load/%{_libdir} +mkdir -p %{buildroot}/%{gdbprettydir} +mv %{buildroot}/%{_libdir}/*-gdb.py* %{buildroot}/%{gdbprettydir} + +%check +cd isl-%{oldversion} +#make check +cd .. + +cd isl-%{version} +#make check + +%ldconfig_scriptlets + +%files +%{_libdir}/libisl.so.%{libmajor} +%{_libdir}/libisl.so.%{libversion} +%{_libdir}/libisl.so.%{oldlibmajor} +%{_libdir}/libisl.so.%{oldlibversion} +%{gdbprettydir}/* +%license %{docdir}/LICENSE +%doc %{docdir}/AUTHORS %{docdir}/ChangeLog %{docdir}/README + +%files devel +%{_includedir}/* +%{_libdir}/libisl.so +%{_libdir}/pkgconfig/isl.pc +%doc %{docdir}/doc/manual.pdf + + +%changelog +* Sat Oct 10 2020 Zhiyi Weng - 0.16.1-10 +- Initial version. diff --git a/python3.patch b/python3.patch new file mode 100644 index 0000000..f030316 --- /dev/null +++ b/python3.patch @@ -0,0 +1,210 @@ +diff --git a/isl-0.14/isl.py b/isl-0.14/isl.py +index 6382f63..9b76f42 100644 +--- a/isl-0.14/isl.py ++++ b/isl-0.14/isl.py +@@ -64,10 +64,10 @@ class IslPrintCommand (gdb.Command): + printer = str_lookup_function(arg) + + if printer == None: +- print "No isl printer for this type" ++ print("No isl printer for this type") + return + +- print printer.to_string() ++ print(printer.to_string()) + + IslPrintCommand() + +diff --git a/isl-0.16.1/isl.py b/isl-0.16.1/isl.py +index 6382f63..9b76f42 100644 +--- a/isl-0.16.1/isl.py ++++ b/isl-0.16.1/isl.py +@@ -64,10 +64,10 @@ class IslPrintCommand (gdb.Command): + printer = str_lookup_function(arg) + + if printer == None: +- print "No isl printer for this type" ++ print("No isl printer for this type") + return + +- print printer.to_string() ++ print(printer.to_string()) + + IslPrintCommand() + +diff --git a/isl-0.14/isl.py b/isl-0.14/isl.py +index 9b76f42..06236ef 100644 +--- a/isl-0.14/isl.py ++++ b/isl-0.14/isl.py +@@ -3,19 +3,19 @@ import re + + # GDB Pretty Printers for most isl objects + class IslObjectPrinter: +- """Print an isl object""" +- def __init__ (self, val, type): ++ """Print an isl object""" ++ def __init__ (self, val, type): + self.val = val + self.type = type + +- def to_string (self): ++ def to_string (self): + # Cast val to a void pointer to stop gdb using this pretty + # printer for the pointer which would lead to an infinite loop. + void_ptr = gdb.lookup_type('void').pointer() + value = str(self.val.cast(void_ptr)) + printer = gdb.parse_and_eval("isl_printer_to_str(isl_" + + str(self.type) +- + "_get_ctx(" + value + "))") ++ + "_get_ctx(" + value + "))") + printer = gdb.parse_and_eval("isl_printer_print_" + + str(self.type) + "(" + + str(printer) + ", " +@@ -25,15 +25,15 @@ class IslObjectPrinter: + gdb.parse_and_eval("isl_printer_free(" + str(printer) + ")") + return string + +- def display_hint (self): ++ def display_hint (self): + return 'string' + + class IslIntPrinter: +- """Print an isl_int """ +- def __init__ (self, val): ++ """Print an isl_int """ ++ def __init__ (self, val): + self.val = val + +- def to_string (self): ++ def to_string (self): + # Cast val to a void pointer to stop gdb using this pretty + # printer for the pointer which would lead to an infinite loop. + void_ptr = gdb.lookup_type('void').pointer() +@@ -51,7 +51,7 @@ class IslIntPrinter: + gdb.parse_and_eval("isl_ctx_free(" + str(context) + ")") + return string + +- def display_hint (self): ++ def display_hint (self): + return 'string' + + class IslPrintCommand (gdb.Command): +@@ -72,21 +72,21 @@ class IslPrintCommand (gdb.Command): + IslPrintCommand() + + def str_lookup_function (val): +- if val.type.code != gdb.TYPE_CODE_PTR: +- if str(val.type) == "isl_int": +- return IslIntPrinter(val) ++ if val.type.code != gdb.TYPE_CODE_PTR: ++ if str(val.type) == "isl_int": ++ return IslIntPrinter(val) + else: + return None + +- lookup_tag = val.type.target() +- regex = re.compile ("^isl_(.*)$") ++ lookup_tag = val.type.target() ++ regex = re.compile ("^isl_(.*)$") + +- if lookup_tag == None: +- return None ++ if lookup_tag == None: ++ return None + +- m = regex.match (str(lookup_tag)) ++ m = regex.match (str(lookup_tag)) + +- if m: ++ if m: + # Those types of printers defined in isl. + if m.group(1) in ["basic_set", "set", "union_set", "basic_map", + "map", "union_map", "qpolynomial", +diff --git a/isl-0.16.1/isl.py b/isl-0.16.1/isl.py +index 9b76f42..06236ef 100644 +--- a/isl-0.16.1/isl.py ++++ b/isl-0.16.1/isl.py +@@ -3,19 +3,19 @@ import re + + # GDB Pretty Printers for most isl objects + class IslObjectPrinter: +- """Print an isl object""" +- def __init__ (self, val, type): ++ """Print an isl object""" ++ def __init__ (self, val, type): + self.val = val + self.type = type + +- def to_string (self): ++ def to_string (self): + # Cast val to a void pointer to stop gdb using this pretty + # printer for the pointer which would lead to an infinite loop. + void_ptr = gdb.lookup_type('void').pointer() + value = str(self.val.cast(void_ptr)) + printer = gdb.parse_and_eval("isl_printer_to_str(isl_" + + str(self.type) +- + "_get_ctx(" + value + "))") ++ + "_get_ctx(" + value + "))") + printer = gdb.parse_and_eval("isl_printer_print_" + + str(self.type) + "(" + + str(printer) + ", " +@@ -25,15 +25,15 @@ class IslObjectPrinter: + gdb.parse_and_eval("isl_printer_free(" + str(printer) + ")") + return string + +- def display_hint (self): ++ def display_hint (self): + return 'string' + + class IslIntPrinter: +- """Print an isl_int """ +- def __init__ (self, val): ++ """Print an isl_int """ ++ def __init__ (self, val): + self.val = val + +- def to_string (self): ++ def to_string (self): + # Cast val to a void pointer to stop gdb using this pretty + # printer for the pointer which would lead to an infinite loop. + void_ptr = gdb.lookup_type('void').pointer() +@@ -51,7 +51,7 @@ class IslIntPrinter: + gdb.parse_and_eval("isl_ctx_free(" + str(context) + ")") + return string + +- def display_hint (self): ++ def display_hint (self): + return 'string' + + class IslPrintCommand (gdb.Command): +@@ -72,21 +72,21 @@ class IslPrintCommand (gdb.Command): + IslPrintCommand() + + def str_lookup_function (val): +- if val.type.code != gdb.TYPE_CODE_PTR: +- if str(val.type) == "isl_int": +- return IslIntPrinter(val) ++ if val.type.code != gdb.TYPE_CODE_PTR: ++ if str(val.type) == "isl_int": ++ return IslIntPrinter(val) + else: + return None + +- lookup_tag = val.type.target() +- regex = re.compile ("^isl_(.*)$") ++ lookup_tag = val.type.target() ++ regex = re.compile ("^isl_(.*)$") + +- if lookup_tag == None: +- return None ++ if lookup_tag == None: ++ return None + +- m = regex.match (str(lookup_tag)) ++ m = regex.match (str(lookup_tag)) + +- if m: ++ if m: + # Those types of printers defined in isl. + if m.group(1) in ["basic_set", "set", "union_set", "basic_map", + "map", "union_map", "qpolynomial",