/* 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.

*/

/*

* ex_cmds.c: some functions for command line commands

*/

#include "vim.h"

#include "version.h"

#ifdef FEAT_FLOAT

# include <float.h>

#endif

static int linelen(int *has_tab);

static void do_filter(linenr_T line1, linenr_T line2, exarg_T *eap, char_u *cmd, int do_in, int do_out);

#ifdef FEAT_VIMINFO

static char_u *viminfo_filename(char_u *);

static void do_viminfo(FILE *fp_in, FILE *fp_out, int flags);

static int viminfo_encoding(vir_T *virp);

static int read_viminfo_up_to_marks(vir_T *virp, int forceit, int writing);

#endif

static int check_readonly(int *forceit, buf_T *buf);

static void delbuf_msg(char_u *name);

static int

#ifdef __BORLANDC__

_RTLENTRYF

#endif

help_compare(const void *s1, const void *s2);

static void prepare_help_buffer(void);

/*

* ":ascii" and "ga".

*/

void

do_ascii(exarg_T *eap UNUSED)

{

int c;

int cval;

char buf1[20];

char buf2[20];

char_u buf3[7];

#ifdef FEAT_DIGRAPHS

char_u *dig;

#endif

#ifdef FEAT_MBYTE

int cc[MAX_MCO];

int ci = 0;

int len;

if (enc_utf8)

c = utfc_ptr2char(ml_get_cursor(), cc);

else

#endif

c = gchar_cursor();

if (c == NUL)

{

MSG("NUL");

return;

}

#ifdef FEAT_MBYTE

IObuff[0] = NUL;

if (!has_mbyte || (enc_dbcs != 0 && c < 0x100) || c < 0x80)

#endif

{

if (c == NL) /* NUL is stored as NL */

c = NUL;

if (c == CAR && get_fileformat(curbuf) == EOL_MAC)

cval = NL; /* NL is stored as CR */

else

cval = c;

if (vim_isprintc_strict(c) && (c < ' '

#ifndef EBCDIC

|| c > '~'

#endif

))

{

transchar_nonprint(buf3, c);

vim_snprintf(buf1, sizeof(buf1), " <%s>", (char *)buf3);

}

else

buf1[0] = NUL;

#ifndef EBCDIC

if (c >= 0x80)

vim_snprintf(buf2, sizeof(buf2), " <M-%s>",

(char *)transchar(c & 0x7f));

else

#endif

buf2[0] = NUL;

#ifdef FEAT_DIGRAPHS

dig = get_digraph_for_char(cval);

if (dig != NULL)

vim_snprintf((char *)IObuff, IOSIZE,

_("<%s>%s%s %d, Hex %02x, Oct %03o, Digr %s"),

transchar(c), buf1, buf2, cval, cval, cval, dig);

else

#endif

vim_snprintf((char *)IObuff, IOSIZE,

_("<%s>%s%s %d, Hex %02x, Octal %03o"),

transchar(c), buf1, buf2, cval, cval, cval);

#ifdef FEAT_MBYTE

if (enc_utf8)

c = cc[ci++];

else

c = 0;

#endif

}

#ifdef FEAT_MBYTE

/* Repeat for combining characters. */

while (has_mbyte && (c >= 0x100 || (enc_utf8 && c >= 0x80)))

{

len = (int)STRLEN(IObuff);

/* This assumes every multi-byte char is printable... */

if (len > 0)

IObuff[len++] = ' ';

IObuff[len++] = '<';

if (enc_utf8 && utf_iscomposing(c)

# ifdef USE_GUI

&& !gui.in_use

# endif

)

IObuff[len++] = ' '; /* draw composing char on top of a space */

len += (*mb_char2bytes)(c, IObuff + len);

#ifdef FEAT_DIGRAPHS

dig = get_digraph_for_char(c);

if (dig != NULL)

vim_snprintf((char *)IObuff + len, IOSIZE - len,

c < 0x10000 ? _("> %d, Hex %04x, Oct %o, Digr %s")

: _("> %d, Hex %08x, Oct %o, Digr %s"),

c, c, c, dig);

else

#endif

vim_snprintf((char *)IObuff + len, IOSIZE - len,

c < 0x10000 ? _("> %d, Hex %04x, Octal %o")

: _("> %d, Hex %08x, Octal %o"),

c, c, c);

if (ci == MAX_MCO)

break;

if (enc_utf8)

c = cc[ci++];

else

c = 0;

}

#endif

msg(IObuff);

}

