GetLineNumber() public method

public GetLineNumber ( int i ) : int
i int
return int
        // Retrieves an object with stack trace information encoded.
        // It leaves out the first "iSkip" lines of the stacktrace.
        //
        private void CaptureStackTrace(int iSkip, bool fNeedFileInfo, Thread targetThread,
                                       Exception e)
        {
            m_iMethodsToSkip += iSkip;

            StackFrameHelper StackF = new StackFrameHelper(fNeedFileInfo, targetThread);

            GetStackFramesInternal(StackF, 0, e);

            m_iNumOfFrames = StackF.GetNumberOfFrames();

            if (m_iMethodsToSkip > m_iNumOfFrames)
            {
                m_iMethodsToSkip = m_iNumOfFrames;
            }

            if (m_iNumOfFrames != 0)
            {
                frames = new StackFrame [m_iNumOfFrames];

                for (int i = 0; i < m_iNumOfFrames; i++)
                {
                    bool       fDummy1 = true;
                    bool       fDummy2 = true;
                    StackFrame sfTemp  = new StackFrame(fDummy1, fDummy2);

                    sfTemp.SetMethodBase(StackF.GetMethodBase(i));
                    sfTemp.SetOffset(StackF.GetOffset(i));
                    sfTemp.SetILOffset(StackF.GetILOffset(i));

                    if (fNeedFileInfo)
                    {
                        sfTemp.SetFileName(StackF.GetFilename(i));
                        sfTemp.SetLineNumber(StackF.GetLineNumber(i));
                        sfTemp.SetColumnNumber(StackF.GetColumnNumber(i));
                    }

                    frames [i] = sfTemp;
                }

                // CalculateFramesToSkip skips all frames in the System.Diagnostics namespace,
                // but this is not desired if building a stack trace from an exception.
                if (e == null)
                {
                    m_iMethodsToSkip += CalculateFramesToSkip(StackF, m_iNumOfFrames);
                }

                m_iNumOfFrames -= m_iMethodsToSkip;
                if (m_iNumOfFrames < 0)
                {
                    m_iNumOfFrames = 0;
                }
            }

            // In case this is the same object being re-used, set frames to null
            else
            {
                frames = null;
            }
        }
        /// <summary>
        /// Retrieves an object with stack trace information encoded.
        /// It leaves out the first "iSkip" lines of the stacktrace.
        /// </summary>
        private void CaptureStackTrace(int skipFrames, bool fNeedFileInfo, Exception e)
        {
            _methodsToSkip = skipFrames;

            StackFrameHelper StackF = new StackFrameHelper(null);

            StackF.InitializeSourceInfo(0, fNeedFileInfo, e);

            _numOfFrames = StackF.GetNumberOfFrames();

            if (_methodsToSkip > _numOfFrames)
            {
                _methodsToSkip = _numOfFrames;
            }

            if (_numOfFrames != 0)
            {
                _stackFrames = new StackFrame[_numOfFrames];

                for (int i = 0; i < _numOfFrames; i++)
                {
                    bool       fDummy1 = true;
                    bool       fDummy2 = true;
                    StackFrame sfTemp  = new StackFrame(fDummy1, fDummy2);

                    sfTemp.SetMethodBase(StackF.GetMethodBase(i));
                    sfTemp.SetOffset(StackF.GetOffset(i));
                    sfTemp.SetILOffset(StackF.GetILOffset(i));

                    sfTemp.SetIsLastFrameFromForeignExceptionStackTrace(StackF.IsLastFrameFromForeignExceptionStackTrace(i));

                    if (fNeedFileInfo)
                    {
                        sfTemp.SetFileName(StackF.GetFilename(i));
                        sfTemp.SetLineNumber(StackF.GetLineNumber(i));
                        sfTemp.SetColumnNumber(StackF.GetColumnNumber(i));
                    }

                    _stackFrames[i] = sfTemp;
                }

                // CalculateFramesToSkip skips all frames in the System.Diagnostics namespace,
                // but this is not desired if building a stack trace from an exception.
                if (e == null)
                {
                    _methodsToSkip += CalculateFramesToSkip(StackF, _numOfFrames);
                }

                _numOfFrames -= _methodsToSkip;
                if (_numOfFrames < 0)
                {
                    _numOfFrames = 0;
                }
            }
        }
        /// <summary>
        /// Called from the class "StackTrace"
        /// </summary>
        internal StackFrame(StackFrameHelper stackFrameHelper, int skipFrames, bool needFileInfo)
        {
            _method       = stackFrameHelper.GetMethodBase(skipFrames);
            _nativeOffset = stackFrameHelper.GetOffset(skipFrames);
            _ilOffset     = stackFrameHelper.GetILOffset(skipFrames);
            _isLastFrameFromForeignExceptionStackTrace = stackFrameHelper.IsLastFrameFromForeignExceptionStackTrace(skipFrames);

            if (needFileInfo)
            {
                _fileName     = stackFrameHelper.GetFilename(skipFrames);
                _lineNumber   = stackFrameHelper.GetLineNumber(skipFrames);
                _columnNumber = stackFrameHelper.GetColumnNumber(skipFrames);
            }
        }
 // Token: 0x06003257 RID: 12887 RVA: 0x000C10A4 File Offset: 0x000BF2A4
 private void CaptureStackTrace(int iSkip, bool fNeedFileInfo, Thread targetThread, Exception e)
 {
     this.m_iMethodsToSkip += iSkip;
     using (StackFrameHelper stackFrameHelper = new StackFrameHelper(targetThread))
     {
         stackFrameHelper.InitializeSourceInfo(0, fNeedFileInfo, e);
         this.m_iNumOfFrames = stackFrameHelper.GetNumberOfFrames();
         if (this.m_iMethodsToSkip > this.m_iNumOfFrames)
         {
             this.m_iMethodsToSkip = this.m_iNumOfFrames;
         }
         if (this.m_iNumOfFrames != 0)
         {
             this.frames = new StackFrame[this.m_iNumOfFrames];
             for (int i = 0; i < this.m_iNumOfFrames; i++)
             {
                 bool       dummyFlag  = true;
                 bool       dummyFlag2 = true;
                 StackFrame stackFrame = new StackFrame(dummyFlag, dummyFlag2);
                 stackFrame.SetMethodBase(stackFrameHelper.GetMethodBase(i));
                 stackFrame.SetOffset(stackFrameHelper.GetOffset(i));
                 stackFrame.SetILOffset(stackFrameHelper.GetILOffset(i));
                 stackFrame.SetIsLastFrameFromForeignExceptionStackTrace(stackFrameHelper.IsLastFrameFromForeignExceptionStackTrace(i));
                 if (fNeedFileInfo)
                 {
                     stackFrame.SetFileName(stackFrameHelper.GetFilename(i));
                     stackFrame.SetLineNumber(stackFrameHelper.GetLineNumber(i));
                     stackFrame.SetColumnNumber(stackFrameHelper.GetColumnNumber(i));
                 }
                 this.frames[i] = stackFrame;
             }
             if (e == null)
             {
                 this.m_iMethodsToSkip += StackTrace.CalculateFramesToSkip(stackFrameHelper, this.m_iNumOfFrames);
             }
             this.m_iNumOfFrames -= this.m_iMethodsToSkip;
             if (this.m_iNumOfFrames < 0)
             {
                 this.m_iNumOfFrames = 0;
             }
         }
         else
         {
             this.frames = null;
         }
     }
 }
