sci-mathematics/4ti2: Fix for gcc-4.7, #422785

(Portage version: 2.2.0_alpha110/cvs/Linux x86_64)

3 files changed, 292 insertions, 3 deletions

diff --git a/sci-mathematics/4ti2/4ti2-1.3.2-r1.ebuild b/sci-mathematics/4ti2/4ti2-1.3.2-r1.ebuild
index dae2a2b3747f..238904e87e41 100644
--- a/sci-mathematics/4ti2/4ti2-1.3.2-r1.ebuild
+++ b/sci-mathematics/4ti2/4ti2-1.3.2-r1.ebuild
@@ -1,6 +1,6 @@
 # Copyright 1999-2012 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
-# $Header: /var/cvsroot/gentoo-x86/sci-mathematics/4ti2/4ti2-1.3.2-r1.ebuild,v 1.5 2012/03/25 18:47:17 grobian Exp $
+# $Header: /var/cvsroot/gentoo-x86/sci-mathematics/4ti2/4ti2-1.3.2-r1.ebuild,v 1.6 2012/06/22 12:39:26 jlec Exp $
 
 EAPI=4
 
@@ -24,7 +24,10 @@ RDEPEND="${DEPEND}"
 
 AUTOTOOLS_IN_SOURCE_BUILD=1
 
