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