Annotation of src/usr.bin/vim/memline.c, Revision 1.1
1.1 ! downsj 1: /* $OpenBSD$ */
! 2: /* vi:set ts=4 sw=4:
! 3: *
! 4: * VIM - Vi IMproved by Bram Moolenaar
! 5: *
! 6: * Do ":help uganda" in Vim to read copying and usage conditions.
! 7: * Do ":help credits" in Vim to see a list of people who contributed.
! 8: */
! 9:
! 10: /* for debugging */
! 11: /* #define CHECK(c, s) if (c) EMSG(s) */
! 12: #define CHECK(c, s)
! 13:
! 14: /*
! 15: * memline.c: Contains the functions for appending, deleting and changing the
! 16: * text lines. The memfile functions are used to store the information in blocks
! 17: * of memory, backed up by a file. The structure of the information is a tree.
! 18: * The root of the tree is a pointer block. The leaves of the tree are data
! 19: * blocks. In between may be several layers of pointer blocks, forming branches.
! 20: *
! 21: * Three types of blocks are used:
! 22: * - Block nr 0 contains information for recovery
! 23: * - Pointer blocks contain list of pointers to other blocks.
! 24: * - Data blocks contain the actual text.
! 25: *
! 26: * Block nr 0 contains the block0 structure (see below).
! 27: *
! 28: * Block nr 1 is the first pointer block. It is the root of the tree.
! 29: * Other pointer blocks are branches.
! 30: *
! 31: * If a line is too big to fit in a single page, the block
! 32: * containing that line is made big enough to hold the line. It may span
! 33: * several pages. Otherwise all blocks are one page.
! 34: *
! 35: * A data block that was filled when starting to edit a file and was not
! 36: * changed since then, can have a negative block number. This means that it
! 37: * has not yet been assigned a place in the file. When recovering, the lines
! 38: * in this data block can be read from the original file. When the block is
! 39: * changed (lines appended/deleted/changed) or when it is flushed it gets
! 40: * a positive number. Use mf_trans_del() to get the new number, before
! 41: * calling mf_get().
! 42: */
! 43:
! 44: /*
! 45: * The following functions are available to work with a memline:
! 46: *
! 47: * ml_open() open a new memline for a buffer
! 48: * ml_setname() change the file name for a memline
! 49: * ml_close() close the memline for a buffer
! 50: * ml_close_all() close all memlines
! 51: * ml_recover() read a memline for recovery
! 52: * ml_sync_all() flush changed blocks to file for all files
! 53: * ml_preserve() flush everything into the file for one file
! 54: * ml_get() get a pointer to a line
! 55: * ml_get_pos() get a pointer to a position in a line
! 56: * ml_get_cursor() get a pointer to the char under the cursor
! 57: * ml_get_buf() get a pointer to a line in a specific buffer
! 58: * ml_line_alloced() return TRUE if line was allocated
! 59: * ml_append() append a new line
! 60: * ml_replace() replace a line
! 61: * ml_delete() delete a line
! 62: * ml_setmarked() set mark for a line (for :global command)
! 63: * ml_firstmarked() get first line with a mark (for :global command)
! 64: * ml_clearmarked() clear all line marks (for :global command)
! 65: */
! 66:
! 67: #if defined MSDOS || defined WIN32
! 68: # include <io.h>
! 69: #endif
! 70:
! 71: #include "vim.h"
! 72: #include "globals.h"
! 73: #include "proto.h"
! 74: #include "option.h"
! 75: #ifdef HAVE_FCNTL_H
! 76: # include <fcntl.h>
! 77: #endif
! 78: #ifndef UNIX /* it's in unix.h for Unix */
! 79: # include <time.h>
! 80: #endif
! 81:
! 82: #ifdef SASC
! 83: # include <proto/dos.h> /* for Open() and Close() */
! 84: #endif
! 85:
! 86: typedef struct block0 ZERO_BL; /* contents of the first block */
! 87: typedef struct pointer_block PTR_BL; /* contents of a pointer block */
! 88: typedef struct data_block DATA_BL; /* contents of a data block */
! 89: typedef struct pointer_entry PTR_EN; /* block/line-count pair */
! 90:
! 91: #define DATA_ID (('d' << 8) + 'a') /* data block id */
! 92: #define PTR_ID (('p' << 8) + 't') /* pointer block id */
! 93: #define BLOCK0_ID0 'b' /* block 0 id 0 */
! 94: #define BLOCK0_ID1 '0' /* block 0 id 1 */
! 95:
! 96: /*
! 97: * pointer to a block, used in a pointer block
! 98: */
! 99: struct pointer_entry
! 100: {
! 101: blocknr_t pe_bnum; /* block number */
! 102: linenr_t pe_line_count; /* number of lines in this branch */
! 103: linenr_t pe_old_lnum; /* lnum for this block (for recovery) */
! 104: int pe_page_count; /* number of pages in block pe_bnum */
! 105: };
! 106:
! 107: /*
! 108: * A pointer block contains a list of branches in the tree.
! 109: */
! 110: struct pointer_block
! 111: {
! 112: short_u pb_id; /* ID for pointer block: PTR_ID */
! 113: short_u pb_count; /* number of pointer in this block */
! 114: short_u pb_count_max; /* maximum value for pb_count */
! 115: PTR_EN pb_pointer[1]; /* list of pointers to blocks (actually longer)
! 116: * followed by empty space until end of page */
! 117: };
! 118:
! 119: /*
! 120: * A data block is a leaf in the tree.
! 121: *
! 122: * The text of the lines is at the end of the block. The text of the first line
! 123: * in the block is put at the end, the text of the second line in front of it,
! 124: * etc. Thus the order of the lines is the opposite of the line number.
! 125: */
! 126: struct data_block
! 127: {
! 128: short_u db_id; /* ID for data block: DATA_ID */
! 129: unsigned db_free; /* free space available */
! 130: unsigned db_txt_start; /* byte where text starts */
! 131: unsigned db_txt_end; /* byte just after data block */
! 132: linenr_t db_line_count; /* number of lines in this block */
! 133: unsigned db_index[1]; /* index for start of line (actually bigger)
! 134: * followed by empty space upto db_txt_start
! 135: * followed by the text in the lines until
! 136: * end of page */
! 137: };
! 138:
! 139: /*
! 140: * The low bits of db_index hold the actual index. The topmost bit is
! 141: * used for the global command to be able to mark a line.
! 142: * This method is not clean, but otherwise there would be at least one extra
! 143: * byte used for each line.
! 144: * The mark has to be in this place to keep it with the correct line when other
! 145: * lines are inserted or deleted.
! 146: */
! 147: #define DB_MARKED ((unsigned)1 << ((sizeof(unsigned) * 8) - 1))
! 148: #define DB_INDEX_MASK (~DB_MARKED)
! 149:
! 150: #define INDEX_SIZE (sizeof(unsigned)) /* size of one db_index entry */
! 151: #define HEADER_SIZE (sizeof(DATA_BL) - INDEX_SIZE) /* size of data block header */
! 152:
! 153: #define B0_FNAME_SIZE 900
! 154: #define B0_UNAME_SIZE 40
! 155: #define B0_HNAME_SIZE 40
! 156: /*
! 157: * Restrict the numbers to 32 bits, otherwise most compilers will complain.
! 158: * This won't detect a 64 bit machine that only swaps a byte in the top 32
! 159: * bits, but that is crazy anyway.
! 160: */
! 161: #define B0_MAGIC_LONG 0x30313233
! 162: #define B0_MAGIC_INT 0x20212223
! 163: #define B0_MAGIC_SHORT 0x10111213
! 164: #define B0_MAGIC_CHAR 0x55
! 165:
! 166: /*
! 167: * Block zero holds all info about the swap file.
! 168: *
! 169: * NOTE: DEFINITION OF BLOCK 0 SHOULD NOT CHANGE, it makes all existing swap
! 170: * files unusable!
! 171: *
! 172: * If size of block0 changes anyway, adjust minimal block size
! 173: * in mf_open()!!
! 174: *
! 175: * This block is built up of single bytes, to make it portable accros
! 176: * different machines. b0_magic_* is used to check the byte order and size of
! 177: * variables, because the rest of the swap is not portable.
! 178: */
! 179: struct block0
! 180: {
! 181: char_u b0_id[2]; /* id for block 0: BLOCK0_ID0 and BLOCK0_ID1 */
! 182: char_u b0_version[10]; /* Vim version string */
! 183: char_u b0_page_size[4];/* number of bytes per page */
! 184: char_u b0_mtime[4]; /* last modification time of file */
! 185: char_u b0_ino[4]; /* inode of b0_fname */
! 186: char_u b0_pid[4]; /* process id of creator (or 0) */
! 187: char_u b0_uname[B0_UNAME_SIZE]; /* name of user (uid if no name) */
! 188: char_u b0_hname[B0_HNAME_SIZE]; /* host name (if it has a name) */
! 189: char_u b0_fname[B0_FNAME_SIZE]; /* name of file being edited */
! 190: long b0_magic_long; /* check for byte order of long */
! 191: int b0_magic_int; /* check for byte order of int */
! 192: short b0_magic_short; /* check for byte order of short */
! 193: char_u b0_magic_char; /* check for last char */
! 194: };
! 195:
! 196: #define STACK_INCR 5 /* nr of entries added to ml_stack at a time */
! 197:
! 198: /*
! 199: * The line number where the first mark may be is remembered.
! 200: * If it is 0 there are no marks at all.
! 201: * (always used for the current buffer only, no buffer change possible while
! 202: * executing a global command).
! 203: */
! 204: static linenr_t lowest_marked = 0;
! 205:
! 206: /*
! 207: * arguments for ml_find_line()
! 208: */
! 209: #define ML_DELETE 0x11 /* delete line */
! 210: #define ML_INSERT 0x12 /* insert line */
! 211: #define ML_FIND 0x13 /* just find the line */
! 212: #define ML_FLUSH 0x02 /* flush locked block */
! 213: #define ML_SIMPLE(x) (x & 0x10) /* DEL, INS or FIND */
! 214:
! 215: static void ml_open_file __ARGS((BUF *));
! 216: static void set_b0_fname __ARGS((ZERO_BL *, BUF *buf));
! 217: static void swapfile_info __ARGS((char_u *));
! 218: static int get_names __ARGS((char_u **, char_u *));
! 219: static int ml_append_int __ARGS((BUF *, linenr_t, char_u *, colnr_t, int));
! 220: static int ml_delete_int __ARGS((BUF *, linenr_t, int));
! 221: static char_u *findswapname __ARGS((BUF *, char_u **, char_u *));
! 222: static void ml_flush_line __ARGS((BUF *));
! 223: static BHDR *ml_new_data __ARGS((MEMFILE *, int, int));
! 224: static BHDR *ml_new_ptr __ARGS((MEMFILE *));
! 225: static BHDR *ml_find_line __ARGS((BUF *, linenr_t, int));
! 226: static int ml_add_stack __ARGS((BUF *));
! 227: static char_u *makeswapname __ARGS((BUF *, char_u *));
! 228: static void ml_lineadd __ARGS((BUF *, int));
! 229: static int b0_magic_wrong __ARGS((ZERO_BL *));
! 230: #ifdef CHECK_INODE
! 231: static int fnamecmp_ino __ARGS((char_u *, char_u *, long));
! 232: #endif
! 233: static void long_to_char __ARGS((long, char_u *));
! 234: static long char_to_long __ARGS((char_u *));
! 235:
! 236: /*
! 237: * open a new memline for 'curbuf'
! 238: *
! 239: * return FAIL for failure, OK otherwise
! 240: */
! 241: int
! 242: ml_open()
! 243: {
! 244: MEMFILE *mfp;
! 245: char_u *fname;
! 246: BHDR *hp = NULL;
! 247: ZERO_BL *b0p;
! 248: PTR_BL *pp;
! 249: DATA_BL *dp;
! 250: char_u *dirp;
! 251:
! 252: /*
! 253: * init fields in memline struct
! 254: */
! 255: curbuf->b_ml.ml_stack_size = 0; /* no stack yet */
! 256: curbuf->b_ml.ml_stack = NULL; /* no stack yet */
! 257: curbuf->b_ml.ml_stack_top = 0; /* nothing in the stack */
! 258: curbuf->b_ml.ml_locked = NULL; /* no cached block */
! 259: curbuf->b_ml.ml_line_lnum = 0; /* no cached line */
! 260:
! 261: /*
! 262: * Make file name for swap file.
! 263: * If we are unable to find a file name, mf_fname will be NULL
! 264: * and the memfile will be in memory only (no recovery possible).
! 265: * When 'updatecount' is 0 and for help files on Unix there is never a swap
! 266: * file.
! 267: */
! 268: #if defined(UNIX) || defined(__EMX__)
! 269: /* why only on Unix an exception for help files??? */
! 270: if (p_uc == 0 || curbuf->b_help)
! 271: #else
! 272: if (p_uc == 0)
! 273: #endif
! 274: dirp = (char_u *)"";
! 275: else
! 276: dirp = p_dir;
! 277:
! 278: /*
! 279: * Open the memfile.
! 280: *
! 281: * If no swap file is wanted *dirp will be NUL, try with fname == NULL.
! 282: * Otherwise try all directories in 'directory' option. If that fails try
! 283: * with fname == NULL.
! 284: */
! 285: for (;;)
! 286: {
! 287: if (*dirp == NUL)
! 288: fname = NULL;
! 289: else
! 290: {
! 291: fname = findswapname(curbuf, &dirp, NULL);
! 292: if (fname == NULL)
! 293: continue;
! 294: }
! 295: mfp = mf_open(fname, TRUE);
! 296: /* stop when memfile opened or no other fname to try */
! 297: if (mfp != NULL || (fname == NULL && *dirp == NUL))
! 298: break;
! 299: vim_free(fname);
! 300: }
! 301:
! 302: if (mfp == NULL)
! 303: goto error;
! 304: curbuf->b_ml.ml_mfp = mfp;
! 305: curbuf->b_ml.ml_flags = ML_EMPTY;
! 306: curbuf->b_ml.ml_line_count = 1;
! 307:
! 308: if (!(p_uc == 0 || curbuf->b_help) && mfp->mf_fname == NULL)
! 309: {
! 310: need_wait_return = TRUE; /* call wait_return later */
! 311: ++no_wait_return;
! 312: (void)EMSG("Unable to open swap file, recovery impossible");
! 313: --no_wait_return;
! 314: }
! 315: #if defined(MSDOS) || defined(WIN32)
! 316: /*
! 317: * set full pathname for swap file now, because a ":!cd dir" may
! 318: * change directory without us knowing it.
! 319: */
! 320: mf_fullname(mfp);
! 321: #endif
! 322:
! 323: /*
! 324: * fill block0 struct and write page 0
! 325: */
! 326: if ((hp = mf_new(mfp, FALSE, 1)) == NULL)
! 327: goto error;
! 328: if (hp->bh_bnum != 0)
! 329: {
! 330: EMSG("didn't get block nr 0?");
! 331: goto error;
! 332: }
! 333: b0p = (ZERO_BL *)(hp->bh_data);
! 334:
! 335: (void)vim_memset(b0p, 0, sizeof(ZERO_BL)); /* init all to zero */
! 336:
! 337: b0p->b0_id[0] = BLOCK0_ID0;
! 338: b0p->b0_id[1] = BLOCK0_ID1;
! 339: b0p->b0_magic_long = (long)B0_MAGIC_LONG;
! 340: b0p->b0_magic_int = (int)B0_MAGIC_INT;
! 341: b0p->b0_magic_short = (short)B0_MAGIC_SHORT;
! 342: b0p->b0_magic_char = B0_MAGIC_CHAR;
! 343:
! 344: STRNCPY(b0p->b0_version, Version, 10);
! 345: set_b0_fname(b0p, curbuf);
! 346: long_to_char((long)mfp->mf_page_size, b0p->b0_page_size);
! 347: (void)mch_get_user_name(b0p->b0_uname, B0_UNAME_SIZE);
! 348: b0p->b0_uname[B0_UNAME_SIZE - 1] = NUL;
! 349: mch_get_host_name(b0p->b0_hname, B0_HNAME_SIZE);
! 350: b0p->b0_hname[B0_HNAME_SIZE - 1] = NUL;
! 351: long_to_char(mch_get_pid(), b0p->b0_pid);
! 352:
! 353: /*
! 354: * Always sync block number 0 to disk, so we can check the file name in
! 355: * the swap file in findswapname(). Don't do this for help files though.
! 356: */
! 357: mf_put(mfp, hp, TRUE, FALSE);
! 358: if (!curbuf->b_help)
! 359: mf_sync(mfp, FALSE, FALSE, FALSE);
! 360:
! 361: /*
! 362: * fill in root pointer block and write page 1
! 363: */
! 364: if ((hp = ml_new_ptr(mfp)) == NULL)
! 365: goto error;
! 366: if (hp->bh_bnum != 1)
! 367: {
! 368: EMSG("didn't get block nr 1?");
! 369: goto error;
! 370: }
! 371: pp = (PTR_BL *)(hp->bh_data);
! 372: pp->pb_count = 1;
! 373: pp->pb_pointer[0].pe_bnum = 2;
! 374: pp->pb_pointer[0].pe_page_count = 1;
! 375: pp->pb_pointer[0].pe_old_lnum = 1;
! 376: pp->pb_pointer[0].pe_line_count = 1; /* line count after insertion */
! 377: mf_put(mfp, hp, TRUE, FALSE);
! 378:
! 379: /*
! 380: * allocate first data block and create an empty line 1.
! 381: */
! 382: if ((hp = ml_new_data(mfp, FALSE, 1)) == NULL)
! 383: goto error;
! 384: if (hp->bh_bnum != 2)
! 385: {
! 386: EMSG("didn't get block nr 2?");
! 387: goto error;
! 388: }
! 389:
! 390: dp = (DATA_BL *)(hp->bh_data);
! 391: dp->db_index[0] = --dp->db_txt_start; /* at end of block */
! 392: dp->db_free -= 1 + INDEX_SIZE;
! 393: dp->db_line_count = 1;
! 394: *((char_u *)dp + dp->db_txt_start) = NUL; /* emtpy line */
! 395:
! 396: return OK;
! 397:
! 398: error:
! 399: if (mfp != NULL)
! 400: {
! 401: if (hp)
! 402: mf_put(mfp, hp, FALSE, FALSE);
! 403: mf_close(mfp, TRUE); /* will also free(mfp->mf_fname) */
! 404: }
! 405: else
! 406: vim_free(fname);
! 407: curbuf->b_ml.ml_mfp = NULL;
! 408: return FAIL;
! 409: }
! 410:
! 411: /*
! 412: * ml_setname() is called when the file name has been changed.
! 413: * It may rename the swap file.
! 414: */
! 415: void
! 416: ml_setname()
! 417: {
! 418: int success = FALSE;
! 419: MEMFILE *mfp;
! 420: char_u *fname;
! 421: char_u *dirp;
! 422:
! 423: /*
! 424: * When 'updatecount' is 0 there is never a swap file.
! 425: * For help files we will make a swap file now.
! 426: */
! 427: if (p_uc == 0)
! 428: return;
! 429:
! 430: mfp = curbuf->b_ml.ml_mfp;
! 431: if (mfp->mf_fd < 0) /* there is no swap file yet */
! 432: {
! 433: ml_open_file(curbuf); /* create a swap file */
! 434: return;
! 435: }
! 436:
! 437: /*
! 438: * Try all directories in the 'directory' option.
! 439: */
! 440: dirp = p_dir;
! 441: for (;;)
! 442: {
! 443: if (*dirp == NUL) /* tried all directories, fail */
! 444: break;
! 445: fname = findswapname(curbuf, &dirp, mfp->mf_fname);
! 446: if (fname == NULL) /* no file name found for this dir */
! 447: continue;
! 448:
! 449: #if defined(MSDOS) || defined(WIN32)
! 450: /*
! 451: * Set full pathname for swap file now, because a ":!cd dir" may
! 452: * change directory without us knowing it.
! 453: */
! 454: if (!did_cd)
! 455: {
! 456: char_u *p;
! 457:
! 458: p = FullName_save(fname);
! 459: vim_free(fname);
! 460: fname = p;
! 461: if (fname == NULL)
! 462: continue;
! 463: }
! 464: #endif
! 465: /* if the file name is the same we don't have to do anything */
! 466: if (fnamecmp(fname, mfp->mf_fname) == 0)
! 467: {
! 468: vim_free(fname);
! 469: success = TRUE;
! 470: break;
! 471: }
! 472: /* need to close the swap file before renaming */
! 473: if (mfp->mf_fd >= 0)
! 474: {
! 475: close(mfp->mf_fd);
! 476: mfp->mf_fd = -1;
! 477: }
! 478:
! 479: /* try to rename the swap file */
! 480: if (vim_rename(mfp->mf_fname, fname) == 0)
! 481: {
! 482: success = TRUE;
! 483: vim_free(mfp->mf_fname);
! 484: mfp->mf_fname = fname;
! 485: vim_free(mfp->mf_xfname);
! 486: mf_set_xfname(mfp);
! 487: break;
! 488: }
! 489: vim_free(fname); /* this fname didn't work, try another */
! 490: }
! 491:
! 492: if (mfp->mf_fd == -1) /* need to (re)open the swap file */
! 493: {
! 494: mfp->mf_fd = open((char *)mfp->mf_fname, O_RDWR | O_EXTRA);
! 495: if (mfp->mf_fd < 0)
! 496: {
! 497: /* could not (re)open the swap file, what can we do???? */
! 498: EMSG("Oops, lost the swap file!!!");
! 499: return;
! 500: }
! 501: }
! 502: if (!success)
! 503: EMSG("Could not rename swap file");
! 504: }
! 505:
! 506: /*
! 507: * Open a file for the memfile for all buffers.
! 508: * Used when 'updatecount' changes from zero to non-zero.
! 509: */
! 510: void
! 511: ml_open_files()
! 512: {
! 513: BUF *buf;
! 514:
! 515: for (buf = firstbuf; buf != NULL; buf = buf->b_next)
! 516: ml_open_file(buf);
! 517: }
! 518:
! 519: /*
! 520: * Open a swap file for an existing memfile, if there is non swap file yet.
! 521: */
! 522: static void
! 523: ml_open_file(buf)
! 524: BUF *buf;
! 525: {
! 526: MEMFILE *mfp;
! 527: char_u *fname;
! 528: char_u *dirp;
! 529:
! 530: mfp = buf->b_ml.ml_mfp;
! 531: if (mfp == NULL || mfp->mf_fd >= 0) /* nothing to do */
! 532: return;
! 533:
! 534: dirp = p_dir;
! 535: /*
! 536: * Try all directories in 'directory' option.
! 537: */
! 538: for (;;)
! 539: {
! 540: if (*dirp == NUL)
! 541: break;
! 542: fname = findswapname(buf, &dirp, NULL);
! 543: if (fname == NULL)
! 544: continue;
! 545: if (mf_open_file(mfp, fname) == OK)
! 546: break;
! 547: vim_free(fname);
! 548: }
! 549:
! 550: if (mfp->mf_fname == NULL) /* Failed! */
! 551: {
! 552: need_wait_return = TRUE; /* call wait_return later */
! 553: ++no_wait_return;
! 554: (void)EMSG2("Unable to open swap file for \"%s\", recovery impossible",
! 555: buf->b_xfilename == NULL ? (char_u *)"No File"
! 556: : buf->b_xfilename);
! 557: --no_wait_return;
! 558: }
! 559: #if defined(MSDOS) || defined(WIN32)
! 560: /*
! 561: * set full pathname for swap file now, because a ":!cd dir" may
! 562: * change directory without us knowing it.
! 563: */
! 564: else
! 565: mf_fullname(mfp);
! 566: #endif
! 567: }
! 568:
! 569: /*
! 570: * Close memline for buffer 'buf'.
! 571: * If 'del_file' is TRUE, delete the swap file
! 572: */
! 573: void
! 574: ml_close(buf, del_file)
! 575: BUF *buf;
! 576: int del_file;
! 577: {
! 578: if (buf->b_ml.ml_mfp == NULL) /* not open */
! 579: return;
! 580: mf_close(buf->b_ml.ml_mfp, del_file); /* close the .swp file */
! 581: if (buf->b_ml.ml_line_lnum != 0 && (buf->b_ml.ml_flags & ML_LINE_DIRTY))
! 582: vim_free(buf->b_ml.ml_line_ptr);
! 583: vim_free(buf->b_ml.ml_stack);
! 584: buf->b_ml.ml_mfp = NULL;
! 585: }
! 586:
! 587: /*
! 588: * Close all existing memlines and memfiles.
! 589: * Used when exiting.
! 590: * When 'del_file' is TRUE, delete the memfiles.
! 591: */
! 592: void
! 593: ml_close_all(del_file)
! 594: int del_file;
! 595: {
! 596: BUF *buf;
! 597:
! 598: for (buf = firstbuf; buf != NULL; buf = buf->b_next)
! 599: ml_close(buf, del_file);
! 600: }
! 601:
! 602: /*
! 603: * Close all memfiles for not modified buffers.
! 604: * Only use just before exiting!
! 605: */
! 606: void
! 607: ml_close_notmod()
! 608: {
! 609: BUF *buf;
! 610:
! 611: for (buf = firstbuf; buf != NULL; buf = buf->b_next)
! 612: if (!buf->b_changed)
! 613: ml_close(buf, TRUE); /* close all not-modified buffers */
! 614: }
! 615:
! 616: /*
! 617: * Update the timestamp in the .swp file.
! 618: * Used when the file has been written.
! 619: */
! 620: void
! 621: ml_timestamp(buf)
! 622: BUF *buf;
! 623: {
! 624: MEMFILE *mfp;
! 625: BHDR *hp;
! 626: ZERO_BL *b0p;
! 627:
! 628: mfp = buf->b_ml.ml_mfp;
! 629:
! 630: if (mfp == NULL || (hp = mf_get(mfp, (blocknr_t)0, 1)) == NULL)
! 631: return;
! 632: b0p = (ZERO_BL *)(hp->bh_data);
! 633: if (b0p->b0_id[0] != BLOCK0_ID0 || b0p->b0_id[1] != BLOCK0_ID1)
! 634: EMSG("ml_timestamp: Didn't get block 0??");
! 635: else
! 636: set_b0_fname(b0p, buf);
! 637: mf_put(mfp, hp, TRUE, FALSE);
! 638: }
! 639:
! 640: /*
! 641: * Write file name and timestamp into block 0 of a swap file.
! 642: * Also set buf->b_mtime.
! 643: * Don't use NameBuff[]!!!
! 644: */
! 645: static void
! 646: set_b0_fname(b0p, buf)
! 647: ZERO_BL *b0p;
! 648: BUF *buf;
! 649: {
! 650: struct stat st;
! 651: size_t flen, ulen;
! 652: char_u uname[B0_UNAME_SIZE];
! 653:
! 654: if (buf->b_filename == NULL)
! 655: b0p->b0_fname[0] = NUL;
! 656: else
! 657: {
! 658: /*
! 659: * For a file under the home directory of the current user, we try to
! 660: * replace the home directory path with "~user". This helps when
! 661: * editing the same file on different machines over a network.
! 662: * First replace home dir path with "~/" with home_replace().
! 663: * Then insert the user name to get "~user/".
! 664: */
! 665: home_replace(NULL, buf->b_filename, b0p->b0_fname, B0_FNAME_SIZE);
! 666: if (b0p->b0_fname[0] == '~')
! 667: {
! 668: flen = STRLEN(b0p->b0_fname);
! 669: /* If there is no user name or it is too long, don't use "~/" */
! 670: if (mch_get_user_name(uname, B0_UNAME_SIZE) == FAIL ||
! 671: (ulen = STRLEN(uname)) + flen > B0_FNAME_SIZE - 1)
! 672: STRNCPY(b0p->b0_fname, buf->b_filename, B0_FNAME_SIZE);
! 673: else
! 674: {
! 675: vim_memmove(b0p->b0_fname + ulen + 1, b0p->b0_fname + 1, flen);
! 676: vim_memmove(b0p->b0_fname + 1, uname, ulen);
! 677: }
! 678: }
! 679: if (stat((char *)buf->b_filename, &st) >= 0)
! 680: {
! 681: long_to_char((long)st.st_mtime, b0p->b0_mtime);
! 682: #ifdef CHECK_INODE
! 683: long_to_char((long)st.st_ino, b0p->b0_ino);
! 684: #endif
! 685: buf->b_mtime = st.st_mtime;
! 686: buf->b_mtime_read = st.st_mtime;
! 687: }
! 688: else
! 689: {
! 690: long_to_char(0L, b0p->b0_mtime);
! 691: #ifdef CHECK_INODE
! 692: long_to_char(0L, b0p->b0_ino);
! 693: #endif
! 694: buf->b_mtime = 0;
! 695: buf->b_mtime_read = 0;
! 696: }
! 697: }
! 698: }
! 699:
! 700: /*
! 701: * try to recover curbuf from the .swp file
! 702: */
! 703: void
! 704: ml_recover()
! 705: {
! 706: BUF *buf = NULL;
! 707: MEMFILE *mfp = NULL;
! 708: char_u *fname;
! 709: BHDR *hp = NULL;
! 710: ZERO_BL *b0p;
! 711: PTR_BL *pp;
! 712: DATA_BL *dp;
! 713: IPTR *ip;
! 714: blocknr_t bnum;
! 715: int page_count;
! 716: struct stat org_stat, swp_stat;
! 717: int len;
! 718: int directly;
! 719: linenr_t lnum;
! 720: char_u *p;
! 721: int i;
! 722: long error;
! 723: int cannot_open;
! 724: linenr_t line_count;
! 725: int has_error;
! 726: int idx;
! 727: int top;
! 728: int txt_start;
! 729: long size;
! 730: int called_from_main;
! 731: int serious_error = TRUE;
! 732: long mtime;
! 733:
! 734: called_from_main = (curbuf->b_ml.ml_mfp == NULL);
! 735: /*
! 736: * If the file name ends in ".sw?" we use it directly.
! 737: * Otherwise a search is done to find the swap file(s).
! 738: */
! 739: fname = curbuf->b_xfilename;
! 740: if (fname == NULL) /* When there is no file name */
! 741: fname = (char_u *)"";
! 742: len = STRLEN(fname);
! 743: if (len >= 4 && vim_strnicmp(fname + len - 4,
! 744: (char_u *)".sw", (size_t)3) == 0)
! 745: {
! 746: directly = TRUE;
! 747: fname = strsave(fname); /* make a copy for mf_open */
! 748: }
! 749: else
! 750: {
! 751: directly = FALSE;
! 752:
! 753: /* count the number of matching swap files */
! 754: len = recover_names(&fname, FALSE, 0);
! 755: if (len == 0) /* no swap files found */
! 756: {
! 757: EMSG2("No swap file found for %s", fname);
! 758: fname = NULL;
! 759: goto theend;
! 760: }
! 761: if (len == 1) /* one swap file found, use it */
! 762: i = 1;
! 763: else /* several swap files found, choose */
! 764: {
! 765: /* list the names of the swap files */
! 766: (void)recover_names(&fname, TRUE, 0);
! 767: msg_outchar('\n');
! 768: MSG_OUTSTR("Enter number of swap file to use (0 to quit): ");
! 769: i = get_number();
! 770: if (i < 1 || i > len)
! 771: {
! 772: fname = NULL;
! 773: goto theend;
! 774: }
! 775: }
! 776: /* get the swap file name that will be used */
! 777: (void)recover_names(&fname, FALSE, i);
! 778: }
! 779: if (fname == NULL)
! 780: goto theend; /* out of memory */
! 781:
! 782: /* When called from main() still need to initialize storage structure */
! 783: if (called_from_main && ml_open() == FAIL)
! 784: getout(1);
! 785:
! 786: /*
! 787: * allocate a buffer structure (only the memline in it is really used)
! 788: */
! 789: buf = (BUF *)alloc((unsigned)sizeof(BUF));
! 790: if (buf == NULL)
! 791: goto theend;
! 792:
! 793: /*
! 794: * init fields in memline struct
! 795: */
! 796: buf->b_ml.ml_stack_size = 0; /* no stack yet */
! 797: buf->b_ml.ml_stack = NULL; /* no stack yet */
! 798: buf->b_ml.ml_stack_top = 0; /* nothing in the stack */
! 799: buf->b_ml.ml_line_lnum = 0; /* no cached line */
! 800: buf->b_ml.ml_locked = NULL; /* no locked block */
! 801: buf->b_ml.ml_flags = 0;
! 802:
! 803: /*
! 804: * open the memfile from the old swap file
! 805: */
! 806: mfp = mf_open(fname, FALSE);
! 807: if (mfp == NULL || mfp->mf_fd < 0)
! 808: {
! 809: EMSG2("Cannot open %s", fname);
! 810: goto theend;
! 811: }
! 812: buf->b_ml.ml_mfp = mfp;
! 813: #if defined(MSDOS) || defined(WIN32)
! 814: /*
! 815: * set full pathname for swap file now, because a ":!cd dir" may
! 816: * change directory without us knowing it.
! 817: * Careful: May free fname!
! 818: */
! 819: mf_fullname(mfp);
! 820: #endif
! 821:
! 822: /*
! 823: * try to read block 0
! 824: */
! 825: if ((hp = mf_get(mfp, (blocknr_t)0, 1)) == NULL)
! 826: {
! 827: msg_start();
! 828: MSG_OUTSTR("Unable to read block 0 from ");
! 829: msg_outtrans(mfp->mf_fname);
! 830: MSG_OUTSTR("\nMaybe no changes were made or Vim did not update the swap file");
! 831: msg_end();
! 832: goto theend;
! 833: }
! 834: b0p = (ZERO_BL *)(hp->bh_data);
! 835: if (b0p->b0_id[0] != BLOCK0_ID0 || b0p->b0_id[1] != BLOCK0_ID1)
! 836: {
! 837: EMSG2("%s is not a swap file", mfp->mf_fname);
! 838: goto theend;
! 839: }
! 840: if (b0_magic_wrong(b0p))
! 841: {
! 842: msg_start();
! 843: MSG_OUTSTR("The file ");
! 844: msg_outtrans(mfp->mf_fname);
! 845: #if defined(MSDOS) || defined(WIN32)
! 846: if (STRNCMP(b0p->b0_hname, "PC ", 3) == 0)
! 847: MSG_OUTSTR(" cannot be used with this version of Vim.\n");
! 848: else
! 849: #endif
! 850: MSG_OUTSTR(" cannot be used on this computer.\n");
! 851: MSG_OUTSTR("The file was created on ");
! 852: /* avoid going past the end of currupted hostname */
! 853: b0p->b0_fname[0] = NUL;
! 854: MSG_OUTSTR(b0p->b0_hname);
! 855: MSG_OUTSTR(",\nor the file has been damaged.");
! 856: msg_end();
! 857: goto theend;
! 858: }
! 859: /*
! 860: * If we guessed the wrong page size, we have to recalculate the
! 861: * highest block number in the file.
! 862: */
! 863: if (mfp->mf_page_size != (unsigned)char_to_long(b0p->b0_page_size))
! 864: {
! 865: mfp->mf_page_size = (unsigned)char_to_long(b0p->b0_page_size);
! 866: if ((size = lseek(mfp->mf_fd, 0L, SEEK_END)) <= 0)
! 867: mfp->mf_blocknr_max = 0; /* no file or empty file */
! 868: else
! 869: mfp->mf_blocknr_max = size / mfp->mf_page_size;
! 870: mfp->mf_infile_count = mfp->mf_blocknr_max;
! 871: }
! 872:
! 873: /*
! 874: * If .swp file name given directly, use name from swap file for buffer.
! 875: */
! 876: if (directly)
! 877: {
! 878: expand_env(b0p->b0_fname, NameBuff, MAXPATHL);
! 879: if (setfname(NameBuff, NULL, TRUE) == FAIL)
! 880: goto theend;
! 881: }
! 882:
! 883: home_replace(NULL, mfp->mf_fname, NameBuff, MAXPATHL);
! 884: smsg((char_u *)"Using swap file \"%s\"", NameBuff);
! 885:
! 886: if (curbuf->b_filename == NULL)
! 887: STRCPY(NameBuff, "No File");
! 888: else
! 889: home_replace(NULL, curbuf->b_filename, NameBuff, MAXPATHL);
! 890: smsg((char_u *)"Original file \"%s\"", NameBuff);
! 891: msg_outchar((char_u)'\n');
! 892:
! 893: /*
! 894: * check date of swap file and original file
! 895: */
! 896: mtime = char_to_long(b0p->b0_mtime);
! 897: if (curbuf->b_filename != NULL &&
! 898: stat((char *)curbuf->b_filename, &org_stat) != -1 &&
! 899: ((stat((char *)mfp->mf_fname, &swp_stat) != -1 &&
! 900: org_stat.st_mtime > swp_stat.st_mtime) ||
! 901: org_stat.st_mtime != mtime))
! 902: {
! 903: EMSG("Warning: Original file may have been changed");
! 904: }
! 905: flushbuf();
! 906: mf_put(mfp, hp, FALSE, FALSE); /* release block 0 */
! 907: hp = NULL;
! 908:
! 909: /*
! 910: * Now that we are sure that the file is going to be recovered, clear the
! 911: * contents of the current buffer.
! 912: */
! 913: while (!(curbuf->b_ml.ml_flags & ML_EMPTY))
! 914: ml_delete((linenr_t)1, FALSE);
! 915:
! 916: bnum = 1; /* start with block 1 */
! 917: page_count = 1; /* which is 1 page */
! 918: lnum = 0; /* append after line 0 in curbuf */
! 919: line_count = 0;
! 920: idx = 0; /* start with first index in block 1 */
! 921: error = 0;
! 922: buf->b_ml.ml_stack_top = 0;
! 923: buf->b_ml.ml_stack = NULL;
! 924: buf->b_ml.ml_stack_size = 0; /* no stack yet */
! 925:
! 926: if (curbuf->b_filename == NULL)
! 927: cannot_open = TRUE;
! 928: else
! 929: cannot_open = FALSE;
! 930:
! 931: serious_error = FALSE;
! 932: for ( ; !got_int; line_breakcheck())
! 933: {
! 934: if (hp != NULL)
! 935: mf_put(mfp, hp, FALSE, FALSE); /* release previous block */
! 936:
! 937: /*
! 938: * get block
! 939: */
! 940: if ((hp = mf_get(mfp, (blocknr_t)bnum, page_count)) == NULL)
! 941: {
! 942: if (bnum == 1)
! 943: {
! 944: EMSG2("Unable to read block 1 from %s", mfp->mf_fname);
! 945: goto theend;
! 946: }
! 947: ++error;
! 948: ml_append(lnum++, (char_u *)"???MANY LINES MISSING", (colnr_t)0, TRUE);
! 949: }
! 950: else /* there is a block */
! 951: {
! 952: pp = (PTR_BL *)(hp->bh_data);
! 953: if (pp->pb_id == PTR_ID) /* it is a pointer block */
! 954: {
! 955: /* check line count when using pointer block first time */
! 956: if (idx == 0 && line_count != 0)
! 957: {
! 958: for (i = 0; i < (int)pp->pb_count; ++i)
! 959: line_count -= pp->pb_pointer[i].pe_line_count;
! 960: if (line_count != 0)
! 961: {
! 962: ++error;
! 963: ml_append(lnum++, (char_u *)"???LINE COUNT WRONG", (colnr_t)0, TRUE);
! 964: }
! 965: }
! 966:
! 967: if (pp->pb_count == 0)
! 968: {
! 969: ml_append(lnum++, (char_u *)"???EMPTY BLOCK", (colnr_t)0, TRUE);
! 970: ++error;
! 971: }
! 972: else if (idx < (int)pp->pb_count) /* go a block deeper */
! 973: {
! 974: if (pp->pb_pointer[idx].pe_bnum < 0)
! 975: {
! 976: /*
! 977: * Data block with negative block number.
! 978: * Try to read lines from the original file.
! 979: * This is slow, but it works.
! 980: */
! 981: if (!cannot_open)
! 982: {
! 983: line_count = pp->pb_pointer[idx].pe_line_count;
! 984: if (readfile(curbuf->b_filename, NULL, lnum, FALSE,
! 985: pp->pb_pointer[idx].pe_old_lnum - 1,
! 986: line_count, FALSE) == FAIL)
! 987: cannot_open = TRUE;
! 988: else
! 989: lnum += line_count;
! 990: }
! 991: if (cannot_open)
! 992: {
! 993: ++error;
! 994: ml_append(lnum++, (char_u *)"???LINES MISSING", (colnr_t)0, TRUE);
! 995: }
! 996: ++idx; /* get same block again for next index */
! 997: continue;
! 998: }
! 999:
! 1000: /*
! 1001: * going one block deeper in the tree
! 1002: */
! 1003: if ((top = ml_add_stack(buf)) < 0) /* new entry in stack */
! 1004: {
! 1005: ++error;
! 1006: break; /* out of memory */
! 1007: }
! 1008: ip = &(buf->b_ml.ml_stack[top]);
! 1009: ip->ip_bnum = bnum;
! 1010: ip->ip_index = idx;
! 1011:
! 1012: bnum = pp->pb_pointer[idx].pe_bnum;
! 1013: line_count = pp->pb_pointer[idx].pe_line_count;
! 1014: page_count = pp->pb_pointer[idx].pe_page_count;
! 1015: continue;
! 1016: }
! 1017: }
! 1018: else /* not a pointer block */
! 1019: {
! 1020: dp = (DATA_BL *)(hp->bh_data);
! 1021: if (dp->db_id != DATA_ID) /* block id wrong */
! 1022: {
! 1023: if (bnum == 1)
! 1024: {
! 1025: EMSG2("Block 1 ID wrong (%s not a .swp file?)",
! 1026: mfp->mf_fname);
! 1027: goto theend;
! 1028: }
! 1029: ++error;
! 1030: ml_append(lnum++, (char_u *)"???BLOCK MISSING", (colnr_t)0, TRUE);
! 1031: }
! 1032: else
! 1033: {
! 1034: /*
! 1035: * it is a data block
! 1036: * Append all the lines in this block
! 1037: */
! 1038: has_error = FALSE;
! 1039: /*
! 1040: * check length of block
! 1041: * if wrong, use length in pointer block
! 1042: */
! 1043: if (page_count * mfp->mf_page_size != dp->db_txt_end)
! 1044: {
! 1045: ml_append(lnum++, (char_u *)"??? from here until ???END lines may be messed up", (colnr_t)0, TRUE);
! 1046: ++error;
! 1047: has_error = TRUE;
! 1048: dp->db_txt_end = page_count * mfp->mf_page_size;
! 1049: }
! 1050:
! 1051: /* make sure there is a NUL at the end of the block */
! 1052: *((char_u *)dp + dp->db_txt_end - 1) = NUL;
! 1053:
! 1054: /*
! 1055: * check number of lines in block
! 1056: * if wrong, use count in data block
! 1057: */
! 1058: if (line_count != dp->db_line_count)
! 1059: {
! 1060: ml_append(lnum++, (char_u *)"??? from here until ???END lines may have been inserted/deleted", (colnr_t)0, TRUE);
! 1061: ++error;
! 1062: has_error = TRUE;
! 1063: }
! 1064:
! 1065: for (i = 0; i < dp->db_line_count; ++i)
! 1066: {
! 1067: txt_start = (dp->db_index[i] & DB_INDEX_MASK);
! 1068: if (txt_start <= HEADER_SIZE || txt_start >= (int)dp->db_txt_end)
! 1069: {
! 1070: p = (char_u *)"???";
! 1071: ++error;
! 1072: }
! 1073: else
! 1074: p = (char_u *)dp + txt_start;
! 1075: ml_append(lnum++, p, (colnr_t)0, TRUE);
! 1076: }
! 1077: if (has_error)
! 1078: ml_append(lnum++, (char_u *)"???END", (colnr_t)0, TRUE);
! 1079: }
! 1080: }
! 1081: }
! 1082:
! 1083: if (buf->b_ml.ml_stack_top == 0) /* finished */
! 1084: break;
! 1085:
! 1086: /*
! 1087: * go one block up in the tree
! 1088: */
! 1089: ip = &(buf->b_ml.ml_stack[--(buf->b_ml.ml_stack_top)]);
! 1090: bnum = ip->ip_bnum;
! 1091: idx = ip->ip_index + 1; /* go to next index */
! 1092: page_count = 1;
! 1093: }
! 1094:
! 1095: /*
! 1096: * The dummy line from the empty buffer will now be after the last line in
! 1097: * the buffer. Delete it.
! 1098: */
! 1099: ml_delete(curbuf->b_ml.ml_line_count, FALSE);
! 1100:
! 1101: recoverymode = FALSE;
! 1102: if (got_int)
! 1103: EMSG("Recovery Interrupted");
! 1104: else if (error)
! 1105: EMSG("Errors detected while recovering; look for lines starting with ???");
! 1106: else
! 1107: {
! 1108: MSG("Recovery completed. You should check if everything is OK.");
! 1109: MSG_OUTSTR("\n(You might want to write out this file under another name\n");
! 1110: MSG_OUTSTR("and run diff with the original file to check for changes)\n");
! 1111: MSG_OUTSTR("Delete the .swp file afterwards.\n\n");
! 1112: cmdline_row = msg_row;
! 1113: }
! 1114:
! 1115: theend:
! 1116: if (mfp != NULL)
! 1117: {
! 1118: if (hp != NULL)
! 1119: mf_put(mfp, hp, FALSE, FALSE);
! 1120: mf_close(mfp, FALSE); /* will also vim_free(mfp->mf_fname) */
! 1121: }
! 1122: else
! 1123: vim_free(fname);
! 1124: vim_free(buf);
! 1125: if (serious_error && called_from_main)
! 1126: ml_close(curbuf, TRUE);
! 1127: return;
! 1128: }
! 1129:
! 1130: /*
! 1131: * Find the names of swap files in current directory and the directory given
! 1132: * with the 'directory' option.
! 1133: *
! 1134: * Used to:
! 1135: * - list the swap files for "vim -r"
! 1136: * - count the number of swap files when recovering
! 1137: * - list the swap files when recovering
! 1138: * - find the name of the n'th swap file when recovering
! 1139: */
! 1140: int
! 1141: recover_names(fname, list, nr)
! 1142: char_u **fname; /* base for swap file name */
! 1143: int list; /* when TRUE, list the swap file names */
! 1144: int nr; /* when non-zero, return nr'th swap file name */
! 1145: {
! 1146: int num_names;
! 1147: char_u *(names[6]);
! 1148: char_u *tail;
! 1149: char_u *p;
! 1150: int num_files;
! 1151: int file_count = 0;
! 1152: char_u **files;
! 1153: int i;
! 1154: char_u *dirp;
! 1155: char_u *dir_name;
! 1156:
! 1157: if (list)
! 1158: {
! 1159: /* use msg() to start the scrolling properly */
! 1160: msg((char_u *)"Swap files found:");
! 1161: msg_outchar('\n');
! 1162: }
! 1163: expand_interactively = TRUE;
! 1164: /*
! 1165: * Do the loop for every directory in 'directory'.
! 1166: */
! 1167: dirp = p_dir;
! 1168: while (*dirp)
! 1169: {
! 1170: /* find character after directory name */
! 1171: dir_name = dirp;
! 1172: while (*dirp && *dirp != ',')
! 1173: ++dirp;
! 1174: dir_name = strnsave(dir_name, (int)(dirp - dir_name));
! 1175: if (dir_name == NULL) /* out of memory */
! 1176: break;
! 1177: if (*dir_name == '.') /* check current dir */
! 1178: {
! 1179: if (fname == NULL || *fname == NULL)
! 1180: {
! 1181: names[0] = strsave((char_u *)"*.sw?");
! 1182: #ifdef UNIX
! 1183: /* for Unix names starting with a dot are special */
! 1184: names[1] = strsave((char_u *)".*.sw?");
! 1185: names[2] = strsave((char_u *)".sw?");
! 1186: num_names = 3;
! 1187: #else
! 1188: num_names = 1;
! 1189: #endif
! 1190: }
! 1191: else
! 1192: num_names = get_names(names, *fname);
! 1193: }
! 1194: else /* check directory dir_name */
! 1195: {
! 1196: if (fname == NULL || *fname == NULL)
! 1197: {
! 1198: names[0] = concat_fnames(dir_name, (char_u *)"*.sw?", TRUE);
! 1199: #ifdef UNIX
! 1200: /* for Unix names starting with a dot are special */
! 1201: names[1] = concat_fnames(dir_name, (char_u *)".*.sw?", TRUE);
! 1202: names[2] = concat_fnames(dir_name, (char_u *)".sw?", TRUE);
! 1203: num_names = 3;
! 1204: #else
! 1205: num_names = 1;
! 1206: #endif
! 1207: }
! 1208: else
! 1209: {
! 1210: tail = gettail(*fname);
! 1211: tail = concat_fnames(dir_name, tail, TRUE);
! 1212: if (tail == NULL)
! 1213: num_names = 0;
! 1214: else
! 1215: {
! 1216: num_names = get_names(names, tail);
! 1217: vim_free(tail);
! 1218: }
! 1219: }
! 1220: }
! 1221:
! 1222: /* check for out-of-memory */
! 1223: for (i = 0; i < num_names; ++i)
! 1224: {
! 1225: if (names[i] == NULL)
! 1226: {
! 1227: for (i = 0; i < num_names; ++i)
! 1228: vim_free(names[i]);
! 1229: num_names = 0;
! 1230: }
! 1231: }
! 1232: if (num_names == 0)
! 1233: num_files = 0;
! 1234: else if (ExpandWildCards(num_names, names,
! 1235: &num_files, &files, TRUE, FALSE) == FAIL)
! 1236: {
! 1237: MSG_OUTSTR(files); /* print error message */
! 1238: num_files = 0;
! 1239: }
! 1240: /*
! 1241: * remove swapfile name of the current buffer, it must be ignored
! 1242: */
! 1243: if (curbuf->b_ml.ml_mfp != NULL &&
! 1244: (p = curbuf->b_ml.ml_mfp->mf_fname) != NULL)
! 1245: {
! 1246: for (i = 0; i < num_files; ++i)
! 1247: if (fullpathcmp(p, files[i]) == FPC_SAME)
! 1248: {
! 1249: vim_free(files[i]);
! 1250: --num_files;
! 1251: for ( ; i < num_files; ++i)
! 1252: files[i] = files[i + 1];
! 1253: break;
! 1254: }
! 1255: }
! 1256: if (nr)
! 1257: {
! 1258: file_count += num_files;
! 1259: if (nr <= file_count)
! 1260: {
! 1261: *fname = strsave(files[nr - 1 + num_files - file_count]);
! 1262: dirp = (char_u *)""; /* stop searching */
! 1263: }
! 1264: }
! 1265: else if (list)
! 1266: {
! 1267: if (*dir_name == '.')
! 1268: {
! 1269: if (fname == NULL || *fname == NULL)
! 1270: MSG_OUTSTR(" In current directory:\n");
! 1271: else
! 1272: MSG_OUTSTR(" Using specified name:\n");
! 1273: }
! 1274: else
! 1275: {
! 1276: MSG_OUTSTR(" In directory ");
! 1277: msg_home_replace(dir_name);
! 1278: MSG_OUTSTR(":\n");
! 1279: }
! 1280:
! 1281: if (num_files)
! 1282: {
! 1283: for (i = 0; i < num_files; ++i)
! 1284: {
! 1285: /* print the swap file name */
! 1286: msg_outnum((long)++file_count);
! 1287: MSG_OUTSTR(". ");
! 1288: msg_outstr(gettail(files[i]));
! 1289: msg_outchar('\n');
! 1290: swapfile_info(files[i]);
! 1291: }
! 1292: }
! 1293: else
! 1294: MSG_OUTSTR(" -- none --\n");
! 1295: flushbuf();
! 1296: }
! 1297: else
! 1298: file_count += num_files;
! 1299:
! 1300: for (i = 0; i < num_names; ++i)
! 1301: vim_free(names[i]);
! 1302: FreeWild(num_files, files);
! 1303:
! 1304: /* advance dirp to next directory name */
! 1305: vim_free(dir_name);
! 1306: if (*dirp == ',')
! 1307: ++dirp;
! 1308: dirp = skipwhite(dirp);
! 1309: }
! 1310: expand_interactively = FALSE;
! 1311: return file_count;
! 1312: }
! 1313:
! 1314: /*
! 1315: * Give information about an existing swap file
! 1316: */
! 1317: static void
! 1318: swapfile_info(fname)
! 1319: char_u *fname;
! 1320: {
! 1321: struct stat st;
! 1322: int fd;
! 1323: struct block0 b0;
! 1324: time_t x;
! 1325:
! 1326: /* print the swap file date */
! 1327: if (stat((char *)fname, &st) != -1)
! 1328: {
! 1329: MSG_OUTSTR(" dated: ");
! 1330: x = st.st_mtime; /* Manx C can't do &st.st_mtime */
! 1331: MSG_OUTSTR(ctime(&x));
! 1332: }
! 1333:
! 1334: /*
! 1335: * print the original file name
! 1336: */
! 1337: fd = open((char *)fname, O_RDONLY | O_EXTRA);
! 1338: if (fd >= 0)
! 1339: {
! 1340: if (read(fd, (char *)&b0, sizeof(b0)) == sizeof(b0))
! 1341: {
! 1342: if (b0.b0_id[0] != BLOCK0_ID0 ||
! 1343: b0.b0_id[1] != BLOCK0_ID1)
! 1344: MSG_OUTSTR(" [is not a swap file]");
! 1345: else
! 1346: {
! 1347: MSG_OUTSTR(" file name: ");
! 1348: msg_outstr(b0.b0_fname);
! 1349:
! 1350: if (*(b0.b0_hname) != NUL)
! 1351: {
! 1352: MSG_OUTSTR("\n host name: ");
! 1353: msg_outstr(b0.b0_hname);
! 1354: }
! 1355:
! 1356: if (*(b0.b0_uname) != NUL)
! 1357: {
! 1358: MSG_OUTSTR("\n user name: ");
! 1359: msg_outstr(b0.b0_uname);
! 1360: }
! 1361:
! 1362: if (char_to_long(b0.b0_pid) != 0L)
! 1363: {
! 1364: MSG_OUTSTR("\n process ID: ");
! 1365: msg_outnum(char_to_long(b0.b0_pid));
! 1366: #if defined(UNIX) || defined(__EMX__)
! 1367: /* EMX kill() not working correctly, it seems */
! 1368: if (kill(char_to_long(b0.b0_pid), 0) == 0)
! 1369: MSG_OUTSTR(" (still running)");
! 1370: #endif
! 1371: }
! 1372:
! 1373: if (b0_magic_wrong(&b0))
! 1374: {
! 1375: #if defined(MSDOS) || defined(WIN32)
! 1376: if (STRNCMP(b0.b0_hname, "PC ", 3) == 0)
! 1377: MSG_OUTSTR("\n [not usable with this version of Vim]");
! 1378: else
! 1379: #endif
! 1380: MSG_OUTSTR("\n [not usable on this computer]");
! 1381: }
! 1382:
! 1383: }
! 1384: }
! 1385: else
! 1386: MSG_OUTSTR(" [cannot be read]");
! 1387: close(fd);
! 1388: }
! 1389: else
! 1390: MSG_OUTSTR(" [cannot be opened]");
! 1391: msg_outchar('\n');
! 1392: }
! 1393:
! 1394: static int
! 1395: get_names(names, fname)
! 1396: char_u **names;
! 1397: char_u *fname;
! 1398: {
! 1399: int num_names;
! 1400:
! 1401: #ifdef SHORT_FNAME
! 1402: /*
! 1403: * (MS-DOS) always short names
! 1404: */
! 1405: names[0] = modname(fname, (char_u *)".sw?");
! 1406: num_names = 1;
! 1407: #else /* !SHORT_FNAME */
! 1408: # ifdef WIN32
! 1409: /*
! 1410: * (WIN32) never short names
! 1411: */
! 1412: num_names = 1;
! 1413: names[0] = concat_fnames(fname, (char_u *)".sw?", FALSE);
! 1414: # else /* !WIN32 */
! 1415: /*
! 1416: * (Not MS-DOS or WIN32) maybe short name, maybe not: try both.
! 1417: * Only use the short name if it is different.
! 1418: */
! 1419:
! 1420: int i;
! 1421:
! 1422: names[0] = concat_fnames(fname, (char_u *)".sw?", FALSE);
! 1423: i = curbuf->b_shortname;
! 1424: curbuf->b_shortname = TRUE;
! 1425: names[1] = modname(fname, (char_u *)".sw?");
! 1426: curbuf->b_shortname = i;
! 1427: if (STRCMP(names[0], names[1]) == 0)
! 1428: {
! 1429: vim_free(names[1]);
! 1430: num_names = 1;
! 1431: }
! 1432: else
! 1433: num_names = 2;
! 1434: # endif /* !WIN32 */
! 1435: #endif /* !SHORT_FNAME */
! 1436: return num_names;
! 1437: }
! 1438:
! 1439: /*
! 1440: * sync all memlines
! 1441: *
! 1442: * If 'check_file' is TRUE, check if original file exists and was not changed.
! 1443: * If 'check_char' is TRUE, stop syncing when character becomes available, but
! 1444: * always sync at least one block.
! 1445: */
! 1446: void
! 1447: ml_sync_all(check_file, check_char)
! 1448: int check_file;
! 1449: int check_char;
! 1450: {
! 1451: BUF *buf;
! 1452: struct stat st;
! 1453:
! 1454: for (buf = firstbuf; buf != NULL; buf = buf->b_next)
! 1455: {
! 1456: if (buf->b_ml.ml_mfp == NULL || buf->b_ml.ml_mfp->mf_fname == NULL)
! 1457: continue; /* no file */
! 1458:
! 1459: ml_flush_line(buf); /* flush buffered line */
! 1460: /* flush locked block */
! 1461: (void)ml_find_line(buf, (linenr_t)0, ML_FLUSH);
! 1462: if (buf->b_changed && check_file && mf_need_trans(buf->b_ml.ml_mfp) &&
! 1463: buf->b_filename != NULL)
! 1464: {
! 1465: /*
! 1466: * if original file does not exist anymore or has been changed
! 1467: * call ml_preserve to get rid of all negative numbered blocks
! 1468: */
! 1469: if (stat((char *)buf->b_filename, &st) == -1 ||
! 1470: st.st_mtime != buf->b_mtime_read)
! 1471: {
! 1472: ml_preserve(buf, FALSE);
! 1473: need_check_timestamps = TRUE; /* give message later */
! 1474: }
! 1475: }
! 1476: if (buf->b_ml.ml_mfp->mf_dirty)
! 1477: {
! 1478: mf_sync(buf->b_ml.ml_mfp, FALSE, check_char, buf->b_changed);
! 1479: if (check_char && mch_char_avail()) /* character available now */
! 1480: break;
! 1481: }
! 1482: }
! 1483: }
! 1484:
! 1485: /*
! 1486: * sync one buffer, including negative blocks
! 1487: *
! 1488: * after this all the blocks are in the swap file
! 1489: *
! 1490: * Used for the :preserve command and when the original file has been
! 1491: * changed or deleted.
! 1492: *
! 1493: * when message is TRUE the success of preserving is reported
! 1494: */
! 1495: void
! 1496: ml_preserve(buf, message)
! 1497: BUF *buf;
! 1498: int message;
! 1499: {
! 1500: BHDR *hp;
! 1501: linenr_t lnum;
! 1502: MEMFILE *mfp = buf->b_ml.ml_mfp;
! 1503: int status;
! 1504:
! 1505: if (mfp == NULL || mfp->mf_fname == NULL)
! 1506: {
! 1507: if (message)
! 1508: EMSG("Cannot preserve, there is no swap file");
! 1509: return;
! 1510: }
! 1511:
! 1512: ml_flush_line(buf); /* flush buffered line */
! 1513: (void)ml_find_line(buf, (linenr_t)0, ML_FLUSH); /* flush locked block */
! 1514: status = mf_sync(mfp, TRUE, FALSE, TRUE);
! 1515:
! 1516: /* stack is invalid after mf_sync(.., TRUE, ..) */
! 1517: buf->b_ml.ml_stack_top = 0;
! 1518:
! 1519: /*
! 1520: * Some of the data blocks may have been changed from negative to
! 1521: * positive block number. In that case the pointer blocks need to be
! 1522: * updated.
! 1523: *
! 1524: * We don't know in which pointer block the references are, so we visit
! 1525: * all data blocks until there are no more translations to be done (or
! 1526: * we hit the end of the file, which can only happen in case a write fails,
! 1527: * e.g. when file system if full).
! 1528: * ml_find_line() does the work by translating the negative block numbers
! 1529: * when getting the first line of each data block.
! 1530: */
! 1531: if (mf_need_trans(mfp))
! 1532: {
! 1533: lnum = 1;
! 1534: while (mf_need_trans(mfp) && lnum <= buf->b_ml.ml_line_count)
! 1535: {
! 1536: hp = ml_find_line(buf, lnum, ML_FIND);
! 1537: if (hp == NULL)
! 1538: {
! 1539: status = FAIL;
! 1540: goto theend;
! 1541: }
! 1542: CHECK(buf->b_ml.ml_locked_low != lnum, "low != lnum");
! 1543: lnum = buf->b_ml.ml_locked_high + 1;
! 1544: }
! 1545: (void)ml_find_line(buf, (linenr_t)0, ML_FLUSH); /* flush locked block */
! 1546: if (mf_sync(mfp, TRUE, FALSE, TRUE) == FAIL) /* sync the updated pointer blocks */
! 1547: status = FAIL;
! 1548: buf->b_ml.ml_stack_top = 0; /* stack is invalid now */
! 1549: }
! 1550: theend:
! 1551: if (message)
! 1552: {
! 1553: if (status == OK)
! 1554: MSG("File preserved");
! 1555: else
! 1556: EMSG("Preserve failed");
! 1557: }
! 1558: }
! 1559:
! 1560: /*
! 1561: * get a pointer to a (read-only copy of a) line
! 1562: *
! 1563: * On failure an error message is given and IObuff is returned (to avoid
! 1564: * having to check for error everywhere).
! 1565: */
! 1566: char_u *
! 1567: ml_get(lnum)
! 1568: linenr_t lnum;
! 1569: {
! 1570: return ml_get_buf(curbuf, lnum, FALSE);
! 1571: }
! 1572:
! 1573: /*
! 1574: * ml_get_pos: get pointer to position 'pos'
! 1575: */
! 1576: char_u *
! 1577: ml_get_pos(pos)
! 1578: FPOS *pos;
! 1579: {
! 1580: return (ml_get_buf(curbuf, pos->lnum, FALSE) + pos->col);
! 1581: }
! 1582:
! 1583: /*
! 1584: * ml_get_pos: get pointer to cursor line.
! 1585: */
! 1586: char_u *
! 1587: ml_get_curline()
! 1588: {
! 1589: return ml_get_buf(curbuf, curwin->w_cursor.lnum, FALSE);
! 1590: }
! 1591:
! 1592: /*
! 1593: * ml_get_pos: get pointer to cursor position
! 1594: */
! 1595: char_u *
! 1596: ml_get_cursor()
! 1597: {
! 1598: return (ml_get_buf(curbuf, curwin->w_cursor.lnum, FALSE) +
! 1599: curwin->w_cursor.col);
! 1600: }
! 1601:
! 1602: /*
! 1603: * get a pointer to a line in a specific buffer
! 1604: *
! 1605: * will_change: if TRUE mark the buffer dirty (chars in the line will be
! 1606: * changed)
! 1607: */
! 1608: char_u *
! 1609: ml_get_buf(buf, lnum, will_change)
! 1610: BUF *buf;
! 1611: linenr_t lnum;
! 1612: int will_change; /* line will be changed */
! 1613: {
! 1614: BHDR *hp;
! 1615: DATA_BL *dp;
! 1616: char_u *ptr;
! 1617:
! 1618: if (lnum > buf->b_ml.ml_line_count) /* invalid line number */
! 1619: {
! 1620: EMSGN("ml_get: invalid lnum: %ld", lnum);
! 1621: errorret:
! 1622: STRCPY(IObuff, "???");
! 1623: return IObuff;
! 1624: }
! 1625: if (lnum <= 0) /* pretend line 0 is line 1 */
! 1626: lnum = 1;
! 1627:
! 1628: if (buf->b_ml.ml_mfp == NULL) /* there are no lines */
! 1629: return (char_u *)"";
! 1630:
! 1631: /*
! 1632: * See if it is the same line as requested last time.
! 1633: * Otherwise may need to flush last used line.
! 1634: */
! 1635: if (buf->b_ml.ml_line_lnum != lnum)
! 1636: {
! 1637: ml_flush_line(buf);
! 1638:
! 1639: /*
! 1640: * find the data block containing the line
! 1641: * This also fills the stack with the blocks from the root to the data block
! 1642: * This also releases any locked block.
! 1643: */
! 1644: if ((hp = ml_find_line(buf, lnum, ML_FIND)) == NULL)
! 1645: {
! 1646: EMSGN("ml_get: cannot find line %ld", lnum);
! 1647: goto errorret;
! 1648: }
! 1649:
! 1650: dp = (DATA_BL *)(hp->bh_data);
! 1651:
! 1652: ptr = (char_u *)dp + ((dp->db_index[lnum - buf->b_ml.ml_locked_low]) & DB_INDEX_MASK);
! 1653: buf->b_ml.ml_line_ptr = ptr;
! 1654: buf->b_ml.ml_line_lnum = lnum;
! 1655: buf->b_ml.ml_flags &= ~ML_LINE_DIRTY;
! 1656: }
! 1657: if (will_change)
! 1658: buf->b_ml.ml_flags |= (ML_LOCKED_DIRTY | ML_LOCKED_POS);
! 1659:
! 1660: return buf->b_ml.ml_line_ptr;
! 1661: }
! 1662:
! 1663: /*
! 1664: * Check if a line that was just obtained by a call to ml_get
! 1665: * is in allocated memory.
! 1666: */
! 1667: int
! 1668: ml_line_alloced()
! 1669: {
! 1670: return (curbuf->b_ml.ml_flags & ML_LINE_DIRTY);
! 1671: }
! 1672:
! 1673: /*
! 1674: * append a line after lnum (may be 0 to insert a line in front of the file)
! 1675: *
! 1676: * newfile: TRUE when starting to edit a new file, meaning that pe_old_lnum
! 1677: * will be set for recovery
! 1678: *
! 1679: * return FAIL for failure, OK otherwise
! 1680: */
! 1681: int
! 1682: ml_append(lnum, line, len, newfile)
! 1683: linenr_t lnum; /* append after this line (can be 0) */
! 1684: char_u *line; /* text of the new line */
! 1685: colnr_t len; /* length of new line, including NUL, or 0 */
! 1686: int newfile; /* flag, see above */
! 1687: {
! 1688: if (curbuf->b_ml.ml_line_lnum != 0)
! 1689: ml_flush_line(curbuf);
! 1690: return ml_append_int(curbuf, lnum, line, len, newfile);
! 1691: }
! 1692:
! 1693: static int
! 1694: ml_append_int(buf, lnum, line, len, newfile)
! 1695: BUF *buf;
! 1696: linenr_t lnum; /* append after this line (can be 0) */
! 1697: char_u *line; /* text of the new line */
! 1698: colnr_t len; /* length of line, including NUL, or 0 */
! 1699: int newfile; /* flag, see above */
! 1700: {
! 1701: int i;
! 1702: int line_count; /* number of indexes in current block */
! 1703: int offset;
! 1704: int from, to;
! 1705: int space_needed; /* space needed for new line */
! 1706: int page_size;
! 1707: int page_count;
! 1708: int db_idx; /* index for lnum in data block */
! 1709: BHDR *hp;
! 1710: MEMFILE *mfp;
! 1711: DATA_BL *dp;
! 1712: PTR_BL *pp;
! 1713: IPTR *ip;
! 1714:
! 1715: /* lnum out of range */
! 1716: if (lnum > buf->b_ml.ml_line_count || buf->b_ml.ml_mfp == NULL)
! 1717: return FAIL;
! 1718:
! 1719: if (lowest_marked && lowest_marked > lnum)
! 1720: lowest_marked = lnum + 1;
! 1721:
! 1722: if (len == 0)
! 1723: len = STRLEN(line) + 1; /* space needed for the text */
! 1724: space_needed = len + INDEX_SIZE; /* space needed for text + index */
! 1725:
! 1726: mfp = buf->b_ml.ml_mfp;
! 1727: page_size = mfp->mf_page_size;
! 1728:
! 1729: /*
! 1730: * find the data block containing the previous line
! 1731: * This also fills the stack with the blocks from the root to the data block
! 1732: * This also releases any locked block.
! 1733: */
! 1734: if ((hp = ml_find_line(buf, lnum == 0 ? (linenr_t)1 : lnum,
! 1735: ML_INSERT)) == NULL)
! 1736: return FAIL;
! 1737:
! 1738: buf->b_ml.ml_flags &= ~ML_EMPTY;
! 1739:
! 1740: if (lnum == 0) /* got line one instead, correct db_idx */
! 1741: db_idx = -1; /* careful, it is negative! */
! 1742: else
! 1743: db_idx = lnum - buf->b_ml.ml_locked_low;
! 1744: /* get line count before the insertion */
! 1745: line_count = buf->b_ml.ml_locked_high - buf->b_ml.ml_locked_low;
! 1746:
! 1747: dp = (DATA_BL *)(hp->bh_data);
! 1748:
! 1749: /*
! 1750: * If
! 1751: * - there is not enough room in the current block
! 1752: * - appending to the last line in the block
! 1753: * - not appending to the last line in the file
! 1754: * insert in front of the next block.
! 1755: */
! 1756: if ((int)dp->db_free < space_needed && db_idx == line_count - 1 &&
! 1757: lnum < buf->b_ml.ml_line_count)
! 1758: {
! 1759: /*
! 1760: * Now that the line is not going to be inserted in the block that we
! 1761: * expected, the line count has to be adjusted in the pointer blocks
! 1762: * by using ml_locked_lineadd.
! 1763: */
! 1764: --(buf->b_ml.ml_locked_lineadd);
! 1765: --(buf->b_ml.ml_locked_high);
! 1766: if ((hp = ml_find_line(buf, lnum + 1, ML_INSERT)) == NULL)
! 1767: return FAIL;
! 1768:
! 1769: db_idx = -1; /* careful, it is negative! */
! 1770: /* get line count before the insertion */
! 1771: line_count = buf->b_ml.ml_locked_high - buf->b_ml.ml_locked_low;
! 1772: CHECK(buf->b_ml.ml_locked_low != lnum + 1, "locked_low != lnum + 1");
! 1773:
! 1774: dp = (DATA_BL *)(hp->bh_data);
! 1775: }
! 1776:
! 1777: ++buf->b_ml.ml_line_count;
! 1778:
! 1779: if ((int)dp->db_free >= space_needed) /* enough room in data block */
! 1780: {
! 1781: /*
! 1782: * Insert new line in existing data block, or in data block allocated above.
! 1783: */
! 1784: dp->db_txt_start -= len;
! 1785: dp->db_free -= space_needed;
! 1786: ++(dp->db_line_count);
! 1787:
! 1788: /*
! 1789: * move the text of the lines that follow to the front
! 1790: * adjust the indexes of the lines that follow
! 1791: */
! 1792: if (line_count > db_idx + 1) /* if there are following lines */
! 1793: {
! 1794: /*
! 1795: * Offset is the start of the previous line.
! 1796: * This will become the character just after the new line.
! 1797: */
! 1798: if (db_idx < 0)
! 1799: offset = dp->db_txt_end;
! 1800: else
! 1801: offset = ((dp->db_index[db_idx]) & DB_INDEX_MASK);
! 1802: vim_memmove((char *)dp + dp->db_txt_start,
! 1803: (char *)dp + dp->db_txt_start + len,
! 1804: (size_t)(offset - (dp->db_txt_start + len)));
! 1805: for (i = line_count - 1; i > db_idx; --i)
! 1806: dp->db_index[i + 1] = dp->db_index[i] - len;
! 1807: dp->db_index[db_idx + 1] = offset - len;
! 1808: }
! 1809: else /* add line at the end */
! 1810: dp->db_index[db_idx + 1] = dp->db_txt_start;
! 1811:
! 1812: /*
! 1813: * copy the text into the block
! 1814: */
! 1815: vim_memmove((char *)dp + dp->db_index[db_idx + 1], line, (size_t)len);
! 1816:
! 1817: /*
! 1818: * Mark the block dirty.
! 1819: */
! 1820: buf->b_ml.ml_flags |= ML_LOCKED_DIRTY;
! 1821: if (!newfile)
! 1822: buf->b_ml.ml_flags |= ML_LOCKED_POS;
! 1823: }
! 1824: else /* not enough space in data block */
! 1825: {
! 1826: /*
! 1827: * If there is not enough room we have to create a new data block and copy some
! 1828: * lines into it.
! 1829: * Then we have to insert an entry in the pointer block.
! 1830: * If this pointer block also is full, we go up another block, and so on, up
! 1831: * to the root if necessary.
! 1832: * The line counts in the pointer blocks have already been adjusted by
! 1833: * ml_find_line().
! 1834: */
! 1835: long line_count_left, line_count_right;
! 1836: int page_count_left, page_count_right;
! 1837: BHDR *hp_left;
! 1838: BHDR *hp_right;
! 1839: BHDR *hp_new;
! 1840: int lines_moved;
! 1841: int data_moved = 0; /* init to shut up gcc */
! 1842: int total_moved = 0; /* init to shut up gcc */
! 1843: DATA_BL *dp_right, *dp_left;
! 1844: int stack_idx;
! 1845: int in_left;
! 1846: int lineadd;
! 1847: blocknr_t bnum_left, bnum_right;
! 1848: linenr_t lnum_left, lnum_right;
! 1849: int pb_idx;
! 1850: PTR_BL *pp_new;
! 1851:
! 1852: /*
! 1853: * We are going to allocate a new data block. Depending on the
! 1854: * situation it will be put to the left or right of the existing
! 1855: * block. If possible we put the new line in the left block and move
! 1856: * the lines after it to the right block. Otherwise the new line is
! 1857: * also put in the right block. This method is more efficient when
! 1858: * inserting a lot of lines at one place.
! 1859: */
! 1860: if (db_idx < 0) /* left block is new, right block is existing */
! 1861: {
! 1862: lines_moved = 0;
! 1863: in_left = TRUE;
! 1864: /* space_needed does not change */
! 1865: }
! 1866: else /* left block is existing, right block is new */
! 1867: {
! 1868: lines_moved = line_count - db_idx - 1;
! 1869: if (lines_moved == 0)
! 1870: in_left = FALSE; /* put new line in right block */
! 1871: /* space_needed does not change */
! 1872: else
! 1873: {
! 1874: data_moved = ((dp->db_index[db_idx]) & DB_INDEX_MASK) -
! 1875: dp->db_txt_start;
! 1876: total_moved = data_moved + lines_moved * INDEX_SIZE;
! 1877: if ((int)dp->db_free + total_moved >= space_needed)
! 1878: {
! 1879: in_left = TRUE; /* put new line in left block */
! 1880: space_needed = total_moved;
! 1881: }
! 1882: else
! 1883: {
! 1884: in_left = FALSE; /* put new line in right block */
! 1885: space_needed += total_moved;
! 1886: }
! 1887: }
! 1888: }
! 1889:
! 1890: page_count = ((space_needed + HEADER_SIZE) + page_size - 1) / page_size;
! 1891: if ((hp_new = ml_new_data(mfp, newfile, page_count)) == NULL)
! 1892: {
! 1893: /* correct line counts in pointer blocks */
! 1894: --(buf->b_ml.ml_locked_lineadd);
! 1895: --(buf->b_ml.ml_locked_high);
! 1896: return FAIL;
! 1897: }
! 1898: if (db_idx < 0) /* left block is new */
! 1899: {
! 1900: hp_left = hp_new;
! 1901: hp_right = hp;
! 1902: line_count_left = 0;
! 1903: line_count_right = line_count;
! 1904: }
! 1905: else /* right block is new */
! 1906: {
! 1907: hp_left = hp;
! 1908: hp_right = hp_new;
! 1909: line_count_left = line_count;
! 1910: line_count_right = 0;
! 1911: }
! 1912: dp_right = (DATA_BL *)(hp_right->bh_data);
! 1913: dp_left = (DATA_BL *)(hp_left->bh_data);
! 1914: bnum_left = hp_left->bh_bnum;
! 1915: bnum_right = hp_right->bh_bnum;
! 1916: page_count_left = hp_left->bh_page_count;
! 1917: page_count_right = hp_right->bh_page_count;
! 1918:
! 1919: /*
! 1920: * May move the new line into the right/new block.
! 1921: */
! 1922: if (!in_left)
! 1923: {
! 1924: dp_right->db_txt_start -= len;
! 1925: dp_right->db_free -= len + INDEX_SIZE;
! 1926: dp_right->db_index[0] = dp_right->db_txt_start;
! 1927: vim_memmove((char *)dp_right + dp_right->db_txt_start,
! 1928: line, (size_t)len);
! 1929: ++line_count_right;
! 1930: }
! 1931: /*
! 1932: * may move lines from the left/old block to the right/new one.
! 1933: */
! 1934: if (lines_moved)
! 1935: {
! 1936: /*
! 1937: */
! 1938: dp_right->db_txt_start -= data_moved;
! 1939: dp_right->db_free -= total_moved;
! 1940: vim_memmove((char *)dp_right + dp_right->db_txt_start,
! 1941: (char *)dp_left + dp_left->db_txt_start,
! 1942: (size_t)data_moved);
! 1943: offset = dp_right->db_txt_start - dp_left->db_txt_start;
! 1944: dp_left->db_txt_start += data_moved;
! 1945: dp_left->db_free += total_moved;
! 1946:
! 1947: /*
! 1948: * update indexes in the new block
! 1949: */
! 1950: for (to = line_count_right, from = db_idx + 1;
! 1951: from < line_count_left; ++from, ++to)
! 1952: dp_right->db_index[to] = dp->db_index[from] + offset;
! 1953: line_count_right += lines_moved;
! 1954: line_count_left -= lines_moved;
! 1955: }
! 1956:
! 1957: /*
! 1958: * May move the new line into the left (old or new) block.
! 1959: */
! 1960: if (in_left)
! 1961: {
! 1962: dp_left->db_txt_start -= len;
! 1963: dp_left->db_free -= len + INDEX_SIZE;
! 1964: dp_left->db_index[line_count_left] = dp_left->db_txt_start;
! 1965: vim_memmove((char *)dp_left + dp_left->db_txt_start,
! 1966: line, (size_t)len);
! 1967: ++line_count_left;
! 1968: }
! 1969:
! 1970: if (db_idx < 0) /* left block is new */
! 1971: {
! 1972: lnum_left = lnum + 1;
! 1973: lnum_right = 0;
! 1974: }
! 1975: else /* right block is new */
! 1976: {
! 1977: lnum_left = 0;
! 1978: if (in_left)
! 1979: lnum_right = lnum + 2;
! 1980: else
! 1981: lnum_right = lnum + 1;
! 1982: }
! 1983: dp_left->db_line_count = line_count_left;
! 1984: dp_right->db_line_count = line_count_right;
! 1985:
! 1986: /*
! 1987: * release the two data blocks
! 1988: * The new one (hp_new) already has a correct blocknumber.
! 1989: * The old one (hp, in ml_locked) gets a positive blocknumber if
! 1990: * we changed it and we are not editing a new file.
! 1991: */
! 1992: if (lines_moved || in_left)
! 1993: buf->b_ml.ml_flags |= ML_LOCKED_DIRTY;
! 1994: if (!newfile && db_idx >= 0 && in_left)
! 1995: buf->b_ml.ml_flags |= ML_LOCKED_POS;
! 1996: mf_put(mfp, hp_new, TRUE, FALSE);
! 1997:
! 1998: /*
! 1999: * flush the old data block
! 2000: * set ml_locked_lineadd to 0, because the updating of the
! 2001: * pointer blocks is done below
! 2002: */
! 2003: lineadd = buf->b_ml.ml_locked_lineadd;
! 2004: buf->b_ml.ml_locked_lineadd = 0;
! 2005: ml_find_line(buf, (linenr_t)0, ML_FLUSH); /* flush data block */
! 2006:
! 2007: /*
! 2008: * update pointer blocks for the new data block
! 2009: */
! 2010: for (stack_idx = buf->b_ml.ml_stack_top - 1; stack_idx >= 0; --stack_idx)
! 2011: {
! 2012: ip = &(buf->b_ml.ml_stack[stack_idx]);
! 2013: pb_idx = ip->ip_index;
! 2014: if ((hp = mf_get(mfp, ip->ip_bnum, 1)) == NULL)
! 2015: return FAIL;
! 2016: pp = (PTR_BL *)(hp->bh_data); /* must be pointer block */
! 2017: if (pp->pb_id != PTR_ID)
! 2018: {
! 2019: EMSG("pointer block id wrong 3");
! 2020: mf_put(mfp, hp, FALSE, FALSE);
! 2021: return FAIL;
! 2022: }
! 2023: /*
! 2024: * TODO: If the pointer block is full and we are adding at the end
! 2025: * try to insert in front of the next block
! 2026: */
! 2027: if (pp->pb_count < pp->pb_count_max) /* block not full, add one entry */
! 2028: {
! 2029: if (pb_idx + 1 < (int)pp->pb_count)
! 2030: vim_memmove(&pp->pb_pointer[pb_idx + 2],
! 2031: &pp->pb_pointer[pb_idx + 1],
! 2032: (size_t)(pp->pb_count - pb_idx - 1) * sizeof(PTR_EN));
! 2033: ++pp->pb_count;
! 2034: pp->pb_pointer[pb_idx].pe_line_count = line_count_left;
! 2035: pp->pb_pointer[pb_idx].pe_bnum = bnum_left;
! 2036: pp->pb_pointer[pb_idx].pe_page_count = page_count_left;
! 2037: pp->pb_pointer[pb_idx + 1].pe_line_count = line_count_right;
! 2038: pp->pb_pointer[pb_idx + 1].pe_bnum = bnum_right;
! 2039: pp->pb_pointer[pb_idx + 1].pe_page_count = page_count_right;
! 2040:
! 2041: if (lnum_left != 0)
! 2042: pp->pb_pointer[pb_idx].pe_old_lnum = lnum_left;
! 2043: if (lnum_right != 0)
! 2044: pp->pb_pointer[pb_idx + 1].pe_old_lnum = lnum_right;
! 2045:
! 2046: mf_put(mfp, hp, TRUE, FALSE);
! 2047: buf->b_ml.ml_stack_top = stack_idx + 1; /* truncate stack */
! 2048:
! 2049: if (lineadd)
! 2050: {
! 2051: --(buf->b_ml.ml_stack_top);
! 2052: /* fix line count for rest of blocks in the stack */
! 2053: ml_lineadd(buf, lineadd);
! 2054: /* fix stack itself */
! 2055: buf->b_ml.ml_stack[buf->b_ml.ml_stack_top].ip_high +=
! 2056: lineadd;
! 2057: ++(buf->b_ml.ml_stack_top);
! 2058: }
! 2059:
! 2060: return OK;
! 2061: }
! 2062: else /* pointer block full */
! 2063: {
! 2064: /*
! 2065: * split the pointer block
! 2066: * allocate a new pointer block
! 2067: * move some of the pointer into the new block
! 2068: * prepare for updating the parent block
! 2069: */
! 2070: for (;;) /* do this twice when splitting block 1 */
! 2071: {
! 2072: hp_new = ml_new_ptr(mfp);
! 2073: if (hp_new == NULL) /* TODO: try to fix tree */
! 2074: return FAIL;
! 2075: pp_new = (PTR_BL *)(hp_new->bh_data);
! 2076:
! 2077: if (hp->bh_bnum != 1)
! 2078: break;
! 2079:
! 2080: /*
! 2081: * if block 1 becomes full the tree is given an extra level
! 2082: * The pointers from block 1 are moved into the new block.
! 2083: * block 1 is updated to point to the new block
! 2084: * then continue to split the new block
! 2085: */
! 2086: vim_memmove(pp_new, pp, (size_t)page_size);
! 2087: pp->pb_count = 1;
! 2088: pp->pb_pointer[0].pe_bnum = hp_new->bh_bnum;
! 2089: pp->pb_pointer[0].pe_line_count = buf->b_ml.ml_line_count;
! 2090: pp->pb_pointer[0].pe_old_lnum = 1;
! 2091: pp->pb_pointer[0].pe_page_count = 1;
! 2092: mf_put(mfp, hp, TRUE, FALSE); /* release block 1 */
! 2093: hp = hp_new; /* new block is to be split */
! 2094: pp = pp_new;
! 2095: CHECK(stack_idx != 0, "stack_idx should be 0");
! 2096: ip->ip_index = 0;
! 2097: ++stack_idx; /* do block 1 again later */
! 2098: }
! 2099: /*
! 2100: * move the pointers after the current one to the new block
! 2101: * If there are none, the new entry will be in the new block.
! 2102: */
! 2103: total_moved = pp->pb_count - pb_idx - 1;
! 2104: if (total_moved)
! 2105: {
! 2106: vim_memmove(&pp_new->pb_pointer[0],
! 2107: &pp->pb_pointer[pb_idx + 1],
! 2108: (size_t)(total_moved) * sizeof(PTR_EN));
! 2109: pp_new->pb_count = total_moved;
! 2110: pp->pb_count -= total_moved - 1;
! 2111: pp->pb_pointer[pb_idx + 1].pe_bnum = bnum_right;
! 2112: pp->pb_pointer[pb_idx + 1].pe_line_count = line_count_right;
! 2113: pp->pb_pointer[pb_idx + 1].pe_page_count = page_count_right;
! 2114: if (lnum_right)
! 2115: pp->pb_pointer[pb_idx + 1].pe_old_lnum = lnum_right;
! 2116: }
! 2117: else
! 2118: {
! 2119: pp_new->pb_count = 1;
! 2120: pp_new->pb_pointer[0].pe_bnum = bnum_right;
! 2121: pp_new->pb_pointer[0].pe_line_count = line_count_right;
! 2122: pp_new->pb_pointer[0].pe_page_count = page_count_right;
! 2123: pp_new->pb_pointer[0].pe_old_lnum = lnum_right;
! 2124: }
! 2125: pp->pb_pointer[pb_idx].pe_bnum = bnum_left;
! 2126: pp->pb_pointer[pb_idx].pe_line_count = line_count_left;
! 2127: pp->pb_pointer[pb_idx].pe_page_count = page_count_left;
! 2128: if (lnum_left)
! 2129: pp->pb_pointer[pb_idx].pe_old_lnum = lnum_left;
! 2130: lnum_left = 0;
! 2131: lnum_right = 0;
! 2132:
! 2133: /*
! 2134: * recompute line counts
! 2135: */
! 2136: line_count_right = 0;
! 2137: for (i = 0; i < (int)pp_new->pb_count; ++i)
! 2138: line_count_right += pp_new->pb_pointer[i].pe_line_count;
! 2139: line_count_left = 0;
! 2140: for (i = 0; i < (int)pp->pb_count; ++i)
! 2141: line_count_left += pp->pb_pointer[i].pe_line_count;
! 2142:
! 2143: bnum_left = hp->bh_bnum;
! 2144: bnum_right = hp_new->bh_bnum;
! 2145: page_count_left = 1;
! 2146: page_count_right = 1;
! 2147: mf_put(mfp, hp, TRUE, FALSE);
! 2148: mf_put(mfp, hp_new, TRUE, FALSE);
! 2149: }
! 2150: }
! 2151: EMSG("Updated too many blocks?");
! 2152: buf->b_ml.ml_stack_top = 0; /* invalidate stack */
! 2153: }
! 2154: return OK;
! 2155: }
! 2156:
! 2157: /*
! 2158: * replace line lnum, with buffering, in current buffer
! 2159: *
! 2160: * If copy is TRUE, make a copy of the line, otherwise the line has been
! 2161: * copied to allocated memory already.
! 2162: *
! 2163: * return FAIL for failure, OK otherwise
! 2164: */
! 2165: int
! 2166: ml_replace(lnum, line, copy)
! 2167: linenr_t lnum;
! 2168: char_u *line;
! 2169: int copy;
! 2170: {
! 2171: if (line == NULL) /* just checking... */
! 2172: return FAIL;
! 2173:
! 2174: if (curbuf->b_ml.ml_line_lnum != lnum) /* other line buffered */
! 2175: ml_flush_line(curbuf); /* flush it */
! 2176: else if (curbuf->b_ml.ml_flags & ML_LINE_DIRTY) /* same line allocated */
! 2177: vim_free(curbuf->b_ml.ml_line_ptr); /* free it */
! 2178: if (copy && (line = strsave(line)) == NULL) /* allocate memory */
! 2179: return FAIL;
! 2180: curbuf->b_ml.ml_line_ptr = line;
! 2181: curbuf->b_ml.ml_line_lnum = lnum;
! 2182: curbuf->b_ml.ml_flags = (curbuf->b_ml.ml_flags | ML_LINE_DIRTY) & ~ML_EMPTY;
! 2183:
! 2184: return OK;
! 2185: }
! 2186:
! 2187: /*
! 2188: * delete line 'lnum'
! 2189: *
! 2190: * return FAIL for failure, OK otherwise
! 2191: */
! 2192: int
! 2193: ml_delete(lnum, message)
! 2194: linenr_t lnum;
! 2195: int message;
! 2196: {
! 2197: ml_flush_line(curbuf);
! 2198: return ml_delete_int(curbuf, lnum, message);
! 2199: }
! 2200:
! 2201: static int
! 2202: ml_delete_int(buf, lnum, message)
! 2203: BUF *buf;
! 2204: linenr_t lnum;
! 2205: int message;
! 2206: {
! 2207: BHDR *hp;
! 2208: MEMFILE *mfp;
! 2209: DATA_BL *dp;
! 2210: PTR_BL *pp;
! 2211: IPTR *ip;
! 2212: int count; /* number of entries in block */
! 2213: int idx;
! 2214: int stack_idx;
! 2215: int text_start;
! 2216: int line_start;
! 2217: int line_size;
! 2218: int i;
! 2219:
! 2220: if (lnum < 1 || lnum > buf->b_ml.ml_line_count)
! 2221: return FAIL;
! 2222:
! 2223: if (lowest_marked && lowest_marked > lnum)
! 2224: lowest_marked--;
! 2225:
! 2226: /*
! 2227: * If the file becomes empty the last line is replaced by an empty line.
! 2228: */
! 2229: if (buf->b_ml.ml_line_count == 1) /* file becomes empty */
! 2230: {
! 2231: if (message)
! 2232: keep_msg = no_lines_msg;
! 2233: i = ml_replace((linenr_t)1, (char_u *)"", TRUE);
! 2234: buf->b_ml.ml_flags |= ML_EMPTY;
! 2235: return i;
! 2236: }
! 2237:
! 2238: /*
! 2239: * find the data block containing the line
! 2240: * This also fills the stack with the blocks from the root to the data block
! 2241: * This also releases any locked block.
! 2242: */
! 2243: mfp = buf->b_ml.ml_mfp;
! 2244: if (mfp == NULL)
! 2245: return FAIL;
! 2246:
! 2247: if ((hp = ml_find_line(buf, lnum, ML_DELETE)) == NULL)
! 2248: return FAIL;
! 2249:
! 2250: dp = (DATA_BL *)(hp->bh_data);
! 2251: /* compute line count before the delete */
! 2252: count = (long)(buf->b_ml.ml_locked_high) - (long)(buf->b_ml.ml_locked_low) + 2;
! 2253: idx = lnum - buf->b_ml.ml_locked_low;
! 2254:
! 2255: --buf->b_ml.ml_line_count;
! 2256:
! 2257: /*
! 2258: * special case: If there is only one line in the data block it becomes empty.
! 2259: * Then we have to remove the entry, pointing to this data block, from the
! 2260: * pointer block. If this pointer block also becomes empty, we go up another
! 2261: * block, and so on, up to the root if necessary.
! 2262: * The line counts in the pointer blocks have already been adjusted by
! 2263: * ml_find_line().
! 2264: */
! 2265: if (count == 1)
! 2266: {
! 2267: mf_free(mfp, hp); /* free the data block */
! 2268: buf->b_ml.ml_locked = NULL;
! 2269:
! 2270: for (stack_idx = buf->b_ml.ml_stack_top - 1; stack_idx >= 0; --stack_idx)
! 2271: {
! 2272: buf->b_ml.ml_stack_top = 0; /* stack is invalid when failing */
! 2273: ip = &(buf->b_ml.ml_stack[stack_idx]);
! 2274: idx = ip->ip_index;
! 2275: if ((hp = mf_get(mfp, ip->ip_bnum, 1)) == NULL)
! 2276: return FAIL;
! 2277: pp = (PTR_BL *)(hp->bh_data); /* must be pointer block */
! 2278: if (pp->pb_id != PTR_ID)
! 2279: {
! 2280: EMSG("pointer block id wrong 4");
! 2281: mf_put(mfp, hp, FALSE, FALSE);
! 2282: return FAIL;
! 2283: }
! 2284: count = --(pp->pb_count);
! 2285: if (count == 0) /* the pointer block becomes empty! */
! 2286: mf_free(mfp, hp);
! 2287: else
! 2288: {
! 2289: if (count != idx) /* move entries after the deleted one */
! 2290: vim_memmove(&pp->pb_pointer[idx], &pp->pb_pointer[idx + 1],
! 2291: (size_t)(count - idx) * sizeof(PTR_EN));
! 2292: mf_put(mfp, hp, TRUE, FALSE);
! 2293:
! 2294: buf->b_ml.ml_stack_top = stack_idx; /* truncate stack */
! 2295: /* fix line count for rest of blocks in the stack */
! 2296: if (buf->b_ml.ml_locked_lineadd)
! 2297: {
! 2298: ml_lineadd(buf, buf->b_ml.ml_locked_lineadd);
! 2299: buf->b_ml.ml_stack[buf->b_ml.ml_stack_top].ip_high +=
! 2300: buf->b_ml.ml_locked_lineadd;
! 2301: }
! 2302: ++(buf->b_ml.ml_stack_top);
! 2303:
! 2304: return OK;
! 2305: }
! 2306: }
! 2307: CHECK(1, "deleted block 1?");
! 2308:
! 2309: return OK;
! 2310: }
! 2311:
! 2312: /*
! 2313: * delete the text by moving the next lines forwards
! 2314: */
! 2315: text_start = dp->db_txt_start;
! 2316: line_start = ((dp->db_index[idx]) & DB_INDEX_MASK);
! 2317: if (idx == 0) /* first line in block, text at the end */
! 2318: line_size = dp->db_txt_end - line_start;
! 2319: else
! 2320: line_size = ((dp->db_index[idx - 1]) & DB_INDEX_MASK) - line_start;
! 2321: vim_memmove((char *)dp + text_start + line_size, (char *)dp + text_start,
! 2322: (size_t)(line_start - text_start));
! 2323:
! 2324: /*
! 2325: * delete the index by moving the next indexes backwards
! 2326: * Adjust the indexes for the text movement.
! 2327: */
! 2328: for (i = idx; i < count - 1; ++i)
! 2329: dp->db_index[i] = dp->db_index[i + 1] + line_size;
! 2330:
! 2331: dp->db_free += line_size + INDEX_SIZE;
! 2332: dp->db_txt_start += line_size;
! 2333: --(dp->db_line_count);
! 2334:
! 2335: /*
! 2336: * mark the block dirty and make sure it is in the file (for recovery)
! 2337: */
! 2338: buf->b_ml.ml_flags |= (ML_LOCKED_DIRTY | ML_LOCKED_POS);
! 2339:
! 2340: return OK;
! 2341: }
! 2342:
! 2343: /*
! 2344: * set the B_MARKED flag for line 'lnum'
! 2345: */
! 2346: void
! 2347: ml_setmarked(lnum)
! 2348: linenr_t lnum;
! 2349: {
! 2350: BHDR *hp;
! 2351: DATA_BL *dp;
! 2352: /* invalid line number */
! 2353: if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count ||
! 2354: curbuf->b_ml.ml_mfp == NULL)
! 2355: return; /* give error message? */
! 2356:
! 2357: if (lowest_marked == 0 || lowest_marked > lnum)
! 2358: lowest_marked = lnum;
! 2359:
! 2360: /*
! 2361: * find the data block containing the line
! 2362: * This also fills the stack with the blocks from the root to the data block
! 2363: * This also releases any locked block.
! 2364: */
! 2365: if ((hp = ml_find_line(curbuf, lnum, ML_FIND)) == NULL)
! 2366: return; /* give error message? */
! 2367:
! 2368: dp = (DATA_BL *)(hp->bh_data);
! 2369: dp->db_index[lnum - curbuf->b_ml.ml_locked_low] |= DB_MARKED;
! 2370: curbuf->b_ml.ml_flags |= ML_LOCKED_DIRTY;
! 2371: }
! 2372:
! 2373: /*
! 2374: * find the first line with its B_MARKED flag set
! 2375: */
! 2376: linenr_t
! 2377: ml_firstmarked()
! 2378: {
! 2379: BHDR *hp;
! 2380: DATA_BL *dp;
! 2381: linenr_t lnum;
! 2382: int i;
! 2383:
! 2384: if (curbuf->b_ml.ml_mfp == NULL)
! 2385: return (linenr_t) 0;
! 2386:
! 2387: /*
! 2388: * The search starts with lowest_marked line. This is the last line where
! 2389: * a mark was found, adjusted by inserting/deleting lines.
! 2390: */
! 2391: for (lnum = lowest_marked; lnum <= curbuf->b_ml.ml_line_count; )
! 2392: {
! 2393: /*
! 2394: * Find the data block containing the line.
! 2395: * This also fills the stack with the blocks from the root to the data
! 2396: * block This also releases any locked block.
! 2397: */
! 2398: if ((hp = ml_find_line(curbuf, lnum, ML_FIND)) == NULL)
! 2399: return (linenr_t)0; /* give error message? */
! 2400:
! 2401: dp = (DATA_BL *)(hp->bh_data);
! 2402:
! 2403: for (i = lnum - curbuf->b_ml.ml_locked_low;
! 2404: lnum <= curbuf->b_ml.ml_locked_high; ++i, ++lnum)
! 2405: if ((dp->db_index[i]) & DB_MARKED)
! 2406: {
! 2407: (dp->db_index[i]) &= DB_INDEX_MASK;
! 2408: curbuf->b_ml.ml_flags |= ML_LOCKED_DIRTY;
! 2409: lowest_marked = lnum + 1;
! 2410: return lnum;
! 2411: }
! 2412: }
! 2413:
! 2414: return (linenr_t) 0;
! 2415: }
! 2416:
! 2417: /*
! 2418: * return TRUE if line 'lnum' has a mark
! 2419: */
! 2420: int
! 2421: ml_has_mark(lnum)
! 2422: linenr_t lnum;
! 2423: {
! 2424: BHDR *hp;
! 2425: DATA_BL *dp;
! 2426:
! 2427: if (curbuf->b_ml.ml_mfp == NULL ||
! 2428: (hp = ml_find_line(curbuf, lnum, ML_FIND)) == NULL)
! 2429: return FALSE;
! 2430:
! 2431: dp = (DATA_BL *)(hp->bh_data);
! 2432: return (int)((dp->db_index[lnum - curbuf->b_ml.ml_locked_low]) & DB_MARKED);
! 2433: }
! 2434:
! 2435: /*
! 2436: * clear all DB_MARKED flags
! 2437: */
! 2438: void
! 2439: ml_clearmarked()
! 2440: {
! 2441: BHDR *hp;
! 2442: DATA_BL *dp;
! 2443: linenr_t lnum;
! 2444: int i;
! 2445:
! 2446: if (curbuf->b_ml.ml_mfp == NULL) /* nothing to do */
! 2447: return;
! 2448:
! 2449: /*
! 2450: * The search starts with line lowest_marked.
! 2451: */
! 2452: for (lnum = lowest_marked; lnum <= curbuf->b_ml.ml_line_count; )
! 2453: {
! 2454: /*
! 2455: * Find the data block containing the line.
! 2456: * This also fills the stack with the blocks from the root to the data block
! 2457: * This also releases any locked block.
! 2458: */
! 2459: if ((hp = ml_find_line(curbuf, lnum, ML_FIND)) == NULL)
! 2460: return; /* give error message? */
! 2461:
! 2462: dp = (DATA_BL *)(hp->bh_data);
! 2463:
! 2464: for (i = lnum - curbuf->b_ml.ml_locked_low;
! 2465: lnum <= curbuf->b_ml.ml_locked_high; ++i, ++lnum)
! 2466: if ((dp->db_index[i]) & DB_MARKED)
! 2467: {
! 2468: (dp->db_index[i]) &= DB_INDEX_MASK;
! 2469: curbuf->b_ml.ml_flags |= ML_LOCKED_DIRTY;
! 2470: }
! 2471: }
! 2472:
! 2473: lowest_marked = 0;
! 2474: return;
! 2475: }
! 2476:
! 2477: /*
! 2478: * flush ml_line if necessary
! 2479: */
! 2480: static void
! 2481: ml_flush_line(buf)
! 2482: BUF *buf;
! 2483: {
! 2484: BHDR *hp;
! 2485: DATA_BL *dp;
! 2486: linenr_t lnum;
! 2487: char_u *new_line;
! 2488: char_u *old_line;
! 2489: colnr_t new_len;
! 2490: int old_len;
! 2491: int extra;
! 2492: int idx;
! 2493: int start;
! 2494: int count;
! 2495: int i;
! 2496:
! 2497: if (buf->b_ml.ml_line_lnum == 0 ||
! 2498: buf->b_ml.ml_mfp == NULL) /* nothing to do */
! 2499: return;
! 2500:
! 2501: if (buf->b_ml.ml_flags & ML_LINE_DIRTY)
! 2502: {
! 2503: lnum = buf->b_ml.ml_line_lnum;
! 2504: new_line = buf->b_ml.ml_line_ptr;
! 2505:
! 2506: hp = ml_find_line(buf, lnum, ML_FIND);
! 2507: if (hp == NULL)
! 2508: EMSGN("Cannot find line %ld", lnum);
! 2509: else
! 2510: {
! 2511: dp = (DATA_BL *)(hp->bh_data);
! 2512: idx = lnum - buf->b_ml.ml_locked_low;
! 2513: start = ((dp->db_index[idx]) & DB_INDEX_MASK);
! 2514: old_line = (char_u *)dp + start;
! 2515: if (idx == 0) /* line is last in block */
! 2516: old_len = dp->db_txt_end - start;
! 2517: else /* text of previous line follows */
! 2518: old_len = (dp->db_index[idx - 1] & DB_INDEX_MASK) - start;
! 2519: new_len = STRLEN(new_line) + 1;
! 2520: extra = new_len - old_len; /* negative if lines gets smaller */
! 2521:
! 2522: /*
! 2523: * if new line fits in data block, replace directly
! 2524: */
! 2525: if ((int)dp->db_free >= extra)
! 2526: {
! 2527: /* if the length changes and there are following lines */
! 2528: count = buf->b_ml.ml_locked_high - buf->b_ml.ml_locked_low + 1;
! 2529: if (extra != 0 && idx < count - 1)
! 2530: {
! 2531: /* move text of following lines */
! 2532: vim_memmove((char *)dp + dp->db_txt_start - extra,
! 2533: (char *)dp + dp->db_txt_start,
! 2534: (size_t)(start - dp->db_txt_start));
! 2535:
! 2536: /* adjust pointers of this and following lines */
! 2537: for (i = idx + 1; i < count; ++i)
! 2538: dp->db_index[i] -= extra;
! 2539: }
! 2540: dp->db_index[idx] -= extra;
! 2541:
! 2542: /* adjust free space */
! 2543: dp->db_free -= extra;
! 2544: dp->db_txt_start -= extra;
! 2545:
! 2546: /* copy new line into the data block */
! 2547: vim_memmove(old_line - extra, new_line, (size_t)new_len);
! 2548: buf->b_ml.ml_flags |= (ML_LOCKED_DIRTY | ML_LOCKED_POS);
! 2549: }
! 2550: else
! 2551: {
! 2552: /*
! 2553: * Cannot do it in one data block: delete and append.
! 2554: */
! 2555: /* How about handling errors??? */
! 2556: (void)ml_delete_int(buf, lnum, FALSE);
! 2557: (void)ml_append_int(buf, lnum - 1, new_line, new_len, FALSE);
! 2558: }
! 2559: }
! 2560: vim_free(new_line);
! 2561: }
! 2562:
! 2563: buf->b_ml.ml_line_lnum = 0;
! 2564: }
! 2565:
! 2566: /*
! 2567: * create a new, empty, data block
! 2568: */
! 2569: static BHDR *
! 2570: ml_new_data(mfp, negative, page_count)
! 2571: MEMFILE *mfp;
! 2572: int negative;
! 2573: int page_count;
! 2574: {
! 2575: BHDR *hp;
! 2576: DATA_BL *dp;
! 2577:
! 2578: if ((hp = mf_new(mfp, negative, page_count)) == NULL)
! 2579: return NULL;
! 2580:
! 2581: dp = (DATA_BL *)(hp->bh_data);
! 2582: dp->db_id = DATA_ID;
! 2583: dp->db_txt_start = dp->db_txt_end = page_count * mfp->mf_page_size;
! 2584: dp->db_free = dp->db_txt_start - HEADER_SIZE;
! 2585: dp->db_line_count = 0;
! 2586:
! 2587: return hp;
! 2588: }
! 2589:
! 2590: /*
! 2591: * create a new, empty, pointer block
! 2592: */
! 2593: static BHDR *
! 2594: ml_new_ptr(mfp)
! 2595: MEMFILE *mfp;
! 2596: {
! 2597: BHDR *hp;
! 2598: PTR_BL *pp;
! 2599:
! 2600: if ((hp = mf_new(mfp, FALSE, 1)) == NULL)
! 2601: return NULL;
! 2602:
! 2603: pp = (PTR_BL *)(hp->bh_data);
! 2604: pp->pb_id = PTR_ID;
! 2605: pp->pb_count = 0;
! 2606: pp->pb_count_max = (mfp->mf_page_size - sizeof(PTR_BL)) / sizeof(PTR_EN) + 1;
! 2607:
! 2608: return hp;
! 2609: }
! 2610:
! 2611: /*
! 2612: * lookup line 'lnum' in a memline
! 2613: *
! 2614: * action: if ML_DELETE or ML_INSERT the line count is updated while searching
! 2615: * if ML_FLUSH only flush a locked block
! 2616: * if ML_FIND just find the line
! 2617: *
! 2618: * If the block was found it is locked and put in ml_locked.
! 2619: * The stack is updated to lead to the locked block. The ip_high field in
! 2620: * the stack is updated to reflect the last line in the block AFTER the
! 2621: * insert or delete, also if the pointer block has not been updated yet. But
! 2622: * if if ml_locked != NULL ml_locked_lineadd must be added to ip_high.
! 2623: *
! 2624: * return: NULL for failure, pointer to block header otherwise
! 2625: */
! 2626: static BHDR *
! 2627: ml_find_line(buf, lnum, action)
! 2628: BUF *buf;
! 2629: linenr_t lnum;
! 2630: int action;
! 2631: {
! 2632: DATA_BL *dp;
! 2633: PTR_BL *pp;
! 2634: IPTR *ip;
! 2635: BHDR *hp;
! 2636: MEMFILE *mfp;
! 2637: linenr_t t;
! 2638: blocknr_t bnum, bnum2;
! 2639: int dirty;
! 2640: linenr_t low, high;
! 2641: int top;
! 2642: int page_count;
! 2643: int idx;
! 2644:
! 2645: mfp = buf->b_ml.ml_mfp;
! 2646:
! 2647: /*
! 2648: * If there is a locked block check if the wanted line is in it.
! 2649: * If not, flush and release the locked block.
! 2650: * Don't do this for ML_INSERT_SAME, because the stack need to be updated.
! 2651: * Don't do this for ML_FLUSH, because we want to flush the locked block.
! 2652: */
! 2653: if (buf->b_ml.ml_locked)
! 2654: {
! 2655: if (ML_SIMPLE(action) && buf->b_ml.ml_locked_low <= lnum &&
! 2656: buf->b_ml.ml_locked_high >= lnum)
! 2657: {
! 2658: /* remember to update pointer blocks and stack later */
! 2659: if (action == ML_INSERT)
! 2660: {
! 2661: ++(buf->b_ml.ml_locked_lineadd);
! 2662: ++(buf->b_ml.ml_locked_high);
! 2663: }
! 2664: else if (action == ML_DELETE)
! 2665: {
! 2666: --(buf->b_ml.ml_locked_lineadd);
! 2667: --(buf->b_ml.ml_locked_high);
! 2668: }
! 2669: return (buf->b_ml.ml_locked);
! 2670: }
! 2671:
! 2672: mf_put(mfp, buf->b_ml.ml_locked, buf->b_ml.ml_flags & ML_LOCKED_DIRTY,
! 2673: buf->b_ml.ml_flags & ML_LOCKED_POS);
! 2674: buf->b_ml.ml_locked = NULL;
! 2675:
! 2676: /*
! 2677: * if lines have been added or deleted in the locked block, need to
! 2678: * update the line count in pointer blocks
! 2679: */
! 2680: if (buf->b_ml.ml_locked_lineadd)
! 2681: ml_lineadd(buf, buf->b_ml.ml_locked_lineadd);
! 2682: }
! 2683:
! 2684: if (action == ML_FLUSH) /* nothing else to do */
! 2685: return NULL;
! 2686:
! 2687: bnum = 1; /* start at the root of the tree */
! 2688: page_count = 1;
! 2689: low = 1;
! 2690: high = buf->b_ml.ml_line_count;
! 2691:
! 2692: if (action == ML_FIND) /* first try stack entries */
! 2693: {
! 2694: for (top = buf->b_ml.ml_stack_top - 1; top >= 0; --top)
! 2695: {
! 2696: ip = &(buf->b_ml.ml_stack[top]);
! 2697: if (ip->ip_low <= lnum && ip->ip_high >= lnum)
! 2698: {
! 2699: bnum = ip->ip_bnum;
! 2700: low = ip->ip_low;
! 2701: high = ip->ip_high;
! 2702: buf->b_ml.ml_stack_top = top; /* truncate stack at prev entry */
! 2703: break;
! 2704: }
! 2705: }
! 2706: if (top < 0)
! 2707: buf->b_ml.ml_stack_top = 0; /* not found, start at the root */
! 2708: }
! 2709: else /* ML_DELETE or ML_INSERT */
! 2710: buf->b_ml.ml_stack_top = 0; /* start at the root */
! 2711:
! 2712: /*
! 2713: * search downwards in the tree until a data block is found
! 2714: */
! 2715: for (;;)
! 2716: {
! 2717: if ((hp = mf_get(mfp, bnum, page_count)) == NULL)
! 2718: goto error_noblock;
! 2719:
! 2720: /*
! 2721: * update high for insert/delete
! 2722: */
! 2723: if (action == ML_INSERT)
! 2724: ++high;
! 2725: else if (action == ML_DELETE)
! 2726: --high;
! 2727:
! 2728: dp = (DATA_BL *)(hp->bh_data);
! 2729: if (dp->db_id == DATA_ID) /* data block */
! 2730: {
! 2731: buf->b_ml.ml_locked = hp;
! 2732: buf->b_ml.ml_locked_low = low;
! 2733: buf->b_ml.ml_locked_high = high;
! 2734: buf->b_ml.ml_locked_lineadd = 0;
! 2735: buf->b_ml.ml_flags &= ~(ML_LOCKED_DIRTY | ML_LOCKED_POS);
! 2736: return hp;
! 2737: }
! 2738:
! 2739: pp = (PTR_BL *)(dp); /* must be pointer block */
! 2740: if (pp->pb_id != PTR_ID)
! 2741: {
! 2742: EMSG("pointer block id wrong");
! 2743: goto error_block;
! 2744: }
! 2745:
! 2746: if ((top = ml_add_stack(buf)) < 0) /* add new entry to stack */
! 2747: goto error_block;
! 2748: ip = &(buf->b_ml.ml_stack[top]);
! 2749: ip->ip_bnum = bnum;
! 2750: ip->ip_low = low;
! 2751: ip->ip_high = high;
! 2752: ip->ip_index = -1; /* index not known yet */
! 2753:
! 2754: dirty = FALSE;
! 2755: for (idx = 0; idx < (int)pp->pb_count; ++idx)
! 2756: {
! 2757: t = pp->pb_pointer[idx].pe_line_count;
! 2758: CHECK(t == 0, "pe_line_count is zero");
! 2759: if ((low += t) > lnum)
! 2760: {
! 2761: ip->ip_index = idx;
! 2762: bnum = pp->pb_pointer[idx].pe_bnum;
! 2763: page_count = pp->pb_pointer[idx].pe_page_count;
! 2764: high = low - 1;
! 2765: low -= t;
! 2766:
! 2767: /*
! 2768: * a negative block number may have been changed
! 2769: */
! 2770: if (bnum < 0)
! 2771: {
! 2772: bnum2 = mf_trans_del(mfp, bnum);
! 2773: if (bnum != bnum2)
! 2774: {
! 2775: bnum = bnum2;
! 2776: pp->pb_pointer[idx].pe_bnum = bnum;
! 2777: dirty = TRUE;
! 2778: }
! 2779: }
! 2780:
! 2781: break;
! 2782: }
! 2783: }
! 2784: if (idx >= (int)pp->pb_count) /* past the end: something wrong! */
! 2785: {
! 2786: if (lnum > buf->b_ml.ml_line_count)
! 2787: EMSGN("line number out of range: %ld past the end",
! 2788: lnum - buf->b_ml.ml_line_count);
! 2789:
! 2790: else
! 2791: EMSGN("line count wrong in block %ld", bnum);
! 2792: goto error_block;
! 2793: }
! 2794: if (action == ML_DELETE)
! 2795: {
! 2796: pp->pb_pointer[idx].pe_line_count--;
! 2797: dirty = TRUE;
! 2798: }
! 2799: else if (action == ML_INSERT)
! 2800: {
! 2801: pp->pb_pointer[idx].pe_line_count++;
! 2802: dirty = TRUE;
! 2803: }
! 2804: mf_put(mfp, hp, dirty, FALSE);
! 2805: }
! 2806:
! 2807: error_block:
! 2808: mf_put(mfp, hp, FALSE, FALSE);
! 2809: error_noblock:
! 2810: /*
! 2811: * If action is ML_DELETE or ML_INSERT we have to correct the tree for
! 2812: * the incremented/decremented line counts, because there won't be a line
! 2813: * inserted/deleted after all.
! 2814: */
! 2815: if (action == ML_DELETE)
! 2816: ml_lineadd(buf, 1);
! 2817: else if (action == ML_INSERT)
! 2818: ml_lineadd(buf, -1);
! 2819: buf->b_ml.ml_stack_top = 0;
! 2820: return NULL;
! 2821: }
! 2822:
! 2823: /*
! 2824: * add an entry to the info pointer stack
! 2825: *
! 2826: * return -1 for failure, number of the new entry otherwise
! 2827: */
! 2828: static int
! 2829: ml_add_stack(buf)
! 2830: BUF *buf;
! 2831: {
! 2832: int top;
! 2833: IPTR *newstack;
! 2834:
! 2835: top = buf->b_ml.ml_stack_top;
! 2836:
! 2837: /* may have to increase the stack size */
! 2838: if (top == buf->b_ml.ml_stack_size)
! 2839: {
! 2840: CHECK(top > 0, "Stack size increases"); /* more than 5 levels??? */
! 2841:
! 2842: newstack = (IPTR *)alloc((unsigned)sizeof(IPTR) *
! 2843: (buf->b_ml.ml_stack_size + STACK_INCR));
! 2844: if (newstack == NULL)
! 2845: return -1;
! 2846: vim_memmove(newstack, buf->b_ml.ml_stack, (size_t)top * sizeof(IPTR));
! 2847: vim_free(buf->b_ml.ml_stack);
! 2848: buf->b_ml.ml_stack = newstack;
! 2849: buf->b_ml.ml_stack_size += STACK_INCR;
! 2850: }
! 2851:
! 2852: buf->b_ml.ml_stack_top++;
! 2853: return top;
! 2854: }
! 2855:
! 2856: /*
! 2857: * Update the pointer blocks on the stack for inserted/deleted lines.
! 2858: * The stack itself is also updated.
! 2859: *
! 2860: * When a insert/delete line action fails, the line is not inserted/deleted,
! 2861: * but the pointer blocks have already been updated. That is fixed here by
! 2862: * walking through the stack.
! 2863: *
! 2864: * Count is the number of lines added, negative if lines have been deleted.
! 2865: */
! 2866: static void
! 2867: ml_lineadd(buf, count)
! 2868: BUF *buf;
! 2869: int count;
! 2870: {
! 2871: int idx;
! 2872: IPTR *ip;
! 2873: PTR_BL *pp;
! 2874: MEMFILE *mfp = buf->b_ml.ml_mfp;
! 2875: BHDR *hp;
! 2876:
! 2877: for (idx = buf->b_ml.ml_stack_top - 1; idx >= 0; --idx)
! 2878: {
! 2879: ip = &(buf->b_ml.ml_stack[idx]);
! 2880: if ((hp = mf_get(mfp, ip->ip_bnum, 1)) == NULL)
! 2881: break;
! 2882: pp = (PTR_BL *)(hp->bh_data); /* must be pointer block */
! 2883: if (pp->pb_id != PTR_ID)
! 2884: {
! 2885: mf_put(mfp, hp, FALSE, FALSE);
! 2886: EMSG("pointer block id wrong 2");
! 2887: break;
! 2888: }
! 2889: pp->pb_pointer[ip->ip_index].pe_line_count += count;
! 2890: ip->ip_high += count;
! 2891: mf_put(mfp, hp, TRUE, FALSE);
! 2892: }
! 2893: }
! 2894:
! 2895: /*
! 2896: * make swap file name out of the filename and a directory name
! 2897: */
! 2898: static char_u *
! 2899: makeswapname(buf, dir_name)
! 2900: BUF *buf;
! 2901: char_u *dir_name;
! 2902: {
! 2903: char_u *r, *s, *fname;
! 2904:
! 2905: #ifdef VMS
! 2906: r = modname(buf->b_xfilename, (char_u *)"_swp");
! 2907: #else
! 2908: r = modname(buf->b_xfilename, (char_u *)".swp");
! 2909: #endif
! 2910: /*
! 2911: * do not use dir_name
! 2912: * - if dir_name starts with '.' (use current directory)
! 2913: * - if out of memory
! 2914: */
! 2915: if (*dir_name == '.' || r == NULL)
! 2916: return r;
! 2917:
! 2918: fname = gettail(r);
! 2919: s = concat_fnames(dir_name, fname, TRUE);
! 2920: vim_free(r);
! 2921: return s;
! 2922: }
! 2923:
! 2924: /*
! 2925: * Find out what name to use for the swap file for buffer 'buf'.
! 2926: *
! 2927: * Several names are tried to find one that does not exist
! 2928: *
! 2929: * Note: if MAXNAMLEN is not correct, you will get error messages for
! 2930: * not being able to open the swapfile
! 2931: */
! 2932: static char_u *
! 2933: findswapname(buf, dirp, old_fname)
! 2934: BUF *buf;
! 2935: char_u **dirp; /* pointer to list of directories */
! 2936: char_u *old_fname; /* don't give warning for this filename */
! 2937: {
! 2938: char_u *fname;
! 2939: int n;
! 2940: time_t x;
! 2941: char_u *dir_name;
! 2942:
! 2943: #ifdef AMIGA
! 2944: BPTR fh;
! 2945: #endif
! 2946:
! 2947: #ifndef SHORT_FNAME
! 2948: int r;
! 2949: FILE *dummyfd = NULL;
! 2950:
! 2951: /*
! 2952: * If we start editing a new file, e.g. "test.doc", which resides on an MSDOS
! 2953: * compatible filesystem, it is possible that the file "test.doc.swp" which we
! 2954: * create will be exactly the same file. To avoid this problem we temporarily
! 2955: * create "test.doc".
! 2956: */
! 2957: if (!(buf->b_p_sn || buf->b_shortname) && buf->b_xfilename &&
! 2958: getperm(buf->b_xfilename) < 0)
! 2959: dummyfd = fopen((char *)buf->b_xfilename, "w");
! 2960: #endif
! 2961:
! 2962: /*
! 2963: * Isolate a directory name from *dirp and put it in dir_name.
! 2964: * First allocate some memore to put the directory name in.
! 2965: */
! 2966: dir_name = alloc((unsigned)STRLEN(*dirp) + 1);
! 2967: if (dir_name != NULL)
! 2968: (void)copy_option_part(dirp, dir_name, 31000, ",");
! 2969:
! 2970: /*
! 2971: * we try different names until we find one that does not exist yet
! 2972: */
! 2973: if (dir_name == NULL) /* out of memory */
! 2974: fname = NULL;
! 2975: else
! 2976: fname = makeswapname(buf, dir_name);
! 2977:
! 2978: for (;;)
! 2979: {
! 2980: if (fname == NULL) /* must be out of memory */
! 2981: break;
! 2982: if ((n = STRLEN(fname)) == 0) /* safety check */
! 2983: {
! 2984: vim_free(fname);
! 2985: fname = NULL;
! 2986: break;
! 2987: }
! 2988: #if (defined(UNIX) || defined(OS2)) && !defined(ARCHIE) && !defined(SHORT_FNAME)
! 2989: /*
! 2990: * Some systems have a MS-DOS compatible filesystem that use 8.3 character
! 2991: * file names. If this is the first try and the swap file name does not fit in
! 2992: * 8.3, detect if this is the case, set shortname and try again.
! 2993: */
! 2994: if (fname[n - 1] == 'p' && !(buf->b_p_sn || buf->b_shortname))
! 2995: {
! 2996: char_u *tail;
! 2997: char_u *fname2;
! 2998: struct stat s1, s2;
! 2999: int f1, f2;
! 3000: int created1 = FALSE, created2 = FALSE;
! 3001: int same = FALSE;
! 3002:
! 3003: /*
! 3004: * Check if swapfilename does not fit in 8.3:
! 3005: * It either contains two dots or it is longer than 8 chars.
! 3006: */
! 3007: tail = gettail(buf->b_xfilename);
! 3008: if (vim_strchr(tail, '.') != NULL || STRLEN(tail) > (size_t)8)
! 3009: {
! 3010: fname2 = alloc(n + 1);
! 3011: if (fname2 != NULL)
! 3012: {
! 3013: STRCPY(fname2, fname);
! 3014: if (vim_strchr(tail, '.') != NULL)
! 3015: fname2[n - 1] = 'x'; /* change ".swp" to ".swx" */
! 3016: else
! 3017: fname2[n - 5] += 1; /* change "x.swp" to "y.swp" */
! 3018: /*
! 3019: * may need to create the files to be able to use stat()
! 3020: */
! 3021: f1 = open((char *)fname, O_RDONLY | O_EXTRA);
! 3022: if (f1 < 0)
! 3023: {
! 3024: f1 = open((char *)fname, O_RDWR|O_CREAT|O_EXCL|O_EXTRA
! 3025: #ifdef AMIGA /* Amiga has no mode argument */
! 3026: );
! 3027: #endif
! 3028: #ifdef UNIX /* open in rw------- mode */
! 3029: , (mode_t)0600);
! 3030: #endif
! 3031: #if defined(MSDOS) || defined(WIN32) || defined(OS2) /* open read/write */
! 3032: , S_IREAD | S_IWRITE);
! 3033: #endif
! 3034: #if defined(OS2)
! 3035: if (f1 < 0 && errno == ENOENT)
! 3036: same = TRUE;
! 3037: #endif
! 3038: created1 = TRUE;
! 3039: }
! 3040: if (f1 >= 0)
! 3041: {
! 3042: f2 = open((char *)fname2, O_RDONLY | O_EXTRA);
! 3043: if (f2 < 0)
! 3044: {
! 3045: f2 = open((char *)fname2,
! 3046: O_RDWR|O_CREAT|O_EXCL|O_EXTRA
! 3047: #ifdef AMIGA /* Amiga has no mode argument */
! 3048: );
! 3049: #endif
! 3050: #ifdef UNIX /* open in rw------- mode */
! 3051: , (mode_t)0600);
! 3052: #endif
! 3053: #if defined(MSDOS) || defined(WIN32) || defined(OS2) /* open read/write */
! 3054: , S_IREAD | S_IWRITE);
! 3055: #endif
! 3056: created2 = TRUE;
! 3057: }
! 3058: if (f2 >= 0)
! 3059: {
! 3060: /*
! 3061: * Both files exist now. If stat() returns the
! 3062: * same device and inode they are the same file.
! 3063: */
! 3064: if (fstat(f1, &s1) != -1 &&
! 3065: fstat(f2, &s2) != -1 &&
! 3066: s1.st_dev == s2.st_dev &&
! 3067: s1.st_ino == s2.st_ino)
! 3068: same = TRUE;
! 3069: close(f2);
! 3070: if (created2)
! 3071: vim_remove(fname2);
! 3072: }
! 3073: close(f1);
! 3074: if (created1)
! 3075: vim_remove(fname);
! 3076: }
! 3077: vim_free(fname2);
! 3078: if (same)
! 3079: {
! 3080: buf->b_shortname = TRUE;
! 3081: vim_free(fname);
! 3082: fname = makeswapname(buf, dir_name);
! 3083: continue; /* try again with b_shortname set */
! 3084: }
! 3085: }
! 3086: }
! 3087: }
! 3088: #endif
! 3089: /*
! 3090: * check if the swapfile already exists
! 3091: */
! 3092: if (getperm(fname) < 0) /* it does not exist */
! 3093: {
! 3094: #ifdef AMIGA
! 3095: fh = Open((UBYTE *)fname, (long)MODE_NEWFILE);
! 3096: /*
! 3097: * on the Amiga getperm() will return -1 when the file exists but
! 3098: * is being used by another program. This happens if you edit
! 3099: * a file twice.
! 3100: */
! 3101: if (fh != (BPTR)NULL) /* can open file, OK */
! 3102: {
! 3103: Close(fh);
! 3104: break;
! 3105: }
! 3106: if (IoErr() != ERROR_OBJECT_IN_USE &&
! 3107: IoErr() != ERROR_OBJECT_EXISTS)
! 3108: #endif
! 3109: break;
! 3110: }
! 3111: /*
! 3112: * A file name equal to old_fname is OK to use.
! 3113: */
! 3114: if (old_fname != NULL && fnamecmp(fname, old_fname) == 0)
! 3115: break;
! 3116:
! 3117: /*
! 3118: * get here when file already exists
! 3119: */
! 3120: if (fname[n - 1] == 'p') /* first try */
! 3121: {
! 3122: #ifndef SHORT_FNAME
! 3123: /*
! 3124: * on MS-DOS compatible filesystems (e.g. messydos) file.doc.swp
! 3125: * and file.doc are the same file. To guess if this problem is
! 3126: * present try if file.doc.swx exists. If it does, we set
! 3127: * buf->b_shortname and try file_doc.swp (dots replaced by
! 3128: * underscores for this file), and try again. If it doesn't we
! 3129: * assume that "file.doc.swp" already exists.
! 3130: */
! 3131: if (!(buf->b_p_sn || buf->b_shortname)) /* not tried yet */
! 3132: {
! 3133: fname[n - 1] = 'x';
! 3134: r = getperm(fname); /* try "file.swx" */
! 3135: fname[n - 1] = 'p';
! 3136: if (r >= 0) /* "file.swx" seems to exist */
! 3137: {
! 3138: buf->b_shortname = TRUE;
! 3139: vim_free(fname);
! 3140: fname = makeswapname(buf, dir_name);
! 3141: continue; /* try again with '.' replaced by '_' */
! 3142: }
! 3143: }
! 3144: #endif
! 3145: /*
! 3146: * If we get here the ".swp" file really exists.
! 3147: * Give an error message, unless recovering, no file name, we are
! 3148: * viewing a help file or when the path of the file is different
! 3149: * (happens when all .swp files are in one directory).
! 3150: */
! 3151: if (!recoverymode && buf->b_xfilename != NULL && !buf->b_help)
! 3152: {
! 3153: int fd;
! 3154: struct block0 b0;
! 3155: int differ = FALSE;
! 3156:
! 3157: /*
! 3158: * Try to read block 0 from the swap file to get the original
! 3159: * file name (and inode number).
! 3160: */
! 3161: fd = open((char *)fname, O_RDONLY | O_EXTRA);
! 3162: if (fd >= 0)
! 3163: {
! 3164: if (read(fd, (char *)&b0, sizeof(b0)) == sizeof(b0))
! 3165: {
! 3166: /*
! 3167: * The name in the swap file may be "~user/path/file".
! 3168: * Expand it first.
! 3169: */
! 3170: expand_env(b0.b0_fname, NameBuff, MAXPATHL);
! 3171: #ifdef CHECK_INODE
! 3172: if (fnamecmp_ino(buf->b_filename, NameBuff,
! 3173: char_to_long(b0.b0_ino)))
! 3174: differ = TRUE;
! 3175: #else
! 3176: if (fnamecmp(NameBuff, buf->b_filename) != 0)
! 3177: differ = TRUE;
! 3178: #endif
! 3179: }
! 3180: close(fd);
! 3181: }
! 3182: if (differ == FALSE)
! 3183: {
! 3184: struct stat st;
! 3185:
! 3186: ++no_wait_return;
! 3187: #ifdef SLEEP_IN_EMSG
! 3188: ++dont_sleep;
! 3189: #endif
! 3190: (void)EMSG("ATTENTION");
! 3191: #ifdef SLEEP_IN_EMSG
! 3192: --dont_sleep;
! 3193: #endif
! 3194: MSG_OUTSTR("\nFound a swap file by the name \"");
! 3195: msg_home_replace(fname);
! 3196: MSG_OUTSTR("\"\n");
! 3197: swapfile_info(fname);
! 3198: MSG_OUTSTR("While opening file \"");
! 3199: msg_outtrans(buf->b_xfilename);
! 3200: MSG_OUTSTR("\"\n");
! 3201: if (stat((char *)buf->b_xfilename, &st) != -1)
! 3202: {
! 3203: MSG_OUTSTR(" dated: ");
! 3204: x = st.st_mtime; /* Manx C can't do &st.st_mtime */
! 3205: MSG_OUTSTR(ctime(&x));
! 3206: }
! 3207: MSG_OUTSTR("\n(1) Another program may be editing the same file.\n");
! 3208: MSG_OUTSTR(" If this is the case, quit this edit session to avoid having\n");
! 3209: MSG_OUTSTR(" two different instances of the same file when making changes.\n");
! 3210: MSG_OUTSTR("\n(2) An edit session for this file crashed.\n");
! 3211: MSG_OUTSTR(" If this is the case, use \":recover\" or \"vim -r ");
! 3212: msg_outtrans(buf->b_xfilename);
! 3213: MSG_OUTSTR("\"\n to recover the changes (see \":help recovery)\".\n");
! 3214: MSG_OUTSTR(" If you did this already, delete the swap file \"");
! 3215: msg_outtrans(fname);
! 3216: MSG_OUTSTR("\"\n to avoid this message.\n\n");
! 3217: cmdline_row = msg_row;
! 3218: --no_wait_return;
! 3219: need_wait_return = TRUE; /* call wait_return later */
! 3220: }
! 3221: }
! 3222: }
! 3223:
! 3224: if (fname[n - 1] == 'a') /* tried enough names, give up */
! 3225: {
! 3226: vim_free(fname);
! 3227: fname = NULL;
! 3228: break;
! 3229: }
! 3230: --fname[n - 1]; /* change last char of the name */
! 3231: }
! 3232:
! 3233: vim_free(dir_name);
! 3234: #ifndef SHORT_FNAME
! 3235: if (dummyfd) /* file has been created temporarily */
! 3236: {
! 3237: fclose(dummyfd);
! 3238: vim_remove(buf->b_xfilename);
! 3239: }
! 3240: #endif
! 3241: return fname;
! 3242: }
! 3243:
! 3244: static int
! 3245: b0_magic_wrong(b0p)
! 3246: ZERO_BL *b0p;
! 3247: {
! 3248: return (b0p->b0_magic_long != (long)B0_MAGIC_LONG ||
! 3249: b0p->b0_magic_int != (int)B0_MAGIC_INT ||
! 3250: b0p->b0_magic_short != (short)B0_MAGIC_SHORT ||
! 3251: b0p->b0_magic_char != B0_MAGIC_CHAR);
! 3252: }
! 3253:
! 3254: #ifdef CHECK_INODE
! 3255: /*
! 3256: * Compare current file name with file name from swap file.
! 3257: * Try to use inode numbers when possible.
! 3258: * Return non-zero when files are different.
! 3259: *
! 3260: * When comparing file names a few things have to be taken into consideration:
! 3261: * - When working over a network the full path of a file depends on the host.
! 3262: * We check the inode number if possible. It is not 100% reliable though,
! 3263: * because the device number cannot be used over a network.
! 3264: * - When a file does not exist yet (editing a new file) there is no inode
! 3265: * number.
! 3266: * - The file name in a swap file may not be valid on the current host. The
! 3267: * "~user" form is used whenever possible to avoid this.
! 3268: *
! 3269: * This is getting complicated, let's make a table:
! 3270: *
! 3271: * ino_c ino_s fname_c fname_s differ =
! 3272: *
! 3273: * both files exist -> compare inode numbers:
! 3274: * != 0 != 0 X X ino_c != ino_s
! 3275: *
! 3276: * inode number(s) unknown, file names available -> compare file names
! 3277: * == 0 X OK OK fname_c != fname_s
! 3278: * X == 0 OK OK fname_c != fname_s
! 3279: *
! 3280: * current file doesn't exist, file for swap file exist, file name(s) not
! 3281: * available -> probably different
! 3282: * == 0 != 0 FAIL X TRUE
! 3283: * == 0 != 0 X FAIL TRUE
! 3284: *
! 3285: * current file exists, inode for swap unknown, file name(s) not
! 3286: * available -> probably different
! 3287: * != 0 == 0 FAIL X TRUE
! 3288: * != 0 == 0 X FAIL TRUE
! 3289: *
! 3290: * current file doesn't exist, inode for swap unknown, one file name not
! 3291: * available -> probably different
! 3292: * == 0 == 0 FAIL OK TRUE
! 3293: * == 0 == 0 OK FAIL TRUE
! 3294: *
! 3295: * current file doesn't exist, inode for swap unknown, both file names not
! 3296: * available -> probably same file
! 3297: * == 0 == 0 FAIL FAIL FALSE
! 3298: */
! 3299:
! 3300: static int
! 3301: fnamecmp_ino(fname_c, fname_s, ino_block0)
! 3302: char_u *fname_c; /* current file name */
! 3303: char_u *fname_s; /* file name from swap file */
! 3304: long ino_block0;
! 3305: {
! 3306: struct stat st;
! 3307: long ino_c = 0; /* ino of current file */
! 3308: long ino_s; /* ino of file from swap file */
! 3309: char_u buf_c[MAXPATHL]; /* full path of fname_c */
! 3310: char_u buf_s[MAXPATHL]; /* full path of fname_s */
! 3311: int retval_c; /* flag: buf_c valid */
! 3312: int retval_s; /* flag: buf_s valid */
! 3313:
! 3314:
! 3315: if (stat((char *)fname_c, &st) == 0)
! 3316: ino_c = st.st_ino;
! 3317:
! 3318: /*
! 3319: * First we try to get the inode from the file name, because the inode in
! 3320: * the swap file may be outdated. If that fails (e.g. this path is not
! 3321: * valid on this machine), use the inode from block 0.
! 3322: */
! 3323: if (stat((char *)fname_s, &st) == 0)
! 3324: ino_s = st.st_ino;
! 3325: else
! 3326: ino_s = ino_block0;
! 3327:
! 3328: if (ino_c && ino_s)
! 3329: return (ino_c != ino_s);
! 3330:
! 3331: /*
! 3332: * One of the inode numbers is unknown, try a forced FullName() and
! 3333: * compare the file names.
! 3334: */
! 3335: retval_c = FullName(fname_c, buf_c, MAXPATHL, TRUE);
! 3336: retval_s = FullName(fname_s, buf_s, MAXPATHL, TRUE);
! 3337: if (retval_c == OK && retval_s == OK)
! 3338: return (STRCMP(buf_c, buf_s) != 0);
! 3339:
! 3340: /*
! 3341: * Can't compare inodes or filenames, guess that the files are different,
! 3342: * unless both appear not to exist at all.
! 3343: */
! 3344: if (ino_s == 0 && ino_c == 0 && retval_c == FAIL && retval_s == FAIL)
! 3345: return FALSE;
! 3346: return TRUE;
! 3347: }
! 3348: #endif /* CHECK_INODE */
! 3349:
! 3350: /*
! 3351: * Move a long integer into a four byte character array.
! 3352: * Used for machine independency in block zero.
! 3353: */
! 3354: static void
! 3355: long_to_char(n, s)
! 3356: long n;
! 3357: char_u *s;
! 3358: {
! 3359: s[0] = (n & 0xff);
! 3360: n >>= 8;
! 3361: s[1] = (n & 0xff);
! 3362: n >>= 8;
! 3363: s[2] = (n & 0xff);
! 3364: n >>= 8;
! 3365: s[3] = (n & 0xff);
! 3366: }
! 3367:
! 3368: static long
! 3369: char_to_long(s)
! 3370: char_u *s;
! 3371: {
! 3372: long retval;
! 3373:
! 3374: retval = s[3];
! 3375: retval <<= 8;
! 3376: retval += s[2];
! 3377: retval <<= 8;
! 3378: retval += s[1];
! 3379: retval <<= 8;
! 3380: retval += s[0];
! 3381:
! 3382: return retval;
! 3383: }
![[BACK]](/icons/back.gif){kind=icon}
Return to memline.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / vim