-PATCHES=( "${FILESDIR}"/${P}-gold.patch )
+PATCHES=(
+	"${FILESDIR}"/${P}-gold.patch
+	"${FILESDIR}"/${P}-gcc47.patch
+	)
 
 src_prepare() {
 	sed \
diff --git a/sci-mathematics/4ti2/ChangeLog b/sci-mathematics/4ti2/ChangeLog
index 553d76cd4a74..201b29a67b82 100644
--- a/sci-mathematics/4ti2/ChangeLog
+++ b/sci-mathematics/4ti2/ChangeLog
@@ -1,6 +1,10 @@
 # ChangeLog for sci-mathematics/4ti2
 # Copyright 1999-2012 Gentoo Foundation; Distributed under the GPL v2
-# $Header: /var/cvsroot/gentoo-x86/sci-mathematics/4ti2/ChangeLog,v 1.8 2012/03/25 18:47:17 grobian Exp $
+# $Header: /var/cvsroot/gentoo-x86/sci-mathematics/4ti2/ChangeLog,v 1.9 2012/06/22 12:39:26 jlec Exp $
+
+  22 Jun 2012; Justin Lecher <jlec@gentoo.org> 4ti2-1.3.2-r1.ebuild,
+  +files/4ti2-1.3.2-gcc47.patch:
+  Fix for gcc-4.7, #422785
 
   25 Mar 2012; Fabian Groffen <grobian@gentoo.org> 4ti2-1.3.2-r1.ebuild:
   Marked ~x86-macos
diff --git a/sci-mathematics/4ti2/files/4ti2-1.3.2-gcc47.patch b/sci-mathematics/4ti2/files/4ti2-1.3.2-gcc47.patch
new file mode 100644
index 000000000000..f9c8849d9ef3
--- /dev/null
+++ b/sci-mathematics/4ti2/files/4ti2-1.3.2-gcc47.patch
@@ -0,0 +1,282 @@
+ src/groebner/CircuitMatrixAlgorithm.tpp  |   28 +++++++++++-----------
+ src/groebner/CircuitSupportAlgorithm.tpp |   36 +++++++++++++++---------------
+ src/groebner/RayMatrixAlgorithm.tpp      |   14 +++++-----
+ src/groebner/RaySupportAlgorithm.tpp     |   14 +++++-----
+ 4 files changed, 46 insertions(+), 46 deletions(-)
+
+diff --git a/src/groebner/CircuitMatrixAlgorithm.tpp b/src/groebner/CircuitMatrixAlgorithm.tpp
+index 9bb650f..48b2103 100644
+--- a/src/groebner/CircuitMatrixAlgorithm.tpp
++++ b/src/groebner/CircuitMatrixAlgorithm.tpp
+@@ -152,23 +152,23 @@ CircuitMatrixAlgorithm<IndexSet>::compute1(
+         )
+ 
+         // Find the next column.
+-        Index next_col = next_column(vs, remaining);
++        Index next_col = this->next_column(vs, remaining);
+ 
+         int start = 0; int end = vs.get_number(); int middle;
+         // We sort the vectors into nonzeros and then zeros.
+-        sort_nonzeros(vs, start, end, rays, supps, pos_supps, neg_supps, next_col, middle);
++        this->sort_nonzeros(vs, start, end, rays, supps, pos_supps, neg_supps, next_col, middle);
+         int nonzero_start = start, nonzero_end = middle;
+         //int zero_start = middle, zero_end = end;
+         // We sort the nonzeros into rays and circuits.
+-        sort_rays(vs, nonzero_start, nonzero_end, rays, supps, pos_supps, neg_supps, middle);
++        this->sort_rays(vs, nonzero_start, nonzero_end, rays, supps, pos_supps, neg_supps, middle);
+         int ray_start = nonzero_start, ray_end = middle;
+         int cir_start = middle, cir_end = nonzero_end;
+         // We sort the rays into positives and then negatives.
+-        sort_positives(vs, ray_start, ray_end, supps, pos_supps, neg_supps, next_col, middle);
++        this->sort_positives(vs, ray_start, ray_end, supps, pos_supps, neg_supps, next_col, middle);
+         int pos_ray_start = ray_start, pos_ray_end = middle;
+         int neg_ray_start = middle, neg_ray_end = ray_end;
+         // We sort the circuits into positives and then negatives.
+-        sort_positives(vs, cir_start, cir_end, supps, pos_supps, neg_supps, next_col, middle);
++        this->sort_positives(vs, cir_start, cir_end, supps, pos_supps, neg_supps, next_col, middle);
+         int pos_cir_start = cir_start, pos_cir_end = middle;
+         int neg_cir_start = middle, neg_cir_end = cir_end;
+ 
+@@ -185,8 +185,8 @@ CircuitMatrixAlgorithm<IndexSet>::compute1(
+ 
+         // Switch the positive and negative supports, so that it is as if all
+         // vectors have a positive entry in the next column.
+-        switch_supports(neg_ray_start, neg_ray_end, pos_supps, neg_supps);
+-        switch_supports(neg_cir_start, neg_cir_end, pos_supps, neg_supps);
++        this->switch_supports(neg_ray_start, neg_ray_end, pos_supps, neg_supps);
++        this->switch_supports(neg_cir_start, neg_cir_end, pos_supps, neg_supps);
+ 
+         matrix = orig_matrix;
+         int remaining_row = upper_triangle(matrix, remaining, 0);
+@@ -212,15 +212,15 @@ CircuitMatrixAlgorithm<IndexSet>::compute1(
+         rays.insert(rays.end(), vs.get_number()-previous_size, false);
+ 
+         // Switch back the positive and negative supports.
+-        switch_supports(neg_ray_start, neg_ray_end, pos_supps, neg_supps);
+-        switch_supports(neg_cir_start, neg_cir_end, pos_supps, neg_supps);
++        this->switch_supports(neg_ray_start, neg_ray_end, pos_supps, neg_supps);
++        this->switch_supports(neg_cir_start, neg_cir_end, pos_supps, neg_supps);
+ 
+         // Update the supp vectors for the next_col.
+-        update_supports(supps, next_col, nonzero_start, nonzero_end);
+-        update_supports(pos_supps, next_col, pos_ray_start, pos_ray_end);
+-        update_supports(pos_supps, next_col, pos_cir_start, pos_cir_end);
+-        update_supports(neg_supps, next_col, neg_ray_start, neg_ray_end);
+-        update_supports(neg_supps, next_col, neg_cir_start, neg_cir_end);
++        this->update_supports(supps, next_col, nonzero_start, nonzero_end);
++        this->update_supports(pos_supps, next_col, pos_ray_start, pos_ray_end);
++        this->update_supports(pos_supps, next_col, pos_cir_start, pos_cir_end);
++        this->update_supports(neg_supps, next_col, neg_ray_start, neg_ray_end);
++        this->update_supports(neg_supps, next_col, neg_cir_start, neg_cir_end);
+ 
+         *out << "\r";
+         *out << "  Left = " << std::setw(3) << num_remaining;
+diff --git a/src/groebner/CircuitSupportAlgorithm.tpp b/src/groebner/CircuitSupportAlgorithm.tpp
+index 07de9aa..e956417 100644
+--- a/src/groebner/CircuitSupportAlgorithm.tpp
++++ b/src/groebner/CircuitSupportAlgorithm.tpp
+@@ -188,23 +188,23 @@ CircuitSupportAlgorithm<IndexSet>::compute1(
+         )
+  
+         // Find the next column.
+-        Index next_col = next_column(vs, remaining);
++        Index next_col = this->next_column(vs, remaining);
+ 
+         int start = 0; int end = vs.get_number(); int middle;
+         // We sort the vectors into nonzeros and then zeros.
+-        sort_nonzeros(vs, start, end, rays, supps, pos_supps, neg_supps, next_col, middle);
++        this->sort_nonzeros(vs, start, end, rays, supps, pos_supps, neg_supps, next_col, middle);
+         int nonzero_start = start, nonzero_end = middle;
+         //int zero_start = middle, zero_end = end;
+         // We sort the nonzeros into rays and circuits.
+-        sort_rays(vs, nonzero_start, nonzero_end, rays, supps, pos_supps, neg_supps, middle);
++        this->sort_rays(vs, nonzero_start, nonzero_end, rays, supps, pos_supps, neg_supps, middle);
+         int ray_start = nonzero_start, ray_end = middle;
+         int cir_start = middle, cir_end = nonzero_end;
+         // We sort the rays into positives and then negatives.
+-        sort_positives(vs, ray_start, ray_end, supps, pos_supps, neg_supps, next_col, middle);
++        this->sort_positives(vs, ray_start, ray_end, supps, pos_supps, neg_supps, next_col, middle);
+         int pos_ray_start = ray_start, pos_ray_end = middle;
+         int neg_ray_start = middle, neg_ray_end = ray_end;
+         // We sort the circuits into positives and the negatives.
+-        sort_positives(vs, cir_start, cir_end, supps, pos_supps, neg_supps, next_col, middle);
++        this->sort_positives(vs, cir_start, cir_end, supps, pos_supps, neg_supps, next_col, middle);
+         int pos_cir_start = cir_start, pos_cir_end = middle;
+         int neg_cir_start = middle, neg_cir_end = cir_end;
+ 
+@@ -233,8 +233,8 @@ CircuitSupportAlgorithm<IndexSet>::compute1(
+ 
+         // Switch the positive and negative supports, so that it is as if all
+         // vectors have a positive entry in the next column.
+-        switch_supports(neg_ray_start, neg_ray_end, pos_supps, neg_supps);
+-        switch_supports(neg_cir_start, neg_cir_end, pos_supps, neg_supps);
++        this->switch_supports(neg_ray_start, neg_ray_end, pos_supps, neg_supps);
++        this->switch_supports(neg_cir_start, neg_cir_end, pos_supps, neg_supps);
+ 
+         //DEBUG_4ti2(*out << "Remaining row " << remaining_row << "\n";)
+         int previous_size = vs.get_number();
+@@ -258,19 +258,19 @@ CircuitSupportAlgorithm<IndexSet>::compute1(
+         rays.insert(rays.end(), vs.get_number()-previous_size, false);
+ 
+         // Switch back the positive and negative supports.
+-        switch_supports(neg_ray_start, neg_ray_end, pos_supps, neg_supps);
+-        switch_supports(neg_cir_start, neg_cir_end, pos_supps, neg_supps);
++        this->switch_supports(neg_ray_start, neg_ray_end, pos_supps, neg_supps);
++        this->switch_supports(neg_cir_start, neg_cir_end, pos_supps, neg_supps);
+ 
+         // Update the supp vectors for the next_col.
+-        update_supports(supps, next_col, nonzero_start, nonzero_end);
+-        update_supports(pos_supps, next_col, pos_ray_start, pos_ray_end);
+-        update_supports(pos_supps, next_col, pos_cir_start, pos_cir_end);
+-        update_supports(pos_supps, col_map[next_col], neg_ray_start, neg_ray_end);
+-        update_supports(pos_supps, col_map[next_col], neg_cir_start, neg_cir_end);
+-        update_supports(neg_supps, next_col, neg_ray_start, neg_ray_end);
+-        update_supports(neg_supps, next_col, neg_cir_start, neg_cir_end);
+-        update_supports(neg_supps, col_map[next_col], pos_ray_start, pos_ray_end);
+-        update_supports(neg_supps, col_map[next_col], pos_cir_start, pos_cir_end);
++        this->update_supports(supps, next_col, nonzero_start, nonzero_end);
++        this->update_supports(pos_supps, next_col, pos_ray_start, pos_ray_end);
++        this->update_supports(pos_supps, next_col, pos_cir_start, pos_cir_end);
++        this->update_supports(pos_supps, col_map[next_col], neg_ray_start, neg_ray_end);
++        this->update_supports(pos_supps, col_map[next_col], neg_cir_start, neg_cir_end);
++        this->update_supports(neg_supps, next_col, neg_ray_start, neg_ray_end);
++        this->update_supports(neg_supps, next_col, neg_cir_start, neg_cir_end);
++        this->update_supports(neg_supps, col_map[next_col], pos_ray_start, pos_ray_end);
++        this->update_supports(neg_supps, col_map[next_col], pos_cir_start, pos_cir_end);
+ 
+         *out << "\r";
+         *out << "  Left = " << std::setw(3) << num_remaining;
+diff --git a/src/groebner/RayMatrixAlgorithm.tpp b/src/groebner/RayMatrixAlgorithm.tpp
+index 346248e..75c202a 100644
+--- a/src/groebner/RayMatrixAlgorithm.tpp
++++ b/src/groebner/RayMatrixAlgorithm.tpp
+@@ -865,7 +865,7 @@ RayMatrixAlgorithm<IndexSet>::compute3(
+         DEBUG_4ti2(unsigned long long int num_checks = 0;)
+         // Find the next column.
+         int next_positive_count, next_negative_count, next_zero_count;
+-        Index next_col = next_column(vs, remaining,
++        Index next_col = this->next_column(vs, remaining,
+                                         next_positive_count,
+                                         next_negative_count,
+                                         next_zero_count);
+@@ -880,7 +880,7 @@ RayMatrixAlgorithm<IndexSet>::compute3(
+         )
+ 
+         // We sort the vectors into zeros, positives, then negatives.
+-        sort(vs, supports, next_col, next_zero_count, next_positive_count,
++        RayImplementation<IndexSet>::sort(vs, supports, next_col, next_zero_count, next_positive_count,
+                         next_negative_count);
+ 
+         DEBUG_4ti2(*out << "Rays:\n" << vs << "\n";)
+@@ -944,7 +944,7 @@ RayMatrixAlgorithm<IndexSet>::compute3(
+                     IndexSet::set_difference(supports[r2], r1_supp, temp_diff);
+                     if (temp_diff.power_of_2())
+                     {
+-                        create_new_vector(vs, supports, r1, r2, next_col,
++                        this->create_new_vector(vs, supports, r1, r2, next_col,
+                                             next_positive_count, next_negative_count,
+                                             temp, temp_supp);
+                         DEBUG_4ti2(++num_one_diff_added;)
+@@ -959,7 +959,7 @@ RayMatrixAlgorithm<IndexSet>::compute3(
+                     IndexSet::set_difference(r1_supp, supports[r2], temp_diff);
+                     if (temp_diff.power_of_2())
+                     {
+-                        create_new_vector(vs, supports, r1, r2, next_col,
++                        this->create_new_vector(vs, supports, r1, r2, next_col,
+                                             next_positive_count, next_negative_count,
+                                             temp, temp_supp);
+                         DEBUG_4ti2(++num_one_diff_added;)
+@@ -984,7 +984,7 @@ RayMatrixAlgorithm<IndexSet>::compute3(
+                             IndexSet::set_difference(r1_supp, supports[r2], temp_diff2);
+                             if (temp_diff2.power_of_2())
+                             {
+-                                create_new_vector(vs, supports, r1, r2, next_col,
++                                this->create_new_vector(vs, supports, r1, r2, next_col,
+                                     next_positive_count, next_negative_count,
+                                     temp, temp_supp);
+                                 DEBUG_4ti2(++num_one_diff_added;)
+@@ -996,7 +996,7 @@ RayMatrixAlgorithm<IndexSet>::compute3(
+                             DEBUG_4ti2(++num_checks;)
+                             if (rank_check(matrix, temp_matrix, temp_diff, r1_rows))
+                             {
+-                                create_new_vector(vs, supports, r1, r2, next_col,
++                                this->create_new_vector(vs, supports, r1, r2, next_col,
+                                                 next_positive_count, next_negative_count,
+                                                 temp, temp_supp);
+                                 DEBUG_4ti2(++num_added;)
+@@ -1012,7 +1012,7 @@ RayMatrixAlgorithm<IndexSet>::compute3(
+                         IndexSet::set_difference(supports[r2], r1_supp, temp_diff);
+                         if (temp_diff.power_of_2())
+                         {
+-                            create_new_vector(vs, supports, r1, r2, next_col,
++                            this->create_new_vector(vs, supports, r1, r2, next_col,
+                                 next_positive_count, next_negative_count,
+                                 temp, temp_supp);
+                             DEBUG_4ti2(++num_one_diff_added;)
+diff --git a/src/groebner/RaySupportAlgorithm.tpp b/src/groebner/RaySupportAlgorithm.tpp
+index 0b31647..2b17957 100644
+--- a/src/groebner/RaySupportAlgorithm.tpp
++++ b/src/groebner/RaySupportAlgorithm.tpp
+@@ -773,7 +773,7 @@ RaySupportAlgorithm<IndexSet>::compute3(
+ 
+         // Find the next column.
+         int next_positive_count, next_negative_count, next_zero_count;
+-        Index next_col = next_column(vs, remaining,
++        Index next_col = this->next_column(vs, remaining,
+                                         next_positive_count,
+                                         next_negative_count,
+                                         next_zero_count);
+@@ -788,7 +788,7 @@ RaySupportAlgorithm<IndexSet>::compute3(
+         )
+ 
+         // We sort the vectors into zeros, positives, then negatives.
+-        sort(vs, supports, next_col, next_zero_count, next_positive_count,
++        RayImplementation<IndexSet>::sort(vs, supports, next_col, next_zero_count, next_positive_count,
+                         next_negative_count);
+ 
+         int original_size = vs.get_number();
+@@ -852,7 +852,7 @@ RaySupportAlgorithm<IndexSet>::compute3(
+                     IndexSet::set_difference(supports[r2], r1_supp, temp_diff);
+                     if (temp_diff.power_of_2())
+                     {
+-                        create_new_vector(vs, supports, r1, r2, next_col,
++                        this->create_new_vector(vs, supports, r1, r2, next_col,
+                                             next_positive_count, next_negative_count,
+                                             temp, temp_supp);
+                         DEBUG_4ti2(++num_added;)
+@@ -866,7 +866,7 @@ RaySupportAlgorithm<IndexSet>::compute3(
+                     IndexSet::set_difference(r1_supp, supports[r2], temp_diff);
+                     if (temp_diff.power_of_2())
+                     {
+-                        create_new_vector(vs, supports, r1, r2, next_col,
++                        this->create_new_vector(vs, supports, r1, r2, next_col,
+                                             next_positive_count, next_negative_count,
+                                             temp, temp_supp);
+                         DEBUG_4ti2(++num_one_diff_added;)
+@@ -885,7 +885,7 @@ RaySupportAlgorithm<IndexSet>::compute3(
+                     zero_supp.set_union(supports[index]);
+                     if (index >= r2_index && index < r2_finish)
+                     {
+-                        create_new_vector(vs, supports, r1, index, next_col,
++                        this->create_new_vector(vs, supports, r1, index, next_col,
+                             next_positive_count, next_negative_count,
+                             temp, temp_supp);
+                         DEBUG_4ti2(++num_added;)
+@@ -905,7 +905,7 @@ RaySupportAlgorithm<IndexSet>::compute3(
+                         IndexSet::set_difference(r1_supp, supports[r2], temp_diff2);
+                         if (temp_diff2.power_of_2())
+                         {
+-                            create_new_vector(vs, supports, r1, r2, next_col,
++                            this->create_new_vector(vs, supports, r1, r2, next_col,
+                                     next_positive_count, next_negative_count,
+                                     temp, temp_supp);
+                             DEBUG_4ti2(++num_one_diff_added;)
+@@ -918,7 +918,7 @@ RaySupportAlgorithm<IndexSet>::compute3(
+                         DEBUG_4ti2(++num_checks;)
+                         if (!tree.dominated(temp_supp, r1, r2))
+                         {
+-                            create_new_vector(vs, supports, r1, r2, next_col,
++                            this->create_new_vector(vs, supports, r1, r2, next_col,
+                                             next_positive_count, next_negative_count,
+                                             temp, temp_supp);
+                             DEBUG_4ti2(++num_added;)