Stackframe.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / clr / src / BCL / System / Diagnostics / Stackframe.cs / 1305376 / Stackframe.cs
                        

                        
                            // ==++== 
//
//   Copyright (c) Microsoft Corporation.  All rights reserved.
//
// ==--== 
namespace System.Diagnostics {
 
    using System.Text; 
    using System;
    using System.IO; 
    using System.Reflection;
    using System.Security.Permissions;

    // There is no good reason for the methods of this class to be virtual. 
    // In order to ensure trusted code can trust the data it gets from a
    // StackTrace, we use an InheritanceDemand to prevent partially-trusted 
    // subclasses. 
    [SecurityPermission(SecurityAction.InheritanceDemand, UnmanagedCode=true)]
    [Serializable] 
    [System.Runtime.InteropServices.ComVisible(true)]
    public class StackFrame
    {
        private MethodBase    method; 
        private int         offset;
        private int            ILOffset; 
        private String        strFileName; 
        private int            iLineNumber;
        private int            iColumnNumber; 

        internal void InitMembers()
        {
            method = null; 
            offset = OFFSET_UNKNOWN;
            ILOffset = OFFSET_UNKNOWN; 
            strFileName = null; 
            iLineNumber = 0;
            iColumnNumber = 0; 
        }

        // Constructs a StackFrame corresponding to the active stack frame.
        public StackFrame() 
        {
            InitMembers(); 
            BuildStackFrame (0 + StackTrace.METHODS_TO_SKIP, false);// iSkipFrames=0 
        }
 
        // Constructs a StackFrame corresponding to the active stack frame.
        public StackFrame(bool fNeedFileInfo)
        {
            InitMembers(); 
            BuildStackFrame (0 + StackTrace.METHODS_TO_SKIP, fNeedFileInfo);// iSkipFrames=0
        } 
 
        // Constructs a StackFrame corresponding to a calling stack frame.
        // 
        [System.Security.SecuritySafeCritical]  // auto-generated
        public StackFrame(int skipFrames)
        {
            InitMembers(); 
            BuildStackFrame (skipFrames + StackTrace.METHODS_TO_SKIP, false);
        } 
 
        // Constructs a StackFrame corresponding to a calling stack frame.
        // 
        public StackFrame(int skipFrames, bool fNeedFileInfo)
        {
            InitMembers();
            BuildStackFrame (skipFrames + StackTrace.METHODS_TO_SKIP, fNeedFileInfo); 
        }
 
 
        // Called from the class "StackTrace"
        // 
        internal StackFrame(bool DummyFlag1, bool DummyFlag2)
        {
            InitMembers();
        } 

        // Constructs a "fake" stack frame, just containing the given file 
        // name and line number.  Use when you don't want to use the 
        // debugger's line mapping logic.
        // 
        [System.Security.SecuritySafeCritical]  // auto-generated
        public StackFrame(String fileName, int lineNumber)
        {
            InitMembers(); 
            BuildStackFrame (StackTrace.METHODS_TO_SKIP, false);
            strFileName = fileName; 
            iLineNumber = lineNumber; 
            iColumnNumber = 0;
        } 


        // Constructs a "fake" stack frame, just containing the given file
        // name, line number and column number.  Use when you don't want to 
        // use the debugger's line mapping logic.
        // 
        [System.Security.SecuritySafeCritical]  // auto-generated 
        public StackFrame(String fileName, int lineNumber, int colNumber)
        { 
            InitMembers();
            BuildStackFrame (StackTrace.METHODS_TO_SKIP, false);
            strFileName = fileName;
            iLineNumber = lineNumber; 
            iColumnNumber = colNumber;
        } 
 

        // Constant returned when the native or IL offset is unknown 
        public const int  OFFSET_UNKNOWN = -1;


        internal virtual void SetMethodBase (MethodBase mb) 
        {
            method = mb; 
        } 

        internal virtual void SetOffset (int iOffset) 
        {
            offset = iOffset;
        }
 
