File: Logging\SerialConsoleLogger.cs
Web Access
Project: ..\..\..\src\Build\Microsoft.Build.csproj (Microsoft.Build)
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
 
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Build.Framework;
using Microsoft.Build.Shared;
using ColorResetter = Microsoft.Build.Logging.ColorResetter;
using ColorSetter = Microsoft.Build.Logging.ColorSetter;
using WriteHandler = Microsoft.Build.Logging.WriteHandler;
 
#nullable disable
 
namespace Microsoft.Build.BackEnd.Logging
{
    internal class SerialConsoleLogger : BaseConsoleLogger
    {
        #region Constructors
 
        /// <summary>
        /// Default constructor.
        /// </summary>
        public SerialConsoleLogger()
            : this(LoggerVerbosity.Normal)
        {
            // do nothing
        }
 
        /// <summary>
        /// Create a logger instance with a specific verbosity.  This logs to
        /// the default console.
        /// </summary>
        /// <param name="verbosity">Verbosity level.</param>
        public SerialConsoleLogger(LoggerVerbosity verbosity)
            :
            this
            (
                verbosity,
                new WriteHandler(Console.Out.Write),
                new ColorSetter(SetColor),
                new ColorResetter(ResetColor))
        {
            // do nothing
        }
 
        /// <summary>
        /// Initializes the logger, with alternate output handlers.
        /// </summary>
        /// <param name="verbosity"></param>
        /// <param name="write"></param>
        /// <param name="colorSet"></param>
        /// <param name="colorReset"></param>
        public SerialConsoleLogger(
            LoggerVerbosity verbosity,
            WriteHandler write,
            ColorSetter colorSet,
            ColorResetter colorReset)
        {
            InitializeConsoleMethods(verbosity, write, colorSet, colorReset);
        }
 
        #endregion
 
        #region Methods
 
        /// <summary>
        /// Reset the states of per-build member variables
        /// VSW#516376
        /// </summary>
        internal override void ResetConsoleLoggerState()
        {
            if (ShowSummary == true)
            {
                errorList = new List<BuildErrorEventArgs>();
                warningList = new List<BuildWarningEventArgs>();
            }
            else
            {
                errorList = null;
                warningList = null;
            }
 
            errorCount = 0;
            warningCount = 0;
 
            projectPerformanceCounters = null;
            targetPerformanceCounters = null;
            taskPerformanceCounters = null;
        }
 
        /// <summary>
        /// Handler for build started events
        /// </summary>
        /// <param name="sender">sender (should be null)</param>
        /// <param name="e">event arguments</param>
        public override void BuildStartedHandler(object sender, BuildStartedEventArgs e)
        {
            buildStarted = e.Timestamp;
 
            if (ShowSummary == true)
            {
                WriteLinePrettyFromResource("BuildStartedWithTime", e.Timestamp);
            }
 
            if (Traits.LogAllEnvironmentVariables)
            {
                WriteEnvironment(e.BuildEnvironment);
            }
            else
            {
                WriteEnvironment(e.BuildEnvironment?.Where(kvp => EnvironmentUtilities.IsWellKnownEnvironmentDerivedProperty(kvp.Key)).ToDictionary(kvp => kvp.Key, kvp => kvp.Value));
            }
        }
 
        /// <summary>
        /// Handler for build finished events
        /// </summary>
        /// <param name="sender">sender (should be null)</param>
        /// <param name="e">event arguments</param>
        public override void BuildFinishedHandler(object sender, BuildFinishedEventArgs e)
        {
            // Show the performance summary if the verbosity is diagnostic or the user specifically asked for it
            // with a logger parameter.
            if (this.showPerfSummary)
            {
                ShowPerfSummary();
            }
 
            if (ShowSummary == true)
            {
                if (e.Succeeded)
                {
                    setColor(ConsoleColor.Green);
                }
 
                // Write the "Build Finished" event.
                WriteNewLine();
                WriteLinePretty(e.Message);
 
                resetColor();
            }
 
            // The decision whether or not to show a summary at this verbosity
            // was made during initialization. We just do what we're told.
            if (ShowSummary == true)
            {
                ShowErrorWarningSummary();
 
                if (IsVerbosityAtLeast(LoggerVerbosity.Normal))
                {
                    // Emit text like:
                    //     1 Warning(s)
                    //     0 Error(s)
                    // Don't color the line if it's zero. (Per Whidbey behavior.)
                    if (warningCount > 0)
                    {
                        setColor(ConsoleColor.Yellow);
                    }
                    WriteLinePrettyFromResource(2, "WarningCount", warningCount);
                    resetColor();
 
                    if (errorCount > 0)
                    {
                        setColor(ConsoleColor.Red);
                    }
                    WriteLinePrettyFromResource(2, "ErrorCount", errorCount);
                    resetColor();
                }
            }
 
            if (ShowSummary == true)
            {
                string timeElapsed = LogFormatter.FormatTimeSpan(e.Timestamp - buildStarted);
 
                WriteNewLine();
                WriteLinePrettyFromResource("TimeElapsed", timeElapsed);
            }
 
            ResetConsoleLoggerState();
        }
 
