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 */ 27typedef 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 */ 46static void newFoldLevelWin __ARGS((win_T *wp)); 47static int checkCloseRec __ARGS((garray_T *gap, linenr_T lnum, int level)); 48static int foldFind __ARGS((garray_T *gap, linenr_T lnum, fold_T **fpp)); 49static int foldLevelWin __ARGS((win_T *wp, linenr_T lnum)); 50static void checkupdate __ARGS((win_T *wp)); 51static void setFoldRepeat __ARGS((linenr_T lnum, long count, int do_open)); 52static linenr_T setManualFold __ARGS((linenr_T lnum, int opening, int recurse, int *donep)); 53static linenr_T setManualFoldWin __ARGS((win_T *wp, linenr_T lnum, int opening, int recurse, int *donep)); 54static void foldOpenNested __ARGS((fold_T *fpr)); 55static void deleteFoldEntry __ARGS((garray_T *gap, int idx, int recursive)); 56static void foldMarkAdjustRecurse __ARGS((garray_T *gap, linenr_T line1, linenr_T line2, long amount, long amount_after)); 57static int getDeepestNestingRecurse __ARGS((garray_T *gap)); 58static int check_closed __ARGS((win_T *win, fold_T *fp, int *use_levelp, int level, int *maybe_smallp, linenr_T lnum_off)); 59static void checkSmall __ARGS((win_T *wp, fold_T *fp, linenr_T lnum_off)); 60static void setSmallMaybe __ARGS((garray_T *gap)); 61static void foldCreateMarkers __ARGS((linenr_T start, linenr_T end)); 62static void foldAddMarker __ARGS((linenr_T lnum, char_u *marker, int markerlen)); 63static void deleteFoldMarkers __ARGS((fold_T *fp, int recursive, linenr_T lnum_off)); 64static void foldDelMarker __ARGS((linenr_T lnum, char_u *marker, int markerlen)); 65static void foldUpdateIEMS __ARGS((win_T *wp, linenr_T top, linenr_T bot)); 66static void parseMarker __ARGS((win_T *wp)); 67 68static 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 */ 74static linenr_T invalid_top = (linenr_T)0; 75static 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 */ 84static linenr_T prev_lnum = 0; 85static 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 92static int foldstartmarkerlen; 93static char_u *foldendmarker; 94static 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 103copyFoldingState(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 118hasAnyFolding(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 134hasFolding(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 144hasFoldingWin(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 255foldLevel(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 282lineFolded(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 299foldedCount(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 316foldmethodIsManual(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 327foldmethodIsIndent(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 338foldmethodIsExpr(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 349foldmethodIsMarker(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 360foldmethodIsSyntax(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 371foldmethodIsDiff(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 383closeFold(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 395closeFoldRecurse(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 407opFoldRange(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 446openFold(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 458openFoldRecurse(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 469foldOpenCursor() 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 489newFoldLevel() 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 514newFoldLevelWin(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 539foldCheckClose() 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 552checkCloseRec(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 587foldManualAllowed(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 605foldCreate(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 732deleteFold(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 829clearFolding(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 844foldUpdate(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 885foldUpdateAll(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 899foldMoveTo(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 1036foldInitWin(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 1050find_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 1073foldAdjustVisual() 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 1113foldAdjustCursor() 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 1126cloneFoldGrowArray(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 1162foldFind(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 1204foldLevelWin(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 1233checkupdate(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 1249setFoldRepeat(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 1277setManualFold(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 1319setManualFoldWin(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 1430foldOpenNested(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 1451deleteFoldEntry(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 1505deleteFoldRecurse(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 1520foldMarkAdjust(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 1540foldMarkAdjustRecurse(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 1657getDeepestNesting() 1658{ 1659 checkupdate(curwin); 1660 return getDeepestNestingRecurse(&curwin->w_folds); 1661} 1662 1663 static int 1664getDeepestNestingRecurse(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 1688check_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 1728checkSmall(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 1765setSmallMaybe(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 1782foldCreateMarkers(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 1806foldAddMarker(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 1845deleteFoldMarkers(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 1869foldDelMarker(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 * 1923get_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 2010foldtext_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 */ 2099typedef 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. */ 2116static int fold_changed; 2117 2118/* Function declarations. {{{2 */ 2119static 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)); 2120static int foldInsert __ARGS((garray_T *gap, int i)); 2121static void foldSplit __ARGS((garray_T *gap, int i, linenr_T top, linenr_T bot)); 2122static void foldRemove __ARGS((garray_T *gap, linenr_T top, linenr_T bot)); 2123static void foldMerge __ARGS((fold_T *fp1, garray_T *gap, fold_T *fp2)); 2124static void foldlevelIndent __ARGS((fline_T *flp)); 2125#ifdef FEAT_DIFF 2126static void foldlevelDiff __ARGS((fline_T *flp)); 2127#endif 2128static void foldlevelExpr __ARGS((fline_T *flp)); 2129static void foldlevelMarker __ARGS((fline_T *flp)); 2130static 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 2138foldUpdateIEMS(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 2394foldUpdateIEMSRecurse(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 2808foldInsert(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 2833foldSplit(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 2897foldRemove(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 2963foldMerge(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 3004foldlevelIndent(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 3041foldlevelDiff(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 3058foldlevelExpr(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 3161parseMarker(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 3180foldlevelMarker(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 3263foldlevelSyntax(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) 3291static int put_folds_recurse __ARGS((FILE *fd, garray_T *gap, linenr_T off)); 3292static 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 3299put_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 3323put_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 3352put_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) */ 3392