private void SubmitTraceEvent(CompilerEvent compilerEvent, string message, int threadID)
{
if (compilerEvent == CompilerEvent.StatusUpdate)
{
return;
}
var log = CreateTimeStampedLog(compilerEvent, message, threadID);
lock (compilerStageLock)
{
if (compilerEvent == CompilerEvent.Error)
{
UpdateLog("Error", message);
UpdateLog("Compiler", log);
}
if (compilerEvent == CompilerEvent.Exception)
{
UpdateLog("Exception", message);
UpdateLog("Compiler", log);
}
else if (compilerEvent == CompilerEvent.Counter)
{
UpdateLog("Counters", message);
}
else
{
UpdateLog("Compiler", log);
}
}
}
private void NotifyEvent(CompilerEvent compilerEvent, string message, int threadID)
{
if (compilerEvent == CompilerEvent.CompileStart ||
compilerEvent == CompilerEvent.CompileEnd ||
compilerEvent == CompilerEvent.CompilingMethods ||
compilerEvent == CompilerEvent.CompilingMethodsCompleted ||
compilerEvent == CompilerEvent.InlineMethodsScheduled ||
compilerEvent == CompilerEvent.LinkingStart ||
compilerEvent == CompilerEvent.LinkingEnd ||
compilerEvent == CompilerEvent.Warning ||
compilerEvent == CompilerEvent.Error ||
compilerEvent == CompilerEvent.Exception)
{
string status = $"Compiling: {$"{(DateTime.Now - CompileStartTime).TotalSeconds:0.00}"} secs: {compilerEvent.ToText()}";
if (!string.IsNullOrEmpty(message))
{
status += $"- { message}";
}
Output(status);
}
else if (compilerEvent == CompilerEvent.Counter)
{
AddCounters(message);
}
}
public static string ToText(this CompilerEvent stage)
{
switch (stage)
{
case CompilerEvent.CompilingMethod: return("Compiling Method");
case CompilerEvent.CompilingType: return("Compiling Type");
case CompilerEvent.SchedulingType: return("Scheduling Type");
case CompilerEvent.SchedulingMethod: return("Scheduling Method");
case CompilerEvent.Linking: return("Linking");
case CompilerEvent.DebugInfo: return("Debug Info");
case CompilerEvent.PreCompileStageStart: return("Pre-Compile Stage Started");
case CompilerEvent.PreCompileStageEnd: return("Pre-Compile Stage Ended");
case CompilerEvent.PostCompileStageStart: return("Post-Compile Stage Started");
case CompilerEvent.PostCompileStageEnd: return("Post-Compile Stage Ended");
case CompilerEvent.Error: return("Error");
case CompilerEvent.Exception: return("Exception");
case CompilerEvent.Warning: return("Warning");
default: return(stage.ToString());
}
}
public void NewCompilerTraceEvent(CompilerEvent compilerStage, string message, int threadID)
{
if (TraceListener == null)
return;
TraceListener.OnNewCompilerTraceEvent(compilerStage, message, threadID);
}
void ITraceListener.OnCompilerEvent(CompilerEvent compilerEvent, string message, int threadID)
{
if (compilerEvent == CompilerEvent.CompilerStart ||
compilerEvent == CompilerEvent.CompilerEnd ||
compilerEvent == CompilerEvent.CompilingMethods ||
compilerEvent == CompilerEvent.CompilingMethodsCompleted ||
compilerEvent == CompilerEvent.InlineMethodsScheduled ||
compilerEvent == CompilerEvent.LinkingStart ||
compilerEvent == CompilerEvent.LinkingEnd ||
compilerEvent == CompilerEvent.Warning ||
compilerEvent == CompilerEvent.Error ||
compilerEvent == CompilerEvent.Exception)
{
string status = $"Compiling: {$"{(DateTime.Now - builder.CompileStartTime).TotalSeconds:0.00}"} secs: {compilerEvent.ToText()}";
if (!string.IsNullOrEmpty(message))
{
status += $"- { message}";
}
lock (_lock)
{
builder.AddOutput(status);
}
}
else if (compilerEvent == CompilerEvent.Counter)
{
lock (_lock)
{
builder.AddCounters(message);
}
}
}
private void SubmitTraceEventGUI(CompilerEvent compilerEvent, string info)
{
if (compilerEvent != CompilerEvent.DebugInfo)
{
SetStatus(compilerEvent.ToText() + ": " + info);
toolStripStatusLabel1.GetCurrentParent().Refresh();
}
}
void ITraceListener.OnNewCompilerTraceEvent(CompilerEvent compilerEvent, string message, int threadID)
{
SubmitTraceEvent(compilerEvent, message, threadID);
MethodInvoker call = () => SubmitTraceEventGUI(compilerEvent, message);
Invoke(call);
}
void ITraceListener.OnNewCompilerTraceEvent(CompilerEvent compilerStage, string info, int threadID)
{
MethodInvoker call = delegate()
{
SubmitTraceEvent(compilerStage, info);
};
Invoke(call);
}
void ITraceListener.OnCompilerEvent(CompilerEvent compilerEvent, string message, int threadID)
{
lock (_statusLock)
{
Status = compilerEvent.ToText() + ": " + message;
}
SubmitTraceEvent(compilerEvent, message, threadID);
}
public void PostCompilerTraceEvent(CompilerEvent compilerEvent, string message, int threadID)
{
if (TraceListener == null)
{
return;
}
TraceListener.OnCompilerEvent(compilerEvent, message, threadID);
}
private void SubmitTraceEvent(CompilerEvent compilerStage, string info)
{
if (compilerStage == CompilerEvent.CompilerStageStart || compilerStage == CompilerEvent.CompilerStageEnd)
{
string status = "Compiling: " + String.Format("{0:0.00}", (DateTime.Now - compileStartTime).TotalSeconds) + " secs: " + compilerStage.ToText() + ": " + info;
toolStripStatusLabel1.Text = status;
toolStripStatusLabel1.GetCurrentParent().Refresh();
AddOutput(status);
}
}
private void NotifyEvent(CompilerEvent compilerEvent, string message, int threadID)
{
message = string.IsNullOrWhiteSpace(message) ? string.Empty : $"{message}";
var status = $"{compilerEvent.ToText()}{message}";
lock (_statusLock)
{
Status = status;
}
SubmitTraceEvent(compilerEvent, message, threadID);
}
public static string ToText(this CompilerEvent stage)
{
switch (stage)
{
case CompilerEvent.CompilerStart: return("Compiler Started");
case CompilerEvent.CompilerEnd: return("Compiler Completed");
case CompilerEvent.CompilingMethods: return("Compiling Methods");
case CompilerEvent.CompilingMethodsCompleted: return("Compiling Methods Completed");
case CompilerEvent.MethodCompileStart: return("Method Compile Started");
case CompilerEvent.MethodCompileEnd: return("Method Compile Completed");
case CompilerEvent.MethodScheduled: return("Method Scheduled");
case CompilerEvent.InlineMethodsScheduled: return("Inline Methods Scheduled");
case CompilerEvent.LinkingStart: return("Linking Started");
case CompilerEvent.LinkingEnd: return("Linking Completed");
case CompilerEvent.SetupStart: return("Setup Started");
case CompilerEvent.SetupEnd: return("Setup Completed");
case CompilerEvent.FinalizationStart: return("Finalization Started");
case CompilerEvent.FinalizationEnd: return("Finalization Completed");
case CompilerEvent.SetupStageStart: return("Setup Stage Started");
case CompilerEvent.SetupStageEnd: return("Setup Stage Completed");
case CompilerEvent.FinalizationStageStart: return("Finalization Stage Started");
case CompilerEvent.FinalizationStageEnd: return("Finalization Stage Completed");
case CompilerEvent.DebugInfo: return("Debug Info");
case CompilerEvent.Warning: return("Warning");
case CompilerEvent.Error: return("Error");
case CompilerEvent.Exception: return("Exception");
default: return(stage.ToString());
}
}
private void NotifyEvent(CompilerEvent compilerEvent, string message, int threadID)
{
if (compilerEvent != CompilerEvent.MethodCompileEnd &&
compilerEvent != CompilerEvent.MethodCompileStart &&
compilerEvent != CompilerEvent.Counter &&
compilerEvent != CompilerEvent.SetupStageStart &&
compilerEvent != CompilerEvent.SetupStageEnd &&
compilerEvent != CompilerEvent.FinalizationStageStart &&
compilerEvent != CompilerEvent.FinalizationStageEnd)
{
message = string.IsNullOrWhiteSpace(message) ? string.Empty : $": {message}";
Console.WriteLine($"{(DateTime.Now - CompileStartTime).TotalSeconds:0.00} [{threadID}] {compilerEvent.ToText()}{message}");
}
}
private void NotifyEvent(CompilerEvent compilerEvent, string message, int threadID)
{
if (compilerEvent != CompilerEvent.Counter)
{
var status = compilerEvent.ToText() + (string.IsNullOrWhiteSpace(message) ? string.Empty : $": {message}");
lock (_statusLock)
{
Status = status;
}
}
SubmitTraceEvent(compilerEvent, message, threadID);
}
void ITraceListener.OnNewCompilerTraceEvent(CompilerEvent compilerStage, string message, int threadID)
{
lock (mylock)
{
if (compilerStage == CompilerEvent.CompilerStageStart || compilerStage == CompilerEvent.CompilerStageEnd || compilerStage == CompilerEvent.Exception)
{
string status = "Compiling: " + String.Format("{0:0.00}", (DateTime.Now - builder.CompileStartTime).TotalSeconds) + " secs: " + compilerStage.ToText() + ": " + message;
builder.AddOutput(status);
}
else if (compilerStage == CompilerEvent.Counter)
{
builder.AddCounters(message);
}
}
}
void ITraceListener.OnNewCompilerTraceEvent(CompilerEvent compilerStage, string message, int threadID)
{
lock (mylock)
{
if (compilerStage == CompilerEvent.CompilerStageStart || compilerStage == CompilerEvent.CompilerStageEnd || compilerStage == CompilerEvent.Exception)
{
string status = "Compiling: " + String.Format("{0:0.00}", (DateTime.Now - builder.CompileStartTime).TotalSeconds) + " secs: " + compilerStage.ToText() + ": " + message;
builder.AddOutput(status);
}
else if (compilerStage == CompilerEvent.Counter)
{
builder.AddCounters(message);
}
}
}
void ITraceListener.OnCompilerEvent(CompilerEvent compilerEvent, string message, int threadID)
{
if (compilerEvent == CompilerEvent.PreCompileStageStart ||
compilerEvent == CompilerEvent.PreCompileStageEnd ||
compilerEvent == CompilerEvent.PostCompileStageStart ||
compilerEvent == CompilerEvent.PostCompileStageEnd ||
compilerEvent == CompilerEvent.Exception)
{
string status = $"Compiling: {$"{(DateTime.Now - builder.CompileStartTime).TotalSeconds:0.00}"} secs: {compilerEvent.ToText()}: {message}";
lock (_lock)
{
builder.AddOutput(status);
}
}
else if (compilerEvent == CompilerEvent.Counter)
{
lock (_lock)
{
builder.AddCounters(message);
}
}
}
private void SubmitTraceEvent(CompilerEvent compilerStage, string message, int threadID)
{
lock (compilerStageLock)
{
if (compilerStage == CompilerEvent.Error)
{
errorLog.Append(compilerStage.ToText()).Append(": ").AppendLine(message);
compileLog.AppendFormat("{0:0.00}", (DateTime.Now - compileStartTime).TotalSeconds).Append(" [").Append(threadID.ToString()).Append("] ").Append(compilerStage.ToText()).Append(": ").AppendLine(message);
}
if (compilerStage == CompilerEvent.Exception)
{
var stringBuilder = exceptionLog.Append(compilerStage.ToText()).Append(": ").AppendLine(message);
var stringBuilder2 = compileLog.AppendFormat("{0:0.00}", (DateTime.Now - compileStartTime).TotalSeconds).Append(" [").Append(threadID.ToString()).Append("] ").Append(compilerStage.ToText()).Append(": ").AppendLine(message);
}
else if (compilerStage == CompilerEvent.Counter)
{
counterLog.Append(compilerStage.ToText()).Append(": ").AppendLine(message);
}
else
{
compileLog.AppendFormat("{0:0.00}", (DateTime.Now - compileStartTime).TotalSeconds).Append(" [").Append(threadID.ToString()).Append("] ").Append(compilerStage.ToText()).Append(": ").AppendLine(message);
}
}
}
private void SubmitTraceEvent(CompilerEvent compilerEvent, string message, int threadID)
{
var part = string.IsNullOrWhiteSpace(message) ? string.Empty : ": " + message;
var msg = $"{compilerEvent.ToText()}{part}";
var timelog = $"{(DateTime.Now - compileStartTime).TotalSeconds:0.00} [{threadID}] {msg}";
lock (compilerStageLock)
{
if (compilerEvent == CompilerEvent.Error)
{
UpdateLog("Error", msg);
UpdateLog("Compiler", timelog);
}
if (compilerEvent == CompilerEvent.Exception)
{
UpdateLog("Exception", msg);
UpdateLog("Compiler", timelog);
}
else if (compilerEvent == CompilerEvent.Counter)
{
if (message.StartsWith("Transform-"))
{
UpdateLog("Transforms", message.Substring(10));
}
else
{
UpdateLog("Counters", message);
}
}
else
{
UpdateLog("Compiler", timelog);
}
}
}
private void SubmitTraceEvent(CompilerEvent compilerStage, string message, int threadID)
{
lock (compilerStageLock)
{
if (compilerStage == CompilerEvent.Error)
{
errorLog.AppendLine(compilerStage.ToText() + ": " + message);
compileLog.AppendLine(String.Format("{0:0.00}", (DateTime.Now - compileStartTime).TotalSeconds) + " [" + threadID.ToString() + "] " + compilerStage.ToText() + ": " + message);
}
if (compilerStage == CompilerEvent.Exception)
{
exceptionLog.AppendLine(compilerStage.ToText() + ": " + message);
compileLog.AppendLine(String.Format("{0:0.00}", (DateTime.Now - compileStartTime).TotalSeconds) + " [" + threadID.ToString() + "] " + compilerStage.ToText() + ": " + message);
}
else if (compilerStage == CompilerEvent.Counter)
{
counterLog.AppendLine(compilerStage.ToText() + ": " + message);
}
else
{
compileLog.AppendLine(String.Format("{0:0.00}", (DateTime.Now - compileStartTime).TotalSeconds) + " [" + threadID.ToString() + "] " + compilerStage.ToText() + ": " + message);
}
}
}
void ITraceListener.OnNewCompilerTraceEvent(CompilerEvent compilerStage, string info, int threadID)
{
Debug.WriteLine(compilerStage.ToString() + ": " + info);
}
private string CreateTimeStampedLog(CompilerEvent compilerEvent, string message, int threadID = 0)
{
return($"{(DateTime.Now - compileStartTime).TotalSeconds:0.00} [{threadID.ToString()}] {compilerEvent.ToText()}: {message}");
}
void ITraceListener.OnNewCompilerTraceEvent(CompilerEvent compilerEvent, string message, int threadID)
{
Debug.WriteLine(compilerEvent.ToString() + ": " + message);
}
protected void Trace(CompilerEvent compilerEvent, string message)
{
methodCompiler.InternalLog.CompilerEventListener.SubmitTraceEvent(compilerEvent, message);
}
/// <summary>
/// Traces the specified compiler event.
/// </summary>
/// <param name="compilerEvent">The compiler event.</param>
/// <param name="message">The message.</param>
protected void NewCompilerTraceEvent(CompilerEvent compilerEvent, string message)
{
CompilerTrace.NewCompilerTraceEvent(compilerEvent, message, 0);
}
void ITraceListener.OnNewCompilerTraceEvent(CompilerEvent compilerStage, string info, int threadID)
{
TraceEvent(compilerStage, info);
}
void ITraceListener.OnNewCompilerTraceEvent(CompilerEvent compilerStage, string info, int threadID)
{
}
void ICompilerEventListener.SubmitTraceEvent(CompilerEvent compilerStage, string info)
{
if (DebugOutput)
Debug.WriteLine(compilerStage.ToString() + ": " + info);
if (!ConsoleOutput)
return;
switch (compilerStage)
{
case CompilerEvent.CompilingMethod:
{
if (Quiet)
{
supressed = info;
break;
}
DisplayCompilingMethod(info);
break;
}
case CompilerEvent.CompilingType:
{
if (Quiet) break;
Console.ForegroundColor = ConsoleColor.Yellow;
Console.Write(@"[Compiling] ");
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(info);
break;
}
case CompilerEvent.SchedulingType:
{
if (Quiet) break;
Console.ForegroundColor = ConsoleColor.Blue;
Console.Write(@"[Scheduling] ");
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(info);
break;
}
case CompilerEvent.SchedulingMethod:
{
if (Quiet) break;
Console.ForegroundColor = ConsoleColor.Blue;
Console.Write(@"[Scheduling] ");
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(info);
break;
}
case CompilerEvent.Error:
{
if (Quiet && !string.IsNullOrEmpty(supressed))
{
DisplayCompilingMethod(supressed);
supressed = null;
}
Console.ForegroundColor = ConsoleColor.Red;
Console.Write(@"[Error] ");
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(info);
break;
}
case CompilerEvent.Warning:
{
if (Quiet && !string.IsNullOrEmpty(supressed))
{
DisplayCompilingMethod(supressed);
supressed = null;
}
Console.ForegroundColor = ConsoleColor.Yellow;
Console.Write(@"[Warning] ");
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(info);
break;
}
default: break;
}
}
private void TraceEvent(CompilerEvent compilerStage, string info)
{
switch (compilerStage)
{
case CompilerEvent.MethodCompileStart:
{
if (Quiet)
{
supressed = info;
break;
}
DisplayCompilingMethod(info);
break;
}
case CompilerEvent.MethodScheduled:
{
if (Quiet)
{
break;
}
Console.ForegroundColor = ConsoleColor.Blue;
Console.Write("[Scheduling] ");
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(info);
break;
}
case CompilerEvent.Exception:
{
if (Quiet && !string.IsNullOrEmpty(supressed))
{
DisplayCompilingMethod(supressed);
supressed = null;
}
Console.ForegroundColor = ConsoleColor.Red;
Console.Write("[Exception] ");
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(info);
break;
}
case CompilerEvent.Error:
{
if (Quiet && !string.IsNullOrEmpty(supressed))
{
DisplayCompilingMethod(supressed);
supressed = null;
}
Console.ForegroundColor = ConsoleColor.Red;
Console.Write("[Error] ");
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(info);
break;
}
case CompilerEvent.Warning:
{
if (Quiet && !string.IsNullOrEmpty(supressed))
{
DisplayCompilingMethod(supressed);
supressed = null;
}
Console.ForegroundColor = ConsoleColor.Yellow;
Console.Write("[Warning] ");
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(info);
break;
}
default: break;
}
}
void ICompilerEventListener.SubmitTraceEvent(CompilerEvent compilerStage, string info)
{
if (compilerStage == CompilerEvent.CompilerStageStart || compilerStage == CompilerEvent.CompilerStageEnd)
{
string status = "Compiling: " + String.Format("{0:0.00}", (DateTime.Now - compileStartTime).TotalSeconds) + " secs: " + compilerStage.ToText() + ": " + info;
toolStripStatusLabel1.Text = status;
toolStripStatusLabel1.GetCurrentParent().Refresh();
AddOutput(status);
}
}
/// <summary>
/// Traces the specified compiler event.
/// </summary>
/// <param name="compilerEvent">The compiler event.</param>
/// <param name="message">The message.</param>
/// <param name="threadID">The thread identifier.</param>
public void PostCompilerTraceEvent(CompilerEvent compilerEvent, string message, int threadID)
{
CompilerTrace.PostCompilerTraceEvent(compilerEvent, message, threadID);
}
/// <summary>
/// Traces the specified compiler event.
/// </summary>
/// <param name="compilerEvent">The compiler event.</param>
/// <param name="message">The message.</param>
public void PostCompilerTraceEvent(CompilerEvent compilerEvent, string message)
{
CompilerTrace.PostCompilerTraceEvent(compilerEvent, message, 0);
}
/// <summary>
/// Traces the specified compiler event.
/// </summary>
/// <param name="compilerEvent">The compiler event.</param>
/// <param name="message">The message.</param>
protected void NewCompilerTraceEvent(CompilerEvent compilerEvent, string message)
{
CompilerTrace.NewCompilerTraceEvent(compilerEvent, message, 0);
}
/// <summary>
/// Traces the specified compiler event.
/// </summary>
/// <param name="compilerEvent">The compiler event.</param>
/// <param name="message">The message.</param>
private void NewCompilerTraceEvent(CompilerEvent compilerEvent, string message)
{
CompilerTrace.NewCompilerTraceEvent(compilerEvent, message, 0);
}
protected void NewCompilerTraceEvent(CompilerEvent compileEvent, string message)
{
MethodCompiler.Trace.NewCompilerTraceEvent(compileEvent, message, MethodCompiler.ThreadID);
}
/// <summary>
/// Traces the specified compiler event.
/// </summary>
/// <param name="compilerEvent">The compiler event.</param>
/// <param name="message">The message.</param>
/// <param name="threadID">The thread identifier.</param>
private void NewCompilerTraceEvent(CompilerEvent compilerEvent, string message, int threadID)
{
CompilerTrace.NewCompilerTraceEvent(compilerEvent, message, threadID);
}
private void TraceEvent(CompilerEvent compilerStage, string info)
{
switch (compilerStage)
{
case CompilerEvent.CompilingMethod:
{
if (Quiet)
{
supressed = info;
break;
}
DisplayCompilingMethod(info);
break;
}
case CompilerEvent.CompilingType:
{
if (Quiet) break;
Console.ForegroundColor = ConsoleColor.Yellow;
Console.Write(@"[Compiling] ");
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(info);
break;
}
case CompilerEvent.SchedulingType:
{
if (Quiet) break;
Console.ForegroundColor = ConsoleColor.Blue;
Console.Write(@"[Scheduling] ");
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(info);
break;
}
case CompilerEvent.SchedulingMethod:
{
if (Quiet) break;
Console.ForegroundColor = ConsoleColor.Blue;
Console.Write(@"[Scheduling] ");
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(info);
break;
}
case CompilerEvent.Exception:
{
if (Quiet && !string.IsNullOrEmpty(supressed))
{
DisplayCompilingMethod(supressed);
supressed = null;
}
Console.ForegroundColor = ConsoleColor.Red;
Console.Write(@"[Exception] ");
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(info);
break;
}
case CompilerEvent.Error:
{
if (Quiet && !string.IsNullOrEmpty(supressed))
{
DisplayCompilingMethod(supressed);
supressed = null;
}
Console.ForegroundColor = ConsoleColor.Red;
Console.Write(@"[Error] ");
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(info);
break;
}
case CompilerEvent.Warning:
{
if (Quiet && !string.IsNullOrEmpty(supressed))
{
DisplayCompilingMethod(supressed);
supressed = null;
}
Console.ForegroundColor = ConsoleColor.Yellow;
Console.Write(@"[Warning] ");
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(info);
break;
}
default: break;
}
}
public void Log(CompilerEvent compilerEvent, string message)
{
if (!Active)
return;
internalTrace.CompilerEventListener.SubmitTraceEvent(compilerEvent, message);
}
void ITraceListener.OnNewCompilerTraceEvent(CompilerEvent compilerStage, string info, int threadID)
{
Debug.WriteLine(compilerStage.ToString() + ": " + info);
}
void ITraceListener.OnNewCompilerTraceEvent(CompilerEvent compilerStage, string info, int threadID)
{
MethodInvoker call = delegate()
{
SubmitTraceEvent(compilerStage, info);
};
Invoke(call);
}
/// <summary>
/// Traces the specified compiler event.
/// </summary>
/// <param name="compilerEvent">The compiler event.</param>
/// <param name="message">The message.</param>
protected void NewCompilerTraceEvent(CompilerEvent compilerEvent, string message, int threadID)
{
CompilerTrace.NewCompilerTraceEvent(compilerEvent, message, threadID);
}
void ICompilerEventListener.SubmitTraceEvent(CompilerEvent compilerStage, string info)
{
Debug.WriteLine(compilerStage.ToString() + ": " + info);
}
protected void PostCompilerTraceEvent(CompilerEvent compileEvent, string message)
{
MethodCompiler.Trace.PostCompilerTraceEvent(compileEvent, message, MethodCompiler.ThreadID);
}
/// <summary>
/// Traces the specified compiler event.
/// </summary>
/// <param name="compilerEvent">The compiler event.</param>
/// <param name="message">The message.</param>
protected void Trace(CompilerEvent compilerEvent, string message)
{
internalTrace.CompilerEventListener.SubmitTraceEvent(compilerEvent, message);
}
