/* 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.

*/

/*

* findfile.c: Search for files in directories listed in 'path'

*/

#include "vim.h"

/*

* File searching functions for 'path', 'tags' and 'cdpath' options.

* External visible functions:

* vim_findfile_init() creates/initialises the search context

* vim_findfile_free_visited() free list of visited files/dirs of search

* context

* vim_findfile() find a file in the search context

* vim_findfile_cleanup() cleanup/free search context created by

* vim_findfile_init()

*

* All static functions and variables start with 'ff_'

*

* In general it works like this:

* First you create yourself a search context by calling vim_findfile_init().

* It is possible to give a search context from a previous call to

* vim_findfile_init(), so it can be reused. After this you call vim_findfile()

* until you are satisfied with the result or it returns NULL. On every call it

* returns the next file which matches the conditions given to

* vim_findfile_init(). If it doesn't find a next file it returns NULL.

*

* It is possible to call vim_findfile_init() again to reinitialise your search

* with some new parameters. Don't forget to pass your old search context to

* it, so it can reuse it and especially reuse the list of already visited

* directories. If you want to delete the list of already visited directories

* simply call vim_findfile_free_visited().

*

* When you are done call vim_findfile_cleanup() to free the search context.

*

* The function vim_findfile_init() has a long comment, which describes the

* needed parameters.

*

*

*

* ATTENTION:

* ==========

* Also we use an allocated search context here, these functions are NOT

* thread-safe!

*

* To minimize parameter passing (or because I'm to lazy), only the

* external visible functions get a search context as a parameter. This is

* then assigned to a static global, which is used throughout the local

* functions.

*/

/*

* 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

string_T ffs_fix_path;

string_T ffs_wc_path;

// files/dirs found in the above directory, matched by the first wildcard

// of wc_part

char_u **ffs_filearray;

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

int ffs_stage;

// 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.

*/

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;

// for unix use inode etc for comparison (needed because of links), else

// use filename.

#ifdef UNIX

int ffv_dev_valid; // ffv_dev and ffv_ino were set

dev_t ffv_dev; // device number

ino_t ffv_ino; // inode number

#endif

// The memory for this struct is allocated according to the length of

// ffv_fname.

char_u 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 a 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;

ff_visited_T *ffvl_visited_list;

} ff_visited_list_hdr_T;

/*

* '**' 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'

*/

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;

string_T ffsc_file_to_search;

string_T ffsc_start_dir;

string_T ffsc_fix_path;

string_T ffsc_wc_path;

int ffsc_level;

string_T *ffsc_stopdirs_v;

int ffsc_find_what;

int ffsc_tagfile;

} ff_search_ctx_T;

// locally needed functions

static int ff_check_visited(ff_visited_T **, char_u *, size_t, char_u *, size_t);

static void vim_findfile_free_visited(void *search_ctx_arg);

static void vim_findfile_free_visited_list(ff_visited_list_hdr_T **list_headp);

static void ff_free_visited_list(ff_visited_T *vl);

static ff_visited_list_hdr_T* ff_get_visited_list(char_u *, size_t, ff_visited_list_hdr_T **list_headp);

static void ff_push(ff_search_ctx_T *search_ctx, ff_stack_T *stack_ptr);

static ff_stack_T *ff_pop(ff_search_ctx_T *search_ctx);

static void ff_clear(ff_search_ctx_T *search_ctx);

static void ff_free_stack_element(ff_stack_T *stack_ptr);

static ff_stack_T *ff_create_stack_element(char_u *, size_t, char_u *, size_t, int, int);

static int ff_path_in_stoplist(char_u *, int, string_T *);

static string_T ff_expand_buffer = {NULL, 0}; // used for expanding filenames

#if 0

/*

* if someone likes findfirst/findnext, here are the functions

* NOT TESTED!!

*/

static void *ff_fn_search_context = NULL;

char_u *

vim_findfirst(char_u *path, char_u *filename, int level)

{

ff_fn_search_context =

vim_findfile_init(path, filename, NULL, level, TRUE, FALSE,

ff_fn_search_context, rel_fname);

if (NULL == ff_fn_search_context)

return NULL;

else

return vim_findnext()

}

char_u *

vim_findnext(void)

{

char_u *ret = vim_findfile(ff_fn_search_context);

if (NULL == ret)

{

vim_findfile_cleanup(ff_fn_search_context);

ff_fn_search_context = NULL;

}

return ret;

}

