/* vi:set ts=8 sts=4 sw=4 noet: * * VIM - Vi IMproved by Bram Moolenaar * * Do ":help uganda" in Vim to read copying and usage conditions. * Do ":help credits" in Vim to see a list of people who contributed. * See README.txt for an overview of the Vim source code. */ /* * Highlighting stuff. */ #include "vim.h" #define SG_TERM 1 // term has been set #define SG_CTERM 2 // cterm has been set #define SG_GUI 4 // gui has been set #define SG_LINK 8 // link has been set #define MAX_SYN_NAME 200 /* * The "term", "cterm" and "gui" arguments can be any combination of the * following names, separated by commas (but no spaces!). */ // must be sorted by the 'value' field because it is used by bsearch()! // note: inverse and reverse use the same key static keyvalue_T highlight_tab[] = { KEYVALUE_ENTRY(HL_BOLD, "bold"), // index 0 KEYVALUE_ENTRY(HL_INVERSE, "inverse"), // index 1 KEYVALUE_ENTRY(HL_ITALIC, "italic"), // index 2 KEYVALUE_ENTRY(HL_NOCOMBINE, "nocombine"), // index 3 KEYVALUE_ENTRY(HL_NORMAL, "NONE"), // index 4 KEYVALUE_ENTRY(HL_INVERSE, "reverse"), // index 5 KEYVALUE_ENTRY(HL_STANDOUT, "standout"), // index 6 KEYVALUE_ENTRY(HL_STRIKETHROUGH, "strikethrough"), // index 7 KEYVALUE_ENTRY(HL_UNDERCURL, "undercurl"), // index 8 KEYVALUE_ENTRY(HL_UNDERDASHED, "underdashed"), // index 9 KEYVALUE_ENTRY(HL_UNDERDOTTED, "underdotted"), // index 10 KEYVALUE_ENTRY(HL_UNDERDOUBLE, "underdouble"), // index 11 KEYVALUE_ENTRY(HL_UNDERLINE, "underline") // index 12 }; // this table is used to display highlight names in the "correct" sequence. // keep this in sync with highlight_tab[]. static keyvalue_T *highlight_index_tab[] = { &highlight_tab[0], // HL_BOLD &highlight_tab[6], // HL_STANDOUT &highlight_tab[12], // HL_UNDERLINE &highlight_tab[8], // HL_UNDERCURL &highlight_tab[11], // HL_UNDERDOUBLE &highlight_tab[10], // HL_UNDERDOTTED &highlight_tab[9], // HL_UNDERDASHED &highlight_tab[2], // HL_ITALIC &highlight_tab[5], // HL_REVERSE &highlight_tab[1], // HL_INVERSE &highlight_tab[3], // HL_NOCOMBINE &highlight_tab[7], // HL_STRIKETHROUGH &highlight_tab[4] // HL_NORMAL }; // length of all attribute names, plus commas, together (and a bit more) #define MAX_ATTR_LEN 120 #define ATTR_COMBINE(attr_a, attr_b) ((((attr_b) & HL_NOCOMBINE) ? (attr_b) : (attr_a)) | (attr_b)) enum { BLACK = 0, DARKBLUE, DARKGREEN, DARKCYAN, DARKRED, DARKMAGENTA, BROWN, DARKYELLOW, GRAY, GREY, LIGHTGRAY, LIGHTGREY, DARKGRAY, DARKGREY, BLUE, LIGHTBLUE, GREEN, LIGHTGREEN, CYAN, LIGHTCYAN, RED, LIGHTRED, MAGENTA, LIGHTMAGENTA, YELLOW, LIGHTYELLOW, WHITE, NONE }; // must be sorted by the 'value' field because it is used by bsearch()! static keyvalue_T color_name_tab[] = { KEYVALUE_ENTRY(BLACK, "Black"), KEYVALUE_ENTRY(BLUE, "Blue"), KEYVALUE_ENTRY(BROWN, "Brown"), KEYVALUE_ENTRY(CYAN, "Cyan"), KEYVALUE_ENTRY(DARKBLUE, "DarkBlue"), KEYVALUE_ENTRY(DARKCYAN, "DarkCyan"), KEYVALUE_ENTRY(DARKGRAY, "DarkGray"), KEYVALUE_ENTRY(DARKGREEN, "DarkGreen"), KEYVALUE_ENTRY(DARKGREY, "DarkGrey"), KEYVALUE_ENTRY(DARKMAGENTA, "DarkMagenta"), KEYVALUE_ENTRY(DARKRED, "DarkRed"), KEYVALUE_ENTRY(DARKYELLOW, "DarkYellow"), KEYVALUE_ENTRY(GRAY, "Gray"), KEYVALUE_ENTRY(GREEN, "Green"), KEYVALUE_ENTRY(GREY, "Grey"), KEYVALUE_ENTRY(LIGHTBLUE, "LightBlue"), KEYVALUE_ENTRY(LIGHTCYAN, "LightCyan"), KEYVALUE_ENTRY(LIGHTGRAY, "LightGray"), KEYVALUE_ENTRY(LIGHTGREEN, "LightGreen"), KEYVALUE_ENTRY(LIGHTGREY, "LightGrey"), KEYVALUE_ENTRY(LIGHTMAGENTA, "LightMagenta"), KEYVALUE_ENTRY(LIGHTRED, "LightRed"), KEYVALUE_ENTRY(LIGHTYELLOW, "LightYellow"), KEYVALUE_ENTRY(MAGENTA, "Magenta"), KEYVALUE_ENTRY(NONE, "NONE"), KEYVALUE_ENTRY(RED, "Red"), KEYVALUE_ENTRY(WHITE, "White"), KEYVALUE_ENTRY(YELLOW, "Yellow") }; /* * Structure that stores information about a highlight group. * The ID of a highlight group is also called group ID. It is the index in * the highlight_ga array PLUS ONE. */ typedef struct { char_u *sg_name; // highlight group name char_u *sg_name_u; // uppercase of sg_name int sg_cleared; // "hi clear" was used // for normal terminals int sg_term; // "term=" highlighting attributes char_u *sg_start; // terminal string for start highl char_u *sg_stop; // terminal string for stop highl int sg_term_attr; // Screen attr for term mode // for color terminals int sg_cterm; // "cterm=" highlighting attr int sg_cterm_bold; // bold attr was set for light color int sg_cterm_fg; // terminal fg color number + 1 int sg_cterm_bg; // terminal bg color number + 1 int sg_cterm_ul; // terminal ul color number + 1 int sg_cterm_attr; // Screen attr for color term mode int sg_cterm_font; // terminal alternative font (0 for normal) // for when using the GUI #if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) guicolor_T sg_gui_fg; // GUI foreground color handle guicolor_T sg_gui_bg; // GUI background color handle guicolor_T sg_gui_sp; // GUI special color handle #endif #ifdef FEAT_GUI GuiFont sg_font; // GUI font handle #ifdef FEAT_XFONTSET GuiFontset sg_fontset; // GUI fontset handle #endif char_u *sg_font_name; // GUI font or fontset name int sg_gui_attr; // Screen attr for GUI mode #endif #if defined(FEAT_GUI) || defined(FEAT_EVAL) // Store the sp color name for the GUI or synIDattr() int sg_gui; // "gui=" highlighting attributes char_u *sg_gui_fg_name;// GUI foreground color name char_u *sg_gui_bg_name;// GUI background color name char_u *sg_gui_sp_name;// GUI special color name #endif int sg_link; // link to this highlight group ID int sg_deflink; // default link; restored in highlight_clear() int sg_set; // combination of SG_* flags #ifdef FEAT_EVAL sctx_T sg_deflink_sctx; // script where the default link was set sctx_T sg_script_ctx; // script in which the group was last set #endif } hl_group_T; // highlight groups for 'highlight' option static garray_T highlight_ga; #define HL_TABLE() ((hl_group_T *)((highlight_ga.ga_data))) /* * An attribute number is the index in attr_table plus ATTR_OFF. */ #define ATTR_OFF (HL_ALL + 1) static void syn_unadd_group(void); static void set_hl_attr(int idx); static void highlight_list_one(int id); static int highlight_list_arg(int id, int didh, int type, int iarg, char_u *sarg, char *name); static int syn_add_group(char_u *name); static int hl_has_settings(int idx, int check_link); static void highlight_clear(int idx); #if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) static void gui_do_one_color(int idx, int do_menu, int do_tooltip); #endif #ifdef FEAT_GUI static int set_group_colors(char_u *name, guicolor_T *fgp, guicolor_T *bgp, int do_menu, int use_norm, int do_tooltip); static void hl_do_font(int idx, char_u *arg, int do_normal, int do_menu, int do_tooltip, int free_font); #endif /* * The default highlight groups. These are compiled-in for fast startup and * they still work when the runtime files can't be found. * When making changes here, also change runtime/colors/default.vim! * The #ifdefs are needed to reduce the amount of static data. Helps to make * the 16 bit DOS (museum) version compile. */ #if defined(FEAT_GUI) || defined(FEAT_EVAL) # define CENT(a, b) b #else # define CENT(a, b) a #endif static char *(highlight_init_both[]) = { CENT("ErrorMsg term=standout ctermbg=DarkRed ctermfg=White", "ErrorMsg term=standout ctermbg=DarkRed ctermfg=White guibg=Red guifg=White"), CENT("IncSearch term=reverse cterm=reverse", "IncSearch term=reverse cterm=reverse gui=reverse"), CENT("ModeMsg term=bold cterm=bold", "ModeMsg term=bold cterm=bold gui=bold"), CENT("NonText term=bold ctermfg=Blue", "NonText term=bold ctermfg=Blue gui=bold guifg=Blue"), CENT("StatusLine term=reverse,bold cterm=reverse,bold", "StatusLine term=reverse,bold cterm=reverse,bold gui=reverse,bold"), CENT("StatusLineNC term=reverse cterm=reverse", "StatusLineNC term=reverse cterm=reverse gui=reverse"), "default link EndOfBuffer NonText", CENT("VertSplit term=reverse cterm=reverse", "VertSplit term=reverse cterm=reverse gui=reverse"), #ifdef FEAT_CLIPBOARD CENT("VisualNOS term=underline,bold cterm=underline,bold", "VisualNOS term=underline,bold cterm=underline,bold gui=underline,bold"), #endif #ifdef FEAT_DIFF CENT("DiffText term=reverse cterm=bold ctermbg=Red", "DiffText term=reverse cterm=bold ctermbg=Red gui=bold guibg=Red"), #endif CENT("PmenuSbar ctermbg=Grey", "PmenuSbar ctermbg=Grey guibg=Grey"), CENT("TabLineSel term=bold cterm=bold", "TabLineSel term=bold cterm=bold gui=bold"), CENT("TabLineFill term=reverse cterm=reverse", "TabLineFill term=reverse cterm=reverse gui=reverse"), #ifdef FEAT_GUI "Cursor guibg=fg guifg=bg", "lCursor guibg=fg guifg=bg", // should be different, but what? #endif "default link QuickFixLine Search", "default link CursorLineSign SignColumn", "default link CursorLineFold FoldColumn", "default link CurSearch Search", "default link PmenuKind Pmenu", "default link PmenuKindSel PmenuSel", "default link PmenuExtra Pmenu", "default link PmenuExtraSel PmenuSel", CENT("Normal cterm=NONE", "Normal gui=NONE"), NULL }; // Default colors only used with a light background. static char *(highlight_init_light[]) = { CENT("Directory term=bold ctermfg=DarkBlue", "Directory term=bold ctermfg=DarkBlue guifg=Blue"), CENT("LineNr term=underline ctermfg=Brown", "LineNr term=underline ctermfg=Brown guifg=Brown"), CENT("CursorLineNr term=bold cterm=underline ctermfg=Brown", "CursorLineNr term=bold cterm=underline ctermfg=Brown gui=bold guifg=Brown"), CENT("MoreMsg term=bold ctermfg=DarkGreen", "MoreMsg term=bold ctermfg=DarkGreen gui=bold guifg=SeaGreen"), CENT("Question term=standout ctermfg=DarkGreen", "Question term=standout ctermfg=DarkGreen gui=bold guifg=SeaGreen"), CENT("Search term=reverse ctermbg=Yellow ctermfg=NONE", "Search term=reverse ctermbg=Yellow ctermfg=NONE guibg=Yellow guifg=NONE"), #ifdef FEAT_SPELL CENT("SpellBad term=reverse ctermbg=LightRed", "SpellBad term=reverse ctermbg=LightRed guisp=Red gui=undercurl"), CENT("SpellCap term=reverse ctermbg=LightBlue", "SpellCap term=reverse ctermbg=LightBlue guisp=Blue gui=undercurl"), CENT("SpellRare term=reverse ctermbg=LightMagenta", "SpellRare term=reverse ctermbg=LightMagenta guisp=Magenta gui=undercurl"), CENT("SpellLocal term=underline ctermbg=Cyan", "SpellLocal term=underline ctermbg=Cyan guisp=DarkCyan gui=undercurl"), #endif CENT("PmenuThumb ctermbg=Black", "PmenuThumb ctermbg=Black guibg=Black"), CENT("Pmenu ctermbg=LightMagenta ctermfg=Black", "Pmenu ctermbg=LightMagenta ctermfg=Black guibg=LightMagenta"), CENT("PmenuSel ctermbg=LightGrey ctermfg=Black", "PmenuSel ctermbg=LightGrey ctermfg=Black guibg=Grey"), CENT("SpecialKey term=bold ctermfg=DarkBlue", "SpecialKey term=bold ctermfg=DarkBlue guifg=Blue"), CENT("Title term=bold ctermfg=DarkMagenta", "Title term=bold ctermfg=DarkMagenta gui=bold guifg=Magenta"), CENT("WarningMsg term=standout ctermfg=DarkRed", "WarningMsg term=standout ctermfg=DarkRed guifg=Red"), CENT("WildMenu term=standout ctermbg=Yellow ctermfg=Black", "WildMenu term=standout ctermbg=Yellow ctermfg=Black guibg=Yellow guifg=Black"), #ifdef FEAT_FOLDING CENT("Folded term=standout ctermbg=Grey ctermfg=DarkBlue", "Folded term=standout ctermbg=Grey ctermfg=DarkBlue guibg=LightGrey guifg=DarkBlue"), CENT("FoldColumn term=standout ctermbg=Grey ctermfg=DarkBlue", "FoldColumn term=standout ctermbg=Grey ctermfg=DarkBlue guibg=Grey guifg=DarkBlue"), #endif #ifdef FEAT_SIGNS CENT("SignColumn term=standout ctermbg=Grey ctermfg=DarkBlue", "SignColumn term=standout ctermbg=Grey ctermfg=DarkBlue guibg=Grey guifg=DarkBlue"), #endif CENT("Visual ctermbg=Grey ctermfg=Black", "Visual ctermbg=Grey ctermfg=Black guibg=LightGrey guifg=Black"), #ifdef FEAT_DIFF CENT("DiffAdd term=bold ctermbg=LightBlue", "DiffAdd term=bold ctermbg=LightBlue guibg=LightBlue"), CENT("DiffChange term=bold ctermbg=LightMagenta", "DiffChange term=bold ctermbg=LightMagenta guibg=LightMagenta"), CENT("DiffDelete term=bold ctermfg=Blue ctermbg=LightCyan", "DiffDelete term=bold ctermfg=Blue ctermbg=LightCyan gui=bold guifg=Blue guibg=LightCyan"), #endif CENT("TabLine term=underline cterm=underline ctermfg=black ctermbg=LightGrey", "TabLine term=underline cterm=underline ctermfg=black ctermbg=LightGrey gui=underline guibg=LightGrey"), #ifdef FEAT_SYN_HL CENT("CursorColumn term=reverse ctermbg=LightGrey", "CursorColumn term=reverse ctermbg=LightGrey guibg=Grey90"), CENT("CursorLine term=underline cterm=underline", "CursorLine term=underline cterm=underline guibg=Grey90"), CENT("ColorColumn term=reverse ctermbg=LightRed", "ColorColumn term=reverse ctermbg=LightRed guibg=LightRed"), #endif #ifdef FEAT_CONCEAL CENT("Conceal ctermbg=DarkGrey ctermfg=LightGrey", "Conceal ctermbg=DarkGrey ctermfg=LightGrey guibg=DarkGrey guifg=LightGrey"), #endif CENT("MatchParen term=reverse ctermbg=Cyan", "MatchParen term=reverse ctermbg=Cyan guibg=Cyan"), #ifdef FEAT_TERMINAL CENT("StatusLineTerm term=reverse,bold cterm=bold ctermfg=White ctermbg=DarkGreen", "StatusLineTerm term=reverse,bold cterm=bold ctermfg=White ctermbg=DarkGreen gui=bold guifg=bg guibg=DarkGreen"), CENT("StatusLineTermNC term=reverse ctermfg=White ctermbg=DarkGreen", "StatusLineTermNC term=reverse ctermfg=White ctermbg=DarkGreen guifg=bg guibg=DarkGreen"), #endif #ifdef FEAT_MENU CENT("ToolbarLine term=underline ctermbg=LightGrey", "ToolbarLine term=underline ctermbg=LightGrey guibg=LightGrey"), CENT("ToolbarButton cterm=bold ctermfg=White ctermbg=DarkGrey", "ToolbarButton cterm=bold ctermfg=White ctermbg=DarkGrey gui=bold guifg=White guibg=Grey40"), #endif NULL }; // Default colors only used with a dark background. static char *(highlight_init_dark[]) = { CENT("Directory term=bold ctermfg=LightCyan", "Directory term=bold ctermfg=LightCyan guifg=Cyan"), CENT("LineNr term=underline ctermfg=Yellow", "LineNr term=underline ctermfg=Yellow guifg=Yellow"), CENT("CursorLineNr term=bold cterm=underline ctermfg=Yellow", "CursorLineNr term=bold cterm=underline ctermfg=Yellow gui=bold guifg=Yellow"), CENT("MoreMsg term=bold ctermfg=LightGreen", "MoreMsg term=bold ctermfg=LightGreen gui=bold guifg=SeaGreen"), CENT("Question term=standout ctermfg=LightGreen", "Question term=standout ctermfg=LightGreen gui=bold guifg=Green"), CENT("Search term=reverse ctermbg=Yellow ctermfg=Black", "Search term=reverse ctermbg=Yellow ctermfg=Black guibg=Yellow guifg=Black"), CENT("SpecialKey term=bold ctermfg=LightBlue", "SpecialKey term=bold ctermfg=LightBlue guifg=Cyan"), #ifdef FEAT_SPELL CENT("SpellBad term=reverse ctermbg=Red", "SpellBad term=reverse ctermbg=Red guisp=Red gui=undercurl"), CENT("SpellCap term=reverse ctermbg=Blue", "SpellCap term=reverse ctermbg=Blue guisp=Blue gui=undercurl"), CENT("SpellRare term=reverse ctermbg=Magenta", "SpellRare term=reverse ctermbg=Magenta guisp=Magenta gui=undercurl"), CENT("SpellLocal term=underline ctermbg=Cyan", "SpellLocal term=underline ctermbg=Cyan guisp=Cyan gui=undercurl"), #endif CENT("PmenuThumb ctermbg=White", "PmenuThumb ctermbg=White guibg=White"), CENT("Pmenu ctermbg=Magenta ctermfg=Black", "Pmenu ctermbg=Magenta ctermfg=Black guibg=Magenta"), CENT("PmenuSel ctermbg=Black ctermfg=DarkGrey", "PmenuSel ctermbg=Black ctermfg=DarkGrey guibg=DarkGrey"), CENT("Title term=bold ctermfg=LightMagenta", "Title term=bold ctermfg=LightMagenta gui=bold guifg=Magenta"), CENT("WarningMsg term=standout ctermfg=LightRed", "WarningMsg term=standout ctermfg=LightRed guifg=Red"), CENT("WildMenu term=standout ctermbg=Yellow ctermfg=Black", "WildMenu term=standout ctermbg=Yellow ctermfg=Black guibg=Yellow guifg=Black"), #ifdef FEAT_FOLDING CENT("Folded term=standout ctermbg=DarkGrey ctermfg=Cyan", "Folded term=standout ctermbg=DarkGrey ctermfg=Cyan guibg=DarkGrey guifg=Cyan"), CENT("FoldColumn term=standout ctermbg=DarkGrey ctermfg=Cyan", "FoldColumn term=standout ctermbg=DarkGrey ctermfg=Cyan guibg=Grey guifg=Cyan"), #endif #ifdef FEAT_SIGNS CENT("SignColumn term=standout ctermbg=DarkGrey ctermfg=Cyan", "SignColumn term=standout ctermbg=DarkGrey ctermfg=Cyan guibg=Grey guifg=Cyan"), #endif CENT("Visual ctermbg=Grey ctermfg=Black", "Visual ctermbg=Grey ctermfg=Black guibg=#575757 guifg=LightGrey"), #ifdef FEAT_DIFF CENT("DiffAdd term=bold ctermbg=DarkBlue", "DiffAdd term=bold ctermbg=DarkBlue guibg=DarkBlue"), CENT("DiffChange term=bold ctermbg=DarkMagenta", "DiffChange term=bold ctermbg=DarkMagenta guibg=DarkMagenta"), CENT("DiffDelete term=bold ctermfg=Blue ctermbg=DarkCyan", "DiffDelete term=bold ctermfg=Blue ctermbg=DarkCyan gui=bold guifg=Blue guibg=DarkCyan"), #endif CENT("TabLine term=underline cterm=underline ctermfg=white ctermbg=DarkGrey", "TabLine term=underline cterm=underline ctermfg=white ctermbg=DarkGrey gui=underline guibg=DarkGrey"), #ifdef FEAT_SYN_HL CENT("CursorColumn term=reverse ctermbg=DarkGrey", "CursorColumn term=reverse ctermbg=DarkGrey guibg=Grey40"), CENT("CursorLine term=underline cterm=underline", "CursorLine term=underline cterm=underline guibg=Grey40"), CENT("ColorColumn term=reverse ctermbg=DarkRed", "ColorColumn term=reverse ctermbg=DarkRed guibg=DarkRed"), #endif CENT("MatchParen term=reverse ctermbg=DarkCyan", "MatchParen term=reverse ctermbg=DarkCyan guibg=DarkCyan"), #ifdef FEAT_CONCEAL CENT("Conceal ctermbg=DarkGrey ctermfg=LightGrey", "Conceal ctermbg=DarkGrey ctermfg=LightGrey guibg=DarkGrey guifg=LightGrey"), #endif #ifdef FEAT_TERMINAL CENT("StatusLineTerm term=reverse,bold cterm=bold ctermfg=Black ctermbg=LightGreen", "StatusLineTerm term=reverse,bold cterm=bold ctermfg=Black ctermbg=LightGreen gui=bold guifg=bg guibg=LightGreen"), CENT("StatusLineTermNC term=reverse ctermfg=Black ctermbg=LightGreen", "StatusLineTermNC term=reverse ctermfg=Black ctermbg=LightGreen guifg=bg guibg=LightGreen"), #endif #ifdef FEAT_MENU CENT("ToolbarLine term=underline ctermbg=DarkGrey", "ToolbarLine term=underline ctermbg=DarkGrey guibg=Grey50"), CENT("ToolbarButton cterm=bold ctermfg=Black ctermbg=LightGrey", "ToolbarButton cterm=bold ctermfg=Black ctermbg=LightGrey gui=bold guifg=Black guibg=LightGrey"), #endif NULL }; #if defined(FEAT_SYN_HL) || defined(PROTO) /* * Returns the number of highlight groups. */ int highlight_num_groups(void) { return highlight_ga.ga_len; } /* * Returns the name of a highlight group. */ char_u * highlight_group_name(int id) { return HL_TABLE()[id].sg_name; } /* * Returns the ID of the link to a highlight group. */ int highlight_link_id(int id) { return HL_TABLE()[id].sg_link; } #endif void init_highlight( int both, // include groups where 'bg' doesn't matter int reset) // clear group first { int i; char **pp; static int had_both = FALSE; #ifdef FEAT_EVAL char_u *p; // Try finding the color scheme file. Used when a color file was loaded // and 'background' or 't_Co' is changed. p = get_var_value((char_u *)"g:colors_name"); if (p != NULL) { // The value of g:colors_name could be freed when sourcing the script, // making "p" invalid, so copy it. char_u *copy_p = vim_strsave(p); int r; if (copy_p != NULL) { r = load_colors(copy_p); vim_free(copy_p); if (r == OK) return; } } #endif // Didn't use a color file, use the compiled-in colors. if (both) { had_both = TRUE; pp = highlight_init_both; for (i = 0; pp[i] != NULL; ++i) do_highlight((char_u *)pp[i], reset, TRUE); } else if (!had_both) // Don't do anything before the call with both == TRUE from main(). // Not everything has been setup then, and that call will overrule // everything anyway. return; if (*p_bg == 'l') pp = highlight_init_light; else pp = highlight_init_dark; for (i = 0; pp[i] != NULL; ++i) do_highlight((char_u *)pp[i], reset, TRUE); // Reverse looks ugly, but grey may not work for less than 8 colors. Thus // let it depend on the number of colors available. if (t_colors < 8) do_highlight((char_u *)"Visual term=reverse cterm=reverse ctermbg=NONE ctermfg=NONE", FALSE, TRUE); // With 8 colors brown is equal to yellow, need to use black for Search fg // to avoid Statement highlighted text disappears. // Clear the attributes, needed when changing the t_Co value. if (t_colors <= 8) { if (*p_bg == 'l') do_highlight((char_u *)"Search ctermfg=black", FALSE, TRUE); } #ifdef FEAT_SYN_HL // If syntax highlighting is enabled load the highlighting for it. if (get_var_value((char_u *)"g:syntax_on") != NULL) { static int recursive = 0; if (recursive >= 5) emsg(_(e_recursive_loop_loading_syncolor_vim)); else { ++recursive; (void)source_runtime((char_u *)"syntax/syncolor.vim", DIP_ALL); --recursive; } } #endif } #if defined(FEAT_EVAL) && (defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)) /* * Load a default color list. Intended to support legacy color names but allows * the user to override the color values. Only loaded once. */ static void load_default_colors_lists(void) { // Lacking a default color list isn't the end of the world but it is likely // an inconvenience so users should know when it is missing. if (source_runtime((char_u *)"colors/lists/default.vim", DIP_ALL) != OK) msg("failed to load colors/lists/default.vim"); } #endif /* * Load color file "name". * Return OK for success, FAIL for failure. */ int load_colors(char_u *name) { char_u *buf; int retval = FAIL; static int recursive = FALSE; // When being called recursively, this is probably because setting // 'background' caused the highlighting to be reloaded. This means it is // working, thus we should return OK. if (recursive) return OK; recursive = TRUE; buf = alloc(STRLEN(name) + 12); if (buf != NULL) { #if defined(FEAT_EVAL) && (defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)) load_default_colors_lists(); #endif apply_autocmds(EVENT_COLORSCHEMEPRE, name, curbuf->b_fname, FALSE, curbuf); sprintf((char *)buf, "colors/%s.vim", name); retval = source_runtime(buf, DIP_START + DIP_OPT); vim_free(buf); if (retval == OK) apply_autocmds(EVENT_COLORSCHEME, name, curbuf->b_fname, FALSE, curbuf); } recursive = FALSE; return retval; } static int color_numbers_16[28] = {0, 1, 2, 3, 4, 5, 6, 6, 7, 7, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, -1}; // for xterm with 88 colors... static int color_numbers_88[28] = {0, 4, 2, 6, 1, 5, 32, 72, 84, 84, 7, 7, 82, 82, 12, 43, 10, 61, 14, 63, 9, 74, 13, 75, 11, 78, 15, -1}; // for xterm with 256 colors... static int color_numbers_256[28] = {0, 4, 2, 6, 1, 5, 130, 3, 248, 248, 7, 7, 242, 242, 12, 81, 10, 121, 14, 159, 9, 224, 13, 225, 11, 229, 15, -1}; // for terminals with less than 16 colors... static int color_numbers_8[28] = {0, 4, 2, 6, 1, 5, 3, 3, 7, 7, 7, 7, 0+8, 0+8, 4+8, 4+8, 2+8, 2+8, 6+8, 6+8, 1+8, 1+8, 5+8, 5+8, 3+8, 3+8, 7+8, -1}; /* * Lookup the "cterm" value to be used for color with index "idx" in * color_name_tab[]. * "boldp" will be set to TRUE or FALSE for a foreground color when using 8 * colors, otherwise it will be unchanged. */ static int lookup_color(int idx, int foreground, int *boldp) { int color = color_numbers_16[idx]; char_u *p; // Use the _16 table to check if it's a valid color name. if (color < 0) return -1; if (t_colors == 8) { // t_Co is 8: use the 8 colors table #if defined(__QNXNTO__) // On qnx, the 8 & 16 color arrays are the same if (STRNCMP(T_NAME, "qansi", 5) == 0) color = color_numbers_16[idx]; else #endif color = color_numbers_8[idx]; if (foreground) { // set/reset bold attribute to get light foreground // colors (on some terminals, e.g. "linux") if (color & 8) *boldp = TRUE; else *boldp = FALSE; } color &= 7; // truncate to 8 colors } else if (t_colors == 16 || t_colors == 88 || t_colors >= 256) { // Guess: if the termcap entry ends in 'm', it is // probably an xterm-like terminal. Use the changed // order for colors. if (*T_CAF != NUL) p = T_CAF; else p = T_CSF; if (*p != NUL && (t_colors > 256 || *(p + STRLEN(p) - 1) == 'm')) { if (t_colors == 88) color = color_numbers_88[idx]; else if (t_colors >= 256) color = color_numbers_256[idx]; else color = color_numbers_8[idx]; } #ifdef FEAT_TERMRESPONSE if (t_colors >= 256 && color == 15 && is_mac_terminal) // Terminal.app has a bug: 15 is light grey. Use white // from the color cube instead. color = 231; #endif } return color; } /* * Link highlight group 'from_hg' to 'to_hg'. * 'dodefault' is set to TRUE for ":highlight default link". * 'forceit' is set to TRUE for ":highlight! link" * 'init' is set to TRUE when initializing all the highlight groups. */ static void highlight_group_link( char_u *from_hg, int from_len, char_u *to_hg, int to_len, int dodefault, int forceit, int init) { int from_id; int to_id; hl_group_T *hlgroup = NULL; from_id = syn_check_group(from_hg, from_len); if (STRNCMP(to_hg, "NONE", 4) == 0) to_id = 0; else to_id = syn_check_group(to_hg, to_len); if (from_id > 0) { hlgroup = &HL_TABLE()[from_id - 1]; if (dodefault && (forceit || hlgroup->sg_deflink == 0)) { hlgroup->sg_deflink = to_id; #ifdef FEAT_EVAL hlgroup->sg_deflink_sctx = current_sctx; hlgroup->sg_deflink_sctx.sc_lnum += SOURCING_LNUM; #endif } } if (from_id > 0 && (!init || hlgroup->sg_set == 0)) { // Don't allow a link when there already is some highlighting // for the group, unless '!' is used if (to_id > 0 && !forceit && !init && hl_has_settings(from_id - 1, dodefault)) { if (SOURCING_NAME == NULL && !dodefault) emsg(_(e_group_has_settings_highlight_link_ignored)); } else if (hlgroup->sg_link != to_id #ifdef FEAT_EVAL || hlgroup->sg_script_ctx.sc_sid != current_sctx.sc_sid #endif || hlgroup->sg_cleared) { if (!init) hlgroup->sg_set |= SG_LINK; hlgroup->sg_link = to_id; #ifdef FEAT_EVAL hlgroup->sg_script_ctx = current_sctx; hlgroup->sg_script_ctx.sc_lnum += SOURCING_LNUM; #endif hlgroup->sg_cleared = FALSE; redraw_all_later(UPD_SOME_VALID); // Only call highlight_changed() once after multiple changes. need_highlight_changed = TRUE; } } } /* * Reset all highlighting to the defaults. Removes all highlighting for the * groups added by the user. */ static void highlight_reset_all(void) { int idx; #ifdef FEAT_GUI // First, we do not destroy the old values, but allocate the new // ones and update the display. THEN we destroy the old values. // If we destroy the old values first, then the old values // (such as GuiFont's or GuiFontset's) will still be displayed but // invalid because they were free'd. if (gui.in_use) { # ifdef FEAT_BEVAL_TIP gui_init_tooltip_font(); # endif # if defined(FEAT_MENU) && defined(FEAT_GUI_MOTIF) gui_init_menu_font(); # endif } # if defined(FEAT_GUI_MSWIN) || defined(FEAT_GUI_X11) gui_mch_def_colors(); # endif # ifdef FEAT_GUI_X11 # ifdef FEAT_MENU // This only needs to be done when there is no Menu highlight // group defined by default, which IS currently the case. gui_mch_new_menu_colors(); # endif if (gui.in_use) { gui_new_scrollbar_colors(); # ifdef FEAT_BEVAL_GUI gui_mch_new_tooltip_colors(); # endif # ifdef FEAT_MENU gui_mch_new_menu_font(); # endif } # endif // Ok, we're done allocating the new default graphics items. // The screen should already be refreshed at this point. // It is now Ok to clear out the old data. #endif #ifdef FEAT_EVAL do_unlet((char_u *)"g:colors_name", TRUE); #endif restore_cterm_colors(); // Clear all default highlight groups and load the defaults. for (idx = 0; idx < highlight_ga.ga_len; ++idx) highlight_clear(idx); init_highlight(TRUE, TRUE); #if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) if (USE_24BIT) highlight_gui_started(); else #endif highlight_changed(); redraw_later_clear(); } /* * Set the 'term' or 'cterm' or 'gui' attributes for the highlight group at * index 'idx'. * 'key' is one of 'TERM' or 'CTERM' or 'GUI' * 'arg' is the list of attribute names separated by comma. * 'init' is set to TRUE when initializing all the highlight groups. * Returns TRUE if the attributes are set. */ static int highlight_set_termgui_attr(int idx, char_u *key, char_u *arg, int init) { int attr; size_t off; keyvalue_T target; keyvalue_T *entry; attr = 0; off = 0; target.key = 0; target.length = 0; // not used, see cmp_keyvalue_value_ni() while (arg[off] != NUL) { target.value = (char *)arg + off; entry = (keyvalue_T *)bsearch(&target, &highlight_tab, ARRAY_LENGTH(highlight_tab), sizeof(highlight_tab[0]), cmp_keyvalue_value_ni); if (entry == NULL) { semsg(_(e_illegal_value_str), arg); return FALSE; } attr |= entry->key; off += entry->length; if (arg[off] == ',') // another one follows ++off; } if (*key == 'T') { if (!init || !(HL_TABLE()[idx].sg_set & SG_TERM)) { if (!init) HL_TABLE()[idx].sg_set |= SG_TERM; HL_TABLE()[idx].sg_term = attr; } } else if (*key == 'C') { if (!init || !(HL_TABLE()[idx].sg_set & SG_CTERM)) { if (!init) HL_TABLE()[idx].sg_set |= SG_CTERM; HL_TABLE()[idx].sg_cterm = attr; HL_TABLE()[idx].sg_cterm_bold = FALSE; } } #if defined(FEAT_GUI) || defined(FEAT_EVAL) else { if (!init || !(HL_TABLE()[idx].sg_set & SG_GUI)) { if (!init) HL_TABLE()[idx].sg_set |= SG_GUI; HL_TABLE()[idx].sg_gui = attr; } } #endif return TRUE; } #ifdef FEAT_GUI /* * Set the font for the highlight group at 'idx'. * 'arg' is the font name. * Returns TRUE if the font is changed. */ static int highlight_set_font( int idx, char_u *arg, int is_normal_group, int is_menu_group, int is_tooltip_group) { int did_change = FALSE; // in non-GUI fonts are simply ignored if (HL_TABLE()[idx].sg_font_name != NULL && STRCMP(HL_TABLE()[idx].sg_font_name, arg) == 0) { // Font name didn't change, ignore. } else if (!gui.shell_created) { // GUI not started yet, always accept the name. vim_free(HL_TABLE()[idx].sg_font_name); HL_TABLE()[idx].sg_font_name = vim_strsave(arg); did_change = TRUE; } else { GuiFont temp_sg_font = HL_TABLE()[idx].sg_font; # ifdef FEAT_XFONTSET GuiFontset temp_sg_fontset = HL_TABLE()[idx].sg_fontset; # endif // First, save the current font/fontset. // Then try to allocate the font/fontset. // If the allocation fails, HL_TABLE()[idx].sg_font OR // sg_fontset will be set to NOFONT or NOFONTSET respectively. HL_TABLE()[idx].sg_font = NOFONT; # ifdef FEAT_XFONTSET HL_TABLE()[idx].sg_fontset = NOFONTSET; # endif hl_do_font(idx, arg, is_normal_group, is_menu_group, is_tooltip_group, FALSE); # ifdef FEAT_XFONTSET if (HL_TABLE()[idx].sg_fontset != NOFONTSET) { // New fontset was accepted. Free the old one, if there // was one. gui_mch_free_fontset(temp_sg_fontset); vim_free(HL_TABLE()[idx].sg_font_name); HL_TABLE()[idx].sg_font_name = vim_strsave(arg); did_change = TRUE; } else HL_TABLE()[idx].sg_fontset = temp_sg_fontset; # endif if (HL_TABLE()[idx].sg_font != NOFONT) { // New font was accepted. Free the old one, if there was // one. gui_mch_free_font(temp_sg_font); vim_free(HL_TABLE()[idx].sg_font_name); HL_TABLE()[idx].sg_font_name = vim_strsave(arg); did_change = TRUE; } else HL_TABLE()[idx].sg_font = temp_sg_font; } return did_change; } #endif /* * Set the cterm foreground color for the Normal highlight group to "color" and * the bold attribute to "bold". */ static void hl_set_ctermfg_normal_group(int color, int bold) { cterm_normal_fg_color = color + 1; cterm_normal_fg_bold = bold; #ifdef FEAT_GUI // Don't do this if the GUI is used. if (!gui.in_use && !gui.starting) #endif { set_must_redraw(UPD_CLEAR); if (termcap_active && color >= 0) term_fg_color(color); } } /* * Set the cterm foreground color for the highlight group at 'idx' to 'color'. */ static void highlight_set_ctermfg(int idx, int color, int is_normal_group) { HL_TABLE()[idx].sg_cterm_fg = color + 1; if (is_normal_group) hl_set_ctermfg_normal_group(color, (HL_TABLE()[idx].sg_cterm & HL_BOLD)); } /* * Set the cterm background color for the Normal highlight group to "color". */ static void hl_set_ctermbg_normal_group(int color) { cterm_normal_bg_color = color + 1; #ifdef FEAT_GUI // Don't mess with 'background' if the GUI is used. if (!gui.in_use && !gui.starting) #endif { set_must_redraw(UPD_CLEAR); if (color >= 0) { int dark = -1; if (termcap_active) term_bg_color(color); if (t_colors < 16) dark = (color == 0 || color == 4); // Limit the heuristic to the standard 16 colors else if (color < 16) dark = (color < 7 || color == 8); // Set the 'background' option if the value is // wrong. if (dark != -1 && dark != (*p_bg == 'd') && !option_was_set((char_u *)"bg")) { set_option_value_give_err((char_u *)"bg", 0L, (char_u *)(dark ? "dark" : "light"), 0); reset_option_was_set((char_u *)"bg"); } } } } /* * Set the cterm background color for the highlight group at 'idx' to 'color'. */ static void highlight_set_ctermbg(int idx, int color, int is_normal_group) { HL_TABLE()[idx].sg_cterm_bg = color + 1; if (is_normal_group) hl_set_ctermbg_normal_group(color); } /* * Set the cterm underline color for the Normal highlight group to "color". */ static void hl_set_ctermul_normal_group(int color) { cterm_normal_ul_color = color + 1; #ifdef FEAT_GUI // Don't do this if the GUI is used. if (!gui.in_use && !gui.starting) #endif { set_must_redraw(UPD_CLEAR); if (termcap_active && color >= 0) term_ul_color(color); } } /* * Set the cterm underline color for the highlight group at 'idx' to 'color'. */ static void highlight_set_ctermul(int idx, int color, int is_normal_group) { HL_TABLE()[idx].sg_cterm_ul = color + 1; if (is_normal_group) hl_set_ctermul_normal_group(color); } /* * Set the cterm font for the highlight group at 'idx'. * 'arg' is the color name or the numeric value as a string. * 'init' is set to TRUE when initializing highlighting. * Called for the ":highlight" command and the "hlset()" function. * * Returns TRUE if the font is set. */ static int highlight_set_cterm_font( int idx, char_u *arg, int init) { int font; if (init && (HL_TABLE()[idx].sg_set & SG_CTERM)) return FALSE; if (!init) HL_TABLE()[idx].sg_set |= SG_CTERM; if (VIM_ISDIGIT(*arg)) font = atoi((char *)arg); else if (STRICMP(arg, "NONE") == 0) font = -1; else return FALSE; HL_TABLE()[idx].sg_cterm_font = font + 1; return TRUE; } /* * Set the cterm fg/bg/ul color for the highlight group at 'idx'. * 'key' is one of 'CTERMFG' or 'CTERMBG' or 'CTERMUL'. * 'keystart' is the color name/value. * 'arg' is the color name or the numeric value as a string. * 'is_normal_group' is set if the highlight group is 'NORMAL' * 'init' is set to TRUE when initializing highlighting. * Called for the ":highlight" command and the "hlset()" function. * * Returns TRUE if the color is set. */ static int highlight_set_cterm_color( int idx, char_u *key, char_u *key_start, char_u *arg, int is_normal_group, int init) { int color; if (init && (HL_TABLE()[idx].sg_set & SG_CTERM)) return FALSE; if (!init) HL_TABLE()[idx].sg_set |= SG_CTERM; // When setting the foreground color, and previously the "bold" // flag was set for a light color, reset it now if (key[5] == 'F' && HL_TABLE()[idx].sg_cterm_bold) { HL_TABLE()[idx].sg_cterm &= ~HL_BOLD; HL_TABLE()[idx].sg_cterm_bold = FALSE; } if (VIM_ISDIGIT(*arg)) color = atoi((char *)arg); else if (STRICMP(arg, "fg") == 0) { if (cterm_normal_fg_color) color = cterm_normal_fg_color - 1; else { emsg(_(e_fg_color_unknown)); return FALSE; } } else if (STRICMP(arg, "bg") == 0) { if (cterm_normal_bg_color > 0) color = cterm_normal_bg_color - 1; else { emsg(_(e_bg_color_unknown)); return FALSE; } } else if (STRICMP(arg, "ul") == 0) { if (cterm_normal_ul_color > 0) color = cterm_normal_ul_color - 1; else { emsg(_(e_ul_color_unknown)); return FALSE; } } else { int bold = MAYBE; keyvalue_T target; keyvalue_T *entry; target.key = 0; target.value = (char *)arg; target.length = 0; // not used, see cmp_keyvalue_value_i() entry = (keyvalue_T *)bsearch(&target, &color_name_tab, ARRAY_LENGTH(color_name_tab), sizeof(color_name_tab[0]), cmp_keyvalue_value_i); if (entry == NULL) { semsg(_(e_color_name_or_number_not_recognized_str), key_start); return FALSE; } color = lookup_color(entry->key, key[5] == 'F', &bold); // set/reset bold attribute to get light foreground // colors (on some terminals, e.g. "linux") if (bold == TRUE) { HL_TABLE()[idx].sg_cterm |= HL_BOLD; HL_TABLE()[idx].sg_cterm_bold = TRUE; } else if (bold == FALSE) HL_TABLE()[idx].sg_cterm &= ~HL_BOLD; } // Add one to the argument, to avoid zero. Zero is used for // "NONE", then "color" is -1. if (key[5] == 'F') highlight_set_ctermfg(idx, color, is_normal_group); else if (key[5] == 'B') highlight_set_ctermbg(idx, color, is_normal_group); else // ctermul highlight_set_ctermul(idx, color, is_normal_group); return TRUE; } #if defined(FEAT_GUI) || defined(FEAT_EVAL) /* * Set the GUI foreground color for the highlight group at 'idx'. * Returns TRUE if the color is set. */ static int highlight_set_guifg( int idx, char_u *arg, int is_menu_group UNUSED, int is_scrollbar_group UNUSED, int is_tooltip_group UNUSED, int *do_colors UNUSED, int init) { # if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) long i; # endif char_u **namep; int did_change = FALSE; if (init && (HL_TABLE()[idx].sg_set & SG_GUI)) return FALSE; namep = &HL_TABLE()[idx].sg_gui_fg_name; if (!init) HL_TABLE()[idx].sg_set |= SG_GUI; # if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) // In GUI guifg colors are only used when recognized i = color_name2handle(arg); if (i != INVALCOLOR || STRCMP(arg, "NONE") == 0 || !USE_24BIT) { HL_TABLE()[idx].sg_gui_fg = i; # endif if (*namep == NULL || STRCMP(*namep, arg) != 0) { vim_free(*namep); if (STRCMP(arg, "NONE") != 0) *namep = vim_strsave(arg); else *namep = NULL; did_change = TRUE; } # if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) # ifdef FEAT_GUI_X11 if (is_menu_group && gui.menu_fg_pixel != i) { gui.menu_fg_pixel = i; *do_colors = TRUE; } if (is_scrollbar_group && gui.scroll_fg_pixel != i) { gui.scroll_fg_pixel = i; *do_colors = TRUE; } # ifdef FEAT_BEVAL_GUI if (is_tooltip_group && gui.tooltip_fg_pixel != i) { gui.tooltip_fg_pixel = i; *do_colors = TRUE; } # endif # endif } # endif return did_change; } /* * Set the GUI background color for the highlight group at 'idx'. * Returns TRUE if the color is set. */ static int highlight_set_guibg( int idx, char_u *arg, int is_menu_group UNUSED, int is_scrollbar_group UNUSED, int is_tooltip_group UNUSED, int *do_colors UNUSED, int init) { # if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) int i; # endif char_u **namep; int did_change = FALSE; if (init && (HL_TABLE()[idx].sg_set & SG_GUI)) return FALSE; namep = &HL_TABLE()[idx].sg_gui_bg_name; if (!init) HL_TABLE()[idx].sg_set |= SG_GUI; # if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) // In GUI guibg colors are only used when recognized i = color_name2handle(arg); if (i != INVALCOLOR || STRCMP(arg, "NONE") == 0 || !USE_24BIT) { HL_TABLE()[idx].sg_gui_bg = i; # endif if (*namep == NULL || STRCMP(*namep, arg) != 0) { vim_free(*namep); if (STRCMP(arg, "NONE") != 0) *namep = vim_strsave(arg); else *namep = NULL; did_change = TRUE; } # if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) # ifdef FEAT_GUI_X11 if (is_menu_group && gui.menu_bg_pixel != i) { gui.menu_bg_pixel = i; *do_colors = TRUE; } if (is_scrollbar_group && gui.scroll_bg_pixel != i) { gui.scroll_bg_pixel = i; *do_colors = TRUE; } # ifdef FEAT_BEVAL_GUI if (is_tooltip_group && gui.tooltip_bg_pixel != i) { gui.tooltip_bg_pixel = i; *do_colors = TRUE; } # endif # endif } # endif return did_change; } /* * Set the GUI undercurl/strikethrough color for the highlight group at 'idx'. * Returns TRUE if the color is set. */ static int highlight_set_guisp(int idx, char_u *arg, int init) { # if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) int i; # endif int did_change = FALSE; char_u **namep; if (init && (HL_TABLE()[idx].sg_set & SG_GUI)) return FALSE; namep = &HL_TABLE()[idx].sg_gui_sp_name; if (!init) HL_TABLE()[idx].sg_set |= SG_GUI; # if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) // In GUI guisp colors are only used when recognized i = color_name2handle(arg); if (i != INVALCOLOR || STRCMP(arg, "NONE") == 0 || !USE_24BIT) { HL_TABLE()[idx].sg_gui_sp = i; # endif if (*namep == NULL || STRCMP(*namep, arg) != 0) { vim_free(*namep); if (STRCMP(arg, "NONE") != 0) *namep = vim_strsave(arg); else *namep = NULL; did_change = TRUE; } # if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) } # endif return did_change; } #endif /* * Set the start/stop terminal codes for a highlight group. * Returns TRUE if the terminal code is set. */ static int highlight_set_startstop_termcode(int idx, char_u *key, char_u *arg, int init) { int off; char_u buf[100]; int len; char_u *tname; char_u *p; if (!init) HL_TABLE()[idx].sg_set |= SG_TERM; // The "start" and "stop" arguments can be a literal escape // sequence, or a comma separated list of terminal codes. if (STRNCMP(arg, "t_", 2) == 0) { off = 0; buf[0] = 0; while (arg[off] != NUL) { // Isolate one termcap name for (len = 0; arg[off + len] && arg[off + len] != ','; ++len) ; tname = vim_strnsave(arg + off, len); if (tname == NULL) // out of memory return FALSE; // lookup the escape sequence for the item p = get_term_code(tname); vim_free(tname); if (p == NULL) // ignore non-existing things p = (char_u *)""; // Append it to the already found stuff if ((int)(STRLEN(buf) + STRLEN(p)) >= 99) { semsg(_(e_terminal_code_too_long_str), arg); return FALSE; } STRCAT(buf, p); // Advance to the next item off += len; if (arg[off] == ',') // another one follows ++off; } } else { // Copy characters from arg[] to buf[], translating <> codes. for (p = arg, off = 0; off < 100 - 6 && *p; ) { len = trans_special(&p, buf + off, FSK_SIMPLIFY, FALSE, NULL); if (len > 0) // recognized special char off += len; else // copy as normal char buf[off++] = *p++; } buf[off] = NUL; } if (STRCMP(buf, "NONE") == 0) // resetting the value p = NULL; else p = vim_strsave(buf); if (key[2] == 'A') { vim_free(HL_TABLE()[idx].sg_start); HL_TABLE()[idx].sg_start = p; } else { vim_free(HL_TABLE()[idx].sg_stop); HL_TABLE()[idx].sg_stop = p; } return TRUE; } /* * Handle the ":highlight .." command. * When using ":hi clear" this is called recursively for each group with * "forceit" and "init" both TRUE. */ void do_highlight( char_u *line, int forceit, int init) // TRUE when called for initializing { char_u *name_end; char_u *linep; char_u *key_start; char_u *arg_start; char_u *key = NULL, *arg = NULL; long i; int id; int idx; hl_group_T item_before; int did_change = FALSE; int dodefault = FALSE; int doclear = FALSE; int dolink = FALSE; int error = FALSE; int is_normal_group = FALSE; // "Normal" group #ifdef FEAT_GUI_X11 int is_menu_group = FALSE; // "Menu" group int is_scrollbar_group = FALSE; // "Scrollbar" group int is_tooltip_group = FALSE; // "Tooltip" group #else # define is_menu_group 0 # define is_tooltip_group 0 # define is_scrollbar_group 0 #endif #if defined(FEAT_GUI) || defined(FEAT_EVAL) int do_colors = FALSE; // need to update colors? #endif #if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) int did_highlight_changed = FALSE; #endif // If no argument, list current highlighting. if (!init && ends_excmd2(line - 1, line)) { for (i = 1; i <= highlight_ga.ga_len && !got_int; ++i) // TODO: only call when the group has attributes set highlight_list_one((int)i); return; } // Isolate the name. name_end = skiptowhite(line); linep = skipwhite(name_end); // Check for "default" argument. if (STRNCMP(line, "default", name_end - line) == 0) { dodefault = TRUE; line = linep; name_end = skiptowhite(line); linep = skipwhite(name_end); } // Check for "clear" or "link" argument. if (STRNCMP(line, "clear", name_end - line) == 0) doclear = TRUE; if (STRNCMP(line, "link", name_end - line) == 0) dolink = TRUE; // ":highlight {group-name}": list highlighting for one group. if (!doclear && !dolink && ends_excmd2(line, linep)) { id = syn_namen2id(line, (int)(name_end - line)); if (id == 0) semsg(_(e_highlight_group_name_not_found_str), line); else highlight_list_one(id); return; } // Handle ":highlight link {from} {to}" command. if (dolink) { char_u *from_start = linep; char_u *from_end; int from_len; char_u *to_start; char_u *to_end; int to_len; from_end = skiptowhite(from_start); to_start = skipwhite(from_end); to_end = skiptowhite(to_start); if (ends_excmd2(line, from_start) || ends_excmd2(line, to_start)) { semsg(_(e_not_enough_arguments_highlight_link_str), from_start); return; } if (!ends_excmd2(line, skipwhite(to_end))) { semsg(_(e_too_many_arguments_highlight_link_str), from_start); return; } from_len = (int)(from_end - from_start); to_len = (int)(to_end - to_start); highlight_group_link(from_start, from_len, to_start, to_len, dodefault, forceit, init); return; } if (doclear) { // ":highlight clear [group]" command. if (ends_excmd2(line, linep)) { // ":highlight clear" without group name highlight_reset_all(); return; } line = linep; name_end = skiptowhite(line); linep = skipwhite(name_end); } // Find the group name in the table. If it does not exist yet, add it. id = syn_check_group(line, (int)(name_end - line)); if (id == 0) // failed (out of memory) return; idx = id - 1; // index is ID minus one // Return if "default" was used and the group already has settings. if (dodefault && hl_has_settings(idx, TRUE)) return; // Make a copy so we can check if any attribute actually changed. item_before = HL_TABLE()[idx]; if (STRCMP(HL_TABLE()[idx].sg_name_u, "NORMAL") == 0) is_normal_group = TRUE; #ifdef FEAT_GUI_X11 else if (STRCMP(HL_TABLE()[idx].sg_name_u, "MENU") == 0) is_menu_group = TRUE; else if (STRCMP(HL_TABLE()[idx].sg_name_u, "SCROLLBAR") == 0) is_scrollbar_group = TRUE; else if (STRCMP(HL_TABLE()[idx].sg_name_u, "TOOLTIP") == 0) is_tooltip_group = TRUE; #endif // Clear the highlighting for ":hi clear {group}" and ":hi clear". if (doclear || (forceit && init)) { highlight_clear(idx); if (!doclear) HL_TABLE()[idx].sg_set = 0; } if (!doclear) while (!ends_excmd2(line, linep)) { key_start = linep; if (*linep == '=') { semsg(_(e_unexpected_equal_sign_str), key_start); error = TRUE; break; } // Isolate the key ("term", "ctermfg", "ctermbg", "font", "guifg" // or "guibg"). while (*linep && !VIM_ISWHITE(*linep) && *linep != '=') ++linep; vim_free(key); key = vim_strnsave_up(key_start, linep - key_start); if (key == NULL) { error = TRUE; break; } linep = skipwhite(linep); if (STRCMP(key, "NONE") == 0) { if (!init || HL_TABLE()[idx].sg_set == 0) { if (!init) HL_TABLE()[idx].sg_set |= SG_TERM+SG_CTERM+SG_GUI; highlight_clear(idx); } continue; } // Check for the equal sign. if (*linep != '=') { semsg(_(e_missing_equal_sign_str_2), key_start); error = TRUE; break; } ++linep; // Isolate the argument. linep = skipwhite(linep); if (*linep == '\'') // guifg='color name' { arg_start = ++linep; linep = vim_strchr(linep, '\''); if (linep == NULL) { semsg(_(e_invalid_argument_str), key_start); error = TRUE; break; } } else { arg_start = linep; linep = skiptowhite(linep); } if (linep == arg_start) { semsg(_(e_missing_argument_str), key_start); error = TRUE; break; } vim_free(arg); arg = vim_strnsave(arg_start, linep - arg_start); if (arg == NULL) { error = TRUE; break; } if (*linep == '\'') ++linep; // Store the argument. if (STRCMP(key, "TERM") == 0 || STRCMP(key, "CTERM") == 0 || STRCMP(key, "GUI") == 0) { if (!highlight_set_termgui_attr(idx, key, arg, init)) { error = TRUE; break; } } else if (STRCMP(key, "FONT") == 0) { // in non-GUI fonts are simply ignored #ifdef FEAT_GUI if (highlight_set_font(idx, arg, is_normal_group, is_menu_group, is_tooltip_group)) did_change = TRUE; #endif } else if (STRCMP(key, "CTERMFG") == 0 || STRCMP(key, "CTERMBG") == 0 || STRCMP(key, "CTERMUL") == 0) { if (!highlight_set_cterm_color(idx, key, key_start, arg, is_normal_group, init)) { error = TRUE; break; } } else if (STRCMP(key, "CTERMFONT") == 0) { if (!highlight_set_cterm_font(idx, arg, init)) { error = TRUE; break; } } else if (STRCMP(key, "GUIFG") == 0) { #if defined(FEAT_GUI) || defined(FEAT_EVAL) if (highlight_set_guifg(idx, arg, is_menu_group, is_scrollbar_group, is_tooltip_group, &do_colors, init)) did_change = TRUE; #endif } else if (STRCMP(key, "GUIBG") == 0) { #if defined(FEAT_GUI) || defined(FEAT_EVAL) if (highlight_set_guibg(idx, arg, is_menu_group, is_scrollbar_group, is_tooltip_group, &do_colors, init)) did_change = TRUE; #endif } else if (STRCMP(key, "GUISP") == 0) { #if defined(FEAT_GUI) || defined(FEAT_EVAL) if (highlight_set_guisp(idx, arg, init)) did_change = TRUE; #endif } else if (STRCMP(key, "START") == 0 || STRCMP(key, "STOP") == 0) { if (!highlight_set_startstop_termcode(idx, key, arg, init)) { error = TRUE; break; } } else { semsg(_(e_illegal_argument_str_3), key_start); error = TRUE; break; } HL_TABLE()[idx].sg_cleared = FALSE; // When highlighting has been given for a group, don't link it. if (!init || !(HL_TABLE()[idx].sg_set & SG_LINK)) HL_TABLE()[idx].sg_link = 0; // Continue with next argument. linep = skipwhite(linep); } // If there is an error, and it's a new entry, remove it from the table. if (error && idx == highlight_ga.ga_len) syn_unadd_group(); else { if (is_normal_group) { HL_TABLE()[idx].sg_term_attr = 0; HL_TABLE()[idx].sg_cterm_attr = 0; #ifdef FEAT_GUI HL_TABLE()[idx].sg_gui_attr = 0; // Need to update all groups, because they might be using "bg" // and/or "fg", which have been changed now. #endif #if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) if (USE_24BIT) { highlight_gui_started(); did_highlight_changed = TRUE; redraw_all_later(UPD_NOT_VALID); } #endif #ifdef FEAT_VTP control_console_color_rgb(); #endif } #ifdef FEAT_GUI_X11 # ifdef FEAT_MENU else if (is_menu_group) { if (gui.in_use && do_colors) gui_mch_new_menu_colors(); } # endif else if (is_scrollbar_group) { if (gui.in_use && do_colors) gui_new_scrollbar_colors(); else set_hl_attr(idx); } # ifdef FEAT_BEVAL_GUI else if (is_tooltip_group) { if (gui.in_use && do_colors) gui_mch_new_tooltip_colors(); } # endif #endif else set_hl_attr(idx); #ifdef FEAT_EVAL HL_TABLE()[idx].sg_script_ctx = current_sctx; HL_TABLE()[idx].sg_script_ctx.sc_lnum += SOURCING_LNUM; #endif } vim_free(key); vim_free(arg); // Only call highlight_changed() once, after a sequence of highlight // commands, and only if an attribute actually changed. if ((did_change || memcmp(&HL_TABLE()[idx], &item_before, sizeof(item_before)) != 0) #if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) && !did_highlight_changed #endif ) { // Do not trigger a redraw when highlighting is changed while // redrawing. This may happen when evaluating 'statusline' changes the // StatusLine group. if (!updating_screen) redraw_all_later(UPD_NOT_VALID); need_highlight_changed = TRUE; } } #if defined(EXITFREE) || defined(PROTO) void free_highlight(void) { int i; for (i = 0; i < highlight_ga.ga_len; ++i) { highlight_clear(i); vim_free(HL_TABLE()[i].sg_name); vim_free(HL_TABLE()[i].sg_name_u); } ga_clear(&highlight_ga); } #endif /* * Reset the cterm colors to what they were before Vim was started, if * possible. Otherwise reset them to zero. */ void restore_cterm_colors(void) { #if defined(MSWIN) && !defined(FEAT_GUI_MSWIN) // Since t_me has been set, this probably means that the user // wants to use this as default colors. Need to reset default // background/foreground colors. mch_set_normal_colors(); #else # ifdef VIMDLL if (!gui.in_use) { mch_set_normal_colors(); return; } # endif cterm_normal_fg_color = 0; cterm_normal_fg_bold = 0; cterm_normal_bg_color = 0; # ifdef FEAT_TERMGUICOLORS cterm_normal_fg_gui_color = INVALCOLOR; cterm_normal_bg_gui_color = INVALCOLOR; cterm_normal_ul_gui_color = INVALCOLOR; # endif #endif } /* * Return TRUE if highlight group "idx" has any settings. * When "check_link" is TRUE also check for an existing link. */ static int hl_has_settings(int idx, int check_link) { return HL_TABLE()[idx].sg_cleared == 0 && ( HL_TABLE()[idx].sg_term_attr != 0 || HL_TABLE()[idx].sg_cterm_attr != 0 || HL_TABLE()[idx].sg_cterm_fg != 0 || HL_TABLE()[idx].sg_cterm_bg != 0 || HL_TABLE()[idx].sg_cterm_font != 0 #ifdef FEAT_GUI || HL_TABLE()[idx].sg_gui_attr != 0 || HL_TABLE()[idx].sg_gui_fg_name != NULL || HL_TABLE()[idx].sg_gui_bg_name != NULL || HL_TABLE()[idx].sg_gui_sp_name != NULL || HL_TABLE()[idx].sg_font_name != NULL #endif || (check_link && (HL_TABLE()[idx].sg_set & SG_LINK))); } /* * Clear highlighting for one group. */ static void highlight_clear(int idx) { HL_TABLE()[idx].sg_cleared = TRUE; HL_TABLE()[idx].sg_term = 0; VIM_CLEAR(HL_TABLE()[idx].sg_start); VIM_CLEAR(HL_TABLE()[idx].sg_stop); HL_TABLE()[idx].sg_term_attr = 0; HL_TABLE()[idx].sg_cterm = 0; HL_TABLE()[idx].sg_cterm_bold = FALSE; HL_TABLE()[idx].sg_cterm_fg = 0; HL_TABLE()[idx].sg_cterm_bg = 0; HL_TABLE()[idx].sg_cterm_attr = 0; HL_TABLE()[idx].sg_cterm_font = 0; #if defined(FEAT_GUI) || defined(FEAT_EVAL) HL_TABLE()[idx].sg_gui = 0; VIM_CLEAR(HL_TABLE()[idx].sg_gui_fg_name); VIM_CLEAR(HL_TABLE()[idx].sg_gui_bg_name); VIM_CLEAR(HL_TABLE()[idx].sg_gui_sp_name); #endif #if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) HL_TABLE()[idx].sg_gui_fg = INVALCOLOR; HL_TABLE()[idx].sg_gui_bg = INVALCOLOR; HL_TABLE()[idx].sg_gui_sp = INVALCOLOR; #endif #ifdef FEAT_GUI gui_mch_free_font(HL_TABLE()[idx].sg_font); HL_TABLE()[idx].sg_font = NOFONT; # ifdef FEAT_XFONTSET gui_mch_free_fontset(HL_TABLE()[idx].sg_fontset); HL_TABLE()[idx].sg_fontset = NOFONTSET; # endif VIM_CLEAR(HL_TABLE()[idx].sg_font_name); HL_TABLE()[idx].sg_gui_attr = 0; #endif // Restore default link and context if they exist. Otherwise clears. HL_TABLE()[idx].sg_link = HL_TABLE()[idx].sg_deflink; #ifdef FEAT_EVAL // Since we set the default link, set the location to where the default // link was set. HL_TABLE()[idx].sg_script_ctx = HL_TABLE()[idx].sg_deflink_sctx; #endif } #if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) || defined(PROTO) /* * Set the normal foreground and background colors according to the "Normal" * highlighting group. For X11 also set "Menu", "Scrollbar", and * "Tooltip" colors. */ void set_normal_colors(void) { # ifdef FEAT_GUI # ifdef FEAT_TERMGUICOLORS if (gui.in_use) # endif { if (set_group_colors((char_u *)"Normal", &gui.norm_pixel, &gui.back_pixel, FALSE, TRUE, FALSE)) { gui_mch_new_colors(); set_must_redraw(UPD_CLEAR); } # ifdef FEAT_GUI_X11 if (set_group_colors((char_u *)"Menu", &gui.menu_fg_pixel, &gui.menu_bg_pixel, TRUE, FALSE, FALSE)) { # ifdef FEAT_MENU gui_mch_new_menu_colors(); # endif set_must_redraw(UPD_CLEAR); } # ifdef FEAT_BEVAL_GUI if (set_group_colors((char_u *)"Tooltip", &gui.tooltip_fg_pixel, &gui.tooltip_bg_pixel, FALSE, FALSE, TRUE)) { # ifdef FEAT_TOOLBAR gui_mch_new_tooltip_colors(); # endif set_must_redraw(UPD_CLEAR); } # endif if (set_group_colors((char_u *)"Scrollbar", &gui.scroll_fg_pixel, &gui.scroll_bg_pixel, FALSE, FALSE, FALSE)) { gui_new_scrollbar_colors(); set_must_redraw(UPD_CLEAR); } # endif } # endif # ifdef FEAT_TERMGUICOLORS # ifdef FEAT_GUI else # endif { int idx; idx = syn_name2id((char_u *)"Normal") - 1; if (idx >= 0) { gui_do_one_color(idx, FALSE, FALSE); // If the normal fg or bg color changed a complete redraw is // required. if (cterm_normal_fg_gui_color != HL_TABLE()[idx].sg_gui_fg || cterm_normal_bg_gui_color != HL_TABLE()[idx].sg_gui_bg) { // if the GUI color is INVALCOLOR then we use the default cterm // color cterm_normal_fg_gui_color = HL_TABLE()[idx].sg_gui_fg; cterm_normal_bg_gui_color = HL_TABLE()[idx].sg_gui_bg; set_must_redraw(UPD_CLEAR); } } } # endif } #endif #if defined(FEAT_GUI) || defined(PROTO) /* * Set the colors for "Normal", "Menu", "Tooltip" or "Scrollbar". */ static int set_group_colors( char_u *name, guicolor_T *fgp, guicolor_T *bgp, int do_menu, int use_norm, int do_tooltip) { int idx; idx = syn_name2id(name) - 1; if (idx < 0) return FALSE; gui_do_one_color(idx, do_menu, do_tooltip); if (HL_TABLE()[idx].sg_gui_fg != INVALCOLOR) *fgp = HL_TABLE()[idx].sg_gui_fg; else if (use_norm) *fgp = gui.def_norm_pixel; if (HL_TABLE()[idx].sg_gui_bg != INVALCOLOR) *bgp = HL_TABLE()[idx].sg_gui_bg; else if (use_norm) *bgp = gui.def_back_pixel; return TRUE; } /* * Get the font of the "Normal" group. * Returns "" when it's not found or not set. */ char_u * hl_get_font_name(void) { int id; char_u *s; id = syn_name2id((char_u *)"Normal"); if (id > 0) { s = HL_TABLE()[id - 1].sg_font_name; if (s != NULL) return s; } return (char_u *)""; } /* * Set font for "Normal" group. Called by gui_mch_init_font() when a font has * actually chosen to be used. */ void hl_set_font_name(char_u *font_name) { int id; id = syn_name2id((char_u *)"Normal"); if (id <= 0) return; vim_free(HL_TABLE()[id - 1].sg_font_name); HL_TABLE()[id - 1].sg_font_name = vim_strsave(font_name); } /* * Set background color for "Normal" group. Called by gui_set_bg_color() * when the color is known. */ void hl_set_bg_color_name( char_u *name) // must have been allocated { int id; if (name == NULL) return; id = syn_name2id((char_u *)"Normal"); if (id <= 0) return; vim_free(HL_TABLE()[id - 1].sg_gui_bg_name); HL_TABLE()[id - 1].sg_gui_bg_name = name; } /* * Set foreground color for "Normal" group. Called by gui_set_fg_color() * when the color is known. */ void hl_set_fg_color_name( char_u *name) // must have been allocated { int id; if (name == NULL) return; id = syn_name2id((char_u *)"Normal"); if (id <= 0) return; vim_free(HL_TABLE()[id - 1].sg_gui_fg_name); HL_TABLE()[id - 1].sg_gui_fg_name = name; } /* * Return the handle for a font name. * Returns NOFONT when failed. */ static GuiFont font_name2handle(char_u *name) { if (STRCMP(name, "NONE") == 0) return NOFONT; return gui_mch_get_font(name, TRUE); } # ifdef FEAT_XFONTSET /* * Return the handle for a fontset name. * Returns NOFONTSET when failed. */ static GuiFontset fontset_name2handle(char_u *name, int fixed_width) { if (STRCMP(name, "NONE") == 0) return NOFONTSET; return gui_mch_get_fontset(name, TRUE, fixed_width); } # endif /* * Get the font or fontset for one highlight group. */ static void hl_do_font( int idx, char_u *arg, int do_normal, // set normal font int do_menu UNUSED, // set menu font int do_tooltip UNUSED, // set tooltip font int free_font) // free current font/fontset { # ifdef FEAT_XFONTSET // If 'guifontset' is not empty, first try using the name as a // fontset. If that doesn't work, use it as a font name. if (*p_guifontset != NUL # ifdef FONTSET_ALWAYS || do_menu # endif # ifdef FEAT_BEVAL_TIP // In Motif, the Tooltip highlight group is always a fontset || do_tooltip # endif ) { if (free_font) gui_mch_free_fontset(HL_TABLE()[idx].sg_fontset); HL_TABLE()[idx].sg_fontset = fontset_name2handle(arg, 0 # ifdef FONTSET_ALWAYS || do_menu # endif # ifdef FEAT_BEVAL_TIP || do_tooltip # endif ); } if (HL_TABLE()[idx].sg_fontset != NOFONTSET) { // If it worked and it's the Normal group, use it as the normal // fontset. Same for the Menu group. if (do_normal) gui_init_font(arg, TRUE); # if defined(FEAT_GUI_MOTIF) && defined(FEAT_MENU) if (do_menu) { # ifdef FONTSET_ALWAYS gui.menu_fontset = HL_TABLE()[idx].sg_fontset; # else // YIKES! This is a bug waiting to crash the program gui.menu_font = HL_TABLE()[idx].sg_fontset; # endif gui_mch_new_menu_font(); } # ifdef FEAT_BEVAL_GUI if (do_tooltip) { // The Athena widget set could not handle switching between // displaying a single font and a fontset. // If the XtNinternational resource is set to True at widget // creation, then a fontset is always used, otherwise an // XFontStruct is used. gui.tooltip_fontset = (XFontSet)HL_TABLE()[idx].sg_fontset; gui_mch_new_tooltip_font(); } # endif # endif } else # endif { if (free_font) gui_mch_free_font(HL_TABLE()[idx].sg_font); HL_TABLE()[idx].sg_font = font_name2handle(arg); // If it worked and it's the Normal group, use it as the // normal font. Same for the Menu group. if (HL_TABLE()[idx].sg_font != NOFONT) { if (do_normal) gui_init_font(arg, FALSE); #ifndef FONTSET_ALWAYS # if defined(FEAT_GUI_MOTIF) && defined(FEAT_MENU) if (do_menu) { gui.menu_font = HL_TABLE()[idx].sg_font; gui_mch_new_menu_font(); } # endif #endif } } } #endif // FEAT_GUI #if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) || defined(PROTO) /* * Return the handle for a color name. * Returns INVALCOLOR when failed. */ guicolor_T color_name2handle(char_u *name) { if (STRCMP(name, "NONE") == 0) return INVALCOLOR; if (STRICMP(name, "fg") == 0 || STRICMP(name, "foreground") == 0) { #if defined(FEAT_TERMGUICOLORS) && defined(FEAT_GUI) if (gui.in_use) #endif #ifdef FEAT_GUI return gui.norm_pixel; #endif #ifdef FEAT_TERMGUICOLORS if (cterm_normal_fg_gui_color != INVALCOLOR) return cterm_normal_fg_gui_color; // Guess that the foreground is black or white. return GUI_GET_COLOR((char_u *)(*p_bg == 'l' ? "black" : "white")); #endif } if (STRICMP(name, "bg") == 0 || STRICMP(name, "background") == 0) { #if defined(FEAT_TERMGUICOLORS) && defined(FEAT_GUI) if (gui.in_use) #endif #ifdef FEAT_GUI return gui.back_pixel; #endif #ifdef FEAT_TERMGUICOLORS if (cterm_normal_bg_gui_color != INVALCOLOR) return cterm_normal_bg_gui_color; // Guess that the background is white or black. return GUI_GET_COLOR((char_u *)(*p_bg == 'l' ? "white" : "black")); #endif } return GUI_GET_COLOR(name); } // On MS-Windows an RGB macro is available and it produces 0x00bbggrr color // values as used by the MS-Windows GDI api. It should be used only for // MS-Windows GDI builds. # if defined(RGB) && defined(MSWIN) && !defined(FEAT_GUI) # undef RGB # endif # ifndef RGB # define RGB(r, g, b) (((r)<<16) | ((g)<<8) | (b)) # endif # ifdef VIMDLL static guicolor_T gui_adjust_rgb(guicolor_T c) { if (gui.in_use) return c; else return ((c & 0xff) << 16) | (c & 0x00ff00) | ((c >> 16) & 0xff); } # else # define gui_adjust_rgb(c) (c) # endif static int hex_digit(int c) { if (SAFE_isdigit(c)) return c - '0'; c = TOLOWER_ASC(c); if (c >= 'a' && c <= 'f') return c - 'a' + 10; return 0x1ffffff; } static guicolor_T decode_hex_color(char_u *hex) { guicolor_T color; if (hex[0] != '#' || STRLEN(hex) != 7) return INVALCOLOR; // Name is in "#rrggbb" format color = RGB(((hex_digit(hex[1]) << 4) + hex_digit(hex[2])), ((hex_digit(hex[3]) << 4) + hex_digit(hex[4])), ((hex_digit(hex[5]) << 4) + hex_digit(hex[6]))); if (color > 0xffffff) return INVALCOLOR; return gui_adjust_rgb(color); } #ifdef FEAT_EVAL // Returns the color currently mapped to the given name or INVALCOLOR if no // such name exists in the color table. The convention is to use lowercase for // all keys in the v:colornames dictionary. The value can be either a string in // the form #rrggbb or a number, either of which is converted to a guicolor_T. static guicolor_T colorname2rgb(char_u *name) { dict_T *colornames_table = get_vim_var_dict(VV_COLORNAMES); char_u *lc_name; dictitem_T *colentry; char_u *colstr; varnumber_T colnum; lc_name = strlow_save(name); if (lc_name == NULL) return INVALCOLOR; colentry = dict_find(colornames_table, lc_name, -1); vim_free(lc_name); if (colentry == NULL) return INVALCOLOR; if (colentry->di_tv.v_type == VAR_STRING) { colstr = tv_get_string_strict(&colentry->di_tv); if ((STRLEN(colstr) == 7) && (*colstr == '#')) { return decode_hex_color(colstr); } else { semsg(_(e_bad_color_string_str), colstr); return INVALCOLOR; } } if (colentry->di_tv.v_type == VAR_NUMBER) { colnum = tv_get_number(&colentry->di_tv); return (guicolor_T)colnum; } return INVALCOLOR; } #endif guicolor_T gui_get_color_cmn(char_u *name) { guicolor_T color; // Only non X11 colors (not present in rgb.txt) and colors in // color_name_tab[], useful when $VIMRUNTIME is not found,. // must be sorted by the 'value' field because it is used by bsearch()! static keyvalue_T rgb_tab[] = { KEYVALUE_ENTRY(RGB(0x00, 0x00, 0x00), "black"), KEYVALUE_ENTRY(RGB(0x00, 0x00, 0xFF), "blue"), KEYVALUE_ENTRY(RGB(0xA5, 0x2A, 0x2A), "brown"), KEYVALUE_ENTRY(RGB(0x00, 0xFF, 0xFF), "cyan"), KEYVALUE_ENTRY(RGB(0x00, 0x00, 0x8B), "darkblue"), KEYVALUE_ENTRY(RGB(0x00, 0x8B, 0x8B), "darkcyan"), KEYVALUE_ENTRY(RGB(0xA9, 0xA9, 0xA9), "darkgray"), KEYVALUE_ENTRY(RGB(0x00, 0x64, 0x00), "darkgreen"), KEYVALUE_ENTRY(RGB(0xA9, 0xA9, 0xA9), "darkgrey"), KEYVALUE_ENTRY(RGB(0x8B, 0x00, 0x8B), "darkmagenta"), KEYVALUE_ENTRY(RGB(0x8B, 0x00, 0x00), "darkred"), KEYVALUE_ENTRY(RGB(0x8B, 0x8B, 0x00), "darkyellow"), // No X11 KEYVALUE_ENTRY(RGB(0xBE, 0xBE, 0xBE), "gray"), KEYVALUE_ENTRY(RGB(0x00, 0xFF, 0x00), "green"), KEYVALUE_ENTRY(RGB(0xBE, 0xBE, 0xBE), "grey"), KEYVALUE_ENTRY(RGB(0x66, 0x66, 0x66), "grey40"), KEYVALUE_ENTRY(RGB(0x7F, 0x7F, 0x7F), "grey50"), KEYVALUE_ENTRY(RGB(0xE5, 0xE5, 0xE5), "grey90"), KEYVALUE_ENTRY(RGB(0xAD, 0xD8, 0xE6), "lightblue"), KEYVALUE_ENTRY(RGB(0xE0, 0xFF, 0xFF), "lightcyan"), KEYVALUE_ENTRY(RGB(0xD3, 0xD3, 0xD3), "lightgray"), KEYVALUE_ENTRY(RGB(0x90, 0xEE, 0x90), "lightgreen"), KEYVALUE_ENTRY(RGB(0xD3, 0xD3, 0xD3), "lightgrey"), KEYVALUE_ENTRY(RGB(0xFF, 0x8B, 0xFF), "lightmagenta"), // No XX KEYVALUE_ENTRY(RGB(0xFF, 0x8B, 0x8B), "lightred"), // No XX KEYVALUE_ENTRY(RGB(0xFF, 0xFF, 0xE0), "lightyellow"), KEYVALUE_ENTRY(RGB(0xFF, 0x00, 0xFF), "magenta"), KEYVALUE_ENTRY(RGB(0xFF, 0x00, 0x00), "red"), KEYVALUE_ENTRY(RGB(0x2E, 0x8B, 0x57), "seagreen"), KEYVALUE_ENTRY(RGB(0xFF, 0xFF, 0xFF), "white"), KEYVALUE_ENTRY(RGB(0xFF, 0xFF, 0x00), "yellow") }; keyvalue_T target; keyvalue_T *entry; color = decode_hex_color(name); if (color != INVALCOLOR) return color; target.key = 0; target.value = (char *)name; target.length = 0; // not used, see cmp_keyvalue_value_i() entry = (keyvalue_T *)bsearch(&target, &rgb_tab, ARRAY_LENGTH(rgb_tab), sizeof(rgb_tab[0]), cmp_keyvalue_value_i); if (entry != NULL) return gui_adjust_rgb((guicolor_T)entry->key); #if defined(FEAT_EVAL) /* * Not a traditional color. Load additional color aliases and then consult the alias table. */ color = colorname2rgb(name); if (color == INVALCOLOR) { load_default_colors_lists(); color = colorname2rgb(name); } return color; #else return INVALCOLOR; #endif } guicolor_T gui_get_rgb_color_cmn(int r, int g, int b) { guicolor_T color = RGB(r, g, b); if (color > 0xffffff) return INVALCOLOR; return gui_adjust_rgb(color); } #endif /* * Table with the specifications for an attribute number. * Note that this table is used by ALL buffers. This is required because the * GUI can redraw at any time for any buffer. */ static garray_T term_attr_table = {0, 0, 0, 0, NULL}; #define TERM_ATTR_ENTRY(idx) ((attrentry_T *)term_attr_table.ga_data)[idx] static garray_T cterm_attr_table = {0, 0, 0, 0, NULL}; #define CTERM_ATTR_ENTRY(idx) ((attrentry_T *)cterm_attr_table.ga_data)[idx] #ifdef FEAT_GUI static garray_T gui_attr_table = {0, 0, 0, 0, NULL}; #define GUI_ATTR_ENTRY(idx) ((attrentry_T *)gui_attr_table.ga_data)[idx] #endif /* * Return the attr number for a set of colors and font. * Add a new entry to the term_attr_table, cterm_attr_table or gui_attr_table * if the combination is new. * Return 0 for error (no more room). */ static int get_attr_entry(garray_T *table, attrentry_T *aep) { int i; attrentry_T *taep; static int recursive = FALSE; // Init the table, in case it wasn't done yet. table->ga_itemsize = sizeof(attrentry_T); table->ga_growsize = 7; // Try to find an entry with the same specifications. for (i = 0; i < table->ga_len; ++i) { taep = &(((attrentry_T *)table->ga_data)[i]); if ( aep->ae_attr == taep->ae_attr && ( #ifdef FEAT_GUI (table == &gui_attr_table && (aep->ae_u.gui.fg_color == taep->ae_u.gui.fg_color && aep->ae_u.gui.bg_color == taep->ae_u.gui.bg_color && aep->ae_u.gui.sp_color == taep->ae_u.gui.sp_color && aep->ae_u.gui.font == taep->ae_u.gui.font # ifdef FEAT_XFONTSET && aep->ae_u.gui.fontset == taep->ae_u.gui.fontset # endif )) || #endif (table == &term_attr_table && (aep->ae_u.term.start == NULL) == (taep->ae_u.term.start == NULL) && (aep->ae_u.term.start == NULL || STRCMP(aep->ae_u.term.start, taep->ae_u.term.start) == 0) && (aep->ae_u.term.stop == NULL) == (taep->ae_u.term.stop == NULL) && (aep->ae_u.term.stop == NULL || STRCMP(aep->ae_u.term.stop, taep->ae_u.term.stop) == 0)) || (table == &cterm_attr_table && aep->ae_u.cterm.fg_color == taep->ae_u.cterm.fg_color && aep->ae_u.cterm.bg_color == taep->ae_u.cterm.bg_color && aep->ae_u.cterm.ul_color == taep->ae_u.cterm.ul_color && aep->ae_u.cterm.font == taep->ae_u.cterm.font #ifdef FEAT_TERMGUICOLORS && aep->ae_u.cterm.fg_rgb == taep->ae_u.cterm.fg_rgb && aep->ae_u.cterm.bg_rgb == taep->ae_u.cterm.bg_rgb && aep->ae_u.cterm.ul_rgb == taep->ae_u.cterm.ul_rgb #endif ))) return i + ATTR_OFF; } if (table->ga_len + ATTR_OFF > MAX_TYPENR) { // Running out of attribute entries! remove all attributes, and // compute new ones for all groups. // When called recursively, we are really out of numbers. if (recursive) { emsg(_(e_too_many_different_highlighting_attributes_in_use)); return 0; } recursive = TRUE; clear_hl_tables(); set_must_redraw(UPD_CLEAR); for (i = 0; i < highlight_ga.ga_len; ++i) set_hl_attr(i); recursive = FALSE; } // This is a new combination of colors and font, add an entry. if (ga_grow(table, 1) == FAIL) return 0; taep = &(((attrentry_T *)table->ga_data)[table->ga_len]); CLEAR_POINTER(taep); taep->ae_attr = aep->ae_attr; #ifdef FEAT_GUI if (table == &gui_attr_table) { taep->ae_u.gui.fg_color = aep->ae_u.gui.fg_color; taep->ae_u.gui.bg_color = aep->ae_u.gui.bg_color; taep->ae_u.gui.sp_color = aep->ae_u.gui.sp_color; taep->ae_u.gui.font = aep->ae_u.gui.font; # ifdef FEAT_XFONTSET taep->ae_u.gui.fontset = aep->ae_u.gui.fontset; # endif } #endif if (table == &term_attr_table) { if (aep->ae_u.term.start == NULL) taep->ae_u.term.start = NULL; else taep->ae_u.term.start = vim_strsave(aep->ae_u.term.start); if (aep->ae_u.term.stop == NULL) taep->ae_u.term.stop = NULL; else taep->ae_u.term.stop = vim_strsave(aep->ae_u.term.stop); } else if (table == &cterm_attr_table) { taep->ae_u.cterm.fg_color = aep->ae_u.cterm.fg_color; taep->ae_u.cterm.bg_color = aep->ae_u.cterm.bg_color; taep->ae_u.cterm.ul_color = aep->ae_u.cterm.ul_color; taep->ae_u.cterm.font = aep->ae_u.cterm.font; #ifdef FEAT_TERMGUICOLORS taep->ae_u.cterm.fg_rgb = aep->ae_u.cterm.fg_rgb; taep->ae_u.cterm.bg_rgb = aep->ae_u.cterm.bg_rgb; taep->ae_u.cterm.ul_rgb = aep->ae_u.cterm.ul_rgb; #endif } ++table->ga_len; return (table->ga_len - 1 + ATTR_OFF); } #if defined(FEAT_TERMINAL) || defined(PROTO) /* * Get an attribute index for a cterm entry. * Uses an existing entry when possible or adds one when needed. */ int get_cterm_attr_idx(int attr, int fg, int bg) { attrentry_T at_en; CLEAR_FIELD(at_en); #ifdef FEAT_TERMGUICOLORS at_en.ae_u.cterm.fg_rgb = INVALCOLOR; at_en.ae_u.cterm.bg_rgb = INVALCOLOR; at_en.ae_u.cterm.ul_rgb = INVALCOLOR; #endif at_en.ae_attr = attr; at_en.ae_u.cterm.fg_color = fg; at_en.ae_u.cterm.bg_color = bg; at_en.ae_u.cterm.ul_color = 0; at_en.ae_u.cterm.font = 0; return get_attr_entry(&cterm_attr_table, &at_en); } #endif #if (defined(FEAT_TERMINAL) && defined(FEAT_TERMGUICOLORS)) || defined(PROTO) /* * Get an attribute index for a 'termguicolors' entry. * Uses an existing entry when possible or adds one when needed. */ int get_tgc_attr_idx(int attr, guicolor_T fg, guicolor_T bg) { attrentry_T at_en; CLEAR_FIELD(at_en); at_en.ae_attr = attr; if (fg == INVALCOLOR && bg == INVALCOLOR) { // If both GUI colors are not set fall back to the cterm colors. Helps // if the GUI only has an attribute, such as undercurl. at_en.ae_u.cterm.fg_rgb = CTERMCOLOR; at_en.ae_u.cterm.bg_rgb = CTERMCOLOR; } else { at_en.ae_u.cterm.fg_rgb = fg; at_en.ae_u.cterm.bg_rgb = bg; } at_en.ae_u.cterm.ul_rgb = INVALCOLOR; return get_attr_entry(&cterm_attr_table, &at_en); } #endif #if (defined(FEAT_TERMINAL) && defined(FEAT_GUI)) || defined(PROTO) /* * Get an attribute index for a cterm entry. * Uses an existing entry when possible or adds one when needed. */ int get_gui_attr_idx(int attr, guicolor_T fg, guicolor_T bg) { attrentry_T at_en; CLEAR_FIELD(at_en); at_en.ae_attr = attr; at_en.ae_u.gui.fg_color = fg; at_en.ae_u.gui.bg_color = bg; return get_attr_entry(&gui_attr_table, &at_en); } #endif /* * Clear all highlight tables. */ void clear_hl_tables(void) { int i; attrentry_T *taep; #ifdef FEAT_GUI ga_clear(&gui_attr_table); #endif for (i = 0; i < term_attr_table.ga_len; ++i) { taep = &(((attrentry_T *)term_attr_table.ga_data)[i]); vim_free(taep->ae_u.term.start); vim_free(taep->ae_u.term.stop); } ga_clear(&term_attr_table); ga_clear(&cterm_attr_table); } /* * Combine special attributes (e.g., for spelling) with other attributes * (e.g., for syntax highlighting). * "prim_attr" overrules "char_attr". * This creates a new group when required. * Since we expect there to be few spelling mistakes we don't cache the * result. * Return the resulting attributes. */ int hl_combine_attr(int char_attr, int prim_attr) { attrentry_T *char_aep = NULL; attrentry_T *prim_aep; attrentry_T new_en; if (char_attr == 0) return prim_attr; if (char_attr <= HL_ALL && prim_attr <= HL_ALL) return ATTR_COMBINE(char_attr, prim_attr); #ifdef FEAT_GUI if (gui.in_use) { if (char_attr > HL_ALL) char_aep = syn_gui_attr2entry(char_attr); if (char_aep != NULL) new_en = *char_aep; else { CLEAR_FIELD(new_en); new_en.ae_u.gui.fg_color = INVALCOLOR; new_en.ae_u.gui.bg_color = INVALCOLOR; new_en.ae_u.gui.sp_color = INVALCOLOR; if (char_attr <= HL_ALL) new_en.ae_attr = char_attr; } if (prim_attr <= HL_ALL) new_en.ae_attr = ATTR_COMBINE(new_en.ae_attr, prim_attr); else { prim_aep = syn_gui_attr2entry(prim_attr); if (prim_aep != NULL) { new_en.ae_attr = ATTR_COMBINE(new_en.ae_attr, prim_aep->ae_attr); if (prim_aep->ae_u.gui.fg_color != INVALCOLOR) new_en.ae_u.gui.fg_color = prim_aep->ae_u.gui.fg_color; if (prim_aep->ae_u.gui.bg_color != INVALCOLOR) new_en.ae_u.gui.bg_color = prim_aep->ae_u.gui.bg_color; if (prim_aep->ae_u.gui.sp_color != INVALCOLOR) new_en.ae_u.gui.sp_color = prim_aep->ae_u.gui.sp_color; if (prim_aep->ae_u.gui.font != NOFONT) new_en.ae_u.gui.font = prim_aep->ae_u.gui.font; # ifdef FEAT_XFONTSET if (prim_aep->ae_u.gui.fontset != NOFONTSET) new_en.ae_u.gui.fontset = prim_aep->ae_u.gui.fontset; # endif } } return get_attr_entry(&gui_attr_table, &new_en); } #endif if (IS_CTERM) { if (char_attr > HL_ALL) char_aep = syn_cterm_attr2entry(char_attr); if (char_aep != NULL) new_en = *char_aep; else { CLEAR_FIELD(new_en); #ifdef FEAT_TERMGUICOLORS new_en.ae_u.cterm.bg_rgb = INVALCOLOR; new_en.ae_u.cterm.fg_rgb = INVALCOLOR; new_en.ae_u.cterm.ul_rgb = INVALCOLOR; #endif if (char_attr <= HL_ALL) new_en.ae_attr = char_attr; } if (prim_attr <= HL_ALL) new_en.ae_attr = ATTR_COMBINE(new_en.ae_attr, prim_attr); else { prim_aep = syn_cterm_attr2entry(prim_attr); if (prim_aep != NULL) { new_en.ae_attr = ATTR_COMBINE(new_en.ae_attr, prim_aep->ae_attr); if (prim_aep->ae_u.cterm.fg_color > 0) new_en.ae_u.cterm.fg_color = prim_aep->ae_u.cterm.fg_color; if (prim_aep->ae_u.cterm.bg_color > 0) new_en.ae_u.cterm.bg_color = prim_aep->ae_u.cterm.bg_color; if (prim_aep->ae_u.cterm.ul_color > 0) new_en.ae_u.cterm.ul_color = prim_aep->ae_u.cterm.ul_color; if (prim_aep->ae_u.cterm.font > 0) new_en.ae_u.cterm.font = prim_aep->ae_u.cterm.font; #ifdef FEAT_TERMGUICOLORS // If both fg and bg are not set fall back to cterm colors. // Helps for SpellBad which uses undercurl in the GUI. if (COLOR_INVALID(prim_aep->ae_u.cterm.fg_rgb) && COLOR_INVALID(prim_aep->ae_u.cterm.bg_rgb)) { if (prim_aep->ae_u.cterm.fg_color > 0) new_en.ae_u.cterm.fg_rgb = CTERMCOLOR; if (prim_aep->ae_u.cterm.bg_color > 0) new_en.ae_u.cterm.bg_rgb = CTERMCOLOR; } else { if (prim_aep->ae_u.cterm.fg_rgb != INVALCOLOR) new_en.ae_u.cterm.fg_rgb = prim_aep->ae_u.cterm.fg_rgb; if (prim_aep->ae_u.cterm.bg_rgb != INVALCOLOR) new_en.ae_u.cterm.bg_rgb = prim_aep->ae_u.cterm.bg_rgb; } if (prim_aep->ae_u.cterm.ul_rgb != INVALCOLOR) new_en.ae_u.cterm.ul_rgb = prim_aep->ae_u.cterm.ul_rgb; #endif } } return get_attr_entry(&cterm_attr_table, &new_en); } if (char_attr > HL_ALL) char_aep = syn_term_attr2entry(char_attr); if (char_aep != NULL) new_en = *char_aep; else { CLEAR_FIELD(new_en); if (char_attr <= HL_ALL) new_en.ae_attr = char_attr; } if (prim_attr <= HL_ALL) new_en.ae_attr = ATTR_COMBINE(new_en.ae_attr, prim_attr); else { prim_aep = syn_term_attr2entry(prim_attr); if (prim_aep != NULL) { new_en.ae_attr = ATTR_COMBINE(new_en.ae_attr, prim_aep->ae_attr); if (prim_aep->ae_u.term.start != NULL) { new_en.ae_u.term.start = prim_aep->ae_u.term.start; new_en.ae_u.term.stop = prim_aep->ae_u.term.stop; } } } return get_attr_entry(&term_attr_table, &new_en); } #ifdef FEAT_GUI attrentry_T * syn_gui_attr2entry(int attr) { attr -= ATTR_OFF; if (attr >= gui_attr_table.ga_len) // did ":syntax clear" return NULL; return &(GUI_ATTR_ENTRY(attr)); } #endif /* * Get the highlight attributes (HL_BOLD etc.) from an attribute nr. * Only to be used when "attr" > HL_ALL. */ int syn_attr2attr(int attr) { attrentry_T *aep; #ifdef FEAT_GUI if (gui.in_use) aep = syn_gui_attr2entry(attr); else #endif if (IS_CTERM) aep = syn_cterm_attr2entry(attr); else aep = syn_term_attr2entry(attr); if (aep == NULL) // highlighting not set return 0; return aep->ae_attr; } attrentry_T * syn_term_attr2entry(int attr) { attr -= ATTR_OFF; if (attr >= term_attr_table.ga_len) // did ":syntax clear" return NULL; return &(TERM_ATTR_ENTRY(attr)); } attrentry_T * syn_cterm_attr2entry(int attr) { attr -= ATTR_OFF; if (attr >= cterm_attr_table.ga_len) // did ":syntax clear" return NULL; return &(CTERM_ATTR_ENTRY(attr)); } #define LIST_ATTR 1 #define LIST_STRING 2 #define LIST_INT 3 static void highlight_list_one(int id) { hl_group_T *sgp; int didh = FALSE; sgp = &HL_TABLE()[id - 1]; // index is ID minus one if (message_filtered(sgp->sg_name)) return; didh = highlight_list_arg(id, didh, LIST_ATTR, sgp->sg_term, NULL, "term"); didh = highlight_list_arg(id, didh, LIST_STRING, 0, sgp->sg_start, "start"); didh = highlight_list_arg(id, didh, LIST_STRING, 0, sgp->sg_stop, "stop"); didh = highlight_list_arg(id, didh, LIST_ATTR, sgp->sg_cterm, NULL, "cterm"); didh = highlight_list_arg(id, didh, LIST_INT, sgp->sg_cterm_fg, NULL, "ctermfg"); didh = highlight_list_arg(id, didh, LIST_INT, sgp->sg_cterm_bg, NULL, "ctermbg"); didh = highlight_list_arg(id, didh, LIST_INT, sgp->sg_cterm_ul, NULL, "ctermul"); didh = highlight_list_arg(id, didh, LIST_INT, sgp->sg_cterm_font, NULL, "ctermfont"); #if defined(FEAT_GUI) || defined(FEAT_EVAL) didh = highlight_list_arg(id, didh, LIST_ATTR, sgp->sg_gui, NULL, "gui"); didh = highlight_list_arg(id, didh, LIST_STRING, 0, sgp->sg_gui_fg_name, "guifg"); didh = highlight_list_arg(id, didh, LIST_STRING, 0, sgp->sg_gui_bg_name, "guibg"); didh = highlight_list_arg(id, didh, LIST_STRING, 0, sgp->sg_gui_sp_name, "guisp"); #endif #ifdef FEAT_GUI didh = highlight_list_arg(id, didh, LIST_STRING, 0, sgp->sg_font_name, "font"); #endif if (sgp->sg_link && !got_int) { (void)syn_list_header(didh, 9999, id); didh = TRUE; msg_puts_attr("links to", HL_ATTR(HLF_D)); msg_putchar(' '); msg_outtrans(HL_TABLE()[HL_TABLE()[id - 1].sg_link - 1].sg_name); } if (!didh) highlight_list_arg(id, didh, LIST_STRING, 0, (char_u *)"cleared", ""); #ifdef FEAT_EVAL if (p_verbose > 0) last_set_msg(sgp->sg_script_ctx); #endif } static int highlight_list_arg( int id, int didh, int type, int iarg, char_u *sarg, char *name) { char_u buf[MAX_ATTR_LEN]; char_u *ts; int i; if (got_int) return FALSE; if (type == LIST_STRING ? (sarg == NULL) : (iarg == 0)) return didh; ts = buf; if (type == LIST_INT) sprintf((char *)buf, "%d", iarg - 1); else if (type == LIST_STRING) ts = sarg; else // type == LIST_ATTR { size_t buflen; buf[0] = NUL; buflen = 0; for (i = 0; i < (int)ARRAY_LENGTH(highlight_index_tab); ++i) { if (iarg & highlight_index_tab[i]->key) { if (buflen > 0) { STRCPY(buf + buflen, (char_u *)","); ++buflen; } STRCPY(buf + buflen, (char_u *)highlight_index_tab[i]->value); buflen += highlight_index_tab[i]->length; iarg &= ~highlight_index_tab[i]->key; // don't want "inverse"/"reverse" } } } (void)syn_list_header(didh, (int)(vim_strsize(ts) + STRLEN(name) + 1), id); didh = TRUE; if (!got_int) { if (*name != NUL) { msg_puts_attr(name, HL_ATTR(HLF_D)); msg_puts_attr("=", HL_ATTR(HLF_D)); } msg_outtrans(ts); } return didh; } #if (((defined(FEAT_EVAL) || defined(FEAT_PRINTER))) && defined(FEAT_SYN_HL)) || defined(PROTO) /* * Return "1" if highlight group "id" has attribute "flag". * Return NULL otherwise. */ char_u * highlight_has_attr( int id, int flag, int modec) // 'g' for GUI, 'c' for cterm, 't' for term { int attr; if (id <= 0 || id > highlight_ga.ga_len) return NULL; #if defined(FEAT_GUI) || defined(FEAT_EVAL) if (modec == 'g') attr = HL_TABLE()[id - 1].sg_gui; else #endif { if (modec == 'c') attr = HL_TABLE()[id - 1].sg_cterm; else attr = HL_TABLE()[id - 1].sg_term; } if (attr & flag) return (char_u *)"1"; return NULL; } #endif #if (defined(FEAT_SYN_HL) && defined(FEAT_EVAL)) || defined(PROTO) /* * Return color name of highlight group "id". */ char_u * highlight_color( int id, char_u *what, // "font", "fg", "bg", "sp", "ul", "fg#", "bg#" or "sp#" int modec) // 'g' for GUI, 'c' for cterm, 't' for term { static char_u name[20]; int n; int fg = FALSE; int sp = FALSE; int ul = FALSE; int font = FALSE; if (id <= 0 || id > highlight_ga.ga_len) return NULL; if (TOLOWER_ASC(what[0]) == 'f' && TOLOWER_ASC(what[1]) == 'g') fg = TRUE; else if (TOLOWER_ASC(what[0]) == 'f' && TOLOWER_ASC(what[1]) == 'o' && TOLOWER_ASC(what[2]) == 'n' && TOLOWER_ASC(what[3]) == 't') font = TRUE; else if (TOLOWER_ASC(what[0]) == 's' && TOLOWER_ASC(what[1]) == 'p') sp = TRUE; else if (TOLOWER_ASC(what[0]) == 'u' && TOLOWER_ASC(what[1]) == 'l') ul = TRUE; else if (!(TOLOWER_ASC(what[0]) == 'b' && TOLOWER_ASC(what[1]) == 'g')) return NULL; if (modec == 'g') { # if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) # ifdef FEAT_GUI // return font name if (font) return HL_TABLE()[id - 1].sg_font_name; # endif // return #RRGGBB form (only possible when GUI is running) if ((USE_24BIT) && what[2] == '#') { guicolor_T color; long_u rgb; static char_u buf[10]; if (fg) color = HL_TABLE()[id - 1].sg_gui_fg; else if (sp) color = HL_TABLE()[id - 1].sg_gui_sp; else color = HL_TABLE()[id - 1].sg_gui_bg; if (color == INVALCOLOR) return NULL; rgb = (long_u)GUI_MCH_GET_RGB(color); sprintf((char *)buf, "#%02x%02x%02x", (unsigned)(rgb >> 16), (unsigned)(rgb >> 8) & 255, (unsigned)rgb & 255); return buf; } # endif if (fg) return (HL_TABLE()[id - 1].sg_gui_fg_name); if (sp) return (HL_TABLE()[id - 1].sg_gui_sp_name); return (HL_TABLE()[id - 1].sg_gui_bg_name); } if (sp) return NULL; if (modec == 'c') { if (fg) n = HL_TABLE()[id - 1].sg_cterm_fg - 1; else if (ul) n = HL_TABLE()[id - 1].sg_cterm_ul - 1; else if (font) n = HL_TABLE()[id - 1].sg_cterm_font - 1; else n = HL_TABLE()[id - 1].sg_cterm_bg - 1; if (n < 0) return NULL; sprintf((char *)name, "%d", n); return name; } // term doesn't have color return NULL; } #endif #if (defined(FEAT_SYN_HL) \ && (defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)) \ && defined(FEAT_PRINTER)) || defined(PROTO) /* * Return color name of highlight group "id" as RGB value. */ long_u highlight_gui_color_rgb( int id, int fg) // TRUE = fg, FALSE = bg { guicolor_T color; if (id <= 0 || id > highlight_ga.ga_len) return 0L; if (fg) color = HL_TABLE()[id - 1].sg_gui_fg; else color = HL_TABLE()[id - 1].sg_gui_bg; if (color == INVALCOLOR) return 0L; return GUI_MCH_GET_RGB(color); } #endif /* * Output the syntax list header. * Return TRUE when started a new line. */ int syn_list_header( int did_header, // did header already int outlen, // length of string that comes int id) // highlight group id { int endcol = 19; int newline = TRUE; int name_col = 0; if (!did_header) { msg_putchar('\n'); if (got_int) return TRUE; msg_outtrans(HL_TABLE()[id - 1].sg_name); name_col = msg_col; endcol = 15; } else if (msg_col + outlen + 1 >= Columns) { msg_putchar('\n'); if (got_int) return TRUE; } else { if (msg_col >= endcol) // wrap around is like starting a new line newline = FALSE; } if (msg_col >= endcol) // output at least one space endcol = msg_col + 1; if (Columns <= endcol) // avoid hang for tiny window endcol = Columns - 1; msg_advance(endcol); // Show "xxx" with the attributes. if (!did_header) { if (endcol == Columns - 1 && endcol <= name_col) msg_putchar(' '); msg_puts_attr("xxx", syn_id2attr(id)); msg_putchar(' '); } return newline; } /* * Set the attribute numbers for a highlight group. * Called after one of the attributes has changed. */ static void set_hl_attr( int idx) // index in array { attrentry_T at_en; hl_group_T *sgp = HL_TABLE() + idx; // The "Normal" group doesn't need an attribute number if (sgp->sg_name_u != NULL && STRCMP(sgp->sg_name_u, "NORMAL") == 0) return; #ifdef FEAT_GUI // For the GUI mode: If there are other than "normal" highlighting // attributes, need to allocate an attr number. if (sgp->sg_gui_fg == INVALCOLOR && sgp->sg_gui_bg == INVALCOLOR && sgp->sg_gui_sp == INVALCOLOR && sgp->sg_font == NOFONT # ifdef FEAT_XFONTSET && sgp->sg_fontset == NOFONTSET # endif ) { sgp->sg_gui_attr = sgp->sg_gui; } else { at_en.ae_attr = sgp->sg_gui; at_en.ae_u.gui.fg_color = sgp->sg_gui_fg; at_en.ae_u.gui.bg_color = sgp->sg_gui_bg; at_en.ae_u.gui.sp_color = sgp->sg_gui_sp; at_en.ae_u.gui.font = sgp->sg_font; # ifdef FEAT_XFONTSET at_en.ae_u.gui.fontset = sgp->sg_fontset; # endif sgp->sg_gui_attr = get_attr_entry(&gui_attr_table, &at_en); } #endif // For the term mode: If there are other than "normal" highlighting // attributes, need to allocate an attr number. if (sgp->sg_start == NULL && sgp->sg_stop == NULL) sgp->sg_term_attr = sgp->sg_term; else { at_en.ae_attr = sgp->sg_term; at_en.ae_u.term.start = sgp->sg_start; at_en.ae_u.term.stop = sgp->sg_stop; sgp->sg_term_attr = get_attr_entry(&term_attr_table, &at_en); } // For the color term mode: If there are other than "normal" // highlighting attributes, need to allocate an attr number. if (sgp->sg_cterm_fg == 0 && sgp->sg_cterm_bg == 0 && sgp->sg_cterm_ul == 0 && sgp->sg_cterm_font == 0 # ifdef FEAT_TERMGUICOLORS && sgp->sg_gui_fg == INVALCOLOR && sgp->sg_gui_bg == INVALCOLOR && sgp->sg_gui_sp == INVALCOLOR # endif ) sgp->sg_cterm_attr = sgp->sg_cterm; else { at_en.ae_attr = sgp->sg_cterm; at_en.ae_u.cterm.fg_color = sgp->sg_cterm_fg; at_en.ae_u.cterm.bg_color = sgp->sg_cterm_bg; at_en.ae_u.cterm.ul_color = sgp->sg_cterm_ul; at_en.ae_u.cterm.font = sgp->sg_cterm_font; # ifdef FEAT_TERMGUICOLORS at_en.ae_u.cterm.fg_rgb = GUI_MCH_GET_RGB2(sgp->sg_gui_fg); at_en.ae_u.cterm.bg_rgb = GUI_MCH_GET_RGB2(sgp->sg_gui_bg); // Only use the underline/undercurl color when used, it may clear the // background color if not supported. if (sgp->sg_cterm & (HL_UNDERLINE | HL_UNDERCURL | HL_UNDERDOUBLE | HL_UNDERDOTTED | HL_UNDERDASHED)) at_en.ae_u.cterm.ul_rgb = GUI_MCH_GET_RGB2(sgp->sg_gui_sp); else at_en.ae_u.cterm.ul_rgb = INVALCOLOR; if (at_en.ae_u.cterm.fg_rgb == INVALCOLOR && at_en.ae_u.cterm.bg_rgb == INVALCOLOR) { // If both fg and bg are invalid fall back to the cterm colors. // Helps when the GUI only uses an attribute, e.g. undercurl. at_en.ae_u.cterm.fg_rgb = CTERMCOLOR; at_en.ae_u.cterm.bg_rgb = CTERMCOLOR; } # endif sgp->sg_cterm_attr = get_attr_entry(&cterm_attr_table, &at_en); } } /* * Lookup a highlight group name and return its ID. * If it is not found, 0 is returned. */ int syn_name2id(char_u *name) { int i; char_u name_u[MAX_SYN_NAME + 1]; // Avoid using stricmp() too much, it's slow on some systems // Avoid alloc()/free(), these are slow too. ID names over 200 chars // don't deserve to be found! vim_strncpy(name_u, name, MAX_SYN_NAME); vim_strup(name_u); for (i = highlight_ga.ga_len; --i >= 0; ) if (HL_TABLE()[i].sg_name_u != NULL && STRCMP(name_u, HL_TABLE()[i].sg_name_u) == 0) break; return i + 1; } /* * Lookup a highlight group name and return its attributes. * Return zero if not found. */ int syn_name2attr(char_u *name) { int id = syn_name2id(name); if (id != 0) return syn_id2attr(id); return 0; } #if defined(FEAT_EVAL) || defined(PROTO) /* * Return TRUE if highlight group "name" exists. */ int highlight_exists(char_u *name) { return (syn_name2id(name) > 0); } # if defined(FEAT_SEARCH_EXTRA) || defined(PROTO) /* * Return the name of highlight group "id". * When not a valid ID return an empty string. */ char_u * syn_id2name(int id) { if (id <= 0 || id > highlight_ga.ga_len) return (char_u *)""; return HL_TABLE()[id - 1].sg_name; } # endif #endif /* * Like syn_name2id(), but take a pointer + length argument. */ int syn_namen2id(char_u *linep, int len) { char_u *name; int id = 0; name = vim_strnsave(linep, len); if (name == NULL) return 0; id = syn_name2id(name); vim_free(name); return id; } /* * Find highlight group name in the table and return its ID. * The argument is a pointer to the name and the length of the name. * If it doesn't exist yet, a new entry is created. * Return 0 for failure. */ int syn_check_group(char_u *pp, int len) { int id; char_u *name; if (len > MAX_SYN_NAME) { emsg(_(e_highlight_group_name_too_long)); return 0; } name = vim_strnsave(pp, len); if (name == NULL) return 0; id = syn_name2id(name); if (id == 0) // doesn't exist yet id = syn_add_group(name); else vim_free(name); return id; } /* * Add new highlight group and return its ID. * "name" must be an allocated string, it will be consumed. * Return 0 for failure. */ static int syn_add_group(char_u *name) { char_u *p; char_u *name_up; // Check that the name is valid (ASCII letters, digits, underscores, dots, or hyphens). for (p = name; *p != NUL; ++p) { if (!vim_isprintc(*p)) { emsg(_(e_unprintable_character_in_group_name)); vim_free(name); return 0; } else if (!ASCII_ISALNUM(*p) && *p != '_' && *p != '.' && *p != '-') { // This is an error, but since there previously was no check only // give a warning. msg_source(HL_ATTR(HLF_W)); msg(_("W18: Invalid character in group name")); break; } } // First call for this growarray: init growing array. if (highlight_ga.ga_data == NULL) { highlight_ga.ga_itemsize = sizeof(hl_group_T); highlight_ga.ga_growsize = 10; } if (highlight_ga.ga_len >= MAX_HL_ID) { emsg(_(e_too_many_highlight_and_syntax_groups)); vim_free(name); return 0; } // Make room for at least one other syntax_highlight entry. if (ga_grow(&highlight_ga, 1) == FAIL) { vim_free(name); return 0; } name_up = vim_strsave_up(name); if (name_up == NULL) { vim_free(name); return 0; } CLEAR_POINTER(&(HL_TABLE()[highlight_ga.ga_len])); HL_TABLE()[highlight_ga.ga_len].sg_name = name; HL_TABLE()[highlight_ga.ga_len].sg_name_u = name_up; #if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) HL_TABLE()[highlight_ga.ga_len].sg_gui_bg = INVALCOLOR; HL_TABLE()[highlight_ga.ga_len].sg_gui_fg = INVALCOLOR; HL_TABLE()[highlight_ga.ga_len].sg_gui_sp = INVALCOLOR; #endif ++highlight_ga.ga_len; return highlight_ga.ga_len; // ID is index plus one } /* * When, just after calling syn_add_group(), an error is discovered, this * function deletes the new name. */ static void syn_unadd_group(void) { --highlight_ga.ga_len; vim_free(HL_TABLE()[highlight_ga.ga_len].sg_name); vim_free(HL_TABLE()[highlight_ga.ga_len].sg_name_u); } /* * Translate a group ID to highlight attributes. * "hl_id" must be valid: > 0, caller must check. */ int syn_id2attr(int hl_id) { int attr; hl_group_T *sgp; hl_id = syn_get_final_id(hl_id); sgp = &HL_TABLE()[hl_id - 1]; // index is ID minus one #ifdef FEAT_GUI // Only use GUI attr when the GUI is being used. if (gui.in_use) attr = sgp->sg_gui_attr; else #endif if (IS_CTERM) attr = sgp->sg_cterm_attr; else attr = sgp->sg_term_attr; return attr; } #if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) || defined(PROTO) /* * Get the GUI colors and attributes for a group ID. * NOTE: the colors will be INVALCOLOR when not set, the color otherwise. */ int syn_id2colors(int hl_id, guicolor_T *fgp, guicolor_T *bgp) { hl_group_T *sgp; hl_id = syn_get_final_id(hl_id); sgp = &HL_TABLE()[hl_id - 1]; // index is ID minus one *fgp = sgp->sg_gui_fg; *bgp = sgp->sg_gui_bg; return sgp->sg_gui; } #endif #if (defined(MSWIN) \ && (!defined(FEAT_GUI_MSWIN) || defined(VIMDLL)) \ && defined(FEAT_TERMGUICOLORS)) \ || defined(FEAT_TERMINAL) || defined(PROTO) void syn_id2cterm_bg(int hl_id, int *fgp, int *bgp) { hl_group_T *sgp; hl_id = syn_get_final_id(hl_id); sgp = &HL_TABLE()[hl_id - 1]; // index is ID minus one *fgp = sgp->sg_cterm_fg - 1; *bgp = sgp->sg_cterm_bg - 1; } #endif /* * Translate a group ID to the final group ID (following links). */ int syn_get_final_id(int hl_id) { int count; hl_group_T *sgp; if (hl_id > highlight_ga.ga_len || hl_id < 1) return 0; // Can be called from eval!! // Follow links until there is no more. // Look out for loops! Break after 100 links. for (count = 100; --count >= 0; ) { sgp = &HL_TABLE()[hl_id - 1]; // index is ID minus one if (sgp->sg_link == 0 || sgp->sg_link > highlight_ga.ga_len) break; hl_id = sgp->sg_link; } return hl_id; } #if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) || defined(PROTO) /* * Call this function just after the GUI has started. * Also called when 'termguicolors' was set, gui.in_use will be FALSE then. * It finds the font and color handles for the highlighting groups. */ void highlight_gui_started(void) { int idx; // First get the colors from the "Normal" and "Menu" group, if set if (USE_24BIT) set_normal_colors(); for (idx = 0; idx < highlight_ga.ga_len; ++idx) gui_do_one_color(idx, FALSE, FALSE); highlight_changed(); } static void gui_do_one_color( int idx, int do_menu UNUSED, // TRUE: might set the menu font int do_tooltip UNUSED) // TRUE: might set the tooltip font { int didit = FALSE; # ifdef FEAT_GUI # ifdef FEAT_TERMGUICOLORS if (gui.in_use) # endif if (HL_TABLE()[idx].sg_font_name != NULL) { hl_do_font(idx, HL_TABLE()[idx].sg_font_name, FALSE, do_menu, do_tooltip, TRUE); didit = TRUE; } # endif if (HL_TABLE()[idx].sg_gui_fg_name != NULL) { HL_TABLE()[idx].sg_gui_fg = color_name2handle(HL_TABLE()[idx].sg_gui_fg_name); didit = TRUE; } if (HL_TABLE()[idx].sg_gui_bg_name != NULL) { HL_TABLE()[idx].sg_gui_bg = color_name2handle(HL_TABLE()[idx].sg_gui_bg_name); didit = TRUE; } if (HL_TABLE()[idx].sg_gui_sp_name != NULL) { HL_TABLE()[idx].sg_gui_sp = color_name2handle(HL_TABLE()[idx].sg_gui_sp_name); didit = TRUE; } if (didit) // need to get a new attr number set_hl_attr(idx); } #endif #if defined(USER_HIGHLIGHT) && defined(FEAT_STL_OPT) /* * Apply difference between User[1-9] and HLF_S to HLF_SNC, HLF_ST or HLF_STNC. */ static void combine_stl_hlt( int id, int id_S, int id_alt, int hlcnt, int i, int hlf, int *table) { hl_group_T *hlt = HL_TABLE(); if (id_alt == 0) { CLEAR_POINTER(&hlt[hlcnt + i]); hlt[hlcnt + i].sg_term = highlight_attr[hlf]; hlt[hlcnt + i].sg_cterm = highlight_attr[hlf]; # if defined(FEAT_GUI) || defined(FEAT_EVAL) hlt[hlcnt + i].sg_gui = highlight_attr[hlf]; # endif } else mch_memmove(&hlt[hlcnt + i], &hlt[id_alt - 1], sizeof(hl_group_T)); hlt[hlcnt + i].sg_link = 0; hlt[hlcnt + i].sg_term ^= hlt[id - 1].sg_term ^ hlt[id_S - 1].sg_term; if (hlt[id - 1].sg_start != hlt[id_S - 1].sg_start) hlt[hlcnt + i].sg_start = hlt[id - 1].sg_start; if (hlt[id - 1].sg_stop != hlt[id_S - 1].sg_stop) hlt[hlcnt + i].sg_stop = hlt[id - 1].sg_stop; hlt[hlcnt + i].sg_cterm ^= hlt[id - 1].sg_cterm ^ hlt[id_S - 1].sg_cterm; if (hlt[id - 1].sg_cterm_fg != hlt[id_S - 1].sg_cterm_fg) hlt[hlcnt + i].sg_cterm_fg = hlt[id - 1].sg_cterm_fg; if (hlt[id - 1].sg_cterm_bg != hlt[id_S - 1].sg_cterm_bg) hlt[hlcnt + i].sg_cterm_bg = hlt[id - 1].sg_cterm_bg; if (hlt[id - 1].sg_cterm_font != hlt[id_S - 1].sg_cterm_font) hlt[hlcnt + i].sg_cterm_font = hlt[id - 1].sg_cterm_font; # if defined(FEAT_GUI) || defined(FEAT_EVAL) hlt[hlcnt + i].sg_gui ^= hlt[id - 1].sg_gui ^ hlt[id_S - 1].sg_gui; # endif # ifdef FEAT_GUI if (hlt[id - 1].sg_gui_fg != hlt[id_S - 1].sg_gui_fg) hlt[hlcnt + i].sg_gui_fg = hlt[id - 1].sg_gui_fg; if (hlt[id - 1].sg_gui_bg != hlt[id_S - 1].sg_gui_bg) hlt[hlcnt + i].sg_gui_bg = hlt[id - 1].sg_gui_bg; if (hlt[id - 1].sg_gui_sp != hlt[id_S - 1].sg_gui_sp) hlt[hlcnt + i].sg_gui_sp = hlt[id - 1].sg_gui_sp; if (hlt[id - 1].sg_font != hlt[id_S - 1].sg_font) hlt[hlcnt + i].sg_font = hlt[id - 1].sg_font; # ifdef FEAT_XFONTSET if (hlt[id - 1].sg_fontset != hlt[id_S - 1].sg_fontset) hlt[hlcnt + i].sg_fontset = hlt[id - 1].sg_fontset; # endif # endif highlight_ga.ga_len = hlcnt + i + 1; set_hl_attr(hlcnt + i); // At long last we can apply table[i] = syn_id2attr(hlcnt + i + 1); } #endif /* * Translate the 'highlight' option into attributes in highlight_attr[] and * set up the user highlights User1..9. If FEAT_STL_OPT is in use, a set of * corresponding highlights to use on top of HLF_SNC is computed. * Called only when the 'highlight' option has been changed and upon first * screen redraw after any :highlight command. * Return FAIL when an invalid flag is found in 'highlight'. OK otherwise. */ int highlight_changed(void) { int hlf; int i; char_u *p; int attr; char_u *end; int id; #ifdef USER_HIGHLIGHT char_u userhl[30]; // use 30 to avoid compiler warning # ifdef FEAT_STL_OPT int id_S = -1; int id_SNC = 0; # ifdef FEAT_TERMINAL int id_ST = 0; int id_STNC = 0; # endif int hlcnt; # endif #endif static int hl_flags[HLF_COUNT] = HL_FLAGS; need_highlight_changed = FALSE; #ifdef FEAT_TERMINAL term_update_colors_all(); term_update_wincolor_all(); #endif // Clear all attributes. for (hlf = 0; hlf < (int)HLF_COUNT; ++hlf) highlight_attr[hlf] = 0; // First set all attributes to their default value. // Then use the attributes from the 'highlight' option. for (i = 0; i < 2; ++i) { if (i) p = p_hl; else p = get_highlight_default(); if (p == NULL) // just in case continue; while (*p) { for (hlf = 0; hlf < (int)HLF_COUNT; ++hlf) if (hl_flags[hlf] == *p) break; ++p; if (hlf == (int)HLF_COUNT || *p == NUL) return FAIL; // Allow several hl_flags to be combined, like "bu" for // bold-underlined. attr = 0; for ( ; *p && *p != ','; ++p) // parse up to comma { if (VIM_ISWHITE(*p)) // ignore white space continue; if (attr > HL_ALL) // Combination with ':' is not allowed. return FAIL; // Note: Keep this in sync with expand_set_highlight(). switch (*p) { case 'b': attr |= HL_BOLD; break; case 'i': attr |= HL_ITALIC; break; case '-': case 'n': // no highlighting break; case 'r': attr |= HL_INVERSE; break; case 's': attr |= HL_STANDOUT; break; case 'u': attr |= HL_UNDERLINE; break; case 'c': attr |= HL_UNDERCURL; break; case '2': attr |= HL_UNDERDOUBLE; break; case 'd': attr |= HL_UNDERDOTTED; break; case '=': attr |= HL_UNDERDASHED; break; case 't': attr |= HL_STRIKETHROUGH; break; case ':': ++p; // highlight group name if (attr || *p == NUL) // no combinations return FAIL; end = vim_strchr(p, ','); if (end == NULL) end = p + STRLEN(p); id = syn_check_group(p, (int)(end - p)); if (id == 0) return FAIL; attr = syn_id2attr(id); p = end - 1; #if defined(FEAT_STL_OPT) && defined(USER_HIGHLIGHT) if (hlf == (int)HLF_SNC) id_SNC = syn_get_final_id(id); # ifdef FEAT_TERMINAL else if (hlf == (int)HLF_ST) id_ST = syn_get_final_id(id); else if (hlf == (int)HLF_STNC) id_STNC = syn_get_final_id(id); # endif else if (hlf == (int)HLF_S) id_S = syn_get_final_id(id); #endif break; default: return FAIL; } } highlight_attr[hlf] = attr; p = skip_to_option_part(p); // skip comma and spaces } } #ifdef USER_HIGHLIGHT // Setup the user highlights // // Temporarily utilize 28 more hl entries: // 9 for User1-User9 combined with StatusLineNC // 9 for User1-User9 combined with StatusLineTerm // 9 for User1-User9 combined with StatusLineTermNC // 1 for StatusLine default // Have to be in there simultaneously in case of table overflows in // get_attr_entry() # ifdef FEAT_STL_OPT if (ga_grow(&highlight_ga, 28) == FAIL) return FAIL; hlcnt = highlight_ga.ga_len; if (id_S == -1) { // Make sure id_S is always valid to simplify code below. Use the last // entry. CLEAR_POINTER(&HL_TABLE()[hlcnt + 27]); HL_TABLE()[hlcnt + 18].sg_term = highlight_attr[HLF_S]; id_S = hlcnt + 19; } # endif for (i = 0; i < 9; i++) { sprintf((char *)userhl, "User%d", i + 1); id = syn_name2id(userhl); if (id == 0) { highlight_user[i] = 0; # ifdef FEAT_STL_OPT highlight_stlnc[i] = 0; # ifdef FEAT_TERMINAL highlight_stlterm[i] = 0; highlight_stltermnc[i] = 0; # endif # endif } else { highlight_user[i] = syn_id2attr(id); # ifdef FEAT_STL_OPT combine_stl_hlt(id, id_S, id_SNC, hlcnt, i, HLF_SNC, highlight_stlnc); # ifdef FEAT_TERMINAL combine_stl_hlt(id, id_S, id_ST, hlcnt + 9, i, HLF_ST, highlight_stlterm); combine_stl_hlt(id, id_S, id_STNC, hlcnt + 18, i, HLF_STNC, highlight_stltermnc); # endif # endif } } # ifdef FEAT_STL_OPT highlight_ga.ga_len = hlcnt; # endif #endif // USER_HIGHLIGHT return OK; } static void highlight_list(void); static void highlight_list_two(int cnt, int attr); /* * Handle command line completion for :highlight command. */ void set_context_in_highlight_cmd(expand_T *xp, char_u *arg) { char_u *p; // Default: expand group names xp->xp_context = EXPAND_HIGHLIGHT; xp->xp_pattern = arg; include_link = 2; include_default = 1; if (*arg == NUL) return; // (part of) subcommand already typed p = skiptowhite(arg); if (*p == NUL) return; // past "default" or group name include_default = 0; if (STRNCMP("default", arg, p - arg) == 0) { arg = skipwhite(p); xp->xp_pattern = arg; p = skiptowhite(arg); } if (*p == NUL) return; // past group name include_link = 0; if (arg[1] == 'i' && arg[0] == 'N') highlight_list(); if (STRNCMP("link", arg, p - arg) == 0 || STRNCMP("clear", arg, p - arg) == 0) { xp->xp_pattern = skipwhite(p); p = skiptowhite(xp->xp_pattern); if (*p != NUL) // past first group name { xp->xp_pattern = skipwhite(p); p = skiptowhite(xp->xp_pattern); } } if (*p != NUL) // past group name(s) xp->xp_context = EXPAND_NOTHING; } /* * List highlighting matches in a nice way. */ static void highlight_list(void) { int i; for (i = 10; --i >= 0; ) highlight_list_two(i, HL_ATTR(HLF_D)); for (i = 40; --i >= 0; ) highlight_list_two(99, 0); } static void highlight_list_two(int cnt, int attr) { msg_puts_attr(&("N \bI \b! \b"[cnt / 11]), attr); msg_clr_eos(); out_flush(); ui_delay(cnt == 99 ? 40L : (long)cnt * 50L, FALSE); } /* * Function given to ExpandGeneric() to obtain the list of group names. */ char_u * get_highlight_name(expand_T *xp UNUSED, int idx) { return get_highlight_name_ext(xp, idx, TRUE); } /* * Obtain a highlight group name. * When "skip_cleared" is TRUE don't return a cleared entry. */ char_u * get_highlight_name_ext(expand_T *xp UNUSED, int idx, int skip_cleared) { if (idx < 0) return NULL; // Items are never removed from the table, skip the ones that were // cleared. if (skip_cleared && idx < highlight_ga.ga_len && HL_TABLE()[idx].sg_cleared) return (char_u *)""; if (idx == highlight_ga.ga_len && include_none != 0) return (char_u *)"none"; if (idx == highlight_ga.ga_len + include_none && include_default != 0) return (char_u *)"default"; if (idx == highlight_ga.ga_len + include_none + include_default && include_link != 0) return (char_u *)"link"; if (idx == highlight_ga.ga_len + include_none + include_default + 1 && include_link != 0) return (char_u *)"clear"; if (idx >= highlight_ga.ga_len) return NULL; return HL_TABLE()[idx].sg_name; } #if defined(FEAT_GUI) || defined(PROTO) /* * Free all the highlight group fonts. * Used when quitting for systems which need it. */ void free_highlight_fonts(void) { int idx; for (idx = 0; idx < highlight_ga.ga_len; ++idx) { gui_mch_free_font(HL_TABLE()[idx].sg_font); HL_TABLE()[idx].sg_font = NOFONT; # ifdef FEAT_XFONTSET gui_mch_free_fontset(HL_TABLE()[idx].sg_fontset); HL_TABLE()[idx].sg_fontset = NOFONTSET; # endif } gui_mch_free_font(gui.norm_font); # ifdef FEAT_XFONTSET gui_mch_free_fontset(gui.fontset); # endif # ifndef FEAT_GUI_GTK gui_mch_free_font(gui.bold_font); gui_mch_free_font(gui.ital_font); gui_mch_free_font(gui.boldital_font); # endif } #endif #if defined(FEAT_EVAL) || defined(PROTO) /* * Convert each of the highlight attribute bits (bold, standout, underline, * etc.) set in 'hlattr' into a separate boolean item in a Dictionary with * the attribute name as the key. */ static dict_T * highlight_get_attr_dict(int hlattr) { dict_T *dict; int i; dict = dict_alloc(); if (dict == NULL) return NULL; for (i = 0; i < (int)ARRAY_LENGTH(highlight_index_tab); ++i) { if (hlattr & highlight_index_tab[i]->key) { dict_add_bool(dict, highlight_index_tab[i]->value, VVAL_TRUE); hlattr &= ~highlight_index_tab[i]->key; // don't want "inverse"/"reverse" } } return dict; } /* * Return the attributes of the highlight group at index 'hl_idx' as a * Dictionary. If 'resolve_link' is TRUE, then resolves the highlight group * links recursively. */ static dict_T * highlight_get_info(int hl_idx, int resolve_link) { dict_T *dict; hl_group_T *sgp; dict_T *attr_dict; int hlgid; dict = dict_alloc(); if (dict == NULL) return dict; sgp = &HL_TABLE()[hl_idx]; // highlight group id is 1-based hlgid = hl_idx + 1; if (dict_add_string(dict, "name", sgp->sg_name) == FAIL) goto error; if (dict_add_number(dict, "id", hlgid) == FAIL) goto error; if (sgp->sg_link && resolve_link) { // resolve the highlight group link recursively while (sgp->sg_link) { hlgid = sgp->sg_link; sgp = &HL_TABLE()[sgp->sg_link - 1]; } } if (sgp->sg_term != 0) { attr_dict = highlight_get_attr_dict(sgp->sg_term); if (attr_dict != NULL) if (dict_add_dict(dict, "term", attr_dict) == FAIL) goto error; } if (sgp->sg_start != NULL) if (dict_add_string(dict, "start", sgp->sg_start) == FAIL) goto error; if (sgp->sg_stop != NULL) if (dict_add_string(dict, "stop", sgp->sg_stop) == FAIL) goto error; if (sgp->sg_cterm != 0) { attr_dict = highlight_get_attr_dict(sgp->sg_cterm); if (attr_dict != NULL) if (dict_add_dict(dict, "cterm", attr_dict) == FAIL) goto error; } if (sgp->sg_cterm_fg != 0) if (dict_add_string(dict, "ctermfg", highlight_color(hlgid, (char_u *)"fg", 'c')) == FAIL) goto error; if (sgp->sg_cterm_bg != 0) if (dict_add_string(dict, "ctermbg", highlight_color(hlgid, (char_u *)"bg", 'c')) == FAIL) goto error; if (sgp->sg_cterm_ul != 0) if (dict_add_string(dict, "ctermul", highlight_color(hlgid, (char_u *)"ul", 'c')) == FAIL) goto error; if (sgp->sg_cterm_font != 0) if (dict_add_string(dict, "ctermfont", highlight_color(hlgid, (char_u *)"font", 'c')) == FAIL) goto error; if (sgp->sg_gui != 0) { attr_dict = highlight_get_attr_dict(sgp->sg_gui); if (attr_dict != NULL) if (dict_add_dict(dict, "gui", attr_dict) == FAIL) goto error; } if (sgp->sg_gui_fg_name != NULL) if (dict_add_string(dict, "guifg", highlight_color(hlgid, (char_u *)"fg", 'g')) == FAIL) goto error; if (sgp->sg_gui_bg_name != NULL) if (dict_add_string(dict, "guibg", highlight_color(hlgid, (char_u *)"bg", 'g')) == FAIL) goto error; if (sgp->sg_gui_sp_name != NULL) if (dict_add_string(dict, "guisp", highlight_color(hlgid, (char_u *)"sp", 'g')) == FAIL) goto error; # ifdef FEAT_GUI if (sgp->sg_font_name != NULL) if (dict_add_string(dict, "font", sgp->sg_font_name) == FAIL) goto error; # endif if (sgp->sg_link) { char_u *link; link = HL_TABLE()[sgp->sg_link - 1].sg_name; if (link != NULL && dict_add_string(dict, "linksto", link) == FAIL) goto error; if (sgp->sg_deflink) dict_add_bool(dict, "default", VVAL_TRUE); } if (dict_len(dict) == 2) // If only 'name' is present, then the highlight group is cleared. dict_add_bool(dict, "cleared", VVAL_TRUE); return dict; error: vim_free(dict); return NULL; } /* * "hlget([name])" function * Return the attributes of a specific highlight group (if specified) or all * the highlight groups. */ void f_hlget(typval_T *argvars, typval_T *rettv) { list_T *list; dict_T *dict; int i; char_u *hlarg = NULL; int resolve_link = FALSE; if (rettv_list_alloc(rettv) == FAIL) return; if (check_for_opt_string_arg(argvars, 0) == FAIL || (argvars[0].v_type != VAR_UNKNOWN && check_for_opt_bool_arg(argvars, 1) == FAIL)) return; if (argvars[0].v_type != VAR_UNKNOWN) { // highlight group name supplied hlarg = tv_get_string_chk(&argvars[0]); if (hlarg == NULL) return; if (argvars[1].v_type != VAR_UNKNOWN) { int error = FALSE; resolve_link = tv_get_bool_chk(&argvars[1], &error); if (error) return; } } list = rettv->vval.v_list; for (i = 0; i < highlight_ga.ga_len && !got_int; ++i) { if (hlarg == NULL || STRICMP(hlarg, HL_TABLE()[i].sg_name) == 0) { dict = highlight_get_info(i, resolve_link); if (dict != NULL) list_append_dict(list, dict); } } } /* * Returns the string value at 'dict[key]'. Returns NULL, if 'key' is not in * 'dict' or the value is not a string type. If the value is not a string type * or is NULL, then 'error' is set to TRUE. */ static char_u * hldict_get_string(dict_T *dict, char_u *key, int *error) { dictitem_T *di; *error = FALSE; di = dict_find(dict, key, -1); if (di == NULL) return NULL; if (di->di_tv.v_type != VAR_STRING || di->di_tv.vval.v_string == NULL) { emsg(_(e_string_required)); *error = TRUE; return NULL; } return di->di_tv.vval.v_string; } /* * Convert the highlight attribute Dictionary at 'dict[key]' into a string * value in 'attr_str' of length 'len'. Returns FALSE if 'dict[key]' is not a * Dictionary or is NULL. */ static int hldict_attr_to_str( dict_T *dict, char_u *key, char_u *attr_str, size_t len) { dictitem_T *di; dict_T *attrdict; int i; char_u *p; attr_str[0] = NUL; di = dict_find(dict, key, -1); if (di == NULL) return TRUE; if (di->di_tv.v_type != VAR_DICT || di->di_tv.vval.v_dict == NULL) { emsg(_(e_dictionary_required)); return FALSE; } attrdict = di->di_tv.vval.v_dict; // If the attribute dict is empty, then return NONE to clear the attributes if (dict_len(attrdict) == 0) { vim_strcat(attr_str, (char_u *)"NONE", len); return TRUE; } p = attr_str; for (i = 0; i < (int)ARRAY_LENGTH(highlight_tab); ++i) { if (dict_get_bool(attrdict, highlight_tab[i].value, VVAL_FALSE) == VVAL_TRUE) { if (p != attr_str && (size_t)(p - attr_str + 2) < len) STRCPY(p, (char_u *)","); if (p - attr_str + highlight_tab[i].length + 1 < len) { STRCPY(p, highlight_tab[i].value); p += highlight_tab[i].length; } } } return TRUE; } // Temporary buffer used to store the command string produced by hlset(). // IObuff cannot be used for this as the error messages produced by hlset() // internally use IObuff. #define HLSETBUFSZ 512 static char_u hlsetBuf[HLSETBUFSZ + 1]; /* * Add the highlight attribute "attr" of length "attrlen" and "value" at * "dptr", which points into "hlsetBuf". * Returns the updated pointer. */ static char_u * add_attr_and_value(char_u *dptr, char_u *attr, int attrlen, char_u *value) { size_t vallen; // Do nothing if the value is not specified or is empty if (value == NULL || *value == NUL) return dptr; vallen = STRLEN(value); if (dptr + attrlen + vallen + 1 < hlsetBuf + HLSETBUFSZ) { STRCPY(dptr, attr); dptr += attrlen; STRCPY(dptr, value); dptr += vallen; } return dptr; } /* * Add or update a highlight group using 'dict' items. Returns TRUE if * successfully updated the highlight group. */ static int hlg_add_or_update(dict_T *dict) { char_u *name; int error; char_u term_attr[MAX_ATTR_LEN]; char_u cterm_attr[MAX_ATTR_LEN]; char_u gui_attr[MAX_ATTR_LEN]; char_u *start; char_u *stop; char_u *ctermfg; char_u *ctermbg; char_u *ctermul; char_u *ctermfont; char_u *guifg; char_u *guibg; char_u *guisp; # ifdef FEAT_GUI char_u *font; # endif int forceit = FALSE; int dodefault = FALSE; int done = FALSE; char_u *p; name = hldict_get_string(dict, (char_u *)"name", &error); if (name == NULL || *name == NUL || error) return FALSE; if (dict_get_bool(dict, "force", VVAL_FALSE) == VVAL_TRUE) forceit = TRUE; if (dict_get_bool(dict, "default", VVAL_FALSE) == VVAL_TRUE) dodefault = TRUE; if (dict_has_key(dict, "cleared")) { varnumber_T cleared; // clear a highlight group cleared = dict_get_bool(dict, "cleared", FALSE); if (cleared == TRUE) { vim_snprintf((char *)hlsetBuf, HLSETBUFSZ, "clear %s", name); do_highlight(hlsetBuf, forceit, FALSE); done = TRUE; } } if (dict_has_key(dict, "linksto")) { char_u *linksto; // link highlight groups linksto = hldict_get_string(dict, (char_u *)"linksto", &error); if (linksto == NULL || *linksto == NUL || error) return FALSE; vim_snprintf((char *)hlsetBuf, HLSETBUFSZ, "%slink %s %s", dodefault ? "default " : "", name, linksto); do_highlight(hlsetBuf, forceit, FALSE); done = TRUE; } // If 'cleared' or 'linksto' are specified, then don't process the other // attributes. if (done) return TRUE; start = hldict_get_string(dict, (char_u *)"start", &error); if (error) return FALSE; stop = hldict_get_string(dict, (char_u *)"stop", &error); if (error) return FALSE; if (!hldict_attr_to_str(dict, (char_u *)"term", term_attr, sizeof(term_attr))) return FALSE; if (!hldict_attr_to_str(dict, (char_u *)"cterm", cterm_attr, sizeof(cterm_attr))) return FALSE; ctermfg = hldict_get_string(dict, (char_u *)"ctermfg", &error); if (error) return FALSE; ctermbg = hldict_get_string(dict, (char_u *)"ctermbg", &error); if (error) return FALSE; ctermul = hldict_get_string(dict, (char_u *)"ctermul", &error); if (error) return FALSE; ctermfont = hldict_get_string(dict, (char_u *)"ctermfont", &error); if (error) return FALSE; if (!hldict_attr_to_str(dict, (char_u *)"gui", gui_attr, sizeof(gui_attr))) return FALSE; guifg = hldict_get_string(dict, (char_u *)"guifg", &error); if (error) return FALSE; guibg = hldict_get_string(dict, (char_u *)"guibg", &error); if (error) return FALSE; guisp = hldict_get_string(dict, (char_u *)"guisp", &error); if (error) return FALSE; # ifdef FEAT_GUI font = hldict_get_string(dict, (char_u *)"font", &error); if (error) return FALSE; # endif // If none of the attributes are specified, then do nothing. if (term_attr[0] == NUL && start == NULL && stop == NULL && cterm_attr[0] == NUL && ctermfg == NULL && ctermbg == NULL && ctermul == NULL && ctermfont == NULL && gui_attr[0] == NUL # ifdef FEAT_GUI && font == NULL # endif && guifg == NULL && guibg == NULL && guisp == NULL ) return TRUE; hlsetBuf[0] = NUL; p = hlsetBuf; if (dodefault) p = add_attr_and_value(p, (char_u *)"default", 7, (char_u *)" "); p = add_attr_and_value(p, (char_u *)"", 0, name); p = add_attr_and_value(p, (char_u *)" term=", 6, term_attr); p = add_attr_and_value(p, (char_u *)" start=", 7, start); p = add_attr_and_value(p, (char_u *)" stop=", 6, stop); p = add_attr_and_value(p, (char_u *)" cterm=", 7, cterm_attr); p = add_attr_and_value(p, (char_u *)" ctermfg=", 9, ctermfg); p = add_attr_and_value(p, (char_u *)" ctermbg=", 9, ctermbg); p = add_attr_and_value(p, (char_u *)" ctermul=", 9, ctermul); p = add_attr_and_value(p, (char_u *)" ctermfont=", 9, ctermfont); p = add_attr_and_value(p, (char_u *)" gui=", 5, gui_attr); # ifdef FEAT_GUI p = add_attr_and_value(p, (char_u *)" font=", 6, font); # endif p = add_attr_and_value(p, (char_u *)" guifg=", 7, guifg); p = add_attr_and_value(p, (char_u *)" guibg=", 7, guibg); (void)add_attr_and_value(p, (char_u *)" guisp=", 7, guisp); do_highlight(hlsetBuf, forceit, FALSE); return TRUE; } /* * "hlset([{highlight_attr}])" function * Add or modify highlight groups */ void f_hlset(typval_T *argvars, typval_T *rettv) { listitem_T *li; dict_T *dict; rettv->vval.v_number = -1; if (check_for_list_arg(argvars, 0) == FAIL) return; FOR_ALL_LIST_ITEMS(argvars->vval.v_list, li) { if (li->li_tv.v_type != VAR_DICT) { emsg(_(e_dictionary_required)); return; } dict = li->li_tv.vval.v_dict; if (!hlg_add_or_update(dict)) return; } rettv->vval.v_number = 0; } #endif