/// @brief
void write_to_console(_In_ uint32_t color, _In_z_ const char* log_message)
{
_ASSERTE(NULL != log_message);
if (NULL == log_message) return;
static HANDLE con_stdout_handle = INVALID_HANDLE_VALUE;
static WORD con_old_color = 0;
if (INVALID_HANDLE_VALUE == con_stdout_handle)
{
CONSOLE_SCREEN_BUFFER_INFO csbi;
con_stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE);
GetConsoleScreenBufferInfo(con_stdout_handle, &csbi);
con_old_color = csbi.wAttributes;
}
DWORD len;
switch (color)
{
case wtc_red:
SetConsoleTextAttribute(con_stdout_handle, FOREGROUND_RED | FOREGROUND_INTENSITY);
WriteConsoleA(con_stdout_handle, log_message, (DWORD)strlen(log_message), &len, NULL);
SetConsoleTextAttribute(con_stdout_handle, con_old_color);
break;
case wtc_green:
SetConsoleTextAttribute(con_stdout_handle, FOREGROUND_GREEN | FOREGROUND_INTENSITY);
WriteConsoleA(con_stdout_handle, log_message, (DWORD)strlen(log_message), &len, NULL);
SetConsoleTextAttribute(con_stdout_handle, con_old_color);
break;
case wtc_none:
default:
WriteConsoleA(con_stdout_handle, log_message, (DWORD)strlen(log_message), &len, NULL);
}
}
void Minilog::logTerm(LogLevel lvl, const char* msg, int len)
{
if (lvl >= termLvl)
{
if (msg != 0 && msg[0] != '\0')
{
const char* hdr = getHeader(lvl);
if(len < 0) len = strlen(msg);
#ifdef _MSC_VER
CONSOLE_SCREEN_BUFFER_INFO csbi = {sizeof(csbi)};
GetConsoleScreenBufferInfo(
stdOut, &csbi);
WORD wAtt = csbi.wAttributes;
setTermColor(lvl);
DWORD dwReal;
WriteConsoleA(stdOut, hdr, strlen(hdr), &dwReal, NULL);
WriteConsoleA(stdOut, msg, nLen, &dwReal, NULL);
SetConsoleTextAttribute(stdOut, wAtt);
#else
setTermColor(lvl);
printf("%s", hdr);
printf("%s", msg);
printf("\033[0m");
#endif
}
}
}
void Hippo_WriteConsole(CONSOLE_COLOR color,char *szstr,... )
{
DWORD numWritten = 0;
static char szParsedString[1024];
va_list va;
va_start( va, szstr );
vsprintf( szParsedString,szstr, va );
va_end( va );
SetConsoleTextAttribute(g_hippo_state->m_console_handle, MakeColor(color));
WriteConsoleA(g_hippo_state->m_console_handle,szParsedString, (DWORD)strlen(szParsedString),&numWritten,0);
WriteConsoleA(g_hippo_state->m_console_handle,"\n", 1,&numWritten,0);
}
EXTERNC
int putch(int c) {
DWORD count;
UpdateWScroll();
if (WriteConsoleA(thData.output, &c, 1, &count, NULL)) return c;
else return EOF;
};
// forces NO prepend even if set to
int log_error_np( LOG_LEVEL logLevel, const char *_Format, ... )
{
if( !g_error_logger_enabled ) return 0;
int ret = 0;
if( (logLevel < 0) || (!_Format) ) return 0;
if( logLevel > g_cfg.WarnMessageLevel ) return 0;
EnterCriticalSection( &g_error_logger_cs );
va_list l;
va_start( l, _Format );
// no prepend, just vfprintf
ret = vfprintf( g_error_logger_file, _Format, l );
// also write to console, if enabled?
if( g_error_logger_enabled_console && (ret > 0) )
{
char *cbuffer = (char *)malloc( ret+1 );
if( cbuffer )
{
va_list l2;
va_start( l2, _Format );
vsprintf( cbuffer, _Format, l2 );
DWORD numWritten = 0;
WriteConsoleA( g_error_logger_stdout, cbuffer, (DWORD)strlen(cbuffer), &numWritten, NULL );
free( cbuffer );
}
}
LeaveCriticalSection( &g_error_logger_cs );
return ret;
}
static void write_normal(const char *buf, int size)
{
if (size == 0)
return;
while (size > 0)
{
if (console->at_right_margin && console->wraparound_mode)
crnl();
/* Write to line end at most */
int line_remain = min(size, console->width - console->x);
if (console->insert_mode && console->x + line_remain < console->width)
scroll(console->x, console->width - 1, console->y, console->y, line_remain, 0);
DWORD bytes_written;
WriteConsoleA(console->out, buf, line_remain, &bytes_written, NULL);
console->x += line_remain;
if (console->x == console->width)
{
console->x--;
console->at_right_margin = 1;
}
buf += line_remain;
size -= line_remain;
}
}
void print()
{
std::ostringstream out;
for (int y = 0; y < HEIGHT; y++)
{
out << chars[y] << std::endl;
chars[y][0] = '\0';
}
auto str = out.str();
//１、cmd.exeのcls命令を使う方法
//system("cls");
//２、Win32APIでカーソル位置を操作する方法
//COORD coord = { 0, 0 };
//SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord);
//std::cout << str;
//３、Win32APIでスクリーンバッファを切り替える方法
DWORD cell;
WriteConsoleA(hSrc, str.c_str(), str.length(), &cell, NULL);
SetConsoleActiveScreenBuffer(hSrc);
hSrc = (hSrc == hSrc0) ? hSrc1 : hSrc0;
}
VOID vPrint(
__in LPCTSTR szMessageText
)
{
//
// Declare the length of buffer required to store multibyte string
// for \n. DBCS char set, needs 2 bytes to store singe char.
//
CHAR szMultiByteString[ERROR_MESSAGE_BUFSIZE];
DWORD dwNumCharsWritten = 0;
if ( !szMessageText )
{
return;
}
//
// Format Unicode Text to a Multibyte
//
if ( WideCharToMultiByte(CP_OEMCP, 0, szMessageText, -1, szMultiByteString,
CCHOF(szMultiByteString), NULL, NULL) )
{
WriteConsoleA(GetStdHandle(STD_OUTPUT_HANDLE), szMultiByteString,
(DWORD) strlen(szMultiByteString),
&dwNumCharsWritten, NULL);
}
}
//debug hook to print JVM messages into console.
static jint JNICALL vfprintfHook(FILE *fp, const char *format, va_list args) {
#ifdef WINDOWS
char buffer[20480];
int len;
HANDLE hConsole;
DWORD wasWritten;
len = _vsnprintf_s(buffer, sizeof(buffer), sizeof(buffer), format, args);
if (len <= 0) {
return len;
}
hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
if (hConsole == INVALID_HANDLE_VALUE) {
return false;
}
//JVM will always pass us ASCII
WriteConsoleA(hConsole, buffer, strlen(buffer), &wasWritten, NULL);
return (jint) len;
#endif //WINDOWS
#ifdef LINUX
return 0;
#endif //LINUX
}
void
tty_printf( const char *fmt, ... )
{
va_list arg_ptr;
if (no_terminal)
return;
if( !initialized )
init_ttyfp();
va_start( arg_ptr, fmt ) ;
#ifdef USE_W32_CONSOLE
{
char *buf = NULL;
int n;
DWORD nwritten;
n = vasprintf(&buf, fmt, arg_ptr);
if( !buf )
log_bug("vasprintf() failed\n");
if( !WriteConsoleA( con.out, buf, n, &nwritten, NULL ) )
log_fatal("WriteConsole failed: rc=%d", (int)GetLastError() );
if( n != nwritten )
log_fatal("WriteConsole failed: %d != %d\n", n, (int)nwritten );
last_prompt_len += n;
xfree (buf);
}
#else
last_prompt_len += vfprintf(ttyfp,fmt,arg_ptr) ;
fflush(ttyfp);
#endif
va_end(arg_ptr);
}
int conprintf(const char* fmt, ...)
{
#ifdef WIN32
char s[1024];
va_list list;
va_start(list, fmt);
vsprintf(s,fmt, list);
va_end(list);
HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
if(handle == INVALID_HANDLE_VALUE)
return 0;
DWORD written = 0;
WriteConsoleA(handle, s, strlen(s), &written, 0);
FlushFileBuffers(handle);
return written;
#else
va_list list;
va_start(list, fmt);
int ret = vsprintf(stderr,fmt,list);
va_end(list);
return ret;
#endif
}
void CWindowsConsoleStream::Write(const void* pData, const uint32 uSizeInBytes, const uint32 uNumberOfElements){
Collection::CList<byte> Data;
try{
Data.Set(uSizeInBytes * uNumberOfElements, (byte*)pData);
for(uint32 uIndex = 0; uIndex < Data.GetLength(); uIndex++){
if(Data[uIndex] == (byte)'\n'){
if(uIndex > 0 && Data[uIndex - 1] == (byte)'\r'){
continue;
}
Data.Insert(uIndex, (byte)'\r');
uIndex++;
}
}
}
catch(Exception::CException& Exception){
throw Exception::CStreamException(
L"Error while converting data for console buffer write.", CR_INFO(), Exception);
}
DWORD dwCount = 0;
if(!WriteConsoleA(this->m_hConsole, Data.GetPointer(), Data.GetSizeInBytes(), &dwCount, 0)){
throw Exception::CStreamException(
L"Failed to write to console buffer. " + CWindowsError(GetLastError()).GetMessage(), CR_INFO());
}
}
/*
* cuiPrintTextA
*
* Purpose:
*
* Output text to the console or file.
* ANSI version.
*
*/
VOID cuiPrintTextA(
_In_ LPSTR lpText,
_In_ BOOL UseReturn
)
{
SIZE_T consoleIO;
DWORD bytesIO;
LPSTR Buffer;
if (lpText == NULL)
return;
consoleIO = _strlen_a(lpText);
if ((consoleIO == 0) || (consoleIO > MAX_PATH * 4))
return;
consoleIO = 5 + consoleIO;
Buffer = (LPSTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, consoleIO);
if (Buffer) {
_strcpy_a(Buffer, lpText);
if (UseReturn) _strcat_a(Buffer, "\r\n");
consoleIO = _strlen_a(Buffer);
if (g_ConsoleOutput != FALSE) {
WriteConsoleA(g_ConOut, Buffer, (DWORD)consoleIO, &bytesIO, NULL);
}
else {
WriteFile(g_ConOut, Buffer, (DWORD)consoleIO, &bytesIO, NULL);
}
HeapFree(GetProcessHeap(), 0, Buffer);
}
}
void ShowHelp(void)
{
#define ID_HELP_TEXT 10020
#define ID_DOS_TEXT 300
CONST CHAR* src;
DWORD src_count, charsWritten;
HGLOBAL res_data;
HANDLE handle;
HRSRC hSrc;
ShowCopyright();
hSrc = FindResourceA(NULL, MAKEINTRESOURCEA(ID_HELP_TEXT),MAKEINTRESOURCEA(ID_DOS_TEXT));
if (!hSrc) return;
src_count = SizeofResource(NULL, hSrc);
res_data = LoadResource(NULL, hSrc);
if (!res_data) return;
src = (char*) LockResource(res_data);
if (!src) return;
if ((handle=GetStdHandle(STD_ERROR_HANDLE)) != INVALID_HANDLE_VALUE)
WriteConsoleA(handle, src, src_count, &charsWritten, NULL);
}
static void cr()
{
DWORD bytes_written;
WriteConsoleA(console->out, "\r", 1, &bytes_written, NULL);
console->x = 0;
console->at_right_margin = 0;
}
static int puts_clbk_console_a(void *ctx, int len, const char *str)
{
LOCK_CONSOLE;
if(!WriteConsoleA(MSVCRT_console_out, str, len, NULL, NULL))
len = -1;
UNLOCK_CONSOLE;
return len;
}
EXTERNC
int cputs(const char *str) {
DWORD count;
if (str == NULL) return EOF;
UpdateWScroll();
if (WriteConsoleA(thData.output, str, strlen(str), &count, NULL)) return count;
else return EOF;
};
basic_win32console_streambuf<char>::int_type basic_win32console_streambuf<char>::overflow(int_type ch)
{
DWORD n;
if(isleadbyte(ch)) {
prev_char_ = ch;
}
else if(isleadbyte(prev_char_)) {
char buffer[3] = {prev_char_, ch, 0};
prev_char_ = 0;
WriteConsoleA(GetStdHandle(STD_OUTPUT_HANDLE), buffer, 2, &n, NULL);
}
else {
char buffer[2] = {ch, 0};
WriteConsoleA(GetStdHandle(STD_OUTPUT_HANDLE), buffer, 1, &n, NULL);
}
return 0;
}
__integer __INTERNAL_FUNC__ PrintDbgInfo_DebugerWrite(__char *pInfo) {
__integer iWritten = 0;
if (g_hWriteConsole) {
if (!WriteConsoleA(g_hWriteConsole, pInfo, __logic_strlen__(pInfo), &iWritten, NULL))
return 0;
return iWritten;
}
return 0;
}
void dprintf(char* fmt, ...)
{
va_list args;
char buffer[255];
va_start(args,fmt);
vsprintf(buffer,fmt,args);
WriteConsoleA(OutputHandle, buffer, strlen(buffer), NULL, NULL);
va_end(args);
}
/*********************************************************************
* _putch (MSVCRT.@)
*/
int CDECL _putch(int c)
{
int retval = MSVCRT_EOF;
DWORD count;
LOCK_CONSOLE;
if (WriteConsoleA(MSVCRT_console_out, &c, 1, &count, NULL) && count == 1)
retval = c;
UNLOCK_CONSOLE;
return retval;
}
void rt_kprintf(const char* fmt, ...)
{
va_list args;
char buffer[255];
if (OutputHandle == NULL) rt_console_init();
va_start(args,fmt);
vsprintf(buffer,fmt,args);
WriteConsoleA(OutputHandle, buffer, strlen(buffer), NULL, NULL);
va_end(args);
}
__integer __INTERNAL_FUNC__ PrintDbgInfo_DebugerWriteLine(__char *pInfo) {
__char szText[__PRINTDBGINFO_WRITECONSOLE_BUFFER_SIZE__] = {0};
__integer iWritten = 0;
__logic_strcpy__(szText, pInfo);
__logic_strcat__(szText, "\n");
if (g_hWriteConsole) {
if (!WriteConsoleA(g_hWriteConsole, szText, __logic_strlen__(szText), &iWritten, NULL))
return 0;
return iWritten;
}
return 0;
}
void Loggable::Static::info(const char* msg, ...)
{
char text[BUF_SZ];
char* text_contents = text + 1;
text[0] = HERMES_EC_INFO;
text[1] = ' ';
text_contents++;
//print the message
va_list arglist;
va_start(arglist, msg);
vsprintf(text_contents, msg, arglist);
va_end(arglist);
//Windows platform
#ifdef _WINDOWS
HANDLE h_console = GetStdHandle(STD_OUTPUT_HANDLE);
//generate console settings
WORD console_attr_red = FOREGROUND_RED, console_attr_green = FOREGROUND_GREEN, console_attr_blue = FOREGROUND_BLUE;
WORD console_attrs = 0;
console_attrs |= console_attr_green;
//set new console settings
SetConsoleTextAttribute(h_console, console_attrs);
//write text
DWORD num_written;
BOOL write_success = WriteConsoleA(h_console, text_contents, strlen(text_contents), &num_written, nullptr);
std::cout << std::endl;
//Linux platform
#else
# define FOREGROUND_RED 1
# define FOREGROUND_GREEN 2
# define FOREGROUND_BLUE 4
//console color code
int console_attrs = 0;
bool console_bold = true;
printf("\033[%dm", console_attrs + 30);
//emphasize and console bold
if(console_bold)
printf("\033[1m");
//print text and reset settings
printf("%s\033[0m\n", text_contents);
#endif
}
/*********************************************************************
* _cputs (MSVCRT.@)
*/
int CDECL _cputs(const char* str)
{
DWORD count;
int retval = MSVCRT_EOF;
LOCK_CONSOLE;
if (WriteConsoleA(MSVCRT_console_out, str, strlen(str), &count, NULL)
&& count == 1)
retval = 0;
UNLOCK_CONSOLE;
return retval;
}
int log_error( LOG_LEVEL logLevel, const char *_Format, ... )
{
if( !g_error_logger_enabled ) return 0;
int ret = 0;
if( (logLevel < 0) || (!_Format) ) return 0;
if( logLevel > g_cfg.WarnMessageLevel ) return 0;
EnterCriticalSection( &g_error_logger_cs );
va_list l;
va_start( l, _Format );
if( g_error_logger_auto_prepend )
{
char *szPrepend = g_error_logger_strtype_unknown;
if( (logLevel >= LOG_OK) && (logLevel <= LOGLEVEL_LAST) )
szPrepend = g_error_logger_strtype[logLevel];
fprintf( g_error_logger_file, "%s", szPrepend );
// also write to console, if enabled
if( g_error_logger_enabled_console )
{
DWORD numWritten = 0;
WriteConsoleA( g_error_logger_stdout, szPrepend, (DWORD)strlen(szPrepend), &numWritten, NULL );
}
}
ret = vfprintf( g_error_logger_file, _Format, l );
// also write to console, if enabled
if( g_error_logger_enabled_console && (ret > 0) )
{
char *cbuffer = (char *)malloc( ret+1 );
if( cbuffer )
{
va_list l2;
va_start( l2, _Format );
vsprintf( cbuffer, _Format, l2 );
DWORD numWritten = 0;
WriteConsoleA( g_error_logger_stdout, cbuffer, (DWORD)strlen(cbuffer), &numWritten, NULL );
free( cbuffer );
}
}
LeaveCriticalSection( &g_error_logger_cs );
return ret;
}
/*
* @implemented
*/
int _cputs(const char *_str)
{
DWORD count;
int retval = EOF;
HANDLE console_out = GetStdHandle(STD_OUTPUT_HANDLE);
//LOCK_CONSOLE;
if (WriteConsoleA(console_out, _str, strlen(_str), &count, NULL)
&& count == 1)
retval = 0;
//UNLOCK_CONSOLE;
return retval;
}
void win_traceA(const char *pszFmt, ...){
CHAR tchbuf[1024] = {'$',0};
va_list argList = NULL;
va_start(argList, pszFmt);
wvsprintfA(&tchbuf[1], pszFmt, argList);
va_end(argList);
lstrcatA(tchbuf, "\r\n");
if(IsDebuggerPresent()){
OutputDebugStringA(tchbuf);
}else{
DWORD dwWrt;
WriteConsoleA(GetStdHandle(STD_ERROR_HANDLE), tchbuf, lstrlenA(tchbuf), &dwWrt, NULL);
}
}
void PrintUnicode(const std::string &str, bool error)
{
#ifdef _WIN32
FILE *out = error ? stderr : stdout;
if ( !_isatty(_fileno(out)) )
fprintf(out, "%s", str.c_str());
else
{
HANDLE stream = GetStdHandle(error ? STD_ERROR_HANDLE : STD_OUTPUT_HANDLE);
if ( stream == INVALID_HANDLE_VALUE ) return;
DWORD charsWritten;
WriteConsoleA(stream, str.c_str(), str.length(), &charsWritten, 0);
}
#endif
}
void SendAnsi(HANDLE hPipe, HANDLE hOut, LPCSTR asSeq)
{
if (!asSeq || !*asSeq) return;
DWORD nWrite, nLen = lstrlenA(asSeq);
if (hPipe)
WriteFile(hPipe, asSeq, nLen, &nWrite, NULL);
if (hOut)
{
LPCSTR pszNextEsc = strchr(asSeq, 27);
while (pszNextEsc)
{
if (pszNextEsc > asSeq)
WriteConsoleA(hOut, asSeq, (pszNextEsc - asSeq), &nWrite, NULL);
WriteConsoleW(hOut, gszAnalogues+27, 1, &nWrite, NULL);
asSeq = pszNextEsc + 1;
pszNextEsc = strchr(asSeq, 27);
}
if (asSeq && *asSeq)
{
nLen = lstrlenA(asSeq);
WriteConsoleA(hOut, asSeq, nLen, &nWrite, NULL);
}
}
}