#endif

/*

* Initialization routine for vim_findfile().

*

* Returns the newly allocated search context or NULL if an error occurred.

*

* Don't forget to clean up by calling vim_findfile_cleanup() if you are done

* with the search context.

*

* Find the file 'filename' in the directory 'path'.

* The parameter 'path' may contain wildcards. If so only search 'level'

* directories deep. The parameter 'level' is the absolute maximum and is

* not related to restricts given to the '**' wildcard. If 'level' is 100

* and you use '**200' vim_findfile() will stop after 100 levels.

*

* 'filename' cannot contain wildcards! It is used as-is, no backslashes to

* escape special characters.

*

* If 'stopdirs' is not NULL and nothing is found downward, the search is

* restarted on the next higher directory level. This is repeated until the

* start-directory of a search is contained in 'stopdirs'. 'stopdirs' has the

* format ";*<dirname>*\(;<dirname>\)*;\=$".

*

* If the 'path' is relative, the starting dir for the search is either VIM's

* current dir or if the path starts with "./" the current files dir.

* If the 'path' is absolute, the starting dir is that part of the path before

* the first wildcard.

*

* 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

* 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

* vim_findfile_free_visited().

*

* Set the parameter 'find_what' to FINDFILE_DIR if you want to search for

* directories only, FINDFILE_FILE for files only, FINDFILE_BOTH for both.

*

* A search context returned by a previous call to vim_findfile_init() can be

* passed in the parameter "search_ctx_arg". This context is reused and

* reinitialized with the new parameters. The list of already visited

* directories from this context is only deleted if the parameter

* "free_visited" is true. Be aware that the passed "search_ctx_arg" is freed

* if the reinitialization fails.

*

* If you don't have a search context from a previous call "search_ctx_arg"

* must be NULL.

*

* This function silently ignores a few errors, vim_findfile() will have

* limited functionality then.

*/

void *

vim_findfile_init(

char_u *path,

char_u *filename,

size_t filenamelen,

char_u *stopdirs UNUSED,

int level,

int free_visited,

int find_what,

void *search_ctx_arg,

int tagfile, // expanding names of tags files

char_u *rel_fname) // file name to use for "."

{

char_u *wc_part;

ff_stack_T *sptr;

ff_search_ctx_T *search_ctx;

int add_sep;

// 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

{

search_ctx = ALLOC_CLEAR_ONE(ff_search_ctx_T);

if (search_ctx == NULL)

goto error_return;

}

search_ctx->ffsc_find_what = find_what;

search_ctx->ffsc_tagfile = tagfile;

// clear the search context, but NOT the visited lists

ff_clear(search_ctx);

// clear visited list if wanted

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.

search_ctx->ffsc_visited_list = ff_get_visited_list(filename,

filenamelen, &search_ctx->ffsc_visited_lists_list);

if (search_ctx->ffsc_visited_list == NULL)

goto error_return;

search_ctx->ffsc_dir_visited_list = ff_get_visited_list(filename,

filenamelen, &search_ctx->ffsc_dir_visited_lists_list);

if (search_ctx->ffsc_dir_visited_list == NULL)

goto error_return;

}

if (ff_expand_buffer.string == NULL)

{

ff_expand_buffer.length = 0;

ff_expand_buffer.string = alloc(MAXPATHL);

if (ff_expand_buffer.string == NULL)

goto error_return;

}

// 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)

{

int len = (int)(gettail(rel_fname) - rel_fname);

if (!vim_isAbsName(rel_fname) && len + 1 < MAXPATHL)

{

// Make the start dir an absolute path name.

vim_strncpy(ff_expand_buffer.string, rel_fname, len);

ff_expand_buffer.length = len;

search_ctx->ffsc_start_dir.string = FullName_save(ff_expand_buffer.string, FALSE);

if (search_ctx->ffsc_start_dir.string == NULL)

goto error_return;

search_ctx->ffsc_start_dir.length = STRLEN(search_ctx->ffsc_start_dir.string);

}

else

{

search_ctx->ffsc_start_dir.length = len;

search_ctx->ffsc_start_dir.string = vim_strnsave(rel_fname,

search_ctx->ffsc_start_dir.length);

if (search_ctx->ffsc_start_dir.string == NULL)

goto error_return;

}

if (*++path != NUL)

++path;

}

