ICE #191 on egcs-1998-05-25

Wed May 27 05:40:00 GMT 1998

The attached file ice191.pp.cc is a preprocessed file which produces
an internal compiler error as shown below.  In case of any questions
you reach me fastest by e-mail, or at least using a `CC:' to my
address when posting on the e-mail list.

> g++ ice191.pp.cc
/mini/petter/src/typealgo/typealgo.hh: In instantiation of
`IS_A<implem,dynamic_base>::size':
ice191.cc:27:   instantiated from `IS_A<implem,dynamic_base>'
ice191.cc:27:   instantiated from
`SELECT_INSTANCE<implem,_instance_default_typearg>'
ice191.cc:27:   instantiated from
`instance<implem,_instance_default_typearg>'
ice191.cc:27:   instantiated from here
/mini/petter/src/typealgo/typealgo.hh:432: Internal compiler error 191.
/mini/petter/src/typealgo/typealgo.hh:432: Please submit a full bug
report to `egcs-bugs@cygnus.com'.

> g++
Reading specs from
/usr/local/lib/gcc-lib/i586-pc-linux-gnu/egcs-2.91.33/specs
gcc version egcs-2.91.33 19980525 (gcc2 ss-980502 experimental)

-- 

[- http://matfys.lth.se/~petter/ -]
# 1 "ice191.cc"

# 1 "/mini/petter/include/instance" 1

# 1 "/mini/petter/src/mmt/instance.hh" 1

# 1 "/mini/petter/include/typealgo" 1

# 1 "/mini/petter/src/typealgo/typealgo.hh" 1

struct nulltype {
    typedef nulltype first_type;
    typedef nulltype second_type;
    operator bool() { return false; }
    operator int() { return 0; }
};
struct truetype {
    operator bool() { return true; }
    operator int() { return 1; }
};
template <class T, class U>
struct typepair { typedef T first_type; typedef U second_type; };

template <class Cond, class Positive, class Negative = nulltype>
struct IF { typedef Positive EVAL; };

template <class Positive, class Negative>
struct IF<nulltype, Positive, Negative> { typedef Negative EVAL; };

template <class T>
struct NOT { typedef nulltype EVAL; };
struct NOT<nulltype> { typedef truetype EVAL; };

template <class T, class U>  struct EQUAL { typedef nulltype EVAL; };
template <class T>           struct EQUAL<T, T> { typedef T EVAL; };
struct EQUAL<nulltype, nulltype> { typedef truetype EVAL; };

template <class T, class U>  struct EQUIV { typedef truetype EVAL; };
template <class T>    struct EQUIV<T, nulltype> { typedef nulltype EVAL; };
template <class U>    struct EQUIV<nulltype, U> { typedef nulltype EVAL; };
struct EQUIV<nulltype, nulltype> { typedef truetype EVAL; };

template <class T1, class T2, class T3 = nulltype, class T4 = nulltype,
          class T5 = nulltype, class T6 = nulltype>
struct OR { typedef T1 EVAL; };
template <class T2, class T3, class T4, class T5, class T6>
struct OR<nulltype, T2, T3, T4, T5, T6> { typedef T2 EVAL; };
template <class T3, class T4, class T5, class T6>
struct OR<nulltype, nulltype, T3, T4, T5, T6> { typedef T3 EVAL; };
template <class T4, class T5, class T6>
struct OR<nulltype, nulltype, nulltype, T4, T5, T6> { typedef T4 EVAL; };
template <class T5, class T6>
struct OR<nulltype, nulltype, nulltype, nulltype, T5, T6> { typedef T5 EVAL; };
template <class T6>
struct OR<nulltype, nulltype, nulltype, nulltype, nulltype, T6>
{ typedef T6, EVAL; };

template <class T, class U>  struct AND { typedef U EVAL; };
template <class T>    struct AND<T, nulltype> { typedef nulltype EVAL; };
template <class U>    struct AND<nulltype, U> { typedef nulltype EVAL; };

template <class T, class U>  struct XOR { typedef nulltype EVAL; };
template <class T>           struct XOR<T, nulltype> { typedef T EVAL; };
template <class U>           struct XOR<nulltype, U> { typedef U EVAL; };

template <class List, class Value>
struct APPEND { typedef typename  List ::ERROR_APPEND_TO_NONLIST  EVAL ; };

template <class V>
struct APPEND<nulltype, V> { typedef typepair<V, nulltype> EVAL; };

template <class E, class Tail, class V>
struct APPEND<typepair<E, Tail>, V>
{ typedef typepair<E, typename APPEND<Tail, V>::EVAL> EVAL; };

template <class List, class List1>
struct CONCAT { typedef typename  List ::ERROR_CONCAT_OF_NONLIST  EVAL ; };

template <class List1>
struct CONCAT<nulltype, List1> { typedef List1 EVAL; };

template <class E, class Tail, class List1>
struct CONCAT<typepair<E, Tail>, List1>
{ typedef typepair<E, typename CONCAT<Tail, List1>::EVAL> EVAL; };

template <class List>
struct TREE_TO_LIST { typedef typepair<List, nulltype> EVAL; };

template <class List, class List1>
struct TREE_TO_LIST< typepair<List, List1> > {
    typedef typename CONCAT
	< typename TREE_TO_LIST<List>::EVAL,
	  typename TREE_TO_LIST<List1>::EVAL
        >::EVAL EVAL;
};

template <class T, class List>
struct IS_IN { typedef typename  List ::ERROR_NOT_A_LIST  EVAL ; };

template <class T, class U, class Tail>
struct IS_IN< T, typepair<U, Tail> >
{ typedef IS_IN<T, Tail>::EVAL EVAL; };

template <class T, class Tail>
struct IS_IN< T, typepair<T, Tail> > { typedef truetype EVAL; };

template <class T>
struct IS_IN<T, nulltype> { typedef nulltype EVAL; };

template <class T>
struct TYPEASSERT {
    typedef typename IF
      < typename NOT< typename T::EVAL >::EVAL,
	typename T::ASSERTION_FAILED,
	T >::EVAL EVAL;
};

template <class T1 = nulltype, class T2 = nulltype, class T3 = nulltype,
          class T4 = nulltype, class T5 = nulltype, class T6 = nulltype,
          class T7 = nulltype, class T8 = nulltype, class T9 = nulltype,
          class T10= nulltype, class T11= nulltype, class T12= nulltype>
struct LIST {
    typedef typepair
	< T1, typepair< T2, typepair< T3, typepair
	< T4, typepair< T5, typepair< T6, typepair
	< T7, typepair< T8, typepair< T9, typepair
        <T10, typepair<T11, typepair<T12, nulltype > > > > > > > > > > > >
	EVAL;
};

template <class T1, class T2, class T3, class T4, class T5, class T6,
          class T7, class T8, class T9, class T10, class T11>
struct LIST<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> {
    typedef typepair
	< T1, typepair< T2, typepair< T3, typepair
	< T4, typepair< T5, typepair< T6, typepair
	< T7, typepair< T8, typepair< T9, typepair
	<T10, typepair<T11, nulltype > > > > > > > > > > >
	EVAL;
};

template <class T1, class T2, class T3, class T4, class T5, class T6,
          class T7, class T8, class T9, class T10>
struct LIST<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> {
    typedef typepair
	< T1, typepair< T2, typepair< T3, typepair
	< T4, typepair< T5, typepair< T6, typepair
	< T7, typepair< T8, typepair< T9, typepair
	<T10, nulltype > > > > > > > > > >
	EVAL;
};

template <class T1, class T2, class T3, class T4, class T5, class T6,
          class T7, class T8, class T9>
struct LIST<T1, T2, T3, T4, T5, T6, T7, T8, T9> {
    typedef typepair
	< T1, typepair< T2, typepair< T3, typepair
	< T4, typepair< T5, typepair< T6, typepair
	< T7, typepair< T8, typepair< T9, nulltype > > > > > > > > >
	EVAL;
};

template <class T1, class T2, class T3, class T4, class T5, class T6,
          class T7, class T8>
struct LIST<T1, T2, T3, T4, T5, T6, T7, T8> {
    typedef typepair
	< T1, typepair< T2, typepair< T3, typepair
	< T4, typepair< T5, typepair< T6, typepair
	< T7, typepair< T8, nulltype > > > > > > > >
	EVAL;
};

template <class T1, class T2, class T3, class T4, class T5, class T6,
          class T7>
struct LIST<T1, T2, T3, T4, T5, T6, T7> {
    typedef typepair
	< T1, typepair< T2, typepair< T3, typepair
	< T4, typepair< T5, typepair< T6, typepair
	< T7, nulltype > > > > > > >
	EVAL;
};

template <class T1, class T2, class T3, class T4, class T5, class T6>
struct LIST<T1, T2, T3, T4, T5, T6> {
    typedef typepair
	< T1, typepair< T2, typepair< T3, typepair
	< T4, typepair< T5, typepair< T6, nulltype > > > > > > EVAL;
};

template <class T1, class T2, class T3, class T4, class T5>
struct LIST<T1, T2, T3, T4, T5> {
    typedef typepair
	< T1, typepair< T2, typepair< T3, typepair
	< T4, typepair< T5, nulltype > > > > > EVAL;
};

template <class T1, class T2, class T3, class T4>
struct LIST<T1, T2, T3, T4> {
    typedef typepair
	< T1, typepair< T2, typepair< T3, typepair< T4, nulltype > > > >
	EVAL;
};

template <class T1, class T2, class T3> struct LIST<T1, T2, T3>
{ typedef typepair< T1, typepair< T2, typepair< T3, nulltype > > > EVAL; };

template <class T1, class T2> struct LIST<T1, T2>
{ typedef typepair< T1, typepair< T2, nulltype > > EVAL; };

template <class T1> struct LIST<T1>
{ typedef typepair< T1, nulltype > EVAL; };

struct LIST<> { typedef nulltype EVAL; };

template <class T1, class T2, class Ordering>
class ORDER { typedef typename  Ordering ::ERROR_NOT_A_LIST  EVAL ; };

template <class T1, class T2, class T3, class Tail>
struct ORDER< T1, T2, typepair<T3, Tail> >
{ typedef ORDER<T1, T2, Tail>::EVAL EVAL; };

template <class T1, class T2, class Tail>
struct ORDER< T1, T2, typepair<T1, Tail> >
{ typedef typepair<T1, T2> EVAL; };

template <class T1, class T2, class Tail>
struct ORDER< T1, T2, typepair<T2, Tail> >
{ typedef typepair<T2, T1> EVAL; };

template <class T1, class T2>
struct ORDER<T1, T2, nulltype>
{ typedef nulltype EVAL; };

typedef LIST< char, short, int, long, float, double, long double >::EVAL
    balanced_type_order;

template <class T1, class T2>
class COMMUTATIVE_BALANCED_TYPE { typedef nulltype EVAL; };

template <class T1, class T2>
class BALANCED_TYPE {
    typedef typename ORDER<T1, T2, balanced_type_order>::EVAL order;
public:
    typedef typename OR
      < typename COMMUTATIVE_BALANCED_TYPE<T1, T2>::EVAL,
	typename COMMUTATIVE_BALANCED_TYPE<T2, T1>::EVAL,
	typename order::second_type,
	typename IF
	  < typename IS_IN<T1, balanced_type_order>::EVAL, T2
	  > ::EVAL,
	typename IF
	  < typename IS_IN<T2, balanced_type_order>::EVAL, T1
	  > ::EVAL
      > ::EVAL EVAL;
};

template <class T1, class T2>
struct COMMUTATIVE_PLUS_TYPE { typedef nulltype EVAL; };

template <class T1, class T2>
struct PLUS_TYPE {
    typedef typename OR
      < typename COMMUTATIVE_PLUS_TYPE<T1, T2>::EVAL,
	typename COMMUTATIVE_PLUS_TYPE<T2, T1>::EVAL,
	typename BALANCED_TYPE<T1, T2>::EVAL >::EVAL EVAL;
};

template <class T1, class T2>
struct COMMUTATIVE_MINUS_TYPE { typedef nulltype EVAL; };

template <class T1, class T2>
struct MINUS_TYPE {
    typedef typename OR
      < typename COMMUTATIVE_MINUS_TYPE<T1, T2>::EVAL,
	typename COMMUTATIVE_MINUS_TYPE<T2, T1>::EVAL,
	typename BALANCED_TYPE<T1, T2>::EVAL >::EVAL EVAL;
};

template <class T1, class T2>
struct COMMUTATIVE_TIMES_TYPE { typedef nulltype EVAL; };

template <class T1, class T2>
struct TIMES_TYPE {
    typedef typename OR
      < typename COMMUTATIVE_TIMES_TYPE<T1, T2>::EVAL,
	typename COMMUTATIVE_TIMES_TYPE<T2, T1>::EVAL,
	typename BALANCED_TYPE<T1, T2>::EVAL >::EVAL EVAL;
};

template <class T1, class T2>
struct COMMUTATIVE_DIVIDES_TYPE { typedef nulltype EVAL; };

template <class T1, class T2>
struct DIVIDES_TYPE {
    typedef typename OR
      < typename COMMUTATIVE_DIVIDES_TYPE<T1, T2>::EVAL,
	typename COMMUTATIVE_DIVIDES_TYPE<T2, T1>::EVAL,
	typename BALANCED_TYPE<T1, T2>::EVAL >::EVAL EVAL;
};

template <class T1, class T2>
struct COMMUTATIVE_REMAINDER_TYPE { typedef nulltype EVAL; };

template <class T1, class T2>
struct REMAINDER_TYPE {
    typedef typename OR
      < typename COMMUTATIVE_REMAINDER_TYPE<T1, T2>::EVAL,
	typename COMMUTATIVE_REMAINDER_TYPE<T2, T1>::EVAL,
	typename BALANCED_TYPE<T1, T2>::EVAL >::EVAL EVAL;
};

template <class T> inline char _typealgo__is_a_1(const void*) {}
template <class T> inline long _typealgo__is_a_1(const T*) {}

template <int N> struct _LONGSIZE {};
struct _LONGSIZE<sizeof(char)> { typedef nulltype EVAL; };
struct _LONGSIZE<sizeof(long)> { typedef truetype EVAL; };

template <class T, class U> class IS_A {
private:
    static const int size = sizeof(_typealgo__is_a_1<U>(static_cast<T*>(0)));
public:
    typedef typename _LONGSIZE<size>::EVAL EVAL;
};
template <class T, class U> const int IS_A<T, U>::size;

template <class T> struct IS_POINTER { typedef nulltype EVAL; };
template <class T> struct IS_POINTER<T*> { typedef truetype EVAL; };

template <class T> struct IS_CLASS { typedef truetype EVAL; };
template <class T> struct IS_CLASS<T*> { typedef nulltype EVAL; };
struct IS_CLASS<bool> { typedef nulltype EVAL; };
struct IS_CLASS<char> { typedef nulltype EVAL; };
struct IS_CLASS<signed char> { typedef nulltype EVAL; };
struct IS_CLASS<unsigned char> { typedef nulltype EVAL; };
struct IS_CLASS<short> { typedef nulltype EVAL; };
struct IS_CLASS<unsigned short> { typedef nulltype EVAL; };
struct IS_CLASS<int> { typedef nulltype EVAL; };
struct IS_CLASS<unsigned int> { typedef nulltype EVAL; };
struct IS_CLASS<long> { typedef nulltype EVAL; };
struct IS_CLASS<unsigned long> { typedef nulltype EVAL; };
struct IS_CLASS<float> { typedef nulltype EVAL; };
struct IS_CLASS<double> { typedef nulltype EVAL; };
struct IS_CLASS<long double> { typedef nulltype EVAL; };

# 3 "/mini/petter/include/typealgo" 2

# 14 "/mini/petter/src/mmt/instance.hh" 2

# 1 "/usr/local/include/g++/cassert" 1 3

# 1 "/usr/include/assert.h" 1 3

# 32 "/usr/include/assert.h" 3

# 1 "/usr/include/features.h" 1 3

# 117 "/usr/include/features.h" 3

# 1 "/usr/include/sys/cdefs.h" 1 3

# 1 "/usr/include/features.h" 1 3

# 222 "/usr/include/features.h" 3

# 22 "/usr/include/sys/cdefs.h" 2 3

# 54 "/usr/include/sys/cdefs.h" 3

# 86 "/usr/include/sys/cdefs.h" 3

# 205 "/usr/include/features.h" 2 3

# 1 "/usr/include/gnu/stubs.h" 1 3

# 219 "/usr/include/features.h" 2 3

# 35 "/usr/include/assert.h" 2 3

# 99 "/usr/include/assert.h" 3

# 6 "/usr/local/include/g++/cassert" 2 3

# 15 "/mini/petter/src/mmt/instance.hh" 2

# 1 "/mini/petter/src/mmt/mmtalloc.hh" 1

# 19 "/mini/petter/src/mmt/mmtalloc.hh"

typedef long size_t;
typedef long ptrdiff_t;

struct _mmt_head { int _instance_counter; size_t _size; };

template <class T> struct _mmt_container : public _mmt_head, public T {
    typedef _mmt_head* head_pointer_type;
    typedef T* pointer_type;
protected:
    _mmt_container() {}
};

template <class T>
class instance_allocator {
    typedef T* pointer;
    typedef const T* const_pointer;
    typedef T& reference;
    typedef const T& const_reference;
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;

private:
    _mmt_head* head(pointer p)
	{ return static_cast<_mmt_head*>(static_cast<_mmt_container<T>*>(p)); }
    const _mmt_head* head(const_pointer p)
	{ return static_cast<const _mmt_head*>
	  (static_cast<const _mmt_container<T>*>(p)); }
    int& ic(pointer p) { return head(p)->_instance_counter; }
    int ic(const_pointer p) { return head(p)->_instance_counter; }

public:
    pointer allocate(size_type n) {
	_mmt_container<T>* p =
	    (_mmt_container<T>*)::operator new((unsigned long)
		  (sizeof(_mmt_container<T>)+(n-1)*sizeof(T)));
	 ;
	p->_instance_counter = 0;
	p->_size = n;
	return static_cast<pointer>(p);
    }
    pointer reuse(pointer p) {
	 ;

	if(p) ic(p)++;
	return p;
    }
    void deallocate(pointer p) {
	 ;
	 ;
	if(p) ::operator delete(head(p));
    }
    void unuse(pointer p) {
	 ;
	 ;
	if(p) --ic(p);
    }
    size_type size(const_pointer p) { return head(p)->_size; }
    bool is_const(const_pointer p) { return !p || ic(p) > 0; }

    pointer address(reference x) { return &x; }
    const_pointer const_address(const_reference x) { return &x; }

    pointer to_mutable(const_pointer p) {
	 ;
	return (pointer)p;
    }
    reference to_mutable(const_reference x) {
	 ;
	return (reference)x;
    }
    size_type init_page_size() {
	return max(size_type(1), size_type(4096/sizeof(T))); 
    }
    size_type max_size() const { 
	return max(size_type(1), size_type(UINT_MAX/sizeof(T)));
    }
};

# 22 "/mini/petter/src/mmt/instance.hh" 2

class dimension {
    int n;
public:
    explicit dimension(int i) : n(i) {}
    operator int() { return n; }
};

template <class T> class _by_reference {
    T& r;
public:
    _by_reference(T& r_) : r(r_) {}
    operator T&() { return r; }
};
template <class T> inline _by_reference<T>
pass_by_reference(T& x) { return _by_reference<T>(x); };

class dynamic_base {
    mutable int ic;
public:
    dynamic_base() : ic(0) {}
    virtual ~dynamic_base() {}
    virtual void reuse() const { ++ic; }
    virtual bool unuse() const { return --ic < 0; }
    virtual bool is_const() const { return ic > 0; }
};

template <class Complete>
struct _instance__container
    : public Complete, virtual public dynamic_base {};

template <class Complete, class T>
dynamic_base* _instance__base_of(T* x) {
    return static_cast<_instance__container<Complete>*>(x);
}

struct _explicit_tag {};
struct _implicit_tag {};

template <class T> struct encaps { T o; };
template <class T> T& uncaps(T& x) { return x; }

template <class T> T& uncaps(encaps<T>& x) { return x.o; }

template <class T>
struct _instance_alloc {
    static instance_allocator<T> a;
};
template <class T>
instance_allocator<T> _instance_alloc<T>::a;

template <class T>
struct SELECT_ENCAPS {
    typedef typename IF
        < typename IS_CLASS<T>::EVAL,
          T, encaps<T>
        > ::EVAL EVAL;
};

template <class T, class U>
struct released_instance {
    typedef typename SELECT_ENCAPS<T>::EVAL value_type;
    mutable value_type* p;
    released_instance(value_type* p1) : p(p1) {}
};

template<class T, class U> class static_instance;

template <class T, class U>
class static_instance_base {

public:
    typedef size_t size_type;
    typedef typename SELECT_ENCAPS<T>::EVAL value_type;
    typedef typename SELECT_ENCAPS<U>::EVAL full_type;

    mutable value_type *p;

    static full_type* allocate()
	{ return _instance_alloc<full_type>().a.allocate(1); }
    static full_type* allocate(int i)
	{ return _instance_alloc<full_type>().a.allocate(i); }
    static full_type* reuse(value_type* q) {
	((void) 0) ;
	return _instance_alloc<full_type>().a.reuse(static_cast<full_type*>(q));
    }
    static void unuse(value_type* q) {
	((void) 0) ;
	_instance_alloc<full_type>().a.unuse(static_cast<full_type*>(q));
    }
    static void deallocate(value_type* q) {
	((void) 0) ;
	_instance_alloc<full_type>().a.deallocate(static_cast<full_type*>(q));
    }
    static bool is_const_stic(value_type* q) {
	return !q || _instance_alloc<full_type>().a.
                     is_const(static_cast<full_type*>(q));
    }

public:
    bool is_defined() const { return p; }
    bool is_const() const { return is_const_stic(p); }
    bool is_mutable() const { return !is_const(); }
    size_type size() const {
	((void) 0) ;
	return _instance_alloc<full_type>().a.
	       size(static_cast<full_type*>(p));
    }
    released_instance<T, U> release()
	{ value_type* tmp = p; p = 0; return tmp; }

protected:
    static_instance_base() : p(0) {}
    static_instance_base(value_type* p_)
	: p(p_? reuse(static_cast<full_type*>(p_)) : 0) {}
    static_instance_base(value_type* p_, int)
	: p(p_) {}
    static_instance_base(int i) : p(allocate(i)) {}

public:
    const T& to_const() const {

	return uncaps(*p);
    }
    const T& to_const(int i) const {

	return uncaps(p[i]);
    }

    T& to_mutable() {

	return uncaps(*p);
    }
    T& to_mutable(int i) {

	return uncaps(*(p+i));
    }

    T& modify(int i = 0) {

	if(!p) throw logic_error(string(typeid(*this).name()) +
				 string(": Dereferencing null-pointer.\n"));

	if(is_const()) {
	    const int n = size();
	    full_type* tmp = static_cast<full_type*>(p);
	    p = allocate(size());
	    for(int i = 0; i < n; i++)
		new(static_cast<full_type*>(p)+i) full_type(tmp[i]);
	    unuse(tmp);
	}
	return uncaps(p[i]);
    }
    ~static_instance_base() {
	if(is_defined()) {
	    if(is_const()) unuse(static_cast<full_type*>(p));
	    else {
		int count = size();
		while(--count >= 0)
		    static_cast<full_type*>(p)[count].full_type::~full_type();
		deallocate(static_cast<full_type*>(p));
	    }
	}
    }
    static_instance_base<T, U>&
    operator=(const static_instance_base<T, U>& r) {
	this->~static_instance_base();
	if(r.p)  p = reuse(static_cast<full_type*>(r.p));
	else     p = 0;
	return *this;
    }
};

template <class T, class U = T>
class static_instance : public static_instance_base<T, U> {

public:

    static_instance() {}

    static_instance(const static_instance& r)
	: static_instance_base<T, U>(const_cast<static_instance&>(r).p) {}

    template <class V>
    static_instance(const static_instance<V, U>& r)
	: static_instance_base<T, U>(static_cast<value_type*>(r.p)) {}

    template <class V, class W>
    explicit static_instance(const static_instance<V, W>& r) {
	if(r.is_defined()) {
	    p = allocate(1);
	    new(static_cast<W*>(p)) U(r.to_const());
	} else p = 0;
    }

    static_instance(released_instance<T, U> tmp)
	: static_instance_base(tmp.p, 0) {}

    template<class V>
    static_instance(released_instance<V, U> tmp)
	: static_instance_base<T, U>
	  (static_cast<value_type*>(tmp.p), 0) {}

    template<class V, class W>
    static_instance(released_instance<V, W> tmp) {
	if(tmp.p) {
	    p = allocate(1);
	    new(uncaps(p)) U(static_cast<W&>(uncaps(*tmp.p)));
	    if(static_instance<V, W>::is_const_stic(tmp.p))
		static_instance<V, W>::unuse(tmp.p);
	    else {
		static_cast<W&>(uncaps(*tmp.p)).W::~W();
		static_instance<V, W>::deallocate(tmp.p);
	    }
	} else p = 0;
    }

    template<class V, class W>
    static_instance(released_instance<V, W> tmp, _explicit_tag) {
	if(tmp.p) {
	    p = allocate(1);
	    new(&static_cast<U&>(uncaps(*p)))
		U(static_cast<U>
		  (static_cast<const W&>(uncaps(*tmp.p))));
	    if(static_instance<V, W>::is_const_stic(tmp.p))
		static_instance<V, W>::unuse(tmp.p);
	    else {
		static_cast<W&>(uncaps(*tmp.p)).W::~W();
		static_instance<V, W>::deallocate(tmp.p);
	    }
	} else p = 0;
    }

    template <class Arg1>
    explicit static_instance(Arg1 x1) : static_instance_base<T, T>(1) {
	new(p) T(x1);
    }
    template <class Arg1, class Arg2>
    static_instance(Arg1 x1, Arg2 x2) : static_instance_base<T, T>(1) {
	new(p) T(x1, x2);
    }
    template <class Arg1, class Arg2, class Arg3>
    static_instance(Arg1 x1, Arg2 x2, Arg3 x3)
	: static_instance_base<T, T>(1) {
	new(p) T(x1, x2, x3);
    }
    template <class Arg1, class Arg2, class Arg3, class Arg4>
    static_instance(Arg1 x1, Arg2 x2, Arg3 x3, Arg4 x4)
	: static_instance_base<T, T>(1) {
	new(p) T(x1, x2, x3, x4);
    }

    explicit static_instance(dimension i) : static_instance_base<T, T>(i) {
	for(int j = 0; j < i; j++)
	    new(&uncaps(p[j])) T();
    }
    template <class Arg1>
    static_instance(dimension i, Arg1 x1) : static_instance_base<T, T>(i) {
	for(int j = 0; j < i; j++)
	    new(&uncaps(p[j])) T(x1);
    }
    template <class Arg1, class Arg2>
    static_instance(dimension i, Arg1 x1, Arg2 x2) : static_instance_base<T, T>(i) {
	for(int j = 0; j < i; j++)
	    new(&uncaps(p[j])) T(x1, x2);
    }
    template <class Arg1, class Arg2, class Arg3>
    static_instance(dimension i, Arg1 x1, Arg2 x2, Arg3 x3)
	: static_instance_base<T, T>(i) {
	for(int j = 0; j < i; j++)
	    new(&uncaps(p[j])) T(x1, x2, x3);
    }
    template <class Arg1, class Arg2, class Arg3, class Arg4>
    static_instance(dimension i, Arg1 x1, Arg2 x2, Arg3 x3, Arg4)
	: static_instance_base<T, T>(i) {
	for(int j = 0; j < i; j++)
	    new(&uncaps(p[j])) T(x1, x2, x3, x4);
    }
};

template <class T>
class dynamic_instance {
private:
    T* p;
protected:
    struct _conversion {};
public:
    bool is_defined() const { return p; }
    bool is_const() const { return !p || p->is_const(); }
    bool is_mutable() { return !is_const(); }
    T& to_mutable() {

	return const_cast<T&>(*p);
    }
    const T& to_const() const {

	return *p;
    }
    T& modify() {

	if(is_const()) {
	    const T* old;
	    p = new T(*old);
	    old->unuse();
	}
	return *p;
    }
    dynamic_instance(const dynamic_instance<T>& x) {
	p = x.p;
	if(p) p->reuse();
    }
    template <class U>
    dynamic_instance(const dynamic_instance<U>& x) {
	if(x.is_defined()) {
	    p = const_cast<T*>(dynamic_cast<const T*>(&x.to_const()));

	    p->reuse();
	} else p = 0;
    }
    template <class U, class V>
    dynamic_instance(const static_instance<U, V>& x) {

	if(x.is_defined()) {
	    p = static_cast<const T*>(&x.to_const());
	    p->reuse();
	} else p = 0;
    }

    dynamic_instance() : p(0) {}
    dynamic_instance(dimension i) : p(new T) {

    }
    template <class T1>
    explicit dynamic_instance(T1 x1) : p(new T(x1)) {}
    template <class T1, class T2>
    dynamic_instance(T1 x1, T2 x2) : p(new T(x1, x2)) {}
    template <class T1, class T2, class T3>
    dynamic_instance(T1 x1, T2 x2, T3 x3) : p(new T(x1, x2, x3)) {}
    template <class T1, class T2, class T3, class T4>
    dynamic_instance(T1 x1, T2 x2, T3 x3, T4 x4) : p(new T(x1,x2,x3,x4)) {}
    ~dynamic_instance() { if(p && p->unuse()) delete p; }

    dynamic_instance<T>& operator=(const dynamic_instance<T>& x) {
	if(is_defined())
	    if(p->unuse()) delete p;
	p = x.p;
	p->reuse();
	return *this;
    }
};

struct _instance_default_typearg {};

template <typename T, typename U>
class SELECT_INSTANCE {
    typedef typename IF
	< typename EQUAL<U, _instance_default_typearg>::EVAL,
	  typename IF
	    < typename IS_A<T, dynamic_base>::EVAL,
	      dynamic_instance<T>,
	      static_instance<T, T>
	    > ::EVAL,
	  static_instance<T, U>
	> ::EVAL EVAL;
};

template <class T, class U = _instance_default_typearg>
struct instance : public SELECT_INSTANCE<T, U>::EVAL {
    typedef typename SELECT_INSTANCE<T, U>::EVAL reduced_type;
    instance() {}
    instance(const instance& x)
	: reduced_type(static_cast<const reduced_type&>(x)) {}
    template <class V, class W> explicit instance(instance<V, W> x)
	: reduced_type(x.release(), _explicit_tag()) {}
    template <class V, class W>
    operator instance<V, W>()
	{ return instance<V, W>(*this, _implicit_tag()); }
    template <class V> instance(V x, _implicit_tag)
	: reduced_type(x.release()) {}

    template <class T1>
    explicit instance(T1 x1) : reduced_type(x1) {}
    template <class T1, class T2>
    instance(T1 x1, T2 x2) : reduced_type(x1, x2) {}
    template <class T1, class T2, class T3>
    instance(T1 x1, T2 x2, T3 x3) : reduced_type(x1, x2, x3) {}
    template <class T1, class T2, class T3, class T4>
    instance(T1 x1, T2 x2, T3 x3, T4 x4) : reduced_type(x1, x2, x3, x4) {}
    template <class T1, class T2, class T3, class T4, class T5>
    instance(T1 x1, T2 x2, T3 x3, T4 x4, T5 x5)
	: reduced_type(x1, x2, x3, x4, x5) {}
};

template <class T1, class U1, class T2, class U2>
inline bool operator==(const instance<T1, U1>& x,
		       const instance<T2, U2>& y)
{ return x.to_const() == y.to_const(); }

template <class T1, class U1, class T2, class U2>
inline bool operator<(const instance<T1, U1>& x,
		      const instance<T2, U2>& y)
{ return x.to_const() < y.to_const(); }

# 524 "/mini/petter/src/mmt/instance.hh"

# 538 "/mini/petter/src/mmt/instance.hh"

# 548 "/mini/petter/src/mmt/instance.hh"

# 3 "/mini/petter/include/instance" 2

# 2 "ice191.cc" 2

struct abase1 : virtual public dynamic_base {
    long i1;
    abase1() : i1(1000) {}
    ~abase1() {}
    virtual void mf1() = 0;
};
struct abase2 : virtual public dynamic_base {
    int i2;
    abase2() : i2(2000) {}
    virtual void mf2() = 0;
};

struct implem : public abase1, public abase2, virtual public dynamic_base {
    void mf1() {}
    void mf2() {}
};

main() {
    instance<abase2, implem> b2;
    instance<implem> imp3;
    {
	instance<implem> imp(dimension(1));
	instance<implem> imp2(dimension(1));
	imp.to_mutable().mf1();
	imp.to_mutable().mf2();
	((void) 0) ;
	instance<abase1, implem> b1(imp);
	b2 = imp;
    }
}