src/formatting_port.cpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : formatting_port.cpp
* DESCRIPTION: Sugar for formatted output
* COPYRIGHT  : (C) 2010  Joris van der Hoeven
*******************************************************************************
* This software falls under the GNU general public license and comes WITHOUT
* ANY WARRANTY WHATSOEVER. See the file $TEXMACS_PATH/LICENSE for more details.
* If you don't have this file, write to the Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
******************************************************************************/

#include <basix/port.hpp>
#include <basix/system.hpp>


namespace mmx {

/******************************************************************************
* Rough support for colors
******************************************************************************/

bool
supports_color () {
  static bool terminal_supports_color=
    get_env ("TERM") == string ("xterm") ||
    get_env ("TERM") == string ("xterm-color") ||
    get_env ("TERM") == string ("xterm-256color");
  return terminal_supports_color && !texmacs_mode && color_mode;
}

/******************************************************************************
* Formatting ports
******************************************************************************/

class formatting_port_rep: public port_rep {
  port   p;
  string prefix;
  bool   need_indent;
  string indenter;

public:
  syntactic expression () const {
    return syn ("formatting_port", flatten (p)); }
  bool is_output_port () {
    return mmx::is_output_port (p); }
  bool is_input_port () {
    return mmx::is_input_port (p); }
  bool error_flag () {
    return mmx::error_flag (p); }
  string error_message () {
    return mmx::error_message (p); }
  bool busy () {
    return mmx::busy (p); }
  nat can_write () {
    return mmx::can_write (p); }
  nat can_read () {
    return mmx::can_read (p); }
  void write (const char* s, nat n) {
    for (nat i=0; i<n; ) {
      nat start= i;
      while (i<n && s[i] != '\n') i++;
      if (i>start && need_indent) mmx::write (p, prefix);
      need_indent= (i<n);
      if (need_indent) i++;
      mmx::write (p, s+start, i-start);
    } }
  void read (char* s, nat n) {
    mmx::read (p, s, n); }
  void flush () {
    mmx::flush (p); }
  bool wait (int msecs) {
    return mmx::wait (p, msecs); }
  port component (const string& name) {
    if (name == "wrapped") return p;
    ERROR ("port not found"); }

  void format (const print_format& fm) {
    switch (fm) {
    case blank:
      indenter= "  ";
      break;
    case stroke:
      indenter= "| ";
      break;
    case indent:
      prefix << indenter;
      break;
    case unindent:
      inside (prefix) -> resize (max (N(prefix), N(indenter)) - N(indenter));
      break;
    case reset_indent:
      inside (prefix) -> resize (0);
      break;
    case cr:
      write ("\r", 1);
      break;
    case lf:
      write ("\n", 1);
      break;
    case hrule:
      write ("--------------------------------------------------------------------------------", 80);
      break;
    case flush_now:
      flush ();
      break;

    case black_foreground:
      if (supports_color ()) write ("\x1b[30m", 5);
      break;
    case red_foreground:
      if (supports_color ()) write ("\x1b[31m", 5);
      break;
    case green_foreground:
      if (supports_color ()) write ("\x1b[32m", 5);
      break;
    case yellow_foreground:
      if (supports_color ()) write ("\x1b[33m", 5);
      break;
    case blue_foreground:
      if (supports_color ()) write ("\x1b[34m", 5);
      break;
    case magenta_foreground:
      if (supports_color ()) write ("\x1b[35m", 5);
      break;
    case cyan_foreground:
      if (supports_color ()) write ("\x1b[36m", 5);
      break;
    case white_foreground:
      if (supports_color ()) write ("\x1b[37m", 5);
      break;

    case black_background:
      if (supports_color ()) write ("\x1b[40m", 5);
      break;
    case red_background:
      if (supports_color ()) write ("\x1b[41m", 5);
      break;
    case green_background:
      if (supports_color ()) write ("\x1b[42m", 5);
      break;
    case yellow_background:
      if (supports_color ()) write ("\x1b[43m", 5);
      break;
    case blue_background:
      if (supports_color ()) write ("\x1b[44m", 5);
      break;
    case magenta_background:
      if (supports_color ()) write ("\x1b[45m", 5);
      break;
    case cyan_background:
      if (supports_color ()) write ("\x1b[46m", 5);
      break;
    case white_background:
      if (supports_color ()) write ("\x1b[47m", 5);
      break;

    case bold:
      if (supports_color ()) write ("\x1b[1m", 4);
      break;
    case underline:
      if (supports_color ()) write ("\x1b[4m", 4);
      break;
    case blink:
      if (supports_color ()) write ("\x1b[5m", 4);
      break;

    case reset_attributes:
      if (supports_color ()) write ("\x1b[0m", 4);
      flush ();
      break;
    }
  }

public:
  inline formatting_port_rep (const port& p2):
    p (p2), prefix (""), need_indent (true), indenter ("  ") {}
};

/******************************************************************************
* Public constructor
******************************************************************************/

port
formatting_port (const port& p) {
  return (port_rep*) new formatting_port_rep (p);
}

} // namespace mmx

---