else if (*path == NUL || !vim_isAbsName(path))

{

#ifdef BACKSLASH_IN_FILENAME

// "c:dir" needs "c:" to be expanded, otherwise use current dir

if (*path != NUL && path[1] == ':')

{

char_u drive[3];

drive[0] = path[0];

drive[1] = ':';

drive[2] = NUL;

if (vim_FullName(drive, ff_expand_buffer.string, MAXPATHL, TRUE) == FAIL)

goto error_return;

path += 2;

}

else

#endif

if (mch_dirname(ff_expand_buffer.string, MAXPATHL) == FAIL)

goto error_return;

ff_expand_buffer.length = STRLEN(ff_expand_buffer.string);

search_ctx->ffsc_start_dir.length = ff_expand_buffer.length;

search_ctx->ffsc_start_dir.string = vim_strnsave(ff_expand_buffer.string,

search_ctx->ffsc_start_dir.length);

if (search_ctx->ffsc_start_dir.string == NULL)

goto error_return;

}

/*

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

int dircount;

while (*walker == ';')

walker++;

dircount = 1;

search_ctx->ffsc_stopdirs_v = ALLOC_ONE(string_T);

if (search_ctx->ffsc_stopdirs_v != NULL)

{

string_T *tmp; // for convenience

do

{

char_u *helper;

void *ptr;

size_t len;

helper = walker;

ptr = vim_realloc(search_ctx->ffsc_stopdirs_v,

(dircount + 1) * sizeof(string_T));

if (ptr)

search_ctx->ffsc_stopdirs_v = ptr;

else

// ignore, keep what we have and continue

break;

walker = vim_strchr(walker, ';');

len = walker ? (size_t)(walker - helper) : STRLEN(helper);

// "" means ascent till top of directory tree.

if (*helper != NUL && !vim_isAbsName(helper)

&& len + 1 < MAXPATHL)

{

// Make the stop dir an absolute path name.

vim_strncpy(ff_expand_buffer.string, helper, len);

ff_expand_buffer.length = len;

tmp = &search_ctx->ffsc_stopdirs_v[dircount - 1];

tmp->string = FullName_save(ff_expand_buffer.string, FALSE);

if (tmp->string != NULL)

tmp->length = STRLEN(tmp->string);

}

else

{

tmp = &search_ctx->ffsc_stopdirs_v[dircount - 1];

tmp->length = len;

tmp->string = vim_strnsave(helper, tmp->length);

if (tmp->string == NULL)

tmp->length = 0;

}

if (walker)

walker++;

dircount++;

} while (walker != NULL);

tmp = &search_ctx->ffsc_stopdirs_v[dircount - 1];

tmp->string = NULL;

tmp->length = 0;

}

}

search_ctx->ffsc_level = level;

/*

* split into:

* -fix path

* -wildcard_stuff (might be NULL)

*/

wc_part = vim_strchr(path, '*');

if (wc_part != NULL)

{

int llevel;

char *errpt;

// save the fix part of the path

search_ctx->ffsc_fix_path.length = (size_t)(wc_part - path);

search_ctx->ffsc_fix_path.string = vim_strnsave(path,

search_ctx->ffsc_fix_path.length);

if (search_ctx->ffsc_fix_path.string == NULL)

goto error_return;

/*

* 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.

*/

ff_expand_buffer.length = 0;

while (*wc_part != NUL)

{

if (ff_expand_buffer.length + 5 >= MAXPATHL)

{

emsg(_(e_path_too_long_for_completion));

break;

}

if (STRNCMP(wc_part, "**", 2) == 0)

{

ff_expand_buffer.string[ff_expand_buffer.length++] = *wc_part++;

ff_expand_buffer.string[ff_expand_buffer.length++] = *wc_part++;

llevel = strtol((char *)wc_part, &errpt, 10);

if ((char_u *)errpt != wc_part && llevel > 0 && llevel < 255)

ff_expand_buffer.string[ff_expand_buffer.length++] = llevel;

else if ((char_u *)errpt != wc_part && llevel == 0)

// restrict is 0 -> remove already added '**'

ff_expand_buffer.length -= 2;

else

ff_expand_buffer.string[ff_expand_buffer.length++] = FF_MAX_STAR_STAR_EXPAND;

wc_part = (char_u *)errpt;

if (*wc_part != NUL && !vim_ispathsep(*wc_part))

{

semsg(_(e_invalid_path_number_must_be_at_end_of_path_or_be_followed_by_str), PATHSEPSTR);

goto error_return;

}

}

else

ff_expand_buffer.string[ff_expand_buffer.length++] = *wc_part++;

}

ff_expand_buffer.string[ff_expand_buffer.length] = NUL;

search_ctx->ffsc_wc_path.length = ff_expand_buffer.length;

search_ctx->ffsc_wc_path.string = vim_strnsave(ff_expand_buffer.string,

search_ctx->ffsc_wc_path.length);

if (search_ctx->ffsc_wc_path.string == NULL)

goto error_return;

}

