Nested exception handling

I am getting an internal compiler error C1001 when I use nested try blocks in
MS C++ 6.0. An example follows. The implementation of the method Change
causes the problem. Is this a compiler bug ? I can't find any syntax error.

#include <stdlib.h>

class ListInteger
{
     public:
         ListInteger(); // simple constructor
         ListInteger(int length); // constructor
         ListInteger(const ListInteger & rhs); // copy constructor (deep)
         ListInteger operator=(const ListInteger & rhs); // assignment (deep
copy)
         ~ListInteger(); // destructor
         int GetLength() const;
         int GetInteger(int k) const;
         void SetInteger(int k,int entry);
         static void Change(ListInteger & X);
         static int * intvec(int length);
         static void del_intvec(int * q,int length);
    private:
         int * itsInteger; // array of integers indexed from zero
         int itsLength; // length of list
};

// produces fatal error C1001: INTERNAL COMPILER ERROR
void ListInteger::Change(ListInteger & L)
{
    try
    {
        ListInteger save = L;
        try
        {
            //...
        }
        catch (...)
        {
            try
            {
                L = save;
                //...
            }
            catch (...)
            {
                try
                {
                    L = save;
                    //...
                 }
                catch (...)
                {
                    //...
                    throw;
                 }
            }
        }
        save = L;
        try
        {
             //...
         }
         catch (...)
         {
              try
              {
                   L = save;
                   //...
               }
              catch (...)
              {
                   try
                   {
                       //...
                    }
                   catch (...)
                   {
                        //...
                        throw;
                   }
               }
           }
       }
       catch (...)
       {
            //...
            throw;
       }
}

ListInteger::ListInteger() : itsInteger(0), itsLength(0)
{
}

ListInteger::ListInteger(int length) : itsInteger(0), itsLength(length)
{
    // entries uninitialised
    itsInteger = (itsLength > 0) ? intvec(itsLength) : 0;
}

ListInteger::ListInteger(const ListInteger & rhs) : itsLength(rhs.GetLength())
{
    // copy constructor
    itsInteger = (itsLength > 0) ? intvec(itsLength) : 0;
    for (int j = 0; j < itsLength; j++) itsInteger[j] = rhs.GetInteger(j);
}

ListInteger ListInteger::operator=(const ListInteger & rhs)
{
    // assignment (deep copy)
    if (this == &rhs) return *this;
    if (itsInteger != 0)
    {
        del_intvec(itsInteger,itsLength);
        itsInteger = 0;
    }
    itsLength = rhs.GetLength();
    itsInteger = (itsLength > 0) ? intvec(itsLength) : 0;
    for (int j = 0; j < itsLength; j++) itsInteger[j] = rhs.GetInteger(j);
    return *this;
}

ListInteger::~ListInteger()
{
    if (itsInteger != 0) del_intvec(itsInteger,itsLength);
}

int ListInteger::GetLength() const
{
    return itsLength;
}

int ListInteger::GetInteger(int j) const
{
    if (j < 0 || j >= itsLength)
    {
        printf(" Index out of range : ListInteger::GetInteger.\n");
        exit(1);
     }
     return itsInteger[j];
}

void ListInteger::SetInteger(int j,int entry)
{
    if (j < 0 || j >= itsLength)
    {
        printf(" Index out of range : ListInteger::SetInteger.\n");
        exit(1);
    }
    itsInteger[j] = entry;
}

void ListInteger::del_intvec(int * q,int length)
{
    delete [] q; // delete array of integers
}

int main()
{
    return 0;
}