#include "precomp.h"

#include "VtIo.hpp"

#include <til/unicode.h>

#include "directio.h"

#include "handle.h" // LockConsole

#include "output.h" // CloseConsoleProcessState

#include "../interactivity/inc/ServiceLocator.hpp"

#include "../renderer/base/renderer.hpp"

#include "../types/inc/CodepointWidthDetector.hpp"

#include "../types/inc/utils.hpp"

using namespace Microsoft::Console;

using namespace Microsoft::Console::Render;

using namespace Microsoft::Console::VirtualTerminal;

using namespace Microsoft::Console::Types;

using namespace Microsoft::Console::Utils;

using namespace Microsoft::Console::Interactivity;

[[nodiscard]] HRESULT VtIo::Initialize(const ConsoleArguments* const pArgs)

}

[[nodiscard]] HRESULT VtIo::_Initialize(const HANDLE InHandle,

}

bool VtIo::IsUsingVt() const

{

return _state != State::Uninitialized;

}

[[nodiscard]] HRESULT VtIo::StartIfNeeded()

}

void VtIo::Shutdown() noexcept

}

void VtIo::SetDeviceAttributes(const til::enumset<DeviceAttribute, uint64_t> attributes) noexcept

{

_deviceAttributes = attributes;

}

til::enumset<DeviceAttribute, uint64_t> VtIo::GetDeviceAttributes() const noexcept

{

return _deviceAttributes;

}

void VtIo::CreatePseudoWindow()

}

void VtIo::SendCloseEvent()

}

static constexpr bool IsControlCharacter(wchar_t wch) noexcept

}

static constexpr size_t formatAttributesMaxLen = 16;

static char* formatAttributes(char* out, const TextAttribute& attributes) noexcept

{

static uint8_t sgr[] = { 30, 31, 32, 33, 34, 35, 36, 37, 90, 91, 92, 93, 94, 95, 96, 97 };

// Applications expect that SetConsoleTextAttribute() completely replaces whatever attributes are currently set,

// including any potential VT-exclusive attributes. Since we don't know what those are, we must always emit a SGR 0.

// Copying 4 bytes instead of the correct 3 means we need just 1 DWORD mov. Neat.

//

// 3 bytes.

memcpy(out, "\x1b[0", 4);

out += 3;

// 2 bytes.

if (attributes.IsReverseVideo())

{

memcpy(out, ";7", 2);

out += 2;

}

// 3 bytes (";97").

if (attributes.GetForeground().IsLegacy())

{

const uint8_t index = sgr[attributes.GetForeground().GetIndex()];

out = fmt::format_to(out, FMT_COMPILE(";{}"), index);

}

// 4 bytes (";107").

if (attributes.GetBackground().IsLegacy())

{

const uint8_t index = sgr[attributes.GetBackground().GetIndex()] + 10;

out = fmt::format_to(out, FMT_COMPILE(";{}"), index);

}

// 1 byte.

*out++ = 'm';

return out;

}

void VtIo::FormatAttributes(std::string& target, const TextAttribute& attributes)

}

void VtIo::FormatAttributes(std::wstring& target, const TextAttribute& attributes)

}

wchar_t VtIo::SanitizeUCS2(wchar_t ch)

}

VtIo::Writer::Writer(VtIo* io) noexcept :

_io{ io }

{

if (_io)

{

_io->_corked += 1;

}

}

VtIo::Writer::~Writer() noexcept

{

// If _io is non-null, then we didn't call Submit, e.g. because of an exception.

// We need to avoid flushing the buffer in that case.

if (_io)

{

_io->_writerTainted = true;

_io->_uncork();

}

}

VtIo::Writer::operator bool() const noexcept

{

return _io != nullptr;

}

void VtIo::Writer::Submit()

{

const auto io = std::exchange(_io, nullptr);

io->_uncork();

}

void VtIo::_uncork()

}

void VtIo::_flushNow()

}

void VtIo::Writer::BackupCursor() const

{

if (!_io->_writerRestoreCursor)

{

_io->_writerRestoreCursor = true;

_io->_back.append("\x1b\x37"); // DECSC: DEC Save Cursor (+ attributes)

}

}

void VtIo::Writer::WriteUTF8(std::string_view str) const

{

_io->_back.append(str);

}

void VtIo::Writer::WriteUTF16(std::wstring_view str) const