else

{

search_ctx->ffsc_fix_path.length = STRLEN(path);

search_ctx->ffsc_fix_path.string = vim_strnsave(path,

search_ctx->ffsc_fix_path.length);

if (search_ctx->ffsc_fix_path.string == NULL)

goto error_return;

}

if (search_ctx->ffsc_start_dir.string == NULL)

{

// store the fix part as startdir.

// This is needed if the parameter path is fully qualified.

search_ctx->ffsc_start_dir.length = search_ctx->ffsc_fix_path.length;

search_ctx->ffsc_start_dir.string = vim_strnsave(search_ctx->ffsc_fix_path.string,

search_ctx->ffsc_start_dir.length);

if (search_ctx->ffsc_start_dir.string == NULL)

goto error_return;

search_ctx->ffsc_fix_path.string[0] = NUL;

search_ctx->ffsc_fix_path.length = 0;

}

// create an absolute path

if (search_ctx->ffsc_start_dir.length

+ search_ctx->ffsc_fix_path.length + 3 >= MAXPATHL)

{

emsg(_(e_path_too_long_for_completion));

goto error_return;

}

add_sep = !after_pathsep(search_ctx->ffsc_start_dir.string,

search_ctx->ffsc_start_dir.string + search_ctx->ffsc_start_dir.length);

ff_expand_buffer.length = vim_snprintf(

(char *)ff_expand_buffer.string,

MAXPATHL,

"%s%s",

search_ctx->ffsc_start_dir.string,

add_sep ? PATHSEPSTR : "");

{

size_t bufsize = ff_expand_buffer.length + search_ctx->ffsc_fix_path.length + 1;

char_u *buf = alloc(bufsize);

if (buf == NULL)

goto error_return;

vim_snprintf(

(char *)buf,

bufsize,

"%s%s",

ff_expand_buffer.string,

search_ctx->ffsc_fix_path.string);

if (mch_isdir(buf))

{

if (search_ctx->ffsc_fix_path.length > 0)

{

add_sep = !after_pathsep(search_ctx->ffsc_fix_path.string,

search_ctx->ffsc_fix_path.string + search_ctx->ffsc_fix_path.length);

ff_expand_buffer.length += vim_snprintf(

(char *)ff_expand_buffer.string + ff_expand_buffer.length,

MAXPATHL - ff_expand_buffer.length,

"%s%s",

search_ctx->ffsc_fix_path.string,

add_sep ? PATHSEPSTR : "");

}

}

else

{

char_u *p = gettail(search_ctx->ffsc_fix_path.string);

int len = (int)search_ctx->ffsc_fix_path.length;

if (p > search_ctx->ffsc_fix_path.string)

{

// do not add '..' to the path and start upwards searching

len = (int)(p - search_ctx->ffsc_fix_path.string) - 1;

if ((len >= 2

&& STRNCMP(search_ctx->ffsc_fix_path.string, "..", 2) == 0)

&& (len == 2 || search_ctx->ffsc_fix_path.string[2] == PATHSEP))

{

vim_free(buf);

goto error_return;

}

add_sep = !after_pathsep(search_ctx->ffsc_fix_path.string,

search_ctx->ffsc_fix_path.string + search_ctx->ffsc_fix_path.length);

ff_expand_buffer.length += vim_snprintf(

(char *)ff_expand_buffer.string + ff_expand_buffer.length,

MAXPATHL - ff_expand_buffer.length,

"%.*s%s",

len,

search_ctx->ffsc_fix_path.string,

add_sep ? PATHSEPSTR : "");

}

if (search_ctx->ffsc_wc_path.string != NULL)

{

size_t tempsize = (search_ctx->ffsc_fix_path.length - len)

+ search_ctx->ffsc_wc_path.length

+ 1;

char_u *temp = alloc(tempsize);

if (temp == NULL)

{

vim_free(buf);

vim_free(temp);

goto error_return;

}

search_ctx->ffsc_wc_path.length = vim_snprintf(

(char *)temp,

tempsize,

"%s%s",

search_ctx->ffsc_fix_path.string + len,

search_ctx->ffsc_wc_path.string);

vim_free(search_ctx->ffsc_wc_path.string);

search_ctx->ffsc_wc_path.string = temp;

}

}

vim_free(buf);

}