        /// <summary>
        /// At the end of the build, repeats the errors and warnings that occurred
        /// during the build, and displays the error count and warning count.
        /// </summary>
        private void ShowErrorWarningSummary()
        {
            if (warningCount == 0 && errorCount == 0)
            {
                return;
            }
 
            // Make some effort to distinguish the summary from the previous output
            WriteNewLine();
 
            if (warningCount > 0)
            {
                setColor(ConsoleColor.Yellow);
                foreach (BuildWarningEventArgs warningEventArgs in warningList)
                {
                    WriteLinePretty(EventArgsFormatting.FormatEventMessage(warningEventArgs, showProjectFile));
                }
            }
 
            if (errorCount > 0)
            {
                setColor(ConsoleColor.Red);
                foreach (BuildErrorEventArgs errorEventArgs in errorList)
                {
                    WriteLinePretty(EventArgsFormatting.FormatEventMessage(errorEventArgs, showProjectFile));
                }
            }
 
            resetColor();
        }
 
        /// <summary>
        /// Handler for project started events
        /// </summary>
        /// <param name="sender">sender (should be null)</param>
        /// <param name="e">event arguments</param>
        public override void ProjectStartedHandler(object sender, ProjectStartedEventArgs e)
        {
            if (!contextStack.IsEmpty())
            {
                this.VerifyStack(contextStack.Peek().type == FrameType.Target, "Bad stack -- Top is project {0}", contextStack.Peek().ID);
            }
 
            // if verbosity is normal, detailed or diagnostic
            if (IsVerbosityAtLeast(LoggerVerbosity.Normal) && ShowSummary != false)
            {
                ShowDeferredMessages();
 
                // check for stack corruption
                if (!contextStack.IsEmpty())
                {
                    this.VerifyStack(contextStack.Peek().type == FrameType.Target, "Bad stack -- Top is target {0}", contextStack.Peek().ID);
                }
 
                contextStack.Push(new Frame(FrameType.Project,
                                            false, // message not yet displayed
                                            this.currentIndentLevel,
                                            e.ProjectFile,
                                            e.TargetNames,
                                            null,
                                            GetCurrentlyBuildingProjectFile()));
                WriteProjectStarted();
            }
            else
            {
                contextStack.Push(new Frame(FrameType.Project,
                                            false, // message not yet displayed
                                            this.currentIndentLevel,
                                            e.ProjectFile,
                                            e.TargetNames,
                                            null,
                                            GetCurrentlyBuildingProjectFile()));
            }
 
            if (this.showPerfSummary)
            {
                PerformanceCounter counter = GetPerformanceCounter(e.ProjectFile, ref projectPerformanceCounters);
 
                // Place the counter "in scope" meaning the project is executing right now.
                counter.InScope = true;
            }
 
            if (Verbosity == LoggerVerbosity.Diagnostic && showItemAndPropertyList)
            {
                if (e.Properties != null)
                {
                    var propertyList = ExtractPropertyList(e.Properties);
                    WriteProperties(propertyList);
                }
 
                if (e.Items != null)
                {
                    SortedList itemList = ExtractItemList(e.Items);
                    WriteItems(itemList);
                }
            }
        }
 
