Microsoft.PowerShell.ConsoleHost

A strongly-typed resource class, for looking up localized strings, etc.

constructor

Returns the cached ResourceManager instance used by this class.

Overrides the current threads CurrentUICulture property for all resource lookups using this strongly typed resource class.

Looks up a localized string similar to Cannot process command because a command is already specified with -Command, -CommandWithArgs, or -EncodedCommand.

Looks up a localized string similar to Cannot process the command because of a missing parameter. A command must follow -Command.

Looks up a localized string similar to Unrecognized parameter: '{0}'.

Looks up a localized string similar to '-' was specified with the -Command parameter; no other arguments to -Command are permitted.

Looks up a localized string similar to '-' was specified as the argument to -Command but standard input has not been redirected for this process.

Looks up a localized string similar to The command cannot be run because no argument has been supplied for the OutputFormat parameter. Specify one of the following formats for this parameter: {0}

Looks up a localized string similar to Cannot process the command because the -InputFormat parameter requires an argument. Specify a valid format argument for this parameter. Valid formats are: {0}

Looks up a localized string similar to Cannot process the command because of an incorrect parameter value. "{0}" is not a valid format. Valid formats are: {1}

Looks up a localized string similar to Cannot process the command because arguments to -Command or -EncodedCommand have already been specified with -EncodedArguments.

Looks up a localized string similar to Cannot process the command because -EncodedArguments requires a value. Specify a value for the -EncodedArguments parameter.

Looks up a localized string similar to The command cannot be run because the File parameter requires a file path. Supply a path for the File parameter and then try the command again.

Looks up a localized string similar to Cannot process the command because -WindowStyle requires an argument that is normal, hidden, minimized or maximized. Specify one of these argument values and try again.

Looks up a localized string similar to Processing -File '{0}' failed: {1} Specify a valid path for the -File parameter.

Looks up a localized string similar to Processing -WindowStyle '{0}' failed: {1}.

Looks up a localized string similar to Processing -File '{0}' failed because the file does not have a '.ps1' extension. Specify a valid PowerShell script file name, and then try again.

Looks up a localized string similar to The argument '{0}' is not recognized as the name of a script file. Check the spelling of the name, or if a path was included, verify that the path is correct and try again.

Looks up a localized string similar to Cannot process the command because the value specified with -EncodedArguments is not properly encoded. The value must be Base64 encoded.

Looks up a localized string similar to Cannot process the command because the value specified with -EncodedCommand is not properly encoded. The value must be Base64 encoded.

Looks up a localized string similar to Cannot process the execution policy because of a missing policy name. A policy name must follow -ExecutionPolicy.

Looks up a localized string similar to Cannot process the command because -STA and -MTA are both specified. Specify either -STA or -MTA.

Looks up a localized string similar to Cannot process the command because -ConfigurationName requires an argument that is a remote endpoint configuration name. Specify this argument and try again.

Looks up a localized string similar to Cannot process the command because -ConfigurationFile requires an argument that is a session configuration (.pssc) file path. Specify this argument and try again.

Looks up a localized string similar to Cannot process the command because -CustomPipeName requires an argument that is a name of the pipe you want to use. Specify this argument and try again.

Looks up a localized string similar to Cannot process the command because -CustomPipeName specified is too long. Pipe names on this platform can be up to {0} characters long. Your pipe name '{1}' is {2} characters.

Looks up a localized string similar to Cannot process the command because -SettingsFile requires an argument that is a file path.

Looks up a localized string similar to Processing -SettingsFile '{0}' failed: {1}. Specify a valid path for the -SettingsFile parameter.

Looks up a localized string similar to The argument '{0}' passed to the -SettingsFile does not exist. Provide the path to an existing json file as an argument to the -SettingsFile parameter.

Looks up a localized string similar to Invalid argument '{0}', did you mean:

Looks up a localized string similar to Parameter -WindowStyle is not implemented on this platform.

Looks up a localized string similar to Cannot process the command because -WorkingDirectory requires an argument that is a directory path.

Looks up a localized string similar to Parameter -MTA is not supported on this platform.

Looks up a localized string similar to Parameter -STA is not supported on this platform.

Looks up a localized string similar to The specified arguments must not contain null elements.

Looks up a localized string similar to Invalid ExecutionPolicy value '{0}'.

Looks up a localized string similar to An argument is required to be supplied to the '{0}' parameter.

A strongly-typed resource class, for looking up localized strings, etc.

constructor

Returns the cached ResourceManager instance used by this class.

Overrides the current threads CurrentUICulture property for all resource lookups using this strongly typed resource class.

Looks up a localized string similar to The Win32 internal error "{0}" 0x{1:X} occurred when adding a break handler. Contact Microsoft Support Services.

Looks up a localized string similar to The Win32 internal error "{0}" 0x{1:X} occurred while trying to remove a break handler. Contact Microsoft Customer Support Services.

Looks up a localized string similar to The Win32 internal error "{0}" 0x{1:X} occurred while getting input about the console handle. Contact Microsoft Customer Support Services.

Looks up a localized string similar to The Win32 internal error "{0}" 0x{1:X} occurred while retrieving the handle for the active console output buffer. Contact Microsoft Customer Support Services.

Looks up a localized string similar to The Win32 internal error "{0}" 0x{1:X} occurred while getting the console mode. Contact Microsoft Customer Support Services.

Looks up a localized string similar to The Win32 internal error "{0}" 0x{1:X} occurred while setting the console mode. Contact Microsoft Customer Support Services.

Looks up a localized string similar to The Win32 internal error "{0}" 0x{1:X} occurred while reading characters from the console input buffer. Contact Microsoft Customer Support Services.

Looks up a localized string similar to The Win32 internal error "{0}" 0x{1:X} occurred while reading input records from the console input buffer. Contact Microsoft Customer Support Services.

Looks up a localized string similar to The Win32 internal error "{0}" 0x{1:X} occurred while reading the contents of the console input buffer. Contact Microsoft Customer Support Services.

Looks up a localized string similar to The Win32 internal error "{0}" 0x{1:X} occurred while getting the number of events in the console input buffer. Contact Microsoft Customer Support Services.

Looks up a localized string similar to The Win32 internal error "{0}" 0x{1:X} occurred while flushing the console input buffer. Contact Microsoft Customer Support Services.

Looks up a localized string similar to The Win32 internal error "{0}" 0x{1:X} occurred while getting console output buffer information. Contact Microsoft Customer Support Services.

Looks up a localized string similar to The Win32 internal error "{0}" 0x{1:X} occurred while setting the console output buffer size. Contact Microsoft Customer Support Services.

Looks up a localized string similar to The Win32 internal error "{0}" 0x{1:X} occurred while writing to the console output buffer. Contact Microsoft Customer Support Services.

Looks up a localized string similar to Win32 internal error "{0}" 0x{1:X} occurred while reading the console output buffer. Contact Microsoft Customer Support Services.

Looks up a localized string similar to The Win32 internal error "{0}" 0x{1:X} occurred while filling the console output buffer with characters. Contact Microsoft Customer Support Services.

Looks up a localized string similar to The Win32 internal error "{0}" 0x{1:X} occurred while filling the console output buffer with attributes. Contact Microsoft Customer Support Services.

Looks up a localized string similar to The Win32 internal error "{0}" 0x{1:X} occurred while scrolling the console output buffer. Contact Microsoft Customer Support Services.

Looks up a localized string similar to The Win32 internal error "{0}" 0x{1:X} occurred while setting the console window information. Contact Microsoft Customer Support Services.

Looks up a localized string similar to The Win32 internal error "{0}" 0x{1:X} occurred while getting the largest console window size. Contact Microsoft Customer Support Services.