sptr = ff_create_stack_element(ff_expand_buffer.string,

ff_expand_buffer.length,

search_ctx->ffsc_wc_path.string,

search_ctx->ffsc_wc_path.length,

level,

0);

if (sptr == NULL)

goto error_return;

ff_push(search_ctx, sptr);

search_ctx->ffsc_file_to_search.length = filenamelen;

search_ctx->ffsc_file_to_search.string = vim_strnsave(filename,

search_ctx->ffsc_file_to_search.length);

if (search_ctx->ffsc_file_to_search.string == NULL)

goto error_return;

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.

*/

vim_findfile_cleanup(search_ctx);

return NULL;

}

/*

* Get the stopdir string. Check that ';' is not escaped.

*/

char_u *

vim_findfile_stopdir(char_u *buf)

{

char_u *r_ptr = buf;

char_u *r_ptr_end = NULL; // points to NUL at end of string "r_ptr"

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'.

if (r_ptr_end == NULL)

r_ptr_end = r_ptr + STRLEN(r_ptr);

mch_memmove(r_ptr, r_ptr + 1,

(size_t)(r_ptr_end - (r_ptr + 1)) + 1); // +1 for NUL

r_ptr++;

--r_ptr_end;

}

r_ptr++;

}

if (*r_ptr == ';')

{

*r_ptr = NUL;

r_ptr++;

}

else if (*r_ptr == NUL)

r_ptr = NULL;

return r_ptr;

}

/*

* Clean up the given search context. Can handle a NULL pointer.

*/

void

vim_findfile_cleanup(void *ctx)

{

if (ctx == NULL)

return;

vim_findfile_free_visited(ctx);

ff_clear(ctx);

vim_free(ctx);

}

/*

* Find a file in a search context.

* The search context was created with vim_findfile_init() above.

* Return a pointer to an allocated file name or NULL if nothing found.

* To get all matching files call this function until you get NULL.

*

* If the passed search_context is NULL, NULL is returned.

*

* The search algorithm is depth first. To change this replace the

* stack with a list (don't forget to leave partly searched directories on the

* top of the list).

*/

char_u *

vim_findfile(void *search_ctx_arg)