/*

* ":left", ":center" and ":right": align text.

*/

void

ex_align(exarg_T *eap)

{

pos_T save_curpos;

int len;

int indent = 0;

int new_indent;

int has_tab;

int width;

#ifdef FEAT_RIGHTLEFT

if (curwin->w_p_rl)

{

/* switch left and right aligning */

if (eap->cmdidx == CMD_right)

eap->cmdidx = CMD_left;

else if (eap->cmdidx == CMD_left)

eap->cmdidx = CMD_right;

}

#endif

width = atoi((char *)eap->arg);

save_curpos = curwin->w_cursor;

if (eap->cmdidx == CMD_left) /* width is used for new indent */

{

if (width >= 0)

indent = width;

}

else

{

/*

* if 'textwidth' set, use it

* else if 'wrapmargin' set, use it

* if invalid value, use 80

*/

if (width <= 0)

width = curbuf->b_p_tw;

if (width == 0 && curbuf->b_p_wm > 0)

width = curwin->w_width - curbuf->b_p_wm;

if (width <= 0)

width = 80;

}

if (u_save((linenr_T)(eap->line1 - 1), (linenr_T)(eap->line2 + 1)) == FAIL)

return;

for (curwin->w_cursor.lnum = eap->line1;

curwin->w_cursor.lnum <= eap->line2; ++curwin->w_cursor.lnum)

{

if (eap->cmdidx == CMD_left) /* left align */

new_indent = indent;

else

{

has_tab = FALSE; /* avoid uninit warnings */

len = linelen(eap->cmdidx == CMD_right ? &has_tab

: NULL) - get_indent();

if (len <= 0) /* skip blank lines */

continue;

if (eap->cmdidx == CMD_center)

new_indent = (width - len) / 2;

else

{

new_indent = width - len; /* right align */

/*

* Make sure that embedded TABs don't make the text go too far

* to the right.

*/

if (has_tab)

while (new_indent > 0)

{

(void)set_indent(new_indent, 0);

if (linelen(NULL) <= width)

{

/*

* Now try to move the line as much as possible to

* the right. Stop when it moves too far.

*/

do

(void)set_indent(++new_indent, 0);

while (linelen(NULL) <= width);

--new_indent;

break;

}

--new_indent;

}

}

}

if (new_indent < 0)

new_indent = 0;

(void)set_indent(new_indent, 0); /* set indent */

}

changed_lines(eap->line1, 0, eap->line2 + 1, 0L);

curwin->w_cursor = save_curpos;

beginline(BL_WHITE | BL_FIX);

}

/*

* Get the length of the current line, excluding trailing white space.

*/

static int

linelen(int *has_tab)

{

char_u *line;

char_u *first;

char_u *last;

int save;

int len;

/* find the first non-blank character */

line = ml_get_curline();

first = skipwhite(line);

/* find the character after the last non-blank character */

for (last = first + STRLEN(first);

last > first && VIM_ISWHITE(last[-1]); --last)

;

save = *last;

*last = NUL;

len = linetabsize(line); /* get line length */

if (has_tab != NULL) /* check for embedded TAB */

*has_tab = (vim_strchr(first, TAB) != NULL);

*last = save;

return len;

}

/* Buffer for two lines used during sorting. They are allocated to

* contain the longest line being sorted. */

static char_u *sortbuf1;

static char_u *sortbuf2;

static int sort_ic; /* ignore case */

static int sort_nr; /* sort on number */

static int sort_rx; /* sort on regex instead of skipping it */

#ifdef FEAT_FLOAT

static int sort_flt; /* sort on floating number */

#endif

static int sort_abort; /* flag to indicate if sorting has been interrupted */

/* Struct to store info to be sorted. */

typedef struct

