2 // System.Diagnostics.DefaultTraceListener.cs
5 // Jonathan Pryor (jonpryor@vt.edu)
6 // Atsushi Enomoto (atsushi@ximian.com)
8 // Comments from John R. Hicks <angryjohn69@nc.rr.com> original implementation
9 // can be found at: /mcs/docs/apidocs/xml/en/System.Diagnostics
11 // (C) 2002 Jonathan Pryor
12 // (C) 2007 Novell, Inc.
16 // Permission is hereby granted, free of charge, to any person obtaining
17 // a copy of this software and associated documentation files (the
18 // "Software"), to deal in the Software without restriction, including
19 // without limitation the rights to use, copy, modify, merge, publish,
20 // distribute, sublicense, and/or sell copies of the Software, and to
21 // permit persons to whom the Software is furnished to do so, subject to
22 // the following conditions:
24 // The above copyright notice and this permission notice shall be
25 // included in all copies or substantial portions of the Software.
27 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
28 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
29 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
30 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
31 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
32 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
33 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
38 using System.Collections;
39 using System.Diagnostics;
40 using System.Reflection;
41 using System.Runtime.CompilerServices;
42 using System.Runtime.InteropServices;
43 using System.Threading;
45 namespace System.Diagnostics {
46 public class DefaultTraceListener : TraceListener {
48 private static readonly bool OnWin32;
50 private const string ConsoleOutTrace = "Console.Out";
51 private const string ConsoleErrorTrace = "Console.Error";
53 private static readonly string MonoTracePrefix;
54 private static readonly string MonoTraceFile;
56 static DefaultTraceListener ()
58 // Determine what platform we're on. This impacts how where we send
59 // messages. On Win32 platforms (OnWin32 = true), we use the
60 // `OutputDebugString' api.
62 // On Linux platforms, we use MONO_TRACE_LISTENER to figure things out. See the
63 // API documentation for more information on MONO_TRACE_LISTENER.
64 OnWin32 = (Path.DirectorySeparatorChar == '\\');
68 string trace = java.lang.System.getProperty("MONO_TRACE");
70 // If we're running on Unix, we don't have OutputDebugString.
71 // Instead, send output to...wherever the MONO_TRACE_LISTENER environment
73 String trace = Environment.GetEnvironmentVariable("MONO_TRACE_LISTENER");
78 trace = ConsoleOutTrace;
85 if (trace.StartsWith (ConsoleOutTrace)) {
86 file = ConsoleOutTrace;
87 prefix = GetPrefix (trace, ConsoleOutTrace);
89 else if (trace.StartsWith (ConsoleErrorTrace)) {
90 file = ConsoleErrorTrace;
91 prefix = GetPrefix (trace, ConsoleErrorTrace);
96 // We can't firgure out what the prefix would be, as ':' is a
97 // valid filename character. Thus, arbitrary files don't support
100 // I don't consider this to be a major issue. Prefixes are useful
101 // with Console.Out and Console.Error to help separate trace
102 // output from the actual program output. Writing to an arbitrary
103 // file doesn't introduce issues with disambiguation.
107 MonoTraceFile = file;
108 MonoTracePrefix = prefix;
114 * Get the prefix for the specified variable.
116 * "Prefixes" are used in the MONO_TRACE_LISTENER variable, and specify text that
117 * should precede each message printed to the console. The prefix is
118 * appended to the console location with a colon (':') separating them.
119 * For example, if MONO_TRACE_LISTENER is "Console.Out:** my prefix", the prefix is
122 * Everything after the colon, if the colon is present, is used as the
125 * @param var The current MONO_TRACE_LISTENER variable
126 * @param target The name of the output location, e.g. "Console.Out"
128 private static string GetPrefix (string var, string target)
130 // actually, we permit any character to separate `target' and the prefix;
131 // we just skip over target the ':' would be. This means that a space or
132 // anything else would suffice, as long as it was only a single
134 if (var.Length > target.Length)
135 return var.Substring (target.Length + 1);
139 private string logFileName = null;
141 private bool assertUiEnabled = false;
143 public DefaultTraceListener () : base ("Default")
147 public bool AssertUiEnabled {
148 get { return assertUiEnabled; }
149 set { assertUiEnabled = value; }
153 public string LogFileName {
154 get {return logFileName;}
155 set {logFileName = value;}
158 public override void Fail (string message)
163 public override void Fail (string message, string detailMessage)
165 base.Fail (message, detailMessage);
166 if (ProcessUI (message, detailMessage) == DialogResult.Abort)
167 Thread.CurrentThread.Abort ();
168 WriteLine (new StackTrace().ToString());
171 DialogResult ProcessUI (string message, string detailMessage)
174 if (!AssertUiEnabled)
175 return DialogResult.None;
177 object messageBoxButtonsAbortRetryIgnore;
178 MethodInfo msgboxShow;
181 Assembly wfAsm = Assembly.Load (Consts.AssemblySystem_Windows_Forms);
183 return DialogResult.None;
185 Type buttons = wfAsm.GetType ("System.Windows.Forms.MessageBoxButtons");
186 messageBoxButtonsAbortRetryIgnore = Enum.Parse (buttons, "AbortRetryIgnore");
187 msgboxShow = wfAsm.GetType ("System.Windows.Forms.MessageBox").GetMethod (
189 new Type [] {typeof (string), typeof (string), buttons});
191 return DialogResult.None;
194 if (msgboxShow == null || messageBoxButtonsAbortRetryIgnore == null)
195 return DialogResult.None;
197 string caption = String.Format ("Assertion Failed: {0} to quit, {1} to debug, {2} to continue", "Abort", "Retry", "Ignore");
198 string msg = String.Format ("{0}{1}{2}{1}{1}{3}", message, Environment.NewLine, detailMessage, new StackTrace ());
200 switch (msgboxShow.Invoke (null, new object [] {msg, caption, messageBoxButtonsAbortRetryIgnore}).ToString ()) {
202 return DialogResult.Ignore;
204 return DialogResult.Abort;
206 return DialogResult.Retry;
218 private void WriteDebugString (string message)
221 [MethodImplAttribute(MethodImplOptions.InternalCall)]
222 private extern static void WriteWindowsDebugString (string message);
224 private void WriteDebugString (string message)
227 WriteWindowsDebugString (message);
230 WriteMonoTrace (message);
233 private void WriteMonoTrace (string message)
235 switch (MonoTraceFile) {
236 case ConsoleOutTrace:
237 Console.Out.Write (message);
239 case ConsoleErrorTrace:
240 Console.Error.Write (message);
243 WriteLogFile (message, MonoTraceFile);
248 private void WritePrefix ()
251 WriteMonoTrace (MonoTracePrefix);
255 private void WriteImpl (string message)
262 WriteDebugString (message);
264 if (Debugger.IsLogging())
265 Debugger.Log (0, null, message);
267 WriteLogFile (message, LogFileName);
270 private void WriteLogFile (string message, string logFile)
272 string fname = logFile;
273 if (fname != null && fname.Length != 0) {
274 FileInfo info = new FileInfo (fname);
275 StreamWriter sw = null;
280 sw = info.AppendText ();
282 sw = info.CreateText ();
285 // We weren't able to open the file for some reason.
286 // We can't write to the log file; so give up.
297 public override void Write (string message)
302 public override void WriteLine (string message)
304 string msg = message + Environment.NewLine;