Beispiel #5
0
        private void CaptureStackTrace(int iSkip, bool fNeedFileInfo, Thread targetThread, Exception e)
        {
            this.m_iMethodsToSkip += iSkip;
            StackFrameHelper sfh = new StackFrameHelper(fNeedFileInfo, targetThread);

            GetStackFramesInternal(sfh, 0, e);
            this.m_iNumOfFrames = sfh.GetNumberOfFrames();
            if (this.m_iMethodsToSkip > this.m_iNumOfFrames)
            {
                this.m_iMethodsToSkip = this.m_iNumOfFrames;
            }
            if (this.m_iNumOfFrames != 0)
            {
                this.frames = new StackFrame[this.m_iNumOfFrames];
                for (int i = 0; i < this.m_iNumOfFrames; i++)
                {
                    bool       flag  = true;
                    bool       flag2 = true;
                    StackFrame frame = new StackFrame(flag, flag2);
                    frame.SetMethodBase(sfh.GetMethodBase(i));
                    frame.SetOffset(sfh.GetOffset(i));
                    frame.SetILOffset(sfh.GetILOffset(i));
                    if (fNeedFileInfo)
                    {
                        frame.SetFileName(sfh.GetFilename(i));
                        frame.SetLineNumber(sfh.GetLineNumber(i));
                        frame.SetColumnNumber(sfh.GetColumnNumber(i));
                    }
                    this.frames[i] = frame;
                }
                if (e == null)
                {
                    this.m_iMethodsToSkip += CalculateFramesToSkip(sfh, this.m_iNumOfFrames);
                }
                this.m_iNumOfFrames -= this.m_iMethodsToSkip;
                if (this.m_iNumOfFrames < 0)
                {
                    this.m_iNumOfFrames = 0;
                }
            }
            else
            {
                this.frames = null;
            }
        }