Looks up a localized string similar to The Win32 internal error "{0}" 0x{1:X} occurred while setting the console window title. Contact Microsoft Customer Support Services.

Looks up a localized string similar to The Win32 internal error "{0}" 0x{1:X} occurred while writing to the console output buffer at the current cursor position. Contact Microsoft Customer Support Services.

Looks up a localized string similar to The Win32 internal error "{0}" 0x{1:X} occurred while setting character attributes for the console output buffer. Contact Microsoft Customer Support Services.

Looks up a localized string similar to The Win32 internal error "{0}" 0x{1:X} occurred while getting cursor information. Contact Microsoft Customer Support Services.

Looks up a localized string similar to Win32 internal error "{0}" 0x{1:X} occurred while setting cursor information.Contact Microsoft Customer Support Services.

Looks up a localized string similar to The Win32 internal error "{0}" 0x{1:X} occurred while getting console font information. Contact Microsoft Customer Support Services.

Looks up a localized string similar to The Win32 internal error "{0}" 0x{1:X} occurred while sending keyboard input. Contact Microsoft Customer Support Services.

A strongly-typed resource class, for looking up localized strings, etc.

constructor

Returns the cached ResourceManager instance used by this class.

Overrides the current threads CurrentUICulture property for all resource lookups using this strongly typed resource class.

Looks up a localized string similar to Cannot process the operation because the supplied coordinate is not valid. Specify a coordinate within the buffer area of {0}.

Looks up a localized string similar to Cannot set the buffer size because the size specified is too large or too small.

Looks up a localized string similar to Cannot set the console color because the value specified is not valid. Specify a valid color as defined by the System.ConsoleColor type.

Looks up a localized string similar to Cannot process CursorSize because the cursor size specified is not valid.

Looks up a localized string similar to Cannot read key options. To read options, set one or both of the following: IncludeKeyDown, IncludeKeyUp.

Looks up a localized string similar to {0} should be greater than or equal to {1}.

Looks up a localized string similar to Cannot use the specified Window X (column) position because it extends past the width of the screen buffer. Specify another X position, starting with 0 as the left most column of the buffer.

Looks up a localized string similar to Cannot use the specified Window Y (row) position because it extends past the height of the screen buffer. Specify another Y position, starting with 0 as the top-most row of the buffer.

Looks up a localized string similar to Window width cannot be less than 1.

Looks up a localized string similar to Window height must be at least 1.

Looks up a localized string similar to Window cannot be wider than the screen buffer.

Looks up a localized string similar to Window cannot be taller than the screen buffer.

Looks up a localized string similar to Window cannot be wider than {0}.

Looks up a localized string similar to Window cannot be taller than {0}.

Looks up a localized string similar to Window size is too narrow.

Looks up a localized string similar to Window size is too short.

Looks up a localized string similar to Window title cannot be empty.

Looks up a localized string similar to Window title cannot be longer than {0} characters.

Looks up a localized string similar to Administrator:

A strongly-typed resource class, for looking up localized strings, etc.

constructor

Returns the cached ResourceManager instance used by this class.

Overrides the current threads CurrentUICulture property for all resource lookups using this strongly typed resource class.

Looks up a localized string similar to Cannot display prompt because too many nested prompts are already running.

Looks up a localized string similar to Cannot process input loop. ExitCurrentLoop was called when no InputLoops were running.

Looks up a localized string similar to PS>

Looks up a localized string similar to The shell cannot be started. A failure occurred during initialization:

Looks up a localized string similar to The shell cannot be started. An InitialSessionState object has been provided along with a -ConfigurationFile argument. Both configuration directives cannot be used at the same time.

Looks up a localized string similar to An error has occurred that was not properly handled. Additional information is shown below. The PowerShell process will exit.

Looks up a localized string similar to ********************** PowerShell transcript start Start time: {0:yyyyMMddHHmmss} Username : {1}\{2} Machine : {3} ({4}) **********************

Looks up a localized string similar to ********************** PowerShell transcript end End time: {0:yyyyMMddHHmmss} **********************

Looks up a localized string similar to Command '{0}' could not be run because some PowerShell Snap-Ins did not load.

Looks up a localized string similar to Command '{0}' was not run as the session in which it was intended to run was either closed or broken

Looks up a localized string similar to Entering debug mode. Use h or ? for help.

Looks up a localized string similar to Hit {0}

Looks up a localized string similar to {0}:{1,-3} {2}

Looks up a localized string similar to The current session does not support debugging; execution will continue.

Looks up a localized string similar to Cannot load PSReadline module. Console is running without PSReadline.

Looks up a localized string similar to More than one server mode parameter was specified. Server mode parameters must be used exclusively.

Looks up a localized string similar to Loading personal and system profiles took {0}ms.

Looks up a localized string similar to Run as Administrator

Looks up a localized string similar to PushRunspace can only push a remote runspace.

Looks up a localized string similar to The '{0}' parameter is mandatory and must be specified when using the '{1}' parameter.

A strongly-typed resource class, for looking up localized strings, etc.

constructor

Returns the cached ResourceManager instance used by this class.

Overrides the current threads CurrentUICulture property for all resource lookups using this strongly typed resource class.

Looks up a localized string similar to User:

Looks up a localized string similar to Password for user {0}:

A strongly-typed resource class, for looking up localized strings, etc.

constructor

Returns the cached ResourceManager instance used by this class.

Overrides the current threads CurrentUICulture property for all resource lookups using this strongly typed resource class.

Looks up a localized string similar to The "{0}" collection must have at least one element.

Looks up a localized string similar to Cannot recognize "{1}" as a {0} due to an overflow error.

Looks up a localized string similar to Cannot recognize "{1}" as a {0} due to a format error.

Looks up a localized string similar to "{0}" cannot be recognized as a valid Prompt command.

Looks up a localized string similar to No help is available for {0}.

Looks up a localized string similar to {0}:

Looks up a localized string similar to The field "{0}" is a zero rank array.

Looks up a localized string similar to "{0}" should have at least one element.

Looks up a localized string similar to "{0}" must be a valid index into "{1}" or -1 for no default choice.

Looks up a localized string similar to "{0}" must be a valid index into "{1}". "{2}" is not a valid index.

Looks up a localized string similar to [?] Help

Looks up a localized string similar to The prompt was canceled.

Looks up a localized string similar to Cannot process the hot key because a question mark ("?") cannot be used as a hot key.

Looks up a localized string similar to Cannot display the prompt for "{0}" because type "{1}" cannot be loaded.

Looks up a localized string similar to "{0}" cannot be null or empty.

Looks up a localized string similar to "{0}" cannot be null.

Looks up a localized string similar to (Type !? for Help.)

Looks up a localized string similar to (default is "{0}"):

Looks up a localized string similar to (default is "{0}")

Looks up a localized string similar to (default choices are {0})

Looks up a localized string similar to Choice[{0}]:

Looks up a localized string similar to DEBUG: {0}

Looks up a localized string similar to VERBOSE: {0}

Looks up a localized string similar to WARNING: {0}

Looks up a localized string similar to PowerShell is in NonInteractive mode. Read and Prompt functionality is not available.

A strongly-typed resource class, for looking up localized strings, etc.

constructor

Returns the cached ResourceManager instance used by this class.

Overrides the current threads CurrentUICulture property for all resource lookups using this strongly typed resource class.

Looks up a localized string similar to PowerShell {0}

Looks up a localized string similar to [Constrained Language Mode]

Looks up a localized string similar to [Constrained Language AUDIT Mode : No Restrictions]

Looks up a localized string similar to [No Language Mode]

Looks up a localized string similar to [Restricted Language Mode]

Looks up a localized string similar to {1} A new PowerShell preview release is available: v{0} {2} {1} Upgrade now, or check out the release page at:{3}{2} {1} https://aka.ms/PowerShell-Release?tag=v{0} {4}{2}