{

linenr_T lnum; /* line number */

union {

struct

{

varnumber_T start_col_nr; /* starting column number */

varnumber_T end_col_nr; /* ending column number */

} line;

varnumber_T value; /* value if sorting by integer */

#ifdef FEAT_FLOAT

float_T value_flt; /* value if sorting by float */

#endif

} st_u;

} sorti_T;

static int

#ifdef __BORLANDC__

_RTLENTRYF

#endif

sort_compare(const void *s1, const void *s2);

static int

#ifdef __BORLANDC__

_RTLENTRYF

#endif

sort_compare(const void *s1, const void *s2)

{

sorti_T l1 = *(sorti_T *)s1;

sorti_T l2 = *(sorti_T *)s2;

int result = 0;

/* If the user interrupts, there's no way to stop qsort() immediately, but

* if we return 0 every time, qsort will assume it's done sorting and

* exit. */

if (sort_abort)

return 0;

fast_breakcheck();

if (got_int)

sort_abort = TRUE;

/* When sorting numbers "start_col_nr" is the number, not the column

* number. */

if (sort_nr)

result = l1.st_u.value == l2.st_u.value ? 0

: l1.st_u.value > l2.st_u.value ? 1 : -1;

#ifdef FEAT_FLOAT

else if (sort_flt)

result = l1.st_u.value_flt == l2.st_u.value_flt ? 0

: l1.st_u.value_flt > l2.st_u.value_flt ? 1 : -1;

#endif

else

{

/* We need to copy one line into "sortbuf1", because there is no

* guarantee that the first pointer becomes invalid when obtaining the

* second one. */

STRNCPY(sortbuf1, ml_get(l1.lnum) + l1.st_u.line.start_col_nr,

l1.st_u.line.end_col_nr - l1.st_u.line.start_col_nr + 1);

sortbuf1[l1.st_u.line.end_col_nr - l1.st_u.line.start_col_nr] = 0;

STRNCPY(sortbuf2, ml_get(l2.lnum) + l2.st_u.line.start_col_nr,

l2.st_u.line.end_col_nr - l2.st_u.line.start_col_nr + 1);

sortbuf2[l2.st_u.line.end_col_nr - l2.st_u.line.start_col_nr] = 0;

result = sort_ic ? STRICMP(sortbuf1, sortbuf2)

: STRCMP(sortbuf1, sortbuf2);

}

/* If two lines have the same value, preserve the original line order. */

if (result == 0)

return (int)(l1.lnum - l2.lnum);

return result;

}

/*

* ":sort".

*/

void

ex_sort(exarg_T *eap)

