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 /* #define CHECK(c, s) if (c) EMSG(s) */
15 * memline.c: Contains the functions for appending, deleting and changing the
16 * text lines. The memfile functions are used to store the information in
17 * blocks of memory, backed up by a file. The structure of the information is
18 * a tree. The root of the tree is a pointer block. The leaves of the tree
19 * are data blocks. In between may be several layers of pointer blocks,
22 * Three types of blocks are used:
23 * - Block nr 0 contains information for recovery
24 * - Pointer blocks contain list of pointers to other blocks.
25 * - Data blocks contain the actual text.
27 * Block nr 0 contains the block0 structure (see below).
29 * Block nr 1 is the first pointer block. It is the root of the tree.
30 * Other pointer blocks are branches.
32 * If a line is too big to fit in a single page, the block containing that
33 * line is made big enough to hold the line. It may span several pages.
34 * Otherwise all blocks are one page.
36 * A data block that was filled when starting to edit a file and was not
37 * changed since then, can have a negative block number. This means that it
38 * has not yet been assigned a place in the file. When recovering, the lines
39 * in this data block can be read from the original file. When the block is
40 * changed (lines appended/deleted/changed) or when it is flushed it gets a
41 * positive number. Use mf_trans_del() to get the new number, before calling
45 #if defined(MSDOS) || defined(WIN16) || defined(WIN32) || defined(_WIN64)
46 # include "vimio.h" /* for mch_open(), must be before vim.h */
51 #ifndef UNIX /* it's in os_unix.h for Unix */
55 #if defined(SASC) || defined(__amigaos4__)
56 # include <proto/dos.h> /* for Open() and Close() */
63 typedef struct block0 ZERO_BL
; /* contents of the first block */
64 typedef struct pointer_block PTR_BL
; /* contents of a pointer block */
65 typedef struct data_block DATA_BL
; /* contents of a data block */
66 typedef struct pointer_entry PTR_EN
; /* block/line-count pair */
68 #define DATA_ID (('d' << 8) + 'a') /* data block id */
69 #define PTR_ID (('p' << 8) + 't') /* pointer block id */
70 #define BLOCK0_ID0 'b' /* block 0 id 0 */
71 #define BLOCK0_ID1 '0' /* block 0 id 1 */
74 * pointer to a block, used in a pointer block
78 blocknr_T pe_bnum
; /* block number */
79 linenr_T pe_line_count
; /* number of lines in this branch */
80 linenr_T pe_old_lnum
; /* lnum for this block (for recovery) */
81 int pe_page_count
; /* number of pages in block pe_bnum */
85 * A pointer block contains a list of branches in the tree.
89 short_u pb_id
; /* ID for pointer block: PTR_ID */
90 short_u pb_count
; /* number of pointer in this block */
91 short_u pb_count_max
; /* maximum value for pb_count */
92 PTR_EN pb_pointer
[1]; /* list of pointers to blocks (actually longer)
93 * followed by empty space until end of page */
97 * A data block is a leaf in the tree.
99 * The text of the lines is at the end of the block. The text of the first line
100 * in the block is put at the end, the text of the second line in front of it,
101 * etc. Thus the order of the lines is the opposite of the line number.
105 short_u db_id
; /* ID for data block: DATA_ID */
106 unsigned db_free
; /* free space available */
107 unsigned db_txt_start
; /* byte where text starts */
108 unsigned db_txt_end
; /* byte just after data block */
109 linenr_T db_line_count
; /* number of lines in this block */
110 unsigned db_index
[1]; /* index for start of line (actually bigger)
111 * followed by empty space upto db_txt_start
112 * followed by the text in the lines until
117 * The low bits of db_index hold the actual index. The topmost bit is
118 * used for the global command to be able to mark a line.
119 * This method is not clean, but otherwise there would be at least one extra
120 * byte used for each line.
121 * The mark has to be in this place to keep it with the correct line when other
122 * lines are inserted or deleted.
124 #define DB_MARKED ((unsigned)1 << ((sizeof(unsigned) * 8) - 1))
125 #define DB_INDEX_MASK (~DB_MARKED)
127 #define INDEX_SIZE (sizeof(unsigned)) /* size of one db_index entry */
128 #define HEADER_SIZE (sizeof(DATA_BL) - INDEX_SIZE) /* size of data block header */
130 #define B0_FNAME_SIZE_ORG 900 /* what it was in older versions */
131 #define B0_FNAME_SIZE 898
132 #define B0_UNAME_SIZE 40
133 #define B0_HNAME_SIZE 40
135 * Restrict the numbers to 32 bits, otherwise most compilers will complain.
136 * This won't detect a 64 bit machine that only swaps a byte in the top 32
137 * bits, but that is crazy anyway.
139 #define B0_MAGIC_LONG 0x30313233L
140 #define B0_MAGIC_INT 0x20212223L
141 #define B0_MAGIC_SHORT 0x10111213L
142 #define B0_MAGIC_CHAR 0x55
145 * Block zero holds all info about the swap file.
147 * NOTE: DEFINITION OF BLOCK 0 SHOULD NOT CHANGE! It would make all existing
148 * swap files unusable!
150 * If size of block0 changes anyway, adjust MIN_SWAP_PAGE_SIZE in vim.h!!
152 * This block is built up of single bytes, to make it portable across
153 * different machines. b0_magic_* is used to check the byte order and size of
154 * variables, because the rest of the swap file is not portable.
158 char_u b0_id
[2]; /* id for block 0: BLOCK0_ID0 and BLOCK0_ID1 */
159 char_u b0_version
[10]; /* Vim version string */
160 char_u b0_page_size
[4];/* number of bytes per page */
161 char_u b0_mtime
[4]; /* last modification time of file */
162 char_u b0_ino
[4]; /* inode of b0_fname */
163 char_u b0_pid
[4]; /* process id of creator (or 0) */
164 char_u b0_uname
[B0_UNAME_SIZE
]; /* name of user (uid if no name) */
165 char_u b0_hname
[B0_HNAME_SIZE
]; /* host name (if it has a name) */
166 char_u b0_fname
[B0_FNAME_SIZE_ORG
]; /* name of file being edited */
167 long b0_magic_long
; /* check for byte order of long */
168 int b0_magic_int
; /* check for byte order of int */
169 short b0_magic_short
; /* check for byte order of short */
170 char_u b0_magic_char
; /* check for last char */
174 * Note: b0_dirty and b0_flags are put at the end of the file name. For very
175 * long file names in older versions of Vim they are invalid.
176 * The 'fileencoding' comes before b0_flags, with a NUL in front. But only
177 * when there is room, for very long file names it's omitted.
179 #define B0_DIRTY 0x55
180 #define b0_dirty b0_fname[B0_FNAME_SIZE_ORG-1]
183 * The b0_flags field is new in Vim 7.0.
185 #define b0_flags b0_fname[B0_FNAME_SIZE_ORG-2]
187 /* The lowest two bits contain the fileformat. Zero means it's not set
188 * (compatible with Vim 6.x), otherwise it's EOL_UNIX + 1, EOL_DOS + 1 or
192 /* Swap file is in directory of edited file. Used to find the file from
193 * different mount points. */
194 #define B0_SAME_DIR 4
196 /* The 'fileencoding' is at the end of b0_fname[], with a NUL in front of it.
197 * When empty there is only the NUL. */
198 #define B0_HAS_FENC 8
200 #define STACK_INCR 5 /* nr of entries added to ml_stack at a time */
203 * The line number where the first mark may be is remembered.
204 * If it is 0 there are no marks at all.
205 * (always used for the current buffer only, no buffer change possible while
206 * executing a global command).
208 static linenr_T lowest_marked
= 0;
211 * arguments for ml_find_line()
213 #define ML_DELETE 0x11 /* delete line */
214 #define ML_INSERT 0x12 /* insert line */
215 #define ML_FIND 0x13 /* just find the line */
216 #define ML_FLUSH 0x02 /* flush locked block */
217 #define ML_SIMPLE(x) (x & 0x10) /* DEL, INS or FIND */
219 static void ml_upd_block0
__ARGS((buf_T
*buf
, int set_fname
));
220 static void set_b0_fname
__ARGS((ZERO_BL
*, buf_T
*buf
));
221 static void set_b0_dir_flag
__ARGS((ZERO_BL
*b0p
, buf_T
*buf
));
223 static void add_b0_fenc
__ARGS((ZERO_BL
*b0p
, buf_T
*buf
));
225 static time_t swapfile_info
__ARGS((char_u
*));
226 static int recov_file_names
__ARGS((char_u
**, char_u
*, int prepend_dot
));
227 static int ml_append_int
__ARGS((buf_T
*, linenr_T
, char_u
*, colnr_T
, int, int));
228 static int ml_delete_int
__ARGS((buf_T
*, linenr_T
, int));
229 static char_u
*findswapname
__ARGS((buf_T
*, char_u
**, char_u
*));
230 static void ml_flush_line
__ARGS((buf_T
*));
231 static bhdr_T
*ml_new_data
__ARGS((memfile_T
*, int, int));
232 static bhdr_T
*ml_new_ptr
__ARGS((memfile_T
*));
233 static bhdr_T
*ml_find_line
__ARGS((buf_T
*, linenr_T
, int));
234 static int ml_add_stack
__ARGS((buf_T
*));
235 static void ml_lineadd
__ARGS((buf_T
*, int));
236 static int b0_magic_wrong
__ARGS((ZERO_BL
*));
238 static int fnamecmp_ino
__ARGS((char_u
*, char_u
*, long));
240 static void long_to_char
__ARGS((long, char_u
*));
241 static long char_to_long
__ARGS((char_u
*));
242 #if defined(UNIX) || defined(WIN3264)
243 static char_u
*make_percent_swname
__ARGS((char_u
*dir
, char_u
*name
));
246 static void ml_updatechunk
__ARGS((buf_T
*buf
, long line
, long len
, int updtype
));
249 static int resolve_symlink
__ARGS((char_u
*fname
, char_u
*buf
));
253 * Open a new memline for "buf".
255 * Return FAIL for failure, OK otherwise.
268 * init fields in memline struct
270 buf
->b_ml
.ml_stack_size
= 0; /* no stack yet */
271 buf
->b_ml
.ml_stack
= NULL
; /* no stack yet */
272 buf
->b_ml
.ml_stack_top
= 0; /* nothing in the stack */
273 buf
->b_ml
.ml_locked
= NULL
; /* no cached block */
274 buf
->b_ml
.ml_line_lnum
= 0; /* no cached line */
276 buf
->b_ml
.ml_chunksize
= NULL
;
280 * When 'updatecount' is non-zero swap file may be opened later.
282 if (p_uc
&& buf
->b_p_swf
)
283 buf
->b_may_swap
= TRUE
;
285 buf
->b_may_swap
= FALSE
;
288 * Open the memfile. No swap file is created yet.
290 mfp
= mf_open(NULL
, 0);
294 buf
->b_ml
.ml_mfp
= mfp
;
295 buf
->b_ml
.ml_flags
= ML_EMPTY
;
296 buf
->b_ml
.ml_line_max
= 0;
297 buf
->b_ml
.ml_line_count
= 1;
298 #ifdef FEAT_LINEBREAK
299 curwin
->w_nrwidth_line_count
= 0;
302 #if defined(MSDOS) && !defined(DJGPP)
303 /* for 16 bit MS-DOS create a swapfile now, because we run out of
304 * memory very quickly */
310 * fill block0 struct and write page 0
312 if ((hp
= mf_new(mfp
, FALSE
, 1)) == NULL
)
314 if (hp
->bh_bnum
!= 0)
316 EMSG(_("E298: Didn't get block nr 0?"));
319 b0p
= (ZERO_BL
*)(hp
->bh_data
);
321 b0p
->b0_id
[0] = BLOCK0_ID0
;
322 b0p
->b0_id
[1] = BLOCK0_ID1
;
323 b0p
->b0_magic_long
= (long)B0_MAGIC_LONG
;
324 b0p
->b0_magic_int
= (int)B0_MAGIC_INT
;
325 b0p
->b0_magic_short
= (short)B0_MAGIC_SHORT
;
326 b0p
->b0_magic_char
= B0_MAGIC_CHAR
;
327 STRNCPY(b0p
->b0_version
, "VIM ", 4);
328 STRNCPY(b0p
->b0_version
+ 4, Version
, 6);
329 long_to_char((long)mfp
->mf_page_size
, b0p
->b0_page_size
);
335 b0p
->b0_dirty
= buf
->b_changed
? B0_DIRTY
: 0;
336 b0p
->b0_flags
= get_fileformat(buf
) + 1;
337 set_b0_fname(b0p
, buf
);
338 (void)get_user_name(b0p
->b0_uname
, B0_UNAME_SIZE
);
339 b0p
->b0_uname
[B0_UNAME_SIZE
- 1] = NUL
;
340 mch_get_host_name(b0p
->b0_hname
, B0_HNAME_SIZE
);
341 b0p
->b0_hname
[B0_HNAME_SIZE
- 1] = NUL
;
342 long_to_char(mch_get_pid(), b0p
->b0_pid
);
346 * Always sync block number 0 to disk, so we can check the file name in
347 * the swap file in findswapname(). Don't do this for help files though
348 * and spell buffer though.
349 * Only works when there's a swapfile, otherwise it's done when the file
352 mf_put(mfp
, hp
, TRUE
, FALSE
);
353 if (!buf
->b_help
&& !B_SPELL(buf
))
354 (void)mf_sync(mfp
, 0);
357 * Fill in root pointer block and write page 1.
359 if ((hp
= ml_new_ptr(mfp
)) == NULL
)
361 if (hp
->bh_bnum
!= 1)
363 EMSG(_("E298: Didn't get block nr 1?"));
366 pp
= (PTR_BL
*)(hp
->bh_data
);
368 pp
->pb_pointer
[0].pe_bnum
= 2;
369 pp
->pb_pointer
[0].pe_page_count
= 1;
370 pp
->pb_pointer
[0].pe_old_lnum
= 1;
371 pp
->pb_pointer
[0].pe_line_count
= 1; /* line count after insertion */
372 mf_put(mfp
, hp
, TRUE
, FALSE
);
375 * Allocate first data block and create an empty line 1.
377 if ((hp
= ml_new_data(mfp
, FALSE
, 1)) == NULL
)
379 if (hp
->bh_bnum
!= 2)
381 EMSG(_("E298: Didn't get block nr 2?"));
385 dp
= (DATA_BL
*)(hp
->bh_data
);
386 dp
->db_index
[0] = --dp
->db_txt_start
; /* at end of block */
387 dp
->db_free
-= 1 + INDEX_SIZE
;
388 dp
->db_line_count
= 1;
389 *((char_u
*)dp
+ dp
->db_txt_start
) = NUL
; /* empty line */
397 mf_put(mfp
, hp
, FALSE
, FALSE
);
398 mf_close(mfp
, TRUE
); /* will also free(mfp->mf_fname) */
400 buf
->b_ml
.ml_mfp
= NULL
;
405 * ml_setname() is called when the file name of "buf" has been changed.
406 * It may rename the swap file.
416 #if defined(MSDOS) || defined(MSWIN)
420 mfp
= buf
->b_ml
.ml_mfp
;
421 if (mfp
->mf_fd
< 0) /* there is no swap file yet */
424 * When 'updatecount' is 0 and 'noswapfile' there is no swap file.
425 * For help files we will make a swap file now.
428 ml_open_file(buf
); /* create a swap file */
433 * Try all directories in the 'directory' option.
438 if (*dirp
== NUL
) /* tried all directories, fail */
440 fname
= findswapname(buf
, &dirp
, mfp
->mf_fname
);
442 if (fname
== NULL
) /* no file name found for this dir */
445 #if defined(MSDOS) || defined(MSWIN)
447 * Set full pathname for swap file now, because a ":!cd dir" may
448 * change directory without us knowing it.
450 p
= FullName_save(fname
, FALSE
);
456 /* if the file name is the same we don't have to do anything */
457 if (fnamecmp(fname
, mfp
->mf_fname
) == 0)
463 /* need to close the swap file before renaming */
470 /* try to rename the swap file */
471 if (vim_rename(mfp
->mf_fname
, fname
) == 0)
474 vim_free(mfp
->mf_fname
);
475 mfp
->mf_fname
= fname
;
476 vim_free(mfp
->mf_ffname
);
477 #if defined(MSDOS) || defined(MSWIN)
478 mfp
->mf_ffname
= NULL
; /* mf_fname is full pathname already */
482 ml_upd_block0(buf
, FALSE
);
485 vim_free(fname
); /* this fname didn't work, try another */
488 if (mfp
->mf_fd
== -1) /* need to (re)open the swap file */
490 mfp
->mf_fd
= mch_open((char *)mfp
->mf_fname
, O_RDWR
| O_EXTRA
, 0);
493 /* could not (re)open the swap file, what can we do???? */
494 EMSG(_("E301: Oops, lost the swap file!!!"));
497 #ifdef HAVE_FD_CLOEXEC
499 int fdflags
= fcntl(mfp
->mf_fd
, F_GETFD
);
500 if (fdflags
>= 0 && (fdflags
& FD_CLOEXEC
) == 0)
501 fcntl(mfp
->mf_fd
, F_SETFD
, fdflags
| FD_CLOEXEC
);
506 EMSG(_("E302: Could not rename swap file"));
510 * Open a file for the memfile for all buffers that are not readonly or have
512 * Used when 'updatecount' changes from zero to non-zero.
519 for (buf
= firstbuf
; buf
!= NULL
; buf
= buf
->b_next
)
520 if (!buf
->b_p_ro
|| buf
->b_changed
)
525 * Open a swap file for an existing memfile, if there is no swap file yet.
526 * If we are unable to find a file name, mf_fname will be NULL
527 * and the memfile will be in memory only (no recovery possible).
537 mfp
= buf
->b_ml
.ml_mfp
;
538 if (mfp
== NULL
|| mfp
->mf_fd
>= 0 || !buf
->b_p_swf
)
539 return; /* nothing to do */
542 /* For a spell buffer use a temp file name. */
545 fname
= vim_tempname('s');
547 (void)mf_open_file(mfp
, fname
); /* consumes fname! */
548 buf
->b_may_swap
= FALSE
;
554 * Try all directories in 'directory' option.
561 /* There is a small chance that between chosing the swap file name and
562 * creating it, another Vim creates the file. In that case the
563 * creation will fail and we will use another directory. */
564 fname
= findswapname(buf
, &dirp
, NULL
); /* allocates fname */
567 if (mf_open_file(mfp
, fname
) == OK
) /* consumes fname! */
569 #if defined(MSDOS) || defined(MSWIN) || defined(RISCOS)
571 * set full pathname for swap file now, because a ":!cd dir" may
572 * change directory without us knowing it.
576 ml_upd_block0(buf
, FALSE
);
578 /* Flush block zero, so others can read it */
579 if (mf_sync(mfp
, MFS_ZERO
) == OK
)
581 /* Mark all blocks that should be in the swapfile as dirty.
582 * Needed for when the 'swapfile' option was reset, so that
583 * the swap file was deleted, and then on again. */
587 /* Writing block 0 failed: close the file and try another dir */
588 mf_close_file(buf
, FALSE
);
592 if (mfp
->mf_fname
== NULL
) /* Failed! */
594 char_u
*bname
= (char_u
*)buf_spname(buf
);
595 need_wait_return
= TRUE
; /* call wait_return later */
597 (void)EMSG2(_("E303: Unable to open swap file for \"%s\", recovery impossible"),
605 /* don't try to open a swap file again */
606 buf
->b_may_swap
= FALSE
;
610 * If still need to create a swap file, and starting to edit a not-readonly
611 * file, or reading into an existing buffer, create a swap file now.
614 check_need_swap(newfile
)
615 int newfile
; /* reading file into new buffer */
617 if (curbuf
->b_may_swap
&& (!curbuf
->b_p_ro
|| !newfile
))
618 ml_open_file(curbuf
);
622 * Close memline for buffer 'buf'.
623 * If 'del_file' is TRUE, delete the swap file
626 ml_close(buf
, del_file
)
630 if (buf
->b_ml
.ml_mfp
== NULL
) /* not open */
632 mf_close(buf
->b_ml
.ml_mfp
, del_file
); /* close the .swp file */
633 if (buf
->b_ml
.ml_line_lnum
!= 0 && (buf
->b_ml
.ml_flags
& ML_LINE_DIRTY
))
634 vim_free(buf
->b_ml
.ml_line_ptr
);
635 vim_free(buf
->b_ml
.ml_stack
);
637 vim_free(buf
->b_ml
.ml_chunksize
);
638 buf
->b_ml
.ml_chunksize
= NULL
;
640 buf
->b_ml
.ml_mfp
= NULL
;
642 /* Reset the "recovered" flag, give the ATTENTION prompt the next time
643 * this buffer is loaded. */
644 buf
->b_flags
&= ~BF_RECOVERED
;
648 * Close all existing memlines and memfiles.
649 * Only used when exiting.
650 * When 'del_file' is TRUE, delete the memfiles.
651 * But don't delete files that were ":preserve"d when we are POSIX compatible.
654 ml_close_all(del_file
)
659 for (buf
= firstbuf
; buf
!= NULL
; buf
= buf
->b_next
)
660 ml_close(buf
, del_file
&& ((buf
->b_flags
& BF_PRESERVED
) == 0
661 || vim_strchr(p_cpo
, CPO_PRESERVE
) == NULL
));
663 vim_deltempdir(); /* delete created temp directory */
668 * Close all memfiles for not modified buffers.
669 * Only use just before exiting!
676 for (buf
= firstbuf
; buf
!= NULL
; buf
= buf
->b_next
)
677 if (!bufIsChanged(buf
))
678 ml_close(buf
, TRUE
); /* close all not-modified buffers */
682 * Update the timestamp in the .swp file.
683 * Used when the file has been written.
689 ml_upd_block0(buf
, TRUE
);
693 * Update the timestamp or the B0_SAME_DIR flag of the .swp file.
696 ml_upd_block0(buf
, set_fname
)
704 mfp
= buf
->b_ml
.ml_mfp
;
705 if (mfp
== NULL
|| (hp
= mf_get(mfp
, (blocknr_T
)0, 1)) == NULL
)
707 b0p
= (ZERO_BL
*)(hp
->bh_data
);
708 if (b0p
->b0_id
[0] != BLOCK0_ID0
|| b0p
->b0_id
[1] != BLOCK0_ID1
)
709 EMSG(_("E304: ml_upd_block0(): Didn't get block 0??"));
713 set_b0_fname(b0p
, buf
);
715 set_b0_dir_flag(b0p
, buf
);
717 mf_put(mfp
, hp
, TRUE
, FALSE
);
721 * Write file name and timestamp into block 0 of a swap file.
722 * Also set buf->b_mtime.
723 * Don't use NameBuff[]!!!
726 set_b0_fname(b0p
, buf
)
732 if (buf
->b_ffname
== NULL
)
733 b0p
->b0_fname
[0] = NUL
;
736 #if defined(MSDOS) || defined(MSWIN) || defined(AMIGA) || defined(RISCOS)
737 /* Systems that cannot translate "~user" back into a path: copy the
738 * file name unmodified. Do use slashes instead of backslashes for
740 vim_strncpy(b0p
->b0_fname
, buf
->b_ffname
, B0_FNAME_SIZE
- 1);
741 # ifdef BACKSLASH_IN_FILENAME
742 forward_slash(b0p
->b0_fname
);
746 char_u uname
[B0_UNAME_SIZE
];
749 * For a file under the home directory of the current user, we try to
750 * replace the home directory path with "~user". This helps when
751 * editing the same file on different machines over a network.
752 * First replace home dir path with "~/" with home_replace().
753 * Then insert the user name to get "~user/".
755 home_replace(NULL
, buf
->b_ffname
, b0p
->b0_fname
, B0_FNAME_SIZE
, TRUE
);
756 if (b0p
->b0_fname
[0] == '~')
758 flen
= STRLEN(b0p
->b0_fname
);
759 /* If there is no user name or it is too long, don't use "~/" */
760 if (get_user_name(uname
, B0_UNAME_SIZE
) == FAIL
761 || (ulen
= STRLEN(uname
)) + flen
> B0_FNAME_SIZE
- 1)
762 vim_strncpy(b0p
->b0_fname
, buf
->b_ffname
, B0_FNAME_SIZE
- 1);
765 mch_memmove(b0p
->b0_fname
+ ulen
+ 1, b0p
->b0_fname
+ 1, flen
);
766 mch_memmove(b0p
->b0_fname
+ 1, uname
, ulen
);
770 if (mch_stat((char *)buf
->b_ffname
, &st
) >= 0)
772 long_to_char((long)st
.st_mtime
, b0p
->b0_mtime
);
774 long_to_char((long)st
.st_ino
, b0p
->b0_ino
);
776 buf_store_time(buf
, &st
, buf
->b_ffname
);
777 buf
->b_mtime_read
= buf
->b_mtime
;
781 long_to_char(0L, b0p
->b0_mtime
);
783 long_to_char(0L, b0p
->b0_ino
);
786 buf
->b_mtime_read
= 0;
787 buf
->b_orig_size
= 0;
788 buf
->b_orig_mode
= 0;
793 /* Also add the 'fileencoding' if there is room. */
794 add_b0_fenc(b0p
, curbuf
);
799 * Update the B0_SAME_DIR flag of the swap file. It's set if the file and the
800 * swapfile for "buf" are in the same directory.
801 * This is fail safe: if we are not sure the directories are equal the flag is
805 set_b0_dir_flag(b0p
, buf
)
809 if (same_directory(buf
->b_ml
.ml_mfp
->mf_fname
, buf
->b_ffname
))
810 b0p
->b0_flags
|= B0_SAME_DIR
;
812 b0p
->b0_flags
&= ~B0_SAME_DIR
;
817 * When there is room, add the 'fileencoding' to block zero.
820 add_b0_fenc(b0p
, buf
)
826 n
= (int)STRLEN(buf
->b_p_fenc
);
827 if (STRLEN(b0p
->b0_fname
) + n
+ 1 > B0_FNAME_SIZE
)
828 b0p
->b0_flags
&= ~B0_HAS_FENC
;
831 mch_memmove((char *)b0p
->b0_fname
+ B0_FNAME_SIZE
- n
,
832 (char *)buf
->b_p_fenc
, (size_t)n
);
833 *(b0p
->b0_fname
+ B0_FNAME_SIZE
- n
- 1) = NUL
;
834 b0p
->b0_flags
|= B0_HAS_FENC
;
841 * try to recover curbuf from the .swp file
847 memfile_T
*mfp
= NULL
;
852 char_u
*b0_fenc
= NULL
;
858 struct stat org_stat
, swp_stat
;
872 int called_from_main
;
873 int serious_error
= TRUE
;
879 called_from_main
= (curbuf
->b_ml
.ml_mfp
== NULL
);
880 attr
= hl_attr(HLF_E
);
883 * If the file name ends in ".s[uvw][a-z]" we assume this is the swap file.
884 * Otherwise a search is done to find the swap file(s).
886 fname
= curbuf
->b_fname
;
887 if (fname
== NULL
) /* When there is no file name */
888 fname
= (char_u
*)"";
889 len
= (int)STRLEN(fname
);
891 #if defined(VMS) || defined(RISCOS)
892 STRNICMP(fname
+ len
- 4, "_s" , 2)
894 STRNICMP(fname
+ len
- 4, ".s" , 2)
897 && vim_strchr((char_u
*)"UVWuvw", fname
[len
- 2]) != NULL
898 && ASCII_ISALPHA(fname
[len
- 1]))
901 fname
= vim_strsave(fname
); /* make a copy for mf_open() */
907 /* count the number of matching swap files */
908 len
= recover_names(&fname
, FALSE
, 0);
909 if (len
== 0) /* no swap files found */
911 EMSG2(_("E305: No swap file found for %s"), fname
);
914 if (len
== 1) /* one swap file found, use it */
916 else /* several swap files found, choose */
918 /* list the names of the swap files */
919 (void)recover_names(&fname
, TRUE
, 0);
921 MSG_PUTS(_("Enter number of swap file to use (0 to quit): "));
922 i
= get_number(FALSE
, NULL
);
923 if (i
< 1 || i
> len
)
926 /* get the swap file name that will be used */
927 (void)recover_names(&fname
, FALSE
, i
);
930 goto theend
; /* out of memory */
932 /* When called from main() still need to initialize storage structure */
933 if (called_from_main
&& ml_open(curbuf
) == FAIL
)
937 * allocate a buffer structure (only the memline in it is really used)
939 buf
= (buf_T
*)alloc((unsigned)sizeof(buf_T
));
947 * init fields in memline struct
949 buf
->b_ml
.ml_stack_size
= 0; /* no stack yet */
950 buf
->b_ml
.ml_stack
= NULL
; /* no stack yet */
951 buf
->b_ml
.ml_stack_top
= 0; /* nothing in the stack */
952 buf
->b_ml
.ml_line_lnum
= 0; /* no cached line */
953 buf
->b_ml
.ml_locked
= NULL
; /* no locked block */
954 buf
->b_ml
.ml_flags
= 0;
957 * open the memfile from the old swap file
959 p
= vim_strsave(fname
); /* save fname for the message
960 (mf_open() may free fname) */
961 mfp
= mf_open(fname
, O_RDONLY
); /* consumes fname! */
962 if (mfp
== NULL
|| mfp
->mf_fd
< 0)
966 EMSG2(_("E306: Cannot open %s"), p
);
972 buf
->b_ml
.ml_mfp
= mfp
;
975 * The page size set in mf_open() might be different from the page size
976 * used in the swap file, we must get it from block 0. But to read block
977 * 0 we need a page size. Use the minimal size for block 0 here, it will
978 * be set to the real value below.
980 mfp
->mf_page_size
= MIN_SWAP_PAGE_SIZE
;
983 * try to read block 0
985 if ((hp
= mf_get(mfp
, (blocknr_T
)0, 1)) == NULL
)
988 MSG_PUTS_ATTR(_("Unable to read block 0 from "), attr
| MSG_HIST
);
989 msg_outtrans_attr(mfp
->mf_fname
, attr
| MSG_HIST
);
991 _("\nMaybe no changes were made or Vim did not update the swap file."),
996 b0p
= (ZERO_BL
*)(hp
->bh_data
);
997 if (STRNCMP(b0p
->b0_version
, "VIM 3.0", 7) == 0)
1000 msg_outtrans_attr(mfp
->mf_fname
, MSG_HIST
);
1001 MSG_PUTS_ATTR(_(" cannot be used with this version of Vim.\n"),
1003 MSG_PUTS_ATTR(_("Use Vim version 3.0.\n"), MSG_HIST
);
1007 if (b0p
->b0_id
[0] != BLOCK0_ID0
|| b0p
->b0_id
[1] != BLOCK0_ID1
)
1009 EMSG2(_("E307: %s does not look like a Vim swap file"), mfp
->mf_fname
);
1012 if (b0_magic_wrong(b0p
))
1015 msg_outtrans_attr(mfp
->mf_fname
, attr
| MSG_HIST
);
1016 #if defined(MSDOS) || defined(MSWIN)
1017 if (STRNCMP(b0p
->b0_hname
, "PC ", 3) == 0)
1018 MSG_PUTS_ATTR(_(" cannot be used with this version of Vim.\n"),
1022 MSG_PUTS_ATTR(_(" cannot be used on this computer.\n"),
1024 MSG_PUTS_ATTR(_("The file was created on "), attr
| MSG_HIST
);
1025 /* avoid going past the end of a currupted hostname */
1026 b0p
->b0_fname
[0] = NUL
;
1027 MSG_PUTS_ATTR(b0p
->b0_hname
, attr
| MSG_HIST
);
1028 MSG_PUTS_ATTR(_(",\nor the file has been damaged."), attr
| MSG_HIST
);
1034 * If we guessed the wrong page size, we have to recalculate the
1035 * highest block number in the file.
1037 if (mfp
->mf_page_size
!= (unsigned)char_to_long(b0p
->b0_page_size
))
1039 unsigned previous_page_size
= mfp
->mf_page_size
;
1041 mf_new_page_size(mfp
, (unsigned)char_to_long(b0p
->b0_page_size
));
1042 if (mfp
->mf_page_size
< previous_page_size
)
1045 msg_outtrans_attr(mfp
->mf_fname
, attr
| MSG_HIST
);
1046 MSG_PUTS_ATTR(_(" has been damaged (page size is smaller than minimum value).\n"),
1051 if ((size
= lseek(mfp
->mf_fd
, (off_t
)0L, SEEK_END
)) <= 0)
1052 mfp
->mf_blocknr_max
= 0; /* no file or empty file */
1054 mfp
->mf_blocknr_max
= (blocknr_T
)(size
/ mfp
->mf_page_size
);
1055 mfp
->mf_infile_count
= mfp
->mf_blocknr_max
;
1057 /* need to reallocate the memory used to store the data */
1058 p
= alloc(mfp
->mf_page_size
);
1061 mch_memmove(p
, hp
->bh_data
, previous_page_size
);
1062 vim_free(hp
->bh_data
);
1064 b0p
= (ZERO_BL
*)(hp
->bh_data
);
1068 * If .swp file name given directly, use name from swap file for buffer.
1072 expand_env(b0p
->b0_fname
, NameBuff
, MAXPATHL
);
1073 if (setfname(curbuf
, NameBuff
, NULL
, TRUE
) == FAIL
)
1077 home_replace(NULL
, mfp
->mf_fname
, NameBuff
, MAXPATHL
, TRUE
);
1078 smsg((char_u
*)_("Using swap file \"%s\""), NameBuff
);
1080 if ((bname
= (char_u
*)buf_spname(curbuf
)) != NULL
)
1082 vim_strncpy(NameBuff
, bname
, MAXPATHL
- 1);
1086 home_replace(NULL
, curbuf
->b_ffname
, NameBuff
, MAXPATHL
, TRUE
);
1087 smsg((char_u
*)_("Original file \"%s\""), NameBuff
);
1091 * check date of swap file and original file
1093 mtime
= char_to_long(b0p
->b0_mtime
);
1094 if (curbuf
->b_ffname
!= NULL
1095 && mch_stat((char *)curbuf
->b_ffname
, &org_stat
) != -1
1096 && ((mch_stat((char *)mfp
->mf_fname
, &swp_stat
) != -1
1097 && org_stat
.st_mtime
> swp_stat
.st_mtime
)
1098 || org_stat
.st_mtime
!= mtime
))
1100 EMSG(_("E308: Warning: Original file may have been changed"));
1104 /* Get the 'fileformat' and 'fileencoding' from block zero. */
1105 b0_ff
= (b0p
->b0_flags
& B0_FF_MASK
);
1106 if (b0p
->b0_flags
& B0_HAS_FENC
)
1108 for (p
= b0p
->b0_fname
+ B0_FNAME_SIZE
;
1109 p
> b0p
->b0_fname
&& p
[-1] != NUL
; --p
)
1111 b0_fenc
= vim_strnsave(p
, (int)(b0p
->b0_fname
+ B0_FNAME_SIZE
- p
));
1114 mf_put(mfp
, hp
, FALSE
, FALSE
); /* release block 0 */
1118 * Now that we are sure that the file is going to be recovered, clear the
1119 * contents of the current buffer.
1121 while (!(curbuf
->b_ml
.ml_flags
& ML_EMPTY
))
1122 ml_delete((linenr_T
)1, FALSE
);
1125 * Try reading the original file to obtain the values of 'fileformat',
1126 * 'fileencoding', etc. Ignore errors. The text itself is not used.
1128 if (curbuf
->b_ffname
!= NULL
)
1130 (void)readfile(curbuf
->b_ffname
, NULL
, (linenr_T
)0,
1131 (linenr_T
)0, (linenr_T
)MAXLNUM
, NULL
, READ_NEW
);
1132 while (!(curbuf
->b_ml
.ml_flags
& ML_EMPTY
))
1133 ml_delete((linenr_T
)1, FALSE
);
1136 /* Use the 'fileformat' and 'fileencoding' as stored in the swap file. */
1138 set_fileformat(b0_ff
- 1, OPT_LOCAL
);
1139 if (b0_fenc
!= NULL
)
1141 set_option_value((char_u
*)"fenc", 0L, b0_fenc
, OPT_LOCAL
);
1144 unchanged(curbuf
, TRUE
);
1146 bnum
= 1; /* start with block 1 */
1147 page_count
= 1; /* which is 1 page */
1148 lnum
= 0; /* append after line 0 in curbuf */
1150 idx
= 0; /* start with first index in block 1 */
1152 buf
->b_ml
.ml_stack_top
= 0;
1153 buf
->b_ml
.ml_stack
= NULL
;
1154 buf
->b_ml
.ml_stack_size
= 0; /* no stack yet */
1156 if (curbuf
->b_ffname
== NULL
)
1159 cannot_open
= FALSE
;
1161 serious_error
= FALSE
;
1162 for ( ; !got_int
; line_breakcheck())
1165 mf_put(mfp
, hp
, FALSE
, FALSE
); /* release previous block */
1170 if ((hp
= mf_get(mfp
, (blocknr_T
)bnum
, page_count
)) == NULL
)
1174 EMSG2(_("E309: Unable to read block 1 from %s"), mfp
->mf_fname
);
1178 ml_append(lnum
++, (char_u
*)_("???MANY LINES MISSING"),
1181 else /* there is a block */
1183 pp
= (PTR_BL
*)(hp
->bh_data
);
1184 if (pp
->pb_id
== PTR_ID
) /* it is a pointer block */
1186 /* check line count when using pointer block first time */
1187 if (idx
== 0 && line_count
!= 0)
1189 for (i
= 0; i
< (int)pp
->pb_count
; ++i
)
1190 line_count
-= pp
->pb_pointer
[i
].pe_line_count
;
1191 if (line_count
!= 0)
1194 ml_append(lnum
++, (char_u
*)_("???LINE COUNT WRONG"),
1199 if (pp
->pb_count
== 0)
1201 ml_append(lnum
++, (char_u
*)_("???EMPTY BLOCK"),
1205 else if (idx
< (int)pp
->pb_count
) /* go a block deeper */
1207 if (pp
->pb_pointer
[idx
].pe_bnum
< 0)
1210 * Data block with negative block number.
1211 * Try to read lines from the original file.
1212 * This is slow, but it works.
1216 line_count
= pp
->pb_pointer
[idx
].pe_line_count
;
1217 if (readfile(curbuf
->b_ffname
, NULL
, lnum
,
1218 pp
->pb_pointer
[idx
].pe_old_lnum
- 1,
1219 line_count
, NULL
, 0) == FAIL
)
1227 ml_append(lnum
++, (char_u
*)_("???LINES MISSING"),
1230 ++idx
; /* get same block again for next index */
1235 * going one block deeper in the tree
1237 if ((top
= ml_add_stack(buf
)) < 0) /* new entry in stack */
1240 break; /* out of memory */
1242 ip
= &(buf
->b_ml
.ml_stack
[top
]);
1246 bnum
= pp
->pb_pointer
[idx
].pe_bnum
;
1247 line_count
= pp
->pb_pointer
[idx
].pe_line_count
;
1248 page_count
= pp
->pb_pointer
[idx
].pe_page_count
;
1252 else /* not a pointer block */
1254 dp
= (DATA_BL
*)(hp
->bh_data
);
1255 if (dp
->db_id
!= DATA_ID
) /* block id wrong */
1259 EMSG2(_("E310: Block 1 ID wrong (%s not a .swp file?)"),
1264 ml_append(lnum
++, (char_u
*)_("???BLOCK MISSING"),
1270 * it is a data block
1271 * Append all the lines in this block
1275 * check length of block
1276 * if wrong, use length in pointer block
1278 if (page_count
* mfp
->mf_page_size
!= dp
->db_txt_end
)
1280 ml_append(lnum
++, (char_u
*)_("??? from here until ???END lines may be messed up"),
1284 dp
->db_txt_end
= page_count
* mfp
->mf_page_size
;
1287 /* make sure there is a NUL at the end of the block */
1288 *((char_u
*)dp
+ dp
->db_txt_end
- 1) = NUL
;
1291 * check number of lines in block
1292 * if wrong, use count in data block
1294 if (line_count
!= dp
->db_line_count
)
1296 ml_append(lnum
++, (char_u
*)_("??? from here until ???END lines may have been inserted/deleted"),
1302 for (i
= 0; i
< dp
->db_line_count
; ++i
)
1304 txt_start
= (dp
->db_index
[i
] & DB_INDEX_MASK
);
1305 if (txt_start
<= (int)HEADER_SIZE
1306 || txt_start
>= (int)dp
->db_txt_end
)
1308 p
= (char_u
*)"???";
1312 p
= (char_u
*)dp
+ txt_start
;
1313 ml_append(lnum
++, p
, (colnr_T
)0, TRUE
);
1316 ml_append(lnum
++, (char_u
*)_("???END"),
1322 if (buf
->b_ml
.ml_stack_top
== 0) /* finished */
1326 * go one block up in the tree
1328 ip
= &(buf
->b_ml
.ml_stack
[--(buf
->b_ml
.ml_stack_top
)]);
1330 idx
= ip
->ip_index
+ 1; /* go to next index */
1335 * The dummy line from the empty buffer will now be after the last line in
1336 * the buffer. Delete it.
1338 ml_delete(curbuf
->b_ml
.ml_line_count
, FALSE
);
1339 curbuf
->b_flags
|= BF_RECOVERED
;
1341 recoverymode
= FALSE
;
1343 EMSG(_("E311: Recovery Interrupted"));
1347 MSG(">>>>>>>>>>>>>");
1348 EMSG(_("E312: Errors detected while recovering; look for lines starting with ???"));
1350 MSG(_("See \":help E312\" for more information."));
1351 MSG(">>>>>>>>>>>>>");
1355 MSG(_("Recovery completed. You should check if everything is OK."));
1356 MSG_PUTS(_("\n(You might want to write out this file under another name\n"));
1357 MSG_PUTS(_("and run diff with the original file to check for changes)\n"));
1358 MSG_PUTS(_("Delete the .swp file afterwards.\n\n"));
1359 cmdline_row
= msg_row
;
1361 redraw_curbuf_later(NOT_VALID
);
1364 recoverymode
= FALSE
;
1368 mf_put(mfp
, hp
, FALSE
, FALSE
);
1369 mf_close(mfp
, FALSE
); /* will also vim_free(mfp->mf_fname) */
1373 vim_free(buf
->b_ml
.ml_stack
);
1376 if (serious_error
&& called_from_main
)
1377 ml_close(curbuf
, TRUE
);
1381 apply_autocmds(EVENT_BUFREADPOST
, NULL
, curbuf
->b_fname
, FALSE
, curbuf
);
1382 apply_autocmds(EVENT_BUFWINENTER
, NULL
, curbuf
->b_fname
, FALSE
, curbuf
);
1389 * Find the names of swap files in current directory and the directory given
1390 * with the 'directory' option.
1393 * - list the swap files for "vim -r"
1394 * - count the number of swap files when recovering
1395 * - list the swap files when recovering
1396 * - find the name of the n'th swap file when recovering
1399 recover_names(fname
, list
, nr
)
1400 char_u
**fname
; /* base for swap file name */
1401 int list
; /* when TRUE, list the swap file names */
1402 int nr
; /* when non-zero, return nr'th swap file name */
1414 char_u
*fname_res
= NULL
;
1415 #ifdef HAVE_READLINK
1416 char_u fname_buf
[MAXPATHL
];
1421 #ifdef HAVE_READLINK
1422 /* Expand symlink in the file name, because the swap file is created with
1423 * the actual file instead of with the symlink. */
1424 if (resolve_symlink(*fname
, fname_buf
) == OK
)
1425 fname_res
= fname_buf
;
1433 /* use msg() to start the scrolling properly */
1434 msg((char_u
*)_("Swap files found:"));
1439 * Do the loop for every directory in 'directory'.
1440 * First allocate some memory to put the directory name in.
1442 dir_name
= alloc((unsigned)STRLEN(p_dir
) + 1);
1444 while (dir_name
!= NULL
&& *dirp
)
1447 * Isolate a directory name from *dirp and put it in dir_name (we know
1448 * it is large enough, so use 31000 for length).
1449 * Advance dirp to next directory name.
1451 (void)copy_option_part(&dirp
, dir_name
, 31000, ",");
1453 if (dir_name
[0] == '.' && dir_name
[1] == NUL
) /* check current dir */
1455 if (fname
== NULL
|| *fname
== NULL
)
1458 names
[0] = vim_strsave((char_u
*)"*_sw%");
1461 names
[0] = vim_strsave((char_u
*)"*_sw#");
1463 names
[0] = vim_strsave((char_u
*)"*.sw?");
1466 #if defined(UNIX) || defined(WIN3264)
1467 /* For Unix names starting with a dot are special. MS-Windows
1468 * supports this too, on some file systems. */
1469 names
[1] = vim_strsave((char_u
*)".*.sw?");
1470 names
[2] = vim_strsave((char_u
*)".sw?");
1474 names
[1] = vim_strsave((char_u
*)".*_sw%");
1482 num_names
= recov_file_names(names
, fname_res
, TRUE
);
1484 else /* check directory dir_name */
1486 if (fname
== NULL
|| *fname
== NULL
)
1489 names
[0] = concat_fnames(dir_name
, (char_u
*)"*_sw%", TRUE
);
1492 names
[0] = concat_fnames(dir_name
, (char_u
*)"*_sw#", TRUE
);
1494 names
[0] = concat_fnames(dir_name
, (char_u
*)"*.sw?", TRUE
);
1497 #if defined(UNIX) || defined(WIN3264)
1498 /* For Unix names starting with a dot are special. MS-Windows
1499 * supports this too, on some file systems. */
1500 names
[1] = concat_fnames(dir_name
, (char_u
*)".*.sw?", TRUE
);
1501 names
[2] = concat_fnames(dir_name
, (char_u
*)".sw?", TRUE
);
1505 names
[1] = concat_fnames(dir_name
, (char_u
*)".*_sw%", TRUE
);
1514 #if defined(UNIX) || defined(WIN3264)
1515 p
= dir_name
+ STRLEN(dir_name
);
1516 if (after_pathsep(dir_name
, p
) && p
[-1] == p
[-2])
1518 /* Ends with '//', Use Full path for swap name */
1519 tail
= make_percent_swname(dir_name
, fname_res
);
1524 tail
= gettail(fname_res
);
1525 tail
= concat_fnames(dir_name
, tail
, TRUE
);
1531 num_names
= recov_file_names(names
, tail
, FALSE
);
1537 /* check for out-of-memory */
1538 for (i
= 0; i
< num_names
; ++i
)
1540 if (names
[i
] == NULL
)
1542 for (i
= 0; i
< num_names
; ++i
)
1549 else if (expand_wildcards(num_names
, names
, &num_files
, &files
,
1550 EW_KEEPALL
|EW_FILE
|EW_SILENT
) == FAIL
)
1554 * When no swap file found, wildcard expansion might have failed (e.g.
1555 * not able to execute the shell).
1556 * Try finding a swap file by simply adding ".swp" to the file name.
1558 if (*dirp
== NUL
&& file_count
+ num_files
== 0
1559 && fname
!= NULL
&& *fname
!= NULL
)
1564 swapname
= modname(fname_res
,
1565 #if defined(VMS) || defined(RISCOS)
1566 (char_u
*)"_swp", FALSE
1568 (char_u
*)".swp", TRUE
1571 if (swapname
!= NULL
)
1573 if (mch_stat((char *)swapname
, &st
) != -1) /* It exists! */
1575 files
= (char_u
**)alloc((unsigned)sizeof(char_u
*));
1578 files
[0] = swapname
;
1588 * remove swapfile name of the current buffer, it must be ignored
1590 if (curbuf
->b_ml
.ml_mfp
!= NULL
1591 && (p
= curbuf
->b_ml
.ml_mfp
->mf_fname
) != NULL
)
1593 for (i
= 0; i
< num_files
; ++i
)
1594 if (fullpathcmp(p
, files
[i
], TRUE
) & FPC_SAME
)
1596 /* Remove the name from files[i]. Move further entries
1597 * down. When the array becomes empty free it here, since
1598 * FreeWild() won't be called below. */
1600 if (--num_files
== 0)
1603 for ( ; i
< num_files
; ++i
)
1604 files
[i
] = files
[i
+ 1];
1609 file_count
+= num_files
;
1610 if (nr
<= file_count
)
1612 *fname
= vim_strsave(files
[nr
- 1 + num_files
- file_count
]);
1613 dirp
= (char_u
*)""; /* stop searching */
1618 if (dir_name
[0] == '.' && dir_name
[1] == NUL
)
1620 if (fname
== NULL
|| *fname
== NULL
)
1621 MSG_PUTS(_(" In current directory:\n"));
1623 MSG_PUTS(_(" Using specified name:\n"));
1627 MSG_PUTS(_(" In directory "));
1628 msg_home_replace(dir_name
);
1634 for (i
= 0; i
< num_files
; ++i
)
1636 /* print the swap file name */
1637 msg_outnum((long)++file_count
);
1639 msg_puts(gettail(files
[i
]));
1641 (void)swapfile_info(files
[i
]);
1645 MSG_PUTS(_(" -- none --\n"));
1649 file_count
+= num_files
;
1651 for (i
= 0; i
< num_names
; ++i
)
1654 FreeWild(num_files
, files
);
1660 #if defined(UNIX) || defined(WIN3264) /* Need _very_ long file names */
1662 * Append the full path to name with path separators made into percent
1663 * signs, to dir. An unnamed buffer is handled as "" (<currentdir>/"")
1666 make_percent_swname(dir
, name
)
1672 f
= fix_fname(name
!= NULL
? name
: (char_u
*) "");
1676 s
= alloc((unsigned)(STRLEN(f
) + 1));
1680 for (d
= s
; *d
!= NUL
; mb_ptr_adv(d
))
1681 if (vim_ispathsep(*d
))
1683 d
= concat_fnames(dir
, s
, TRUE
);
1692 #if (defined(UNIX) || defined(__EMX__) || defined(VMS)) && (defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG))
1693 static int process_still_running
;
1697 * Give information about an existing swap file.
1698 * Returns timestamp (0 when unknown).
1701 swapfile_info(fname
)
1707 time_t x
= (time_t)0;
1710 char_u uname
[B0_UNAME_SIZE
];
1713 /* print the swap file date */
1714 if (mch_stat((char *)fname
, &st
) != -1)
1717 /* print name of owner of the file */
1718 if (mch_get_uname(st
.st_uid
, uname
, B0_UNAME_SIZE
) == OK
)
1720 MSG_PUTS(_(" owned by: "));
1721 msg_outtrans(uname
);
1722 MSG_PUTS(_(" dated: "));
1726 MSG_PUTS(_(" dated: "));
1727 x
= st
.st_mtime
; /* Manx C can't do &st.st_mtime */
1728 p
= ctime(&x
); /* includes '\n' */
1730 MSG_PUTS("(invalid)\n");
1736 * print the original file name
1738 fd
= mch_open((char *)fname
, O_RDONLY
| O_EXTRA
, 0);
1741 if (read(fd
, (char *)&b0
, sizeof(b0
)) == sizeof(b0
))
1743 if (STRNCMP(b0
.b0_version
, "VIM 3.0", 7) == 0)
1745 MSG_PUTS(_(" [from Vim version 3.0]"));
1747 else if (b0
.b0_id
[0] != BLOCK0_ID0
|| b0
.b0_id
[1] != BLOCK0_ID1
)
1749 MSG_PUTS(_(" [does not look like a Vim swap file]"));
1753 MSG_PUTS(_(" file name: "));
1754 if (b0
.b0_fname
[0] == NUL
)
1755 MSG_PUTS(_("[No Name]"));
1757 msg_outtrans(b0
.b0_fname
);
1759 MSG_PUTS(_("\n modified: "));
1760 MSG_PUTS(b0
.b0_dirty
? _("YES") : _("no"));
1762 if (*(b0
.b0_uname
) != NUL
)
1764 MSG_PUTS(_("\n user name: "));
1765 msg_outtrans(b0
.b0_uname
);
1768 if (*(b0
.b0_hname
) != NUL
)
1770 if (*(b0
.b0_uname
) != NUL
)
1771 MSG_PUTS(_(" host name: "));
1773 MSG_PUTS(_("\n host name: "));
1774 msg_outtrans(b0
.b0_hname
);
1777 if (char_to_long(b0
.b0_pid
) != 0L)
1779 MSG_PUTS(_("\n process ID: "));
1780 msg_outnum(char_to_long(b0
.b0_pid
));
1781 #if defined(UNIX) || defined(__EMX__)
1782 /* EMX kill() not working correctly, it seems */
1783 if (kill((pid_t
)char_to_long(b0
.b0_pid
), 0) == 0)
1785 MSG_PUTS(_(" (still running)"));
1786 # if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
1787 process_still_running
= TRUE
;
1793 if (b0_magic_wrong(&b0
))
1795 #if defined(MSDOS) || defined(MSWIN)
1796 if (STRNCMP(b0
.b0_hname
, "PC ", 3) == 0)
1797 MSG_PUTS(_("\n [not usable with this version of Vim]"));
1800 MSG_PUTS(_("\n [not usable on this computer]"));
1805 MSG_PUTS(_(" [cannot be read]"));
1809 MSG_PUTS(_(" [cannot be opened]"));
1816 recov_file_names(names
, path
, prepend_dot
)
1825 * (MS-DOS) always short names
1827 names
[0] = modname(path
, (char_u
*)".sw?", FALSE
);
1829 #else /* !SHORT_FNAME */
1831 * (Win32 and Win64) never short names, but do prepend a dot.
1832 * (Not MS-DOS or Win32 or Win64) maybe short name, maybe not: Try both.
1833 * Only use the short name if it is different.
1838 int shortname
= curbuf
->b_shortname
;
1840 curbuf
->b_shortname
= FALSE
;
1846 * May also add the file name with a dot prepended, for swap file in same
1847 * dir as original file.
1851 names
[num_names
] = modname(path
, (char_u
*)".sw?", TRUE
);
1852 if (names
[num_names
] == NULL
)
1858 * Form the normal swap file name pattern by appending ".sw?".
1861 names
[num_names
] = concat_fnames(path
, (char_u
*)"_sw%", FALSE
);
1864 names
[num_names
] = concat_fnames(path
, (char_u
*)"_sw#", FALSE
);
1866 names
[num_names
] = concat_fnames(path
, (char_u
*)".sw?", FALSE
);
1869 if (names
[num_names
] == NULL
)
1871 if (num_names
>= 1) /* check if we have the same name twice */
1873 p
= names
[num_names
- 1];
1874 i
= (int)STRLEN(names
[num_names
- 1]) - (int)STRLEN(names
[num_names
]);
1876 p
+= i
; /* file name has been expanded to full path */
1878 if (STRCMP(p
, names
[num_names
]) != 0)
1881 vim_free(names
[num_names
]);
1888 * Also try with 'shortname' set, in case the file is on a DOS filesystem.
1890 curbuf
->b_shortname
= TRUE
;
1892 names
[num_names
] = modname(path
, (char_u
*)"_sw%", FALSE
);
1895 names
[num_names
] = modname(path
, (char_u
*)"_sw#", FALSE
);
1897 names
[num_names
] = modname(path
, (char_u
*)".sw?", FALSE
);
1900 if (names
[num_names
] == NULL
)
1904 * Remove the one from 'shortname', if it's the same as with 'noshortname'.
1906 p
= names
[num_names
];
1907 i
= STRLEN(names
[num_names
]) - STRLEN(names
[num_names
- 1]);
1909 p
+= i
; /* file name has been expanded to full path */
1910 if (STRCMP(names
[num_names
- 1], p
) == 0)
1911 vim_free(names
[num_names
]);
1918 curbuf
->b_shortname
= shortname
;
1921 #endif /* !SHORT_FNAME */
1929 * If 'check_file' is TRUE, check if original file exists and was not changed.
1930 * If 'check_char' is TRUE, stop syncing when character becomes available, but
1931 * always sync at least one block.
1934 ml_sync_all(check_file
, check_char
)
1941 for (buf
= firstbuf
; buf
!= NULL
; buf
= buf
->b_next
)
1943 if (buf
->b_ml
.ml_mfp
== NULL
|| buf
->b_ml
.ml_mfp
->mf_fname
== NULL
)
1944 continue; /* no file */
1946 ml_flush_line(buf
); /* flush buffered line */
1947 /* flush locked block */
1948 (void)ml_find_line(buf
, (linenr_T
)0, ML_FLUSH
);
1949 if (bufIsChanged(buf
) && check_file
&& mf_need_trans(buf
->b_ml
.ml_mfp
)
1950 && buf
->b_ffname
!= NULL
)
1953 * If the original file does not exist anymore or has been changed
1954 * call ml_preserve() to get rid of all negative numbered blocks.
1956 if (mch_stat((char *)buf
->b_ffname
, &st
) == -1
1957 || st
.st_mtime
!= buf
->b_mtime_read
1958 || (size_t)st
.st_size
!= buf
->b_orig_size
)
1960 ml_preserve(buf
, FALSE
);
1961 did_check_timestamps
= FALSE
;
1962 need_check_timestamps
= TRUE
; /* give message later */
1965 if (buf
->b_ml
.ml_mfp
->mf_dirty
)
1967 (void)mf_sync(buf
->b_ml
.ml_mfp
, (check_char
? MFS_STOP
: 0)
1968 | (bufIsChanged(buf
) ? MFS_FLUSH
: 0));
1969 if (check_char
&& ui_char_avail()) /* character available now */
1976 * sync one buffer, including negative blocks
1978 * after this all the blocks are in the swap file
1980 * Used for the :preserve command and when the original file has been
1981 * changed or deleted.
1983 * when message is TRUE the success of preserving is reported
1986 ml_preserve(buf
, message
)
1992 memfile_T
*mfp
= buf
->b_ml
.ml_mfp
;
1994 int got_int_save
= got_int
;
1996 if (mfp
== NULL
|| mfp
->mf_fname
== NULL
)
1999 EMSG(_("E313: Cannot preserve, there is no swap file"));
2003 /* We only want to stop when interrupted here, not when interrupted
2007 ml_flush_line(buf
); /* flush buffered line */
2008 (void)ml_find_line(buf
, (linenr_T
)0, ML_FLUSH
); /* flush locked block */
2009 status
= mf_sync(mfp
, MFS_ALL
| MFS_FLUSH
);
2011 /* stack is invalid after mf_sync(.., MFS_ALL) */
2012 buf
->b_ml
.ml_stack_top
= 0;
2015 * Some of the data blocks may have been changed from negative to
2016 * positive block number. In that case the pointer blocks need to be
2019 * We don't know in which pointer block the references are, so we visit
2020 * all data blocks until there are no more translations to be done (or
2021 * we hit the end of the file, which can only happen in case a write fails,
2022 * e.g. when file system if full).
2023 * ml_find_line() does the work by translating the negative block numbers
2024 * when getting the first line of each data block.
2026 if (mf_need_trans(mfp
) && !got_int
)
2029 while (mf_need_trans(mfp
) && lnum
<= buf
->b_ml
.ml_line_count
)
2031 hp
= ml_find_line(buf
, lnum
, ML_FIND
);
2037 CHECK(buf
->b_ml
.ml_locked_low
!= lnum
, "low != lnum");
2038 lnum
= buf
->b_ml
.ml_locked_high
+ 1;
2040 (void)ml_find_line(buf
, (linenr_T
)0, ML_FLUSH
); /* flush locked block */
2041 /* sync the updated pointer blocks */
2042 if (mf_sync(mfp
, MFS_ALL
| MFS_FLUSH
) == FAIL
)
2044 buf
->b_ml
.ml_stack_top
= 0; /* stack is invalid now */
2047 got_int
|= got_int_save
;
2052 MSG(_("File preserved"));
2054 EMSG(_("E314: Preserve failed"));
2059 * NOTE: The pointer returned by the ml_get_*() functions only remains valid
2060 * until the next call!
2061 * line1 = ml_get(1);
2062 * line2 = ml_get(2); // line1 is now invalid!
2063 * Make a copy of the line if necessary.
2066 * get a pointer to a (read-only copy of a) line
2068 * On failure an error message is given and IObuff is returned (to avoid
2069 * having to check for error everywhere).
2075 return ml_get_buf(curbuf
, lnum
, FALSE
);
2079 * ml_get_pos: get pointer to position 'pos'
2085 return (ml_get_buf(curbuf
, pos
->lnum
, FALSE
) + pos
->col
);
2089 * ml_get_curline: get pointer to cursor line.
2094 return ml_get_buf(curbuf
, curwin
->w_cursor
.lnum
, FALSE
);
2098 * ml_get_cursor: get pointer to cursor position
2103 return (ml_get_buf(curbuf
, curwin
->w_cursor
.lnum
, FALSE
) +
2104 curwin
->w_cursor
.col
);
2108 * get a pointer to a line in a specific buffer
2110 * "will_change": if TRUE mark the buffer dirty (chars in the line will be
2114 ml_get_buf(buf
, lnum
, will_change
)
2117 int will_change
; /* line will be changed */
2122 static int recursive
= 0;
2124 if (lnum
> buf
->b_ml
.ml_line_count
) /* invalid line number */
2128 /* Avoid giving this message for a recursive call, may happen when
2129 * the GUI redraws part of the text. */
2131 EMSGN(_("E315: ml_get: invalid lnum: %ld"), lnum
);
2135 STRCPY(IObuff
, "???");
2138 if (lnum
<= 0) /* pretend line 0 is line 1 */
2141 if (buf
->b_ml
.ml_mfp
== NULL
) /* there are no lines */
2142 return (char_u
*)"";
2145 * See if it is the same line as requested last time.
2146 * Otherwise may need to flush last used line.
2147 * Don't use the last used line when 'swapfile' is reset, need to load all
2150 if (buf
->b_ml
.ml_line_lnum
!= lnum
|| mf_dont_release
)
2155 * Find the data block containing the line.
2156 * This also fills the stack with the blocks from the root to the data
2157 * block and releases any locked block.
2159 if ((hp
= ml_find_line(buf
, lnum
, ML_FIND
)) == NULL
)
2163 /* Avoid giving this message for a recursive call, may happen
2164 * when the GUI redraws part of the text. */
2166 EMSGN(_("E316: ml_get: cannot find line %ld"), lnum
);
2172 dp
= (DATA_BL
*)(hp
->bh_data
);
2174 ptr
= (char_u
*)dp
+ ((dp
->db_index
[lnum
- buf
->b_ml
.ml_locked_low
]) & DB_INDEX_MASK
);
2175 buf
->b_ml
.ml_line_ptr
= ptr
;
2176 buf
->b_ml
.ml_line_lnum
= lnum
;
2177 buf
->b_ml
.ml_flags
&= ~ML_LINE_DIRTY
;
2180 buf
->b_ml
.ml_flags
|= (ML_LOCKED_DIRTY
| ML_LOCKED_POS
);
2182 return buf
->b_ml
.ml_line_ptr
;
2186 * Check if a line that was just obtained by a call to ml_get
2187 * is in allocated memory.
2192 return (curbuf
->b_ml
.ml_flags
& ML_LINE_DIRTY
);
2196 * Append a line after lnum (may be 0 to insert a line in front of the file).
2197 * "line" does not need to be allocated, but can't be another line in a
2198 * buffer, unlocking may make it invalid.
2200 * newfile: TRUE when starting to edit a new file, meaning that pe_old_lnum
2201 * will be set for recovery
2202 * Check: The caller of this function should probably also call
2205 * return FAIL for failure, OK otherwise
2208 ml_append(lnum
, line
, len
, newfile
)
2209 linenr_T lnum
; /* append after this line (can be 0) */
2210 char_u
*line
; /* text of the new line */
2211 colnr_T len
; /* length of new line, including NUL, or 0 */
2212 int newfile
; /* flag, see above */
2214 /* When starting up, we might still need to create the memfile */
2215 if (curbuf
->b_ml
.ml_mfp
== NULL
&& open_buffer(FALSE
, NULL
) == FAIL
)
2218 if (curbuf
->b_ml
.ml_line_lnum
!= 0)
2219 ml_flush_line(curbuf
);
2220 return ml_append_int(curbuf
, lnum
, line
, len
, newfile
, FALSE
);
2224 * Append string to line lnum, with buffering, in current buffer.
2226 * Always makes a copy of the incoming string
2228 * Check: The caller of this function should probably also call
2229 * changed_lines(), unless update_screen(NOT_VALID) is used.
2231 * return FAIL for failure, OK otherwise
2234 ml_append_string(lnum
, string
, slen
)
2242 append_len
= STRLEN(string
);
2245 if (string
== NULL
) /* just checking... */
2249 ml_append (lnum
, string
, slen
, 0);
2251 /* When starting up, we might still need to create the memfile */
2252 if (curbuf
->b_ml
.ml_mfp
== NULL
&& open_buffer(FALSE
, NULL
) == FAIL
)
2255 #ifdef FEAT_NETBEANS_INTG
2257 #error I am 99% sure this is broken
2260 netbeans_removed(curbuf, lnum, 0, (long)STRLEN(ml_get(lnum)));
2261 netbeans_inserted(curbuf, lnum, 0, string, (int)STRLEN(string));
2265 if ((curbuf
->b_ml
.ml_line_lnum
!= lnum
) || /* other line buffered */
2266 (curbuf
->b_ml
.ml_flags
& ML_LINE_DIRTY
) == 0)
2268 ml_flush_line(curbuf
); /* flush it, this frees ml_line_ptr */
2270 /* Take a pointer to the existing line, will get re-alloced right
2271 * away below because it is not big enough */
2272 curbuf
->b_ml
.ml_line_ptr
= ml_get(lnum
);
2273 curbuf
->b_ml
.ml_flags
&= ~ML_LINE_DIRTY
;
2274 curbuf
->b_ml
.ml_line_max
= STRLEN(curbuf
->b_ml
.ml_line_ptr
);
2275 curbuf
->b_ml
.ml_line_lnum
= lnum
;
2278 * curbuf->b_ml.ml_line_ptr - is filled with the correct existing line
2279 * curbuf->b_ml.ml_line_max - is the alloced size of the line
2281 line_len
= STRLEN(curbuf
->b_ml
.ml_line_ptr
);
2282 if (curbuf
->b_ml
.ml_line_max
< line_len
+ append_len
+ 1)
2284 int new_len
= (curbuf
->b_ml
.ml_line_max
+ append_len
+ 2) * 2;
2286 if (new_len
< 80) new_len
= 80;
2287 new_line
= vim_strnsave(curbuf
->b_ml
.ml_line_ptr
, new_len
);
2288 if (curbuf
->b_ml
.ml_flags
& ML_LINE_DIRTY
)
2289 vim_free(curbuf
->b_ml
.ml_line_ptr
);
2290 curbuf
->b_ml
.ml_line_ptr
= new_line
;
2291 curbuf
->b_ml
.ml_line_max
= new_len
;
2292 curbuf
->b_ml
.ml_flags
= (curbuf
->b_ml
.ml_flags
| ML_LINE_DIRTY
) & ~ML_EMPTY
;
2295 * ml_line_ptr is allocated to fit the current line + the append
2296 * ml_line_max is the total alloced size of the line
2298 STRCPY (&curbuf
->b_ml
.ml_line_ptr
[line_len
], string
); /* Append our string */
2299 curbuf
->b_ml
.ml_line_ptr
[line_len
+ append_len
] = NUL
; /* End the line */
2305 #if defined(FEAT_SPELL) || defined(PROTO)
2307 * Like ml_append() but for an arbitrary buffer. The buffer must already have
2311 ml_append_buf(buf
, lnum
, line
, len
, newfile
)
2313 linenr_T lnum
; /* append after this line (can be 0) */
2314 char_u
*line
; /* text of the new line */
2315 colnr_T len
; /* length of new line, including NUL, or 0 */
2316 int newfile
; /* flag, see above */
2318 if (buf
->b_ml
.ml_mfp
== NULL
)
2321 if (buf
->b_ml
.ml_line_lnum
!= 0)
2323 return ml_append_int(buf
, lnum
, line
, len
, newfile
, FALSE
);
2328 ml_append_int(buf
, lnum
, line
, len
, newfile
, mark
)
2330 linenr_T lnum
; /* append after this line (can be 0) */
2331 char_u
*line
; /* text of the new line */
2332 colnr_T len
; /* length of line, including NUL, or 0 */
2333 int newfile
; /* flag, see above */
2334 int mark
; /* mark the new line */
2337 int line_count
; /* number of indexes in current block */
2340 int space_needed
; /* space needed for new line */
2343 int db_idx
; /* index for lnum in data block */
2350 /* lnum out of range */
2351 if (lnum
> buf
->b_ml
.ml_line_count
|| buf
->b_ml
.ml_mfp
== NULL
)
2354 if (lowest_marked
&& lowest_marked
> lnum
)
2355 lowest_marked
= lnum
+ 1;
2358 len
= (colnr_T
)STRLEN(line
) + 1; /* space needed for the text */
2359 space_needed
= len
+ INDEX_SIZE
; /* space needed for text + index */
2361 mfp
= buf
->b_ml
.ml_mfp
;
2362 page_size
= mfp
->mf_page_size
;
2365 * find the data block containing the previous line
2366 * This also fills the stack with the blocks from the root to the data block
2367 * This also releases any locked block.
2369 if ((hp
= ml_find_line(buf
, lnum
== 0 ? (linenr_T
)1 : lnum
,
2370 ML_INSERT
)) == NULL
)
2373 buf
->b_ml
.ml_flags
&= ~ML_EMPTY
;
2375 if (lnum
== 0) /* got line one instead, correct db_idx */
2376 db_idx
= -1; /* careful, it is negative! */
2378 db_idx
= lnum
- buf
->b_ml
.ml_locked_low
;
2379 /* get line count before the insertion */
2380 line_count
= buf
->b_ml
.ml_locked_high
- buf
->b_ml
.ml_locked_low
;
2382 dp
= (DATA_BL
*)(hp
->bh_data
);
2386 * - there is not enough room in the current block
2387 * - appending to the last line in the block
2388 * - not appending to the last line in the file
2389 * insert in front of the next block.
2391 if ((int)dp
->db_free
< space_needed
&& db_idx
== line_count
- 1
2392 && lnum
< buf
->b_ml
.ml_line_count
)
2395 * Now that the line is not going to be inserted in the block that we
2396 * expected, the line count has to be adjusted in the pointer blocks
2397 * by using ml_locked_lineadd.
2399 --(buf
->b_ml
.ml_locked_lineadd
);
2400 --(buf
->b_ml
.ml_locked_high
);
2401 if ((hp
= ml_find_line(buf
, lnum
+ 1, ML_INSERT
)) == NULL
)
2404 db_idx
= -1; /* careful, it is negative! */
2405 /* get line count before the insertion */
2406 line_count
= buf
->b_ml
.ml_locked_high
- buf
->b_ml
.ml_locked_low
;
2407 CHECK(buf
->b_ml
.ml_locked_low
!= lnum
+ 1, "locked_low != lnum + 1");
2409 dp
= (DATA_BL
*)(hp
->bh_data
);
2412 ++buf
->b_ml
.ml_line_count
;
2414 if ((int)dp
->db_free
>= space_needed
) /* enough room in data block */
2417 * Insert new line in existing data block, or in data block allocated above.
2419 dp
->db_txt_start
-= len
;
2420 dp
->db_free
-= space_needed
;
2421 ++(dp
->db_line_count
);
2424 * move the text of the lines that follow to the front
2425 * adjust the indexes of the lines that follow
2427 if (line_count
> db_idx
+ 1) /* if there are following lines */
2430 * Offset is the start of the previous line.
2431 * This will become the character just after the new line.
2434 offset
= dp
->db_txt_end
;
2436 offset
= ((dp
->db_index
[db_idx
]) & DB_INDEX_MASK
);
2437 mch_memmove((char *)dp
+ dp
->db_txt_start
,
2438 (char *)dp
+ dp
->db_txt_start
+ len
,
2439 (size_t)(offset
- (dp
->db_txt_start
+ len
)));
2440 for (i
= line_count
- 1; i
> db_idx
; --i
)
2441 dp
->db_index
[i
+ 1] = dp
->db_index
[i
] - len
;
2442 dp
->db_index
[db_idx
+ 1] = offset
- len
;
2444 else /* add line at the end */
2445 dp
->db_index
[db_idx
+ 1] = dp
->db_txt_start
;
2448 * copy the text into the block
2450 mch_memmove((char *)dp
+ dp
->db_index
[db_idx
+ 1], line
, (size_t)len
);
2452 dp
->db_index
[db_idx
+ 1] |= DB_MARKED
;
2455 * Mark the block dirty.
2457 buf
->b_ml
.ml_flags
|= ML_LOCKED_DIRTY
;
2459 buf
->b_ml
.ml_flags
|= ML_LOCKED_POS
;
2461 else /* not enough space in data block */
2464 * If there is not enough room we have to create a new data block and copy some
2466 * Then we have to insert an entry in the pointer block.
2467 * If this pointer block also is full, we go up another block, and so on, up
2468 * to the root if necessary.
2469 * The line counts in the pointer blocks have already been adjusted by
2472 long line_count_left
, line_count_right
;
2473 int page_count_left
, page_count_right
;
2478 int data_moved
= 0; /* init to shut up gcc */
2479 int total_moved
= 0; /* init to shut up gcc */
2480 DATA_BL
*dp_right
, *dp_left
;
2484 blocknr_T bnum_left
, bnum_right
;
2485 linenr_T lnum_left
, lnum_right
;
2490 * We are going to allocate a new data block. Depending on the
2491 * situation it will be put to the left or right of the existing
2492 * block. If possible we put the new line in the left block and move
2493 * the lines after it to the right block. Otherwise the new line is
2494 * also put in the right block. This method is more efficient when
2495 * inserting a lot of lines at one place.
2497 if (db_idx
< 0) /* left block is new, right block is existing */
2501 /* space_needed does not change */
2503 else /* left block is existing, right block is new */
2505 lines_moved
= line_count
- db_idx
- 1;
2506 if (lines_moved
== 0)
2507 in_left
= FALSE
; /* put new line in right block */
2508 /* space_needed does not change */
2511 data_moved
= ((dp
->db_index
[db_idx
]) & DB_INDEX_MASK
) -
2513 total_moved
= data_moved
+ lines_moved
* INDEX_SIZE
;
2514 if ((int)dp
->db_free
+ total_moved
>= space_needed
)
2516 in_left
= TRUE
; /* put new line in left block */
2517 space_needed
= total_moved
;
2521 in_left
= FALSE
; /* put new line in right block */
2522 space_needed
+= total_moved
;
2527 page_count
= ((space_needed
+ HEADER_SIZE
) + page_size
- 1) / page_size
;
2528 if ((hp_new
= ml_new_data(mfp
, newfile
, page_count
)) == NULL
)
2530 /* correct line counts in pointer blocks */
2531 --(buf
->b_ml
.ml_locked_lineadd
);
2532 --(buf
->b_ml
.ml_locked_high
);
2535 if (db_idx
< 0) /* left block is new */
2539 line_count_left
= 0;
2540 line_count_right
= line_count
;
2542 else /* right block is new */
2546 line_count_left
= line_count
;
2547 line_count_right
= 0;
2549 dp_right
= (DATA_BL
*)(hp_right
->bh_data
);
2550 dp_left
= (DATA_BL
*)(hp_left
->bh_data
);
2551 bnum_left
= hp_left
->bh_bnum
;
2552 bnum_right
= hp_right
->bh_bnum
;
2553 page_count_left
= hp_left
->bh_page_count
;
2554 page_count_right
= hp_right
->bh_page_count
;
2557 * May move the new line into the right/new block.
2561 dp_right
->db_txt_start
-= len
;
2562 dp_right
->db_free
-= len
+ INDEX_SIZE
;
2563 dp_right
->db_index
[0] = dp_right
->db_txt_start
;
2565 dp_right
->db_index
[0] |= DB_MARKED
;
2567 mch_memmove((char *)dp_right
+ dp_right
->db_txt_start
,
2572 * may move lines from the left/old block to the right/new one.
2578 dp_right
->db_txt_start
-= data_moved
;
2579 dp_right
->db_free
-= total_moved
;
2580 mch_memmove((char *)dp_right
+ dp_right
->db_txt_start
,
2581 (char *)dp_left
+ dp_left
->db_txt_start
,
2582 (size_t)data_moved
);
2583 offset
= dp_right
->db_txt_start
- dp_left
->db_txt_start
;
2584 dp_left
->db_txt_start
+= data_moved
;
2585 dp_left
->db_free
+= total_moved
;
2588 * update indexes in the new block
2590 for (to
= line_count_right
, from
= db_idx
+ 1;
2591 from
< line_count_left
; ++from
, ++to
)
2592 dp_right
->db_index
[to
] = dp
->db_index
[from
] + offset
;
2593 line_count_right
+= lines_moved
;
2594 line_count_left
-= lines_moved
;
2598 * May move the new line into the left (old or new) block.
2602 dp_left
->db_txt_start
-= len
;
2603 dp_left
->db_free
-= len
+ INDEX_SIZE
;
2604 dp_left
->db_index
[line_count_left
] = dp_left
->db_txt_start
;
2606 dp_left
->db_index
[line_count_left
] |= DB_MARKED
;
2607 mch_memmove((char *)dp_left
+ dp_left
->db_txt_start
,
2612 if (db_idx
< 0) /* left block is new */
2614 lnum_left
= lnum
+ 1;
2617 else /* right block is new */
2621 lnum_right
= lnum
+ 2;
2623 lnum_right
= lnum
+ 1;
2625 dp_left
->db_line_count
= line_count_left
;
2626 dp_right
->db_line_count
= line_count_right
;
2629 * release the two data blocks
2630 * The new one (hp_new) already has a correct blocknumber.
2631 * The old one (hp, in ml_locked) gets a positive blocknumber if
2632 * we changed it and we are not editing a new file.
2634 if (lines_moved
|| in_left
)
2635 buf
->b_ml
.ml_flags
|= ML_LOCKED_DIRTY
;
2636 if (!newfile
&& db_idx
>= 0 && in_left
)
2637 buf
->b_ml
.ml_flags
|= ML_LOCKED_POS
;
2638 mf_put(mfp
, hp_new
, TRUE
, FALSE
);
2641 * flush the old data block
2642 * set ml_locked_lineadd to 0, because the updating of the
2643 * pointer blocks is done below
2645 lineadd
= buf
->b_ml
.ml_locked_lineadd
;
2646 buf
->b_ml
.ml_locked_lineadd
= 0;
2647 ml_find_line(buf
, (linenr_T
)0, ML_FLUSH
); /* flush data block */
2650 * update pointer blocks for the new data block
2652 for (stack_idx
= buf
->b_ml
.ml_stack_top
- 1; stack_idx
>= 0;
2655 ip
= &(buf
->b_ml
.ml_stack
[stack_idx
]);
2656 pb_idx
= ip
->ip_index
;
2657 if ((hp
= mf_get(mfp
, ip
->ip_bnum
, 1)) == NULL
)
2659 pp
= (PTR_BL
*)(hp
->bh_data
); /* must be pointer block */
2660 if (pp
->pb_id
!= PTR_ID
)
2662 EMSG(_("E317: pointer block id wrong 3"));
2663 mf_put(mfp
, hp
, FALSE
, FALSE
);
2667 * TODO: If the pointer block is full and we are adding at the end
2668 * try to insert in front of the next block
2670 /* block not full, add one entry */
2671 if (pp
->pb_count
< pp
->pb_count_max
)
2673 if (pb_idx
+ 1 < (int)pp
->pb_count
)
2674 mch_memmove(&pp
->pb_pointer
[pb_idx
+ 2],
2675 &pp
->pb_pointer
[pb_idx
+ 1],
2676 (size_t)(pp
->pb_count
- pb_idx
- 1) * sizeof(PTR_EN
));
2678 pp
->pb_pointer
[pb_idx
].pe_line_count
= line_count_left
;
2679 pp
->pb_pointer
[pb_idx
].pe_bnum
= bnum_left
;
2680 pp
->pb_pointer
[pb_idx
].pe_page_count
= page_count_left
;
2681 pp
->pb_pointer
[pb_idx
+ 1].pe_line_count
= line_count_right
;
2682 pp
->pb_pointer
[pb_idx
+ 1].pe_bnum
= bnum_right
;
2683 pp
->pb_pointer
[pb_idx
+ 1].pe_page_count
= page_count_right
;
2686 pp
->pb_pointer
[pb_idx
].pe_old_lnum
= lnum_left
;
2687 if (lnum_right
!= 0)
2688 pp
->pb_pointer
[pb_idx
+ 1].pe_old_lnum
= lnum_right
;
2690 mf_put(mfp
, hp
, TRUE
, FALSE
);
2691 buf
->b_ml
.ml_stack_top
= stack_idx
+ 1; /* truncate stack */
2695 --(buf
->b_ml
.ml_stack_top
);
2696 /* fix line count for rest of blocks in the stack */
2697 ml_lineadd(buf
, lineadd
);
2698 /* fix stack itself */
2699 buf
->b_ml
.ml_stack
[buf
->b_ml
.ml_stack_top
].ip_high
+=
2701 ++(buf
->b_ml
.ml_stack_top
);
2705 * We are finished, break the loop here.
2709 else /* pointer block full */
2712 * split the pointer block
2713 * allocate a new pointer block
2714 * move some of the pointer into the new block
2715 * prepare for updating the parent block
2717 for (;;) /* do this twice when splitting block 1 */
2719 hp_new
= ml_new_ptr(mfp
);
2720 if (hp_new
== NULL
) /* TODO: try to fix tree */
2722 pp_new
= (PTR_BL
*)(hp_new
->bh_data
);
2724 if (hp
->bh_bnum
!= 1)
2728 * if block 1 becomes full the tree is given an extra level
2729 * The pointers from block 1 are moved into the new block.
2730 * block 1 is updated to point to the new block
2731 * then continue to split the new block
2733 mch_memmove(pp_new
, pp
, (size_t)page_size
);
2735 pp
->pb_pointer
[0].pe_bnum
= hp_new
->bh_bnum
;
2736 pp
->pb_pointer
[0].pe_line_count
= buf
->b_ml
.ml_line_count
;
2737 pp
->pb_pointer
[0].pe_old_lnum
= 1;
2738 pp
->pb_pointer
[0].pe_page_count
= 1;
2739 mf_put(mfp
, hp
, TRUE
, FALSE
); /* release block 1 */
2740 hp
= hp_new
; /* new block is to be split */
2742 CHECK(stack_idx
!= 0, _("stack_idx should be 0"));
2744 ++stack_idx
; /* do block 1 again later */
2747 * move the pointers after the current one to the new block
2748 * If there are none, the new entry will be in the new block.
2750 total_moved
= pp
->pb_count
- pb_idx
- 1;
2753 mch_memmove(&pp_new
->pb_pointer
[0],
2754 &pp
->pb_pointer
[pb_idx
+ 1],
2755 (size_t)(total_moved
) * sizeof(PTR_EN
));
2756 pp_new
->pb_count
= total_moved
;
2757 pp
->pb_count
-= total_moved
- 1;
2758 pp
->pb_pointer
[pb_idx
+ 1].pe_bnum
= bnum_right
;
2759 pp
->pb_pointer
[pb_idx
+ 1].pe_line_count
= line_count_right
;
2760 pp
->pb_pointer
[pb_idx
+ 1].pe_page_count
= page_count_right
;
2762 pp
->pb_pointer
[pb_idx
+ 1].pe_old_lnum
= lnum_right
;
2766 pp_new
->pb_count
= 1;
2767 pp_new
->pb_pointer
[0].pe_bnum
= bnum_right
;
2768 pp_new
->pb_pointer
[0].pe_line_count
= line_count_right
;
2769 pp_new
->pb_pointer
[0].pe_page_count
= page_count_right
;
2770 pp_new
->pb_pointer
[0].pe_old_lnum
= lnum_right
;
2772 pp
->pb_pointer
[pb_idx
].pe_bnum
= bnum_left
;
2773 pp
->pb_pointer
[pb_idx
].pe_line_count
= line_count_left
;
2774 pp
->pb_pointer
[pb_idx
].pe_page_count
= page_count_left
;
2776 pp
->pb_pointer
[pb_idx
].pe_old_lnum
= lnum_left
;
2781 * recompute line counts
2783 line_count_right
= 0;
2784 for (i
= 0; i
< (int)pp_new
->pb_count
; ++i
)
2785 line_count_right
+= pp_new
->pb_pointer
[i
].pe_line_count
;
2786 line_count_left
= 0;
2787 for (i
= 0; i
< (int)pp
->pb_count
; ++i
)
2788 line_count_left
+= pp
->pb_pointer
[i
].pe_line_count
;
2790 bnum_left
= hp
->bh_bnum
;
2791 bnum_right
= hp_new
->bh_bnum
;
2792 page_count_left
= 1;
2793 page_count_right
= 1;
2794 mf_put(mfp
, hp
, TRUE
, FALSE
);
2795 mf_put(mfp
, hp_new
, TRUE
, FALSE
);
2800 * Safety check: fallen out of for loop?
2804 EMSG(_("E318: Updated too many blocks?"));
2805 buf
->b_ml
.ml_stack_top
= 0; /* invalidate stack */
2810 /* The line was inserted below 'lnum' */
2811 ml_updatechunk(buf
, lnum
+ 1, (long)len
, ML_CHNK_ADDLINE
);
2813 #ifdef FEAT_NETBEANS_INTG
2816 if (STRLEN(line
) > 0)
2817 netbeans_inserted(buf
, lnum
+1, (colnr_T
)0, line
, (int)STRLEN(line
));
2818 netbeans_inserted(buf
, lnum
+1, (colnr_T
)STRLEN(line
),
2826 * Replace line lnum, with buffering, in current buffer.
2828 * If "copy" is TRUE, make a copy of the line, otherwise the line has been
2829 * copied to allocated memory already.
2831 * Check: The caller of this function should probably also call
2832 * changed_lines(), unless update_screen(NOT_VALID) is used.
2834 * return FAIL for failure, OK otherwise
2837 ml_replace(lnum
, line
, copy
)
2842 if (line
== NULL
) /* just checking... */
2845 /* When starting up, we might still need to create the memfile */
2846 if (curbuf
->b_ml
.ml_mfp
== NULL
&& open_buffer(FALSE
, NULL
) == FAIL
)
2849 if (copy
&& (line
= vim_strsave(line
)) == NULL
) /* allocate memory */
2851 #ifdef FEAT_NETBEANS_INTG
2854 netbeans_removed(curbuf
, lnum
, 0, (long)STRLEN(ml_get(lnum
)));
2855 netbeans_inserted(curbuf
, lnum
, 0, line
, (int)STRLEN(line
));
2858 if (curbuf
->b_ml
.ml_line_lnum
!= lnum
) /* other line buffered */
2859 ml_flush_line(curbuf
); /* flush it */
2860 else if (curbuf
->b_ml
.ml_flags
& ML_LINE_DIRTY
) /* same line allocated */
2861 vim_free(curbuf
->b_ml
.ml_line_ptr
); /* free it */
2862 curbuf
->b_ml
.ml_line_ptr
= line
;
2863 curbuf
->b_ml
.ml_line_lnum
= lnum
;
2864 curbuf
->b_ml
.ml_line_max
= 0;
2865 curbuf
->b_ml
.ml_flags
= (curbuf
->b_ml
.ml_flags
| ML_LINE_DIRTY
) & ~ML_EMPTY
;
2871 * Delete line 'lnum' in the current buffer.
2873 * Check: The caller of this function should probably also call
2874 * deleted_lines() after this.
2876 * return FAIL for failure, OK otherwise
2879 ml_delete(lnum
, message
)
2883 ml_flush_line(curbuf
);
2884 return ml_delete_int(curbuf
, lnum
, message
);
2888 ml_delete_int(buf
, lnum
, message
)
2898 int count
; /* number of entries in block */
2906 if (lnum
< 1 || lnum
> buf
->b_ml
.ml_line_count
)
2909 if (lowest_marked
&& lowest_marked
> lnum
)
2913 * If the file becomes empty the last line is replaced by an empty line.
2915 if (buf
->b_ml
.ml_line_count
== 1) /* file becomes empty */
2918 #ifdef FEAT_NETBEANS_INTG
2919 && !netbeansSuppressNoLines
2922 set_keep_msg((char_u
*)_(no_lines_msg
), 0);
2924 /* FEAT_BYTEOFF already handled in there, dont worry 'bout it below */
2925 i
= ml_replace((linenr_T
)1, (char_u
*)"", TRUE
);
2926 buf
->b_ml
.ml_flags
|= ML_EMPTY
;
2932 * find the data block containing the line
2933 * This also fills the stack with the blocks from the root to the data block
2934 * This also releases any locked block.
2936 mfp
= buf
->b_ml
.ml_mfp
;
2940 if ((hp
= ml_find_line(buf
, lnum
, ML_DELETE
)) == NULL
)
2943 dp
= (DATA_BL
*)(hp
->bh_data
);
2944 /* compute line count before the delete */
2945 count
= (long)(buf
->b_ml
.ml_locked_high
)
2946 - (long)(buf
->b_ml
.ml_locked_low
) + 2;
2947 idx
= lnum
- buf
->b_ml
.ml_locked_low
;
2949 --buf
->b_ml
.ml_line_count
;
2951 line_start
= ((dp
->db_index
[idx
]) & DB_INDEX_MASK
);
2952 if (idx
== 0) /* first line in block, text at the end */
2953 line_size
= dp
->db_txt_end
- line_start
;
2955 line_size
= ((dp
->db_index
[idx
- 1]) & DB_INDEX_MASK
) - line_start
;
2957 #ifdef FEAT_NETBEANS_INTG
2959 netbeans_removed(buf
, lnum
, 0, (long)line_size
);
2963 * special case: If there is only one line in the data block it becomes empty.
2964 * Then we have to remove the entry, pointing to this data block, from the
2965 * pointer block. If this pointer block also becomes empty, we go up another
2966 * block, and so on, up to the root if necessary.
2967 * The line counts in the pointer blocks have already been adjusted by
2972 mf_free(mfp
, hp
); /* free the data block */
2973 buf
->b_ml
.ml_locked
= NULL
;
2975 for (stack_idx
= buf
->b_ml
.ml_stack_top
- 1; stack_idx
>= 0; --stack_idx
)
2977 buf
->b_ml
.ml_stack_top
= 0; /* stack is invalid when failing */
2978 ip
= &(buf
->b_ml
.ml_stack
[stack_idx
]);
2980 if ((hp
= mf_get(mfp
, ip
->ip_bnum
, 1)) == NULL
)
2982 pp
= (PTR_BL
*)(hp
->bh_data
); /* must be pointer block */
2983 if (pp
->pb_id
!= PTR_ID
)
2985 EMSG(_("E317: pointer block id wrong 4"));
2986 mf_put(mfp
, hp
, FALSE
, FALSE
);
2989 count
= --(pp
->pb_count
);
2990 if (count
== 0) /* the pointer block becomes empty! */
2994 if (count
!= idx
) /* move entries after the deleted one */
2995 mch_memmove(&pp
->pb_pointer
[idx
], &pp
->pb_pointer
[idx
+ 1],
2996 (size_t)(count
- idx
) * sizeof(PTR_EN
));
2997 mf_put(mfp
, hp
, TRUE
, FALSE
);
2999 buf
->b_ml
.ml_stack_top
= stack_idx
; /* truncate stack */
3000 /* fix line count for rest of blocks in the stack */
3001 if (buf
->b_ml
.ml_locked_lineadd
!= 0)
3003 ml_lineadd(buf
, buf
->b_ml
.ml_locked_lineadd
);
3004 buf
->b_ml
.ml_stack
[buf
->b_ml
.ml_stack_top
].ip_high
+=
3005 buf
->b_ml
.ml_locked_lineadd
;
3007 ++(buf
->b_ml
.ml_stack_top
);
3012 CHECK(stack_idx
< 0, _("deleted block 1?"));
3017 * delete the text by moving the next lines forwards
3019 text_start
= dp
->db_txt_start
;
3020 mch_memmove((char *)dp
+ text_start
+ line_size
,
3021 (char *)dp
+ text_start
, (size_t)(line_start
- text_start
));
3024 * delete the index by moving the next indexes backwards
3025 * Adjust the indexes for the text movement.
3027 for (i
= idx
; i
< count
- 1; ++i
)
3028 dp
->db_index
[i
] = dp
->db_index
[i
+ 1] + line_size
;
3030 dp
->db_free
+= line_size
+ INDEX_SIZE
;
3031 dp
->db_txt_start
+= line_size
;
3032 --(dp
->db_line_count
);
3035 * mark the block dirty and make sure it is in the file (for recovery)
3037 buf
->b_ml
.ml_flags
|= (ML_LOCKED_DIRTY
| ML_LOCKED_POS
);
3041 ml_updatechunk(buf
, lnum
, line_size
, ML_CHNK_DELLINE
);
3047 * set the B_MARKED flag for line 'lnum'
3055 /* invalid line number */
3056 if (lnum
< 1 || lnum
> curbuf
->b_ml
.ml_line_count
3057 || curbuf
->b_ml
.ml_mfp
== NULL
)
3058 return; /* give error message? */
3060 if (lowest_marked
== 0 || lowest_marked
> lnum
)
3061 lowest_marked
= lnum
;
3064 * find the data block containing the line
3065 * This also fills the stack with the blocks from the root to the data block
3066 * This also releases any locked block.
3068 if ((hp
= ml_find_line(curbuf
, lnum
, ML_FIND
)) == NULL
)
3069 return; /* give error message? */
3071 dp
= (DATA_BL
*)(hp
->bh_data
);
3072 dp
->db_index
[lnum
- curbuf
->b_ml
.ml_locked_low
] |= DB_MARKED
;
3073 curbuf
->b_ml
.ml_flags
|= ML_LOCKED_DIRTY
;
3077 * find the first line with its B_MARKED flag set
3087 if (curbuf
->b_ml
.ml_mfp
== NULL
)
3088 return (linenr_T
) 0;
3091 * The search starts with lowest_marked line. This is the last line where
3092 * a mark was found, adjusted by inserting/deleting lines.
3094 for (lnum
= lowest_marked
; lnum
<= curbuf
->b_ml
.ml_line_count
; )
3097 * Find the data block containing the line.
3098 * This also fills the stack with the blocks from the root to the data
3099 * block This also releases any locked block.
3101 if ((hp
= ml_find_line(curbuf
, lnum
, ML_FIND
)) == NULL
)
3102 return (linenr_T
)0; /* give error message? */
3104 dp
= (DATA_BL
*)(hp
->bh_data
);
3106 for (i
= lnum
- curbuf
->b_ml
.ml_locked_low
;
3107 lnum
<= curbuf
->b_ml
.ml_locked_high
; ++i
, ++lnum
)
3108 if ((dp
->db_index
[i
]) & DB_MARKED
)
3110 (dp
->db_index
[i
]) &= DB_INDEX_MASK
;
3111 curbuf
->b_ml
.ml_flags
|= ML_LOCKED_DIRTY
;
3112 lowest_marked
= lnum
+ 1;
3117 return (linenr_T
) 0;
3120 #if 0 /* not used */
3122 * return TRUE if line 'lnum' has a mark
3131 if (curbuf
->b_ml
.ml_mfp
== NULL
3132 || (hp
= ml_find_line(curbuf
, lnum
, ML_FIND
)) == NULL
)
3135 dp
= (DATA_BL
*)(hp
->bh_data
);
3136 return (int)((dp
->db_index
[lnum
- curbuf
->b_ml
.ml_locked_low
]) & DB_MARKED
);
3141 * clear all DB_MARKED flags
3151 if (curbuf
->b_ml
.ml_mfp
== NULL
) /* nothing to do */
3155 * The search starts with line lowest_marked.
3157 for (lnum
= lowest_marked
; lnum
<= curbuf
->b_ml
.ml_line_count
; )
3160 * Find the data block containing the line.
3161 * This also fills the stack with the blocks from the root to the data
3162 * block and releases any locked block.
3164 if ((hp
= ml_find_line(curbuf
, lnum
, ML_FIND
)) == NULL
)
3165 return; /* give error message? */
3167 dp
= (DATA_BL
*)(hp
->bh_data
);
3169 for (i
= lnum
- curbuf
->b_ml
.ml_locked_low
;
3170 lnum
<= curbuf
->b_ml
.ml_locked_high
; ++i
, ++lnum
)
3171 if ((dp
->db_index
[i
]) & DB_MARKED
)
3173 (dp
->db_index
[i
]) &= DB_INDEX_MASK
;
3174 curbuf
->b_ml
.ml_flags
|= ML_LOCKED_DIRTY
;
3183 * flush ml_line if necessary
3201 static int entered
= FALSE
;
3203 if (buf
->b_ml
.ml_line_lnum
== 0 || buf
->b_ml
.ml_mfp
== NULL
)
3204 return; /* nothing to do */
3206 if (buf
->b_ml
.ml_flags
& ML_LINE_DIRTY
)
3208 /* This code doesn't work recursively, but Netbeans may call back here
3209 * when obtaining the cursor position. */
3214 lnum
= buf
->b_ml
.ml_line_lnum
;
3215 new_line
= buf
->b_ml
.ml_line_ptr
;
3217 hp
= ml_find_line(buf
, lnum
, ML_FIND
);
3219 EMSGN(_("E320: Cannot find line %ld"), lnum
);
3222 dp
= (DATA_BL
*)(hp
->bh_data
);
3223 idx
= lnum
- buf
->b_ml
.ml_locked_low
;
3224 start
= ((dp
->db_index
[idx
]) & DB_INDEX_MASK
);
3225 old_line
= (char_u
*)dp
+ start
;
3226 if (idx
== 0) /* line is last in block */
3227 old_len
= dp
->db_txt_end
- start
;
3228 else /* text of previous line follows */
3229 old_len
= (dp
->db_index
[idx
- 1] & DB_INDEX_MASK
) - start
;
3230 new_len
= (colnr_T
)STRLEN(new_line
) + 1;
3231 extra
= new_len
- old_len
; /* negative if lines gets smaller */
3234 * if new line fits in data block, replace directly
3236 if ((int)dp
->db_free
>= extra
)
3238 /* if the length changes and there are following lines */
3239 count
= buf
->b_ml
.ml_locked_high
- buf
->b_ml
.ml_locked_low
+ 1;
3240 if (extra
!= 0 && idx
< count
- 1)
3242 /* move text of following lines */
3243 mch_memmove((char *)dp
+ dp
->db_txt_start
- extra
,
3244 (char *)dp
+ dp
->db_txt_start
,
3245 (size_t)(start
- dp
->db_txt_start
));
3247 /* adjust pointers of this and following lines */
3248 for (i
= idx
+ 1; i
< count
; ++i
)
3249 dp
->db_index
[i
] -= extra
;
3251 dp
->db_index
[idx
] -= extra
;
3253 /* adjust free space */
3254 dp
->db_free
-= extra
;
3255 dp
->db_txt_start
-= extra
;
3257 /* copy new line into the data block */
3258 mch_memmove(old_line
- extra
, new_line
, (size_t)new_len
);
3259 buf
->b_ml
.ml_flags
|= (ML_LOCKED_DIRTY
| ML_LOCKED_POS
);
3261 /* The else case is already covered by the insert and delete */
3262 ml_updatechunk(buf
, lnum
, (long)extra
, ML_CHNK_UPDLINE
);
3268 * Cannot do it in one data block: Delete and append.
3269 * Append first, because ml_delete_int() cannot delete the
3270 * last line in a buffer, which causes trouble for a buffer
3271 * that has only one line.
3272 * Don't forget to copy the mark!
3274 /* How about handling errors??? */
3275 (void)ml_append_int(buf
, lnum
, new_line
, new_len
, FALSE
,
3276 (dp
->db_index
[idx
] & DB_MARKED
));
3277 (void)ml_delete_int(buf
, lnum
, FALSE
);
3285 buf
->b_ml
.ml_line_lnum
= 0;
3289 * create a new, empty, data block
3292 ml_new_data(mfp
, negative
, page_count
)
3300 if ((hp
= mf_new(mfp
, negative
, page_count
)) == NULL
)
3303 dp
= (DATA_BL
*)(hp
->bh_data
);
3304 dp
->db_id
= DATA_ID
;
3305 dp
->db_txt_start
= dp
->db_txt_end
= page_count
* mfp
->mf_page_size
;
3306 dp
->db_free
= dp
->db_txt_start
- HEADER_SIZE
;
3307 dp
->db_line_count
= 0;
3313 * create a new, empty, pointer block
3322 if ((hp
= mf_new(mfp
, FALSE
, 1)) == NULL
)
3325 pp
= (PTR_BL
*)(hp
->bh_data
);
3328 pp
->pb_count_max
= (short_u
)((mfp
->mf_page_size
- sizeof(PTR_BL
)) / sizeof(PTR_EN
) + 1);
3334 * lookup line 'lnum' in a memline
3336 * action: if ML_DELETE or ML_INSERT the line count is updated while searching
3337 * if ML_FLUSH only flush a locked block
3338 * if ML_FIND just find the line
3340 * If the block was found it is locked and put in ml_locked.
3341 * The stack is updated to lead to the locked block. The ip_high field in
3342 * the stack is updated to reflect the last line in the block AFTER the
3343 * insert or delete, also if the pointer block has not been updated yet. But
3344 * if ml_locked != NULL ml_locked_lineadd must be added to ip_high.
3346 * return: NULL for failure, pointer to block header otherwise
3349 ml_find_line(buf
, lnum
, action
)
3360 blocknr_T bnum
, bnum2
;
3367 mfp
= buf
->b_ml
.ml_mfp
;
3370 * If there is a locked block check if the wanted line is in it.
3371 * If not, flush and release the locked block.
3372 * Don't do this for ML_INSERT_SAME, because the stack need to be updated.
3373 * Don't do this for ML_FLUSH, because we want to flush the locked block.
3374 * Don't do this when 'swapfile' is reset, we want to load all the blocks.
3376 if (buf
->b_ml
.ml_locked
)
3378 if (ML_SIMPLE(action
)
3379 && buf
->b_ml
.ml_locked_low
<= lnum
3380 && buf
->b_ml
.ml_locked_high
>= lnum
3381 && !mf_dont_release
)
3383 /* remember to update pointer blocks and stack later */
3384 if (action
== ML_INSERT
)
3386 ++(buf
->b_ml
.ml_locked_lineadd
);
3387 ++(buf
->b_ml
.ml_locked_high
);
3389 else if (action
== ML_DELETE
)
3391 --(buf
->b_ml
.ml_locked_lineadd
);
3392 --(buf
->b_ml
.ml_locked_high
);
3394 return (buf
->b_ml
.ml_locked
);
3397 mf_put(mfp
, buf
->b_ml
.ml_locked
, buf
->b_ml
.ml_flags
& ML_LOCKED_DIRTY
,
3398 buf
->b_ml
.ml_flags
& ML_LOCKED_POS
);
3399 buf
->b_ml
.ml_locked
= NULL
;
3402 * If lines have been added or deleted in the locked block, need to
3403 * update the line count in pointer blocks.
3405 if (buf
->b_ml
.ml_locked_lineadd
!= 0)
3406 ml_lineadd(buf
, buf
->b_ml
.ml_locked_lineadd
);
3409 if (action
== ML_FLUSH
) /* nothing else to do */
3412 bnum
= 1; /* start at the root of the tree */
3415 high
= buf
->b_ml
.ml_line_count
;
3417 if (action
== ML_FIND
) /* first try stack entries */
3419 for (top
= buf
->b_ml
.ml_stack_top
- 1; top
>= 0; --top
)
3421 ip
= &(buf
->b_ml
.ml_stack
[top
]);
3422 if (ip
->ip_low
<= lnum
&& ip
->ip_high
>= lnum
)
3427 buf
->b_ml
.ml_stack_top
= top
; /* truncate stack at prev entry */
3432 buf
->b_ml
.ml_stack_top
= 0; /* not found, start at the root */
3434 else /* ML_DELETE or ML_INSERT */
3435 buf
->b_ml
.ml_stack_top
= 0; /* start at the root */
3438 * search downwards in the tree until a data block is found
3442 if ((hp
= mf_get(mfp
, bnum
, page_count
)) == NULL
)
3446 * update high for insert/delete
3448 if (action
== ML_INSERT
)
3450 else if (action
== ML_DELETE
)
3453 dp
= (DATA_BL
*)(hp
->bh_data
);
3454 if (dp
->db_id
== DATA_ID
) /* data block */
3456 buf
->b_ml
.ml_locked
= hp
;
3457 buf
->b_ml
.ml_locked_low
= low
;
3458 buf
->b_ml
.ml_locked_high
= high
;
3459 buf
->b_ml
.ml_locked_lineadd
= 0;
3460 buf
->b_ml
.ml_flags
&= ~(ML_LOCKED_DIRTY
| ML_LOCKED_POS
);
3464 pp
= (PTR_BL
*)(dp
); /* must be pointer block */
3465 if (pp
->pb_id
!= PTR_ID
)
3467 EMSG(_("E317: pointer block id wrong"));
3471 if ((top
= ml_add_stack(buf
)) < 0) /* add new entry to stack */
3473 ip
= &(buf
->b_ml
.ml_stack
[top
]);
3477 ip
->ip_index
= -1; /* index not known yet */
3480 for (idx
= 0; idx
< (int)pp
->pb_count
; ++idx
)
3482 t
= pp
->pb_pointer
[idx
].pe_line_count
;
3483 CHECK(t
== 0, _("pe_line_count is zero"));
3484 if ((low
+= t
) > lnum
)
3487 bnum
= pp
->pb_pointer
[idx
].pe_bnum
;
3488 page_count
= pp
->pb_pointer
[idx
].pe_page_count
;
3493 * a negative block number may have been changed
3497 bnum2
= mf_trans_del(mfp
, bnum
);
3501 pp
->pb_pointer
[idx
].pe_bnum
= bnum
;
3509 if (idx
>= (int)pp
->pb_count
) /* past the end: something wrong! */
3511 if (lnum
> buf
->b_ml
.ml_line_count
)
3512 EMSGN(_("E322: line number out of range: %ld past the end"),
3513 lnum
- buf
->b_ml
.ml_line_count
);
3516 EMSGN(_("E323: line count wrong in block %ld"), bnum
);
3519 if (action
== ML_DELETE
)
3521 pp
->pb_pointer
[idx
].pe_line_count
--;
3524 else if (action
== ML_INSERT
)
3526 pp
->pb_pointer
[idx
].pe_line_count
++;
3529 mf_put(mfp
, hp
, dirty
, FALSE
);
3533 mf_put(mfp
, hp
, FALSE
, FALSE
);
3536 * If action is ML_DELETE or ML_INSERT we have to correct the tree for
3537 * the incremented/decremented line counts, because there won't be a line
3538 * inserted/deleted after all.
3540 if (action
== ML_DELETE
)
3542 else if (action
== ML_INSERT
)
3543 ml_lineadd(buf
, -1);
3544 buf
->b_ml
.ml_stack_top
= 0;
3549 * add an entry to the info pointer stack
3551 * return -1 for failure, number of the new entry otherwise
3558 infoptr_T
*newstack
;
3560 top
= buf
->b_ml
.ml_stack_top
;
3562 /* may have to increase the stack size */
3563 if (top
== buf
->b_ml
.ml_stack_size
)
3565 CHECK(top
> 0, _("Stack size increases")); /* more than 5 levels??? */
3567 newstack
= (infoptr_T
*)alloc((unsigned)sizeof(infoptr_T
) *
3568 (buf
->b_ml
.ml_stack_size
+ STACK_INCR
));
3569 if (newstack
== NULL
)
3571 mch_memmove(newstack
, buf
->b_ml
.ml_stack
,
3572 (size_t)top
* sizeof(infoptr_T
));
3573 vim_free(buf
->b_ml
.ml_stack
);
3574 buf
->b_ml
.ml_stack
= newstack
;
3575 buf
->b_ml
.ml_stack_size
+= STACK_INCR
;
3578 buf
->b_ml
.ml_stack_top
++;
3583 * Update the pointer blocks on the stack for inserted/deleted lines.
3584 * The stack itself is also updated.
3586 * When a insert/delete line action fails, the line is not inserted/deleted,
3587 * but the pointer blocks have already been updated. That is fixed here by
3588 * walking through the stack.
3590 * Count is the number of lines added, negative if lines have been deleted.
3593 ml_lineadd(buf
, count
)
3600 memfile_T
*mfp
= buf
->b_ml
.ml_mfp
;
3603 for (idx
= buf
->b_ml
.ml_stack_top
- 1; idx
>= 0; --idx
)
3605 ip
= &(buf
->b_ml
.ml_stack
[idx
]);
3606 if ((hp
= mf_get(mfp
, ip
->ip_bnum
, 1)) == NULL
)
3608 pp
= (PTR_BL
*)(hp
->bh_data
); /* must be pointer block */
3609 if (pp
->pb_id
!= PTR_ID
)
3611 mf_put(mfp
, hp
, FALSE
, FALSE
);
3612 EMSG(_("E317: pointer block id wrong 2"));
3615 pp
->pb_pointer
[ip
->ip_index
].pe_line_count
+= count
;
3616 ip
->ip_high
+= count
;
3617 mf_put(mfp
, hp
, TRUE
, FALSE
);
3621 #ifdef HAVE_READLINK
3623 * Resolve a symlink in the last component of a file name.
3624 * Note that f_resolve() does it for every part of the path, we don't do that
3626 * If it worked returns OK and the resolved link in "buf[MAXPATHL]".
3627 * Otherwise returns FAIL.
3630 resolve_symlink(fname
, buf
)
3634 char_u tmp
[MAXPATHL
];
3641 /* Put the result so far in tmp[], starting with the original name. */
3642 vim_strncpy(tmp
, fname
, MAXPATHL
- 1);
3646 /* Limit symlink depth to 100, catch recursive loops. */
3649 EMSG2(_("E773: Symlink loop for \"%s\""), fname
);
3653 ret
= readlink((char *)tmp
, (char *)buf
, MAXPATHL
- 1);
3656 if (errno
== EINVAL
|| errno
== ENOENT
)
3658 /* Found non-symlink or not existing file, stop here.
3659 * When at the first level use the unmodified name, skip the
3660 * call to vim_FullName(). */
3664 /* Use the resolved name in tmp[]. */
3668 /* There must be some error reading links, use original name. */
3674 * Check whether the symlink is relative or absolute.
3675 * If it's relative, build a new path based on the directory
3676 * portion of the filename (if any) and the path the symlink
3679 if (mch_isFullName(buf
))
3685 tail
= gettail(tmp
);
3686 if (STRLEN(tail
) + STRLEN(buf
) >= MAXPATHL
)
3693 * Try to resolve the full name of the file so that the swapfile name will
3694 * be consistent even when opening a relative symlink from different
3695 * working directories.
3697 return vim_FullName(tmp
, buf
, MAXPATHL
, TRUE
);
3702 * Make swap file name out of the file name and a directory name.
3703 * Returns pointer to allocated memory or NULL.
3706 makeswapname(fname
, ffname
, buf
, dir_name
)
3708 char_u
*ffname UNUSED
;
3713 char_u
*fname_res
= fname
;
3714 #ifdef HAVE_READLINK
3715 char_u fname_buf
[MAXPATHL
];
3718 #if defined(UNIX) || defined(WIN3264) /* Need _very_ long file names */
3719 s
= dir_name
+ STRLEN(dir_name
);
3720 if (after_pathsep(dir_name
, s
) && s
[-1] == s
[-2])
3721 { /* Ends with '//', Use Full path */
3723 if ((s
= make_percent_swname(dir_name
, fname
)) != NULL
)
3725 r
= modname(s
, (char_u
*)".swp", FALSE
);
3732 #ifdef HAVE_READLINK
3733 /* Expand symlink in the file name, so that we put the swap file with the
3734 * actual file instead of with the symlink. */
3735 if (resolve_symlink(fname
, fname_buf
) == OK
)
3736 fname_res
= fname_buf
;
3743 (buf
->b_p_sn
|| buf
->b_shortname
),
3746 /* Avoid problems if fname has special chars, eg <Wimp$Scrap> */
3752 #if defined(VMS) || defined(RISCOS)
3757 #ifdef SHORT_FNAME /* always 8.3 file name */
3760 /* Prepend a '.' to the swap file name for the current directory. */
3761 dir_name
[0] == '.' && dir_name
[1] == NUL
3764 if (r
== NULL
) /* out of memory */
3767 s
= get_file_in_dir(r
, dir_name
);
3773 * Get file name to use for swap file or backup file.
3774 * Use the name of the edited file "fname" and an entry in the 'dir' or 'bdir'
3776 * - If "dname" is ".", return "fname" (swap file in dir of file).
3777 * - If "dname" starts with "./", insert "dname" in "fname" (swap file
3778 * relative to dir of file).
3779 * - Otherwise, prepend "dname" to the tail of "fname" (swap file in specific
3782 * The return value is an allocated string and can be NULL.
3785 get_file_in_dir(fname
, dname
)
3787 char_u
*dname
; /* don't use "dirname", it is a global for Alpha */
3794 tail
= gettail(fname
);
3796 if (dname
[0] == '.' && dname
[1] == NUL
)
3797 retval
= vim_strsave(fname
);
3798 else if (dname
[0] == '.' && vim_ispathsep(dname
[1]))
3800 if (tail
== fname
) /* no path before file name */
3801 retval
= concat_fnames(dname
+ 2, tail
, TRUE
);
3806 t
= concat_fnames(fname
, dname
+ 2, TRUE
);
3808 if (t
== NULL
) /* out of memory */
3812 retval
= concat_fnames(t
, tail
, TRUE
);
3818 retval
= concat_fnames(dname
, tail
, TRUE
);
3823 static void attention_message
__ARGS((buf_T
*buf
, char_u
*fname
));
3826 * Print the ATTENTION message: info about an existing swap file.
3829 attention_message(buf
, fname
)
3830 buf_T
*buf
; /* buffer being edited */
3831 char_u
*fname
; /* swap file name */
3838 (void)EMSG(_("E325: ATTENTION"));
3839 MSG_PUTS(_("\nFound a swap file by the name \""));
3840 msg_home_replace(fname
);
3842 sx
= swapfile_info(fname
);
3843 MSG_PUTS(_("While opening file \""));
3844 msg_outtrans(buf
->b_fname
);
3846 if (mch_stat((char *)buf
->b_fname
, &st
) != -1)
3848 MSG_PUTS(_(" dated: "));
3849 x
= st
.st_mtime
; /* Manx C can't do &st.st_mtime */
3850 p
= ctime(&x
); /* includes '\n' */
3852 MSG_PUTS("(invalid)\n");
3855 if (sx
!= 0 && x
> sx
)
3856 MSG_PUTS(_(" NEWER than swap file!\n"));
3858 /* Some of these messages are long to allow translation to
3859 * other languages. */
3860 MSG_PUTS(_("\n(1) Another program may be editing the same file.\n If this is the case, be careful not to end up with two\n different instances of the same file when making changes.\n"));
3861 MSG_PUTS(_(" Quit, or continue with caution.\n"));
3862 MSG_PUTS(_("\n(2) An edit session for this file crashed.\n"));
3863 MSG_PUTS(_(" If this is the case, use \":recover\" or \"vim -r "));
3864 msg_outtrans(buf
->b_fname
);
3865 MSG_PUTS(_("\"\n to recover the changes (see \":help recovery\").\n"));
3866 MSG_PUTS(_(" If you did this already, delete the swap file \""));
3867 msg_outtrans(fname
);
3868 MSG_PUTS(_("\"\n to avoid this message.\n"));
3869 cmdline_row
= msg_row
;
3874 static int do_swapexists
__ARGS((buf_T
*buf
, char_u
*fname
));
3877 * Trigger the SwapExists autocommands.
3878 * Returns a value for equivalent to do_dialog() (see below):
3879 * 0: still need to ask for a choice
3888 do_swapexists(buf
, fname
)
3892 set_vim_var_string(VV_SWAPNAME
, fname
, -1);
3893 set_vim_var_string(VV_SWAPCHOICE
, NULL
, -1);
3895 /* Trigger SwapExists autocommands with <afile> set to the file being
3896 * edited. Disallow changing directory here. */
3898 apply_autocmds(EVENT_SWAPEXISTS
, buf
->b_fname
, NULL
, FALSE
, NULL
);
3901 set_vim_var_string(VV_SWAPNAME
, NULL
, -1);
3903 switch (*get_vim_var_str(VV_SWAPCHOICE
))
3918 * Find out what name to use for the swap file for buffer 'buf'.
3920 * Several names are tried to find one that does not exist
3921 * Returns the name in allocated memory or NULL.
3923 * Note: If BASENAMELEN is not correct, you will get error messages for
3924 * not being able to open the swap or undo file
3925 * Note: May trigger SwapExists autocmd, pointers may change!
3928 findswapname(buf
, dirp
, old_fname
)
3930 char_u
**dirp
; /* pointer to list of directories */
3931 char_u
*old_fname
; /* don't give warning for this file name */
3943 #if !defined(SHORT_FNAME) \
3944 && ((!defined(UNIX) && !defined(OS2)) || defined(ARCHIE))
3945 # define CREATE_DUMMY_FILE
3946 FILE *dummyfd
= NULL
;
3949 * If we start editing a new file, e.g. "test.doc", which resides on an MSDOS
3950 * compatible filesystem, it is possible that the file "test.doc.swp" which we
3951 * create will be exactly the same file. To avoid this problem we temporarily
3952 * create "test.doc".
3953 * Don't do this when the check below for a 8.3 file name is used.
3955 if (!(buf
->b_p_sn
|| buf
->b_shortname
) && buf
->b_fname
!= NULL
3956 && mch_getperm(buf
->b_fname
) < 0)
3957 dummyfd
= mch_fopen((char *)buf
->b_fname
, "w");
3961 * Isolate a directory name from *dirp and put it in dir_name.
3962 * First allocate some memory to put the directory name in.
3964 dir_name
= alloc((unsigned)STRLEN(*dirp
) + 1);
3965 if (dir_name
!= NULL
)
3966 (void)copy_option_part(dirp
, dir_name
, 31000, ",");
3969 * we try different names until we find one that does not exist yet
3971 if (dir_name
== NULL
) /* out of memory */
3974 fname
= makeswapname(buf
->b_fname
, buf
->b_ffname
, buf
, dir_name
);
3978 if (fname
== NULL
) /* must be out of memory */
3980 if ((n
= (int)STRLEN(fname
)) == 0) /* safety check */
3986 #if (defined(UNIX) || defined(OS2)) && !defined(ARCHIE) && !defined(SHORT_FNAME)
3988 * Some systems have a MS-DOS compatible filesystem that use 8.3 character
3989 * file names. If this is the first try and the swap file name does not fit in
3990 * 8.3, detect if this is the case, set shortname and try again.
3992 if (fname
[n
- 2] == 'w' && fname
[n
- 1] == 'p'
3993 && !(buf
->b_p_sn
|| buf
->b_shortname
))
3999 int created1
= FALSE
, created2
= FALSE
;
4003 * Check if swapfile name does not fit in 8.3:
4004 * It either contains two dots, is longer than 8 chars, or starts
4007 tail
= gettail(buf
->b_fname
);
4008 if ( vim_strchr(tail
, '.') != NULL
4009 || STRLEN(tail
) > (size_t)8
4010 || *gettail(fname
) == '.')
4012 fname2
= alloc(n
+ 2);
4015 STRCPY(fname2
, fname
);
4016 /* if fname == "xx.xx.swp", fname2 = "xx.xx.swx"
4017 * if fname == ".xx.swp", fname2 = ".xx.swpx"
4018 * if fname == "123456789.swp", fname2 = "12345678x.swp"
4020 if (vim_strchr(tail
, '.') != NULL
)
4021 fname2
[n
- 1] = 'x';
4022 else if (*gettail(fname
) == '.')
4025 fname2
[n
+ 1] = NUL
;
4030 * may need to create the files to be able to use mch_stat()
4032 f1
= mch_open((char *)fname
, O_RDONLY
| O_EXTRA
, 0);
4035 f1
= mch_open_rw((char *)fname
,
4036 O_RDWR
|O_CREAT
|O_EXCL
|O_EXTRA
);
4038 if (f1
< 0 && errno
== ENOENT
)
4045 f2
= mch_open((char *)fname2
, O_RDONLY
| O_EXTRA
, 0);
4048 f2
= mch_open_rw((char *)fname2
,
4049 O_RDWR
|O_CREAT
|O_EXCL
|O_EXTRA
);
4055 * Both files exist now. If mch_stat() returns the
4056 * same device and inode they are the same file.
4058 if (mch_fstat(f1
, &s1
) != -1
4059 && mch_fstat(f2
, &s2
) != -1
4060 && s1
.st_dev
== s2
.st_dev
4061 && s1
.st_ino
== s2
.st_ino
)
4074 buf
->b_shortname
= TRUE
;
4076 fname
= makeswapname(buf
->b_fname
, buf
->b_ffname
,
4078 continue; /* try again with b_shortname set */
4085 * check if the swapfile already exists
4087 if (mch_getperm(fname
) < 0) /* it does not exist */
4093 * Extra security check: When a swap file is a symbolic link, this
4094 * is most likely a symlink attack.
4096 if (mch_lstat((char *)fname
, &sb
) < 0)
4099 fh
= Open((UBYTE
*)fname
, (long)MODE_NEWFILE
);
4101 * on the Amiga mch_getperm() will return -1 when the file exists
4102 * but is being used by another program. This happens if you edit
4105 if (fh
!= (BPTR
)NULL
) /* can open file, OK */
4111 if (IoErr() != ERROR_OBJECT_IN_USE
4112 && IoErr() != ERROR_OBJECT_EXISTS
)
4119 * A file name equal to old_fname is OK to use.
4121 if (old_fname
!= NULL
&& fnamecmp(fname
, old_fname
) == 0)
4125 * get here when file already exists
4127 if (fname
[n
- 2] == 'w' && fname
[n
- 1] == 'p') /* first try */
4131 * on MS-DOS compatible filesystems (e.g. messydos) file.doc.swp
4132 * and file.doc are the same file. To guess if this problem is
4133 * present try if file.doc.swx exists. If it does, we set
4134 * buf->b_shortname and try file_doc.swp (dots replaced by
4135 * underscores for this file), and try again. If it doesn't we
4136 * assume that "file.doc.swp" already exists.
4138 if (!(buf
->b_p_sn
|| buf
->b_shortname
)) /* not tried yet */
4141 r
= mch_getperm(fname
); /* try "file.swx" */
4143 if (r
>= 0) /* "file.swx" seems to exist */
4145 buf
->b_shortname
= TRUE
;
4147 fname
= makeswapname(buf
->b_fname
, buf
->b_ffname
,
4149 continue; /* try again with '.' replaced with '_' */
4154 * If we get here the ".swp" file really exists.
4155 * Give an error message, unless recovering, no file name, we are
4156 * viewing a help file or when the path of the file is different
4157 * (happens when all .swp files are in one directory).
4159 if (!recoverymode
&& buf
->b_fname
!= NULL
4160 && !buf
->b_help
&& !(buf
->b_flags
& BF_DUMMY
))
4167 * Try to read block 0 from the swap file to get the original
4168 * file name (and inode number).
4170 fd
= mch_open((char *)fname
, O_RDONLY
| O_EXTRA
, 0);
4173 if (read(fd
, (char *)&b0
, sizeof(b0
)) == sizeof(b0
))
4176 * If the swapfile has the same directory as the
4177 * buffer don't compare the directory names, they can
4178 * have a different mountpoint.
4180 if (b0
.b0_flags
& B0_SAME_DIR
)
4182 if (fnamecmp(gettail(buf
->b_ffname
),
4183 gettail(b0
.b0_fname
)) != 0
4184 || !same_directory(fname
, buf
->b_ffname
))
4187 /* Symlinks may point to the same file even
4188 * when the name differs, need to check the
4190 expand_env(b0
.b0_fname
, NameBuff
, MAXPATHL
);
4191 if (fnamecmp_ino(buf
->b_ffname
, NameBuff
,
4192 char_to_long(b0
.b0_ino
)))
4200 * The name in the swap file may be
4201 * "~user/path/file". Expand it first.
4203 expand_env(b0
.b0_fname
, NameBuff
, MAXPATHL
);
4205 if (fnamecmp_ino(buf
->b_ffname
, NameBuff
,
4206 char_to_long(b0
.b0_ino
)))
4209 if (fnamecmp(NameBuff
, buf
->b_ffname
) != 0)
4218 /* Can't open swap file, though it does exist.
4219 * Assume that the user is editing two files with
4220 * the same name in different directories. No error.
4225 /* give the ATTENTION message when there is an old swap file
4226 * for the current file, and the buffer was not recovered. */
4227 if (differ
== FALSE
&& !(curbuf
->b_flags
& BF_RECOVERED
)
4228 && vim_strchr(p_shm
, SHM_ATTENTION
) == NULL
)
4230 #if defined(HAS_SWAP_EXISTS_ACTION)
4233 #ifdef CREATE_DUMMY_FILE
4234 int did_use_dummy
= FALSE
;
4236 /* Avoid getting a warning for the file being created
4237 * outside of Vim, it was created at the start of this
4238 * function. Delete the file now, because Vim might exit
4239 * here if the window is closed. */
4240 if (dummyfd
!= NULL
)
4244 mch_remove(buf
->b_fname
);
4245 did_use_dummy
= TRUE
;
4249 #if (defined(UNIX) || defined(__EMX__) || defined(VMS)) && (defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG))
4250 process_still_running
= FALSE
;
4254 * If there is an SwapExists autocommand and we can handle
4255 * the response, trigger it. It may return 0 to ask the
4258 if (swap_exists_action
!= SEA_NONE
4259 && has_autocmd(EVENT_SWAPEXISTS
, buf
->b_fname
, buf
))
4260 choice
= do_swapexists(buf
, fname
);
4266 /* If we are supposed to start the GUI but it wasn't
4267 * completely started yet, start it now. This makes
4268 * the messages displayed in the Vim window when
4269 * loading a session from the .gvimrc file. */
4270 if (gui
.starting
&& !gui
.in_use
)
4273 /* Show info about the existing swap file. */
4274 attention_message(buf
, fname
);
4276 /* We don't want a 'q' typed at the more-prompt
4277 * interrupt loading a file. */
4281 #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
4282 if (swap_exists_action
!= SEA_NONE
&& choice
== 0)
4286 name
= alloc((unsigned)(STRLEN(fname
)
4287 + STRLEN(_("Swap file \""))
4288 + STRLEN(_("\" already exists!")) + 5));
4291 STRCPY(name
, _("Swap file \""));
4292 home_replace(NULL
, fname
, name
+ STRLEN(name
),
4294 STRCAT(name
, _("\" already exists!"));
4296 choice
= do_dialog(VIM_WARNING
,
4297 (char_u
*)_("VIM - ATTENTION"),
4299 ? (char_u
*)_("Swap file already exists!")
4301 # if defined(UNIX) || defined(__EMX__) || defined(VMS)
4302 process_still_running
4303 ? (char_u
*)_("&Open Read-Only\n&Edit anyway\n&Recover\n&Quit\n&Abort") :
4305 (char_u
*)_("&Open Read-Only\n&Edit anyway\n&Recover\n&Delete it\n&Quit\n&Abort"), 1, NULL
);
4307 # if defined(UNIX) || defined(__EMX__) || defined(VMS)
4308 if (process_still_running
&& choice
>= 4)
4309 choice
++; /* Skip missing "Delete it" button */
4313 /* pretend screen didn't scroll, need redraw anyway */
4315 redraw_all_later(NOT_VALID
);
4319 #if defined(HAS_SWAP_EXISTS_ACTION)
4330 swap_exists_action
= SEA_RECOVER
;
4336 swap_exists_action
= SEA_QUIT
;
4339 swap_exists_action
= SEA_QUIT
;
4344 /* If the file was deleted this fname can be used. */
4345 if (mch_getperm(fname
) < 0)
4352 if (msg_silent
== 0)
4353 /* call wait_return() later */
4354 need_wait_return
= TRUE
;
4357 #ifdef CREATE_DUMMY_FILE
4358 /* Going to try another name, need the dummy file again. */
4360 dummyfd
= mch_fopen((char *)buf
->b_fname
, "w");
4367 * Change the ".swp" extension to find another file that can be used.
4368 * First decrement the last char: ".swo", ".swn", etc.
4369 * If that still isn't enough decrement the last but one char: ".svz"
4370 * Can happen when editing many "No Name" buffers.
4372 if (fname
[n
- 1] == 'a') /* ".s?a" */
4374 if (fname
[n
- 2] == 'a') /* ".saa": tried enough, give up */
4376 EMSG(_("E326: Too many swap files found"));
4381 --fname
[n
- 2]; /* ".svz", ".suz", etc. */
4382 fname
[n
- 1] = 'z' + 1;
4384 --fname
[n
- 1]; /* ".swo", ".swn", etc. */
4388 #ifdef CREATE_DUMMY_FILE
4389 if (dummyfd
!= NULL
) /* file has been created temporarily */
4392 mch_remove(buf
->b_fname
);
4402 return (b0p
->b0_magic_long
!= (long)B0_MAGIC_LONG
4403 || b0p
->b0_magic_int
!= (int)B0_MAGIC_INT
4404 || b0p
->b0_magic_short
!= (short)B0_MAGIC_SHORT
4405 || b0p
->b0_magic_char
!= B0_MAGIC_CHAR
);
4410 * Compare current file name with file name from swap file.
4411 * Try to use inode numbers when possible.
4412 * Return non-zero when files are different.
4414 * When comparing file names a few things have to be taken into consideration:
4415 * - When working over a network the full path of a file depends on the host.
4416 * We check the inode number if possible. It is not 100% reliable though,
4417 * because the device number cannot be used over a network.
4418 * - When a file does not exist yet (editing a new file) there is no inode
4420 * - The file name in a swap file may not be valid on the current host. The
4421 * "~user" form is used whenever possible to avoid this.
4423 * This is getting complicated, let's make a table:
4425 * ino_c ino_s fname_c fname_s differ =
4427 * both files exist -> compare inode numbers:
4428 * != 0 != 0 X X ino_c != ino_s
4430 * inode number(s) unknown, file names available -> compare file names
4431 * == 0 X OK OK fname_c != fname_s
4432 * X == 0 OK OK fname_c != fname_s
4434 * current file doesn't exist, file for swap file exist, file name(s) not
4435 * available -> probably different
4436 * == 0 != 0 FAIL X TRUE
4437 * == 0 != 0 X FAIL TRUE
4439 * current file exists, inode for swap unknown, file name(s) not
4440 * available -> probably different
4441 * != 0 == 0 FAIL X TRUE
4442 * != 0 == 0 X FAIL TRUE
4444 * current file doesn't exist, inode for swap unknown, one file name not
4445 * available -> probably different
4446 * == 0 == 0 FAIL OK TRUE
4447 * == 0 == 0 OK FAIL TRUE
4449 * current file doesn't exist, inode for swap unknown, both file names not
4450 * available -> probably same file
4451 * == 0 == 0 FAIL FAIL FALSE
4453 * Note that when the ino_t is 64 bits, only the last 32 will be used. This
4454 * can't be changed without making the block 0 incompatible with 32 bit
4459 fnamecmp_ino(fname_c
, fname_s
, ino_block0
)
4460 char_u
*fname_c
; /* current file name */
4461 char_u
*fname_s
; /* file name from swap file */
4465 ino_t ino_c
= 0; /* ino of current file */
4466 ino_t ino_s
; /* ino of file from swap file */
4467 char_u buf_c
[MAXPATHL
]; /* full path of fname_c */
4468 char_u buf_s
[MAXPATHL
]; /* full path of fname_s */
4469 int retval_c
; /* flag: buf_c valid */
4470 int retval_s
; /* flag: buf_s valid */
4472 if (mch_stat((char *)fname_c
, &st
) == 0)
4473 ino_c
= (ino_t
)st
.st_ino
;
4476 * First we try to get the inode from the file name, because the inode in
4477 * the swap file may be outdated. If that fails (e.g. this path is not
4478 * valid on this machine), use the inode from block 0.
4480 if (mch_stat((char *)fname_s
, &st
) == 0)
4481 ino_s
= (ino_t
)st
.st_ino
;
4483 ino_s
= (ino_t
)ino_block0
;
4486 return (ino_c
!= ino_s
);
4489 * One of the inode numbers is unknown, try a forced vim_FullName() and
4490 * compare the file names.
4492 retval_c
= vim_FullName(fname_c
, buf_c
, MAXPATHL
, TRUE
);
4493 retval_s
= vim_FullName(fname_s
, buf_s
, MAXPATHL
, TRUE
);
4494 if (retval_c
== OK
&& retval_s
== OK
)
4495 return (STRCMP(buf_c
, buf_s
) != 0);
4498 * Can't compare inodes or file names, guess that the files are different,
4499 * unless both appear not to exist at all.
4501 if (ino_s
== 0 && ino_c
== 0 && retval_c
== FAIL
&& retval_s
== FAIL
)
4505 #endif /* CHECK_INODE */
4508 * Move a long integer into a four byte character array.
4509 * Used for machine independency in block zero.
4516 s
[0] = (char_u
)(n
& 0xff);
4517 n
= (unsigned)n
>> 8;
4518 s
[1] = (char_u
)(n
& 0xff);
4519 n
= (unsigned)n
>> 8;
4520 s
[2] = (char_u
)(n
& 0xff);
4521 n
= (unsigned)n
>> 8;
4522 s
[3] = (char_u
)(n
& 0xff);
4543 * Set the flags in the first block of the swap file:
4544 * - file is modified or not: buf->b_changed
4555 if (!buf
->b_ml
.ml_mfp
)
4557 for (hp
= buf
->b_ml
.ml_mfp
->mf_used_last
; hp
!= NULL
; hp
= hp
->bh_prev
)
4559 if (hp
->bh_bnum
== 0)
4561 b0p
= (ZERO_BL
*)(hp
->bh_data
);
4562 b0p
->b0_dirty
= buf
->b_changed
? B0_DIRTY
: 0;
4563 b0p
->b0_flags
= (b0p
->b0_flags
& ~B0_FF_MASK
)
4564 | (get_fileformat(buf
) + 1);
4566 add_b0_fenc(b0p
, buf
);
4568 hp
->bh_flags
|= BH_DIRTY
;
4569 mf_sync(buf
->b_ml
.ml_mfp
, MFS_ZERO
);
4575 #if defined(FEAT_BYTEOFF) || defined(PROTO)
4577 #define MLCS_MAXL 800 /* max no of lines in chunk */
4578 #define MLCS_MINL 400 /* should be half of MLCS_MAXL */
4581 * Keep information for finding byte offset of a line, updtytpe may be one of:
4582 * ML_CHNK_ADDLINE: Add len to parent chunk, possibly splitting it
4583 * Careful: ML_CHNK_ADDLINE may cause ml_find_line() to be called.
4584 * ML_CHNK_DELLINE: Subtract len from parent chunk, possibly deleting it
4585 * ML_CHNK_UPDLINE: Add len to parent chunk, as a signed entity.
4588 ml_updatechunk(buf
, line
, len
, updtype
)
4594 static buf_T
*ml_upd_lastbuf
= NULL
;
4595 static linenr_T ml_upd_lastline
;
4596 static linenr_T ml_upd_lastcurline
;
4597 static int ml_upd_lastcurix
;
4599 linenr_T curline
= ml_upd_lastcurline
;
4600 int curix
= ml_upd_lastcurix
;
4602 chunksize_T
*curchnk
;
4607 if (buf
->b_ml
.ml_usedchunks
== -1 || len
== 0)
4609 if (buf
->b_ml
.ml_chunksize
== NULL
)
4611 buf
->b_ml
.ml_chunksize
= (chunksize_T
*)
4612 alloc((unsigned)sizeof(chunksize_T
) * 100);
4613 if (buf
->b_ml
.ml_chunksize
== NULL
)
4615 buf
->b_ml
.ml_usedchunks
= -1;
4618 buf
->b_ml
.ml_numchunks
= 100;
4619 buf
->b_ml
.ml_usedchunks
= 1;
4620 buf
->b_ml
.ml_chunksize
[0].mlcs_numlines
= 1;
4621 buf
->b_ml
.ml_chunksize
[0].mlcs_totalsize
= 1;
4624 if (updtype
== ML_CHNK_UPDLINE
&& buf
->b_ml
.ml_line_count
== 1)
4627 * First line in empty buffer from ml_flush_line() -- reset
4629 buf
->b_ml
.ml_usedchunks
= 1;
4630 buf
->b_ml
.ml_chunksize
[0].mlcs_numlines
= 1;
4631 buf
->b_ml
.ml_chunksize
[0].mlcs_totalsize
=
4632 (long)STRLEN(buf
->b_ml
.ml_line_ptr
) + 1;
4637 * Find chunk that our line belongs to, curline will be at start of the
4640 if (buf
!= ml_upd_lastbuf
|| line
!= ml_upd_lastline
+ 1
4641 || updtype
!= ML_CHNK_ADDLINE
)
4643 for (curline
= 1, curix
= 0;
4644 curix
< buf
->b_ml
.ml_usedchunks
- 1
4645 && line
>= curline
+ buf
->b_ml
.ml_chunksize
[curix
].mlcs_numlines
;
4648 curline
+= buf
->b_ml
.ml_chunksize
[curix
].mlcs_numlines
;
4651 else if (line
>= curline
+ buf
->b_ml
.ml_chunksize
[curix
].mlcs_numlines
4652 && curix
< buf
->b_ml
.ml_usedchunks
- 1)
4654 /* Adjust cached curix & curline */
4655 curline
+= buf
->b_ml
.ml_chunksize
[curix
].mlcs_numlines
;
4658 curchnk
= buf
->b_ml
.ml_chunksize
+ curix
;
4660 if (updtype
== ML_CHNK_DELLINE
)
4662 curchnk
->mlcs_totalsize
+= len
;
4663 if (updtype
== ML_CHNK_ADDLINE
)
4665 curchnk
->mlcs_numlines
++;
4667 /* May resize here so we don't have to do it in both cases below */
4668 if (buf
->b_ml
.ml_usedchunks
+ 1 >= buf
->b_ml
.ml_numchunks
)
4670 buf
->b_ml
.ml_numchunks
= buf
->b_ml
.ml_numchunks
* 3 / 2;
4671 buf
->b_ml
.ml_chunksize
= (chunksize_T
*)
4672 vim_realloc(buf
->b_ml
.ml_chunksize
,
4673 sizeof(chunksize_T
) * buf
->b_ml
.ml_numchunks
);
4674 if (buf
->b_ml
.ml_chunksize
== NULL
)
4676 /* Hmmmm, Give up on offset for this buffer */
4677 buf
->b_ml
.ml_usedchunks
= -1;
4682 if (buf
->b_ml
.ml_chunksize
[curix
].mlcs_numlines
>= MLCS_MAXL
)
4684 int count
; /* number of entries in block */
4689 mch_memmove(buf
->b_ml
.ml_chunksize
+ curix
+ 1,
4690 buf
->b_ml
.ml_chunksize
+ curix
,
4691 (buf
->b_ml
.ml_usedchunks
- curix
) *
4692 sizeof(chunksize_T
));
4693 /* Compute length of first half of lines in the split chunk */
4696 while (curline
< buf
->b_ml
.ml_line_count
4697 && linecnt
< MLCS_MINL
)
4699 if ((hp
= ml_find_line(buf
, curline
, ML_FIND
)) == NULL
)
4701 buf
->b_ml
.ml_usedchunks
= -1;
4704 dp
= (DATA_BL
*)(hp
->bh_data
);
4705 count
= (long)(buf
->b_ml
.ml_locked_high
) -
4706 (long)(buf
->b_ml
.ml_locked_low
) + 1;
4707 idx
= curline
- buf
->b_ml
.ml_locked_low
;
4708 curline
= buf
->b_ml
.ml_locked_high
+ 1;
4709 if (idx
== 0)/* first line in block, text at the end */
4710 text_end
= dp
->db_txt_end
;
4712 text_end
= ((dp
->db_index
[idx
- 1]) & DB_INDEX_MASK
);
4713 /* Compute index of last line to use in this MEMLINE */
4715 if (linecnt
+ rest
> MLCS_MINL
)
4717 idx
+= MLCS_MINL
- linecnt
- 1;
4718 linecnt
= MLCS_MINL
;
4725 size
+= text_end
- ((dp
->db_index
[idx
]) & DB_INDEX_MASK
);
4727 buf
->b_ml
.ml_chunksize
[curix
].mlcs_numlines
= linecnt
;
4728 buf
->b_ml
.ml_chunksize
[curix
+ 1].mlcs_numlines
-= linecnt
;
4729 buf
->b_ml
.ml_chunksize
[curix
].mlcs_totalsize
= size
;
4730 buf
->b_ml
.ml_chunksize
[curix
+ 1].mlcs_totalsize
-= size
;
4731 buf
->b_ml
.ml_usedchunks
++;
4732 ml_upd_lastbuf
= NULL
; /* Force recalc of curix & curline */
4735 else if (buf
->b_ml
.ml_chunksize
[curix
].mlcs_numlines
>= MLCS_MINL
4736 && curix
== buf
->b_ml
.ml_usedchunks
- 1
4737 && buf
->b_ml
.ml_line_count
- line
<= 1)
4740 * We are in the last chunk and it is cheap to crate a new one
4741 * after this. Do it now to avoid the loop above later on
4743 curchnk
= buf
->b_ml
.ml_chunksize
+ curix
+ 1;
4744 buf
->b_ml
.ml_usedchunks
++;
4745 if (line
== buf
->b_ml
.ml_line_count
)
4747 curchnk
->mlcs_numlines
= 0;
4748 curchnk
->mlcs_totalsize
= 0;
4753 * Line is just prior to last, move count for last
4754 * This is the common case when loading a new file
4756 hp
= ml_find_line(buf
, buf
->b_ml
.ml_line_count
, ML_FIND
);
4759 buf
->b_ml
.ml_usedchunks
= -1;
4762 dp
= (DATA_BL
*)(hp
->bh_data
);
4763 if (dp
->db_line_count
== 1)
4764 rest
= dp
->db_txt_end
- dp
->db_txt_start
;
4767 ((dp
->db_index
[dp
->db_line_count
- 2]) & DB_INDEX_MASK
)
4769 curchnk
->mlcs_totalsize
= rest
;
4770 curchnk
->mlcs_numlines
= 1;
4771 curchnk
[-1].mlcs_totalsize
-= rest
;
4772 curchnk
[-1].mlcs_numlines
-= 1;
4776 else if (updtype
== ML_CHNK_DELLINE
)
4778 curchnk
->mlcs_numlines
--;
4779 ml_upd_lastbuf
= NULL
; /* Force recalc of curix & curline */
4780 if (curix
< (buf
->b_ml
.ml_usedchunks
- 1)
4781 && (curchnk
->mlcs_numlines
+ curchnk
[1].mlcs_numlines
)
4785 curchnk
= buf
->b_ml
.ml_chunksize
+ curix
;
4787 else if (curix
== 0 && curchnk
->mlcs_numlines
<= 0)
4789 buf
->b_ml
.ml_usedchunks
--;
4790 mch_memmove(buf
->b_ml
.ml_chunksize
, buf
->b_ml
.ml_chunksize
+ 1,
4791 buf
->b_ml
.ml_usedchunks
* sizeof(chunksize_T
));
4794 else if (curix
== 0 || (curchnk
->mlcs_numlines
> 10
4795 && (curchnk
->mlcs_numlines
+ curchnk
[-1].mlcs_numlines
)
4801 /* Collapse chunks */
4802 curchnk
[-1].mlcs_numlines
+= curchnk
->mlcs_numlines
;
4803 curchnk
[-1].mlcs_totalsize
+= curchnk
->mlcs_totalsize
;
4804 buf
->b_ml
.ml_usedchunks
--;
4805 if (curix
< buf
->b_ml
.ml_usedchunks
)
4807 mch_memmove(buf
->b_ml
.ml_chunksize
+ curix
,
4808 buf
->b_ml
.ml_chunksize
+ curix
+ 1,
4809 (buf
->b_ml
.ml_usedchunks
- curix
) *
4810 sizeof(chunksize_T
));
4814 ml_upd_lastbuf
= buf
;
4815 ml_upd_lastline
= line
;
4816 ml_upd_lastcurline
= curline
;
4817 ml_upd_lastcurix
= curix
;
4821 * Find offset for line or line with offset.
4822 * Find line with offset if "lnum" is 0; return remaining offset in offp
4823 * Find offset of line if "lnum" > 0
4824 * return -1 if information is not available
4827 ml_find_line_or_offset(buf
, lnum
, offp
)
4837 int count
; /* number of entries in block */
4843 int ffdos
= (get_fileformat(buf
) == EOL_DOS
);
4846 /* take care of cached line first */
4847 ml_flush_line(curbuf
);
4849 if (buf
->b_ml
.ml_usedchunks
== -1
4850 || buf
->b_ml
.ml_chunksize
== NULL
4858 if (lnum
== 0 && offset
<= 0)
4859 return 1; /* Not a "find offset" and offset 0 _must_ be in line 1 */
4861 * Find the last chunk before the one containing our line. Last chunk is
4862 * special because it will never qualify
4866 while (curix
< buf
->b_ml
.ml_usedchunks
- 1
4868 && lnum
>= curline
+ buf
->b_ml
.ml_chunksize
[curix
].mlcs_numlines
)
4870 && offset
> size
+ buf
->b_ml
.ml_chunksize
[curix
].mlcs_totalsize
4871 + ffdos
* buf
->b_ml
.ml_chunksize
[curix
].mlcs_numlines
)))
4873 curline
+= buf
->b_ml
.ml_chunksize
[curix
].mlcs_numlines
;
4874 size
+= buf
->b_ml
.ml_chunksize
[curix
].mlcs_totalsize
;
4875 if (offset
&& ffdos
)
4876 size
+= buf
->b_ml
.ml_chunksize
[curix
].mlcs_numlines
;
4880 while ((lnum
!= 0 && curline
< lnum
) || (offset
!= 0 && size
< offset
))
4882 if (curline
> buf
->b_ml
.ml_line_count
4883 || (hp
= ml_find_line(buf
, curline
, ML_FIND
)) == NULL
)
4885 dp
= (DATA_BL
*)(hp
->bh_data
);
4886 count
= (long)(buf
->b_ml
.ml_locked_high
) -
4887 (long)(buf
->b_ml
.ml_locked_low
) + 1;
4888 start_idx
= idx
= curline
- buf
->b_ml
.ml_locked_low
;
4889 if (idx
== 0)/* first line in block, text at the end */
4890 text_end
= dp
->db_txt_end
;
4892 text_end
= ((dp
->db_index
[idx
- 1]) & DB_INDEX_MASK
);
4893 /* Compute index of last line to use in this MEMLINE */
4896 if (curline
+ (count
- idx
) >= lnum
)
4897 idx
+= lnum
- curline
- 1;
4904 while (offset
>= size
4905 + text_end
- (int)((dp
->db_index
[idx
]) & DB_INDEX_MASK
)
4910 if (idx
== count
- 1)
4918 len
= text_end
- ((dp
->db_index
[idx
]) & DB_INDEX_MASK
);
4920 if (offset
!= 0 && size
>= offset
)
4922 if (size
+ ffdos
== offset
)
4924 else if (idx
== start_idx
)
4925 *offp
= offset
- size
+ len
;
4927 *offp
= offset
- size
+ len
4928 - (text_end
- ((dp
->db_index
[idx
- 1]) & DB_INDEX_MASK
));
4929 curline
+= idx
- start_idx
+ extra
;
4930 if (curline
> buf
->b_ml
.ml_line_count
)
4931 return -1; /* exactly one byte beyond the end */
4934 curline
= buf
->b_ml
.ml_locked_high
+ 1;
4939 /* Count extra CR characters. */
4943 /* Don't count the last line break if 'bin' and 'noeol'. */
4944 if (buf
->b_p_bin
&& !buf
->b_p_eol
)
4952 * Goto byte in buffer with offset 'cnt'.
4961 ml_flush_line(curbuf
); /* cached line may be dirty */
4965 lnum
= ml_find_line_or_offset(curbuf
, (linenr_T
)0, &boff
);
4966 if (lnum
< 1) /* past the end */
4968 curwin
->w_cursor
.lnum
= curbuf
->b_ml
.ml_line_count
;
4969 curwin
->w_curswant
= MAXCOL
;
4970 coladvance((colnr_T
)MAXCOL
);
4974 curwin
->w_cursor
.lnum
= lnum
;
4975 curwin
->w_cursor
.col
= (colnr_T
)boff
;
4976 # ifdef FEAT_VIRTUALEDIT
4977 curwin
->w_cursor
.coladd
= 0;
4979 curwin
->w_set_curswant
= TRUE
;
4984 /* Make sure the cursor is on the first byte of a multi-byte char. */