        internal virtual void SetILOffset (int iOffset)
        { 
            ILOffset = iOffset; 
        }
 
        internal virtual void SetFileName (String strFName)
        {
            strFileName = strFName;
        } 

        internal virtual void SetLineNumber (int iLine) 
        { 
            iLineNumber = iLine;
        } 

        internal virtual void SetColumnNumber (int iCol)
        {
            iColumnNumber = iCol; 
        }
 
 
        // Returns the method the frame is executing
        // 
        public virtual MethodBase GetMethod ()
        {
            return method;
        } 

        // Returns the offset from the start of the native (jitted) code for the 
        // method being executed 
        //
        public virtual int GetNativeOffset () 
        {
            return offset;
        }
 

        // Returns the offset from the start of the IL code for the 
        // method being executed.  This offset may be approximate depending 
        // on whether the jitter is generating debuggable code or not.
        // 
        public virtual int GetILOffset()
        {
            return ILOffset;
        } 

        // Returns the file name containing the code being executed.  This 
        // information is normally extracted from the debugging symbols 
        // for the executable.
        // 
        [System.Security.SecuritySafeCritical]  // auto-generated
        public virtual String GetFileName()
        {
            if (strFileName != null) 
            {
                // This isn't really correct, but we don't have 
                // a permission that protects discovery of potentially 
                // local urls so we'll use this.
 
                FileIOPermission perm = new FileIOPermission( PermissionState.None );
                perm.AllFiles = FileIOPermissionAccess.PathDiscovery;
                perm.Demand();
            } 

            return strFileName; 
        } 

        // Returns the line number in the file containing the code being executed. 
        // This information is normally extracted from the debugging symbols
        // for the executable.
        //
        public virtual int GetFileLineNumber() 
        {
            return iLineNumber; 
        } 

        // Returns the column number in the line containing the code being executed. 
        // This information is normally extracted from the debugging symbols
        // for the executable.
        //
        public virtual int GetFileColumnNumber() 
        {
            return iColumnNumber; 
        } 

 
        // Builds a readable representation of the stack frame
        //
        [System.Security.SecuritySafeCritical]  // auto-generated
        public override String ToString() 
        {
            StringBuilder sb = new StringBuilder(255); 
 
            if (method != null)
            { 
                sb.Append(method.Name);

                // deal with the generic portion of the method
                if (method is MethodInfo && ((MethodInfo)method).IsGenericMethod) 
                {
                    Type[] typars = ((MethodInfo)method).GetGenericArguments(); 
 
                    sb.Append("<");
                    int k = 0; 
                    bool fFirstTyParam = true;
                    while (k < typars.Length)
                    {
                        if (fFirstTyParam == false) 
                            sb.Append(",");
                        else 
                            fFirstTyParam = false; 

                        sb.Append(typars[k].Name); 
                        k++;
                    }

                    sb.Append(">"); 
                }
 
                sb.Append(" at offset "); 
                if (offset == OFFSET_UNKNOWN)
                    sb.Append(""); 
                else
                    sb.Append(offset);

                sb.Append(" in file:line:column "); 

                bool useFileName = (strFileName != null); 
 
                if (useFileName)
                { 
                    try
                    {
                        // This isn't really correct, but we don't have
                        // a permission that protects discovery of potentially 
                        // local urls so we'll use this.
 
                        FileIOPermission perm = new FileIOPermission(PermissionState.None); 
                        perm.AllFiles = FileIOPermissionAccess.PathDiscovery;
                        perm.Demand(); 
                    }
                    catch (System.Security.SecurityException)
                    {
                        useFileName = false; 
                    }
                } 
 
                if (!useFileName)
                    sb.Append(""); 
                else
                    sb.Append(strFileName);
                sb.Append(":");
                sb.Append(iLineNumber); 
                sb.Append(":");
                sb.Append(iColumnNumber); 
            } 
            else
            { 
                sb.Append("");
            }
            sb.Append(Environment.NewLine);
 
            return sb.ToString();
        } 
 

        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);
                }
            }
        } 
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// ==++== 
//
//   Copyright (c) Microsoft Corporation.  All rights reserved.
//
// ==--== 
namespace System.Diagnostics {
 