{

regmatch_T regmatch;

int len;

linenr_T lnum;

long maxlen = 0;

sorti_T *nrs;

size_t count = (size_t)(eap->line2 - eap->line1 + 1);

size_t i;

char_u *p;

char_u *s;

char_u *s2;

char_u c; /* temporary character storage */

int unique = FALSE;

long deleted;

colnr_T start_col;

colnr_T end_col;

int sort_what = 0;

int format_found = 0;

int change_occurred = FALSE; // Buffer contents changed.

/* Sorting one line is really quick! */

if (count <= 1)

return;

if (u_save((linenr_T)(eap->line1 - 1), (linenr_T)(eap->line2 + 1)) == FAIL)

return;

sortbuf1 = NULL;

sortbuf2 = NULL;

regmatch.regprog = NULL;

nrs = (sorti_T *)lalloc((long_u)(count * sizeof(sorti_T)), TRUE);

if (nrs == NULL)

goto sortend;

sort_abort = sort_ic = sort_rx = sort_nr = 0;

#ifdef FEAT_FLOAT

sort_flt = 0;

#endif

for (p = eap->arg; *p != NUL; ++p)

{

if (VIM_ISWHITE(*p))

;

else if (*p == 'i')

sort_ic = TRUE;

else if (*p == 'r')

sort_rx = TRUE;

else if (*p == 'n')

{

sort_nr = 1;

++format_found;

}

#ifdef FEAT_FLOAT

else if (*p == 'f')

{

sort_flt = 1;

++format_found;

}

#endif

else if (*p == 'b')

{

sort_what = STR2NR_BIN + STR2NR_FORCE;

++format_found;

}

else if (*p == 'o')

{

sort_what = STR2NR_OCT + STR2NR_FORCE;

++format_found;

}

else if (*p == 'x')

{

sort_what = STR2NR_HEX + STR2NR_FORCE;

++format_found;

}

else if (*p == 'u')

unique = TRUE;

else if (*p == '"') /* comment start */

break;

else if (check_nextcmd(p) != NULL)

{

eap->nextcmd = check_nextcmd(p);

break;

}

else if (!ASCII_ISALPHA(*p) && regmatch.regprog == NULL)

{

s = skip_regexp(p + 1, *p, TRUE, NULL);

if (*s != *p)

{

EMSG(_(e_invalpat));

goto sortend;

}

*s = NUL;

/* Use last search pattern if sort pattern is empty. */

if (s == p + 1)

{

if (last_search_pat() == NULL)

{

EMSG(_(e_noprevre));

goto sortend;

}

regmatch.regprog = vim_regcomp(last_search_pat(), RE_MAGIC);

}

else

regmatch.regprog = vim_regcomp(p + 1, RE_MAGIC);

if (regmatch.regprog == NULL)

goto sortend;

p = s; /* continue after the regexp */

regmatch.rm_ic = p_ic;

}

else

{

EMSG2(_(e_invarg2), p);

goto sortend;

}

}

/* Can only have one of 'n', 'b', 'o' and 'x'. */

if (format_found > 1)

{

EMSG(_(e_invarg));

goto sortend;

}

/* From here on "sort_nr" is used as a flag for any integer number

* sorting. */

sort_nr += sort_what;

/*

* Make an array with all line numbers. This avoids having to copy all

* the lines into allocated memory.

* When sorting on strings "start_col_nr" is the offset in the line, for

* numbers sorting it's the number to sort on. This means the pattern

* matching and number conversion only has to be done once per line.

* Also get the longest line length for allocating "sortbuf".

*/

for (lnum = eap->line1; lnum <= eap->line2; ++lnum)

{

s = ml_get(lnum);

len = (int)STRLEN(s);

if (maxlen < len)

maxlen = len;

start_col = 0;

end_col = len;

if (regmatch.regprog != NULL && vim_regexec(&regmatch, s, 0))

{

if (sort_rx)

{

start_col = (colnr_T)(regmatch.startp[0] - s);

end_col = (colnr_T)(regmatch.endp[0] - s);

}

else

start_col = (colnr_T)(regmatch.endp[0] - s);

}

else

if (regmatch.regprog != NULL)

end_col = 0;

if (sort_nr

#ifdef FEAT_FLOAT

|| sort_flt

#endif

)

{

/* Make sure vim_str2nr doesn't read any digits past the end

* of the match, by temporarily terminating the string there */

s2 = s + end_col;

c = *s2;

*s2 = NUL;

/* Sorting on number: Store the number itself. */

p = s + start_col;

if (sort_nr)

{

if (sort_what & STR2NR_HEX)

s = skiptohex(p);

else if (sort_what & STR2NR_BIN)

s = skiptobin(p);

else

s = skiptodigit(p);

if (s > p && s[-1] == '-')

--s; /* include preceding negative sign */

if (*s == NUL)

/* empty line should sort before any number */

nrs[lnum - eap->line1].st_u.value = -MAXLNUM;

else

vim_str2nr(s, NULL, NULL, sort_what,

&nrs[lnum - eap->line1].st_u.value, NULL, 0);

}

#ifdef FEAT_FLOAT

else

{

s = skipwhite(p);

if (*s == '+')

s = skipwhite(s + 1);

if (*s == NUL)

/* empty line should sort before any number */

nrs[lnum - eap->line1].st_u.value_flt = -DBL_MAX;

else

nrs[lnum - eap->line1].st_u.value_flt =

strtod((char *)s, NULL);

}

#endif

*s2 = c;

}

else

{

/* Store the column to sort at. */

nrs[lnum - eap->line1].st_u.line.start_col_nr = start_col;

nrs[lnum - eap->line1].st_u.line.end_col_nr = end_col;

}

nrs[lnum - eap->line1].lnum = lnum;

if (regmatch.regprog != NULL)

fast_breakcheck();

if (got_int)

goto sortend;

}

/* Allocate a buffer that can hold the longest line. */

sortbuf1 = alloc((unsigned)maxlen + 1);

if (sortbuf1 == NULL)

goto sortend;

sortbuf2 = alloc((unsigned)maxlen + 1);

if (sortbuf2 == NULL)

goto sortend;

/* Sort the array of line numbers. Note: can't be interrupted! */

qsort((void *)nrs, count, sizeof(sorti_T), sort_compare);

if (sort_abort)

goto sortend;

/* Insert the lines in the sorted order below the last one. */

lnum = eap->line2;

for (i = 0; i < count; ++i)

{

linenr_T get_lnum = nrs[eap->forceit ? count - i - 1 : i].lnum;

// If the original line number of the line being placed is not the same

// as "lnum" (accounting for offset), we know that the buffer changed.

if (get_lnum + ((linenr_T)count - 1) != lnum)

change_occurred = TRUE;

s = ml_get(get_lnum);

if (!unique || i == 0

|| (sort_ic ? STRICMP(s, sortbuf1) : STRCMP(s, sortbuf1)) != 0)

{

// Copy the line into a buffer, it may become invalid in

// ml_append(). And it's needed for "unique".

STRCPY(sortbuf1, s);

if (ml_append(lnum++, sortbuf1, (colnr_T)0, FALSE) == FAIL)

break;

}

fast_breakcheck();

if (got_int)

goto sortend;

}

/* delete the original lines if appending worked */

if (i == count)

for (i = 0; i < count; ++i)

ml_delete(eap->line1, FALSE);

else

count = 0;

/* Adjust marks for deleted (or added) lines and prepare for displaying. */

deleted = (long)(count - (lnum - eap->line2));

if (deleted > 0)

mark_adjust(eap->line2 - deleted, eap->line2, (long)MAXLNUM, -deleted);

else if (deleted < 0)

mark_adjust(eap->line2, MAXLNUM, -deleted, 0L);

if (change_occurred || deleted != 0)

changed_lines(eap->line1, 0, eap->line2 + 1, -deleted);

curwin->w_cursor.lnum = eap->line1;

beginline(BL_WHITE | BL_FIX);

sortend:

vim_free(nrs);

vim_free(sortbuf1);

vim_free(sortbuf2);

vim_regfree(regmatch.regprog);

if (got_int)

EMSG(_(e_interr));

}

