* fixed some mindboggling tremendous superhuge gigantic #*@$&! memory leaks.
authorRichard Kreckel <Richard.Kreckel@uni-mainz.de>
Thu, 19 Apr 2001 00:41:18 +0000 (00:41 +0000)
committerRichard Kreckel <Richard.Kreckel@uni-mainz.de>
Thu, 19 Apr 2001 00:41:18 +0000 (00:41 +0000)
ginac/normal.cpp
ginac/structure.pl

index 9c9082acc3c87251a4d66edb05245509d66382c3..369e2c656449ff296385397b1bce19c1b1b356af 100644 (file)
@@ -386,7 +386,7 @@ ex quo(const ex &a, const ex &b, const symbol &x, bool check_args)
                        term = rcoeff / blcoeff;
                else {
                        if (!divide(rcoeff, blcoeff, term, false))
                        term = rcoeff / blcoeff;
                else {
                        if (!divide(rcoeff, blcoeff, term, false))
-                               return *new ex(fail());
+                               return (new fail())->setflag(status_flags::dynallocated);
                }
                term *= power(x, rdeg - bdeg);
                q += term;
                }
                term *= power(x, rdeg - bdeg);
                q += term;
@@ -439,7 +439,7 @@ ex rem(const ex &a, const ex &b, const symbol &x, bool check_args)
                        term = rcoeff / blcoeff;
                else {
                        if (!divide(rcoeff, blcoeff, term, false))
                        term = rcoeff / blcoeff;
                else {
                        if (!divide(rcoeff, blcoeff, term, false))
-                               return *new ex(fail());
+                               return (new fail())->setflag(status_flags::dynallocated);
                }
                term *= power(x, rdeg - bdeg);
                r -= (term * b).expand();
                }
                term *= power(x, rdeg - bdeg);
                r -= (term * b).expand();
@@ -1283,7 +1283,7 @@ ex mul::smod(const numeric &xi) const
                it++;
        }
 #endif // def DO_GINAC_ASSERT
                it++;
        }
 #endif // def DO_GINAC_ASSERT
-       mul * mulcopyp=new mul(*this);
+       mul * mulcopyp = new mul(*this);
        GINAC_ASSERT(is_ex_exactly_of_type(overall_coeff,numeric));
        mulcopyp->overall_coeff = GiNaC::smod(ex_to_numeric(overall_coeff),xi);
        mulcopyp->clearflag(status_flags::evaluated);
        GINAC_ASSERT(is_ex_exactly_of_type(overall_coeff,numeric));
        mulcopyp->overall_coeff = GiNaC::smod(ex_to_numeric(overall_coeff),xi);
        mulcopyp->clearflag(status_flags::evaluated);
