nyx/vim
1
0
Fork 0
mirror of https://github.com/vim/vim synced 2025-03-16 14:57:52 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 3
vim/src/viminfo.c
Yegappan Lakshmanan 084529c03d
patch 9.1.0957: MS-Windows: conversion warnings 
Problem:  MS-Windows: conversion warnings
Solution: add explicit type casts (Yegappan Lakshmanan)

closes: #16288

Signed-off-by: Yegappan Lakshmanan <yegappan@yahoo.com>
Signed-off-by: Christian Brabandt <cb@256bit.org>
2024-12-24 09:50:01 +01:00

3375 lines
81 KiB
C
Raw Permalink Blame History

/* 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) // 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)
return FALSE;
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 = NULL;
char_u *p;
type = hist_char2type(virp->vir_line[0]);
if (viminfo_hisidx[type] >= viminfo_hislen[type])
goto done;
val = viminfo_readstring(virp, 1, TRUE);
if (val == NULL || *val == NUL)
goto done;
int sep = (*val == ' ' ? NUL : *val);
if (in_history(type, val + (type == HIST_SEARCH), viminfo_add_at_front,
sep, writing))
goto done;
// Need to re-allocate to append the separator byte.
len = STRLEN(val);
if (type == HIST_SEARCH)
{
p = alloc((size_t)len + 1); // +1 for the NUL. val already
// includes the separator.
if (p == NULL)
goto done;
// Search entry: Move the separator from the first
// column to after the NUL.
mch_memmove(p, val + 1, (size_t)len);
p[len] = sep;
--len; // take into account the shortened string
}
else
{
p = alloc((size_t)len + 2); // +1 for NUL and +1 for separator
if (p == NULL)
goto done;
// Not a search entry: No separator in the viminfo
// file, add a NUL separator.
mch_memmove(p, val, (size_t)len + 1); // +1 to include the NUL
p[len + 1] = NUL; // put the separator *after* the string's NUL
}
viminfo_history[type][viminfo_hisidx[type]].hisstr = p;
viminfo_history[type][viminfo_hisidx[type]].hisstrlen = (size_t)len;
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]++;
done:
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])
return;
val = vp[3].bv_string;
if (val == NULL || *val == NUL)
return;
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))
return;
// 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;
len = viminfo_history[type][idx].hisstrlen;
if (STRCMP(val, p) == 0
&& (type != HIST_SEARCH || sep == p[len + 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].hisstrlen = (size_t)len;
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].hisstrlen = viminfo_history[type][i].hisstrlen;
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;
tot_hist[i]->hisstrlen = 0;
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);
viminfo_history[type][i].hisstrlen = 0;
}
for (i = 0; i < hislen; i++)
{
vim_free(histentry[i].hisstr);
histentry[i].hisstrlen = 0;
}
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;
size_t plen;
time_t timestamp;
int c = NUL;
if (round == 1)
{
p = histentry[i].hisstr;
plen = histentry[i].hisstrlen;
timestamp = histentry[i].time_set;
}
else
{
if (viminfo_history[type] == NULL)
{
p = NULL;
plen = 0;
timestamp = 0;
}
else
{
p = viminfo_history[type][i].hisstr;
plen = viminfo_history[type][i].hisstrlen;
timestamp = 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[plen + 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);
viminfo_history[type][i].hisstrlen = 0;
}
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)
return;
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 (SAFE_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;
len = (int)STRLEN(s);
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_strnsave(s, len);
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;
case 'F': type = VAR_FLOAT; break;
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);
else if (type == VAR_FLOAT)
(void)string2float(tab + 1, &tv.vval.v_float, FALSE);
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_ALL_HASHTAB_ITEMS(gvht, hi, todo)
{
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:
case VAR_CLASS:
case VAR_OBJECT:
case VAR_TYPEALIAS:
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)
return;
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)
return;
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)
return;
#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)
return;
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].string);
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;
string_T *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(string_T, 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)
{
string_T *new_array = (string_T *)
alloc(limit * 2 * sizeof(string_T));
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].string = str;
array[size].length = STRLEN(str);
++size;
}
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].string);
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(string_T, size);
for (i = 0; i < size; i++)
{
if (y_current_p->y_array == NULL)
{
VIM_CLEAR_STRING(array[i]);
}
else
{
y_current_p->y_array[i].string = array[i].string;
y_current_p->y_array[i].length = array[i].length;
}
}
}
}
else
{
// Free array[] if it was filled.
for (i = 0; i < size; i++)
vim_free(array[i].string);
}
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].string);
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(string_T, 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].string = vp[i + 6].bv_string;
y_ptr->y_array[i].length = vp[i + 6].bv_len;
vp[i + 6].bv_string = NULL;
}
else if (vp[i + 6].bv_type != BVAL_STRING)
{
free(y_ptr->y_array);
y_ptr->y_array = NULL;
}
else
{
y_ptr->y_array[i].string = vim_strnsave(vp[i + 6].bv_string, vp[i + 6].bv_len);
y_ptr->y_array[i].length = vp[i + 6].bv_len;
}
}
}
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].string == 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)y_ptr->y_array[j].length + 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].string);
}
{
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].string,
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 ", &ltime);
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) || SAFE_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
Reference in a new issue View git blame Copy permalink