src/fold.c

   1 /* vim:set ts=8 sts=4 sw=4:
   2  * vim600:fdm=marker fdl=1 fdc=3:
   3  *
   4  * VIM - Vi IMproved    by Bram Moolenaar
   5  *
   6  * Do ":help uganda"  in Vim to read copying and usage conditions.
   7  * Do ":help credits" in Vim to see a list of people who contributed.
   8  * See README.txt for an overview of the Vim source code.
   9  */
  10
  11 /*
  12  * fold.c: code for folding
  13  */
  14
  15 #include "vim.h"
  16
  17 #if defined(FEAT_FOLDING) || defined(PROTO)
  18
  19 /* local declarations. {{{1 */
  20 /* typedef fold_T {{{2 */
  21 /*
  22  * The toplevel folds for each window are stored in the w_folds growarray.
  23  * Each toplevel fold can contain an array of second level folds in the
  24  * fd_nested growarray.
  25  * The info stored in both growarrays is the same: An array of fold_T.
  26  */
  27 typedef struct
  28 {
  29     linenr_T    fd_top;         /* first line of fold; for nested fold
  30                                  * relative to parent */
  31     linenr_T    fd_len;         /* number of lines in the fold */
  32     garray_T    fd_nested;      /* array of nested folds */
  33     char        fd_flags;       /* see below */
  34     char        fd_small;       /* TRUE, FALSE or MAYBE: fold smaller than
  35                                    'foldminlines'; MAYBE applies to nested
  36                                    folds too */
  37 } fold_T;
  38
  39 #define FD_OPEN         0       /* fold is open (nested ones can be closed) */
  40 #define FD_CLOSED       1       /* fold is closed */
  41 #define FD_LEVEL        2       /* depends on 'foldlevel' (nested folds too) */
  42
  43 #define MAX_LEVEL       20      /* maximum fold depth */
  44
  45 /* static functions {{{2 */
  46 static void newFoldLevelWin __ARGS((win_T *wp));
  47 static int checkCloseRec __ARGS((garray_T *gap, linenr_T lnum, int level));
  48 static int foldFind __ARGS((garray_T *gap, linenr_T lnum, fold_T **fpp));
  49 static int foldLevelWin __ARGS((win_T *wp, linenr_T lnum));
  50 static void checkupdate __ARGS((win_T *wp));
  51 static void setFoldRepeat __ARGS((linenr_T lnum, long count, int do_open));
  52 static linenr_T setManualFold __ARGS((linenr_T lnum, int opening, int recurse, int *donep));
  53 static linenr_T setManualFoldWin __ARGS((win_T *wp, linenr_T lnum, int opening, int recurse, int *donep));
  54 static void foldOpenNested __ARGS((fold_T *fpr));
  55 static void deleteFoldEntry __ARGS((garray_T *gap, int idx, int recursive));
  56 static void foldMarkAdjustRecurse __ARGS((garray_T *gap, linenr_T line1, linenr_T line2, long amount, long amount_after));
  57 static int getDeepestNestingRecurse __ARGS((garray_T *gap));
  58 static int check_closed __ARGS((win_T *win, fold_T *fp, int *use_levelp, int level, int *maybe_smallp, linenr_T lnum_off));
  59 static void checkSmall __ARGS((win_T *wp, fold_T *fp, linenr_T lnum_off));
  60 static void setSmallMaybe __ARGS((garray_T *gap));
  61 static void foldCreateMarkers __ARGS((linenr_T start, linenr_T end));
  62 static void foldAddMarker __ARGS((linenr_T lnum, char_u *marker, int markerlen));
  63 static void deleteFoldMarkers __ARGS((fold_T *fp, int recursive, linenr_T lnum_off));
  64 static void foldDelMarker __ARGS((linenr_T lnum, char_u *marker, int markerlen));
  65 static void foldUpdateIEMS __ARGS((win_T *wp, linenr_T top, linenr_T bot));
  66 static void parseMarker __ARGS((win_T *wp));
  67
  68 static char *e_nofold = N_("E490: No fold found");
  69
  70 /*
  71  * While updating the folds lines between invalid_top and invalid_bot have an
  72  * undefined fold level.  Only used for the window currently being updated.
  73  */
  74 static linenr_T invalid_top = (linenr_T)0;
  75 static linenr_T invalid_bot = (linenr_T)0;
  76
  77 /*
  78  * When using 'foldexpr' we sometimes get the level of the next line, which
  79  * calls foldlevel() to get the level of the current line, which hasn't been
  80  * stored yet.  To get around this chicken-egg problem the level of the
  81  * previous line is stored here when available.  prev_lnum is zero when the
  82  * level is not available.
  83  */
  84 static linenr_T prev_lnum = 0;
  85 static int prev_lnum_lvl = -1;
  86
  87 /* Flags used for "done" argument of setManualFold. */
  88 #define DONE_NOTHING    0
  89 #define DONE_ACTION     1       /* did close or open a fold */
  90 #define DONE_FOLD       2       /* did find a fold */
  91
  92 static int foldstartmarkerlen;
  93 static char_u *foldendmarker;
  94 static int foldendmarkerlen;
  95
  96 /* Exported folding functions. {{{1 */
  97 /* copyFoldingState() {{{2 */
  98 #if defined(FEAT_WINDOWS) || defined(PROTO)
  99 /*
 100  * Copy that folding state from window "wp_from" to window "wp_to".
 101  */
 102     void
 103 copyFoldingState(wp_from, wp_to)
 104     win_T       *wp_from;
 105     win_T       *wp_to;
 106 {
 107     wp_to->w_fold_manual = wp_from->w_fold_manual;
 108     wp_to->w_foldinvalid = wp_from->w_foldinvalid;
 109     cloneFoldGrowArray(&wp_from->w_folds, &wp_to->w_folds);
 110 }
 111 #endif
 112
 113 /* hasAnyFolding() {{{2 */
 114 /*
 115  * Return TRUE if there may be folded lines in the current window.
 116  */
 117     int
 118 hasAnyFolding(win)
 119     win_T       *win;
 120 {
 121     /* very simple now, but can become more complex later */
 122     return (win->w_p_fen
 123             && (!foldmethodIsManual(win) || win->w_folds.ga_len > 0));
 124 }
 125
 126 /* hasFolding() {{{2 */
 127 /*
 128  * Return TRUE if line "lnum" in the current window is part of a closed
 129  * fold.
 130  * When returning TRUE, *firstp and *lastp are set to the first and last
 131  * lnum of the sequence of folded lines (skipped when NULL).
 132  */
 133     int
 134 hasFolding(lnum, firstp, lastp)
 135     linenr_T    lnum;
 136     linenr_T    *firstp;
 137     linenr_T    *lastp;
 138 {
 139     return hasFoldingWin(curwin, lnum, firstp, lastp, TRUE, NULL);
 140 }
 141
 142 /* hasFoldingWin() {{{2 */
 143     int
 144 hasFoldingWin(win, lnum, firstp, lastp, cache, infop)
 145     win_T       *win;
 146     linenr_T    lnum;
 147     linenr_T    *firstp;
 148     linenr_T    *lastp;
 149     int         cache;          /* when TRUE: use cached values of window */
 150     foldinfo_T  *infop;         /* where to store fold info */
 151 {
 152     int         had_folded = FALSE;
 153     linenr_T    first = 0;
 154     linenr_T    last = 0;
 155     linenr_T    lnum_rel = lnum;
 156     int         x;
 157     fold_T      *fp;
 158     int         level = 0;
 159     int         use_level = FALSE;
 160     int         maybe_small = FALSE;
 161     garray_T    *gap;
 162     int         low_level = 0;;
 163
 164     checkupdate(win);
 165     /*
 166      * Return quickly when there is no folding at all in this window.
 167      */
 168     if (!hasAnyFolding(win))
 169     {
 170         if (infop != NULL)
 171             infop->fi_level = 0;
 172         return FALSE;
 173     }
 174
 175     if (cache)
 176     {
 177         /*
 178          * First look in cached info for displayed lines.  This is probably
 179          * the fastest, but it can only be used if the entry is still valid.
 180          */
 181         x = find_wl_entry(win, lnum);
 182         if (x >= 0)
 183         {
 184             first = win->w_lines[x].wl_lnum;
 185             last = win->w_lines[x].wl_lastlnum;
 186             had_folded = win->w_lines[x].wl_folded;
 187         }
 188     }
 189
 190     if (first == 0)
 191     {
 192         /*
 193          * Recursively search for a fold that contains "lnum".
 194          */
 195         gap = &win->w_folds;
 196         for (;;)
 197         {
 198             if (!foldFind(gap, lnum_rel, &fp))
 199                 break;
 200
 201             /* Remember lowest level of fold that starts in "lnum". */
 202             if (lnum_rel == fp->fd_top && low_level == 0)
 203                 low_level = level + 1;
 204
 205             first += fp->fd_top;
 206             last += fp->fd_top;
 207
 208             /* is this fold closed? */
 209             had_folded = check_closed(win, fp, &use_level, level,
 210                                                &maybe_small, lnum - lnum_rel);
 211             if (had_folded)
 212             {
 213                 /* Fold closed: Set last and quit loop. */
 214                 last += fp->fd_len - 1;
 215                 break;
 216             }
 217
 218             /* Fold found, but it's open: Check nested folds.  Line number is
 219              * relative to containing fold. */
 220             gap = &fp->fd_nested;
 221             lnum_rel -= fp->fd_top;
 222             ++level;
 223         }
 224     }
 225
 226     if (!had_folded)
 227     {
 228         if (infop != NULL)
 229         {
 230             infop->fi_level = level;
 231             infop->fi_lnum = lnum - lnum_rel;
 232             infop->fi_low_level = low_level == 0 ? level : low_level;
 233         }
 234         return FALSE;
 235     }
 236
 237     if (lastp != NULL)
 238         *lastp = last;
 239     if (firstp != NULL)
 240         *firstp = first;
 241     if (infop != NULL)
 242     {
 243         infop->fi_level = level + 1;
 244         infop->fi_lnum = first;
 245         infop->fi_low_level = low_level == 0 ? level + 1 : low_level;
 246     }
 247     return TRUE;
 248 }
 249
 250 /* foldLevel() {{{2 */
 251 /*
 252  * Return fold level at line number "lnum" in the current window.
 253  */
 254     int
 255 foldLevel(lnum)
 256     linenr_T    lnum;
 257 {
 258     /* While updating the folds lines between invalid_top and invalid_bot have
 259      * an undefined fold level.  Otherwise update the folds first. */
 260     if (invalid_top == (linenr_T)0)
 261         checkupdate(curwin);
 262     else if (lnum == prev_lnum && prev_lnum_lvl >= 0)
 263         return prev_lnum_lvl;
 264     else if (lnum >= invalid_top && lnum <= invalid_bot)
 265         return -1;
 266
 267     /* Return quickly when there is no folding at all in this window. */
 268     if (!hasAnyFolding(curwin))
 269         return 0;
 270
 271     return foldLevelWin(curwin, lnum);
 272 }
 273
 274 /* lineFolded() {{{2 */
 275 /*
 276  * Low level function to check if a line is folded.  Doesn't use any caching.
 277  * Return TRUE if line is folded.
 278  * Return FALSE if line is not folded.
 279  * Return MAYBE if the line is folded when next to a folded line.
 280  */
 281     int
 282 lineFolded(win, lnum)
 283     win_T       *win;
 284     linenr_T    lnum;
 285 {
 286     return foldedCount(win, lnum, NULL) != 0;
 287 }
 288
 289 /* foldedCount() {{{2 */
 290 /*
 291  * Count the number of lines that are folded at line number "lnum".
 292  * Normally "lnum" is the first line of a possible fold, and the returned
 293  * number is the number of lines in the fold.
 294  * Doesn't use caching from the displayed window.
 295  * Returns number of folded lines from "lnum", or 0 if line is not folded.
 296  * When "infop" is not NULL, fills *infop with the fold level info.
 297  */
 298     long
 299 foldedCount(win, lnum, infop)
 300     win_T       *win;
 301     linenr_T    lnum;
 302     foldinfo_T  *infop;
 303 {
 304     linenr_T    last;
 305
 306     if (hasFoldingWin(win, lnum, NULL, &last, FALSE, infop))
 307         return (long)(last - lnum + 1);
 308     return 0;
 309 }
 310
 311 /* foldmethodIsManual() {{{2 */
 312 /*
 313  * Return TRUE if 'foldmethod' is "manual"
 314  */
 315     int
 316 foldmethodIsManual(wp)
 317     win_T       *wp;
 318 {
 319     return (wp->w_p_fdm[3] == 'u');
 320 }
 321
 322 /* foldmethodIsIndent() {{{2 */
 323 /*
 324  * Return TRUE if 'foldmethod' is "indent"
 325  */
 326     int
 327 foldmethodIsIndent(wp)
 328     win_T       *wp;
 329 {
 330     return (wp->w_p_fdm[0] == 'i');
 331 }
 332
 333 /* foldmethodIsExpr() {{{2 */
 334 /*
 335  * Return TRUE if 'foldmethod' is "expr"
 336  */
 337     int
 338 foldmethodIsExpr(wp)
 339     win_T       *wp;
 340 {
 341     return (wp->w_p_fdm[1] == 'x');
 342 }
 343
 344 /* foldmethodIsMarker() {{{2 */
 345 /*
 346  * Return TRUE if 'foldmethod' is "marker"
 347  */
 348     int
 349 foldmethodIsMarker(wp)
 350     win_T       *wp;
 351 {
 352     return (wp->w_p_fdm[2] == 'r');
 353 }
 354
 355 /* foldmethodIsSyntax() {{{2 */
 356 /*
 357  * Return TRUE if 'foldmethod' is "syntax"
 358  */
 359     int
 360 foldmethodIsSyntax(wp)
 361     win_T       *wp;
 362 {
 363     return (wp->w_p_fdm[0] == 's');
 364 }
 365
 366 /* foldmethodIsDiff() {{{2 */
 367 /*
 368  * Return TRUE if 'foldmethod' is "diff"
 369  */
 370     int
 371 foldmethodIsDiff(wp)
 372     win_T       *wp;
 373 {
 374     return (wp->w_p_fdm[0] == 'd');
 375 }
 376
 377 /* closeFold() {{{2 */
 378 /*
 379  * Close fold for current window at line "lnum".
 380  * Repeat "count" times.
 381  */
 382     void
 383 closeFold(lnum, count)
 384     linenr_T    lnum;
 385     long        count;
 386 {
 387     setFoldRepeat(lnum, count, FALSE);
 388 }
 389
 390 /* closeFoldRecurse() {{{2 */
 391 /*
 392  * Close fold for current window at line "lnum" recursively.
 393  */
 394     void
 395 closeFoldRecurse(lnum)
 396     linenr_T    lnum;
 397 {
 398     (void)setManualFold(lnum, FALSE, TRUE, NULL);
 399 }
 400
 401 /* opFoldRange() {{{2 */
 402 /*
 403  * Open or Close folds for current window in lines "first" to "last".
 404  * Used for "zo", "zO", "zc" and "zC" in Visual mode.
 405  */
 406     void
 407 opFoldRange(first, last, opening, recurse, had_visual)
 408     linenr_T    first;
 409     linenr_T    last;
 410     int         opening;        /* TRUE to open, FALSE to close */
 411     int         recurse;        /* TRUE to do it recursively */
 412     int         had_visual;     /* TRUE when Visual selection used */
 413 {
 414     int         done = DONE_NOTHING;    /* avoid error messages */
 415     linenr_T    lnum;
 416     linenr_T    lnum_next;
 417
 418     for (lnum = first; lnum <= last; lnum = lnum_next + 1)
 419     {
 420         lnum_next = lnum;
 421         /* Opening one level only: next fold to open is after the one going to
 422          * be opened. */
 423         if (opening && !recurse)
 424             (void)hasFolding(lnum, NULL, &lnum_next);
 425         (void)setManualFold(lnum, opening, recurse, &done);
 426         /* Closing one level only: next line to close a fold is after just
 427          * closed fold. */
 428         if (!opening && !recurse)
 429             (void)hasFolding(lnum, NULL, &lnum_next);
 430     }
 431     if (done == DONE_NOTHING)
 432         EMSG(_(e_nofold));
 433 #ifdef FEAT_VISUAL
 434     /* Force a redraw to remove the Visual highlighting. */
 435     if (had_visual)
 436         redraw_curbuf_later(INVERTED);
 437 #endif
 438 }
 439
 440 /* openFold() {{{2 */
 441 /*
 442  * Open fold for current window at line "lnum".
 443  * Repeat "count" times.
 444  */
 445     void
 446 openFold(lnum, count)
 447     linenr_T    lnum;
 448     long        count;
 449 {
 450     setFoldRepeat(lnum, count, TRUE);
 451 }
 452
 453 /* openFoldRecurse() {{{2 */
 454 /*
 455  * Open fold for current window at line "lnum" recursively.
 456  */
 457     void
 458 openFoldRecurse(lnum)
 459     linenr_T    lnum;
 460 {
 461     (void)setManualFold(lnum, TRUE, TRUE, NULL);
 462 }
 463
 464 /* foldOpenCursor() {{{2 */
 465 /*
 466  * Open folds until the cursor line is not in a closed fold.
 467  */
 468     void
 469 foldOpenCursor()
 470 {
 471     int         done;
 472
 473     checkupdate(curwin);
 474     if (hasAnyFolding(curwin))
 475         for (;;)
 476         {
 477             done = DONE_NOTHING;
 478             (void)setManualFold(curwin->w_cursor.lnum, TRUE, FALSE, &done);
 479             if (!(done & DONE_ACTION))
 480                 break;
 481         }
 482 }
 483
 484 /* newFoldLevel() {{{2 */
 485 /*
 486  * Set new foldlevel for current window.
 487  */
 488     void
 489 newFoldLevel()
 490 {
 491     newFoldLevelWin(curwin);
 492
 493 #ifdef FEAT_DIFF
 494     if (foldmethodIsDiff(curwin) && curwin->w_p_scb)
 495     {
 496         win_T       *wp;
 497
 498         /*
 499          * Set the same foldlevel in other windows in diff mode.
 500          */
 501         FOR_ALL_WINDOWS(wp)
 502         {
 503             if (wp != curwin && foldmethodIsDiff(wp) && wp->w_p_scb)
 504             {
 505                 wp->w_p_fdl = curwin->w_p_fdl;
 506                 newFoldLevelWin(wp);
 507             }
 508         }
 509     }
 510 #endif
 511 }
 512
 513     static void
 514 newFoldLevelWin(wp)
 515     win_T       *wp;
 516 {
 517     fold_T      *fp;
 518     int         i;
 519
 520     checkupdate(wp);
 521     if (wp->w_fold_manual)
 522     {
 523         /* Set all flags for the first level of folds to FD_LEVEL.  Following
 524          * manual open/close will then change the flags to FD_OPEN or
 525          * FD_CLOSED for those folds that don't use 'foldlevel'. */
 526         fp = (fold_T *)wp->w_folds.ga_data;
 527         for (i = 0; i < wp->w_folds.ga_len; ++i)
 528             fp[i].fd_flags = FD_LEVEL;
 529         wp->w_fold_manual = FALSE;
 530     }
 531     changed_window_setting_win(wp);
 532 }
 533
 534 /* foldCheckClose() {{{2 */
 535 /*
 536  * Apply 'foldlevel' to all folds that don't contain the cursor.
 537  */
 538     void
 539 foldCheckClose()
 540 {
 541     if (*p_fcl != NUL)  /* can only be "all" right now */
 542     {
 543         checkupdate(curwin);
 544         if (checkCloseRec(&curwin->w_folds, curwin->w_cursor.lnum,
 545                                                         (int)curwin->w_p_fdl))
 546             changed_window_setting();
 547     }
 548 }
 549
 550 /* checkCloseRec() {{{2 */
 551     static int
 552 checkCloseRec(gap, lnum, level)
 553     garray_T    *gap;
 554     linenr_T    lnum;
 555     int         level;
 556 {
 557     fold_T      *fp;
 558     int         retval = FALSE;
 559     int         i;
 560
 561     fp = (fold_T *)gap->ga_data;
 562     for (i = 0; i < gap->ga_len; ++i)
 563     {
 564         /* Only manually opened folds may need to be closed. */
 565         if (fp[i].fd_flags == FD_OPEN)
 566         {
 567             if (level <= 0 && (lnum < fp[i].fd_top
 568                                       || lnum >= fp[i].fd_top + fp[i].fd_len))
 569             {
 570                 fp[i].fd_flags = FD_LEVEL;
 571                 retval = TRUE;
 572             }
 573             else
 574                 retval |= checkCloseRec(&fp[i].fd_nested, lnum - fp[i].fd_top,
 575                                                                    level - 1);
 576         }
 577     }
 578     return retval;
 579 }
 580
 581 /* foldCreateAllowed() {{{2 */
 582 /*
 583  * Return TRUE if it's allowed to manually create or delete a fold.
 584  * Give an error message and return FALSE if not.
 585  */
 586     int
 587 foldManualAllowed(create)
 588     int         create;
 589 {
 590     if (foldmethodIsManual(curwin) || foldmethodIsMarker(curwin))
 591         return TRUE;
 592     if (create)
 593         EMSG(_("E350: Cannot create fold with current 'foldmethod'"));
 594     else
 595         EMSG(_("E351: Cannot delete fold with current 'foldmethod'"));
 596     return FALSE;
 597 }
 598
 599 /* foldCreate() {{{2 */
 600 /*
 601  * Create a fold from line "start" to line "end" (inclusive) in the current
 602  * window.
 603  */
 604     void
 605 foldCreate(start, end)
 606     linenr_T    start;
 607     linenr_T    end;
 608 {
 609     fold_T      *fp;
 610     garray_T    *gap;
 611     garray_T    fold_ga;
 612     int         i, j;
 613     int         cont;
 614     int         use_level = FALSE;
 615     int         closed = FALSE;
 616     int         level = 0;
 617     linenr_T    start_rel = start;
 618     linenr_T    end_rel = end;
 619
 620     if (start > end)
 621     {
 622         /* reverse the range */
 623         end = start_rel;
 624         start = end_rel;
 625         start_rel = start;
 626         end_rel = end;
 627     }
 628
 629     /* When 'foldmethod' is "marker" add markers, which creates the folds. */
 630     if (foldmethodIsMarker(curwin))
 631     {
 632         foldCreateMarkers(start, end);
 633         return;
 634     }
 635
 636     checkupdate(curwin);
 637
 638     /* Find the place to insert the new fold. */
 639     gap = &curwin->w_folds;
 640     for (;;)
 641     {
 642         if (!foldFind(gap, start_rel, &fp))
 643             break;
 644         if (fp->fd_top + fp->fd_len > end_rel)
 645         {
 646             /* New fold is completely inside this fold: Go one level deeper. */
 647             gap = &fp->fd_nested;
 648             start_rel -= fp->fd_top;
 649             end_rel -= fp->fd_top;
 650             if (use_level || fp->fd_flags == FD_LEVEL)
 651             {
 652                 use_level = TRUE;
 653                 if (level >= curwin->w_p_fdl)
 654                     closed = TRUE;
 655             }
 656             else if (fp->fd_flags == FD_CLOSED)
 657                 closed = TRUE;
 658             ++level;
 659         }
 660         else
 661         {
 662             /* This fold and new fold overlap: Insert here and move some folds
 663              * inside the new fold. */
 664             break;
 665         }
 666     }
 667
 668     i = (int)(fp - (fold_T *)gap->ga_data);
 669     if (ga_grow(gap, 1) == OK)
 670     {
 671         fp = (fold_T *)gap->ga_data + i;
 672         ga_init2(&fold_ga, (int)sizeof(fold_T), 10);
 673
 674         /* Count number of folds that will be contained in the new fold. */
 675         for (cont = 0; i + cont < gap->ga_len; ++cont)
 676             if (fp[cont].fd_top > end_rel)
 677                 break;
 678         if (cont > 0 && ga_grow(&fold_ga, cont) == OK)
 679         {
 680             /* If the first fold starts before the new fold, let the new fold
 681              * start there.  Otherwise the existing fold would change. */
 682             if (start_rel > fp->fd_top)
 683                 start_rel = fp->fd_top;
 684
 685             /* When last contained fold isn't completely contained, adjust end
 686              * of new fold. */
 687             if (end_rel < fp[cont - 1].fd_top + fp[cont - 1].fd_len - 1)
 688                 end_rel = fp[cont - 1].fd_top + fp[cont - 1].fd_len - 1;
 689             /* Move contained folds to inside new fold. */
 690             mch_memmove(fold_ga.ga_data, fp, sizeof(fold_T) * cont);
 691             fold_ga.ga_len += cont;
 692             i += cont;
 693
 694             /* Adjust line numbers in contained folds to be relative to the
 695              * new fold. */
 696             for (j = 0; j < cont; ++j)
 697                 ((fold_T *)fold_ga.ga_data)[j].fd_top -= start_rel;
 698         }
 699         /* Move remaining entries to after the new fold. */
 700         if (i < gap->ga_len)
 701             mch_memmove(fp + 1, (fold_T *)gap->ga_data + i,
 702                                      sizeof(fold_T) * (gap->ga_len - i));
 703         gap->ga_len = gap->ga_len + 1 - cont;
 704
 705         /* insert new fold */
 706         fp->fd_nested = fold_ga;
 707         fp->fd_top = start_rel;
 708         fp->fd_len = end_rel - start_rel + 1;
 709
 710         /* We want the new fold to be closed.  If it would remain open because
 711          * of using 'foldlevel', need to adjust fd_flags of containing folds.
 712          */
 713         if (use_level && !closed && level < curwin->w_p_fdl)
 714             closeFold(start, 1L);
 715         if (!use_level)
 716             curwin->w_fold_manual = TRUE;
 717         fp->fd_flags = FD_CLOSED;
 718         fp->fd_small = MAYBE;
 719
 720         /* redraw */
 721         changed_window_setting();
 722     }
 723 }
 724
 725 /* deleteFold() {{{2 */
 726 /*
 727  * Delete a fold at line "start" in the current window.
 728  * When "end" is not 0, delete all folds from "start" to "end".
 729  * When "recursive" is TRUE delete recursively.
 730  */
 731     void
 732 deleteFold(start, end, recursive, had_visual)
 733     linenr_T    start;
 734     linenr_T    end;
 735     int         recursive;
 736     int         had_visual;     /* TRUE when Visual selection used */
 737 {
 738     garray_T    *gap;
 739     fold_T      *fp;
 740     garray_T    *found_ga;
 741     fold_T      *found_fp = NULL;
 742     linenr_T    found_off = 0;
 743     int         use_level;
 744     int         maybe_small = FALSE;
 745     int         level = 0;
 746     linenr_T    lnum = start;
 747     linenr_T    lnum_off;
 748     int         did_one = FALSE;
 749     linenr_T    first_lnum = MAXLNUM;
 750     linenr_T    last_lnum = 0;
 751
 752     checkupdate(curwin);
 753
 754     while (lnum <= end)
 755     {
 756         /* Find the deepest fold for "start". */
 757         gap = &curwin->w_folds;
 758         found_ga = NULL;
 759         lnum_off = 0;
 760         use_level = FALSE;
 761         for (;;)
 762         {
 763             if (!foldFind(gap, lnum - lnum_off, &fp))
 764                 break;
 765             /* lnum is inside this fold, remember info */
 766             found_ga = gap;
 767             found_fp = fp;
 768             found_off = lnum_off;
 769
 770             /* if "lnum" is folded, don't check nesting */
 771             if (check_closed(curwin, fp, &use_level, level,
 772                                                       &maybe_small, lnum_off))
 773                 break;
 774
 775             /* check nested folds */
 776             gap = &fp->fd_nested;
 777             lnum_off += fp->fd_top;
 778             ++level;
 779         }
 780         if (found_ga == NULL)
 781         {
 782             ++lnum;
 783         }
 784         else
 785         {
 786             lnum = found_fp->fd_top + found_fp->fd_len + found_off;
 787
 788             if (foldmethodIsManual(curwin))
 789                 deleteFoldEntry(found_ga,
 790                     (int)(found_fp - (fold_T *)found_ga->ga_data), recursive);
 791             else
 792             {
 793                 if (first_lnum > found_fp->fd_top + found_off)
 794                     first_lnum = found_fp->fd_top + found_off;
 795                 if (last_lnum < lnum)
 796                     last_lnum = lnum;
 797                 if (!did_one)
 798                     parseMarker(curwin);
 799                 deleteFoldMarkers(found_fp, recursive, found_off);
 800             }
 801             did_one = TRUE;
 802
 803             /* redraw window */
 804             changed_window_setting();
 805         }
 806     }
 807     if (!did_one)
 808     {
 809         EMSG(_(e_nofold));
 810 #ifdef FEAT_VISUAL
 811         /* Force a redraw to remove the Visual highlighting. */
 812         if (had_visual)
 813             redraw_curbuf_later(INVERTED);
 814 #endif
 815     }
 816     else
 817         /* Deleting markers may make cursor column invalid. */
 818         check_cursor_col();
 819
 820     if (last_lnum > 0)
 821         changed_lines(first_lnum, (colnr_T)0, last_lnum, 0L);
 822 }
 823
 824 /* clearFolding() {{{2 */
 825 /*
 826  * Remove all folding for window "win".
 827  */
 828     void
 829 clearFolding(win)
 830     win_T       *win;
 831 {
 832     deleteFoldRecurse(&win->w_folds);
 833     win->w_foldinvalid = FALSE;
 834 }
 835
 836 /* foldUpdate() {{{2 */
 837 /*
 838  * Update folds for changes in the buffer of a window.
 839  * Note that inserted/deleted lines must have already been taken care of by
 840  * calling foldMarkAdjust().
 841  * The changes in lines from top to bot (inclusive).
 842  */
 843     void
 844 foldUpdate(wp, top, bot)
 845     win_T       *wp;
 846     linenr_T    top;
 847     linenr_T    bot;
 848 {
 849     fold_T      *fp;
 850
 851     /* Mark all folds from top to bot as maybe-small. */
 852     (void)foldFind(&curwin->w_folds, top, &fp);
 853     while (fp < (fold_T *)curwin->w_folds.ga_data + curwin->w_folds.ga_len
 854             && fp->fd_top < bot)
 855     {
 856         fp->fd_small = MAYBE;
 857         ++fp;
 858     }
 859
 860     if (foldmethodIsIndent(wp)
 861             || foldmethodIsExpr(wp)
 862             || foldmethodIsMarker(wp)
 863 #ifdef FEAT_DIFF
 864             || foldmethodIsDiff(wp)
 865 #endif
 866             || foldmethodIsSyntax(wp))
 867     {
 868         int save_got_int = got_int;
 869
 870         /* reset got_int here, otherwise it won't work */
 871         got_int = FALSE;
 872         foldUpdateIEMS(wp, top, bot);
 873         got_int |= save_got_int;
 874     }
 875 }
 876
 877 /* foldUpdateAll() {{{2 */
 878 /*
 879  * Update all lines in a window for folding.
 880  * Used when a fold setting changes or after reloading the buffer.
 881  * The actual updating is postponed until fold info is used, to avoid doing
 882  * every time a setting is changed or a syntax item is added.
 883  */
 884     void
 885 foldUpdateAll(win)
 886     win_T       *win;
 887 {
 888     win->w_foldinvalid = TRUE;
 889     redraw_win_later(win, NOT_VALID);
 890 }
 891
 892 /* foldMoveTo() {{{2 */
 893 /*
 894  * If "updown" is FALSE: Move to the start or end of the fold.
 895  * If "updown" is TRUE: move to fold at the same level.
 896  * If not moved return FAIL.
 897  */
 898     int
 899 foldMoveTo(updown, dir, count)
 900     int         updown;
 901     int         dir;        /* FORWARD or BACKWARD */
 902     long        count;
 903 {
 904     long        n;
 905     int         retval = FAIL;
 906     linenr_T    lnum_off;
 907     linenr_T    lnum_found;
 908     linenr_T    lnum;
 909     int         use_level;
 910     int         maybe_small;
 911     garray_T    *gap;
 912     fold_T      *fp;
 913     int         level;
 914     int         last;
 915
 916     checkupdate(curwin);
 917
 918     /* Repeat "count" times. */
 919     for (n = 0; n < count; ++n)
 920     {
 921         /* Find nested folds.  Stop when a fold is closed.  The deepest fold
 922          * that moves the cursor is used. */
 923         lnum_off = 0;
 924         gap = &curwin->w_folds;
 925         use_level = FALSE;
 926         maybe_small = FALSE;
 927         lnum_found = curwin->w_cursor.lnum;
 928         level = 0;
 929         last = FALSE;
 930         for (;;)
 931         {
 932             if (!foldFind(gap, curwin->w_cursor.lnum - lnum_off, &fp))
 933             {
 934                 if (!updown)
 935                     break;
 936
 937                 /* When moving up, consider a fold above the cursor; when
 938                  * moving down consider a fold below the cursor. */
 939                 if (dir == FORWARD)
 940                 {
 941                     if (fp - (fold_T *)gap->ga_data >= gap->ga_len)
 942                         break;
 943                     --fp;
 944                 }
 945                 else
 946                 {
 947                     if (fp == (fold_T *)gap->ga_data)
 948                         break;
 949                 }
 950                 /* don't look for contained folds, they will always move
 951                  * the cursor too far. */
 952                 last = TRUE;
 953             }
 954
 955             if (!last)
 956             {
 957                 /* Check if this fold is closed. */
 958                 if (check_closed(curwin, fp, &use_level, level,
 959                                                       &maybe_small, lnum_off))
 960                     last = TRUE;
 961
 962                 /* "[z" and "]z" stop at closed fold */
 963                 if (last && !updown)
 964                     break;
 965             }
 966
 967             if (updown)
 968             {
 969                 if (dir == FORWARD)
 970                 {
 971                     /* to start of next fold if there is one */
 972                     if (fp + 1 - (fold_T *)gap->ga_data < gap->ga_len)
 973                     {
 974                         lnum = fp[1].fd_top + lnum_off;
 975                         if (lnum > curwin->w_cursor.lnum)
 976                             lnum_found = lnum;
 977                     }
 978                 }
 979                 else
 980                 {
 981                     /* to end of previous fold if there is one */
 982                     if (fp > (fold_T *)gap->ga_data)
 983                     {
 984                         lnum = fp[-1].fd_top + lnum_off + fp[-1].fd_len - 1;
 985                         if (lnum < curwin->w_cursor.lnum)
 986                             lnum_found = lnum;
 987                     }
 988                 }
 989             }
 990             else
 991             {
 992                 /* Open fold found, set cursor to its start/end and then check
 993                  * nested folds. */
 994                 if (dir == FORWARD)
 995                 {
 996                     lnum = fp->fd_top + lnum_off + fp->fd_len - 1;
 997                     if (lnum > curwin->w_cursor.lnum)
 998                         lnum_found = lnum;
 999                 }
1000                 else
1001                 {
1002                     lnum = fp->fd_top + lnum_off;
1003                     if (lnum < curwin->w_cursor.lnum)
1004                         lnum_found = lnum;
1005                 }
1006             }
1007
1008             if (last)
1009                 break;
1010
1011             /* Check nested folds (if any). */
1012             gap = &fp->fd_nested;
1013             lnum_off += fp->fd_top;
1014             ++level;
1015         }
1016         if (lnum_found != curwin->w_cursor.lnum)
1017         {
1018             if (retval == FAIL)
1019                 setpcmark();
1020             curwin->w_cursor.lnum = lnum_found;
1021             curwin->w_cursor.col = 0;
1022             retval = OK;
1023         }
1024         else
1025             break;
1026     }
1027
1028     return retval;
1029 }
1030
1031 /* foldInitWin() {{{2 */
1032 /*
1033  * Init the fold info in a new window.
1034  */
1035     void
1036 foldInitWin(newwin)
1037     win_T       *newwin;
1038 {
1039     ga_init2(&newwin->w_folds, (int)sizeof(fold_T), 10);
1040 }
1041
1042 /* find_wl_entry() {{{2 */
1043 /*
1044  * Find an entry in the win->w_lines[] array for buffer line "lnum".
1045  * Only valid entries are considered (for entries where wl_valid is FALSE the
1046  * line number can be wrong).
1047  * Returns index of entry or -1 if not found.
1048  */
1049     int
1050 find_wl_entry(win, lnum)
1051     win_T       *win;
1052     linenr_T    lnum;
1053 {
1054     int         i;
1055
1056     for (i = 0; i < win->w_lines_valid; ++i)
1057         if (win->w_lines[i].wl_valid)
1058         {
1059             if (lnum < win->w_lines[i].wl_lnum)
1060                 return -1;
1061             if (lnum <= win->w_lines[i].wl_lastlnum)
1062                 return i;
1063         }
1064     return -1;
1065 }
1066
1067 /* foldAdjustVisual() {{{2 */
1068 #ifdef FEAT_VISUAL
1069 /*
1070  * Adjust the Visual area to include any fold at the start or end completely.
1071  */
1072     void
1073 foldAdjustVisual()
1074 {
1075     pos_T       *start, *end;
1076     char_u      *ptr;
1077
1078     if (!VIsual_active || !hasAnyFolding(curwin))
1079         return;
1080
1081     if (ltoreq(VIsual, curwin->w_cursor))
1082     {
1083         start = &VIsual;
1084         end = &curwin->w_cursor;
1085     }
1086     else
1087     {
1088         start = &curwin->w_cursor;
1089         end = &VIsual;
1090     }
1091     if (hasFolding(start->lnum, &start->lnum, NULL))
1092         start->col = 0;
1093     if (hasFolding(end->lnum, NULL, &end->lnum))
1094     {
1095         ptr = ml_get(end->lnum);
1096         end->col = (colnr_T)STRLEN(ptr);
1097         if (end->col > 0 && *p_sel == 'o')
1098             --end->col;
1099 #ifdef FEAT_MBYTE
1100         /* prevent cursor from moving on the trail byte */
1101         if (has_mbyte)
1102             mb_adjust_cursor();
1103 #endif
1104     }
1105 }
1106 #endif
1107
1108 /* cursor_foldstart() {{{2 */
1109 /*
1110  * Move the cursor to the first line of a closed fold.
1111  */
1112     void
1113 foldAdjustCursor()
1114 {
1115     (void)hasFolding(curwin->w_cursor.lnum, &curwin->w_cursor.lnum, NULL);
1116 }
1117
1118 /* Internal functions for "fold_T" {{{1 */
1119 /* cloneFoldGrowArray() {{{2 */
1120 /*
1121  * Will "clone" (i.e deep copy) a garray_T of folds.
1122  *
1123  * Return FAIL if the operation cannot be completed, otherwise OK.
1124  */
1125     void
1126 cloneFoldGrowArray(from, to)
1127     garray_T    *from;
1128     garray_T    *to;
1129 {
1130     int         i;
1131     fold_T      *from_p;
1132     fold_T      *to_p;
1133
1134     ga_init2(to, from->ga_itemsize, from->ga_growsize);
1135     if (from->ga_len == 0 || ga_grow(to, from->ga_len) == FAIL)
1136         return;
1137
1138     from_p = (fold_T *)from->ga_data;
1139     to_p = (fold_T *)to->ga_data;
1140
1141     for (i = 0; i < from->ga_len; i++)
1142     {
1143         to_p->fd_top = from_p->fd_top;
1144         to_p->fd_len = from_p->fd_len;
1145         to_p->fd_flags = from_p->fd_flags;
1146         to_p->fd_small = from_p->fd_small;
1147         cloneFoldGrowArray(&from_p->fd_nested, &to_p->fd_nested);
1148         ++to->ga_len;
1149         ++from_p;
1150         ++to_p;
1151     }
1152 }
1153
1154 /* foldFind() {{{2 */
1155 /*
1156  * Search for line "lnum" in folds of growarray "gap".
1157  * Set *fpp to the fold struct for the fold that contains "lnum" or
1158  * the first fold below it (careful: it can be beyond the end of the array!).
1159  * Returns FALSE when there is no fold that contains "lnum".
1160  */
1161     static int
1162 foldFind(gap, lnum, fpp)
1163     garray_T    *gap;
1164     linenr_T    lnum;
1165     fold_T      **fpp;
1166 {
1167     linenr_T    low, high;
1168     fold_T      *fp;
1169     int         i;
1170
1171     /*
1172      * Perform a binary search.
1173      * "low" is lowest index of possible match.
1174      * "high" is highest index of possible match.
1175      */
1176     fp = (fold_T *)gap->ga_data;
1177     low = 0;
1178     high = gap->ga_len - 1;
1179     while (low <= high)
1180     {
1181         i = (low + high) / 2;
1182         if (fp[i].fd_top > lnum)
1183             /* fold below lnum, adjust high */
1184             high = i - 1;
1185         else if (fp[i].fd_top + fp[i].fd_len <= lnum)
1186             /* fold above lnum, adjust low */
1187             low = i + 1;
1188         else
1189         {
1190             /* lnum is inside this fold */
1191             *fpp = fp + i;
1192             return TRUE;
1193         }
1194     }
1195     *fpp = fp + low;
1196     return FALSE;
1197 }
1198
1199 /* foldLevelWin() {{{2 */
1200 /*
1201  * Return fold level at line number "lnum" in window "wp".
1202  */
1203     static int
1204 foldLevelWin(wp, lnum)
1205     win_T       *wp;
1206     linenr_T    lnum;
1207 {
1208     fold_T      *fp;
1209     linenr_T    lnum_rel = lnum;
1210     int         level =  0;
1211     garray_T    *gap;
1212
1213     /* Recursively search for a fold that contains "lnum". */
1214     gap = &wp->w_folds;
1215     for (;;)
1216     {
1217         if (!foldFind(gap, lnum_rel, &fp))
1218             break;
1219         /* Check nested folds.  Line number is relative to containing fold. */
1220         gap = &fp->fd_nested;
1221         lnum_rel -= fp->fd_top;
1222         ++level;
1223     }
1224
1225     return level;
1226 }
1227
1228 /* checkupdate() {{{2 */
1229 /*
1230  * Check if the folds in window "wp" are invalid and update them if needed.
1231  */
1232     static void
1233 checkupdate(wp)
1234     win_T       *wp;
1235 {
1236     if (wp->w_foldinvalid)
1237     {
1238         foldUpdate(wp, (linenr_T)1, (linenr_T)MAXLNUM); /* will update all */
1239         wp->w_foldinvalid = FALSE;
1240     }
1241 }
1242
1243 /* setFoldRepeat() {{{2 */
1244 /*
1245  * Open or close fold for current window at line "lnum".
1246  * Repeat "count" times.
1247  */
1248     static void
1249 setFoldRepeat(lnum, count, do_open)
1250     linenr_T    lnum;
1251     long        count;
1252     int         do_open;
1253 {
1254     int         done;
1255     long        n;
1256
1257     for (n = 0; n < count; ++n)
1258     {
1259         done = DONE_NOTHING;
1260         (void)setManualFold(lnum, do_open, FALSE, &done);
1261         if (!(done & DONE_ACTION))
1262         {
1263             /* Only give an error message when no fold could be opened. */
1264             if (n == 0 && !(done & DONE_FOLD))
1265                 EMSG(_(e_nofold));
1266             break;
1267         }
1268     }
1269 }
1270
1271 /* setManualFold() {{{2 */
1272 /*
1273  * Open or close the fold in the current window which contains "lnum".
1274  * Also does this for other windows in diff mode when needed.
1275  */
1276     static linenr_T
1277 setManualFold(lnum, opening, recurse, donep)
1278     linenr_T    lnum;
1279     int         opening;    /* TRUE when opening, FALSE when closing */
1280     int         recurse;    /* TRUE when closing/opening recursive */
1281     int         *donep;
1282 {
1283 #ifdef FEAT_DIFF
1284     if (foldmethodIsDiff(curwin) && curwin->w_p_scb)
1285     {
1286         win_T       *wp;
1287         linenr_T    dlnum;
1288
1289         /*
1290          * Do the same operation in other windows in diff mode.  Calculate the
1291          * line number from the diffs.
1292          */
1293         FOR_ALL_WINDOWS(wp)
1294         {
1295             if (wp != curwin && foldmethodIsDiff(wp) && wp->w_p_scb)
1296             {
1297                 dlnum = diff_lnum_win(curwin->w_cursor.lnum, wp);
1298                 if (dlnum != 0)
1299                     (void)setManualFoldWin(wp, dlnum, opening, recurse, NULL);
1300             }
1301         }
1302     }
1303 #endif
1304
1305     return setManualFoldWin(curwin, lnum, opening, recurse, donep);
1306 }
1307
1308 /* setManualFoldWin() {{{2 */
1309 /*
1310  * Open or close the fold in window "wp" which contains "lnum".
1311  * "donep", when not NULL, points to flag that is set to DONE_FOLD when some
1312  * fold was found and to DONE_ACTION when some fold was opened or closed.
1313  * When "donep" is NULL give an error message when no fold was found for
1314  * "lnum", but only if "wp" is "curwin".
1315  * Return the line number of the next line that could be closed.
1316  * It's only valid when "opening" is TRUE!
1317  */
1318     static linenr_T
1319 setManualFoldWin(wp, lnum, opening, recurse, donep)
1320     win_T       *wp;
1321     linenr_T    lnum;
1322     int         opening;    /* TRUE when opening, FALSE when closing */
1323     int         recurse;    /* TRUE when closing/opening recursive */
1324     int         *donep;
1325 {
1326     fold_T      *fp;
1327     fold_T      *fp2;
1328     fold_T      *found = NULL;
1329     int         j;
1330     int         level = 0;
1331     int         use_level = FALSE;
1332     int         found_fold = FALSE;
1333     garray_T    *gap;
1334     linenr_T    next = MAXLNUM;
1335     linenr_T    off = 0;
1336     int         done = 0;
1337
1338     checkupdate(wp);
1339
1340     /*
1341      * Find the fold, open or close it.
1342      */
1343     gap = &wp->w_folds;
1344     for (;;)
1345     {
1346         if (!foldFind(gap, lnum, &fp))
1347         {
1348             /* If there is a following fold, continue there next time. */
1349             if (fp < (fold_T *)gap->ga_data + gap->ga_len)
1350                 next = fp->fd_top + off;
1351             break;
1352         }
1353
1354         /* lnum is inside this fold */
1355         found_fold = TRUE;
1356
1357         /* If there is a following fold, continue there next time. */
1358         if (fp + 1 < (fold_T *)gap->ga_data + gap->ga_len)
1359             next = fp[1].fd_top + off;
1360
1361         /* Change from level-dependent folding to manual. */
1362         if (use_level || fp->fd_flags == FD_LEVEL)
1363         {
1364             use_level = TRUE;
1365             if (level >= wp->w_p_fdl)
1366                 fp->fd_flags = FD_CLOSED;
1367             else
1368                 fp->fd_flags = FD_OPEN;
1369             fp2 = (fold_T *)fp->fd_nested.ga_data;
1370             for (j = 0; j < fp->fd_nested.ga_len; ++j)
1371                 fp2[j].fd_flags = FD_LEVEL;
1372         }
1373
1374         /* Simple case: Close recursively means closing the fold. */
1375         if (!opening && recurse)
1376         {
1377             if (fp->fd_flags != FD_CLOSED)
1378             {
1379                 done |= DONE_ACTION;
1380                 fp->fd_flags = FD_CLOSED;
1381             }
1382         }
1383         else if (fp->fd_flags == FD_CLOSED)
1384         {
1385             /* When opening, open topmost closed fold. */
1386             if (opening)
1387             {
1388                 fp->fd_flags = FD_OPEN;
1389                 done |= DONE_ACTION;
1390                 if (recurse)
1391                     foldOpenNested(fp);
1392             }
1393             break;
1394         }
1395
1396         /* fold is open, check nested folds */
1397         found = fp;
1398         gap = &fp->fd_nested;
1399         lnum -= fp->fd_top;
1400         off += fp->fd_top;
1401         ++level;
1402     }
1403     if (found_fold)
1404     {
1405         /* When closing and not recurse, close deepest open fold. */
1406         if (!opening && found != NULL)
1407         {
1408             found->fd_flags = FD_CLOSED;
1409             done |= DONE_ACTION;
1410         }
1411         wp->w_fold_manual = TRUE;
1412         if (done & DONE_ACTION)
1413             changed_window_setting_win(wp);
1414         done |= DONE_FOLD;
1415     }
1416     else if (donep == NULL && wp == curwin)
1417         EMSG(_(e_nofold));
1418
1419     if (donep != NULL)
1420         *donep |= done;
1421
1422     return next;
1423 }
1424
1425 /* foldOpenNested() {{{2 */
1426 /*
1427  * Open all nested folds in fold "fpr" recursively.
1428  */
1429     static void
1430 foldOpenNested(fpr)
1431     fold_T      *fpr;
1432 {
1433     int         i;
1434     fold_T      *fp;
1435
1436     fp = (fold_T *)fpr->fd_nested.ga_data;
1437     for (i = 0; i < fpr->fd_nested.ga_len; ++i)
1438     {
1439         foldOpenNested(&fp[i]);
1440         fp[i].fd_flags = FD_OPEN;
1441     }
1442 }
1443
1444 /* deleteFoldEntry() {{{2 */
1445 /*
1446  * Delete fold "idx" from growarray "gap".
1447  * When "recursive" is TRUE also delete all the folds contained in it.
1448  * When "recursive" is FALSE contained folds are moved one level up.
1449  */
1450     static void
1451 deleteFoldEntry(gap, idx, recursive)
1452     garray_T    *gap;
1453     int         idx;
1454     int         recursive;
1455 {
1456     fold_T      *fp;
1457     int         i;
1458     long        moved;
1459     fold_T      *nfp;
1460
1461     fp = (fold_T *)gap->ga_data + idx;
1462     if (recursive || fp->fd_nested.ga_len == 0)
1463     {
1464         /* recursively delete the contained folds */
1465         deleteFoldRecurse(&fp->fd_nested);
1466         --gap->ga_len;
1467         if (idx < gap->ga_len)
1468             mch_memmove(fp, fp + 1, sizeof(fold_T) * (gap->ga_len - idx));
1469     }
1470     else
1471     {
1472         /* move nested folds one level up, to overwrite the fold that is
1473          * deleted. */
1474         moved = fp->fd_nested.ga_len;
1475         if (ga_grow(gap, (int)(moved - 1)) == OK)
1476         {
1477             /* adjust fd_top and fd_flags for the moved folds */
1478             nfp = (fold_T *)fp->fd_nested.ga_data;
1479             for (i = 0; i < moved; ++i)
1480             {
1481                 nfp[i].fd_top += fp->fd_top;
1482                 if (fp->fd_flags == FD_LEVEL)
1483                     nfp[i].fd_flags = FD_LEVEL;
1484                 if (fp->fd_small == MAYBE)
1485                     nfp[i].fd_small = MAYBE;
1486             }
1487
1488             /* move the existing folds down to make room */
1489             if (idx < gap->ga_len)
1490                 mch_memmove(fp + moved, fp + 1,
1491                                         sizeof(fold_T) * (gap->ga_len - idx));
1492             /* move the contained folds one level up */
1493             mch_memmove(fp, nfp, (size_t)(sizeof(fold_T) * moved));
1494             vim_free(nfp);
1495             gap->ga_len += moved - 1;
1496         }
1497     }
1498 }
1499
1500 /* deleteFoldRecurse() {{{2 */
1501 /*
1502  * Delete nested folds in a fold.
1503  */
1504     void
1505 deleteFoldRecurse(gap)
1506     garray_T    *gap;
1507 {
1508     int         i;
1509
1510     for (i = 0; i < gap->ga_len; ++i)
1511         deleteFoldRecurse(&(((fold_T *)(gap->ga_data))[i].fd_nested));
1512     ga_clear(gap);
1513 }
1514
1515 /* foldMarkAdjust() {{{2 */
1516 /*
1517  * Update line numbers of folds for inserted/deleted lines.
1518  */
1519     void
1520 foldMarkAdjust(wp, line1, line2, amount, amount_after)
1521     win_T       *wp;
1522     linenr_T    line1;
1523     linenr_T    line2;
1524     long        amount;
1525     long        amount_after;
1526 {
1527     /* If deleting marks from line1 to line2, but not deleting all those
1528      * lines, set line2 so that only deleted lines have their folds removed. */
1529     if (amount == MAXLNUM && line2 >= line1 && line2 - line1 >= -amount_after)
1530         line2 = line1 - amount_after - 1;
1531     /* If appending a line in Insert mode, it should be included in the fold
1532      * just above the line. */
1533     if ((State & INSERT) && amount == (linenr_T)1 && line2 == MAXLNUM)
1534         --line1;
1535     foldMarkAdjustRecurse(&wp->w_folds, line1, line2, amount, amount_after);
1536 }
1537
1538 /* foldMarkAdjustRecurse() {{{2 */
1539     static void
1540 foldMarkAdjustRecurse(gap, line1, line2, amount, amount_after)
1541     garray_T    *gap;
1542     linenr_T    line1;
1543     linenr_T    line2;
1544     long        amount;
1545     long        amount_after;
1546 {
1547     fold_T      *fp;
1548     int         i;
1549     linenr_T    last;
1550     linenr_T    top;
1551
1552     /* In Insert mode an inserted line at the top of a fold is considered part
1553      * of the fold, otherwise it isn't. */
1554     if ((State & INSERT) && amount == (linenr_T)1 && line2 == MAXLNUM)
1555         top = line1 + 1;
1556     else
1557         top = line1;
1558
1559     /* Find the fold containing or just below "line1". */
1560     (void)foldFind(gap, line1, &fp);
1561
1562     /*
1563      * Adjust all folds below "line1" that are affected.
1564      */
1565     for (i = (int)(fp - (fold_T *)gap->ga_data); i < gap->ga_len; ++i, ++fp)
1566     {
1567         /*
1568          * Check for these situations:
1569          *        1  2  3
1570          *        1  2  3
1571          * line1     2  3  4  5
1572          *           2  3  4  5
1573          *           2  3  4  5
1574          * line2     2  3  4  5
1575          *              3     5  6
1576          *              3     5  6
1577          */
1578
1579         last = fp->fd_top + fp->fd_len - 1; /* last line of fold */
1580
1581         /* 1. fold completely above line1: nothing to do */
1582         if (last < line1)
1583             continue;
1584
1585         /* 6. fold below line2: only adjust for amount_after */
1586         if (fp->fd_top > line2)
1587         {
1588             if (amount_after == 0)
1589                 break;
1590             fp->fd_top += amount_after;
1591         }
1592         else
1593         {
1594             if (fp->fd_top >= top && last <= line2)
1595             {
1596                 /* 4. fold completely contained in range */
1597                 if (amount == MAXLNUM)
1598                 {
1599                     /* Deleting lines: delete the fold completely */
1600                     deleteFoldEntry(gap, i, TRUE);
1601                     --i;    /* adjust index for deletion */
1602                     --fp;
1603                 }
1604                 else
1605                     fp->fd_top += amount;
1606             }
1607             else
1608             {
1609                 if (fp->fd_top < top)
1610                 {
1611                     /* 2 or 3: need to correct nested folds too */
1612                     foldMarkAdjustRecurse(&fp->fd_nested, line1 - fp->fd_top,
1613                                   line2 - fp->fd_top, amount, amount_after);
1614                     if (last <= line2)
1615                     {
1616                         /* 2. fold contains line1, line2 is below fold */
1617                         if (amount == MAXLNUM)
1618                             fp->fd_len = line1 - fp->fd_top;
1619                         else
1620                             fp->fd_len += amount;
1621                     }
1622                     else
1623                     {
1624                         /* 3. fold contains line1 and line2 */
1625                         fp->fd_len += amount_after;
1626                     }
1627                 }
1628                 else
1629                 {
1630                     /* 5. fold is below line1 and contains line2; need to
1631                      * correct nested folds too */
1632                     foldMarkAdjustRecurse(&fp->fd_nested, line1 - fp->fd_top,
1633                                   line2 - fp->fd_top, amount,
1634                                   amount_after + (fp->fd_top - top));
1635                     if (amount == MAXLNUM)
1636                     {
1637                         fp->fd_len -= line2 - fp->fd_top + 1;
1638                         fp->fd_top = line1;
1639                     }
1640                     else
1641                     {
1642                         fp->fd_len += amount_after - amount;
1643                         fp->fd_top += amount;
1644                     }
1645                 }
1646             }
1647         }
1648     }
1649 }
1650
1651 /* getDeepestNesting() {{{2 */
1652 /*
1653  * Get the lowest 'foldlevel' value that makes the deepest nested fold in the
1654  * current window open.
1655  */
1656     int
1657 getDeepestNesting()
1658 {
1659     checkupdate(curwin);
1660     return getDeepestNestingRecurse(&curwin->w_folds);
1661 }
1662
1663     static int
1664 getDeepestNestingRecurse(gap)
1665     garray_T    *gap;
1666 {
1667     int         i;
1668     int         level;
1669     int         maxlevel = 0;
1670     fold_T      *fp;
1671
1672     fp = (fold_T *)gap->ga_data;
1673     for (i = 0; i < gap->ga_len; ++i)
1674     {
1675         level = getDeepestNestingRecurse(&fp[i].fd_nested) + 1;
1676         if (level > maxlevel)
1677             maxlevel = level;
1678     }
1679
1680     return maxlevel;
1681 }
1682
1683 /* check_closed() {{{2 */
1684 /*
1685  * Check if a fold is closed and update the info needed to check nested folds.
1686  */
1687     static int
1688 check_closed(win, fp, use_levelp, level, maybe_smallp, lnum_off)
1689     win_T       *win;
1690     fold_T      *fp;
1691     int         *use_levelp;        /* TRUE: outer fold had FD_LEVEL */
1692     int         level;              /* folding depth */
1693     int         *maybe_smallp;      /* TRUE: outer this had fd_small == MAYBE */
1694     linenr_T    lnum_off;           /* line number offset for fp->fd_top */
1695 {
1696     int         closed = FALSE;
1697
1698     /* Check if this fold is closed.  If the flag is FD_LEVEL this
1699      * fold and all folds it contains depend on 'foldlevel'. */
1700     if (*use_levelp || fp->fd_flags == FD_LEVEL)
1701     {
1702         *use_levelp = TRUE;
1703         if (level >= win->w_p_fdl)
1704             closed = TRUE;
1705     }
1706     else if (fp->fd_flags == FD_CLOSED)
1707         closed = TRUE;
1708
1709     /* Small fold isn't closed anyway. */
1710     if (fp->fd_small == MAYBE)
1711         *maybe_smallp = TRUE;
1712     if (closed)
1713     {
1714         if (*maybe_smallp)
1715             fp->fd_small = MAYBE;
1716         checkSmall(win, fp, lnum_off);
1717         if (fp->fd_small == TRUE)
1718             closed = FALSE;
1719     }
1720     return closed;
1721 }
1722
1723 /* checkSmall() {{{2 */
1724 /*
1725  * Update fd_small field of fold "fp".
1726  */
1727     static void
1728 checkSmall(wp, fp, lnum_off)
1729     win_T       *wp;
1730     fold_T      *fp;
1731     linenr_T    lnum_off;       /* offset for fp->fd_top */
1732 {
1733     int         count;
1734     int         n;
1735
1736     if (fp->fd_small == MAYBE)
1737     {
1738         /* Mark any nested folds to maybe-small */
1739         setSmallMaybe(&fp->fd_nested);
1740
1741         if (fp->fd_len > curwin->w_p_fml)
1742             fp->fd_small = FALSE;
1743         else
1744         {
1745             count = 0;
1746             for (n = 0; n < fp->fd_len; ++n)
1747             {
1748                 count += plines_win_nofold(wp, fp->fd_top + lnum_off + n);
1749                 if (count > curwin->w_p_fml)
1750                 {
1751                     fp->fd_small = FALSE;
1752                     return;
1753                 }
1754             }
1755             fp->fd_small = TRUE;
1756         }
1757     }
1758 }
1759
1760 /* setSmallMaybe() {{{2 */
1761 /*
1762  * Set small flags in "gap" to MAYBE.
1763  */
1764     static void
1765 setSmallMaybe(gap)
1766     garray_T    *gap;
1767 {
1768     int         i;
1769     fold_T      *fp;
1770
1771     fp = (fold_T *)gap->ga_data;
1772     for (i = 0; i < gap->ga_len; ++i)
1773         fp[i].fd_small = MAYBE;
1774 }
1775
1776 /* foldCreateMarkers() {{{2 */
1777 /*
1778  * Create a fold from line "start" to line "end" (inclusive) in the current
1779  * window by adding markers.
1780  */
1781     static void
1782 foldCreateMarkers(start, end)
1783     linenr_T    start;
1784     linenr_T    end;
1785 {
1786     if (!curbuf->b_p_ma)
1787     {
1788         EMSG(_(e_modifiable));
1789         return;
1790     }
1791     parseMarker(curwin);
1792
1793     foldAddMarker(start, curwin->w_p_fmr, foldstartmarkerlen);
1794     foldAddMarker(end, foldendmarker, foldendmarkerlen);
1795
1796     /* Update both changes here, to avoid all folds after the start are
1797      * changed when the start marker is inserted and the end isn't. */
1798     changed_lines(start, (colnr_T)0, end, 0L);
1799 }
1800
1801 /* foldAddMarker() {{{2 */
1802 /*
1803  * Add "marker[markerlen]" in 'commentstring' to line "lnum".
1804  */
1805     static void
1806 foldAddMarker(lnum, marker, markerlen)
1807     linenr_T    lnum;
1808     char_u      *marker;
1809     int         markerlen;
1810 {
1811     char_u      *cms = curbuf->b_p_cms;
1812     char_u      *line;
1813     int         line_len;
1814     char_u      *newline;
1815     char_u      *p = (char_u *)strstr((char *)curbuf->b_p_cms, "%s");
1816
1817     /* Allocate a new line: old-line + 'cms'-start + marker + 'cms'-end */
1818     line = ml_get(lnum);
1819     line_len = (int)STRLEN(line);
1820
1821     if (u_save(lnum - 1, lnum + 1) == OK)
1822     {
1823         newline = alloc((unsigned)(line_len + markerlen + STRLEN(cms) + 1));
1824         if (newline == NULL)
1825             return;
1826         STRCPY(newline, line);
1827         if (p == NULL)
1828             vim_strncpy(newline + line_len, marker, markerlen);
1829         else
1830         {
1831             STRCPY(newline + line_len, cms);
1832             STRNCPY(newline + line_len + (p - cms), marker, markerlen);
1833             STRCPY(newline + line_len + (p - cms) + markerlen, p + 2);
1834         }
1835
1836         ml_replace(lnum, newline, FALSE);
1837     }
1838 }
1839
1840 /* deleteFoldMarkers() {{{2 */
1841 /*
1842  * Delete the markers for a fold, causing it to be deleted.
1843  */
1844     static void
1845 deleteFoldMarkers(fp, recursive, lnum_off)
1846     fold_T      *fp;
1847     int         recursive;
1848     linenr_T    lnum_off;       /* offset for fp->fd_top */
1849 {
1850     int         i;
1851
1852     if (recursive)
1853         for (i = 0; i < fp->fd_nested.ga_len; ++i)
1854             deleteFoldMarkers((fold_T *)fp->fd_nested.ga_data + i, TRUE,
1855                                                        lnum_off + fp->fd_top);
1856     foldDelMarker(fp->fd_top + lnum_off, curwin->w_p_fmr, foldstartmarkerlen);
1857     foldDelMarker(fp->fd_top + lnum_off + fp->fd_len - 1,
1858                                              foldendmarker, foldendmarkerlen);
1859 }
1860
1861 /* foldDelMarker() {{{2 */
1862 /*
1863  * Delete marker "marker[markerlen]" at the end of line "lnum".
1864  * Delete 'commentstring' if it matches.
1865  * If the marker is not found, there is no error message.  Could a missing
1866  * close-marker.
1867  */
1868     static void
1869 foldDelMarker(lnum, marker, markerlen)
1870     linenr_T    lnum;
1871     char_u      *marker;
1872     int         markerlen;
1873 {
1874     char_u      *line;
1875     char_u      *newline;
1876     char_u      *p;
1877     int         len;
1878     char_u      *cms = curbuf->b_p_cms;
1879     char_u      *cms2;
1880
1881     line = ml_get(lnum);
1882     for (p = line; *p != NUL; ++p)
1883         if (STRNCMP(p, marker, markerlen) == 0)
1884         {
1885             /* Found the marker, include a digit if it's there. */
1886             len = markerlen;
1887             if (VIM_ISDIGIT(p[len]))
1888                 ++len;
1889             if (*cms != NUL)
1890             {
1891                 /* Also delete 'commentstring' if it matches. */
1892                 cms2 = (char_u *)strstr((char *)cms, "%s");
1893                 if (p - line >= cms2 - cms
1894                         && STRNCMP(p - (cms2 - cms), cms, cms2 - cms) == 0
1895                         && STRNCMP(p + len, cms2 + 2, STRLEN(cms2 + 2)) == 0)
1896                 {
1897                     p -= cms2 - cms;
1898                     len += (int)STRLEN(cms) - 2;
1899                 }
1900             }
1901             if (u_save(lnum - 1, lnum + 1) == OK)
1902             {
1903                 /* Make new line: text-before-marker + text-after-marker */
1904                 newline = alloc((unsigned)(STRLEN(line) - len + 1));
1905                 if (newline != NULL)
1906                 {
1907                     STRNCPY(newline, line, p - line);
1908                     STRCPY(newline + (p - line), p + len);
1909                     ml_replace(lnum, newline, FALSE);
1910                 }
1911             }
1912             break;
1913         }
1914 }
1915
1916 /* get_foldtext() {{{2 */
1917 /*
1918  * Return the text for a closed fold at line "lnum", with last line "lnume".
1919  * When 'foldtext' isn't set puts the result in "buf[51]".  Otherwise the
1920  * result is in allocated memory.
1921  */
1922     char_u *
1923 get_foldtext(wp, lnum, lnume, foldinfo, buf)
1924     win_T       *wp;
1925     linenr_T    lnum, lnume;
1926     foldinfo_T  *foldinfo;
1927     char_u      *buf;
1928 {
1929     char_u      *text = NULL;
1930
1931 #ifdef FEAT_EVAL
1932     if (*wp->w_p_fdt != NUL)
1933     {
1934         char_u  dashes[MAX_LEVEL + 2];
1935         win_T   *save_curwin;
1936         int     level;
1937         char_u  *p;
1938
1939         /* Set "v:foldstart" and "v:foldend". */
1940         set_vim_var_nr(VV_FOLDSTART, lnum);
1941         set_vim_var_nr(VV_FOLDEND, lnume);
1942
1943         /* Set "v:folddashes" to a string of "level" dashes. */
1944         /* Set "v:foldlevel" to "level". */
1945         level = foldinfo->fi_level;
1946         if (level > (int)sizeof(dashes) - 1)
1947             level = (int)sizeof(dashes) - 1;
1948         vim_memset(dashes, '-', (size_t)level);
1949         dashes[level] = NUL;
1950         set_vim_var_string(VV_FOLDDASHES, dashes, -1);
1951         set_vim_var_nr(VV_FOLDLEVEL, (long)level);
1952         save_curwin = curwin;
1953         curwin = wp;
1954         curbuf = wp->w_buffer;
1955
1956         ++emsg_off;
1957         text = eval_to_string_safe(wp->w_p_fdt, NULL,
1958                          was_set_insecurely((char_u *)"foldtext", OPT_LOCAL));
1959         --emsg_off;
1960
1961         curwin = save_curwin;
1962         curbuf = curwin->w_buffer;
1963         set_vim_var_string(VV_FOLDDASHES, NULL, -1);
1964
1965         if (text != NULL)
1966         {
1967             /* Replace unprintable characters, if there are any.  But
1968              * replace a TAB with a space. */
1969             for (p = text; *p != NUL; ++p)
1970             {
1971 # ifdef FEAT_MBYTE
1972                 int     len;
1973
1974                 if (has_mbyte && (len = (*mb_ptr2len)(p)) > 1)
1975                 {
1976                     if (!vim_isprintc((*mb_ptr2char)(p)))
1977                         break;
1978                     p += len - 1;
1979                 }
1980                 else
1981 # endif
1982                     if (*p == TAB)
1983                         *p = ' ';
1984                     else if (ptr2cells(p) > 1)
1985                         break;
1986             }
1987             if (*p != NUL)
1988             {
1989                 p = transstr(text);
1990                 vim_free(text);
1991                 text = p;
1992             }
1993         }
1994     }
1995     if (text == NULL)
1996 #endif
1997     {
1998         sprintf((char *)buf, _("+--%3ld lines folded "),
1999                                                     (long)(lnume - lnum + 1));
2000         text = buf;
2001     }
2002     return text;
2003 }
2004
2005 /* foldtext_cleanup() {{{2 */
2006 /*
2007  * Remove 'foldmarker' and 'commentstring' from "str" (in-place).
2008  */
2009     void
2010 foldtext_cleanup(str)
2011     char_u      *str;
2012 {
2013     char_u      *cms_start;     /* first part or the whole comment */
2014     int         cms_slen = 0;   /* length of cms_start */
2015     char_u      *cms_end;       /* last part of the comment or NULL */
2016     int         cms_elen = 0;   /* length of cms_end */
2017     char_u      *s;
2018     char_u      *p;
2019     int         len;
2020     int         did1 = FALSE;
2021     int         did2 = FALSE;
2022
2023     /* Ignore leading and trailing white space in 'commentstring'. */
2024     cms_start = skipwhite(curbuf->b_p_cms);
2025     cms_slen = (int)STRLEN(cms_start);
2026     while (cms_slen > 0 && vim_iswhite(cms_start[cms_slen - 1]))
2027         --cms_slen;
2028
2029     /* locate "%s" in 'commentstring', use the part before and after it. */
2030     cms_end = (char_u *)strstr((char *)cms_start, "%s");
2031     if (cms_end != NULL)
2032     {
2033         cms_elen = cms_slen - (int)(cms_end - cms_start);
2034         cms_slen = (int)(cms_end - cms_start);
2035
2036         /* exclude white space before "%s" */
2037         while (cms_slen > 0 && vim_iswhite(cms_start[cms_slen - 1]))
2038             --cms_slen;
2039
2040         /* skip "%s" and white space after it */
2041         s = skipwhite(cms_end + 2);
2042         cms_elen -= (int)(s - cms_end);
2043         cms_end = s;
2044     }
2045     parseMarker(curwin);
2046
2047     for (s = str; *s != NUL; )
2048     {
2049         len = 0;
2050         if (STRNCMP(s, curwin->w_p_fmr, foldstartmarkerlen) == 0)
2051             len = foldstartmarkerlen;
2052         else if (STRNCMP(s, foldendmarker, foldendmarkerlen) == 0)
2053             len = foldendmarkerlen;
2054         if (len > 0)
2055         {
2056             if (VIM_ISDIGIT(s[len]))
2057                 ++len;
2058
2059             /* May remove 'commentstring' start.  Useful when it's a double
2060              * quote and we already removed a double quote. */
2061             for (p = s; p > str && vim_iswhite(p[-1]); --p)
2062                 ;
2063             if (p >= str + cms_slen
2064                            && STRNCMP(p - cms_slen, cms_start, cms_slen) == 0)
2065             {
2066                 len += (int)(s - p) + cms_slen;
2067                 s = p - cms_slen;
2068             }
2069         }
2070         else if (cms_end != NULL)
2071         {
2072             if (!did1 && cms_slen > 0 && STRNCMP(s, cms_start, cms_slen) == 0)
2073             {
2074                 len = cms_slen;
2075                 did1 = TRUE;
2076             }
2077             else if (!did2 && cms_elen > 0
2078                                         && STRNCMP(s, cms_end, cms_elen) == 0)
2079             {
2080                 len = cms_elen;
2081                 did2 = TRUE;
2082             }
2083         }
2084         if (len != 0)
2085         {
2086             while (vim_iswhite(s[len]))
2087                 ++len;
2088             STRMOVE(s, s + len);
2089         }
2090         else
2091         {
2092             mb_ptr_adv(s);
2093         }
2094     }
2095 }
2096
2097 /* Folding by indent, expr, marker and syntax. {{{1 */
2098 /* Define "fline_T", passed to get fold level for a line. {{{2 */
2099 typedef struct
2100 {
2101     win_T       *wp;            /* window */
2102     linenr_T    lnum;           /* current line number */
2103     linenr_T    off;            /* offset between lnum and real line number */
2104     linenr_T    lnum_save;      /* line nr used by foldUpdateIEMSRecurse() */
2105     int         lvl;            /* current level (-1 for undefined) */
2106     int         lvl_next;       /* level used for next line */
2107     int         start;          /* number of folds that are forced to start at
2108                                    this line. */
2109     int         end;            /* level of fold that is forced to end below
2110                                    this line */
2111     int         had_end;        /* level of fold that is forced to end above
2112                                    this line (copy of "end" of prev. line) */
2113 } fline_T;
2114
2115 /* Flag is set when redrawing is needed. */
2116 static int fold_changed;
2117
2118 /* Function declarations. {{{2 */
2119 static linenr_T foldUpdateIEMSRecurse __ARGS((garray_T *gap, int level, linenr_T startlnum, fline_T *flp, void (*getlevel)__ARGS((fline_T *)), linenr_T bot, int topflags));
2120 static int foldInsert __ARGS((garray_T *gap, int i));
2121 static void foldSplit __ARGS((garray_T *gap, int i, linenr_T top, linenr_T bot));
2122 static void foldRemove __ARGS((garray_T *gap, linenr_T top, linenr_T bot));
2123 static void foldMerge __ARGS((fold_T *fp1, garray_T *gap, fold_T *fp2));
2124 static void foldlevelIndent __ARGS((fline_T *flp));
2125 #ifdef FEAT_DIFF
2126 static void foldlevelDiff __ARGS((fline_T *flp));
2127 #endif
2128 static void foldlevelExpr __ARGS((fline_T *flp));
2129 static void foldlevelMarker __ARGS((fline_T *flp));
2130 static void foldlevelSyntax __ARGS((fline_T *flp));
2131
2132 /* foldUpdateIEMS() {{{2 */
2133 /*
2134  * Update the folding for window "wp", at least from lines "top" to "bot".
2135  * Return TRUE if any folds did change.
2136  */
2137     static void
2138 foldUpdateIEMS(wp, top, bot)
2139     win_T       *wp;
2140     linenr_T    top;
2141     linenr_T    bot;
2142 {
2143     linenr_T    start;
2144     linenr_T    end;
2145     fline_T     fline;
2146     void        (*getlevel)__ARGS((fline_T *));
2147     int         level;
2148     fold_T      *fp;
2149
2150     /* Avoid problems when being called recursively. */
2151     if (invalid_top != (linenr_T)0)
2152         return;
2153
2154     if (wp->w_foldinvalid)
2155     {
2156         /* Need to update all folds. */
2157         top = 1;
2158         bot = wp->w_buffer->b_ml.ml_line_count;
2159         wp->w_foldinvalid = FALSE;
2160
2161         /* Mark all folds a maybe-small. */
2162         setSmallMaybe(&wp->w_folds);
2163     }
2164
2165 #ifdef FEAT_DIFF
2166     /* add the context for "diff" folding */
2167     if (foldmethodIsDiff(wp))
2168     {
2169         if (top > diff_context)
2170             top -= diff_context;
2171         else
2172             top = 1;
2173         bot += diff_context;
2174     }
2175 #endif
2176
2177     /* When deleting lines at the end of the buffer "top" can be past the end
2178      * of the buffer. */
2179     if (top > wp->w_buffer->b_ml.ml_line_count)
2180         top = wp->w_buffer->b_ml.ml_line_count;
2181
2182     fold_changed = FALSE;
2183     fline.wp = wp;
2184     fline.off = 0;
2185     fline.lvl = 0;
2186     fline.lvl_next = -1;
2187     fline.start = 0;
2188     fline.end = MAX_LEVEL + 1;
2189     fline.had_end = MAX_LEVEL + 1;
2190
2191     invalid_top = top;
2192     invalid_bot = bot;
2193
2194     if (foldmethodIsMarker(wp))
2195     {
2196         getlevel = foldlevelMarker;
2197
2198         /* Init marker variables to speed up foldlevelMarker(). */
2199         parseMarker(wp);
2200
2201         /* Need to get the level of the line above top, it is used if there is
2202          * no marker at the top. */
2203         if (top > 1)
2204         {
2205             /* Get the fold level at top - 1. */
2206             level = foldLevelWin(wp, top - 1);
2207
2208             /* The fold may end just above the top, check for that. */
2209             fline.lnum = top - 1;
2210             fline.lvl = level;
2211             getlevel(&fline);
2212
2213             /* If a fold started here, we already had the level, if it stops
2214              * here, we need to use lvl_next.  Could also start and end a fold
2215              * in the same line. */
2216             if (fline.lvl > level)
2217                 fline.lvl = level - (fline.lvl - fline.lvl_next);
2218             else
2219                 fline.lvl = fline.lvl_next;
2220         }
2221         fline.lnum = top;
2222         getlevel(&fline);
2223     }
2224     else
2225     {
2226         fline.lnum = top;
2227         if (foldmethodIsExpr(wp))
2228         {
2229             getlevel = foldlevelExpr;
2230             /* start one line back, because a "<1" may indicate the end of a
2231              * fold in the topline */
2232             if (top > 1)
2233                 --fline.lnum;
2234         }
2235         else if (foldmethodIsSyntax(wp))
2236             getlevel = foldlevelSyntax;
2237 #ifdef FEAT_DIFF
2238         else if (foldmethodIsDiff(wp))
2239             getlevel = foldlevelDiff;
2240 #endif
2241         else
2242             getlevel = foldlevelIndent;
2243
2244         /* Backup to a line for which the fold level is defined.  Since it's
2245          * always defined for line one, we will stop there. */
2246         fline.lvl = -1;
2247         for ( ; !got_int; --fline.lnum)
2248         {
2249             /* Reset lvl_next each time, because it will be set to a value for
2250              * the next line, but we search backwards here. */
2251             fline.lvl_next = -1;
2252             getlevel(&fline);
2253             if (fline.lvl >= 0)
2254                 break;
2255         }
2256     }
2257
2258     /*
2259      * If folding is defined by the syntax, it is possible that a change in
2260      * one line will cause all sub-folds of the current fold to change (e.g.,
2261      * closing a C-style comment can cause folds in the subsequent lines to
2262      * appear). To take that into account we should adjust the value of "bot"
2263      * to point to the end of the current fold:
2264      */
2265     if (foldlevelSyntax == getlevel)
2266     {
2267         garray_T *gap = &wp->w_folds;
2268         fold_T   *fpn = NULL;
2269         int       current_fdl = 0;
2270         linenr_T  fold_start_lnum = 0;
2271         linenr_T  lnum_rel = fline.lnum;
2272
2273         while (current_fdl < fline.lvl)
2274         {
2275             if (!foldFind(gap, lnum_rel, &fpn))
2276                 break;
2277             ++current_fdl;
2278
2279             fold_start_lnum += fpn->fd_top;
2280             gap = &fpn->fd_nested;
2281             lnum_rel -= fpn->fd_top;
2282         }
2283         if (fpn != NULL && current_fdl == fline.lvl)
2284         {
2285             linenr_T fold_end_lnum = fold_start_lnum + fpn->fd_len;
2286
2287             if (fold_end_lnum > bot)
2288                 bot = fold_end_lnum;
2289         }
2290     }
2291
2292     start = fline.lnum;
2293     end = bot;
2294     /* Do at least one line. */
2295     if (start > end && end < wp->w_buffer->b_ml.ml_line_count)
2296         end = start;
2297     while (!got_int)
2298     {
2299         /* Always stop at the end of the file ("end" can be past the end of
2300          * the file). */
2301         if (fline.lnum > wp->w_buffer->b_ml.ml_line_count)
2302             break;
2303         if (fline.lnum > end)
2304         {
2305             /* For "marker", "expr"  and "syntax"  methods: If a change caused
2306              * a fold to be removed, we need to continue at least until where
2307              * it ended. */
2308             if (getlevel != foldlevelMarker
2309                     && getlevel != foldlevelSyntax
2310                     && getlevel != foldlevelExpr)
2311                 break;
2312             if ((start <= end
2313                         && foldFind(&wp->w_folds, end, &fp)
2314                         && fp->fd_top + fp->fd_len - 1 > end)
2315                     || (fline.lvl == 0
2316                         && foldFind(&wp->w_folds, fline.lnum, &fp)
2317                         && fp->fd_top < fline.lnum))
2318                 end = fp->fd_top + fp->fd_len - 1;
2319             else if (getlevel == foldlevelSyntax
2320                     && foldLevelWin(wp, fline.lnum) != fline.lvl)
2321                 /* For "syntax" method: Compare the foldlevel that the syntax
2322                  * tells us to the foldlevel from the existing folds.  If they
2323                  * don't match continue updating folds. */
2324                 end = fline.lnum;
2325             else
2326                 break;
2327         }
2328
2329         /* A level 1 fold starts at a line with foldlevel > 0. */
2330         if (fline.lvl > 0)
2331         {
2332             invalid_top = fline.lnum;
2333             invalid_bot = end;
2334             end = foldUpdateIEMSRecurse(&wp->w_folds,
2335                                    1, start, &fline, getlevel, end, FD_LEVEL);
2336             start = fline.lnum;
2337         }
2338         else
2339         {
2340             if (fline.lnum == wp->w_buffer->b_ml.ml_line_count)
2341                 break;
2342             ++fline.lnum;
2343             fline.lvl = fline.lvl_next;
2344             getlevel(&fline);
2345         }
2346     }
2347
2348     /* There can't be any folds from start until end now. */
2349     foldRemove(&wp->w_folds, start, end);
2350
2351     /* If some fold changed, need to redraw and position cursor. */
2352     if (fold_changed && wp->w_p_fen)
2353         changed_window_setting_win(wp);
2354
2355     /* If we updated folds past "bot", need to redraw more lines.  Don't do
2356      * this in other situations, the changed lines will be redrawn anyway and
2357      * this method can cause the whole window to be updated. */
2358     if (end != bot)
2359     {
2360         if (wp->w_redraw_top == 0 || wp->w_redraw_top > top)
2361             wp->w_redraw_top = top;
2362         if (wp->w_redraw_bot < end)
2363             wp->w_redraw_bot = end;
2364     }
2365
2366     invalid_top = (linenr_T)0;
2367 }
2368
2369 /* foldUpdateIEMSRecurse() {{{2 */
2370 /*
2371  * Update a fold that starts at "flp->lnum".  At this line there is always a
2372  * valid foldlevel, and its level >= "level".
2373  * "flp" is valid for "flp->lnum" when called and it's valid when returning.
2374  * "flp->lnum" is set to the lnum just below the fold, if it ends before
2375  * "bot", it's "bot" plus one if the fold continues and it's bigger when using
2376  * the marker method and a text change made following folds to change.
2377  * When returning, "flp->lnum_save" is the line number that was used to get
2378  * the level when the level at "flp->lnum" is invalid.
2379  * Remove any folds from "startlnum" up to here at this level.
2380  * Recursively update nested folds.
2381  * Below line "bot" there are no changes in the text.
2382  * "flp->lnum", "flp->lnum_save" and "bot" are relative to the start of the
2383  * outer fold.
2384  * "flp->off" is the offset to the real line number in the buffer.
2385  *
2386  * All this would be a lot simpler if all folds in the range would be deleted
2387  * and then created again.  But we would lose all information about the
2388  * folds, even when making changes that don't affect the folding (e.g. "vj~").
2389  *
2390  * Returns bot, which may have been increased for lines that also need to be
2391  * updated as a result of a detected change in the fold.
2392  */
2393     static linenr_T
2394 foldUpdateIEMSRecurse(gap, level, startlnum, flp, getlevel, bot, topflags)
2395     garray_T    *gap;
2396     int         level;
2397     linenr_T    startlnum;
2398     fline_T     *flp;
2399     void        (*getlevel)__ARGS((fline_T *));
2400     linenr_T    bot;
2401     int         topflags;       /* flags used by containing fold */
2402 {
2403     linenr_T    ll;
2404     fold_T      *fp = NULL;
2405     fold_T      *fp2;
2406     int         lvl = level;
2407     linenr_T    startlnum2 = startlnum;
2408     linenr_T    firstlnum = flp->lnum;  /* first lnum we got */
2409     int         i;
2410     int         finish = FALSE;
2411     linenr_T    linecount = flp->wp->w_buffer->b_ml.ml_line_count - flp->off;
2412     int         concat;
2413
2414     /*
2415      * If using the marker method, the start line is not the start of a fold
2416      * at the level we're dealing with and the level is non-zero, we must use
2417      * the previous fold.  But ignore a fold that starts at or below
2418      * startlnum, it must be deleted.
2419      */
2420     if (getlevel == foldlevelMarker && flp->start <= flp->lvl - level
2421                                                               && flp->lvl > 0)
2422     {
2423         foldFind(gap, startlnum - 1, &fp);
2424         if (fp >= ((fold_T *)gap->ga_data) + gap->ga_len
2425                                                    || fp->fd_top >= startlnum)
2426             fp = NULL;
2427     }
2428
2429     /*
2430      * Loop over all lines in this fold, or until "bot" is hit.
2431      * Handle nested folds inside of this fold.
2432      * "flp->lnum" is the current line.  When finding the end of the fold, it
2433      * is just below the end of the fold.
2434      * "*flp" contains the level of the line "flp->lnum" or a following one if
2435      * there are lines with an invalid fold level.  "flp->lnum_save" is the
2436      * line number that was used to get the fold level (below "flp->lnum" when
2437      * it has an invalid fold level).  When called the fold level is always
2438      * valid, thus "flp->lnum_save" is equal to "flp->lnum".
2439      */
2440     flp->lnum_save = flp->lnum;
2441     while (!got_int)
2442     {
2443         /* Updating folds can be slow, check for CTRL-C. */
2444         line_breakcheck();
2445
2446         /* Set "lvl" to the level of line "flp->lnum".  When flp->start is set
2447          * and after the first line of the fold, set the level to zero to
2448          * force the fold to end.  Do the same when had_end is set: Previous
2449          * line was marked as end of a fold. */
2450         lvl = flp->lvl;
2451         if (lvl > MAX_LEVEL)
2452             lvl = MAX_LEVEL;
2453         if (flp->lnum > firstlnum
2454                 && (level > lvl - flp->start || level >= flp->had_end))
2455             lvl = 0;
2456
2457         if (flp->lnum > bot && !finish && fp != NULL)
2458         {
2459             /* For "marker" and "syntax" methods:
2460              * - If a change caused a nested fold to be removed, we need to
2461              *   delete it and continue at least until where it ended.
2462              * - If a change caused a nested fold to be created, or this fold
2463              *   to continue below its original end, need to finish this fold.
2464              */
2465             if (getlevel != foldlevelMarker
2466                     && getlevel != foldlevelExpr
2467                     && getlevel != foldlevelSyntax)
2468                 break;
2469             i = 0;
2470             fp2 = fp;
2471             if (lvl >= level)
2472             {
2473                 /* Compute how deep the folds currently are, if it's deeper
2474                  * than "lvl" then some must be deleted, need to update
2475                  * at least one nested fold. */
2476                 ll = flp->lnum - fp->fd_top;
2477                 while (foldFind(&fp2->fd_nested, ll, &fp2))
2478                 {
2479                     ++i;
2480                     ll -= fp2->fd_top;
2481                 }
2482             }
2483             if (lvl < level + i)
2484             {
2485                 foldFind(&fp->fd_nested, flp->lnum - fp->fd_top, &fp2);
2486                 if (fp2 != NULL)
2487                     bot = fp2->fd_top + fp2->fd_len - 1 + fp->fd_top;
2488             }
2489             else if (fp->fd_top + fp->fd_len <= flp->lnum && lvl >= level)
2490                 finish = TRUE;
2491             else
2492                 break;
2493         }
2494
2495         /* At the start of the first nested fold and at the end of the current
2496          * fold: check if existing folds at this level, before the current
2497          * one, need to be deleted or truncated. */
2498         if (fp == NULL
2499                 && (lvl != level
2500                     || flp->lnum_save >= bot
2501                     || flp->start != 0
2502                     || flp->had_end <= MAX_LEVEL
2503                     || flp->lnum == linecount))
2504         {
2505             /*
2506              * Remove or update folds that have lines between startlnum and
2507              * firstlnum.
2508              */
2509             while (!got_int)
2510             {
2511                 /* set concat to 1 if it's allowed to concatenated this fold
2512                  * with a previous one that touches it. */
2513                 if (flp->start != 0 || flp->had_end <= MAX_LEVEL)
2514                     concat = 0;
2515                 else
2516                     concat = 1;
2517
2518                 /* Find an existing fold to re-use.  Preferably one that
2519                  * includes startlnum, otherwise one that ends just before
2520                  * startlnum or starts after it. */
2521                 if (foldFind(gap, startlnum, &fp)
2522                         || (fp < ((fold_T *)gap->ga_data) + gap->ga_len
2523                             && fp->fd_top <= firstlnum)
2524                         || foldFind(gap, firstlnum - concat, &fp)
2525                         || (fp < ((fold_T *)gap->ga_data) + gap->ga_len
2526                             && ((lvl < level && fp->fd_top < flp->lnum)
2527                                 || (lvl >= level
2528                                            && fp->fd_top <= flp->lnum_save))))
2529                 {
2530                     if (fp->fd_top + fp->fd_len + concat > firstlnum)
2531                     {
2532                         /* Use existing fold for the new fold.  If it starts
2533                          * before where we started looking, extend it.  If it
2534                          * starts at another line, update nested folds to keep
2535                          * their position, compensating for the new fd_top. */
2536                         if (fp->fd_top >= startlnum && fp->fd_top != firstlnum)
2537                         {
2538                             if (fp->fd_top > firstlnum)
2539                                 /* like lines are inserted */
2540                                 foldMarkAdjustRecurse(&fp->fd_nested,
2541                                         (linenr_T)0, (linenr_T)MAXLNUM,
2542                                         (long)(fp->fd_top - firstlnum), 0L);
2543                             else
2544                                 /* like lines are deleted */
2545                                 foldMarkAdjustRecurse(&fp->fd_nested,
2546                                         (linenr_T)0,
2547                                         (long)(firstlnum - fp->fd_top - 1),
2548                                         (linenr_T)MAXLNUM,
2549                                         (long)(fp->fd_top - firstlnum));
2550                             fp->fd_len += fp->fd_top - firstlnum;
2551                             fp->fd_top = firstlnum;
2552                             fold_changed = TRUE;
2553                         }
2554                         else if (flp->start != 0 && lvl == level
2555                                                    && fp->fd_top != firstlnum)
2556                         {
2557                             /* Existing fold that includes startlnum must stop
2558                              * if we find the start of a new fold at the same
2559                              * level.  Split it.  Delete contained folds at
2560                              * this point to split them too. */
2561                             foldRemove(&fp->fd_nested, flp->lnum - fp->fd_top,
2562                                                       flp->lnum - fp->fd_top);
2563                             i = (int)(fp - (fold_T *)gap->ga_data);
2564                             foldSplit(gap, i, flp->lnum, flp->lnum - 1);
2565                             fp = (fold_T *)gap->ga_data + i + 1;
2566                             /* If using the "marker" or "syntax" method, we
2567                              * need to continue until the end of the fold is
2568                              * found. */
2569                             if (getlevel == foldlevelMarker
2570                                     || getlevel == foldlevelExpr
2571                                     || getlevel == foldlevelSyntax)
2572                                 finish = TRUE;
2573                         }
2574                         break;
2575                     }
2576                     if (fp->fd_top >= startlnum)
2577                     {
2578                         /* A fold that starts at or after startlnum and stops
2579                          * before the new fold must be deleted.  Continue
2580                          * looking for the next one. */
2581                         deleteFoldEntry(gap,
2582                                      (int)(fp - (fold_T *)gap->ga_data), TRUE);
2583                     }
2584                     else
2585                     {
2586                         /* A fold has some lines above startlnum, truncate it
2587                          * to stop just above startlnum.  */
2588                         fp->fd_len = startlnum - fp->fd_top;
2589                         foldMarkAdjustRecurse(&fp->fd_nested,
2590                                 (linenr_T)fp->fd_len, (linenr_T)MAXLNUM,
2591                                                        (linenr_T)MAXLNUM, 0L);
2592                         fold_changed = TRUE;
2593                     }
2594                 }
2595                 else
2596                 {
2597                     /* Insert new fold.  Careful: ga_data may be NULL and it
2598                      * may change! */
2599                     i = (int)(fp - (fold_T *)gap->ga_data);
2600                     if (foldInsert(gap, i) != OK)
2601                         return bot;
2602                     fp = (fold_T *)gap->ga_data + i;
2603                     /* The new fold continues until bot, unless we find the
2604                      * end earlier. */
2605                     fp->fd_top = firstlnum;
2606                     fp->fd_len = bot - firstlnum + 1;
2607                     /* When the containing fold is open, the new fold is open.
2608                      * The new fold is closed if the fold above it is closed.
2609                      * The first fold depends on the containing fold. */
2610                     if (topflags == FD_OPEN)
2611                     {
2612                         flp->wp->w_fold_manual = TRUE;
2613                         fp->fd_flags = FD_OPEN;
2614                     }
2615                     else if (i <= 0)
2616                     {
2617                         fp->fd_flags = topflags;
2618                         if (topflags != FD_LEVEL)
2619                             flp->wp->w_fold_manual = TRUE;
2620                     }
2621                     else
2622                         fp->fd_flags = (fp - 1)->fd_flags;
2623                     fp->fd_small = MAYBE;
2624                     /* If using the "marker", "expr" or "syntax" method, we
2625                      * need to continue until the end of the fold is found. */
2626                     if (getlevel == foldlevelMarker
2627                             || getlevel == foldlevelExpr
2628                             || getlevel == foldlevelSyntax)
2629                         finish = TRUE;
2630                     fold_changed = TRUE;
2631                     break;
2632                 }
2633             }
2634         }
2635
2636         if (lvl < level || flp->lnum > linecount)
2637         {
2638             /*
2639              * Found a line with a lower foldlevel, this fold ends just above
2640              * "flp->lnum".
2641              */
2642             break;
2643         }
2644
2645         /*
2646          * The fold includes the line "flp->lnum" and "flp->lnum_save".
2647          * Check "fp" for safety.
2648          */
2649         if (lvl > level && fp != NULL)
2650         {
2651             /*
2652              * There is a nested fold, handle it recursively.
2653              */
2654             /* At least do one line (can happen when finish is TRUE). */
2655             if (bot < flp->lnum)
2656                 bot = flp->lnum;
2657
2658             /* Line numbers in the nested fold are relative to the start of
2659              * this fold. */
2660             flp->lnum = flp->lnum_save - fp->fd_top;
2661             flp->off += fp->fd_top;
2662             i = (int)(fp - (fold_T *)gap->ga_data);
2663             bot = foldUpdateIEMSRecurse(&fp->fd_nested, level + 1,
2664                                        startlnum2 - fp->fd_top, flp, getlevel,
2665                                               bot - fp->fd_top, fp->fd_flags);
2666             fp = (fold_T *)gap->ga_data + i;
2667             flp->lnum += fp->fd_top;
2668             flp->lnum_save += fp->fd_top;
2669             flp->off -= fp->fd_top;
2670             bot += fp->fd_top;
2671             startlnum2 = flp->lnum;
2672
2673             /* This fold may end at the same line, don't incr. flp->lnum. */
2674         }
2675         else
2676         {
2677             /*
2678              * Get the level of the next line, then continue the loop to check
2679              * if it ends there.
2680              * Skip over undefined lines, to find the foldlevel after it.
2681              * For the last line in the file the foldlevel is always valid.
2682              */
2683             flp->lnum = flp->lnum_save;
2684             ll = flp->lnum + 1;
2685             while (!got_int)
2686             {
2687                 /* Make the previous level available to foldlevel(). */
2688                 prev_lnum = flp->lnum;
2689                 prev_lnum_lvl = flp->lvl;
2690
2691                 if (++flp->lnum > linecount)
2692                     break;
2693                 flp->lvl = flp->lvl_next;
2694                 getlevel(flp);
2695                 if (flp->lvl >= 0 || flp->had_end <= MAX_LEVEL)
2696                     break;
2697             }
2698             prev_lnum = 0;
2699             if (flp->lnum > linecount)
2700                 break;
2701
2702             /* leave flp->lnum_save to lnum of the line that was used to get
2703              * the level, flp->lnum to the lnum of the next line. */
2704             flp->lnum_save = flp->lnum;
2705             flp->lnum = ll;
2706         }
2707     }
2708
2709     if (fp == NULL)     /* only happens when got_int is set */
2710         return bot;
2711
2712     /*
2713      * Get here when:
2714      * lvl < level: the folds ends just above "flp->lnum"
2715      * lvl >= level: fold continues below "bot"
2716      */
2717
2718     /* Current fold at least extends until lnum. */
2719     if (fp->fd_len < flp->lnum - fp->fd_top)
2720     {
2721         fp->fd_len = flp->lnum - fp->fd_top;
2722         fp->fd_small = MAYBE;
2723         fold_changed = TRUE;
2724     }
2725
2726     /* Delete contained folds from the end of the last one found until where
2727      * we stopped looking. */
2728     foldRemove(&fp->fd_nested, startlnum2 - fp->fd_top,
2729                                                   flp->lnum - 1 - fp->fd_top);
2730
2731     if (lvl < level)
2732     {
2733         /* End of fold found, update the length when it got shorter. */
2734         if (fp->fd_len != flp->lnum - fp->fd_top)
2735         {
2736             if (fp->fd_top + fp->fd_len > bot + 1)
2737             {
2738                 /* fold continued below bot */
2739                 if (getlevel == foldlevelMarker
2740                         || getlevel == foldlevelExpr
2741                         || getlevel == foldlevelSyntax)
2742                 {
2743                     /* marker method: truncate the fold and make sure the
2744                      * previously included lines are processed again */
2745                     bot = fp->fd_top + fp->fd_len - 1;
2746                     fp->fd_len = flp->lnum - fp->fd_top;
2747                 }
2748                 else
2749                 {
2750                     /* indent or expr method: split fold to create a new one
2751                      * below bot */
2752                     i = (int)(fp - (fold_T *)gap->ga_data);
2753                     foldSplit(gap, i, flp->lnum, bot);
2754                     fp = (fold_T *)gap->ga_data + i;
2755                 }
2756             }
2757             else
2758                 fp->fd_len = flp->lnum - fp->fd_top;
2759             fold_changed = TRUE;
2760         }
2761     }
2762
2763     /* delete following folds that end before the current line */
2764     for (;;)
2765     {
2766         fp2 = fp + 1;
2767         if (fp2 >= (fold_T *)gap->ga_data + gap->ga_len
2768                                                   || fp2->fd_top > flp->lnum)
2769             break;
2770         if (fp2->fd_top + fp2->fd_len > flp->lnum)
2771         {
2772             if (fp2->fd_top < flp->lnum)
2773             {
2774                 /* Make fold that includes lnum start at lnum. */
2775                 foldMarkAdjustRecurse(&fp2->fd_nested,
2776                         (linenr_T)0, (long)(flp->lnum - fp2->fd_top - 1),
2777                         (linenr_T)MAXLNUM, (long)(fp2->fd_top - flp->lnum));
2778                 fp2->fd_len -= flp->lnum - fp2->fd_top;
2779                 fp2->fd_top = flp->lnum;
2780                 fold_changed = TRUE;
2781             }
2782
2783             if (lvl >= level)
2784             {
2785                 /* merge new fold with existing fold that follows */
2786                 foldMerge(fp, gap, fp2);
2787             }
2788             break;
2789         }
2790         fold_changed = TRUE;
2791         deleteFoldEntry(gap, (int)(fp2 - (fold_T *)gap->ga_data), TRUE);
2792     }
2793
2794     /* Need to redraw the lines we inspected, which might be further down than
2795      * was asked for. */
2796     if (bot < flp->lnum - 1)
2797         bot = flp->lnum - 1;
2798
2799     return bot;
2800 }
2801
2802 /* foldInsert() {{{2 */
2803 /*
2804  * Insert a new fold in "gap" at position "i".
2805  * Returns OK for success, FAIL for failure.
2806  */
2807     static int
2808 foldInsert(gap, i)
2809     garray_T    *gap;
2810     int         i;
2811 {
2812     fold_T      *fp;
2813
2814     if (ga_grow(gap, 1) != OK)
2815         return FAIL;
2816     fp = (fold_T *)gap->ga_data + i;
2817     if (i < gap->ga_len)
2818         mch_memmove(fp + 1, fp, sizeof(fold_T) * (gap->ga_len - i));
2819     ++gap->ga_len;
2820     ga_init2(&fp->fd_nested, (int)sizeof(fold_T), 10);
2821     return OK;
2822 }
2823
2824 /* foldSplit() {{{2 */
2825 /*
2826  * Split the "i"th fold in "gap", which starts before "top" and ends below
2827  * "bot" in two pieces, one ending above "top" and the other starting below
2828  * "bot".
2829  * The caller must first have taken care of any nested folds from "top" to
2830  * "bot"!
2831  */
2832     static void
2833 foldSplit(gap, i, top, bot)
2834     garray_T    *gap;
2835     int         i;
2836     linenr_T    top;
2837     linenr_T    bot;
2838 {
2839     fold_T      *fp;
2840     fold_T      *fp2;
2841     garray_T    *gap1;
2842     garray_T    *gap2;
2843     int         idx;
2844     int         len;
2845
2846     /* The fold continues below bot, need to split it. */
2847     if (foldInsert(gap, i + 1) == FAIL)
2848         return;
2849     fp = (fold_T *)gap->ga_data + i;
2850     fp[1].fd_top = bot + 1;
2851     fp[1].fd_len = fp->fd_len - (fp[1].fd_top - fp->fd_top);
2852     fp[1].fd_flags = fp->fd_flags;
2853     fp[1].fd_small = MAYBE;
2854     fp->fd_small = MAYBE;
2855
2856     /* Move nested folds below bot to new fold.  There can't be
2857      * any between top and bot, they have been removed by the caller. */
2858     gap1 = &fp->fd_nested;
2859     gap2 = &fp[1].fd_nested;
2860     (void)(foldFind(gap1, bot + 1 - fp->fd_top, &fp2));
2861     len = (int)((fold_T *)gap1->ga_data + gap1->ga_len - fp2);
2862     if (len > 0 && ga_grow(gap2, len) == OK)
2863     {
2864         for (idx = 0; idx < len; ++idx)
2865         {
2866             ((fold_T *)gap2->ga_data)[idx] = fp2[idx];
2867             ((fold_T *)gap2->ga_data)[idx].fd_top
2868                                                  -= fp[1].fd_top - fp->fd_top;
2869         }
2870         gap2->ga_len = len;
2871         gap1->ga_len -= len;
2872     }
2873     fp->fd_len = top - fp->fd_top;
2874     fold_changed = TRUE;
2875 }
2876
2877 /* foldRemove() {{{2 */
2878 /*
2879  * Remove folds within the range "top" to and including "bot".
2880  * Check for these situations:
2881  *      1  2  3
2882  *      1  2  3
2883  * top     2  3  4  5
2884  *         2  3  4  5
2885  * bot     2  3  4  5
2886  *            3     5  6
2887  *            3     5  6
2888  *
2889  * 1: not changed
2890  * 2: truncate to stop above "top"
2891  * 3: split in two parts, one stops above "top", other starts below "bot".
2892  * 4: deleted
2893  * 5: made to start below "bot".
2894  * 6: not changed
2895  */
2896     static void
2897 foldRemove(gap, top, bot)
2898     garray_T    *gap;
2899     linenr_T    top;
2900     linenr_T    bot;
2901 {
2902     fold_T      *fp = NULL;
2903
2904     if (bot < top)
2905         return;         /* nothing to do */
2906
2907     for (;;)
2908     {
2909         /* Find fold that includes top or a following one. */
2910         if (foldFind(gap, top, &fp) && fp->fd_top < top)
2911         {
2912             /* 2: or 3: need to delete nested folds */
2913             foldRemove(&fp->fd_nested, top - fp->fd_top, bot - fp->fd_top);
2914             if (fp->fd_top + fp->fd_len > bot + 1)
2915             {
2916                 /* 3: need to split it. */
2917                 foldSplit(gap, (int)(fp - (fold_T *)gap->ga_data), top, bot);
2918             }
2919             else
2920             {
2921                 /* 2: truncate fold at "top". */
2922                 fp->fd_len = top - fp->fd_top;
2923             }
2924             fold_changed = TRUE;
2925             continue;
2926         }
2927         if (fp >= (fold_T *)(gap->ga_data) + gap->ga_len
2928                 || fp->fd_top > bot)
2929         {
2930             /* 6: Found a fold below bot, can stop looking. */
2931             break;
2932         }
2933         if (fp->fd_top >= top)
2934         {
2935             /* Found an entry below top. */
2936             fold_changed = TRUE;
2937             if (fp->fd_top + fp->fd_len - 1 > bot)
2938             {
2939                 /* 5: Make fold that includes bot start below bot. */
2940                 foldMarkAdjustRecurse(&fp->fd_nested,
2941                         (linenr_T)0, (long)(bot - fp->fd_top),
2942                         (linenr_T)MAXLNUM, (long)(fp->fd_top - bot - 1));
2943                 fp->fd_len -= bot - fp->fd_top + 1;
2944                 fp->fd_top = bot + 1;
2945                 break;
2946             }
2947
2948             /* 4: Delete completely contained fold. */
2949             deleteFoldEntry(gap, (int)(fp - (fold_T *)gap->ga_data), TRUE);
2950         }
2951     }
2952 }
2953
2954 /* foldMerge() {{{2 */
2955 /*
2956  * Merge two adjacent folds (and the nested ones in them).
2957  * This only works correctly when the folds are really adjacent!  Thus "fp1"
2958  * must end just above "fp2".
2959  * The resulting fold is "fp1", nested folds are moved from "fp2" to "fp1".
2960  * Fold entry "fp2" in "gap" is deleted.
2961  */
2962     static void
2963 foldMerge(fp1, gap, fp2)
2964     fold_T      *fp1;
2965     garray_T    *gap;
2966     fold_T      *fp2;
2967 {
2968     fold_T      *fp3;
2969     fold_T      *fp4;
2970     int         idx;
2971     garray_T    *gap1 = &fp1->fd_nested;
2972     garray_T    *gap2 = &fp2->fd_nested;
2973
2974     /* If the last nested fold in fp1 touches the first nested fold in fp2,
2975      * merge them recursively. */
2976     if (foldFind(gap1, fp1->fd_len - 1L, &fp3) && foldFind(gap2, 0L, &fp4))
2977         foldMerge(fp3, gap2, fp4);
2978
2979     /* Move nested folds in fp2 to the end of fp1. */
2980     if (gap2->ga_len > 0 && ga_grow(gap1, gap2->ga_len) == OK)
2981     {
2982         for (idx = 0; idx < gap2->ga_len; ++idx)
2983         {
2984             ((fold_T *)gap1->ga_data)[gap1->ga_len]
2985                                         = ((fold_T *)gap2->ga_data)[idx];
2986             ((fold_T *)gap1->ga_data)[gap1->ga_len].fd_top += fp1->fd_len;
2987             ++gap1->ga_len;
2988         }
2989         gap2->ga_len = 0;
2990     }
2991
2992     fp1->fd_len += fp2->fd_len;
2993     deleteFoldEntry(gap, (int)(fp2 - (fold_T *)gap->ga_data), TRUE);
2994     fold_changed = TRUE;
2995 }
2996
2997 /* foldlevelIndent() {{{2 */
2998 /*
2999  * Low level function to get the foldlevel for the "indent" method.
3000  * Doesn't use any caching.
3001  * Returns a level of -1 if the foldlevel depends on surrounding lines.
3002  */
3003     static void
3004 foldlevelIndent(flp)
3005     fline_T     *flp;
3006 {
3007     char_u      *s;
3008     buf_T       *buf;
3009     linenr_T    lnum = flp->lnum + flp->off;
3010
3011     buf = flp->wp->w_buffer;
3012     s = skipwhite(ml_get_buf(buf, lnum, FALSE));
3013
3014     /* empty line or lines starting with a character in 'foldignore': level
3015      * depends on surrounding lines */
3016     if (*s == NUL || vim_strchr(flp->wp->w_p_fdi, *s) != NULL)
3017     {
3018         /* first and last line can't be undefined, use level 0 */
3019         if (lnum == 1 || lnum == buf->b_ml.ml_line_count)
3020             flp->lvl = 0;
3021         else
3022             flp->lvl = -1;
3023     }
3024     else
3025         flp->lvl = get_indent_buf(buf, lnum) / buf->b_p_sw;
3026     if (flp->lvl > flp->wp->w_p_fdn)
3027     {
3028         flp->lvl = flp->wp->w_p_fdn;
3029         if (flp->lvl < 0)
3030             flp->lvl = 0;
3031     }
3032 }
3033
3034 /* foldlevelDiff() {{{2 */
3035 #ifdef FEAT_DIFF
3036 /*
3037  * Low level function to get the foldlevel for the "diff" method.
3038  * Doesn't use any caching.
3039  */
3040     static void
3041 foldlevelDiff(flp)
3042     fline_T     *flp;
3043 {
3044     if (diff_infold(flp->wp, flp->lnum + flp->off))
3045         flp->lvl = 1;
3046     else
3047         flp->lvl = 0;
3048 }
3049 #endif
3050
3051 /* foldlevelExpr() {{{2 */
3052 /*
3053  * Low level function to get the foldlevel for the "expr" method.
3054  * Doesn't use any caching.
3055  * Returns a level of -1 if the foldlevel depends on surrounding lines.
3056  */
3057     static void
3058 foldlevelExpr(flp)
3059     fline_T     *flp;
3060 {
3061 #ifndef FEAT_EVAL
3062     flp->start = FALSE;
3063     flp->lvl = 0;
3064 #else
3065     win_T       *win;
3066     int         n;
3067     int         c;
3068     linenr_T    lnum = flp->lnum + flp->off;
3069     int         save_keytyped;
3070
3071     win = curwin;
3072     curwin = flp->wp;
3073     curbuf = flp->wp->w_buffer;
3074     set_vim_var_nr(VV_LNUM, lnum);
3075
3076     flp->start = 0;
3077     flp->had_end = flp->end;
3078     flp->end = MAX_LEVEL + 1;
3079     if (lnum <= 1)
3080         flp->lvl = 0;
3081
3082     /* KeyTyped may be reset to 0 when calling a function which invokes
3083      * do_cmdline().  To make 'foldopen' work correctly restore KeyTyped. */
3084     save_keytyped = KeyTyped;
3085     n = eval_foldexpr(flp->wp->w_p_fde, &c);
3086     KeyTyped = save_keytyped;
3087
3088     switch (c)
3089     {
3090         /* "a1", "a2", .. : add to the fold level */
3091         case 'a': if (flp->lvl >= 0)
3092                   {
3093                       flp->lvl += n;
3094                       flp->lvl_next = flp->lvl;
3095                   }
3096                   flp->start = n;
3097                   break;
3098
3099         /* "s1", "s2", .. : subtract from the fold level */
3100         case 's': if (flp->lvl >= 0)
3101                   {
3102                       if (n > flp->lvl)
3103                           flp->lvl_next = 0;
3104                       else
3105                           flp->lvl_next = flp->lvl - n;
3106                       flp->end = flp->lvl_next + 1;
3107                   }
3108                   break;
3109
3110         /* ">1", ">2", .. : start a fold with a certain level */
3111         case '>': flp->lvl = n;
3112                   flp->lvl_next = n;
3113                   flp->start = 1;
3114                   break;
3115
3116         /* "<1", "<2", .. : end a fold with a certain level */
3117         case '<': flp->lvl_next = n - 1;
3118                   flp->end = n;
3119                   break;
3120
3121         /* "=": No change in level */
3122         case '=': flp->lvl_next = flp->lvl;
3123                   break;
3124
3125         /* "-1", "0", "1", ..: set fold level */
3126         default:  if (n < 0)
3127                       /* Use the current level for the next line, so that "a1"
3128                        * will work there. */
3129                       flp->lvl_next = flp->lvl;
3130                   else
3131                       flp->lvl_next = n;
3132                   flp->lvl = n;
3133                   break;
3134     }
3135
3136     /* If the level is unknown for the first or the last line in the file, use
3137      * level 0. */
3138     if (flp->lvl < 0)
3139     {
3140         if (lnum <= 1)
3141         {
3142             flp->lvl = 0;
3143             flp->lvl_next = 0;
3144         }
3145         if (lnum == curbuf->b_ml.ml_line_count)
3146             flp->lvl_next = 0;
3147     }
3148
3149     curwin = win;
3150     curbuf = curwin->w_buffer;
3151 #endif
3152 }
3153
3154 /* parseMarker() {{{2 */
3155 /*
3156  * Parse 'foldmarker' and set "foldendmarker", "foldstartmarkerlen" and
3157  * "foldendmarkerlen".
3158  * Relies on the option value to have been checked for correctness already.
3159  */
3160     static void
3161 parseMarker(wp)
3162     win_T       *wp;
3163 {
3164     foldendmarker = vim_strchr(wp->w_p_fmr, ',');
3165     foldstartmarkerlen = (int)(foldendmarker++ - wp->w_p_fmr);
3166     foldendmarkerlen = (int)STRLEN(foldendmarker);
3167 }
3168
3169 /* foldlevelMarker() {{{2 */
3170 /*
3171  * Low level function to get the foldlevel for the "marker" method.
3172  * "foldendmarker", "foldstartmarkerlen" and "foldendmarkerlen" must have been
3173  * set before calling this.
3174  * Requires that flp->lvl is set to the fold level of the previous line!
3175  * Careful: This means you can't call this function twice on the same line.
3176  * Doesn't use any caching.
3177  * Sets flp->start when a start marker was found.
3178  */
3179     static void
3180 foldlevelMarker(flp)
3181     fline_T     *flp;
3182 {
3183     char_u      *startmarker;
3184     int         cstart;
3185     int         cend;
3186     int         start_lvl = flp->lvl;
3187     char_u      *s;
3188     int         n;
3189
3190     /* cache a few values for speed */
3191     startmarker = flp->wp->w_p_fmr;
3192     cstart = *startmarker;
3193     ++startmarker;
3194     cend = *foldendmarker;
3195
3196     /* Default: no start found, next level is same as current level */
3197     flp->start = 0;
3198     flp->lvl_next = flp->lvl;
3199
3200     s = ml_get_buf(flp->wp->w_buffer, flp->lnum + flp->off, FALSE);
3201     while (*s)
3202     {
3203         if (*s == cstart
3204                   && STRNCMP(s + 1, startmarker, foldstartmarkerlen - 1) == 0)
3205         {
3206             /* found startmarker: set flp->lvl */
3207             s += foldstartmarkerlen;
3208             if (VIM_ISDIGIT(*s))
3209             {
3210                 n = atoi((char *)s);
3211                 if (n > 0)
3212                 {
3213                     flp->lvl = n;
3214                     flp->lvl_next = n;
3215                     if (n <= start_lvl)
3216                         flp->start = 1;
3217                     else
3218                         flp->start = n - start_lvl;
3219                 }
3220             }
3221             else
3222             {
3223                 ++flp->lvl;
3224                 ++flp->lvl_next;
3225                 ++flp->start;
3226             }
3227         }
3228         else if (*s == cend
3229               && STRNCMP(s + 1, foldendmarker + 1, foldendmarkerlen - 1) == 0)
3230         {
3231             /* found endmarker: set flp->lvl_next */
3232             s += foldendmarkerlen;
3233             if (VIM_ISDIGIT(*s))
3234             {
3235                 n = atoi((char *)s);
3236                 if (n > 0)
3237                 {
3238                     flp->lvl = n;
3239                     flp->lvl_next = n - 1;
3240                     /* never start a fold with an end marker */
3241                     if (flp->lvl_next > start_lvl)
3242                         flp->lvl_next = start_lvl;
3243                 }
3244             }
3245             else
3246                 --flp->lvl_next;
3247         }
3248         else
3249             mb_ptr_adv(s);
3250     }
3251
3252     /* The level can't go negative, must be missing a start marker. */
3253     if (flp->lvl_next < 0)
3254         flp->lvl_next = 0;
3255 }
3256
3257 /* foldlevelSyntax() {{{2 */
3258 /*
3259  * Low level function to get the foldlevel for the "syntax" method.
3260  * Doesn't use any caching.
3261  */
3262     static void
3263 foldlevelSyntax(flp)
3264     fline_T     *flp;
3265 {
3266 #ifndef FEAT_SYN_HL
3267     flp->start = 0;
3268     flp->lvl = 0;
3269 #else
3270     linenr_T    lnum = flp->lnum + flp->off;
3271     int         n;
3272
3273     /* Use the maximum fold level at the start of this line and the next. */
3274     flp->lvl = syn_get_foldlevel(flp->wp, lnum);
3275     flp->start = 0;
3276     if (lnum < flp->wp->w_buffer->b_ml.ml_line_count)
3277     {
3278         n = syn_get_foldlevel(flp->wp, lnum + 1);
3279         if (n > flp->lvl)
3280         {
3281             flp->start = n - flp->lvl;  /* fold(s) start here */
3282             flp->lvl = n;
3283         }
3284     }
3285 #endif
3286 }
3287
3288 /* functions for storing the fold state in a View {{{1 */
3289 /* put_folds() {{{2 */
3290 #if defined(FEAT_SESSION) || defined(PROTO)
3291 static int put_folds_recurse __ARGS((FILE *fd, garray_T *gap, linenr_T off));
3292 static int put_foldopen_recurse __ARGS((FILE *fd, garray_T *gap, linenr_T off));
3293
3294 /*
3295  * Write commands to "fd" to restore the manual folds in window "wp".
3296  * Return FAIL if writing fails.
3297  */
3298     int
3299 put_folds(fd, wp)
3300     FILE        *fd;
3301     win_T       *wp;
3302 {
3303     if (foldmethodIsManual(wp))
3304     {
3305         if (put_line(fd, "silent! normal! zE") == FAIL
3306                 || put_folds_recurse(fd, &wp->w_folds, (linenr_T)0) == FAIL)
3307             return FAIL;
3308     }
3309
3310     /* If some folds are manually opened/closed, need to restore that. */
3311     if (wp->w_fold_manual)
3312         return put_foldopen_recurse(fd, &wp->w_folds, (linenr_T)0);
3313
3314     return OK;
3315 }
3316
3317 /* put_folds_recurse() {{{2 */
3318 /*
3319  * Write commands to "fd" to recreate manually created folds.
3320  * Returns FAIL when writing failed.
3321  */
3322     static int
3323 put_folds_recurse(fd, gap, off)
3324     FILE        *fd;
3325     garray_T    *gap;
3326     linenr_T    off;
3327 {
3328     int         i;
3329     fold_T      *fp;
3330
3331     fp = (fold_T *)gap->ga_data;
3332     for (i = 0; i < gap->ga_len; i++)
3333     {
3334         /* Do nested folds first, they will be created closed. */
3335         if (put_folds_recurse(fd, &fp->fd_nested, off + fp->fd_top) == FAIL)
3336             return FAIL;
3337         if (fprintf(fd, "%ld,%ldfold", fp->fd_top + off,
3338                                         fp->fd_top + off + fp->fd_len - 1) < 0
3339                 || put_eol(fd) == FAIL)
3340             return FAIL;
3341         ++fp;
3342     }
3343     return OK;
3344 }
3345
3346 /* put_foldopen_recurse() {{{2 */
3347 /*
3348  * Write commands to "fd" to open and close manually opened/closed folds.
3349  * Returns FAIL when writing failed.
3350  */
3351     static int
3352 put_foldopen_recurse(fd, gap, off)
3353     FILE        *fd;
3354     garray_T    *gap;
3355     linenr_T    off;
3356 {
3357     int         i;
3358     fold_T      *fp;
3359
3360     fp = (fold_T *)gap->ga_data;
3361     for (i = 0; i < gap->ga_len; i++)
3362     {
3363         if (fp->fd_flags != FD_LEVEL)
3364         {
3365             if (fp->fd_nested.ga_len > 0)
3366             {
3367                 /* open/close nested folds while this fold is open */
3368                 if (fprintf(fd, "%ld", fp->fd_top + off) < 0
3369                         || put_eol(fd) == FAIL
3370                         || put_line(fd, "normal zo") == FAIL)
3371                     return FAIL;
3372                 if (put_foldopen_recurse(fd, &fp->fd_nested, off + fp->fd_top)
3373                         == FAIL)
3374                     return FAIL;
3375             }
3376             if (fprintf(fd, "%ld", fp->fd_top + off) < 0
3377                     || put_eol(fd) == FAIL
3378                     || fprintf(fd, "normal z%c",
3379                                     fp->fd_flags == FD_CLOSED ? 'c' : 'o') < 0
3380                     || put_eol(fd) == FAIL)
3381                 return FAIL;
3382         }
3383         ++fp;
3384     }
3385
3386     return OK;
3387 }
3388 #endif /* FEAT_SESSION */
3389
3390 /* }}}1 */
3391 #endif /* defined(FEAT_FOLDING) || defined(PROTO) */