etc.!

and here is today's bug report:

template <class T1, class T2>
struct C
{
  C()
  { }

  template <class U1, class U2>
  C(const C<U1, U2> &p)
  // Error: 'C<int ,int >::C<int ,int >' is already defined
  { }
};

template <class T1, class T2>
inline bool operator==(const C<T1, T2> &x, const C<T1, T2> &y)
{
  return true;
}


int main()
{
  C<const int, int> a;
  C<const int, int> b;

  if (a == b)
  { }

  return 0;
}


bye, Christof

-- 
http://cmeerw.org                                 JID: cmeerw@jabber.at mailto cmeerw at web.de

...and what have you contributed to the Net?

Here is another one: Internal error: cgobj 1728

It once was a simple "std::list<std::pair<std::pair<std::string, char>, int> > a;"

Is this already hitting some size limitation of generated symbols?


template<class T1, class T2>
struct D
{ };

template<class T1>
struct E
{ };


template <class T, class T2 = E<T> >
class L
{
 public:
  D<T, T> g();
  D<T, E<T> > g() const;

  template <class U>
  void f(D<T, T> i, U u)
  { }

  L<T, T2> &operator=(const L<T, T2> &__x);
};

template <class T, class T2>
L<T, T2> &L<T, T2>::operator=(const L<T, T2> &x)
{
  f(g(), x.g());
  return *this;
}


struct B1234567890123456789012345678901234567890123456789
{ };

template <class T1, class T2, class T3>
class FFFFFFFFFFFFF
{ };

template <class T1, class T2>
struct CCC
{ };


typedef FFFFFFFFFFFFF<char, B1234567890123456789012345678901234567890123456789,
  B1234567890123456789012345678901234567890123456789 > F;


int main()
{
  L<CCC<CCC<F, char>, int> > a;

  return 0;
};



bye, Christof

-- 
http://cmeerw.org                                 JID: cmeerw@jabber.at mailto cmeerw at web.de

...and what have you contributed to the Net?

Yes, that's a size limitation problem. -Walter

"Christof Meerwald" <cmeerw@web.de> wrote in message news:ahn650$l1d$1@digitaldaemon.com...
> Here is another one: Internal error: cgobj 1728
>
> It once was a simple "std::list<std::pair<std::pair<std::string, char>, int> > a;"
>
> Is this already hitting some size limitation of generated symbols?
>
>
> template<class T1, class T2>
> struct D
> { };
>
> template<class T1>
> struct E
> { };
>
>
> template <class T, class T2 = E<T> >
> class L
> {
>  public:
>   D<T, T> g();
>   D<T, E<T> > g() const;
>
>   template <class U>
>   void f(D<T, T> i, U u)
>   { }
>
>   L<T, T2> &operator=(const L<T, T2> &__x);
> };
>
> template <class T, class T2>
> L<T, T2> &L<T, T2>::operator=(const L<T, T2> &x)
> {
>   f(g(), x.g());
>   return *this;
> }
>
>
> struct B1234567890123456789012345678901234567890123456789
> { };
>
> template <class T1, class T2, class T3>
> class FFFFFFFFFFFFF
> { };
>
> template <class T1, class T2>
> struct CCC
> { };
>
>
> typedef FFFFFFFFFFFFF<char,
B1234567890123456789012345678901234567890123456789,
>   B1234567890123456789012345678901234567890123456789 > F;
>
>
> int main()
> {
>   L<CCC<CCC<F, char>, int> > a;
>
>   return 0;
> };
>
>
>
> bye, Christof
>
> --
> http://cmeerw.org                                 JID: cmeerw@jabber.at mailto cmeerw at web.de
>
> ...and what have you contributed to the Net?

On Wed, 24 Jul 2002 17:42:32 -0700, Walter wrote:
> Yes, that's a size limitation problem. -Walter

Is this just an arbitrary limit that can easily be extended or is it a file format limitation?

I am afraid that most applications using the STL will reach this limit...


> "Christof Meerwald" <cmeerw@web.de> wrote in message news:ahn650$l1d$1@digitaldaemon.com...
>> Here is another one: Internal error: cgobj 1728
>>
>> It once was a simple "std::list<std::pair<std::pair<std::string, char>, int> > a;"
[...]


bye, Christof

-- 
http://cmeerw.org                                 JID: cmeerw@jabber.at mailto cmeerw at web.de

...and what have you contributed to the Net?

"Christof Meerwald" <cmeerw@web.de> wrote in message news:ahpbup$30fs$1@digitaldaemon.com...
> On Wed, 24 Jul 2002 17:42:32 -0700, Walter wrote:
> > Yes, that's a size limitation problem. -Walter
>
> Is this just an arbitrary limit that can easily be extended or is it a
file
> format limitation?
>
> I am afraid that most applications using the STL will reach this limit...

I was afraid you were going to say that. The trouble is that the Intel OMF used by all the tools has a record size limit of 1024.

On Thu, 25 Jul 2002 11:21:20 -0700 "Walter" <walter@digitalmars.com> wrote:

> I was afraid you were going to say that. The trouble is that the Intel OMF used by all the tools has a record size limit of 1024.

Borland C++ 5.5 also uses OMF, but they've found some sort of workaround - at least all the STL works properly.

How far over does it go? The latest beta will say.

"Christof Meerwald" <cmeerw@web.de> wrote in message news:ahpbup$30fs$1@digitaldaemon.com...
> On Wed, 24 Jul 2002 17:42:32 -0700, Walter wrote:
> > Yes, that's a size limitation problem. -Walter
>
> Is this just an arbitrary limit that can easily be extended or is it a
file
> format limitation?
>
> I am afraid that most applications using the STL will reach this limit...

On Thu, 25 Jul 2002 13:50:09 -0700, Walter wrote:
> How far over does it go? The latest beta will say.

here are two examples:

std::list<std::pair<std::pair<std::string, char>, int> > a;

decorated identifier '...' is 64 longer than maximum of 900

decorated identifier '...' is 37 longer than maximum of 900 (with
_STLP_USE_ABBREVS defined)


std::list<std::pair<std::pair<std::string,
  std::basic_string<unsigned char> >, int> > b;

Error: decorated identifier '...' is 584 longer than maximum of 900

Error: decorated identifier '...' is 557 longer than maximum of 900 (with
_STLP_USE_ABBREVS defined)


Using _STLP_USE_ABBREVS doesn't seem to make much difference, but strings seem to really generate long symbols.


BTW, I have briefly looked at some OMF documentation but haven't found a reason for this 1024-byte limitation (the record size field is 16 bits), but maybe I have missed something...


bye, Christof

-- 
http://cmeerw.org                                 JID: cmeerw@jabber.at mailto cmeerw at web.de

...and what have you contributed to the Net?

"Christof Meerwald" <cmeerw@web.de> wrote in message news:ahpqeg$gn0$1@digitaldaemon.com...
> BTW, I have briefly looked at some OMF documentation but haven't found a reason for this 1024-byte limitation (the record size field is 16 bits),
but
> maybe I have missed something...

It specifically says in the OMF spec that the limit is 1024, despite it being a 16 bit value. One reason is the offsets in FIXUPPs are 10 bits.