Looks up a localized string similar to {1} A new PowerShell stable release is available: v{0} {2} {1} Upgrade now, or check out the release page at:{3}{2} {1} https://aka.ms/PowerShell-Release?tag=v{0} {4}{2}

Looks up a localized string similar to {1} A new PowerShell LTS release is available: v{0} {2} {1} Upgrade now, or check out the release page at:{3}{2} {1} https://aka.ms/PowerShell-Release?tag=v{0} {4}{2}

A strongly-typed resource class, for looking up localized strings, etc.

constructor

Returns the cached ResourceManager instance used by this class.

Overrides the current threads CurrentUICulture property for all resource lookups using this strongly typed resource class.

Looks up a localized string similar to {0}{1} remaining.

Looks up a localized string similar to {0} activity not shown...

Looks up a localized string similar to {0} activities not shown...

A strongly-typed resource class, for looking up localized strings, etc.

constructor

Returns the cached ResourceManager instance used by this class.

Overrides the current threads CurrentUICulture property for all resource lookups using this strongly typed resource class.

Looks up a localized string similar to Transcript started, output file is {0}

Looks up a localized string similar to Transcript stopped, output file is {0}

Looks up a localized string similar to Transcription cannot be started due to the error: {0}

Looks up a localized string similar to The current provider ({0}) cannot open a file.

Looks up a localized string similar to File {0} is read-only. Cannot write to this file. "Start-Transcript -Force" will clear the read-only attribute.

Looks up a localized string similar to Cannot perform operation because the path resolved to more than one file. This command cannot operate on multiple files.

Looks up a localized string similar to File {0} already exists and {1} was specified.

Looks up a localized string similar to An error occurred stopping transcription: {0}

Null class implementation of PSHostUserInterface used when no console is available and when PowerShell is run in servmode where no console is needed.

RawUI.

Prompt.

PromptForChoice.

PromptForCredential.

ReadLine.

ReadLineAsSecureString.

Write.

WriteDebugLine.

WriteErrorLine.

WriteLine.

WriteProgress.

WriteVerboseLine.

WriteWarningLine.

These represent the parameters that are used when starting pwsh. We can query in our telemetry to determine how pwsh was invoked.

Processes the -SettingFile Argument.

The command line parameters to be processed. The index in args to the argument following '-SettingFile'. Returns true if the argument was parsed successfully and false if not.

Gets the word in a switch from the current argument or parses a file. For example -foo, /foo, or --foo would return 'foo'.

The command line parameters to be processed. The index in args to the argument to process. Used during parsing files. Returns a Tuple: The first value is a String called 'switchKey' with the word in a switch from the current argument or null. The second value is a bool called 'shouldBreak', indicating if the parsing look should break.

Determine the execution policy based on the supplied string. If the string doesn't match to any known execution policy, set it to incorrect.

The value provided on the command line. The execution policy.

Processes all the command line parameters to ConsoleHost. Returns the exit code to be used to terminate the process, or Success to indicate that the program should continue running.

The command line parameters to be processed.

