void
Log(const wchar_t *fmt, ...)
{
#if !defined(SHOW_CONSOLE)
DWORD dwRes = 0;
if (!GetDWORDRegKey(cehDumpDebugStrings, dwRes) || !dwRes) {
return;
}
#endif
va_list a = nullptr;
wchar_t szDebugString[1024];
if(!lstrlenW(fmt))
return;
va_start(a,fmt);
vswprintf(szDebugString, 1024, fmt, a);
va_end(a);
if(!lstrlenW(szDebugString))
return;
DWORD len;
WriteConsoleW(sCon, szDebugString, lstrlenW(szDebugString), &len, nullptr);
WriteConsoleW(sCon, L"\n", 1, &len, nullptr);
OutputDebugStringW(szDebugString);
OutputDebugStringW(L"\n");
}
void console_message_handlert::print(
unsigned level,
const std::string &message)
{
if(verbosity<level)
return;
#ifdef _WIN32
HANDLE out_handle=
GetStdHandle((level>1)?STD_OUTPUT_HANDLE:STD_ERROR_HANDLE);
// We use UTF16 when we write to the console,
// but we write UTF8 otherwise.
DWORD consoleMode;
if(GetConsoleMode(out_handle, &consoleMode))
{
// writing to the console
std::wstring wide_message=widen(message);
DWORD number_written;
WriteConsoleW(
out_handle, wide_message.c_str(),
(DWORD)wide_message.size(), &number_written, NULL);
WriteConsoleW(out_handle, L"\r\n", 2, &number_written, NULL);
}
else
{
// writing to a file
if(level>=4)
{
std::cout << message << '\n';
if(level<=6)
std::cout << std::flush;
}
else
std::cerr << message << '\n' << std::flush;
}
#else
// We flush after messages of level 6 or lower.
// We don't for messages of level 7 or higher to improve performance,
// in particular when writing to NFS.
// Messages level 3 or lower go to cerr, messages level 4 or
// above go to cout.
if(level>=4)
{
std::cout << message << '\n';
if(level<=6)
std::cout << std::flush;
}
else
std::cerr << message << '\n' << std::flush;
#endif
}
void
Log(const wchar_t *fmt, ...)
{
#if !defined(SHOW_CONSOLE)
return;
#endif
va_list a = nullptr;
wchar_t szDebugString[1024];
if(!lstrlenW(fmt))
return;
va_start(a,fmt);
vswprintf(szDebugString, 1024, fmt, a);
va_end(a);
if(!lstrlenW(szDebugString))
return;
DWORD len;
WriteConsoleW(sCon, szDebugString, lstrlenW(szDebugString), &len, nullptr);
WriteConsoleW(sCon, L"\n", 1, &len, nullptr);
if (IsDebuggerPresent()) {
OutputDebugStringW(szDebugString);
OutputDebugStringW(L"\n");
}
}
static BOOL
TUIDisplayStatusMessage(
IN PGINA_CONTEXT pgContext,
IN HDESK hDesktop,
IN DWORD dwOptions,
IN PWSTR pTitle,
IN PWSTR pMessage)
{
static LPCWSTR newLine = L"\n";
DWORD result;
TRACE("TUIDisplayStatusMessage(%ws)\n", pMessage);
UNREFERENCED_PARAMETER(pgContext);
UNREFERENCED_PARAMETER(hDesktop);
UNREFERENCED_PARAMETER(dwOptions);
UNREFERENCED_PARAMETER(pTitle);
return
WriteConsoleW(
GetStdHandle(STD_OUTPUT_HANDLE),
pMessage,
wcslen(pMessage),
&result,
NULL) &&
WriteConsoleW(
GetStdHandle(STD_OUTPUT_HANDLE),
newLine,
wcslen(newLine),
&result,
NULL);
}
static BOOL
DisplayResourceText(
IN UINT uIdResourceText,
IN BOOL AddNewLine)
{
WCHAR Prompt[256];
static LPCWSTR newLine = L"\n";
DWORD count;
if (0 == LoadStringW(hDllInstance, uIdResourceText, Prompt, _countof(Prompt)))
return FALSE;
if (!WriteConsoleW(
GetStdHandle(STD_OUTPUT_HANDLE),
Prompt, wcslen(Prompt),
&count, NULL))
{
return FALSE;
}
if (AddNewLine)
{
if (!WriteConsoleW(
GetStdHandle(STD_OUTPUT_HANDLE),
newLine, wcslen(newLine),
&count, NULL))
{
return FALSE;
}
}
return TRUE;
}
static void print_string(const WCHAR *string)
{
DWORD count, ret, len, lena;
char *buf;
if(wshInteractive) {
static const WCHAR windows_script_hostW[] =
{'W','i','n','d','o','w','s',' ','S','c','r','i','p','t',' ','H','o','s','t',0};
MessageBoxW(NULL, string, windows_script_hostW, MB_OK);
return;
}
len = strlenW(string);
ret = WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), string, len, &count, NULL);
if(ret) {
static const WCHAR crnlW[] = {'\r','\n'};
WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), crnlW, sizeof(crnlW)/sizeof(*crnlW), &count, NULL);
return;
}
lena = WideCharToMultiByte(GetConsoleOutputCP(), 0, string, len, NULL, 0, NULL, NULL);
buf = heap_alloc(len);
if(!buf)
return;
WideCharToMultiByte(GetConsoleOutputCP(), 0, string, len, buf, lena, NULL, NULL);
WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), buf, lena, &count, FALSE);
heap_free(buf);
WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), "\r\n", 2, &count, FALSE);
}
static DWORD WCEL_WriteConsole(WCEL_Context* ctx, DWORD beg, DWORD len)
{
DWORD i, last, dw, ret = 0;
WCHAR tmp[2];
for (i = last = 0; i < len; i++)
{
if (ctx->line[beg + i] < ' ')
{
if (last != i)
{
WriteConsoleW(ctx->hConOut, &ctx->line[beg + last], i - last, &dw, NULL);
ret += dw;
}
tmp[0] = '^';
tmp[1] = '@' + ctx->line[beg + i];
WriteConsoleW(ctx->hConOut, tmp, 2, &dw, NULL);
last = i + 1;
ret += dw;
}
}
if (last != len)
{
WriteConsoleW(ctx->hConOut, &ctx->line[beg + last], len - last, &dw, NULL);
ret += dw;
}
return ret;
}
void Cell::Draw() const
{ //this handles changing the color and shape based on its' members
_CONSOLE_SCREEN_BUFFER_INFO t;
HANDLE st = GetStdHandle(STD_OUTPUT_HANDLE);
GetConsoleScreenBufferInfo(st, &t);
if(m_touched)
SetConsoleTextAttribute(st, m_color+1 | BACKGROUND_BLUE | BACKGROUND_INTENSITY);
else
SetConsoleTextAttribute(st, m_color+1);
if(m_shape==1 && m_color==1)//wild
{
SetConsoleTextAttribute(st, 15 | BACKGROUND_BLUE | BACKGROUND_INTENSITY);
wchar_t t[] = {223,0};
DWORD x;
WriteConsoleW(st, t, 1, &x, NULL);
}
else
{
if(m_shape)
{
wchar_t t[] = {m_shape+223,0};
DWORD x;
WriteConsoleW(st, t, 1, &x, NULL);
}
else
{
DWORD x;
WriteConsoleW(st, " ", 1, &x, NULL);
}
}
//change them back
SetConsoleTextAttribute(st,t.wAttributes);
}
void wrt_Wchr(WCHAR wc[]){
IS_HANDLE_NULL;
DWORD ws;
WriteConsoleW(hConsole,wc,wcslen(wc),&ws,NULL);
WCHAR enter[]=L"\r\n";
WriteConsoleW(hConsole,enter,wcslen(enter),&ws,NULL);
}
// async_wait 调用到这里
void operator()(boost::system::error_code ec)
{
DWORD r =0;
INPUT_RECORD ir;
ReadConsoleInputW(console_handle.native_handle(), &ir, 1, &r);
if (ir.EventType == KEY_EVENT && ir.Event.KeyEvent.bKeyDown && ir.Event.KeyEvent.uChar.UnicodeChar)
{
WCHAR c = ir.Event.KeyEvent.uChar.UnicodeChar;
if (c == L'\b')
{
// 退格键啊，应该删了
// WriteConsoleOutputW();
if (!readbuf.empty())
{
WCHAR lc = readbuf.back();
readbuf.pop_back();
if (lc >= 256)
{
WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), L"\b \b \b", 5, &r, 0);
}
else
{
WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), L"\b \b", 3, &r, 0);
}
}
}
else
{
readbuf.push_back(c);
}
if (iswprint(c))
{
WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), &c, 1, &r, 0);
}
// 判定 是不是读取到了 "\n"
// 是的话就可以调用 handler 了
if (c == L'\r')
{
// 读取到行尾啦！回调吧
std::string thisline = wide_to_utf8(std::wstring(readbuf.data(), readbuf.size()));
readbuf.clear();
WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), L"\n", 1, &r, 0);
SetConsoleMode(console_handle.native_handle(), m_savedmode);
m_handler(thisline);
return;
}
}
// 重复读取
console_handle.async_wait(*this);
}
void WriteOutput(int channel, const char *str)
{
wstring wstr = StringFormat::UTF82Wide(string(str));
if(channel == OSUtility::Output_DebugMon)
OutputDebugStringW(wstr.c_str());
else if(channel == OSUtility::Output_StdOut)
WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), wstr.c_str(), DWORD(wstr.size()), NULL, NULL);
else if(channel == OSUtility::Output_StdErr)
WriteConsoleW(GetStdHandle(STD_ERROR_HANDLE), wstr.c_str(), DWORD(wstr.size()), NULL, NULL);
}
/*
* cuiPrintTextW
*
* Purpose:
*
* Output text to the console or file.
* UNICODE version.
*
*/
VOID cuiPrintTextW(
_In_ LPWSTR lpText,
_In_ BOOL UseReturn
)
{
SIZE_T consoleIO;
DWORD bytesIO;
LPWSTR Buffer;
if (lpText == NULL)
return;
consoleIO = _strlen_w(lpText);
if ((consoleIO == 0) || (consoleIO > MAX_PATH * 4))
return;
consoleIO = consoleIO * sizeof(WCHAR) + 4 + sizeof(UNICODE_NULL);
Buffer = (LPWSTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, consoleIO);
if (Buffer) {
_strcpy(Buffer, lpText);
if (UseReturn) _strcat_w(Buffer, TEXT("\r\n"));
consoleIO = _strlen_w(Buffer);
if (g_ConsoleOutput != FALSE) {
WriteConsoleW(g_ConOut, Buffer, (DWORD)consoleIO, &bytesIO, NULL);
}
else {
WriteFile(g_ConOut, Buffer, (DWORD)(consoleIO * sizeof(WCHAR)), &bytesIO, NULL);
}
HeapFree(GetProcessHeap(), 0, Buffer);
}
}
int aa_fprintf(FILE *fp, const char *fmt, ...)
{
va_list ap;
int cnt;
HANDLE fh = (HANDLE)_get_osfhandle(_fileno(fp));
if (GetFileType(fh) != FILE_TYPE_CHAR) {
va_start(ap, fmt);
cnt = vfprintf(fp, fmt, ap);
va_end(ap);
} else {
char *s;
wchar_t *ws;
DWORD nw;
va_start(ap, fmt);
cnt = _vscprintf(fmt, ap);
va_end(ap);
s = malloc(cnt + 1);
va_start(ap, fmt);
cnt = _vsnprintf(s, cnt + 1, fmt, ap);
va_end(ap);
codepage_decode_wchar(CP_UTF8, s, &ws);
free(s);
fflush(fp);
WriteConsoleW(fh, ws, wcslen(ws), &nw, 0);
free(ws);
}
return cnt;
}
static void write_console_text(HANDLE wstream, char *buf)
{
wchar_t *out = mp_from_utf8(NULL, buf);
size_t out_len = wcslen(out);
WriteConsoleW(wstream, out, out_len, NULL, NULL);
talloc_free(out);
}
void WindowsConsoleLogger::write()
{
if (this->stdOut != NULL) {
DWORD check;
WriteConsoleW(this->stdOut, (void*)this->buffer, this->size, &check, NULL);
}
}
int x264_vfprintf( FILE *stream, const char *format, va_list arg )
{
HANDLE console = NULL;
DWORD mode;
if( stream == stdout )
console = GetStdHandle( STD_OUTPUT_HANDLE );
else if( stream == stderr )
console = GetStdHandle( STD_ERROR_HANDLE );
/* Only attempt to convert to UTF-16 when writing to a non-redirected console screen buffer. */
if( GetConsoleMode( console, &mode ) )
{
char buf[4096];
wchar_t buf_utf16[4096];
va_list arg2;
va_copy( arg2, arg );
int length = vsnprintf( buf, sizeof(buf), format, arg2 );
va_end( arg2 );
if( length > 0 && length < sizeof(buf) )
{
/* WriteConsoleW is the most reliable way to output Unicode to a console. */
int length_utf16 = MultiByteToWideChar( CP_UTF8, 0, buf, length, buf_utf16, sizeof(buf_utf16)/sizeof(wchar_t) );
DWORD written;
WriteConsoleW( console, buf_utf16, length_utf16, &written, NULL );
return length;
}
}
return vfprintf( stream, format, arg );
}
void _wprintf(LPCWSTR asBuffer)
{
if (!asBuffer) return;
int nAllLen = lstrlenW(asBuffer);
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
DWORD dwWritten = 0;
if (!IsOutputRedirected())
{
WriteConsoleW(hOut, asBuffer, nAllLen, &dwWritten, 0);
}
else
{
UINT cp = GetConsoleOutputCP();
int cchMax = WideCharToMultiByte(cp, 0, asBuffer, -1, NULL, 0, NULL, NULL) + 1;
char* pszOem = (cchMax > 1) ? (char*)malloc(cchMax) : NULL;
if (pszOem)
{
int nWrite = WideCharToMultiByte(cp, 0, asBuffer, -1, pszOem, cchMax, NULL, NULL);
if (nWrite > 1)
{
// Don't write terminating '\0' to redirected output
WriteFile(hOut, pszOem, nWrite-1, &dwWritten, 0);
}
free(pszOem);
}
}
}
int write(char const *p,int n)
{
namespace uf = boost::locale::utf;
char const *b = p;
char const *e = p+n;
if(!isatty_) {
DWORD size=0;
if(!WriteFile(handle_,p,n,&size,0) || static_cast<int>(size) != n)
return -1;
return n;
}
if(n > buffer_size)
return -1;
wchar_t *out = wbuffer_;
uf::code_point c;
size_t decoded = 0;
while(p < e && (c = uf::utf_traits<char>::decode(p,e))!=uf::illegal && c!=uf::incomplete) {
out = uf::utf_traits<wchar_t>::encode(c,out);
decoded = p-b;
}
if(c==uf::illegal)
return -1;
if(!WriteConsoleW(handle_,wbuffer_,out - wbuffer_,0,0))
return -1;
return decoded;
}
static int hostname_vprintfW(const WCHAR *msg, va_list va_args)
{
int wlen;
DWORD count, ret;
WCHAR msg_buffer[8192];
wlen = vsprintfW(msg_buffer, msg, va_args);
ret = WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), msg_buffer, wlen, &count, NULL);
if (!ret)
{
DWORD len;
char *msgA;
len = WideCharToMultiByte(GetConsoleOutputCP(), 0, msg_buffer, wlen,
NULL, 0, NULL, NULL);
msgA = HeapAlloc(GetProcessHeap(), 0, len);
if (!msgA)
return 0;
WideCharToMultiByte(GetConsoleOutputCP(), 0, msg_buffer, wlen, msgA, len,
NULL, NULL);
WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), msgA, len, &count, FALSE);
HeapFree(GetProcessHeap(), 0, msgA);
}
return count;
}
static int output_write(const WCHAR* str, int len)
{
DWORD ret, count;
ret = WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), str, len, &count, NULL);
if (!ret)
{
DWORD lenA;
char* strA;
/* On Windows WriteConsoleW() fails if the output is redirected. So fall
* back to WriteFile(), assuming the console encoding is still the right
* one in that case.
*/
lenA = WideCharToMultiByte(GetConsoleOutputCP(), 0, str, len,
NULL, 0, NULL, NULL);
strA = HeapAlloc(GetProcessHeap(), 0, lenA);
if (!strA)
return 0;
WideCharToMultiByte(GetConsoleOutputCP(), 0, str, len, strA, lenA,
NULL, NULL);
WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), strA, len, &count, FALSE);
HeapFree(GetProcessHeap(), 0, strA);
}
return count;
}
/**
Output given message to stdout without formatting.
*/
static void output(const WCHAR *message)
{
DWORD count;
DWORD res;
int wlen = strlenW(message);
if (!wlen) return;
res = WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), message, wlen, &count, NULL);
/* If writing to console fails, assume its file
i/o so convert to OEM codepage and output */
if (!res)
{
DWORD len;
char *mesA;
/* Convert to OEM, then output */
len = WideCharToMultiByte( GetConsoleOutputCP(), 0, message, wlen, NULL, 0, NULL, NULL );
mesA = HeapAlloc(GetProcessHeap(), 0, len*sizeof(char));
if (!mesA) return;
WideCharToMultiByte( GetConsoleOutputCP(), 0, message, wlen, mesA, len, NULL, NULL );
WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), mesA, len, &count, FALSE);
HeapFree(GetProcessHeap(), 0, mesA);
}
}
size_t
mm_stdio_c::_write(const void *buffer,
size_t size) {
HANDLE h_stdout = GetStdHandle(STD_OUTPUT_HANDLE);
if (INVALID_HANDLE_VALUE == h_stdout)
return 0;
DWORD file_type = GetFileType(h_stdout);
bool is_console = false;
if ((FILE_TYPE_UNKNOWN != file_type) && ((file_type & ~FILE_TYPE_REMOTE) == FILE_TYPE_CHAR)) {
DWORD dummy;
is_console = GetConsoleMode(h_stdout, &dummy);
}
if (is_console) {
const std::wstring &w = to_wide(g_cc_stdio->utf8(std::string(static_cast<const char *>(buffer), size)));
DWORD bytes_written = 0;
WriteConsoleW(h_stdout, w.c_str(), w.length(), &bytes_written, NULL);
return bytes_written;
}
size_t bytes_written = fwrite(buffer, 1, size, stdout);
fflush(stdout);
m_cached_size = -1;
return bytes_written;
}
void TestWriteConsole::test1()
{
//㘵
HANDLE std_output = GetStdHandle( STD_OUTPUT_HANDLE );
std::wstring ws = L"㘵中华人民共和国abc\n";
WriteConsoleW( std_output, ws.c_str(), ws.size(), NULL, NULL );
}
static int
flush_ansi(ansi_stream *as)
{ size_t written = 0;
while ( written < as->buffered )
{ BOOL rc;
DWORD done;
rc = WriteConsoleW(as->hConsole,
&as->buffer[written],
(DWORD)(as->buffered-written),
&done,
NULL);
if ( rc )
{ written += done;
} else
{ as->buffered = 0;
return -1;
}
}
as->buffered = 0;
return 0;
}
virtual int_type overflow(int_type ch)
{
DWORD n;
char_type _ch = (char_type)ch;
WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), &_ch, 1, &n, NULL);
return 0;
}
/*
fopen by file system codepage
*/
FILE *
fsyscp_fopen (const char *filename, const char *mode)
{
FILE *f;
wchar_t *fnamew, modew[4];
int i;
#if defined (KPSE_COMPAT_API)
kpathsea kpse;
#endif
assert(filename && mode);
fnamew = get_wstring_from_fsyscp(filename, fnamew=NULL);
for(i=0; (modew[i]=(wchar_t)mode[i]); i++) {} /* mode[i] must be ASCII */
f = _wfopen(fnamew, modew);
#if defined (KPSE_COMPAT_API)
if (f != NULL) {
kpse = kpse_def;
if (KPATHSEA_DEBUG_P (KPSE_DEBUG_FOPEN)) {
DEBUGF_START ();
fprintf (stderr, "fsyscp_fopen(%s [", filename);
WriteConsoleW( GetStdHandle( STD_ERROR_HANDLE ), fnamew, wcslen( fnamew ), NULL, NULL );
#if defined(_WIN64)
fprintf (stderr, "], %s) => 0x%I64x\n", mode, (unsigned __int64) f);
#else
fprintf (stderr, "], %s) => 0x%lx\n", mode, (unsigned long) f);
#endif
DEBUGF_END ();
}
}
#endif
free(fnamew);
return f;
}
static int reg_printfW(const WCHAR *msg, ...)
{
va_list va_args;
int wlen;
DWORD count, ret;
WCHAR msg_buffer[8192];
va_start(va_args, msg);
vsprintfW(msg_buffer, msg, va_args);
va_end(va_args);
wlen = lstrlenW(msg_buffer);
ret = WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), msg_buffer, wlen, &count, NULL);
if (!ret)
{
DWORD len;
char *msgA;
len = WideCharToMultiByte(GetConsoleOutputCP(), 0, msg_buffer, wlen,
NULL, 0, NULL, NULL);
msgA = HeapAlloc(GetProcessHeap(), 0, len * sizeof(char));
if (!msgA)
return 0;
WideCharToMultiByte(GetConsoleOutputCP(), 0, msg_buffer, wlen, msgA, len,
NULL, NULL);
WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), msgA, len, &count, FALSE);
HeapFree(GetProcessHeap(), 0, msgA);
}
return count;
}
//------------------------------------------------------------------------------
int hooked_fwrite(const void* data, int size, int count, void* unused)
{
wchar_t buf[2048];
size_t characters;
DWORD written;
size *= count;
characters = MultiByteToWideChar(
CP_UTF8, 0,
(const char*)data, size,
buf, sizeof_array(buf)
);
characters = characters ? characters : sizeof_array(buf) - 1;
buf[characters] = L'\0';
if (g_alt_fwrite_hook)
{
g_alt_fwrite_hook(buf);
}
else
{
HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
WriteConsoleW(handle, buf, (DWORD)wcslen(buf), &written, NULL);
}
return size;
}
static int taskkill_vprintfW(const WCHAR *msg, __ms_va_list va_args)
{
int wlen;
DWORD count, ret;
WCHAR msg_buffer[8192];
wlen = FormatMessageW(FORMAT_MESSAGE_FROM_STRING, msg, 0, 0, msg_buffer,
sizeof(msg_buffer)/sizeof(*msg_buffer), &va_args);
ret = WriteConsoleW(GetStdHandle(STD_OUTPUT_HANDLE), msg_buffer, wlen, &count, NULL);
if (!ret)
{
DWORD len;
char *msgA;
/* On Windows WriteConsoleW() fails if the output is redirected. So fall
* back to WriteFile(), assuming the console encoding is still the right
* one in that case.
*/
len = WideCharToMultiByte(GetConsoleOutputCP(), 0, msg_buffer, wlen,
NULL, 0, NULL, NULL);
msgA = HeapAlloc(GetProcessHeap(), 0, len);
if (!msgA)
return 0;
WideCharToMultiByte(GetConsoleOutputCP(), 0, msg_buffer, wlen, msgA, len,
NULL, NULL);
WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), msgA, len, &count, FALSE);
HeapFree(GetProcessHeap(), 0, msgA);
}
return count;
}
DWORD write(char const *p, DWORD n)
{
namespace uf = nowide::utf;
char const *b = p;
char const *e = p+n;
DWORD size=0;
if(!isatty_) {
if(!WriteFile(handle_,p,n,&size,0) || size != n)
return -1;
return n;
}
if(n > buffer_size)
return -1;
wchar_t *out = wbuffer_;
uf::code_point c;
DWORD decoded = 0;
while(p < e && (c = uf::utf_traits<char>::decode(p,e))!=uf::illegal && c!=uf::incomplete) {
out = uf::utf_traits<wchar_t>::encode(c,out);
decoded = static_cast<DWORD>(p-b);
}
if(c==uf::illegal)
return -1;
if(!WriteConsoleW(handle_,wbuffer_, static_cast<DWORD>(out - wbuffer_),&size,0))
return -1;
return decoded;
}
