home *** CD-ROM | disk | FTP | other *** search
/ vim.ftp.fu-berlin.de / 2015-02-03.vim.ftp.fu-berlin.de.tar / vim.ftp.fu-berlin.de / patches / 7.1 / 7.1.256 < prev    next >
Encoding:
Internet Message Format  |  2008-02-19  |  49.7 KB
  1. To: vim-dev@vim.org
  2. Subject: Patch 7.1.256
  3. Fcc: outbox
  4. From: Bram Moolenaar <Bram@moolenaar.net>
  5. Mime-Version: 1.0
  6. Content-Type: text/plain; charset=ISO-8859-1
  7. Content-Transfer-Encoding: 8bit
  8. ------------
  9.  
  10. Patch 7.1.256
  11. Problem:    findfile() also returns directories.
  12. Solution:   Cleanup the code for finding files and directories in a list of
  13.             directories.  Remove the ugly global ff_search_ctx.
  14. Files:      src/eval.c, src/misc2.c, src/vim.h, src/tag.c
  15.  
  16.  
  17. *** ../vim-7.1.255/src/eval.c    Wed Feb 13 12:41:30 2008
  18. --- src/eval.c    Wed Feb 20 11:08:21 2008
  19. ***************
  20. *** 9203,9215 ****
  21.       rettv->vval.v_number = filewritable(get_tv_string(&argvars[0]));
  22.   }
  23.   
  24. ! static void findfilendir __ARGS((typval_T *argvars, typval_T *rettv, int dir));
  25.   
  26.       static void
  27. ! findfilendir(argvars, rettv, dir)
  28.       typval_T    *argvars;
  29.       typval_T    *rettv;
  30. !     int        dir;
  31.   {
  32.   #ifdef FEAT_SEARCHPATH
  33.       char_u    *fname;
  34. --- 9205,9217 ----
  35.       rettv->vval.v_number = filewritable(get_tv_string(&argvars[0]));
  36.   }
  37.   
  38. ! static void findfilendir __ARGS((typval_T *argvars, typval_T *rettv, int find_what));
  39.   
  40.       static void
  41. ! findfilendir(argvars, rettv, find_what)
  42.       typval_T    *argvars;
  43.       typval_T    *rettv;
  44. !     int        find_what;
  45.   {
  46.   #ifdef FEAT_SEARCHPATH
  47.       char_u    *fname;
  48. ***************
  49. *** 9254,9261 ****
  50.           vim_free(fresult);
  51.           fresult = find_file_in_path_option(first ? fname : NULL,
  52.                              first ? (int)STRLEN(fname) : 0,
  53. !                     0, first, path, dir, curbuf->b_ffname,
  54. !                     dir ? (char_u *)"" : curbuf->b_p_sua);
  55.           first = FALSE;
  56.   
  57.           if (fresult != NULL && rettv->v_type == VAR_LIST)
  58. --- 9256,9266 ----
  59.           vim_free(fresult);
  60.           fresult = find_file_in_path_option(first ? fname : NULL,
  61.                              first ? (int)STRLEN(fname) : 0,
  62. !                     0, first, path,
  63. !                     find_what,
  64. !                     curbuf->b_ffname,
  65. !                     find_what == FINDFILE_DIR
  66. !                         ? (char_u *)"" : curbuf->b_p_sua);
  67.           first = FALSE;
  68.   
  69.           if (fresult != NULL && rettv->v_type == VAR_LIST)
  70. ***************
  71. *** 9445,9451 ****
  72.       typval_T    *argvars;
  73.       typval_T    *rettv;
  74.   {
  75. !     findfilendir(argvars, rettv, TRUE);
  76.   }
  77.   
  78.   /*
  79. --- 9450,9456 ----
  80.       typval_T    *argvars;
  81.       typval_T    *rettv;
  82.   {
  83. !     findfilendir(argvars, rettv, FINDFILE_DIR);
  84.   }
  85.   
  86.   /*
  87. ***************
  88. *** 9456,9462 ****
  89.       typval_T    *argvars;
  90.       typval_T    *rettv;
  91.   {
  92. !     findfilendir(argvars, rettv, FALSE);
  93.   }
  94.   
  95.   /*
  96. --- 9461,9467 ----
  97.       typval_T    *argvars;
  98.       typval_T    *rettv;
  99.   {
  100. !     findfilendir(argvars, rettv, FINDFILE_FILE);
  101.   }
  102.   
  103.   /*
  104. *** ../vim-7.1.255/src/misc2.c    Fri Jan  4 21:25:01 2008
  105. --- src/misc2.c    Wed Feb 13 17:19:21 2008
  106. ***************
  107. *** 3777,3785 ****
  108.       char_u        ffs_filearray_cur;   /* needed for partly handled dirs */
  109.   
  110.       /* to store status of partly handled directories
  111. !      * 0: we work the on this directory for the first time
  112.        * 1: this directory was partly searched in an earlier step
  113. !     */
  114.       int            ffs_stage;
  115.   
  116.       /* How deep are we in the directory tree?
  117. --- 3778,3786 ----
  118.       char_u        ffs_filearray_cur;   /* needed for partly handled dirs */
  119.   
  120.       /* to store status of partly handled directories
  121. !      * 0: we work on this directory for the first time
  122.        * 1: this directory was partly searched in an earlier step
  123. !      */
  124.       int            ffs_stage;
  125.   
  126.       /* How deep are we in the directory tree?
  127. ***************
  128. *** 3848,3853 ****
  129. --- 3849,3855 ----
  130.    * Set the default maximum depth.
  131.    */
  132.   #define FF_MAX_STAR_STAR_EXPAND ((char_u)30)
  133. + 
  134.   /*
  135.    * The search context:
  136.    *   ffsc_stack_ptr:    the stack for the dirs to search
  137. ***************
  138. *** 3862,3868 ****
  139.    *   ffsc_wc_path:    the part of the given path containing wildcards
  140.    *   ffsc_level:    how many levels of dirs to search downwards
  141.    *   ffsc_stopdirs_v:    array of stop directories for upward search
  142. !  *   ffsc_need_dir:    TRUE if we search for a directory
  143.    */
  144.   typedef struct ff_search_ctx_T
  145.   {
  146. --- 3864,3870 ----
  147.    *   ffsc_wc_path:    the part of the given path containing wildcards
  148.    *   ffsc_level:    how many levels of dirs to search downwards
  149.    *   ffsc_stopdirs_v:    array of stop directories for upward search
  150. !  *   ffsc_find_what:    FINDFILE_BOTH, FINDFILE_DIR or FINDFILE_FILE
  151.    */
  152.   typedef struct ff_search_ctx_T
  153.   {
  154. ***************
  155. *** 3879,3889 ****
  156.        int            ffsc_level;
  157.        char_u            **ffsc_stopdirs_v;
  158.   #endif
  159. !      int            ffsc_need_dir;
  160.   } ff_search_ctx_T;
  161.   
  162. - static ff_search_ctx_T *ff_search_ctx = NULL;
  163. - 
  164.   /* locally needed functions */
  165.   #ifdef FEAT_PATH_EXTRA
  166.   static int ff_check_visited __ARGS((ff_visited_T **, char_u *, char_u *));
  167. --- 3881,3889 ----
  168.        int            ffsc_level;
  169.        char_u            **ffsc_stopdirs_v;
  170.   #endif
  171. !      int            ffsc_find_what;
  172.   } ff_search_ctx_T;
  173.   
  174.   /* locally needed functions */
  175.   #ifdef FEAT_PATH_EXTRA
  176.   static int ff_check_visited __ARGS((ff_visited_T **, char_u *, char_u *));
  177. ***************
  178. *** 3897,3906 ****
  179.   static int ff_wc_equal __ARGS((char_u *s1, char_u *s2));
  180.   #endif
  181.   
  182. ! static void ff_push __ARGS((ff_stack_T *));
  183. ! static ff_stack_T * ff_pop __ARGS((void));
  184. ! static void ff_clear __ARGS((void));
  185. ! static void ff_free_stack_element __ARGS((ff_stack_T *));
  186.   #ifdef FEAT_PATH_EXTRA
  187.   static ff_stack_T *ff_create_stack_element __ARGS((char_u *, char_u *, int, int));
  188.   #else
  189. --- 3897,3906 ----
  190.   static int ff_wc_equal __ARGS((char_u *s1, char_u *s2));
  191.   #endif
  192.   
  193. ! static void ff_push __ARGS((ff_search_ctx_T *search_ctx, ff_stack_T *stack_ptr));
  194. ! static ff_stack_T *ff_pop __ARGS((ff_search_ctx_T *search_ctx));
  195. ! static void ff_clear __ARGS((ff_search_ctx_T *search_ctx));
  196. ! static void ff_free_stack_element __ARGS((ff_stack_T *stack_ptr));
  197.   #ifdef FEAT_PATH_EXTRA
  198.   static ff_stack_T *ff_create_stack_element __ARGS((char_u *, char_u *, int, int));
  199.   #else
  200. ***************
  201. *** 3961,3966 ****
  202. --- 3961,3969 ----
  203.    * not related to restricts given to the '**' wildcard. If 'level' is 100
  204.    * and you use '**200' vim_findfile() will stop after 100 levels.
  205.    *
  206. +  * 'filename' cannot contain wildcards!  It is used as-is, no backslashes to
  207. +  * escape special characters.
  208. +  *
  209.    * If 'stopdirs' is not NULL and nothing is found downward, the search is
  210.    * restarted on the next higher directory level. This is repeated until the
  211.    * start-directory of a search is contained in 'stopdirs'. 'stopdirs' has the
  212. ***************
  213. *** 3980,4053 ****
  214.    * The list of visited files/dirs can also be cleared with the function
  215.    * vim_findfile_free_visited().
  216.    *
  217. !  * Set the parameter 'need_dir' to TRUE if you want to search for a directory
  218. !  * instead of a file.
  219.    *
  220.    * A search context returned by a previous call to vim_findfile_init() can be
  221. !  * passed in the parameter 'search_ctx'. This context is than reused and
  222. !  * reinitialized with the new parameters. The list of already viseted
  223.    * directories from this context is only deleted if the parameter
  224. !  * 'free_visited' is true. Be aware that the passed search_context is freed if
  225. !  * the reinitialization fails.
  226.    *
  227. !  * If you don't have a search context from a previous call 'search_ctx' must be
  228. !  * NULL.
  229.    *
  230.    * This function silently ignores a few errors, vim_findfile() will have
  231.    * limited functionality then.
  232.    */
  233.   /*ARGSUSED*/
  234.       void *
  235. ! vim_findfile_init(path, filename, stopdirs, level, free_visited, need_dir,
  236. !                         search_ctx, tagfile, rel_fname)
  237.       char_u    *path;
  238.       char_u    *filename;
  239.       char_u    *stopdirs;
  240.       int        level;
  241.       int        free_visited;
  242. !     int        need_dir;
  243. !     void    *search_ctx;
  244.       int        tagfile;
  245.       char_u    *rel_fname;    /* file name to use for "." */
  246.   {
  247.   #ifdef FEAT_PATH_EXTRA
  248. !     char_u    *wc_part;
  249.   #endif
  250. !     ff_stack_T    *sptr;
  251.   
  252.       /* If a search context is given by the caller, reuse it, else allocate a
  253.        * new one.
  254.        */
  255. !     if (search_ctx != NULL)
  256. !     ff_search_ctx = search_ctx;
  257.       else
  258.       {
  259. !     ff_search_ctx = (ff_search_ctx_T*)alloc(
  260. !                        (unsigned)sizeof(ff_search_ctx_T));
  261. !     if (ff_search_ctx == NULL)
  262.           goto error_return;
  263. !     memset(ff_search_ctx, 0, sizeof(ff_search_ctx_T));
  264.       }
  265.   
  266.       /* clear the search context, but NOT the visited lists */
  267. !     ff_clear();
  268.   
  269.       /* clear visited list if wanted */
  270.       if (free_visited == TRUE)
  271. !     vim_findfile_free_visited(ff_search_ctx);
  272.       else
  273.       {
  274.       /* Reuse old visited lists. Get the visited list for the given
  275.        * filename. If no list for the current filename exists, creates a new
  276. !      * one.
  277. !      */
  278. !     ff_search_ctx->ffsc_visited_list = ff_get_visited_list(filename,
  279. !                      &ff_search_ctx->ffsc_visited_lists_list);
  280. !     if (ff_search_ctx->ffsc_visited_list == NULL)
  281.           goto error_return;
  282. !     ff_search_ctx->ffsc_dir_visited_list = ff_get_visited_list(filename,
  283. !                  &ff_search_ctx->ffsc_dir_visited_lists_list);
  284. !     if (ff_search_ctx->ffsc_dir_visited_list == NULL)
  285.           goto error_return;
  286.       }
  287.   
  288. --- 3983,4056 ----
  289.    * The list of visited files/dirs can also be cleared with the function
  290.    * vim_findfile_free_visited().
  291.    *
  292. !  * Set the parameter 'find_what' to FINDFILE_DIR if you want to search for
  293. !  * directories only, FINDFILE_FILE for files only, FINDFILE_BOTH for both.
  294.    *
  295.    * A search context returned by a previous call to vim_findfile_init() can be
  296. !  * passed in the parameter "search_ctx_arg".  This context is reused and
  297. !  * reinitialized with the new parameters.  The list of already visited
  298.    * directories from this context is only deleted if the parameter
  299. !  * "free_visited" is true.  Be aware that the passed "search_ctx_arg" is freed
  300. !  * if the reinitialization fails.
  301.    *
  302. !  * If you don't have a search context from a previous call "search_ctx_arg"
  303. !  * must be NULL.
  304.    *
  305.    * This function silently ignores a few errors, vim_findfile() will have
  306.    * limited functionality then.
  307.    */
  308.   /*ARGSUSED*/
  309.       void *
  310. ! vim_findfile_init(path, filename, stopdirs, level, free_visited, find_what,
  311. !                        search_ctx_arg, tagfile, rel_fname)
  312.       char_u    *path;
  313.       char_u    *filename;
  314.       char_u    *stopdirs;
  315.       int        level;
  316.       int        free_visited;
  317. !     int        find_what;
  318. !     void    *search_ctx_arg;
  319.       int        tagfile;
  320.       char_u    *rel_fname;    /* file name to use for "." */
  321.   {
  322.   #ifdef FEAT_PATH_EXTRA
  323. !     char_u        *wc_part;
  324.   #endif
  325. !     ff_stack_T        *sptr;
  326. !     ff_search_ctx_T    *search_ctx;
  327.   
  328.       /* If a search context is given by the caller, reuse it, else allocate a
  329.        * new one.
  330.        */
  331. !     if (search_ctx_arg != NULL)
  332. !     search_ctx = search_ctx_arg;
  333.       else
  334.       {
  335. !     search_ctx = (ff_search_ctx_T*)alloc((unsigned)sizeof(ff_search_ctx_T));
  336. !     if (search_ctx == NULL)
  337.           goto error_return;
  338. !     memset(search_ctx, 0, sizeof(ff_search_ctx_T));
  339.       }
  340. +     search_ctx->ffsc_find_what = find_what;
  341.   
  342.       /* clear the search context, but NOT the visited lists */
  343. !     ff_clear(search_ctx);
  344.   
  345.       /* clear visited list if wanted */
  346.       if (free_visited == TRUE)
  347. !     vim_findfile_free_visited(search_ctx);
  348.       else
  349.       {
  350.       /* Reuse old visited lists. Get the visited list for the given
  351.        * filename. If no list for the current filename exists, creates a new
  352. !      * one. */
  353. !     search_ctx->ffsc_visited_list = ff_get_visited_list(filename,
  354. !                     &search_ctx->ffsc_visited_lists_list);
  355. !     if (search_ctx->ffsc_visited_list == NULL)
  356.           goto error_return;
  357. !     search_ctx->ffsc_dir_visited_list = ff_get_visited_list(filename,
  358. !                     &search_ctx->ffsc_dir_visited_lists_list);
  359. !     if (search_ctx->ffsc_dir_visited_list == NULL)
  360.           goto error_return;
  361.       }
  362.   
  363. ***************
  364. *** 4071,4082 ****
  365.       {
  366.           /* Make the start dir an absolute path name. */
  367.           vim_strncpy(ff_expand_buffer, rel_fname, len);
  368. !         ff_search_ctx->ffsc_start_dir = FullName_save(ff_expand_buffer,
  369. !                                        FALSE);
  370.       }
  371.       else
  372. !         ff_search_ctx->ffsc_start_dir = vim_strnsave(rel_fname, len);
  373. !     if (ff_search_ctx->ffsc_start_dir == NULL)
  374.           goto error_return;
  375.       if (*++path != NUL)
  376.           ++path;
  377. --- 4074,4084 ----
  378.       {
  379.           /* Make the start dir an absolute path name. */
  380.           vim_strncpy(ff_expand_buffer, rel_fname, len);
  381. !         search_ctx->ffsc_start_dir = FullName_save(ff_expand_buffer, FALSE);
  382.       }
  383.       else
  384. !         search_ctx->ffsc_start_dir = vim_strnsave(rel_fname, len);
  385. !     if (search_ctx->ffsc_start_dir == NULL)
  386.           goto error_return;
  387.       if (*++path != NUL)
  388.           ++path;
  389. ***************
  390. *** 4101,4108 ****
  391.       if (mch_dirname(ff_expand_buffer, MAXPATHL) == FAIL)
  392.           goto error_return;
  393.   
  394. !     ff_search_ctx->ffsc_start_dir = vim_strsave(ff_expand_buffer);
  395. !     if (ff_search_ctx->ffsc_start_dir == NULL)
  396.           goto error_return;
  397.   
  398.   #ifdef BACKSLASH_IN_FILENAME
  399. --- 4103,4110 ----
  400.       if (mch_dirname(ff_expand_buffer, MAXPATHL) == FAIL)
  401.           goto error_return;
  402.   
  403. !     search_ctx->ffsc_start_dir = vim_strsave(ff_expand_buffer);
  404. !     if (search_ctx->ffsc_start_dir == NULL)
  405.           goto error_return;
  406.   
  407.   #ifdef BACKSLASH_IN_FILENAME
  408. ***************
  409. *** 4110,4117 ****
  410.        * directory (but not for "//machine/dir").  Only use the drive name. */
  411.       if ((*path == '/' || *path == '\\')
  412.           && path[1] != path[0]
  413. !         && ff_search_ctx->ffsc_start_dir[1] == ':')
  414. !         ff_search_ctx->ffsc_start_dir[2] = NUL;
  415.   #endif
  416.       }
  417.   
  418. --- 4112,4119 ----
  419.        * directory (but not for "//machine/dir").  Only use the drive name. */
  420.       if ((*path == '/' || *path == '\\')
  421.           && path[1] != path[0]
  422. !         && search_ctx->ffsc_start_dir[1] == ':')
  423. !         search_ctx->ffsc_start_dir[2] = NUL;
  424.   #endif
  425.       }
  426.   
  427. ***************
  428. *** 4121,4127 ****
  429.        * If this fails (mem allocation), there is no upward search at all or a
  430.        * stop directory is not recognized -> continue silently.
  431.        * If stopdirs just contains a ";" or is empty,
  432. !      * ff_search_ctx->ffsc_stopdirs_v will only contain a  NULL pointer. This
  433.        * is handled as unlimited upward search.  See function
  434.        * ff_path_in_stoplist() for details.
  435.        */
  436. --- 4123,4129 ----
  437.        * If this fails (mem allocation), there is no upward search at all or a
  438.        * stop directory is not recognized -> continue silently.
  439.        * If stopdirs just contains a ";" or is empty,
  440. !      * search_ctx->ffsc_stopdirs_v will only contain a  NULL pointer. This
  441.        * is handled as unlimited upward search.  See function
  442.        * ff_path_in_stoplist() for details.
  443.        */
  444. ***************
  445. *** 4134,4143 ****
  446.           walker++;
  447.   
  448.       dircount = 1;
  449. !     ff_search_ctx->ffsc_stopdirs_v =
  450. !         (char_u **)alloc((unsigned)sizeof(char_u *));
  451.   
  452. !     if (ff_search_ctx->ffsc_stopdirs_v != NULL)
  453.       {
  454.           do
  455.           {
  456. --- 4136,4145 ----
  457.           walker++;
  458.   
  459.       dircount = 1;
  460. !     search_ctx->ffsc_stopdirs_v =
  461. !                  (char_u **)alloc((unsigned)sizeof(char_u *));
  462.   
  463. !     if (search_ctx->ffsc_stopdirs_v != NULL)
  464.       {
  465.           do
  466.           {
  467. ***************
  468. *** 4145,4181 ****
  469.           void    *ptr;
  470.   
  471.           helper = walker;
  472. !         ptr = vim_realloc(ff_search_ctx->ffsc_stopdirs_v,
  473.                          (dircount + 1) * sizeof(char_u *));
  474.           if (ptr)
  475. !             ff_search_ctx->ffsc_stopdirs_v = ptr;
  476.           else
  477.               /* ignore, keep what we have and continue */
  478.               break;
  479.           walker = vim_strchr(walker, ';');
  480.           if (walker)
  481.           {
  482. !             ff_search_ctx->ffsc_stopdirs_v[dircount-1] =
  483. !             vim_strnsave(helper, (int)(walker - helper));
  484.               walker++;
  485.           }
  486.           else
  487.               /* this might be "", which means ascent till top
  488.                * of directory tree.
  489.                */
  490. !             ff_search_ctx->ffsc_stopdirs_v[dircount-1] =
  491. !             vim_strsave(helper);
  492.   
  493.           dircount++;
  494.   
  495.           } while (walker != NULL);
  496. !         ff_search_ctx->ffsc_stopdirs_v[dircount-1] = NULL;
  497.       }
  498.       }
  499.   #endif
  500.   
  501.   #ifdef FEAT_PATH_EXTRA
  502. !     ff_search_ctx->ffsc_level = level;
  503.   
  504.       /* split into:
  505.        *  -fix path
  506. --- 4147,4183 ----
  507.           void    *ptr;
  508.   
  509.           helper = walker;
  510. !         ptr = vim_realloc(search_ctx->ffsc_stopdirs_v,
  511.                          (dircount + 1) * sizeof(char_u *));
  512.           if (ptr)
  513. !             search_ctx->ffsc_stopdirs_v = ptr;
  514.           else
  515.               /* ignore, keep what we have and continue */
  516.               break;
  517.           walker = vim_strchr(walker, ';');
  518.           if (walker)
  519.           {
  520. !             search_ctx->ffsc_stopdirs_v[dircount-1] =
  521. !                  vim_strnsave(helper, (int)(walker - helper));
  522.               walker++;
  523.           }
  524.           else
  525.               /* this might be "", which means ascent till top
  526.                * of directory tree.
  527.                */
  528. !             search_ctx->ffsc_stopdirs_v[dircount-1] =
  529. !                               vim_strsave(helper);
  530.   
  531.           dircount++;
  532.   
  533.           } while (walker != NULL);
  534. !         search_ctx->ffsc_stopdirs_v[dircount-1] = NULL;
  535.       }
  536.       }
  537.   #endif
  538.   
  539.   #ifdef FEAT_PATH_EXTRA
  540. !     search_ctx->ffsc_level = level;
  541.   
  542.       /* split into:
  543.        *  -fix path
  544. ***************
  545. *** 4189,4196 ****
  546.       char    *errpt;
  547.   
  548.       /* save the fix part of the path */
  549. !     ff_search_ctx->ffsc_fix_path = vim_strnsave(path,
  550. !                                (int)(wc_part - path));
  551.   
  552.       /*
  553.        * copy wc_path and add restricts to the '**' wildcard.
  554. --- 4191,4197 ----
  555.       char    *errpt;
  556.   
  557.       /* save the fix part of the path */
  558. !     search_ctx->ffsc_fix_path = vim_strnsave(path, (int)(wc_part - path));
  559.   
  560.       /*
  561.        * copy wc_path and add restricts to the '**' wildcard.
  562. ***************
  563. *** 4229,4275 ****
  564.           ff_expand_buffer[len++] = *wc_part++;
  565.       }
  566.       ff_expand_buffer[len] = NUL;
  567. !     ff_search_ctx->ffsc_wc_path = vim_strsave(ff_expand_buffer);
  568.   
  569. !     if (ff_search_ctx->ffsc_wc_path == NULL)
  570.           goto error_return;
  571.       }
  572.       else
  573.   #endif
  574. !     ff_search_ctx->ffsc_fix_path = vim_strsave(path);
  575.   
  576. !     if (ff_search_ctx->ffsc_start_dir == NULL)
  577.       {
  578.       /* store the fix part as startdir.
  579.        * This is needed if the parameter path is fully qualified.
  580.        */
  581. !     ff_search_ctx->ffsc_start_dir = vim_strsave(ff_search_ctx->ffsc_fix_path);
  582. !     if (ff_search_ctx->ffsc_start_dir)
  583. !         ff_search_ctx->ffsc_fix_path[0] = NUL;
  584.       }
  585.   
  586.       /* create an absolute path */
  587. !     STRCPY(ff_expand_buffer, ff_search_ctx->ffsc_start_dir);
  588.       add_pathsep(ff_expand_buffer);
  589. !     STRCAT(ff_expand_buffer, ff_search_ctx->ffsc_fix_path);
  590.       add_pathsep(ff_expand_buffer);
  591.   
  592.       sptr = ff_create_stack_element(ff_expand_buffer,
  593.   #ifdef FEAT_PATH_EXTRA
  594. !         ff_search_ctx->ffsc_wc_path,
  595.   #endif
  596.           level, 0);
  597.   
  598.       if (sptr == NULL)
  599.       goto error_return;
  600.   
  601. !     ff_push(sptr);
  602.   
  603. !     ff_search_ctx->ffsc_file_to_search = vim_strsave(filename);
  604. !     if (ff_search_ctx->ffsc_file_to_search == NULL)
  605.       goto error_return;
  606.   
  607. !     return ff_search_ctx;
  608.   
  609.   error_return:
  610.       /*
  611. --- 4230,4276 ----
  612.           ff_expand_buffer[len++] = *wc_part++;
  613.       }
  614.       ff_expand_buffer[len] = NUL;
  615. !     search_ctx->ffsc_wc_path = vim_strsave(ff_expand_buffer);
  616.   
  617. !     if (search_ctx->ffsc_wc_path == NULL)
  618.           goto error_return;
  619.       }
  620.       else
  621.   #endif
  622. !     search_ctx->ffsc_fix_path = vim_strsave(path);
  623.   
  624. !     if (search_ctx->ffsc_start_dir == NULL)
  625.       {
  626.       /* store the fix part as startdir.
  627.        * This is needed if the parameter path is fully qualified.
  628.        */
  629. !     search_ctx->ffsc_start_dir = vim_strsave(search_ctx->ffsc_fix_path);
  630. !     if (search_ctx->ffsc_start_dir)
  631. !         search_ctx->ffsc_fix_path[0] = NUL;
  632.       }
  633.   
  634.       /* create an absolute path */
  635. !     STRCPY(ff_expand_buffer, search_ctx->ffsc_start_dir);
  636.       add_pathsep(ff_expand_buffer);
  637. !     STRCAT(ff_expand_buffer, search_ctx->ffsc_fix_path);
  638.       add_pathsep(ff_expand_buffer);
  639.   
  640.       sptr = ff_create_stack_element(ff_expand_buffer,
  641.   #ifdef FEAT_PATH_EXTRA
  642. !         search_ctx->ffsc_wc_path,
  643.   #endif
  644.           level, 0);
  645.   
  646.       if (sptr == NULL)
  647.       goto error_return;
  648.   
  649. !     ff_push(search_ctx, sptr);
  650.   
  651. !     search_ctx->ffsc_file_to_search = vim_strsave(filename);
  652. !     if (search_ctx->ffsc_file_to_search == NULL)
  653.       goto error_return;
  654.   
  655. !     return search_ctx;
  656.   
  657.   error_return:
  658.       /*
  659. ***************
  660. *** 4277,4283 ****
  661.        * Even when the caller gave us a (perhaps valid) context we free it here,
  662.        * as we might have already destroyed it.
  663.        */
  664. !     vim_findfile_cleanup(ff_search_ctx);
  665.       return NULL;
  666.   }
  667.   
  668. --- 4278,4284 ----
  669.        * Even when the caller gave us a (perhaps valid) context we free it here,
  670.        * as we might have already destroyed it.
  671.        */
  672. !     vim_findfile_cleanup(search_ctx);
  673.       return NULL;
  674.   }
  675.   
  676. ***************
  677. *** 4314,4320 ****
  678.   }
  679.   #endif
  680.   
  681. ! /* Clean up the given search context. Can handle a NULL pointer */
  682.       void
  683.   vim_findfile_cleanup(ctx)
  684.       void    *ctx;
  685. --- 4315,4323 ----
  686.   }
  687.   #endif
  688.   
  689. ! /*
  690. !  * Clean up the given search context. Can handle a NULL pointer.
  691. !  */
  692.       void
  693.   vim_findfile_cleanup(ctx)
  694.       void    *ctx;
  695. ***************
  696. *** 4322,4333 ****
  697.       if (ctx == NULL)
  698.       return;
  699.   
  700. -     ff_search_ctx = ctx;
  701. - 
  702.       vim_findfile_free_visited(ctx);
  703. !     ff_clear();
  704.       vim_free(ctx);
  705. -     ff_search_ctx = NULL;
  706.   }
  707.   
  708.   /*
  709. --- 4325,4333 ----
  710.       if (ctx == NULL)
  711.       return;
  712.   
  713.       vim_findfile_free_visited(ctx);
  714. !     ff_clear(ctx);
  715.       vim_free(ctx);
  716.   }
  717.   
  718.   /*
  719. ***************
  720. *** 4343,4357 ****
  721.    * top of the list).
  722.    */
  723.       char_u *
  724. ! vim_findfile(search_ctx)
  725. !     void    *search_ctx;
  726.   {
  727.       char_u    *file_path;
  728.   #ifdef FEAT_PATH_EXTRA
  729.       char_u    *rest_of_wildcards;
  730.       char_u    *path_end = NULL;
  731.   #endif
  732. !     ff_stack_T    *ctx;
  733.   #if defined(FEAT_SEARCHPATH) || defined(FEAT_PATH_EXTRA)
  734.       int        len;
  735.   #endif
  736. --- 4343,4357 ----
  737.    * top of the list).
  738.    */
  739.       char_u *
  740. ! vim_findfile(search_ctx_arg)
  741. !     void    *search_ctx_arg;
  742.   {
  743.       char_u    *file_path;
  744.   #ifdef FEAT_PATH_EXTRA
  745.       char_u    *rest_of_wildcards;
  746.       char_u    *path_end = NULL;
  747.   #endif
  748. !     ff_stack_T    *stackp;
  749.   #if defined(FEAT_SEARCHPATH) || defined(FEAT_PATH_EXTRA)
  750.       int        len;
  751.   #endif
  752. ***************
  753. *** 4360,4370 ****
  754.   #ifdef FEAT_SEARCHPATH
  755.       char_u    *suf;
  756.   #endif
  757.   
  758. !     if (search_ctx == NULL)
  759.       return NULL;
  760.   
  761. !     ff_search_ctx = (ff_search_ctx_T*)search_ctx;
  762.   
  763.       /*
  764.        * filepath is used as buffer for various actions and as the storage to
  765. --- 4360,4371 ----
  766.   #ifdef FEAT_SEARCHPATH
  767.       char_u    *suf;
  768.   #endif
  769. +     ff_search_ctx_T *search_ctx;
  770.   
  771. !     if (search_ctx_arg == NULL)
  772.       return NULL;
  773.   
  774. !     search_ctx = (ff_search_ctx_T *)search_ctx_arg;
  775.   
  776.       /*
  777.        * filepath is used as buffer for various actions and as the storage to
  778. ***************
  779. *** 4375,4382 ****
  780.   
  781.   #ifdef FEAT_PATH_EXTRA
  782.       /* store the end of the start dir -- needed for upward search */
  783. !     if (ff_search_ctx->ffsc_start_dir != NULL)
  784. !     path_end = &ff_search_ctx->ffsc_start_dir[STRLEN(ff_search_ctx->ffsc_start_dir)];
  785.   #endif
  786.   
  787.   #ifdef FEAT_PATH_EXTRA
  788. --- 4376,4384 ----
  789.   
  790.   #ifdef FEAT_PATH_EXTRA
  791.       /* store the end of the start dir -- needed for upward search */
  792. !     if (search_ctx->ffsc_start_dir != NULL)
  793. !     path_end = &search_ctx->ffsc_start_dir[
  794. !                       STRLEN(search_ctx->ffsc_start_dir)];
  795.   #endif
  796.   
  797.   #ifdef FEAT_PATH_EXTRA
  798. ***************
  799. *** 4393,4400 ****
  800.           break;
  801.   
  802.           /* get directory to work on from stack */
  803. !         ctx = ff_pop();
  804. !         if (ctx == NULL)
  805.           break;
  806.   
  807.           /*
  808. --- 4395,4402 ----
  809.           break;
  810.   
  811.           /* get directory to work on from stack */
  812. !         stackp = ff_pop(search_ctx);
  813. !         if (stackp == NULL)
  814.           break;
  815.   
  816.           /*
  817. ***************
  818. *** 4414,4427 ****
  819.            *  /etc/rc.d/init.d is linked to /etc/rc.d -> endless loop)
  820.            *
  821.            * This check is only needed for directories we work on for the
  822. !          * first time (hence ctx->ff_filearray == NULL)
  823.            */
  824. !         if (ctx->ffs_filearray == NULL
  825. !             && ff_check_visited(&ff_search_ctx->ffsc_dir_visited_list
  826.                                 ->ffvl_visited_list,
  827. !             ctx->ffs_fix_path
  828.   #ifdef FEAT_PATH_EXTRA
  829. !             , ctx->ffs_wc_path
  830.   #endif
  831.               ) == FAIL)
  832.           {
  833. --- 4416,4429 ----
  834.            *  /etc/rc.d/init.d is linked to /etc/rc.d -> endless loop)
  835.            *
  836.            * This check is only needed for directories we work on for the
  837. !          * first time (hence stackp->ff_filearray == NULL)
  838.            */
  839. !         if (stackp->ffs_filearray == NULL
  840. !             && ff_check_visited(&search_ctx->ffsc_dir_visited_list
  841.                                 ->ffvl_visited_list,
  842. !             stackp->ffs_fix_path
  843.   #ifdef FEAT_PATH_EXTRA
  844. !             , stackp->ffs_wc_path
  845.   #endif
  846.               ) == FAIL)
  847.           {
  848. ***************
  849. *** 4430,4442 ****
  850.           {
  851.               verbose_enter_scroll();
  852.               smsg((char_u *)"Already Searched: %s (%s)",
  853. !                        ctx->ffs_fix_path, ctx->ffs_wc_path);
  854.               /* don't overwrite this either */
  855.               msg_puts((char_u *)"\n");
  856.               verbose_leave_scroll();
  857.           }
  858.   #endif
  859. !         ff_free_stack_element(ctx);
  860.           continue;
  861.           }
  862.   #ifdef FF_VERBOSE
  863. --- 4432,4444 ----
  864.           {
  865.               verbose_enter_scroll();
  866.               smsg((char_u *)"Already Searched: %s (%s)",
  867. !                    stackp->ffs_fix_path, stackp->ffs_wc_path);
  868.               /* don't overwrite this either */
  869.               msg_puts((char_u *)"\n");
  870.               verbose_leave_scroll();
  871.           }
  872.   #endif
  873. !         ff_free_stack_element(stackp);
  874.           continue;
  875.           }
  876.   #ifdef FF_VERBOSE
  877. ***************
  878. *** 4444,4450 ****
  879.           {
  880.           verbose_enter_scroll();
  881.           smsg((char_u *)"Searching: %s (%s)",
  882. !                      ctx->ffs_fix_path, ctx->ffs_wc_path);
  883.           /* don't overwrite this either */
  884.           msg_puts((char_u *)"\n");
  885.           verbose_leave_scroll();
  886. --- 4446,4452 ----
  887.           {
  888.           verbose_enter_scroll();
  889.           smsg((char_u *)"Searching: %s (%s)",
  890. !                    stackp->ffs_fix_path, stackp->ffs_wc_path);
  891.           /* don't overwrite this either */
  892.           msg_puts((char_u *)"\n");
  893.           verbose_leave_scroll();
  894. ***************
  895. *** 4452,4460 ****
  896.   #endif
  897.   
  898.           /* check depth */
  899. !         if (ctx->ffs_level <= 0)
  900.           {
  901. !         ff_free_stack_element(ctx);
  902.           continue;
  903.           }
  904.   
  905. --- 4454,4462 ----
  906.   #endif
  907.   
  908.           /* check depth */
  909. !         if (stackp->ffs_level <= 0)
  910.           {
  911. !         ff_free_stack_element(stackp);
  912.           continue;
  913.           }
  914.   
  915. ***************
  916. *** 4466,4472 ****
  917.            * and all possible expands are returned in one array. We use this
  918.            * to handle the expansion of '**' into an empty string.
  919.            */
  920. !         if (ctx->ffs_filearray == NULL)
  921.           {
  922.           char_u *dirptrs[2];
  923.   
  924. --- 4468,4474 ----
  925.            * and all possible expands are returned in one array. We use this
  926.            * to handle the expansion of '**' into an empty string.
  927.            */
  928. !         if (stackp->ffs_filearray == NULL)
  929.           {
  930.           char_u *dirptrs[2];
  931.   
  932. ***************
  933. *** 4477,4495 ****
  934.           dirptrs[1] = NULL;
  935.   
  936.           /* if we have a start dir copy it in */
  937. !         if (!vim_isAbsName(ctx->ffs_fix_path)
  938. !             && ff_search_ctx->ffsc_start_dir)
  939.           {
  940. !             STRCPY(file_path, ff_search_ctx->ffsc_start_dir);
  941.               add_pathsep(file_path);
  942.           }
  943.   
  944.           /* append the fix part of the search path */
  945. !         STRCAT(file_path, ctx->ffs_fix_path);
  946.           add_pathsep(file_path);
  947.   
  948.   #ifdef FEAT_PATH_EXTRA
  949. !         rest_of_wildcards = ctx->ffs_wc_path;
  950.           if (*rest_of_wildcards != NUL)
  951.           {
  952.               len = (int)STRLEN(file_path);
  953. --- 4479,4497 ----
  954.           dirptrs[1] = NULL;
  955.   
  956.           /* if we have a start dir copy it in */
  957. !         if (!vim_isAbsName(stackp->ffs_fix_path)
  958. !                         && search_ctx->ffsc_start_dir)
  959.           {
  960. !             STRCPY(file_path, search_ctx->ffsc_start_dir);
  961.               add_pathsep(file_path);
  962.           }
  963.   
  964.           /* append the fix part of the search path */
  965. !         STRCAT(file_path, stackp->ffs_fix_path);
  966.           add_pathsep(file_path);
  967.   
  968.   #ifdef FEAT_PATH_EXTRA
  969. !         rest_of_wildcards = stackp->ffs_wc_path;
  970.           if (*rest_of_wildcards != NUL)
  971.           {
  972.               len = (int)STRLEN(file_path);
  973. ***************
  974. *** 4516,4526 ****
  975.               else
  976.                   rest_of_wildcards += 3;
  977.   
  978. !             if (ctx->ffs_star_star_empty == 0)
  979.               {
  980.                   /* if not done before, expand '**' to empty */
  981. !                 ctx->ffs_star_star_empty = 1;
  982. !                 dirptrs[1] = ctx->ffs_fix_path;
  983.               }
  984.               }
  985.   
  986. --- 4518,4528 ----
  987.               else
  988.                   rest_of_wildcards += 3;
  989.   
  990. !             if (stackp->ffs_star_star_empty == 0)
  991.               {
  992.                   /* if not done before, expand '**' to empty */
  993. !                 stackp->ffs_star_star_empty = 1;
  994. !                 dirptrs[1] = stackp->ffs_fix_path;
  995.               }
  996.               }
  997.   
  998. ***************
  999. *** 4547,4576 ****
  1000.            */
  1001.           if (path_with_url(dirptrs[0]))
  1002.           {
  1003. !             ctx->ffs_filearray = (char_u **)
  1004.                             alloc((unsigned)sizeof(char *));
  1005. !             if (ctx->ffs_filearray != NULL
  1006. !                 && (ctx->ffs_filearray[0]
  1007.                   = vim_strsave(dirptrs[0])) != NULL)
  1008. !             ctx->ffs_filearray_size = 1;
  1009.               else
  1010. !             ctx->ffs_filearray_size = 0;
  1011.           }
  1012.           else
  1013.               expand_wildcards((dirptrs[1] == NULL) ? 1 : 2, dirptrs,
  1014. !                 &ctx->ffs_filearray_size,
  1015. !                 &ctx->ffs_filearray,
  1016.                   EW_DIR|EW_ADDSLASH|EW_SILENT);
  1017.   
  1018. !         ctx->ffs_filearray_cur = 0;
  1019. !         ctx->ffs_stage = 0;
  1020.           }
  1021.   #ifdef FEAT_PATH_EXTRA
  1022.           else
  1023. !         rest_of_wildcards = &ctx->ffs_wc_path[STRLEN(ctx->ffs_wc_path)];
  1024.   #endif
  1025.   
  1026. !         if (ctx->ffs_stage == 0)
  1027.           {
  1028.           /* this is the first time we work on this directory */
  1029.   #ifdef FEAT_PATH_EXTRA
  1030. --- 4549,4579 ----
  1031.            */
  1032.           if (path_with_url(dirptrs[0]))
  1033.           {
  1034. !             stackp->ffs_filearray = (char_u **)
  1035.                             alloc((unsigned)sizeof(char *));
  1036. !             if (stackp->ffs_filearray != NULL
  1037. !                 && (stackp->ffs_filearray[0]
  1038.                   = vim_strsave(dirptrs[0])) != NULL)
  1039. !             stackp->ffs_filearray_size = 1;
  1040.               else
  1041. !             stackp->ffs_filearray_size = 0;
  1042.           }
  1043.           else
  1044.               expand_wildcards((dirptrs[1] == NULL) ? 1 : 2, dirptrs,
  1045. !                 &stackp->ffs_filearray_size,
  1046. !                 &stackp->ffs_filearray,
  1047.                   EW_DIR|EW_ADDSLASH|EW_SILENT);
  1048.   
  1049. !         stackp->ffs_filearray_cur = 0;
  1050. !         stackp->ffs_stage = 0;
  1051.           }
  1052.   #ifdef FEAT_PATH_EXTRA
  1053.           else
  1054. !         rest_of_wildcards = &stackp->ffs_wc_path[
  1055. !                          STRLEN(stackp->ffs_wc_path)];
  1056.   #endif
  1057.   
  1058. !         if (stackp->ffs_stage == 0)
  1059.           {
  1060.           /* this is the first time we work on this directory */
  1061.   #ifdef FEAT_PATH_EXTRA
  1062. ***************
  1063. *** 4581,4598 ****
  1064.                * we don't have further wildcards to expand, so we have to
  1065.                * check for the final file now
  1066.                */
  1067. !             for (i = ctx->ffs_filearray_cur;
  1068. !                          i < ctx->ffs_filearray_size; ++i)
  1069.               {
  1070. !             if (!path_with_url(ctx->ffs_filearray[i])
  1071. !                      && !mch_isdir(ctx->ffs_filearray[i]))
  1072.                   continue;   /* not a directory */
  1073.   
  1074.               /* prepare the filename to be checked for existance
  1075.                * below */
  1076. !             STRCPY(file_path, ctx->ffs_filearray[i]);
  1077.               add_pathsep(file_path);
  1078. !             STRCAT(file_path, ff_search_ctx->ffsc_file_to_search);
  1079.   
  1080.               /*
  1081.                * Try without extra suffix and then with suffixes
  1082. --- 4584,4601 ----
  1083.                * we don't have further wildcards to expand, so we have to
  1084.                * check for the final file now
  1085.                */
  1086. !             for (i = stackp->ffs_filearray_cur;
  1087. !                       i < stackp->ffs_filearray_size; ++i)
  1088.               {
  1089. !             if (!path_with_url(stackp->ffs_filearray[i])
  1090. !                       && !mch_isdir(stackp->ffs_filearray[i]))
  1091.                   continue;   /* not a directory */
  1092.   
  1093.               /* prepare the filename to be checked for existance
  1094.                * below */
  1095. !             STRCPY(file_path, stackp->ffs_filearray[i]);
  1096.               add_pathsep(file_path);
  1097. !             STRCAT(file_path, search_ctx->ffsc_file_to_search);
  1098.   
  1099.               /*
  1100.                * Try without extra suffix and then with suffixes
  1101. ***************
  1102. *** 4606,4617 ****
  1103.               {
  1104.                   /* if file exists and we didn't already find it */
  1105.                   if ((path_with_url(file_path)
  1106. !                     || (mch_getperm(file_path) >= 0
  1107. !                         && (!ff_search_ctx->ffsc_need_dir
  1108. !                         || mch_isdir(file_path))))
  1109.   #ifndef FF_VERBOSE
  1110.                       && (ff_check_visited(
  1111. !                         &ff_search_ctx->ffsc_visited_list->ffvl_visited_list,
  1112.                           file_path
  1113.   #ifdef FEAT_PATH_EXTRA
  1114.                           , (char_u *)""
  1115. --- 4609,4623 ----
  1116.               {
  1117.                   /* if file exists and we didn't already find it */
  1118.                   if ((path_with_url(file_path)
  1119. !                   || (mch_getperm(file_path) >= 0
  1120. !                       && (search_ctx->ffsc_find_what
  1121. !                                   == FINDFILE_BOTH
  1122. !                       || ((search_ctx->ffsc_find_what
  1123. !                                   == FINDFILE_DIR)
  1124. !                            == mch_isdir(file_path)))))
  1125.   #ifndef FF_VERBOSE
  1126.                       && (ff_check_visited(
  1127. !                         &search_ctx->ffsc_visited_list->ffvl_visited_list,
  1128.                           file_path
  1129.   #ifdef FEAT_PATH_EXTRA
  1130.                           , (char_u *)""
  1131. ***************
  1132. *** 4622,4628 ****
  1133.                   {
  1134.   #ifdef FF_VERBOSE
  1135.                   if (ff_check_visited(
  1136. !                         &ff_search_ctx->ffsc_visited_list->ffvl_visited_list,
  1137.                           file_path
  1138.   #ifdef FEAT_PATH_EXTRA
  1139.                           , (char_u *)""
  1140. --- 4628,4634 ----
  1141.                   {
  1142.   #ifdef FF_VERBOSE
  1143.                   if (ff_check_visited(
  1144. !                         &search_ctx->ffsc_visited_list->ffvl_visited_list,
  1145.                           file_path
  1146.   #ifdef FEAT_PATH_EXTRA
  1147.                           , (char_u *)""
  1148. ***************
  1149. *** 4643,4650 ****
  1150.   #endif
  1151.   
  1152.                   /* push dir to examine rest of subdirs later */
  1153. !                 ctx->ffs_filearray_cur = i + 1;
  1154. !                 ff_push(ctx);
  1155.   
  1156.                   simplify_filename(file_path);
  1157.                   if (mch_dirname(ff_expand_buffer, MAXPATHL)
  1158. --- 4649,4656 ----
  1159.   #endif
  1160.   
  1161.                   /* push dir to examine rest of subdirs later */
  1162. !                 stackp->ffs_filearray_cur = i + 1;
  1163. !                 ff_push(search_ctx, stackp);
  1164.   
  1165.                   simplify_filename(file_path);
  1166.                   if (mch_dirname(ff_expand_buffer, MAXPATHL)
  1167. ***************
  1168. *** 4686,4704 ****
  1169.                * still wildcards left, push the directories for further
  1170.                * search
  1171.                */
  1172. !             for (i = ctx->ffs_filearray_cur;
  1173. !                          i < ctx->ffs_filearray_size; ++i)
  1174.               {
  1175. !             if (!mch_isdir(ctx->ffs_filearray[i]))
  1176.                   continue;    /* not a directory */
  1177.   
  1178. !             ff_push(ff_create_stack_element(ctx->ffs_filearray[i],
  1179. !                       rest_of_wildcards, ctx->ffs_level - 1, 0));
  1180.               }
  1181.           }
  1182.   #endif
  1183. !         ctx->ffs_filearray_cur = 0;
  1184. !         ctx->ffs_stage = 1;
  1185.           }
  1186.   
  1187.   #ifdef FEAT_PATH_EXTRA
  1188. --- 4692,4713 ----
  1189.                * still wildcards left, push the directories for further
  1190.                * search
  1191.                */
  1192. !             for (i = stackp->ffs_filearray_cur;
  1193. !                       i < stackp->ffs_filearray_size; ++i)
  1194.               {
  1195. !             if (!mch_isdir(stackp->ffs_filearray[i]))
  1196.                   continue;    /* not a directory */
  1197.   
  1198. !             ff_push(search_ctx,
  1199. !                 ff_create_stack_element(
  1200. !                              stackp->ffs_filearray[i],
  1201. !                              rest_of_wildcards,
  1202. !                              stackp->ffs_level - 1, 0));
  1203.               }
  1204.           }
  1205.   #endif
  1206. !         stackp->ffs_filearray_cur = 0;
  1207. !         stackp->ffs_stage = 1;
  1208.           }
  1209.   
  1210.   #ifdef FEAT_PATH_EXTRA
  1211. ***************
  1212. *** 4706,4728 ****
  1213.            * if wildcards contains '**' we have to descent till we reach the
  1214.            * leaves of the directory tree.
  1215.            */
  1216. !         if (STRNCMP(ctx->ffs_wc_path, "**", 2) == 0)
  1217.           {
  1218. !         for (i = ctx->ffs_filearray_cur;
  1219. !                          i < ctx->ffs_filearray_size; ++i)
  1220.           {
  1221. !             if (fnamecmp(ctx->ffs_filearray[i], ctx->ffs_fix_path) == 0)
  1222.               continue; /* don't repush same directory */
  1223. !             if (!mch_isdir(ctx->ffs_filearray[i]))
  1224.               continue;   /* not a directory */
  1225. !             ff_push(ff_create_stack_element(ctx->ffs_filearray[i],
  1226. !                 ctx->ffs_wc_path, ctx->ffs_level - 1, 1));
  1227.           }
  1228.           }
  1229.   #endif
  1230.   
  1231.           /* we are done with the current directory */
  1232. !         ff_free_stack_element(ctx);
  1233.   
  1234.       }
  1235.   
  1236. --- 4715,4739 ----
  1237.            * if wildcards contains '**' we have to descent till we reach the
  1238.            * leaves of the directory tree.
  1239.            */
  1240. !         if (STRNCMP(stackp->ffs_wc_path, "**", 2) == 0)
  1241.           {
  1242. !         for (i = stackp->ffs_filearray_cur;
  1243. !                       i < stackp->ffs_filearray_size; ++i)
  1244.           {
  1245. !             if (fnamecmp(stackp->ffs_filearray[i],
  1246. !                            stackp->ffs_fix_path) == 0)
  1247.               continue; /* don't repush same directory */
  1248. !             if (!mch_isdir(stackp->ffs_filearray[i]))
  1249.               continue;   /* not a directory */
  1250. !             ff_push(search_ctx,
  1251. !                 ff_create_stack_element(stackp->ffs_filearray[i],
  1252. !                 stackp->ffs_wc_path, stackp->ffs_level - 1, 1));
  1253.           }
  1254.           }
  1255.   #endif
  1256.   
  1257.           /* we are done with the current directory */
  1258. !         ff_free_stack_element(stackp);
  1259.   
  1260.       }
  1261.   
  1262. ***************
  1263. *** 4730,4769 ****
  1264.       /* If we reached this, we didn't find anything downwards.
  1265.        * Let's check if we should do an upward search.
  1266.        */
  1267. !     if (ff_search_ctx->ffsc_start_dir
  1268. !         && ff_search_ctx->ffsc_stopdirs_v != NULL && !got_int)
  1269.       {
  1270.           ff_stack_T  *sptr;
  1271.   
  1272.           /* is the last starting directory in the stop list? */
  1273. !         if (ff_path_in_stoplist(ff_search_ctx->ffsc_start_dir,
  1274. !                (int)(path_end - ff_search_ctx->ffsc_start_dir),
  1275. !                ff_search_ctx->ffsc_stopdirs_v) == TRUE)
  1276.           break;
  1277.   
  1278.           /* cut of last dir */
  1279. !         while (path_end > ff_search_ctx->ffsc_start_dir
  1280. !             && vim_ispathsep(*path_end))
  1281.           path_end--;
  1282. !         while (path_end > ff_search_ctx->ffsc_start_dir
  1283. !             && !vim_ispathsep(path_end[-1]))
  1284.           path_end--;
  1285.           *path_end = 0;
  1286.           path_end--;
  1287.   
  1288. !         if (*ff_search_ctx->ffsc_start_dir == 0)
  1289.           break;
  1290.   
  1291. !         STRCPY(file_path, ff_search_ctx->ffsc_start_dir);
  1292.           add_pathsep(file_path);
  1293. !         STRCAT(file_path, ff_search_ctx->ffsc_fix_path);
  1294.   
  1295.           /* create a new stack entry */
  1296.           sptr = ff_create_stack_element(file_path,
  1297. !             ff_search_ctx->ffsc_wc_path, ff_search_ctx->ffsc_level, 0);
  1298.           if (sptr == NULL)
  1299.           break;
  1300. !         ff_push(sptr);
  1301.       }
  1302.       else
  1303.           break;
  1304. --- 4741,4780 ----
  1305.       /* If we reached this, we didn't find anything downwards.
  1306.        * Let's check if we should do an upward search.
  1307.        */
  1308. !     if (search_ctx->ffsc_start_dir
  1309. !         && search_ctx->ffsc_stopdirs_v != NULL && !got_int)
  1310.       {
  1311.           ff_stack_T  *sptr;
  1312.   
  1313.           /* is the last starting directory in the stop list? */
  1314. !         if (ff_path_in_stoplist(search_ctx->ffsc_start_dir,
  1315. !                (int)(path_end - search_ctx->ffsc_start_dir),
  1316. !                search_ctx->ffsc_stopdirs_v) == TRUE)
  1317.           break;
  1318.   
  1319.           /* cut of last dir */
  1320. !         while (path_end > search_ctx->ffsc_start_dir
  1321. !                           && vim_ispathsep(*path_end))
  1322.           path_end--;
  1323. !         while (path_end > search_ctx->ffsc_start_dir
  1324. !                           && !vim_ispathsep(path_end[-1]))
  1325.           path_end--;
  1326.           *path_end = 0;
  1327.           path_end--;
  1328.   
  1329. !         if (*search_ctx->ffsc_start_dir == 0)
  1330.           break;
  1331.   
  1332. !         STRCPY(file_path, search_ctx->ffsc_start_dir);
  1333.           add_pathsep(file_path);
  1334. !         STRCAT(file_path, search_ctx->ffsc_fix_path);
  1335.   
  1336.           /* create a new stack entry */
  1337.           sptr = ff_create_stack_element(file_path,
  1338. !             search_ctx->ffsc_wc_path, search_ctx->ffsc_level, 0);
  1339.           if (sptr == NULL)
  1340.           break;
  1341. !         ff_push(search_ctx, sptr);
  1342.       }
  1343.       else
  1344.           break;
  1345. ***************
  1346. *** 4779,4794 ****
  1347.    * Can handle it if the passed search_context is NULL;
  1348.    */
  1349.       void
  1350. ! vim_findfile_free_visited(search_ctx)
  1351. !     void    *search_ctx;
  1352.   {
  1353. !     if (search_ctx == NULL)
  1354. !     return;
  1355.   
  1356. !     ff_search_ctx = (ff_search_ctx_T *)search_ctx;
  1357.   
  1358. !     vim_findfile_free_visited_list(&ff_search_ctx->ffsc_visited_lists_list);
  1359. !     vim_findfile_free_visited_list(&ff_search_ctx->ffsc_dir_visited_lists_list);
  1360.   }
  1361.   
  1362.       static void
  1363. --- 4790,4806 ----
  1364.    * Can handle it if the passed search_context is NULL;
  1365.    */
  1366.       void
  1367. ! vim_findfile_free_visited(search_ctx_arg)
  1368. !     void    *search_ctx_arg;
  1369.   {
  1370. !     ff_search_ctx_T *search_ctx;
  1371.   
  1372. !     if (search_ctx_arg == NULL)
  1373. !     return;
  1374.   
  1375. !     search_ctx = (ff_search_ctx_T *)search_ctx_arg;
  1376. !     vim_findfile_free_visited_list(&search_ctx->ffsc_visited_lists_list);
  1377. !     vim_findfile_free_visited_list(&search_ctx->ffsc_dir_visited_lists_list);
  1378.   }
  1379.   
  1380.       static void
  1381. ***************
  1382. *** 5103,5135 ****
  1383.   }
  1384.   
  1385.   /*
  1386. !  * push a dir on the directory stack
  1387.    */
  1388.       static void
  1389. ! ff_push(ctx)
  1390. !     ff_stack_T *ctx;
  1391.   {
  1392.       /* check for NULL pointer, not to return an error to the user, but
  1393.        * to prevent a crash */
  1394. !     if (ctx != NULL)
  1395.       {
  1396. !     ctx->ffs_prev   = ff_search_ctx->ffsc_stack_ptr;
  1397. !     ff_search_ctx->ffsc_stack_ptr = ctx;
  1398.       }
  1399.   }
  1400.   
  1401.   /*
  1402. !  * pop a dir from the directory stack
  1403. !  * returns NULL if stack is empty
  1404.    */
  1405.       static ff_stack_T *
  1406. ! ff_pop()
  1407.   {
  1408.       ff_stack_T  *sptr;
  1409.   
  1410. !     sptr = ff_search_ctx->ffsc_stack_ptr;
  1411. !     if (ff_search_ctx->ffsc_stack_ptr != NULL)
  1412. !     ff_search_ctx->ffsc_stack_ptr = ff_search_ctx->ffsc_stack_ptr->ffs_prev;
  1413.   
  1414.       return sptr;
  1415.   }
  1416. --- 5115,5149 ----
  1417.   }
  1418.   
  1419.   /*
  1420. !  * Push a dir on the directory stack.
  1421.    */
  1422.       static void
  1423. ! ff_push(search_ctx, stack_ptr)
  1424. !     ff_search_ctx_T *search_ctx;
  1425. !     ff_stack_T        *stack_ptr;
  1426.   {
  1427.       /* check for NULL pointer, not to return an error to the user, but
  1428.        * to prevent a crash */
  1429. !     if (stack_ptr != NULL)
  1430.       {
  1431. !     stack_ptr->ffs_prev = search_ctx->ffsc_stack_ptr;
  1432. !     search_ctx->ffsc_stack_ptr = stack_ptr;
  1433.       }
  1434.   }
  1435.   
  1436.   /*
  1437. !  * Pop a dir from the directory stack.
  1438. !  * Returns NULL if stack is empty.
  1439.    */
  1440.       static ff_stack_T *
  1441. ! ff_pop(search_ctx)
  1442. !     ff_search_ctx_T *search_ctx;
  1443.   {
  1444.       ff_stack_T  *sptr;
  1445.   
  1446. !     sptr = search_ctx->ffsc_stack_ptr;
  1447. !     if (search_ctx->ffsc_stack_ptr != NULL)
  1448. !     search_ctx->ffsc_stack_ptr = search_ctx->ffsc_stack_ptr->ffs_prev;
  1449.   
  1450.       return sptr;
  1451.   }
  1452. ***************
  1453. *** 5138,5199 ****
  1454.    * free the given stack element
  1455.    */
  1456.       static void
  1457. ! ff_free_stack_element(ctx)
  1458. !     ff_stack_T  *ctx;
  1459.   {
  1460.       /* vim_free handles possible NULL pointers */
  1461. !     vim_free(ctx->ffs_fix_path);
  1462.   #ifdef FEAT_PATH_EXTRA
  1463. !     vim_free(ctx->ffs_wc_path);
  1464.   #endif
  1465.   
  1466. !     if (ctx->ffs_filearray != NULL)
  1467. !     FreeWild(ctx->ffs_filearray_size, ctx->ffs_filearray);
  1468.   
  1469. !     vim_free(ctx);
  1470.   }
  1471.   
  1472.   /*
  1473. !  * clear the search context
  1474.    */
  1475.       static void
  1476. ! ff_clear()
  1477.   {
  1478.       ff_stack_T   *sptr;
  1479.   
  1480.       /* clear up stack */
  1481. !     while ((sptr = ff_pop()) != NULL)
  1482.       ff_free_stack_element(sptr);
  1483.   
  1484. !     vim_free(ff_search_ctx->ffsc_file_to_search);
  1485. !     vim_free(ff_search_ctx->ffsc_start_dir);
  1486. !     vim_free(ff_search_ctx->ffsc_fix_path);
  1487.   #ifdef FEAT_PATH_EXTRA
  1488. !     vim_free(ff_search_ctx->ffsc_wc_path);
  1489.   #endif
  1490.   
  1491.   #ifdef FEAT_PATH_EXTRA
  1492. !     if (ff_search_ctx->ffsc_stopdirs_v != NULL)
  1493.       {
  1494.       int  i = 0;
  1495.   
  1496. !     while (ff_search_ctx->ffsc_stopdirs_v[i] != NULL)
  1497.       {
  1498. !         vim_free(ff_search_ctx->ffsc_stopdirs_v[i]);
  1499.           i++;
  1500.       }
  1501. !     vim_free(ff_search_ctx->ffsc_stopdirs_v);
  1502.       }
  1503. !     ff_search_ctx->ffsc_stopdirs_v = NULL;
  1504.   #endif
  1505.   
  1506.       /* reset everything */
  1507. !     ff_search_ctx->ffsc_file_to_search    = NULL;
  1508. !     ff_search_ctx->ffsc_start_dir    = NULL;
  1509. !     ff_search_ctx->ffsc_fix_path    = NULL;
  1510.   #ifdef FEAT_PATH_EXTRA
  1511. !     ff_search_ctx->ffsc_wc_path        = NULL;
  1512. !     ff_search_ctx->ffsc_level        = 0;
  1513.   #endif
  1514.   }
  1515.   
  1516. --- 5152,5214 ----
  1517.    * free the given stack element
  1518.    */
  1519.       static void
  1520. ! ff_free_stack_element(stack_ptr)
  1521. !     ff_stack_T  *stack_ptr;
  1522.   {
  1523.       /* vim_free handles possible NULL pointers */
  1524. !     vim_free(stack_ptr->ffs_fix_path);
  1525.   #ifdef FEAT_PATH_EXTRA
  1526. !     vim_free(stack_ptr->ffs_wc_path);
  1527.   #endif
  1528.   
  1529. !     if (stack_ptr->ffs_filearray != NULL)
  1530. !     FreeWild(stack_ptr->ffs_filearray_size, stack_ptr->ffs_filearray);
  1531.   
  1532. !     vim_free(stack_ptr);
  1533.   }
  1534.   
  1535.   /*
  1536. !  * Clear the search context, but NOT the visited list.
  1537.    */
  1538.       static void
  1539. ! ff_clear(search_ctx)
  1540. !     ff_search_ctx_T *search_ctx;
  1541.   {
  1542.       ff_stack_T   *sptr;
  1543.   
  1544.       /* clear up stack */
  1545. !     while ((sptr = ff_pop(search_ctx)) != NULL)
  1546.       ff_free_stack_element(sptr);
  1547.   
  1548. !     vim_free(search_ctx->ffsc_file_to_search);
  1549. !     vim_free(search_ctx->ffsc_start_dir);
  1550. !     vim_free(search_ctx->ffsc_fix_path);
  1551.   #ifdef FEAT_PATH_EXTRA
  1552. !     vim_free(search_ctx->ffsc_wc_path);
  1553.   #endif
  1554.   
  1555.   #ifdef FEAT_PATH_EXTRA
  1556. !     if (search_ctx->ffsc_stopdirs_v != NULL)
  1557.       {
  1558.       int  i = 0;
  1559.   
  1560. !     while (search_ctx->ffsc_stopdirs_v[i] != NULL)
  1561.       {
  1562. !         vim_free(search_ctx->ffsc_stopdirs_v[i]);
  1563.           i++;
  1564.       }
  1565. !     vim_free(search_ctx->ffsc_stopdirs_v);
  1566.       }
  1567. !     search_ctx->ffsc_stopdirs_v = NULL;
  1568.   #endif
  1569.   
  1570.       /* reset everything */
  1571. !     search_ctx->ffsc_file_to_search = NULL;
  1572. !     search_ctx->ffsc_start_dir = NULL;
  1573. !     search_ctx->ffsc_fix_path = NULL;
  1574.   #ifdef FEAT_PATH_EXTRA
  1575. !     search_ctx->ffsc_wc_path = NULL;
  1576. !     search_ctx->ffsc_level = 0;
  1577.   #endif
  1578.   }
  1579.   
  1580. ***************
  1581. *** 5242,5248 ****
  1582.   
  1583.   #if defined(FEAT_SEARCHPATH) || defined(PROTO)
  1584.   /*
  1585. !  * Find the file name "ptr[len]" in the path.
  1586.    *
  1587.    * On the first call set the parameter 'first' to TRUE to initialize
  1588.    * the search.  For repeating calls to FALSE.
  1589. --- 5257,5263 ----
  1590.   
  1591.   #if defined(FEAT_SEARCHPATH) || defined(PROTO)
  1592.   /*
  1593. !  * Find the file name "ptr[len]" in the path.  Also finds directory names.
  1594.    *
  1595.    * On the first call set the parameter 'first' to TRUE to initialize
  1596.    * the search.  For repeating calls to FALSE.
  1597. ***************
  1598. *** 5276,5282 ****
  1599.   {
  1600.       return find_file_in_path_option(ptr, len, options, first,
  1601.           *curbuf->b_p_path == NUL ? p_path : curbuf->b_p_path,
  1602. !         FALSE, rel_fname, curbuf->b_p_sua);
  1603.   }
  1604.   
  1605.   static char_u    *ff_file_to_find = NULL;
  1606. --- 5291,5297 ----
  1607.   {
  1608.       return find_file_in_path_option(ptr, len, options, first,
  1609.           *curbuf->b_p_path == NUL ? p_path : curbuf->b_p_path,
  1610. !         FINDFILE_BOTH, rel_fname, curbuf->b_p_sua);
  1611.   }
  1612.   
  1613.   static char_u    *ff_file_to_find = NULL;
  1614. ***************
  1615. *** 5309,5325 ****
  1616.       char_u    *rel_fname;    /* file name searching relative to */
  1617.   {
  1618.       return find_file_in_path_option(ptr, len, options, TRUE, p_cdpath,
  1619. !                            TRUE, rel_fname, (char_u *)"");
  1620.   }
  1621.   
  1622.       char_u *
  1623. ! find_file_in_path_option(ptr, len, options, first, path_option, need_dir, rel_fname, suffixes)
  1624.       char_u    *ptr;        /* file name */
  1625.       int        len;        /* length of file name */
  1626.       int        options;
  1627.       int        first;        /* use count'th matching file name */
  1628.       char_u    *path_option;    /* p_path or p_cdpath */
  1629. !     int        need_dir;    /* looking for directory name */
  1630.       char_u    *rel_fname;    /* file name we are looking relative to. */
  1631.       char_u    *suffixes;    /* list of suffixes, 'suffixesadd' option */
  1632.   {
  1633. --- 5324,5340 ----
  1634.       char_u    *rel_fname;    /* file name searching relative to */
  1635.   {
  1636.       return find_file_in_path_option(ptr, len, options, TRUE, p_cdpath,
  1637. !                        FINDFILE_DIR, rel_fname, (char_u *)"");
  1638.   }
  1639.   
  1640.       char_u *
  1641. ! find_file_in_path_option(ptr, len, options, first, path_option, find_what, rel_fname, suffixes)
  1642.       char_u    *ptr;        /* file name */
  1643.       int        len;        /* length of file name */
  1644.       int        options;
  1645.       int        first;        /* use count'th matching file name */
  1646.       char_u    *path_option;    /* p_path or p_cdpath */
  1647. !     int        find_what;    /* FINDFILE_FILE, _DIR or _BOTH */
  1648.       char_u    *rel_fname;    /* file name we are looking relative to. */
  1649.       char_u    *suffixes;    /* list of suffixes, 'suffixesadd' option */
  1650.   {
  1651. ***************
  1652. *** 5421,5432 ****
  1653.   #ifdef DJGPP
  1654.                   /* "C:" by itself will fail for mch_getperm(),
  1655.                    * assume it's always valid. */
  1656. !                 (need_dir && NameBuff[0] != NUL
  1657.                     && NameBuff[1] == ':'
  1658.                     && NameBuff[2] == NUL) ||
  1659.   #endif
  1660.                   (mch_getperm(NameBuff) >= 0
  1661. !                        && (!need_dir || mch_isdir(NameBuff))))
  1662.               {
  1663.               file_name = vim_strsave(NameBuff);
  1664.               goto theend;
  1665. --- 5436,5449 ----
  1666.   #ifdef DJGPP
  1667.                   /* "C:" by itself will fail for mch_getperm(),
  1668.                    * assume it's always valid. */
  1669. !                 (find_what != FINDFILE_FILE && NameBuff[0] != NUL
  1670.                     && NameBuff[1] == ':'
  1671.                     && NameBuff[2] == NUL) ||
  1672.   #endif
  1673.                   (mch_getperm(NameBuff) >= 0
  1674. !                  && (find_what == FINDFILE_BOTH
  1675. !                  || ((find_what == FINDFILE_DIR)
  1676. !                             == mch_isdir(NameBuff)))))
  1677.               {
  1678.               file_name = vim_strsave(NameBuff);
  1679.               goto theend;
  1680. ***************
  1681. *** 5457,5465 ****
  1682.       {
  1683.           if (did_findfile_init)
  1684.           {
  1685. -         ff_search_ctx->ffsc_need_dir = need_dir;
  1686.           file_name = vim_findfile(fdip_search_ctx);
  1687. -         ff_search_ctx->ffsc_need_dir = FALSE;
  1688.           if (file_name != NULL)
  1689.               break;
  1690.   
  1691. --- 5474,5480 ----
  1692. ***************
  1693. *** 5492,5498 ****
  1694.           r_ptr = NULL;
  1695.   #endif
  1696.           fdip_search_ctx = vim_findfile_init(buf, ff_file_to_find,
  1697. !                         r_ptr, 100, FALSE, TRUE,
  1698.                          fdip_search_ctx, FALSE, rel_fname);
  1699.           if (fdip_search_ctx != NULL)
  1700.               did_findfile_init = TRUE;
  1701. --- 5507,5513 ----
  1702.           r_ptr = NULL;
  1703.   #endif
  1704.           fdip_search_ctx = vim_findfile_init(buf, ff_file_to_find,
  1705. !                         r_ptr, 100, FALSE, find_what,
  1706.                          fdip_search_ctx, FALSE, rel_fname);
  1707.           if (fdip_search_ctx != NULL)
  1708.               did_findfile_init = TRUE;
  1709. ***************
  1710. *** 5504,5510 ****
  1711.       {
  1712.       if (first == TRUE)
  1713.       {
  1714. !         if (need_dir)
  1715.           EMSG2(_("E344: Can't find directory \"%s\" in cdpath"),
  1716.               ff_file_to_find);
  1717.           else
  1718. --- 5519,5525 ----
  1719.       {
  1720.       if (first == TRUE)
  1721.       {
  1722. !         if (find_what == FINDFILE_DIR)
  1723.           EMSG2(_("E344: Can't find directory \"%s\" in cdpath"),
  1724.               ff_file_to_find);
  1725.           else
  1726. ***************
  1727. *** 5513,5519 ****
  1728.       }
  1729.       else
  1730.       {
  1731. !         if (need_dir)
  1732.           EMSG2(_("E346: No more directory \"%s\" found in cdpath"),
  1733.               ff_file_to_find);
  1734.           else
  1735. --- 5528,5534 ----
  1736.       }
  1737.       else
  1738.       {
  1739. !         if (find_what == FINDFILE_DIR)
  1740.           EMSG2(_("E346: No more directory \"%s\" found in cdpath"),
  1741.               ff_file_to_find);
  1742.           else
  1743. *** ../vim-7.1.255/src/vim.h    Sat Jan 19 15:55:51 2008
  1744. --- src/vim.h    Tue Jan 22 22:35:16 2008
  1745. ***************
  1746. *** 721,726 ****
  1747. --- 721,731 ----
  1748.   /* Note: mostly EW_NOTFOUND and EW_SILENT are mutually exclusive: EW_NOTFOUND
  1749.    * is used when executing commands and EW_SILENT for interactive expanding. */
  1750.   
  1751. + /* Flags for find_file_*() functions. */
  1752. + #define FINDFILE_FILE    0    /* only files */
  1753. + #define FINDFILE_DIR    1    /* only directories */
  1754. + #define FINDFILE_BOTH    2    /* files and directories */
  1755. + 
  1756.   #ifdef FEAT_VERTSPLIT
  1757.   # define W_WINCOL(wp)    (wp->w_wincol)
  1758.   # define W_WIDTH(wp)    (wp->w_width)
  1759. *** ../vim-7.1.255/src/tag.c    Sat Jan 19 15:55:51 2008
  1760. --- src/tag.c    Wed Feb 13 18:02:32 2008
  1761. ***************
  1762. *** 2669,2676 ****
  1763.   
  1764.           tnp->tn_search_ctx = vim_findfile_init(buf, filename,
  1765.               r_ptr, 100,
  1766. !             FALSE, /* don't free visited list */
  1767. !             FALSE, /* we search for a file */
  1768.               tnp->tn_search_ctx, TRUE, curbuf->b_ffname);
  1769.           if (tnp->tn_search_ctx != NULL)
  1770.           tnp->tn_did_filefind_init = TRUE;
  1771. --- 2669,2676 ----
  1772.   
  1773.           tnp->tn_search_ctx = vim_findfile_init(buf, filename,
  1774.               r_ptr, 100,
  1775. !             FALSE,         /* don't free visited list */
  1776. !             FINDFILE_FILE, /* we search for a file */
  1777.               tnp->tn_search_ctx, TRUE, curbuf->b_ffname);
  1778.           if (tnp->tn_search_ctx != NULL)
  1779.           tnp->tn_did_filefind_init = TRUE;
  1780. ***************
  1781. *** 2691,2696 ****
  1782. --- 2691,2697 ----
  1783.   {
  1784.       vim_free(tnp->tn_tags);
  1785.       vim_findfile_cleanup(tnp->tn_search_ctx);
  1786. +     tnp->tn_search_ctx = NULL;
  1787.       ga_clear_strings(&tag_fnames);
  1788.   }
  1789.   
  1790. *** ../vim-7.1.255/src/version.c    Wed Feb 20 11:27:59 2008
  1791. --- src/version.c    Wed Feb 20 12:09:54 2008
  1792. ***************
  1793. *** 668,669 ****
  1794. --- 668,671 ----
  1795.   {   /* Add new patch number below this line */
  1796. + /**/
  1797. +     256,
  1798.   /**/
  1799.  
  1800. -- 
  1801. hundred-and-one symptoms of being an internet addict:
  1802. 38. You wake up at 3 a.m. to go to the bathroom and stop and check your e-mail
  1803.     on the way back to bed.
  1804.  
  1805.  /// Bram Moolenaar -- Bram@Moolenaar.net -- http://www.Moolenaar.net   \\\
  1806. ///        sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ \\\
  1807. \\\        download, build and distribute -- http://www.A-A-P.org        ///
  1808.  \\\            help me help AIDS victims -- http://ICCF-Holland.org    ///
  1809.