Class ConsoleControl is used to wrap the various win32 console APIs 1:1 (i.e. at a low level, without attempting to be a "true" object-oriented library.

The absolute position of the mouse, or the amount of motion since the last mouse event was generated, depending on the value of the dwFlags member. Absolute data is specified as the x coordinate of the mouse; relative data is specified as the number of pixels moved.

The absolute position of the mouse, or the amount of motion since the last mouse event was generated, depending on the value of the dwFlags member. Absolute data is specified as the y coordinate of the mouse; relative data is specified as the number of pixels moved.

If dwFlags contains MOUSEEVENTF_WHEEL, then mouseData specifies the amount of wheel movement. A positive value indicates that the wheel was rotated forward, away from the user; a negative value indicates that the wheel was rotated backward, toward the user. One wheel click is defined as WHEEL_DELTA, which is 120.

A set of bit flags that specify various aspects of mouse motion and button clicks. See (https://msdn.microsoft.com/library/ms646273(VS.85).aspx)

The time stamp for the event, in milliseconds. If this parameter is 0, the system will provide its own time stamp.

An additional value associated with the mouse event. An application calls GetMessageExtraInfo to obtain this extra information.

A virtual-key code. The code must be a value in the range 1 to 254. If the dwFlags member specifies KEYEVENTF_UNICODE, wVk must be 0.

A hardware scan code for the key. If dwFlags specifies KEYEVENTF_UNICODE, wScan specifies a Unicode character which is to be sent to the foreground application.

Specifies various aspects of a keystroke. This member can be certain combinations of the following values.

The time stamp for the event, in milliseconds. If this parameter is zero, the system will provide its own time stamp.

An additional value associated with the keystroke. Use the GetMessageExtraInfo function to obtain this information.

The message generated by the input hardware.

The low-order word of the lParam parameter for uMsg.

The high-order word of the lParam parameter for uMsg.

LEFT ARROW key.

ENTER key.

Specify the type of the input.

INPUT_MOUSE = 0x00.

INPUT_KEYBOARD = 0x01.

INPUT_HARDWARE = 0x02.

If specified, the scan code was preceded by a prefix byte that has the value 0xE0 (224).

If specified, the key is being released. If not specified, the key is being pressed.

If specified, wScan identifies the key and wVk is ignored.

If specified, the system synthesizes a VK_PACKET keystroke. The wVk parameter must be zero. This flag can only be combined with the KEYEVENTF_KEYUP flag.

Code to control the display properties of the a window...

The window to show... The command to do. True if it was successful.

Types of control ConsoleBreakSignals received by break Win32Handler delegates.

Set the console's break handler.

If Win32's SetConsoleCtrlHandler fails

Set the console's break handler to null.

If Win32's SetConsoleCtrlHandler fails

Returns a ConsoleHandle to the console (keyboard device)

Returns a ConsoleHandle to the active screen buffer, even if that output has been redirected.

If Win32's CreateFile fails

Flags used by ConsoleControl.GetMode and ConsoleControl.SetMode.

Returns a mask of ConsoleModes flags describing the current modality of the console.

If Win32's GetConsoleMode fails

Sets the current mode of the console device.

Handle to the console device returned by GetInputHandle Mask of mode flags If Win32's SetConsoleMode fails

Wraps Win32 ReadConsoleInput. Returns the number of records read in buffer.

handle for the console where input is read array where data read are stored actual number of input records read If Win32's ReadConsoleInput fails

Wraps Win32 PeekConsoleInput.

handle for the console where input is peeked array where data read are stored actual number of input records peeked If Win32's PeekConsoleInput fails

Wraps Win32 GetNumberOfConsoleInputEvents.

handle for the console where the number of console input events is obtained number of console input events If Win32's GetNumberOfConsoleInputEvents fails

Wraps Win32 FlushConsoleInputBuffer.

handle for the console where the input buffer is flushed If Win32's FlushConsoleInputBuffer fails

Wraps Win32 GetConsoleScreenBufferInfo Returns Console Screen Buffer Info.

Handle for the console where the screen buffer info is obtained info about the screen buffer. See the definition of CONSOLE_SCREEN_BUFFER_INFO If Win32's GetConsoleScreenBufferInfo fails

Set the output buffer's size.

If Win32's SetConsoleScreenBufferSize fails

Wrap32 WriteConsoleOutput. This wrapper is not limited to 64K or 8K CHAR_INFO to which Win32's WriteConsoleOutput is constrained.

handle for the console where output is written location on screen buffer where writing starts 2D array of cells. Caller needs to ensure that the array is 2D. If Win32's GetConsoleScreenBufferInfo fails If there is not enough memory to complete calls to Win32's WriteConsoleOutput If is null If it is illegal to write to the output buffer

Check the existing screen columns left and right of areas to be written.

Must be within the screen buffer. If it is illegal to write at If there is not enough memory to complete calls to Win32's ReadConsoleOutput

Wrap32 ReadConsoleOutput This wrapper is not limited to 64K or 8K CHAR_INFO to which Win32's ReadConsoleOutput is constrained.

handle for the console where output is read location on screen buffer where reading begins indicates the area in where the data read is stored. this is ref because the bounds and size of the array are needed. If there is not enough memory to complete calls to Win32's ReadConsoleOutput

If an edge cell read is a blank, it is potentially part of a double width character. Hence, at least one of the left and right edges should be checked.

Can handle reading CJK characters, but the left and right edges are not checked.

If there is not enough memory to complete calls to Win32's ReadConsoleOutput

Wraps Win32 FillConsoleOutputCharacter.

handle for the console where output is filled character to fill the console output number of times to write character location on screen buffer where writing starts If Win32's FillConsoleOutputCharacter fails

Wraps Win32 FillConsoleOutputAttribute.

handle for the console where output is filled attribute to fill the console output number of times to write attribute location on screen buffer where writing starts If Win32's FillConsoleOutputAttribute fails

Wrap Win32 ScrollConsoleScreenBuffer.

handle for the console where screen buffer is scrolled area to be scrolled area to be updated after scrolling location to which the top left corner of scrollRectangle move character and attribute to fill the area vacated by the scroll If Win32's ScrollConsoleScreenBuffer fails

Wraps Win32 SetConsoleWindowInfo.

handle for the console where window info is set If this parameter is TRUE, the coordinates specify the new upper-left and lower-right corners of the window. If it is false, the coordinates are offsets to the current window-corner coordinates specify the size and position of the console screen buffer's window If Win32's SetConsoleWindowInfo fails

Wraps Win32 GetLargestConsoleWindowSize.

handle for the console for which the largest window size is obtained the largest window size If Win32's GetLargestConsoleWindowSize fails

Wraps Win32 GetConsoleTitle. 1K is the safe limit experimentally. The 64K limit found in the docs is disregarded because it is essentially meaningless.

a string for the title of the window If Win32's GetConsoleTitle fails

Wraps Win32 SetConsoleTitle.

a string for the title of the window If Win32's SetConsoleTitle fails

Wrap Win32 WriteConsole.

Handle for the console where the string is written. String that is written. New line is written. If the Win32's WriteConsole fails.

Wraps Win32 SetConsoleTextAttribute.

handle for the console where text attribute is set text attribute to set the console if the Win32's SetConsoleTextAttribute fails

From IsConsoleFullWidth in \windows\core\ntcon\server\dbcs.c.

Check if the output buffer code page is Japanese, Simplified Chinese, Korean, or Traditional Chinese.

Wraps Win32 GetConsoleCursorInfo.

handle for the console where cursor info is obtained cursor info If Win32's GetConsoleCursorInfo fails

Wraps Win32 SetConsoleCursorInfo.

handle for the console where cursor info is set cursor info to set the cursor If Win32's SetConsoleCursorInfo fails

Helper function to create the proper HostException.

Class to hold the Native Methods used in this file enclosing class.

Subclasses S.M.A.Host to implement a console-mode monad host.

Internal Entry point in msh console host implementation.

Banner text to be displayed by ConsoleHost Help text for minishell. This is displayed on 'minishell -?'. True when an external caller provides an InitialSessionState object, which can conflict with '-ConfigurationFile' argument. The exit code for the shell. The behavior here is related to monitor work. The low word of the exit code is available for the user. The high word is reserved for the shell and monitor. The shell process needs to return: - if the shell.exe fails init, 0xFFFF0000 - if the exit keyword is called with no parameter at the point of top-level prompt, 0x80000000 (e.g. 0 with the high bit set) - if the exit keyword is called with any int param less than or equal to 0xFFFF, then that int masked with the high bit set. e.g. "exit 3" results in 0x80000003 - if the script ends (in the case of msh -command or msh -commandfile), then 0x80000000. - if ctrl-break is pressed, with 0xFFFE0000 - if the shell.exe is passed a bad command-line parameter, with 0xFFFD0000. - if the shell.exe crashes, with 0x00000000 The monitor process gets the exit code. If the high bit is set, then the shell process exited normally (though possibly due to an error). If not, the shell process crashed. If the shell.exe exit code is x00000000 (crashed) or 0xFFFE0000 (user hit ctrl-break), the monitor should restart the shell.exe. Otherwise, the monitor should exit with the same exit code as the shell.exe. Anyone checking the exit code of the shell or monitor can mask off the high word to determine the exit code passed by the script that the shell last executed.

The break handler for the program. Dispatches a break event to the current Executor.

Spin up a new thread to cancel the current pipeline. This will allow subsequent break interrupts to be received even if the cancellation is blocked (which can be the case when the pipeline blocks and nothing implements Cmdlet.Stop properly). That is because the OS will not inject another thread when a break event occurs if one has already been injected and is running.

if true, then flag the parent ConsoleHost that it should shutdown the session. If false, then only the current executing instance is stopped.

Create single instance of ConsoleHost.

See base class.

Handles state changed event of the remote runspace. If the remote runspace gets into a broken or closed state, writes a message and pops out the runspace.

Not sure. Arguments describing this event.

See base class.

True if a runspace is pushed; false otherwise.

Returns the current runspace associated with this host.

Return the actual console host object so that the user can get at the unproxied methods.

See base class.

If an input loop is running, then starts a new, nested input loop. If an input loop is not running, throws an exception.

If a nested prompt is entered while the host is not running at least one prompt loop.

See base class.

If there is no nested prompt.

See base class.

See base class

Constructs a new instance.

Disposes of this instance, per the IDisposable pattern.

Finalizes an instance of the class.

Indicates if the session should be terminated or not. Typically set by the break handler for Close, Logoff, and Shutdown events. Note that the only valid transition for this property is from false to true: it is not legal to try to set it to false after is was set to true.

true to shut down the session. false is only allowed if the property is already false.

The Runspace ref object being used by this Host instance. A host only opens one Runspace.

The main run loop of the program: processes command line parameters, and starts up a runspace.

Commandline parameter parser. The commandline parameter parser is expected to parse all the arguments before calling this method. Is there any warning at startup The process exit code to be returned by Main.

Loops over the Host's sole Runspace; opens the runspace, initializes it, then recycles it if the Runspace fails.

The process exit code to be returned by Main.

Opens and Initializes the Host's sole Runspace. Processes the startup scripts and runs any command passed on the command line.

Runspace creation event arguments.

Escapes backtick and tick characters with a backtick, returns the result.

Reports an exception according to the exception reporting settings in effect.

The exception to report. Optional header message. Empty or null means "no header"

Raised when the host pops a runspace.

Raised when the host pushes a runspace.

Handler for debugger events.

Returns true if the host is in debug mode.

True when debugger command is user and available for stopping.

Sets the host to debug mode and enters a nested prompt.

Exits the debugger's nested prompt.

Writes a line using the debugger colors.

InputLoop represents the prompt-input-execute loop of the interactive host. Input loops can be nested, meaning that one input loop can be interrupted and another started; when the second ends, the first resumes. Neither this class' instances nor its static data is threadsafe. Caller is responsible for ensuring threadsafe access.

True if next input loop is nested, False otherwise. when there is no instanceStack.Count == 0

Returns current root (non-nested) loop only if there is no nesting. This is used *only* by the debugger for remote debugging where data handling on the base commands needs to be blocked during remote debug stop handling.

When a runspace is popped, we need to reevaluate the prompt.

Sender of this event, unused. Arguments describing this event, unused.

Evaluates the prompt, displays it, gets a command from the console, and executes it. Repeats until the command is "exit", or until the shutdown flag is set.

By declaring runspace as ObjectRef<Runspace> we are able to hide the real runspace with a remote runspace in the PushRunspace scenario. By declaring it as a mask, the variable runspace becomes an indirect reference to the actual runspace which we can override with a remote runspace while it is pushed. Also we can easily revert back to the original runspace when the PopRunspace command is invoked.

Defines arguments passed to ConsoleHost.CreateRunspace.

Constructs RunspaceCreationEventArgs.

Implementation of RawConsole for powershell.

If obtaining the buffer's foreground and background color failed

See base class.

If set to an invalid ConsoleColor If obtaining information about the buffer failed OR Win32's SetConsoleTextAttribute

See base class.

If set to an invalid ConsoleColor If obtaining information about the buffer failed OR Win32's SetConsoleTextAttribute

See base class.

If set to outside of the buffer If obtaining information about the buffer failed OR Win32's SetConsoleCursorPosition failed

See base class.

Cursor size If set to under 0 or over 100 If obtaining a handle to the active screen buffer failed OR Win32's GetConsoleCursorInfo failed OR Win32's SetConsoleCursorInfo failed

See base class.

If set outside of the buffer If obtaining information about the buffer failed OR Win32's SetConsoleWindowInfo failed

See base class.

If setting to an invalid size If obtaining a handle to the active screen buffer failed OR obtaining information about the buffer failed OR Win32's SetConsoleScreenBufferSize failed

See base class.

If setting width or height to less than 1, larger than the screen buffer, over the maximum window size allowed If obtaining information about the buffer failed OR Win32's SetConsoleWindowInfo failed

See base class.

If obtaining information about the buffer failed

See base class.

If obtaining a handle to the active screen buffer failed OR Win32's GetLargestConsoleWindowSize failed

Helper method to create and trace PipelineStoppedException.

Used by ReadKey, cache KeyEvent based on if input.RepeatCount > 1.

Input key event record. Cache key event.

See base class This method unwraps the repeat count in KEY_EVENT_RECORD by caching repeated keystrokes in a logical queue. The implications are: 1) Per discussion with Sburns on 2005/01/20, calling this method with allowCtrlC | includeKeyUp may not return ctrl-c even it is pressed. This is because ctrl-c could generate the following sequence of key events: {Ctrl, KeyDown}, {Ctrl-c KeyDown}, {Ctrl, KeyUp}, {c, KeyUp} if Ctrl is released before c. In this case, {Ctrl, KeyUp}, {c, KeyUp} would be returned. 2) If the cache is non-empty, a call to ReadLine will not return the cached keys. This behavior is the same as that of System.Console.ReadKey.

