git.oblomov.eu Git - git/blob - compat/winansi.c

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