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 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
};

int translate_color( char *str )
{
	char *endptr;
	int color;

	if( !str )
		return -1;

	errno = 0;
	color = strtol( str, &endptr, 10 );

	if( *endptr || color<0 || errno )
	{
		size_t i;
		color = -1;
		for( i=0; i<COLORS; i++ )
		{
			
			if( strcasecmp( col[i], str ) == 0 )
			{
				color = col_idx[i];				
				break;
			}
		}
	}	
	return color;
	
}

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 )
{
	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") );
	}

}