If neither IncludeKeyDown or IncludeKeyUp is set in If obtaining a handle to the active screen buffer failed OR Win32's setting input buffer mode to disregard window and mouse input failed OR Win32's ReadConsoleInput failed

See base class.

If obtaining a handle to the active screen buffer failed OR Win32's FlushConsoleInputBuffer failed

See base class.

If obtaining a handle to the active screen buffer failed OR Win32's GetNumberOfConsoleInputEvents failed OR Win32's PeekConsoleInput failed

See base class.

If set to null If set to a string whose length is not between 1 to 1023 If Win32's GetConsoleWindowTitle failed OR Win32's SetConsoleWindowTitle failed

See base class.

location on screen buffer where contents will be written array of info to be written If is outside of the screen buffer. OR is an ill-formed BufferCell array OR it is illegal to write at in the buffer If obtaining a handle to the active screen buffer failed OR obtaining information about the buffer failed OR there is not enough memory to complete calls to Win32's WriteConsoleOutput

If is completely outside of the screen buffer, it's a no-op.

region with all elements = -1 means "entire screen buffer" character and attribute to fill the screen buffer Provided for clearing regions -- less chatty than passing an array of cells. Clear screen is: SetBufferContents(new Rectangle(-1, -1, -1, -1), ' ', ForegroundColor, BackgroundColor); CursorPosition = new Coordinates(0, 0); fill.Type is ignored If 's Left exceeds Right or Bottom exceeds Top OR it is illegal to set in the buffer with If Win32's CreateFile fails OR Win32's GetConsoleScreenBufferInfo fails OR there is not enough memory to complete calls to Win32's WriteConsoleOutput

See base class. If the rectangle is invalid, ie, Right exceeds Left OR Bottom exceeds Top,

area on screen buffer to be read an array of BufferCell containing screen buffer contents If 's Left exceeds Right or Bottom exceeds Top. If obtaining a handle to the active screen buffer failed OR obtaining information about the buffer failed OR there is not enough memory to complete calls to Win32's ReadConsoleOutput

See base class.

area to be moved top left corner to which source to be moved area to be updated caused by the move character and attribute to fill the area vacated by the move If obtaining the active screen buffer failed OR Call to Win32's ScrollConsoleScreenBuffer failed

See base class.

If Win32's WideCharToMultiByte fails

See base class.

If Win32's WideCharToMultiByte fails

See base class.

If Win32's WideCharToMultiByte fails

Clear the ReadKey cache.

If is outside of the output buffer area

Get output buffer info.

If Win32's CreateFile fails OR Win32's GetConsoleScreenBufferInfo fails

ConsoleHostUserInterface implements console-mode user interface for powershell.

This is the char that is echoed to the console when the input is masked. This not localizable.

Command completion implementation object.

This is a test hook for programmatically reading and writing ConsoleHost I/O.

Return true if the console supports a VT100 like virtual terminal.

Constructs an instance.

Supplies an implementation of PSHostRawUserInterface that provides low-level console mode UI facilities.

True if command completion is currently running.

True if the Read* functions should read from the stdin stream instead of from the win32 console.

True if the host shouldn't write out prompts.

See base class.

If Win32's SetConsoleMode fails OR Win32's ReadConsole fails OR obtaining information about the buffer failed OR Win32's SetConsoleCursorPosition failed

See base class.

If obtaining a handle to the active screen buffer failed OR Win32's setting input buffer mode to disregard window and mouse input failed OR Win32's ReadConsole failed If Ctrl-C is entered by user

Implementation based on NT CredUI's GetPasswdStr. Use Win32.ReadConsole to construct a SecureString. The advantage of ReadConsole over ReadKey is Alt-ddd where d is {0-9} is allowed. It also manages the cursor as keys are entered and "backspaced". However, it is possible that while this method is running, the console buffer contents could change. Then, its cursor mgmt will likely be messed up. Secondary implementation for Unix based on Console.ReadKey(), where the advantage is portability through abstraction. Does not support arrow key movement, but supports backspace.

True to specify reading a SecureString; false reading a string string for output echo If obtaining a handle to the active screen buffer failed OR Win32's setting input buffer mode to disregard window and mouse input failed OR Win32's ReadConsole failed OR obtaining information about the buffer failed OR Win32's SetConsoleCursorPosition failed If Ctrl-C is entered by user

Handle writing print token with proper cursor adjustment for ReadLineSafe.

token output for each char input. It must be a one-char string it is the cursor position where ReadLineSafe begins If obtaining information about the buffer failed OR Win32's SetConsoleCursorPosition failed

Handle backspace with proper cursor adjustment for ReadLineSafe.

it is the cursor position where ReadLineSafe begins If obtaining information about the buffer failed OR Win32's SetConsoleCursorPosition failed

Blank out at and move rawui.CursorPosition to

Position to blank out.

If is set on , unset it and return true; otherwise return false.

a flag in ConsoleControl.ConsoleModes to be unset in true if is set on false otherwise

See base class.

If Win32's CreateFile fails OR Win32's GetConsoleMode fails OR Win32's SetConsoleMode fails OR Win32's WriteConsole fails

See base class.

