fish-shell/set_color.cpp

#include "config.h"


#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <termios.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <locale.h>

#if HAVE_NCURSES_H
#include <ncurses.h>
#else
#include <curses.h>
#endif

#if HAVE_TERMIO_H
#include <termio.h>
#endif

#if HAVE_TERM_H
#include <term.h>
#elif HAVE_NCURSES_TERM_H
#include <ncurses/term.h>
#endif

#include <errno.h>

#ifdef HAVE_GETOPT_H
#include <getopt.h>
#endif

#if HAVE_LIBINTL_H
#include <libintl.h>
#endif

#include "fallback.h"
#include "print_help.h"
#include "color.h"

/*
  Small utility for setting the color.
  Usage: set_color COLOR
  where COLOR is either an integer from 0 to seven or one of the strings in the col array.
*/

#define COLORS (sizeof(col)/sizeof(char *))

/**
   Program name
*/
#define SET_COLOR "set_color"

/**
   Getopt short switches for set_color
*/
#define GETOPT_STRING "b:hvocu"

#ifdef _
 #undef _
#endif

#ifdef USE_GETTEXT
#define _(string) gettext(string)
#else
#define _(string) (string)
#endif

const char *col[]=
{
  "black",
  "red",
  "green",
  "brown",
  "yellow",
  "blue",
  "magenta",
  "purple",
  "cyan",
  "white",
  "normal"
};

const int col_idx[]=
{
  0,
  1,
  2,
  3,
  3,
  4,
  5,
  5,
  6,
  7,
  8
};

void print_colors()
{
  size_t i;
  for( i=0; i<COLORS; i++ )
  {
    printf( "%s\n", col[i] );
  }
}

static void check_locale_init()
{
  static int is_init = 0;
  if( is_init )
    return;

  is_init = 1;
  setlocale( LC_ALL, "" );
  bindtextdomain( PACKAGE_NAME, LOCALEDIR );
  textdomain( PACKAGE_NAME );
}

/* A lot of this code is taken straight from output.cpp; it sure would be nice to factor these together. */

static bool support_term256;
static bool output_get_supports_term256(void) {
    return support_term256;
}

static bool term256_support_is_native(void) {
    /* Return YES if we think the term256 support is "native" as opposed to forced. */
    return max_colors == 256;
}

static bool write_color(char *todo, unsigned char idx, bool is_fg) {
    bool result = false;
    if (idx < 16 || term256_support_is_native()) {
        /* Use tparm */
        putp( tparm( todo, idx ) );
        result = true;
    } else {
        /* We are attempting to bypass the term here. Generate the ANSI escape sequence ourself. */
        char stridx[128];
        format_long_safe(stridx, (long)idx);
        char buff[128] = "\x1b[";
        strcat(buff, is_fg ? "38;5;" : "48;5;");
        strcat(buff, stridx);
        strcat(buff, "m");
        write_loop(STDOUT_FILENO, buff, strlen(buff));
        result = true;
    }
    return result;
}

static bool write_foreground_color(unsigned char idx) {
    if (set_a_foreground && set_a_foreground[0]) {
        return write_color(set_a_foreground, idx, true);
    } else if (set_foreground && set_foreground[0]) {
        return write_color(set_foreground, idx, true);
    } else {
        return false;
    }
}

static bool write_background_color(unsigned char idx) {
    if (set_a_background && set_a_background[0]) {
        return write_color(set_a_background, idx, false);
    } else if (set_background && set_background[0]) {
        return write_color(set_background, idx, false);
    } else {
        return false;
    }
}

static unsigned char index_for_color(rgb_color_t c) {
    if (c.is_named() || ! output_get_supports_term256()) {
        return c.to_name_index();
    } else {
        return c.to_term256_index();
    }
}


int main( int argc, char **argv )
{
    /* Some code passes variables to set_color that don't exist, like $fish_user_whatever. As a hack, quietly return failure. */
    if (argc <= 1)
        return EXIT_FAILURE;

  char *bgcolor=0;
  char *fgcolor=0;
  bool bold=false;
  bool underline=false;

  while( 1 )
  {
    static struct option
      long_options[] =
      {
        {
          "background", required_argument, 0, 'b'
        }
        ,
        {
          "help", no_argument, 0, 'h'
        }
        ,
        {
          "bold", no_argument, 0, 'o'
        }
        ,
        {
          "underline", no_argument, 0, 'u'
        }
        ,
        {
          "version", no_argument, 0, 'v'
        }
        ,
        {
          "print-colors", no_argument, 0, 'c'
        }
        ,
        {
          0, 0, 0, 0
        }
      }
    ;

    int opt_index = 0;

    int opt = getopt_long( argc,
                 argv,
                 GETOPT_STRING,
                 long_options,
                 &opt_index );

    if( opt == -1 )
      break;

    switch( opt )
    {
      case 0:
        break;

      case 'b':
        bgcolor = optarg;
        break;
      case 'h':
        print_help( argv[0], 1 );
        exit(0);

      case 'o':
        bold=true;
        break;

      case 'u':
        underline=true;
        break;

      case 'v':
        check_locale_init();
        fprintf( stderr, _("%s, version %s\n"), SET_COLOR, PACKAGE_VERSION );
        exit( 0 );

      case 'c':
        print_colors();
        exit(0);

      case '?':
        return 1;

    }

  }

  switch( argc-optind)
  {
    case 0:
//      printf( "no fg\n" );
      break;

    case 1:
      fgcolor=argv[optind];
//      printf( "fg %s\n", fgcolor );
      break;

    default:
      check_locale_init();
      printf( _("%s: Too many arguments\n"), SET_COLOR );
      return 1;
  }

    /* Infer term256 support */
    char *fish_term256 = getenv("fish_term256");
    if (fish_term256) {
        support_term256 = from_string<bool>(fish_term256);
    } else {
        const char *term = getenv("TERM");
        support_term256 = term && strstr(term, "256color");
    }

  if( !fgcolor && !bgcolor && !bold && !underline )
  {
    check_locale_init();
    fprintf( stderr, _("%s: Expected an argument\n"), SET_COLOR );
    print_help( argv[0], 2 );
    return 1;
  }

    rgb_color_t fg = rgb_color_t(fgcolor ? fgcolor : "");
  if( fgcolor && fg.is_none())
  {
    check_locale_init();
    fprintf( stderr, _("%s: Unknown color '%s'\n"), SET_COLOR, fgcolor );
    return 1;
  }

    rgb_color_t bg = rgb_color_t(bgcolor ? bgcolor : "");
  if( bgcolor && bg.is_none())
  {
    check_locale_init();
    fprintf( stderr, _("%s: Unknown color '%s'\n"), SET_COLOR, bgcolor );
    return 1;
  }

  setupterm( 0, STDOUT_FILENO, 0);

  if( bold )
  {
    if( enter_bold_mode )
      putp( enter_bold_mode );
  }

  if( underline )
  {
    if( enter_underline_mode )
      putp( enter_underline_mode );
  }

  if( bgcolor )
  {
    if( bg.is_normal() )
    {
            write_background_color(0);
      putp( tparm(exit_attribute_mode) );
    }
  }

  if( fgcolor )
  {
    if( fg.is_normal() )
    {
            write_foreground_color(0);
      putp( tparm(exit_attribute_mode) );
    }
    else
    {
            write_foreground_color(index_for_color(fg));
    }
  }

  if( bgcolor )
  {
    if( ! bg.is_normal() )
    {
            write_background_color(index_for_color(bg));
    }
  }

  if( del_curterm( cur_term ) == ERR )
  {
    fprintf( stderr, "%s", _("Error while closing terminfo") );
  }

}