src/line_printer.cc

   1 // Copyright 2013 Google Inc. All Rights Reserved.
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 #include "line_printer.h"
  16
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #ifdef _WIN32
  20 #include <windows.h>
  21 #else
  22 #include <unistd.h>
  23 #include <sys/ioctl.h>
  24 #include <termios.h>
  25 #include <sys/time.h>
  26 #endif
  27
  28 #include "util.h"
  29
  30 LinePrinter::LinePrinter() : have_blank_line_(true), console_locked_(false) {
  31 #ifndef _WIN32
  32   const char* term = getenv("TERM");
  33   smart_terminal_ = isatty(1) && term && string(term) != "dumb";
  34 #else
  35   // Disable output buffer.  It'd be nice to use line buffering but
  36   // MSDN says: "For some systems, [_IOLBF] provides line
  37   // buffering. However, for Win32, the behavior is the same as _IOFBF
  38   // - Full Buffering."
  39   setvbuf(stdout, NULL, _IONBF, 0);
  40   console_ = GetStdHandle(STD_OUTPUT_HANDLE);
  41   CONSOLE_SCREEN_BUFFER_INFO csbi;
  42   smart_terminal_ = GetConsoleScreenBufferInfo(console_, &csbi);
  43 #endif
  44 }
  45
  46 void LinePrinter::Print(string to_print, LineType type) {
  47   if (console_locked_) {
  48     line_buffer_ = to_print;
  49     line_type_ = type;
  50     return;
  51   }
  52
  53   if (smart_terminal_) {
  54     printf("\r");  // Print over previous line, if any.
  55     // On Windows, calling a C library function writing to stdout also handles
  56     // pausing the executable when the "Pause" key or Ctrl-S is pressed.
  57   }
  58
  59   if (smart_terminal_ && type == ELIDE) {
  60 #ifdef _WIN32
  61     CONSOLE_SCREEN_BUFFER_INFO csbi;
  62     GetConsoleScreenBufferInfo(console_, &csbi);
  63
  64     to_print = ElideMiddle(to_print, static_cast<size_t>(csbi.dwSize.X));
  65     // We don't want to have the cursor spamming back and forth, so instead of
  66     // printf use WriteConsoleOutput which updates the contents of the buffer,
  67     // but doesn't move the cursor position.
  68     COORD buf_size = { csbi.dwSize.X, 1 };
  69     COORD zero_zero = { 0, 0 };
  70     SMALL_RECT target = {
  71       csbi.dwCursorPosition.X, csbi.dwCursorPosition.Y,
  72       static_cast<SHORT>(csbi.dwCursorPosition.X + csbi.dwSize.X - 1),
  73       csbi.dwCursorPosition.Y
  74     };
  75     vector<CHAR_INFO> char_data(csbi.dwSize.X);
  76     for (size_t i = 0; i < static_cast<size_t>(csbi.dwSize.X); ++i) {
  77       char_data[i].Char.AsciiChar = i < to_print.size() ? to_print[i] : ' ';
  78       char_data[i].Attributes = csbi.wAttributes;
  79     }
  80     WriteConsoleOutput(console_, &char_data[0], buf_size, zero_zero, &target);
  81 #else
  82     // Limit output to width of the terminal if provided so we don't cause
  83     // line-wrapping.
  84     winsize size;
  85     if ((ioctl(0, TIOCGWINSZ, &size) == 0) && size.ws_col) {
  86       to_print = ElideMiddle(to_print, size.ws_col);
  87     }
  88     printf("%s", to_print.c_str());
  89     printf("\x1B[K");  // Clear to end of line.
  90     fflush(stdout);
  91 #endif
  92
  93     have_blank_line_ = false;
  94   } else {
  95     printf("%s\n", to_print.c_str());
  96   }
  97 }
  98
  99 void LinePrinter::PrintOrBuffer(const char* data, size_t size) {
 100   if (console_locked_) {
 101     output_buffer_.append(data, size);
 102   } else {
 103     // Avoid printf and C strings, since the actual output might contain null
 104     // bytes like UTF-16 does (yuck).
 105     fwrite(data, 1, size, stdout);
 106   }
 107 }
 108
 109 void LinePrinter::PrintOnNewLine(const string& to_print) {
 110   if (console_locked_ && !line_buffer_.empty()) {
 111     output_buffer_.append(line_buffer_);
 112     output_buffer_.append(1, '\n');
 113     line_buffer_.clear();
 114   }
 115   if (!have_blank_line_) {
 116     PrintOrBuffer("\n", 1);
 117   }
 118   if (!to_print.empty()) {
 119     PrintOrBuffer(&to_print[0], to_print.size());
 120   }
 121   have_blank_line_ = to_print.empty() || *to_print.rbegin() == '\n';
 122 }
 123
 124 void LinePrinter::SetConsoleLocked(bool locked) {
 125   if (locked == console_locked_)
 126     return;
 127
 128   if (locked)
 129     PrintOnNewLine("");
 130
 131   console_locked_ = locked;
 132
 133   if (!locked) {
 134     PrintOnNewLine(output_buffer_);
 135     if (!line_buffer_.empty()) {
 136       Print(line_buffer_, line_type_);
 137     }
 138     output_buffer_.clear();
 139     line_buffer_.clear();
 140   }
 141 }