If obtaining information about the buffer failed OR Win32's SetConsoleTextAttribute OR Win32's CreateFile fails OR Win32's GetConsoleMode fails OR Win32's SetConsoleMode fails OR Win32's WriteConsole fails

See base class.

Win32's CreateFile fails OR Win32's GetConsoleMode fails OR Win32's SetConsoleMode fails OR Win32's WriteConsole fails

See base class.

Win32's CreateFile fails OR Win32's GetConsoleMode fails OR Win32's SetConsoleMode fails OR Win32's WriteConsole fails

This is a poor-man's word-wrapping routine. It breaks a single string into segments small enough to fit within a given number of cells. A break is determined by the last occurrence of whitespace that allows all prior characters on a line to be written within a given number of cells. If there is no whitespace found within that span, then the largest span that will fit in the bounds is used. The problem is complicated by the fact that a single character may consume more than one cell. Conceptually, this is the same case as placing an upper bound on the length of a line while also having a strlen function that arbitrarily considers the length of any single character to be 1 or greater.

Text to be emitted. Each tab character in the text is replaced with a space in the results. Max width, in buffer cells, of a single line. Note that a single character may consume more than one cell. The number of cells consumed is determined by calling ConsoleHostRawUserInterface.LengthInBufferCells. A list of strings representing the text broken into "lines" each of which are guaranteed not to exceed maxWidthInBufferCells.

Struct used by WrapText.

Chops text into "words," where a word is defined to be a sequence of whitespace characters, or a sequence of non-whitespace characters, each sequence being no longer than a given maximum. Therefore, in the text "this is a string" there are 7 words: 4 sequences of non-whitespace characters and 3 sequences of whitespace characters. Whitespace is considered to be spaces or tabs. Each tab character is replaced with a single space.

The text to be chopped up. The maximum number of buffer cells that each word may consume. A list of words, in the same order they appear in the source text. This can be made faster by, instead of creating little strings for each word, creating indices of the start and end range of a word. That would reduce the string allocations.

Helper for ChopTextIntoWords. Takes a span of characters in a string and adds it to the word list, further subdividing the span as needed so that each subdivision fits within the limit.

The string of characters in which the span is to be extracted. index into text of the start of the word to be added. index of the char after the last char to be included in the word. The maximum number of buffer cells that each word may consume. true if the span is whitespace, false if not. The list into which the words will be added.

See base class.

Invoked by CommandBase.WriteProgress to display a progress record.

Reads a line of input from the console. Returns when the user hits enter, a break key, a break event occurs. In the case that stdin has been redirected, reads from the stdin stream instead of the console.

true to end input when the user hits the tab or shift-tab keys, false to only end on the enter key (or a break event). Ignored if not reading from the console device. The initial contents of the input buffer. Nice if you want to have a default result. Ignored if not reading from the console device. Receives an enum value indicating how input was ended. TBD true to include the results in any transcription that might be happening. The string read from either the console or the stdin stream. null if: - stdin was read and EOF was reached on the stream, or - the console was read, and input was terminated with Ctrl-C, Ctrl-Break, or Close. If Win32's SetConsoleMode fails OR Win32's ReadConsole fails OR obtaining information about the buffer failed OR Win32's SetConsoleCursorPosition failed

Get the character at the cursor when the user types 'tab' in the middle of line.

The cursor position where 'tab' is hit.

Strip nulls from a string.

The string to process. The string with any '\0' characters removed.

Reads a line, and completes the input for the user if they hit tab.

The Executor instance on which to run any pipelines that are needed to find matches null on a break event the completed line otherwise

Called at the end of a prompt loop to take down any progress display that might have appeared and purge any outstanding progress activity state.

Invoked by ConsoleHostUserInterface.WriteProgress to update the set of outstanding activities for which ProgressRecords have been received.

TimerCallback for '_progPaneUpdateTimer' to update 'progPaneUpdateFlag'

Used by Prompt to indicate any common errors when converting the user input string to the type of the parameter.

No error or not an error prompt handles.

Format error.

Overflow error.

See base class.

If is null OR at least one FieldDescription in is null If count is less than 1 OR at least one FieldDescription.AssemblyFullName in is null or empty If a FieldDescription in specifies one of SecureString or PSCredential and the type can not be loaded. OR at least one FieldDescription in specifies an array whose rank is less than 1. If the converting the user input to the prompt field type fails unless it is caused by OverflowException or FormatException

Called by Prompt. Reads user input and processes tilde commands.

Prompt written to host for the field. The field to be read. True to echo user input. True if the field is a list. Valid only if listInput is true. set to true if the input signals end of list input. True if-and-only-if the input is canceled, e.g., by Ctrl-C or Ctrl-Break. Processed input string to be converted with LanguagePrimitives.ConvertTo.

Uses LanguagePrimitives.ConvertTo to parse inputString for fieldType. Handles two most common parse exceptions: OverflowException and FormatException.

The type that inputString is to be interpreted. Is the call coming from a remote host. The string to be converted. if there's no error in the conversion, the converted object will be assigned here; otherwise, this will be the same as the inputString An object of type fieldType that inputString represents.

Handles Tilde Commands in Prompt If input does not start with PromptCommandPrefix (= "!"), returns input Tilde commands - ! end of list, only valid for input field types that implement IList, returns string.Empty !!* input !* literally, returns !* where * is any string !h prints out field's Quick Help, returns null All others tilde comments are invalid and return null returns null if-and-only-if there's nothing the caller can process.

See base class.

If is null. If .Count is 0. If is greater than the length of . when prompt is canceled by, for example, Ctrl-c.

Presents a dialog allowing the user to choose options from a set of options.

Caption to precede or title the prompt. E.g. "Parameters for get-foo (instance 1 of 2)" A message that describes what the choice is for. An Collection of ChoiceDescription objects that describe each choice. The index of the labels in the choices collection element to be presented to the user as the default choice(s). The indices of the choice elements that corresponds to the options selected.

Guarantee a contrasting color for the prompt...

Guarantee a contrasting color for the default prompt that is slightly different from the other prompt elements.

Prompt for credentials. In future, when we have Credential object from the security team, this function will be modified to prompt using secure-path if so configured.

Prompt for credentials.

Name of the user whose creds are to be prompted for. If set to null or empty string, the function will prompt for user name first. Name of the target for which creds are being collected. Message to be displayed. Caption for the message. What type of creds can be supplied by the user. Options that control the cred gathering UI behavior. PSCredential object, or null if input was cancelled (or if reading from stdin and stdin at EOF).

This class provides an entry point which is called to transfer control to console host implementation.

Entry point in to ConsoleShell. This method is called by main of minishell.

Banner text to be displayed by ConsoleHost. Help text for minishell. This is displayed on 'minishell -?'. Commandline parameters specified by user. An integer value which should be used as exit code for the process.

Entry point in to ConsoleShell. Used to create a custom Powershell console application.

InitialSessionState to be used by the ConsoleHost. Banner text to be displayed by ConsoleHost. Help text for the shell. Commandline parameters specified by user. An integer value which should be used as exit code for the process.

Implementation of entry point to ConsoleShell. Used to create a custom Powershell console application.

InitialSessionState to be used by the ConsoleHost. Banner text to be displayed by ConsoleHost. Help text for the shell. Commandline parameters specified by user. True when the InitialSessionState object is provided by caller. An integer value which should be used as exit code for the process.

Executor wraps a Pipeline instance, and provides helper methods for executing commands in that pipeline. It is used to provide bookkeeping and structure to the use of pipeline in such a way that they can be interrupted and cancelled by a break event handler, and to track nesting of pipelines (which happens with interrupted input loops (aka subshells) and use of tab-completion in prompts). The bookkeeping is necessary because the break handler is static and global, and there is no means for tying a break handler to an instance of an object. The class' instance methods manage a single pipeline. The class' static methods track the outstanding instances to ensure that only one instance is 'active' (and therefore cancellable) at a time.