        /// <summary>
        /// Handler for project finished events
        /// </summary>
        /// <param name="sender">sender (should be null)</param>
        /// <param name="e">event arguments</param>
        public override void ProjectFinishedHandler(object sender, ProjectFinishedEventArgs e)
        {
            if (this.showPerfSummary)
            {
                PerformanceCounter counter = GetPerformanceCounter(e.ProjectFile, ref projectPerformanceCounters);
 
                // Place the counter "in scope" meaning the project is done executing right now.
                counter.InScope = false;
            }
 
            // if verbosity is detailed or diagnostic,
            // or there was an error or warning
            if (contextStack.Peek().hasErrorsOrWarnings
                || (IsVerbosityAtLeast(LoggerVerbosity.Detailed)))
            {
                setColor(ConsoleColor.Cyan);
 
                if (IsVerbosityAtLeast(LoggerVerbosity.Normal))
                {
                    WriteNewLine();
                }
 
                WriteLinePretty(e.Message);
 
                resetColor();
            }
 
            Frame top = contextStack.Pop();
 
            this.VerifyStack(top.type == FrameType.Project, "Unexpected project frame {0}", top.ID);
            this.VerifyStack(top.ID == e.ProjectFile, "Project frame {0} expected, but was {1}.", e.ProjectFile, top.ID);
        }
 
        /// <summary>
        /// Handler for target started events
        /// </summary>
        /// <param name="sender">sender (should be null)</param>
        /// <param name="e">event arguments</param>
        public override void TargetStartedHandler(object sender, TargetStartedEventArgs e)
        {
            contextStack.Push(new Frame(FrameType.Target,
                                        false,
                                        this.currentIndentLevel,
                                        e.TargetName,
                                        null,
                                        e.TargetFile,
                                        GetCurrentlyBuildingProjectFile()));
 
            // if verbosity is detailed or diagnostic
            if (IsVerbosityAtLeast(LoggerVerbosity.Detailed))
            {
                WriteTargetStarted();
            }
 
            if (this.showPerfSummary)
            {
                PerformanceCounter counter = GetPerformanceCounter(e.TargetName, ref targetPerformanceCounters);
 
                // Place the counter "in scope" meaning the target is executing right now.
                counter.InScope = true;
            }
 
            // Bump up the overall number of indents, so that anything within this target will show up
            // indented.
            this.currentIndentLevel++;
        }
 
        /// <summary>
        /// Handler for target finished events
        /// </summary>
        /// <param name="sender">sender (should be null)</param>
        /// <param name="e">event arguments</param>
        public override void TargetFinishedHandler(object sender, TargetFinishedEventArgs e)
        {
            // Done with the target, so shift everything left again.
            this.currentIndentLevel--;
 
            if (this.showPerfSummary)
            {
                PerformanceCounter counter = GetPerformanceCounter(e.TargetName, ref targetPerformanceCounters);
 
                // Place the counter "in scope" meaning the target is done executing right now.
                counter.InScope = false;
            }
 
            bool targetHasErrorsOrWarnings = contextStack.Peek().hasErrorsOrWarnings;
 
            // if verbosity is diagnostic,
            // or there was an error or warning and verbosity is normal or detailed
            if ((targetHasErrorsOrWarnings && (IsVerbosityAtLeast(LoggerVerbosity.Normal)))
                  || Verbosity == LoggerVerbosity.Diagnostic)
            {
                setColor(ConsoleColor.Cyan);
 
                if (showTargetOutputs)
                {
                    IEnumerable targetOutputs = e.TargetOutputs;
 
                    if (targetOutputs != null)
                    {
                        WriteLinePretty(ResourceUtilities.GetResourceString("TargetOutputItemsHeader"));
                        foreach (ITaskItem item in targetOutputs)
                        {
                            WriteLinePretty(ResourceUtilities.FormatResourceStringIgnoreCodeAndKeyword("TargetOutputItem", item.ItemSpec));
                        }
                    }
                }
 
                WriteLinePretty(e.Message);
                resetColor();
            }
 
            Frame top = contextStack.Pop();
            this.VerifyStack(top.type == FrameType.Target, "bad stack frame type");
            this.VerifyStack(top.ID == e.TargetName, "bad stack frame id");
 
            // set the value on the Project frame, for the ProjectFinished handler
            if (targetHasErrorsOrWarnings)
            {
                SetErrorsOrWarningsOnCurrentFrame();
            }
        }
 