{

string_T file_path;

string_T rest_of_wildcards;

char_u *path_end = NULL;

ff_stack_T *stackp;

ff_search_ctx_T *search_ctx;

if (search_ctx_arg == NULL)

return NULL;

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.

*/

if ((file_path.string = alloc(MAXPATHL)) == NULL)

return NULL;

// store the end of the start dir -- needed for upward search

if (search_ctx->ffsc_start_dir.string != NULL)

path_end = &search_ctx->ffsc_start_dir.string[

search_ctx->ffsc_start_dir.length];

// upward search loop

for (;;)

{

// downward search loop

for (;;)

{

// check if user wants to stop the search

ui_breakcheck();

if (got_int)

break;

// get directory to work on from stack

stackp = ff_pop(search_ctx);

if (stackp == NULL)

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)

*/

if (stackp->ffs_filearray == NULL

&& ff_check_visited(&search_ctx->ffsc_dir_visited_list

->ffvl_visited_list,

stackp->ffs_fix_path.string,

stackp->ffs_fix_path.length,

stackp->ffs_wc_path.string,

stackp->ffs_wc_path.length) == FAIL)

{

#ifdef FF_VERBOSE

if (p_verbose >= 5)

{

verbose_enter_scroll();

smsg("Already Searched: %s (%s)",

stackp->ffs_fix_path.string, stackp->ffs_wc_path.string);

// don't overwrite this either

msg_puts("\n");

verbose_leave_scroll();

}

#endif

ff_free_stack_element(stackp);

continue;

}

#ifdef FF_VERBOSE

else if (p_verbose >= 5)

{

verbose_enter_scroll();

smsg("Searching: %s (%s)",

stackp->ffs_fix_path.string, stackp->ffs_wc_path.string);

// don't overwrite this either

msg_puts("\n");

verbose_leave_scroll();

}

#endif

// check depth

if (stackp->ffs_level <= 0)

{

ff_free_stack_element(stackp);

continue;

}

file_path.string[0] = NUL;

file_path.length = 0;

/*

* 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_u *dirptrs[2];

// we use filepath to build the path expand_wildcards() should

// expand.

dirptrs[0] = file_path.string;

dirptrs[1] = NULL;

// if we have a start dir copy it in

if (!vim_isAbsName(stackp->ffs_fix_path.string)

&& search_ctx->ffsc_start_dir.string)

{

if (search_ctx->ffsc_start_dir.length + 1 < MAXPATHL)

{

int add_sep = !after_pathsep(search_ctx->ffsc_start_dir.string,

search_ctx->ffsc_start_dir.string + search_ctx->ffsc_start_dir.length);

file_path.length = vim_snprintf(

(char *)file_path.string,

MAXPATHL,

"%s%s",

search_ctx->ffsc_start_dir.string,

add_sep ? PATHSEPSTR : "");

}

else

{

ff_free_stack_element(stackp);

goto fail;

}

}

// append the fix part of the search path

if (file_path.length + stackp->ffs_fix_path.length + 1 < MAXPATHL)

{

int add_sep = !after_pathsep(stackp->ffs_fix_path.string,

stackp->ffs_fix_path.string + stackp->ffs_fix_path.length);

file_path.length += vim_snprintf(

(char *)file_path.string + file_path.length,

MAXPATHL - file_path.length,

"%s%s",

stackp->ffs_fix_path.string,

add_sep ? PATHSEPSTR : "");

}

else

{

ff_free_stack_element(stackp);

goto fail;

}

rest_of_wildcards.string = stackp->ffs_wc_path.string;

rest_of_wildcards.length = stackp->ffs_wc_path.length;

if (*rest_of_wildcards.string != NUL)

{

if (STRNCMP(rest_of_wildcards.string, "**", 2) == 0)

{

char_u *p;

// pointer to the restrict byte

// The restrict byte is not a character!

p = rest_of_wildcards.string + 2;

if (*p > 0)

{

(*p)--;

if (file_path.length + 1 < MAXPATHL)

file_path.string[file_path.length++] = '*';

else

{

ff_free_stack_element(stackp);

goto fail;

}

}

if (*p == 0)

{

// remove '**<numb> from wildcards

mch_memmove(rest_of_wildcards.string,

rest_of_wildcards.string + 3,

(size_t)(rest_of_wildcards.length - 3) + 1); // +1 for NUL

rest_of_wildcards.length -= 3;

stackp->ffs_wc_path.length = rest_of_wildcards.length;

}

else

{

rest_of_wildcards.string += 3;

rest_of_wildcards.length -= 3;

}

if (stackp->ffs_star_star_empty == 0)

{

// if not done before, expand '**' to empty

stackp->ffs_star_star_empty = 1;

dirptrs[1] = stackp->ffs_fix_path.string;

}

}

/*

* 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.string

&& !vim_ispathsep(*rest_of_wildcards.string))

{

if (file_path.length + 1 < MAXPATHL)

{

file_path.string[file_path.length++] = *rest_of_wildcards.string++;

--rest_of_wildcards.length;

}

else

{

ff_free_stack_element(stackp);

goto fail;

}

}

file_path.string[file_path.length] = NUL;

if (vim_ispathsep(*rest_of_wildcards.string))

{

rest_of_wildcards.string++;

rest_of_wildcards.length--;

}

}

/*

* Expand wildcards like "*" and "$VAR".

* If the path is a URL don't try this.

*/

if (path_with_url(/sitelet?url=https%3A%2F%2Fgithub.com%2Fmacvim-dev%2Fmacvim%2Fblob%2Fmaster%2Fsrc%2Fdirptrs%5B0%5D))

{

stackp->ffs_filearray = ALLOC_ONE(char_u *);

if (stackp->ffs_filearray != NULL