    using System.Text; 
    using System;
    using System.IO; 
    using System.Reflection;
    using System.Security.Permissions;

    // There is no good reason for the methods of this class to be virtual. 
    // In order to ensure trusted code can trust the data it gets from a
    // StackTrace, we use an InheritanceDemand to prevent partially-trusted 
    // subclasses. 
    [SecurityPermission(SecurityAction.InheritanceDemand, UnmanagedCode=true)]
    [Serializable] 
    [System.Runtime.InteropServices.ComVisible(true)]
    public class StackFrame
    {
        private MethodBase    method; 
        private int         offset;
        private int            ILOffset; 
        private String        strFileName; 
        private int            iLineNumber;
        private int            iColumnNumber; 

        internal void InitMembers()
        {
            method = null; 
            offset = OFFSET_UNKNOWN;
            ILOffset = OFFSET_UNKNOWN; 
            strFileName = null; 
            iLineNumber = 0;
            iColumnNumber = 0; 
        }

        // Constructs a StackFrame corresponding to the active stack frame.
        public StackFrame() 
        {
            InitMembers(); 
            BuildStackFrame (0 + StackTrace.METHODS_TO_SKIP, false);// iSkipFrames=0 
        }
 
        // Constructs a StackFrame corresponding to the active stack frame.
        public StackFrame(bool fNeedFileInfo)
        {
            InitMembers(); 
            BuildStackFrame (0 + StackTrace.METHODS_TO_SKIP, fNeedFileInfo);// iSkipFrames=0
        } 
 
        // Constructs a StackFrame corresponding to a calling stack frame.
        // 
        [System.Security.SecuritySafeCritical]  // auto-generated
        public StackFrame(int skipFrames)
        {
            InitMembers(); 
            BuildStackFrame (skipFrames + StackTrace.METHODS_TO_SKIP, false);
        } 
 
        // Constructs a StackFrame corresponding to a calling stack frame.
        // 
        public StackFrame(int skipFrames, bool fNeedFileInfo)
        {
            InitMembers();
            BuildStackFrame (skipFrames + StackTrace.METHODS_TO_SKIP, fNeedFileInfo); 
        }
 
 
        // Called from the class "StackTrace"
        // 
        internal StackFrame(bool DummyFlag1, bool DummyFlag2)
        {
            InitMembers();
        } 

        // Constructs a "fake" stack frame, just containing the given file 
        // name and line number.  Use when you don't want to use the 
        // debugger's line mapping logic.
        // 
        [System.Security.SecuritySafeCritical]  // auto-generated
        public StackFrame(String fileName, int lineNumber)
        {
            InitMembers(); 
            BuildStackFrame (StackTrace.METHODS_TO_SKIP, false);
            strFileName = fileName; 
            iLineNumber = lineNumber; 
            iColumnNumber = 0;
        } 


        // Constructs a "fake" stack frame, just containing the given file
        // name, line number and column number.  Use when you don't want to 
        // use the debugger's line mapping logic.
        // 
        [System.Security.SecuritySafeCritical]  // auto-generated 
        public StackFrame(String fileName, int lineNumber, int colNumber)
        { 
            InitMembers();
            BuildStackFrame (StackTrace.METHODS_TO_SKIP, false);
            strFileName = fileName;
            iLineNumber = lineNumber; 
            iColumnNumber = colNumber;
        } 
 

        // Constant returned when the native or IL offset is unknown 
        public const int  OFFSET_UNKNOWN = -1;


        internal virtual void SetMethodBase (MethodBase mb) 
        {
            method = mb; 
        } 

        internal virtual void SetOffset (int iOffset) 
        {
            offset = iOffset;
        }
 
        internal virtual void SetILOffset (int iOffset)
        { 
            ILOffset = iOffset; 
        }
 