        /// <summary>
        /// Handler for task started events
        /// </summary>
        /// <param name="sender">sender (should be null)</param>
        /// <param name="e">event arguments</param>
        public override void TaskStartedHandler(object sender, TaskStartedEventArgs e)
        {
            // if verbosity is detailed or diagnostic
            if (IsVerbosityAtLeast(LoggerVerbosity.Detailed))
            {
                setColor(ConsoleColor.Cyan);
                WriteLinePretty(e.Message);
                resetColor();
            }
 
            if (this.showPerfSummary)
            {
                PerformanceCounter counter = GetPerformanceCounter(e.TaskName, ref taskPerformanceCounters);
 
                // Place the counter "in scope" meaning the task is executing right now.
                counter.InScope = true;
            }
 
            // Bump up the overall number of indents, so that anything within this task will show up
            // indented.
            this.currentIndentLevel++;
        }
 
        /// <summary>
        /// Handler for task finished events
        /// </summary>
        /// <param name="sender">sender (should be null)</param>
        /// <param name="e">event arguments</param>
        public override void TaskFinishedHandler(object sender, TaskFinishedEventArgs e)
        {
            // Done with the task, so shift everything left again.
            this.currentIndentLevel--;
 
            if (this.showPerfSummary)
            {
                PerformanceCounter counter = GetPerformanceCounter(e.TaskName, ref taskPerformanceCounters);
 
                // Place the counter "in scope" meaning the task is done executing.
                counter.InScope = false;
            }
 
            // if verbosity is detailed or diagnostic
            if (IsVerbosityAtLeast(LoggerVerbosity.Detailed))
            {
                setColor(ConsoleColor.Cyan);
                WriteLinePretty(e.Message);
                resetColor();
            }
        }
 
        /// <summary>
        /// Prints an error event
        /// </summary>
        public override void ErrorHandler(object sender, BuildErrorEventArgs e)
        {
            errorCount++;
            SetErrorsOrWarningsOnCurrentFrame();
            ShowDeferredMessages();
            setColor(ConsoleColor.Red);
            WriteLinePretty(EventArgsFormatting.FormatEventMessage(e, showProjectFile));
            if (ShowSummary == true)
            {
                errorList.Add(e);
            }
            resetColor();
        }
 
        /// <summary>
        /// Prints a warning event
        /// </summary>
        public override void WarningHandler(object sender, BuildWarningEventArgs e)
        {
            warningCount++;
            SetErrorsOrWarningsOnCurrentFrame();
            ShowDeferredMessages();
            setColor(ConsoleColor.Yellow);
            WriteLinePretty(EventArgsFormatting.FormatEventMessage(e, showProjectFile));
            if (ShowSummary == true)
            {
                warningList.Add(e);
            }
            resetColor();
        }
 
        /// <summary>
        /// Prints a message event
        /// </summary>
        public override void MessageHandler(object sender, BuildMessageEventArgs e)
        {
            LoggerVerbosity minimumVerbosity = ImportanceToMinimumVerbosity(e.Importance, out bool lightenText);
            bool print = IsVerbosityAtLeast(minimumVerbosity);
 
            if (print)
            {
                ShowDeferredMessages();
 
                if (lightenText)
                {
                    setColor(ConsoleColor.DarkGray);
                }
 
                string nonNullMessage = e is EnvironmentVariableReadEventArgs environmentDerivedProperty
                    ? ResourceUtilities.FormatResourceStringIgnoreCodeAndKeyword("EnvironmentDerivedPropertyRead", environmentDerivedProperty.EnvironmentVariableName, e.Message)
                    : e.Message ?? String.Empty;
 
                // Include file information if present.
                if (e.File != null)
                {
                    nonNullMessage = EventArgsFormatting.FormatEventMessage(e, showProjectFile);
                }
 
                WriteLinePretty(nonNullMessage);
 
                if (lightenText)
                {
                    resetColor();
                }
            }
        }
 
        /// <summary>
        /// Prints a custom event
        /// </summary>
        public override void CustomEventHandler(object sender, CustomBuildEventArgs e)
        {
            // if verbosity is detailed or diagnostic
            if (IsVerbosityAtLeast(LoggerVerbosity.Detailed))
            {
                // ignore custom events with null messages -- some other
                // logger will handle them appropriately
                if (e.Message != null)
                {
                    ShowDeferredMessages();
                    WriteLinePretty(e.Message);
                }
            }
        }
 
        public override void StatusEventHandler(object sender, BuildStatusEventArgs e)
        {
            if (e is ProjectEvaluationStartedEventArgs projectEvaluationStarted)
            {
                if (showPerfSummary)
                {
                    PerformanceCounter counter = GetPerformanceCounter(projectEvaluationStarted.ProjectFile, ref projectEvaluationPerformanceCounters);
                    counter.InScope = true;
                }
            }
            else if (e is ProjectEvaluationFinishedEventArgs projectEvaluationFinished)
            {
                if (showPerfSummary)
                {
                    PerformanceCounter counter = GetPerformanceCounter(projectEvaluationFinished.ProjectFile, ref projectEvaluationPerformanceCounters);
                    counter.InScope = false;
                }
 
                if (Verbosity == LoggerVerbosity.Diagnostic && showItemAndPropertyList)
                {
                    if (projectEvaluationFinished.Properties != null)
                    {
                        var propertyList = ExtractPropertyList(projectEvaluationFinished.Properties);
                        WriteProperties(propertyList);
                    }
 
                    if (projectEvaluationFinished.Items != null)
                    {
                        SortedList itemList = ExtractItemList(projectEvaluationFinished.Items);
                        WriteItems(itemList);
                    }
                }
            }
            else if (e is BuildCanceledEventArgs buildCanceled)
            {;
                Console.WriteLine(e.Message);
            }
        }
 
        /// <summary>
        /// Writes project started messages.
        /// </summary>
        internal void WriteProjectStarted()
        {
            this.VerifyStack(!contextStack.IsEmpty(), "Bad project stack");
 
            // Pop the current project
            Frame outerMost = contextStack.Pop();
 
            this.VerifyStack(!outerMost.displayed, "Bad project stack on {0}", outerMost.ID);
            this.VerifyStack(outerMost.type == FrameType.Project, "Bad project stack");
 
            outerMost.displayed = true;
            contextStack.Push(outerMost);
 
            WriteProjectStartedText(outerMost.ID, outerMost.targetNames, outerMost.parentProjectFile,
                this.IsVerbosityAtLeast(LoggerVerbosity.Normal) ? outerMost.indentLevel : 0);
        }
 
        /// <summary>
        /// Displays the text for a project started message.
        /// </summary>
        /// <param name ="current">current project file</param>
        /// <param name ="previous">previous project file</param>
        /// <param name="targetNames">targets that are being invoked</param>
        /// <param name="indentLevel">indentation level</param>
        private void WriteProjectStartedText(string current, string targetNames, string previous, int indentLevel)
        {
            if (!SkipProjectStartedText)
            {
                setColor(ConsoleColor.Cyan);
 
                this.VerifyStack(current != null, "Unexpected null project stack");
 
                WriteLinePretty(projectSeparatorLine);
 
                if (previous == null)
                {
                    if (string.IsNullOrEmpty(targetNames))
                    {
                        WriteLinePrettyFromResource(indentLevel, "ProjectStartedPrefixForTopLevelProjectWithDefaultTargets", current);
                    }
                    else
                    {
                        WriteLinePrettyFromResource(indentLevel, "ProjectStartedPrefixForTopLevelProjectWithTargetNames", current, targetNames);
                    }
                }
                else
                {
                    if (string.IsNullOrEmpty(targetNames))
                    {
                        WriteLinePrettyFromResource(indentLevel, "ProjectStartedPrefixForNestedProjectWithDefaultTargets", previous, current);
                    }
                    else
                    {
                        WriteLinePrettyFromResource(indentLevel, "ProjectStartedPrefixForNestedProjectWithTargetNames", previous, current, targetNames);
                    }
                }
 
                // add a little bit of extra space
                WriteNewLine();
 
                resetColor();
            }
        }
 
