compat/winansi.c

   1 /*
   2  * Copyright 2008 Peter Harris <git@peter.is-a-geek.org>
   3  */
   4
   5 #include "../git-compat-util.h"
   6 #include <malloc.h>
   7 #include <wingdi.h>
   8 #include <winreg.h>
   9
  10 /*
  11  Functions to be wrapped:
  12 */
  13 #undef printf
  14 #undef fprintf
  15 #undef fputs
  16 #undef vfprintf
  17 /* TODO: write */
  18
  19 /*
  20  ANSI codes used by git: m, K
  21
  22  This file is git-specific. Therefore, this file does not attempt
  23  to implement any codes that are not used by git.
  24 */
  25
  26 static HANDLE console;
  27 static WORD plain_attr;
  28 static WORD attr;
  29 static int negative;
  30 static FILE *last_stream = NULL;
  31
  32 typedef struct _CONSOLE_FONT_INFOEX {
  33         ULONG cbSize;
  34         DWORD nFont;
  35         COORD dwFontSize;
  36         UINT FontFamily;
  37         UINT FontWeight;
  38         WCHAR FaceName[LF_FACESIZE];
  39 } CONSOLE_FONT_INFOEX, *PCONSOLE_FONT_INFOEX;
  40
  41 typedef BOOL (WINAPI *PGETCURRENTCONSOLEFONTEX)(HANDLE, BOOL,
  42                 PCONSOLE_FONT_INFOEX);
  43
  44 static void print_font_warning(void)
  45 {
  46         warning("Your console font probably doesn\'t support Unicode. If "
  47                 "you experience strange characters in the output, consider "
  48                 "switching to a TrueType font such as Lucida Console!");
  49 }
  50
  51 static void check_truetype_font(void)
  52 {
  53         static int truetype_font_checked;
  54         DWORD fontFamily = 0;
  55         PGETCURRENTCONSOLEFONTEX pGetCurrentConsoleFontEx;
  56
  57         /* don't do this twice */
  58         if (truetype_font_checked)
  59                 return;
  60         truetype_font_checked = 1;
  61
  62         /* GetCurrentConsoleFontEx is available since Vista */
  63         pGetCurrentConsoleFontEx = GetProcAddress(GetModuleHandle("kernel32.dll"),
  64                         "GetCurrentConsoleFontEx");
  65         if (pGetCurrentConsoleFontEx) {
  66                 CONSOLE_FONT_INFOEX cfi;
  67                 cfi.cbSize = sizeof(cfi);
  68                 if (pGetCurrentConsoleFontEx(console, 0, &cfi))
  69                         fontFamily = cfi.FontFamily;
  70         } else {
  71                 /* pre-Vista: check default console font in registry */
  72                 HKEY hkey;
  73                 if (ERROR_SUCCESS == RegOpenKeyExA(HKEY_CURRENT_USER, "Console", 0,
  74                                 KEY_READ, &hkey)) {
  75                         DWORD size = sizeof(fontFamily);
  76                         RegQueryValueExA(hkey, "FontFamily", NULL, NULL,
  77                                         (LPVOID) &fontFamily, &size);
  78                         RegCloseKey(hkey);
  79                 }
  80         }
  81
  82         if (!(fontFamily & TMPF_TRUETYPE))
  83                 atexit(print_font_warning);
  84 }
  85
  86 static int is_console(FILE *stream)
  87 {
  88         CONSOLE_SCREEN_BUFFER_INFO sbi;
  89         HANDLE hcon;
  90
  91         static int initialized = 0;
  92
  93         /* use cached value if stream hasn't changed */
  94         if (stream == last_stream)
  95                 return console != NULL;
  96
  97         last_stream = stream;
  98         console = NULL;
  99
 100         /* get OS handle of the stream */
 101         hcon = (HANDLE) _get_osfhandle(_fileno(stream));
 102         if (hcon == INVALID_HANDLE_VALUE)
 103                 return 0;
 104
 105         /* check if its a handle to a console output screen buffer */
 106         if (!GetConsoleScreenBufferInfo(hcon, &sbi))
 107                 return 0;
 108
 109         if (!initialized) {
 110                 attr = plain_attr = sbi.wAttributes;
 111                 negative = 0;
 112                 initialized = 1;
 113         }
 114
 115         console = hcon;
 116         return 1;
 117 }
 118
 119 static int write_console(const char *str, size_t len)
 120 {
 121         /* convert utf-8 to utf-16, write directly to console */
 122         int wlen = MultiByteToWideChar(CP_UTF8, 0, str, len, NULL, 0);
 123         wchar_t *wbuf = (wchar_t *) alloca(wlen * sizeof(wchar_t));
 124         MultiByteToWideChar(CP_UTF8, 0, str, len, wbuf, wlen);
 125
 126         WriteConsoleW(console, wbuf, wlen, NULL, NULL);
 127
 128         /*
 129          * if non-ascii characters are printed, check that the current console
 130          * font supports this
 131          */
 132         if (wlen != len)
 133                 check_truetype_font();
 134
 135         /* return original (utf-8 encoded) length */
 136         return len;
 137 }
 138
 139 #define FOREGROUND_ALL (FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE)
 140 #define BACKGROUND_ALL (BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE)
 141
 142 static void set_console_attr(void)
 143 {
 144         WORD attributes = attr;
 145         if (negative) {
 146                 attributes &= ~FOREGROUND_ALL;
 147                 attributes &= ~BACKGROUND_ALL;
 148
 149                 /* This could probably use a bitmask
 150                    instead of a series of ifs */
 151                 if (attr & FOREGROUND_RED)
 152                         attributes |= BACKGROUND_RED;
 153                 if (attr & FOREGROUND_GREEN)
 154                         attributes |= BACKGROUND_GREEN;
 155                 if (attr & FOREGROUND_BLUE)
 156                         attributes |= BACKGROUND_BLUE;
 157
 158                 if (attr & BACKGROUND_RED)
 159                         attributes |= FOREGROUND_RED;
 160                 if (attr & BACKGROUND_GREEN)
 161                         attributes |= FOREGROUND_GREEN;
 162                 if (attr & BACKGROUND_BLUE)
 163                         attributes |= FOREGROUND_BLUE;
 164         }
 165         SetConsoleTextAttribute(console, attributes);
 166 }
 167
 168 static void erase_in_line(void)
 169 {
 170         CONSOLE_SCREEN_BUFFER_INFO sbi;
 171         DWORD dummy; /* Needed for Windows 7 (or Vista) regression */
 172
 173         if (!console)
 174                 return;
 175
 176         GetConsoleScreenBufferInfo(console, &sbi);
 177         FillConsoleOutputCharacterA(console, ' ',
 178                 sbi.dwSize.X - sbi.dwCursorPosition.X, sbi.dwCursorPosition,
 179                 &dummy);
 180 }
 181
 182
 183 static const char *set_attr(const char *str)
 184 {
 185         const char *func;
 186         size_t len = strspn(str, "0123456789;");
 187         func = str + len;
 188
 189         switch (*func) {
 190         case 'm':
 191                 do {
 192                         long val = strtol(str, (char **)&str, 10);
 193                         switch (val) {
 194                         case 0: /* reset */
 195                                 attr = plain_attr;
 196                                 negative = 0;
 197                                 break;
 198                         case 1: /* bold */
 199                                 attr |= FOREGROUND_INTENSITY;
 200                                 break;
 201                         case 2:  /* faint */
 202                         case 22: /* normal */
 203                                 attr &= ~FOREGROUND_INTENSITY;
 204                                 break;
 205                         case 3:  /* italic */
 206                                 /* Unsupported */
 207                                 break;
 208                         case 4:  /* underline */
 209                         case 21: /* double underline */
 210                                 /* Wikipedia says this flag does nothing */
 211                                 /* Furthermore, mingw doesn't define this flag
 212                                 attr |= COMMON_LVB_UNDERSCORE; */
 213                                 break;
 214                         case 24: /* no underline */
 215                                 /* attr &= ~COMMON_LVB_UNDERSCORE; */
 216                                 break;
 217                         case 5:  /* slow blink */
 218                         case 6:  /* fast blink */
 219                                 /* We don't have blink, but we do have
 220                                    background intensity */
 221                                 attr |= BACKGROUND_INTENSITY;
 222                                 break;
 223                         case 25: /* no blink */
 224                                 attr &= ~BACKGROUND_INTENSITY;
 225                                 break;
 226                         case 7:  /* negative */
 227                                 negative = 1;
 228                                 break;
 229                         case 27: /* positive */
 230                                 negative = 0;
 231                                 break;
 232                         case 8:  /* conceal */
 233                         case 28: /* reveal */
 234                                 /* Unsupported */
 235                                 break;
 236                         case 30: /* Black */
 237                                 attr &= ~FOREGROUND_ALL;
 238                                 break;
 239                         case 31: /* Red */
 240                                 attr &= ~FOREGROUND_ALL;
 241                                 attr |= FOREGROUND_RED;
 242                                 break;
 243                         case 32: /* Green */
 244                                 attr &= ~FOREGROUND_ALL;
 245                                 attr |= FOREGROUND_GREEN;
 246                                 break;
 247                         case 33: /* Yellow */
 248                                 attr &= ~FOREGROUND_ALL;
 249                                 attr |= FOREGROUND_RED | FOREGROUND_GREEN;
 250                                 break;
 251                         case 34: /* Blue */
 252                                 attr &= ~FOREGROUND_ALL;
 253                                 attr |= FOREGROUND_BLUE;
 254                                 break;
 255                         case 35: /* Magenta */
 256                                 attr &= ~FOREGROUND_ALL;
 257                                 attr |= FOREGROUND_RED | FOREGROUND_BLUE;
 258                                 break;
 259                         case 36: /* Cyan */
 260                                 attr &= ~FOREGROUND_ALL;
 261                                 attr |= FOREGROUND_GREEN | FOREGROUND_BLUE;
 262                                 break;
 263                         case 37: /* White */
 264                                 attr |= FOREGROUND_RED |
 265                                         FOREGROUND_GREEN |
 266                                         FOREGROUND_BLUE;
 267                                 break;
 268                         case 38: /* Unknown */
 269                                 break;
 270                         case 39: /* reset */
 271                                 attr &= ~FOREGROUND_ALL;
 272                                 attr |= (plain_attr & FOREGROUND_ALL);
 273                                 break;
 274                         case 40: /* Black */
 275                                 attr &= ~BACKGROUND_ALL;
 276                                 break;
 277                         case 41: /* Red */
 278                                 attr &= ~BACKGROUND_ALL;
 279                                 attr |= BACKGROUND_RED;
 280                                 break;
 281                         case 42: /* Green */
 282                                 attr &= ~BACKGROUND_ALL;
 283                                 attr |= BACKGROUND_GREEN;
 284                                 break;
 285                         case 43: /* Yellow */
 286                                 attr &= ~BACKGROUND_ALL;
 287                                 attr |= BACKGROUND_RED | BACKGROUND_GREEN;
 288                                 break;
 289                         case 44: /* Blue */
 290                                 attr &= ~BACKGROUND_ALL;
 291                                 attr |= BACKGROUND_BLUE;
 292                                 break;
 293                         case 45: /* Magenta */
 294                                 attr &= ~BACKGROUND_ALL;
 295                                 attr |= BACKGROUND_RED | BACKGROUND_BLUE;
 296                                 break;
 297                         case 46: /* Cyan */
 298                                 attr &= ~BACKGROUND_ALL;
 299                                 attr |= BACKGROUND_GREEN | BACKGROUND_BLUE;
 300                                 break;
 301                         case 47: /* White */
 302                                 attr |= BACKGROUND_RED |
 303                                         BACKGROUND_GREEN |
 304                                         BACKGROUND_BLUE;
 305                                 break;
 306                         case 48: /* Unknown */
 307                                 break;
 308                         case 49: /* reset */
 309                                 attr &= ~BACKGROUND_ALL;
 310                                 attr |= (plain_attr & BACKGROUND_ALL);
 311                                 break;
 312                         default:
 313                                 /* Unsupported code */
 314                                 break;
 315                         }
 316                         str++;
 317                 } while (*(str-1) == ';');
 318
 319                 set_console_attr();
 320                 break;
 321         case 'K':
 322                 erase_in_line();
 323                 break;
 324         default:
 325                 /* Unsupported code */
 326                 break;
 327         }
 328
 329         return func + 1;
 330 }
 331
 332 static int ansi_emulate(const char *str, FILE *stream)
 333 {
 334         int rv = 0;
 335         const char *pos = str;
 336
 337         fflush(stream);
 338
 339         while (*pos) {
 340                 pos = strstr(str, "\033[");
 341                 if (pos) {
 342                         size_t len = pos - str;
 343
 344                         if (len) {
 345                                 size_t out_len = write_console(str, len);
 346                                 rv += out_len;
 347                                 if (out_len < len)
 348                                         return rv;
 349                         }
 350
 351                         str = pos + 2;
 352                         rv += 2;
 353
 354                         pos = set_attr(str);
 355                         rv += pos - str;
 356                         str = pos;
 357                 } else {
 358                         size_t len = strlen(str);
 359                         rv += write_console(str, len);
 360                         return rv;
 361                 }
 362         }
 363         return rv;
 364 }
 365
 366 int winansi_fputs(const char *str, FILE *stream)
 367 {
 368         int rv;
 369
 370         if (!is_console(stream))
 371                 return fputs(str, stream);
 372
 373         rv = ansi_emulate(str, stream);
 374
 375         if (rv >= 0)
 376                 return 0;
 377         else
 378                 return EOF;
 379 }
 380
 381 int winansi_vfprintf(FILE *stream, const char *format, va_list list)
 382 {
 383         int len, rv;
 384         char small_buf[256];
 385         char *buf = small_buf;
 386         va_list cp;
 387
 388         if (!is_console(stream))
 389                 goto abort;
 390
 391         va_copy(cp, list);
 392         len = vsnprintf(small_buf, sizeof(small_buf), format, cp);
 393         va_end(cp);
 394
 395         if (len > sizeof(small_buf) - 1) {
 396                 buf = malloc(len + 1);
 397                 if (!buf)
 398                         goto abort;
 399
 400                 len = vsnprintf(buf, len + 1, format, list);
 401         }
 402
 403         rv = ansi_emulate(buf, stream);
 404
 405         if (buf != small_buf)
 406                 free(buf);
 407         return rv;
 408
 409 abort:
 410         rv = vfprintf(stream, format, list);
 411         return rv;
 412 }
 413
 414 int winansi_fprintf(FILE *stream, const char *format, ...)
 415 {
 416         va_list list;
 417         int rv;
 418
 419         va_start(list, format);
 420         rv = winansi_vfprintf(stream, format, list);
 421         va_end(list);
 422
 423         return rv;
 424 }
 425
 426 int winansi_printf(const char *format, ...)
 427 {
 428         va_list list;
 429         int rv;
 430
 431         va_start(list, format);
 432         rv = winansi_vfprintf(stdout, format, list);
 433         va_end(list);
 434
 435         return rv;
 436 }