# V3052\. The original exception object was swallowed\. Stack of original exception could be lost\.

The analyzer detected that the original object of a caught exception was not used properly when re\-throwing from a catch block\. This issue makes some errors hard to detect since the stack of the original exception is lost\.

Further we will discuss a couple of examples of incorrect code\. The first example:

```cpp
public Asn1Object ToAsn1Object()
{
  try
  {
    return Foo(_constructed, _tagNumber);
  }
  catch (IOException e)
  {
    throw new ParsingException(e.Message);
  }
}
```

In this code, the programmer wanted to transform the caught I/O exception into a new exception of type 'ParsingException'\. However, only the message from the first exception is included, so some of the information is lost\.

The fixed version of the code:

```cpp
public Asn1Object ToAsn1Object()
{
  try
  {
    return Foo(_constructed, _tagNumber);
  }
  catch (IOException e)
  {
    throw new ParsingException(e.Message, e);
  }
}
```

In the fixed version, the original exception is re\-thrown as an inner one, so all the information about the original error is saved\.

Here's the second example:

```cpp
private int ReadClearText(byte[] buffer, int offset, int count)
{
  int pos = offset;
  try
  {
    ....
  }
  catch (IOException ioe)
  {
    if (pos == offset) throw ioe;
  }
  return pos - offset;
}
```

In this case, the caught I/O exception is thrown again, completely erasing the stack of the original error\. To avoid this defect, we just need to re\-throw the original exception\.

The fixed version of the code:

```cpp
private int ReadClearText(byte[] buffer, int offset, int count)
{
  int pos = offset;
  try
  {
    ....
  }
  catch (IOException ioe)
  {
    if (pos == offset) throw;
  }
  return pos - offset;
}
```