        /// <summary>
        /// Writes target started messages.
        /// </summary>
        private void WriteTargetStarted()
        {
            Frame f = contextStack.Pop();
            f.displayed = true;
            contextStack.Push(f);
 
            setColor(ConsoleColor.Cyan);
 
            if (this.Verbosity == LoggerVerbosity.Diagnostic)
            {
                WriteLinePrettyFromResource(f.indentLevel, "TargetStartedFromFile", f.ID, f.file);
            }
            else
            {
                WriteLinePrettyFromResource(this.IsVerbosityAtLeast(LoggerVerbosity.Normal) ? f.indentLevel : 0,
                    "TargetStartedPrefix", f.ID);
            }
 
            resetColor();
        }
 
        /// <summary>
        /// Determines the currently building project file.
        /// </summary>
        /// <returns>name of project file currently being built</returns>
        private string GetCurrentlyBuildingProjectFile()
        {
            if (contextStack.IsEmpty())
            {
                return null;
            }
 
            Frame topOfStack = contextStack.Peek();
 
            // If the top of the stack is a TargetStarted event, then its parent project
            // file is the one we want.
            if (topOfStack.type == FrameType.Target)
            {
                return topOfStack.parentProjectFile;
            }
            // If the top of the stack is a ProjectStarted event, then its ID is the project
            // file we want.
            else if (topOfStack.type == FrameType.Project)
            {
                return topOfStack.ID;
            }
            else
            {
                ErrorUtilities.ThrowInternalError("Unexpected frame type.");
                return null;
            }
        }
 
        /// <summary>
        /// Displays project started and target started messages that
        /// are shown only when the associated project or target produces
        /// output.
        /// </summary>
        private void ShowDeferredMessages()
        {
            if (contextStack.IsEmpty())
            {
                return;
            }
 
            if (!contextStack.Peek().displayed)
            {
                Frame f = contextStack.Pop();
 
                ShowDeferredMessages();
 
                // push now, so that the stack is in a good state
                // for WriteProjectStarted() and WriteLinePretty()
                // because we use the stack to control indenting
                contextStack.Push(f);
 
                switch (f.type)
                {
                    case FrameType.Project:
                        WriteProjectStarted();
                        break;
 
                    case FrameType.Target:
                        // Only do things if we're at normal verbosity.  If
                        // we're at a higher verbosity, we can assume that all
                        // targets have already be printed.  If we're at lower
                        // verbosity we don't need to print at all.
                        ErrorUtilities.VerifyThrow(this.Verbosity < LoggerVerbosity.Detailed,
                            "This target should have already been printed at a higher verbosity.");
 
                        if (IsVerbosityAtLeast(LoggerVerbosity.Normal))
                        {
                            WriteTargetStarted();
                        }
 
                        break;
 
                    default:
                        ErrorUtilities.ThrowInternalError("Unexpected frame type.");
                        break;
                }
            }
        }
 
        /// <summary>
        /// Marks the current frame to indicate that an error or warning
        /// occurred during it.
        /// </summary>
        private void SetErrorsOrWarningsOnCurrentFrame()
        {
            // under unit test, there may not be frames on the stack
            if (contextStack.Count == 0)
            {
                return;
            }
 
            Frame frame = contextStack.Pop();
            frame.hasErrorsOrWarnings = true;
            contextStack.Push(frame);
        }
 
        /// <summary>
        /// Checks the condition passed in.  If it's false, it emits an error message to the console
        /// indicating that there's a problem with the console logger.  These "problems" should
        /// never occur in the real world after we ship, unless there's a bug in the MSBuild
        /// engine such that events aren't getting paired up properly.  So the messages don't
        /// really need to be localized here, since they're only for our own benefit, and have
        /// zero value to a customer.
        /// </summary>
        /// <param name="condition"></param>
        /// <param name="unformattedMessage"></param>
        /// <param name="args"></param>
        private void VerifyStack(
            bool condition,
            string unformattedMessage,
            params object[] args)
        {
            if (!condition && !ignoreLoggerErrors)
            {
                string errorMessage = "INTERNAL CONSOLE LOGGER ERROR. " + ResourceUtilities.FormatString(unformattedMessage, args);
                ErrorUtilities.ThrowInternalError(errorMessage);
            }
        }
        #endregion
 
        #region Supporting classes
 
        /// <summary>
        /// This enumeration represents the kinds of context that can be
        /// stored in the context stack.
        /// </summary>
        internal enum FrameType
        {
            Project,
            Target
        }
 