@@ -1333,7 +1333,7 @@ static ex heur_gcd(const ex &a, const ex &b, ex *ca, ex *cb, sym_desc_vec::const
 
        // Algorithms only works for non-vanishing input polynomials
        if (a.is_zero() || b.is_zero())
 
        // Algorithms only works for non-vanishing input polynomials
        if (a.is_zero() || b.is_zero())
-               return *new ex(fail());
+               return (new fail())->setflag(status_flags::dynallocated);
 
        // GCD of two numeric values -> CLN
        if (is_ex_exactly_of_type(a, numeric) && is_ex_exactly_of_type(b, numeric)) {
 
        // GCD of two numeric values -> CLN
        if (is_ex_exactly_of_type(a, numeric) && is_ex_exactly_of_type(b, numeric)) {
@@ -1367,7 +1367,7 @@ static ex heur_gcd(const ex &a, const ex &b, ex *ca, ex *cb, sym_desc_vec::const
        // 6 tries maximum
        for (int t=0; t<6; t++) {
                if (xi.int_length() * maxdeg > 100000) {
        // 6 tries maximum
        for (int t=0; t<6; t++) {
                if (xi.int_length() * maxdeg > 100000) {
-//std::clog << "giving up heur_gcd, xi.int_length = " << xi.int_length() << ", maxdeg = " << maxdeg << endl;
+//std::clog << "giving up heur_gcd, xi.int_length = " << xi.int_length() << ", maxdeg = " << maxdeg << std::endl;
                        throw gcdheu_failed();
                }
 
                        throw gcdheu_failed();
                }
 
@@ -1425,7 +1425,7 @@ static ex heur_gcd(const ex &a, const ex &b, ex *ca, ex *cb, sym_desc_vec::const
                // Next evaluation point
                xi = iquo(xi * isqrt(isqrt(xi)) * numeric(73794), numeric(27011));
        }
                // Next evaluation point
                xi = iquo(xi * isqrt(isqrt(xi)) * numeric(73794), numeric(27011));
        }
-       return *new ex(fail());
+       return (new fail())->setflag(status_flags::dynallocated);
 }
 
 
 }
 
 
@@ -1599,20 +1599,20 @@ factored_b:
        int min_ldeg = std::min(ldeg_a,ldeg_b);
        if (min_ldeg > 0) {
                ex common = power(x, min_ldeg);
        int min_ldeg = std::min(ldeg_a,ldeg_b);
        if (min_ldeg > 0) {
                ex common = power(x, min_ldeg);
-//std::clog << "trivial common factor " << common << endl;
+//std::clog << "trivial common factor " << common << std::endl;
                return gcd((aex / common).expand(), (bex / common).expand(), ca, cb, false) * common;
        }
 
        // Try to eliminate variables
        if (var->deg_a == 0) {
                return gcd((aex / common).expand(), (bex / common).expand(), ca, cb, false) * common;
        }
 
        // Try to eliminate variables
        if (var->deg_a == 0) {
-//std::clog << "eliminating variable " << x << " from b" << endl;
+//std::clog << "eliminating variable " << x << " from b" << std::endl;
                ex c = bex.content(x);
                ex g = gcd(aex, c, ca, cb, false);
                if (cb)
                        *cb *= bex.unit(x) * bex.primpart(x, c);
                return g;
        } else if (var->deg_b == 0) {
                ex c = bex.content(x);
                ex g = gcd(aex, c, ca, cb, false);
                if (cb)
                        *cb *= bex.unit(x) * bex.primpart(x, c);
                return g;
        } else if (var->deg_b == 0) {
-//std::clog << "eliminating variable " << x << " from a" << endl;
+//std::clog << "eliminating variable " << x << " from a" << std::endl;
                ex c = aex.content(x);
                ex g = gcd(c, bex, ca, cb, false);
                if (ca)
                ex c = aex.content(x);
                ex g = gcd(c, bex, ca, cb, false);
                if (ca)
@@ -1626,10 +1626,10 @@ factored_b:
        try {
                g = heur_gcd(aex, bex, ca, cb, var);
        } catch (gcdheu_failed) {
        try {
                g = heur_gcd(aex, bex, ca, cb, var);
        } catch (gcdheu_failed) {
-               g = *new ex(fail());
+               g = fail();
        }
        if (is_ex_exactly_of_type(g, fail)) {
        }
        if (is_ex_exactly_of_type(g, fail)) {
-//std::clog << "heuristics failed" << endl;
+//std::clog << "heuristics failed" << std::endl;
 #if STATISTICS
                heur_gcd_failed++;
 #endif
 #if STATISTICS
                heur_gcd_failed++;
 #endif
@@ -1877,7 +1877,7 @@ static ex frac_cancel(const ex &n, const ex &d)
        ex den = d;
        numeric pre_factor = _num1();
 
        ex den = d;
        numeric pre_factor = _num1();
 
-//std::clog << "frac_cancel num = " << num << ", den = " << den << endl;
+//std::clog << "frac_cancel num = " << num << ", den = " << den << std::endl;
 
        // Handle trivial case where denominator is 1
        if (den.is_equal(_ex1()))
 
        // Handle trivial case where denominator is 1
        if (den.is_equal(_ex1()))
@@ -1916,7 +1916,7 @@ static ex frac_cancel(const ex &n, const ex &d)
        }
 
        // Return result as list
        }
 
        // Return result as list
-//std::clog << " returns num = " << num << ", den = " << den << ", pre_factor = " << pre_factor << endl;
+//std::clog << " returns num = " << num << ", den = " << den << ", pre_factor = " << pre_factor << std::endl;
        return (new lst(num * pre_factor.numer(), den * pre_factor.denom()))->setflag(status_flags::dynallocated);
 }
 
        return (new lst(num * pre_factor.numer(), den * pre_factor.denom()))->setflag(status_flags::dynallocated);
 }
 
@@ -1954,10 +1954,10 @@ ex add::normal(lst &sym_lst, lst &repl_lst, int level) const
        // Add fractions sequentially
        exvector::const_iterator num_it = nums.begin(), num_itend = nums.end();
        exvector::const_iterator den_it = dens.begin(), den_itend = dens.end();
        // Add fractions sequentially
        exvector::const_iterator num_it = nums.begin(), num_itend = nums.end();
        exvector::const_iterator den_it = dens.begin(), den_itend = dens.end();
-//std::clog << " num = " << *num_it << ", den = " << *den_it << endl;
+//std::clog << " num = " << *num_it << ", den = " << *den_it << std::endl;
        ex num = *num_it++, den = *den_it++;
        while (num_it != num_itend) {
        ex num = *num_it++, den = *den_it++;
        while (num_it != num_itend) {
-//std::clog << " num = " << *num_it << ", den = " << *den_it << endl;
+//std::clog << " num = " << *num_it << ", den = " << *den_it << std::endl;
                ex next_num = *num_it++, next_den = *den_it++;
 
                // Trivially add sequences of fractions with identical denominators
                ex next_num = *num_it++, next_den = *den_it++;
 
                // Trivially add sequences of fractions with identical denominators
@@ -1973,7 +1973,7 @@ ex add::normal(lst &sym_lst, lst &repl_lst, int level) const
                num = ((num * co_den2) + (next_num * co_den1)).expand();
                den *= co_den2;         // this is the lcm(den, next_den)
        }
                num = ((num * co_den2) + (next_num * co_den1)).expand();
                den *= co_den2;         // this is the lcm(den, next_den)
        }
-//std::clog << " common denominator = " << den << endl;
+//std::clog << " common denominator = " << den << std::endl;
 
        // Cancel common factors from num/den
        return frac_cancel(num, den);
 
        // Cancel common factors from num/den
        return frac_cancel(num, den);
index 1455825c1ecc598097dfcf275f3213173d933d55..901c5722d11da5b2f459d2d83c83a0cc3cc35b47 100755 (executable)
@@ -249,6 +249,7 @@ $implementation=<<END_OF_IMPLEMENTATION;
 ${input_structure}
 
 #include <iostream>
 ${input_structure}
 
 #include <iostream>
+#include <stdexcept>
 
 #include "${STRUCTURE}.h"
 #include "print.h"
 
 #include "${STRUCTURE}.h"
 #include "print.h"
@@ -346,8 +347,7 @@ ex & ${STRUCTURE}::let_op(int i)
        switch (i) {
 ${let_op_statements}
        }
        switch (i) {
 ${let_op_statements}
        }
-       errormsg("${STRUCTURE}::let_op(): should not reach this point");
-       return *new ex(fail());
+       throw(std::runtime_error("${STRUCTURE}::let_op(): should not have reached this point"));
 }
 
 ex ${STRUCTURE}::expand(unsigned options) const
 }
 
 ex ${STRUCTURE}::expand(unsigned options) const