7.1.256

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