/*

* ":retab".

*/

void

ex_retab(exarg_T *eap)

{

linenr_T lnum;

int got_tab = FALSE;

long num_spaces = 0;

long num_tabs;

long len;

long col;

long vcol;

long start_col = 0; /* For start of white-space string */

long start_vcol = 0; /* For start of white-space string */

long old_len;

char_u *ptr;

char_u *new_line = (char_u *)1; /* init to non-NULL */

int did_undo; /* called u_save for current line */

#ifdef FEAT_VARTABS

int *new_vts_array = NULL;

char_u *new_ts_str; /* string value of tab argument */

#else

int temp;

int new_ts;

#endif

int save_list;

linenr_T first_line = 0; /* first changed line */

linenr_T last_line = 0; /* last changed line */

save_list = curwin->w_p_list;

curwin->w_p_list = 0; /* don't want list mode here */

#ifdef FEAT_VARTABS

new_ts_str = eap->arg;

if (!tabstop_set(eap->arg, &new_vts_array))

return;

while (vim_isdigit(*(eap->arg)) || *(eap->arg) == ',')

++(eap->arg);

// This ensures that either new_vts_array and new_ts_str are freshly

// allocated, or new_vts_array points to an existing array and new_ts_str

// is null.

if (new_vts_array == NULL)

{

new_vts_array = curbuf->b_p_vts_array;

new_ts_str = NULL;

}

else

new_ts_str = vim_strnsave(new_ts_str, eap->arg - new_ts_str);

#else

new_ts = getdigits(&(eap->arg));

if (new_ts < 0)

{

EMSG(_(e_positive));

return;

}

if (new_ts == 0)

new_ts = curbuf->b_p_ts;

#endif

for (lnum = eap->line1; !got_int && lnum <= eap->line2; ++lnum)

{

ptr = ml_get(lnum);

col = 0;

vcol = 0;

did_undo = FALSE;

for (;;)

{

if (VIM_ISWHITE(ptr[col]))

{

if (!got_tab && num_spaces == 0)

{

/* First consecutive white-space */

start_vcol = vcol;

start_col = col;

}

if (ptr[col] == ' ')

num_spaces++;

else

got_tab = TRUE;

}

else

{

if (got_tab || (eap->forceit && num_spaces > 1))

{

/* Retabulate this string of white-space */

/* len is virtual length of white string */

len = num_spaces = vcol - start_vcol;

num_tabs = 0;

if (!curbuf->b_p_et)

{

#ifdef FEAT_VARTABS

int t, s;

tabstop_fromto(start_vcol, vcol,

curbuf->b_p_ts, new_vts_array, &t, &s);

num_tabs = t;

num_spaces = s;

#else

temp = new_ts - (start_vcol % new_ts);

if (num_spaces >= temp)

{

num_spaces -= temp;

num_tabs++;

}

num_tabs += num_spaces / new_ts;

num_spaces -= (num_spaces / new_ts) * new_ts;

#endif

}

if (curbuf->b_p_et || got_tab ||

(num_spaces + num_tabs < len))

{

if (did_undo == FALSE)

{

did_undo = TRUE;

if (u_save((linenr_T)(lnum - 1),

(linenr_T)(lnum + 1)) == FAIL)

{

new_line = NULL; /* flag out-of-memory */

break;

}

}

/* len is actual number of white characters used */

len = num_spaces + num_tabs;

old_len = (long)STRLEN(ptr);

new_line = lalloc(old_len - col + start_col + len + 1,

TRUE);

if (new_line == NULL)

break;

if (start_col > 0)

mch_memmove(new_line, ptr, (size_t)start_col);

mch_memmove(new_line + start_col + len,

ptr + col, (size_t)(old_len - col + 1));

ptr = new_line + start_col;

for (col = 0; col < len; col++)

ptr[col] = (col < num_tabs) ? '\t' : ' ';

ml_replace(lnum, new_line, FALSE);

if (first_line == 0)

first_line = lnum;

last_line = lnum;

ptr = new_line;

col = start_col + len;

}

}

got_tab = FALSE;

num_spaces = 0;

}

if (ptr[col] == NUL)

break;

vcol += chartabsize(ptr + col, (colnr_T)vcol);

#ifdef FEAT_MBYTE

if (has_mbyte)

col += (*mb_ptr2len)(ptr + col);

else

#endif

++col;

}

if (new_line == NULL) /* out of memory */

break;

line_breakcheck();

}

if (got_int)

EMSG(_(e_interr));

#ifdef FEAT_VARTABS

// If a single value was given then it can be considered equal to

// either the value of 'tabstop' or the value of 'vartabstop'.

if (tabstop_count(curbuf->b_p_vts_array) == 0

&& tabstop_count(new_vts_array) == 1

&& curbuf->b_p_ts == tabstop_first(new_vts_array))

; /* not changed */

else if (tabstop_count(curbuf->b_p_vts_array) > 0

&& tabstop_eq(curbuf->b_p_vts_array, new_vts_array))

; /* not changed */

else

redraw_curbuf_later(NOT_VALID);

#else

if (curbuf->b_p_ts != new_ts)

redraw_curbuf_later(NOT_VALID);

#endif

if (first_line != 0)

changed_lines(first_line, 0, last_line + 1, 0L);

curwin->w_p_list = save_list; /* restore 'list' */

#ifdef FEAT_VARTABS

if (new_ts_str != NULL) /* set the new tabstop */

{

// If 'vartabstop' is in use or if the value given to retab has more

// than one tabstop then update 'vartabstop'.

int *old_vts_ary = curbuf->b_p_vts_array;

if (tabstop_count(old_vts_ary) > 0 || tabstop_count(new_vts_array) > 1)

{

set_string_option_direct((char_u *)"vts", -1, new_ts_str,

OPT_FREE|OPT_LOCAL, 0);

curbuf->b_p_vts_array = new_vts_array;

vim_free(old_vts_ary);

}

else

{

// 'vartabstop' wasn't in use and a single value was given to

// retab then update 'tabstop'.

curbuf->b_p_ts = tabstop_first(new_vts_array);

vim_free(new_vts_array);

}

vim_free(new_ts_str);

}

#else

curbuf->b_p_ts = new_ts;

#endif

coladvance(curwin->w_curswant);

u_clearline();

}