Beispiel #6
0
        private void CaptureStackTrace(int iSkip, bool fNeedFileInfo, Thread targetThread, Exception e)
        {
            this.m_iMethodsToSkip = this.m_iMethodsToSkip + iSkip;
            StackFrameHelper stackFrameHelper = new StackFrameHelper(fNeedFileInfo, targetThread);

            StackTrace.GetStackFramesInternal(stackFrameHelper, 0, e);
            this.m_iNumOfFrames = stackFrameHelper.GetNumberOfFrames();
            if (this.m_iMethodsToSkip > this.m_iNumOfFrames)
            {
                this.m_iMethodsToSkip = this.m_iNumOfFrames;
            }
            if (this.m_iNumOfFrames != 0)
            {
                this.frames = new StackFrame[this.m_iNumOfFrames];
                for (int i = 0; i < this.m_iNumOfFrames; ++i)
                {
                    StackFrame stackFrame = new StackFrame(true, true);
                    stackFrame.SetMethodBase(stackFrameHelper.GetMethodBase(i));
                    stackFrame.SetOffset(stackFrameHelper.GetOffset(i));
                    stackFrame.SetILOffset(stackFrameHelper.GetILOffset(i));
                    stackFrame.SetIsLastFrameFromForeignExceptionStackTrace(stackFrameHelper.IsLastFrameFromForeignExceptionStackTrace(i));
                    if (fNeedFileInfo)
                    {
                        stackFrame.SetFileName(stackFrameHelper.GetFilename(i));
                        stackFrame.SetLineNumber(stackFrameHelper.GetLineNumber(i));
                        stackFrame.SetColumnNumber(stackFrameHelper.GetColumnNumber(i));
                    }
                    this.frames[i] = stackFrame;
                }
                if (e == null)
                {
                    this.m_iMethodsToSkip = this.m_iMethodsToSkip + StackTrace.CalculateFramesToSkip(stackFrameHelper, this.m_iNumOfFrames);
                }
                this.m_iNumOfFrames = this.m_iNumOfFrames - this.m_iMethodsToSkip;
                if (this.m_iNumOfFrames >= 0)
                {
                    return;
                }
                this.m_iNumOfFrames = 0;
            }
            else
            {
                this.frames = (StackFrame[])null;
            }
        }
Beispiel #7
0
 private void BuildStackFrame(int skipFrames, bool fNeedFileInfo)
 {
     StackFrameHelper sfh = new StackFrameHelper(fNeedFileInfo, null);
     StackTrace.GetStackFramesInternal(sfh, 0, null);
     int numberOfFrames = sfh.GetNumberOfFrames();
     skipFrames += StackTrace.CalculateFramesToSkip(sfh, numberOfFrames);
     if ((numberOfFrames - skipFrames) > 0)
     {
         this.method = sfh.GetMethodBase(skipFrames);
         this.offset = sfh.GetOffset(skipFrames);
         this.ILOffset = sfh.GetILOffset(skipFrames);
         if (fNeedFileInfo)
         {
             this.strFileName = sfh.GetFilename(skipFrames);
             this.iLineNumber = sfh.GetLineNumber(skipFrames);
             this.iColumnNumber = sfh.GetColumnNumber(skipFrames);
         }
     }
 }
