mirror of https://github.com/GOSTSec/ccminer
392 lines
7.7 KiB
392 lines
7.7 KiB
/** |
|
* Old Git implementation of windows terminal colors (2009) |
|
* before use of a threaded wrapper. |
|
*/ |
|
|
|
#undef NOGDI |
|
#include <windows.h> |
|
#include <wingdi.h> |
|
#include <winreg.h> |
|
#include <malloc.h> |
|
#include <stdio.h> |
|
#include <io.h> |
|
|
|
#include "compat/winansi.h" |
|
/* |
|
* Copyright 2008 Peter Harris <git@peter.is-a-geek.org> |
|
*/ |
|
|
|
/* |
|
Functions to be wrapped: |
|
*/ |
|
#undef printf |
|
#undef fprintf |
|
#undef fputs |
|
#undef vfprintf |
|
/* TODO: write */ |
|
|
|
/* |
|
ANSI codes used by git: m, K |
|
|
|
This file is git-specific. Therefore, this file does not attempt |
|
to implement any codes that are not used by git. |
|
*/ |
|
|
|
static HANDLE console; |
|
static WORD plain_attr; |
|
static WORD attr; |
|
static int negative; |
|
|
|
static void init(void) |
|
{ |
|
CONSOLE_SCREEN_BUFFER_INFO sbi; |
|
|
|
static int initialized = 0; |
|
if (initialized) |
|
return; |
|
|
|
console = GetStdHandle(STD_OUTPUT_HANDLE); |
|
if (console == INVALID_HANDLE_VALUE) |
|
console = NULL; |
|
|
|
if (!console) |
|
return; |
|
|
|
GetConsoleScreenBufferInfo(console, &sbi); |
|
attr = plain_attr = sbi.wAttributes; |
|
negative = 0; |
|
|
|
initialized = 1; |
|
} |
|
|
|
static int write_console(const char *str, int len) |
|
{ |
|
/* convert utf-8 to utf-16, write directly to console */ |
|
int wlen = MultiByteToWideChar(CP_UTF8, 0, str, len, NULL, 0); |
|
wchar_t *wbuf = (wchar_t *)alloca(wlen * sizeof(wchar_t)); |
|
MultiByteToWideChar(CP_UTF8, 0, str, len, wbuf, wlen); |
|
|
|
WriteConsoleW(console, wbuf, wlen, NULL, NULL); |
|
|
|
/* return original (utf-8 encoded) length */ |
|
return len; |
|
} |
|
|
|
#define FOREGROUND_ALL (FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE) |
|
#define BACKGROUND_ALL (BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE) |
|
|
|
static void set_console_attr(void) |
|
{ |
|
WORD attributes = attr; |
|
if (negative) { |
|
attributes &= ~FOREGROUND_ALL; |
|
attributes &= ~BACKGROUND_ALL; |
|
|
|
/* This could probably use a bitmask |
|
instead of a series of ifs */ |
|
if (attr & FOREGROUND_RED) |
|
attributes |= BACKGROUND_RED; |
|
if (attr & FOREGROUND_GREEN) |
|
attributes |= BACKGROUND_GREEN; |
|
if (attr & FOREGROUND_BLUE) |
|
attributes |= BACKGROUND_BLUE; |
|
|
|
if (attr & BACKGROUND_RED) |
|
attributes |= FOREGROUND_RED; |
|
if (attr & BACKGROUND_GREEN) |
|
attributes |= FOREGROUND_GREEN; |
|
if (attr & BACKGROUND_BLUE) |
|
attributes |= FOREGROUND_BLUE; |
|
} |
|
SetConsoleTextAttribute(console, attributes); |
|
} |
|
|
|
static void erase_in_line(void) |
|
{ |
|
CONSOLE_SCREEN_BUFFER_INFO sbi; |
|
DWORD dummy; /* Needed for Windows 7 (or Vista) regression */ |
|
|
|
if (!console) |
|
return; |
|
|
|
GetConsoleScreenBufferInfo(console, &sbi); |
|
FillConsoleOutputCharacterA(console, ' ', |
|
sbi.dwSize.X - sbi.dwCursorPosition.X, sbi.dwCursorPosition, |
|
&dummy); |
|
} |
|
|
|
|
|
static const char *set_attr(const char *str) |
|
{ |
|
const char *func; |
|
size_t len = strspn(str, "0123456789;"); |
|
func = str + len; |
|
|
|
switch (*func) { |
|
case 'm': |
|
do { |
|
long val = strtol(str, (char **)&str, 10); |
|
switch (val) { |
|
case 0: /* reset */ |
|
attr = plain_attr; |
|
negative = 0; |
|
break; |
|
case 1: /* bold */ |
|
attr |= FOREGROUND_INTENSITY; |
|
break; |
|
case 2: /* faint */ |
|
case 22: /* normal */ |
|
attr &= ~FOREGROUND_INTENSITY; |
|
break; |
|
case 3: /* italic */ |
|
/* Unsupported */ |
|
break; |
|
case 4: /* underline */ |
|
case 21: /* double underline */ |
|
/* Wikipedia says this flag does nothing */ |
|
/* Furthermore, mingw doesn't define this flag |
|
attr |= COMMON_LVB_UNDERSCORE; */ |
|
break; |
|
case 24: /* no underline */ |
|
/* attr &= ~COMMON_LVB_UNDERSCORE; */ |
|
break; |
|
case 5: /* slow blink */ |
|
case 6: /* fast blink */ |
|
/* We don't have blink, but we do have |
|
background intensity */ |
|
attr |= BACKGROUND_INTENSITY; |
|
break; |
|
case 25: /* no blink */ |
|
attr &= ~BACKGROUND_INTENSITY; |
|
break; |
|
case 7: /* negative */ |
|
negative = 1; |
|
break; |
|
case 27: /* positive */ |
|
negative = 0; |
|
break; |
|
case 8: /* conceal */ |
|
case 28: /* reveal */ |
|
/* Unsupported */ |
|
break; |
|
case 30: /* Black */ |
|
attr &= ~FOREGROUND_ALL; |
|
break; |
|
case 31: /* Red */ |
|
attr &= ~FOREGROUND_ALL; |
|
attr |= FOREGROUND_RED; |
|
break; |
|
case 32: /* Green */ |
|
attr &= ~FOREGROUND_ALL; |
|
attr |= FOREGROUND_GREEN; |
|
break; |
|
case 33: /* Yellow */ |
|
attr &= ~FOREGROUND_ALL; |
|
attr |= FOREGROUND_RED | FOREGROUND_GREEN; |
|
break; |
|
case 34: /* Blue */ |
|
attr &= ~FOREGROUND_ALL; |
|
attr |= FOREGROUND_BLUE; |
|
break; |
|
case 35: /* Magenta */ |
|
attr &= ~FOREGROUND_ALL; |
|
attr |= FOREGROUND_RED | FOREGROUND_BLUE; |
|
break; |
|
case 36: /* Cyan */ |
|
attr &= ~FOREGROUND_ALL; |
|
attr |= FOREGROUND_GREEN | FOREGROUND_BLUE; |
|
break; |
|
case 37: /* White */ |
|
attr |= FOREGROUND_RED | |
|
FOREGROUND_GREEN | |
|
FOREGROUND_BLUE; |
|
break; |
|
case 38: /* Unknown */ |
|
break; |
|
case 39: /* reset */ |
|
attr &= ~FOREGROUND_ALL; |
|
attr |= (plain_attr & FOREGROUND_ALL); |
|
break; |
|
case 40: /* Black */ |
|
attr &= ~BACKGROUND_ALL; |
|
break; |
|
case 41: /* Red */ |
|
attr &= ~BACKGROUND_ALL; |
|
attr |= BACKGROUND_RED; |
|
break; |
|
case 42: /* Green */ |
|
attr &= ~BACKGROUND_ALL; |
|
attr |= BACKGROUND_GREEN; |
|
break; |
|
case 43: /* Yellow */ |
|
attr &= ~BACKGROUND_ALL; |
|
attr |= BACKGROUND_RED | BACKGROUND_GREEN; |
|
break; |
|
case 44: /* Blue */ |
|
attr &= ~BACKGROUND_ALL; |
|
attr |= BACKGROUND_BLUE; |
|
break; |
|
case 45: /* Magenta */ |
|
attr &= ~BACKGROUND_ALL; |
|
attr |= BACKGROUND_RED | BACKGROUND_BLUE; |
|
break; |
|
case 46: /* Cyan */ |
|
attr &= ~BACKGROUND_ALL; |
|
attr |= BACKGROUND_GREEN | BACKGROUND_BLUE; |
|
break; |
|
case 47: /* White */ |
|
attr |= BACKGROUND_RED | |
|
BACKGROUND_GREEN | |
|
BACKGROUND_BLUE; |
|
break; |
|
case 48: /* Unknown */ |
|
break; |
|
case 49: /* reset */ |
|
attr &= ~BACKGROUND_ALL; |
|
attr |= (plain_attr & BACKGROUND_ALL); |
|
break; |
|
default: |
|
/* Unsupported code */ |
|
break; |
|
} |
|
str++; |
|
} while (*(str - 1) == ';'); |
|
|
|
set_console_attr(); |
|
break; |
|
case 'K': |
|
erase_in_line(); |
|
break; |
|
default: |
|
/* Unsupported code */ |
|
break; |
|
} |
|
|
|
return func + 1; |
|
} |
|
|
|
static int ansi_emulate(const char *str, FILE *stream) |
|
{ |
|
int rv = 0; |
|
const char *pos = str; |
|
|
|
fflush(stream); |
|
|
|
while (*pos) { |
|
pos = strstr(str, "\033["); |
|
if (pos) { |
|
int len = (int) (pos - str); |
|
|
|
if (len) { |
|
int out_len = write_console(str, len); |
|
rv += out_len; |
|
if (out_len < len) |
|
return rv; |
|
} |
|
|
|
str = pos + 2; |
|
rv += 2; |
|
|
|
pos = set_attr(str); |
|
rv += (int) (pos - str); |
|
str = pos; |
|
} |
|
else { |
|
int len = (int) strlen(str); |
|
rv += write_console(str, len); |
|
return rv; |
|
} |
|
} |
|
return rv; |
|
} |
|
|
|
int winansi_fputs(const char *str, FILE *stream) |
|
{ |
|
int rv; |
|
|
|
if (!isatty(fileno(stream))) |
|
return fputs(str, stream); |
|
|
|
init(); |
|
|
|
if (!console) |
|
return fputs(str, stream); |
|
|
|
rv = ansi_emulate(str, stream); |
|
|
|
if (rv >= 0) |
|
return 0; |
|
else |
|
return EOF; |
|
} |
|
|
|
int winansi_vfprintf(FILE *stream, const char *format, va_list list) |
|
{ |
|
int len, rv; |
|
char small_buf[256] = { 0 }; |
|
char *buf = small_buf; |
|
va_list cp; |
|
|
|
if (!isatty(fileno(stream))) |
|
goto abort; |
|
|
|
init(); |
|
|
|
if (!console) |
|
goto abort; |
|
|
|
va_copy(cp, list); |
|
len = vsnprintf(small_buf, sizeof(small_buf), format, cp); |
|
#ifdef WIN32 |
|
/* bug on long strings without that */ |
|
if (len == -1) |
|
len = _vscprintf(format, cp); |
|
#endif |
|
va_end(cp); |
|
|
|
if (len > sizeof(small_buf) - 1) { |
|
buf = malloc(len + 1); |
|
if (!buf) |
|
goto abort; |
|
|
|
len = vsnprintf(buf, len + 1, format, list); |
|
#ifdef WIN32 |
|
if (len == -1) |
|
len = _vscprintf(format, list); |
|
#endif |
|
} |
|
|
|
rv = ansi_emulate(buf, stream); |
|
|
|
if (buf != small_buf) |
|
free(buf); |
|
return rv; |
|
|
|
abort: |
|
rv = vfprintf(stream, format, list); |
|
return rv; |
|
} |
|
|
|
int winansi_fprintf(FILE *stream, const char *format, ...) |
|
{ |
|
va_list list; |
|
int rv; |
|
|
|
va_start(list, format); |
|
rv = winansi_vfprintf(stream, format, list); |
|
va_end(list); |
|
|
|
return rv; |
|
} |
|
|
|
int winansi_printf(const char *format, ...) |
|
{ |
|
va_list list; |
|
int rv; |
|
|
|
va_start(list, format); |
|
rv = winansi_vfprintf(stdout, format, list); |
|
va_end(list); |
|
|
|
return rv; |
|
} |