Constructs a new instance.

A reference to the parent ConsoleHost that created this instance. true if the executor is supposed to use nested pipelines; false if not. True if the instance will be used to execute the prompt function, which will delay stopping the pipeline by some milliseconds. This will prevent us from stopping the pipeline so quickly that, when the user leans on the ctrl-c key, the prompt "stops working" (because it is being stopped faster than it can run to completion).

This method handles failures in executing the pipeline asynchronously.

Executes a pipeline in the console when we are running asnyc.

The pipeline to execute. Any exception thrown trying to run the pipeline. The options to use to execute the pipeline.

All calls to the Runspace to execute a command line must be done with this function, which properly synchronizes access to the running pipeline between the main thread and the break handler thread. This synchronization is necessary so that executions can be aborted with Ctrl-C (including evaluation of the prompt and collection of command-completion candidates). On any given Executor instance, ExecuteCommand should be called at most once at a time by any one thread. It is NOT reentrant.

The command line to be executed. Must be non-null. Receives the Exception thrown by the execution of the command, if any. If no exception is thrown, then set to null. Can be tested to see if the execution was successful or not. Options to govern the execution The object stream resulting from the execution. May be null.

Executes a command (by calling this.ExecuteCommand), and coerces the first result object to a string. Any Exception thrown in the course of execution is returned through the exceptionThrown parameter.

The command to execute. May be any valid monad command. Receives the Exception thrown by the execution of the command, if any. Set to null if no exception is thrown. Can be tested to see if the execution was successful or not. The string representation of the first result object returned, or null if an exception was thrown or no objects were returned by the command.

Executes a command (by calling this.ExecuteCommand), and coerces the first result object to a bool. Any Exception thrown in the course of execution is caught and ignored.

The command to execute. May be any valid monad command. The Nullable`bool representation of the first result object returned, or null if an exception was thrown or no objects were returned by the command.

Executes a command (by calling this.ExecuteCommand), and coerces the first result object to a bool. Any Exception thrown in the course of execution is returned through the exceptionThrown parameter.

The command to execute. May be any valid monad command. Receives the Exception thrown by the execution of the command, if any. Set to null if no exception is thrown. Can be tested to see if the execution was successful or not. The Nullable`bool representation of the first result object returned, or null if an exception was thrown or no objects were returned by the command.

Cancels execution of the current instance. Does nothing if the current instance is not running. Called in response to a break handler, by the static Executor.Cancel method.

Resets the instance to its post-ctor state. Does not cancel execution.

Makes the given instance the "current" instance, that is, the instance that will receive a Cancel call if the break handler is triggered and calls the static Cancel method.

The instance to make current. Null is allowed. Here are some state-transition cases to illustrate the use of CurrentExecutor null is current p1.ExecuteCommand set p1 as current promptforparams tab complete p2.ExecuteCommand set p2 as current p2.Execute completes restore old current to p1 p1.Execute completes restore null as current Here's another case: null is current p1.ExecuteCommand set p1 as current ShouldProcess - suspend EnterNestedPrompt set null as current so that break does not exit the subshell evaluate prompt p2.ExecuteCommand set p2 as current Execute completes restore null as current nested loop exit restore p1 as current Summary: ExecuteCommand always saves/sets/restores CurrentExecutor Host.EnterNestedPrompt always saves/clears/restores CurrentExecutor

Cancels the execution of the current instance (the instance last passed to PushCurrentExecutor), if any. Does nothing if no instance is Current.

Defines an entry point from unmanaged code to PowerShell.

Starts PowerShell.

Deprecated: Console file used to create a runspace configuration to start PowerShell Command line arguments to the PowerShell Length of the passed in argument array.

Starts PowerShell.

Command line arguments to PowerShell Length of the passed in argument array.

Represents all of the outstanding progress activities received by the host, and includes methods to update that state upon receipt of new ProgressRecords, and to render that state into an array of strings such that ProgressPane can display it. The set of activities that we're tracking is logically a binary tree, with siblings in one branch and children in another. For ease of implementation, this tree is represented as lists of lists. We use ArrayList as out list type, although List1 (generic List) would also have worked. I suspect that ArrayList is faster because there are fewer links to twiddle, though I have not measured that. This class uses lots of nearly identical helper functions to recursively traverse the tree. If I weren't so pressed for time, I would see if generic methods could be used to collapse the number of traversers.

Update the data structures that represent the outstanding progress records reported so far.

Identifier of the source of the event. This is used as part of the "key" for matching newly received records with records that have already been received. For a record to match (meaning that they refer to the same activity), both the source and activity identifiers need to match. The ProgressRecord received that will either update the status of an activity which we are already tracking, or represent a new activity that we need to track.

Removes a node from the tree.

List in the tree from which the node is to be removed. Index into the list of the node to be removed.

Adds a node to the tree, first removing the oldest node if the tree is too large.

List in the tree where the node is to be added. Node to be added.

Convenience overload.

Finds a node with a given ActivityId in provided set of nodes. Recursively walks the set of nodes and their children.

Identifier of the source of the record. ActivityId to search for. Receives reference to the List where the found node was located, or null if no suitable node was found. Receives the index into listWhereFound that indicating where in the list the node was located, or -1 if no suitable node was found. The found node, or null if no suitable node was located.

Finds the oldest node with a given rendering style that is at least as old as a given age.

List of nodes to search. Child lists of each node in this list will also be searched. The minimum age of the node to be located. To find the oldest node, pass 0. The rendering style of the node to be located. The found node, or null if no suitable node was located.

Increments the age of each of the nodes in the given list, and all their children. Also sets the rendering style of each node to "full." All nodes are aged every time a new ProgressRecord is received.

Generates an array of strings representing as much of the outstanding progress activities as possible within the given space. As more outstanding activities are collected, nodes are "compressed" (i.e. rendered in an increasing terse fashion) in order to display as many as possible. Ultimately, some nodes may be compressed to the point of invisibility. The oldest nodes are compressed first.

The maximum width (in BufferCells) that the rendering may consume. The maximum height (in BufferCells) that the rendering may consume. The PSHostRawUserInterface used to gauge string widths in the rendering. An array of strings containing the textual representation of the outstanding progress activities.

Helper function for Render(). Recursively renders nodes.

The rendered strings so far. Additional rendering will be appended. The nodes to be rendered. All child nodes will also be rendered. The current indentation level (in BufferCells). The maximum number of BufferCells that the rendering can consume, horizontally. The PSHostRawUserInterface used to gauge string widths in the rendering.

Tallies up the number of BufferCells vertically that will be required to show all the ProgressNodes in the given list, and all of their children.

The maximum height (in BufferCells) that the rendering may consume. The PSHostRawUserInterface used to gauge string widths in the rendering. The vertical height (in BufferCells) that will be required to show all of the nodes in the given list.

Helper function to CompressToFit. Considers compressing nodes from one level to another.

The PSHostRawUserInterface used to gauge string widths in the rendering. The maximum height (in BufferCells) that the rendering may consume. The maximum width (in BufferCells) that the rendering may consume. Receives the number of nodes that were compressed. If the result of the method is false, then this will be the total number of nodes being tracked (i.e. all of them will have been compressed). The rendering style (e.g. "compression level") that the nodes are expected to currently have. The new rendering style that a node will have when it is compressed. If the result of the method is false, then all nodes will have this rendering style. true to indicate that the nodes are compressed to the point that their rendering will fit within the constraint, or false to indicate that all of the nodes are compressed to a given level, but that the rendering still can't fit within the constraint.

