static int list_insert_tv __ARGS((list_T *l, typval_T *tv, listitem_T *item));
static int list_extend __ARGS((list_T *l1, list_T *l2, listitem_T *bef));
static int list_concat __ARGS((list_T *l1, list_T *l2, typval_T *tv));
-static list_T *list_copy __ARGS((list_T *orig, int deep));
+static list_T *list_copy __ARGS((list_T *orig, int deep, int copyID));
static void list_remove __ARGS((list_T *l, listitem_T *item, listitem_T *item2));
static char_u *list2string __ARGS((typval_T *tv));
-static void list_join __ARGS((garray_T *gap, list_T *l, char_u *sep, int echo));
+static int list_join __ARGS((garray_T *gap, list_T *l, char_u *sep, int echo));
static dict_T *dict_alloc __ARGS((void));
static void dict_unref __ARGS((dict_T *d));
static dictitem_T *dictitem_copy __ARGS((dictitem_T *org));
static void dictitem_remove __ARGS((dict_T *dict, dictitem_T *item));
static void dictitem_free __ARGS((dictitem_T *item));
+static dict_T *dict_copy __ARGS((dict_T *orig, int deep, int copyID));
static int dict_add __ARGS((dict_T *d, dictitem_T *item));
static long dict_len __ARGS((dict_T *d));
static dictitem_T *dict_find __ARGS((dict_T *d, char_u *key, int len));
static char_u *deref_func_name __ARGS((char_u *name, int *lenp));
static int get_func_tv __ARGS((char_u *name, int len, typval_T *rettv, char_u **arg, linenr_T firstline, linenr_T lastline, int *doesrange, int evaluate, dict_T *selfdict));
static int call_func __ARGS((char_u *name, int len, typval_T *rettv, int argcount, typval_T *argvars, linenr_T firstline, linenr_T lastline, int *doesrange, int evaluate, dict_T *selfdict));
+static void emsg_funcname __ARGS((char *msg, char_u *name));
static void f_add __ARGS((typval_T *argvars, typval_T *rettv));
static void f_append __ARGS((typval_T *argvars, typval_T *rettv));
static int var_check_ro __ARGS((int flags, char_u *name));
static int tv_check_lock __ARGS((int lock, char_u *name));
static void copy_tv __ARGS((typval_T *from, typval_T *to));
-static void item_copy __ARGS((typval_T *from, typval_T *to, int deep));
+static int item_copy __ARGS((typval_T *from, typval_T *to, int deep, int copyID));
static char_u *find_option_end __ARGS((char_u **arg, int *opt_flags));
static char_u *trans_function_name __ARGS((char_u **pp, int skip, int flags, funcdict_T *fd));
static int eval_fname_script __ARGS((char_u *p));
if (*startarg != '(')
{
- if (*name == K_SPECIAL)
- EMSG2(_("E107: Missing braces: <SNR>%s"), name + 3);
- else
- EMSG2(_("E107: Missing braces: %s"), name);
+ EMSG2(_("E107: Missing braces: %s"), eap->arg);
goto end;
}
list_T *l;
/* make a copy of the first list. */
- l = list_copy(l1, FALSE);
+ l = list_copy(l1, FALSE, 0);
if (l == NULL)
return FAIL;
tv->v_type = VAR_LIST;
/*
* Make a copy of list "orig". Shallow if "deep" is FALSE.
* The refcount of the new list is set to 1.
+ * See item_copy() for "copyID".
* Returns NULL when out of memory.
*/
static list_T *
-list_copy(orig, deep)
+list_copy(orig, deep, copyID)
list_T *orig;
int deep;
+ int copyID;
{
list_T *copy;
listitem_T *item;
copy = list_alloc();
if (copy != NULL)
{
- for (item = orig->lv_first; item != NULL; item = item->li_next)
+ if (copyID != 0)
+ {
+ /* Do this before adding the items, because one of the items may
+ * refer back to this list. */
+ orig->lv_copyID = copyID;
+ orig->lv_copylist = copy;
+ }
+ for (item = orig->lv_first; item != NULL && !got_int;
+ item = item->li_next)
{
ni = listitem_alloc();
if (ni == NULL)
break;
if (deep)
- item_copy(&item->li_tv, &ni->li_tv, deep);
+ {
+ if (item_copy(&item->li_tv, &ni->li_tv, deep, copyID) == FAIL)
+ {
+ vim_free(ni);
+ break;
+ }
+ }
else
copy_tv(&item->li_tv, &ni->li_tv);
list_append(copy, ni);
}
++copy->lv_refcount;
+ if (item != NULL)
+ {
+ list_unref(copy);
+ copy = NULL;
+ }
}
return copy;
return NULL;
ga_init2(&ga, (int)sizeof(char), 80);
ga_append(&ga, '[');
- list_join(&ga, tv->vval.v_list, (char_u *)", ", FALSE);
+ if (list_join(&ga, tv->vval.v_list, (char_u *)", ", FALSE) == FAIL)
+ {
+ vim_free(ga.ga_data);
+ return NULL;
+ }
ga_append(&ga, ']');
ga_append(&ga, NUL);
return (char_u *)ga.ga_data;
/*
* Join list "l" into a string in "*gap", using separator "sep".
* When "echo" is TRUE use String as echoed, otherwise as inside a List.
+ * Return FAIL or OK.
*/
- static void
+ static int
list_join(gap, l, sep, echo)
garray_T *gap;
list_T *l;
listitem_T *item;
char_u *s;
- for (item = l->lv_first; item != NULL; item = item->li_next)
+ for (item = l->lv_first; item != NULL && !got_int; item = item->li_next)
{
if (first)
first = FALSE;
if (s != NULL)
ga_concat(gap, s);
vim_free(tofree);
+ if (s == NULL)
+ return FAIL;
}
+ return OK;
}
/*
hash_init(&d->dv_hashtab);
d->dv_lock = 0;
d->dv_refcount = 0;
+ d->dv_copyID = 0;
}
return d;
}
/*
* Make a copy of dict "d". Shallow if "deep" is FALSE.
* The refcount of the new dict is set to 1.
+ * See item_copy() for "copyID".
* Returns NULL when out of memory.
*/
static dict_T *
-dict_copy(orig, deep)
+dict_copy(orig, deep, copyID)
dict_T *orig;
int deep;
+ int copyID;
{
dict_T *copy;
dictitem_T *di;
copy = dict_alloc();
if (copy != NULL)
{
+ if (copyID != 0)
+ {
+ orig->dv_copyID = copyID;
+ orig->dv_copydict = copy;
+ }
todo = orig->dv_hashtab.ht_used;
- for (hi = orig->dv_hashtab.ht_array; todo > 0; ++hi)
+ for (hi = orig->dv_hashtab.ht_array; todo > 0 && !got_int; ++hi)
{
if (!HASHITEM_EMPTY(hi))
{
if (di == NULL)
break;
if (deep)
- item_copy(&HI2DI(hi)->di_tv, &di->di_tv, deep);
+ {
+ if (item_copy(&HI2DI(hi)->di_tv, &di->di_tv, deep,
+ copyID) == FAIL)
+ {
+ vim_free(di);
+ break;
+ }
+ }
else
copy_tv(&HI2DI(hi)->di_tv, &di->di_tv);
if (dict_add(copy, di) == FAIL)
}
++copy->dv_refcount;
+ if (todo > 0)
+ {
+ dict_unref(copy);
+ copy = NULL;
+ }
}
return copy;
ga_append(&ga, '{');
todo = d->dv_hashtab.ht_used;
- for (hi = d->dv_hashtab.ht_array; todo > 0; ++hi)
+ for (hi = d->dv_hashtab.ht_array; todo > 0 && !got_int; ++hi)
{
if (!HASHITEM_EMPTY(hi))
{
if (s != NULL)
ga_concat(&ga, s);
vim_free(tofree);
+ if (s == NULL)
+ break;
}
}
+ if (todo > 0)
+ {
+ vim_free(ga.ga_data);
+ return NULL;
+ }
ga_append(&ga, '}');
ga_append(&ga, NUL);
{"count", 2, 4, f_count},
{"cscope_connection",0,3, f_cscope_connection},
{"cursor", 2, 2, f_cursor},
- {"deepcopy", 1, 1, f_deepcopy},
+ {"deepcopy", 1, 2, f_deepcopy},
{"delete", 1, 1, f_delete},
{"did_filetype", 0, 0, f_did_filetype},
{"diff_filler", 1, 1, f_diff_filler},
else if (!aborting())
{
if (argcount == MAX_FUNC_ARGS)
- EMSG2(_("E740: Too many arguments for function %s"), name);
+ emsg_funcname("E740: Too many arguments for function %s", name);
else
- EMSG2(_("E116: Invalid arguments for function %s"), name);
+ emsg_funcname("E116: Invalid arguments for function %s", name);
}
while (--argcount >= 0)
switch (error)
{
case ERROR_UNKNOWN:
- EMSG2(_("E117: Unknown function: %s"), name);
+ emsg_funcname("E117: Unknown function: %s", name);
break;
case ERROR_TOOMANY:
- EMSG2(_(e_toomanyarg), name);
+ emsg_funcname(e_toomanyarg, name);
break;
case ERROR_TOOFEW:
- EMSG2(_("E119: Not enough arguments for function: %s"),
+ emsg_funcname("E119: Not enough arguments for function: %s",
name);
break;
case ERROR_SCRIPT:
- EMSG2(_("E120: Using <SID> not in a script context: %s"),
+ emsg_funcname("E120: Using <SID> not in a script context: %s",
name);
break;
case ERROR_DICT:
- EMSG2(_("E725: Calling dict function without Dictionary: %s"),
+ emsg_funcname("E725: Calling dict function without Dictionary: %s",
name);
break;
}
return ret;
}
+/*
+ * Give an error message with a function name. Handle <SNR> things.
+ */
+ static void
+emsg_funcname(msg, name)
+ char *msg;
+ char_u *name;
+{
+ char_u *p;
+
+ if (*name == K_SPECIAL)
+ p = concat_str((char_u *)"<SNR>", name + 3);
+ else
+ p = name;
+ EMSG2(_(msg), p);
+ if (p != name)
+ vim_free(p);
+}
+
/*********************************************
* Implementation of the built-in functions
*/
typval_T *argvars;
typval_T *rettv;
{
- item_copy(&argvars[0], rettv, FALSE);
+ item_copy(&argvars[0], rettv, FALSE, 0);
}
/*
typval_T *argvars;
typval_T *rettv;
{
- item_copy(&argvars[0], rettv, TRUE);
+ static int copyID = 0;
+ int noref = 0;
+
+ if (argvars[1].v_type != VAR_UNKNOWN)
+ noref = get_tv_number(&argvars[1]);
+ if (noref < 0 || noref > 1)
+ EMSG(_(e_invarg));
+ else
+ item_copy(&argvars[0], rettv, TRUE, noref == 0 ? ++copyID : 0);
}
/*
char_u *save_cpo;
long start = 0;
long nth = 1;
- int match;
+ int match = 0;
list_T *l = NULL;
listitem_T *li = NULL;
long idx = 0;
}
vim_free(tofree);
str = echo_string(&li->li_tv, &tofree, strbuf);
+ if (str == NULL)
+ break;
}
match = vim_regexec_nl(®match, str, (colnr_T)0);
&& !tv_check_lock(l->lv_lock, (char_u *)"reverse()"))
{
li = l->lv_last;
- l->lv_first = l->lv_last = li;
+ l->lv_first = l->lv_last = NULL;
l->lv_len = 0;
while (li != NULL)
{
}
if (function_exists(name))
{
- EMSG2(_("705: Variable name conflicts with existing function: %s"), name);
+ EMSG2(_("705: Variable name conflicts with existing function: %s"),
+ name);
return;
}
}
/*
* Make a copy of an item.
* Lists and Dictionaries are also copied. A deep copy if "deep" is set.
+ * For deepcopy() "copyID" is zero for a full copy or the ID for when a
+ * reference to an already copied list/dict can be used.
+ * Returns FAIL or OK.
*/
- static void
-item_copy(from, to, deep)
+ static int
+item_copy(from, to, deep, copyID)
typval_T *from;
typval_T *to;
int deep;
+ int copyID;
{
static int recurse = 0;
+ int ret = OK;
if (recurse >= DICT_MAXNEST)
{
EMSG(_("E698: variable nested too deep for making a copy"));
- return;
+ return FAIL;
}
++recurse;
case VAR_LIST:
to->v_type = VAR_LIST;
to->v_lock = 0;
- to->vval.v_list = list_copy(from->vval.v_list, deep);
+ if (from->vval.v_list == NULL)
+ to->vval.v_list = NULL;
+ else if (copyID != 0 && from->vval.v_list->lv_copyID == copyID)
+ {
+ /* use the copy made earlier */
+ to->vval.v_list = from->vval.v_list->lv_copylist;
+ ++to->vval.v_list->lv_refcount;
+ }
+ else
+ to->vval.v_list = list_copy(from->vval.v_list, deep, copyID);
+ if (to->vval.v_list == NULL)
+ ret = FAIL;
break;
case VAR_DICT:
to->v_type = VAR_DICT;
to->v_lock = 0;
- to->vval.v_dict = dict_copy(from->vval.v_dict, deep);
+ if (from->vval.v_dict == NULL)
+ to->vval.v_dict = NULL;
+ else if (copyID != 0 && from->vval.v_dict->dv_copyID == copyID)
+ {
+ /* use the copy made earlier */
+ to->vval.v_dict = from->vval.v_dict->dv_copydict;
+ ++to->vval.v_dict->dv_refcount;
+ }
+ else
+ to->vval.v_dict = dict_copy(from->vval.v_dict, deep, copyID);
+ if (to->vval.v_dict == NULL)
+ ret = FAIL;
break;
default:
EMSG2(_(e_intern2), "item_copy()");
+ ret = FAIL;
}
--recurse;
+ return ret;
}
/*
}
else if (eap->cmdidx == CMD_echo)
msg_puts_attr((char_u *)" ", echo_attr);
- for (p = echo_string(&rettv, &tofree, numbuf);
- *p != NUL && !got_int; ++p)
- if (*p == '\n' || *p == '\r' || *p == TAB)
+ p = echo_string(&rettv, &tofree, numbuf);
+ if (p != NULL)
+ for ( ; *p != NUL && !got_int; ++p)
{
- if (*p != TAB && needclr)
+ if (*p == '\n' || *p == '\r' || *p == TAB)
{
- /* remove any text still there from the command */
- msg_clr_eos();
- needclr = FALSE;
+ if (*p != TAB && needclr)
+ {
+ /* remove any text still there from the command */
+ msg_clr_eos();
+ needclr = FALSE;
+ }
+ msg_putchar_attr(*p, echo_attr);
}
- msg_putchar_attr(*p, echo_attr);
- }
- else
- {
-#ifdef FEAT_MBYTE
- if (has_mbyte)
+ else
{
- int i = (*mb_ptr2len_check)(p);
+#ifdef FEAT_MBYTE
+ if (has_mbyte)
+ {
+ int i = (*mb_ptr2len_check)(p);
- (void)msg_outtrans_len_attr(p, i, echo_attr);
- p += i - 1;
- }
- else
+ (void)msg_outtrans_len_attr(p, i, echo_attr);
+ p += i - 1;
+ }
+ else
#endif
- (void)msg_outtrans_len_attr(p, 1, echo_attr);
+ (void)msg_outtrans_len_attr(p, 1, echo_attr);
+ }
}
vim_free(tofree);
}
}
}
else
- EMSG2(_("E123: Undefined function: %s"), name);
+ emsg_funcname("E123: Undefined function: %s", name);
}
goto ret_free;
}
if (fudi.fd_dict != NULL && fudi.fd_newkey == NULL)
EMSG(_(e_funcdict));
else if (name != NULL && find_func(name) != NULL)
- EMSG2(_(e_funcexts), name);
+ emsg_funcname(e_funcexts, name);
}
msg_putchar('\n'); /* don't overwrite the function name */
v = find_var(name, NULL);
if (v != NULL && v->di_tv.v_type == VAR_FUNC)
{
- EMSG2(_("E707: Function name conflicts with variable: %s"), name);
+ emsg_funcname("E707: Function name conflicts with variable: %s",
+ name);
goto erret;
}
{
if (!eap->forceit)
{
- EMSG2(_(e_funcexts), name);
+ emsg_funcname(e_funcexts, name);
goto erret;
}
if (fp->calls > 0)
{
- EMSG2(_("E127: Cannot redefine function %s: It is in use"),
+ emsg_funcname("E127: Cannot redefine function %s: It is in use",
name);
goto erret;
}
get_return_cmd(rettv)
void *rettv;
{
- char_u *s;
+ char_u *s = NULL;
char_u *tofree = NULL;
char_u numbuf[NUMBUFLEN];
- if (rettv == NULL)
- s = (char_u *)"";
- else
+ if (rettv != NULL)
s = echo_string((typval_T *)rettv, &tofree, numbuf);
+ if (s == NULL)
+ s = (char_u *)"";
STRCPY(IObuff, ":return ");
STRNCPY(IObuff + 8, s, IOSIZE - 8);
dictitem_T *this_var;
int todo;
char *s;
+ char_u *p;
char_u *tofree;
char_u numbuf[NUMBUFLEN];
default: continue;
}
fprintf(fp, "!%s\t%s\t", this_var->di_key, s);
- viminfo_writestring(fp, echo_string(&this_var->di_tv,
- &tofree, numbuf));
+ p = echo_string(&this_var->di_tv, &tofree, numbuf);
+ if (p != NULL)
+ viminfo_writestring(fp, p);
vim_free(tofree);
}
}
char_u *theline;
int did_undo = FALSE;
linenr_T lnum = eap->line2;
+ int indent = 0;
+ char_u *p;
+ int vcol;
+ int empty = (curbuf->b_ml.ml_flags & ML_EMPTY);
if (eap->cmdidx != CMD_append)
--lnum;
+ /* when the buffer is empty append to line 0 and delete the dummy line */
+ if (empty && lnum == 1)
+ lnum = 0;
+
State = INSERT; /* behave like in Insert mode */
if (curbuf->b_p_iminsert == B_IMODE_LMAP)
State |= LANGMAP;
+
while (1)
{
msg_scroll = TRUE;
need_wait_return = FALSE;
+ if (curbuf->b_p_ai && lnum > 0)
+ indent = get_indent_lnum(lnum);
if (eap->getline == NULL)
theline = getcmdline(
#ifdef FEAT_EVAL
eap->cstack->cs_looplevel > 0 ? -1 :
#endif
- NUL, 0L, 0);
+ NUL, 0L, indent);
else
theline = eap->getline(
#ifdef FEAT_EVAL
eap->cstack->cs_looplevel > 0 ? -1 :
#endif
- NUL, eap->cookie, 0);
+ NUL, eap->cookie, indent);
lines_left = Rows - 1;
- if (theline == NULL || (theline[0] == '.' && theline[1] == NUL)
- || (!did_undo && u_save(lnum, lnum + 1) == FAIL))
+ if (theline == NULL)
+ break;
+
+ /* Look for the "." after automatic indent. */
+ vcol = 0;
+ for (p = theline; indent > vcol; ++p)
+ {
+ if (*p == ' ')
+ ++vcol;
+ else if (*p == TAB)
+ vcol += 8 - vcol % 8;
+ else
+ break;
+ }
+ if ((p[0] == '.' && p[1] == NUL)
+ || (!did_undo && u_save(lnum, lnum + 1) == FAIL))
{
vim_free(theline);
break;
vim_free(theline);
++lnum;
msg_didout = TRUE; /* also scroll for empty line */
+
+ if (empty)
+ {
+ ml_delete(2L, FALSE);
+ empty = FALSE;
+ }
}
State = NORMAL;
exarg_T *eap;
{
char_u *x;
- int bigness = curwin->w_height - 3;
- char_u kind;
+ int bigness;
+ char_u *kind;
int numbered = FALSE;
int minus = 0;
linenr_T start, end, curs, i;
int j;
linenr_T lnum = eap->line2;
+ /* Vi compatible: ":z!" uses display height, without a count uses
+ * 'scroll' */
+ if (eap->forceit)
+ bigness = curwin->w_height;
+ else if (firstwin == lastwin)
+ bigness = curwin->w_p_scr * 2;
+ else
+ bigness = curwin->w_height - 3;
if (bigness < 1)
bigness = 1;
++x;
}
- kind = *x;
- if (kind == '-' || kind == '+' || kind == '=' || kind == '^' || kind == '.')
+ kind = x;
+ if (*kind == '-' || *kind == '+' || *kind == '='
+ || *kind == '^' || *kind == '.')
+ ++x;
+ while (*x == '-' || *x == '+')
++x;
if (*x != 0)
return;
}
else
+ {
bigness = atoi((char *)x);
+ p_window = bigness;
+ }
}
- switch (kind)
+ /* the number of '-' and '+' multiplies the distance */
+ if (*kind == '-' || *kind == '+')
+ for (x = kind + 1; *x == *kind; ++x)
+ ;
+
+ switch (*kind)
{
case '-':
- start = lnum - bigness;
- end = lnum;
- curs = lnum;
+ start = lnum - bigness * (x - kind);
+ end = start + bigness;
+ curs = end;
break;
case '=':
default: /* '+' */
start = lnum;
- end = lnum + bigness;
+ if (*kind == '+')
+ start += bigness * (x - kind - 1);
+ end = start + bigness;
curs = end;
break;
}
int which_pat;
char_u *cmd;
int save_State;
- linenr_T first_line = 0; /* first changed line */
- linenr_T last_line= 0; /* below last changed line AFTER the
+ linenr_T first_line = 0; /* first changed line */
+ linenr_T last_line= 0; /* below last changed line AFTER the
* change */
linenr_T old_line_count = curbuf->b_ml.ml_line_count;
linenr_T line2;
- long nmatch; /* number of lines in match */
- linenr_T sub_firstlnum; /* nr of first sub line */
- char_u *sub_firstline; /* allocated copy of first sub line */
- int endcolumn; /* put cursor in last column when done */
+ long nmatch; /* number of lines in match */
+ linenr_T sub_firstlnum; /* nr of first sub line */
+ char_u *sub_firstline; /* allocated copy of first sub line */
+ int endcolumn = FALSE; /* cursor in last column when done */
cmd = eap->arg;
if (!global_busy)
projects / vim / commitdiff