        internal virtual void SetFileName (String strFName)
        {
            strFileName = strFName;
        } 

        internal virtual void SetLineNumber (int iLine) 
        { 
            iLineNumber = iLine;
        } 

        internal virtual void SetColumnNumber (int iCol)
        {
            iColumnNumber = iCol; 
        }
 
 
        // Returns the method the frame is executing
        // 
        public virtual MethodBase GetMethod ()
        {
            return method;
        } 

        // Returns the offset from the start of the native (jitted) code for the 
        // method being executed 
        //
        public virtual int GetNativeOffset () 
        {
            return offset;
        }
 

        // Returns the offset from the start of the IL code for the 
        // method being executed.  This offset may be approximate depending 
        // on whether the jitter is generating debuggable code or not.
        // 
        public virtual int GetILOffset()
        {
            return ILOffset;
        } 

        // Returns the file name containing the code being executed.  This 
        // information is normally extracted from the debugging symbols 
        // for the executable.
        // 
        [System.Security.SecuritySafeCritical]  // auto-generated
        public virtual String GetFileName()
        {
            if (strFileName != null) 
            {
                // This isn't really correct, but we don't have 
                // a permission that protects discovery of potentially 
                // local urls so we'll use this.
 
                FileIOPermission perm = new FileIOPermission( PermissionState.None );
                perm.AllFiles = FileIOPermissionAccess.PathDiscovery;
                perm.Demand();
            } 

            return strFileName; 
        } 

        // Returns the line number in the file containing the code being executed. 
        // This information is normally extracted from the debugging symbols
        // for the executable.
        //
        public virtual int GetFileLineNumber() 
        {
            return iLineNumber; 
        } 

        // Returns the column number in the line containing the code being executed. 
        // This information is normally extracted from the debugging symbols
        // for the executable.
        //
        public virtual int GetFileColumnNumber() 
        {
            return iColumnNumber; 
        } 

 
        // Builds a readable representation of the stack frame
        //
        [System.Security.SecuritySafeCritical]  // auto-generated
        public override String ToString() 
        {
            StringBuilder sb = new StringBuilder(255); 
 
            if (method != null)
            { 
                sb.Append(method.Name);

                // deal with the generic portion of the method
                if (method is MethodInfo && ((MethodInfo)method).IsGenericMethod) 
                {
                    Type[] typars = ((MethodInfo)method).GetGenericArguments(); 
 
                    sb.Append("<");
                    int k = 0; 
                    bool fFirstTyParam = true;
                    while (k < typars.Length)
                    {
                        if (fFirstTyParam == false) 
                            sb.Append(",");
                        else 
                            fFirstTyParam = false; 

                        sb.Append(typars[k].Name); 
                        k++;
                    }

                    sb.Append(">"); 
                }
 
                sb.Append(" at offset "); 
                if (offset == OFFSET_UNKNOWN)
                    sb.Append(""); 
                else
                    sb.Append(offset);

                sb.Append(" in file:line:column "); 

                bool useFileName = (strFileName != null); 
 
                if (useFileName)
                { 
                    try
                    {
                        // This isn't really correct, but we don't have
                        // a permission that protects discovery of potentially 
                        // local urls so we'll use this.
 
                        FileIOPermission perm = new FileIOPermission(PermissionState.None); 
                        perm.AllFiles = FileIOPermissionAccess.PathDiscovery;
                        perm.Demand(); 
                    }
                    catch (System.Security.SecurityException)
                    {
                        useFileName = false; 
                    }
                } 
 
                if (!useFileName)
                    sb.Append(""); 
                else
                    sb.Append(strFileName);
                sb.Append(":");
                sb.Append(iLineNumber); 
                sb.Append(":");
                sb.Append(iColumnNumber); 
            } 
            else
            { 
                sb.Append("");
            }
            sb.Append(Environment.NewLine);
 
            return sb.ToString();
        } 
 

        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);
                }
            }
        } 
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK