From 268b92edcdb1ff4e1848ce50526bce287d3d1983 Mon Sep 17 00:00:00 2001 From: fiplox Date: Mon, 13 Dec 2021 10:44:21 +0100 Subject: [PATCH] ............ --- backtrace.c | 52 + cparse.c | 100 ++ cparse.c.~1~ | 121 ++ memline.c | 4322 ++++++++++++++++++++++++++++++++++++++++++++++++++ vec.c | 97 ++ vec.h | 23 +- 6 files changed, 4710 insertions(+), 5 deletions(-) create mode 100644 backtrace.c create mode 100644 cparse.c create mode 100644 cparse.c.~1~ create mode 100644 memline.c create mode 100644 vec.c diff --git a/backtrace.c b/backtrace.c new file mode 100644 index 0000000..51b27a3 --- /dev/null +++ b/backtrace.c @@ -0,0 +1,52 @@ +#include +#include +#include +#include + +void myfunc3(void) +{ + int j, nptrs; +#define SIZE 100 + void *buffer[100]; + char **strings; + + nptrs = backtrace(buffer, SIZE); + printf("backtrace() returned %d addresses\n", nptrs); + + /* The call backtrace_symbols_fd(buffer, nptrs, STDOUT_FILENO) + would produce similar output to the following: */ + + strings = backtrace_symbols(buffer, nptrs); + if (strings == NULL) { + perror("backtrace_symbols"); + exit(EXIT_FAILURE); + } + + for (j = 0; j < nptrs; j++) + printf("%s\n", strings[j]); + + free(strings); +} + +static void myfunc2(void) /* "static" means don't export the symbol... */ +{ + myfunc3(); +} + +void myfunc(int ncalls) +{ + if (ncalls > 1) + myfunc(ncalls - 1); + else + myfunc2(); +} + +int main(int argc, char *argv[]) +{ + if (argc != 2) { + fprintf(stderr, "%s num-calls\n", argv[0]); + exit(EXIT_FAILURE); + } + myfunc(atoi(argv[1])); + exit(EXIT_SUCCESS); +} diff --git a/cparse.c b/cparse.c new file mode 100644 index 0000000..2697d3b --- /dev/null +++ b/cparse.c @@ -0,0 +1,100 @@ +#include "vec.h" +#include +#include +#include +#include +#include +#include + +int find_funcs(const char *path) +{ + FILE *fp; + regex_t fdre, fcre; + int ret; + char line[1024]; + char boum[1024]; + regmatch_t rm[2]; + const char *re_func_decl = "^(\\w+(\\s+)?){2,}\\([^!@#$+%^]+?\\)\\s+"; + const char *re_func_call = "([a-zA-Z_0-9]+)\\(.*\\)"; + + fp = fopen(path, "r"); + if (fp == 0) { + fprintf(stderr, "Failed to open file %s (%d: %s)\n", path, errno, strerror(errno)); + return EXIT_FAILURE; + } + ret = regcomp(&fdre, re_func_decl, REG_EXTENDED); + if (ret != 0) { + fprintf(stderr, "Failed to compile regex '%s'\n", re_func_decl); + return EXIT_FAILURE; + } + ret = regcomp(&fcre, re_func_call, REG_EXTENDED); + if (ret != 0) { + fprintf(stderr, "Failed to compile regex '%s'\n", re_func_call); + return EXIT_FAILURE; + } + int i = 0; + bool in = false; + graph_vec g = new_graph(10); + int index; + int i1, i2 = -1; + while ((fgets(line, 1024, fp)) != NULL) { + if (in && line[0] == '}') { + in = false; + } + if (in) { + if (regexec(&fcre, line, 2, rm, 0) == 0) { + // printf("Line: <<%.*s>>\n", (int)(rm[0].rm_eo - rm[0].rm_so), line + rm[0].rm_so); + sprintf(boum, "%.*s", (int)(rm[1].rm_eo - rm[1].rm_so), line + rm[1].rm_so); + // printf("%.*s\n", (int)(rm[1].rm_eo - rm[1].rm_so), line + rm[1].rm_so); + if ((index = is_in(g, boum))) { + if (g.node[i2]->nbs == g.node[i2]->cap) + g.node[i2]->succ = reallocarray(g.node[i2]->succ, (g.node[i2]->cap += 5), sizeof(nodept)); + g.node[i2]->succ[i1] = g.node[index]; + g.node[i2]->nbs++; + i1++; + } else { + insert_node(&g, i, boum, false); + if (g.node[i2]->nbs == g.node[i2]->cap) + g.node[i2]->succ = reallocarray(g.node[i2]->succ, (g.node[i2]->cap += 5), sizeof(nodept)); + g.node[i2]->succ[i1] = g.node[i]; + g.node[i2]->nbs++; + i1++; + i++; + } + } + } else if (regexec(&fdre, line, 2, rm, 0) == 0) { + sprintf(boum, "%.*s", (int)(rm[1].rm_eo - rm[1].rm_so), line + rm[1].rm_so); + // printf("%.*s\n", (int)(rm[1].rm_eo - rm[1].rm_so), line + rm[1].rm_so); + insert_node(&g, i, boum, true); + i++; + i2++; + in = true; + i1 = 0; + } + } + // for (int j = 0; j < i; j++) { + // printf("NODE %d: %s\n", j, g.node[j]->func); + // for (int n = 0; n < g.node[j]->nbs; n++) { + // printf("SUCC %d: %s\n", j, g.node[j]->succ[n]->func); + // } + // } + print_node(g.node[0]); + regfree(&fdre); + regfree(&fcre); + fclose(fp); + delete_graph(&g); + return 0; +} + +int main(int argc, char *argv[]) +{ + find_funcs("./memline.c"); + // graph_vec g = new_graph(3); + // insert_node(&g, new_node(0), "main"); + // insert_node(&g, new_node(1), "main1"); + // insert_node(&g, new_node(2), "main2"); + // printf("%d %d %d\n", g.node[0]->num,g.node[1]->num,g.node[2]->num); + // printf("%s %s %s\n", g.func[0],g.func[1],g.func[2]); + // delete_graph(&g); + return 0; +} diff --git a/cparse.c.~1~ b/cparse.c.~1~ new file mode 100644 index 0000000..f42b194 --- /dev/null +++ b/cparse.c.~1~ @@ -0,0 +1,121 @@ +#include "vec.h" +#include +#include +#include +#include +#include +#include + +int find_funcs(const char *path) +{ + FILE *fp; + regex_t fdre, fcre; + int ret; + char line[1024]; + char boum[1024]; + regmatch_t rm[2]; + const char *re_func_decl = "^(\\w+(\\s+)?){2,}\\([^!@#$+%^]+?\\)\\s+"; + const char *re_func_call = "([a-zA-Z_0-9]+)\\(.*\\)"; + + fp = fopen(path, "r"); + if (fp == 0) { + fprintf(stderr, "Failed to open file %s (%d: %s)\n", path, errno, strerror(errno)); + return EXIT_FAILURE; + } + ret = regcomp(&fdre, re_func_decl, REG_EXTENDED); + if (ret != 0) { + fprintf(stderr, "Failed to compile regex '%s'\n", re_func_decl); + return EXIT_FAILURE; + } + ret = regcomp(&fcre, re_func_call, REG_EXTENDED); + if (ret != 0) { + fprintf(stderr, "Failed to compile regex '%s'\n", re_func_call); + return EXIT_FAILURE; + } + int i = 0; + bool in = false; + graph_vec g = new_graph(10); + // while ((fgets(line, 1024, fp)) != NULL) { + // if (regexec(&fdre, line, 2, rm, 0) == 0) { + // // printf("Line: <<%.*s>>\n", (int)(rm[0].rm_eo - rm[0].rm_so), line + rm[0].rm_so); + // sprintf(boum, "%.*s", (int)(rm[1].rm_eo - rm[1].rm_so), line + rm[1].rm_so); + // insert_node(&g, i, boum); + // i++; + // } + // } + // rewind(fp); + // i = -1; + int index; + int i1, i2 = -1; + while ((fgets(line, 1024, fp)) != NULL) { + if (in && line[0] == '}') { + in = false; + } + if (in) { + if (regexec(&fcre, line, 2, rm, 0) == 0) { + // printf("Line: <<%.*s>>\n", (int)(rm[0].rm_eo - rm[0].rm_so), line + rm[0].rm_so); + sprintf(boum, "%.*s", (int)(rm[1].rm_eo - rm[1].rm_so), line + rm[1].rm_so); + if ((index = is_in(g, boum))) { + if (g.node[i2]->nbs == g.node[i2]->cap) + g.node[i2]->succ = reallocarray(g.node[i2]->succ, (g.node[i2]->cap += 5), sizeof(nodept)); + // printf("NBS = %d %s\n", g.node[index]->num, g.func[index]); + // g.node[i]->succ = malloc(sizeof(nodept)); + g.node[i2]->succ[i1] = g.node[index]; + g.node[i2]->nbs++; + i1++; + // insert_succ(g.node[i], g.node[index]); + } else { + insert_node(&g, i, boum); + i++; + // if (g.node[i]->nbs == g.node[i]->cap) + // g.node[i]->succ = reallocarray(g.node[i]->succ, (g.node[i]->cap += 5), sizeof(nodept)); + // struct node *n = malloc(sizeof(struct node)); + // n->num = i; + // n->nbs = 0; + // // n->cap = 5; + // // n->succ = malloc(5 * sizeof(nodept)); + // strcpy(n->func, boum); + // g.node[i]->succ[i1] = n; + // g.node[i]->nbs++; + // i1++; + // insert_succ(&g, i, i1, boum); + // i1++; + } + } + } else if (regexec(&fdre, line, 2, rm, 0) == 0) { + sprintf(boum, "%.*s", (int)(rm[1].rm_eo - rm[1].rm_so), line + rm[1].rm_so); + insert_node(&g, i, boum); + i++; + i2++; + in = true; + i1 = 0; + } + } + for (int j = 0; j < i; j++) { + printf("NODE %d: %s\n",j, g.node[j]->func); + for (int n = 0; n < g.node[j]->nbs; n++) { + printf("SUCC %d: %s\n",j, g.node[j]->succ[n]->func); + } + } + // for (int j = 0; j < i; j++) { + // printf("fc %s\n", boum2[j]); + // } + regfree(&fdre); + regfree(&fcre); + fclose(fp); + delete_graph(&g); + return 0; +} + +int main(int argc, char *argv[]) +{ + find_funcs("./memline.c"); + // graph_vec g = new_graph(3); + // insert_node(&g, new_node(0), "main"); + // insert_node(&g, new_node(1), "main1"); + // insert_node(&g, new_node(2), "main2"); + // printf("%d %d %d\n", g.node[0]->num,g.node[1]->num,g.node[2]->num); + // printf("%s %s %s\n", g.func[0],g.func[1],g.func[2]); + // delete_graph(&g); + return 0; +} diff --git a/memline.c b/memline.c new file mode 100644 index 0000000..08202a6 --- /dev/null +++ b/memline.c @@ -0,0 +1,4322 @@ +// This is an open source non-commercial project. Dear PVS-Studio, please check +// it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com + +// for debugging +// #define CHECK(c, s) do { if (c) emsg(s); } while (0) +#define CHECK(c, s) do { } while (0) + +/* + * memline.c: Contains the functions for appending, deleting and changing the + * text lines. The memfile functions are used to store the information in + * blocks of memory, backed up by a file. The structure of the information is + * a tree. The root of the tree is a pointer block. The leaves of the tree + * are data blocks. In between may be several layers of pointer blocks, + * forming branches. + * + * Three types of blocks are used: + * - Block nr 0 contains information for recovery + * - Pointer blocks contain list of pointers to other blocks. + * - Data blocks contain the actual text. + * + * Block nr 0 contains the block0 structure (see below). + * + * Block nr 1 is the first pointer block. It is the root of the tree. + * Other pointer blocks are branches. + * + * If a line is too big to fit in a single page, the block containing that + * line is made big enough to hold the line. It may span several pages. + * Otherwise all blocks are one page. + * + * A data block that was filled when starting to edit a file and was not + * changed since then, can have a negative block number. This means that it + * has not yet been assigned a place in the file. When recovering, the lines + * in this data block can be read from the original file. When the block is + * changed (lines appended/deleted/changed) or when it is flushed it gets a + * positive number. Use mf_trans_del() to get the new number, before calling + * mf_get(). + */ + +#include +#include +#include +#include +#include +#include + +#include "nvim/ascii.h" +#include "nvim/buffer.h" +#include "nvim/change.h" +#include "nvim/cursor.h" +#include "nvim/eval.h" +#include "nvim/fileio.h" +#include "nvim/func_attr.h" +#include "nvim/getchar.h" +#include "nvim/main.h" +#include "nvim/mark.h" +#include "nvim/mbyte.h" +#include "nvim/memfile.h" +#include "nvim/memline.h" +#include "nvim/memory.h" +#include "nvim/message.h" +#include "nvim/misc1.h" +#include "nvim/option.h" +#include "nvim/os/input.h" +#include "nvim/os/os.h" +#include "nvim/os/process.h" +#include "nvim/os_unix.h" +#include "nvim/path.h" +#include "nvim/screen.h" +#include "nvim/sha256.h" +#include "nvim/spell.h" +#include "nvim/strings.h" +#include "nvim/ui.h" +#include "nvim/undo.h" +#include "nvim/version.h" +#include "nvim/vim.h" +#include "nvim/window.h" + +#ifndef UNIX // it's in os/unix_defs.h for Unix +# include +#endif + +typedef struct block0 ZERO_BL; // contents of the first block +typedef struct pointer_block PTR_BL; // contents of a pointer block +typedef struct data_block DATA_BL; // contents of a data block +typedef struct pointer_entry PTR_EN; // block/line-count pair + +#define DATA_ID (('d' << 8) + 'a') // data block id +#define PTR_ID (('p' << 8) + 't') // pointer block id +#define BLOCK0_ID0 'b' // block 0 id 0 +#define BLOCK0_ID1 '0' // block 0 id 1 + +/* + * pointer to a block, used in a pointer block + */ +struct pointer_entry { + blocknr_T pe_bnum; // block number + linenr_T pe_line_count; // number of lines in this branch + linenr_T pe_old_lnum; // lnum for this block (for recovery) + int pe_page_count; // number of pages in block pe_bnum +}; + +/* + * A pointer block contains a list of branches in the tree. + */ +struct pointer_block { + uint16_t pb_id; // ID for pointer block: PTR_ID + uint16_t pb_count; // number of pointers in this block + uint16_t pb_count_max; // maximum value for pb_count + PTR_EN pb_pointer[1]; // list of pointers to blocks (actually longer) + // followed by empty space until end of page +}; + +/* + * A data block is a leaf in the tree. + * + * The text of the lines is at the end of the block. The text of the first line + * in the block is put at the end, the text of the second line in front of it, + * etc. Thus the order of the lines is the opposite of the line number. + */ +struct data_block { + uint16_t db_id; // ID for data block: DATA_ID + unsigned db_free; // free space available + unsigned db_txt_start; // byte where text starts + unsigned db_txt_end; // byte just after data block + linenr_T db_line_count; // number of lines in this block + unsigned db_index[1]; // index for start of line (actually bigger) + // followed by empty space up to db_txt_start + // followed by the text in the lines until + // end of page +}; + +/* + * The low bits of db_index hold the actual index. The topmost bit is + * used for the global command to be able to mark a line. + * This method is not clean, but otherwise there would be at least one extra + * byte used for each line. + * The mark has to be in this place to keep it with the correct line when other + * lines are inserted or deleted. + */ +#define DB_MARKED ((unsigned)1 << ((sizeof(unsigned) * 8) - 1)) +#define DB_INDEX_MASK (~DB_MARKED) + +#define INDEX_SIZE (sizeof(unsigned)) // size of one db_index entry +#define HEADER_SIZE (sizeof(DATA_BL) - INDEX_SIZE) // size of data block header + +#define B0_FNAME_SIZE_ORG 900 // what it was in older versions +#define B0_FNAME_SIZE_NOCRYPT 898 // 2 bytes used for other things +#define B0_FNAME_SIZE_CRYPT 890 // 10 bytes used for other things +#define B0_UNAME_SIZE 40 +#define B0_HNAME_SIZE 40 +/* + * Restrict the numbers to 32 bits, otherwise most compilers will complain. + * This won't detect a 64 bit machine that only swaps a byte in the top 32 + * bits, but that is crazy anyway. + */ +#define B0_MAGIC_LONG 0x30313233L +#define B0_MAGIC_INT 0x20212223L +#define B0_MAGIC_SHORT 0x10111213L +#define B0_MAGIC_CHAR 0x55 + +/* + * Block zero holds all info about the swap file. + * + * NOTE: DEFINITION OF BLOCK 0 SHOULD NOT CHANGE! It would make all existing + * swap files unusable! + * + * If size of block0 changes anyway, adjust MIN_SWAP_PAGE_SIZE in vim.h!! + * + * This block is built up of single bytes, to make it portable across + * different machines. b0_magic_* is used to check the byte order and size of + * variables, because the rest of the swap file is not portable. + */ +struct block0 { + char_u b0_id[2]; ///< ID for block 0: BLOCK0_ID0 and BLOCK0_ID1. + char_u b0_version[10]; // Vim version string + char_u b0_page_size[4]; // number of bytes per page + char_u b0_mtime[4]; // last modification time of file + char_u b0_ino[4]; // inode of b0_fname + char_u b0_pid[4]; // process id of creator (or 0) + char_u b0_uname[B0_UNAME_SIZE]; // name of user (uid if no name) + char_u b0_hname[B0_HNAME_SIZE]; // host name (if it has a name) + char_u b0_fname[B0_FNAME_SIZE_ORG]; // name of file being edited + long b0_magic_long; // check for byte order of long + int b0_magic_int; // check for byte order of int + short b0_magic_short; // check for byte order of short + char_u b0_magic_char; // check for last char +}; + +/* + * Note: b0_dirty and b0_flags are put at the end of the file name. For very + * long file names in older versions of Vim they are invalid. + * The 'fileencoding' comes before b0_flags, with a NUL in front. But only + * when there is room, for very long file names it's omitted. + */ +#define B0_DIRTY 0x55 +#define b0_dirty b0_fname[B0_FNAME_SIZE_ORG - 1] + +/* + * The b0_flags field is new in Vim 7.0. + */ +#define b0_flags b0_fname[B0_FNAME_SIZE_ORG - 2] + +// The lowest two bits contain the fileformat. Zero means it's not set +// (compatible with Vim 6.x), otherwise it's EOL_UNIX + 1, EOL_DOS + 1 or +// EOL_MAC + 1. +#define B0_FF_MASK 3 + +// Swap file is in directory of edited file. Used to find the file from +// different mount points. +#define B0_SAME_DIR 4 + +// The 'fileencoding' is at the end of b0_fname[], with a NUL in front of it. +// When empty there is only the NUL. +#define B0_HAS_FENC 8 + +#define STACK_INCR 5 // nr of entries added to ml_stack at a time + +/* + * The line number where the first mark may be is remembered. + * If it is 0 there are no marks at all. + * (always used for the current buffer only, no buffer change possible while + * executing a global command). + */ +static linenr_T lowest_marked = 0; + +/* + * arguments for ml_find_line() + */ +#define ML_DELETE 0x11 // delete line +#define ML_INSERT 0x12 // insert line +#define ML_FIND 0x13 // just find the line +#define ML_FLUSH 0x02 // flush locked block +#define ML_SIMPLE(x) (x & 0x10) // DEL, INS or FIND + +// argument for ml_upd_block0() +typedef enum { + UB_FNAME = 0, // update timestamp and filename + UB_SAME_DIR, // update the B0_SAME_DIR flag +} upd_block0_T; + +#ifdef INCLUDE_GENERATED_DECLARATIONS +# include "memline.c.generated.h" +#endif + +/* + * Open a new memline for "buf". + * + * Return FAIL for failure, OK otherwise. + */ +int ml_open(buf_T *buf) +{ + bhdr_T *hp = NULL; + ZERO_BL *b0p; + PTR_BL *pp; + DATA_BL *dp; + + /* + * init fields in memline struct + */ + buf->b_ml.ml_stack_size = 0; // no stack yet + buf->b_ml.ml_stack = NULL; // no stack yet + buf->b_ml.ml_stack_top = 0; // nothing in the stack + buf->b_ml.ml_locked = NULL; // no cached block + buf->b_ml.ml_line_lnum = 0; // no cached line + buf->b_ml.ml_line_offset = 0; + buf->b_ml.ml_chunksize = NULL; + buf->b_ml.ml_usedchunks = 0; + + if (cmdmod.noswapfile) { + buf->b_p_swf = false; + } + + /* + * When 'updatecount' is non-zero swap file may be opened later. + */ + if (!buf->terminal && p_uc && buf->b_p_swf) { + buf->b_may_swap = true; + } else { + buf->b_may_swap = false; + } + + // Open the memfile. No swap file is created yet. + memfile_T *mfp = mf_open(NULL, 0); + if (mfp == NULL) { + goto error; + } + + buf->b_ml.ml_mfp = mfp; + buf->b_ml.ml_flags = ML_EMPTY; + buf->b_ml.ml_line_count = 1; + curwin->w_nrwidth_line_count = 0; + + + /* + * fill block0 struct and write page 0 + */ + hp = mf_new(mfp, false, 1); + if (hp->bh_bnum != 0) { + iemsg(_("E298: Didn't get block nr 0?")); + goto error; + } + b0p = hp->bh_data; + + b0p->b0_id[0] = BLOCK0_ID0; + b0p->b0_id[1] = BLOCK0_ID1; + b0p->b0_magic_long = (long)B0_MAGIC_LONG; + b0p->b0_magic_int = (int)B0_MAGIC_INT; + b0p->b0_magic_short = (short)B0_MAGIC_SHORT; + b0p->b0_magic_char = B0_MAGIC_CHAR; + xstrlcpy(xstpcpy((char *)b0p->b0_version, "VIM "), Version, 6); + long_to_char((long)mfp->mf_page_size, b0p->b0_page_size); + + if (!buf->b_spell) { + b0p->b0_dirty = buf->b_changed ? B0_DIRTY : 0; + b0p->b0_flags = get_fileformat(buf) + 1; + set_b0_fname(b0p, buf); + (void)os_get_user_name((char *)b0p->b0_uname, B0_UNAME_SIZE); + b0p->b0_uname[B0_UNAME_SIZE - 1] = NUL; + os_get_hostname((char *)b0p->b0_hname, B0_HNAME_SIZE); + b0p->b0_hname[B0_HNAME_SIZE - 1] = NUL; + long_to_char(os_get_pid(), b0p->b0_pid); + } + + /* + * Always sync block number 0 to disk, so we can check the file name in + * the swap file in findswapname(). Don't do this for a help files or + * a spell buffer though. + * Only works when there's a swapfile, otherwise it's done when the file + * is created. + */ + mf_put(mfp, hp, true, false); + if (!buf->b_help && !B_SPELL(buf)) { + (void)mf_sync(mfp, 0); + } + + /* + * Fill in root pointer block and write page 1. + */ + if ((hp = ml_new_ptr(mfp)) == NULL) { + goto error; + } + if (hp->bh_bnum != 1) { + iemsg(_("E298: Didn't get block nr 1?")); + goto error; + } + pp = hp->bh_data; + pp->pb_count = 1; + pp->pb_pointer[0].pe_bnum = 2; + pp->pb_pointer[0].pe_page_count = 1; + pp->pb_pointer[0].pe_old_lnum = 1; + pp->pb_pointer[0].pe_line_count = 1; // line count after insertion + mf_put(mfp, hp, true, false); + + /* + * Allocate first data block and create an empty line 1. + */ + hp = ml_new_data(mfp, false, 1); + if (hp->bh_bnum != 2) { + iemsg(_("E298: Didn't get block nr 2?")); + goto error; + } + + dp = hp->bh_data; + dp->db_index[0] = --dp->db_txt_start; // at end of block + dp->db_free -= 1 + INDEX_SIZE; + dp->db_line_count = 1; + *((char_u *)dp + dp->db_txt_start) = NUL; // empty line + + return OK; + +error: + if (mfp != NULL) { + if (hp) { + mf_put(mfp, hp, false, false); + } + mf_close(mfp, true); // will also xfree(mfp->mf_fname) + } + buf->b_ml.ml_mfp = NULL; + return FAIL; +} + +/* + * ml_setname() is called when the file name of "buf" has been changed. + * It may rename the swap file. + */ +void ml_setname(buf_T *buf) +{ + bool success = false; + memfile_T *mfp; + char_u *fname; + char_u *dirp; + + mfp = buf->b_ml.ml_mfp; + if (mfp->mf_fd < 0) { // there is no swap file yet + /* + * When 'updatecount' is 0 and 'noswapfile' there is no swap file. + * For help files we will make a swap file now. + */ + if (p_uc != 0 && !cmdmod.noswapfile) { + ml_open_file(buf); // create a swap file + } + return; + } + + /* + * Try all directories in the 'directory' option. + */ + dirp = p_dir; + bool found_existing_dir = false; + for (;;) { + if (*dirp == NUL) { // tried all directories, fail + break; + } + fname = (char_u *)findswapname(buf, (char **)&dirp, (char *)mfp->mf_fname, + &found_existing_dir); + // alloc's fname + if (dirp == NULL) { // out of memory + break; + } + if (fname == NULL) { // no file name found for this dir + continue; + } + + // if the file name is the same we don't have to do anything + if (fnamecmp(fname, mfp->mf_fname) == 0) { + xfree(fname); + success = true; + break; + } + // need to close the swap file before renaming + if (mfp->mf_fd >= 0) { + close(mfp->mf_fd); + mfp->mf_fd = -1; + } + + // try to rename the swap file + if (vim_rename(mfp->mf_fname, fname) == 0) { + success = true; + mf_free_fnames(mfp); + mf_set_fnames(mfp, fname); + ml_upd_block0(buf, UB_SAME_DIR); + break; + } + xfree(fname); // this fname didn't work, try another + } + + if (mfp->mf_fd == -1) { // need to (re)open the swap file + mfp->mf_fd = os_open((char *)mfp->mf_fname, O_RDWR, 0); + if (mfp->mf_fd < 0) { + // could not (re)open the swap file, what can we do???? + emsg(_("E301: Oops, lost the swap file!!!")); + return; + } + (void)os_set_cloexec(mfp->mf_fd); + } + if (!success) { + emsg(_("E302: Could not rename swap file")); + } +} + +/* + * Open a file for the memfile for all buffers that are not readonly or have + * been modified. + * Used when 'updatecount' changes from zero to non-zero. + */ +void ml_open_files(void) +{ + FOR_ALL_BUFFERS(buf) { + if (!buf->b_p_ro || buf->b_changed) { + ml_open_file(buf); + } + } +} + +/* + * Open a swap file for an existing memfile, if there is no swap file yet. + * If we are unable to find a file name, mf_fname will be NULL + * and the memfile will be in memory only (no recovery possible). + */ +void ml_open_file(buf_T *buf) +{ + memfile_T *mfp; + char_u *fname; + char_u *dirp; + + mfp = buf->b_ml.ml_mfp; + if (mfp == NULL || mfp->mf_fd >= 0 || !buf->b_p_swf || cmdmod.noswapfile + || buf->terminal) { + return; // nothing to do + } + + // For a spell buffer use a temp file name. + if (buf->b_spell) { + fname = vim_tempname(); + if (fname != NULL) { + (void)mf_open_file(mfp, fname); // consumes fname! + } + buf->b_may_swap = false; + return; + } + + /* + * Try all directories in 'directory' option. + */ + dirp = p_dir; + bool found_existing_dir = false; + for (;;) { + if (*dirp == NUL) { + break; + } + // There is a small chance that between choosing the swap file name + // and creating it, another Vim creates the file. In that case the + // creation will fail and we will use another directory. + fname = (char_u *)findswapname(buf, (char **)&dirp, NULL, + &found_existing_dir); + if (dirp == NULL) { + break; // out of memory + } + if (fname == NULL) { + continue; + } + if (mf_open_file(mfp, fname) == OK) { // consumes fname! + ml_upd_block0(buf, UB_SAME_DIR); + + // Flush block zero, so others can read it + if (mf_sync(mfp, MFS_ZERO) == OK) { + // Mark all blocks that should be in the swapfile as dirty. + // Needed for when the 'swapfile' option was reset, so that + // the swap file was deleted, and then on again. + mf_set_dirty(mfp); + break; + } + // Writing block 0 failed: close the file and try another dir + mf_close_file(buf, false); + } + } + + if (*p_dir != NUL && mfp->mf_fname == NULL) { + need_wait_return = true; // call wait_return later + no_wait_return++; + (void)semsg(_("E303: Unable to open swap file for \"%s\", recovery impossible"), + buf_spname(buf) != NULL ? buf_spname(buf) : buf->b_fname); + --no_wait_return; + } + + // don't try to open a swap file again + buf->b_may_swap = false; +} + +/// If still need to create a swap file, and starting to edit a not-readonly +/// file, or reading into an existing buffer, create a swap file now. +/// +/// @param newfile reading file into new buffer +void check_need_swap(bool newfile) +{ + int old_msg_silent = msg_silent; // might be reset by an E325 message + msg_silent = 0; // If swap dialog prompts for input, user needs to see it! + + if (curbuf->b_may_swap && (!curbuf->b_p_ro || !newfile)) { + ml_open_file(curbuf); + } + + msg_silent = old_msg_silent; +} + +/* + * Close memline for buffer 'buf'. + * If 'del_file' is TRUE, delete the swap file + */ +void ml_close(buf_T *buf, int del_file) +{ + if (buf->b_ml.ml_mfp == NULL) { // not open + return; + } + mf_close(buf->b_ml.ml_mfp, del_file); // close the .swp file + if (buf->b_ml.ml_line_lnum != 0 && (buf->b_ml.ml_flags & ML_LINE_DIRTY)) { + xfree(buf->b_ml.ml_line_ptr); + } + xfree(buf->b_ml.ml_stack); + XFREE_CLEAR(buf->b_ml.ml_chunksize); + buf->b_ml.ml_mfp = NULL; + + // Reset the "recovered" flag, give the ATTENTION prompt the next time + // this buffer is loaded. + buf->b_flags &= ~BF_RECOVERED; +} + +/* + * Close all existing memlines and memfiles. + * Only used when exiting. + * When 'del_file' is TRUE, delete the memfiles. + * But don't delete files that were ":preserve"d when we are POSIX compatible. + */ +void ml_close_all(int del_file) +{ + FOR_ALL_BUFFERS(buf) { + ml_close(buf, del_file && ((buf->b_flags & BF_PRESERVED) == 0)); + } + spell_delete_wordlist(); // delete the internal wordlist + vim_deltempdir(); // delete created temp directory +} + +/* + * Close all memfiles for not modified buffers. + * Only use just before exiting! + */ +void ml_close_notmod(void) +{ + FOR_ALL_BUFFERS(buf) { + if (!bufIsChanged(buf)) { + ml_close(buf, TRUE); // close all not-modified buffers + } + } +} + +/* + * Update the timestamp in the .swp file. + * Used when the file has been written. + */ +void ml_timestamp(buf_T *buf) +{ + ml_upd_block0(buf, UB_FNAME); +} + +/// Checks whether the IDs in b0 are valid. +static bool ml_check_b0_id(ZERO_BL *b0p) + FUNC_ATTR_NONNULL_ALL +{ + return b0p->b0_id[0] == BLOCK0_ID0 && b0p->b0_id[1] == BLOCK0_ID1; +} + +/// Checks whether all strings in b0 are valid (i.e. nul-terminated). +static bool ml_check_b0_strings(ZERO_BL *b0p) + FUNC_ATTR_NONNULL_ALL +{ + return (memchr(b0p->b0_version, NUL, 10) + && memchr(b0p->b0_uname, NUL, B0_UNAME_SIZE) + && memchr(b0p->b0_hname, NUL, B0_HNAME_SIZE) + && memchr(b0p->b0_fname, NUL, B0_FNAME_SIZE_CRYPT)); // -V512 +} + +/* + * Update the timestamp or the B0_SAME_DIR flag of the .swp file. + */ +static void ml_upd_block0(buf_T *buf, upd_block0_T what) +{ + memfile_T *mfp; + bhdr_T *hp; + ZERO_BL *b0p; + + mfp = buf->b_ml.ml_mfp; + if (mfp == NULL || (hp = mf_get(mfp, 0, 1)) == NULL) { + return; + } + b0p = hp->bh_data; + if (ml_check_b0_id(b0p) == FAIL) { + iemsg(_("E304: ml_upd_block0(): Didn't get block 0??")); + } else { + if (what == UB_FNAME) { + set_b0_fname(b0p, buf); + } else { // what == UB_SAME_DIR + set_b0_dir_flag(b0p, buf); + } + } + mf_put(mfp, hp, true, false); +} + +/* + * Write file name and timestamp into block 0 of a swap file. + * Also set buf->b_mtime. + * Don't use NameBuff[]!!! + */ +static void set_b0_fname(ZERO_BL *b0p, buf_T *buf) +{ + if (buf->b_ffname == NULL) { + b0p->b0_fname[0] = NUL; + } else { + char uname[B0_UNAME_SIZE]; + + /* + * For a file under the home directory of the current user, we try to + * replace the home directory path with "~user". This helps when + * editing the same file on different machines over a network. + * First replace home dir path with "~/" with home_replace(). + * Then insert the user name to get "~user/". + */ + home_replace(NULL, buf->b_ffname, b0p->b0_fname, + B0_FNAME_SIZE_CRYPT, TRUE); + if (b0p->b0_fname[0] == '~') { + // If there is no user name or it is too long, don't use "~/" + int retval = os_get_user_name(uname, B0_UNAME_SIZE); + size_t ulen = STRLEN(uname); + size_t flen = STRLEN(b0p->b0_fname); + if (retval == FAIL || ulen + flen > B0_FNAME_SIZE_CRYPT - 1) { + STRLCPY(b0p->b0_fname, buf->b_ffname, B0_FNAME_SIZE_CRYPT); + } else { + memmove(b0p->b0_fname + ulen + 1, b0p->b0_fname + 1, flen); + memmove(b0p->b0_fname + 1, uname, ulen); + } + } + FileInfo file_info; + if (os_fileinfo((char *)buf->b_ffname, &file_info)) { + long_to_char(file_info.stat.st_mtim.tv_sec, b0p->b0_mtime); + long_to_char((long)os_fileinfo_inode(&file_info), b0p->b0_ino); + buf_store_file_info(buf, &file_info); + buf->b_mtime_read = buf->b_mtime; + } else { + long_to_char(0L, b0p->b0_mtime); + long_to_char(0L, b0p->b0_ino); + buf->b_mtime = 0; + buf->b_mtime_read = 0; + buf->b_orig_size = 0; + buf->b_orig_mode = 0; + } + } + + // Also add the 'fileencoding' if there is room. + add_b0_fenc(b0p, curbuf); +} + +/* + * Update the B0_SAME_DIR flag of the swap file. It's set if the file and the + * swapfile for "buf" are in the same directory. + * This is fail safe: if we are not sure the directories are equal the flag is + * not set. + */ +static void set_b0_dir_flag(ZERO_BL *b0p, buf_T *buf) +{ + if (same_directory(buf->b_ml.ml_mfp->mf_fname, buf->b_ffname)) { + b0p->b0_flags |= B0_SAME_DIR; + } else { + b0p->b0_flags &= ~B0_SAME_DIR; + } +} + +/* + * When there is room, add the 'fileencoding' to block zero. + */ +static void add_b0_fenc(ZERO_BL *b0p, buf_T *buf) +{ + int n; + int size = B0_FNAME_SIZE_NOCRYPT; + + n = (int)STRLEN(buf->b_p_fenc); + if ((int)STRLEN(b0p->b0_fname) + n + 1 > size) { + b0p->b0_flags &= ~B0_HAS_FENC; + } else { + memmove((char *)b0p->b0_fname + size - n, + (char *)buf->b_p_fenc, (size_t)n); + *(b0p->b0_fname + size - n - 1) = NUL; + b0p->b0_flags |= B0_HAS_FENC; + } +} + + +/// Try to recover curbuf from the .swp file. +/// @param checkext If true, check the extension and detect whether it is a +/// swap file. +void ml_recover(bool checkext) +{ + buf_T *buf = NULL; + memfile_T *mfp = NULL; + char_u *fname; + char_u *fname_used = NULL; + bhdr_T *hp = NULL; + ZERO_BL *b0p; + int b0_ff; + char_u *b0_fenc = NULL; + PTR_BL *pp; + DATA_BL *dp; + infoptr_T *ip; + blocknr_T bnum; + int page_count; + int len; + bool directly; + linenr_T lnum; + char_u *p; + int i; + long error; + bool cannot_open; + linenr_T line_count; + bool has_error; + int idx; + int top; + int txt_start; + off_T size; + int called_from_main; + bool serious_error = true; + long mtime; + int attr; + int orig_file_status = NOTDONE; + + recoverymode = TRUE; + called_from_main = (curbuf->b_ml.ml_mfp == NULL); + attr = HL_ATTR(HLF_E); + + // If the file name ends in ".s[a-w][a-z]" we assume this is the swap file. + // Otherwise a search is done to find the swap file(s). + fname = curbuf->b_fname; + if (fname == NULL) { // When there is no file name + fname = (char_u *)""; + } + len = (int)STRLEN(fname); + if (checkext && len >= 4 + && STRNICMP(fname + len - 4, ".s", 2) == 0 + && vim_strchr((char_u *)"abcdefghijklmnopqrstuvw", + TOLOWER_ASC(fname[len - 2])) != NULL + && ASCII_ISALPHA(fname[len - 1])) { + directly = true; + fname_used = vim_strsave(fname); // make a copy for mf_open() + } else { + directly = false; + + // count the number of matching swap files + len = recover_names(fname, FALSE, 0, NULL); + if (len == 0) { // no swap files found + semsg(_("E305: No swap file found for %s"), fname); + goto theend; + } + if (len == 1) { // one swap file found, use it + i = 1; + } else { // several swap files found, choose + // list the names of the swap files + (void)recover_names(fname, TRUE, 0, NULL); + msg_putchar('\n'); + msg_puts(_("Enter number of swap file to use (0 to quit): ")); + i = get_number(FALSE, NULL); + if (i < 1 || i > len) { + goto theend; + } + } + // get the swap file name that will be used + (void)recover_names(fname, FALSE, i, &fname_used); + } + if (fname_used == NULL) { + goto theend; // user chose invalid number. + } + // When called from main() still need to initialize storage structure + if (called_from_main && ml_open(curbuf) == FAIL) { + getout(1); + } + + /* + * Allocate a buffer structure for the swap file that is used for recovery. + * Only the memline in it is really used. + */ + buf = xmalloc(sizeof(buf_T)); + + /* + * init fields in memline struct + */ + buf->b_ml.ml_stack_size = 0; // no stack yet + buf->b_ml.ml_stack = NULL; // no stack yet + buf->b_ml.ml_stack_top = 0; // nothing in the stack + buf->b_ml.ml_line_lnum = 0; // no cached line + buf->b_ml.ml_line_offset = 0; + buf->b_ml.ml_locked = NULL; // no locked block + buf->b_ml.ml_flags = 0; + + /* + * open the memfile from the old swap file + */ + p = vim_strsave(fname_used); // save "fname_used" for the message: + // mf_open() will consume "fname_used"! + mfp = mf_open(fname_used, O_RDONLY); + fname_used = p; + if (mfp == NULL || mfp->mf_fd < 0) { + semsg(_("E306: Cannot open %s"), fname_used); + goto theend; + } + buf->b_ml.ml_mfp = mfp; + + /* + * The page size set in mf_open() might be different from the page size + * used in the swap file, we must get it from block 0. But to read block + * 0 we need a page size. Use the minimal size for block 0 here, it will + * be set to the real value below. + */ + mfp->mf_page_size = MIN_SWAP_PAGE_SIZE; + + /* + * try to read block 0 + */ + if ((hp = mf_get(mfp, 0, 1)) == NULL) { + msg_start(); + msg_puts_attr(_("Unable to read block 0 from "), attr | MSG_HIST); + msg_outtrans_attr(mfp->mf_fname, attr | MSG_HIST); + msg_puts_attr(_("\nMaybe no changes were made or Vim did not update the swap file."), + attr | MSG_HIST); + msg_end(); + goto theend; + } + b0p = hp->bh_data; + if (STRNCMP(b0p->b0_version, "VIM 3.0", 7) == 0) { + msg_start(); + msg_outtrans_attr(mfp->mf_fname, MSG_HIST); + msg_puts_attr(_(" cannot be used with this version of Vim.\n"), + MSG_HIST); + msg_puts_attr(_("Use Vim version 3.0.\n"), MSG_HIST); + msg_end(); + goto theend; + } + if (ml_check_b0_id(b0p) == FAIL) { + semsg(_("E307: %s does not look like a Vim swap file"), mfp->mf_fname); + goto theend; + } + if (b0_magic_wrong(b0p)) { + msg_start(); + msg_outtrans_attr(mfp->mf_fname, attr | MSG_HIST); + msg_puts_attr(_(" cannot be used on this computer.\n"), + attr | MSG_HIST); + msg_puts_attr(_("The file was created on "), attr | MSG_HIST); + // avoid going past the end of a corrupted hostname + b0p->b0_fname[0] = NUL; + msg_puts_attr((char *)b0p->b0_hname, attr | MSG_HIST); + msg_puts_attr(_(",\nor the file has been damaged."), attr | MSG_HIST); + msg_end(); + goto theend; + } + + /* + * If we guessed the wrong page size, we have to recalculate the + * highest block number in the file. + */ + if (mfp->mf_page_size != (unsigned)char_to_long(b0p->b0_page_size)) { + unsigned previous_page_size = mfp->mf_page_size; + + mf_new_page_size(mfp, (unsigned)char_to_long(b0p->b0_page_size)); + if (mfp->mf_page_size < previous_page_size) { + msg_start(); + msg_outtrans_attr(mfp->mf_fname, attr | MSG_HIST); + msg_puts_attr(_(" has been damaged (page size is smaller than minimum value).\n"), + attr | MSG_HIST); + msg_end(); + goto theend; + } + if ((size = vim_lseek(mfp->mf_fd, (off_T)0L, SEEK_END)) <= 0) { + mfp->mf_blocknr_max = 0; // no file or empty file + } else { + mfp->mf_blocknr_max = size / mfp->mf_page_size; + } + mfp->mf_infile_count = mfp->mf_blocknr_max; + + // need to reallocate the memory used to store the data + p = xmalloc(mfp->mf_page_size); + memmove(p, hp->bh_data, previous_page_size); + xfree(hp->bh_data); + hp->bh_data = p; + b0p = hp->bh_data; + } + + /* + * If .swp file name given directly, use name from swap file for buffer. + */ + if (directly) { + expand_env(b0p->b0_fname, NameBuff, MAXPATHL); + if (setfname(curbuf, NameBuff, NULL, true) == FAIL) { + goto theend; + } + } + + home_replace(NULL, mfp->mf_fname, NameBuff, MAXPATHL, TRUE); + smsg(_("Using swap file \"%s\""), NameBuff); + + if (buf_spname(curbuf) != NULL) { + STRLCPY(NameBuff, buf_spname(curbuf), MAXPATHL); + } else { + home_replace(NULL, curbuf->b_ffname, NameBuff, MAXPATHL, TRUE); + } + smsg(_("Original file \"%s\""), NameBuff); + msg_putchar('\n'); + + /* + * check date of swap file and original file + */ + FileInfo org_file_info; + FileInfo swp_file_info; + mtime = char_to_long(b0p->b0_mtime); + if (curbuf->b_ffname != NULL + && os_fileinfo((char *)curbuf->b_ffname, &org_file_info) + && ((os_fileinfo((char *)mfp->mf_fname, &swp_file_info) + && org_file_info.stat.st_mtim.tv_sec + > swp_file_info.stat.st_mtim.tv_sec) + || org_file_info.stat.st_mtim.tv_sec != mtime)) { + emsg(_("E308: Warning: Original file may have been changed")); + } + ui_flush(); + + // Get the 'fileformat' and 'fileencoding' from block zero. + b0_ff = (b0p->b0_flags & B0_FF_MASK); + if (b0p->b0_flags & B0_HAS_FENC) { + int fnsize = B0_FNAME_SIZE_NOCRYPT; + + for (p = b0p->b0_fname + fnsize; p > b0p->b0_fname && p[-1] != NUL; p--) { + } + b0_fenc = vim_strnsave(p, b0p->b0_fname + fnsize - p); + } + + mf_put(mfp, hp, false, false); // release block 0 + hp = NULL; + + /* + * Now that we are sure that the file is going to be recovered, clear the + * contents of the current buffer. + */ + while (!(curbuf->b_ml.ml_flags & ML_EMPTY)) { + ml_delete((linenr_T)1, false); + } + + /* + * Try reading the original file to obtain the values of 'fileformat', + * 'fileencoding', etc. Ignore errors. The text itself is not used. + */ + if (curbuf->b_ffname != NULL) { + orig_file_status = readfile(curbuf->b_ffname, NULL, (linenr_T)0, + (linenr_T)0, (linenr_T)MAXLNUM, NULL, READ_NEW); + } + + // Use the 'fileformat' and 'fileencoding' as stored in the swap file. + if (b0_ff != 0) { + set_fileformat(b0_ff - 1, OPT_LOCAL); + } + if (b0_fenc != NULL) { + set_option_value("fenc", 0L, (char *)b0_fenc, OPT_LOCAL); + xfree(b0_fenc); + } + unchanged(curbuf, true, true); + + bnum = 1; // start with block 1 + page_count = 1; // which is 1 page + lnum = 0; // append after line 0 in curbuf + line_count = 0; + idx = 0; // start with first index in block 1 + error = 0; + buf->b_ml.ml_stack_top = 0; + buf->b_ml.ml_stack = NULL; + buf->b_ml.ml_stack_size = 0; // no stack yet + + if (curbuf->b_ffname == NULL) { + cannot_open = true; + } else { + cannot_open = false; + } + + serious_error = false; + for (; !got_int; line_breakcheck()) { + if (hp != NULL) { + mf_put(mfp, hp, false, false); // release previous block + } + /* + * get block + */ + if ((hp = mf_get(mfp, bnum, page_count)) == NULL) { + if (bnum == 1) { + semsg(_("E309: Unable to read block 1 from %s"), mfp->mf_fname); + goto theend; + } + ++error; + ml_append(lnum++, (char_u *)_("???MANY LINES MISSING"), + (colnr_T)0, true); + } else { // there is a block + pp = hp->bh_data; + if (pp->pb_id == PTR_ID) { // it is a pointer block + // check line count when using pointer block first time + if (idx == 0 && line_count != 0) { + for (i = 0; i < (int)pp->pb_count; ++i) { + line_count -= pp->pb_pointer[i].pe_line_count; + } + if (line_count != 0) { + ++error; + ml_append(lnum++, (char_u *)_("???LINE COUNT WRONG"), + (colnr_T)0, true); + } + } + + if (pp->pb_count == 0) { + ml_append(lnum++, (char_u *)_("???EMPTY BLOCK"), + (colnr_T)0, true); + error++; + } else if (idx < (int)pp->pb_count) { // go a block deeper + if (pp->pb_pointer[idx].pe_bnum < 0) { + /* + * Data block with negative block number. + * Try to read lines from the original file. + * This is slow, but it works. + */ + if (!cannot_open) { + line_count = pp->pb_pointer[idx].pe_line_count; + if (readfile(curbuf->b_ffname, NULL, lnum, + pp->pb_pointer[idx].pe_old_lnum - 1, line_count, + NULL, 0) != OK) { + cannot_open = true; + } else { + lnum += line_count; + } + } + if (cannot_open) { + ++error; + ml_append(lnum++, (char_u *)_("???LINES MISSING"), + (colnr_T)0, true); + } + ++idx; // get same block again for next index + continue; + } + + /* + * going one block deeper in the tree + */ + top = ml_add_stack(buf); // new entry in stack + ip = &(buf->b_ml.ml_stack[top]); + ip->ip_bnum = bnum; + ip->ip_index = idx; + + bnum = pp->pb_pointer[idx].pe_bnum; + line_count = pp->pb_pointer[idx].pe_line_count; + page_count = pp->pb_pointer[idx].pe_page_count; + idx = 0; + continue; + } + } else { // not a pointer block + dp = hp->bh_data; + if (dp->db_id != DATA_ID) { // block id wrong + if (bnum == 1) { + semsg(_("E310: Block 1 ID wrong (%s not a .swp file?)"), + mfp->mf_fname); + goto theend; + } + ++error; + ml_append(lnum++, (char_u *)_("???BLOCK MISSING"), + (colnr_T)0, true); + } else { + // it is a data block + // Append all the lines in this block + has_error = false; + // check length of block + // if wrong, use length in pointer block + if (page_count * mfp->mf_page_size != dp->db_txt_end) { + ml_append(lnum++, + (char_u *)_("??? from here until ???END lines" + " may be messed up"), + (colnr_T)0, true); + error++; + has_error = true; + dp->db_txt_end = page_count * mfp->mf_page_size; + } + + // make sure there is a NUL at the end of the block + *((char_u *)dp + dp->db_txt_end - 1) = NUL; + + /* + * check number of lines in block + * if wrong, use count in data block + */ + if (line_count != dp->db_line_count) { + ml_append(lnum++, + (char_u *)_("??? from here until ???END lines" + " may have been inserted/deleted"), + (colnr_T)0, true); + error++; + has_error = true; + } + + for (i = 0; i < dp->db_line_count; ++i) { + txt_start = (dp->db_index[i] & DB_INDEX_MASK); + if (txt_start <= (int)HEADER_SIZE + || txt_start >= (int)dp->db_txt_end) { + p = (char_u *)"???"; + ++error; + } else { + p = (char_u *)dp + txt_start; + } + ml_append(lnum++, p, (colnr_T)0, true); + } + if (has_error) { + ml_append(lnum++, (char_u *)_("???END"), (colnr_T)0, true); + } + } + } + } + + if (buf->b_ml.ml_stack_top == 0) { // finished + break; + } + + /* + * go one block up in the tree + */ + ip = &(buf->b_ml.ml_stack[--(buf->b_ml.ml_stack_top)]); + bnum = ip->ip_bnum; + idx = ip->ip_index + 1; // go to next index + page_count = 1; + } + + /* + * Compare the buffer contents with the original file. When they differ + * set the 'modified' flag. + * Lines 1 - lnum are the new contents. + * Lines lnum + 1 to ml_line_count are the original contents. + * Line ml_line_count + 1 in the dummy empty line. + */ + if (orig_file_status != OK || curbuf->b_ml.ml_line_count != lnum * 2 + 1) { + // Recovering an empty file results in two lines and the first line is + // empty. Don't set the modified flag then. + if (!(curbuf->b_ml.ml_line_count == 2 && *ml_get(1) == NUL)) { + changed_internal(); + buf_inc_changedtick(curbuf); + } + } else { + for (idx = 1; idx <= lnum; ++idx) { + // Need to copy one line, fetching the other one may flush it. + p = vim_strsave(ml_get(idx)); + i = STRCMP(p, ml_get(idx + lnum)); + xfree(p); + if (i != 0) { + changed_internal(); + buf_inc_changedtick(curbuf); + break; + } + } + } + + /* + * Delete the lines from the original file and the dummy line from the + * empty buffer. These will now be after the last line in the buffer. + */ + while (curbuf->b_ml.ml_line_count > lnum + && !(curbuf->b_ml.ml_flags & ML_EMPTY)) { + ml_delete(curbuf->b_ml.ml_line_count, false); + } + curbuf->b_flags |= BF_RECOVERED; + check_cursor(); + + recoverymode = FALSE; + if (got_int) { + emsg(_("E311: Recovery Interrupted")); + } else if (error) { + ++no_wait_return; + msg(">>>>>>>>>>>>>"); + emsg(_("E312: Errors detected while recovering; look for lines starting with ???")); + --no_wait_return; + msg(_("See \":help E312\" for more information.")); + msg(">>>>>>>>>>>>>"); + } else { + if (curbuf->b_changed) { + msg(_("Recovery completed. You should check if everything is OK.")); + msg_puts(_("\n(You might want to write out this file under another name\n")); + msg_puts(_("and run diff with the original file to check for changes)")); + } else { + msg(_("Recovery completed. Buffer contents equals file contents.")); + } + msg_puts(_("\nYou may want to delete the .swp file now.\n\n")); + cmdline_row = msg_row; + } + redraw_curbuf_later(NOT_VALID); + +theend: + xfree(fname_used); + recoverymode = FALSE; + if (mfp != NULL) { + if (hp != NULL) { + mf_put(mfp, hp, false, false); + } + mf_close(mfp, false); // will also xfree(mfp->mf_fname) + } + if (buf != NULL) { //may be NULL if swap file not found. + xfree(buf->b_ml.ml_stack); + xfree(buf); + } + if (serious_error && called_from_main) { + ml_close(curbuf, TRUE); + } else { + apply_autocmds(EVENT_BUFREADPOST, NULL, curbuf->b_fname, FALSE, curbuf); + apply_autocmds(EVENT_BUFWINENTER, NULL, curbuf->b_fname, FALSE, curbuf); + } +} + +/// Find the names of swap files in current directory and the directory given +/// with the 'directory' option. +/// +/// Used to: +/// - list the swap files for "vim -r" +/// - count the number of swap files when recovering +/// - list the swap files when recovering +/// - find the name of the n'th swap file when recovering +/// +/// @param fname base for swap file name +/// @param list when TRUE, list the swap file names +/// @param nr when non-zero, return nr'th swap file name +/// @param fname_out result when "nr" > 0 +int recover_names(char_u *fname, int list, int nr, char_u **fname_out) +{ + int num_names; + char_u *(names[6]); + char_u *tail; + char_u *p; + int num_files; + int file_count = 0; + char_u **files; + char_u *dirp; + char_u *dir_name; + char_u *fname_res = NULL; +#ifdef HAVE_READLINK + char_u fname_buf[MAXPATHL]; +#endif + + if (fname != NULL) { +#ifdef HAVE_READLINK + // Expand symlink in the file name, because the swap file is created + // with the actual file instead of with the symlink. + if (resolve_symlink(fname, fname_buf) == OK) { + fname_res = fname_buf; + } else +#endif + fname_res = fname; + } + + if (list) { + // use msg() to start the scrolling properly + msg(_("Swap files found:")); + msg_putchar('\n'); + } + + // Do the loop for every directory in 'directory'. + // First allocate some memory to put the directory name in. + dir_name = xmalloc(STRLEN(p_dir) + 1); + dirp = p_dir; + while (*dirp) { + // Isolate a directory name from *dirp and put it in dir_name (we know + // it is large enough, so use 31000 for length). + // Advance dirp to next directory name. + (void)copy_option_part(&dirp, dir_name, 31000, ","); + + if (dir_name[0] == '.' && dir_name[1] == NUL) { // check current dir + if (fname == NULL) { + names[0] = vim_strsave((char_u *)"*.sw?"); + // For Unix names starting with a dot are special. MS-Windows + // supports this too, on some file systems. + names[1] = vim_strsave((char_u *)".*.sw?"); + names[2] = vim_strsave((char_u *)".sw?"); + num_names = 3; + } else { + num_names = recov_file_names(names, fname_res, TRUE); + } + } else { // check directory dir_name + if (fname == NULL) { + names[0] = (char_u *)concat_fnames((char *)dir_name, "*.sw?", true); + // For Unix names starting with a dot are special. MS-Windows + // supports this too, on some file systems. + names[1] = (char_u *)concat_fnames((char *)dir_name, ".*.sw?", true); + names[2] = (char_u *)concat_fnames((char *)dir_name, ".sw?", true); + num_names = 3; + } else { + int len = (int)STRLEN(dir_name); + p = dir_name + len; + if (after_pathsep((char *)dir_name, (char *)p) + && len > 1 + && p[-1] == p[-2]) { + // Ends with '//', Use Full path for swap name + tail = (char_u *)make_percent_swname((char *)dir_name, + (char *)fname_res); + } else { + tail = path_tail(fname_res); + tail = (char_u *)concat_fnames((char *)dir_name, (char *)tail, TRUE); + } + num_names = recov_file_names(names, tail, FALSE); + xfree(tail); + } + } + + if (num_names == 0) { + num_files = 0; + } else if (expand_wildcards(num_names, names, &num_files, &files, + EW_KEEPALL|EW_FILE|EW_SILENT) == FAIL) { + num_files = 0; + } + + /* + * When no swap file found, wildcard expansion might have failed (e.g. + * not able to execute the shell). + * Try finding a swap file by simply adding ".swp" to the file name. + */ + if (*dirp == NUL && file_count + num_files == 0 && fname != NULL) { + char_u *swapname = (char_u *)modname((char *)fname_res, ".swp", true); + if (swapname != NULL) { + if (os_path_exists(swapname)) { + files = xmalloc(sizeof(char_u *)); + files[0] = swapname; + swapname = NULL; + num_files = 1; + } + xfree(swapname); + } + } + + /* + * remove swapfile name of the current buffer, it must be ignored + */ + if (curbuf->b_ml.ml_mfp != NULL + && (p = curbuf->b_ml.ml_mfp->mf_fname) != NULL) { + for (int i = 0; i < num_files; i++) { + // Do not expand wildcards, on Windows would try to expand + // "%tmp%" in "%tmp%file" + if (path_full_compare(p, files[i], true, false) & kEqualFiles) { + // Remove the name from files[i]. Move further entries + // down. When the array becomes empty free it here, since + // FreeWild() won't be called below. + xfree(files[i]); + if (--num_files == 0) { + xfree(files); + } else { + for (; i < num_files; ++i) { + files[i] = files[i + 1]; + } + } + } + } + } + if (nr > 0) { + file_count += num_files; + if (nr <= file_count) { + *fname_out = vim_strsave(files[nr - 1 + num_files - file_count]); + dirp = (char_u *)""; // stop searching + } + } else if (list) { + if (dir_name[0] == '.' && dir_name[1] == NUL) { + if (fname == NULL) { + msg_puts(_(" In current directory:\n")); + } else { + msg_puts(_(" Using specified name:\n")); + } + } else { + msg_puts(_(" In directory ")); + msg_home_replace(dir_name); + msg_puts(":\n"); + } + + if (num_files) { + for (int i = 0; i < num_files; ++i) { + // print the swap file name + msg_outnum((long)++file_count); + msg_puts(". "); + msg_puts((const char *)path_tail(files[i])); + msg_putchar('\n'); + (void)swapfile_info(files[i]); + } + } else { + msg_puts(_(" -- none --\n")); + } + ui_flush(); + } else { + file_count += num_files; + } + + for (int i = 0; i < num_names; ++i) { + xfree(names[i]); + } + if (num_files > 0) { + FreeWild(num_files, files); + } + } + xfree(dir_name); + return file_count; +} + +/* + * Append the full path to name with path separators made into percent + * signs, to dir. An unnamed buffer is handled as "" (/"") + */ +char *make_percent_swname(const char *dir, const char *name) + FUNC_ATTR_NONNULL_ARG(1) +{ + char *d = NULL; + char *f = fix_fname(name != NULL ? name : ""); + if (f != NULL) { + char *s = xstrdup(f); + for (d = s; *d != NUL; MB_PTR_ADV(d)) { + if (vim_ispathsep(*d)) { + *d = '%'; + } + } + d = concat_fnames(dir, s, TRUE); + xfree(s); + xfree(f); + } + return d; +} + +static bool process_still_running; + +/// Return information found in swapfile "fname" in dictionary "d". +/// This is used by the swapinfo() function. +void get_b0_dict(const char *fname, dict_T *d) +{ + int fd; + struct block0 b0; + + if ((fd = os_open(fname, O_RDONLY, 0)) >= 0) { + if (read_eintr(fd, &b0, sizeof(b0)) == sizeof(b0)) { + if (ml_check_b0_id(&b0) == FAIL) { + tv_dict_add_str(d, S_LEN("error"), "Not a swap file"); + } else if (b0_magic_wrong(&b0)) { + tv_dict_add_str(d, S_LEN("error"), "Magic number mismatch"); + } else { + // We have swap information. + tv_dict_add_str_len(d, S_LEN("version"), (char *)b0.b0_version, 10); + tv_dict_add_str_len(d, S_LEN("user"), (char *)b0.b0_uname, + B0_UNAME_SIZE); + tv_dict_add_str_len(d, S_LEN("host"), (char *)b0.b0_hname, + B0_HNAME_SIZE); + tv_dict_add_str_len(d, S_LEN("fname"), (char *)b0.b0_fname, + B0_FNAME_SIZE_ORG); + + tv_dict_add_nr(d, S_LEN("pid"), char_to_long(b0.b0_pid)); + tv_dict_add_nr(d, S_LEN("mtime"), char_to_long(b0.b0_mtime)); + tv_dict_add_nr(d, S_LEN("dirty"), b0.b0_dirty ? 1 : 0); + tv_dict_add_nr(d, S_LEN("inode"), char_to_long(b0.b0_ino)); + } + } else { + tv_dict_add_str(d, S_LEN("error"), "Cannot read file"); + } + close(fd); + } else { + tv_dict_add_str(d, S_LEN("error"), "Cannot open file"); + } +} + +/// Give information about an existing swap file. +/// Returns timestamp (0 when unknown). +static time_t swapfile_info(char_u *fname) +{ + assert(fname != NULL); + int fd; + struct block0 b0; + time_t x = (time_t)0; +#ifdef UNIX + char uname[B0_UNAME_SIZE]; +#endif + + // print the swap file date + FileInfo file_info; + if (os_fileinfo((char *)fname, &file_info)) { +#ifdef UNIX + // print name of owner of the file + if (os_get_uname(file_info.stat.st_uid, uname, B0_UNAME_SIZE) == OK) { + msg_puts(_(" owned by: ")); + msg_outtrans((char_u *)uname); + msg_puts(_(" dated: ")); + } else +#endif + msg_puts(_(" dated: ")); + x = file_info.stat.st_mtim.tv_sec; + char ctime_buf[50]; + msg_puts(os_ctime_r(&x, ctime_buf, sizeof(ctime_buf))); + } + + /* + * print the original file name + */ + fd = os_open((char *)fname, O_RDONLY, 0); + if (fd >= 0) { + if (read_eintr(fd, &b0, sizeof(b0)) == sizeof(b0)) { + if (STRNCMP(b0.b0_version, "VIM 3.0", 7) == 0) { + msg_puts(_(" [from Vim version 3.0]")); + } else if (ml_check_b0_id(&b0) == FAIL) { + msg_puts(_(" [does not look like a Vim swap file]")); + } else if (!ml_check_b0_strings(&b0)) { + msg_puts(_(" [garbled strings (not nul terminated)]")); + } else { + msg_puts(_(" file name: ")); + if (b0.b0_fname[0] == NUL) { + msg_puts(_("[No Name]")); + } else { + msg_outtrans(b0.b0_fname); + } + + msg_puts(_("\n modified: ")); + msg_puts(b0.b0_dirty ? _("YES") : _("no")); + + if (*(b0.b0_uname) != NUL) { + msg_puts(_("\n user name: ")); + msg_outtrans(b0.b0_uname); + } + + if (*(b0.b0_hname) != NUL) { + if (*(b0.b0_uname) != NUL) { + msg_puts(_(" host name: ")); + } else { + msg_puts(_("\n host name: ")); + } + msg_outtrans(b0.b0_hname); + } + + if (char_to_long(b0.b0_pid) != 0L) { + msg_puts(_("\n process ID: ")); + msg_outnum(char_to_long(b0.b0_pid)); + if (os_proc_running((int)char_to_long(b0.b0_pid))) { + msg_puts(_(" (STILL RUNNING)")); + process_still_running = true; + } + } + + if (b0_magic_wrong(&b0)) { + msg_puts(_("\n [not usable on this computer]")); + } + } + } else { + msg_puts(_(" [cannot be read]")); + } + close(fd); + } else { + msg_puts(_(" [cannot be opened]")); + } + msg_putchar('\n'); + + return x; +} + +/// Returns TRUE if the swap file looks OK and there are no changes, thus it +/// can be safely deleted. +static time_t swapfile_unchanged(char *fname) +{ + struct block0 b0; + int ret = true; + + // Swap file must exist. + if (!os_path_exists((char_u *)fname)) { + return false; + } + + // must be able to read the first block + int fd = os_open(fname, O_RDONLY, 0); + if (fd < 0) { + return false; + } + if (read_eintr(fd, &b0, sizeof(b0)) != sizeof(b0)) { + close(fd); + return false; + } + + // the ID and magic number must be correct + if (ml_check_b0_id(&b0) == FAIL || b0_magic_wrong(&b0)) { + ret = false; + } + + // must be unchanged + if (b0.b0_dirty) { + ret = false; + } + + // process must be known and not running. + long pid = char_to_long(b0.b0_pid); + if (pid == 0L || os_proc_running((int)pid)) { + ret = false; + } + + // TODO(bram): Should we check if the swap file was created on the current + // system? And the current user? + + close(fd); + return ret; +} + +static int recov_file_names(char_u **names, char_u *path, int prepend_dot) + FUNC_ATTR_NONNULL_ALL +{ + int num_names = 0; + + // May also add the file name with a dot prepended, for swap file in same + // dir as original file. + if (prepend_dot) { + names[num_names] = (char_u *)modname((char *)path, ".sw?", true); + if (names[num_names] == NULL) { + return num_names; + } + num_names++; + } + + // Form the normal swap file name pattern by appending ".sw?". + names[num_names] = (char_u *)concat_fnames((char *)path, ".sw?", FALSE); + if (num_names >= 1) { // check if we have the same name twice + char_u *p = names[num_names - 1]; + int i = (int)STRLEN(names[num_names - 1]) - (int)STRLEN(names[num_names]); + if (i > 0) { + p += i; // file name has been expanded to full path + } + if (STRCMP(p, names[num_names]) != 0) { + ++num_names; + } else { + xfree(names[num_names]); + } + } else { + ++num_names; + } + + return num_names; +} + +/* + * sync all memlines + * + * If 'check_file' is TRUE, check if original file exists and was not changed. + * If 'check_char' is TRUE, stop syncing when character becomes available, but + * always sync at least one block. + */ +void ml_sync_all(int check_file, int check_char, bool do_fsync) +{ + FOR_ALL_BUFFERS(buf) { + if (buf->b_ml.ml_mfp == NULL || buf->b_ml.ml_mfp->mf_fname == NULL) { + continue; // no file + } + ml_flush_line(buf); // flush buffered line + // flush locked block + (void)ml_find_line(buf, (linenr_T)0, ML_FLUSH); + if (bufIsChanged(buf) && check_file && mf_need_trans(buf->b_ml.ml_mfp) + && buf->b_ffname != NULL) { + /* + * If the original file does not exist anymore or has been changed + * call ml_preserve() to get rid of all negative numbered blocks. + */ + FileInfo file_info; + if (!os_fileinfo((char *)buf->b_ffname, &file_info) + || file_info.stat.st_mtim.tv_sec != buf->b_mtime_read + || os_fileinfo_size(&file_info) != buf->b_orig_size) { + ml_preserve(buf, false, do_fsync); + did_check_timestamps = false; + need_check_timestamps = true; // give message later + } + } + if (buf->b_ml.ml_mfp->mf_dirty) { + (void)mf_sync(buf->b_ml.ml_mfp, (check_char ? MFS_STOP : 0) + | (do_fsync && bufIsChanged(buf) ? MFS_FLUSH : 0)); + if (check_char && os_char_avail()) { // character available now + break; + } + } + } +} + +/* + * sync one buffer, including negative blocks + * + * after this all the blocks are in the swap file + * + * Used for the :preserve command and when the original file has been + * changed or deleted. + * + * when message is TRUE the success of preserving is reported + */ +void ml_preserve(buf_T *buf, int message, bool do_fsync) +{ + bhdr_T *hp; + linenr_T lnum; + memfile_T *mfp = buf->b_ml.ml_mfp; + int status; + int got_int_save = got_int; + + if (mfp == NULL || mfp->mf_fname == NULL) { + if (message) { + emsg(_("E313: Cannot preserve, there is no swap file")); + } + return; + } + + // We only want to stop when interrupted here, not when interrupted + // before. + got_int = false; + + ml_flush_line(buf); // flush buffered line + (void)ml_find_line(buf, (linenr_T)0, ML_FLUSH); // flush locked block + status = mf_sync(mfp, MFS_ALL | (do_fsync ? MFS_FLUSH : 0)); + + // stack is invalid after mf_sync(.., MFS_ALL) + buf->b_ml.ml_stack_top = 0; + + /* + * Some of the data blocks may have been changed from negative to + * positive block number. In that case the pointer blocks need to be + * updated. + * + * We don't know in which pointer block the references are, so we visit + * all data blocks until there are no more translations to be done (or + * we hit the end of the file, which can only happen in case a write fails, + * e.g. when file system if full). + * ml_find_line() does the work by translating the negative block numbers + * when getting the first line of each data block. + */ + if (mf_need_trans(mfp) && !got_int) { + lnum = 1; + while (mf_need_trans(mfp) && lnum <= buf->b_ml.ml_line_count) { + hp = ml_find_line(buf, lnum, ML_FIND); + if (hp == NULL) { + status = FAIL; + goto theend; + } + CHECK(buf->b_ml.ml_locked_low != lnum, "low != lnum"); + lnum = buf->b_ml.ml_locked_high + 1; + } + (void)ml_find_line(buf, (linenr_T)0, ML_FLUSH); // flush locked block + // sync the updated pointer blocks + if (mf_sync(mfp, MFS_ALL | (do_fsync ? MFS_FLUSH : 0)) == FAIL) { + status = FAIL; + } + buf->b_ml.ml_stack_top = 0; // stack is invalid now + } +theend: + got_int |= got_int_save; + + if (message) { + if (status == OK) { + msg(_("File preserved")); + } else { + emsg(_("E314: Preserve failed")); + } + } +} + +/* + * NOTE: The pointer returned by the ml_get_*() functions only remains valid + * until the next call! + * line1 = ml_get(1); + * line2 = ml_get(2); // line1 is now invalid! + * Make a copy of the line if necessary. + */ +/* + * Return a pointer to a (read-only copy of a) line. + * + * On failure an error message is given and IObuff is returned (to avoid + * having to check for error everywhere). + */ +char_u *ml_get(linenr_T lnum) +{ + return ml_get_buf(curbuf, lnum, false); +} + +/* + * Return pointer to position "pos". + */ +char_u *ml_get_pos(const pos_T *pos) + FUNC_ATTR_NONNULL_ALL +{ + return ml_get_buf(curbuf, pos->lnum, false) + pos->col; +} + +/// Return a pointer to a line in a specific buffer +/// +/// @param will_change true mark the buffer dirty (chars in the line will be changed) +char_u *ml_get_buf(buf_T *buf, linenr_T lnum, bool will_change) + FUNC_ATTR_NONNULL_ALL +{ + bhdr_T *hp; + DATA_BL *dp; + char_u *ptr; + static int recursive = 0; + + if (lnum > buf->b_ml.ml_line_count) { // invalid line number + if (recursive == 0) { + // Avoid giving this message for a recursive call, may happen when + // the GUI redraws part of the text. + recursive++; + siemsg(_("E315: ml_get: invalid lnum: %" PRId64), (int64_t)lnum); + recursive--; + } +errorret: + STRCPY(IObuff, "???"); + return IObuff; + } + if (lnum <= 0) { // pretend line 0 is line 1 + lnum = 1; + } + + if (buf->b_ml.ml_mfp == NULL) { // there are no lines + return (char_u *)""; + } + + /* + * See if it is the same line as requested last time. + * Otherwise may need to flush last used line. + * Don't use the last used line when 'swapfile' is reset, need to load all + * blocks. + */ + if (buf->b_ml.ml_line_lnum != lnum) { + ml_flush_line(buf); + + /* + * Find the data block containing the line. + * This also fills the stack with the blocks from the root to the data + * block and releases any locked block. + */ + if ((hp = ml_find_line(buf, lnum, ML_FIND)) == NULL) { + if (recursive == 0) { + // Avoid giving this message for a recursive call, may happen + // when the GUI redraws part of the text. + recursive++; + get_trans_bufname(buf); + shorten_dir(NameBuff); + siemsg(_("E316: ml_get: cannot find line %" PRId64 " in buffer %d %s"), + (int64_t)lnum, buf->b_fnum, NameBuff); + recursive--; + } + goto errorret; + } + + dp = hp->bh_data; + + ptr = (char_u *)dp + + ((dp->db_index[lnum - buf->b_ml.ml_locked_low]) & DB_INDEX_MASK); + buf->b_ml.ml_line_ptr = ptr; + buf->b_ml.ml_line_lnum = lnum; + buf->b_ml.ml_flags &= ~ML_LINE_DIRTY; + } + if (will_change) { + buf->b_ml.ml_flags |= (ML_LOCKED_DIRTY | ML_LOCKED_POS); + ml_add_deleted_len_buf(buf, buf->b_ml.ml_line_ptr, -1); + } + + return buf->b_ml.ml_line_ptr; +} + +/* + * Check if a line that was just obtained by a call to ml_get + * is in allocated memory. + */ +int ml_line_alloced(void) +{ + return curbuf->b_ml.ml_flags & ML_LINE_DIRTY; +} + +/// Append a line after lnum (may be 0 to insert a line in front of the file). +/// "line" does not need to be allocated, but can't be another line in a +/// buffer, unlocking may make it invalid. +/// +/// newfile: TRUE when starting to edit a new file, meaning that pe_old_lnum +/// will be set for recovery +/// Check: The caller of this function should probably also call +/// appended_lines(). +/// +/// @param lnum append after this line (can be 0) +/// @param line text of the new line +/// @param len length of new line, including NUL, or 0 +/// @param newfile flag, see above +/// +/// @return FAIL for failure, OK otherwise +int ml_append(linenr_T lnum, char_u *line, colnr_T len, bool newfile) +{ + // When starting up, we might still need to create the memfile + if (curbuf->b_ml.ml_mfp == NULL && open_buffer(FALSE, NULL, 0) == FAIL) { + return FAIL; + } + + if (curbuf->b_ml.ml_line_lnum != 0) { + ml_flush_line(curbuf); + } + return ml_append_int(curbuf, lnum, line, len, newfile, FALSE); +} + +/// Like ml_append() but for an arbitrary buffer. The buffer must already have +/// a memline. +/// +/// @param lnum append after this line (can be 0) +/// @param line text of the new line +/// @param len length of new line, including NUL, or 0 +/// @param newfile flag, see above +int ml_append_buf(buf_T *buf, linenr_T lnum, char_u *line, colnr_T len, bool newfile) + FUNC_ATTR_NONNULL_ARG(1) +{ + if (buf->b_ml.ml_mfp == NULL) { + return FAIL; + } + + if (buf->b_ml.ml_line_lnum != 0) { + ml_flush_line(buf); + } + return ml_append_int(buf, lnum, line, len, newfile, FALSE); +} + +/// @param lnum append after this line (can be 0) +/// @param line text of the new line +/// @param len length of line, including NUL, or 0 +/// @param newfile flag, see above +/// @param mark mark the new line +static int ml_append_int(buf_T *buf, linenr_T lnum, char_u *line, colnr_T len, bool newfile, + int mark) +{ + int i; + int line_count; // number of indexes in current block + int offset; + int from, to; + int space_needed; // space needed for new line + int page_size; + int page_count; + int db_idx; // index for lnum in data block + bhdr_T *hp; + memfile_T *mfp; + DATA_BL *dp; + PTR_BL *pp; + infoptr_T *ip; + + // lnum out of range + if (lnum > buf->b_ml.ml_line_count || buf->b_ml.ml_mfp == NULL) { + return FAIL; + } + + if (lowest_marked && lowest_marked > lnum) { + lowest_marked = lnum + 1; + } + + if (len == 0) { + len = (colnr_T)STRLEN(line) + 1; // space needed for the text + } + space_needed = len + INDEX_SIZE; // space needed for text + index + + mfp = buf->b_ml.ml_mfp; + page_size = mfp->mf_page_size; + + /* + * find the data block containing the previous line + * This also fills the stack with the blocks from the root to the data block + * This also releases any locked block. + */ + if ((hp = ml_find_line(buf, lnum == 0 ? (linenr_T)1 : lnum, + ML_INSERT)) == NULL) { + return FAIL; + } + + buf->b_ml.ml_flags &= ~ML_EMPTY; + + if (lnum == 0) { // got line one instead, correct db_idx + db_idx = -1; // careful, it is negative! + } else { + db_idx = lnum - buf->b_ml.ml_locked_low; + } + // get line count before the insertion + line_count = buf->b_ml.ml_locked_high - buf->b_ml.ml_locked_low; + + dp = hp->bh_data; + + /* + * If + * - there is not enough room in the current block + * - appending to the last line in the block + * - not appending to the last line in the file + * insert in front of the next block. + */ + if ((int)dp->db_free < space_needed && db_idx == line_count - 1 + && lnum < buf->b_ml.ml_line_count) { + /* + * Now that the line is not going to be inserted in the block that we + * expected, the line count has to be adjusted in the pointer blocks + * by using ml_locked_lineadd. + */ + --(buf->b_ml.ml_locked_lineadd); + --(buf->b_ml.ml_locked_high); + if ((hp = ml_find_line(buf, lnum + 1, ML_INSERT)) == NULL) { + return FAIL; + } + + db_idx = -1; // careful, it is negative! + // get line count before the insertion + line_count = buf->b_ml.ml_locked_high - buf->b_ml.ml_locked_low; + CHECK(buf->b_ml.ml_locked_low != lnum + 1, "locked_low != lnum + 1"); + + dp = hp->bh_data; + } + + ++buf->b_ml.ml_line_count; + + if ((int)dp->db_free >= space_needed) { // enough room in data block + /* + * Insert new line in existing data block, or in data block allocated above. + */ + dp->db_txt_start -= len; + dp->db_free -= space_needed; + ++(dp->db_line_count); + + /* + * move the text of the lines that follow to the front + * adjust the indexes of the lines that follow + */ + if (line_count > db_idx + 1) { // if there are following lines + /* + * Offset is the start of the previous line. + * This will become the character just after the new line. + */ + if (db_idx < 0) { + offset = dp->db_txt_end; + } else { + offset = ((dp->db_index[db_idx]) & DB_INDEX_MASK); + } + memmove((char *)dp + dp->db_txt_start, + (char *)dp + dp->db_txt_start + len, + (size_t)(offset - (dp->db_txt_start + len))); + for (i = line_count - 1; i > db_idx; --i) { + dp->db_index[i + 1] = dp->db_index[i] - len; + } + dp->db_index[db_idx + 1] = offset - len; + } else { // add line at the end + dp->db_index[db_idx + 1] = dp->db_txt_start; + } + + /* + * copy the text into the block + */ + memmove((char *)dp + dp->db_index[db_idx + 1], line, (size_t)len); + if (mark) { + dp->db_index[db_idx + 1] |= DB_MARKED; + } + + /* + * Mark the block dirty. + */ + buf->b_ml.ml_flags |= ML_LOCKED_DIRTY; + if (!newfile) { + buf->b_ml.ml_flags |= ML_LOCKED_POS; + } + } else { // not enough space in data block + /* + * If there is not enough room we have to create a new data block and copy some + * lines into it. + * Then we have to insert an entry in the pointer block. + * If this pointer block also is full, we go up another block, and so on, up + * to the root if necessary. + * The line counts in the pointer blocks have already been adjusted by + * ml_find_line(). + */ + long line_count_left, line_count_right; + int page_count_left, page_count_right; + bhdr_T *hp_left; + bhdr_T *hp_right; + bhdr_T *hp_new; + int lines_moved; + int data_moved = 0; // init to shut up gcc + int total_moved = 0; // init to shut up gcc + DATA_BL *dp_right, *dp_left; + int stack_idx; + bool in_left; + int lineadd; + blocknr_T bnum_left, bnum_right; + linenr_T lnum_left, lnum_right; + int pb_idx; + PTR_BL *pp_new; + + /* + * We are going to allocate a new data block. Depending on the + * situation it will be put to the left or right of the existing + * block. If possible we put the new line in the left block and move + * the lines after it to the right block. Otherwise the new line is + * also put in the right block. This method is more efficient when + * inserting a lot of lines at one place. + */ + if (db_idx < 0) { // left block is new, right block is existing + lines_moved = 0; + in_left = true; + // space_needed does not change + } else { // left block is existing, right block is new + lines_moved = line_count - db_idx - 1; + if (lines_moved == 0) { + in_left = false; // put new line in right block + // space_needed does not change + } else { + data_moved = ((dp->db_index[db_idx]) & DB_INDEX_MASK) - + dp->db_txt_start; + total_moved = data_moved + lines_moved * INDEX_SIZE; + if ((int)dp->db_free + total_moved >= space_needed) { + in_left = true; // put new line in left block + space_needed = total_moved; + } else { + in_left = false; // put new line in right block + space_needed += total_moved; + } + } + } + + page_count = ((space_needed + HEADER_SIZE) + page_size - 1) / page_size; + hp_new = ml_new_data(mfp, newfile, page_count); + if (db_idx < 0) { // left block is new + hp_left = hp_new; + hp_right = hp; + line_count_left = 0; + line_count_right = line_count; + } else { // right block is new + hp_left = hp; + hp_right = hp_new; + line_count_left = line_count; + line_count_right = 0; + } + dp_right = hp_right->bh_data; + dp_left = hp_left->bh_data; + bnum_left = hp_left->bh_bnum; + bnum_right = hp_right->bh_bnum; + page_count_left = hp_left->bh_page_count; + page_count_right = hp_right->bh_page_count; + + /* + * May move the new line into the right/new block. + */ + if (!in_left) { + dp_right->db_txt_start -= len; + dp_right->db_free -= len + INDEX_SIZE; + dp_right->db_index[0] = dp_right->db_txt_start; + if (mark) { + dp_right->db_index[0] |= DB_MARKED; + } + + memmove((char *)dp_right + dp_right->db_txt_start, + line, (size_t)len); + ++line_count_right; + } + /* + * may move lines from the left/old block to the right/new one. + */ + if (lines_moved) { + /* + */ + dp_right->db_txt_start -= data_moved; + dp_right->db_free -= total_moved; + memmove((char *)dp_right + dp_right->db_txt_start, + (char *)dp_left + dp_left->db_txt_start, + (size_t)data_moved); + offset = dp_right->db_txt_start - dp_left->db_txt_start; + dp_left->db_txt_start += data_moved; + dp_left->db_free += total_moved; + + /* + * update indexes in the new block + */ + for (to = line_count_right, from = db_idx + 1; + from < line_count_left; ++from, ++to) { + dp_right->db_index[to] = dp->db_index[from] + offset; + } + line_count_right += lines_moved; + line_count_left -= lines_moved; + } + + /* + * May move the new line into the left (old or new) block. + */ + if (in_left) { + dp_left->db_txt_start -= len; + dp_left->db_free -= len + INDEX_SIZE; + dp_left->db_index[line_count_left] = dp_left->db_txt_start; + if (mark) { + dp_left->db_index[line_count_left] |= DB_MARKED; + } + memmove((char *)dp_left + dp_left->db_txt_start, + line, (size_t)len); + ++line_count_left; + } + + if (db_idx < 0) { // left block is new + lnum_left = lnum + 1; + lnum_right = 0; + } else { // right block is new + lnum_left = 0; + if (in_left) { + lnum_right = lnum + 2; + } else { + lnum_right = lnum + 1; + } + } + dp_left->db_line_count = line_count_left; + dp_right->db_line_count = line_count_right; + + /* + * release the two data blocks + * The new one (hp_new) already has a correct blocknumber. + * The old one (hp, in ml_locked) gets a positive blocknumber if + * we changed it and we are not editing a new file. + */ + if (lines_moved || in_left) { + buf->b_ml.ml_flags |= ML_LOCKED_DIRTY; + } + if (!newfile && db_idx >= 0 && in_left) { + buf->b_ml.ml_flags |= ML_LOCKED_POS; + } + mf_put(mfp, hp_new, true, false); + + /* + * flush the old data block + * set ml_locked_lineadd to 0, because the updating of the + * pointer blocks is done below + */ + lineadd = buf->b_ml.ml_locked_lineadd; + buf->b_ml.ml_locked_lineadd = 0; + (void)ml_find_line(buf, (linenr_T)0, ML_FLUSH); // flush data block + + /* + * update pointer blocks for the new data block + */ + for (stack_idx = buf->b_ml.ml_stack_top - 1; stack_idx >= 0; + --stack_idx) { + ip = &(buf->b_ml.ml_stack[stack_idx]); + pb_idx = ip->ip_index; + if ((hp = mf_get(mfp, ip->ip_bnum, 1)) == NULL) { + return FAIL; + } + pp = hp->bh_data; // must be pointer block + if (pp->pb_id != PTR_ID) { + iemsg(_("E317: pointer block id wrong 3")); + mf_put(mfp, hp, false, false); + return FAIL; + } + /* + * TODO: If the pointer block is full and we are adding at the end + * try to insert in front of the next block + */ + // block not full, add one entry + if (pp->pb_count < pp->pb_count_max) { + if (pb_idx + 1 < (int)pp->pb_count) { + memmove(&pp->pb_pointer[pb_idx + 2], + &pp->pb_pointer[pb_idx + 1], + (size_t)(pp->pb_count - pb_idx - 1) * sizeof(PTR_EN)); + } + ++pp->pb_count; + pp->pb_pointer[pb_idx].pe_line_count = line_count_left; + pp->pb_pointer[pb_idx].pe_bnum = bnum_left; + pp->pb_pointer[pb_idx].pe_page_count = page_count_left; + pp->pb_pointer[pb_idx + 1].pe_line_count = line_count_right; + pp->pb_pointer[pb_idx + 1].pe_bnum = bnum_right; + pp->pb_pointer[pb_idx + 1].pe_page_count = page_count_right; + + if (lnum_left != 0) { + pp->pb_pointer[pb_idx].pe_old_lnum = lnum_left; + } + if (lnum_right != 0) { + pp->pb_pointer[pb_idx + 1].pe_old_lnum = lnum_right; + } + + mf_put(mfp, hp, true, false); + buf->b_ml.ml_stack_top = stack_idx + 1; // truncate stack + + if (lineadd) { + --(buf->b_ml.ml_stack_top); + // fix line count for rest of blocks in the stack + ml_lineadd(buf, lineadd); + // fix stack itself + buf->b_ml.ml_stack[buf->b_ml.ml_stack_top].ip_high += + lineadd; + ++(buf->b_ml.ml_stack_top); + } + + /* + * We are finished, break the loop here. + */ + break; + } else { // pointer block full + /* + * split the pointer block + * allocate a new pointer block + * move some of the pointer into the new block + * prepare for updating the parent block + */ + for (;;) { // do this twice when splitting block 1 + hp_new = ml_new_ptr(mfp); + if (hp_new == NULL) { // TODO: try to fix tree + return FAIL; + } + pp_new = hp_new->bh_data; + + if (hp->bh_bnum != 1) { + break; + } + + /* + * if block 1 becomes full the tree is given an extra level + * The pointers from block 1 are moved into the new block. + * block 1 is updated to point to the new block + * then continue to split the new block + */ + memmove(pp_new, pp, (size_t)page_size); + pp->pb_count = 1; + pp->pb_pointer[0].pe_bnum = hp_new->bh_bnum; + pp->pb_pointer[0].pe_line_count = buf->b_ml.ml_line_count; + pp->pb_pointer[0].pe_old_lnum = 1; + pp->pb_pointer[0].pe_page_count = 1; + mf_put(mfp, hp, true, false); // release block 1 + hp = hp_new; // new block is to be split + pp = pp_new; + CHECK(stack_idx != 0, _("stack_idx should be 0")); + ip->ip_index = 0; + ++stack_idx; // do block 1 again later + } + /* + * move the pointers after the current one to the new block + * If there are none, the new entry will be in the new block. + */ + total_moved = pp->pb_count - pb_idx - 1; + if (total_moved) { + memmove(&pp_new->pb_pointer[0], + &pp->pb_pointer[pb_idx + 1], + (size_t)(total_moved) * sizeof(PTR_EN)); + pp_new->pb_count = total_moved; + pp->pb_count -= total_moved - 1; + pp->pb_pointer[pb_idx + 1].pe_bnum = bnum_right; + pp->pb_pointer[pb_idx + 1].pe_line_count = line_count_right; + pp->pb_pointer[pb_idx + 1].pe_page_count = page_count_right; + if (lnum_right) { + pp->pb_pointer[pb_idx + 1].pe_old_lnum = lnum_right; + } + } else { + pp_new->pb_count = 1; + pp_new->pb_pointer[0].pe_bnum = bnum_right; + pp_new->pb_pointer[0].pe_line_count = line_count_right; + pp_new->pb_pointer[0].pe_page_count = page_count_right; + pp_new->pb_pointer[0].pe_old_lnum = lnum_right; + } + pp->pb_pointer[pb_idx].pe_bnum = bnum_left; + pp->pb_pointer[pb_idx].pe_line_count = line_count_left; + pp->pb_pointer[pb_idx].pe_page_count = page_count_left; + if (lnum_left) { + pp->pb_pointer[pb_idx].pe_old_lnum = lnum_left; + } + lnum_left = 0; + lnum_right = 0; + + /* + * recompute line counts + */ + line_count_right = 0; + for (i = 0; i < (int)pp_new->pb_count; ++i) { + line_count_right += pp_new->pb_pointer[i].pe_line_count; + } + line_count_left = 0; + for (i = 0; i < (int)pp->pb_count; ++i) { + line_count_left += pp->pb_pointer[i].pe_line_count; + } + + bnum_left = hp->bh_bnum; + bnum_right = hp_new->bh_bnum; + page_count_left = 1; + page_count_right = 1; + mf_put(mfp, hp, true, false); + mf_put(mfp, hp_new, true, false); + } + } + + /* + * Safety check: fallen out of for loop? + */ + if (stack_idx < 0) { + iemsg(_("E318: Updated too many blocks?")); + buf->b_ml.ml_stack_top = 0; // invalidate stack + } + } + + // The line was inserted below 'lnum' + ml_updatechunk(buf, lnum + 1, (long)len, ML_CHNK_ADDLINE); + return OK; +} + +void ml_add_deleted_len(char_u *ptr, ssize_t len) +{ + ml_add_deleted_len_buf(curbuf, ptr, len); +} + +void ml_add_deleted_len_buf(buf_T *buf, char_u *ptr, ssize_t len) +{ + if (inhibit_delete_count) { + return; + } + if (len == -1) { + len = STRLEN(ptr); + } + curbuf->deleted_bytes += len+1; + curbuf->deleted_bytes2 += len+1; + if (curbuf->update_need_codepoints) { + mb_utflen(ptr, len, &curbuf->deleted_codepoints, + &curbuf->deleted_codeunits); + curbuf->deleted_codepoints++; // NL char + curbuf->deleted_codeunits++; + } +} + + +int ml_replace(linenr_T lnum, char_u *line, bool copy) +{ + return ml_replace_buf(curbuf, lnum, line, copy); +} + +// Replace line "lnum", with buffering, in current buffer. +// +// If "copy" is true, make a copy of the line, otherwise the line has been +// copied to allocated memory already. +// If "copy" is false the "line" may be freed to add text properties! +// Do not use it after calling ml_replace(). +// +// Check: The caller of this function should probably also call +// changed_lines(), unless update_screen(NOT_VALID) is used. +// +// return FAIL for failure, OK otherwise +int ml_replace_buf(buf_T *buf, linenr_T lnum, char_u *line, bool copy) +{ + if (line == NULL) { // just checking... + return FAIL; + } + + // When starting up, we might still need to create the memfile + if (buf->b_ml.ml_mfp == NULL && open_buffer(false, NULL, 0) == FAIL) { + return FAIL; + } + + bool readlen = true; + + if (copy) { + line = vim_strsave(line); + } + if (buf->b_ml.ml_line_lnum != lnum) { // other line buffered + ml_flush_line(buf); // flush it + } else if (buf->b_ml.ml_flags & ML_LINE_DIRTY) { // same line allocated + ml_add_deleted_len_buf(buf, buf->b_ml.ml_line_ptr, -1); + readlen = false; // already added the length + + xfree(buf->b_ml.ml_line_ptr); // free it + } + + if (readlen && kv_size(buf->update_callbacks)) { + ml_add_deleted_len_buf(buf, ml_get_buf(buf, lnum, false), -1); + } + + buf->b_ml.ml_line_ptr = line; + buf->b_ml.ml_line_lnum = lnum; + buf->b_ml.ml_flags = (buf->b_ml.ml_flags | ML_LINE_DIRTY) & ~ML_EMPTY; + + return OK; +} + +/// Delete line `lnum` in the current buffer. +/// +/// @note The caller of this function should probably also call +/// deleted_lines() after this. +/// +/// @param message Show "--No lines in buffer--" message. +/// @return FAIL for failure, OK otherwise +int ml_delete(linenr_T lnum, bool message) +{ + ml_flush_line(curbuf); + return ml_delete_int(curbuf, lnum, message); +} + +static int ml_delete_int(buf_T *buf, linenr_T lnum, bool message) +{ + bhdr_T *hp; + memfile_T *mfp; + DATA_BL *dp; + PTR_BL *pp; + infoptr_T *ip; + int count; // number of entries in block + int idx; + int stack_idx; + int text_start; + int line_start; + long line_size; + int i; + + if (lnum < 1 || lnum > buf->b_ml.ml_line_count) { + return FAIL; + } + + if (lowest_marked && lowest_marked > lnum) { + lowest_marked--; + } + + /* + * If the file becomes empty the last line is replaced by an empty line. + */ + if (buf->b_ml.ml_line_count == 1) { // file becomes empty + if (message) { + set_keep_msg(_(no_lines_msg), 0); + } + + i = ml_replace((linenr_T)1, (char_u *)"", true); + buf->b_ml.ml_flags |= ML_EMPTY; + + return i; + } + + /* + * find the data block containing the line + * This also fills the stack with the blocks from the root to the data block + * This also releases any locked block. + */ + mfp = buf->b_ml.ml_mfp; + if (mfp == NULL) { + return FAIL; + } + + if ((hp = ml_find_line(buf, lnum, ML_DELETE)) == NULL) { + return FAIL; + } + + dp = hp->bh_data; + // compute line count before the delete + count = (long)(buf->b_ml.ml_locked_high) + - (long)(buf->b_ml.ml_locked_low) + 2; + idx = lnum - buf->b_ml.ml_locked_low; + + --buf->b_ml.ml_line_count; + + line_start = ((dp->db_index[idx]) & DB_INDEX_MASK); + if (idx == 0) { // first line in block, text at the end + line_size = dp->db_txt_end - line_start; + } else { + line_size = ((dp->db_index[idx - 1]) & DB_INDEX_MASK) - line_start; + } + + // Line should always have an NL char internally (represented as NUL), + // even if 'noeol' is set. + assert(line_size >= 1); + ml_add_deleted_len_buf(buf, (char_u *)dp + line_start, line_size-1); + + /* + * special case: If there is only one line in the data block it becomes empty. + * Then we have to remove the entry, pointing to this data block, from the + * pointer block. If this pointer block also becomes empty, we go up another + * block, and so on, up to the root if necessary. + * The line counts in the pointer blocks have already been adjusted by + * ml_find_line(). + */ + if (count == 1) { + mf_free(mfp, hp); // free the data block + buf->b_ml.ml_locked = NULL; + + for (stack_idx = buf->b_ml.ml_stack_top - 1; stack_idx >= 0; + --stack_idx) { + buf->b_ml.ml_stack_top = 0; // stack is invalid when failing + ip = &(buf->b_ml.ml_stack[stack_idx]); + idx = ip->ip_index; + if ((hp = mf_get(mfp, ip->ip_bnum, 1)) == NULL) { + return FAIL; + } + pp = hp->bh_data; // must be pointer block + if (pp->pb_id != PTR_ID) { + iemsg(_("E317: pointer block id wrong 4")); + mf_put(mfp, hp, false, false); + return FAIL; + } + count = --(pp->pb_count); + if (count == 0) { // the pointer block becomes empty! + mf_free(mfp, hp); + } else { + if (count != idx) { // move entries after the deleted one + memmove(&pp->pb_pointer[idx], &pp->pb_pointer[idx + 1], + (size_t)(count - idx) * sizeof(PTR_EN)); + } + mf_put(mfp, hp, true, false); + + buf->b_ml.ml_stack_top = stack_idx; // truncate stack + // fix line count for rest of blocks in the stack + if (buf->b_ml.ml_locked_lineadd != 0) { + ml_lineadd(buf, buf->b_ml.ml_locked_lineadd); + buf->b_ml.ml_stack[buf->b_ml.ml_stack_top].ip_high += + buf->b_ml.ml_locked_lineadd; + } + ++(buf->b_ml.ml_stack_top); + + break; + } + } + CHECK(stack_idx < 0, _("deleted block 1?")); + } else { + /* + * delete the text by moving the next lines forwards + */ + text_start = dp->db_txt_start; + memmove((char *)dp + text_start + line_size, + (char *)dp + text_start, (size_t)(line_start - text_start)); + + /* + * delete the index by moving the next indexes backwards + * Adjust the indexes for the text movement. + */ + for (i = idx; i < count - 1; ++i) { + dp->db_index[i] = dp->db_index[i + 1] + line_size; + } + + dp->db_free += line_size + INDEX_SIZE; + dp->db_txt_start += line_size; + --(dp->db_line_count); + + /* + * mark the block dirty and make sure it is in the file (for recovery) + */ + buf->b_ml.ml_flags |= (ML_LOCKED_DIRTY | ML_LOCKED_POS); + } + + ml_updatechunk(buf, lnum, line_size, ML_CHNK_DELLINE); + return OK; +} + +/* + * set the B_MARKED flag for line 'lnum' + */ +void ml_setmarked(linenr_T lnum) +{ + bhdr_T *hp; + DATA_BL *dp; + // invalid line number + if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count + || curbuf->b_ml.ml_mfp == NULL) { + return; // give error message? + } + if (lowest_marked == 0 || lowest_marked > lnum) { + lowest_marked = lnum; + } + + /* + * find the data block containing the line + * This also fills the stack with the blocks from the root to the data block + * This also releases any locked block. + */ + if ((hp = ml_find_line(curbuf, lnum, ML_FIND)) == NULL) { + return; // give error message? + } + dp = hp->bh_data; + dp->db_index[lnum - curbuf->b_ml.ml_locked_low] |= DB_MARKED; + curbuf->b_ml.ml_flags |= ML_LOCKED_DIRTY; +} + +/* + * find the first line with its B_MARKED flag set + */ +linenr_T ml_firstmarked(void) +{ + bhdr_T *hp; + DATA_BL *dp; + linenr_T lnum; + int i; + + if (curbuf->b_ml.ml_mfp == NULL) { + return (linenr_T)0; + } + + /* + * The search starts with lowest_marked line. This is the last line where + * a mark was found, adjusted by inserting/deleting lines. + */ + for (lnum = lowest_marked; lnum <= curbuf->b_ml.ml_line_count;) { + /* + * Find the data block containing the line. + * This also fills the stack with the blocks from the root to the data + * block This also releases any locked block. + */ + if ((hp = ml_find_line(curbuf, lnum, ML_FIND)) == NULL) { + return (linenr_T)0; // give error message? + } + dp = hp->bh_data; + + for (i = lnum - curbuf->b_ml.ml_locked_low; + lnum <= curbuf->b_ml.ml_locked_high; ++i, ++lnum) { + if ((dp->db_index[i]) & DB_MARKED) { + (dp->db_index[i]) &= DB_INDEX_MASK; + curbuf->b_ml.ml_flags |= ML_LOCKED_DIRTY; + lowest_marked = lnum + 1; + return lnum; + } + } + } + + return (linenr_T)0; +} + +/* + * clear all DB_MARKED flags + */ +void ml_clearmarked(void) +{ + bhdr_T *hp; + DATA_BL *dp; + linenr_T lnum; + int i; + + if (curbuf->b_ml.ml_mfp == NULL) { // nothing to do + return; + } + + /* + * The search starts with line lowest_marked. + */ + for (lnum = lowest_marked; lnum <= curbuf->b_ml.ml_line_count;) { + /* + * Find the data block containing the line. + * This also fills the stack with the blocks from the root to the data + * block and releases any locked block. + */ + if ((hp = ml_find_line(curbuf, lnum, ML_FIND)) == NULL) { + return; // give error message? + } + dp = hp->bh_data; + + for (i = lnum - curbuf->b_ml.ml_locked_low; + lnum <= curbuf->b_ml.ml_locked_high; ++i, ++lnum) { + if ((dp->db_index[i]) & DB_MARKED) { + (dp->db_index[i]) &= DB_INDEX_MASK; + curbuf->b_ml.ml_flags |= ML_LOCKED_DIRTY; + } + } + } + + lowest_marked = 0; +} + +size_t ml_flush_deleted_bytes(buf_T *buf, size_t *codepoints, size_t *codeunits) +{ + size_t ret = buf->deleted_bytes; + *codepoints = buf->deleted_codepoints; + *codeunits = buf->deleted_codeunits; + buf->deleted_bytes = 0; + buf->deleted_codepoints = 0; + buf->deleted_codeunits = 0; + return ret; +} + +/* + * flush ml_line if necessary + */ +static void ml_flush_line(buf_T *buf) +{ + bhdr_T *hp; + DATA_BL *dp; + linenr_T lnum; + char_u *new_line; + char_u *old_line; + colnr_T new_len; + int old_len; + int extra; + int idx; + int start; + int count; + int i; + static bool entered = false; + + if (buf->b_ml.ml_line_lnum == 0 || buf->b_ml.ml_mfp == NULL) { + return; // nothing to do + } + if (buf->b_ml.ml_flags & ML_LINE_DIRTY) { + // This code doesn't work recursively. + if (entered) { + return; + } + entered = true; + + buf->flush_count++; + + lnum = buf->b_ml.ml_line_lnum; + new_line = buf->b_ml.ml_line_ptr; + + hp = ml_find_line(buf, lnum, ML_FIND); + if (hp == NULL) { + siemsg(_("E320: Cannot find line %" PRId64), (int64_t)lnum); + } else { + dp = hp->bh_data; + idx = lnum - buf->b_ml.ml_locked_low; + start = ((dp->db_index[idx]) & DB_INDEX_MASK); + old_line = (char_u *)dp + start; + if (idx == 0) { // line is last in block + old_len = dp->db_txt_end - start; + } else { // text of previous line follows + old_len = (dp->db_index[idx - 1] & DB_INDEX_MASK) - start; + } + new_len = (colnr_T)STRLEN(new_line) + 1; + extra = new_len - old_len; // negative if lines gets smaller + + /* + * if new line fits in data block, replace directly + */ + if ((int)dp->db_free >= extra) { + // if the length changes and there are following lines + count = buf->b_ml.ml_locked_high - buf->b_ml.ml_locked_low + 1; + if (extra != 0 && idx < count - 1) { + // move text of following lines + memmove((char *)dp + dp->db_txt_start - extra, + (char *)dp + dp->db_txt_start, + (size_t)(start - dp->db_txt_start)); + + // adjust pointers of this and following lines + for (i = idx + 1; i < count; ++i) { + dp->db_index[i] -= extra; + } + } + dp->db_index[idx] -= extra; + + // adjust free space + dp->db_free -= extra; + dp->db_txt_start -= extra; + + // copy new line into the data block + memmove(old_line - extra, new_line, (size_t)new_len); + buf->b_ml.ml_flags |= (ML_LOCKED_DIRTY | ML_LOCKED_POS); + // The else case is already covered by the insert and delete + ml_updatechunk(buf, lnum, (long)extra, ML_CHNK_UPDLINE); + } else { + // Cannot do it in one data block: Delete and append. + // Append first, because ml_delete_int() cannot delete the + // last line in a buffer, which causes trouble for a buffer + // that has only one line. + // Don't forget to copy the mark! + // How about handling errors??? + (void)ml_append_int(buf, lnum, new_line, new_len, false, + (dp->db_index[idx] & DB_MARKED)); + (void)ml_delete_int(buf, lnum, false); + } + } + xfree(new_line); + + entered = false; + } + + buf->b_ml.ml_line_lnum = 0; + buf->b_ml.ml_line_offset = 0; +} + +/* + * create a new, empty, data block + */ +static bhdr_T *ml_new_data(memfile_T *mfp, bool negative, int page_count) +{ + assert(page_count >= 0); + bhdr_T *hp = mf_new(mfp, negative, (unsigned)page_count); + DATA_BL *dp = hp->bh_data; + dp->db_id = DATA_ID; + dp->db_txt_start = dp->db_txt_end = page_count * mfp->mf_page_size; + dp->db_free = dp->db_txt_start - HEADER_SIZE; + dp->db_line_count = 0; + + return hp; +} + +/* + * create a new, empty, pointer block + */ +static bhdr_T *ml_new_ptr(memfile_T *mfp) +{ + bhdr_T *hp = mf_new(mfp, false, 1); + PTR_BL *pp = hp->bh_data; + pp->pb_id = PTR_ID; + pp->pb_count = 0; + pp->pb_count_max = (mfp->mf_page_size - sizeof(PTR_BL)) / sizeof(PTR_EN) + 1; + + return hp; +} + +/* + * lookup line 'lnum' in a memline + * + * action: if ML_DELETE or ML_INSERT the line count is updated while searching + * if ML_FLUSH only flush a locked block + * if ML_FIND just find the line + * + * If the block was found it is locked and put in ml_locked. + * The stack is updated to lead to the locked block. The ip_high field in + * the stack is updated to reflect the last line in the block AFTER the + * insert or delete, also if the pointer block has not been updated yet. But + * if ml_locked != NULL ml_locked_lineadd must be added to ip_high. + * + * return: NULL for failure, pointer to block header otherwise + */ +static bhdr_T *ml_find_line(buf_T *buf, linenr_T lnum, int action) +{ + DATA_BL *dp; + PTR_BL *pp; + infoptr_T *ip; + bhdr_T *hp; + memfile_T *mfp; + linenr_T t; + blocknr_T bnum, bnum2; + int dirty; + linenr_T low, high; + int top; + int page_count; + int idx; + + mfp = buf->b_ml.ml_mfp; + + /* + * If there is a locked block check if the wanted line is in it. + * If not, flush and release the locked block. + * Don't do this for ML_INSERT_SAME, because the stack need to be updated. + * Don't do this for ML_FLUSH, because we want to flush the locked block. + * Don't do this when 'swapfile' is reset, we want to load all the blocks. + */ + if (buf->b_ml.ml_locked) { + if (ML_SIMPLE(action) + && buf->b_ml.ml_locked_low <= lnum + && buf->b_ml.ml_locked_high >= lnum) { + // remember to update pointer blocks and stack later + if (action == ML_INSERT) { + ++(buf->b_ml.ml_locked_lineadd); + ++(buf->b_ml.ml_locked_high); + } else if (action == ML_DELETE) { + --(buf->b_ml.ml_locked_lineadd); + --(buf->b_ml.ml_locked_high); + } + return buf->b_ml.ml_locked; + } + + mf_put(mfp, buf->b_ml.ml_locked, buf->b_ml.ml_flags & ML_LOCKED_DIRTY, + buf->b_ml.ml_flags & ML_LOCKED_POS); + buf->b_ml.ml_locked = NULL; + + /* + * If lines have been added or deleted in the locked block, need to + * update the line count in pointer blocks. + */ + if (buf->b_ml.ml_locked_lineadd != 0) { + ml_lineadd(buf, buf->b_ml.ml_locked_lineadd); + } + } + + if (action == ML_FLUSH) { // nothing else to do + return NULL; + } + + bnum = 1; // start at the root of the tree + page_count = 1; + low = 1; + high = buf->b_ml.ml_line_count; + + if (action == ML_FIND) { // first try stack entries + for (top = buf->b_ml.ml_stack_top - 1; top >= 0; --top) { + ip = &(buf->b_ml.ml_stack[top]); + if (ip->ip_low <= lnum && ip->ip_high >= lnum) { + bnum = ip->ip_bnum; + low = ip->ip_low; + high = ip->ip_high; + buf->b_ml.ml_stack_top = top; // truncate stack at prev entry + break; + } + } + if (top < 0) { + buf->b_ml.ml_stack_top = 0; // not found, start at the root + } + } else { // ML_DELETE or ML_INSERT + buf->b_ml.ml_stack_top = 0; // start at the root + } + /* + * search downwards in the tree until a data block is found + */ + for (;;) { + if ((hp = mf_get(mfp, bnum, page_count)) == NULL) { + goto error_noblock; + } + + /* + * update high for insert/delete + */ + if (action == ML_INSERT) { + ++high; + } else if (action == ML_DELETE) { + --high; + } + + dp = hp->bh_data; + if (dp->db_id == DATA_ID) { // data block + buf->b_ml.ml_locked = hp; + buf->b_ml.ml_locked_low = low; + buf->b_ml.ml_locked_high = high; + buf->b_ml.ml_locked_lineadd = 0; + buf->b_ml.ml_flags &= ~(ML_LOCKED_DIRTY | ML_LOCKED_POS); + return hp; + } + + pp = (PTR_BL *)(dp); // must be pointer block + if (pp->pb_id != PTR_ID) { + iemsg(_("E317: pointer block id wrong")); + goto error_block; + } + + top = ml_add_stack(buf); // add new entry to stack + ip = &(buf->b_ml.ml_stack[top]); + ip->ip_bnum = bnum; + ip->ip_low = low; + ip->ip_high = high; + ip->ip_index = -1; // index not known yet + + dirty = FALSE; + for (idx = 0; idx < (int)pp->pb_count; ++idx) { + t = pp->pb_pointer[idx].pe_line_count; + CHECK(t == 0, _("pe_line_count is zero")); + if ((low += t) > lnum) { + ip->ip_index = idx; + bnum = pp->pb_pointer[idx].pe_bnum; + page_count = pp->pb_pointer[idx].pe_page_count; + high = low - 1; + low -= t; + + /* + * a negative block number may have been changed + */ + if (bnum < 0) { + bnum2 = mf_trans_del(mfp, bnum); + if (bnum != bnum2) { + bnum = bnum2; + pp->pb_pointer[idx].pe_bnum = bnum; + dirty = TRUE; + } + } + + break; + } + } + if (idx >= (int)pp->pb_count) { // past the end: something wrong! + if (lnum > buf->b_ml.ml_line_count) { + siemsg(_("E322: line number out of range: %" PRId64 " past the end"), + (int64_t)lnum - buf->b_ml.ml_line_count); + } else { + siemsg(_("E323: line count wrong in block %" PRId64), bnum); + } + goto error_block; + } + if (action == ML_DELETE) { + pp->pb_pointer[idx].pe_line_count--; + dirty = TRUE; + } else if (action == ML_INSERT) { + pp->pb_pointer[idx].pe_line_count++; + dirty = TRUE; + } + mf_put(mfp, hp, dirty, false); + } + +error_block: + mf_put(mfp, hp, false, false); +error_noblock: + /* + * If action is ML_DELETE or ML_INSERT we have to correct the tree for + * the incremented/decremented line counts, because there won't be a line + * inserted/deleted after all. + */ + if (action == ML_DELETE) { + ml_lineadd(buf, 1); + } else if (action == ML_INSERT) { + ml_lineadd(buf, -1); + } + buf->b_ml.ml_stack_top = 0; + return NULL; +} + +/* + * add an entry to the info pointer stack + * + * return number of the new entry + */ +static int ml_add_stack(buf_T *buf) +{ + int top = buf->b_ml.ml_stack_top; + + // may have to increase the stack size + if (top == buf->b_ml.ml_stack_size) { + CHECK(top > 0, _("Stack size increases")); // more than 5 levels??? + + buf->b_ml.ml_stack_size += STACK_INCR; + size_t new_size = sizeof(infoptr_T) * buf->b_ml.ml_stack_size; + buf->b_ml.ml_stack = xrealloc(buf->b_ml.ml_stack, new_size); + } + + buf->b_ml.ml_stack_top++; + return top; +} + +/* + * Update the pointer blocks on the stack for inserted/deleted lines. + * The stack itself is also updated. + * + * When an insert/delete line action fails, the line is not inserted/deleted, + * but the pointer blocks have already been updated. That is fixed here by + * walking through the stack. + * + * Count is the number of lines added, negative if lines have been deleted. + */ +static void ml_lineadd(buf_T *buf, int count) +{ + int idx; + infoptr_T *ip; + PTR_BL *pp; + memfile_T *mfp = buf->b_ml.ml_mfp; + bhdr_T *hp; + + for (idx = buf->b_ml.ml_stack_top - 1; idx >= 0; --idx) { + ip = &(buf->b_ml.ml_stack[idx]); + if ((hp = mf_get(mfp, ip->ip_bnum, 1)) == NULL) { + break; + } + pp = hp->bh_data; // must be pointer block + if (pp->pb_id != PTR_ID) { + mf_put(mfp, hp, false, false); + iemsg(_("E317: pointer block id wrong 2")); + break; + } + pp->pb_pointer[ip->ip_index].pe_line_count += count; + ip->ip_high += count; + mf_put(mfp, hp, true, false); + } +} + +#if defined(HAVE_READLINK) +/* + * Resolve a symlink in the last component of a file name. + * Note that f_resolve() does it for every part of the path, we don't do that + * here. + * If it worked returns OK and the resolved link in "buf[MAXPATHL]". + * Otherwise returns FAIL. + */ +int resolve_symlink(const char_u *fname, char_u *buf) +{ + char_u tmp[MAXPATHL]; + int ret; + int depth = 0; + + if (fname == NULL) { + return FAIL; + } + + // Put the result so far in tmp[], starting with the original name. + STRLCPY(tmp, fname, MAXPATHL); + + for (;;) { + // Limit symlink depth to 100, catch recursive loops. + if (++depth == 100) { + semsg(_("E773: Symlink loop for \"%s\""), fname); + return FAIL; + } + + ret = readlink((char *)tmp, (char *)buf, MAXPATHL - 1); + if (ret <= 0) { + if (errno == EINVAL || errno == ENOENT) { + // Found non-symlink or not existing file, stop here. + // When at the first level use the unmodified name, skip the + // call to vim_FullName(). + if (depth == 1) { + return FAIL; + } + + // Use the resolved name in tmp[]. + break; + } + + // There must be some error reading links, use original name. + return FAIL; + } + buf[ret] = NUL; + + // Check whether the symlink is relative or absolute. + // If it's relative, build a new path based on the directory + // portion of the filename (if any) and the path the symlink + // points to. + if (path_is_absolute(buf)) { + STRCPY(tmp, buf); + } else { + char_u *tail = path_tail(tmp); + if (STRLEN(tail) + STRLEN(buf) >= MAXPATHL) { + return FAIL; + } + STRCPY(tail, buf); + } + } + + /* + * Try to resolve the full name of the file so that the swapfile name will + * be consistent even when opening a relative symlink from different + * working directories. + */ + return vim_FullName((char *)tmp, (char *)buf, MAXPATHL, TRUE); +} +#endif + +/* + * Make swap file name out of the file name and a directory name. + * Returns pointer to allocated memory or NULL. + */ +char_u *makeswapname(char_u *fname, char_u *ffname, buf_T *buf, char_u *dir_name) +{ + char_u *r, *s; + char_u *fname_res = fname; +#ifdef HAVE_READLINK + char_u fname_buf[MAXPATHL]; + + // Expand symlink in the file name, so that we put the swap file with the + // actual file instead of with the symlink. + if (resolve_symlink(fname, fname_buf) == OK) { + fname_res = fname_buf; + } +#endif + int len = (int)STRLEN(dir_name); + + s = dir_name + len; + if (after_pathsep((char *)dir_name, (char *)s) + && len > 1 + && s[-1] == s[-2]) { // Ends with '//', Use Full path + r = NULL; + s = (char_u *)make_percent_swname((char *)dir_name, (char *)fname_res); + if (s != NULL) { + r = (char_u *)modname((char *)s, ".swp", false); + xfree(s); + } + return r; + } + + // Prepend a '.' to the swap file name for the current directory. + r = (char_u *)modname((char *)fname_res, ".swp", + dir_name[0] == '.' && dir_name[1] == NUL); + if (r == NULL) { // out of memory + return NULL; + } + + s = get_file_in_dir(r, dir_name); + xfree(r); + return s; +} + +/// Get file name to use for swap file or backup file. +/// Use the name of the edited file "fname" and an entry in the 'dir' or 'bdir' +/// option "dname". +/// - If "dname" is ".", return "fname" (swap file in dir of file). +/// - If "dname" starts with "./", insert "dname" in "fname" (swap file +/// relative to dir of file). +/// - Otherwise, prepend "dname" to the tail of "fname" (swap file in specific +/// dir). +/// +/// The return value is an allocated string and can be NULL. +/// +/// @param dname don't use "dirname", it is a global for Alpha +char_u *get_file_in_dir(char_u *fname, char_u *dname) +{ + char_u *t; + char_u *tail; + char_u *retval; + int save_char; + + tail = path_tail(fname); + + if (dname[0] == '.' && dname[1] == NUL) { + retval = vim_strsave(fname); + } else if (dname[0] == '.' && vim_ispathsep(dname[1])) { + if (tail == fname) { // no path before file name + retval = (char_u *)concat_fnames((char *)dname + 2, (char *)tail, TRUE); + } else { + save_char = *tail; + *tail = NUL; + t = (char_u *)concat_fnames((char *)fname, (char *)dname + 2, TRUE); + *tail = save_char; + retval = (char_u *)concat_fnames((char *)t, (char *)tail, TRUE); + xfree(t); + } + } else { + retval = (char_u *)concat_fnames((char *)dname, (char *)tail, TRUE); + } + + return retval; +} + + +/// Print the ATTENTION message: info about an existing swap file. +/// +/// @param buf buffer being edited +/// @param fname swap file name +static void attention_message(buf_T *buf, char_u *fname) +{ + assert(buf->b_fname != NULL); + + ++no_wait_return; + (void)emsg(_("E325: ATTENTION")); + msg_puts(_("\nFound a swap file by the name \"")); + msg_home_replace(fname); + msg_puts("\"\n"); + const time_t swap_mtime = swapfile_info(fname); + msg_puts(_("While opening file \"")); + msg_outtrans(buf->b_fname); + msg_puts("\"\n"); + FileInfo file_info; + if (!os_fileinfo((char *)buf->b_fname, &file_info)) { + msg_puts(_(" CANNOT BE FOUND")); + } else { + msg_puts(_(" dated: ")); + time_t x = file_info.stat.st_mtim.tv_sec; + char ctime_buf[50]; + msg_puts(os_ctime_r(&x, ctime_buf, sizeof(ctime_buf))); + if (swap_mtime != 0 && x > swap_mtime) { + msg_puts(_(" NEWER than swap file!\n")); + } + } + // Some of these messages are long to allow translation to + // other languages. + msg_puts(_("\n(1) Another program may be editing the same file. If this is" + " the case,\n be careful not to end up with two different" + " instances of the same\n file when making changes." + " Quit, or continue with caution.\n")); + msg_puts(_("(2) An edit session for this file crashed.\n")); + msg_puts(_(" If this is the case, use \":recover\" or \"vim -r ")); + msg_outtrans(buf->b_fname); + msg_puts(_("\"\n to recover the changes (see \":help recovery\").\n")); + msg_puts(_(" If you did this already, delete the swap file \"")); + msg_outtrans(fname); + msg_puts(_("\"\n to avoid this message.\n")); + cmdline_row = msg_row; + --no_wait_return; +} + + +/* + * Trigger the SwapExists autocommands. + * Returns a value for equivalent to do_dialog() (see below): + * 0: still need to ask for a choice + * 1: open read-only + * 2: edit anyway + * 3: recover + * 4: delete it + * 5: quit + * 6: abort + */ +static int do_swapexists(buf_T *buf, char_u *fname) +{ + set_vim_var_string(VV_SWAPNAME, (char *)fname, -1); + set_vim_var_string(VV_SWAPCHOICE, NULL, -1); + + // Trigger SwapExists autocommands with set to the file being + // edited. Disallow changing directory here. + allbuf_lock++; + apply_autocmds(EVENT_SWAPEXISTS, buf->b_fname, NULL, false, NULL); + allbuf_lock--; + + set_vim_var_string(VV_SWAPNAME, NULL, -1); + + switch (*get_vim_var_str(VV_SWAPCHOICE)) { + case 'o': + return 1; + case 'e': + return 2; + case 'r': + return 3; + case 'd': + return 4; + case 'q': + return 5; + case 'a': + return 6; + } + + return 0; +} + +/// Find out what name to use for the swap file for buffer 'buf'. +/// +/// Several names are tried to find one that does not exist. Last directory in +/// option is automatically created. +/// +/// @note If BASENAMELEN is not correct, you will get error messages for +/// not being able to open the swap or undo file. +/// @note May trigger SwapExists autocmd, pointers may change! +/// +/// @param[in] buf Buffer for which swap file names needs to be found. +/// @param[in,out] dirp Pointer to a list of directories. When out of memory, +/// is set to NULL. Is advanced to the next directory in +/// the list otherwise. +/// @param[in] old_fname Allowed existing swap file name. Except for this +/// case, name of the non-existing file is used. +/// @param[in,out] found_existing_dir If points to true, then new directory +/// for swap file is not created. At first +/// findswapname() call this argument must +/// point to false. This parameter may only +/// be set to true by this function, it is +/// never set to false. +/// +/// @return [allocated] Name of the swap file. +static char *findswapname(buf_T *buf, char **dirp, char *old_fname, bool *found_existing_dir) + FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ARG(1, 2, 4) +{ + char *fname; + size_t n; + char *dir_name; + char *buf_fname = (char *)buf->b_fname; + + /* + * Isolate a directory name from *dirp and put it in dir_name. + * First allocate some memory to put the directory name in. + */ + const size_t dir_len = strlen(*dirp) + 1; + dir_name = xmalloc(dir_len); + (void)copy_option_part((char_u **)dirp, (char_u *)dir_name, dir_len, ","); + + /* + * we try different names until we find one that does not exist yet + */ + fname = (char *)makeswapname((char_u *)buf_fname, buf->b_ffname, buf, + (char_u *)dir_name); + + for (;;) { + if (fname == NULL) { // must be out of memory + break; + } + if ((n = strlen(fname)) == 0) { // safety check + XFREE_CLEAR(fname); + break; + } + // check if the swapfile already exists + // Extra security check: When a swap file is a symbolic link, this + // is most likely a symlink attack. + FileInfo file_info; + bool file_or_link_found = os_fileinfo_link(fname, &file_info); + if (!file_or_link_found) { + break; + } + + // A file name equal to old_fname is OK to use. + if (old_fname != NULL && fnamecmp(fname, old_fname) == 0) { + break; + } + + // get here when file already exists + if (fname[n - 2] == 'w' && fname[n - 1] == 'p') { // first try + // If we get here the ".swp" file really exists. + // Give an error message, unless recovering, no file name, we are + // viewing a help file or when the path of the file is different + // (happens when all .swp files are in one directory). + if (!recoverymode && buf_fname != NULL + && !buf->b_help && !(buf->b_flags & BF_DUMMY)) { + int fd; + struct block0 b0; + int differ = FALSE; + + // Try to read block 0 from the swap file to get the original + // file name (and inode number). + fd = os_open(fname, O_RDONLY, 0); + if (fd >= 0) { + if (read_eintr(fd, &b0, sizeof(b0)) == sizeof(b0)) { + // If the swapfile has the same directory as the + // buffer don't compare the directory names, they can + // have a different mountpoint. + if (b0.b0_flags & B0_SAME_DIR) { + if (fnamecmp(path_tail(buf->b_ffname), + path_tail(b0.b0_fname)) != 0 + || !same_directory((char_u *)fname, buf->b_ffname)) { + // Symlinks may point to the same file even + // when the name differs, need to check the + // inode too. + expand_env(b0.b0_fname, NameBuff, MAXPATHL); + if (fnamecmp_ino(buf->b_ffname, NameBuff, + char_to_long(b0.b0_ino))) { + differ = TRUE; + } + } + } else { + // The name in the swap file may be + // "~user/path/file". Expand it first. + expand_env(b0.b0_fname, NameBuff, MAXPATHL); + if (fnamecmp_ino(buf->b_ffname, NameBuff, + char_to_long(b0.b0_ino))) { + differ = TRUE; + } + } + } + close(fd); + } + + // give the ATTENTION message when there is an old swap file + // for the current file, and the buffer was not recovered. + if (differ == false && !(curbuf->b_flags & BF_RECOVERED) + && vim_strchr(p_shm, SHM_ATTENTION) == NULL) { + int choice = 0; + + process_still_running = false; + // It's safe to delete the swap file if all these are true: + // - the edited file exists + // - the swap file has no changes and looks OK + if (os_path_exists(buf->b_fname) && swapfile_unchanged(fname)) { + choice = 4; + if (p_verbose > 0) { + verb_msg(_("Found a swap file that is not useful, deleting it")); + } + } + + // If there is a SwapExists autocommand and we can handle the + // response, trigger it. It may return 0 to ask the user anyway. + if (choice == 0 + && swap_exists_action != SEA_NONE + && has_autocmd(EVENT_SWAPEXISTS, (char_u *)buf_fname, buf)) { + choice = do_swapexists(buf, (char_u *)fname); + } + + if (choice == 0) { + // Show info about the existing swap file. + attention_message(buf, (char_u *)fname); + + // We don't want a 'q' typed at the more-prompt + // interrupt loading a file. + got_int = false; + + // If vimrc has "simalt ~x" we don't want it to + // interfere with the prompt here. + flush_buffers(FLUSH_TYPEAHEAD); + } + + if (swap_exists_action != SEA_NONE && choice == 0) { + const char *const sw_msg_1 = _("Swap file \""); + const char *const sw_msg_2 = _("\" already exists!"); + + const size_t fname_len = strlen(fname); + const size_t sw_msg_1_len = strlen(sw_msg_1); + const size_t sw_msg_2_len = strlen(sw_msg_2); + + const size_t name_len = sw_msg_1_len + fname_len + sw_msg_2_len + 5; + + char *const name = xmalloc(name_len); + memcpy(name, sw_msg_1, sw_msg_1_len + 1); + home_replace(NULL, (char_u *)fname, (char_u *)&name[sw_msg_1_len], + fname_len, true); + xstrlcat(name, sw_msg_2, name_len); + choice = do_dialog(VIM_WARNING, (char_u *)_("VIM - ATTENTION"), + (char_u *)name, + process_still_running + ? (char_u *)_("&Open Read-Only\n&Edit anyway\n&Recover" + "\n&Quit\n&Abort") : + (char_u *)_("&Open Read-Only\n&Edit anyway\n&Recover" + "\n&Delete it\n&Quit\n&Abort"), + 1, NULL, false); + + if (process_still_running && choice >= 4) { + choice++; // Skip missing "Delete it" button. + } + xfree(name); + + // pretend screen didn't scroll, need redraw anyway + msg_reset_scroll(); + } + + if (choice > 0) { + switch (choice) { + case 1: + buf->b_p_ro = TRUE; + break; + case 2: + break; + case 3: + swap_exists_action = SEA_RECOVER; + break; + case 4: + os_remove(fname); + break; + case 5: + swap_exists_action = SEA_QUIT; + break; + case 6: + swap_exists_action = SEA_QUIT; + got_int = TRUE; + break; + } + + // If the file was deleted this fname can be used. + if (!os_path_exists((char_u *)fname)) { + break; + } + } else { + msg_puts("\n"); + if (msg_silent == 0) { + // call wait_return() later + need_wait_return = true; + } + } + } + } + } + + /* + * Change the ".swp" extension to find another file that can be used. + * First decrement the last char: ".swo", ".swn", etc. + * If that still isn't enough decrement the last but one char: ".svz" + * Can happen when editing many "No Name" buffers. + */ + if (fname[n - 1] == 'a') { // ".s?a" + if (fname[n - 2] == 'a') { // ".saa": tried enough, give up + emsg(_("E326: Too many swap files found")); + XFREE_CLEAR(fname); + break; + } + --fname[n - 2]; // ".svz", ".suz", etc. + fname[n - 1] = 'z' + 1; + } + --fname[n - 1]; // ".swo", ".swn", etc. + } + + if (os_isdir((char_u *)dir_name)) { + *found_existing_dir = true; + } else if (!*found_existing_dir && **dirp == NUL) { + int ret; + char *failed_dir; + if ((ret = os_mkdir_recurse(dir_name, 0755, &failed_dir)) != 0) { + semsg(_("E303: Unable to create directory \"%s\" for swap file, " + "recovery impossible: %s"), + failed_dir, os_strerror(ret)); + xfree(failed_dir); + } + } + + xfree(dir_name); + return fname; +} + +static int b0_magic_wrong(ZERO_BL *b0p) +{ + return b0p->b0_magic_long != (long)B0_MAGIC_LONG + || b0p->b0_magic_int != (int)B0_MAGIC_INT + || b0p->b0_magic_short != (short)B0_MAGIC_SHORT + || b0p->b0_magic_char != B0_MAGIC_CHAR; +} + +/// Compare current file name with file name from swap file. +/// Try to use inode numbers when possible. +/// Return non-zero when files are different. +/// +/// When comparing file names a few things have to be taken into consideration: +/// - When working over a network the full path of a file depends on the host. +/// We check the inode number if possible. It is not 100% reliable though, +/// because the device number cannot be used over a network. +/// - When a file does not exist yet (editing a new file) there is no inode +/// number. +/// - The file name in a swap file may not be valid on the current host. The +/// "~user" form is used whenever possible to avoid this. +/// +/// This is getting complicated, let's make a table: +/// +/// ino_c ino_s fname_c fname_s differ = +/// +/// both files exist -> compare inode numbers: +/// != 0 != 0 X X ino_c != ino_s +/// +/// inode number(s) unknown, file names available -> compare file names +/// == 0 X OK OK fname_c != fname_s +/// X == 0 OK OK fname_c != fname_s +/// +/// current file doesn't exist, file for swap file exist, file name(s) not +/// available -> probably different +/// == 0 != 0 FAIL X TRUE +/// == 0 != 0 X FAIL TRUE +/// +/// current file exists, inode for swap unknown, file name(s) not +/// available -> probably different +/// != 0 == 0 FAIL X TRUE +/// != 0 == 0 X FAIL TRUE +/// +/// current file doesn't exist, inode for swap unknown, one file name not +/// available -> probably different +/// == 0 == 0 FAIL OK TRUE +/// == 0 == 0 OK FAIL TRUE +/// +/// current file doesn't exist, inode for swap unknown, both file names not +/// available -> compare file names +/// == 0 == 0 FAIL FAIL fname_c != fname_s +/// +/// Only the last 32 bits of the inode will be used. This can't be changed +/// without making the block 0 incompatible with 32 bit versions. +/// +/// @param fname_c current file name +/// @param fname_s file name from swap file +static bool fnamecmp_ino(char_u *fname_c, char_u *fname_s, long ino_block0) +{ + uint64_t ino_c = 0; // ino of current file + uint64_t ino_s; // ino of file from swap file + char_u buf_c[MAXPATHL]; // full path of fname_c + char_u buf_s[MAXPATHL]; // full path of fname_s + int retval_c; // flag: buf_c valid + int retval_s; // flag: buf_s valid + + FileInfo file_info; + if (os_fileinfo((char *)fname_c, &file_info)) { + ino_c = os_fileinfo_inode(&file_info); + } + + /* + * First we try to get the inode from the file name, because the inode in + * the swap file may be outdated. If that fails (e.g. this path is not + * valid on this machine), use the inode from block 0. + */ + if (os_fileinfo((char *)fname_s, &file_info)) { + ino_s = os_fileinfo_inode(&file_info); + } else { + ino_s = (uint64_t)ino_block0; + } + + if (ino_c && ino_s) { + return ino_c != ino_s; + } + + /* + * One of the inode numbers is unknown, try a forced vim_FullName() and + * compare the file names. + */ + retval_c = vim_FullName((char *)fname_c, (char *)buf_c, MAXPATHL, TRUE); + retval_s = vim_FullName((char *)fname_s, (char *)buf_s, MAXPATHL, TRUE); + if (retval_c == OK && retval_s == OK) { + return STRCMP(buf_c, buf_s) != 0; + } + + /* + * Can't compare inodes or file names, guess that the files are different, + * unless both appear not to exist at all, then compare with the file name + * in the swap file. + */ + if (ino_s == 0 && ino_c == 0 && retval_c == FAIL && retval_s == FAIL) { + return STRCMP(fname_c, fname_s) != 0; + } + return true; +} + +/* + * Move a long integer into a four byte character array. + * Used for machine independency in block zero. + */ +static void long_to_char(long n, char_u *s) +{ + s[0] = (char_u)(n & 0xff); + n = (unsigned)n >> 8; + s[1] = (char_u)(n & 0xff); + n = (unsigned)n >> 8; + s[2] = (char_u)(n & 0xff); + n = (unsigned)n >> 8; + s[3] = (char_u)(n & 0xff); +} + +static long char_to_long(char_u *s) +{ + long retval; + + retval = s[3]; + retval <<= 8; + retval |= s[2]; + retval <<= 8; + retval |= s[1]; + retval <<= 8; + retval |= s[0]; + + return retval; +} + +/* + * Set the flags in the first block of the swap file: + * - file is modified or not: buf->b_changed + * - 'fileformat' + * - 'fileencoding' + */ +void ml_setflags(buf_T *buf) +{ + bhdr_T *hp; + ZERO_BL *b0p; + + if (!buf->b_ml.ml_mfp) { + return; + } + for (hp = buf->b_ml.ml_mfp->mf_used_last; hp != NULL; hp = hp->bh_prev) { + if (hp->bh_bnum == 0) { + b0p = hp->bh_data; + b0p->b0_dirty = buf->b_changed ? B0_DIRTY : 0; + b0p->b0_flags = (b0p->b0_flags & ~B0_FF_MASK) + | (get_fileformat(buf) + 1); + add_b0_fenc(b0p, buf); + hp->bh_flags |= BH_DIRTY; + mf_sync(buf->b_ml.ml_mfp, MFS_ZERO); + break; + } + } +} + +#define MLCS_MAXL 800 // max no of lines in chunk +#define MLCS_MINL 400 // should be half of MLCS_MAXL + +/* + * Keep information for finding byte offset of a line, updtype may be one of: + * ML_CHNK_ADDLINE: Add len to parent chunk, possibly splitting it + * Careful: ML_CHNK_ADDLINE may cause ml_find_line() to be called. + * ML_CHNK_DELLINE: Subtract len from parent chunk, possibly deleting it + * ML_CHNK_UPDLINE: Add len to parent chunk, as a signed entity. + */ +static void ml_updatechunk(buf_T *buf, linenr_T line, long len, int updtype) +{ + static buf_T *ml_upd_lastbuf = NULL; + static linenr_T ml_upd_lastline; + static linenr_T ml_upd_lastcurline; + static int ml_upd_lastcurix; + + linenr_T curline = ml_upd_lastcurline; + int curix = ml_upd_lastcurix; + long size; + chunksize_T *curchnk; + int rest; + bhdr_T *hp; + DATA_BL *dp; + + if (buf->b_ml.ml_usedchunks == -1 || len == 0) { + return; + } + if (buf->b_ml.ml_chunksize == NULL) { + buf->b_ml.ml_chunksize = xmalloc(sizeof(chunksize_T) * 100); + buf->b_ml.ml_numchunks = 100; + buf->b_ml.ml_usedchunks = 1; + buf->b_ml.ml_chunksize[0].mlcs_numlines = 1; + buf->b_ml.ml_chunksize[0].mlcs_totalsize = 1; + } + + if (updtype == ML_CHNK_UPDLINE && buf->b_ml.ml_line_count == 1) { + /* + * First line in empty buffer from ml_flush_line() -- reset + */ + buf->b_ml.ml_usedchunks = 1; + buf->b_ml.ml_chunksize[0].mlcs_numlines = 1; + buf->b_ml.ml_chunksize[0].mlcs_totalsize = + (long)STRLEN(buf->b_ml.ml_line_ptr) + 1; + return; + } + + /* + * Find chunk that our line belongs to, curline will be at start of the + * chunk. + */ + if (buf != ml_upd_lastbuf || line != ml_upd_lastline + 1 + || updtype != ML_CHNK_ADDLINE) { + for (curline = 1, curix = 0; + curix < buf->b_ml.ml_usedchunks - 1 + && line >= curline + + buf->b_ml.ml_chunksize[curix].mlcs_numlines; + curix++) { + curline += buf->b_ml.ml_chunksize[curix].mlcs_numlines; + } + } else if (curix < buf->b_ml.ml_usedchunks - 1 + && line >= curline + buf->b_ml.ml_chunksize[curix].mlcs_numlines) { + // Adjust cached curix & curline + curline += buf->b_ml.ml_chunksize[curix].mlcs_numlines; + curix++; + } + curchnk = buf->b_ml.ml_chunksize + curix; + + if (updtype == ML_CHNK_DELLINE) { + len = -len; + } + curchnk->mlcs_totalsize += len; + if (updtype == ML_CHNK_ADDLINE) { + curchnk->mlcs_numlines++; + + // May resize here so we don't have to do it in both cases below + if (buf->b_ml.ml_usedchunks + 1 >= buf->b_ml.ml_numchunks) { + buf->b_ml.ml_numchunks = buf->b_ml.ml_numchunks * 3 / 2; + buf->b_ml.ml_chunksize = xrealloc(buf->b_ml.ml_chunksize, + sizeof(chunksize_T) * buf->b_ml.ml_numchunks); + } + + if (buf->b_ml.ml_chunksize[curix].mlcs_numlines >= MLCS_MAXL) { + int count; // number of entries in block + int idx; + int text_end; + int linecnt; + + memmove(buf->b_ml.ml_chunksize + curix + 1, + buf->b_ml.ml_chunksize + curix, + (buf->b_ml.ml_usedchunks - curix) * + sizeof(chunksize_T)); + // Compute length of first half of lines in the split chunk + size = 0; + linecnt = 0; + while (curline < buf->b_ml.ml_line_count + && linecnt < MLCS_MINL) { + if ((hp = ml_find_line(buf, curline, ML_FIND)) == NULL) { + buf->b_ml.ml_usedchunks = -1; + return; + } + dp = hp->bh_data; + count = (long)(buf->b_ml.ml_locked_high) - + (long)(buf->b_ml.ml_locked_low) + 1; + idx = curline - buf->b_ml.ml_locked_low; + curline = buf->b_ml.ml_locked_high + 1; + if (idx == 0) { // first line in block, text at the end + text_end = dp->db_txt_end; + } else { + text_end = ((dp->db_index[idx - 1]) & DB_INDEX_MASK); + } + // Compute index of last line to use in this MEMLINE + rest = count - idx; + if (linecnt + rest > MLCS_MINL) { + idx += MLCS_MINL - linecnt - 1; + linecnt = MLCS_MINL; + } else { + idx = count - 1; + linecnt += rest; + } + size += text_end - ((dp->db_index[idx]) & DB_INDEX_MASK); + } + buf->b_ml.ml_chunksize[curix].mlcs_numlines = linecnt; + buf->b_ml.ml_chunksize[curix + 1].mlcs_numlines -= linecnt; + buf->b_ml.ml_chunksize[curix].mlcs_totalsize = size; + buf->b_ml.ml_chunksize[curix + 1].mlcs_totalsize -= size; + buf->b_ml.ml_usedchunks++; + ml_upd_lastbuf = NULL; // Force recalc of curix & curline + return; + } else if (buf->b_ml.ml_chunksize[curix].mlcs_numlines >= MLCS_MINL + && curix == buf->b_ml.ml_usedchunks - 1 + && buf->b_ml.ml_line_count - line <= 1) { + /* + * We are in the last chunk and it is cheap to crate a new one + * after this. Do it now to avoid the loop above later on + */ + curchnk = buf->b_ml.ml_chunksize + curix + 1; + buf->b_ml.ml_usedchunks++; + if (line == buf->b_ml.ml_line_count) { + curchnk->mlcs_numlines = 0; + curchnk->mlcs_totalsize = 0; + } else { + /* + * Line is just prior to last, move count for last + * This is the common case when loading a new file + */ + hp = ml_find_line(buf, buf->b_ml.ml_line_count, ML_FIND); + if (hp == NULL) { + buf->b_ml.ml_usedchunks = -1; + return; + } + dp = hp->bh_data; + if (dp->db_line_count == 1) { + rest = dp->db_txt_end - dp->db_txt_start; + } else { + rest = + ((dp->db_index[dp->db_line_count - 2]) & DB_INDEX_MASK) + - dp->db_txt_start; + } + curchnk->mlcs_totalsize = rest; + curchnk->mlcs_numlines = 1; + curchnk[-1].mlcs_totalsize -= rest; + curchnk[-1].mlcs_numlines -= 1; + } + } + } else if (updtype == ML_CHNK_DELLINE) { + curchnk->mlcs_numlines--; + ml_upd_lastbuf = NULL; // Force recalc of curix & curline + if (curix < (buf->b_ml.ml_usedchunks - 1) + && (curchnk->mlcs_numlines + curchnk[1].mlcs_numlines) + <= MLCS_MINL) { + curix++; + curchnk = buf->b_ml.ml_chunksize + curix; + } else if (curix == 0 && curchnk->mlcs_numlines <= 0) { + buf->b_ml.ml_usedchunks--; + memmove(buf->b_ml.ml_chunksize, buf->b_ml.ml_chunksize + 1, + buf->b_ml.ml_usedchunks * sizeof(chunksize_T)); + return; + } else if (curix == 0 || (curchnk->mlcs_numlines > 10 + && (curchnk->mlcs_numlines + + curchnk[-1].mlcs_numlines) + > MLCS_MINL)) { + return; + } + + // Collapse chunks + curchnk[-1].mlcs_numlines += curchnk->mlcs_numlines; + curchnk[-1].mlcs_totalsize += curchnk->mlcs_totalsize; + buf->b_ml.ml_usedchunks--; + if (curix < buf->b_ml.ml_usedchunks) { + memmove(buf->b_ml.ml_chunksize + curix, + buf->b_ml.ml_chunksize + curix + 1, + (buf->b_ml.ml_usedchunks - curix) * + sizeof(chunksize_T)); + } + return; + } + ml_upd_lastbuf = buf; + ml_upd_lastline = line; + ml_upd_lastcurline = curline; + ml_upd_lastcurix = curix; +} + +/// Find offset for line or line with offset. +/// +/// @param buf buffer to use +/// @param lnum if > 0, find offset of lnum, return offset +/// if == 0, return line with offset *offp +/// @param offp offset to use to find line, store remaining column offset +/// Should be NULL when getting offset of line +/// @param no_ff ignore 'fileformat' option, always use one byte for NL. +/// +/// @return -1 if information is not available +long ml_find_line_or_offset(buf_T *buf, linenr_T lnum, long *offp, bool no_ff) +{ + linenr_T curline; + int curix; + long size; + bhdr_T *hp; + DATA_BL *dp; + int count; // number of entries in block + int idx; + int start_idx; + int text_end; + long offset; + int len; + int ffdos = !no_ff && (get_fileformat(buf) == EOL_DOS); + int extra = 0; + + // take care of cached line first. Only needed if the cached line is before + // the requested line. Additionally cache the value for the cached line. + // This is used by the extmark code which needs the byte offset of the edited + // line. So when doing multiple small edits on the same line the value is + // only calculated once. + // + // NB: caching doesn't work with 'fileformat'. This is not a problem for + // bytetracking, as bytetracking ignores 'fileformat' option. But calling + // line2byte() will invalidate the cache for the time being (this function + // was never cached to start with anyway). + bool can_cache = (lnum != 0 && !ffdos && buf->b_ml.ml_line_lnum == lnum); + if (lnum == 0 || buf->b_ml.ml_line_lnum < lnum || !no_ff) { + ml_flush_line(curbuf); + } else if (can_cache && buf->b_ml.ml_line_offset > 0) { + return buf->b_ml.ml_line_offset; + } + + if (buf->b_ml.ml_usedchunks == -1 + || buf->b_ml.ml_chunksize == NULL + || lnum < 0) { + return -1; + } + + if (offp == NULL) { + offset = 0; + } else { + offset = *offp; + } + if (lnum == 0 && offset <= 0) { + return 1; // Not a "find offset" and offset 0 _must_ be in line 1 + } + /* + * Find the last chunk before the one containing our line. Last chunk is + * special because it will never qualify + */ + curline = 1; + curix = size = 0; + while (curix < buf->b_ml.ml_usedchunks - 1 + && ((lnum != 0 + && lnum >= curline + buf->b_ml.ml_chunksize[curix].mlcs_numlines) + || (offset != 0 + && offset > size + + buf->b_ml.ml_chunksize[curix].mlcs_totalsize + + ffdos * buf->b_ml.ml_chunksize[curix].mlcs_numlines))) { + curline += buf->b_ml.ml_chunksize[curix].mlcs_numlines; + size += buf->b_ml.ml_chunksize[curix].mlcs_totalsize; + if (offset && ffdos) { + size += buf->b_ml.ml_chunksize[curix].mlcs_numlines; + } + curix++; + } + + while ((lnum != 0 && curline < lnum) || (offset != 0 && size < offset)) { + if (curline > buf->b_ml.ml_line_count + || (hp = ml_find_line(buf, curline, ML_FIND)) == NULL) { + return -1; + } + dp = hp->bh_data; + count = (long)(buf->b_ml.ml_locked_high) - + (long)(buf->b_ml.ml_locked_low) + 1; + start_idx = idx = curline - buf->b_ml.ml_locked_low; + if (idx == 0) { // first line in block, text at the end + text_end = dp->db_txt_end; + } else { + text_end = ((dp->db_index[idx - 1]) & DB_INDEX_MASK); + } + // Compute index of last line to use in this MEMLINE + if (lnum != 0) { + if (curline + (count - idx) >= lnum) { + idx += lnum - curline - 1; + } else { + idx = count - 1; + } + } else { + extra = 0; + while (offset >= size + + text_end - (int)((dp->db_index[idx]) & DB_INDEX_MASK) + + ffdos) { + if (ffdos) { + size++; + } + if (idx == count - 1) { + extra = 1; + break; + } + idx++; + } + } + len = text_end - ((dp->db_index[idx]) & DB_INDEX_MASK); + size += len; + if (offset != 0 && size >= offset) { + if (size + ffdos == offset) { + *offp = 0; + } else if (idx == start_idx) { + *offp = offset - size + len; + } else { + *offp = offset - size + len + - (text_end - ((dp->db_index[idx - 1]) & DB_INDEX_MASK)); + } + curline += idx - start_idx + extra; + if (curline > buf->b_ml.ml_line_count) { + return -1; // exactly one byte beyond the end + } + return curline; + } + curline = buf->b_ml.ml_locked_high + 1; + } + + if (lnum != 0) { + // Count extra CR characters. + if (ffdos) { + size += lnum - 1; + } + + // Don't count the last line break if 'noeol' and ('bin' or + // 'nofixeol'). + if ((!buf->b_p_fixeol || buf->b_p_bin) && !buf->b_p_eol + && lnum > buf->b_ml.ml_line_count) { + size -= ffdos + 1; + } + } + + if (can_cache && size > 0) { + buf->b_ml.ml_line_offset = size; + } + + return size; +} + +/// Goto byte in buffer with offset 'cnt'. +void goto_byte(long cnt) +{ + long boff = cnt; + linenr_T lnum; + + ml_flush_line(curbuf); // cached line may be dirty + setpcmark(); + if (boff) { + boff--; + } + lnum = ml_find_line_or_offset(curbuf, (linenr_T)0, &boff, false); + if (lnum < 1) { // past the end + curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count; + curwin->w_curswant = MAXCOL; + coladvance(MAXCOL); + } else { + curwin->w_cursor.lnum = lnum; + curwin->w_cursor.col = (colnr_T)boff; + curwin->w_cursor.coladd = 0; + curwin->w_set_curswant = TRUE; + } + check_cursor(); + + // Make sure the cursor is on the first byte of a multi-byte char. + mb_adjust_cursor(); +} + +/// Increment the line pointer "lp" crossing line boundaries as necessary. +/// Return 1 when going to the next line. +/// Return 2 when moving forward onto a NUL at the end of the line). +/// Return -1 when at the end of file. +/// Return 0 otherwise. +int inc(pos_T *lp) +{ + // when searching position may be set to end of a line + if (lp->col != MAXCOL) { + const char_u *const p = ml_get_pos(lp); + if (*p != NUL) { // still within line, move to next char (may be NUL) + const int l = utfc_ptr2len(p); + + lp->col += l; + return ((p[l] != NUL) ? 0 : 2); + } + } + if (lp->lnum != curbuf->b_ml.ml_line_count) { // there is a next line + lp->col = 0; + lp->lnum++; + lp->coladd = 0; + return 1; + } + return -1; +} + +/// Same as inc(), but skip NUL at the end of non-empty lines. +int incl(pos_T *lp) +{ + int r; + + if ((r = inc(lp)) >= 1 && lp->col) { + r = inc(lp); + } + return r; +} + +int dec(pos_T *lp) +{ + lp->coladd = 0; + if (lp->col == MAXCOL) { + // past end of line + char_u *p = ml_get(lp->lnum); + lp->col = (colnr_T)STRLEN(p); + lp->col -= utf_head_off(p, p + lp->col); + return 0; + } + + if (lp->col > 0) { + // still within line + lp->col--; + char_u *p = ml_get(lp->lnum); + lp->col -= utf_head_off(p, p + lp->col); + return 0; + } + if (lp->lnum > 1) { + // there is a prior line + lp->lnum--; + char_u *p = ml_get(lp->lnum); + lp->col = (colnr_T)STRLEN(p); + lp->col -= utf_head_off(p, p + lp->col); + return 1; + } + + // at start of file + return -1; +} + +/// Same as dec(), but skip NUL at the end of non-empty lines. +int decl(pos_T *lp) +{ + int r; + + if ((r = dec(lp)) == 1 && lp->col) { + r = dec(lp); + } + return r; +} diff --git a/vec.c b/vec.c new file mode 100644 index 0000000..20f905f --- /dev/null +++ b/vec.c @@ -0,0 +1,97 @@ +#include "vec.h" +#include +#include +#include +#include + +nodept new_node(int num) +{ + struct node *n = malloc(sizeof(nodept)); + assert(n); + // n->succ = malloc((n->cap = 8) * sizeof(nodept)); + // assert(n->succ); + n->num = num; + n->nbs = 0; + return n; +} + +void delete_node(struct node *n) +{ + int i; + // for (i = 0; i < n->nbs; i++) { + // free(n->succ[i]); + // } + // free(n->succ); +} + +void insert_succ(graph_vec *g, int i, int i1, fix_str str) +{ + if (g->node[i]->nbs == g->node[i]->cap) + g->node[i]->succ = reallocarray(g->node[i]->succ, (g->node[i]->cap += 5), sizeof(nodept)); + struct node *n = malloc(sizeof(struct node)); + n->num = i; + n->nbs = 0; + strcpy(n->func, str); + g->node[i]->succ[i1] = n; + g->node[i]->nbs++; +} + +graph_vec new_graph(int cap) +{ + graph_vec g; + g.n = -1; + g.cap = cap; + // g.func = calloc(cap, sizeof(fix_str)); + // g.node = calloc(cap, sizeof(nodept)); + return g; +} + +void insert_node(graph_vec *g, int i, fix_str str, bool intern) +{ + ++g->n; + struct node *n = malloc(sizeof(struct node)); + n->num = i; + n->nbs = 0; + n->cap = 5; + n->succ = malloc(5 * sizeof(nodept)); + strcpy(n->func, str); + g->node[g->n] = n; +} + +void delete_graph(graph_vec *g) +{ + int i, j; + for (i = 0; i <= g->n; ++i) { + if (g->node[i]) { + if (g->node[i]->succ) { + free(g->node[i]->succ); + g->node[i]->succ = NULL; + } + free(g->node[i]); + g->node[i] = NULL; + } + } +} + +int is_in(graph_vec g, fix_str func) +{ + int i; + for (i = 0; i < g.n; ++i) { + if (strcmp(g.node[i]->func, func) == 0) + return i; + } + return 0; +} + +void print_node(nodept node) +{ + int i; + printf("NODE: %s\n", node->func); + for (int i = 0; i < node->nbs; ++i) { + printf("SUCC: %s\n", node->succ[i]->func); + } + for (int i = 0; i < node->nbs; ++i) { + if (node->succ[i]->intern) + print_node(node->succ[i]); + } +} diff --git a/vec.h b/vec.h index d01b4cb..58f4baa 100644 --- a/vec.h +++ b/vec.h @@ -1,3 +1,5 @@ +#include + typedef char fix_str[256]; typedef struct node *nodept; typedef struct nodes graph_vec; @@ -5,12 +7,23 @@ typedef struct nodes graph_vec; struct nodes { int n; int cap; - fix_str *func; // noms de fonctions - nodept *node; + nodept node[1000]; }; struct node { - int num; // le numero de noeud - int nbs; // nombre de successeurs - struct node **succ; // les successeurs + bool intern; + int num; // le numero de noeud + int nbs; // nombre de successeurs + fix_str func; // noms de fonctions + int cap; + nodept *succ; // les successeurs }; + +struct node *new_node(int num); +void delete_node(struct node *n); +void insert_succ(graph_vec *g, int i, int i1, fix_str str); +graph_vec new_graph(int cap); +void insert_node(graph_vec *g, int i, fix_str str, bool intern); +void delete_graph(graph_vec *g); +int is_in(graph_vec g, fix_str func); +void print_node(nodept node);