/* vi:set ts=8 sts=4 sw=4: * * VIM - Vi IMproved by Bram Moolenaar * * Do ":help uganda" in Vim to read copying and usage conditions. * Do ":help credits" in Vim to see a list of people who contributed. * See README.txt for an overview of the Vim source code. */ /* for debugging */ /* #define CHECK(c, s) if (c) EMSG(s) */ #define CHECK(c, s) /* * memline.c: Contains the functions for appending, deleting and changing the * text lines. The memfile functions are used to store the information in * blocks of memory, backed up by a file. The structure of the information is * a tree. The root of the tree is a pointer block. The leaves of the tree * are data blocks. In between may be several layers of pointer blocks, * forming branches. * * Three types of blocks are used: * - Block nr 0 contains information for recovery * - Pointer blocks contain list of pointers to other blocks. * - Data blocks contain the actual text. * * Block nr 0 contains the block0 structure (see below). * * Block nr 1 is the first pointer block. It is the root of the tree. * Other pointer blocks are branches. * * If a line is too big to fit in a single page, the block containing that * line is made big enough to hold the line. It may span several pages. * Otherwise all blocks are one page. * * A data block that was filled when starting to edit a file and was not * changed since then, can have a negative block number. This means that it * has not yet been assigned a place in the file. When recovering, the lines * in this data block can be read from the original file. When the block is * changed (lines appended/deleted/changed) or when it is flushed it gets a * positive number. Use mf_trans_del() to get the new number, before calling * mf_get(). */ #if defined(MSDOS) || defined(WIN16) || defined(WIN32) || defined(_WIN64) # include "vimio.h" /* for mch_open(), must be before vim.h */ #endif #include "vim.h" #ifndef UNIX /* it's in os_unix.h for Unix */ # include #endif #if defined(SASC) || defined(__amigaos4__) # include /* for Open() and Close() */ #endif #ifdef HAVE_ERRNO_H # include #endif typedef struct block0 ZERO_BL; /* contents of the first block */ typedef struct pointer_block PTR_BL; /* contents of a pointer block */ typedef struct data_block DATA_BL; /* contents of a data block */ typedef struct pointer_entry PTR_EN; /* block/line-count pair */ #define DATA_ID (('d' << 8) + 'a') /* data block id */ #define PTR_ID (('p' << 8) + 't') /* pointer block id */ #define BLOCK0_ID0 'b' /* block 0 id 0 */ #define BLOCK0_ID1 '0' /* block 0 id 1 */ /* * pointer to a block, used in a pointer block */ struct pointer_entry { blocknr_T pe_bnum; /* block number */ linenr_T pe_line_count; /* number of lines in this branch */ linenr_T pe_old_lnum; /* lnum for this block (for recovery) */ int pe_page_count; /* number of pages in block pe_bnum */ }; /* * A pointer block contains a list of branches in the tree. */ struct pointer_block { short_u pb_id; /* ID for pointer block: PTR_ID */ short_u pb_count; /* number of pointer in this block */ short_u pb_count_max; /* maximum value for pb_count */ PTR_EN pb_pointer[1]; /* list of pointers to blocks (actually longer) * followed by empty space until end of page */ }; /* * A data block is a leaf in the tree. * * The text of the lines is at the end of the block. The text of the first line * in the block is put at the end, the text of the second line in front of it, * etc. Thus the order of the lines is the opposite of the line number. */ struct data_block { short_u db_id; /* ID for data block: DATA_ID */ unsigned db_free; /* free space available */ unsigned db_txt_start; /* byte where text starts */ unsigned db_txt_end; /* byte just after data block */ linenr_T db_line_count; /* number of lines in this block */ unsigned db_index[1]; /* index for start of line (actually bigger) * followed by empty space upto db_txt_start * followed by the text in the lines until * end of page */ }; /* * The low bits of db_index hold the actual index. The topmost bit is * used for the global command to be able to mark a line. * This method is not clean, but otherwise there would be at least one extra * byte used for each line. * The mark has to be in this place to keep it with the correct line when other * lines are inserted or deleted. */ #define DB_MARKED ((unsigned)1 << ((sizeof(unsigned) * 8) - 1)) #define DB_INDEX_MASK (~DB_MARKED) #define INDEX_SIZE (sizeof(unsigned)) /* size of one db_index entry */ #define HEADER_SIZE (sizeof(DATA_BL) - INDEX_SIZE) /* size of data block header */ #define B0_FNAME_SIZE_ORG 900 /* what it was in older versions */ #define B0_FNAME_SIZE 898 #define B0_UNAME_SIZE 40 #define B0_HNAME_SIZE 40 /* * Restrict the numbers to 32 bits, otherwise most compilers will complain. * This won't detect a 64 bit machine that only swaps a byte in the top 32 * bits, but that is crazy anyway. */ #define B0_MAGIC_LONG 0x30313233L #define B0_MAGIC_INT 0x20212223L #define B0_MAGIC_SHORT 0x10111213L #define B0_MAGIC_CHAR 0x55 /* * Block zero holds all info about the swap file. * * NOTE: DEFINITION OF BLOCK 0 SHOULD NOT CHANGE! It would make all existing * swap files unusable! * * If size of block0 changes anyway, adjust MIN_SWAP_PAGE_SIZE in vim.h!! * * This block is built up of single bytes, to make it portable across * different machines. b0_magic_* is used to check the byte order and size of * variables, because the rest of the swap file is not portable. */ struct block0 { char_u b0_id[2]; /* id for block 0: BLOCK0_ID0 and BLOCK0_ID1 */ char_u b0_version[10]; /* Vim version string */ char_u b0_page_size[4];/* number of bytes per page */ char_u b0_mtime[4]; /* last modification time of file */ char_u b0_ino[4]; /* inode of b0_fname */ char_u b0_pid[4]; /* process id of creator (or 0) */ char_u b0_uname[B0_UNAME_SIZE]; /* name of user (uid if no name) */ char_u b0_hname[B0_HNAME_SIZE]; /* host name (if it has a name) */ char_u b0_fname[B0_FNAME_SIZE_ORG]; /* name of file being edited */ long b0_magic_long; /* check for byte order of long */ int b0_magic_int; /* check for byte order of int */ short b0_magic_short; /* check for byte order of short */ char_u b0_magic_char; /* check for last char */ }; /* * Note: b0_dirty and b0_flags are put at the end of the file name. For very * long file names in older versions of Vim they are invalid. * The 'fileencoding' comes before b0_flags, with a NUL in front. But only * when there is room, for very long file names it's omitted. */ #define B0_DIRTY 0x55 #define b0_dirty b0_fname[B0_FNAME_SIZE_ORG-1] /* * The b0_flags field is new in Vim 7.0. */ #define b0_flags b0_fname[B0_FNAME_SIZE_ORG-2] /* The lowest two bits contain the fileformat. Zero means it's not set * (compatible with Vim 6.x), otherwise it's EOL_UNIX + 1, EOL_DOS + 1 or * EOL_MAC + 1. */ #define B0_FF_MASK 3 /* Swap file is in directory of edited file. Used to find the file from * different mount points. */ #define B0_SAME_DIR 4 /* The 'fileencoding' is at the end of b0_fname[], with a NUL in front of it. * When empty there is only the NUL. */ #define B0_HAS_FENC 8 #define STACK_INCR 5 /* nr of entries added to ml_stack at a time */ /* * The line number where the first mark may be is remembered. * If it is 0 there are no marks at all. * (always used for the current buffer only, no buffer change possible while * executing a global command). */ static linenr_T lowest_marked = 0; /* * arguments for ml_find_line() */ #define ML_DELETE 0x11 /* delete line */ #define ML_INSERT 0x12 /* insert line */ #define ML_FIND 0x13 /* just find the line */ #define ML_FLUSH 0x02 /* flush locked block */ #define ML_SIMPLE(x) (x & 0x10) /* DEL, INS or FIND */ static void ml_upd_block0 __ARGS((buf_T *buf, int set_fname)); static void set_b0_fname __ARGS((ZERO_BL *, buf_T *buf)); static void set_b0_dir_flag __ARGS((ZERO_BL *b0p, buf_T *buf)); #ifdef FEAT_MBYTE static void add_b0_fenc __ARGS((ZERO_BL *b0p, buf_T *buf)); #endif static time_t swapfile_info __ARGS((char_u *)); static int recov_file_names __ARGS((char_u **, char_u *, int prepend_dot)); static int ml_append_int __ARGS((buf_T *, linenr_T, char_u *, colnr_T, int, int)); static int ml_delete_int __ARGS((buf_T *, linenr_T, int)); static char_u *findswapname __ARGS((buf_T *, char_u **, char_u *)); static void ml_flush_line __ARGS((buf_T *)); static bhdr_T *ml_new_data __ARGS((memfile_T *, int, int)); static bhdr_T *ml_new_ptr __ARGS((memfile_T *)); static bhdr_T *ml_find_line __ARGS((buf_T *, linenr_T, int)); static int ml_add_stack __ARGS((buf_T *)); static void ml_lineadd __ARGS((buf_T *, int)); static int b0_magic_wrong __ARGS((ZERO_BL *)); #ifdef CHECK_INODE static int fnamecmp_ino __ARGS((char_u *, char_u *, long)); #endif static void long_to_char __ARGS((long, char_u *)); static long char_to_long __ARGS((char_u *)); #if defined(UNIX) || defined(WIN3264) static char_u *make_percent_swname __ARGS((char_u *dir, char_u *name)); #endif #ifdef FEAT_BYTEOFF static void ml_updatechunk __ARGS((buf_T *buf, long line, long len, int updtype)); #endif #ifdef HAVE_READLINK static int resolve_symlink __ARGS((char_u *fname, char_u *buf)); #endif /* * Open a new memline for "buf". * * Return FAIL for failure, OK otherwise. */ int ml_open(buf) buf_T *buf; { memfile_T *mfp; bhdr_T *hp = NULL; ZERO_BL *b0p; PTR_BL *pp; DATA_BL *dp; /* * init fields in memline struct */ buf->b_ml.ml_stack_size = 0; /* no stack yet */ buf->b_ml.ml_stack = NULL; /* no stack yet */ buf->b_ml.ml_stack_top = 0; /* nothing in the stack */ buf->b_ml.ml_locked = NULL; /* no cached block */ buf->b_ml.ml_line_lnum = 0; /* no cached line */ #ifdef FEAT_BYTEOFF buf->b_ml.ml_chunksize = NULL; #endif /* * When 'updatecount' is non-zero swap file may be opened later. */ if (p_uc && buf->b_p_swf) buf->b_may_swap = TRUE; else buf->b_may_swap = FALSE; /* * Open the memfile. No swap file is created yet. */ mfp = mf_open(NULL, 0); if (mfp == NULL) goto error; buf->b_ml.ml_mfp = mfp; buf->b_ml.ml_flags = ML_EMPTY; buf->b_ml.ml_line_count = 1; #ifdef FEAT_LINEBREAK curwin->w_nrwidth_line_count = 0; #endif #if defined(MSDOS) && !defined(DJGPP) /* for 16 bit MS-DOS create a swapfile now, because we run out of * memory very quickly */ if (p_uc != 0) ml_open_file(buf); #endif /* * fill block0 struct and write page 0 */ if ((hp = mf_new(mfp, FALSE, 1)) == NULL) goto error; if (hp->bh_bnum != 0) { EMSG(_("E298: Didn't get block nr 0?")); goto error; } b0p = (ZERO_BL *)(hp->bh_data); b0p->b0_id[0] = BLOCK0_ID0; b0p->b0_id[1] = BLOCK0_ID1; b0p->b0_magic_long = (long)B0_MAGIC_LONG; b0p->b0_magic_int = (int)B0_MAGIC_INT; b0p->b0_magic_short = (short)B0_MAGIC_SHORT; b0p->b0_magic_char = B0_MAGIC_CHAR; STRNCPY(b0p->b0_version, "VIM ", 4); STRNCPY(b0p->b0_version + 4, Version, 6); long_to_char((long)mfp->mf_page_size, b0p->b0_page_size); #ifdef FEAT_SPELL if (!buf->b_spell) #endif { b0p->b0_dirty = buf->b_changed ? B0_DIRTY : 0; b0p->b0_flags = get_fileformat(buf) + 1; set_b0_fname(b0p, buf); (void)get_user_name(b0p->b0_uname, B0_UNAME_SIZE); b0p->b0_uname[B0_UNAME_SIZE - 1] = NUL; mch_get_host_name(b0p->b0_hname, B0_HNAME_SIZE); b0p->b0_hname[B0_HNAME_SIZE - 1] = NUL; long_to_char(mch_get_pid(), b0p->b0_pid); } /* * Always sync block number 0 to disk, so we can check the file name in * the swap file in findswapname(). Don't do this for help files though * and spell buffer though. * Only works when there's a swapfile, otherwise it's done when the file * is created. */ mf_put(mfp, hp, TRUE, FALSE); if (!buf->b_help && !B_SPELL(buf)) (void)mf_sync(mfp, 0); /* * Fill in root pointer block and write page 1. */ if ((hp = ml_new_ptr(mfp)) == NULL) goto error; if (hp->bh_bnum != 1) { EMSG(_("E298: Didn't get block nr 1?")); goto error; } pp = (PTR_BL *)(hp->bh_data); pp->pb_count = 1; pp->pb_pointer[0].pe_bnum = 2; pp->pb_pointer[0].pe_page_count = 1; pp->pb_pointer[0].pe_old_lnum = 1; pp->pb_pointer[0].pe_line_count = 1; /* line count after insertion */ mf_put(mfp, hp, TRUE, FALSE); /* * Allocate first data block and create an empty line 1. */ if ((hp = ml_new_data(mfp, FALSE, 1)) == NULL) goto error; if (hp->bh_bnum != 2) { EMSG(_("E298: Didn't get block nr 2?")); goto error; } dp = (DATA_BL *)(hp->bh_data); dp->db_index[0] = --dp->db_txt_start; /* at end of block */ dp->db_free -= 1 + INDEX_SIZE; dp->db_line_count = 1; *((char_u *)dp + dp->db_txt_start) = NUL; /* empty line */ return OK; error: if (mfp != NULL) { if (hp) mf_put(mfp, hp, FALSE, FALSE); mf_close(mfp, TRUE); /* will also free(mfp->mf_fname) */ } buf->b_ml.ml_mfp = NULL; return FAIL; } /* * ml_setname() is called when the file name of "buf" has been changed. * It may rename the swap file. */ void ml_setname(buf) buf_T *buf; { int success = FALSE; memfile_T *mfp; char_u *fname; char_u *dirp; #if defined(MSDOS) || defined(MSWIN) char_u *p; #endif mfp = buf->b_ml.ml_mfp; if (mfp->mf_fd < 0) /* there is no swap file yet */ { /* * When 'updatecount' is 0 and 'noswapfile' there is no swap file. * For help files we will make a swap file now. */ if (p_uc != 0) ml_open_file(buf); /* create a swap file */ return; } /* * Try all directories in the 'directory' option. */ dirp = p_dir; for (;;) { if (*dirp == NUL) /* tried all directories, fail */ break; fname = findswapname(buf, &dirp, mfp->mf_fname); /* alloc's fname */ if (fname == NULL) /* no file name found for this dir */ continue; #if defined(MSDOS) || defined(MSWIN) /* * Set full pathname for swap file now, because a ":!cd dir" may * change directory without us knowing it. */ p = FullName_save(fname, FALSE); vim_free(fname); fname = p; if (fname == NULL) continue; #endif /* if the file name is the same we don't have to do anything */ if (fnamecmp(fname, mfp->mf_fname) == 0) { vim_free(fname); success = TRUE; break; } /* need to close the swap file before renaming */ if (mfp->mf_fd >= 0) { close(mfp->mf_fd); mfp->mf_fd = -1; } /* try to rename the swap file */ if (vim_rename(mfp->mf_fname, fname) == 0) { success = TRUE; vim_free(mfp->mf_fname); mfp->mf_fname = fname; vim_free(mfp->mf_ffname); #if defined(MSDOS) || defined(MSWIN) mfp->mf_ffname = NULL; /* mf_fname is full pathname already */ #else mf_set_ffname(mfp); #endif ml_upd_block0(buf, FALSE); break; } vim_free(fname); /* this fname didn't work, try another */ } if (mfp->mf_fd == -1) /* need to (re)open the swap file */ { mfp->mf_fd = mch_open((char *)mfp->mf_fname, O_RDWR | O_EXTRA, 0); if (mfp->mf_fd < 0) { /* could not (re)open the swap file, what can we do???? */ EMSG(_("E301: Oops, lost the swap file!!!")); return; } #ifdef HAVE_FD_CLOEXEC { int fdflags = fcntl(mfp->mf_fd, F_GETFD); if (fdflags >= 0 && (fdflags & FD_CLOEXEC) == 0) fcntl(mfp->mf_fd, F_SETFD, fdflags | FD_CLOEXEC); } #endif } if (!success) EMSG(_("E302: Could not rename swap file")); } /* * Open a file for the memfile for all buffers that are not readonly or have * been modified. * Used when 'updatecount' changes from zero to non-zero. */ void ml_open_files() { buf_T *buf; for (buf = firstbuf; buf != NULL; buf = buf->b_next) if (!buf->b_p_ro || buf->b_changed) ml_open_file(buf); } /* * Open a swap file for an existing memfile, if there is no swap file yet. * If we are unable to find a file name, mf_fname will be NULL * and the memfile will be in memory only (no recovery possible). */ void ml_open_file(buf) buf_T *buf; { memfile_T *mfp; char_u *fname; char_u *dirp; mfp = buf->b_ml.ml_mfp; if (mfp == NULL || mfp->mf_fd >= 0 || !buf->b_p_swf) return; /* nothing to do */ #ifdef FEAT_SPELL /* For a spell buffer use a temp file name. */ if (buf->b_spell) { fname = vim_tempname('s'); if (fname != NULL) (void)mf_open_file(mfp, fname); /* consumes fname! */ buf->b_may_swap = FALSE; return; } #endif /* * Try all directories in 'directory' option. */ dirp = p_dir; for (;;) { if (*dirp == NUL) break; /* There is a small chance that between chosing the swap file name and * creating it, another Vim creates the file. In that case the * creation will fail and we will use another directory. */ fname = findswapname(buf, &dirp, NULL); /* allocates fname */ if (fname == NULL) continue; if (mf_open_file(mfp, fname) == OK) /* consumes fname! */ { #if defined(MSDOS) || defined(MSWIN) || defined(RISCOS) /* * set full pathname for swap file now, because a ":!cd dir" may * change directory without us knowing it. */ mf_fullname(mfp); #endif ml_upd_block0(buf, FALSE); /* Flush block zero, so others can read it */ if (mf_sync(mfp, MFS_ZERO) == OK) { /* Mark all blocks that should be in the swapfile as dirty. * Needed for when the 'swapfile' option was reset, so that * the swap file was deleted, and then on again. */ mf_set_dirty(mfp); break; } /* Writing block 0 failed: close the file and try another dir */ mf_close_file(buf, FALSE); } } if (mfp->mf_fname == NULL) /* Failed! */ { need_wait_return = TRUE; /* call wait_return later */ ++no_wait_return; (void)EMSG2(_("E303: Unable to open swap file for \"%s\", recovery impossible"), buf_spname(buf) != NULL ? (char_u *)buf_spname(buf) : buf->b_fname); --no_wait_return; } /* don't try to open a swap file again */ buf->b_may_swap = FALSE; } /* * If still need to create a swap file, and starting to edit a not-readonly * file, or reading into an existing buffer, create a swap file now. */ void check_need_swap(newfile) int newfile; /* reading file into new buffer */ { if (curbuf->b_may_swap && (!curbuf->b_p_ro || !newfile)) ml_open_file(curbuf); } /* * Close memline for buffer 'buf'. * If 'del_file' is TRUE, delete the swap file */ void ml_close(buf, del_file) buf_T *buf; int del_file; { if (buf->b_ml.ml_mfp == NULL) /* not open */ return; mf_close(buf->b_ml.ml_mfp, del_file); /* close the .swp file */ if (buf->b_ml.ml_line_lnum != 0 && (buf->b_ml.ml_flags & ML_LINE_DIRTY)) vim_free(buf->b_ml.ml_line_ptr); vim_free(buf->b_ml.ml_stack); #ifdef FEAT_BYTEOFF vim_free(buf->b_ml.ml_chunksize); buf->b_ml.ml_chunksize = NULL; #endif buf->b_ml.ml_mfp = NULL; /* Reset the "recovered" flag, give the ATTENTION prompt the next time * this buffer is loaded. */ buf->b_flags &= ~BF_RECOVERED; } /* * Close all existing memlines and memfiles. * Only used when exiting. * When 'del_file' is TRUE, delete the memfiles. * But don't delete files that were ":preserve"d when we are POSIX compatible. */ void ml_close_all(del_file) int del_file; { buf_T *buf; for (buf = firstbuf; buf != NULL; buf = buf->b_next) ml_close(buf, del_file && ((buf->b_flags & BF_PRESERVED) == 0 || vim_strchr(p_cpo, CPO_PRESERVE) == NULL)); #ifdef TEMPDIRNAMES vim_deltempdir(); /* delete created temp directory */ #endif } /* * Close all memfiles for not modified buffers. * Only use just before exiting! */ void ml_close_notmod() { buf_T *buf; for (buf = firstbuf; buf != NULL; buf = buf->b_next) if (!bufIsChanged(buf)) ml_close(buf, TRUE); /* close all not-modified buffers */ } /* * Update the timestamp in the .swp file. * Used when the file has been written. */ void ml_timestamp(buf) buf_T *buf; { ml_upd_block0(buf, TRUE); } /* * Update the timestamp or the B0_SAME_DIR flag of the .swp file. */ static void ml_upd_block0(buf, set_fname) buf_T *buf; int set_fname; { memfile_T *mfp; bhdr_T *hp; ZERO_BL *b0p; mfp = buf->b_ml.ml_mfp; if (mfp == NULL || (hp = mf_get(mfp, (blocknr_T)0, 1)) == NULL) return; b0p = (ZERO_BL *)(hp->bh_data); if (b0p->b0_id[0] != BLOCK0_ID0 || b0p->b0_id[1] != BLOCK0_ID1) EMSG(_("E304: ml_upd_block0(): Didn't get block 0??")); else { if (set_fname) set_b0_fname(b0p, buf); else set_b0_dir_flag(b0p, buf); } mf_put(mfp, hp, TRUE, FALSE); } /* * Write file name and timestamp into block 0 of a swap file. * Also set buf->b_mtime. * Don't use NameBuff[]!!! */ static void set_b0_fname(b0p, buf) ZERO_BL *b0p; buf_T *buf; { struct stat st; if (buf->b_ffname == NULL) b0p->b0_fname[0] = NUL; else { #if defined(MSDOS) || defined(MSWIN) || defined(AMIGA) || defined(RISCOS) /* Systems that cannot translate "~user" back into a path: copy the * file name unmodified. Do use slashes instead of backslashes for * portability. */ vim_strncpy(b0p->b0_fname, buf->b_ffname, B0_FNAME_SIZE - 1); # ifdef BACKSLASH_IN_FILENAME forward_slash(b0p->b0_fname); # endif #else size_t flen, ulen; char_u uname[B0_UNAME_SIZE]; /* * For a file under the home directory of the current user, we try to * replace the home directory path with "~user". This helps when * editing the same file on different machines over a network. * First replace home dir path with "~/" with home_replace(). * Then insert the user name to get "~user/". */ home_replace(NULL, buf->b_ffname, b0p->b0_fname, B0_FNAME_SIZE, TRUE); if (b0p->b0_fname[0] == '~') { flen = STRLEN(b0p->b0_fname); /* If there is no user name or it is too long, don't use "~/" */ if (get_user_name(uname, B0_UNAME_SIZE) == FAIL || (ulen = STRLEN(uname)) + flen > B0_FNAME_SIZE - 1) vim_strncpy(b0p->b0_fname, buf->b_ffname, B0_FNAME_SIZE - 1); else { mch_memmove(b0p->b0_fname + ulen + 1, b0p->b0_fname + 1, flen); mch_memmove(b0p->b0_fname + 1, uname, ulen); } } #endif if (mch_stat((char *)buf->b_ffname, &st) >= 0) { long_to_char((long)st.st_mtime, b0p->b0_mtime); #ifdef CHECK_INODE long_to_char((long)st.st_ino, b0p->b0_ino); #endif buf_store_time(buf, &st, buf->b_ffname); buf->b_mtime_read = buf->b_mtime; } else { long_to_char(0L, b0p->b0_mtime); #ifdef CHECK_INODE long_to_char(0L, b0p->b0_ino); #endif buf->b_mtime = 0; buf->b_mtime_read = 0; buf->b_orig_size = 0; buf->b_orig_mode = 0; } } #ifdef FEAT_MBYTE /* Also add the 'fileencoding' if there is room. */ add_b0_fenc(b0p, curbuf); #endif } /* * Update the B0_SAME_DIR flag of the swap file. It's set if the file and the * swapfile for "buf" are in the same directory. * This is fail safe: if we are not sure the directories are equal the flag is * not set. */ static void set_b0_dir_flag(b0p, buf) ZERO_BL *b0p; buf_T *buf; { if (same_directory(buf->b_ml.ml_mfp->mf_fname, buf->b_ffname)) b0p->b0_flags |= B0_SAME_DIR; else b0p->b0_flags &= ~B0_SAME_DIR; } #ifdef FEAT_MBYTE /* * When there is room, add the 'fileencoding' to block zero. */ static void add_b0_fenc(b0p, buf) ZERO_BL *b0p; buf_T *buf; { int n; n = (int)STRLEN(buf->b_p_fenc); if (STRLEN(b0p->b0_fname) + n + 1 > B0_FNAME_SIZE) b0p->b0_flags &= ~B0_HAS_FENC; else { mch_memmove((char *)b0p->b0_fname + B0_FNAME_SIZE - n, (char *)buf->b_p_fenc, (size_t)n); *(b0p->b0_fname + B0_FNAME_SIZE - n - 1) = NUL; b0p->b0_flags |= B0_HAS_FENC; } } #endif /* * try to recover curbuf from the .swp file */ void ml_recover() { buf_T *buf = NULL; memfile_T *mfp = NULL; char_u *fname; bhdr_T *hp = NULL; ZERO_BL *b0p; int b0_ff; char_u *b0_fenc = NULL; PTR_BL *pp; DATA_BL *dp; infoptr_T *ip; blocknr_T bnum; int page_count; struct stat org_stat, swp_stat; int len; int directly; linenr_T lnum; char_u *p; int i; long error; int cannot_open; linenr_T line_count; int has_error; int idx; int top; int txt_start; off_t size; int called_from_main; int serious_error = TRUE; long mtime; int attr; recoverymode = TRUE; called_from_main = (curbuf->b_ml.ml_mfp == NULL); attr = hl_attr(HLF_E); /* * If the file name ends in ".s[uvw][a-z]" we assume this is the swap file. * Otherwise a search is done to find the swap file(s). */ fname = curbuf->b_fname; if (fname == NULL) /* When there is no file name */ fname = (char_u *)""; len = (int)STRLEN(fname); if (len >= 4 && #if defined(VMS) || defined(RISCOS) STRNICMP(fname + len - 4, "_s" , 2) #else STRNICMP(fname + len - 4, ".s" , 2) #endif == 0 && vim_strchr((char_u *)"UVWuvw", fname[len - 2]) != NULL && ASCII_ISALPHA(fname[len - 1])) { directly = TRUE; fname = vim_strsave(fname); /* make a copy for mf_open() */ } else { directly = FALSE; /* count the number of matching swap files */ len = recover_names(&fname, FALSE, 0); if (len == 0) /* no swap files found */ { EMSG2(_("E305: No swap file found for %s"), fname); goto theend; } if (len == 1) /* one swap file found, use it */ i = 1; else /* several swap files found, choose */ { /* list the names of the swap files */ (void)recover_names(&fname, TRUE, 0); msg_putchar('\n'); MSG_PUTS(_("Enter number of swap file to use (0 to quit): ")); i = get_number(FALSE, NULL); if (i < 1 || i > len) goto theend; } /* get the swap file name that will be used */ (void)recover_names(&fname, FALSE, i); } if (fname == NULL) goto theend; /* out of memory */ /* When called from main() still need to initialize storage structure */ if (called_from_main && ml_open(curbuf) == FAIL) getout(1); /* * allocate a buffer structure (only the memline in it is really used) */ buf = (buf_T *)alloc((unsigned)sizeof(buf_T)); if (buf == NULL) { vim_free(fname); goto theend; } /* * init fields in memline struct */ buf->b_ml.ml_stack_size = 0; /* no stack yet */ buf->b_ml.ml_stack = NULL; /* no stack yet */ buf->b_ml.ml_stack_top = 0; /* nothing in the stack */ buf->b_ml.ml_line_lnum = 0; /* no cached line */ buf->b_ml.ml_locked = NULL; /* no locked block */ buf->b_ml.ml_flags = 0; /* * open the memfile from the old swap file */ p = vim_strsave(fname); /* save fname for the message (mf_open() may free fname) */ mfp = mf_open(fname, O_RDONLY); /* consumes fname! */ if (mfp == NULL || mfp->mf_fd < 0) { if (p != NULL) { EMSG2(_("E306: Cannot open %s"), p); vim_free(p); } goto theend; } vim_free(p); buf->b_ml.ml_mfp = mfp; /* * The page size set in mf_open() might be different from the page size * used in the swap file, we must get it from block 0. But to read block * 0 we need a page size. Use the minimal size for block 0 here, it will * be set to the real value below. */ mfp->mf_page_size = MIN_SWAP_PAGE_SIZE; /* * try to read block 0 */ if ((hp = mf_get(mfp, (blocknr_T)0, 1)) == NULL) { msg_start(); MSG_PUTS_ATTR(_("Unable to read block 0 from "), attr | MSG_HIST); msg_outtrans_attr(mfp->mf_fname, attr | MSG_HIST); MSG_PUTS_ATTR( _("\nMaybe no changes were made or Vim did not update the swap file."), attr | MSG_HIST); msg_end(); goto theend; } b0p = (ZERO_BL *)(hp->bh_data); if (STRNCMP(b0p->b0_version, "VIM 3.0", 7) == 0) { msg_start(); msg_outtrans_attr(mfp->mf_fname, MSG_HIST); MSG_PUTS_ATTR(_(" cannot be used with this version of Vim.\n"), MSG_HIST); MSG_PUTS_ATTR(_("Use Vim version 3.0.\n"), MSG_HIST); msg_end(); goto theend; } if (b0p->b0_id[0] != BLOCK0_ID0 || b0p->b0_id[1] != BLOCK0_ID1) { EMSG2(_("E307: %s does not look like a Vim swap file"), mfp->mf_fname); goto theend; } if (b0_magic_wrong(b0p)) { msg_start(); msg_outtrans_attr(mfp->mf_fname, attr | MSG_HIST); #if defined(MSDOS) || defined(MSWIN) if (STRNCMP(b0p->b0_hname, "PC ", 3) == 0) MSG_PUTS_ATTR(_(" cannot be used with this version of Vim.\n"), attr | MSG_HIST); else #endif MSG_PUTS_ATTR(_(" cannot be used on this computer.\n"), attr | MSG_HIST); MSG_PUTS_ATTR(_("The file was created on "), attr | MSG_HIST); /* avoid going past the end of a currupted hostname */ b0p->b0_fname[0] = NUL; MSG_PUTS_ATTR(b0p->b0_hname, attr | MSG_HIST); MSG_PUTS_ATTR(_(",\nor the file has been damaged."), attr | MSG_HIST); msg_end(); goto theend; } /* * If we guessed the wrong page size, we have to recalculate the * highest block number in the file. */ if (mfp->mf_page_size != (unsigned)char_to_long(b0p->b0_page_size)) { unsigned previous_page_size = mfp->mf_page_size; mf_new_page_size(mfp, (unsigned)char_to_long(b0p->b0_page_size)); if (mfp->mf_page_size < previous_page_size) { msg_start(); msg_outtrans_attr(mfp->mf_fname, attr | MSG_HIST); MSG_PUTS_ATTR(_(" has been damaged (page size is smaller than minimum value).\n"), attr | MSG_HIST); msg_end(); goto theend; } if ((size = lseek(mfp->mf_fd, (off_t)0L, SEEK_END)) <= 0) mfp->mf_blocknr_max = 0; /* no file or empty file */ else mfp->mf_blocknr_max = (blocknr_T)(size / mfp->mf_page_size); mfp->mf_infile_count = mfp->mf_blocknr_max; /* need to reallocate the memory used to store the data */ p = alloc(mfp->mf_page_size); if (p == NULL) goto theend; mch_memmove(p, hp->bh_data, previous_page_size); vim_free(hp->bh_data); hp->bh_data = p; b0p = (ZERO_BL *)(hp->bh_data); } /* * If .swp file name given directly, use name from swap file for buffer. */ if (directly) { expand_env(b0p->b0_fname, NameBuff, MAXPATHL); if (setfname(curbuf, NameBuff, NULL, TRUE) == FAIL) goto theend; } home_replace(NULL, mfp->mf_fname, NameBuff, MAXPATHL, TRUE); smsg((char_u *)_("Using swap file \"%s\""), NameBuff); if (buf_spname(curbuf) != NULL) STRCPY(NameBuff, buf_spname(curbuf)); else home_replace(NULL, curbuf->b_ffname, NameBuff, MAXPATHL, TRUE); smsg((char_u *)_("Original file \"%s\""), NameBuff); msg_putchar('\n'); /* * check date of swap file and original file */ mtime = char_to_long(b0p->b0_mtime); if (curbuf->b_ffname != NULL && mch_stat((char *)curbuf->b_ffname, &org_stat) != -1 && ((mch_stat((char *)mfp->mf_fname, &swp_stat) != -1 && org_stat.st_mtime > swp_stat.st_mtime) || org_stat.st_mtime != mtime)) { EMSG(_("E308: Warning: Original file may have been changed")); } out_flush(); /* Get the 'fileformat' and 'fileencoding' from block zero. */ b0_ff = (b0p->b0_flags & B0_FF_MASK); if (b0p->b0_flags & B0_HAS_FENC) { for (p = b0p->b0_fname + B0_FNAME_SIZE; p > b0p->b0_fname && p[-1] != NUL; --p) ; b0_fenc = vim_strnsave(p, (int)(b0p->b0_fname + B0_FNAME_SIZE - p)); } mf_put(mfp, hp, FALSE, FALSE); /* release block 0 */ hp = NULL; /* * Now that we are sure that the file is going to be recovered, clear the * contents of the current buffer. */ while (!(curbuf->b_ml.ml_flags & ML_EMPTY)) ml_delete((linenr_T)1, FALSE); /* * Try reading the original file to obtain the values of 'fileformat', * 'fileencoding', etc. Ignore errors. The text itself is not used. */ if (curbuf->b_ffname != NULL) { (void)readfile(curbuf->b_ffname, NULL, (linenr_T)0, (linenr_T)0, (linenr_T)MAXLNUM, NULL, READ_NEW); while (!(curbuf->b_ml.ml_flags & ML_EMPTY)) ml_delete((linenr_T)1, FALSE); } /* Use the 'fileformat' and 'fileencoding' as stored in the swap file. */ if (b0_ff != 0) set_fileformat(b0_ff - 1, OPT_LOCAL); if (b0_fenc != NULL) { set_option_value((char_u *)"fenc", 0L, b0_fenc, OPT_LOCAL); vim_free(b0_fenc); } unchanged(curbuf, TRUE); bnum = 1; /* start with block 1 */ page_count = 1; /* which is 1 page */ lnum = 0; /* append after line 0 in curbuf */ line_count = 0; idx = 0; /* start with first index in block 1 */ error = 0; buf->b_ml.ml_stack_top = 0; buf->b_ml.ml_stack = NULL; buf->b_ml.ml_stack_size = 0; /* no stack yet */ if (curbuf->b_ffname == NULL) cannot_open = TRUE; else cannot_open = FALSE; serious_error = FALSE; for ( ; !got_int; line_breakcheck()) { if (hp != NULL) mf_put(mfp, hp, FALSE, FALSE); /* release previous block */ /* * get block */ if ((hp = mf_get(mfp, (blocknr_T)bnum, page_count)) == NULL) { if (bnum == 1) { EMSG2(_("E309: Unable to read block 1 from %s"), mfp->mf_fname); goto theend; } ++error; ml_append(lnum++, (char_u *)_("???MANY LINES MISSING"), (colnr_T)0, TRUE); } else /* there is a block */ { pp = (PTR_BL *)(hp->bh_data); if (pp->pb_id == PTR_ID) /* it is a pointer block */ { /* check line count when using pointer block first time */ if (idx == 0 && line_count != 0) { for (i = 0; i < (int)pp->pb_count; ++i) line_count -= pp->pb_pointer[i].pe_line_count; if (line_count != 0) { ++error; ml_append(lnum++, (char_u *)_("???LINE COUNT WRONG"), (colnr_T)0, TRUE); } } if (pp->pb_count == 0) { ml_append(lnum++, (char_u *)_("???EMPTY BLOCK"), (colnr_T)0, TRUE); ++error; } else if (idx < (int)pp->pb_count) /* go a block deeper */ { if (pp->pb_pointer[idx].pe_bnum < 0) { /* * Data block with negative block number. * Try to read lines from the original file. * This is slow, but it works. */ if (!cannot_open) { line_count = pp->pb_pointer[idx].pe_line_count; if (readfile(curbuf->b_ffname, NULL, lnum, pp->pb_pointer[idx].pe_old_lnum - 1, line_count, NULL, 0) == FAIL) cannot_open = TRUE; else lnum += line_count; } if (cannot_open) { ++error; ml_append(lnum++, (char_u *)_("???LINES MISSING"), (colnr_T)0, TRUE); } ++idx; /* get same block again for next index */ continue; } /* * going one block deeper in the tree */ if ((top = ml_add_stack(buf)) < 0) /* new entry in stack */ { ++error; break; /* out of memory */ } ip = &(buf->b_ml.ml_stack[top]); ip->ip_bnum = bnum; ip->ip_index = idx; bnum = pp->pb_pointer[idx].pe_bnum; line_count = pp->pb_pointer[idx].pe_line_count; page_count = pp->pb_pointer[idx].pe_page_count; continue; } } else /* not a pointer block */ { dp = (DATA_BL *)(hp->bh_data); if (dp->db_id != DATA_ID) /* block id wrong */ { if (bnum == 1) { EMSG2(_("E310: Block 1 ID wrong (%s not a .swp file?)"), mfp->mf_fname); goto theend; } ++error; ml_append(lnum++, (char_u *)_("???BLOCK MISSING"), (colnr_T)0, TRUE); } else { /* * it is a data block * Append all the lines in this block */ has_error = FALSE; /* * check length of block * if wrong, use length in pointer block */ if (page_count * mfp->mf_page_size != dp->db_txt_end) { ml_append(lnum++, (char_u *)_("??? from here until ???END lines may be messed up"), (colnr_T)0, TRUE); ++error; has_error = TRUE; dp->db_txt_end = page_count * mfp->mf_page_size; } /* make sure there is a NUL at the end of the block */ *((char_u *)dp + dp->db_txt_end - 1) = NUL; /* * check number of lines in block * if wrong, use count in data block */ if (line_count != dp->db_line_count) { ml_append(lnum++, (char_u *)_("??? from here until ???END lines may have been inserted/deleted"), (colnr_T)0, TRUE); ++error; has_error = TRUE; } for (i = 0; i < dp->db_line_count; ++i) { txt_start = (dp->db_index[i] & DB_INDEX_MASK); if (txt_start <= (int)HEADER_SIZE || txt_start >= (int)dp->db_txt_end) { p = (char_u *)"???"; ++error; } else p = (char_u *)dp + txt_start; ml_append(lnum++, p, (colnr_T)0, TRUE); } if (has_error) ml_append(lnum++, (char_u *)_("???END"), (colnr_T)0, TRUE); } } } if (buf->b_ml.ml_stack_top == 0) /* finished */ break; /* * go one block up in the tree */ ip = &(buf->b_ml.ml_stack[--(buf->b_ml.ml_stack_top)]); bnum = ip->ip_bnum; idx = ip->ip_index + 1; /* go to next index */ page_count = 1; } /* * The dummy line from the empty buffer will now be after the last line in * the buffer. Delete it. */ ml_delete(curbuf->b_ml.ml_line_count, FALSE); curbuf->b_flags |= BF_RECOVERED; recoverymode = FALSE; if (got_int) EMSG(_("E311: Recovery Interrupted")); else if (error) { ++no_wait_return; MSG(">>>>>>>>>>>>>"); EMSG(_("E312: Errors detected while recovering; look for lines starting with ???")); --no_wait_return; MSG(_("See \":help E312\" for more information.")); MSG(">>>>>>>>>>>>>"); } else { MSG(_("Recovery completed. You should check if everything is OK.")); MSG_PUTS(_("\n(You might want to write out this file under another name\n")); MSG_PUTS(_("and run diff with the original file to check for changes)\n")); MSG_PUTS(_("Delete the .swp file afterwards.\n\n")); cmdline_row = msg_row; } redraw_curbuf_later(NOT_VALID); theend: recoverymode = FALSE; if (mfp != NULL) { if (hp != NULL) mf_put(mfp, hp, FALSE, FALSE); mf_close(mfp, FALSE); /* will also vim_free(mfp->mf_fname) */ } if (buf != NULL) { vim_free(buf->b_ml.ml_stack); vim_free(buf); } if (serious_error && called_from_main) ml_close(curbuf, TRUE); #ifdef FEAT_AUTOCMD else { apply_autocmds(EVENT_BUFREADPOST, NULL, curbuf->b_fname, FALSE, curbuf); apply_autocmds(EVENT_BUFWINENTER, NULL, curbuf->b_fname, FALSE, curbuf); } #endif return; } /* * Find the names of swap files in current directory and the directory given * with the 'directory' option. * * Used to: * - list the swap files for "vim -r" * - count the number of swap files when recovering * - list the swap files when recovering * - find the name of the n'th swap file when recovering */ int recover_names(fname, list, nr) char_u **fname; /* base for swap file name */ int list; /* when TRUE, list the swap file names */ int nr; /* when non-zero, return nr'th swap file name */ { int num_names; char_u *(names[6]); char_u *tail; char_u *p; int num_files; int file_count = 0; char_u **files; int i; char_u *dirp; char_u *dir_name; char_u *fname_res = NULL; #ifdef HAVE_READLINK char_u fname_buf[MAXPATHL]; #endif if (fname != NULL) { #ifdef HAVE_READLINK /* Expand symlink in the file name, because the swap file is created with * the actual file instead of with the symlink. */ if (resolve_symlink(*fname, fname_buf) == OK) fname_res = fname_buf; else #endif fname_res = *fname; } if (list) { /* use msg() to start the scrolling properly */ msg((char_u *)_("Swap files found:")); msg_putchar('\n'); } /* * Do the loop for every directory in 'directory'. * First allocate some memory to put the directory name in. */ dir_name = alloc((unsigned)STRLEN(p_dir) + 1); dirp = p_dir; while (dir_name != NULL && *dirp) { /* * Isolate a directory name from *dirp and put it in dir_name (we know * it is large enough, so use 31000 for length). * Advance dirp to next directory name. */ (void)copy_option_part(&dirp, dir_name, 31000, ","); if (dir_name[0] == '.' && dir_name[1] == NUL) /* check current dir */ { if (fname == NULL || *fname == NULL) { #ifdef VMS names[0] = vim_strsave((char_u *)"*_sw%"); #else # ifdef RISCOS names[0] = vim_strsave((char_u *)"*_sw#"); # else names[0] = vim_strsave((char_u *)"*.sw?"); # endif #endif #if defined(UNIX) || defined(WIN3264) /* For Unix names starting with a dot are special. MS-Windows * supports this too, on some file systems. */ names[1] = vim_strsave((char_u *)".*.sw?"); names[2] = vim_strsave((char_u *)".sw?"); num_names = 3; #else # ifdef VMS names[1] = vim_strsave((char_u *)".*_sw%"); num_names = 2; # else num_names = 1; # endif #endif } else num_names = recov_file_names(names, fname_res, TRUE); } else /* check directory dir_name */ { if (fname == NULL || *fname == NULL) { #ifdef VMS names[0] = concat_fnames(dir_name, (char_u *)"*_sw%", TRUE); #else # ifdef RISCOS names[0] = concat_fnames(dir_name, (char_u *)"*_sw#", TRUE); # else names[0] = concat_fnames(dir_name, (char_u *)"*.sw?", TRUE); # endif #endif #if defined(UNIX) || defined(WIN3264) /* For Unix names starting with a dot are special. MS-Windows * supports this too, on some file systems. */ names[1] = concat_fnames(dir_name, (char_u *)".*.sw?", TRUE); names[2] = concat_fnames(dir_name, (char_u *)".sw?", TRUE); num_names = 3; #else # ifdef VMS names[1] = concat_fnames(dir_name, (char_u *)".*_sw%", TRUE); num_names = 2; # else num_names = 1; # endif #endif } else { #if defined(UNIX) || defined(WIN3264) p = dir_name + STRLEN(dir_name); if (after_pathsep(dir_name, p) && p[-1] == p[-2]) { /* Ends with '//', Use Full path for swap name */ tail = make_percent_swname(dir_name, fname_res); } else #endif { tail = gettail(fname_res); tail = concat_fnames(dir_name, tail, TRUE); } if (tail == NULL) num_names = 0; else { num_names = recov_file_names(names, tail, FALSE); vim_free(tail); } } } /* check for out-of-memory */ for (i = 0; i < num_names; ++i) { if (names[i] == NULL) { for (i = 0; i < num_names; ++i) vim_free(names[i]); num_names = 0; } } if (num_names == 0) num_files = 0; else if (expand_wildcards(num_names, names, &num_files, &files, EW_KEEPALL|EW_FILE|EW_SILENT) == FAIL) num_files = 0; /* * When no swap file found, wildcard expansion might have failed (e.g. * not able to execute the shell). * Try finding a swap file by simply adding ".swp" to the file name. */ if (*dirp == NUL && file_count + num_files == 0 && fname != NULL && *fname != NULL) { struct stat st; char_u *swapname; swapname = modname(fname_res, #if defined(VMS) || defined(RISCOS) (char_u *)"_swp", FALSE #else (char_u *)".swp", TRUE #endif ); if (swapname != NULL) { if (mch_stat((char *)swapname, &st) != -1) /* It exists! */ { files = (char_u **)alloc((unsigned)sizeof(char_u *)); if (files != NULL) { files[0] = swapname; swapname = NULL; num_files = 1; } } vim_free(swapname); } } /* * remove swapfile name of the current buffer, it must be ignored */ if (curbuf->b_ml.ml_mfp != NULL && (p = curbuf->b_ml.ml_mfp->mf_fname) != NULL) { for (i = 0; i < num_files; ++i) if (fullpathcmp(p, files[i], TRUE) & FPC_SAME) { /* Remove the name from files[i]. Move further entries * down. When the array becomes empty free it here, since * FreeWild() won't be called below. */ vim_free(files[i]); if (--num_files == 0) vim_free(files); else for ( ; i < num_files; ++i) files[i] = files[i + 1]; } } if (nr > 0) { file_count += num_files; if (nr <= file_count) { *fname = vim_strsave(files[nr - 1 + num_files - file_count]); dirp = (char_u *)""; /* stop searching */ } } else if (list) { if (dir_name[0] == '.' && dir_name[1] == NUL) { if (fname == NULL || *fname == NULL) MSG_PUTS(_(" In current directory:\n")); else MSG_PUTS(_(" Using specified name:\n")); } else { MSG_PUTS(_(" In directory ")); msg_home_replace(dir_name); MSG_PUTS(":\n"); } if (num_files) { for (i = 0; i < num_files; ++i) { /* print the swap file name */ msg_outnum((long)++file_count); MSG_PUTS(". "); msg_puts(gettail(files[i])); msg_putchar('\n'); (void)swapfile_info(files[i]); } } else MSG_PUTS(_(" -- none --\n")); out_flush(); } else file_count += num_files; for (i = 0; i < num_names; ++i) vim_free(names[i]); if (num_files > 0) FreeWild(num_files, files); } vim_free(dir_name); return file_count; } #if defined(UNIX) || defined(WIN3264) /* Need _very_ long file names */ /* * Append the full path to name with path separators made into percent * signs, to dir. An unnamed buffer is handled as "" (/"") */ static char_u * make_percent_swname(dir, name) char_u *dir; char_u *name; { char_u *d, *s, *f; f = fix_fname(name != NULL ? name : (char_u *) ""); d = NULL; if (f != NULL) { s = alloc((unsigned)(STRLEN(f) + 1)); if (s != NULL) { STRCPY(s, f); for (d = s; *d != NUL; mb_ptr_adv(d)) if (vim_ispathsep(*d)) *d = '%'; d = concat_fnames(dir, s, TRUE); vim_free(s); } vim_free(f); } return d; } #endif #if (defined(UNIX) || defined(__EMX__) || defined(VMS)) && (defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)) static int process_still_running; #endif /* * Give information about an existing swap file. * Returns timestamp (0 when unknown). */ static time_t swapfile_info(fname) char_u *fname; { struct stat st; int fd; struct block0 b0; time_t x = (time_t)0; char *p; #ifdef UNIX char_u uname[B0_UNAME_SIZE]; #endif /* print the swap file date */ if (mch_stat((char *)fname, &st) != -1) { #ifdef UNIX /* print name of owner of the file */ if (mch_get_uname(st.st_uid, uname, B0_UNAME_SIZE) == OK) { MSG_PUTS(_(" owned by: ")); msg_outtrans(uname); MSG_PUTS(_(" dated: ")); } else #endif MSG_PUTS(_(" dated: ")); x = st.st_mtime; /* Manx C can't do &st.st_mtime */ p = ctime(&x); /* includes '\n' */ if (p == NULL) MSG_PUTS("(invalid)\n"); else MSG_PUTS(p); } /* * print the original file name */ fd = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0); if (fd >= 0) { if (read(fd, (char *)&b0, sizeof(b0)) == sizeof(b0)) { if (STRNCMP(b0.b0_version, "VIM 3.0", 7) == 0) { MSG_PUTS(_(" [from Vim version 3.0]")); } else if (b0.b0_id[0] != BLOCK0_ID0 || b0.b0_id[1] != BLOCK0_ID1) { MSG_PUTS(_(" [does not look like a Vim swap file]")); } else { MSG_PUTS(_(" file name: ")); if (b0.b0_fname[0] == NUL) MSG_PUTS(_("[No Name]")); else msg_outtrans(b0.b0_fname); MSG_PUTS(_("\n modified: ")); MSG_PUTS(b0.b0_dirty ? _("YES") : _("no")); if (*(b0.b0_uname) != NUL) { MSG_PUTS(_("\n user name: ")); msg_outtrans(b0.b0_uname); } if (*(b0.b0_hname) != NUL) { if (*(b0.b0_uname) != NUL) MSG_PUTS(_(" host name: ")); else MSG_PUTS(_("\n host name: ")); msg_outtrans(b0.b0_hname); } if (char_to_long(b0.b0_pid) != 0L) { MSG_PUTS(_("\n process ID: ")); msg_outnum(char_to_long(b0.b0_pid)); #if defined(UNIX) || defined(__EMX__) /* EMX kill() not working correctly, it seems */ if (kill((pid_t)char_to_long(b0.b0_pid), 0) == 0) { MSG_PUTS(_(" (still running)")); # if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG) process_still_running = TRUE; # endif } #endif } if (b0_magic_wrong(&b0)) { #if defined(MSDOS) || defined(MSWIN) if (STRNCMP(b0.b0_hname, "PC ", 3) == 0) MSG_PUTS(_("\n [not usable with this version of Vim]")); else #endif MSG_PUTS(_("\n [not usable on this computer]")); } } } else MSG_PUTS(_(" [cannot be read]")); close(fd); } else MSG_PUTS(_(" [cannot be opened]")); msg_putchar('\n'); return x; } static int recov_file_names(names, path, prepend_dot) char_u **names; char_u *path; int prepend_dot; { int num_names; #ifdef SHORT_FNAME /* * (MS-DOS) always short names */ names[0] = modname(path, (char_u *)".sw?", FALSE); num_names = 1; #else /* !SHORT_FNAME */ /* * (Win32 and Win64) never short names, but do prepend a dot. * (Not MS-DOS or Win32 or Win64) maybe short name, maybe not: Try both. * Only use the short name if it is different. */ char_u *p; int i; # ifndef WIN3264 int shortname = curbuf->b_shortname; curbuf->b_shortname = FALSE; # endif num_names = 0; /* * May also add the file name with a dot prepended, for swap file in same * dir as original file. */ if (prepend_dot) { names[num_names] = modname(path, (char_u *)".sw?", TRUE); if (names[num_names] == NULL) goto end; ++num_names; } /* * Form the normal swap file name pattern by appending ".sw?". */ #ifdef VMS names[num_names] = concat_fnames(path, (char_u *)"_sw%", FALSE); #else # ifdef RISCOS names[num_names] = concat_fnames(path, (char_u *)"_sw#", FALSE); # else names[num_names] = concat_fnames(path, (char_u *)".sw?", FALSE); # endif #endif if (names[num_names] == NULL) goto end; if (num_names >= 1) /* check if we have the same name twice */ { p = names[num_names - 1]; i = (int)STRLEN(names[num_names - 1]) - (int)STRLEN(names[num_names]); if (i > 0) p += i; /* file name has been expanded to full path */ if (STRCMP(p, names[num_names]) != 0) ++num_names; else vim_free(names[num_names]); } else ++num_names; # ifndef WIN3264 /* * Also try with 'shortname' set, in case the file is on a DOS filesystem. */ curbuf->b_shortname = TRUE; #ifdef VMS names[num_names] = modname(path, (char_u *)"_sw%", FALSE); #else # ifdef RISCOS names[num_names] = modname(path, (char_u *)"_sw#", FALSE); # else names[num_names] = modname(path, (char_u *)".sw?", FALSE); # endif #endif if (names[num_names] == NULL) goto end; /* * Remove the one from 'shortname', if it's the same as with 'noshortname'. */ p = names[num_names]; i = STRLEN(names[num_names]) - STRLEN(names[num_names - 1]); if (i > 0) p += i; /* file name has been expanded to full path */ if (STRCMP(names[num_names - 1], p) == 0) vim_free(names[num_names]); else ++num_names; # endif end: # ifndef WIN3264 curbuf->b_shortname = shortname; # endif #endif /* !SHORT_FNAME */ return num_names; } /* * sync all memlines * * If 'check_file' is TRUE, check if original file exists and was not changed. * If 'check_char' is TRUE, stop syncing when character becomes available, but * always sync at least one block. */ void ml_sync_all(check_file, check_char) int check_file; int check_char; { buf_T *buf; struct stat st; for (buf = firstbuf; buf != NULL; buf = buf->b_next) { if (buf->b_ml.ml_mfp == NULL || buf->b_ml.ml_mfp->mf_fname == NULL) continue; /* no file */ ml_flush_line(buf); /* flush buffered line */ /* flush locked block */ (void)ml_find_line(buf, (linenr_T)0, ML_FLUSH); if (bufIsChanged(buf) && check_file && mf_need_trans(buf->b_ml.ml_mfp) && buf->b_ffname != NULL) { /* * If the original file does not exist anymore or has been changed * call ml_preserve() to get rid of all negative numbered blocks. */ if (mch_stat((char *)buf->b_ffname, &st) == -1 || st.st_mtime != buf->b_mtime_read || (size_t)st.st_size != buf->b_orig_size) { ml_preserve(buf, FALSE); did_check_timestamps = FALSE; need_check_timestamps = TRUE; /* give message later */ } } if (buf->b_ml.ml_mfp->mf_dirty) { (void)mf_sync(buf->b_ml.ml_mfp, (check_char ? MFS_STOP : 0) | (bufIsChanged(buf) ? MFS_FLUSH : 0)); if (check_char && ui_char_avail()) /* character available now */ break; } } } /* * sync one buffer, including negative blocks * * after this all the blocks are in the swap file * * Used for the :preserve command and when the original file has been * changed or deleted. * * when message is TRUE the success of preserving is reported */ void ml_preserve(buf, message) buf_T *buf; int message; { bhdr_T *hp; linenr_T lnum; memfile_T *mfp = buf->b_ml.ml_mfp; int status; int got_int_save = got_int; if (mfp == NULL || mfp->mf_fname == NULL) { if (message) EMSG(_("E313: Cannot preserve, there is no swap file")); return; } /* We only want to stop when interrupted here, not when interrupted * before. */ got_int = FALSE; ml_flush_line(buf); /* flush buffered line */ (void)ml_find_line(buf, (linenr_T)0, ML_FLUSH); /* flush locked block */ status = mf_sync(mfp, MFS_ALL | MFS_FLUSH); /* stack is invalid after mf_sync(.., MFS_ALL) */ buf->b_ml.ml_stack_top = 0; /* * Some of the data blocks may have been changed from negative to * positive block number. In that case the pointer blocks need to be * updated. * * We don't know in which pointer block the references are, so we visit * all data blocks until there are no more translations to be done (or * we hit the end of the file, which can only happen in case a write fails, * e.g. when file system if full). * ml_find_line() does the work by translating the negative block numbers * when getting the first line of each data block. */ if (mf_need_trans(mfp) && !got_int) { lnum = 1; while (mf_need_trans(mfp) && lnum <= buf->b_ml.ml_line_count) { hp = ml_find_line(buf, lnum, ML_FIND); if (hp == NULL) { status = FAIL; goto theend; } CHECK(buf->b_ml.ml_locked_low != lnum, "low != lnum"); lnum = buf->b_ml.ml_locked_high + 1; } (void)ml_find_line(buf, (linenr_T)0, ML_FLUSH); /* flush locked block */ /* sync the updated pointer blocks */ if (mf_sync(mfp, MFS_ALL | MFS_FLUSH) == FAIL) status = FAIL; buf->b_ml.ml_stack_top = 0; /* stack is invalid now */ } theend: got_int |= got_int_save; if (message) { if (status == OK) MSG(_("File preserved")); else EMSG(_("E314: Preserve failed")); } } /* * NOTE: The pointer returned by the ml_get_*() functions only remains valid * until the next call! * line1 = ml_get(1); * line2 = ml_get(2); // line1 is now invalid! * Make a copy of the line if necessary. */ /* * get a pointer to a (read-only copy of a) line * * On failure an error message is given and IObuff is returned (to avoid * having to check for error everywhere). */ char_u * ml_get(lnum) linenr_T lnum; { return ml_get_buf(curbuf, lnum, FALSE); } /* * ml_get_pos: get pointer to position 'pos' */ char_u * ml_get_pos(pos) pos_T *pos; { return (ml_get_buf(curbuf, pos->lnum, FALSE) + pos->col); } /* * ml_get_curline: get pointer to cursor line. */ char_u * ml_get_curline() { return ml_get_buf(curbuf, curwin->w_cursor.lnum, FALSE); } /* * ml_get_cursor: get pointer to cursor position */ char_u * ml_get_cursor() { return (ml_get_buf(curbuf, curwin->w_cursor.lnum, FALSE) + curwin->w_cursor.col); } /* * get a pointer to a line in a specific buffer * * "will_change": if TRUE mark the buffer dirty (chars in the line will be * changed) */ char_u * ml_get_buf(buf, lnum, will_change) buf_T *buf; linenr_T lnum; int will_change; /* line will be changed */ { bhdr_T *hp; DATA_BL *dp; char_u *ptr; static int recursive = 0; if (lnum > buf->b_ml.ml_line_count) /* invalid line number */ { if (recursive == 0) { /* Avoid giving this message for a recursive call, may happen when * the GUI redraws part of the text. */ ++recursive; EMSGN(_("E315: ml_get: invalid lnum: %ld"), lnum); --recursive; } errorret: STRCPY(IObuff, "???"); return IObuff; } if (lnum <= 0) /* pretend line 0 is line 1 */ lnum = 1; if (buf->b_ml.ml_mfp == NULL) /* there are no lines */ return (char_u *)""; /* * See if it is the same line as requested last time. * Otherwise may need to flush last used line. * Don't use the last used line when 'swapfile' is reset, need to load all * blocks. */ if (buf->b_ml.ml_line_lnum != lnum || mf_dont_release) { ml_flush_line(buf); /* * Find the data block containing the line. * This also fills the stack with the blocks from the root to the data * block and releases any locked block. */ if ((hp = ml_find_line(buf, lnum, ML_FIND)) == NULL) { if (recursive == 0) { /* Avoid giving this message for a recursive call, may happen * when the GUI redraws part of the text. */ ++recursive; EMSGN(_("E316: ml_get: cannot find line %ld"), lnum); --recursive; } goto errorret; } dp = (DATA_BL *)(hp->bh_data); ptr = (char_u *)dp + ((dp->db_index[lnum - buf->b_ml.ml_locked_low]) & DB_INDEX_MASK); buf->b_ml.ml_line_ptr = ptr; buf->b_ml.ml_line_lnum = lnum; buf->b_ml.ml_flags &= ~ML_LINE_DIRTY; } if (will_change) buf->b_ml.ml_flags |= (ML_LOCKED_DIRTY | ML_LOCKED_POS); return buf->b_ml.ml_line_ptr; } /* * Check if a line that was just obtained by a call to ml_get * is in allocated memory. */ int ml_line_alloced() { return (curbuf->b_ml.ml_flags & ML_LINE_DIRTY); } /* * Append a line after lnum (may be 0 to insert a line in front of the file). * "line" does not need to be allocated, but can't be another line in a * buffer, unlocking may make it invalid. * * newfile: TRUE when starting to edit a new file, meaning that pe_old_lnum * will be set for recovery * Check: The caller of this function should probably also call * appended_lines(). * * return FAIL for failure, OK otherwise */ int ml_append(lnum, line, len, newfile) linenr_T lnum; /* append after this line (can be 0) */ char_u *line; /* text of the new line */ colnr_T len; /* length of new line, including NUL, or 0 */ int newfile; /* flag, see above */ { /* When starting up, we might still need to create the memfile */ if (curbuf->b_ml.ml_mfp == NULL && open_buffer(FALSE, NULL) == FAIL) return FAIL; if (curbuf->b_ml.ml_line_lnum != 0) ml_flush_line(curbuf); return ml_append_int(curbuf, lnum, line, len, newfile, FALSE); } #if defined(FEAT_SPELL) || defined(PROTO) /* * Like ml_append() but for an arbitrary buffer. The buffer must already have * a memline. */ int ml_append_buf(buf, lnum, line, len, newfile) buf_T *buf; linenr_T lnum; /* append after this line (can be 0) */ char_u *line; /* text of the new line */ colnr_T len; /* length of new line, including NUL, or 0 */ int newfile; /* flag, see above */ { if (buf->b_ml.ml_mfp == NULL) return FAIL; if (buf->b_ml.ml_line_lnum != 0) ml_flush_line(buf); return ml_append_int(buf, lnum, line, len, newfile, FALSE); } #endif static int ml_append_int(buf, lnum, line, len, newfile, mark) buf_T *buf; linenr_T lnum; /* append after this line (can be 0) */ char_u *line; /* text of the new line */ colnr_T len; /* length of line, including NUL, or 0 */ int newfile; /* flag, see above */ int mark; /* mark the new line */ { int i; int line_count; /* number of indexes in current block */ int offset; int from, to; int space_needed; /* space needed for new line */ int page_size; int page_count; int db_idx; /* index for lnum in data block */ bhdr_T *hp; memfile_T *mfp; DATA_BL *dp; PTR_BL *pp; infoptr_T *ip; /* lnum out of range */ if (lnum > buf->b_ml.ml_line_count || buf->b_ml.ml_mfp == NULL) return FAIL; if (lowest_marked && lowest_marked > lnum) lowest_marked = lnum + 1; if (len == 0) len = (colnr_T)STRLEN(line) + 1; /* space needed for the text */ space_needed = len + INDEX_SIZE; /* space needed for text + index */ mfp = buf->b_ml.ml_mfp; page_size = mfp->mf_page_size; /* * find the data block containing the previous line * This also fills the stack with the blocks from the root to the data block * This also releases any locked block. */ if ((hp = ml_find_line(buf, lnum == 0 ? (linenr_T)1 : lnum, ML_INSERT)) == NULL) return FAIL; buf->b_ml.ml_flags &= ~ML_EMPTY; if (lnum == 0) /* got line one instead, correct db_idx */ db_idx = -1; /* careful, it is negative! */ else db_idx = lnum - buf->b_ml.ml_locked_low; /* get line count before the insertion */ line_count = buf->b_ml.ml_locked_high - buf->b_ml.ml_locked_low; dp = (DATA_BL *)(hp->bh_data); /* * If * - there is not enough room in the current block * - appending to the last line in the block * - not appending to the last line in the file * insert in front of the next block. */ if ((int)dp->db_free < space_needed && db_idx == line_count - 1 && lnum < buf->b_ml.ml_line_count) { /* * Now that the line is not going to be inserted in the block that we * expected, the line count has to be adjusted in the pointer blocks * by using ml_locked_lineadd. */ --(buf->b_ml.ml_locked_lineadd); --(buf->b_ml.ml_locked_high); if ((hp = ml_find_line(buf, lnum + 1, ML_INSERT)) == NULL) return FAIL; db_idx = -1; /* careful, it is negative! */ /* get line count before the insertion */ line_count = buf->b_ml.ml_locked_high - buf->b_ml.ml_locked_low; CHECK(buf->b_ml.ml_locked_low != lnum + 1, "locked_low != lnum + 1"); dp = (DATA_BL *)(hp->bh_data); } ++buf->b_ml.ml_line_count; if ((int)dp->db_free >= space_needed) /* enough room in data block */ { /* * Insert new line in existing data block, or in data block allocated above. */ dp->db_txt_start -= len; dp->db_free -= space_needed; ++(dp->db_line_count); /* * move the text of the lines that follow to the front * adjust the indexes of the lines that follow */ if (line_count > db_idx + 1) /* if there are following lines */ { /* * Offset is the start of the previous line. * This will become the character just after the new line. */ if (db_idx < 0) offset = dp->db_txt_end; else offset = ((dp->db_index[db_idx]) & DB_INDEX_MASK); mch_memmove((char *)dp + dp->db_txt_start, (char *)dp + dp->db_txt_start + len, (size_t)(offset - (dp->db_txt_start + len))); for (i = line_count - 1; i > db_idx; --i) dp->db_index[i + 1] = dp->db_index[i] - len; dp->db_index[db_idx + 1] = offset - len; } else /* add line at the end */ dp->db_index[db_idx + 1] = dp->db_txt_start; /* * copy the text into the block */ mch_memmove((char *)dp + dp->db_index[db_idx + 1], line, (size_t)len); if (mark) dp->db_index[db_idx + 1] |= DB_MARKED; /* * Mark the block dirty. */ buf->b_ml.ml_flags |= ML_LOCKED_DIRTY; if (!newfile) buf->b_ml.ml_flags |= ML_LOCKED_POS; } else /* not enough space in data block */ { /* * If there is not enough room we have to create a new data block and copy some * lines into it. * Then we have to insert an entry in the pointer block. * If this pointer block also is full, we go up another block, and so on, up * to the root if necessary. * The line counts in the pointer blocks have already been adjusted by * ml_find_line(). */ long line_count_left, line_count_right; int page_count_left, page_count_right; bhdr_T *hp_left; bhdr_T *hp_right; bhdr_T *hp_new; int lines_moved; int data_moved = 0; /* init to shut up gcc */ int total_moved = 0; /* init to shut up gcc */ DATA_BL *dp_right, *dp_left; int stack_idx; int in_left; int lineadd; blocknr_T bnum_left, bnum_right; linenr_T lnum_left, lnum_right; int pb_idx; PTR_BL *pp_new; /* * We are going to allocate a new data block. Depending on the * situation it will be put to the left or right of the existing * block. If possible we put the new line in the left block and move * the lines after it to the right block. Otherwise the new line is * also put in the right block. This method is more efficient when * inserting a lot of lines at one place. */ if (db_idx < 0) /* left block is new, right block is existing */ { lines_moved = 0; in_left = TRUE; /* space_needed does not change */ } else /* left block is existing, right block is new */ { lines_moved = line_count - db_idx - 1; if (lines_moved == 0) in_left = FALSE; /* put new line in right block */ /* space_needed does not change */ else { data_moved = ((dp->db_index[db_idx]) & DB_INDEX_MASK) - dp->db_txt_start; total_moved = data_moved + lines_moved * INDEX_SIZE; if ((int)dp->db_free + total_moved >= space_needed) { in_left = TRUE; /* put new line in left block */ space_needed = total_moved; } else { in_left = FALSE; /* put new line in right block */ space_needed += total_moved; } } } page_count = ((space_needed + HEADER_SIZE) + page_size - 1) / page_size; if ((hp_new = ml_new_data(mfp, newfile, page_count)) == NULL) { /* correct line counts in pointer blocks */ --(buf->b_ml.ml_locked_lineadd); --(buf->b_ml.ml_locked_high); return FAIL; } if (db_idx < 0) /* left block is new */ { hp_left = hp_new; hp_right = hp; line_count_left = 0; line_count_right = line_count; } else /* right block is new */ { hp_left = hp; hp_right = hp_new; line_count_left = line_count; line_count_right = 0; } dp_right = (DATA_BL *)(hp_right->bh_data); dp_left = (DATA_BL *)(hp_left->bh_data); bnum_left = hp_left->bh_bnum; bnum_right = hp_right->bh_bnum; page_count_left = hp_left->bh_page_count; page_count_right = hp_right->bh_page_count; /* * May move the new line into the right/new block. */ if (!in_left) { dp_right->db_txt_start -= len; dp_right->db_free -= len + INDEX_SIZE; dp_right->db_index[0] = dp_right->db_txt_start; if (mark) dp_right->db_index[0] |= DB_MARKED; mch_memmove((char *)dp_right + dp_right->db_txt_start, line, (size_t)len); ++line_count_right; } /* * may move lines from the left/old block to the right/new one. */ if (lines_moved) { /* */ dp_right->db_txt_start -= data_moved; dp_right->db_free -= total_moved; mch_memmove((char *)dp_right + dp_right->db_txt_start, (char *)dp_left + dp_left->db_txt_start, (size_t)data_moved); offset = dp_right->db_txt_start - dp_left->db_txt_start; dp_left->db_txt_start += data_moved; dp_left->db_free += total_moved; /* * update indexes in the new block */ for (to = line_count_right, from = db_idx + 1; from < line_count_left; ++from, ++to) dp_right->db_index[to] = dp->db_index[from] + offset; line_count_right += lines_moved; line_count_left -= lines_moved; } /* * May move the new line into the left (old or new) block. */ if (in_left) { dp_left->db_txt_start -= len; dp_left->db_free -= len + INDEX_SIZE; dp_left->db_index[line_count_left] = dp_left->db_txt_start; if (mark) dp_left->db_index[line_count_left] |= DB_MARKED; mch_memmove((char *)dp_left + dp_left->db_txt_start, line, (size_t)len); ++line_count_left; } if (db_idx < 0) /* left block is new */ { lnum_left = lnum + 1; lnum_right = 0; } else /* right block is new */ { lnum_left = 0; if (in_left) lnum_right = lnum + 2; else lnum_right = lnum + 1; } dp_left->db_line_count = line_count_left; dp_right->db_line_count = line_count_right; /* * release the two data blocks * The new one (hp_new) already has a correct blocknumber. * The old one (hp, in ml_locked) gets a positive blocknumber if * we changed it and we are not editing a new file. */ if (lines_moved || in_left) buf->b_ml.ml_flags |= ML_LOCKED_DIRTY; if (!newfile && db_idx >= 0 && in_left) buf->b_ml.ml_flags |= ML_LOCKED_POS; mf_put(mfp, hp_new, TRUE, FALSE); /* * flush the old data block * set ml_locked_lineadd to 0, because the updating of the * pointer blocks is done below */ lineadd = buf->b_ml.ml_locked_lineadd; buf->b_ml.ml_locked_lineadd = 0; ml_find_line(buf, (linenr_T)0, ML_FLUSH); /* flush data block */ /* * update pointer blocks for the new data block */ for (stack_idx = buf->b_ml.ml_stack_top - 1; stack_idx >= 0; --stack_idx) { ip = &(buf->b_ml.ml_stack[stack_idx]); pb_idx = ip->ip_index; if ((hp = mf_get(mfp, ip->ip_bnum, 1)) == NULL) return FAIL; pp = (PTR_BL *)(hp->bh_data); /* must be pointer block */ if (pp->pb_id != PTR_ID) { EMSG(_("E317: pointer block id wrong 3")); mf_put(mfp, hp, FALSE, FALSE); return FAIL; } /* * TODO: If the pointer block is full and we are adding at the end * try to insert in front of the next block */ /* block not full, add one entry */ if (pp->pb_count < pp->pb_count_max) { if (pb_idx + 1 < (int)pp->pb_count) mch_memmove(&pp->pb_pointer[pb_idx + 2], &pp->pb_pointer[pb_idx + 1], (size_t)(pp->pb_count - pb_idx - 1) * sizeof(PTR_EN)); ++pp->pb_count; pp->pb_pointer[pb_idx].pe_line_count = line_count_left; pp->pb_pointer[pb_idx].pe_bnum = bnum_left; pp->pb_pointer[pb_idx].pe_page_count = page_count_left; pp->pb_pointer[pb_idx + 1].pe_line_count = line_count_right; pp->pb_pointer[pb_idx + 1].pe_bnum = bnum_right; pp->pb_pointer[pb_idx + 1].pe_page_count = page_count_right; if (lnum_left != 0) pp->pb_pointer[pb_idx].pe_old_lnum = lnum_left; if (lnum_right != 0) pp->pb_pointer[pb_idx + 1].pe_old_lnum = lnum_right; mf_put(mfp, hp, TRUE, FALSE); buf->b_ml.ml_stack_top = stack_idx + 1; /* truncate stack */ if (lineadd) { --(buf->b_ml.ml_stack_top); /* fix line count for rest of blocks in the stack */ ml_lineadd(buf, lineadd); /* fix stack itself */ buf->b_ml.ml_stack[buf->b_ml.ml_stack_top].ip_high += lineadd; ++(buf->b_ml.ml_stack_top); } /* * We are finished, break the loop here. */ break; } else /* pointer block full */ { /* * split the pointer block * allocate a new pointer block * move some of the pointer into the new block * prepare for updating the parent block */ for (;;) /* do this twice when splitting block 1 */ { hp_new = ml_new_ptr(mfp); if (hp_new == NULL) /* TODO: try to fix tree */ return FAIL; pp_new = (PTR_BL *)(hp_new->bh_data); if (hp->bh_bnum != 1) break; /* * if block 1 becomes full the tree is given an extra level * The pointers from block 1 are moved into the new block. * block 1 is updated to point to the new block * then continue to split the new block */ mch_memmove(pp_new, pp, (size_t)page_size); pp->pb_count = 1; pp->pb_pointer[0].pe_bnum = hp_new->bh_bnum; pp->pb_pointer[0].pe_line_count = buf->b_ml.ml_line_count; pp->pb_pointer[0].pe_old_lnum = 1; pp->pb_pointer[0].pe_page_count = 1; mf_put(mfp, hp, TRUE, FALSE); /* release block 1 */ hp = hp_new; /* new block is to be split */ pp = pp_new; CHECK(stack_idx != 0, _("stack_idx should be 0")); ip->ip_index = 0; ++stack_idx; /* do block 1 again later */ } /* * move the pointers after the current one to the new block * If there are none, the new entry will be in the new block. */ total_moved = pp->pb_count - pb_idx - 1; if (total_moved) { mch_memmove(&pp_new->pb_pointer[0], &pp->pb_pointer[pb_idx + 1], (size_t)(total_moved) * sizeof(PTR_EN)); pp_new->pb_count = total_moved; pp->pb_count -= total_moved - 1; pp->pb_pointer[pb_idx + 1].pe_bnum = bnum_right; pp->pb_pointer[pb_idx + 1].pe_line_count = line_count_right; pp->pb_pointer[pb_idx + 1].pe_page_count = page_count_right; if (lnum_right) pp->pb_pointer[pb_idx + 1].pe_old_lnum = lnum_right; } else { pp_new->pb_count = 1; pp_new->pb_pointer[0].pe_bnum = bnum_right; pp_new->pb_pointer[0].pe_line_count = line_count_right; pp_new->pb_pointer[0].pe_page_count = page_count_right; pp_new->pb_pointer[0].pe_old_lnum = lnum_right; } pp->pb_pointer[pb_idx].pe_bnum = bnum_left; pp->pb_pointer[pb_idx].pe_line_count = line_count_left; pp->pb_pointer[pb_idx].pe_page_count = page_count_left; if (lnum_left) pp->pb_pointer[pb_idx].pe_old_lnum = lnum_left; lnum_left = 0; lnum_right = 0; /* * recompute line counts */ line_count_right = 0; for (i = 0; i < (int)pp_new->pb_count; ++i) line_count_right += pp_new->pb_pointer[i].pe_line_count; line_count_left = 0; for (i = 0; i < (int)pp->pb_count; ++i) line_count_left += pp->pb_pointer[i].pe_line_count; bnum_left = hp->bh_bnum; bnum_right = hp_new->bh_bnum; page_count_left = 1; page_count_right = 1; mf_put(mfp, hp, TRUE, FALSE); mf_put(mfp, hp_new, TRUE, FALSE); } } /* * Safety check: fallen out of for loop? */ if (stack_idx < 0) { EMSG(_("E318: Updated too many blocks?")); buf->b_ml.ml_stack_top = 0; /* invalidate stack */ } } #ifdef FEAT_BYTEOFF /* The line was inserted below 'lnum' */ ml_updatechunk(buf, lnum + 1, (long)len, ML_CHNK_ADDLINE); #endif #ifdef FEAT_NETBEANS_INTG if (usingNetbeans) { if (STRLEN(line) > 0) netbeans_inserted(buf, lnum+1, (colnr_T)0, line, (int)STRLEN(line)); netbeans_inserted(buf, lnum+1, (colnr_T)STRLEN(line), (char_u *)"\n", 1); } #endif return OK; } /* * Replace line lnum, with buffering, in current buffer. * * If "copy" is TRUE, make a copy of the line, otherwise the line has been * copied to allocated memory already. * * Check: The caller of this function should probably also call * changed_lines(), unless update_screen(NOT_VALID) is used. * * return FAIL for failure, OK otherwise */ int ml_replace(lnum, line, copy) linenr_T lnum; char_u *line; int copy; { if (line == NULL) /* just checking... */ return FAIL; /* When starting up, we might still need to create the memfile */ if (curbuf->b_ml.ml_mfp == NULL && open_buffer(FALSE, NULL) == FAIL) return FAIL; if (copy && (line = vim_strsave(line)) == NULL) /* allocate memory */ return FAIL; #ifdef FEAT_NETBEANS_INTG if (usingNetbeans) { netbeans_removed(curbuf, lnum, 0, (long)STRLEN(ml_get(lnum))); netbeans_inserted(curbuf, lnum, 0, line, (int)STRLEN(line)); } #endif if (curbuf->b_ml.ml_line_lnum != lnum) /* other line buffered */ ml_flush_line(curbuf); /* flush it */ else if (curbuf->b_ml.ml_flags & ML_LINE_DIRTY) /* same line allocated */ vim_free(curbuf->b_ml.ml_line_ptr); /* free it */ curbuf->b_ml.ml_line_ptr = line; curbuf->b_ml.ml_line_lnum = lnum; curbuf->b_ml.ml_flags = (curbuf->b_ml.ml_flags | ML_LINE_DIRTY) & ~ML_EMPTY; return OK; } /* * Delete line 'lnum' in the current buffer. * * Check: The caller of this function should probably also call * deleted_lines() after this. * * return FAIL for failure, OK otherwise */ int ml_delete(lnum, message) linenr_T lnum; int message; { ml_flush_line(curbuf); return ml_delete_int(curbuf, lnum, message); } static int ml_delete_int(buf, lnum, message) buf_T *buf; linenr_T lnum; int message; { bhdr_T *hp; memfile_T *mfp; DATA_BL *dp; PTR_BL *pp; infoptr_T *ip; int count; /* number of entries in block */ int idx; int stack_idx; int text_start; int line_start; long line_size; int i; if (lnum < 1 || lnum > buf->b_ml.ml_line_count) return FAIL; if (lowest_marked && lowest_marked > lnum) lowest_marked--; /* * If the file becomes empty the last line is replaced by an empty line. */ if (buf->b_ml.ml_line_count == 1) /* file becomes empty */ { if (message #ifdef FEAT_NETBEANS_INTG && !netbeansSuppressNoLines #endif ) set_keep_msg((char_u *)_(no_lines_msg), 0); /* FEAT_BYTEOFF already handled in there, dont worry 'bout it below */ i = ml_replace((linenr_T)1, (char_u *)"", TRUE); buf->b_ml.ml_flags |= ML_EMPTY; return i; } /* * find the data block containing the line * This also fills the stack with the blocks from the root to the data block * This also releases any locked block. */ mfp = buf->b_ml.ml_mfp; if (mfp == NULL) return FAIL; if ((hp = ml_find_line(buf, lnum, ML_DELETE)) == NULL) return FAIL; dp = (DATA_BL *)(hp->bh_data); /* compute line count before the delete */ count = (long)(buf->b_ml.ml_locked_high) - (long)(buf->b_ml.ml_locked_low) + 2; idx = lnum - buf->b_ml.ml_locked_low; --buf->b_ml.ml_line_count; line_start = ((dp->db_index[idx]) & DB_INDEX_MASK); if (idx == 0) /* first line in block, text at the end */ line_size = dp->db_txt_end - line_start; else line_size = ((dp->db_index[idx - 1]) & DB_INDEX_MASK) - line_start; #ifdef FEAT_NETBEANS_INTG if (usingNetbeans) netbeans_removed(buf, lnum, 0, (long)line_size); #endif /* * special case: If there is only one line in the data block it becomes empty. * Then we have to remove the entry, pointing to this data block, from the * pointer block. If this pointer block also becomes empty, we go up another * block, and so on, up to the root if necessary. * The line counts in the pointer blocks have already been adjusted by * ml_find_line(). */ if (count == 1) { mf_free(mfp, hp); /* free the data block */ buf->b_ml.ml_locked = NULL; for (stack_idx = buf->b_ml.ml_stack_top - 1; stack_idx >= 0; --stack_idx) { buf->b_ml.ml_stack_top = 0; /* stack is invalid when failing */ ip = &(buf->b_ml.ml_stack[stack_idx]); idx = ip->ip_index; if ((hp = mf_get(mfp, ip->ip_bnum, 1)) == NULL) return FAIL; pp = (PTR_BL *)(hp->bh_data); /* must be pointer block */ if (pp->pb_id != PTR_ID) { EMSG(_("E317: pointer block id wrong 4")); mf_put(mfp, hp, FALSE, FALSE); return FAIL; } count = --(pp->pb_count); if (count == 0) /* the pointer block becomes empty! */ mf_free(mfp, hp); else { if (count != idx) /* move entries after the deleted one */ mch_memmove(&pp->pb_pointer[idx], &pp->pb_pointer[idx + 1], (size_t)(count - idx) * sizeof(PTR_EN)); mf_put(mfp, hp, TRUE, FALSE); buf->b_ml.ml_stack_top = stack_idx; /* truncate stack */ /* fix line count for rest of blocks in the stack */ if (buf->b_ml.ml_locked_lineadd != 0) { ml_lineadd(buf, buf->b_ml.ml_locked_lineadd); buf->b_ml.ml_stack[buf->b_ml.ml_stack_top].ip_high += buf->b_ml.ml_locked_lineadd; } ++(buf->b_ml.ml_stack_top); break; } } CHECK(stack_idx < 0, _("deleted block 1?")); } else { /* * delete the text by moving the next lines forwards */ text_start = dp->db_txt_start; mch_memmove((char *)dp + text_start + line_size, (char *)dp + text_start, (size_t)(line_start - text_start)); /* * delete the index by moving the next indexes backwards * Adjust the indexes for the text movement. */ for (i = idx; i < count - 1; ++i) dp->db_index[i] = dp->db_index[i + 1] + line_size; dp->db_free += line_size + INDEX_SIZE; dp->db_txt_start += line_size; --(dp->db_line_count); /* * mark the block dirty and make sure it is in the file (for recovery) */ buf->b_ml.ml_flags |= (ML_LOCKED_DIRTY | ML_LOCKED_POS); } #ifdef FEAT_BYTEOFF ml_updatechunk(buf, lnum, line_size, ML_CHNK_DELLINE); #endif return OK; } /* * set the B_MARKED flag for line 'lnum' */ void ml_setmarked(lnum) linenr_T lnum; { bhdr_T *hp; DATA_BL *dp; /* invalid line number */ if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count || curbuf->b_ml.ml_mfp == NULL) return; /* give error message? */ if (lowest_marked == 0 || lowest_marked > lnum) lowest_marked = lnum; /* * find the data block containing the line * This also fills the stack with the blocks from the root to the data block * This also releases any locked block. */ if ((hp = ml_find_line(curbuf, lnum, ML_FIND)) == NULL) return; /* give error message? */ dp = (DATA_BL *)(hp->bh_data); dp->db_index[lnum - curbuf->b_ml.ml_locked_low] |= DB_MARKED; curbuf->b_ml.ml_flags |= ML_LOCKED_DIRTY; } /* * find the first line with its B_MARKED flag set */ linenr_T ml_firstmarked() { bhdr_T *hp; DATA_BL *dp; linenr_T lnum; int i; if (curbuf->b_ml.ml_mfp == NULL) return (linenr_T) 0; /* * The search starts with lowest_marked line. This is the last line where * a mark was found, adjusted by inserting/deleting lines. */ for (lnum = lowest_marked; lnum <= curbuf->b_ml.ml_line_count; ) { /* * Find the data block containing the line. * This also fills the stack with the blocks from the root to the data * block This also releases any locked block. */ if ((hp = ml_find_line(curbuf, lnum, ML_FIND)) == NULL) return (linenr_T)0; /* give error message? */ dp = (DATA_BL *)(hp->bh_data); for (i = lnum - curbuf->b_ml.ml_locked_low; lnum <= curbuf->b_ml.ml_locked_high; ++i, ++lnum) if ((dp->db_index[i]) & DB_MARKED) { (dp->db_index[i]) &= DB_INDEX_MASK; curbuf->b_ml.ml_flags |= ML_LOCKED_DIRTY; lowest_marked = lnum + 1; return lnum; } } return (linenr_T) 0; } #if 0 /* not used */ /* * return TRUE if line 'lnum' has a mark */ int ml_has_mark(lnum) linenr_T lnum; { bhdr_T *hp; DATA_BL *dp; if (curbuf->b_ml.ml_mfp == NULL || (hp = ml_find_line(curbuf, lnum, ML_FIND)) == NULL) return FALSE; dp = (DATA_BL *)(hp->bh_data); return (int)((dp->db_index[lnum - curbuf->b_ml.ml_locked_low]) & DB_MARKED); } #endif /* * clear all DB_MARKED flags */ void ml_clearmarked() { bhdr_T *hp; DATA_BL *dp; linenr_T lnum; int i; if (curbuf->b_ml.ml_mfp == NULL) /* nothing to do */ return; /* * The search starts with line lowest_marked. */ for (lnum = lowest_marked; lnum <= curbuf->b_ml.ml_line_count; ) { /* * Find the data block containing the line. * This also fills the stack with the blocks from the root to the data * block and releases any locked block. */ if ((hp = ml_find_line(curbuf, lnum, ML_FIND)) == NULL) return; /* give error message? */ dp = (DATA_BL *)(hp->bh_data); for (i = lnum - curbuf->b_ml.ml_locked_low; lnum <= curbuf->b_ml.ml_locked_high; ++i, ++lnum) if ((dp->db_index[i]) & DB_MARKED) { (dp->db_index[i]) &= DB_INDEX_MASK; curbuf->b_ml.ml_flags |= ML_LOCKED_DIRTY; } } lowest_marked = 0; return; } /* * flush ml_line if necessary */ static void ml_flush_line(buf) buf_T *buf; { bhdr_T *hp; DATA_BL *dp; linenr_T lnum; char_u *new_line; char_u *old_line; colnr_T new_len; int old_len; int extra; int idx; int start; int count; int i; static int entered = FALSE; if (buf->b_ml.ml_line_lnum == 0 || buf->b_ml.ml_mfp == NULL) return; /* nothing to do */ if (buf->b_ml.ml_flags & ML_LINE_DIRTY) { /* This code doesn't work recursively, but Netbeans may call back here * when obtaining the cursor position. */ if (entered) return; entered = TRUE; lnum = buf->b_ml.ml_line_lnum; new_line = buf->b_ml.ml_line_ptr; hp = ml_find_line(buf, lnum, ML_FIND); if (hp == NULL) EMSGN(_("E320: Cannot find line %ld"), lnum); else { dp = (DATA_BL *)(hp->bh_data); idx = lnum - buf->b_ml.ml_locked_low; start = ((dp->db_index[idx]) & DB_INDEX_MASK); old_line = (char_u *)dp + start; if (idx == 0) /* line is last in block */ old_len = dp->db_txt_end - start; else /* text of previous line follows */ old_len = (dp->db_index[idx - 1] & DB_INDEX_MASK) - start; new_len = (colnr_T)STRLEN(new_line) + 1; extra = new_len - old_len; /* negative if lines gets smaller */ /* * if new line fits in data block, replace directly */ if ((int)dp->db_free >= extra) { /* if the length changes and there are following lines */ count = buf->b_ml.ml_locked_high - buf->b_ml.ml_locked_low + 1; if (extra != 0 && idx < count - 1) { /* move text of following lines */ mch_memmove((char *)dp + dp->db_txt_start - extra, (char *)dp + dp->db_txt_start, (size_t)(start - dp->db_txt_start)); /* adjust pointers of this and following lines */ for (i = idx + 1; i < count; ++i) dp->db_index[i] -= extra; } dp->db_index[idx] -= extra; /* adjust free space */ dp->db_free -= extra; dp->db_txt_start -= extra; /* copy new line into the data block */ mch_memmove(old_line - extra, new_line, (size_t)new_len); buf->b_ml.ml_flags |= (ML_LOCKED_DIRTY | ML_LOCKED_POS); #ifdef FEAT_BYTEOFF /* The else case is already covered by the insert and delete */ ml_updatechunk(buf, lnum, (long)extra, ML_CHNK_UPDLINE); #endif } else { /* * Cannot do it in one data block: Delete and append. * Append first, because ml_delete_int() cannot delete the * last line in a buffer, which causes trouble for a buffer * that has only one line. * Don't forget to copy the mark! */ /* How about handling errors??? */ (void)ml_append_int(buf, lnum, new_line, new_len, FALSE, (dp->db_index[idx] & DB_MARKED)); (void)ml_delete_int(buf, lnum, FALSE); } } vim_free(new_line); entered = FALSE; } buf->b_ml.ml_line_lnum = 0; } /* * create a new, empty, data block */ static bhdr_T * ml_new_data(mfp, negative, page_count) memfile_T *mfp; int negative; int page_count; { bhdr_T *hp; DATA_BL *dp; if ((hp = mf_new(mfp, negative, page_count)) == NULL) return NULL; dp = (DATA_BL *)(hp->bh_data); dp->db_id = DATA_ID; dp->db_txt_start = dp->db_txt_end = page_count * mfp->mf_page_size; dp->db_free = dp->db_txt_start - HEADER_SIZE; dp->db_line_count = 0; return hp; } /* * create a new, empty, pointer block */ static bhdr_T * ml_new_ptr(mfp) memfile_T *mfp; { bhdr_T *hp; PTR_BL *pp; if ((hp = mf_new(mfp, FALSE, 1)) == NULL) return NULL; pp = (PTR_BL *)(hp->bh_data); pp->pb_id = PTR_ID; pp->pb_count = 0; pp->pb_count_max = (short_u)((mfp->mf_page_size - sizeof(PTR_BL)) / sizeof(PTR_EN) + 1); return hp; } /* * lookup line 'lnum' in a memline * * action: if ML_DELETE or ML_INSERT the line count is updated while searching * if ML_FLUSH only flush a locked block * if ML_FIND just find the line * * If the block was found it is locked and put in ml_locked. * The stack is updated to lead to the locked block. The ip_high field in * the stack is updated to reflect the last line in the block AFTER the * insert or delete, also if the pointer block has not been updated yet. But * if ml_locked != NULL ml_locked_lineadd must be added to ip_high. * * return: NULL for failure, pointer to block header otherwise */ static bhdr_T * ml_find_line(buf, lnum, action) buf_T *buf; linenr_T lnum; int action; { DATA_BL *dp; PTR_BL *pp; infoptr_T *ip; bhdr_T *hp; memfile_T *mfp; linenr_T t; blocknr_T bnum, bnum2; int dirty; linenr_T low, high; int top; int page_count; int idx; mfp = buf->b_ml.ml_mfp; /* * If there is a locked block check if the wanted line is in it. * If not, flush and release the locked block. * Don't do this for ML_INSERT_SAME, because the stack need to be updated. * Don't do this for ML_FLUSH, because we want to flush the locked block. * Don't do this when 'swapfile' is reset, we want to load all the blocks. */ if (buf->b_ml.ml_locked) { if (ML_SIMPLE(action) && buf->b_ml.ml_locked_low <= lnum && buf->b_ml.ml_locked_high >= lnum && !mf_dont_release) { /* remember to update pointer blocks and stack later */ if (action == ML_INSERT) { ++(buf->b_ml.ml_locked_lineadd); ++(buf->b_ml.ml_locked_high); } else if (action == ML_DELETE) { --(buf->b_ml.ml_locked_lineadd); --(buf->b_ml.ml_locked_high); } return (buf->b_ml.ml_locked); } mf_put(mfp, buf->b_ml.ml_locked, buf->b_ml.ml_flags & ML_LOCKED_DIRTY, buf->b_ml.ml_flags & ML_LOCKED_POS); buf->b_ml.ml_locked = NULL; /* * If lines have been added or deleted in the locked block, need to * update the line count in pointer blocks. */ if (buf->b_ml.ml_locked_lineadd != 0) ml_lineadd(buf, buf->b_ml.ml_locked_lineadd); } if (action == ML_FLUSH) /* nothing else to do */ return NULL; bnum = 1; /* start at the root of the tree */ page_count = 1; low = 1; high = buf->b_ml.ml_line_count; if (action == ML_FIND) /* first try stack entries */ { for (top = buf->b_ml.ml_stack_top - 1; top >= 0; --top) { ip = &(buf->b_ml.ml_stack[top]); if (ip->ip_low <= lnum && ip->ip_high >= lnum) { bnum = ip->ip_bnum; low = ip->ip_low; high = ip->ip_high; buf->b_ml.ml_stack_top = top; /* truncate stack at prev entry */ break; } } if (top < 0) buf->b_ml.ml_stack_top = 0; /* not found, start at the root */ } else /* ML_DELETE or ML_INSERT */ buf->b_ml.ml_stack_top = 0; /* start at the root */ /* * search downwards in the tree until a data block is found */ for (;;) { if ((hp = mf_get(mfp, bnum, page_count)) == NULL) goto error_noblock; /* * update high for insert/delete */ if (action == ML_INSERT) ++high; else if (action == ML_DELETE) --high; dp = (DATA_BL *)(hp->bh_data); if (dp->db_id == DATA_ID) /* data block */ { buf->b_ml.ml_locked = hp; buf->b_ml.ml_locked_low = low; buf->b_ml.ml_locked_high = high; buf->b_ml.ml_locked_lineadd = 0; buf->b_ml.ml_flags &= ~(ML_LOCKED_DIRTY | ML_LOCKED_POS); return hp; } pp = (PTR_BL *)(dp); /* must be pointer block */ if (pp->pb_id != PTR_ID) { EMSG(_("E317: pointer block id wrong")); goto error_block; } if ((top = ml_add_stack(buf)) < 0) /* add new entry to stack */ goto error_block; ip = &(buf->b_ml.ml_stack[top]); ip->ip_bnum = bnum; ip->ip_low = low; ip->ip_high = high; ip->ip_index = -1; /* index not known yet */ dirty = FALSE; for (idx = 0; idx < (int)pp->pb_count; ++idx) { t = pp->pb_pointer[idx].pe_line_count; CHECK(t == 0, _("pe_line_count is zero")); if ((low += t) > lnum) { ip->ip_index = idx; bnum = pp->pb_pointer[idx].pe_bnum; page_count = pp->pb_pointer[idx].pe_page_count; high = low - 1; low -= t; /* * a negative block number may have been changed */ if (bnum < 0) { bnum2 = mf_trans_del(mfp, bnum); if (bnum != bnum2) { bnum = bnum2; pp->pb_pointer[idx].pe_bnum = bnum; dirty = TRUE; } } break; } } if (idx >= (int)pp->pb_count) /* past the end: something wrong! */ { if (lnum > buf->b_ml.ml_line_count) EMSGN(_("E322: line number out of range: %ld past the end"), lnum - buf->b_ml.ml_line_count); else EMSGN(_("E323: line count wrong in block %ld"), bnum); goto error_block; } if (action == ML_DELETE) { pp->pb_pointer[idx].pe_line_count--; dirty = TRUE; } else if (action == ML_INSERT) { pp->pb_pointer[idx].pe_line_count++; dirty = TRUE; } mf_put(mfp, hp, dirty, FALSE); } error_block: mf_put(mfp, hp, FALSE, FALSE); error_noblock: /* * If action is ML_DELETE or ML_INSERT we have to correct the tree for * the incremented/decremented line counts, because there won't be a line * inserted/deleted after all. */ if (action == ML_DELETE) ml_lineadd(buf, 1); else if (action == ML_INSERT) ml_lineadd(buf, -1); buf->b_ml.ml_stack_top = 0; return NULL; } /* * add an entry to the info pointer stack * * return -1 for failure, number of the new entry otherwise */ static int ml_add_stack(buf) buf_T *buf; { int top; infoptr_T *newstack; top = buf->b_ml.ml_stack_top; /* may have to increase the stack size */ if (top == buf->b_ml.ml_stack_size) { CHECK(top > 0, _("Stack size increases")); /* more than 5 levels??? */ newstack = (infoptr_T *)alloc((unsigned)sizeof(infoptr_T) * (buf->b_ml.ml_stack_size + STACK_INCR)); if (newstack == NULL) return -1; mch_memmove(newstack, buf->b_ml.ml_stack, (size_t)top * sizeof(infoptr_T)); vim_free(buf->b_ml.ml_stack); buf->b_ml.ml_stack = newstack; buf->b_ml.ml_stack_size += STACK_INCR; } buf->b_ml.ml_stack_top++; return top; } /* * Update the pointer blocks on the stack for inserted/deleted lines. * The stack itself is also updated. * * When a insert/delete line action fails, the line is not inserted/deleted, * but the pointer blocks have already been updated. That is fixed here by * walking through the stack. * * Count is the number of lines added, negative if lines have been deleted. */ static void ml_lineadd(buf, count) buf_T *buf; int count; { int idx; infoptr_T *ip; PTR_BL *pp; memfile_T *mfp = buf->b_ml.ml_mfp; bhdr_T *hp; for (idx = buf->b_ml.ml_stack_top - 1; idx >= 0; --idx) { ip = &(buf->b_ml.ml_stack[idx]); if ((hp = mf_get(mfp, ip->ip_bnum, 1)) == NULL) break; pp = (PTR_BL *)(hp->bh_data); /* must be pointer block */ if (pp->pb_id != PTR_ID) { mf_put(mfp, hp, FALSE, FALSE); EMSG(_("E317: pointer block id wrong 2")); break; } pp->pb_pointer[ip->ip_index].pe_line_count += count; ip->ip_high += count; mf_put(mfp, hp, TRUE, FALSE); } } #ifdef HAVE_READLINK /* * Resolve a symlink in the last component of a file name. * Note that f_resolve() does it for every part of the path, we don't do that * here. * If it worked returns OK and the resolved link in "buf[MAXPATHL]". * Otherwise returns FAIL. */ static int resolve_symlink(fname, buf) char_u *fname; char_u *buf; { char_u tmp[MAXPATHL]; int ret; int depth = 0; if (fname == NULL) return FAIL; /* Put the result so far in tmp[], starting with the original name. */ vim_strncpy(tmp, fname, MAXPATHL - 1); for (;;) { /* Limit symlink depth to 100, catch recursive loops. */ if (++depth == 100) { EMSG2(_("E773: Symlink loop for \"%s\""), fname); return FAIL; } ret = readlink((char *)tmp, (char *)buf, MAXPATHL - 1); if (ret <= 0) { if (errno == EINVAL || errno == ENOENT) { /* Found non-symlink or not existing file, stop here. * When at the first level use the unmodified name, skip the * call to vim_FullName(). */ if (depth == 1) return FAIL; /* Use the resolved name in tmp[]. */ break; } /* There must be some error reading links, use original name. */ return FAIL; } buf[ret] = NUL; /* * Check whether the symlink is relative or absolute. * If it's relative, build a new path based on the directory * portion of the filename (if any) and the path the symlink * points to. */ if (mch_isFullName(buf)) STRCPY(tmp, buf); else { char_u *tail; tail = gettail(tmp); if (STRLEN(tail) + STRLEN(buf) >= MAXPATHL) return FAIL; STRCPY(tail, buf); } } /* * Try to resolve the full name of the file so that the swapfile name will * be consistent even when opening a relative symlink from different * working directories. */ return vim_FullName(tmp, buf, MAXPATHL, TRUE); } #endif /* * Make swap file name out of the file name and a directory name. * Returns pointer to allocated memory or NULL. */ char_u * makeswapname(fname, ffname, buf, dir_name) char_u *fname; char_u *ffname UNUSED; buf_T *buf; char_u *dir_name; { char_u *r, *s; char_u *fname_res = fname; #ifdef HAVE_READLINK char_u fname_buf[MAXPATHL]; #endif #if defined(UNIX) || defined(WIN3264) /* Need _very_ long file names */ s = dir_name + STRLEN(dir_name); if (after_pathsep(dir_name, s) && s[-1] == s[-2]) { /* Ends with '//', Use Full path */ r = NULL; if ((s = make_percent_swname(dir_name, fname)) != NULL) { r = modname(s, (char_u *)".swp", FALSE); vim_free(s); } return r; } #endif #ifdef HAVE_READLINK /* Expand symlink in the file name, so that we put the swap file with the * actual file instead of with the symlink. */ if (resolve_symlink(fname, fname_buf) == OK) fname_res = fname_buf; #endif r = buf_modname( #ifdef SHORT_FNAME TRUE, #else (buf->b_p_sn || buf->b_shortname), #endif #ifdef RISCOS /* Avoid problems if fname has special chars, eg */ ffname, #else fname_res, #endif (char_u *) #if defined(VMS) || defined(RISCOS) "_swp", #else ".swp", #endif #ifdef SHORT_FNAME /* always 8.3 file name */ FALSE #else /* Prepend a '.' to the swap file name for the current directory. */ dir_name[0] == '.' && dir_name[1] == NUL #endif ); if (r == NULL) /* out of memory */ return NULL; s = get_file_in_dir(r, dir_name); vim_free(r); return s; } /* * Get file name to use for swap file or backup file. * Use the name of the edited file "fname" and an entry in the 'dir' or 'bdir' * option "dname". * - If "dname" is ".", return "fname" (swap file in dir of file). * - If "dname" starts with "./", insert "dname" in "fname" (swap file * relative to dir of file). * - Otherwise, prepend "dname" to the tail of "fname" (swap file in specific * dir). * * The return value is an allocated string and can be NULL. */ char_u * get_file_in_dir(fname, dname) char_u *fname; char_u *dname; /* don't use "dirname", it is a global for Alpha */ { char_u *t; char_u *tail; char_u *retval; int save_char; tail = gettail(fname); if (dname[0] == '.' && dname[1] == NUL) retval = vim_strsave(fname); else if (dname[0] == '.' && vim_ispathsep(dname[1])) { if (tail == fname) /* no path before file name */ retval = concat_fnames(dname + 2, tail, TRUE); else { save_char = *tail; *tail = NUL; t = concat_fnames(fname, dname + 2, TRUE); *tail = save_char; if (t == NULL) /* out of memory */ retval = NULL; else { retval = concat_fnames(t, tail, TRUE); vim_free(t); } } } else retval = concat_fnames(dname, tail, TRUE); return retval; } static void attention_message __ARGS((buf_T *buf, char_u *fname)); /* * Print the ATTENTION message: info about an existing swap file. */ static void attention_message(buf, fname) buf_T *buf; /* buffer being edited */ char_u *fname; /* swap file name */ { struct stat st; time_t x, sx; char *p; ++no_wait_return; (void)EMSG(_("E325: ATTENTION")); MSG_PUTS(_("\nFound a swap file by the name \"")); msg_home_replace(fname); MSG_PUTS("\"\n"); sx = swapfile_info(fname); MSG_PUTS(_("While opening file \"")); msg_outtrans(buf->b_fname); MSG_PUTS("\"\n"); if (mch_stat((char *)buf->b_fname, &st) != -1) { MSG_PUTS(_(" dated: ")); x = st.st_mtime; /* Manx C can't do &st.st_mtime */ p = ctime(&x); /* includes '\n' */ if (p == NULL) MSG_PUTS("(invalid)\n"); else MSG_PUTS(p); if (sx != 0 && x > sx) MSG_PUTS(_(" NEWER than swap file!\n")); } /* Some of these messages are long to allow translation to * other languages. */ 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")); MSG_PUTS(_(" Quit, or continue with caution.\n")); MSG_PUTS(_("\n(2) An edit session for this file crashed.\n")); MSG_PUTS(_(" If this is the case, use \":recover\" or \"vim -r ")); msg_outtrans(buf->b_fname); MSG_PUTS(_("\"\n to recover the changes (see \":help recovery\").\n")); MSG_PUTS(_(" If you did this already, delete the swap file \"")); msg_outtrans(fname); MSG_PUTS(_("\"\n to avoid this message.\n")); cmdline_row = msg_row; --no_wait_return; } #ifdef FEAT_AUTOCMD static int do_swapexists __ARGS((buf_T *buf, char_u *fname)); /* * Trigger the SwapExists autocommands. * Returns a value for equivalent to do_dialog() (see below): * 0: still need to ask for a choice * 1: open read-only * 2: edit anyway * 3: recover * 4: delete it * 5: quit * 6: abort */ static int do_swapexists(buf, fname) buf_T *buf; char_u *fname; { set_vim_var_string(VV_SWAPNAME, fname, -1); set_vim_var_string(VV_SWAPCHOICE, NULL, -1); /* Trigger SwapExists autocommands with set to the file being * edited. Disallow changing directory here. */ ++allbuf_lock; apply_autocmds(EVENT_SWAPEXISTS, buf->b_fname, NULL, FALSE, NULL); --allbuf_lock; set_vim_var_string(VV_SWAPNAME, NULL, -1); switch (*get_vim_var_str(VV_SWAPCHOICE)) { case 'o': return 1; case 'e': return 2; case 'r': return 3; case 'd': return 4; case 'q': return 5; case 'a': return 6; } return 0; } #endif /* * Find out what name to use for the swap file for buffer 'buf'. * * Several names are tried to find one that does not exist * Returns the name in allocated memory or NULL. * * Note: If BASENAMELEN is not correct, you will get error messages for * not being able to open the swapfile * Note: May trigger SwapExists autocmd, pointers may change! */ static char_u * findswapname(buf, dirp, old_fname) buf_T *buf; char_u **dirp; /* pointer to list of directories */ char_u *old_fname; /* don't give warning for this file name */ { char_u *fname; int n; char_u *dir_name; #ifdef AMIGA BPTR fh; #endif #ifndef SHORT_FNAME int r; #endif #if !defined(SHORT_FNAME) \ && ((!defined(UNIX) && !defined(OS2)) || defined(ARCHIE)) # define CREATE_DUMMY_FILE FILE *dummyfd = NULL; /* * If we start editing a new file, e.g. "test.doc", which resides on an MSDOS * compatible filesystem, it is possible that the file "test.doc.swp" which we * create will be exactly the same file. To avoid this problem we temporarily * create "test.doc". * Don't do this when the check below for a 8.3 file name is used. */ if (!(buf->b_p_sn || buf->b_shortname) && buf->b_fname != NULL && mch_getperm(buf->b_fname) < 0) dummyfd = mch_fopen((char *)buf->b_fname, "w"); #endif /* * Isolate a directory name from *dirp and put it in dir_name. * First allocate some memory to put the directory name in. */ dir_name = alloc((unsigned)STRLEN(*dirp) + 1); if (dir_name != NULL) (void)copy_option_part(dirp, dir_name, 31000, ","); /* * we try different names until we find one that does not exist yet */ if (dir_name == NULL) /* out of memory */ fname = NULL; else fname = makeswapname(buf->b_fname, buf->b_ffname, buf, dir_name); for (;;) { if (fname == NULL) /* must be out of memory */ break; if ((n = (int)STRLEN(fname)) == 0) /* safety check */ { vim_free(fname); fname = NULL; break; } #if (defined(UNIX) || defined(OS2)) && !defined(ARCHIE) && !defined(SHORT_FNAME) /* * Some systems have a MS-DOS compatible filesystem that use 8.3 character * file names. If this is the first try and the swap file name does not fit in * 8.3, detect if this is the case, set shortname and try again. */ if (fname[n - 2] == 'w' && fname[n - 1] == 'p' && !(buf->b_p_sn || buf->b_shortname)) { char_u *tail; char_u *fname2; struct stat s1, s2; int f1, f2; int created1 = FALSE, created2 = FALSE; int same = FALSE; /* * Check if swapfile name does not fit in 8.3: * It either contains two dots, is longer than 8 chars, or starts * with a dot. */ tail = gettail(buf->b_fname); if ( vim_strchr(tail, '.') != NULL || STRLEN(tail) > (size_t)8 || *gettail(fname) == '.') { fname2 = alloc(n + 2); if (fname2 != NULL) { STRCPY(fname2, fname); /* if fname == "xx.xx.swp", fname2 = "xx.xx.swx" * if fname == ".xx.swp", fname2 = ".xx.swpx" * if fname == "123456789.swp", fname2 = "12345678x.swp" */ if (vim_strchr(tail, '.') != NULL) fname2[n - 1] = 'x'; else if (*gettail(fname) == '.') { fname2[n] = 'x'; fname2[n + 1] = NUL; } else fname2[n - 5] += 1; /* * may need to create the files to be able to use mch_stat() */ f1 = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0); if (f1 < 0) { f1 = mch_open_rw((char *)fname, O_RDWR|O_CREAT|O_EXCL|O_EXTRA); #if defined(OS2) if (f1 < 0 && errno == ENOENT) same = TRUE; #endif created1 = TRUE; } if (f1 >= 0) { f2 = mch_open((char *)fname2, O_RDONLY | O_EXTRA, 0); if (f2 < 0) { f2 = mch_open_rw((char *)fname2, O_RDWR|O_CREAT|O_EXCL|O_EXTRA); created2 = TRUE; } if (f2 >= 0) { /* * Both files exist now. If mch_stat() returns the * same device and inode they are the same file. */ if (mch_fstat(f1, &s1) != -1 && mch_fstat(f2, &s2) != -1 && s1.st_dev == s2.st_dev && s1.st_ino == s2.st_ino) same = TRUE; close(f2); if (created2) mch_remove(fname2); } close(f1); if (created1) mch_remove(fname); } vim_free(fname2); if (same) { buf->b_shortname = TRUE; vim_free(fname); fname = makeswapname(buf->b_fname, buf->b_ffname, buf, dir_name); continue; /* try again with b_shortname set */ } } } } #endif /* * check if the swapfile already exists */ if (mch_getperm(fname) < 0) /* it does not exist */ { #ifdef HAVE_LSTAT struct stat sb; /* * Extra security check: When a swap file is a symbolic link, this * is most likely a symlink attack. */ if (mch_lstat((char *)fname, &sb) < 0) #else # ifdef AMIGA fh = Open((UBYTE *)fname, (long)MODE_NEWFILE); /* * on the Amiga mch_getperm() will return -1 when the file exists * but is being used by another program. This happens if you edit * a file twice. */ if (fh != (BPTR)NULL) /* can open file, OK */ { Close(fh); mch_remove(fname); break; } if (IoErr() != ERROR_OBJECT_IN_USE && IoErr() != ERROR_OBJECT_EXISTS) # endif #endif break; } /* * A file name equal to old_fname is OK to use. */ if (old_fname != NULL && fnamecmp(fname, old_fname) == 0) break; /* * get here when file already exists */ if (fname[n - 2] == 'w' && fname[n - 1] == 'p') /* first try */ { #ifndef SHORT_FNAME /* * on MS-DOS compatible filesystems (e.g. messydos) file.doc.swp * and file.doc are the same file. To guess if this problem is * present try if file.doc.swx exists. If it does, we set * buf->b_shortname and try file_doc.swp (dots replaced by * underscores for this file), and try again. If it doesn't we * assume that "file.doc.swp" already exists. */ if (!(buf->b_p_sn || buf->b_shortname)) /* not tried yet */ { fname[n - 1] = 'x'; r = mch_getperm(fname); /* try "file.swx" */ fname[n - 1] = 'p'; if (r >= 0) /* "file.swx" seems to exist */ { buf->b_shortname = TRUE; vim_free(fname); fname = makeswapname(buf->b_fname, buf->b_ffname, buf, dir_name); continue; /* try again with '.' replaced with '_' */ } } #endif /* * If we get here the ".swp" file really exists. * Give an error message, unless recovering, no file name, we are * viewing a help file or when the path of the file is different * (happens when all .swp files are in one directory). */ if (!recoverymode && buf->b_fname != NULL && !buf->b_help && !(buf->b_flags & BF_DUMMY)) { int fd; struct block0 b0; int differ = FALSE; /* * Try to read block 0 from the swap file to get the original * file name (and inode number). */ fd = mch_open((char *)fname, O_RDONLY | O_EXTRA, 0); if (fd >= 0) { if (read(fd, (char *)&b0, sizeof(b0)) == sizeof(b0)) { /* * If the swapfile has the same directory as the * buffer don't compare the directory names, they can * have a different mountpoint. */ if (b0.b0_flags & B0_SAME_DIR) { if (fnamecmp(gettail(buf->b_ffname), gettail(b0.b0_fname)) != 0 || !same_directory(fname, buf->b_ffname)) { #ifdef CHECK_INODE /* Symlinks may point to the same file even * when the name differs, need to check the * inode too. */ expand_env(b0.b0_fname, NameBuff, MAXPATHL); if (fnamecmp_ino(buf->b_ffname, NameBuff, char_to_long(b0.b0_ino))) #endif differ = TRUE; } } else { /* * The name in the swap file may be * "~user/path/file". Expand it first. */ expand_env(b0.b0_fname, NameBuff, MAXPATHL); #ifdef CHECK_INODE if (fnamecmp_ino(buf->b_ffname, NameBuff, char_to_long(b0.b0_ino))) differ = TRUE; #else if (fnamecmp(NameBuff, buf->b_ffname) != 0) differ = TRUE; #endif } } close(fd); } #ifdef RISCOS else /* Can't open swap file, though it does exist. * Assume that the user is editing two files with * the same name in different directories. No error. */ differ = TRUE; #endif /* give the ATTENTION message when there is an old swap file * for the current file, and the buffer was not recovered. */ if (differ == FALSE && !(curbuf->b_flags & BF_RECOVERED) && vim_strchr(p_shm, SHM_ATTENTION) == NULL) { #if defined(HAS_SWAP_EXISTS_ACTION) int choice = 0; #endif #ifdef CREATE_DUMMY_FILE int did_use_dummy = FALSE; /* Avoid getting a warning for the file being created * outside of Vim, it was created at the start of this * function. Delete the file now, because Vim might exit * here if the window is closed. */ if (dummyfd != NULL) { fclose(dummyfd); dummyfd = NULL; mch_remove(buf->b_fname); did_use_dummy = TRUE; } #endif #if (defined(UNIX) || defined(__EMX__) || defined(VMS)) && (defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)) process_still_running = FALSE; #endif #ifdef FEAT_AUTOCMD /* * If there is an SwapExists autocommand and we can handle * the response, trigger it. It may return 0 to ask the * user anyway. */ if (swap_exists_action != SEA_NONE && has_autocmd(EVENT_SWAPEXISTS, buf->b_fname, buf)) choice = do_swapexists(buf, fname); if (choice == 0) #endif { #ifdef FEAT_GUI /* If we are supposed to start the GUI but it wasn't * completely started yet, start it now. This makes * the messages displayed in the Vim window when * loading a session from the .gvimrc file. */ if (gui.starting && !gui.in_use) gui_start(); #endif /* Show info about the existing swap file. */ attention_message(buf, fname); /* We don't want a 'q' typed at the more-prompt * interrupt loading a file. */ got_int = FALSE; } #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG) if (swap_exists_action != SEA_NONE && choice == 0) { char_u *name; name = alloc((unsigned)(STRLEN(fname) + STRLEN(_("Swap file \"")) + STRLEN(_("\" already exists!")) + 5)); if (name != NULL) { STRCPY(name, _("Swap file \"")); home_replace(NULL, fname, name + STRLEN(name), 1000, TRUE); STRCAT(name, _("\" already exists!")); } choice = do_dialog(VIM_WARNING, (char_u *)_("VIM - ATTENTION"), name == NULL ? (char_u *)_("Swap file already exists!") : name, # if defined(UNIX) || defined(__EMX__) || defined(VMS) process_still_running ? (char_u *)_("&Open Read-Only\n&Edit anyway\n&Recover\n&Quit\n&Abort") : # endif (char_u *)_("&Open Read-Only\n&Edit anyway\n&Recover\n&Delete it\n&Quit\n&Abort"), 1, NULL); # if defined(UNIX) || defined(__EMX__) || defined(VMS) if (process_still_running && choice >= 4) choice++; /* Skip missing "Delete it" button */ # endif vim_free(name); /* pretend screen didn't scroll, need redraw anyway */ msg_scrolled = 0; redraw_all_later(NOT_VALID); } #endif #if defined(HAS_SWAP_EXISTS_ACTION) if (choice > 0) { switch (choice) { case 1: buf->b_p_ro = TRUE; break; case 2: break; case 3: swap_exists_action = SEA_RECOVER; break; case 4: mch_remove(fname); break; case 5: swap_exists_action = SEA_QUIT; break; case 6: swap_exists_action = SEA_QUIT; got_int = TRUE; break; } /* If the file was deleted this fname can be used. */ if (mch_getperm(fname) < 0) break; } else #endif { MSG_PUTS("\n"); if (msg_silent == 0) /* call wait_return() later */ need_wait_return = TRUE; } #ifdef CREATE_DUMMY_FILE /* Going to try another name, need the dummy file again. */ if (did_use_dummy) dummyfd = mch_fopen((char *)buf->b_fname, "w"); #endif } } } /* * Change the ".swp" extension to find another file that can be used. * First decrement the last char: ".swo", ".swn", etc. * If that still isn't enough decrement the last but one char: ".svz" * Can happen when editing many "No Name" buffers. */ if (fname[n - 1] == 'a') /* ".s?a" */ { if (fname[n - 2] == 'a') /* ".saa": tried enough, give up */ { EMSG(_("E326: Too many swap files found")); vim_free(fname); fname = NULL; break; } --fname[n - 2]; /* ".svz", ".suz", etc. */ fname[n - 1] = 'z' + 1; } --fname[n - 1]; /* ".swo", ".swn", etc. */ } vim_free(dir_name); #ifdef CREATE_DUMMY_FILE if (dummyfd != NULL) /* file has been created temporarily */ { fclose(dummyfd); mch_remove(buf->b_fname); } #endif return fname; } static int b0_magic_wrong(b0p) ZERO_BL *b0p; { return (b0p->b0_magic_long != (long)B0_MAGIC_LONG || b0p->b0_magic_int != (int)B0_MAGIC_INT || b0p->b0_magic_short != (short)B0_MAGIC_SHORT || b0p->b0_magic_char != B0_MAGIC_CHAR); } #ifdef CHECK_INODE /* * Compare current file name with file name from swap file. * Try to use inode numbers when possible. * Return non-zero when files are different. * * When comparing file names a few things have to be taken into consideration: * - When working over a network the full path of a file depends on the host. * We check the inode number if possible. It is not 100% reliable though, * because the device number cannot be used over a network. * - When a file does not exist yet (editing a new file) there is no inode * number. * - The file name in a swap file may not be valid on the current host. The * "~user" form is used whenever possible to avoid this. * * This is getting complicated, let's make a table: * * ino_c ino_s fname_c fname_s differ = * * both files exist -> compare inode numbers: * != 0 != 0 X X ino_c != ino_s * * inode number(s) unknown, file names available -> compare file names * == 0 X OK OK fname_c != fname_s * X == 0 OK OK fname_c != fname_s * * current file doesn't exist, file for swap file exist, file name(s) not * available -> probably different * == 0 != 0 FAIL X TRUE * == 0 != 0 X FAIL TRUE * * current file exists, inode for swap unknown, file name(s) not * available -> probably different * != 0 == 0 FAIL X TRUE * != 0 == 0 X FAIL TRUE * * current file doesn't exist, inode for swap unknown, one file name not * available -> probably different * == 0 == 0 FAIL OK TRUE * == 0 == 0 OK FAIL TRUE * * current file doesn't exist, inode for swap unknown, both file names not * available -> probably same file * == 0 == 0 FAIL FAIL FALSE * * Note that when the ino_t is 64 bits, only the last 32 will be used. This * can't be changed without making the block 0 incompatible with 32 bit * versions. */ static int fnamecmp_ino(fname_c, fname_s, ino_block0) char_u *fname_c; /* current file name */ char_u *fname_s; /* file name from swap file */ long ino_block0; { struct stat st; ino_t ino_c = 0; /* ino of current file */ ino_t ino_s; /* ino of file from swap file */ char_u buf_c[MAXPATHL]; /* full path of fname_c */ char_u buf_s[MAXPATHL]; /* full path of fname_s */ int retval_c; /* flag: buf_c valid */ int retval_s; /* flag: buf_s valid */ if (mch_stat((char *)fname_c, &st) == 0) ino_c = (ino_t)st.st_ino; /* * First we try to get the inode from the file name, because the inode in * the swap file may be outdated. If that fails (e.g. this path is not * valid on this machine), use the inode from block 0. */ if (mch_stat((char *)fname_s, &st) == 0) ino_s = (ino_t)st.st_ino; else ino_s = (ino_t)ino_block0; if (ino_c && ino_s) return (ino_c != ino_s); /* * One of the inode numbers is unknown, try a forced vim_FullName() and * compare the file names. */ retval_c = vim_FullName(fname_c, buf_c, MAXPATHL, TRUE); retval_s = vim_FullName(fname_s, buf_s, MAXPATHL, TRUE); if (retval_c == OK && retval_s == OK) return (STRCMP(buf_c, buf_s) != 0); /* * Can't compare inodes or file names, guess that the files are different, * unless both appear not to exist at all. */ if (ino_s == 0 && ino_c == 0 && retval_c == FAIL && retval_s == FAIL) return FALSE; return TRUE; } #endif /* CHECK_INODE */ /* * Move a long integer into a four byte character array. * Used for machine independency in block zero. */ static void long_to_char(n, s) long n; char_u *s; { s[0] = (char_u)(n & 0xff); n = (unsigned)n >> 8; s[1] = (char_u)(n & 0xff); n = (unsigned)n >> 8; s[2] = (char_u)(n & 0xff); n = (unsigned)n >> 8; s[3] = (char_u)(n & 0xff); } static long char_to_long(s) char_u *s; { long retval; retval = s[3]; retval <<= 8; retval |= s[2]; retval <<= 8; retval |= s[1]; retval <<= 8; retval |= s[0]; return retval; } /* * Set the flags in the first block of the swap file: * - file is modified or not: buf->b_changed * - 'fileformat' * - 'fileencoding' */ void ml_setflags(buf) buf_T *buf; { bhdr_T *hp; ZERO_BL *b0p; if (!buf->b_ml.ml_mfp) return; for (hp = buf->b_ml.ml_mfp->mf_used_last; hp != NULL; hp = hp->bh_prev) { if (hp->bh_bnum == 0) { b0p = (ZERO_BL *)(hp->bh_data); b0p->b0_dirty = buf->b_changed ? B0_DIRTY : 0; b0p->b0_flags = (b0p->b0_flags & ~B0_FF_MASK) | (get_fileformat(buf) + 1); #ifdef FEAT_MBYTE add_b0_fenc(b0p, buf); #endif hp->bh_flags |= BH_DIRTY; mf_sync(buf->b_ml.ml_mfp, MFS_ZERO); break; } } } #if defined(FEAT_BYTEOFF) || defined(PROTO) #define MLCS_MAXL 800 /* max no of lines in chunk */ #define MLCS_MINL 400 /* should be half of MLCS_MAXL */ /* * Keep information for finding byte offset of a line, updtytpe may be one of: * ML_CHNK_ADDLINE: Add len to parent chunk, possibly splitting it * Careful: ML_CHNK_ADDLINE may cause ml_find_line() to be called. * ML_CHNK_DELLINE: Subtract len from parent chunk, possibly deleting it * ML_CHNK_UPDLINE: Add len to parent chunk, as a signed entity. */ static void ml_updatechunk(buf, line, len, updtype) buf_T *buf; linenr_T line; long len; int updtype; { static buf_T *ml_upd_lastbuf = NULL; static linenr_T ml_upd_lastline; static linenr_T ml_upd_lastcurline; static int ml_upd_lastcurix; linenr_T curline = ml_upd_lastcurline; int curix = ml_upd_lastcurix; long size; chunksize_T *curchnk; int rest; bhdr_T *hp; DATA_BL *dp; if (buf->b_ml.ml_usedchunks == -1 || len == 0) return; if (buf->b_ml.ml_chunksize == NULL) { buf->b_ml.ml_chunksize = (chunksize_T *) alloc((unsigned)sizeof(chunksize_T) * 100); if (buf->b_ml.ml_chunksize == NULL) { buf->b_ml.ml_usedchunks = -1; return; } buf->b_ml.ml_numchunks = 100; buf->b_ml.ml_usedchunks = 1; buf->b_ml.ml_chunksize[0].mlcs_numlines = 1; buf->b_ml.ml_chunksize[0].mlcs_totalsize = 1; } if (updtype == ML_CHNK_UPDLINE && buf->b_ml.ml_line_count == 1) { /* * First line in empty buffer from ml_flush_line() -- reset */ buf->b_ml.ml_usedchunks = 1; buf->b_ml.ml_chunksize[0].mlcs_numlines = 1; buf->b_ml.ml_chunksize[0].mlcs_totalsize = (long)STRLEN(buf->b_ml.ml_line_ptr) + 1; return; } /* * Find chunk that our line belongs to, curline will be at start of the * chunk. */ if (buf != ml_upd_lastbuf || line != ml_upd_lastline + 1 || updtype != ML_CHNK_ADDLINE) { for (curline = 1, curix = 0; curix < buf->b_ml.ml_usedchunks - 1 && line >= curline + buf->b_ml.ml_chunksize[curix].mlcs_numlines; curix++) { curline += buf->b_ml.ml_chunksize[curix].mlcs_numlines; } } else if (line >= curline + buf->b_ml.ml_chunksize[curix].mlcs_numlines && curix < buf->b_ml.ml_usedchunks - 1) { /* Adjust cached curix & curline */ curline += buf->b_ml.ml_chunksize[curix].mlcs_numlines; curix++; } curchnk = buf->b_ml.ml_chunksize + curix; if (updtype == ML_CHNK_DELLINE) len = -len; curchnk->mlcs_totalsize += len; if (updtype == ML_CHNK_ADDLINE) { curchnk->mlcs_numlines++; /* May resize here so we don't have to do it in both cases below */ if (buf->b_ml.ml_usedchunks + 1 >= buf->b_ml.ml_numchunks) { buf->b_ml.ml_numchunks = buf->b_ml.ml_numchunks * 3 / 2; buf->b_ml.ml_chunksize = (chunksize_T *) vim_realloc(buf->b_ml.ml_chunksize, sizeof(chunksize_T) * buf->b_ml.ml_numchunks); if (buf->b_ml.ml_chunksize == NULL) { /* Hmmmm, Give up on offset for this buffer */ buf->b_ml.ml_usedchunks = -1; return; } } if (buf->b_ml.ml_chunksize[curix].mlcs_numlines >= MLCS_MAXL) { int count; /* number of entries in block */ int idx; int text_end; int linecnt; mch_memmove(buf->b_ml.ml_chunksize + curix + 1, buf->b_ml.ml_chunksize + curix, (buf->b_ml.ml_usedchunks - curix) * sizeof(chunksize_T)); /* Compute length of first half of lines in the split chunk */ size = 0; linecnt = 0; while (curline < buf->b_ml.ml_line_count && linecnt < MLCS_MINL) { if ((hp = ml_find_line(buf, curline, ML_FIND)) == NULL) { buf->b_ml.ml_usedchunks = -1; return; } dp = (DATA_BL *)(hp->bh_data); count = (long)(buf->b_ml.ml_locked_high) - (long)(buf->b_ml.ml_locked_low) + 1; idx = curline - buf->b_ml.ml_locked_low; curline = buf->b_ml.ml_locked_high + 1; if (idx == 0)/* first line in block, text at the end */ text_end = dp->db_txt_end; else text_end = ((dp->db_index[idx - 1]) & DB_INDEX_MASK); /* Compute index of last line to use in this MEMLINE */ rest = count - idx; if (linecnt + rest > MLCS_MINL) { idx += MLCS_MINL - linecnt - 1; linecnt = MLCS_MINL; } else { idx = count - 1; linecnt += rest; } size += text_end - ((dp->db_index[idx]) & DB_INDEX_MASK); } buf->b_ml.ml_chunksize[curix].mlcs_numlines = linecnt; buf->b_ml.ml_chunksize[curix + 1].mlcs_numlines -= linecnt; buf->b_ml.ml_chunksize[curix].mlcs_totalsize = size; buf->b_ml.ml_chunksize[curix + 1].mlcs_totalsize -= size; buf->b_ml.ml_usedchunks++; ml_upd_lastbuf = NULL; /* Force recalc of curix & curline */ return; } else if (buf->b_ml.ml_chunksize[curix].mlcs_numlines >= MLCS_MINL && curix == buf->b_ml.ml_usedchunks - 1 && buf->b_ml.ml_line_count - line <= 1) { /* * We are in the last chunk and it is cheap to crate a new one * after this. Do it now to avoid the loop above later on */ curchnk = buf->b_ml.ml_chunksize + curix + 1; buf->b_ml.ml_usedchunks++; if (line == buf->b_ml.ml_line_count) { curchnk->mlcs_numlines = 0; curchnk->mlcs_totalsize = 0; } else { /* * Line is just prior to last, move count for last * This is the common case when loading a new file */ hp = ml_find_line(buf, buf->b_ml.ml_line_count, ML_FIND); if (hp == NULL) { buf->b_ml.ml_usedchunks = -1; return; } dp = (DATA_BL *)(hp->bh_data); if (dp->db_line_count == 1) rest = dp->db_txt_end - dp->db_txt_start; else rest = ((dp->db_index[dp->db_line_count - 2]) & DB_INDEX_MASK) - dp->db_txt_start; curchnk->mlcs_totalsize = rest; curchnk->mlcs_numlines = 1; curchnk[-1].mlcs_totalsize -= rest; curchnk[-1].mlcs_numlines -= 1; } } } else if (updtype == ML_CHNK_DELLINE) { curchnk->mlcs_numlines--; ml_upd_lastbuf = NULL; /* Force recalc of curix & curline */ if (curix < (buf->b_ml.ml_usedchunks - 1) && (curchnk->mlcs_numlines + curchnk[1].mlcs_numlines) <= MLCS_MINL) { curix++; curchnk = buf->b_ml.ml_chunksize + curix; } else if (curix == 0 && curchnk->mlcs_numlines <= 0) { buf->b_ml.ml_usedchunks--; mch_memmove(buf->b_ml.ml_chunksize, buf->b_ml.ml_chunksize + 1, buf->b_ml.ml_usedchunks * sizeof(chunksize_T)); return; } else if (curix == 0 || (curchnk->mlcs_numlines > 10 && (curchnk->mlcs_numlines + curchnk[-1].mlcs_numlines) > MLCS_MINL)) { return; } /* Collapse chunks */ curchnk[-1].mlcs_numlines += curchnk->mlcs_numlines; curchnk[-1].mlcs_totalsize += curchnk->mlcs_totalsize; buf->b_ml.ml_usedchunks--; if (curix < buf->b_ml.ml_usedchunks) { mch_memmove(buf->b_ml.ml_chunksize + curix, buf->b_ml.ml_chunksize + curix + 1, (buf->b_ml.ml_usedchunks - curix) * sizeof(chunksize_T)); } return; } ml_upd_lastbuf = buf; ml_upd_lastline = line; ml_upd_lastcurline = curline; ml_upd_lastcurix = curix; } /* * Find offset for line or line with offset. * Find line with offset if "lnum" is 0; return remaining offset in offp * Find offset of line if "lnum" > 0 * return -1 if information is not available */ long ml_find_line_or_offset(buf, lnum, offp) buf_T *buf; linenr_T lnum; long *offp; { linenr_T curline; int curix; long size; bhdr_T *hp; DATA_BL *dp; int count; /* number of entries in block */ int idx; int start_idx; int text_end; long offset; int len; int ffdos = (get_fileformat(buf) == EOL_DOS); int extra = 0; /* take care of cached line first */ ml_flush_line(curbuf); if (buf->b_ml.ml_usedchunks == -1 || buf->b_ml.ml_chunksize == NULL || lnum < 0) return -1; if (offp == NULL) offset = 0; else offset = *offp; if (lnum == 0 && offset <= 0) return 1; /* Not a "find offset" and offset 0 _must_ be in line 1 */ /* * Find the last chunk before the one containing our line. Last chunk is * special because it will never qualify */ curline = 1; curix = size = 0; while (curix < buf->b_ml.ml_usedchunks - 1 && ((lnum != 0 && lnum >= curline + buf->b_ml.ml_chunksize[curix].mlcs_numlines) || (offset != 0 && offset > size + buf->b_ml.ml_chunksize[curix].mlcs_totalsize + ffdos * buf->b_ml.ml_chunksize[curix].mlcs_numlines))) { curline += buf->b_ml.ml_chunksize[curix].mlcs_numlines; size += buf->b_ml.ml_chunksize[curix].mlcs_totalsize; if (offset && ffdos) size += buf->b_ml.ml_chunksize[curix].mlcs_numlines; curix++; } while ((lnum != 0 && curline < lnum) || (offset != 0 && size < offset)) { if (curline > buf->b_ml.ml_line_count || (hp = ml_find_line(buf, curline, ML_FIND)) == NULL) return -1; dp = (DATA_BL *)(hp->bh_data); count = (long)(buf->b_ml.ml_locked_high) - (long)(buf->b_ml.ml_locked_low) + 1; start_idx = idx = curline - buf->b_ml.ml_locked_low; if (idx == 0)/* first line in block, text at the end */ text_end = dp->db_txt_end; else text_end = ((dp->db_index[idx - 1]) & DB_INDEX_MASK); /* Compute index of last line to use in this MEMLINE */ if (lnum != 0) { if (curline + (count - idx) >= lnum) idx += lnum - curline - 1; else idx = count - 1; } else { extra = 0; while (offset >= size + text_end - (int)((dp->db_index[idx]) & DB_INDEX_MASK) + ffdos) { if (ffdos) size++; if (idx == count - 1) { extra = 1; break; } idx++; } } len = text_end - ((dp->db_index[idx]) & DB_INDEX_MASK); size += len; if (offset != 0 && size >= offset) { if (size + ffdos == offset) *offp = 0; else if (idx == start_idx) *offp = offset - size + len; else *offp = offset - size + len - (text_end - ((dp->db_index[idx - 1]) & DB_INDEX_MASK)); curline += idx - start_idx + extra; if (curline > buf->b_ml.ml_line_count) return -1; /* exactly one byte beyond the end */ return curline; } curline = buf->b_ml.ml_locked_high + 1; } if (lnum != 0) { /* Count extra CR characters. */ if (ffdos) size += lnum - 1; /* Don't count the last line break if 'bin' and 'noeol'. */ if (buf->b_p_bin && !buf->b_p_eol) size -= ffdos + 1; } return size; } /* * Goto byte in buffer with offset 'cnt'. */ void goto_byte(cnt) long cnt; { long boff = cnt; linenr_T lnum; ml_flush_line(curbuf); /* cached line may be dirty */ setpcmark(); if (boff) --boff; lnum = ml_find_line_or_offset(curbuf, (linenr_T)0, &boff); if (lnum < 1) /* past the end */ { curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count; curwin->w_curswant = MAXCOL; coladvance((colnr_T)MAXCOL); } else { curwin->w_cursor.lnum = lnum; curwin->w_cursor.col = (colnr_T)boff; # ifdef FEAT_VIRTUALEDIT curwin->w_cursor.coladd = 0; # endif curwin->w_set_curswant = TRUE; } check_cursor(); # ifdef FEAT_MBYTE /* Make sure the cursor is on the first byte of a multi-byte char. */ if (has_mbyte) mb_adjust_cursor(); # endif } #endif