{

if (str.empty())

{

return;

}

const auto existingUTF8Len = _io->_back.size();

const auto incomingUTF16Len = str.size();

// When converting from UTF-16 to UTF-8 the worst case is 3 bytes per UTF-16 code unit.

const auto incomingUTF8Cap = incomingUTF16Len * 3;

const auto totalUTF8Cap = existingUTF8Len + incomingUTF8Cap;

// Since WideCharToMultiByte() only supports `int` lengths, we check for an overflow past INT_MAX/3.

// We also check for an overflow of totalUTF8Cap just to be sure.

if (incomingUTF16Len > gsl::narrow_cast<size_t>(INT_MAX / 3) || totalUTF8Cap <= existingUTF8Len)

{

THROW_HR_MSG(E_INVALIDARG, "string too large");

}

// C++23's resize_and_overwrite is too valuable to not use.

// It reduce the CPU overhead by roughly half.

#if !defined(__cpp_lib_string_resize_and_overwrite) && _MSVC_STL_UPDATE >= 202111L

#define resize_and_overwrite _Resize_and_overwrite

#elif !defined(__cpp_lib_string_resize_and_overwrite)

#error "rely on resize_and_overwrite"

#endif

// NOTE: Throwing inside resize_and_overwrite invokes undefined behavior.

_io->_back.resize_and_overwrite(totalUTF8Cap, [&](char* buf, const size_t) noexcept {

const auto len = WideCharToMultiByte(CP_UTF8, 0, str.data(), gsl::narrow_cast<int>(incomingUTF16Len), buf + existingUTF8Len, gsl::narrow_cast<int>(incomingUTF8Cap), nullptr, nullptr);

return existingUTF8Len + std::max(0, len);

});

#undef resize_and_overwrite

}

void VtIo::Writer::WriteUTF16TranslateCRLF(std::wstring_view str) const

{

const auto beg = str.begin();

const auto end = str.end();

auto begCopy = beg;

auto endCopy = beg;

// Our goal is to prepend a \r in front of \n that don't already have one.

// There's no point in replacing \n\n\n with \r\n\r\n\r\n, however. It's just fine to do \r\n\n\n.

// After all we aren't a text file, we're a terminal, and \r\n and \n are identical if we're at the first column.

for (;;)

{

// To do so, we'll first find the next LF and emit the unrelated text before it.

endCopy = std::find(endCopy, end, L'\n');

WriteUTF16({ begCopy, endCopy });

begCopy = endCopy;

// Done? Great.

if (begCopy == end)

{

break;

}

// We only need to prepend a CR if the LF isn't already preceded by one.

if (begCopy == beg || begCopy[-1] != L'\r')

{

_io->_back.push_back('\r');

}

// Now extend the end of the next WriteUTF16 *past* this series of CRs and LFs.

// We've just ensured that the LF is preceded by a CR, so we can skip all this safely.

while (++endCopy != end && (*endCopy == L'\n' || *endCopy == L'\r'))

{

}

}

}

void VtIo::Writer::WriteUTF16StripControlChars(std::wstring_view str) const

{

auto it = str.data();

const auto end = it + str.size();

// We can picture `str` as a repeated sequence of regular characters followed by control characters.

while (it != end)

{

const auto begControlChars = FindActionableControlCharacter(it, end - it);

WriteUTF16({ it, begControlChars });

for (it = begControlChars; it != end && IsControlCharacter(*it); ++it)

{

WriteUCS2(SanitizeUCS2(*it));

}

}

}

void VtIo::Writer::WriteUCS2(wchar_t ch) const

{

char buf[4];

size_t len = 0;

if (til::is_surrogate(ch))

{

ch = UNICODE_REPLACEMENT;

}

if (ch <= 0x7f)

{

buf[len++] = static_cast<char>(ch);

}

else if (ch <= 0x7ff)

{

buf[len++] = static_cast<char>(0xc0 | (ch >> 6));

buf[len++] = static_cast<char>(0x80 | (ch & 0x3f));

}

else

{

buf[len++] = static_cast<char>(0xe0 | (ch >> 12));

buf[len++] = static_cast<char>(0x80 | ((ch >> 6) & 0x3f));

buf[len++] = static_cast<char>(0x80 | (ch & 0x3f));

}

_io->_back.append(buf, len);

}

void VtIo::Writer::WriteCUP(til::point position) const

{

fmt::format_to(std::back_inserter(_io->_back), FMT_COMPILE("\x1b[{};{}H"), position.y + 1, position.x + 1);

}

void VtIo::Writer::WriteDECTCEM(bool enabled) const

{

char buf[] = "\x1b[?25h";

buf[std::size(buf) - 2] = enabled ? 'h' : 'l';

_io->_back.append(&buf[0], std::size(buf) - 1);

}

void VtIo::Writer::WriteSGR1006(bool enabled) const

{

char buf[] = "\x1b[?1003;1006h";

buf[std::size(buf) - 2] = enabled ? 'h' : 'l';

_io->_back.append(&buf[0], std::size(buf) - 1);

}

void VtIo::Writer::WriteDECAWM(bool enabled) const

{

char buf[] = "\x1b[?7h";

buf[std::size(buf) - 2] = enabled ? 'h' : 'l';

_io->_back.append(&buf[0], std::size(buf) - 1);

}

