IntenseFinance/neovim
3
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-02-25 18:55:25 -06:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #7116 from lonerover/vim-8.0.0081

Browse Source 
vim-patch:8.0.0081
This commit is contained in:
James McCoy 2017-08-04 10:32:47 -04:00 committed by GitHub
commit 36a91c790e
4 changed files with 95 additions and 219 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/nvim/ex_cmds.lua
View File

@ -628,13 +628,13 @@ return {
command='cscope',
flags=bit.bor(EXTRA, NOTRLCOM, XFILE),
addr_type=ADDR_LINES,
func='do_cscope',
func='ex_cscope',
},
{
command='cstag',
flags=bit.bor(BANG, TRLBAR, WORD1),
addr_type=ADDR_LINES,
func='do_cstag',
func='ex_cstag',
},
{
command='cunmap',
@ -1324,7 +1324,7 @@ return {
command='lcscope',
flags=bit.bor(EXTRA, NOTRLCOM, XFILE),
addr_type=ADDR_LINES,
func='do_cscope',
func='ex_cscope',
},
{
command='ldo',
@ -2334,7 +2334,7 @@ return {
command='scscope',
flags=bit.bor(EXTRA, NOTRLCOM),
addr_type=ADDR_LINES,
func='do_scscope',
func='ex_scscope',
},
{
command='set',

2
src/nvim/ex_docmd.c
View File

@ -8321,7 +8321,7 @@ static void ex_tag_cmd(exarg_T *eap, char_u *name)
break;
default: /* ":tag" */
if (p_cst && *eap->arg != NUL) {
do_cstag(eap);
ex_cstag(eap);
return;
}
cmd = DT_TAG;

302
src/nvim/if_cscope.c
View File

@ -172,14 +172,10 @@ void set_context_in_cscope_cmd(expand_T *xp, const char *arg, cmdidx_T cmdidx)
}
/*
* PRIVATE: do_cscope_general
*
* Find the command, print help if invalid, and then call the corresponding
* command function.
*/
static void
do_cscope_general (
/// Find the command, print help if invalid, and then call the corresponding
/// command function.
static void
do_cscope_general(
exarg_T *eap,
int make_split /* whether to split window */
)
@ -208,29 +204,20 @@ do_cscope_general (
postponed_split_tab = 0;
}
/*
* PUBLIC: do_cscope
*/
void do_cscope(exarg_T *eap)
/// Implementation of ":cscope" and ":lcscope"
void ex_cscope(exarg_T *eap)
{
do_cscope_general(eap, FALSE);
}
/*
* PUBLIC: do_scscope
*
* same as do_cscope, but splits window, too.
*/
void do_scscope(exarg_T *eap)
/// Implementation of ":scscope". Same as ex_cscope(), but splits window, too.
void ex_scscope(exarg_T *eap)
{
do_cscope_general(eap, TRUE);
}
/*
* PUBLIC: do_cstag
*
*/
void do_cstag(exarg_T *eap)
/// Implementation of ":cstag"
void ex_cstag(exarg_T *eap)
{
int ret = FALSE;
@ -285,18 +272,13 @@ void do_cstag(exarg_T *eap)
(void)EMSG(_("E257: cstag: tag not found"));
g_do_tagpreview = 0;
}
} /* do_cscope */
}
/*
* PUBLIC: cs_find
*
* this simulates a vim_fgets(), but for cscope, returns the next line
* from the cscope output. should only be called from find_tags()
*
* returns TRUE if eof, FALSE otherwise
*/
/// This simulates a vim_fgets(), but for cscope, returns the next line
/// from the cscope output. should only be called from find_tags()
///
/// @return TRUE if eof, FALSE otherwise
int cs_fgets(char_u *buf, int size)
{
char *p;
@ -309,21 +291,13 @@ int cs_fgets(char_u *buf, int size)
} /* cs_fgets */
/*
* PUBLIC: cs_free_tags
*
* called only from do_tag(), when popping the tag stack
*/
/// Called only from do_tag(), when popping the tag stack.
void cs_free_tags(void)
{
cs_manage_matches(NULL, NULL, 0, Free);
}
/*
* PUBLIC: cs_print_tags
*
* called from do_tag()
*/
/// Called from do_tag().
void cs_print_tags(void)
{
cs_manage_matches(NULL, NULL, 0, Print);
@ -404,14 +378,8 @@ int cs_connection(int num, char_u *dbpath, char_u *ppath)
* PRIVATE functions
****************************************************************************/
/*
* PRIVATE: cs_add
*
* add cscope database or a directory name (to look for cscope.out)
* to the cscope connection list
*
* MAXPATHL 256
*/
/// Add cscope database or a directory name (to look for cscope.out)
/// to the cscope connection list.
static int cs_add(exarg_T *eap)
{
char *fname, *ppath, *flags = NULL;
@ -437,17 +405,13 @@ static void cs_stat_emsg(char *fname)
}
/*
* PRIVATE: cs_add_common
*
* the common routine to add a new cscope connection. called by
* cs_add() and cs_reset(). i really don't like to do this, but this
* routine uses a number of goto statements.
*/
static int
cs_add_common (
char *arg1, /* filename - may contain environment variables */
char *arg2, /* prepend path - may contain environment variables */
/// The common routine to add a new cscope connection. Called by
/// cs_add() and cs_reset(). I really don't like to do this, but this
/// routine uses a number of goto statements.
static int
cs_add_common(
char *arg1, // filename - may contain environment variables
char *arg2, // prepend path - may contain environment variables
char *flags
)
{
@ -561,11 +525,7 @@ static int cs_check_for_tags(void)
return p_tags[0] != NUL && curbuf->b_p_tags != NULL;
} /* cs_check_for_tags */
/*
* PRIVATE: cs_cnt_connections
*
* count the number of cscope connections
*/
/// Count the number of cscope connections.
static size_t cs_cnt_connections(void)
{
size_t cnt = 0;
@ -585,11 +545,7 @@ static void cs_reading_emsg(
}
#define CSREAD_BUFSIZE 2048
/*
* PRIVATE: cs_cnt_matches
*
* count the number of matches for a given cscope connection.
*/
/// Count the number of matches for a given cscope connection.
static int cs_cnt_matches(size_t idx)
{
char *stok;
@ -639,11 +595,7 @@ static int cs_cnt_matches(size_t idx)
} /* cs_cnt_matches */
/*
* PRIVATE: cs_create_cmd
*
* Creates the actual cscope command query from what the user entered.
*/
/// Creates the actual cscope command query from what the user entered.
static char *cs_create_cmd(char *csoption, char *pattern)
{
char *cmd;
@ -699,12 +651,8 @@ static char *cs_create_cmd(char *csoption, char *pattern)
} /* cs_create_cmd */
/*
* PRIVATE: cs_create_connection
*
* This piece of code was taken/adapted from nvi. do we need to add
* the BSD license notice?
*/
/// This piece of code was taken/adapted from nvi. do we need to add
/// the BSD license notice?
static int cs_create_connection(size_t i)
{
#ifdef UNIX
@ -893,14 +841,10 @@ err_closing:
} /* cs_create_connection */
/*
* PRIVATE: cs_find
*
* query cscope using command line interface. parse the output and use tselect
* to allow choices. like Nvi, creates a pipe to send to/from query/cscope.
*
* returns TRUE if we jump to a tag or abort, FALSE if not.
*/
/// Query cscope using command line interface. Parse the output and use tselect
/// to allow choices. Like Nvi, creates a pipe to send to/from query/cscope.
///
/// @return TRUE if we jump to a tag or abort, FALSE if not.
static int cs_find(exarg_T *eap)
{
char *opt, *pat;
@ -934,11 +878,7 @@ static int cs_find(exarg_T *eap)
} /* cs_find */
/*
* PRIVATE: cs_find_common
*
* common code for cscope find, shared by cs_find() and do_cstag()
*/
/// Common code for cscope find, shared by cs_find() and ex_cstag().
static int cs_find_common(char *opt, char *pat, int forceit, int verbose,
int use_ll, char_u *cmdline)
{
@ -1111,11 +1051,7 @@ static int cs_find_common(char *opt, char *pat, int forceit, int verbose,
} /* cs_find_common */
/*
* PRIVATE: cs_help
*
* print help
*/
/// Print help.
static int cs_help(exarg_T *eap)
{
cscmd_T *cmdp = cs_cmds;
@ -1163,11 +1099,7 @@ static void clear_csinfo(size_t i)
csinfo[i].to_fp = NULL;
}
/*
* PRIVATE: cs_insert_filelist
*
* insert a new cscope database filename into the filelist
*/
/// Insert a new cscope database filename into the filelist.
static int cs_insert_filelist(char *fname, char *ppath, char *flags,
FileInfo *file_info)
{
@ -1227,11 +1159,7 @@ static int cs_insert_filelist(char *fname, char *ppath, char *flags,
} /* cs_insert_filelist */
/*
* PRIVATE: cs_lookup_cmd
*
* find cscope command in command table
*/
/// Find cscope command in command table.
static cscmd_T * cs_lookup_cmd(exarg_T *eap)
{
cscmd_T *cmdp;
@ -1256,11 +1184,7 @@ static cscmd_T * cs_lookup_cmd(exarg_T *eap)
} /* cs_lookup_cmd */
/*
* PRIVATE: cs_kill
*
* nuke em
*/
/// Nuke em.
static int cs_kill(exarg_T *eap)
{
char *stok;
@ -1317,11 +1241,7 @@ static int cs_kill(exarg_T *eap)
} /* cs_kill */
/*
* PRIVATE: cs_kill_execute
*
* Actually kills a specific cscope connection.
*/
/// Actually kills a specific cscope connection.
static void cs_kill_execute(
size_t i, /* cscope table index */
char *cname /* cscope database name */
@ -1336,26 +1256,22 @@ static void cs_kill_execute(
}
/*
* PRIVATE: cs_make_vim_style_matches
*
* convert the cscope output into a ctags style entry (as might be found
* in a ctags tags file). there's one catch though: cscope doesn't tell you
* the type of the tag you are looking for. for example, in Darren Hiebert's
* ctags (the one that comes with vim), #define's use a line number to find the
* tag in a file while function definitions use a regexp search pattern.
*
* i'm going to always use the line number because cscope does something
* quirky (and probably other things i don't know about):
*
* if you have "# define" in your source file, which is
* perfectly legal, cscope thinks you have "#define". this
* will result in a failed regexp search. :(
*
* besides, even if this particular case didn't happen, the search pattern
* would still have to be modified to escape all the special regular expression
* characters to comply with ctags formatting.
*/
/// Convert the cscope output into a ctags style entry (as might be found
/// in a ctags tags file). there's one catch though: cscope doesn't tell you
/// the type of the tag you are looking for. for example, in Darren Hiebert's
/// ctags (the one that comes with vim), #define's use a line number to find the
/// tag in a file while function definitions use a regexp search pattern.
///
/// I'm going to always use the line number because cscope does something
/// quirky (and probably other things i don't know about):
///
/// if you have "# define" in your source file, which is
/// perfectly legal, cscope thinks you have "#define". this
/// will result in a failed regexp search. :(
///
/// Besides, even if this particular case didn't happen, the search pattern
/// would still have to be modified to escape all the special regular expression
/// characters to comply with ctags formatting.
static char *cs_make_vim_style_matches(char *fname, char *slno, char *search,
char *tagstr)
{
@ -1389,24 +1305,20 @@ static char *cs_make_vim_style_matches(char *fname, char *slno, char *search,
} /* cs_make_vim_style_matches */
/*
* PRIVATE: cs_manage_matches
*
* this is kind of hokey, but i don't see an easy way round this..
*
* Store: keep a ptr to the (malloc'd) memory of matches originally
* generated from cs_find(). the matches are originally lines directly
* from cscope output, but transformed to look like something out of a
* ctags. see cs_make_vim_style_matches for more details.
*
* Get: used only from cs_fgets(), this simulates a vim_fgets() to return
* the next line from the cscope output. it basically keeps track of which
* lines have been "used" and returns the next one.
*
* Free: frees up everything and resets
*
* Print: prints the tags
*/
/// This is kind of hokey, but i don't see an easy way round this.
///
/// Store: keep a ptr to the (malloc'd) memory of matches originally
/// generated from cs_find(). the matches are originally lines directly
/// from cscope output, but transformed to look like something out of a
/// ctags. see cs_make_vim_style_matches for more details.
///
/// Get: used only from cs_fgets(), this simulates a vim_fgets() to return
/// the next line from the cscope output. it basically keeps track of which
/// lines have been "used" and returns the next one.
///
/// Free: frees up everything and resets
///
/// Print: prints the tags
static char *cs_manage_matches(char **matches, char **contexts,
size_t totmatches, mcmd_e cmd)
{
@ -1461,11 +1373,7 @@ static char *cs_manage_matches(char **matches, char **contexts,
} /* cs_manage_matches */
/*
* PRIVATE: cs_parse_results
*
* parse cscope output
*/
/// Parse cscope output.
static char *cs_parse_results(size_t cnumber, char *buf, int bufsize,
char **context, char **linenumber, char **search)
{
@ -1515,11 +1423,7 @@ static char *cs_parse_results(size_t cnumber, char *buf, int bufsize,
return name;
}
/*
* PRIVATE: cs_file_results
*
* write cscope find results to file
*/
/// Write cscope find results to file.
static void cs_file_results(FILE *f, int *nummatches_a)
{
char *search, *slno;
@ -1560,13 +1464,9 @@ static void cs_file_results(FILE *f, int *nummatches_a)
xfree(buf);
}
/*
* PRIVATE: cs_fill_results
*
* get parsed cscope output and calls cs_make_vim_style_matches to convert
* into ctags format
* When there are no matches sets "*matches_p" to NULL.
*/
/// Get parsed cscope output and calls cs_make_vim_style_matches to convert
/// into ctags format.
/// When there are no matches sets "*matches_p" to NULL.
static void cs_fill_results(char *tagstr, size_t totmatches, int *nummatches_a,
char ***matches_p, char ***cntxts_p,
size_t *matched)
@ -1758,11 +1658,7 @@ static void cs_print_tags_priv(char **matches, char **cntxts,
xfree(buf);
}
/*
* PRIVATE: cs_read_prompt
*
* read a cscope prompt (basically, skip over the ">> ")
*/
/// Read a cscope prompt (basically, skip over the ">> ").
static int cs_read_prompt(size_t i)
{
int ch;
@ -1847,12 +1743,8 @@ static void sig_handler(int s) {
#endif
/*
* PRIVATE: cs_release_csp
*
* Does the actual free'ing for the cs ptr with an optional flag of whether
* or not to free the filename. Called by cs_kill and cs_reset.
*/
/// Does the actual free'ing for the cs ptr with an optional flag of whether
/// or not to free the filename. Called by cs_kill and cs_reset.
static void cs_release_csp(size_t i, int freefnpp)
{
// Trying to exit normally (not sure whether it is fit to Unix cscope)
@ -1964,11 +1856,7 @@ static void cs_release_csp(size_t i, int freefnpp)
} /* cs_release_csp */
/*
* PRIVATE: cs_reset
*
* calls cs_kill on all cscope connections then reinits
*/
/// Calls cs_kill on all cscope connections then reinits.
static int cs_reset(exarg_T *eap)
{
char **dblist = NULL, **pplist = NULL, **fllist = NULL;
@ -2018,17 +1906,13 @@ static int cs_reset(exarg_T *eap)
} /* cs_reset */
/*
* PRIVATE: cs_resolve_file
*
* Construct the full pathname to a file found in the cscope database.
* (Prepends ppath, if there is one and if it's not already prepended,
* otherwise just uses the name found.)
*
* We need to prepend the prefix because on some cscope's (e.g., the one that
* ships with Solaris 2.6), the output never has the prefix prepended.
* Contrast this with my development system (Digital Unix), which does.
*/
/// Construct the full pathname to a file found in the cscope database.
/// (Prepends ppath, if there is one and if it's not already prepended,
/// otherwise just uses the name found.)
///
/// We need to prepend the prefix because on some cscope's (e.g., the one that
/// ships with Solaris 2.6), the output never has the prefix prepended.
/// Contrast this with my development system (Digital Unix), which does.
static char *cs_resolve_file(size_t i, char *name)
{
char *fullname;
@ -2074,11 +1958,7 @@ static char *cs_resolve_file(size_t i, char *name)
}
/*
* PRIVATE: cs_show
*
* show all cscope connections
*/
/// Show all cscope connections.
static int cs_show(exarg_T *eap)
{
if (cs_cnt_connections() == 0)
@ -2106,11 +1986,7 @@ static int cs_show(exarg_T *eap)
} /* cs_show */
/*
* PUBLIC: cs_end
*
* Only called when VIM exits to quit any cscope sessions.
*/
/// Only called when VIM exits to quit any cscope sessions.
void cs_end(void)
{
for (size_t i = 0; i < csinfo_size; i++)

2
src/nvim/version.c
View File

@ -648,7 +648,7 @@ static const int included_patches[] = {
84,
83,
// 82 NA
// 81,
81,
// 80 NA
79,
78,