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
   8 /*
   9  Functions to be wrapped:
  10 */
  11 #undef printf
  12 #undef fprintf
  13 #undef fputs
  14 #undef vfprintf
  15 /* TODO: write */
  16
  17 /*
  18  ANSI codes used by git: m, K
  19
  20  This file is git-specific. Therefore, this file does not attempt
  21  to implement any codes that are not used by git.
  22 */
  23
  24 static HANDLE console;
  25 static WORD plain_attr;
  26 static WORD attr;
  27 static int negative;
  28
  29 static void init(void)
  30 {
  31         CONSOLE_SCREEN_BUFFER_INFO sbi;
  32
  33         static int initialized = 0;
  34         if (initialized)
  35                 return;
  36
  37         console = GetStdHandle(STD_OUTPUT_HANDLE);
  38         if (console == INVALID_HANDLE_VALUE)
  39                 console = NULL;
  40
  41         if (!console)
  42                 return;
  43
  44         GetConsoleScreenBufferInfo(console, &sbi);
  45         attr = plain_attr = sbi.wAttributes;
  46         negative = 0;
  47
  48         initialized = 1;
  49 }
  50
  51 static int write_console(const char *str, size_t len)
  52 {
  53         /* convert utf-8 to utf-16, write directly to console */
  54         int wlen = MultiByteToWideChar(CP_UTF8, 0, str, len, NULL, 0);
  55         wchar_t *wbuf = (wchar_t *) alloca(wlen * sizeof(wchar_t));
  56         MultiByteToWideChar(CP_UTF8, 0, str, len, wbuf, wlen);
  57
  58         WriteConsoleW(console, wbuf, wlen, NULL, NULL);
  59
  60         /* return original (utf-8 encoded) length */
  61         return len;
  62 }
  63
  64 #define FOREGROUND_ALL (FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE)
  65 #define BACKGROUND_ALL (BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE)
  66
  67 static void set_console_attr(void)
  68 {
  69         WORD attributes = attr;
  70         if (negative) {
  71                 attributes &= ~FOREGROUND_ALL;
  72                 attributes &= ~BACKGROUND_ALL;
  73
  74                 /* This could probably use a bitmask
  75                    instead of a series of ifs */
  76                 if (attr & FOREGROUND_RED)
  77                         attributes |= BACKGROUND_RED;
  78                 if (attr & FOREGROUND_GREEN)
  79                         attributes |= BACKGROUND_GREEN;
  80                 if (attr & FOREGROUND_BLUE)
  81                         attributes |= BACKGROUND_BLUE;
  82
  83                 if (attr & BACKGROUND_RED)
  84                         attributes |= FOREGROUND_RED;
  85                 if (attr & BACKGROUND_GREEN)
  86                         attributes |= FOREGROUND_GREEN;
  87                 if (attr & BACKGROUND_BLUE)
  88                         attributes |= FOREGROUND_BLUE;
  89         }
  90         SetConsoleTextAttribute(console, attributes);
  91 }
  92
  93 static void erase_in_line(void)
  94 {
  95         CONSOLE_SCREEN_BUFFER_INFO sbi;
  96         DWORD dummy; /* Needed for Windows 7 (or Vista) regression */
  97
  98         if (!console)
  99                 return;
 100
 101         GetConsoleScreenBufferInfo(console, &sbi);
 102         FillConsoleOutputCharacterA(console, ' ',
 103                 sbi.dwSize.X - sbi.dwCursorPosition.X, sbi.dwCursorPosition,
 104                 &dummy);
 105 }
 106
 107
 108 static const char *set_attr(const char *str)
 109 {
 110         const char *func;
 111         size_t len = strspn(str, "0123456789;");
 112         func = str + len;
 113
 114         switch (*func) {
 115         case 'm':
 116                 do {
 117                         long val = strtol(str, (char **)&str, 10);
 118                         switch (val) {
 119                         case 0: /* reset */
 120                                 attr = plain_attr;
 121                                 negative = 0;
 122                                 break;
 123                         case 1: /* bold */
 124                                 attr |= FOREGROUND_INTENSITY;
 125                                 break;
 126                         case 2:  /* faint */
 127                         case 22: /* normal */
 128                                 attr &= ~FOREGROUND_INTENSITY;
 129                                 break;
 130                         case 3:  /* italic */
 131                                 /* Unsupported */
 132                                 break;
 133                         case 4:  /* underline */
 134                         case 21: /* double underline */
 135                                 /* Wikipedia says this flag does nothing */
 136                                 /* Furthermore, mingw doesn't define this flag
 137                                 attr |= COMMON_LVB_UNDERSCORE; */
 138                                 break;
 139                         case 24: /* no underline */
 140                                 /* attr &= ~COMMON_LVB_UNDERSCORE; */
 141                                 break;
 142                         case 5:  /* slow blink */
 143                         case 6:  /* fast blink */
 144                                 /* We don't have blink, but we do have
 145                                    background intensity */
 146                                 attr |= BACKGROUND_INTENSITY;
 147                                 break;
 148                         case 25: /* no blink */
 149                                 attr &= ~BACKGROUND_INTENSITY;
 150                                 break;
 151                         case 7:  /* negative */
 152                                 negative = 1;
 153                                 break;
 154                         case 27: /* positive */
 155                                 negative = 0;
 156                                 break;
 157                         case 8:  /* conceal */
 158                         case 28: /* reveal */
 159                                 /* Unsupported */
 160                                 break;
 161                         case 30: /* Black */
 162                                 attr &= ~FOREGROUND_ALL;
 163                                 break;
 164                         case 31: /* Red */
 165                                 attr &= ~FOREGROUND_ALL;
 166                                 attr |= FOREGROUND_RED;
 167                                 break;
 168                         case 32: /* Green */
 169                                 attr &= ~FOREGROUND_ALL;
 170                                 attr |= FOREGROUND_GREEN;
 171                                 break;
 172                         case 33: /* Yellow */
 173                                 attr &= ~FOREGROUND_ALL;
 174                                 attr |= FOREGROUND_RED | FOREGROUND_GREEN;
 175                                 break;
 176                         case 34: /* Blue */
 177                                 attr &= ~FOREGROUND_ALL;
 178                                 attr |= FOREGROUND_BLUE;
 179                                 break;
 180                         case 35: /* Magenta */
 181                                 attr &= ~FOREGROUND_ALL;
 182                                 attr |= FOREGROUND_RED | FOREGROUND_BLUE;
 183                                 break;
 184                         case 36: /* Cyan */
 185                                 attr &= ~FOREGROUND_ALL;
 186                                 attr |= FOREGROUND_GREEN | FOREGROUND_BLUE;
 187                                 break;
 188                         case 37: /* White */
 189                                 attr |= FOREGROUND_RED |
 190                                         FOREGROUND_GREEN |
 191                                         FOREGROUND_BLUE;
 192                                 break;
 193                         case 38: /* Unknown */
 194                                 break;
 195                         case 39: /* reset */
 196                                 attr &= ~FOREGROUND_ALL;
 197                                 attr |= (plain_attr & FOREGROUND_ALL);
 198                                 break;
 199                         case 40: /* Black */
 200                                 attr &= ~BACKGROUND_ALL;
 201                                 break;
 202                         case 41: /* Red */
 203                                 attr &= ~BACKGROUND_ALL;
 204                                 attr |= BACKGROUND_RED;
 205                                 break;
 206                         case 42: /* Green */
 207                                 attr &= ~BACKGROUND_ALL;
 208                                 attr |= BACKGROUND_GREEN;
 209                                 break;
 210                         case 43: /* Yellow */
 211                                 attr &= ~BACKGROUND_ALL;
 212                                 attr |= BACKGROUND_RED | BACKGROUND_GREEN;
 213                                 break;
 214                         case 44: /* Blue */
 215                                 attr &= ~BACKGROUND_ALL;
 216                                 attr |= BACKGROUND_BLUE;
 217                                 break;
 218                         case 45: /* Magenta */
 219                                 attr &= ~BACKGROUND_ALL;
 220                                 attr |= BACKGROUND_RED | BACKGROUND_BLUE;
 221                                 break;
 222                         case 46: /* Cyan */
 223                                 attr &= ~BACKGROUND_ALL;
 224                                 attr |= BACKGROUND_GREEN | BACKGROUND_BLUE;
 225                                 break;
 226                         case 47: /* White */
 227                                 attr |= BACKGROUND_RED |
 228                                         BACKGROUND_GREEN |
 229                                         BACKGROUND_BLUE;
 230                                 break;
 231                         case 48: /* Unknown */
 232                                 break;
 233                         case 49: /* reset */
 234                                 attr &= ~BACKGROUND_ALL;
 235                                 attr |= (plain_attr & BACKGROUND_ALL);
 236                                 break;
 237                         default:
 238                                 /* Unsupported code */
 239                                 break;
 240                         }
 241                         str++;
 242                 } while (*(str-1) == ';');
 243
 244                 set_console_attr();
 245                 break;
 246         case 'K':
 247                 erase_in_line();
 248                 break;
 249         default:
 250                 /* Unsupported code */
 251                 break;
 252         }
 253
 254         return func + 1;
 255 }
 256
 257 static int ansi_emulate(const char *str, FILE *stream)
 258 {
 259         int rv = 0;
 260         const char *pos = str;
 261
 262         fflush(stream);
 263
 264         while (*pos) {
 265                 pos = strstr(str, "\033[");
 266                 if (pos) {
 267                         size_t len = pos - str;
 268
 269                         if (len) {
 270                                 size_t out_len = write_console(str, len);
 271                                 rv += out_len;
 272                                 if (out_len < len)
 273                                         return rv;
 274                         }
 275
 276                         str = pos + 2;
 277                         rv += 2;
 278
 279                         pos = set_attr(str);
 280                         rv += pos - str;
 281                         str = pos;
 282                 } else {
 283                         size_t len = strlen(str);
 284                         rv += write_console(str, len);
 285                         return rv;
 286                 }
 287         }
 288         return rv;
 289 }
 290
 291 int winansi_fputs(const char *str, FILE *stream)
 292 {
 293         int rv;
 294
 295         if (!isatty(fileno(stream)))
 296                 return fputs(str, stream);
 297
 298         init();
 299
 300         if (!console)
 301                 return fputs(str, stream);
 302
 303         rv = ansi_emulate(str, stream);
 304
 305         if (rv >= 0)
 306                 return 0;
 307         else
 308                 return EOF;
 309 }
 310
 311 int winansi_vfprintf(FILE *stream, const char *format, va_list list)
 312 {
 313         int len, rv;
 314         char small_buf[256];
 315         char *buf = small_buf;
 316         va_list cp;
 317
 318         if (!isatty(fileno(stream)))
 319                 goto abort;
 320
 321         init();
 322
 323         if (!console)
 324                 goto abort;
 325
 326         va_copy(cp, list);
 327         len = vsnprintf(small_buf, sizeof(small_buf), format, cp);
 328         va_end(cp);
 329
 330         if (len > sizeof(small_buf) - 1) {
 331                 buf = malloc(len + 1);
 332                 if (!buf)
 333                         goto abort;
 334
 335                 len = vsnprintf(buf, len + 1, format, list);
 336         }
 337
 338         rv = ansi_emulate(buf, stream);
 339
 340         if (buf != small_buf)
 341                 free(buf);
 342         return rv;
 343
 344 abort:
 345         rv = vfprintf(stream, format, list);
 346         return rv;
 347 }
 348
 349 int winansi_fprintf(FILE *stream, const char *format, ...)
 350 {
 351         va_list list;
 352         int rv;
 353
 354         va_start(list, format);
 355         rv = winansi_vfprintf(stream, format, list);
 356         va_end(list);
 357
 358         return rv;
 359 }
 360
 361 int winansi_printf(const char *format, ...)
 362 {
 363         va_list list;
 364         int rv;
 365
 366         va_start(list, format);
 367         rv = winansi_vfprintf(stdout, format, list);
 368         va_end(list);
 369
 370         return rv;
 371 }