1 /* vi:set ts=8 sts=4 sw=4:
3 * VIM - Vi IMproved by Bram Moolenaar
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
11 * undo.c: multi level undo facility
13 * The saved lines are stored in a list of lists (one for each buffer):
15 * b_u_oldhead------------------------------------------------+
18 * +--------------+ +--------------+ +--------------+
19 * b_u_newhead--->| u_header | | u_header | | u_header |
20 * | uh_next------>| uh_next------>| uh_next---->NULL
21 * NULL<--------uh_prev |<---------uh_prev |<---------uh_prev |
22 * | uh_entry | | uh_entry | | uh_entry |
23 * +--------|-----+ +--------|-----+ +--------|-----+
26 * +--------------+ +--------------+ +--------------+
27 * | u_entry | | u_entry | | u_entry |
28 * | ue_next | | ue_next | | ue_next |
29 * +--------|-----+ +--------|-----+ +--------|-----+
32 * +--------------+ NULL NULL
40 * Each u_entry list contains the information for one undo or redo.
41 * curbuf->b_u_curhead points to the header of the last undo (the next redo),
42 * or is NULL if nothing has been undone (end of the branch).
44 * For keeping alternate undo/redo branches the uh_alt field is used. Thus at
45 * each point in the list a branch may appear for an alternate to redo. The
46 * uh_seq field is numbered sequentially to be able to find a newer or older
49 * +---------------+ +---------------+
50 * b_u_oldhead --->| u_header | | u_header |
51 * | uh_alt_next ---->| uh_alt_next ----> NULL
52 * NULL <----- uh_alt_prev |<------ uh_alt_prev |
53 * | uh_prev | | uh_prev |
54 * +-----|---------+ +-----|---------+
57 * +---------------+ +---------------+
58 * | u_header | | u_header |
59 * | uh_alt_next | | uh_alt_next |
60 * b_u_newhead --->| uh_alt_prev | | uh_alt_prev |
61 * | uh_prev | | uh_prev |
62 * +-----|---------+ +-----|---------+
65 * NULL +---------------+ +---------------+
66 * | u_header | | u_header |
67 * | uh_alt_next ---->| uh_alt_next |
68 * | uh_alt_prev |<------ uh_alt_prev |
69 * | uh_prev | | uh_prev |
70 * +-----|---------+ +-----|---------+
75 * All data is allocated with U_ALLOC_LINE(), it will be freed as soon as the
81 /* See below: use malloc()/free() for memory management. */
82 #define U_USE_MALLOC 1
84 static void u_unch_branch
__ARGS((u_header_T
*uhp
));
85 static u_entry_T
*u_get_headentry
__ARGS((void));
86 static void u_getbot
__ARGS((void));
87 static int u_savecommon
__ARGS((linenr_T
, linenr_T
, linenr_T
));
88 static void u_doit
__ARGS((int count
));
89 static void u_undoredo
__ARGS((int undo
));
90 static void u_undo_end
__ARGS((int did_undo
, int absolute
));
91 static void u_add_time
__ARGS((char_u
*buf
, size_t buflen
, time_t tt
));
92 static void u_freeheader
__ARGS((buf_T
*buf
, u_header_T
*uhp
, u_header_T
**uhpp
));
93 static void u_freebranch
__ARGS((buf_T
*buf
, u_header_T
*uhp
, u_header_T
**uhpp
));
94 static void u_freeentries
__ARGS((buf_T
*buf
, u_header_T
*uhp
, u_header_T
**uhpp
));
95 static void u_freeentry
__ARGS((u_entry_T
*, long));
98 # define U_FREE_LINE(ptr) vim_free(ptr)
99 # define U_ALLOC_LINE(size) lalloc((long_u)((size) + 1), FALSE)
101 static void u_free_line
__ARGS((char_u
*ptr
, int keep
));
102 static char_u
*u_alloc_line
__ARGS((unsigned size
));
103 # define U_FREE_LINE(ptr) u_free_line((ptr), FALSE)
104 # define U_ALLOC_LINE(size) u_alloc_line(size)
106 static char_u
*u_save_line
__ARGS((linenr_T
));
108 static long u_newcount
, u_oldcount
;
111 * When 'u' flag included in 'cpoptions', we behave like vi. Need to remember
112 * the action that "u" should do.
114 static int undo_undoes
= FALSE
;
117 * Save the current line for both the "u" and "U" command.
118 * Returns OK or FAIL.
123 return (u_save((linenr_T
)(curwin
->w_cursor
.lnum
- 1),
124 (linenr_T
)(curwin
->w_cursor
.lnum
+ 1)));
128 * Save the lines between "top" and "bot" for both the "u" and "U" command.
129 * "top" may be 0 and bot may be curbuf->b_ml.ml_line_count + 1.
130 * Returns FAIL when lines could not be saved, OK otherwise.
139 if (top
> curbuf
->b_ml
.ml_line_count
||
140 top
>= bot
|| bot
> curbuf
->b_ml
.ml_line_count
+ 1)
141 return FALSE
; /* rely on caller to do error messages */
144 u_saveline((linenr_T
)(top
+ 1));
146 return (u_savecommon(top
, bot
, (linenr_T
)0));
150 * save the line "lnum" (used by ":s" and "~" command)
151 * The line is replaced, so the new bottom line is lnum + 1.
160 return (u_savecommon(lnum
- 1, lnum
+ 1, lnum
+ 1));
164 * a new line is inserted before line "lnum" (used by :s command)
165 * The line is inserted, so the new bottom line is lnum + 1.
174 return (u_savecommon(lnum
- 1, lnum
, lnum
+ 1));
178 * save the lines "lnum" - "lnum" + nlines (used by delete command)
179 * The lines are deleted, so the new bottom line is lnum, unless the buffer
183 u_savedel(lnum
, nlines
)
190 return (u_savecommon(lnum
- 1, lnum
+ nlines
,
191 nlines
== curbuf
->b_ml
.ml_line_count
? 2 : lnum
));
195 * Return TRUE when undo is allowed. Otherwise give an error message and
201 /* Don't allow changes when 'modifiable' is off. */
204 EMSG(_(e_modifiable
));
209 /* In the sandbox it's not allowed to change the text. */
217 /* Don't allow changes in the buffer while editing the cmdline. The
218 * caller of getcmdline() may get confused. */
229 u_savecommon(top
, bot
, newbot
)
236 u_header_T
*old_curhead
;
241 /* When making changes is not allowed return FAIL. It's a crude way to
242 * make all change commands fail. */
246 #ifdef FEAT_NETBEANS_INTG
248 * Netbeans defines areas that cannot be modified. Bail out here when
249 * trying to change text in a guarded area.
253 if (netbeans_is_guarded(top
, bot
))
260 EMSG(_(e_nbreadonly
));
268 * Saving text for undo means we are going to make a change. Give a
269 * warning for a read-only file before making the change, so that the
270 * FileChangedRO event can replace the buffer with a read-write version
271 * (e.g., obtained from a source control system).
276 size
= bot
- top
- 1;
279 * if curbuf->b_u_synced == TRUE make a new header
281 if (curbuf
->b_u_synced
)
284 /* Need to create new entry in b_changelist. */
285 curbuf
->b_new_change
= TRUE
;
291 * Make a new header entry. Do this first so that we don't mess
292 * up the undo info when out of memory.
294 uhp
= (u_header_T
*)U_ALLOC_LINE((unsigned)sizeof(u_header_T
));
302 * If we undid more than we redid, move the entry lists before and
303 * including curbuf->b_u_curhead to an alternate branch.
305 old_curhead
= curbuf
->b_u_curhead
;
306 if (old_curhead
!= NULL
)
308 curbuf
->b_u_newhead
= old_curhead
->uh_next
;
309 curbuf
->b_u_curhead
= NULL
;
313 * free headers to keep the size right
315 while (curbuf
->b_u_numhead
> p_ul
&& curbuf
->b_u_oldhead
!= NULL
)
317 u_header_T
*uhfree
= curbuf
->b_u_oldhead
;
319 /* If there is no branch only free one header. */
320 if (uhfree
->uh_alt_next
== NULL
)
321 u_freeheader(curbuf
, uhfree
, &old_curhead
);
324 /* Free the oldest alternate branch as a whole. */
325 while (uhfree
->uh_alt_next
!= NULL
)
326 uhfree
= uhfree
->uh_alt_next
;
327 u_freebranch(curbuf
, uhfree
, &old_curhead
);
331 if (uhp
== NULL
) /* no undo at all */
333 if (old_curhead
!= NULL
)
334 u_freebranch(curbuf
, old_curhead
, NULL
);
335 curbuf
->b_u_synced
= FALSE
;
340 uhp
->uh_next
= curbuf
->b_u_newhead
;
341 uhp
->uh_alt_next
= old_curhead
;
342 if (old_curhead
!= NULL
)
344 old_curhead
->uh_alt_prev
= uhp
;
345 if (curbuf
->b_u_oldhead
== old_curhead
)
346 curbuf
->b_u_oldhead
= uhp
;
348 uhp
->uh_alt_prev
= NULL
;
349 if (curbuf
->b_u_newhead
!= NULL
)
350 curbuf
->b_u_newhead
->uh_prev
= uhp
;
352 uhp
->uh_seq
= ++curbuf
->b_u_seq_last
;
353 curbuf
->b_u_seq_cur
= uhp
->uh_seq
;
354 uhp
->uh_time
= time(NULL
);
355 curbuf
->b_u_seq_time
= uhp
->uh_time
+ 1;
358 uhp
->uh_entry
= NULL
;
359 uhp
->uh_getbot_entry
= NULL
;
360 uhp
->uh_cursor
= curwin
->w_cursor
; /* save cursor pos. for undo */
361 #ifdef FEAT_VIRTUALEDIT
362 if (virtual_active() && curwin
->w_cursor
.coladd
> 0)
363 uhp
->uh_cursor_vcol
= getviscol();
365 uhp
->uh_cursor_vcol
= -1;
368 /* save changed and buffer empty flag for undo */
369 uhp
->uh_flags
= (curbuf
->b_changed
? UH_CHANGED
: 0) +
370 ((curbuf
->b_ml
.ml_flags
& ML_EMPTY
) ? UH_EMPTYBUF
: 0);
372 /* save named marks and Visual marks for undo */
373 mch_memmove(uhp
->uh_namedm
, curbuf
->b_namedm
, sizeof(pos_T
) * NMARKS
);
375 uhp
->uh_visual
= curbuf
->b_visual
;
378 curbuf
->b_u_newhead
= uhp
;
379 if (curbuf
->b_u_oldhead
== NULL
)
380 curbuf
->b_u_oldhead
= uhp
;
381 ++curbuf
->b_u_numhead
;
385 if (p_ul
< 0) /* no undo at all */
389 * When saving a single line, and it has been saved just before, it
390 * doesn't make sense saving it again. Saves a lot of memory when
391 * making lots of changes inside the same line.
392 * This is only possible if the previous change didn't increase or
393 * decrease the number of lines.
394 * Check the ten last changes. More doesn't make sense and takes too
399 uep
= u_get_headentry();
401 for (i
= 0; i
< 10; ++i
)
406 /* If lines have been inserted/deleted we give up.
407 * Also when the line was included in a multi-line save. */
408 if ((curbuf
->b_u_newhead
->uh_getbot_entry
!= uep
409 ? (uep
->ue_top
+ uep
->ue_size
+ 1
411 ? curbuf
->b_ml
.ml_line_count
+ 1
413 : uep
->ue_lcount
!= curbuf
->b_ml
.ml_line_count
)
415 && top
>= uep
->ue_top
416 && top
+ 2 <= uep
->ue_top
+ uep
->ue_size
+ 1))
419 /* If it's the same line we can skip saving it again. */
420 if (uep
->ue_size
== 1 && uep
->ue_top
== top
)
424 /* It's not the last entry: get ue_bot for the last
425 * entry now. Following deleted/inserted lines go to
426 * the re-used entry. */
428 curbuf
->b_u_synced
= FALSE
;
430 /* Move the found entry to become the last entry. The
431 * order of undo/redo doesn't matter for the entries
432 * we move it over, since they don't change the line
433 * count and don't include this line. It does matter
434 * for the found entry if the line count is changed by
435 * the executed command. */
436 prev_uep
->ue_next
= uep
->ue_next
;
437 uep
->ue_next
= curbuf
->b_u_newhead
->uh_entry
;
438 curbuf
->b_u_newhead
->uh_entry
= uep
;
441 /* The executed command may change the line count. */
443 uep
->ue_bot
= newbot
;
444 else if (bot
> curbuf
->b_ml
.ml_line_count
)
448 uep
->ue_lcount
= curbuf
->b_ml
.ml_line_count
;
449 curbuf
->b_u_newhead
->uh_getbot_entry
= uep
;
458 /* find line number for ue_bot for previous u_save() */
462 #if !defined(UNIX) && !defined(DJGPP) && !defined(WIN32) && !defined(__EMX__)
464 * With Amiga and MSDOS 16 bit we can't handle big undo's, because
465 * then u_alloc_line would have to allocate a block larger than 32K
472 * add lines in front of entry list
474 uep
= (u_entry_T
*)U_ALLOC_LINE((unsigned)sizeof(u_entry_T
));
481 uep
->ue_bot
= newbot
;
483 * Use 0 for ue_bot if bot is below last line.
484 * Otherwise we have to compute ue_bot later.
486 else if (bot
> curbuf
->b_ml
.ml_line_count
)
490 uep
->ue_lcount
= curbuf
->b_ml
.ml_line_count
;
491 curbuf
->b_u_newhead
->uh_getbot_entry
= uep
;
496 if ((uep
->ue_array
= (char_u
**)U_ALLOC_LINE(
497 (unsigned)(sizeof(char_u
*) * size
))) == NULL
)
499 u_freeentry(uep
, 0L);
502 for (i
= 0, lnum
= top
+ 1; i
< size
; ++i
)
510 if ((uep
->ue_array
[i
] = u_save_line(lnum
++)) == NULL
)
518 uep
->ue_array
= NULL
;
519 uep
->ue_next
= curbuf
->b_u_newhead
->uh_entry
;
520 curbuf
->b_u_newhead
->uh_entry
= uep
;
521 curbuf
->b_u_synced
= FALSE
;
527 msg_silent
= 0; /* must display the prompt */
528 if (ask_yesno((char_u
*)_("No undo possible; continue anyway"), TRUE
)
531 undo_off
= TRUE
; /* will be reset when character typed */
534 do_outofmem_msg((long_u
)0);
539 * If 'cpoptions' contains 'u': Undo the previous undo or redo (vi compatible).
540 * If 'cpoptions' does not contain 'u': Always undo.
547 * If we get an undo command while executing a macro, we behave like the
548 * original vi. If this happens twice in one macro the result will not
551 if (curbuf
->b_u_synced
== FALSE
)
557 if (vim_strchr(p_cpo
, CPO_UNDO
) == NULL
)
560 undo_undoes
= !undo_undoes
;
565 * If 'cpoptions' contains 'u': Repeat the previous undo or redo.
566 * If 'cpoptions' does not contain 'u': Always redo.
572 if (vim_strchr(p_cpo
, CPO_UNDO
) == NULL
)
578 * Undo or redo, depending on 'undo_undoes', 'count' times.
584 int count
= startcount
;
591 if (curbuf
->b_ml
.ml_flags
& ML_EMPTY
)
597 if (curbuf
->b_u_curhead
== NULL
) /* first undo */
598 curbuf
->b_u_curhead
= curbuf
->b_u_newhead
;
599 else if (p_ul
> 0) /* multi level undo */
601 curbuf
->b_u_curhead
= curbuf
->b_u_curhead
->uh_next
;
602 /* nothing to undo */
603 if (curbuf
->b_u_numhead
== 0 || curbuf
->b_u_curhead
== NULL
)
605 /* stick curbuf->b_u_curhead at end */
606 curbuf
->b_u_curhead
= curbuf
->b_u_oldhead
;
608 if (count
== startcount
- 1)
610 MSG(_("Already at oldest change"));
620 if (curbuf
->b_u_curhead
== NULL
|| p_ul
<= 0)
622 beep_flush(); /* nothing to redo */
623 if (count
== startcount
- 1)
625 MSG(_("Already at newest change"));
633 /* Advance for next redo. Set "newhead" when at the end of the
634 * redoable changes. */
635 if (curbuf
->b_u_curhead
->uh_prev
== NULL
)
636 curbuf
->b_u_newhead
= curbuf
->b_u_curhead
;
637 curbuf
->b_u_curhead
= curbuf
->b_u_curhead
->uh_prev
;
640 u_undo_end(undo_undoes
, FALSE
);
643 static int lastmark
= 0;
646 * Undo or redo over the timeline.
647 * When "step" is negative go back in time, otherwise goes forward in time.
648 * When "sec" is FALSE make "step" steps, when "sec" is TRUE use "step" as
650 * When "absolute" is TRUE use "step" as the sequence number to jump to.
651 * "sec" must be FALSE then.
654 undo_time(step
, sec
, absolute
)
662 long closest_seq
= 0;
673 /* First make sure the current undoable change is synced. */
674 if (curbuf
->b_u_synced
== FALSE
)
679 if (curbuf
->b_ml
.ml_flags
& ML_EMPTY
)
682 /* "target" is the node below which we want to be.
683 * Init "closest" to a value we can't reach. */
691 /* When doing computations with time_t subtract starttime, because
692 * time_t converted to a long may result in a wrong number. */
694 target
= (long)(curbuf
->b_u_seq_time
- starttime
) + step
;
696 target
= curbuf
->b_u_seq_cur
+ step
;
706 closest
= (long)(time(NULL
) - starttime
+ 1);
708 closest
= curbuf
->b_u_seq_last
+ 2;
709 if (target
>= closest
)
710 target
= closest
- 1;
713 closest_start
= closest
;
714 closest_seq
= curbuf
->b_u_seq_cur
;
718 * 1. Search for "target", update "closest" to the best match found.
719 * 2. If "target" not found search for "closest".
721 * When using the closest time we use the sequence number in the second
722 * round, because there may be several entries with the same time.
724 for (round
= 1; round
<= 2; ++round
)
726 /* Find the path from the current state to where we want to go. The
727 * desired state can be anywhere in the undo tree, need to go all over
728 * it. We put "nomark" in uh_walk where we have been without success,
729 * "mark" where it could possibly be. */
733 if (curbuf
->b_u_curhead
== NULL
) /* at leaf of the tree */
734 uhp
= curbuf
->b_u_newhead
;
736 uhp
= curbuf
->b_u_curhead
;
741 val
= (long)(dosec
? (uhp
->uh_time
- starttime
) : uhp
->uh_seq
);
745 /* Remember the header that is closest to the target.
746 * It must be at least in the right direction (checked with
747 * "b_u_seq_cur"). When the timestamp is equal find the
748 * highest/lowest sequence number. */
749 if ((step
< 0 ? uhp
->uh_seq
<= curbuf
->b_u_seq_cur
750 : uhp
->uh_seq
> curbuf
->b_u_seq_cur
)
751 && ((dosec
&& val
== closest
)
753 ? uhp
->uh_seq
< closest_seq
754 : uhp
->uh_seq
> closest_seq
)
755 : closest
== closest_start
758 ? val
- target
<= closest
- target
759 : val
- target
<= target
- closest
)
761 ? target
- val
<= closest
- target
762 : target
- val
<= target
- closest
))))
765 closest_seq
= uhp
->uh_seq
;
769 /* Quit searching when we found a match. But when searching for a
770 * time we need to continue looking for the best uh_seq. */
771 if (target
== val
&& !dosec
)
774 /* go down in the tree if we haven't been there */
775 if (uhp
->uh_prev
!= NULL
&& uhp
->uh_prev
->uh_walk
!= nomark
776 && uhp
->uh_prev
->uh_walk
!= mark
)
779 /* go to alternate branch if we haven't been there */
780 else if (uhp
->uh_alt_next
!= NULL
781 && uhp
->uh_alt_next
->uh_walk
!= nomark
782 && uhp
->uh_alt_next
->uh_walk
!= mark
)
783 uhp
= uhp
->uh_alt_next
;
785 /* go up in the tree if we haven't been there and we are at the
786 * start of alternate branches */
787 else if (uhp
->uh_next
!= NULL
&& uhp
->uh_alt_prev
== NULL
788 && uhp
->uh_next
->uh_walk
!= nomark
789 && uhp
->uh_next
->uh_walk
!= mark
)
791 /* If still at the start we don't go through this change. */
792 if (uhp
== curbuf
->b_u_curhead
)
793 uhp
->uh_walk
= nomark
;
799 /* need to backtrack; mark this node as useless */
800 uhp
->uh_walk
= nomark
;
801 if (uhp
->uh_alt_prev
!= NULL
)
802 uhp
= uhp
->uh_alt_prev
;
808 if (uhp
!= NULL
) /* found it */
813 EMSGN(_("Undo number %ld not found"), step
);
817 if (closest
== closest_start
)
820 MSG(_("Already at oldest change"));
822 MSG(_("Already at newest change"));
826 target
= closest_seq
;
829 above
= TRUE
; /* stop above the header */
832 /* If we found it: Follow the path to go to where we want to be. */
836 * First go up the tree as much as needed.
840 uhp
= curbuf
->b_u_curhead
;
842 uhp
= curbuf
->b_u_newhead
;
845 if (uhp
== NULL
|| uhp
->uh_walk
!= mark
846 || (uhp
->uh_seq
== target
&& !above
))
848 curbuf
->b_u_curhead
= uhp
;
850 uhp
->uh_walk
= nomark
; /* don't go back down here */
854 * And now go down the tree (redo), branching off where needed.
856 uhp
= curbuf
->b_u_curhead
;
859 /* Find the last branch with a mark, that's the one. */
861 while (last
->uh_alt_next
!= NULL
862 && last
->uh_alt_next
->uh_walk
== mark
)
863 last
= last
->uh_alt_next
;
866 /* Make the used branch the first entry in the list of
867 * alternatives to make "u" and CTRL-R take this branch. */
868 if (last
->uh_alt_next
!= NULL
)
869 last
->uh_alt_next
->uh_alt_prev
= last
->uh_alt_prev
;
870 last
->uh_alt_prev
->uh_alt_next
= last
->uh_alt_next
;
871 last
->uh_alt_prev
= NULL
;
872 last
->uh_alt_next
= uhp
;
873 uhp
->uh_alt_prev
= last
;
876 if (uhp
->uh_next
!= NULL
)
877 uhp
->uh_next
->uh_prev
= uhp
;
879 curbuf
->b_u_curhead
= uhp
;
881 if (uhp
->uh_walk
!= mark
)
882 break; /* must have reached the target */
884 /* Stop when going backwards in time and didn't find the exact
885 * header we were looking for. */
886 if (uhp
->uh_seq
== target
&& above
)
888 curbuf
->b_u_seq_cur
= target
- 1;
894 /* Advance "curhead" to below the header we last used. If it
895 * becomes NULL then we need to set "newhead" to this leaf. */
896 if (uhp
->uh_prev
== NULL
)
897 curbuf
->b_u_newhead
= uhp
;
898 curbuf
->b_u_curhead
= uhp
->uh_prev
;
901 if (uhp
->uh_seq
== target
) /* found it! */
905 if (uhp
== NULL
|| uhp
->uh_walk
!= mark
)
907 /* Need to redo more but can't find it... */
908 EMSG2(_(e_intern2
), "undo_time()");
913 u_undo_end(did_undo
, absolute
);
917 * u_undoredo: common code for undo and redo
919 * The lines in the file are replaced by the lines in the entry list at
920 * curbuf->b_u_curhead. The replaced lines in the file are saved in the entry
921 * list for the next undo/redo.
923 * When "undo" is TRUE we go up in the tree, when FALSE we go down.
929 char_u
**newarray
= NULL
;
934 linenr_T newlnum
= MAXLNUM
;
936 u_entry_T
*uep
, *nuep
;
937 u_entry_T
*newlist
= NULL
;
940 pos_T namedm
[NMARKS
];
942 visualinfo_T visualinfo
;
944 int empty_buffer
; /* buffer became empty */
945 u_header_T
*curhead
= curbuf
->b_u_curhead
;
947 old_flags
= curhead
->uh_flags
;
948 new_flags
= (curbuf
->b_changed
? UH_CHANGED
: 0) +
949 ((curbuf
->b_ml
.ml_flags
& ML_EMPTY
) ? UH_EMPTYBUF
: 0);
953 * save marks before undo/redo
955 mch_memmove(namedm
, curbuf
->b_namedm
, sizeof(pos_T
) * NMARKS
);
957 visualinfo
= curbuf
->b_visual
;
959 curbuf
->b_op_start
.lnum
= curbuf
->b_ml
.ml_line_count
;
960 curbuf
->b_op_start
.col
= 0;
961 curbuf
->b_op_end
.lnum
= 0;
962 curbuf
->b_op_end
.col
= 0;
964 for (uep
= curhead
->uh_entry
; uep
!= NULL
; uep
= nuep
)
969 bot
= curbuf
->b_ml
.ml_line_count
+ 1;
970 if (top
> curbuf
->b_ml
.ml_line_count
|| top
>= bot
971 || bot
> curbuf
->b_ml
.ml_line_count
+ 1)
973 EMSG(_("E438: u_undo: line numbers wrong"));
974 changed(); /* don't want UNCHANGED now */
978 oldsize
= bot
- top
- 1; /* number of lines before undo */
979 newsize
= uep
->ue_size
; /* number of lines after undo */
983 /* If the saved cursor is somewhere in this undo block, move it to
984 * the remembered position. Makes "gwap" put the cursor back
986 lnum
= curhead
->uh_cursor
.lnum
;
987 if (lnum
>= top
&& lnum
<= top
+ newsize
+ 1)
989 curwin
->w_cursor
= curhead
->uh_cursor
;
990 newlnum
= curwin
->w_cursor
.lnum
- 1;
994 /* Use the first line that actually changed. Avoids that
995 * undoing auto-formatting puts the cursor in the previous
997 for (i
= 0; i
< newsize
&& i
< oldsize
; ++i
)
998 if (STRCMP(uep
->ue_array
[i
], ml_get(top
+ 1 + i
)) != 0)
1000 if (i
== newsize
&& newlnum
== MAXLNUM
&& uep
->ue_next
== NULL
)
1003 curwin
->w_cursor
.lnum
= newlnum
+ 1;
1005 else if (i
< newsize
)
1008 curwin
->w_cursor
.lnum
= newlnum
+ 1;
1013 empty_buffer
= FALSE
;
1015 /* delete the lines between top and bot and save them in newarray */
1018 if ((newarray
= (char_u
**)U_ALLOC_LINE(
1019 (unsigned)(sizeof(char_u
*) * oldsize
))) == NULL
)
1021 do_outofmem_msg((long_u
)(sizeof(char_u
*) * oldsize
));
1023 * We have messed up the entry list, repair is impossible.
1024 * we have to free the rest of the list.
1028 nuep
= uep
->ue_next
;
1029 u_freeentry(uep
, uep
->ue_size
);
1034 /* delete backwards, it goes faster in most cases */
1035 for (lnum
= bot
- 1, i
= oldsize
; --i
>= 0; --lnum
)
1037 /* what can we do when we run out of memory? */
1038 if ((newarray
[i
] = u_save_line(lnum
)) == NULL
)
1039 do_outofmem_msg((long_u
)0);
1040 /* remember we deleted the last line in the buffer, and a
1041 * dummy empty line will be inserted */
1042 if (curbuf
->b_ml
.ml_line_count
== 1)
1043 empty_buffer
= TRUE
;
1044 ml_delete(lnum
, FALSE
);
1050 /* insert the lines in u_array between top and bot */
1053 for (lnum
= top
, i
= 0; i
< newsize
; ++i
, ++lnum
)
1056 * If the file is empty, there is an empty line 1 that we
1057 * should get rid of, by replacing it with the new line
1059 if (empty_buffer
&& lnum
== 0)
1060 ml_replace((linenr_T
)1, uep
->ue_array
[i
], TRUE
);
1062 ml_append(lnum
, uep
->ue_array
[i
], (colnr_T
)0, FALSE
);
1063 U_FREE_LINE(uep
->ue_array
[i
]);
1065 U_FREE_LINE((char_u
*)uep
->ue_array
);
1069 if (oldsize
!= newsize
)
1071 mark_adjust(top
+ 1, top
+ oldsize
, (long)MAXLNUM
,
1072 (long)newsize
- (long)oldsize
);
1073 if (curbuf
->b_op_start
.lnum
> top
+ oldsize
)
1074 curbuf
->b_op_start
.lnum
+= newsize
- oldsize
;
1075 if (curbuf
->b_op_end
.lnum
> top
+ oldsize
)
1076 curbuf
->b_op_end
.lnum
+= newsize
- oldsize
;
1079 changed_lines(top
+ 1, 0, bot
, newsize
- oldsize
);
1081 /* set '[ and '] mark */
1082 if (top
+ 1 < curbuf
->b_op_start
.lnum
)
1083 curbuf
->b_op_start
.lnum
= top
+ 1;
1084 if (newsize
== 0 && top
+ 1 > curbuf
->b_op_end
.lnum
)
1085 curbuf
->b_op_end
.lnum
= top
+ 1;
1086 else if (top
+ newsize
> curbuf
->b_op_end
.lnum
)
1087 curbuf
->b_op_end
.lnum
= top
+ newsize
;
1089 u_newcount
+= newsize
;
1090 u_oldcount
+= oldsize
;
1091 uep
->ue_size
= oldsize
;
1092 uep
->ue_array
= newarray
;
1093 uep
->ue_bot
= top
+ newsize
+ 1;
1096 * insert this entry in front of the new entry list
1098 nuep
= uep
->ue_next
;
1099 uep
->ue_next
= newlist
;
1103 curhead
->uh_entry
= newlist
;
1104 curhead
->uh_flags
= new_flags
;
1105 if ((old_flags
& UH_EMPTYBUF
) && bufempty())
1106 curbuf
->b_ml
.ml_flags
|= ML_EMPTY
;
1107 if (old_flags
& UH_CHANGED
)
1110 #ifdef FEAT_NETBEANS_INTG
1111 /* per netbeans undo rules, keep it as modified */
1112 if (!isNetbeansModified(curbuf
))
1114 unchanged(curbuf
, FALSE
);
1117 * restore marks from before undo/redo
1119 for (i
= 0; i
< NMARKS
; ++i
)
1120 if (curhead
->uh_namedm
[i
].lnum
!= 0)
1122 curbuf
->b_namedm
[i
] = curhead
->uh_namedm
[i
];
1123 curhead
->uh_namedm
[i
] = namedm
[i
];
1126 if (curhead
->uh_visual
.vi_start
.lnum
!= 0)
1128 curbuf
->b_visual
= curhead
->uh_visual
;
1129 curhead
->uh_visual
= visualinfo
;
1134 * If the cursor is only off by one line, put it at the same position as
1135 * before starting the change (for the "o" command).
1136 * Otherwise the cursor should go to the first undone line.
1138 if (curhead
->uh_cursor
.lnum
+ 1 == curwin
->w_cursor
.lnum
1139 && curwin
->w_cursor
.lnum
> 1)
1140 --curwin
->w_cursor
.lnum
;
1141 if (curhead
->uh_cursor
.lnum
== curwin
->w_cursor
.lnum
)
1143 curwin
->w_cursor
.col
= curhead
->uh_cursor
.col
;
1144 #ifdef FEAT_VIRTUALEDIT
1145 if (virtual_active() && curhead
->uh_cursor_vcol
>= 0)
1146 coladvance((colnr_T
)curhead
->uh_cursor_vcol
);
1148 curwin
->w_cursor
.coladd
= 0;
1151 else if (curwin
->w_cursor
.lnum
<= curbuf
->b_ml
.ml_line_count
)
1152 beginline(BL_SOL
| BL_FIX
);
1155 /* We get here with the current cursor line being past the end (eg
1156 * after adding lines at the end of the file, and then undoing it).
1157 * check_cursor() will move the cursor to the last line. Move it to
1158 * the first column here. */
1159 curwin
->w_cursor
.col
= 0;
1160 #ifdef FEAT_VIRTUALEDIT
1161 curwin
->w_cursor
.coladd
= 0;
1165 /* Make sure the cursor is on an existing line and column. */
1168 /* Remember where we are for "g-" and ":earlier 10s". */
1169 curbuf
->b_u_seq_cur
= curhead
->uh_seq
;
1171 /* We are below the previous undo. However, to make ":earlier 1s"
1172 * work we compute this as being just above the just undone change. */
1173 --curbuf
->b_u_seq_cur
;
1175 /* The timestamp can be the same for multiple changes, just use the one of
1176 * the undone/redone change. */
1177 curbuf
->b_u_seq_time
= curhead
->uh_time
;
1181 * If we deleted or added lines, report the number of less/more lines.
1182 * Otherwise, report the number of changes (this may be incorrect
1183 * in some cases, but it's better than nothing).
1186 u_undo_end(did_undo
, absolute
)
1187 int did_undo
; /* just did an undo */
1188 int absolute
; /* used ":undo N" */
1195 if ((fdo_flags
& FDO_UNDO
) && KeyTyped
)
1199 if (global_busy
/* no messages now, wait until global is finished */
1200 || !messaging()) /* 'lazyredraw' set, don't do messages now */
1203 if (curbuf
->b_ml
.ml_flags
& ML_EMPTY
)
1206 u_oldcount
-= u_newcount
;
1207 if (u_oldcount
== -1)
1208 msgstr
= N_("more line");
1209 else if (u_oldcount
< 0)
1210 msgstr
= N_("more lines");
1211 else if (u_oldcount
== 1)
1212 msgstr
= N_("line less");
1213 else if (u_oldcount
> 1)
1214 msgstr
= N_("fewer lines");
1217 u_oldcount
= u_newcount
;
1218 if (u_newcount
== 1)
1219 msgstr
= N_("change");
1221 msgstr
= N_("changes");
1224 if (curbuf
->b_u_curhead
!= NULL
)
1226 /* For ":undo N" we prefer a "after #N" message. */
1227 if (absolute
&& curbuf
->b_u_curhead
->uh_next
!= NULL
)
1229 uhp
= curbuf
->b_u_curhead
->uh_next
;
1233 uhp
= curbuf
->b_u_curhead
;
1235 uhp
= curbuf
->b_u_curhead
->uh_next
;
1238 uhp
= curbuf
->b_u_newhead
;
1243 u_add_time(msgbuf
, sizeof(msgbuf
), uhp
->uh_time
);
1245 smsg((char_u
*)_("%ld %s; %s #%ld %s"),
1246 u_oldcount
< 0 ? -u_oldcount
: u_oldcount
,
1248 did_undo
? _("before") : _("after"),
1249 uhp
== NULL
? 0L : uhp
->uh_seq
,
1254 * u_sync: stop adding to the current entry list
1258 int force
; /* Also sync when no_u_sync is set. */
1260 /* Skip it when already synced or syncing is disabled. */
1261 if (curbuf
->b_u_synced
|| (!force
&& no_u_sync
> 0))
1263 #if defined(FEAT_XIM) && defined(FEAT_GUI_GTK)
1264 if (im_is_preediting())
1265 return; /* XIM is busy, don't break an undo sequence */
1268 curbuf
->b_u_synced
= TRUE
; /* no entries, nothing to do */
1271 u_getbot(); /* compute ue_bot of previous u_save */
1272 curbuf
->b_u_curhead
= NULL
;
1277 * ":undolist": List the leafs of the undo tree
1292 * 1: walk the tree to find all leafs, put the info in "ga".
1294 * 3: display the list
1297 nomark
= ++lastmark
;
1298 ga_init2(&ga
, (int)sizeof(char *), 20);
1300 uhp
= curbuf
->b_u_oldhead
;
1303 if (uhp
->uh_prev
== NULL
&& uhp
->uh_walk
!= nomark
1304 && uhp
->uh_walk
!= mark
)
1306 if (ga_grow(&ga
, 1) == FAIL
)
1308 vim_snprintf((char *)IObuff
, IOSIZE
, "%6ld %7ld ",
1309 uhp
->uh_seq
, changes
);
1310 u_add_time(IObuff
+ STRLEN(IObuff
), IOSIZE
- STRLEN(IObuff
),
1312 ((char_u
**)(ga
.ga_data
))[ga
.ga_len
++] = vim_strsave(IObuff
);
1315 uhp
->uh_walk
= mark
;
1317 /* go down in the tree if we haven't been there */
1318 if (uhp
->uh_prev
!= NULL
&& uhp
->uh_prev
->uh_walk
!= nomark
1319 && uhp
->uh_prev
->uh_walk
!= mark
)
1325 /* go to alternate branch if we haven't been there */
1326 else if (uhp
->uh_alt_next
!= NULL
1327 && uhp
->uh_alt_next
->uh_walk
!= nomark
1328 && uhp
->uh_alt_next
->uh_walk
!= mark
)
1329 uhp
= uhp
->uh_alt_next
;
1331 /* go up in the tree if we haven't been there and we are at the
1332 * start of alternate branches */
1333 else if (uhp
->uh_next
!= NULL
&& uhp
->uh_alt_prev
== NULL
1334 && uhp
->uh_next
->uh_walk
!= nomark
1335 && uhp
->uh_next
->uh_walk
!= mark
)
1343 /* need to backtrack; mark this node as done */
1344 uhp
->uh_walk
= nomark
;
1345 if (uhp
->uh_alt_prev
!= NULL
)
1346 uhp
= uhp
->uh_alt_prev
;
1356 MSG(_("Nothing to undo"));
1359 sort_strings((char_u
**)ga
.ga_data
, ga
.ga_len
);
1362 msg_puts_attr((char_u
*)_("number changes time"), hl_attr(HLF_T
));
1363 for (i
= 0; i
< ga
.ga_len
&& !got_int
; ++i
)
1368 msg_puts(((char_u
**)ga
.ga_data
)[i
]);
1372 ga_clear_strings(&ga
);
1377 * Put the timestamp of an undo header in "buf[buflen]" in a nice format.
1380 u_add_time(buf
, buflen
, tt
)
1385 #ifdef HAVE_STRFTIME
1388 if (time(NULL
) - tt
>= 100)
1390 curtime
= localtime(&tt
);
1391 (void)strftime((char *)buf
, buflen
, "%H:%M:%S", curtime
);
1395 vim_snprintf((char *)buf
, buflen
, _("%ld seconds ago"),
1396 (long)(time(NULL
) - tt
));
1400 * ":undojoin": continue adding to the last entry list
1407 if (curbuf
->b_u_newhead
== NULL
)
1408 return; /* nothing changed before */
1409 if (curbuf
->b_u_curhead
!= NULL
)
1411 EMSG(_("E790: undojoin is not allowed after undo"));
1414 if (!curbuf
->b_u_synced
)
1415 return; /* already unsynced */
1417 return; /* no entries, nothing to do */
1420 /* Go back to the last entry */
1421 curbuf
->b_u_curhead
= curbuf
->b_u_newhead
;
1422 curbuf
->b_u_synced
= FALSE
; /* no entries, nothing to do */
1427 * Called after writing the file and setting b_changed to FALSE.
1428 * Now an undo means that the buffer is modified.
1434 u_unch_branch(buf
->b_u_oldhead
);
1435 buf
->b_did_warn
= FALSE
;
1444 for (uh
= uhp
; uh
!= NULL
; uh
= uh
->uh_prev
)
1446 uh
->uh_flags
|= UH_CHANGED
;
1447 if (uh
->uh_alt_next
!= NULL
)
1448 u_unch_branch(uh
->uh_alt_next
); /* recursive */
1453 * Get pointer to last added entry.
1454 * If it's not valid, give an error message and return NULL.
1459 if (curbuf
->b_u_newhead
== NULL
|| curbuf
->b_u_newhead
->uh_entry
== NULL
)
1461 EMSG(_("E439: undo list corrupt"));
1464 return curbuf
->b_u_newhead
->uh_entry
;
1468 * u_getbot(): compute the line number of the previous u_save
1469 * It is called only when b_u_synced is FALSE.
1477 uep
= u_get_headentry(); /* check for corrupt undo list */
1481 uep
= curbuf
->b_u_newhead
->uh_getbot_entry
;
1485 * the new ue_bot is computed from the number of lines that has been
1486 * inserted (0 - deleted) since calling u_save. This is equal to the
1487 * old line count subtracted from the current line count.
1489 extra
= curbuf
->b_ml
.ml_line_count
- uep
->ue_lcount
;
1490 uep
->ue_bot
= uep
->ue_top
+ uep
->ue_size
+ 1 + extra
;
1491 if (uep
->ue_bot
< 1 || uep
->ue_bot
> curbuf
->b_ml
.ml_line_count
)
1493 EMSG(_("E440: undo line missing"));
1494 uep
->ue_bot
= uep
->ue_top
+ 1; /* assume all lines deleted, will
1495 * get all the old lines back
1496 * without deleting the current
1500 curbuf
->b_u_newhead
->uh_getbot_entry
= NULL
;
1503 curbuf
->b_u_synced
= TRUE
;
1507 * Free one header and its entry list and adjust the pointers.
1510 u_freeheader(buf
, uhp
, uhpp
)
1513 u_header_T
**uhpp
; /* if not NULL reset when freeing this header */
1515 /* When there is an alternate redo list free that branch completely,
1516 * because we can never go there. */
1517 if (uhp
->uh_alt_next
!= NULL
)
1518 u_freebranch(buf
, uhp
->uh_alt_next
, uhpp
);
1520 if (uhp
->uh_alt_prev
!= NULL
)
1521 uhp
->uh_alt_prev
->uh_alt_next
= NULL
;
1523 /* Update the links in the list to remove the header. */
1524 if (uhp
->uh_next
== NULL
)
1525 buf
->b_u_oldhead
= uhp
->uh_prev
;
1527 uhp
->uh_next
->uh_prev
= uhp
->uh_prev
;
1529 if (uhp
->uh_prev
== NULL
)
1530 buf
->b_u_newhead
= uhp
->uh_next
;
1532 uhp
->uh_prev
->uh_next
= uhp
->uh_next
;
1534 u_freeentries(buf
, uhp
, uhpp
);
1538 * Free an alternate branch and any following alternate branches.
1541 u_freebranch(buf
, uhp
, uhpp
)
1544 u_header_T
**uhpp
; /* if not NULL reset when freeing this header */
1546 u_header_T
*tofree
, *next
;
1548 if (uhp
->uh_alt_prev
!= NULL
)
1549 uhp
->uh_alt_prev
->uh_alt_next
= NULL
;
1552 while (next
!= NULL
)
1555 if (tofree
->uh_alt_next
!= NULL
)
1556 u_freebranch(buf
, tofree
->uh_alt_next
, uhpp
); /* recursive */
1557 next
= tofree
->uh_prev
;
1558 u_freeentries(buf
, tofree
, uhpp
);
1563 * Free all the undo entries for one header and the header itself.
1564 * This means that "uhp" is invalid when returning.
1567 u_freeentries(buf
, uhp
, uhpp
)
1570 u_header_T
**uhpp
; /* if not NULL reset when freeing this header */
1572 u_entry_T
*uep
, *nuep
;
1574 /* Check for pointers to the header that become invalid now. */
1575 if (buf
->b_u_curhead
== uhp
)
1576 buf
->b_u_curhead
= NULL
;
1577 if (uhpp
!= NULL
&& uhp
== *uhpp
)
1580 for (uep
= uhp
->uh_entry
; uep
!= NULL
; uep
= nuep
)
1582 nuep
= uep
->ue_next
;
1583 u_freeentry(uep
, uep
->ue_size
);
1586 U_FREE_LINE((char_u
*)uhp
);
1591 * free entry 'uep' and 'n' lines in uep->ue_array[]
1599 U_FREE_LINE(uep
->ue_array
[--n
]);
1600 U_FREE_LINE((char_u
*)uep
->ue_array
);
1601 U_FREE_LINE((char_u
*)uep
);
1605 * invalidate the undo buffer; called when storage has already been released
1611 buf
->b_u_newhead
= buf
->b_u_oldhead
= buf
->b_u_curhead
= NULL
;
1612 buf
->b_u_synced
= TRUE
;
1613 buf
->b_u_numhead
= 0;
1614 buf
->b_u_line_ptr
= NULL
;
1615 buf
->b_u_line_lnum
= 0;
1619 * save the line "lnum" for the "U" command
1625 if (lnum
== curbuf
->b_u_line_lnum
) /* line is already saved */
1627 if (lnum
< 1 || lnum
> curbuf
->b_ml
.ml_line_count
) /* should never happen */
1630 curbuf
->b_u_line_lnum
= lnum
;
1631 if (curwin
->w_cursor
.lnum
== lnum
)
1632 curbuf
->b_u_line_colnr
= curwin
->w_cursor
.col
;
1634 curbuf
->b_u_line_colnr
= 0;
1635 if ((curbuf
->b_u_line_ptr
= u_save_line(lnum
)) == NULL
)
1636 do_outofmem_msg((long_u
)0);
1640 * clear the line saved for the "U" command
1641 * (this is used externally for crossing a line while in insert mode)
1646 if (curbuf
->b_u_line_ptr
!= NULL
)
1648 U_FREE_LINE(curbuf
->b_u_line_ptr
);
1649 curbuf
->b_u_line_ptr
= NULL
;
1650 curbuf
->b_u_line_lnum
= 0;
1655 * Implementation of the "U" command.
1656 * Differentiation from vi: "U" can be undone with the next "U".
1657 * We also allow the cursor to be in another line.
1668 if (curbuf
->b_u_line_ptr
== NULL
||
1669 curbuf
->b_u_line_lnum
> curbuf
->b_ml
.ml_line_count
)
1674 /* first save the line for the 'u' command */
1675 if (u_savecommon(curbuf
->b_u_line_lnum
- 1,
1676 curbuf
->b_u_line_lnum
+ 1, (linenr_T
)0) == FAIL
)
1678 oldp
= u_save_line(curbuf
->b_u_line_lnum
);
1681 do_outofmem_msg((long_u
)0);
1684 ml_replace(curbuf
->b_u_line_lnum
, curbuf
->b_u_line_ptr
, TRUE
);
1685 changed_bytes(curbuf
->b_u_line_lnum
, 0);
1686 U_FREE_LINE(curbuf
->b_u_line_ptr
);
1687 curbuf
->b_u_line_ptr
= oldp
;
1689 t
= curbuf
->b_u_line_colnr
;
1690 if (curwin
->w_cursor
.lnum
== curbuf
->b_u_line_lnum
)
1691 curbuf
->b_u_line_colnr
= curwin
->w_cursor
.col
;
1692 curwin
->w_cursor
.col
= t
;
1693 curwin
->w_cursor
.lnum
= curbuf
->b_u_line_lnum
;
1697 * There are two implementations of the memory management for undo:
1698 * 1. Use the standard malloc()/free() functions.
1699 * This should be fast for allocating memory, but when a buffer is
1700 * abandoned every single allocated chunk must be freed, which may be slow.
1701 * 2. Allocate larger blocks of memory and keep track of chunks ourselves.
1702 * This is fast for abandoning, but the use of linked lists is slow for
1703 * finding a free chunk. Esp. when a lot of lines are changed or deleted.
1704 * A bit of profiling showed that the first method is faster, especially when
1705 * making a large number of changes, under the condition that malloc()/free()
1706 * is implemented efficiently.
1710 * Version of undo memory allocation using malloc()/free()
1712 * U_FREE_LINE() and U_ALLOC_LINE() are macros that invoke vim_free() and
1713 * lalloc() directly.
1717 * Free all allocated memory blocks for the buffer 'buf'.
1723 while (buf
->b_u_oldhead
!= NULL
)
1724 u_freeheader(buf
, buf
->b_u_oldhead
, NULL
);
1725 U_FREE_LINE(buf
->b_u_line_ptr
);
1730 * Storage allocation for the undo lines and blocks of the current file.
1731 * Version where Vim keeps track of the available memory.
1735 * Memory is allocated in relatively large blocks. These blocks are linked
1736 * in the allocated block list, headed by curbuf->b_block_head. They are all
1737 * freed when abandoning a file, so we don't have to free every single line.
1738 * The list is kept sorted on memory address.
1739 * block_alloc() allocates a block.
1740 * m_blockfree() frees all blocks.
1742 * The available chunks of memory are kept in free chunk lists. There is
1743 * one free list for each block of allocated memory. The list is kept sorted
1744 * on memory address.
1745 * u_alloc_line() gets a chunk from the free lists.
1746 * u_free_line() returns a chunk to the free lists.
1747 * curbuf->b_m_search points to the chunk before the chunk that was
1748 * freed/allocated the last time.
1749 * curbuf->b_mb_current points to the b_head where curbuf->b_m_search
1750 * points into the free list.
1753 * b_block_head /---> block #1 /---> block #2
1754 * mb_next ---/ mb_next ---/ mb_next ---> NULL
1755 * mb_info mb_info mb_info
1758 * NULL free chunk #1.1 free chunk #2.1
1761 * free chunk #1.2 NULL
1766 * When a single free chunk list would have been used, it could take a lot
1767 * of time in u_free_line() to find the correct place to insert a chunk in the
1768 * free list. The single free list would become very long when many lines are
1769 * changed (e.g. with :%s/^M$//).
1773 * this blocksize is used when allocating new lines
1775 #define MEMBLOCKSIZE 2044
1778 * The size field contains the size of the chunk, including the size field
1781 * When the chunk is not in-use it is preceded with the m_info structure.
1782 * The m_next field links it in one of the free chunk lists.
1784 * On most unix systems structures have to be longword (32 or 64 bit) aligned.
1785 * On most other systems they are short (16 bit) aligned.
1788 /* the structure definitions are now in structs.h */
1791 /* size of m_size */
1792 # define M_OFFSET (sizeof(long_u))
1794 /* size of m_size */
1795 # define M_OFFSET (sizeof(short_u))
1798 static char_u
*u_blockalloc
__ARGS((long_u
));
1801 * Allocate a block of memory and link it in the allocated block list.
1808 mblock_T
*mp
, *next
;
1810 p
= (mblock_T
*)lalloc(size
+ sizeof(mblock_T
), FALSE
);
1813 /* Insert the block into the allocated block list, keeping it
1814 sorted on address. */
1815 for (mp
= &curbuf
->b_block_head
;
1816 (next
= mp
->mb_next
) != NULL
&& next
< p
;
1819 p
->mb_next
= next
; /* link in block list */
1821 p
->mb_maxsize
= 0; /* nothing free yet */
1823 p
->mb_info
.m_next
= NULL
; /* clear free list */
1824 p
->mb_info
.m_size
= 0;
1825 curbuf
->b_mb_current
= p
; /* remember current block */
1826 curbuf
->b_m_search
= NULL
;
1827 p
++; /* return usable memory */
1833 * free all allocated memory blocks for the buffer 'buf'
1841 for (p
= buf
->b_block_head
.mb_next
; p
!= NULL
; p
= np
)
1846 buf
->b_block_head
.mb_next
= NULL
;
1847 buf
->b_m_search
= NULL
;
1848 buf
->b_mb_current
= NULL
;
1852 * Free a chunk of memory for the current buffer.
1853 * Insert the chunk into the correct free list, keeping it sorted on address.
1856 u_free_line(ptr
, keep
)
1858 int keep
; /* don't free the block when it's empty */
1861 minfo_T
*prev
, *curr
;
1867 if (ptr
== NULL
|| ptr
== IObuff
)
1868 return; /* illegal address can happen in out-of-memory situations */
1870 mp
= (minfo_T
*)(ptr
- M_OFFSET
);
1872 /* find block where chunk could be a part off */
1873 /* if we change curbuf->b_mb_current, curbuf->b_m_search is set to NULL */
1874 if (curbuf
->b_mb_current
== NULL
|| mp
< (minfo_T
*)curbuf
->b_mb_current
)
1876 curbuf
->b_mb_current
= curbuf
->b_block_head
.mb_next
;
1877 curbuf
->b_m_search
= NULL
;
1879 if ((nextb
= curbuf
->b_mb_current
->mb_next
) != NULL
1880 && (minfo_T
*)nextb
< mp
)
1882 curbuf
->b_mb_current
= nextb
;
1883 curbuf
->b_m_search
= NULL
;
1885 while ((nextb
= curbuf
->b_mb_current
->mb_next
) != NULL
1886 && (minfo_T
*)nextb
< mp
)
1887 curbuf
->b_mb_current
= nextb
;
1891 * If mp is smaller than curbuf->b_m_search->m_next go to the start of
1894 if (curbuf
->b_m_search
== NULL
|| mp
< (curbuf
->b_m_search
->m_next
))
1895 next
= &(curbuf
->b_mb_current
->mb_info
);
1897 next
= curbuf
->b_m_search
;
1899 * The following loop is executed very often.
1900 * Therefore it has been optimized at the cost of readability.
1903 #ifdef SLOW_BUT_EASY_TO_READ
1908 next
= next
->m_next
;
1910 while (mp
> next
&& next
!= NULL
);
1912 do /* first, middle, last */
1914 prev
= next
->m_next
; /* curr, next, prev */
1915 if (prev
== NULL
|| mp
<= prev
)
1919 next
= next
->m_next
;
1922 curr
= prev
->m_next
; /* next, prev, curr */
1923 if (curr
== NULL
|| mp
<= curr
)
1926 curr
= prev
->m_next
;
1927 next
= curr
->m_next
;
1930 next
= curr
->m_next
; /* prev, curr, next */
1932 while (mp
> next
&& next
!= NULL
);
1935 /* if *mp and *next are concatenated, join them into one chunk */
1936 if ((char_u
*)mp
+ mp
->m_size
== (char_u
*)next
)
1938 mp
->m_size
+= next
->m_size
;
1939 mp
->m_next
= next
->m_next
;
1943 maxsize
= mp
->m_size
;
1945 /* if *curr and *mp are concatenated, join them */
1946 if (prev
!= NULL
&& (char_u
*)curr
+ curr
->m_size
== (char_u
*)mp
)
1948 curr
->m_size
+= mp
->m_size
;
1949 maxsize
= curr
->m_size
;
1950 curr
->m_next
= mp
->m_next
;
1951 curbuf
->b_m_search
= prev
;
1956 curbuf
->b_m_search
= curr
; /* put curbuf->b_m_search before freed
1961 * If the block only containes free memory now, release it.
1963 if (!keep
&& curbuf
->b_mb_current
->mb_size
1964 == curbuf
->b_mb_current
->mb_info
.m_next
->m_size
)
1966 /* Find the block before the current one to be able to unlink it from
1967 * the list of blocks. */
1968 prevb
= &curbuf
->b_block_head
;
1969 for (nextb
= prevb
->mb_next
; nextb
!= curbuf
->b_mb_current
;
1970 nextb
= nextb
->mb_next
)
1972 prevb
->mb_next
= nextb
->mb_next
;
1974 curbuf
->b_mb_current
= NULL
;
1975 curbuf
->b_m_search
= NULL
;
1977 else if (curbuf
->b_mb_current
->mb_maxsize
< maxsize
)
1978 curbuf
->b_mb_current
->mb_maxsize
= maxsize
;
1982 * Allocate and initialize a new line structure with room for at least
1983 * 'size' characters plus a terminating NUL.
1989 minfo_T
*mp
, *mprev
, *mp2
;
1994 * Add room for size field and trailing NUL byte.
1995 * Adjust for minimal size (must be able to store minfo_T
1996 * plus a trailing NUL, so the chunk can be released again)
1998 size
+= M_OFFSET
+ 1;
1999 if (size
< sizeof(minfo_T
) + 1)
2000 size
= sizeof(minfo_T
) + 1;
2003 * round size up for alignment
2005 size_align
= (size
+ ALIGN_MASK
) & ~ALIGN_MASK
;
2008 * If curbuf->b_m_search is NULL (uninitialized free list) start at
2009 * curbuf->b_block_head
2011 if (curbuf
->b_mb_current
== NULL
|| curbuf
->b_m_search
== NULL
)
2013 curbuf
->b_mb_current
= &curbuf
->b_block_head
;
2014 curbuf
->b_m_search
= &(curbuf
->b_block_head
.mb_info
);
2017 /* Search for a block with enough space. */
2018 mbp
= curbuf
->b_mb_current
;
2019 while (mbp
->mb_maxsize
< size_align
)
2021 if (mbp
->mb_next
!= NULL
)
2024 mbp
= &curbuf
->b_block_head
;
2025 if (mbp
== curbuf
->b_mb_current
)
2027 int n
= (size_align
> (MEMBLOCKSIZE
/ 4)
2028 ? size_align
: MEMBLOCKSIZE
);
2030 /* Back where we started in block list: need to add a new block
2031 * with enough space. */
2032 mp
= (minfo_T
*)u_blockalloc((long_u
)n
);
2036 u_free_line((char_u
*)mp
+ M_OFFSET
, TRUE
);
2037 mbp
= curbuf
->b_mb_current
;
2041 if (mbp
!= curbuf
->b_mb_current
)
2042 curbuf
->b_m_search
= &(mbp
->mb_info
);
2044 /* In this block find a chunk with enough space. */
2045 mprev
= curbuf
->b_m_search
;
2046 mp
= curbuf
->b_m_search
->m_next
;
2049 if (mp
== NULL
) /* at end of the list */
2050 mp
= &(mbp
->mb_info
); /* wrap around to begin */
2051 if (mp
->m_size
>= size
)
2053 if (mp
== curbuf
->b_m_search
)
2055 /* back where we started in free chunk list: "cannot happen" */
2056 EMSG2(_(e_intern2
), "u_alloc_line()");
2063 /* when using the largest chunk adjust mb_maxsize */
2064 if (mp
->m_size
>= mbp
->mb_maxsize
)
2065 mbp
->mb_maxsize
= 0;
2067 /* if the chunk we found is large enough, split it up in two */
2068 if ((long)mp
->m_size
- size_align
>= (long)(sizeof(minfo_T
) + 1))
2070 mp2
= (minfo_T
*)((char_u
*)mp
+ size_align
);
2071 mp2
->m_size
= mp
->m_size
- size_align
;
2072 mp2
->m_next
= mp
->m_next
;
2073 mprev
->m_next
= mp2
;
2074 mp
->m_size
= size_align
;
2076 else /* remove *mp from the free list */
2078 mprev
->m_next
= mp
->m_next
;
2080 curbuf
->b_m_search
= mprev
;
2081 curbuf
->b_mb_current
= mbp
;
2083 /* If using the largest chunk need to find the new largest chunk */
2084 if (mbp
->mb_maxsize
== 0)
2085 for (mp2
= &(mbp
->mb_info
); mp2
!= NULL
; mp2
= mp2
->m_next
)
2086 if (mbp
->mb_maxsize
< mp2
->m_size
)
2087 mbp
->mb_maxsize
= mp2
->m_size
;
2089 mp
= (minfo_T
*)((char_u
*)mp
+ M_OFFSET
);
2090 *(char_u
*)mp
= NUL
; /* set the first byte to NUL */
2092 return ((char_u
*)mp
);
2097 * u_save_line(): allocate memory with u_alloc_line() and copy line 'lnum'
2109 len
= (unsigned)STRLEN(src
);
2110 if ((dst
= U_ALLOC_LINE(len
)) != NULL
)
2111 mch_memmove(dst
, src
, (size_t)(len
+ 1));
2116 * Check if the 'modified' flag is set, or 'ff' has changed (only need to
2117 * check the first character, because it can only be "dos", "unix" or "mac").
2118 * "nofile" and "scratch" type buffers are considered to always be unchanged.
2125 #ifdef FEAT_QUICKFIX
2126 !bt_dontwrite(buf
) &&
2128 (buf
->b_changed
|| file_ff_differs(buf
));
2135 #ifdef FEAT_QUICKFIX
2136 !bt_dontwrite(curbuf
) &&
2138 (curbuf
->b_changed
|| file_ff_differs(curbuf
));