From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- gcc/testsuite/g++.old-deja/g++.law/code-gen5.C | 287 +++++++++++++++++++++++++ 1 file changed, 287 insertions(+) create mode 100644 gcc/testsuite/g++.old-deja/g++.law/code-gen5.C (limited to 'gcc/testsuite/g++.old-deja/g++.law/code-gen5.C') diff --git a/gcc/testsuite/g++.old-deja/g++.law/code-gen5.C b/gcc/testsuite/g++.old-deja/g++.law/code-gen5.C new file mode 100644 index 000000000..0a992d0b9 --- /dev/null +++ b/gcc/testsuite/g++.old-deja/g++.law/code-gen5.C @@ -0,0 +1,287 @@ +// { dg-do run } +// GROUPS passed code-generation +// code-gen file +// From: "David" +// Date: Mon, 15 Nov 1993 20:59:14 -0600 (CST) +// Subject: An error! +// Message-ID: <9311160259.AA03353@pi14.arc.umn.edu> + +#include +#include +#include +#include +#include +#include + +#define ANSI_C + +typedef double VEC ; + +class Vector; + +class VectorInt +{ + public: + + /* Nothing public!! Only Vector can use this class */ + + private: + + VectorInt( int ); + VectorInt( int, double *, int = 0 ); + VectorInt( const VectorInt & ); + ~VectorInt(); + + VectorInt *refer(); + void unrefer(); + int count; /* Number of Vector's referring to me */ + + VEC *vec; + + friend class Vector; + friend class VecElem; +}; + +class VecElem +{ + public: + + operator double(); + double operator=( double ); + + private: + + VecElem( Vector &, int ); + VecElem( const VecElem & ); + + Vector &v; + int row; /* Row element refers to */ + + friend class Vector; +}; + +class Vector +{ + public: + + Vector(); // Must be assigned to before used + Vector( VectorInt * ); + Vector( int ); + Vector( int, double *, int beg = 0 ); + Vector( const Vector & ); + Vector &operator=( const Vector & ); + ~Vector() { if(r) r->unrefer(); } + + int row() const { return 19; } + int dim() const { return 10; } + + double operator()( int ) const; + VecElem operator()( int ); + + double assign( int, double ); + + friend std::ostream& operator<<(std::ostream&, const Vector& m ); + + private: + + VectorInt *r; /* Reference to real data */ + + friend class VecElem; + friend class LUDecom; + friend class SVD; +}; + + +Vector:: +Vector() + : r(0) +{} + +Vector:: +Vector( VectorInt *vi ) + : r(vi) +{ + r->refer(); +} + +Vector:: +Vector( int row ) +{ + assert( row > 0 ); + + r = new VectorInt( row ); + + r->refer(); +} + +Vector:: +Vector( int row, double *d, int beg ) +{ + assert( row > 0 ); + + r = new VectorInt( row, d, beg ); + + r->refer(); +} + +Vector:: +Vector( const Vector &A ) + : r( A.r->refer() ) +{} + +Vector& Vector:: +operator=( const Vector &A ) +{ + if( r ) + r->unrefer(); + + r = A.r->refer(); + + return *this; +} + +double Vector:: +operator()( int row ) const +{ + assert(r != 0); + + return *r->vec; +} + +VecElem Vector:: +operator()( int r ) +{ + assert(r != 0); + + return VecElem( *this, r ); +} + + /* assign changes the matrix, it does not create a new one! */ +double Vector:: +assign( int rownum, double d ) +{ + assert(r != 0); + + if( rownum > row() || rownum <= 0 ) { + std::cerr << "Warning: trying to assign out of bounds" << std::endl; + std::cerr << "row " << rownum << std::endl; + std::cerr << "Vector size " << row() << std::endl; + std::abort(); + } + + if( r->count == 1 ) { + /* Don't need to create a new matrix, since we are the only */ + /* one pointing to ours */ + } + else { + VectorInt *vi = new VectorInt( *r ); + r->unrefer(); + r = vi->refer(); + } + + return d; +} + + +VectorInt:: +VectorInt( int sx ) + : vec( new double[sx] ), count(0) +{ } + +VectorInt:: +VectorInt( int sx, double *, int ) + : vec( new double[sx] ), count(0) +{ +} + +VectorInt:: +VectorInt( const VectorInt & ) + : vec( new double[10] ), count(0) +{ +} + +VectorInt * VectorInt:: +refer() +{ + count ++; + return this; + + // cout << "Refering vec" << endl; +} + +void VectorInt:: +unrefer() +{ + count--; + + if( count == 0 ) { + delete this; + } + + // cout << "Unrefering vec" << endl; +} + +VectorInt:: +~VectorInt() +{ + delete vec; + vec = 0; +} + +VecElem:: +VecElem( Vector &vec, int r ) + : v(vec), row(r) +{ + if( r < 1 || r > vec.row() ) { + std::cerr << "Trying to access vector element out of bounds"; + std::cerr << std::endl; + std::abort(); + } +} + +VecElem:: +VecElem( const VecElem &elem ) + : v(elem.v), row(elem.row) +{} + +VecElem:: +operator double() +{ + assert( v.r->vec != 0 ); + return *v.r->vec; +} + +double VecElem:: +operator=( double d ) +{ + return v.assign( row, d ); +} + + + + + +int makeforms( Vector cen, Vector **a, Vector **b ); + +int main() +{ + Vector *a[8], *b[8], disp(3); + Vector cen(3), cen2(3); + int i, j; + + if (makeforms (cen,a,b) != 10) + { std::printf ("FAIL\n"); return 1; } + else + std::printf ("PASS\n"); + + +} + +int +makeforms( Vector cen, Vector **a, Vector **b) +{ + return 10; +} + + + -- cgit v1.2.3