Merge pull request #4273 from watiko/vim-7.4.957

vim-patch:7.4.{941,942,957}

runtime/doc/options.txt

@@ -3410,7 +3410,7 @@ A jump table for the options with a short description can be found at |Q_op|.
 			global
 	Ignore case in search patterns.  Also used when searching in the tags
 	file.
-	Also see 'smartcase'.
+	Also see 'smartcase' and 'tagcase'.
 	Can be overruled by using "\c" or "\C" in the pattern, see
 	|/ignorecase|.
 
@@ -6321,19 +6321,22 @@ A jump table for the options with a short description can be found at |Q_op|.
 <	[The whitespace before and after the '0' must be a single <Tab>]
 
 	When a binary search was done and no match was found in any of the
-	files listed in 'tags', and 'ignorecase' is set or a pattern is used
+	files listed in 'tags', and case is ignored or a pattern is used
 	instead of a normal tag name, a retry is done with a linear search.
 	Tags in unsorted tags files, and matches with different case will only
 	be found in the retry.
 
 	If a tag file indicates that it is case-fold sorted, the second,
-	linear search can be avoided for the 'ignorecase' case.  Use a value
+	linear search can be avoided when case is ignored.  Use a value of '2'
-	of '2' in the "!_TAG_FILE_SORTED" line for this.  A tag file can be
+	in the "!_TAG_FILE_SORTED" line for this.  A tag file can be case-fold
-	case-fold sorted with the -f switch to "sort" in most unices, as in
+	sorted with the -f switch to "sort" in most unices, as in the command:
-	the command: "sort -f -o tags tags".  For "Exuberant ctags" version
+	"sort -f -o tags tags".  For "Exuberant ctags" version 5.x or higher
-	5.x or higher (at least 5.5) the --sort=foldcase switch can be used
+	(at least 5.5) the --sort=foldcase switch can be used for this as
-	for this as well.  Note that case must be folded to uppercase for this
+	well.  Note that case must be folded to uppercase for this to work.
-	to work.
+
+	By default, tag searches are case-sensitive.  Case is ignored when
+	'ignorecase' is set and 'tagcase' is "followic", or when 'tagcase' is
+	"ignore".
 
 	When 'tagbsearch' is off, tags searching is slower when a full match
 	exists, but faster when no full match exists.  Tags in unsorted tags
@@ -6344,6 +6347,16 @@ A jump table for the options with a short description can be found at |Q_op|.
 	This option doesn't affect commands that find all matching tags (e.g.,
 	command-line completion and ":help").
 
+							*'tagcase'* *'tc'*
+'tagcase' 'tc'		string	(default "followic")
+			global or local to buffer |global-local|
+			{not in Vi}
+	This option specifies how case is handled when searching the tags
+	file:
+	   followic	Follow the 'ignorecase' option
+	   ignore	Ignore case
+	   match	Match case
+
 						*'taglength'* *'tl'*
 'taglength' 'tl'	number	(default 0)
 			global

runtime/doc/quickref.txt

@@ -879,6 +879,7 @@ Short explanation of each option:		*option-list*
 'tabpagemax'	  'tpm'     maximum number of tab pages for |-p| and "tab all"
 'tabstop'	  'ts'	    number of spaces that <Tab> in file uses
 'tagbsearch'	  'tbs'     use binary searching in tags files
+'tagcase'	  'tc'      how to handle case when searching in tags files
 'taglength'	  'tl'	    number of significant characters for a tag
 'tagrelative'	  'tr'	    file names in tag file are relative
 'tags'		  'tag'     list of file names used by the tag command

runtime/doc/tagsrch.txt

@@ -84,11 +84,13 @@ changed, to avoid confusion when using ":tnext".  It is changed when using
 ":tag {ident}".
 
 The ignore-case matches are not found for a ":tag" command when the
