Merge remote-tracking branch 'upstream/master' into floattitlefloattitle

1 files changed, 275 insertions, 349 deletions

diff --git a/src/nvim/file_search.c b/src/nvim/file_search.c
index 2d09e7aa71..d9adf84acc 100644
--- a/src/nvim/file_search.c
+++ b/src/nvim/file_search.c
@@ -69,17 +69,14 @@
 #include "nvim/vim.h"
 #include "nvim/window.h"
 
-static char_u *ff_expand_buffer = NULL;  // used for expanding filenames
+static char *ff_expand_buffer = NULL;  // used for expanding filenames
 
-/*
- * type for the directory search stack
- */
+// type for the directory search stack
 typedef struct ff_stack {
   struct ff_stack *ffs_prev;
 
-  /* the fix part (no wildcards) and the part containing the wildcards
-   * of the search path
-   */
+  // the fix part (no wildcards) and the part containing the wildcards
+  // of the search path
   char_u *ffs_fix_path;
   char_u *ffs_wc_path;
 
@@ -89,98 +86,87 @@ typedef struct ff_stack {
   int ffs_filearray_size;
   int ffs_filearray_cur;                  // needed for partly handled dirs
 
-  /* to store status of partly handled directories
-   * 0: we work on this directory for the first time
-   * 1: this directory was partly searched in an earlier step
-   */
+  // to store status of partly handled directories
+  // 0: we work on this directory for the first time
+  // 1: this directory was partly searched in an earlier step
   int ffs_stage;
 
-  /* How deep are we in the directory tree?
-   * Counts backward from value of level parameter to vim_findfile_init
-   */
+  // How deep are we in the directory tree?
+  // Counts backward from value of level parameter to vim_findfile_init
   int ffs_level;
 
   // Did we already expand '**' to an empty string?
   int ffs_star_star_empty;
 } ff_stack_T;
 
-/*
- * type for already visited directories or files.
- */
+// type for already visited directories or files.
 typedef struct ff_visited {
   struct ff_visited *ffv_next;
 
-  /* Visited directories are different if the wildcard string are
-   * different. So we have to save it.
-   */
-  char_u *ffv_wc_path;
+  // Visited directories are different if the wildcard string are
+  // different. So we have to save it.
+  char *ffv_wc_path;
+
   // use FileID for comparison (needed because of links), else use filename.
   bool file_id_valid;
   FileID file_id;
-  /* The memory for this struct is allocated according to the length of
-   * ffv_fname.
-   */
-  char_u ffv_fname[1];                  // actually longer
+  // The memory for this struct is allocated according to the length of
+  // ffv_fname.
+  char ffv_fname[1];                  // actually longer
 } ff_visited_T;
 
-/*
- * We might have to manage several visited lists during a search.
- * This is especially needed for the tags option. If tags is set to:
- *      "./++/tags,./++/TAGS,++/tags"  (replace + with *)
- * So we have to do 3 searches:
- *   1) search from the current files directory downward for the file "tags"
- *   2) search from the current files directory downward for the file "TAGS"
- *   3) search from Vims current directory downwards for the file "tags"
- * As you can see, the first and the third search are for the same file, so for
- * the third search we can use the visited list of the first search. For the
- * second search we must start from an empty visited list.
- * The struct ff_visited_list_hdr is used to manage a linked list of already
- * visited lists.
- */
+// We might have to manage several visited lists during a search.
+// This is especially needed for the tags option. If tags is set to:
+//      "./++/tags,./++/TAGS,++/tags"  (replace + with *)
+// So we have to do 3 searches:
+//   1) search from the current files directory downward for the file "tags"
+//   2) search from the current files directory downward for the file "TAGS"
+//   3) search from Vims current directory downwards for the file "tags"
+// As you can see, the first and the third search are for the same file, so for
+// the third search we can use the visited list of the first search. For the
+// second search we must start from an empty visited list.
+// The struct ff_visited_list_hdr is used to manage a linked list of already
+// visited lists.
 typedef struct ff_visited_list_hdr {
   struct ff_visited_list_hdr *ffvl_next;
 
   // the filename the attached visited list is for
-  char_u *ffvl_filename;
+  char *ffvl_filename;
 
   ff_visited_T *ffvl_visited_list;
 } ff_visited_list_hdr_T;
 
-/*
- * '**' can be expanded to several directory levels.
- * Set the default maximum depth.
- */
+// '**' can be expanded to several directory levels.
+// Set the default maximum depth.
 #define FF_MAX_STAR_STAR_EXPAND ((char_u)30)
 
-/*
- * The search context:
- *   ffsc_stack_ptr:    the stack for the dirs to search
- *   ffsc_visited_list: the currently active visited list
- *   ffsc_dir_visited_list: the currently active visited list for search dirs
- *   ffsc_visited_lists_list: the list of all visited lists
- *   ffsc_dir_visited_lists_list: the list of all visited lists for search dirs
- *   ffsc_file_to_search:     the file to search for
- *   ffsc_start_dir:    the starting directory, if search path was relative
- *   ffsc_fix_path:     the fix part of the given path (without wildcards)
- *                      Needed for upward search.
- *   ffsc_wc_path:      the part of the given path containing wildcards
- *   ffsc_level:        how many levels of dirs to search downwards
- *   ffsc_stopdirs_v:   array of stop directories for upward search
- *   ffsc_find_what:    FINDFILE_BOTH, FINDFILE_DIR or FINDFILE_FILE
- *   ffsc_tagfile:      searching for tags file, don't use 'suffixesadd'
- */
+// The search context:
+//   ffsc_stack_ptr:    the stack for the dirs to search
+//   ffsc_visited_list: the currently active visited list
+//   ffsc_dir_visited_list: the currently active visited list for search dirs
+//   ffsc_visited_lists_list: the list of all visited lists
+//   ffsc_dir_visited_lists_list: the list of all visited lists for search dirs
+//   ffsc_file_to_search:     the file to search for
+//   ffsc_start_dir:    the starting directory, if search path was relative
+//   ffsc_fix_path:     the fix part of the given path (without wildcards)
+//                      Needed for upward search.
+//   ffsc_wc_path:      the part of the given path containing wildcards
+//   ffsc_level:        how many levels of dirs to search downwards
+//   ffsc_stopdirs_v:   array of stop directories for upward search
+//   ffsc_find_what:    FINDFILE_BOTH, FINDFILE_DIR or FINDFILE_FILE
+//   ffsc_tagfile:      searching for tags file, don't use 'suffixesadd'
 typedef struct ff_search_ctx_T {
   ff_stack_T *ffsc_stack_ptr;
   ff_visited_list_hdr_T *ffsc_visited_list;
   ff_visited_list_hdr_T *ffsc_dir_visited_list;
   ff_visited_list_hdr_T *ffsc_visited_lists_list;
   ff_visited_list_hdr_T *ffsc_dir_visited_lists_list;
-  char_u *ffsc_file_to_search;
-  char_u *ffsc_start_dir;
-  char_u *ffsc_fix_path;
-  char_u *ffsc_wc_path;
+  char *ffsc_file_to_search;
+  char *ffsc_start_dir;
+  char *ffsc_fix_path;
+  char *ffsc_wc_path;
   int ffsc_level;
-  char_u **ffsc_stopdirs_v;
+  char **ffsc_stopdirs_v;
   int ffsc_find_what;
   int ffsc_tagfile;
 } ff_search_ctx_T;
@@ -221,8 +207,8 @@ static char_u e_pathtoolong[] = N_("E854: path too long for completion");
 ///
 /// Upward search is only done on the starting dir.
 ///
-/// If 'free_visited' is TRUE the list of already visited files/directories is
-/// cleared. Set this to FALSE if you just want to search from another
+/// If 'free_visited' is true the list of already visited files/directories is
+/// cleared. Set this to false if you just want to search from another
 /// directory, but want to be sure that no directory from a previous search is
 /// searched again. This is useful if you search for a file at different places.
 /// The list of visited files/dirs can also be cleared with the function
@@ -246,17 +232,15 @@ static char_u e_pathtoolong[] = N_("E854: path too long for completion");
 ///
 /// @param tagfile  expanding names of tags files
 /// @param rel_fname  file name to use for "."
-void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int level,
-                        int free_visited, int find_what, void *search_ctx_arg, int tagfile,
-                        char_u *rel_fname)
+void *vim_findfile_init(char *path, char *filename, char *stopdirs, int level, int free_visited,
+                        int find_what, void *search_ctx_arg, int tagfile, char *rel_fname)
 {
-  char_u *wc_part;
+  char *wc_part;
   ff_stack_T *sptr;
   ff_search_ctx_T *search_ctx;
 
-  /* If a search context is given by the caller, reuse it, else allocate a
-   * new one.
-   */
+  // If a search context is given by the caller, reuse it, else allocate a
+  // new one.
   if (search_ctx_arg != NULL) {
     search_ctx = search_ctx_arg;
   } else {
@@ -269,12 +253,12 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
   ff_clear(search_ctx);
 
   // clear visited list if wanted
-  if (free_visited == TRUE) {
+  if (free_visited == true) {
     vim_findfile_free_visited(search_ctx);
   } else {
-    /* Reuse old visited lists. Get the visited list for the given
-     * filename. If no list for the current filename exists, creates a new
-     * one. */
+    // Reuse old visited lists. Get the visited list for the given
+    // filename. If no list for the current filename exists, creates a new
+    // one.
     search_ctx->ffsc_visited_list = ff_get_visited_list(filename,
                                                         &search_ctx->ffsc_visited_lists_list);
     if (search_ctx->ffsc_visited_list == NULL) {
@@ -291,25 +275,25 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
     ff_expand_buffer = xmalloc(MAXPATHL);
   }
 
-  /* Store information on starting dir now if path is relative.
-   * If path is absolute, we do that later.  */
+  // Store information on starting dir now if path is relative.
+  // If path is absolute, we do that later.
   if (path[0] == '.'
       && (vim_ispathsep(path[1]) || path[1] == NUL)
       && (!tagfile || vim_strchr(p_cpo, CPO_DOTTAG) == NULL)
       && rel_fname != NULL) {
-    size_t len = (size_t)((char_u *)path_tail((char *)rel_fname) - rel_fname);
+    size_t len = (size_t)(path_tail(rel_fname) - rel_fname);
 
-    if (!vim_isAbsName(rel_fname) && len + 1 < MAXPATHL) {
+    if (!vim_isAbsName((char_u *)rel_fname) && len + 1 < MAXPATHL) {
       // Make the start dir an absolute path name.
       STRLCPY(ff_expand_buffer, rel_fname, len + 1);
-      search_ctx->ffsc_start_dir = (char_u *)FullName_save((char *)ff_expand_buffer, FALSE);
+      search_ctx->ffsc_start_dir = FullName_save(ff_expand_buffer, false);
     } else {
-      search_ctx->ffsc_start_dir = vim_strnsave(rel_fname, len);
+      search_ctx->ffsc_start_dir = xstrnsave(rel_fname, len);
     }
     if (*++path != NUL) {
       path++;
     }
-  } else if (*path == NUL || !vim_isAbsName(path)) {
+  } else if (*path == NUL || !vim_isAbsName((char_u *)path)) {
 #ifdef BACKSLASH_IN_FILENAME
     // "c:dir" needs "c:" to be expanded, otherwise use current dir
     if (*path != NUL && path[1] == ':') {
@@ -326,15 +310,15 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
       path += 2;
     } else
 #endif
-    if (os_dirname(ff_expand_buffer, MAXPATHL) == FAIL) {
+    if (os_dirname((char_u *)ff_expand_buffer, MAXPATHL) == FAIL) {
       goto error_return;
     }
 
-    search_ctx->ffsc_start_dir = vim_strsave(ff_expand_buffer);
+    search_ctx->ffsc_start_dir = xstrdup(ff_expand_buffer);
 
 #ifdef BACKSLASH_IN_FILENAME
-    /* A path that starts with "/dir" is relative to the drive, not to the
-     * directory (but not for "//machine/dir").  Only use the drive name. */
+    // A path that starts with "/dir" is relative to the drive, not to the
+    // directory (but not for "//machine/dir").  Only use the drive name.
     if ((*path == '/' || *path == '\\')
         && path[1] != path[0]
         && search_ctx->ffsc_start_dir[1] == ':') {
@@ -343,17 +327,15 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
 #endif
   }
 
-  /*
-   * If stopdirs are given, split them into an array of pointers.
-   * If this fails (mem allocation), there is no upward search at all or a
-   * stop directory is not recognized -> continue silently.
-   * If stopdirs just contains a ";" or is empty,
-   * search_ctx->ffsc_stopdirs_v will only contain a  NULL pointer. This
-   * is handled as unlimited upward search.  See function
-   * ff_path_in_stoplist() for details.
-   */
+  // If stopdirs are given, split them into an array of pointers.
+  // If this fails (mem allocation), there is no upward search at all or a
+  // stop directory is not recognized -> continue silently.
+  // If stopdirs just contains a ";" or is empty,
+  // search_ctx->ffsc_stopdirs_v will only contain a  NULL pointer. This
+  // is handled as unlimited upward search.  See function
+  // ff_path_in_stoplist() for details.
   if (stopdirs != NULL) {
-    char_u *walker = stopdirs;
+    char *walker = stopdirs;
 
     while (*walker == ';') {
       walker++;
@@ -363,25 +345,21 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
     search_ctx->ffsc_stopdirs_v = xmalloc(sizeof(char_u *));
 
     do {
-      char_u *helper;
+      char *helper;
       void *ptr;
 
       helper = walker;
       ptr = xrealloc(search_ctx->ffsc_stopdirs_v,
                      (dircount + 1) * sizeof(char_u *));
       search_ctx->ffsc_stopdirs_v = ptr;
-      walker = (char_u *)vim_strchr((char *)walker, ';');
+      walker = vim_strchr(walker, ';');
       if (walker) {
         assert(walker - helper >= 0);
-        search_ctx->ffsc_stopdirs_v[dircount - 1] =
-          vim_strnsave(helper, (size_t)(walker - helper));
+        search_ctx->ffsc_stopdirs_v[dircount - 1] = xstrnsave(helper, (size_t)(walker - helper));
         walker++;
       } else {
-        /* this might be "", which means ascent till top
-         * of directory tree.
-         */
-        search_ctx->ffsc_stopdirs_v[dircount - 1] =
-          vim_strsave(helper);
+        // this might be "", which means ascent till top of directory tree.
+        search_ctx->ffsc_stopdirs_v[dircount - 1] = xstrdup(helper);
       }
 
       dircount++;
@@ -391,11 +369,10 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
 
   search_ctx->ffsc_level = level;
 
-  /* split into:
-   *  -fix path
-   *  -wildcard_stuff (might be NULL)
-   */
-  wc_part = (char_u *)vim_strchr((char *)path, '*');
+  // split into:
+  //  -fix path
+  //  -wildcard_stuff (might be NULL)
+  wc_part = vim_strchr(path, '*');
   if (wc_part != NULL) {
     int64_t llevel;
     int len;
@@ -403,17 +380,15 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
 
     // save the fix part of the path
     assert(wc_part - path >= 0);
-    search_ctx->ffsc_fix_path = vim_strnsave(path, (size_t)(wc_part - path));
-
-    /*
-     * copy wc_path and add restricts to the '**' wildcard.
-     * The octet after a '**' is used as a (binary) counter.
-     * So '**3' is transposed to '**^C' ('^C' is ASCII value 3)
-     * or '**76' is transposed to '**N'( 'N' is ASCII value 76).
-     * If no restrict is given after '**' the default is used.
-     * Due to this technique the path looks awful if you print it as a
-     * string.
-     */
+    search_ctx->ffsc_fix_path = xstrnsave(path, (size_t)(wc_part - path));
+
+    // copy wc_path and add restricts to the '**' wildcard.
+    // The octet after a '**' is used as a (binary) counter.
+    // So '**3' is transposed to '**^C' ('^C' is ASCII value 3)
+    // or '**76' is transposed to '**N'( 'N' is ASCII value 76).
+    // If no restrict is given after '**' the default is used.
+    // Due to this technique the path looks awful if you print it as a
+    // string.
     len = 0;
     while (*wc_part != NUL) {
       if (len + 5 >= MAXPATHL) {
@@ -424,16 +399,16 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
         ff_expand_buffer[len++] = *wc_part++;
         ff_expand_buffer[len++] = *wc_part++;
 
-        llevel = strtol((char *)wc_part, &errpt, 10);
-        if ((char_u *)errpt != wc_part && llevel > 0 && llevel < 255) {
-          ff_expand_buffer[len++] = (char_u)llevel;
-        } else if ((char_u *)errpt != wc_part && llevel == 0) {
+        llevel = strtol(wc_part, &errpt, 10);
+        if (errpt != wc_part && llevel > 0 && llevel < 255) {
+          ff_expand_buffer[len++] = (char)llevel;
+        } else if (errpt != wc_part && llevel == 0) {
           // restrict is 0 -> remove already added '**'
           len -= 2;
         } else {
           ff_expand_buffer[len++] = FF_MAX_STAR_STAR_EXPAND;
         }
-        wc_part = (char_u *)errpt;
+        wc_part = errpt;
         if (*wc_part != NUL && !vim_ispathsep(*wc_part)) {
           semsg(_(
                  "E343: Invalid path: '**[number]' must be at the end of the path or be followed by '%s'."),
@@ -445,40 +420,39 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
       }
     }
     ff_expand_buffer[len] = NUL;
-    search_ctx->ffsc_wc_path = vim_strsave(ff_expand_buffer);
+    search_ctx->ffsc_wc_path = xstrdup(ff_expand_buffer);
   } else {
-    search_ctx->ffsc_fix_path = vim_strsave(path);
+    search_ctx->ffsc_fix_path = xstrdup(path);
   }
 
   if (search_ctx->ffsc_start_dir == NULL) {
-    /* store the fix part as startdir.
-     * This is needed if the parameter path is fully qualified.
-     */
-    search_ctx->ffsc_start_dir = vim_strsave(search_ctx->ffsc_fix_path);
+    // store the fix part as startdir.
+    // This is needed if the parameter path is fully qualified.
+    search_ctx->ffsc_start_dir = xstrdup(search_ctx->ffsc_fix_path);
     search_ctx->ffsc_fix_path[0] = NUL;
   }
 
   // create an absolute path
-  if (STRLEN(search_ctx->ffsc_start_dir)
-      + STRLEN(search_ctx->ffsc_fix_path) + 3 >= MAXPATHL) {
+  if (strlen(search_ctx->ffsc_start_dir)
+      + strlen(search_ctx->ffsc_fix_path) + 3 >= MAXPATHL) {
     emsg(_(e_pathtoolong));
     goto error_return;
   }
   STRCPY(ff_expand_buffer, search_ctx->ffsc_start_dir);
-  add_pathsep((char *)ff_expand_buffer);
+  add_pathsep(ff_expand_buffer);
   {
-    size_t eb_len = STRLEN(ff_expand_buffer);
-    char_u *buf = xmalloc(eb_len + STRLEN(search_ctx->ffsc_fix_path) + 1);
+    size_t eb_len = strlen(ff_expand_buffer);
+    char_u *buf = xmalloc(eb_len + strlen(search_ctx->ffsc_fix_path) + 1);
 
     STRCPY(buf, ff_expand_buffer);
     STRCPY(buf + eb_len, search_ctx->ffsc_fix_path);
-    if (os_isdir(buf)) {
+    if (os_isdir((char *)buf)) {
       STRCAT(ff_expand_buffer, search_ctx->ffsc_fix_path);
-      add_pathsep((char *)ff_expand_buffer);
+      add_pathsep(ff_expand_buffer);
     } else {
-      char_u *p = (char_u *)path_tail((char *)search_ctx->ffsc_fix_path);
-      char_u *wc_path = NULL;
-      char_u *temp = NULL;
+      char *p = path_tail(search_ctx->ffsc_fix_path);
+      char *wc_path = NULL;
+      char *temp = NULL;
       int len = 0;
 
       if (p > search_ctx->ffsc_fix_path) {
@@ -489,16 +463,16 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
           xfree(buf);
           goto error_return;
         }
-        STRLCAT(ff_expand_buffer, search_ctx->ffsc_fix_path, eb_len + (size_t)len + 1);
-        add_pathsep((char *)ff_expand_buffer);
+        xstrlcat(ff_expand_buffer, search_ctx->ffsc_fix_path, eb_len + (size_t)len + 1);
+        add_pathsep(ff_expand_buffer);
       } else {
-        len = (int)STRLEN(search_ctx->ffsc_fix_path);
+        len = (int)strlen(search_ctx->ffsc_fix_path);
       }
 
       if (search_ctx->ffsc_wc_path != NULL) {
-        wc_path = vim_strsave(search_ctx->ffsc_wc_path);
-        temp = xmalloc(STRLEN(search_ctx->ffsc_wc_path)
-                       + STRLEN(search_ctx->ffsc_fix_path + len)
+        wc_path = xstrdup(search_ctx->ffsc_wc_path);
+        temp = xmalloc(strlen(search_ctx->ffsc_wc_path)
+                       + strlen(search_ctx->ffsc_fix_path + len)
                        + 1);
         STRCPY(temp, search_ctx->ffsc_fix_path + len);
         STRCAT(temp, search_ctx->ffsc_wc_path);
@@ -510,20 +484,16 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
     xfree(buf);
   }
 
-  sptr = ff_create_stack_element(ff_expand_buffer,
-                                 search_ctx->ffsc_wc_path,
-                                 level, 0);
+  sptr = ff_create_stack_element(ff_expand_buffer, search_ctx->ffsc_wc_path, level, 0);
 
   ff_push(search_ctx, sptr);
-  search_ctx->ffsc_file_to_search = vim_strsave(filename);
+  search_ctx->ffsc_file_to_search = xstrdup(filename);
   return search_ctx;
 
 error_return:
-  /*
-   * We clear the search context now!
-   * Even when the caller gave us a (perhaps valid) context we free it here,
-   * as we might have already destroyed it.
-   */
+  // We clear the search context now!
+  // Even when the caller gave us a (perhaps valid) context we free it here,
+  // as we might have already destroyed it.
   vim_findfile_cleanup(search_ctx);
   return NULL;
 }
@@ -535,8 +505,8 @@ char_u *vim_findfile_stopdir(char_u *buf)
 
   while (*r_ptr != NUL && *r_ptr != ';') {
     if (r_ptr[0] == '\\' && r_ptr[1] == ';') {
-      /* Overwrite the escape char,
-       * use STRLEN(r_ptr) to move the trailing '\0'. */
+      // Overwrite the escape char,
+      // use STRLEN(r_ptr) to move the trailing '\0'.
       STRMOVE(r_ptr, r_ptr + 1);
       r_ptr++;
     }
@@ -593,16 +563,13 @@ char_u *vim_findfile(void *search_ctx_arg)
 
   search_ctx = (ff_search_ctx_T *)search_ctx_arg;
 
-  /*
-   * filepath is used as buffer for various actions and as the storage to
-   * return a found filename.
-   */
+  // filepath is used as buffer for various actions and as the storage to
+  // return a found filename.
   file_path = xmalloc(MAXPATHL);
 
   // store the end of the start dir -- needed for upward search
   if (search_ctx->ffsc_start_dir != NULL) {
-    path_end = &search_ctx->ffsc_start_dir[
-                                           STRLEN(search_ctx->ffsc_start_dir)];
+    path_end = (char_u *)&search_ctx->ffsc_start_dir[strlen(search_ctx->ffsc_start_dir)];
   }
 
   // upward search loop
@@ -621,31 +588,26 @@ char_u *vim_findfile(void *search_ctx_arg)
         break;
       }
 
-      /*
-       * TODO: decide if we leave this test in
-       *
-       * GOOD: don't search a directory(-tree) twice.
-       * BAD:  - check linked list for every new directory entered.
-       *       - check for double files also done below
-       *
-       * Here we check if we already searched this directory.
-       * We already searched a directory if:
-       * 1) The directory is the same.
-       * 2) We would use the same wildcard string.
-       *
-       * Good if you have links on same directory via several ways
-       *  or you have selfreferences in directories (e.g. SuSE Linux 6.3:
-       *  /etc/rc.d/init.d is linked to /etc/rc.d -> endless loop)
-       *
-       * This check is only needed for directories we work on for the
-       * first time (hence stackp->ff_filearray == NULL)
-       */
+      // TODO(vim): decide if we leave this test in
+      //
+      // GOOD: don't search a directory(-tree) twice.
+      // BAD:  - check linked list for every new directory entered.
+      //       - check for double files also done below
+      //
+      // Here we check if we already searched this directory.
+      // We already searched a directory if:
+      // 1) The directory is the same.
+      // 2) We would use the same wildcard string.
+      //
+      // Good if you have links on same directory via several ways
+      //  or you have selfreferences in directories (e.g. SuSE Linux 6.3:
+      //  /etc/rc.d/init.d is linked to /etc/rc.d -> endless loop)
+      //
+      // This check is only needed for directories we work on for the
+      // first time (hence stackp->ff_filearray == NULL)
       if (stackp->ffs_filearray == NULL
-          && ff_check_visited(&search_ctx->ffsc_dir_visited_list
-                              ->ffvl_visited_list,
-                              stackp->ffs_fix_path,
-                              stackp->ffs_wc_path
-                              ) == FAIL) {
+          && ff_check_visited(&search_ctx->ffsc_dir_visited_list->ffvl_visited_list,
+                              (char *)stackp->ffs_fix_path, (char *)stackp->ffs_wc_path) == FAIL) {
 #ifdef FF_VERBOSE
         if (p_verbose >= 5) {
           verbose_enter_scroll();
@@ -676,25 +638,21 @@ char_u *vim_findfile(void *search_ctx_arg)
 
       file_path[0] = NUL;
 
-      /*
-       * If no filearray till now expand wildcards
-       * The function expand_wildcards() can handle an array of paths
-       * and all possible expands are returned in one array. We use this
-       * to handle the expansion of '**' into an empty string.
-       */
+      // If no filearray till now expand wildcards
+      // The function expand_wildcards() can handle an array of paths
+      // and all possible expands are returned in one array. We use this
+      // to handle the expansion of '**' into an empty string.
       if (stackp->ffs_filearray == NULL) {
         char *dirptrs[2];
 
-        /* we use filepath to build the path expand_wildcards() should
-         * expand.
-         */
+        // we use filepath to build the path expand_wildcards() should expand.
         dirptrs[0] = (char *)file_path;
         dirptrs[1] = NULL;
 
         // if we have a start dir copy it in
         if (!vim_isAbsName(stackp->ffs_fix_path)
             && search_ctx->ffsc_start_dir) {
-          if (STRLEN(search_ctx->ffsc_start_dir) + 1 >= MAXPATHL) {
+          if (strlen(search_ctx->ffsc_start_dir) + 1 >= MAXPATHL) {
             ff_free_stack_element(stackp);
             goto fail;
           }
@@ -747,13 +705,11 @@ char_u *vim_findfile(void *search_ctx_arg)
             }
           }
 
-          /*
-           * Here we copy until the next path separator or the end of
-           * the path. If we stop at a path separator, there is
-           * still something else left. This is handled below by
-           * pushing every directory returned from expand_wildcards()
-           * on the stack again for further search.
-           */
+          // Here we copy until the next path separator or the end of
+          // the path. If we stop at a path separator, there is
+          // still something else left. This is handled below by
+          // pushing every directory returned from expand_wildcards()
+          // on the stack again for further search.
           while (*rest_of_wildcards
                  && !vim_ispathsep(*rest_of_wildcards)) {
             if (len + 1 >= MAXPATHL) {
@@ -769,18 +725,16 @@ char_u *vim_findfile(void *search_ctx_arg)
           }
         }
 
-        /*
-         * Expand wildcards like "*" and "$VAR".
-         * If the path is a URL don't try this.
-         */
+        // Expand wildcards like "*" and "$VAR".
+        // If the path is a URL don't try this.
         if (path_with_url(dirptrs[0])) {
           stackp->ffs_filearray = xmalloc(sizeof(char *));
           stackp->ffs_filearray[0] = xstrdup(dirptrs[0]);
           stackp->ffs_filearray_size = 1;
         } else {
-          /* Add EW_NOTWILD because the expanded path may contain
-           * wildcard characters that are to be taken literally.
-           * This is a bit of a hack. */
+          // Add EW_NOTWILD because the expanded path may contain
+          // wildcard characters that are to be taken literally.
+          // This is a bit of a hack.
           expand_wildcards((dirptrs[1] == NULL) ? 1 : 2, dirptrs,
                            &stackp->ffs_filearray_size,
                            &stackp->ffs_filearray,
@@ -790,25 +744,22 @@ char_u *vim_findfile(void *search_ctx_arg)
         stackp->ffs_filearray_cur = 0;
         stackp->ffs_stage = 0;
       } else {
-        rest_of_wildcards = &stackp->ffs_wc_path[
-                                                 STRLEN(stackp->ffs_wc_path)];
+        rest_of_wildcards = &stackp->ffs_wc_path[STRLEN(stackp->ffs_wc_path)];
       }
 
       if (stackp->ffs_stage == 0) {
         // this is the first time we work on this directory
         if (*rest_of_wildcards == NUL) {
-          /*
-           * We don't have further wildcards to expand, so we have to
-           * check for the final file now.
-           */
+          // We don't have further wildcards to expand, so we have to
+          // check for the final file now.
           for (int i = stackp->ffs_filearray_cur; i < stackp->ffs_filearray_size; i++) {
             if (!path_with_url(stackp->ffs_filearray[i])
-                && !os_isdir((char_u *)stackp->ffs_filearray[i])) {
+                && !os_isdir(stackp->ffs_filearray[i])) {
               continue;                 // not a directory
             }
             // prepare the filename to be checked for existence below
-            if (STRLEN(stackp->ffs_filearray[i]) + 1
-                + STRLEN(search_ctx->ffsc_file_to_search) >= MAXPATHL) {
+            if (strlen(stackp->ffs_filearray[i]) + 1
+                + strlen(search_ctx->ffsc_file_to_search) >= MAXPATHL) {
               ff_free_stack_element(stackp);
               goto fail;
             }
@@ -819,37 +770,29 @@ char_u *vim_findfile(void *search_ctx_arg)
             }
             STRCAT(file_path, search_ctx->ffsc_file_to_search);
 
-            /*
-             * Try without extra suffix and then with suffixes
-             * from 'suffixesadd'.
-             */
+            // Try without extra suffix and then with suffixes
+            // from 'suffixesadd'.
             len = STRLEN(file_path);
             if (search_ctx->ffsc_tagfile) {
               suf = "";
             } else {
-              suf = (char *)curbuf->b_p_sua;
+              suf = curbuf->b_p_sua;
             }
             for (;;) {
               // if file exists and we didn't already find it
               if ((path_with_url((char *)file_path)
-                   || (os_path_exists(file_path)
-                       && (search_ctx->ffsc_find_what
-                           == FINDFILE_BOTH
-                           || ((search_ctx->ffsc_find_what
-                                == FINDFILE_DIR)
-                               == os_isdir(file_path)))))
+                   || (os_path_exists((char *)file_path)
+                       && (search_ctx->ffsc_find_what == FINDFILE_BOTH
+                           || ((search_ctx->ffsc_find_what == FINDFILE_DIR)
+                               == os_isdir((char *)file_path)))))
 #ifndef FF_VERBOSE
                   && (ff_check_visited(&search_ctx->ffsc_visited_list->ffvl_visited_list,
-                                       file_path,
-                                       (char_u *)""
-                                       ) == OK)
+                                       (char *)file_path, "") == OK)
 #endif
                   ) {
 #ifdef FF_VERBOSE
                 if (ff_check_visited(&search_ctx->ffsc_visited_list->ffvl_visited_list,
-                                     file_path,
-                                     (char_u *)""
-                                     ) == FAIL) {
+                                     file_path, (char_u *)"") == FAIL) {
                   if (p_verbose >= 5) {
                     verbose_enter_scroll();
                     smsg("Already: %s", file_path);
@@ -868,10 +811,9 @@ char_u *vim_findfile(void *search_ctx_arg)
                 if (!path_with_url((char *)file_path)) {
                   simplify_filename(file_path);
                 }
-                if (os_dirname(ff_expand_buffer, MAXPATHL)
+                if (os_dirname((char_u *)ff_expand_buffer, MAXPATHL)
                     == OK) {
-                  p = path_shorten_fname(file_path,
-                                         ff_expand_buffer);
+                  p = (char_u *)path_shorten_fname((char *)file_path, ff_expand_buffer);
                   if (p != NULL) {
                     STRMOVE(file_path, p);
                   }
@@ -898,12 +840,12 @@ char_u *vim_findfile(void *search_ctx_arg)
         } else {
           // still wildcards left, push the directories for further search
           for (int i = stackp->ffs_filearray_cur; i < stackp->ffs_filearray_size; i++) {
-            if (!os_isdir((char_u *)stackp->ffs_filearray[i])) {
+            if (!os_isdir(stackp->ffs_filearray[i])) {
               continue;                 // not a directory
             }
             ff_push(search_ctx,
-                    ff_create_stack_element((char_u *)stackp->ffs_filearray[i],
-                                            rest_of_wildcards,
+                    ff_create_stack_element(stackp->ffs_filearray[i],
+                                            (char *)rest_of_wildcards,
                                             stackp->ffs_level - 1, 0));
           }
         }
@@ -911,23 +853,21 @@ char_u *vim_findfile(void *search_ctx_arg)
         stackp->ffs_stage = 1;
       }
 
-      /*
-       * if wildcards contains '**' we have to descent till we reach the
-       * leaves of the directory tree.
-       */
+      // if wildcards contains '**' we have to descent till we reach the
+      // leaves of the directory tree.
       if (STRNCMP(stackp->ffs_wc_path, "**", 2) == 0) {
         for (int i = stackp->ffs_filearray_cur;
              i < stackp->ffs_filearray_size; i++) {
-          if (FNAMECMP(stackp->ffs_filearray[i],
-                       stackp->ffs_fix_path) == 0) {
+          if (path_fnamecmp(stackp->ffs_filearray[i],
+                            (char *)stackp->ffs_fix_path) == 0) {
             continue;             // don't repush same directory
           }
-          if (!os_isdir((char_u *)stackp->ffs_filearray[i])) {
+          if (!os_isdir(stackp->ffs_filearray[i])) {
             continue;               // not a directory
           }
           ff_push(search_ctx,
-                  ff_create_stack_element((char_u *)stackp->ffs_filearray[i],
-                                          stackp->ffs_wc_path, stackp->ffs_level - 1, 1));
+                  ff_create_stack_element(stackp->ffs_filearray[i],
+                                          (char *)stackp->ffs_wc_path, stackp->ffs_level - 1, 1));
         }
       }
 
@@ -935,27 +875,24 @@ char_u *vim_findfile(void *search_ctx_arg)
       ff_free_stack_element(stackp);
     }
 
-    /* If we reached this, we didn't find anything downwards.
-     * Let's check if we should do an upward search.
-     */
+    // If we reached this, we didn't find anything downwards.
+    // Let's check if we should do an upward search.
     if (search_ctx->ffsc_start_dir
         && search_ctx->ffsc_stopdirs_v != NULL && !got_int) {
       ff_stack_T *sptr;
 
       // is the last starting directory in the stop list?
       if (ff_path_in_stoplist(search_ctx->ffsc_start_dir,
-                              (int)(path_end - search_ctx->ffsc_start_dir),
-                              search_ctx->ffsc_stopdirs_v) == TRUE) {
+                              (int)(path_end - (char_u *)search_ctx->ffsc_start_dir),
+                              search_ctx->ffsc_stopdirs_v) == true) {
         break;
       }
 
       // cut of last dir
-      while (path_end > search_ctx->ffsc_start_dir
-             && vim_ispathsep(*path_end)) {
+      while (path_end > (char_u *)search_ctx->ffsc_start_dir && vim_ispathsep(*path_end)) {
         path_end--;
       }
-      while (path_end > search_ctx->ffsc_start_dir
-             && !vim_ispathsep(path_end[-1])) {
+      while (path_end > (char_u *)search_ctx->ffsc_start_dir && !vim_ispathsep(path_end[-1])) {
         path_end--;
       }
       *path_end = 0;
@@ -965,8 +902,8 @@ char_u *vim_findfile(void *search_ctx_arg)
         break;
       }
 
-      if (STRLEN(search_ctx->ffsc_start_dir) + 1
-          + STRLEN(search_ctx->ffsc_fix_path) >= MAXPATHL) {
+      if (strlen(search_ctx->ffsc_start_dir) + 1
+          + strlen(search_ctx->ffsc_fix_path) >= MAXPATHL) {
         goto fail;
       }
       STRCPY(file_path, search_ctx->ffsc_start_dir);
@@ -976,7 +913,7 @@ char_u *vim_findfile(void *search_ctx_arg)
       STRCAT(file_path, search_ctx->ffsc_fix_path);
 
       // create a new stack entry
-      sptr = ff_create_stack_element(file_path,
+      sptr = ff_create_stack_element((char *)file_path,
                                      search_ctx->ffsc_wc_path, search_ctx->ffsc_level, 0);
       ff_push(search_ctx, sptr);
     } else {
@@ -1034,7 +971,7 @@ static void ff_free_visited_list(ff_visited_T *vl)
 
 /// @return  the already visited list for the given filename. If none is found it
 ///          allocates a new one.
-static ff_visited_list_hdr_T *ff_get_visited_list(char_u *filename,
+static ff_visited_list_hdr_T *ff_get_visited_list(char *filename,
                                                   ff_visited_list_hdr_T **list_headp)
 {
   ff_visited_list_hdr_T *retptr = NULL;
@@ -1043,7 +980,7 @@ static ff_visited_list_hdr_T *ff_get_visited_list(char_u *filename,
   if (*list_headp != NULL) {
     retptr = *list_headp;
     while (retptr != NULL) {