| OLD | NEW | 
|    1 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file |    1 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file | 
|    2 // for details. All rights reserved. Use of this source code is governed by a |    2 // for details. All rights reserved. Use of this source code is governed by a | 
|    3 // BSD-style license that can be found in the LICENSE file. |    3 // BSD-style license that can be found in the LICENSE file. | 
|    4  |    4  | 
|    5 #if !defined(DART_IO_DISABLED) |    5 #if !defined(DART_IO_DISABLED) | 
|    6  |    6  | 
|    7 #include "platform/globals.h" |    7 #include "platform/globals.h" | 
|    8 #if defined(HOST_OS_WINDOWS) |    8 #if defined(HOST_OS_WINDOWS) | 
|    9  |    9  | 
|   10 #include "bin/stdio.h" |   10 #include "bin/stdio.h" | 
| (...skipping 16 matching lines...) Expand all  Loading... | 
|   27   uint8_t buffer[1]; |   27   uint8_t buffer[1]; | 
|   28   DWORD read = 0; |   28   DWORD read = 0; | 
|   29   BOOL success = ReadFile(h, buffer, 1, &read, NULL); |   29   BOOL success = ReadFile(h, buffer, 1, &read, NULL); | 
|   30   if (!success && (GetLastError() != ERROR_BROKEN_PIPE)) { |   30   if (!success && (GetLastError() != ERROR_BROKEN_PIPE)) { | 
|   31     return false; |   31     return false; | 
|   32   } |   32   } | 
|   33   *byte = (read == 1) ? buffer[0] : -1; |   33   *byte = (read == 1) ? buffer[0] : -1; | 
|   34   return true; |   34   return true; | 
|   35 } |   35 } | 
|   36  |   36  | 
|   37  |  | 
|   38 bool Stdin::GetEchoMode(bool* enabled) { |   37 bool Stdin::GetEchoMode(bool* enabled) { | 
|   39   HANDLE h = GetStdHandle(STD_INPUT_HANDLE); |   38   HANDLE h = GetStdHandle(STD_INPUT_HANDLE); | 
|   40   DWORD mode; |   39   DWORD mode; | 
|   41   if (!GetConsoleMode(h, &mode)) { |   40   if (!GetConsoleMode(h, &mode)) { | 
|   42     return false; |   41     return false; | 
|   43   } |   42   } | 
|   44   *enabled = ((mode & ENABLE_ECHO_INPUT) != 0); |   43   *enabled = ((mode & ENABLE_ECHO_INPUT) != 0); | 
|   45   return true; |   44   return true; | 
|   46 } |   45 } | 
|   47  |   46  | 
|   48  |  | 
|   49 bool Stdin::SetEchoMode(bool enabled) { |   47 bool Stdin::SetEchoMode(bool enabled) { | 
|   50   HANDLE h = GetStdHandle(STD_INPUT_HANDLE); |   48   HANDLE h = GetStdHandle(STD_INPUT_HANDLE); | 
|   51   DWORD mode; |   49   DWORD mode; | 
|   52   if (!GetConsoleMode(h, &mode)) { |   50   if (!GetConsoleMode(h, &mode)) { | 
|   53     return false; |   51     return false; | 
|   54   } |   52   } | 
|   55   if (enabled) { |   53   if (enabled) { | 
|   56     mode |= ENABLE_ECHO_INPUT; |   54     mode |= ENABLE_ECHO_INPUT; | 
|   57   } else { |   55   } else { | 
|   58     mode &= ~ENABLE_ECHO_INPUT; |   56     mode &= ~ENABLE_ECHO_INPUT; | 
|   59   } |   57   } | 
|   60   return SetConsoleMode(h, mode); |   58   return SetConsoleMode(h, mode); | 
|   61 } |   59 } | 
|   62  |   60  | 
|   63  |  | 
|   64 bool Stdin::GetLineMode(bool* enabled) { |   61 bool Stdin::GetLineMode(bool* enabled) { | 
|   65   HANDLE h = GetStdHandle(STD_INPUT_HANDLE); |   62   HANDLE h = GetStdHandle(STD_INPUT_HANDLE); | 
|   66   DWORD mode; |   63   DWORD mode; | 
|   67   if (!GetConsoleMode(h, &mode)) { |   64   if (!GetConsoleMode(h, &mode)) { | 
|   68     return false; |   65     return false; | 
|   69   } |   66   } | 
|   70   *enabled = (mode & ENABLE_LINE_INPUT) != 0; |   67   *enabled = (mode & ENABLE_LINE_INPUT) != 0; | 
|   71   return true; |   68   return true; | 
|   72 } |   69 } | 
|   73  |   70  | 
|   74  |  | 
|   75 bool Stdin::SetLineMode(bool enabled) { |   71 bool Stdin::SetLineMode(bool enabled) { | 
|   76   HANDLE h = GetStdHandle(STD_INPUT_HANDLE); |   72   HANDLE h = GetStdHandle(STD_INPUT_HANDLE); | 
|   77   DWORD mode; |   73   DWORD mode; | 
|   78   if (!GetConsoleMode(h, &mode)) { |   74   if (!GetConsoleMode(h, &mode)) { | 
|   79     return false; |   75     return false; | 
|   80   } |   76   } | 
|   81   if (enabled) { |   77   if (enabled) { | 
|   82     mode |= ENABLE_LINE_INPUT; |   78     mode |= ENABLE_LINE_INPUT; | 
|   83   } else { |   79   } else { | 
|   84     mode &= ~ENABLE_LINE_INPUT; |   80     mode &= ~ENABLE_LINE_INPUT; | 
|   85   } |   81   } | 
|   86   return SetConsoleMode(h, mode); |   82   return SetConsoleMode(h, mode); | 
|   87 } |   83 } | 
|   88  |   84  | 
|   89  |  | 
|   90 bool Stdin::AnsiSupported(bool* supported) { |   85 bool Stdin::AnsiSupported(bool* supported) { | 
|   91   ASSERT(supported != NULL); |   86   ASSERT(supported != NULL); | 
|   92   HANDLE h = GetStdHandle(STD_INPUT_HANDLE); |   87   HANDLE h = GetStdHandle(STD_INPUT_HANDLE); | 
|   93   if (h == INVALID_HANDLE_VALUE) { |   88   if (h == INVALID_HANDLE_VALUE) { | 
|   94     *supported = false; |   89     *supported = false; | 
|   95     return true; |   90     return true; | 
|   96   } |   91   } | 
|   97   DWORD mode; |   92   DWORD mode; | 
|   98   if (!GetConsoleMode(h, &mode)) { |   93   if (!GetConsoleMode(h, &mode)) { | 
|   99     *supported = false; |   94     *supported = false; | 
|  100     return true; |   95     return true; | 
|  101   } |   96   } | 
|  102   *supported = (mode & ENABLE_VIRTUAL_TERMINAL_INPUT) != 0; |   97   *supported = (mode & ENABLE_VIRTUAL_TERMINAL_INPUT) != 0; | 
|  103   return true; |   98   return true; | 
|  104 } |   99 } | 
|  105  |  100  | 
|  106  |  | 
|  107 bool Stdout::GetTerminalSize(intptr_t fd, int size[2]) { |  101 bool Stdout::GetTerminalSize(intptr_t fd, int size[2]) { | 
|  108   HANDLE h; |  102   HANDLE h; | 
|  109   if (fd == 1) { |  103   if (fd == 1) { | 
|  110     h = GetStdHandle(STD_OUTPUT_HANDLE); |  104     h = GetStdHandle(STD_OUTPUT_HANDLE); | 
|  111   } else { |  105   } else { | 
|  112     h = GetStdHandle(STD_ERROR_HANDLE); |  106     h = GetStdHandle(STD_ERROR_HANDLE); | 
|  113   } |  107   } | 
|  114   CONSOLE_SCREEN_BUFFER_INFO info; |  108   CONSOLE_SCREEN_BUFFER_INFO info; | 
|  115   if (!GetConsoleScreenBufferInfo(h, &info)) { |  109   if (!GetConsoleScreenBufferInfo(h, &info)) { | 
|  116     return false; |  110     return false; | 
|  117   } |  111   } | 
|  118   size[0] = info.srWindow.Right - info.srWindow.Left + 1; |  112   size[0] = info.srWindow.Right - info.srWindow.Left + 1; | 
|  119   size[1] = info.srWindow.Bottom - info.srWindow.Top + 1; |  113   size[1] = info.srWindow.Bottom - info.srWindow.Top + 1; | 
|  120   return true; |  114   return true; | 
|  121 } |  115 } | 
|  122  |  116  | 
|  123  |  | 
|  124 bool Stdout::AnsiSupported(intptr_t fd, bool* supported) { |  117 bool Stdout::AnsiSupported(intptr_t fd, bool* supported) { | 
|  125   ASSERT(supported != NULL); |  118   ASSERT(supported != NULL); | 
|  126   HANDLE h; |  119   HANDLE h; | 
|  127   if (fd == 1) { |  120   if (fd == 1) { | 
|  128     h = GetStdHandle(STD_OUTPUT_HANDLE); |  121     h = GetStdHandle(STD_OUTPUT_HANDLE); | 
|  129   } else { |  122   } else { | 
|  130     h = GetStdHandle(STD_ERROR_HANDLE); |  123     h = GetStdHandle(STD_ERROR_HANDLE); | 
|  131   } |  124   } | 
|  132   if (h == INVALID_HANDLE_VALUE) { |  125   if (h == INVALID_HANDLE_VALUE) { | 
|  133     *supported = false; |  126     *supported = false; | 
|  134     return true; |  127     return true; | 
|  135   } |  128   } | 
|  136   DWORD mode; |  129   DWORD mode; | 
|  137   if (!GetConsoleMode(h, &mode)) { |  130   if (!GetConsoleMode(h, &mode)) { | 
|  138     *supported = false; |  131     *supported = false; | 
|  139     return true; |  132     return true; | 
|  140   } |  133   } | 
|  141   *supported = (mode & ENABLE_VIRTUAL_TERMINAL_PROCESSING) != 0; |  134   *supported = (mode & ENABLE_VIRTUAL_TERMINAL_PROCESSING) != 0; | 
|  142   return true; |  135   return true; | 
|  143 } |  136 } | 
|  144  |  137  | 
|  145 }  // namespace bin |  138 }  // namespace bin | 
|  146 }  // namespace dart |  139 }  // namespace dart | 
|  147  |  140  | 
|  148 #endif  // defined(HOST_OS_WINDOWS) |  141 #endif  // defined(HOST_OS_WINDOWS) | 
|  149  |  142  | 
|  150 #endif  // !defined(DART_IO_DISABLED) |  143 #endif  // !defined(DART_IO_DISABLED) | 
| OLD | NEW |