Beispiel #8
0
        private void BuildStackFrame(int skipFrames, bool fNeedFileInfo)
        {
            StackFrameHelper sfh = new StackFrameHelper(fNeedFileInfo, null);

            StackTrace.GetStackFramesInternal(sfh, 0, null);
            int numberOfFrames = sfh.GetNumberOfFrames();

            skipFrames += StackTrace.CalculateFramesToSkip(sfh, numberOfFrames);
            if ((numberOfFrames - skipFrames) > 0)
            {
                this.method   = sfh.GetMethodBase(skipFrames);
                this.offset   = sfh.GetOffset(skipFrames);
                this.ILOffset = sfh.GetILOffset(skipFrames);
                if (fNeedFileInfo)
                {
                    this.strFileName   = sfh.GetFilename(skipFrames);
                    this.iLineNumber   = sfh.GetLineNumber(skipFrames);
                    this.iColumnNumber = sfh.GetColumnNumber(skipFrames);
                }
            }
        }
 // Token: 0x06003275 RID: 12917 RVA: 0x000C1890 File Offset: 0x000BFA90
 private void BuildStackFrame(int skipFrames, bool fNeedFileInfo)
 {
     using (StackFrameHelper stackFrameHelper = new StackFrameHelper(null))
     {
         stackFrameHelper.InitializeSourceInfo(0, fNeedFileInfo, null);
         int numberOfFrames = stackFrameHelper.GetNumberOfFrames();
         skipFrames += StackTrace.CalculateFramesToSkip(stackFrameHelper, numberOfFrames);
         if (numberOfFrames - skipFrames > 0)
         {
             this.method   = stackFrameHelper.GetMethodBase(skipFrames);
             this.offset   = stackFrameHelper.GetOffset(skipFrames);
             this.ILOffset = stackFrameHelper.GetILOffset(skipFrames);
             if (fNeedFileInfo)
             {
                 this.strFileName   = stackFrameHelper.GetFilename(skipFrames);
                 this.iLineNumber   = stackFrameHelper.GetLineNumber(skipFrames);
                 this.iColumnNumber = stackFrameHelper.GetColumnNumber(skipFrames);
             }
         }
     }
 }
Beispiel #10
0
        private void BuildStackFrame(int skipFrames, bool needFileInfo)
        {
            StackFrameHelper StackF = new StackFrameHelper(null);

            StackF.InitializeSourceInfo(0, needFileInfo, null);

            int iNumOfFrames = StackF.GetNumberOfFrames();

            skipFrames += StackTrace.CalculateFramesToSkip(StackF, iNumOfFrames);

            if ((iNumOfFrames - skipFrames) > 0)
            {
                _method       = StackF.GetMethodBase(skipFrames);
                _nativeOffset = StackF.GetOffset(skipFrames);
                _ilOffset     = StackF.GetILOffset(skipFrames);
                if (needFileInfo)
                {
                    _fileName     = StackF.GetFilename(skipFrames);
                    _lineNumber   = StackF.GetLineNumber(skipFrames);
                    _columnNumber = StackF.GetColumnNumber(skipFrames);
                }
            }
        }
Beispiel #11
0
        private void BuildStackFrame(int skipFrames, bool fNeedFileInfo)
        {
            StackFrameHelper StackF = new StackFrameHelper(fNeedFileInfo, null);

            StackTrace.GetStackFramesInternal(StackF, 0, null);

            int iNumOfFrames = StackF.GetNumberOfFrames();

            skipFrames += StackTrace.CalculateFramesToSkip(StackF, iNumOfFrames);

            if ((iNumOfFrames - skipFrames) > 0)
            {
                method   = StackF.GetMethodBase(skipFrames);
                offset   = StackF.GetOffset(skipFrames);
                ILOffset = StackF.GetILOffset(skipFrames);
                if (fNeedFileInfo)
                {
                    strFileName   = StackF.GetFilename(skipFrames);
                    iLineNumber   = StackF.GetLineNumber(skipFrames);
                    iColumnNumber = StackF.GetColumnNumber(skipFrames);
                }
            }
        }