void VtIo::Writer::WriteASB(bool enabled) const

{

char buf[] = "\x1b[?1049h";

buf[std::size(buf) - 2] = enabled ? 'h' : 'l';

_io->_back.append(&buf[0], std::size(buf) - 1);

}

bool VtIo::Writer::WriteDSRCPR() const

{

if (!_io->_pVtInputThread)

{

return false;

}

_io->_back.append("\x1b[6n");

_io->_pVtInputThread->CaptureNextCursorPositionReport();

return true;

}

void VtIo::Writer::WriteWindowVisibility(bool visible) const

{

char buf[] = "\x1b[1t";

buf[2] = visible ? '1' : '2';

_io->_back.append(&buf[0], std::size(buf) - 1);

}

void VtIo::Writer::WriteWindowTitle(std::wstring_view title) const

{

WriteUTF8("\x1b]0;");

WriteUTF16StripControlChars(title);

WriteUTF8("\x1b\\");

}

void VtIo::Writer::WriteAttributes(const TextAttribute& attributes) const

{

FormatAttributes(_io->_back, attributes);

}

void VtIo::Writer::WriteInfos(til::point target, std::span<const CHAR_INFO> infos) const

{

const auto beg = infos.begin();

const auto end = infos.end();

const auto last = end - 1;

WORD attributes = 0xffff;

WriteCUP(target);

for (auto it = beg; it != end; ++it)

{

const auto& ci = *it;

auto ch = ci.Char.UnicodeChar;

auto wide = WI_IsAnyFlagSet(ci.Attributes, COMMON_LVB_LEADING_BYTE | COMMON_LVB_TRAILING_BYTE);

if (wide)

{

if (WI_IsAnyFlagSet(ci.Attributes, COMMON_LVB_LEADING_BYTE))

{

if (it == last)

{

// The leading half of a wide glyph won't fit into the last remaining column.

// --> Replace it with a space.

ch = L' ';

wide = false;

}

}

else

{

if (it == beg)

{

// The trailing half of a wide glyph won't fit into the first column. It's incomplete.

// --> Replace it with a space.

ch = L' ';

wide = false;

}

else

{

// Trailing halves of glyphs are ignored within the run. We only emit the leading half.

continue;

}

}

}

if (attributes != ci.Attributes)

{

attributes = ci.Attributes;

WriteAttributes(TextAttribute{ attributes });

}

int repeat = 1;

if (wide && (til::is_surrogate(ch) || IsControlCharacter(ch)))

{

// Control characters, U+FFFD, etc. are narrow characters, so if the caller

// asked for a wide glyph we need to repeat the replacement character twice.

repeat++;

}

do

{

WriteUCS2(SanitizeUCS2(ch));

} while (--repeat);

}

}

void VtIo::Writer::WriteScreenInfo(SCREEN_INFORMATION& newContext, til::size oldSize) const

{

const auto area = static_cast<size_t>(oldSize.width * oldSize.height);

auto& main = newContext.GetMainBuffer();

auto& alt = newContext.GetActiveBuffer();

const auto hasAltBuffer = &alt != &main;

// TODO GH#5094: This could use xterm's XTWINOPS "\e[8;<height>;<width>t" escape sequence here.

if (oldSize != main.GetBufferSize().Dimensions())

{

THROW_IF_NTSTATUS_FAILED(main.ResizeTraditional(oldSize));

main.SetViewportSize(&oldSize);

}

if (hasAltBuffer && oldSize != alt.GetBufferSize().Dimensions())

{

THROW_IF_NTSTATUS_FAILED(alt.ResizeTraditional(oldSize));

alt.SetViewportSize(&oldSize);

}

const auto request = Viewport::FromDimensions({}, oldSize);

Viewport read;

til::small_vector<CHAR_INFO, 1024> infos;

infos.resize(area, CHAR_INFO{ L' ', FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED });

const auto dumpScreenInfo = [&](SCREEN_INFORMATION& screenInfo) {

THROW_IF_FAILED(ReadConsoleOutputWImplHelper(screenInfo, infos, request, read));

for (til::CoordType i = 0; i < oldSize.height; i++)

{

WriteInfos({ 0, i }, { infos.begin() + i * oldSize.width, static_cast<size_t>(oldSize.width) });

}

WriteCUP(screenInfo.GetTextBuffer().GetCursor().GetPosition());

WriteAttributes(screenInfo.GetAttributes());

WriteDECTCEM(screenInfo.GetTextBuffer().GetCursor().IsVisible());

WriteDECAWM(WI_IsFlagSet(screenInfo.OutputMode, ENABLE_WRAP_AT_EOL_OUTPUT));

};

WriteASB(false);

dumpScreenInfo(main);

if (hasAltBuffer)

{

WriteASB(true);

dumpScreenInfo(alt);

}

}