        /// <summary>
        /// This struct represents context information about a single
        /// target or project.
        /// </summary>
        internal struct Frame
        {
            /// <summary>
            /// Initializes a new instance of the <see cref="Frame"/> struct with all fields specified.
            /// </summary>
            /// <param name="t">the type of the this frame</param>
            /// <param name="d">display state. true indicates this frame has been displayed to the user</param>
            /// <param name="indent">indentation level for this frame</param>
            /// <param name="s">frame id</param>
            /// <param name="targets">targets to execute, in the case of a project frame</param>
            /// <param name="fileOfTarget">the file name where the target is defined</param>
            /// <param name="parent">parent project file</param>
            internal Frame(
                FrameType t,
                bool d,
                int indent,
                string s,
                string targets,
                string fileOfTarget,
                string parent)
            {
                type = t;
                displayed = d;
                indentLevel = indent;
                ID = s;
                targetNames = targets;
                file = fileOfTarget;
                hasErrorsOrWarnings = false;
                parentProjectFile = parent;
            }
 
            /// <summary>
            /// Indicates if project or target frame.
            /// </summary>
            internal FrameType type;
 
            /// <summary>
            /// Set to true to indicate the user has seen a message about this frame.
            /// </summary>
            internal bool displayed;
 
            /// <summary>
            /// The number of tabstops to indent this event when it is eventually displayed.
            /// </summary>
            internal int indentLevel;
 
            /// <summary>
            /// A string associated with this frame -- should be a target name
            /// or a project file.
            /// </summary>
            internal string ID;
 
            /// <summary>
            /// For a TargetStarted or a ProjectStarted event, this field tells us
            /// the name of the *parent* project file that was responsible.
            /// </summary>
            internal string parentProjectFile;
 
            /// <summary>
            /// Stores the TargetNames from the ProjectStarted event. Null for Target frames.
            /// </summary>
            internal string targetNames;
 
            /// <summary>
            /// For TargetStarted events, this stores the filename where the Target is defined
            /// (e.g., Microsoft.Common.targets).  This is different than the project that is
            /// being built.
            /// For ProjectStarted events, this is null.
            /// </summary>
            internal string file;
 
            /// <summary>
            /// True if there were errors/warnings during the project or target frame.
            /// </summary>
            internal bool hasErrorsOrWarnings;
        }
 
        /// <summary>
        /// The FrameStack class represents a (lifo) stack of Frames.
        /// </summary>
        internal class FrameStack
        {
            /// <summary>
            /// The frames member is contained by FrameStack and does
            /// all the heavy lifting for FrameStack.
            /// </summary>
            private readonly Stack<Frame> _frames;
 
            /// <summary>
            /// Initializes a new instance of the <see cref="FrameStack"/> class.
            /// </summary>
            internal FrameStack()
            {
                _frames = new Stack<Frame>();
            }
 
            /// <summary>
            /// Remove and return the top element in the stack.
            /// </summary>
            /// <exception cref="InvalidOperationException">Thrown when stack is empty.</exception>
            internal Frame Pop()
            {
                return _frames.Pop();
            }
 
            /// <summary>
            /// Returns, but does not remove, the top of the stack.
            /// </summary>
            internal Frame Peek()
            {
                return _frames.Peek();
            }
 
            /// <summary>
            /// Push(f) adds f to the top of the stack.
            /// </summary>
            /// <param name="f">a frame to push</param>
            internal void Push(Frame f)
            {
                _frames.Push(f);
            }
 
            /// <summary>
            /// Constant property that indicates the number of elements
            /// in the stack.
            /// </summary>
            internal int Count
            {
                get
                {
                    return _frames.Count;
                }
            }
 
            /// <summary>
            /// s.IsEmpty() is true iff s.Count == 0
            /// </summary>
            internal bool IsEmpty()
            {
                return _frames.Count == 0;
            }
        }
        #endregion
 
        #region Private member data
 
        /// <summary>
        /// contextStack is the only interesting state in the console
        /// logger.  The context stack contains a sequence of frames
        /// denoting current and previous containing projects and targets
        /// </summary>
        internal FrameStack contextStack = new FrameStack();
        #endregion
    }
}