-'ignorecase' option is off.  They are found when a pattern is used (starting
+'ignorecase' option is off and 'tagcase' is "followic" or when 'tagcase' is
-with a "/") and for ":tselect", also when 'ignorecase' is off.  Note that
+"match".  They are found when a pattern is used (starting with a "/") and for
-using ignore-case tag searching disables binary searching in the tags file,
+":tselect", also when 'ignorecase' is off and 'tagcase' is "followic" or when
-which causes a slowdown.  This can be avoided by fold-case sorting the tag
+'tagcase' is "match".  Note that using ignore-case tag searching disables
-file.  See the 'tagbsearch' option for an explanation.
+binary searching in the tags file, which causes a slowdown.  This can be
+avoided by fold-case sorting the tag file.  See the 'tagbsearch' option for an
+explanation.
 
 ==============================================================================
 2. Tag stack				*tag-stack* *tagstack* *E425*
@@ -418,12 +420,13 @@ file "tags".  It can also be used to access a common tags file.
 The next file in the list is not used when:
 - A matching static tag for the current buffer has been found.
 - A matching global tag has been found.
-This also depends on the 'ignorecase' option.  If it is off, and the tags file
+This also depends on whether case is ignored.  Case is ignored when
-only has a match without matching case, the next tags file is searched for a
+'ignorecase' is set and 'tagcase' is "followic", or when 'tagcase' is
-match with matching case.  If no tag with matching case is found, the first
+"ignore".  If case is not ignored, and the tags file only has a match without
-match without matching case is used.  If 'ignorecase' is on, and a matching
+matching case, the next tags file is searched for a match with matching case.
-global tag with or without matching case is found, this one is used, no
+If no tag with matching case is found, the first match without matching case
-further tags files are searched.
+is used.  If case is ignored, and a matching global tag with or without
+matching case is found, this one is used, no further tags files are searched.
 
 When a tag file name starts with "./", the '.' is replaced with the path of
 the current file.  This makes it possible to use a tags file in the directory
@@ -556,8 +559,10 @@ that indicates if the file was sorted.  When this line is found, Vim uses
 binary searching for the tags file:
 	!_TAG_FILE_SORTED<Tab>1<Tab>{anything} ~
 
-A tag file may be case-fold sorted to avoid a linear search when 'ignorecase'
+A tag file may be case-fold sorted to avoid a linear search when case is
-is on.  See 'tagbsearch' for details.  The value '2' should be used then:
+ignored.  (Case is ignored when 'ignorecase' is set and 'tagcase' is
+"followic", or when 'tagcase' is "ignore".)  See 'tagbsearch' for details.
+The value '2' should be used then:
 	!_TAG_FILE_SORTED<Tab>2<Tab>{anything} ~
 
 The other tag that Vim recognizes, but only when compiled with the

runtime/doc/usr_29.txt

@@ -255,7 +255,8 @@ function.
 
 RELATED ITEMS
 
-You can set 'ignorecase' to make case in tag names be ignored.
+To make case in tag names be ignored, you can set 'ignorecase' while leaving
+'tagcase' as "followic", or set 'tagcase' to "ignore".
 
 The 'tagbsearch' option tells if the tags file is sorted or not.  The default
 is to assume a sorted tags file, which makes a tags search a lot faster, but

runtime/optwin.vim

@@ -289,6 +289,10 @@ call append("$", " \tset tl=" . &tl)
 call append("$", "tags\tlist of file names to search for tags")
 call append("$", "\t(global or local to buffer)")
 call <SID>OptionG("tag", &tag)
+call append("$", "tagcase\thow to handle case when searching in tags files:")
+call append("$", "\t\"followic\" to follow 'ignorecase', \"ignore\" or \"match\"")
+call append("$", "\t(global or local to buffer)")
+call <SID>OptionG("tc", &tc)
 call append("$", "tagrelative\tfile names in a tags file are relative to the tags file")
 call <SID>BinOptionG("tr", &tr)
 call append("$", "tagstack\ta :tag command will use the tagstack")

src/nvim/buffer.c

