Mercurial > vim
view src/viminfo.c @ 30158:008808e60963 v9.0.0415
patch 9.0.0415: on MS-Windows some tests are flaky
Commit: https://github.com/vim/vim/commit/0500e87eba7b2a82392dbb5d573de19f8ff138e7
Author: K.Takata <kentkt@csc.jp>
Date: Thu Sep 8 12:28:02 2022 +0100
patch 9.0.0415: on MS-Windows some tests are flaky
Problem: On MS-Windows some tests are flaky.
Solution: Add sleeps, disable swapfile, mark test as flaky. (Ken Takata,
closes #11082)
author | Bram Moolenaar <Bram@vim.org> |
---|---|
date | Thu, 08 Sep 2022 13:30:05 +0200 |
parents | d45ee1f829ba |
children | 029c59bf78f1 |
line wrap: on
line source
/* vi:set ts=8 sts=4 sw=4 noet: * * VIM - Vi IMproved by Bram Moolenaar * * Do ":help uganda" in Vim to read copying and usage conditions. * Do ":help credits" in Vim to see a list of people who contributed. * See README.txt for an overview of the Vim source code. */ /* * viminfo.c: viminfo related functions */ #include "vim.h" #include "version.h" /* * Structure used for reading from the viminfo file. */ typedef struct { char_u *vir_line; // text of the current line FILE *vir_fd; // file descriptor vimconv_T vir_conv; // encoding conversion int vir_version; // viminfo version detected or -1 garray_T vir_barlines; // lines starting with | } vir_T; typedef enum { BVAL_NR, BVAL_STRING, BVAL_EMPTY } btype_T; typedef struct { btype_T bv_type; long bv_nr; char_u *bv_string; char_u *bv_tofree; // free later when not NULL int bv_len; // length of bv_string int bv_allocated; // bv_string was allocated } bval_T; #if defined(FEAT_VIMINFO) || defined(PROTO) static int viminfo_errcnt; /* * Find the parameter represented by the given character (eg ''', ':', '"', or * '/') in the 'viminfo' option and return a pointer to the string after it. * Return NULL if the parameter is not specified in the string. */ static char_u * find_viminfo_parameter(int type) { char_u *p; for (p = p_viminfo; *p; ++p) { if (*p == type) return p + 1; if (*p == 'n') // 'n' is always the last one break; p = vim_strchr(p, ','); // skip until next ',' if (p == NULL) // hit the end without finding parameter break; } return NULL; } /* * Find the parameter represented by the given character (eg ', :, ", or /), * and return its associated value in the 'viminfo' string. * Only works for number parameters, not for 'r' or 'n'. * If the parameter is not specified in the string or there is no following * number, return -1. */ int get_viminfo_parameter(int type) { char_u *p; p = find_viminfo_parameter(type); if (p != NULL && VIM_ISDIGIT(*p)) return atoi((char *)p); return -1; } /* * Get the viminfo file name to use. * If "file" is given and not empty, use it (has already been expanded by * cmdline functions). * Otherwise use "-i file_name", value from 'viminfo' or the default, and * expand environment variables. * Returns an allocated string. NULL when out of memory. */ static char_u * viminfo_filename(char_u *file) { if (file == NULL || *file == NUL) { if (*p_viminfofile != NUL) file = p_viminfofile; else if ((file = find_viminfo_parameter('n')) == NULL || *file == NUL) { #ifdef VIMINFO_FILE2 # ifdef VMS if (mch_getenv((char_u *)"SYS$LOGIN") == NULL) # else # ifdef MSWIN // Use $VIM only if $HOME is the default "C:/". if (STRCMP(vim_getenv((char_u *)"HOME", NULL), "C:/") == 0 && mch_getenv((char_u *)"HOME") == NULL) # else if (mch_getenv((char_u *)"HOME") == NULL) # endif # endif { // don't use $VIM when not available. expand_env((char_u *)"$VIM", NameBuff, MAXPATHL); if (STRCMP("$VIM", NameBuff) != 0) // $VIM was expanded file = (char_u *)VIMINFO_FILE2; else file = (char_u *)VIMINFO_FILE; } else #endif file = (char_u *)VIMINFO_FILE; } expand_env(file, NameBuff, MAXPATHL); file = NameBuff; } return vim_strsave(file); } /* * write string to viminfo file * - replace CTRL-V with CTRL-V CTRL-V * - replace '\n' with CTRL-V 'n' * - add a '\n' at the end * * For a long line: * - write " CTRL-V <length> \n " in first line * - write " < <string> \n " in second line */ static void viminfo_writestring(FILE *fd, char_u *p) { int c; char_u *s; int len = 0; for (s = p; *s != NUL; ++s) { if (*s == Ctrl_V || *s == '\n') ++len; ++len; } // If the string will be too long, write its length and put it in the next // line. Take into account that some room is needed for what comes before // the string (e.g., variable name). Add something to the length for the // '<', NL and trailing NUL. if (len > LSIZE / 2) fprintf(fd, "\026%d\n<", len + 3); while ((c = *p++) != NUL) { if (c == Ctrl_V || c == '\n') { putc(Ctrl_V, fd); if (c == '\n') c = 'n'; } putc(c, fd); } putc('\n', fd); } /* * Write a string in quotes that barline_parse() can read back. * Breaks the line in less than LSIZE pieces when needed. * Returns remaining characters in the line. */ static int barline_writestring(FILE *fd, char_u *s, int remaining_start) { char_u *p; int remaining = remaining_start; int len = 2; // Count the number of characters produced, including quotes. for (p = s; *p != NUL; ++p) { if (*p == NL) len += 2; else if (*p == '"' || *p == '\\') len += 2; else ++len; } if (len > remaining - 2) { fprintf(fd, ">%d\n|<", len); remaining = LSIZE - 20; } putc('"', fd); for (p = s; *p != NUL; ++p) { if (*p == NL) { putc('\\', fd); putc('n', fd); --remaining; } else if (*p == '"' || *p == '\\') { putc('\\', fd); putc(*p, fd); --remaining; } else putc(*p, fd); --remaining; if (remaining < 3) { putc('\n', fd); putc('|', fd); putc('<', fd); // Leave enough space for another continuation. remaining = LSIZE - 20; } } putc('"', fd); return remaining - 2; } /* * Check string read from viminfo file. * Remove '\n' at the end of the line. * - replace CTRL-V CTRL-V with CTRL-V * - replace CTRL-V 'n' with '\n' * * Check for a long line as written by viminfo_writestring(). * * Return the string in allocated memory (NULL when out of memory). */ static char_u * viminfo_readstring( vir_T *virp, int off, // offset for virp->vir_line int convert UNUSED) // convert the string { char_u *retval = NULL; char_u *s, *d; long len; if (virp->vir_line[off] == Ctrl_V && vim_isdigit(virp->vir_line[off + 1])) { len = atol((char *)virp->vir_line + off + 1); if (len > 0 && len < 1000000) retval = lalloc(len, TRUE); if (retval == NULL) { // Invalid length, line too long, out of memory? Skip next line. (void)vim_fgets(virp->vir_line, 10, virp->vir_fd); return NULL; } (void)vim_fgets(retval, (int)len, virp->vir_fd); s = retval + 1; // Skip the leading '<' } else { retval = vim_strsave(virp->vir_line + off); if (retval == NULL) return NULL; s = retval; } // Change CTRL-V CTRL-V to CTRL-V and CTRL-V n to \n in-place. d = retval; while (*s != NUL && *s != '\n') { if (s[0] == Ctrl_V && s[1] != NUL) { if (s[1] == 'n') *d++ = '\n'; else *d++ = Ctrl_V; s += 2; } else *d++ = *s++; } *d = NUL; if (convert && virp->vir_conv.vc_type != CONV_NONE && *retval != NUL) { d = string_convert(&virp->vir_conv, retval, NULL); if (d != NULL) { vim_free(retval); retval = d; } } return retval; } /* * Read a line from the viminfo file. * Returns TRUE for end-of-file; */ static int viminfo_readline(vir_T *virp) { return vim_fgets(virp->vir_line, LSIZE, virp->vir_fd); } static int read_viminfo_bufferlist( vir_T *virp, int writing) { char_u *tab; linenr_T lnum; colnr_T col; buf_T *buf; char_u *sfname; char_u *xline; // Handle long line and escaped characters. xline = viminfo_readstring(virp, 1, FALSE); // don't read in if there are files on the command-line or if writing: if (xline != NULL && !writing && ARGCOUNT == 0 && find_viminfo_parameter('%') != NULL) { // Format is: <fname> Tab <lnum> Tab <col>. // Watch out for a Tab in the file name, work from the end. lnum = 0; col = 0; tab = vim_strrchr(xline, '\t'); if (tab != NULL) { *tab++ = '\0'; col = (colnr_T)atoi((char *)tab); tab = vim_strrchr(xline, '\t'); if (tab != NULL) { *tab++ = '\0'; lnum = atol((char *)tab); } } // Expand "~/" in the file name at "line + 1" to a full path. // Then try shortening it by comparing with the current directory expand_env(xline, NameBuff, MAXPATHL); sfname = shorten_fname1(NameBuff); buf = buflist_new(NameBuff, sfname, (linenr_T)0, BLN_LISTED); if (buf != NULL) // just in case... { buf->b_last_cursor.lnum = lnum; buf->b_last_cursor.col = col; buflist_setfpos(buf, curwin, lnum, col, FALSE); } } vim_free(xline); return viminfo_readline(virp); } /* * Return TRUE if "name" is on removable media (depending on 'viminfo'). */ static int removable(char_u *name) { char_u *p; char_u part[51]; int retval = FALSE; size_t n; name = home_replace_save(NULL, name); if (name != NULL) { for (p = p_viminfo; *p; ) { copy_option_part(&p, part, 51, ", "); if (part[0] == 'r') { n = STRLEN(part + 1); if (MB_STRNICMP(part + 1, name, n) == 0) { retval = TRUE; break; } } } vim_free(name); } return retval; } static void write_viminfo_bufferlist(FILE *fp) { buf_T *buf; win_T *win; tabpage_T *tp; char_u *line; int max_buffers; if (find_viminfo_parameter('%') == NULL) return; // Without a number -1 is returned: do all buffers. max_buffers = get_viminfo_parameter('%'); // Allocate room for the file name, lnum and col. #define LINE_BUF_LEN (MAXPATHL + 40) line = alloc(LINE_BUF_LEN); if (line == NULL) return; FOR_ALL_TAB_WINDOWS(tp, win) set_last_cursor(win); fputs(_("\n# Buffer list:\n"), fp); FOR_ALL_BUFFERS(buf) { if (buf->b_fname == NULL || !buf->b_p_bl || bt_quickfix(buf) || bt_terminal(buf) || removable(buf->b_ffname)) continue; if (max_buffers-- == 0) break; putc('%', fp); home_replace(NULL, buf->b_ffname, line, MAXPATHL, TRUE); vim_snprintf_add((char *)line, LINE_BUF_LEN, "\t%ld\t%d", (long)buf->b_last_cursor.lnum, buf->b_last_cursor.col); viminfo_writestring(fp, line); } vim_free(line); } /* * Buffers for history read from a viminfo file. Only valid while reading. */ static histentry_T *viminfo_history[HIST_COUNT] = {NULL, NULL, NULL, NULL, NULL}; static int viminfo_hisidx[HIST_COUNT] = {0, 0, 0, 0, 0}; static int viminfo_hislen[HIST_COUNT] = {0, 0, 0, 0, 0}; static int viminfo_add_at_front = FALSE; /* * Translate a history type number to the associated character. */ static int hist_type2char( int type, int use_question) // use '?' instead of '/' { if (type == HIST_CMD) return ':'; if (type == HIST_SEARCH) { if (use_question) return '?'; else return '/'; } if (type == HIST_EXPR) return '='; return '@'; } /* * Prepare for reading the history from the viminfo file. * This allocates history arrays to store the read history lines. */ static void prepare_viminfo_history(int asklen, int writing) { int i; int num; int type; int len; int hislen; init_history(); hislen = get_hislen(); viminfo_add_at_front = (asklen != 0 && !writing); if (asklen > hislen) asklen = hislen; for (type = 0; type < HIST_COUNT; ++type) { histentry_T *histentry = get_histentry(type); // Count the number of empty spaces in the history list. Entries read // from viminfo previously are also considered empty. If there are // more spaces available than we request, then fill them up. for (i = 0, num = 0; i < hislen; i++) if (histentry[i].hisstr == NULL || histentry[i].viminfo) num++; len = asklen; if (num > len) len = num; if (len <= 0) viminfo_history[type] = NULL; else viminfo_history[type] = LALLOC_MULT(histentry_T, len); if (viminfo_history[type] == NULL) len = 0; viminfo_hislen[type] = len; viminfo_hisidx[type] = 0; } } /* * Accept a line from the viminfo, store it in the history array when it's * new. */ static int read_viminfo_history(vir_T *virp, int writing) { int type; long_u len; char_u *val; char_u *p; type = hist_char2type(virp->vir_line[0]); if (viminfo_hisidx[type] < viminfo_hislen[type]) { val = viminfo_readstring(virp, 1, TRUE); if (val != NULL && *val != NUL) { int sep = (*val == ' ' ? NUL : *val); if (!in_history(type, val + (type == HIST_SEARCH), viminfo_add_at_front, sep, writing)) { // Need to re-allocate to append the separator byte. len = STRLEN(val); p = alloc(len + 2); if (p != NULL) { if (type == HIST_SEARCH) { // Search entry: Move the separator from the first // column to after the NUL. mch_memmove(p, val + 1, (size_t)len); p[len] = sep; } else { // Not a search entry: No separator in the viminfo // file, add a NUL separator. mch_memmove(p, val, (size_t)len + 1); p[len + 1] = NUL; } viminfo_history[type][viminfo_hisidx[type]].hisstr = p; viminfo_history[type][viminfo_hisidx[type]].time_set = 0; viminfo_history[type][viminfo_hisidx[type]].viminfo = TRUE; viminfo_history[type][viminfo_hisidx[type]].hisnum = 0; viminfo_hisidx[type]++; } } } vim_free(val); } return viminfo_readline(virp); } /* * Accept a new style history line from the viminfo, store it in the history * array when it's new. */ static void handle_viminfo_history( garray_T *values, int writing) { int type; long_u len; char_u *val; char_u *p; bval_T *vp = (bval_T *)values->ga_data; // Check the format: // |{bartype},{histtype},{timestamp},{separator},"text" if (values->ga_len < 4 || vp[0].bv_type != BVAL_NR || vp[1].bv_type != BVAL_NR || (vp[2].bv_type != BVAL_NR && vp[2].bv_type != BVAL_EMPTY) || vp[3].bv_type != BVAL_STRING) return; type = vp[0].bv_nr; if (type >= HIST_COUNT) return; if (viminfo_hisidx[type] < viminfo_hislen[type]) { val = vp[3].bv_string; if (val != NULL && *val != NUL) { int sep = type == HIST_SEARCH && vp[2].bv_type == BVAL_NR ? vp[2].bv_nr : NUL; int idx; int overwrite = FALSE; if (!in_history(type, val, viminfo_add_at_front, sep, writing)) { // If lines were written by an older Vim we need to avoid // getting duplicates. See if the entry already exists. for (idx = 0; idx < viminfo_hisidx[type]; ++idx) { p = viminfo_history[type][idx].hisstr; if (STRCMP(val, p) == 0 && (type != HIST_SEARCH || sep == p[STRLEN(p) + 1])) { overwrite = TRUE; break; } } if (!overwrite) { // Need to re-allocate to append the separator byte. len = vp[3].bv_len; p = alloc(len + 2); } else len = 0; // for picky compilers if (p != NULL) { viminfo_history[type][idx].time_set = vp[1].bv_nr; if (!overwrite) { mch_memmove(p, val, (size_t)len + 1); // Put the separator after the NUL. p[len + 1] = sep; viminfo_history[type][idx].hisstr = p; viminfo_history[type][idx].hisnum = 0; viminfo_history[type][idx].viminfo = TRUE; viminfo_hisidx[type]++; } } } } } } /* * Concatenate history lines from viminfo after the lines typed in this Vim. */ static void concat_history(int type) { int idx; int i; int hislen = get_hislen(); histentry_T *histentry = get_histentry(type); int *hisidx = get_hisidx(type); int *hisnum = get_hisnum(type); idx = *hisidx + viminfo_hisidx[type]; if (idx >= hislen) idx -= hislen; else if (idx < 0) idx = hislen - 1; if (viminfo_add_at_front) *hisidx = idx; else { if (*hisidx == -1) *hisidx = hislen - 1; do { if (histentry[idx].hisstr != NULL || histentry[idx].viminfo) break; if (++idx == hislen) idx = 0; } while (idx != *hisidx); if (idx != *hisidx && --idx < 0) idx = hislen - 1; } for (i = 0; i < viminfo_hisidx[type]; i++) { vim_free(histentry[idx].hisstr); histentry[idx].hisstr = viminfo_history[type][i].hisstr; histentry[idx].viminfo = TRUE; histentry[idx].time_set = viminfo_history[type][i].time_set; if (--idx < 0) idx = hislen - 1; } idx += 1; idx %= hislen; for (i = 0; i < viminfo_hisidx[type]; i++) { histentry[idx++].hisnum = ++*hisnum; idx %= hislen; } } static int sort_hist(const void *s1, const void *s2) { histentry_T *p1 = *(histentry_T **)s1; histentry_T *p2 = *(histentry_T **)s2; if (p1->time_set < p2->time_set) return -1; if (p1->time_set > p2->time_set) return 1; return 0; } /* * Merge history lines from viminfo and lines typed in this Vim based on the * timestamp; */ static void merge_history(int type) { int max_len; histentry_T **tot_hist; histentry_T *new_hist; int i; int len; int hislen = get_hislen(); histentry_T *histentry = get_histentry(type); int *hisidx = get_hisidx(type); int *hisnum = get_hisnum(type); // Make one long list with all entries. max_len = hislen + viminfo_hisidx[type]; tot_hist = ALLOC_MULT(histentry_T *, max_len); new_hist = ALLOC_MULT(histentry_T, hislen); if (tot_hist == NULL || new_hist == NULL) { vim_free(tot_hist); vim_free(new_hist); return; } for (i = 0; i < viminfo_hisidx[type]; i++) tot_hist[i] = &viminfo_history[type][i]; len = i; for (i = 0; i < hislen; i++) if (histentry[i].hisstr != NULL) tot_hist[len++] = &histentry[i]; // Sort the list on timestamp. qsort((void *)tot_hist, (size_t)len, sizeof(histentry_T *), sort_hist); // Keep the newest ones. for (i = 0; i < hislen; i++) { if (i < len) { new_hist[i] = *tot_hist[i]; tot_hist[i]->hisstr = NULL; if (new_hist[i].hisnum == 0) new_hist[i].hisnum = ++*hisnum; } else clear_hist_entry(&new_hist[i]); } *hisidx = (i < len ? i : len) - 1; // Free what is not kept. for (i = 0; i < viminfo_hisidx[type]; i++) vim_free(viminfo_history[type][i].hisstr); for (i = 0; i < hislen; i++) vim_free(histentry[i].hisstr); vim_free(histentry); set_histentry(type, new_hist); vim_free(tot_hist); } /* * Finish reading history lines from viminfo. Not used when writing viminfo. */ static void finish_viminfo_history(vir_T *virp) { int type; int merge = virp->vir_version >= VIMINFO_VERSION_WITH_HISTORY; for (type = 0; type < HIST_COUNT; ++type) { if (get_histentry(type) == NULL) continue; if (merge) merge_history(type); else concat_history(type); VIM_CLEAR(viminfo_history[type]); viminfo_hisidx[type] = 0; } } /* * Write history to viminfo file in "fp". * When "merge" is TRUE merge history lines with a previously read viminfo * file, data is in viminfo_history[]. * When "merge" is FALSE just write all history lines. Used for ":wviminfo!". */ static void write_viminfo_history(FILE *fp, int merge) { int i; int type; int num_saved; int round; int hislen; init_history(); hislen = get_hislen(); if (hislen == 0) return; for (type = 0; type < HIST_COUNT; ++type) { histentry_T *histentry = get_histentry(type); int *hisidx = get_hisidx(type); num_saved = get_viminfo_parameter(hist_type2char(type, FALSE)); if (num_saved == 0) continue; if (num_saved < 0) // Use default num_saved = hislen; fprintf(fp, _("\n# %s History (newest to oldest):\n"), type == HIST_CMD ? _("Command Line") : type == HIST_SEARCH ? _("Search String") : type == HIST_EXPR ? _("Expression") : type == HIST_INPUT ? _("Input Line") : _("Debug Line")); if (num_saved > hislen) num_saved = hislen; // Merge typed and viminfo history: // round 1: history of typed commands. // round 2: history from recently read viminfo. for (round = 1; round <= 2; ++round) { if (round == 1) // start at newest entry, somewhere in the list i = *hisidx; else if (viminfo_hisidx[type] > 0) // start at newest entry, first in the list i = 0; else // empty list i = -1; if (i >= 0) while (num_saved > 0 && !(round == 2 && i >= viminfo_hisidx[type])) { char_u *p; time_t timestamp; int c = NUL; if (round == 1) { p = histentry[i].hisstr; timestamp = histentry[i].time_set; } else { p = viminfo_history[type] == NULL ? NULL : viminfo_history[type][i].hisstr; timestamp = viminfo_history[type] == NULL ? 0 : viminfo_history[type][i].time_set; } if (p != NULL && (round == 2 || !merge || !histentry[i].viminfo)) { --num_saved; fputc(hist_type2char(type, TRUE), fp); // For the search history: put the separator in the // second column; use a space if there isn't one. if (type == HIST_SEARCH) { c = p[STRLEN(p) + 1]; putc(c == NUL ? ' ' : c, fp); } viminfo_writestring(fp, p); { char cbuf[NUMBUFLEN]; // New style history with a bar line. Format: // |{bartype},{histtype},{timestamp},{separator},"text" if (c == NUL) cbuf[0] = NUL; else sprintf(cbuf, "%d", c); fprintf(fp, "|%d,%d,%ld,%s,", BARTYPE_HISTORY, type, (long)timestamp, cbuf); barline_writestring(fp, p, LSIZE - 20); putc('\n', fp); } } if (round == 1) { // Decrement index, loop around and stop when back at // the start. if (--i < 0) i = hislen - 1; if (i == *hisidx) break; } else { // Increment index. Stop at the end in the while. ++i; } } } for (i = 0; i < viminfo_hisidx[type]; ++i) if (viminfo_history[type] != NULL) vim_free(viminfo_history[type][i].hisstr); VIM_CLEAR(viminfo_history[type]); viminfo_hisidx[type] = 0; } } static void write_viminfo_barlines(vir_T *virp, FILE *fp_out) { int i; garray_T *gap = &virp->vir_barlines; int seen_useful = FALSE; char *line; if (gap->ga_len > 0) { fputs(_("\n# Bar lines, copied verbatim:\n"), fp_out); // Skip over continuation lines until seeing a useful line. for (i = 0; i < gap->ga_len; ++i) { line = ((char **)(gap->ga_data))[i]; if (seen_useful || line[1] != '<') { fputs(line, fp_out); seen_useful = TRUE; } } } } /* * Parse a viminfo line starting with '|'. * Add each decoded value to "values". * Returns TRUE if the next line is to be read after using the parsed values. */ static int barline_parse(vir_T *virp, char_u *text, garray_T *values) { char_u *p = text; char_u *nextp = NULL; char_u *buf = NULL; bval_T *value; int i; int allocated = FALSE; int eof; char_u *sconv; int converted; while (*p == ',') { ++p; if (ga_grow(values, 1) == FAIL) break; value = (bval_T *)(values->ga_data) + values->ga_len; if (*p == '>') { // Need to read a continuation line. Put strings in allocated // memory, because virp->vir_line is overwritten. if (!allocated) { for (i = 0; i < values->ga_len; ++i) { bval_T *vp = (bval_T *)(values->ga_data) + i; if (vp->bv_type == BVAL_STRING && !vp->bv_allocated) { vp->bv_string = vim_strnsave(vp->bv_string, vp->bv_len); vp->bv_allocated = TRUE; } } allocated = TRUE; } if (vim_isdigit(p[1])) { size_t len; size_t todo; size_t n; // String value was split into lines that are each shorter // than LSIZE: // |{bartype},>{length of "{text}{text2}"} // |<"{text1} // |<{text2}",{value} // Length includes the quotes. ++p; len = getdigits(&p); buf = alloc((int)(len + 1)); if (buf == NULL) return TRUE; p = buf; for (todo = len; todo > 0; todo -= n) { eof = viminfo_readline(virp); if (eof || virp->vir_line[0] != '|' || virp->vir_line[1] != '<') { // File was truncated or garbled. Read another line if // this one starts with '|'. vim_free(buf); return eof || virp->vir_line[0] == '|'; } // Get length of text, excluding |< and NL chars. n = STRLEN(virp->vir_line); while (n > 0 && (virp->vir_line[n - 1] == NL || virp->vir_line[n - 1] == CAR)) --n; n -= 2; if (n > todo) { // more values follow after the string nextp = virp->vir_line + 2 + todo; n = todo; } mch_memmove(p, virp->vir_line + 2, n); p += n; } *p = NUL; p = buf; } else { // Line ending in ">" continues in the next line: // |{bartype},{lots of values},> // |<{value},{value} eof = viminfo_readline(virp); if (eof || virp->vir_line[0] != '|' || virp->vir_line[1] != '<') // File was truncated or garbled. Read another line if // this one starts with '|'. return eof || virp->vir_line[0] == '|'; p = virp->vir_line + 2; } } if (isdigit(*p)) { value->bv_type = BVAL_NR; value->bv_nr = getdigits(&p); ++values->ga_len; } else if (*p == '"') { int len = 0; char_u *s = p; // Unescape special characters in-place. ++p; while (*p != '"') { if (*p == NL || *p == NUL) return TRUE; // syntax error, drop the value if (*p == '\\') { ++p; if (*p == 'n') s[len++] = '\n'; else s[len++] = *p; ++p; } else s[len++] = *p++; } ++p; s[len] = NUL; converted = FALSE; value->bv_tofree = NULL; if (virp->vir_conv.vc_type != CONV_NONE && *s != NUL) { sconv = string_convert(&virp->vir_conv, s, NULL); if (sconv != NULL) { if (s == buf) // the converted string is stored in bv_string and // freed later, also need to free "buf" later value->bv_tofree = buf; s = sconv; converted = TRUE; } } // Need to copy in allocated memory if the string wasn't allocated // above and we did allocate before, thus vir_line may change. if (s != buf && allocated && !converted) s = vim_strsave(s); value->bv_string = s; value->bv_type = BVAL_STRING; value->bv_len = len; value->bv_allocated = allocated || converted; ++values->ga_len; if (nextp != NULL) { // values following a long string p = nextp; nextp = NULL; } } else if (*p == ',') { value->bv_type = BVAL_EMPTY; ++values->ga_len; } else break; } return TRUE; } static void write_viminfo_version(FILE *fp_out) { fprintf(fp_out, "# Viminfo version\n|%d,%d\n\n", BARTYPE_VERSION, VIMINFO_VERSION); } static int no_viminfo(void) { // "vim -i NONE" does not read or write a viminfo file return STRCMP(p_viminfofile, "NONE") == 0; } /* * Report an error for reading a viminfo file. * Count the number of errors. When there are more than 10, return TRUE. */ static int viminfo_error(char *errnum, char *message, char_u *line) { vim_snprintf((char *)IObuff, IOSIZE, _("%sviminfo: %s in line: "), errnum, message); STRNCAT(IObuff, line, IOSIZE - STRLEN(IObuff) - 1); if (IObuff[STRLEN(IObuff) - 1] == '\n') IObuff[STRLEN(IObuff) - 1] = NUL; emsg((char *)IObuff); if (++viminfo_errcnt >= 10) { emsg(_(e_viminfo_too_many_errors_skipping_rest_of_file)); return TRUE; } return FALSE; } /* * Compare the 'encoding' value in the viminfo file with the current value of * 'encoding'. If different and the 'c' flag is in 'viminfo', setup for * conversion of text with iconv() in viminfo_readstring(). */ static int viminfo_encoding(vir_T *virp) { char_u *p; int i; if (get_viminfo_parameter('c') != 0) { p = vim_strchr(virp->vir_line, '='); if (p != NULL) { // remove trailing newline ++p; for (i = 0; vim_isprintc(p[i]); ++i) ; p[i] = NUL; convert_setup(&virp->vir_conv, p, p_enc); } } return viminfo_readline(virp); } #if defined(FEAT_EVAL) || defined(PROTO) /* * Restore global vars that start with a capital from the viminfo file */ static int read_viminfo_varlist(vir_T *virp, int writing) { char_u *tab; int type = VAR_NUMBER; typval_T tv; funccal_entry_T funccal_entry; if (!writing && (find_viminfo_parameter('!') != NULL)) { tab = vim_strchr(virp->vir_line + 1, '\t'); if (tab != NULL) { *tab++ = '\0'; // isolate the variable name switch (*tab) { case 'S': type = VAR_STRING; break; #ifdef FEAT_FLOAT case 'F': type = VAR_FLOAT; break; #endif case 'D': type = VAR_DICT; break; case 'L': type = VAR_LIST; break; case 'B': type = VAR_BLOB; break; case 'X': type = VAR_SPECIAL; break; } tab = vim_strchr(tab, '\t'); if (tab != NULL) { tv.v_type = type; if (type == VAR_STRING || type == VAR_DICT || type == VAR_LIST || type == VAR_BLOB) tv.vval.v_string = viminfo_readstring(virp, (int)(tab - virp->vir_line + 1), TRUE); #ifdef FEAT_FLOAT else if (type == VAR_FLOAT) (void)string2float(tab + 1, &tv.vval.v_float, FALSE); #endif else { tv.vval.v_number = atol((char *)tab + 1); if (type == VAR_SPECIAL && (tv.vval.v_number == VVAL_FALSE || tv.vval.v_number == VVAL_TRUE)) tv.v_type = VAR_BOOL; } if (type == VAR_DICT || type == VAR_LIST) { typval_T *etv = eval_expr(tv.vval.v_string, NULL); if (etv == NULL) // Failed to parse back the dict or list, use it as a // string. tv.v_type = VAR_STRING; else { vim_free(tv.vval.v_string); tv = *etv; vim_free(etv); } } else if (type == VAR_BLOB) { blob_T *blob = string2blob(tv.vval.v_string); if (blob == NULL) // Failed to parse back the blob, use it as a string. tv.v_type = VAR_STRING; else { vim_free(tv.vval.v_string); tv.v_type = VAR_BLOB; tv.vval.v_blob = blob; } } // when in a function use global variables save_funccal(&funccal_entry); set_var(virp->vir_line + 1, &tv, FALSE); restore_funccal(); if (tv.v_type == VAR_STRING) vim_free(tv.vval.v_string); else if (tv.v_type == VAR_DICT || tv.v_type == VAR_LIST || tv.v_type == VAR_BLOB) clear_tv(&tv); } } } return viminfo_readline(virp); } /* * Write global vars that start with a capital to the viminfo file */ static void write_viminfo_varlist(FILE *fp) { hashtab_T *gvht = get_globvar_ht(); hashitem_T *hi; dictitem_T *this_var; int todo; char *s = ""; char_u *p; char_u *tofree; char_u numbuf[NUMBUFLEN]; if (find_viminfo_parameter('!') == NULL) return; fputs(_("\n# global variables:\n"), fp); todo = (int)gvht->ht_used; for (hi = gvht->ht_array; todo > 0; ++hi) { if (!HASHITEM_EMPTY(hi)) { --todo; this_var = HI2DI(hi); if (var_flavour(this_var->di_key) == VAR_FLAVOUR_VIMINFO) { switch (this_var->di_tv.v_type) { case VAR_STRING: s = "STR"; break; case VAR_NUMBER: s = "NUM"; break; case VAR_FLOAT: s = "FLO"; break; case VAR_DICT: { dict_T *di = this_var->di_tv.vval.v_dict; int copyID = get_copyID(); s = "DIC"; if (di != NULL && !set_ref_in_ht( &di->dv_hashtab, copyID, NULL) && di->dv_copyID == copyID) // has a circular reference, can't turn the // value into a string continue; break; } case VAR_LIST: { list_T *l = this_var->di_tv.vval.v_list; int copyID = get_copyID(); s = "LIS"; if (l != NULL && !set_ref_in_list_items( l, copyID, NULL) && l->lv_copyID == copyID) // has a circular reference, can't turn the // value into a string continue; break; } case VAR_BLOB: s = "BLO"; break; case VAR_BOOL: s = "XPL"; break; // backwards compat. case VAR_SPECIAL: s = "XPL"; break; case VAR_UNKNOWN: case VAR_ANY: case VAR_VOID: case VAR_FUNC: case VAR_PARTIAL: case VAR_JOB: case VAR_CHANNEL: case VAR_INSTR: continue; } fprintf(fp, "!%s\t%s\t", this_var->di_key, s); if (this_var->di_tv.v_type == VAR_BOOL || this_var->di_tv.v_type == VAR_SPECIAL) { // do not use "v:true" but "1" sprintf((char *)numbuf, "%ld", (long)this_var->di_tv.vval.v_number); p = numbuf; tofree = NULL; } else p = echo_string(&this_var->di_tv, &tofree, numbuf, 0); if (p != NULL) viminfo_writestring(fp, p); vim_free(tofree); } } } } #endif // FEAT_EVAL static int read_viminfo_sub_string(vir_T *virp, int force) { if (force || get_old_sub() == NULL) set_old_sub(viminfo_readstring(virp, 1, TRUE)); return viminfo_readline(virp); } static void write_viminfo_sub_string(FILE *fp) { char_u *old_sub = get_old_sub(); if (get_viminfo_parameter('/') != 0 && old_sub != NULL) { fputs(_("\n# Last Substitute String:\n$"), fp); viminfo_writestring(fp, old_sub); } } /* * Functions relating to reading/writing the search pattern from viminfo */ static int read_viminfo_search_pattern(vir_T *virp, int force) { char_u *lp; int idx = -1; int magic = FALSE; int no_scs = FALSE; int off_line = FALSE; int off_end = 0; long off = 0; int setlast = FALSE; #ifdef FEAT_SEARCH_EXTRA static int hlsearch_on = FALSE; #endif char_u *val; spat_T *spat; // Old line types: // "/pat", "&pat": search/subst. pat // "~/pat", "~&pat": last used search/subst. pat // New line types: // "~h", "~H": hlsearch highlighting off/on // "~<magic><smartcase><line><end><off><last><which>pat" // <magic>: 'm' off, 'M' on // <smartcase>: 's' off, 'S' on // <line>: 'L' line offset, 'l' char offset // <end>: 'E' from end, 'e' from start // <off>: decimal, offset // <last>: '~' last used pattern // <which>: '/' search pat, '&' subst. pat lp = virp->vir_line; if (lp[0] == '~' && (lp[1] == 'm' || lp[1] == 'M')) // new line type { if (lp[1] == 'M') // magic on magic = TRUE; if (lp[2] == 's') no_scs = TRUE; if (lp[3] == 'L') off_line = TRUE; if (lp[4] == 'E') off_end = SEARCH_END; lp += 5; off = getdigits(&lp); } if (lp[0] == '~') // use this pattern for last-used pattern { setlast = TRUE; lp++; } if (lp[0] == '/') idx = RE_SEARCH; else if (lp[0] == '&') idx = RE_SUBST; #ifdef FEAT_SEARCH_EXTRA else if (lp[0] == 'h') // ~h: 'hlsearch' highlighting off hlsearch_on = FALSE; else if (lp[0] == 'H') // ~H: 'hlsearch' highlighting on hlsearch_on = TRUE; #endif if (idx >= 0) { spat = get_spat(idx); if (force || spat->pat == NULL) { val = viminfo_readstring(virp, (int)(lp - virp->vir_line + 1), TRUE); if (val != NULL) { set_last_search_pat(val, idx, magic, setlast); vim_free(val); spat->no_scs = no_scs; spat->off.line = off_line; spat->off.end = off_end; spat->off.off = off; #ifdef FEAT_SEARCH_EXTRA if (setlast) set_no_hlsearch(!hlsearch_on); #endif } } } return viminfo_readline(virp); } static void wvsp_one( FILE *fp, // file to write to int idx, // spats[] index char *s, // search pat int sc) // dir char { spat_T *spat = get_spat(idx); if (spat->pat != NULL) { fprintf(fp, _("\n# Last %sSearch Pattern:\n~"), s); // off.dir is not stored, it's reset to forward fprintf(fp, "%c%c%c%c%ld%s%c", spat->magic ? 'M' : 'm', // magic spat->no_scs ? 's' : 'S', // smartcase spat->off.line ? 'L' : 'l', // line offset spat->off.end ? 'E' : 'e', // offset from end spat->off.off, // offset get_spat_last_idx() == idx ? "~" : "", // last used pat sc); viminfo_writestring(fp, spat->pat); } } static void write_viminfo_search_pattern(FILE *fp) { if (get_viminfo_parameter('/') != 0) { #ifdef FEAT_SEARCH_EXTRA fprintf(fp, "\n# hlsearch on (H) or off (h):\n~%c", (no_hlsearch || find_viminfo_parameter('h') != NULL) ? 'h' : 'H'); #endif wvsp_one(fp, RE_SEARCH, "", '/'); wvsp_one(fp, RE_SUBST, _("Substitute "), '&'); } } /* * Functions relating to reading/writing registers from viminfo */ static yankreg_T *y_read_regs = NULL; #define REG_PREVIOUS 1 #define REG_EXEC 2 /* * Prepare for reading viminfo registers when writing viminfo later. */ static void prepare_viminfo_registers(void) { y_read_regs = ALLOC_CLEAR_MULT(yankreg_T, NUM_REGISTERS); } static void finish_viminfo_registers(void) { int i; int j; if (y_read_regs != NULL) { for (i = 0; i < NUM_REGISTERS; ++i) if (y_read_regs[i].y_array != NULL) { for (j = 0; j < y_read_regs[i].y_size; j++) vim_free(y_read_regs[i].y_array[j]); vim_free(y_read_regs[i].y_array); } VIM_CLEAR(y_read_regs); } } static int read_viminfo_register(vir_T *virp, int force) { int eof; int do_it = TRUE; int size; int limit; int i; int set_prev = FALSE; char_u *str; char_u **array = NULL; int new_type = MCHAR; // init to shut up compiler colnr_T new_width = 0; // init to shut up compiler yankreg_T *y_current_p; // We only get here (hopefully) if line[0] == '"' str = virp->vir_line + 1; // If the line starts with "" this is the y_previous register. if (*str == '"') { set_prev = TRUE; str++; } if (!ASCII_ISALNUM(*str) && *str != '-') { if (viminfo_error("E577: ", _(e_illegal_register_name), virp->vir_line)) return TRUE; // too many errors, pretend end-of-file do_it = FALSE; } get_yank_register(*str++, FALSE); y_current_p = get_y_current(); if (!force && y_current_p->y_array != NULL) do_it = FALSE; if (*str == '@') { // "x@: register x used for @@ if (force || get_execreg_lastc() == NUL) set_execreg_lastc(str[-1]); } size = 0; limit = 100; // Optimized for registers containing <= 100 lines if (do_it) { // Build the new register in array[]. // y_array is kept as-is until done. // The "do_it" flag is reset when something is wrong, in which case // array[] needs to be freed. if (set_prev) set_y_previous(y_current_p); array = ALLOC_MULT(char_u *, limit); str = skipwhite(skiptowhite(str)); if (STRNCMP(str, "CHAR", 4) == 0) new_type = MCHAR; else if (STRNCMP(str, "BLOCK", 5) == 0) new_type = MBLOCK; else new_type = MLINE; // get the block width; if it's missing we get a zero, which is OK str = skipwhite(skiptowhite(str)); new_width = getdigits(&str); } while (!(eof = viminfo_readline(virp)) && (virp->vir_line[0] == TAB || virp->vir_line[0] == '<')) { if (do_it) { if (size == limit) { char_u **new_array = (char_u **) alloc(limit * 2 * sizeof(char_u *)); if (new_array == NULL) { do_it = FALSE; break; } for (i = 0; i < limit; i++) new_array[i] = array[i]; vim_free(array); array = new_array; limit *= 2; } str = viminfo_readstring(virp, 1, TRUE); if (str != NULL) array[size++] = str; else // error, don't store the result do_it = FALSE; } } if (do_it) { // free y_array[] for (i = 0; i < y_current_p->y_size; i++) vim_free(y_current_p->y_array[i]); vim_free(y_current_p->y_array); y_current_p->y_type = new_type; y_current_p->y_width = new_width; y_current_p->y_size = size; y_current_p->y_time_set = 0; if (size == 0) { y_current_p->y_array = NULL; } else { // Move the lines from array[] to y_array[]. y_current_p->y_array = ALLOC_MULT(char_u *, size); for (i = 0; i < size; i++) { if (y_current_p->y_array == NULL) vim_free(array[i]); else y_current_p->y_array[i] = array[i]; } } } else { // Free array[] if it was filled. for (i = 0; i < size; i++) vim_free(array[i]); } vim_free(array); return eof; } /* * Accept a new style register line from the viminfo, store it when it's new. */ static void handle_viminfo_register(garray_T *values, int force) { bval_T *vp = (bval_T *)values->ga_data; int flags; int name; int type; int linecount; int width; time_t timestamp; yankreg_T *y_ptr; yankreg_T *y_regs_p = get_y_regs(); int i; // Check the format: // |{bartype},{flags},{name},{type}, // {linecount},{width},{timestamp},"line1","line2" if (values->ga_len < 6 || vp[0].bv_type != BVAL_NR || vp[1].bv_type != BVAL_NR || vp[2].bv_type != BVAL_NR || vp[3].bv_type != BVAL_NR || vp[4].bv_type != BVAL_NR || vp[5].bv_type != BVAL_NR) return; flags = vp[0].bv_nr; name = vp[1].bv_nr; if (name < 0 || name >= NUM_REGISTERS) return; type = vp[2].bv_nr; if (type != MCHAR && type != MLINE && type != MBLOCK) return; linecount = vp[3].bv_nr; if (values->ga_len < 6 + linecount) return; width = vp[4].bv_nr; if (width < 0) return; if (y_read_regs != NULL) // Reading viminfo for merging and writing. Store the register // content, don't update the current registers. y_ptr = &y_read_regs[name]; else y_ptr = &y_regs_p[name]; // Do not overwrite unless forced or the timestamp is newer. timestamp = (time_t)vp[5].bv_nr; if (y_ptr->y_array != NULL && !force && (timestamp == 0 || y_ptr->y_time_set > timestamp)) return; if (y_ptr->y_array != NULL) for (i = 0; i < y_ptr->y_size; i++) vim_free(y_ptr->y_array[i]); vim_free(y_ptr->y_array); if (y_read_regs == NULL) { if (flags & REG_PREVIOUS) set_y_previous(y_ptr); if ((flags & REG_EXEC) && (force || get_execreg_lastc() == NUL)) set_execreg_lastc(get_register_name(name)); } y_ptr->y_type = type; y_ptr->y_width = width; y_ptr->y_size = linecount; y_ptr->y_time_set = timestamp; if (linecount == 0) { y_ptr->y_array = NULL; return; } y_ptr->y_array = ALLOC_MULT(char_u *, linecount); if (y_ptr->y_array == NULL) { y_ptr->y_size = 0; // ensure object state is consistent return; } for (i = 0; i < linecount; i++) { if (vp[i + 6].bv_allocated) { y_ptr->y_array[i] = vp[i + 6].bv_string; vp[i + 6].bv_string = NULL; } else y_ptr->y_array[i] = vim_strsave(vp[i + 6].bv_string); } } static void write_viminfo_registers(FILE *fp) { int i, j; char_u *type; char_u c; int num_lines; int max_num_lines; int max_kbyte; long len; yankreg_T *y_ptr; yankreg_T *y_regs_p = get_y_regs();; fputs(_("\n# Registers:\n"), fp); // Get '<' value, use old '"' value if '<' is not found. max_num_lines = get_viminfo_parameter('<'); if (max_num_lines < 0) max_num_lines = get_viminfo_parameter('"'); if (max_num_lines == 0) return; max_kbyte = get_viminfo_parameter('s'); if (max_kbyte == 0) return; for (i = 0; i < NUM_REGISTERS; i++) { #ifdef FEAT_CLIPBOARD // Skip '*'/'+' register, we don't want them back next time if (i == STAR_REGISTER || i == PLUS_REGISTER) continue; #endif #ifdef FEAT_DND // Neither do we want the '~' register if (i == TILDE_REGISTER) continue; #endif // When reading viminfo for merging and writing: Use the register from // viminfo if it's newer. if (y_read_regs != NULL && y_read_regs[i].y_array != NULL && (y_regs_p[i].y_array == NULL || y_read_regs[i].y_time_set > y_regs_p[i].y_time_set)) y_ptr = &y_read_regs[i]; else if (y_regs_p[i].y_array == NULL) continue; else y_ptr = &y_regs_p[i]; // Skip empty registers. num_lines = y_ptr->y_size; if (num_lines == 0 || (num_lines == 1 && y_ptr->y_type == MCHAR && *y_ptr->y_array[0] == NUL)) continue; if (max_kbyte > 0) { // Skip register if there is more text than the maximum size. len = 0; for (j = 0; j < num_lines; j++) len += (long)STRLEN(y_ptr->y_array[j]) + 1L; if (len > (long)max_kbyte * 1024L) continue; } switch (y_ptr->y_type) { case MLINE: type = (char_u *)"LINE"; break; case MCHAR: type = (char_u *)"CHAR"; break; case MBLOCK: type = (char_u *)"BLOCK"; break; default: semsg(_(e_unknown_register_type_nr), y_ptr->y_type); type = (char_u *)"LINE"; break; } if (get_y_previous() == &y_regs_p[i]) fprintf(fp, "\""); c = get_register_name(i); fprintf(fp, "\"%c", c); if (c == get_execreg_lastc()) fprintf(fp, "@"); fprintf(fp, "\t%s\t%d\n", type, (int)y_ptr->y_width); // If max_num_lines < 0, then we save ALL the lines in the register if (max_num_lines > 0 && num_lines > max_num_lines) num_lines = max_num_lines; for (j = 0; j < num_lines; j++) { putc('\t', fp); viminfo_writestring(fp, y_ptr->y_array[j]); } { int flags = 0; int remaining; // New style with a bar line. Format: // |{bartype},{flags},{name},{type}, // {linecount},{width},{timestamp},"line1","line2" // flags: REG_PREVIOUS - register is y_previous // REG_EXEC - used for @@ if (get_y_previous() == &y_regs_p[i]) flags |= REG_PREVIOUS; if (c == get_execreg_lastc()) flags |= REG_EXEC; fprintf(fp, "|%d,%d,%d,%d,%d,%d,%ld", BARTYPE_REGISTER, flags, i, y_ptr->y_type, num_lines, (int)y_ptr->y_width, (long)y_ptr->y_time_set); // 11 chars for type/flags/name/type, 3 * 20 for numbers remaining = LSIZE - 71; for (j = 0; j < num_lines; j++) { putc(',', fp); --remaining; remaining = barline_writestring(fp, y_ptr->y_array[j], remaining); } putc('\n', fp); } } } /* * Functions relating to reading/writing marks from viminfo */ static xfmark_T *vi_namedfm = NULL; static xfmark_T *vi_jumplist = NULL; static int vi_jumplist_len = 0; static void write_one_mark(FILE *fp_out, int c, pos_T *pos) { if (pos->lnum != 0) fprintf(fp_out, "\t%c\t%ld\t%d\n", c, (long)pos->lnum, (int)pos->col); } static void write_buffer_marks(buf_T *buf, FILE *fp_out) { int i; pos_T pos; home_replace(NULL, buf->b_ffname, IObuff, IOSIZE, TRUE); fprintf(fp_out, "\n> "); viminfo_writestring(fp_out, IObuff); // Write the last used timestamp as the lnum of the non-existing mark '*'. // Older Vims will ignore it and/or copy it. pos.lnum = (linenr_T)buf->b_last_used; pos.col = 0; write_one_mark(fp_out, '*', &pos); write_one_mark(fp_out, '"', &buf->b_last_cursor); write_one_mark(fp_out, '^', &buf->b_last_insert); write_one_mark(fp_out, '.', &buf->b_last_change); // changelist positions are stored oldest first for (i = 0; i < buf->b_changelistlen; ++i) { // skip duplicates if (i == 0 || !EQUAL_POS(buf->b_changelist[i - 1], buf->b_changelist[i])) write_one_mark(fp_out, '+', &buf->b_changelist[i]); } for (i = 0; i < NMARKS; i++) write_one_mark(fp_out, 'a' + i, &buf->b_namedm[i]); } /* * Return TRUE if marks for "buf" should not be written. */ static int skip_for_viminfo(buf_T *buf) { return bt_terminal(buf) || removable(buf->b_ffname); } /* * Write all the named marks for all buffers. * When "buflist" is not NULL fill it with the buffers for which marks are to * be written. */ static void write_viminfo_marks(FILE *fp_out, garray_T *buflist) { buf_T *buf; int is_mark_set; int i; win_T *win; tabpage_T *tp; // Set b_last_cursor for the all buffers that have a window. FOR_ALL_TAB_WINDOWS(tp, win) set_last_cursor(win); fputs(_("\n# History of marks within files (newest to oldest):\n"), fp_out); FOR_ALL_BUFFERS(buf) { // Only write something if buffer has been loaded and at least one // mark is set. if (buf->b_marks_read) { if (buf->b_last_cursor.lnum != 0) is_mark_set = TRUE; else { is_mark_set = FALSE; for (i = 0; i < NMARKS; i++) if (buf->b_namedm[i].lnum != 0) { is_mark_set = TRUE; break; } } if (is_mark_set && buf->b_ffname != NULL && buf->b_ffname[0] != NUL && !skip_for_viminfo(buf)) { if (buflist == NULL) write_buffer_marks(buf, fp_out); else if (ga_grow(buflist, 1) == OK) ((buf_T **)buflist->ga_data)[buflist->ga_len++] = buf; } } } } static void write_one_filemark( FILE *fp, xfmark_T *fm, int c1, int c2) { char_u *name; if (fm->fmark.mark.lnum == 0) // not set return; if (fm->fmark.fnum != 0) // there is a buffer name = buflist_nr2name(fm->fmark.fnum, TRUE, FALSE); else name = fm->fname; // use name from .viminfo if (name != NULL && *name != NUL) { fprintf(fp, "%c%c %ld %ld ", c1, c2, (long)fm->fmark.mark.lnum, (long)fm->fmark.mark.col); viminfo_writestring(fp, name); // Barline: |{bartype},{name},{lnum},{col},{timestamp},{filename} // size up to filename: 8 + 3 * 20 fprintf(fp, "|%d,%d,%ld,%ld,%ld,", BARTYPE_MARK, c2, (long)fm->fmark.mark.lnum, (long)fm->fmark.mark.col, (long)fm->time_set); barline_writestring(fp, name, LSIZE - 70); putc('\n', fp); } if (fm->fmark.fnum != 0) vim_free(name); } static void write_viminfo_filemarks(FILE *fp) { int i; char_u *name; buf_T *buf; xfmark_T *namedfm_p = get_namedfm(); xfmark_T *fm; int vi_idx; int idx; if (get_viminfo_parameter('f') == 0) return; fputs(_("\n# File marks:\n"), fp); // Write the filemarks 'A - 'Z for (i = 0; i < NMARKS; i++) { if (vi_namedfm != NULL && (vi_namedfm[i].time_set > namedfm_p[i].time_set)) fm = &vi_namedfm[i]; else fm = &namedfm_p[i]; write_one_filemark(fp, fm, '\'', i + 'A'); } // Find a mark that is the same file and position as the cursor. // That one, or else the last one is deleted. // Move '0 to '1, '1 to '2, etc. until the matching one or '9 // Set the '0 mark to current cursor position. if (curbuf->b_ffname != NULL && !skip_for_viminfo(curbuf)) { name = buflist_nr2name(curbuf->b_fnum, TRUE, FALSE); for (i = NMARKS; i < NMARKS + EXTRA_MARKS - 1; ++i) if (namedfm_p[i].fmark.mark.lnum == curwin->w_cursor.lnum && (namedfm_p[i].fname == NULL ? namedfm_p[i].fmark.fnum == curbuf->b_fnum : (name != NULL && STRCMP(name, namedfm_p[i].fname) == 0))) break; vim_free(name); vim_free(namedfm_p[i].fname); for ( ; i > NMARKS; --i) namedfm_p[i] = namedfm_p[i - 1]; namedfm_p[NMARKS].fmark.mark = curwin->w_cursor; namedfm_p[NMARKS].fmark.fnum = curbuf->b_fnum; namedfm_p[NMARKS].fname = NULL; namedfm_p[NMARKS].time_set = vim_time(); } // Write the filemarks '0 - '9. Newest (highest timestamp) first. vi_idx = NMARKS; idx = NMARKS; for (i = NMARKS; i < NMARKS + EXTRA_MARKS; i++) { xfmark_T *vi_fm = vi_namedfm != NULL ? &vi_namedfm[vi_idx] : NULL; if (vi_fm != NULL && vi_fm->fmark.mark.lnum != 0 && (vi_fm->time_set > namedfm_p[idx].time_set || namedfm_p[idx].fmark.mark.lnum == 0)) { fm = vi_fm; ++vi_idx; } else { fm = &namedfm_p[idx++]; if (vi_fm != NULL && vi_fm->fmark.mark.lnum == fm->fmark.mark.lnum && vi_fm->time_set == fm->time_set && ((vi_fm->fmark.fnum != 0 && vi_fm->fmark.fnum == fm->fmark.fnum) || (vi_fm->fname != NULL && fm->fname != NULL && STRCMP(vi_fm->fname, fm->fname) == 0))) ++vi_idx; // skip duplicate } write_one_filemark(fp, fm, '\'', i - NMARKS + '0'); } // Write the jumplist with -' fputs(_("\n# Jumplist (newest first):\n"), fp); setpcmark(); // add current cursor position cleanup_jumplist(curwin, FALSE); vi_idx = 0; idx = curwin->w_jumplistlen - 1; for (i = 0; i < JUMPLISTSIZE; ++i) { xfmark_T *vi_fm; fm = idx >= 0 ? &curwin->w_jumplist[idx] : NULL; vi_fm = (vi_jumplist != NULL && vi_idx < vi_jumplist_len) ? &vi_jumplist[vi_idx] : NULL; if (fm == NULL && vi_fm == NULL) break; if (fm == NULL || (vi_fm != NULL && fm->time_set < vi_fm->time_set)) { fm = vi_fm; ++vi_idx; } else --idx; if (fm->fmark.fnum == 0 || ((buf = buflist_findnr(fm->fmark.fnum)) != NULL && !skip_for_viminfo(buf))) write_one_filemark(fp, fm, '-', '\''); } } /* * Compare functions for qsort() below, that compares b_last_used. */ int buf_compare(const void *s1, const void *s2) { buf_T *buf1 = *(buf_T **)s1; buf_T *buf2 = *(buf_T **)s2; if (buf1->b_last_used == buf2->b_last_used) return 0; return buf1->b_last_used > buf2->b_last_used ? -1 : 1; } /* * Handle marks in the viminfo file: * fp_out != NULL: copy marks, in time order with buffers in "buflist". * fp_out == NULL && (flags & VIF_WANT_MARKS): read marks for curbuf * fp_out == NULL && (flags & VIF_ONLY_CURBUF): bail out after curbuf marks * fp_out == NULL && (flags & VIF_GET_OLDFILES | VIF_FORCEIT): fill v:oldfiles */ static void copy_viminfo_marks( vir_T *virp, FILE *fp_out, garray_T *buflist, int eof, int flags) { char_u *line = virp->vir_line; buf_T *buf; int num_marked_files; int load_marks; int copy_marks_out; char_u *str; int i; char_u *p; char_u *name_buf; pos_T pos; #ifdef FEAT_EVAL list_T *list = NULL; #endif int count = 0; int buflist_used = 0; buf_T *buflist_buf = NULL; if ((name_buf = alloc(LSIZE)) == NULL) return; *name_buf = NUL; if (fp_out != NULL && buflist->ga_len > 0) { // Sort the list of buffers on b_last_used. qsort(buflist->ga_data, (size_t)buflist->ga_len, sizeof(buf_T *), buf_compare); buflist_buf = ((buf_T **)buflist->ga_data)[0]; } #ifdef FEAT_EVAL if (fp_out == NULL && (flags & (VIF_GET_OLDFILES | VIF_FORCEIT))) { list = list_alloc(); if (list != NULL) set_vim_var_list(VV_OLDFILES, list); } #endif num_marked_files = get_viminfo_parameter('\''); while (!eof && (count < num_marked_files || fp_out == NULL)) { if (line[0] != '>') { if (line[0] != '\n' && line[0] != '\r' && line[0] != '#') { if (viminfo_error("E576: ", _(e_nonr_missing_gt), line)) break; // too many errors, return now } eof = vim_fgets(line, LSIZE, virp->vir_fd); continue; // Skip this dud line } // Handle long line and translate escaped characters. // Find file name, set str to start. // Ignore leading and trailing white space. str = skipwhite(line + 1); str = viminfo_readstring(virp, (int)(str - virp->vir_line), FALSE); if (str == NULL) continue; p = str + STRLEN(str); while (p != str && (*p == NUL || vim_isspace(*p))) p--; if (*p) p++; *p = NUL; #ifdef FEAT_EVAL if (list != NULL) list_append_string(list, str, -1); #endif // If fp_out == NULL, load marks for current buffer. // If fp_out != NULL, copy marks for buffers not in buflist. load_marks = copy_marks_out = FALSE; if (fp_out == NULL) { if ((flags & VIF_WANT_MARKS) && curbuf->b_ffname != NULL) { if (*name_buf == NUL) // only need to do this once home_replace(NULL, curbuf->b_ffname, name_buf, LSIZE, TRUE); if (fnamecmp(str, name_buf) == 0) load_marks = TRUE; } } else // fp_out != NULL { // This is slow if there are many buffers!! FOR_ALL_BUFFERS(buf) if (buf->b_ffname != NULL) { home_replace(NULL, buf->b_ffname, name_buf, LSIZE, TRUE); if (fnamecmp(str, name_buf) == 0) break; } // Copy marks if the buffer has not been loaded. if (buf == NULL || !buf->b_marks_read) { int did_read_line = FALSE; if (buflist_buf != NULL) { // Read the next line. If it has the "*" mark compare the // time stamps. Write entries from "buflist" that are // newer. if (!viminfo_readline(virp) && line[0] == TAB) { did_read_line = TRUE; if (line[1] == '*') { long ltime; sscanf((char *)line + 2, "%ld ", <ime); while ((time_T)ltime < buflist_buf->b_last_used) { write_buffer_marks(buflist_buf, fp_out); if (++count >= num_marked_files) break; if (++buflist_used == buflist->ga_len) { buflist_buf = NULL; break; } buflist_buf = ((buf_T **)buflist->ga_data)[buflist_used]; } } else { // No timestamp, must be written by an older Vim. // Assume all remaining buffers are older than // ours. while (count < num_marked_files && buflist_used < buflist->ga_len) { buflist_buf = ((buf_T **)buflist->ga_data) [buflist_used++]; write_buffer_marks(buflist_buf, fp_out); ++count; } buflist_buf = NULL; } if (count >= num_marked_files) { vim_free(str); break; } } } fputs("\n> ", fp_out); viminfo_writestring(fp_out, str); if (did_read_line) fputs((char *)line, fp_out); count++; copy_marks_out = TRUE; } } vim_free(str); pos.coladd = 0; while (!(eof = viminfo_readline(virp)) && line[0] == TAB) { if (load_marks) { if (line[1] != NUL) { unsigned u; sscanf((char *)line + 2, "%ld %u", &pos.lnum, &u); pos.col = u; switch (line[1]) { case '"': curbuf->b_last_cursor = pos; break; case '^': curbuf->b_last_insert = pos; break; case '.': curbuf->b_last_change = pos; break; case '+': // changelist positions are stored oldest // first if (curbuf->b_changelistlen == JUMPLISTSIZE) // list is full, remove oldest entry mch_memmove(curbuf->b_changelist, curbuf->b_changelist + 1, sizeof(pos_T) * (JUMPLISTSIZE - 1)); else ++curbuf->b_changelistlen; curbuf->b_changelist[ curbuf->b_changelistlen - 1] = pos; break; // Using the line number for the last-used // timestamp. case '*': curbuf->b_last_used = pos.lnum; break; default: if ((i = line[1] - 'a') >= 0 && i < NMARKS) curbuf->b_namedm[i] = pos; } } } else if (copy_marks_out) fputs((char *)line, fp_out); } if (load_marks) { win_T *wp; FOR_ALL_WINDOWS(wp) { if (wp->w_buffer == curbuf) wp->w_changelistidx = curbuf->b_changelistlen; } if (flags & VIF_ONLY_CURBUF) break; } } if (fp_out != NULL) // Write any remaining entries from buflist. while (count < num_marked_files && buflist_used < buflist->ga_len) { buflist_buf = ((buf_T **)buflist->ga_data)[buflist_used++]; write_buffer_marks(buflist_buf, fp_out); ++count; } vim_free(name_buf); } /* * Read marks for the current buffer from the viminfo file, when we support * buffer marks and the buffer has a name. */ void check_marks_read(void) { if (!curbuf->b_marks_read && get_viminfo_parameter('\'') > 0 && curbuf->b_ffname != NULL) read_viminfo(NULL, VIF_WANT_MARKS | VIF_ONLY_CURBUF); // Always set b_marks_read; needed when 'viminfo' is changed to include // the ' parameter after opening a buffer. curbuf->b_marks_read = TRUE; } static int read_viminfo_filemark(vir_T *virp, int force) { char_u *str; xfmark_T *namedfm_p = get_namedfm(); xfmark_T *fm; int i; // We only get here if line[0] == '\'' or '-'. // Illegal mark names are ignored (for future expansion). str = virp->vir_line + 1; if (*str <= 127 && ((*virp->vir_line == '\'' && (VIM_ISDIGIT(*str) || isupper(*str))) || (*virp->vir_line == '-' && *str == '\''))) { if (*str == '\'') { // If the jumplist isn't full insert fmark as oldest entry if (curwin->w_jumplistlen == JUMPLISTSIZE) fm = NULL; else { for (i = curwin->w_jumplistlen; i > 0; --i) curwin->w_jumplist[i] = curwin->w_jumplist[i - 1]; ++curwin->w_jumplistidx; ++curwin->w_jumplistlen; fm = &curwin->w_jumplist[0]; fm->fmark.mark.lnum = 0; fm->fname = NULL; } } else if (VIM_ISDIGIT(*str)) fm = &namedfm_p[*str - '0' + NMARKS]; else fm = &namedfm_p[*str - 'A']; if (fm != NULL && (fm->fmark.mark.lnum == 0 || force)) { str = skipwhite(str + 1); fm->fmark.mark.lnum = getdigits(&str); str = skipwhite(str); fm->fmark.mark.col = getdigits(&str); fm->fmark.mark.coladd = 0; fm->fmark.fnum = 0; str = skipwhite(str); vim_free(fm->fname); fm->fname = viminfo_readstring(virp, (int)(str - virp->vir_line), FALSE); fm->time_set = 0; } } return vim_fgets(virp->vir_line, LSIZE, virp->vir_fd); } /* * Prepare for reading viminfo marks when writing viminfo later. */ static void prepare_viminfo_marks(void) { vi_namedfm = ALLOC_CLEAR_MULT(xfmark_T, NMARKS + EXTRA_MARKS); vi_jumplist = ALLOC_CLEAR_MULT(xfmark_T, JUMPLISTSIZE); vi_jumplist_len = 0; } static void finish_viminfo_marks(void) { int i; if (vi_namedfm != NULL) { for (i = 0; i < NMARKS + EXTRA_MARKS; ++i) vim_free(vi_namedfm[i].fname); VIM_CLEAR(vi_namedfm); } if (vi_jumplist != NULL) { for (i = 0; i < vi_jumplist_len; ++i) vim_free(vi_jumplist[i].fname); VIM_CLEAR(vi_jumplist); } } /* * Accept a new style mark line from the viminfo, store it when it's new. */ static void handle_viminfo_mark(garray_T *values, int force) { bval_T *vp = (bval_T *)values->ga_data; int name; linenr_T lnum; colnr_T col; time_t timestamp; xfmark_T *fm = NULL; // Check the format: // |{bartype},{name},{lnum},{col},{timestamp},{filename} if (values->ga_len < 5 || vp[0].bv_type != BVAL_NR || vp[1].bv_type != BVAL_NR || vp[2].bv_type != BVAL_NR || vp[3].bv_type != BVAL_NR || vp[4].bv_type != BVAL_STRING) return; name = vp[0].bv_nr; if (name != '\'' && !VIM_ISDIGIT(name) && !ASCII_ISUPPER(name)) return; lnum = vp[1].bv_nr; col = vp[2].bv_nr; if (lnum <= 0 || col < 0) return; timestamp = (time_t)vp[3].bv_nr; if (name == '\'') { if (vi_jumplist != NULL) { if (vi_jumplist_len < JUMPLISTSIZE) fm = &vi_jumplist[vi_jumplist_len++]; } else { int idx; int i; // If we have a timestamp insert it in the right place. if (timestamp != 0) { for (idx = curwin->w_jumplistlen - 1; idx >= 0; --idx) if (curwin->w_jumplist[idx].time_set < timestamp) { ++idx; break; } // idx cannot be zero now if (idx < 0 && curwin->w_jumplistlen < JUMPLISTSIZE) // insert as the oldest entry idx = 0; } else if (curwin->w_jumplistlen < JUMPLISTSIZE) // insert as oldest entry idx = 0; else idx = -1; if (idx >= 0) { if (curwin->w_jumplistlen == JUMPLISTSIZE) { // Drop the oldest entry. --idx; vim_free(curwin->w_jumplist[0].fname); for (i = 0; i < idx; ++i) curwin->w_jumplist[i] = curwin->w_jumplist[i + 1]; } else { // Move newer entries forward. for (i = curwin->w_jumplistlen; i > idx; --i) curwin->w_jumplist[i] = curwin->w_jumplist[i - 1]; ++curwin->w_jumplistidx; ++curwin->w_jumplistlen; } fm = &curwin->w_jumplist[idx]; fm->fmark.mark.lnum = 0; fm->fname = NULL; fm->time_set = 0; } } } else { int idx; xfmark_T *namedfm_p = get_namedfm(); if (VIM_ISDIGIT(name)) { if (vi_namedfm != NULL) idx = name - '0' + NMARKS; else { int i; // Do not use the name from the viminfo file, insert in time // order. for (idx = NMARKS; idx < NMARKS + EXTRA_MARKS; ++idx) if (namedfm_p[idx].time_set < timestamp) break; if (idx == NMARKS + EXTRA_MARKS) // All existing entries are newer. return; i = NMARKS + EXTRA_MARKS - 1; vim_free(namedfm_p[i].fname); for ( ; i > idx; --i) namedfm_p[i] = namedfm_p[i - 1]; namedfm_p[idx].fname = NULL; } } else idx = name - 'A'; if (vi_namedfm != NULL) fm = &vi_namedfm[idx]; else fm = &namedfm_p[idx]; } if (fm != NULL) { if (vi_namedfm != NULL || fm->fmark.mark.lnum == 0 || fm->time_set < timestamp || force) { fm->fmark.mark.lnum = lnum; fm->fmark.mark.col = col; fm->fmark.mark.coladd = 0; fm->fmark.fnum = 0; vim_free(fm->fname); if (vp[4].bv_allocated) { fm->fname = vp[4].bv_string; vp[4].bv_string = NULL; } else fm->fname = vim_strsave(vp[4].bv_string); fm->time_set = timestamp; } } } static int read_viminfo_barline(vir_T *virp, int got_encoding, int force, int writing) { char_u *p = virp->vir_line + 1; int bartype; garray_T values; bval_T *vp; int i; int read_next = TRUE; // The format is: |{bartype},{value},... // For a very long string: // |{bartype},>{length of "{text}{text2}"} // |<{text1} // |<{text2},{value} // For a long line not using a string // |{bartype},{lots of values},> // |<{value},{value} if (*p == '<') { // Continuation line of an unrecognized item. if (writing) ga_copy_string(&virp->vir_barlines, virp->vir_line); } else { ga_init2(&values, sizeof(bval_T), 20); bartype = getdigits(&p); switch (bartype) { case BARTYPE_VERSION: // Only use the version when it comes before the encoding. // If it comes later it was copied by a Vim version that // doesn't understand the version. if (!got_encoding) { read_next = barline_parse(virp, p, &values); vp = (bval_T *)values.ga_data; if (values.ga_len > 0 && vp->bv_type == BVAL_NR) virp->vir_version = vp->bv_nr; } break; case BARTYPE_HISTORY: read_next = barline_parse(virp, p, &values); handle_viminfo_history(&values, writing); break; case BARTYPE_REGISTER: read_next = barline_parse(virp, p, &values); handle_viminfo_register(&values, force); break; case BARTYPE_MARK: read_next = barline_parse(virp, p, &values); handle_viminfo_mark(&values, force); break; default: // copy unrecognized line (for future use) if (writing) ga_copy_string(&virp->vir_barlines, virp->vir_line); } for (i = 0; i < values.ga_len; ++i) { vp = (bval_T *)values.ga_data + i; if (vp->bv_type == BVAL_STRING && vp->bv_allocated) vim_free(vp->bv_string); vim_free(vp->bv_tofree); } ga_clear(&values); } if (read_next) return viminfo_readline(virp); return FALSE; } /* * read_viminfo_up_to_marks() -- Only called from do_viminfo(). Reads in the * first part of the viminfo file which contains everything but the marks that * are local to a file. Returns TRUE when end-of-file is reached. -- webb */ static int read_viminfo_up_to_marks( vir_T *virp, int forceit, int writing) { int eof; buf_T *buf; int got_encoding = FALSE; prepare_viminfo_history(forceit ? 9999 : 0, writing); eof = viminfo_readline(virp); while (!eof && virp->vir_line[0] != '>') { switch (virp->vir_line[0]) { // Characters reserved for future expansion, ignored now case '+': // "+40 /path/dir file", for running vim without args case '^': // to be defined case '<': // long line - ignored // A comment or empty line. case NUL: case '\r': case '\n': case '#': eof = viminfo_readline(virp); break; case '|': eof = read_viminfo_barline(virp, got_encoding, forceit, writing); break; case '*': // "*encoding=value" got_encoding = TRUE; eof = viminfo_encoding(virp); break; case '!': // global variable #ifdef FEAT_EVAL eof = read_viminfo_varlist(virp, writing); #else eof = viminfo_readline(virp); #endif break; case '%': // entry for buffer list eof = read_viminfo_bufferlist(virp, writing); break; case '"': // When registers are in bar lines skip the old style register // lines. if (virp->vir_version < VIMINFO_VERSION_WITH_REGISTERS) eof = read_viminfo_register(virp, forceit); else do { eof = viminfo_readline(virp); } while (!eof && (virp->vir_line[0] == TAB || virp->vir_line[0] == '<')); break; case '/': // Search string case '&': // Substitute search string case '~': // Last search string, followed by '/' or '&' eof = read_viminfo_search_pattern(virp, forceit); break; case '$': eof = read_viminfo_sub_string(virp, forceit); break; case ':': case '?': case '=': case '@': // When history is in bar lines skip the old style history // lines. if (virp->vir_version < VIMINFO_VERSION_WITH_HISTORY) eof = read_viminfo_history(virp, writing); else eof = viminfo_readline(virp); break; case '-': case '\'': // When file marks are in bar lines skip the old style lines. if (virp->vir_version < VIMINFO_VERSION_WITH_MARKS) eof = read_viminfo_filemark(virp, forceit); else eof = viminfo_readline(virp); break; default: if (viminfo_error("E575: ", _(e_illegal_starting_char), virp->vir_line)) eof = TRUE; else eof = viminfo_readline(virp); break; } } // Finish reading history items. if (!writing) finish_viminfo_history(virp); // Change file names to buffer numbers for fmarks. FOR_ALL_BUFFERS(buf) fmarks_check_names(buf); return eof; } /* * do_viminfo() -- Should only be called from read_viminfo() & write_viminfo(). */ static void do_viminfo(FILE *fp_in, FILE *fp_out, int flags) { int eof = FALSE; vir_T vir; int merge = FALSE; int do_copy_marks = FALSE; garray_T buflist; if ((vir.vir_line = alloc(LSIZE)) == NULL) return; vir.vir_fd = fp_in; vir.vir_conv.vc_type = CONV_NONE; ga_init2(&vir.vir_barlines, sizeof(char_u *), 100); vir.vir_version = -1; if (fp_in != NULL) { if (flags & VIF_WANT_INFO) { if (fp_out != NULL) { // Registers and marks are read and kept separate from what // this Vim is using. They are merged when writing. prepare_viminfo_registers(); prepare_viminfo_marks(); } eof = read_viminfo_up_to_marks(&vir, flags & VIF_FORCEIT, fp_out != NULL); merge = TRUE; } else if (flags != 0) // Skip info, find start of marks while (!(eof = viminfo_readline(&vir)) && vir.vir_line[0] != '>') ; do_copy_marks = (flags & (VIF_WANT_MARKS | VIF_ONLY_CURBUF | VIF_GET_OLDFILES | VIF_FORCEIT)); } if (fp_out != NULL) { // Write the info: fprintf(fp_out, _("# This viminfo file was generated by Vim %s.\n"), VIM_VERSION_MEDIUM); fputs(_("# You may edit it if you're careful!\n\n"), fp_out); write_viminfo_version(fp_out); fputs(_("# Value of 'encoding' when this file was written\n"), fp_out); fprintf(fp_out, "*encoding=%s\n\n", p_enc); write_viminfo_search_pattern(fp_out); write_viminfo_sub_string(fp_out); write_viminfo_history(fp_out, merge); write_viminfo_registers(fp_out); finish_viminfo_registers(); #ifdef FEAT_EVAL write_viminfo_varlist(fp_out); #endif write_viminfo_filemarks(fp_out); finish_viminfo_marks(); write_viminfo_bufferlist(fp_out); write_viminfo_barlines(&vir, fp_out); if (do_copy_marks) ga_init2(&buflist, sizeof(buf_T *), 50); write_viminfo_marks(fp_out, do_copy_marks ? &buflist : NULL); } if (do_copy_marks) { copy_viminfo_marks(&vir, fp_out, &buflist, eof, flags); if (fp_out != NULL) ga_clear(&buflist); } vim_free(vir.vir_line); if (vir.vir_conv.vc_type != CONV_NONE) convert_setup(&vir.vir_conv, NULL, NULL); ga_clear_strings(&vir.vir_barlines); } /* * read_viminfo() -- Read the viminfo file. Registers etc. which are already * set are not over-written unless "flags" includes VIF_FORCEIT. -- webb */ int read_viminfo( char_u *file, // file name or NULL to use default name int flags) // VIF_WANT_INFO et al. { FILE *fp; char_u *fname; stat_T st; // mch_stat() of existing viminfo file if (no_viminfo()) return FAIL; fname = viminfo_filename(file); // get file name in allocated buffer if (fname == NULL) return FAIL; fp = mch_fopen((char *)fname, READBIN); if (p_verbose > 0) { verbose_enter(); smsg(_("Reading viminfo file \"%s\"%s%s%s%s"), fname, (flags & VIF_WANT_INFO) ? _(" info") : "", (flags & VIF_WANT_MARKS) ? _(" marks") : "", (flags & VIF_GET_OLDFILES) ? _(" oldfiles") : "", fp == NULL ? _(" FAILED") : ""); verbose_leave(); } vim_free(fname); if (fp == NULL) return FAIL; if (mch_fstat(fileno(fp), &st) < 0 || S_ISDIR(st.st_mode)) { fclose(fp); return FAIL; } viminfo_errcnt = 0; do_viminfo(fp, NULL, flags); fclose(fp); return OK; } /* * Write the viminfo file. The old one is read in first so that effectively a * merge of current info and old info is done. This allows multiple vims to * run simultaneously, without losing any marks etc. * If "forceit" is TRUE, then the old file is not read in, and only internal * info is written to the file. */ void write_viminfo(char_u *file, int forceit) { char_u *fname; FILE *fp_in = NULL; // input viminfo file, if any FILE *fp_out = NULL; // output viminfo file char_u *tempname = NULL; // name of temp viminfo file stat_T st_new; // mch_stat() of potential new file stat_T st_old; // mch_stat() of existing viminfo file #if defined(UNIX) || defined(VMS) mode_t umask_save; #endif #ifdef UNIX int shortname = FALSE; // use 8.3 file name #endif #ifdef MSWIN int hidden = FALSE; #endif if (no_viminfo()) return; fname = viminfo_filename(file); // may set to default if NULL if (fname == NULL) return; fp_in = mch_fopen((char *)fname, READBIN); if (fp_in == NULL) { int fd; // if it does exist, but we can't read it, don't try writing if (mch_stat((char *)fname, &st_new) == 0) goto end; // Create the new .viminfo non-accessible for others, because it may // contain text from non-accessible documents. It is up to the user to // widen access (e.g. to a group). This may also fail if there is a // race condition, then just give up. fd = mch_open((char *)fname, O_CREAT|O_EXTRA|O_EXCL|O_WRONLY|O_NOFOLLOW, 0600); if (fd < 0) goto end; fp_out = fdopen(fd, WRITEBIN); } else { // There is an existing viminfo file. Create a temporary file to // write the new viminfo into, in the same directory as the // existing viminfo file, which will be renamed once all writing is // successful. if (mch_fstat(fileno(fp_in), &st_old) < 0 || S_ISDIR(st_old.st_mode) #ifdef UNIX // For Unix we check the owner of the file. It's not very nice // to overwrite a user's viminfo file after a "su root", with a // viminfo file that the user can't read. || (getuid() != ROOT_UID && !(st_old.st_uid == getuid() ? (st_old.st_mode & 0200) : (st_old.st_gid == getgid() ? (st_old.st_mode & 0020) : (st_old.st_mode & 0002)))) #endif ) { int tt = msg_didany; // avoid a wait_return() for this message, it's annoying semsg(_(e_viminfo_file_is_not_writable_str), fname); msg_didany = tt; fclose(fp_in); goto end; } #ifdef MSWIN // Get the file attributes of the existing viminfo file. hidden = mch_ishidden(fname); #endif // Make tempname, find one that does not exist yet. // Beware of a race condition: If someone logs out and all Vim // instances exit at the same time a temp file might be created between // stat() and open(). Use mch_open() with O_EXCL to avoid that. // May try twice: Once normal and once with shortname set, just in // case somebody puts his viminfo file in an 8.3 filesystem. for (;;) { int next_char = 'z'; char_u *wp; tempname = buf_modname( #ifdef UNIX shortname, #else FALSE, #endif fname, #ifdef VMS (char_u *)"-tmp", #else (char_u *)".tmp", #endif FALSE); if (tempname == NULL) // out of memory break; // Try a series of names. Change one character, just before // the extension. This should also work for an 8.3 // file name, when after adding the extension it still is // the same file as the original. wp = tempname + STRLEN(tempname) - 5; if (wp < gettail(tempname)) // empty file name? wp = gettail(tempname); for (;;) { // Check if tempfile already exists. Never overwrite an // existing file! if (mch_stat((char *)tempname, &st_new) == 0) { #ifdef UNIX // Check if tempfile is same as original file. May happen // when modname() gave the same file back. E.g. silly // link, or file name-length reached. Try again with // shortname set. if (!shortname && st_new.st_dev == st_old.st_dev && st_new.st_ino == st_old.st_ino) { VIM_CLEAR(tempname); shortname = TRUE; break; } #endif } else { // Try creating the file exclusively. This may fail if // another Vim tries to do it at the same time. #ifdef VMS // fdopen() fails for some reason umask_save = umask(077); fp_out = mch_fopen((char *)tempname, WRITEBIN); (void)umask(umask_save); #else int fd; // Use mch_open() to be able to use O_NOFOLLOW and set file // protection: // Unix: same as original file, but strip s-bit. Reset // umask to avoid it getting in the way. // Others: r&w for user only. # ifdef UNIX umask_save = umask(0); fd = mch_open((char *)tempname, O_CREAT|O_EXTRA|O_EXCL|O_WRONLY|O_NOFOLLOW, (int)((st_old.st_mode & 0777) | 0600)); (void)umask(umask_save); # else fd = mch_open((char *)tempname, O_CREAT|O_EXTRA|O_EXCL|O_WRONLY|O_NOFOLLOW, 0600); # endif if (fd < 0) { fp_out = NULL; # ifdef EEXIST // Avoid trying lots of names while the problem is lack // of permission, only retry if the file already // exists. if (errno != EEXIST) break; # endif } else fp_out = fdopen(fd, WRITEBIN); #endif // VMS if (fp_out != NULL) break; } // Assume file exists, try again with another name. if (next_char == 'a' - 1) { // They all exist? Must be something wrong! Don't write // the viminfo file then. semsg(_(e_too_many_viminfo_temp_files_like_str), tempname); break; } *wp = next_char; --next_char; } if (tempname != NULL) break; // continue if shortname was set } #if defined(UNIX) && defined(HAVE_FCHOWN) if (tempname != NULL && fp_out != NULL) { stat_T tmp_st; // Make sure the original owner can read/write the tempfile and // otherwise preserve permissions, making sure the group matches. if (mch_stat((char *)tempname, &tmp_st) >= 0) { if (st_old.st_uid != tmp_st.st_uid) // Changing the owner might fail, in which case the // file will now be owned by the current user, oh well. vim_ignored = fchown(fileno(fp_out), st_old.st_uid, -1); if (st_old.st_gid != tmp_st.st_gid && fchown(fileno(fp_out), -1, st_old.st_gid) == -1) // can't set the group to what it should be, remove // group permissions (void)mch_setperm(tempname, 0600); } else // can't stat the file, set conservative permissions (void)mch_setperm(tempname, 0600); } #endif } // Check if the new viminfo file can be written to. if (fp_out == NULL) { semsg(_(e_cant_write_viminfo_file_str), (fp_in == NULL || tempname == NULL) ? fname : tempname); if (fp_in != NULL) fclose(fp_in); goto end; } if (p_verbose > 0) { verbose_enter(); smsg(_("Writing viminfo file \"%s\""), fname); verbose_leave(); } viminfo_errcnt = 0; do_viminfo(fp_in, fp_out, forceit ? 0 : (VIF_WANT_INFO | VIF_WANT_MARKS)); if (fclose(fp_out) == EOF) ++viminfo_errcnt; if (fp_in != NULL) { fclose(fp_in); // In case of an error keep the original viminfo file. Otherwise // rename the newly written file. Give an error if that fails. if (viminfo_errcnt == 0) { if (vim_rename(tempname, fname) == -1) { ++viminfo_errcnt; semsg(_(e_cant_rename_viminfo_file_to_str), fname); } # ifdef MSWIN // If the viminfo file was hidden then also hide the new file. else if (hidden) mch_hide(fname); # endif } if (viminfo_errcnt > 0) mch_remove(tempname); } end: vim_free(fname); vim_free(tempname); } /* * ":rviminfo" and ":wviminfo". */ void ex_viminfo( exarg_T *eap) { char_u *save_viminfo; save_viminfo = p_viminfo; if (*p_viminfo == NUL) p_viminfo = (char_u *)"'100"; if (eap->cmdidx == CMD_rviminfo) { if (read_viminfo(eap->arg, VIF_WANT_INFO | VIF_WANT_MARKS | (eap->forceit ? VIF_FORCEIT : 0)) == FAIL) emsg(_(e_cannot_open_viminfo_file_for_reading)); } else write_viminfo(eap->arg, eap->forceit); p_viminfo = save_viminfo; } #endif // FEAT_VIMINFO