"Compresses" the nodes representing the outstanding progress activities until their rendering will fit within a "given height, or until they are compressed to a given level. The oldest nodes are compressed first. This is a 4-stage process -- from least compressed to "invisible". At each stage we find the oldest nodes in the tree and change their rendering style to a more compact style. As soon as the rendering of the nodes will fit within the maxHeight, we stop. The result is that the most recent nodes will be the least compressed, the idea being that the rendering should show the most recently updated activities with the most complete rendering for them possible.

Called for each node in the tree.

The node being visited. The list in which the node resides. The index into listWhereFound of the node. true to continue visiting nodes, false if not.

ProgressNode is an augmentation of the ProgressRecord type that adds extra fields for the purposes of tracking outstanding activities received by the host, and rendering them in the console.

Indicates the various layouts for rendering a particular node.

Allocate only one line for displaying the StatusDescription or the CurrentOperation, truncate the rest if the StatusDescription or CurrentOperation doesn't fit in one line.

The node will be displayed the same as Full, plus, the whole StatusDescription and CurrentOperation will be displayed (in multiple lines if needed).

The node will be displayed using ANSI escape sequences.

Constructs an instance from a ProgressRecord.

Renders a single progress node as strings of text according to that node's style. The text is appended to the supplied list of strings.

List of strings to which the node's rendering will be appended. The indentation level (in BufferCells) at which the node should be rendered. The maximum number of BufferCells that the rendering is allowed to consume. The PSHostRawUserInterface used to gauge string widths in the rendering.

Renders a node in the "Full" style.

Renders a node in the "Compact" style.

Renders a node in the "Minimal" style.

Renders a node in the "ANSI" style.

List of strings to which the node's rendering will be appended. The indentation level in chars at which the node should be rendered. The maximum number of chars that the rendering is allowed to consume.

The nodes that have this node as their parent.

The "age" of the node. A node's age is incremented by PendingProgress.Update each time a new ProgressRecord is received by the host. A node's age is reset when a corresponding ProgressRecord is received. Thus, the age of a node reflects the number of ProgressRecord that have been received since the node was last updated. The age is used by PendingProgress.Render to determine which nodes should be rendered on the display, and how. As the display has finite size, it may be possible to have many more outstanding progress activities than will fit in that space. The rendering of nodes can be progressively "compressed" into a more terse format, or not rendered at all in order to fit as many nodes as possible in the available space. The oldest nodes are compressed or skipped first.

The style in which this node should be rendered.

Identifies the source of the progress record.

The number of vertical BufferCells that are required to render the node in its current style.

The number of vertical BufferCells that are required to render the node in the Full style.

The number of vertical BufferCells that are required to render the node in the Compact style.

ProgressPane is a class that represents the "window" in which outstanding activities for which the host has received progress updates are shown.

Constructs a new instance.

An implementation of the PSHostRawUserInterface with which the pane will be shown and hidden.

Indicates whether the pane is visible on the screen buffer or not.

true if the pane is visible, false if not.

Shows the pane in the screen buffer. Saves off the content of the region of the buffer that will be overwritten so that it can be restored again.

Hides the pane by restoring the saved contents of the region of the buffer that the pane occupies. If the pane is not showing, then does nothing.

Updates the pane with the rendering of the supplied PendingProgress, and shows it.

A PendingProgress instance that represents the outstanding activities that should be shown.

Wraps Hitesh's xml serializer in such a way that it will select the proper serializer based on the data format.

Describes the format of the data streamed between minishells, e.g. the allowed arguments to the minishell -outputformat and -inputformat command line parameters.

Text format -- i.e. stream text just as out-default would display it.

XML-serialized format.

Indicates that the data should be discarded instead of processed.

Implements the start-transcript cmdlet.

The name of the file in which to write the transcript. If not provided, the file indicated by the variable $TRANSCRIPT is used. If neither the filename is supplied or $TRANSCRIPT is not set, the filename shall be $HOME/My Documents/PowerShell_transcript.YYYYMMDDmmss.txt.

The literal name of the file in which to write the transcript.

Describes the current state of the activity.

Property that sets force parameter. This will reset the read-only attribute on an existing file.

The read-only attribute will not be replaced when the transcript is done.

Property that prevents file overwrite.

Whether to include command invocation time headers between commands.

Gets or sets whether to use minimal transcript header.

Starts the transcription.

resolve a user provided file name or path (including globbing characters) to a fully qualified file path, using the file system provider

Implements the stop-transcript cmdlet.

Stops the transcription.

A Helper class for printing notification on PowerShell startup when there is a new update.

For the detailed design, please take a look at the corresponding RFC.

The version of new update is persisted using a file, not as the file content, but instead baked in the file name in the following template: `update{notification-type}_{version}_{publish-date}` -- held by 's_updateFileNameTemplate', while 's_updateFileNamePattern' holds the pattern of this file name.

For each notification type, we need two files to achieve the synchronization for the update check: `_sentinel{notification-type}_` -- held by 's_sentinelFileName'; `sentinel{notification-type}-{year}-{month}-{day}.done` -- held by 's_doneFileNameTemplate', while 's_doneFileNamePattern' holds the pattern of this file name. The {notification-type} part will be the integer value of the corresponding `NotificationType` member. The {year}-{month}-{day} part will be filled with the date of current day when the update check runs.

Gets a value indicating whether update notification should be done.

Check for the existence of the update file and parse the file name if it exists.

Get the exact update file path. Get the version of the new release. Get the publish date of the new release. False, when 1. found more than one update files that matched the pattern; OR 2. found only one update file, but failed to parse its name for version and publish date. True, when 1. no update file was found, namely no new updates yet; 2. found only one update file, and succeeded to parse its name for version and publish date.

Get the notification type setting.

Notification type that can be configured.

Turn off the update notification.

Give you the default behaviors: - the preview version 'pwsh' checks for the new preview version and the new GA version. - the GA version 'pwsh' checks for the new GA version only.

Both preview and GA version 'pwsh' checks for the new LTS version only.

The datetime stamp is in UTC. For example: 2019-03-28T18:42:02Z.

The release tag name.

IntPtr is being used for the string fields to make the marshaller faster and simpler. With IntPtr, all fields are blittable, and since we don't use the string fields at all, nothing is lost.

A property store.

Gets the number of properties contained in the property store.

Get a property key located at a specific index.

Gets the value of a property from the store.

Sets the value of a property in the store.

Commits the changes.

HRESULT Wrapper

S_OK

S_FALSE.

E_INVALIDARG.

E_OUTOFMEMORY.

E_NOINTERFACE.

E_FAIL.

E_ELEMENTNOTFOUND.

TYPE_E_ELEMENTNOTFOUND.

NO_OBJECT.

Win32 Error code: ERROR_CANCELLED.

ERROR_CANCELLED.

The requested resource is in use.

The requested resources is read-only.

Defines a unique key for a Shell Property.

A unique GUID for the property.

Property identifier (PID)

PropertyKey Constructor.

A unique GUID for the property. Property identifier (PID).

Returns whether this object is equal to another. This is vital for performance of value types.

The object to compare against. Equality result.

Returns the hash code of the object. This is vital for performance of value types.

Returns whether this object is equal to another. This is vital for performance of value types.

The object to compare against. Equality result.

Implements the == (equality) operator.

First property key to compare. Second property key to compare. True if object a equals object b. false otherwise.

Implements the != (inequality) operator.

First property key to compare. Second property key to compare. True if object a does not equal object b. false otherwise.

Override ToString() to provide a user friendly string representation.

String representing the property key.

Represents the OLE struct PROPVARIANT. This class is intended for internal use only.

Originally sourced from https://blogs.msdn.com/adamroot/pages/interop-with-propvariants-in-net.aspx and modified to add ability to set values

Set a string value.

Disposes the object, calls the clear function.

Finalizes an instance of the class.