mcs/class/System/System.Diagnostics/StackTrace.jvm.cs

   1 //\r
   2 // System.Diagnostics.StackTrace.cs\r
   3 //\r
   4 // Author:\r
   5 //      Alexander Klyubin (klyubin@aqris.com)\r
   6 //      Dietmar Maurer (dietmar@ximian.com)\r
   7 //\r
   8 // (C) 2001\r
   9 //\r
  10 \r
  11 using System;\r
  12 using System.Reflection;\r
  13 using System.Threading;\r
  14 using System.Runtime.CompilerServices;\r
  15 using System.Collections;\r
  16 \r
  17 namespace System.Diagnostics {\r
  18         /// <summary>\r
  19         ///   Stack trace.\r
  20         ///   TODO: more information.\r
  21         /// </summary>\r
  22         [Serializable]\r
  23         public class StackTrace {\r
  24                 /// <value>\r
  25                 ///   Uses a constant to define the number of methods that are\r
  26                 ///   to be omitted from the stack trace.\r
  27                 /// </value>\r
  28                 public const int METHODS_TO_SKIP = 0;\r
  29                 \r
  30                 /// <value>\r
  31                 ///   Frames. First frame is the last stack frame pushed.\r
  32                 /// </value>\r
  33                 private StackFrame[] frames;\r
  34 \r
  35                 /// <summary>\r
  36                 ///   Initializes a new instance of the StackTrace class.\r
  37                 /// </summary>\r
  38                 [MonoTODO]\r
  39                 public StackTrace() {\r
  40                         init_frames (METHODS_TO_SKIP, false);\r
  41                 }\r
  42                 \r
  43                 /// <summary>\r
  44                 ///   Initializes a new instance of the StackTrace class.\r
  45                 /// </summary>\r
  46                 /// <param name="needFileInfo">\r
  47                 ///   TODO:\r
  48                 /// </param>\r
  49                 public StackTrace(bool needFileInfo) {\r
  50                         init_frames (METHODS_TO_SKIP, needFileInfo);\r
  51                 }\r
  52 \r
  53                 /// <summary>\r
  54                 ///   Initializes a new instance of the StackTrace class\r
  55                 ///   from the current location, in a caller's frame.\r
  56                 /// </summary>\r
  57                 /// <param name="skipFrames">\r
  58                 ///   The number of frames up the stack to start the trace\r
  59                 ///   from.\r
  60                 /// </param>\r
  61                 public StackTrace(int skipFrames) {\r
  62                         init_frames (skipFrames, false);\r
  63                 }\r
  64 \r
  65                 /// <summary>\r
  66                 ///   Initializes a new instance of the StackTrace class\r
  67                 ///   from the current location, in a caller's frame.\r
  68                 /// </summary>\r
  69                 /// <param name="skipFrames">\r
  70                 ///   The number of frames up the stack to start the trace\r
  71                 ///   from.\r
  72                 /// </param>\r
  73                 /// <param name="needFileInfo">\r
  74                 ///   TODO:\r
  75                 /// </param>\r
  76                 public StackTrace(int skipFrames, bool needFileInfo) {\r
  77                         init_frames (skipFrames, needFileInfo);\r
  78                 }\r
  79 \r
  80                 void init_frames (int skipFrames, bool needFileInfo)\r
  81                 {\r
  82                         StackFrame sf;\r
  83                         ArrayList al = new ArrayList ();\r
  84 \r
  85                         skipFrames += 2;\r
  86                         \r
  87                         while ((sf = new StackFrame (skipFrames, needFileInfo)) != null &&\r
  88                                sf.GetMethod () != null) {\r
  89                                 \r
  90                                 al.Add (sf);\r
  91                                 skipFrames++;\r
  92                         };\r
  93 \r
  94                         frames = (StackFrame [])al.ToArray (typeof (StackFrame));\r
  95                 }\r
  96 #if TARGET_JVM\r
  97                 static StackFrame [] get_trace (Exception e, int skipFrames, bool needFileInfo)\r
  98                 {\r
  99                         return null;\r
 100                 }\r
 101 #else\r
 102                 [MethodImplAttribute(MethodImplOptions.InternalCall)]\r
 103                 extern static StackFrame [] get_trace (Exception e, int skipFrames, bool needFileInfo);\r
 104 #endif\r
 105                 /// <summary>\r
 106                 ///   Initializes a new instance of the StackTrace class.\r
 107                 /// </summary>\r
 108                 /// <param name="e">\r
 109                 ///   TODO:\r
 110                 /// </param>\r
 111                 public StackTrace(Exception e) \r
 112                                 {\r
 113                         frames = get_trace (e, METHODS_TO_SKIP, false);\r
 114                 }\r
 115                                 \r
 116                 /// <summary>\r
 117                 ///   Initializes a new instance of the StackTrace class,\r
 118                 ///   using the provided exception object. The resulting stack\r
 119                 ///   trace describes the stack at the time of the exception.\r
 120                 /// </summary>\r
 121                 /// <param name="e">\r
 122                 ///   TODO:\r
 123                 /// </param>\r
 124                 /// <param name="needFileInfo">\r
 125                 ///   TODO:\r
 126                 /// </param>\r
 127                 public StackTrace(Exception e, bool needFileInfo) {\r
 128                         frames = get_trace (e, METHODS_TO_SKIP, needFileInfo);\r
 129                 }\r
 130                 \r
 131                 /// <summary>\r
 132                 ///   Initializes a new instance of the StackTrace class,\r
 133                 ///   using the provided exception object. The resulting stack\r
 134                 ///   trace describes the stack at the time of the exception.\r
 135                 /// </summary>\r
 136                 /// <param name="e">\r
 137                 ///   Exception.\r
 138                 /// </param>\r
 139                 /// <param name="skipFrames">\r
 140                 ///   The number of frames up the stack to start the trace\r
 141                 ///   from.\r
 142                 /// </param>\r
 143                 public StackTrace(Exception e, int skipFrames) {\r
 144                         frames = get_trace (e, skipFrames, false);\r
 145                 }\r
 146                 \r
 147                 /// <summary>\r
 148                 ///   Initializes a new instance of the StackTrace class,\r
 149                 ///   using the provided exception object. The resulting stack\r
 150                 ///   trace describes the stack at the time of the exception.\r
 151                 /// </summary>\r
 152                 /// <param name="e">\r
 153                 ///   Exception.\r
 154                 /// </param>\r
 155                 /// <param name="skipFrames">\r
 156                 ///   The number of frames up the stack to start the trace\r
 157                 ///   from.\r
 158                 /// </param>\r
 159                 /// <param name="needFileInfo">\r
 160                 ///   TODO:\r
 161                 /// </param>\r
 162                 public StackTrace(Exception e, int skipFrames, bool needFileInfo) {\r
 163                         frames = get_trace (e, skipFrames, needFileInfo);\r
 164                 }\r
 165                               \r
 166                 /// <summary>\r
 167                 ///   Initializes a new instance of the StackTrace class\r
 168                 ///   containing a single frame.\r
 169                 /// </summary>\r
 170                 /// <param name="frame">\r
 171                 ///   The frame that the StackTrace object should contain.\r
 172                 /// </param>\r
 173                 public StackTrace(StackFrame frame) {\r
 174                         this.frames = new StackFrame[1];\r
 175                         this.frames[0] = frame;\r
 176                 }\r
 177                                \r
 178                 /// <summary>\r
 179                 ///   Initializes a new instance of the StackTrace class.\r
 180                 /// </summary>\r
 181                 /// <param name="targetThread">\r
 182                 ///   TODO:\r
 183                 /// </param>\r
 184                 /// <param name="needFileInfo">\r
 185                 ///   TODO:\r
 186                 /// </param>\r
 187                 [MonoTODO]\r
 188                 public StackTrace(Thread targetThread, bool needFileInfo) {\r
 189                         throw new NotImplementedException();\r
 190                 }\r
 191                \r
 192                 /// <summary>\r
 193                 ///   Holds the number of frames in the stack trace.\r
 194                 /// </summary>\r
 195                 public virtual int FrameCount {\r
 196                         get {\r
 197                                 return (frames == null) ? 0 : frames.Length;\r
 198                         }\r
 199                 }             \r
 200                               \r
 201                 /// <summary>\r
 202                 ///   Gets the specified stack frame.\r
 203                 /// </summary>\r
 204                 /// <param name="index">\r
 205                 ///   The index of the stack frame requested.\r
 206                 /// </param>\r
 207                 /// <returns>\r
 208                 ///   The specified stack frame. Returns <code>null</code> if\r
 209                 ///   frame with specified index does not exist in this stack\r
 210                 ///   trace.\r
 211                 /// </returns>\r
 212                 /// <remarks>\r
 213                 ///   Stack frames are numbered starting at zero, which is the\r
 214                 ///   last stack frame pushed.\r
 215                 /// </remarks>\r
 216                 public virtual StackFrame GetFrame(int index) {\r
 217                         if ((index < 0) || (index >= FrameCount)) {\r
 218                                 return null;\r
 219                         }\r
 220                         \r
 221                         return frames[index];\r
 222                 }              \r
 223                 \r
 224                 /// <summary>\r
 225                 ///   Builds a readable representation of the stack trace.\r
 226                 /// </summary>\r
 227                 /// <returns>\r
 228                 ///   A readable representation of the stack trace.\r
 229                 /// </returns>\r
 230                 public override string ToString() {\r
 231                         string result = "";\r
 232                         for (int i = 0; i < FrameCount; i++) {\r
 233                                 StackFrame frame = GetFrame(i);\r
 234                                 result += "\n\tat " + FrameToString(frame);\r
 235                         }\r
 236                         \r
 237                         return result;\r
 238                 }\r
 239                 \r
 240                 public override bool Equals(Object obj) {\r
 241                         if ((obj == null) || (!(obj is StackTrace))) {\r
 242                                 return false;\r
 243                         }\r
 244                         \r
 245                         StackTrace rhs = (StackTrace) obj;\r
 246                         \r
 247                         if (FrameCount != rhs.FrameCount) {\r
 248                                 return false;\r
 249                         }\r
 250                         \r
 251                         for (int i = 0; i < FrameCount; i++) {\r
 252                                 if (!GetFrame(i).Equals(rhs.GetFrame(i))) {\r
 253                                         return false;\r
 254                                 }\r
 255                         }\r
 256                         \r
 257                         return true;\r
 258                 }\r
 259                 \r
 260                 public override int GetHashCode() {\r
 261                         return FrameCount;\r
 262                 }\r
 263                 \r
 264                 /// <summary>\r
 265                 ///   Converts single stack frame to string to be used in\r
 266                 ///   ToString method.\r
 267                 /// </summary>\r
 268                 /// <param name="frame">\r
 269                 ///   Frame to convert.\r
 270                 /// </param>\r
 271                 /// <returns>\r
 272                 ///   A readable representation of stack frame for using\r
 273                 ///   ToString.\r
 274                 /// </returns>\r
 275                 private static String FrameToString(StackFrame frame) {\r
 276                         MethodBase method = frame.GetMethod();\r
 277                         if (method != null) {\r
 278                                 // Method information available\r
 279                                 return  method.DeclaringType.FullName\r
 280                                         + "." + method.Name + "()";\r
 281                         } else {\r
 282                                 // Method information not available\r
 283                                 return "<unknown method>";\r
 284                         }\r
 285                 }\r
 286         }\r
 287 }\r