Beispiel #12
0
        // Retrieves an object with stack trace information encoded.
        // It leaves out the first "iSkip" lines of the stacktrace.
        //
        private void CaptureStackTrace(int iSkip, bool fNeedFileInfo, Thread targetThread, Exception e)
        {
            m_iMethodsToSkip += iSkip;

            using (StackFrameHelper StackF = new StackFrameHelper(targetThread))
            {
                StackF.InitializeSourceInfo(0, fNeedFileInfo, e);

                m_iNumOfFrames = StackF.GetNumberOfFrames();

                if (m_iMethodsToSkip > m_iNumOfFrames)
                {
                    m_iMethodsToSkip = m_iNumOfFrames;
                }

                if (m_iNumOfFrames != 0)
                {
                    frames = new StackFrame[m_iNumOfFrames];

                    for (int i = 0; i < m_iNumOfFrames; i++)
                    {
                        bool       fDummy1 = true;
                        bool       fDummy2 = true;
                        StackFrame sfTemp  = new StackFrame(fDummy1, fDummy2);

                        sfTemp.SetMethodBase(StackF.GetMethodBase(i));
                        sfTemp.SetOffset(StackF.GetOffset(i));
                        sfTemp.SetILOffset(StackF.GetILOffset(i));

#if FEATURE_EXCEPTIONDISPATCHINFO
                        sfTemp.SetIsLastFrameFromForeignExceptionStackTrace(StackF.IsLastFrameFromForeignExceptionStackTrace(i));
#endif // FEATURE_EXCEPTIONDISPATCHINFO

                        if (fNeedFileInfo)
                        {
                            sfTemp.SetFileName(StackF.GetFilename(i));
                            sfTemp.SetLineNumber(StackF.GetLineNumber(i));
                            sfTemp.SetColumnNumber(StackF.GetColumnNumber(i));
                        }

                        frames[i] = sfTemp;
                    }

                    // CalculateFramesToSkip skips all frames in the System.Diagnostics namespace,
                    // but this is not desired if building a stack trace from an exception.
                    if (e == null)
                    {
                        m_iMethodsToSkip += CalculateFramesToSkip(StackF, m_iNumOfFrames);
                    }

                    m_iNumOfFrames -= m_iMethodsToSkip;
                    if (m_iNumOfFrames < 0)
                    {
                        m_iNumOfFrames = 0;
                    }
                }

                // In case this is the same object being re-used, set frames to null
                else
                {
                    frames = null;
                }
            }
        }
Beispiel #13
0
        // Retrieves an object with stack trace information encoded.
        // It leaves out the first "iSkip" lines of the stacktrace.
        //
        private void CaptureStackTrace(int iSkip, bool fNeedFileInfo, Thread targetThread, Exception e)
        {
            m_iMethodsToSkip += iSkip;

            using (StackFrameHelper StackF = new StackFrameHelper(targetThread))
            {
                StackF.InitializeSourceInfo(0, fNeedFileInfo, e);

                m_iNumOfFrames = StackF.GetNumberOfFrames();

                if (m_iMethodsToSkip > m_iNumOfFrames)
                    m_iMethodsToSkip = m_iNumOfFrames;

                if (m_iNumOfFrames != 0)
                {
                    frames = new StackFrame[m_iNumOfFrames];

                    for (int i = 0; i < m_iNumOfFrames; i++)
                    {
                        bool fDummy1 = true;
                        bool fDummy2 = true;
                        StackFrame sfTemp = new StackFrame(fDummy1, fDummy2);

                        sfTemp.SetMethodBase(StackF.GetMethodBase(i));
                        sfTemp.SetOffset(StackF.GetOffset(i));
                        sfTemp.SetILOffset(StackF.GetILOffset(i));

#if FEATURE_EXCEPTIONDISPATCHINFO
                    sfTemp.SetIsLastFrameFromForeignExceptionStackTrace(StackF.IsLastFrameFromForeignExceptionStackTrace(i));
#endif // FEATURE_EXCEPTIONDISPATCHINFO

                        if (fNeedFileInfo)
                        {
                            sfTemp.SetFileName(StackF.GetFilename(i));
                            sfTemp.SetLineNumber(StackF.GetLineNumber(i));
                            sfTemp.SetColumnNumber(StackF.GetColumnNumber(i));
                        }

                        frames[i] = sfTemp;
                    }

                    // CalculateFramesToSkip skips all frames in the System.Diagnostics namespace,
                    // but this is not desired if building a stack trace from an exception.
                    if (e == null)
                        m_iMethodsToSkip += CalculateFramesToSkip(StackF, m_iNumOfFrames);

                    m_iNumOfFrames -= m_iMethodsToSkip;
                    if (m_iNumOfFrames < 0)
                    {
                        m_iNumOfFrames = 0;
                    }
                }

                // In case this is the same object being re-used, set frames to null
                else
                    frames = null;
            }
        }
Beispiel #14
0
     private void BuildStackFrame(int skipFrames, bool fNeedFileInfo)
     {
         StackFrameHelper StackF = new StackFrameHelper(fNeedFileInfo, null);
 
         StackTrace.GetStackFramesInternal (StackF, 0, null); 
 
         int iNumOfFrames = StackF.GetNumberOfFrames();
 
         skipFrames += StackTrace.CalculateFramesToSkip (StackF, iNumOfFrames);
 
         if ((iNumOfFrames - skipFrames) > 0)
         {
             method = StackF.GetMethodBase (skipFrames);
             offset = StackF.GetOffset (skipFrames);
             ILOffset = StackF.GetILOffset (skipFrames);
             if (fNeedFileInfo)
             {
                 strFileName = StackF.GetFilename (skipFrames);
                 iLineNumber = StackF.GetLineNumber (skipFrames);
                 iColumnNumber = StackF.GetColumnNumber (skipFrames);
             }        
         }
     }
Beispiel #15
0
    	// PRIVATE method to retrieve an object with stack trace information
    	// encoded.
    	//
    	// This version leaves out the first "iSkip" lines of the stacktrace.
    	private void CaptureStackTrace(int iSkip, bool fNeedFileInfo, Thread targetThread,
                                       Exception e)
    	{
    		m_iMethodsToSkip += iSkip;
    
    		StackFrameHelper StackF = new StackFrameHelper(fNeedFileInfo, targetThread);
    
    		GetStackFramesInternal (StackF, 0, e);
    
    		m_iNumOfFrames = StackF.GetNumberOfFrames();

            if (m_iNumOfFrames != 0)
            {
                frames = new StackFrame [m_iNumOfFrames];

                for (int i=0; i<m_iNumOfFrames; i++)
                {
                    bool fDummy1 = true;
                    bool fDummy2 = true;
                    StackFrame sfTemp = new StackFrame (fDummy1, fDummy2);

                    sfTemp.SetMethodBase (StackF.GetMethodBase(i));
                    sfTemp.SetOffset (StackF.GetOffset(i));
                    sfTemp.SetILOffset (StackF.GetILOffset(i));

                    if (fNeedFileInfo)
                    {
                        sfTemp.SetFileName (StackF.GetFilename (i));
                        sfTemp.SetLineNumber (StackF.GetLineNumber (i));
                        sfTemp.SetColumnNumber (StackF.GetColumnNumber (i));
                    } 

                    frames [i] = sfTemp;
                }

                // CalculateFramesToSkip skips all frames in the System.Diagnostics namespace,
                // but this is not desired if building a stack trace from an exception.
                if (e == null)
                    m_iMethodsToSkip += CalculateFramesToSkip (StackF, m_iNumOfFrames);

                m_iNumOfFrames -= m_iMethodsToSkip;
                if (m_iNumOfFrames < 0)
                    m_iNumOfFrames = 0;
            }

            // In case this is the same object being re-used, set frames to null
            else
                frames = null;
    	}
 private void CaptureStackTrace(int iSkip, bool fNeedFileInfo, Thread targetThread, Exception e)
 {
     this.m_iMethodsToSkip += iSkip;
     StackFrameHelper sfh = new StackFrameHelper(fNeedFileInfo, targetThread);
     GetStackFramesInternal(sfh, 0, e);
     this.m_iNumOfFrames = sfh.GetNumberOfFrames();
     if (this.m_iMethodsToSkip > this.m_iNumOfFrames)
     {
         this.m_iMethodsToSkip = this.m_iNumOfFrames;
     }
     if (this.m_iNumOfFrames != 0)
     {
         this.frames = new StackFrame[this.m_iNumOfFrames];
         for (int i = 0; i < this.m_iNumOfFrames; i++)
         {
             bool flag = true;
             bool flag2 = true;
             StackFrame frame = new StackFrame(flag, flag2);
             frame.SetMethodBase(sfh.GetMethodBase(i));
             frame.SetOffset(sfh.GetOffset(i));
             frame.SetILOffset(sfh.GetILOffset(i));
             if (fNeedFileInfo)
             {
                 frame.SetFileName(sfh.GetFilename(i));
                 frame.SetLineNumber(sfh.GetLineNumber(i));
                 frame.SetColumnNumber(sfh.GetColumnNumber(i));
             }
             this.frames[i] = frame;
         }
         if (e == null)
         {
             this.m_iMethodsToSkip += CalculateFramesToSkip(sfh, this.m_iNumOfFrames);
         }
         this.m_iNumOfFrames -= this.m_iMethodsToSkip;
         if (this.m_iNumOfFrames < 0)
         {
             this.m_iNumOfFrames = 0;
         }
     }
     else
     {
         this.frames = null;
     }
 }