Subversion Repositories openrisc

// { dg-do run  }
// GROUPS passed code-generation
// code-gen file
// From: "David" <norman@pi14.arc.umn.edu>
// Date:     Mon, 15 Nov 1993 20:59:14 -0600 (CST)
// Subject:  An error!
// Message-ID: <9311160259.AA03353@pi14.arc.umn.edu>

#include <cstdlib>
#include <cstdio>
#include <cassert>
#include <fstream>
#include <iostream>
#include <cmath>

#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;
}