/*

* :move command - move lines line1-line2 to line dest

*

* return FAIL for failure, OK otherwise

*/

int

do_move(linenr_T line1, linenr_T line2, linenr_T dest)

{

char_u *str;

linenr_T l;

linenr_T extra; /* Num lines added before line1 */

linenr_T num_lines; /* Num lines moved */

linenr_T last_line; /* Last line in file after adding new text */

#ifdef FEAT_FOLDING

win_T *win;

tabpage_T *tp;

#endif

if (dest >= line1 && dest < line2)

{

EMSG(_("E134: Move lines into themselves"));

return FAIL;

}

num_lines = line2 - line1 + 1;

/*

* First we copy the old text to its new location -- webb

* Also copy the flag that ":global" command uses.

*/

if (u_save(dest, dest + 1) == FAIL)

return FAIL;

for (extra = 0, l = line1; l <= line2; l++)

{

str = vim_strsave(ml_get(l + extra));

if (str != NULL)

{

ml_append(dest + l - line1, str, (colnr_T)0, FALSE);

vim_free(str);

if (dest < line1)

extra++;

}

}

/*

* Now we must be careful adjusting our marks so that we don't overlap our

* mark_adjust() calls.

*

* We adjust the marks within the old text so that they refer to the

* last lines of the file (temporarily), because we know no other marks

* will be set there since these line numbers did not exist until we added

* our new lines.

*

* Then we adjust the marks on lines between the old and new text positions

* (either forwards or backwards).

*

* And Finally we adjust the marks we put at the end of the file back to

* their final destination at the new text position -- webb

*/

last_line = curbuf->b_ml.ml_line_count;

mark_adjust_nofold(line1, line2, last_line - line2, 0L);

if (dest >= line2)

{

mark_adjust_nofold(line2 + 1, dest, -num_lines, 0L);

#ifdef FEAT_FOLDING

FOR_ALL_TAB_WINDOWS(tp, win) {

if (win->w_buffer == curbuf)

foldMoveRange(&win->w_folds, line1, line2, dest);

}

#endif

curbuf->b_op_start.lnum = dest - num_lines + 1;

curbuf->b_op_end.lnum = dest;

}

else

{

mark_adjust_nofold(dest + 1, line1 - 1, num_lines, 0L);

#ifdef FEAT_FOLDING

FOR_ALL_TAB_WINDOWS(tp, win) {

if (win->w_buffer == curbuf)

foldMoveRange(&win->w_folds, dest + 1, line1 - 1, line2);

}

#endif

curbuf->b_op_start.lnum = dest + 1;

curbuf->b_op_end.lnum = dest + num_lines;

}

curbuf->b_op_start.col = curbuf->b_op_end.col = 0;

mark_adjust_nofold(last_line - num_lines + 1, last_line,

-(last_line - dest - extra), 0L);

/*

* Now we delete the original text -- webb

*/

if (u_save(line1 + extra - 1, line2 + extra + 1) == FAIL)

return FAIL;

for (l = line1; l <= line2; l++)

ml_delete(line1 + extra, TRUE);

if (!global_busy && num_lines > p_report)

{

if (num_lines == 1)

MSG(_("1 line moved"));

else

smsg((char_u *)_("%ld lines moved"), num_lines);

}

/*

* Leave the cursor on the last of the moved lines.

*/

if (dest >= line1)

curwin->w_cursor.lnum = dest;

else