@@ -1553,6 +1553,7 @@ void free_buf_options(buf_T *buf, int free_p_ff)
   clear_string_option(&buf->b_p_ep);
   clear_string_option(&buf->b_p_path);
   clear_string_option(&buf->b_p_tags);
+  clear_string_option(&buf->b_p_tc);
   clear_string_option(&buf->b_p_dict);
   clear_string_option(&buf->b_p_tsr);
   clear_string_option(&buf->b_p_qe);

src/nvim/buffer_defs.h

@@ -666,19 +666,21 @@ struct file_buffer {
   long b_p_wm_nopaste;          ///< b_p_wm saved for paste mode
   char_u *b_p_keymap;           ///< 'keymap'
 
-  /* local values for options which are normally global */
+  // local values for options which are normally global
-  char_u      *b_p_gp;          /* 'grepprg' local value */
+  char_u *b_p_gp;               ///< 'grepprg' local value
-  char_u      *b_p_mp;          /* 'makeprg' local value */
+  char_u *b_p_mp;               ///< 'makeprg' local value
-  char_u      *b_p_efm;         /* 'errorformat' local value */
+  char_u *b_p_efm;              ///< 'errorformat' local value
-  char_u      *b_p_ep;          /* 'equalprg' local value */
+  char_u *b_p_ep;               ///< 'equalprg' local value
-  char_u      *b_p_path;        /* 'path' local value */
+  char_u *b_p_path;             ///< 'path' local value
-  int b_p_ar;                   /* 'autoread' local value */
+  int b_p_ar;                   ///< 'autoread' local value
-  char_u      *b_p_tags;        /* 'tags' local value */
+  char_u *b_p_tags;             ///< 'tags' local value
-  char_u      *b_p_dict;        /* 'dictionary' local value */
+  char_u *b_p_tc;               ///< 'tagcase' local value
-  char_u      *b_p_tsr;         /* 'thesaurus' local value */
+  unsigned b_tc_flags;          ///< flags for 'tagcase'
-  long b_p_ul;                  /* 'undolevels' local value */
+  char_u *b_p_dict;             ///< 'dictionary' local value
-  int b_p_udf;                  /* 'undofile' */
+  char_u *b_p_tsr;              ///< 'thesaurus' local value
-  char_u      *b_p_lw;          // 'lispwords' local value
+  long b_p_ul;                  ///< 'undolevels' local value
+  int b_p_udf;                  ///< 'undofile'
+  char_u *b_p_lw;               ///< 'lispwords' local value
 
   /* end of buffer options */
 
@@ -955,16 +957,14 @@ struct window_S {
                                        time through cursupdate() to the
                                        current virtual column */
 
-  /*
+  // the next seven are used to update the visual part
-   * the next six are used to update the visual part
+  char w_old_visual_mode;           ///< last known VIsual_mode
-   */
+  linenr_T w_old_cursor_lnum;       ///< last known end of visual part
-  char w_old_visual_mode;           /* last known VIsual_mode */
+  colnr_T w_old_cursor_fcol;        ///< first column for block visual part
-  linenr_T w_old_cursor_lnum;       /* last known end of visual part */
+  colnr_T w_old_cursor_lcol;        ///< last column for block visual part
-  colnr_T w_old_cursor_fcol;        /* first column for block visual part */
+  linenr_T w_old_visual_lnum;       ///< last known start of visual part
-  colnr_T w_old_cursor_lcol;        /* last column for block visual part */
+  colnr_T w_old_visual_col;         ///< last known start of visual part
-  linenr_T w_old_visual_lnum;       /* last known start of visual part */
+  colnr_T w_old_curswant;           ///< last known value of Curswant
-  colnr_T w_old_visual_col;         /* last known start of visual part */
-  colnr_T w_old_curswant;           /* last known value of Curswant */
 
   /*
    * "w_topline", "w_leftcol" and "w_skipcol" specify the offsets for

src/nvim/option.c

@@ -2057,6 +2057,7 @@ static void didset_options(void)
   (void)opt_strings_flags(p_vop, p_ssop_values, &vop_flags, true);
   (void)opt_strings_flags(p_fdo, p_fdo_values, &fdo_flags, true);
   (void)opt_strings_flags(p_dy, p_dy_values, &dy_flags, true);
+  (void)opt_strings_flags(p_tc, p_tc_values, &tc_flags, false);
   (void)opt_strings_flags(p_ve, p_ve_values, &ve_flags, true);
   (void)spell_check_msm();
   (void)spell_check_sps();
@@ -2144,6 +2145,7 @@ void check_buf_options(buf_T *buf)
   check_string_option(&buf->b_p_ep);
   check_string_option(&buf->b_p_path);
   check_string_option(&buf->b_p_tags);
+  check_string_option(&buf->b_p_tc);
   check_string_option(&buf->b_p_dict);
   check_string_option(&buf->b_p_tsr);
   check_string_option(&buf->b_p_lw);
@@ -2983,6 +2985,24 @@ did_set_string_option (
     if (opt_strings_flags(p_bo, p_bo_values, &bo_flags, true) != OK) {
       errmsg = e_invarg;
     }
+  } else if (gvarp == &p_tc) {  // 'tagcase'
+    unsigned int *flags;
+
+    if (opt_flags & OPT_LOCAL) {
+      p = curbuf->b_p_tc;
+      flags = &curbuf->b_tc_flags;
+    } else {
+      p = p_tc;
+      flags = &tc_flags;
+    }
+
+    if ((opt_flags & OPT_LOCAL) && *p == NUL) {
+      // make the local value empty: use the global value
+      *flags = 0;
+    } else if (*p == NUL
+               || opt_strings_flags(p, p_tc_values, flags, false) != OK) {
+      errmsg = e_invarg;
+    }
   } else if (varp == &p_cmp) {  // 'casemap'
     if (opt_strings_flags(p_cmp, p_cmp_values, &cmp_flags, true) != OK)
       errmsg = e_invarg;
@@ -5111,6 +5131,10 @@ void unset_global_local_option(char *name, void *from)
     case PV_TAGS:
       clear_string_option(&buf->b_p_tags);
       break;
+    case PV_TC:
+      clear_string_option(&buf->b_p_tc);
+      buf->b_tc_flags = 0;
+      break;
     case PV_DEF:
       clear_string_option(&buf->b_p_def);
       break;
@@ -5164,6 +5188,7 @@ static char_u *get_varp_scope(vimoption_T *p, int opt_flags)
     case PV_PATH: return (char_u *)&(curbuf->b_p_path);
     case PV_AR:   return (char_u *)&(curbuf->b_p_ar);
     case PV_TAGS: return (char_u *)&(curbuf->b_p_tags);
+    case PV_TC:   return (char_u *)&(curbuf->b_p_tc);
     case PV_DEF:  return (char_u *)&(curbuf->b_p_def);
     case PV_INC:  return (char_u *)&(curbuf->b_p_inc);
     case PV_DICT: return (char_u *)&(curbuf->b_p_dict);
@@ -5201,6 +5226,8 @@ static char_u *get_varp(vimoption_T *p)
            ? (char_u *)&(curbuf->b_p_ar) : p->var;
   case PV_TAGS:   return *curbuf->b_p_tags != NUL
            ? (char_u *)&(curbuf->b_p_tags) : p->var;
+  case PV_TC:     return *curbuf->b_p_tc != NUL
+           ? (char_u *)&(curbuf->b_p_tc) : p->var;
   case PV_BKC:    return *curbuf->b_p_bkc != NUL
            ? (char_u *)&(curbuf->b_p_bkc) : p->var;
   case PV_DEF:    return *curbuf->b_p_def != NUL
@@ -5580,6 +5607,8 @@ void buf_copy_options(buf_T *buf, int flags)
       buf->b_p_kp = empty_option;
       buf->b_p_path = empty_option;
       buf->b_p_tags = empty_option;
+      buf->b_p_tc = empty_option;
+      buf->b_tc_flags = 0;
       buf->b_p_def = empty_option;
       buf->b_p_inc = empty_option;
       buf->b_p_inex = vim_strsave(p_inex);

src/nvim/option_defs.h

@@ -597,6 +597,14 @@ static char *(p_swb_values[]) =
 #define SWB_NEWTAB              0x008
 #define SWB_VSPLIT              0x010
 EXTERN int p_tbs;               ///< 'tagbsearch'
+EXTERN char_u *p_tc;            ///< 'tagcase'
+EXTERN unsigned tc_flags;       ///< flags from 'tagcase'
+#ifdef IN_OPTION_C
+static char *(p_tc_values[]) = { "followic", "ignore", "match", NULL };
+#endif
+#define TC_FOLLOWIC             0x01
+#define TC_IGNORE               0x02
+#define TC_MATCH                0x04
 EXTERN long p_tl;               ///< 'taglength'
 EXTERN int p_tr;                ///< 'tagrelative'
 EXTERN char_u *p_tags;          ///< 'tags'
@@ -737,6 +745,7 @@ enum {
   , BV_SW
   , BV_SWF
   , BV_TAGS
+  , BV_TC
   , BV_TS
   , BV_TW
   , BV_TX

src/nvim/options.lua

@@ -2331,6 +2331,13 @@ return {
       varname='p_tbs',
       defaults={if_true={vi=true}}
     },
+    {
+      full_name='tagcase', abbreviation='tc',
+      type='string', scope={'global', 'buffer'},
+      vim=true,
+      varname='p_tc',
+      defaults={if_true={vi="followic", vim="followic"}}
+    },
     {
       full_name='taglength', abbreviation='tl',
       type='number', scope={'global'},

src/nvim/tag.c

@@ -1147,6 +1147,22 @@ find_tags (
   int get_it_again = FALSE;
   int use_cscope = (flags & TAG_CSCOPE);
   int verbose = (flags & TAG_VERBOSE);
+  int save_p_ic = p_ic;
+
+  // Change the value of 'ignorecase' according to 'tagcase' for the
+  // duration of this function.
+  switch (curbuf->b_tc_flags ? curbuf->b_tc_flags : tc_flags) {
+    case TC_FOLLOWIC:
+      break;
+    case TC_IGNORE:
+      p_ic = true;
+      break;
+    case TC_MATCH:
+      p_ic = false;
+      break;
+    default:
+      assert(false);
+  }
 
   help_save = curbuf->b_help;
   orgpat.pat = pat;
@@ -1955,6 +1971,8 @@ findtag_end:
   curbuf->b_help = help_save;
   xfree(saved_pat);
 
+  p_ic = save_p_ic;
+
   return retval;
 }
 

src/nvim/version.c

@@ -720,7 +720,7 @@ static int included_patches[] = {
   // 960 NA
   // 959 NA
   958,
-  // 957,
+  957,
   // 956 NA
   955,
   // 954 NA
@@ -735,8 +735,8 @@ static int included_patches[] = {
   945,
   944,
   // 943 NA
-  // 942,
+  942,
-  // 941,
+  941,
   // 940 NA
   939,
   // 938 NA

test/functional/legacy/tagcase_spec.lua

@@ -0,0 +1,150 @@
+local helpers = require('test.functional.helpers')
+local clear = helpers.clear
+local eq = helpers.eq
+local eval = helpers.eval
+local exc_exec = helpers.exc_exec
+local expect = helpers.expect
+local insert = helpers.insert
+local source = helpers.source
+local write_file = helpers.write_file
+
+describe("'tagcase' option", function()
+  setup(function()
+    write_file('Xtags', [[
+      Bar	Xtext	3
+      Foo	Xtext	2
+      foo	Xtext	4]])
+  end)
+
+  before_each(function()
+    clear()
+    source([[
+      lang mess C
+      set tags=Xtags]])
+  end)
+
+  teardown(function()
+    os.remove('Xtags')
+  end)
+
+  it('should have correct default values', function()
+    source([[
+      set ic&
+      setg tc&
+      setl tc&
+      ]])
+
+    eq(0, eval('&ic'))
+    eq('followic', eval('&g:tc'))
+    eq('followic', eval('&l:tc'))
+    eq('followic', eval('&tc'))
+  end)
+
+  it('should accept <empty> only for setlocal', function()
+    -- Verify that the local setting accepts <empty> but that the global setting
+    -- does not.  The first of these (setting the local value to <empty>) should
+    -- succeed; the other two should fail.
+    eq(0, exc_exec('setl tc='))
+    eq('Vim(setglobal):E474: Invalid argument: tc=', exc_exec('setg tc='))
+    eq('Vim(set):E474: Invalid argument: tc=', exc_exec('set tc='))
+  end)
+
+  it("should work with 'ignorecase' correctly in all combinations", function()
+    -- Verify that the correct number of matching tags is found for all values of
+    -- 'ignorecase' and global and local values 'tagcase', in all combinations.
+    insert([[
+      
+      Foo
+      Bar
+      foo
+      
+      end text]])
+
+    source([[
+      for &ic in [0, 1]
+        for &g:tc in ["followic", "ignore", "match"]
+          for &l:tc in ["", "followic", "ignore", "match"]
+            call append('$', "ic=".&ic." g:tc=".&g:tc." l:tc=".&l:tc." tc=".&tc)
+            call append('$', len(taglist("^foo$")))
+            call append('$', len(taglist("^Foo$")))
+          endfor
+        endfor
+      endfor
+      
+      1,/^end text$/d]])
+
+    expect([[
+      ic=0 g:tc=followic l:tc= tc=followic
+      1
+      1
+      ic=0 g:tc=followic l:tc=followic tc=followic
+      1
+      1
+      ic=0 g:tc=followic l:tc=ignore tc=ignore
+      2
+      2
+      ic=0 g:tc=followic l:tc=match tc=match
+      1
+      1
+      ic=0 g:tc=ignore l:tc= tc=ignore
+      2
+      2
+      ic=0 g:tc=ignore l:tc=followic tc=followic
+      1
+      1
+      ic=0 g:tc=ignore l:tc=ignore tc=ignore
+      2
+      2
+      ic=0 g:tc=ignore l:tc=match tc=match
+      1
+      1
+      ic=0 g:tc=match l:tc= tc=match
+      1
+      1
+      ic=0 g:tc=match l:tc=followic tc=followic
+      1
+      1
+      ic=0 g:tc=match l:tc=ignore tc=ignore
+      2
+      2
+      ic=0 g:tc=match l:tc=match tc=match
+      1
+      1
+      ic=1 g:tc=followic l:tc= tc=followic
+      2
+      2
+      ic=1 g:tc=followic l:tc=followic tc=followic
+      2
+      2
+      ic=1 g:tc=followic l:tc=ignore tc=ignore
+      2
+      2
+      ic=1 g:tc=followic l:tc=match tc=match
+      1
+      1
+      ic=1 g:tc=ignore l:tc= tc=ignore
+      2
+      2
+      ic=1 g:tc=ignore l:tc=followic tc=followic
+      2
+      2
+      ic=1 g:tc=ignore l:tc=ignore tc=ignore
+      2
+      2
+      ic=1 g:tc=ignore l:tc=match tc=match
+      1
+      1
+      ic=1 g:tc=match l:tc= tc=match
+      1
+      1
+      ic=1 g:tc=match l:tc=followic tc=followic
+      2
+      2
+      ic=1 g:tc=match l:tc=ignore tc=ignore
+      2
+      2
+      ic=1 g:tc=match l:tc=match tc=match
+      1
+      1]])
+  end)
+end)