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

*/

/*

* eval.c: Expression evaluation.

*/

#define USING_FLOAT_STUFF

#include "vim.h"

#if defined(FEAT_EVAL) || defined(PROTO)

#ifdef VMS

# include <float.h>

#endif

static char *e_missbrac = N_("E111: Missing ']'");

static char *e_dictrange = N_("E719: Cannot use [:] with a Dictionary");

#ifdef FEAT_FLOAT

static char *e_float_as_string = N_("E806: using Float as a String");

#endif

static char *e_nowhitespace = N_("E274: No white space allowed before parenthesis");

#define NAMESPACE_CHAR (char_u *)"abglstvw"

/*

* When recursively copying lists and dicts we need to remember which ones we

* have done to avoid endless recursiveness. This unique ID is used for that.

* The last bit is used for previous_funccal, ignored when comparing.

*/

static int current_copyID = 0;

static int echo_attr = 0; /* attributes used for ":echo" */

/*

* Info used by a ":for" loop.

*/

typedef struct

{

int fi_semicolon; /* TRUE if ending in '; var]' */

int fi_varcount; /* nr of variables in the list */

listwatch_T fi_lw; /* keep an eye on the item used. */

list_T *fi_list; /* list being used */

int fi_bi; /* index of blob */

blob_T *fi_blob; /* blob being used */

} forinfo_T;

static int tv_op(typval_T *tv1, typval_T *tv2, char_u *op);

static int eval2(char_u **arg, typval_T *rettv, int evaluate);

static int eval3(char_u **arg, typval_T *rettv, int evaluate);

static int eval4(char_u **arg, typval_T *rettv, int evaluate);

static int eval5(char_u **arg, typval_T *rettv, int evaluate);

static int eval6(char_u **arg, typval_T *rettv, int evaluate, int want_string);

static int eval7(char_u **arg, typval_T *rettv, int evaluate, int want_string);

static int eval7_leader(typval_T *rettv, char_u *start_leader, char_u **end_leaderp);

static int get_string_tv(char_u **arg, typval_T *rettv, int evaluate);

static int get_lit_string_tv(char_u **arg, typval_T *rettv, int evaluate);

static int free_unref_items(int copyID);

static int get_env_tv(char_u **arg, typval_T *rettv, int evaluate);

static char_u *make_expanded_name(char_u *in_start, char_u *expr_start, char_u *expr_end, char_u *in_end);

static int tv_check_lock(typval_T *tv, char_u *name, int use_gettext);

/*

* Return "n1" divided by "n2", taking care of dividing by zero.

*/

varnumber_T

num_divide(varnumber_T n1, varnumber_T n2)

{

varnumber_T result;

if (n2 == 0) // give an error message?

{

if (n1 == 0)

result = VARNUM_MIN; // similar to NaN

else if (n1 < 0)

result = -VARNUM_MAX;

else

result = VARNUM_MAX;

}

else

result = n1 / n2;

return result;

}

/*

* Return "n1" modulus "n2", taking care of dividing by zero.

*/

varnumber_T

num_modulus(varnumber_T n1, varnumber_T n2)

{

// Give an error when n2 is 0?

return (n2 == 0) ? 0 : (n1 % n2);

}

#if defined(EBCDIC) || defined(PROTO)

/*

* Compare struct fst by function name.

*/

static int

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

{

struct fst *p1 = (struct fst *)s1;

struct fst *p2 = (struct fst *)s2;

return STRCMP(p1->f_name, p2->f_name);

}

/*

* Sort the function table by function name.

* The sorting of the table above is ASCII dependent.

* On machines using EBCDIC we have to sort it.

*/

static void

sortFunctions(void)

{

int funcCnt = (int)(sizeof(functions) / sizeof(struct fst)) - 1;

qsort(functions, (size_t)funcCnt, sizeof(struct fst), compare_func_name);

}

#endif

/*

* Initialize the global and v: variables.

*/

void

eval_init(void)

{

evalvars_init();

func_init();

#ifdef EBCDIC

/*

* Sort the function table, to enable binary search.

*/

sortFunctions();

#endif

}

#if defined(EXITFREE) || defined(PROTO)

void

eval_clear(void)

{

evalvars_clear();

free_scriptnames();

free_locales();

// autoloaded script names

free_autoload_scriptnames();

// unreferenced lists and dicts

(void)garbage_collect(FALSE);

// functions not garbage collected

free_all_functions();

}

#endif

/*

* Top level evaluation function, returning a boolean.

* Sets "error" to TRUE if there was an error.

* Return TRUE or FALSE.

*/

int

eval_to_bool(

char_u *arg,

int *error,

char_u **nextcmd,

int skip) /* only parse, don't execute */

{

typval_T tv;

varnumber_T retval = FALSE;

if (skip)

++emsg_skip;

if (eval0(arg, &tv, nextcmd, !skip) == FAIL)

*error = TRUE;

else

{

*error = FALSE;

if (!skip)

{

retval = (tv_get_number_chk(&tv, error) != 0);

clear_tv(&tv);

}

}

if (skip)

--emsg_skip;

return (int)retval;

}

/*

* Call eval1() and give an error message if not done at a lower level.

*/

static int

eval1_emsg(char_u **arg, typval_T *rettv, int evaluate)

{

char_u *start = *arg;

int ret;

int did_emsg_before = did_emsg;

int called_emsg_before = called_emsg;

ret = eval1(arg, rettv, evaluate);

if (ret == FAIL)

{

// Report the invalid expression unless the expression evaluation has

// been cancelled due to an aborting error, an interrupt, or an

// exception, or we already gave a more specific error.

// Also check called_emsg for when using assert_fails().

if (!aborting() && did_emsg == did_emsg_before

&& called_emsg == called_emsg_before)

semsg(_(e_invexpr2), start);

}

return ret;

}

int

eval_expr_typval(typval_T *expr, typval_T *argv, int argc, typval_T *rettv)

{

char_u *s;

char_u buf[NUMBUFLEN];

funcexe_T funcexe;

if (expr->v_type == VAR_FUNC)

{

s = expr->vval.v_string;

if (s == NULL || *s == NUL)

return FAIL;

vim_memset(&funcexe, 0, sizeof(funcexe));

funcexe.evaluate = TRUE;

if (call_func(s, -1, rettv, argc, argv, &funcexe) == FAIL)

return FAIL;

}

else if (expr->v_type == VAR_PARTIAL)

{

partial_T *partial = expr->vval.v_partial;

s = partial_name(partial);

if (s == NULL || *s == NUL)

return FAIL;

vim_memset(&funcexe, 0, sizeof(funcexe));

funcexe.evaluate = TRUE;

funcexe.partial = partial;

if (call_func(s, -1, rettv, argc, argv, &funcexe) == FAIL)

return FAIL;

}

else

{

s = tv_get_string_buf_chk(expr, buf);

if (s == NULL)

return FAIL;

s = skipwhite(s);

if (eval1_emsg(&s, rettv, TRUE) == FAIL)

return FAIL;

if (*s != NUL) /* check for trailing chars after expr */

{

clear_tv(rettv);

semsg(_(e_invexpr2), s);

return FAIL;

}

}

return OK;

}

/*

* Like eval_to_bool() but using a typval_T instead of a string.

* Works for string, funcref and partial.

*/

int

eval_expr_to_bool(typval_T *expr, int *error)

{

typval_T rettv;

int res;

if (eval_expr_typval(expr, NULL, 0, &rettv) == FAIL)

{

*error = TRUE;

return FALSE;

}

res = (tv_get_number_chk(&rettv, error) != 0);

clear_tv(&rettv);

return res;

}

/*

* Top level evaluation function, returning a string. If "skip" is TRUE,

* only parsing to "nextcmd" is done, without reporting errors. Return

* pointer to allocated memory, or NULL for failure or when "skip" is TRUE.

*/

char_u *

eval_to_string_skip(

char_u *arg,

char_u **nextcmd,

int skip) /* only parse, don't execute */

{

typval_T tv;

char_u *retval;

if (skip)

++emsg_skip;

if (eval0(arg, &tv, nextcmd, !skip) == FAIL || skip)

retval = NULL;

else

{

retval = vim_strsave(tv_get_string(&tv));

clear_tv(&tv);

}

if (skip)

--emsg_skip;

return retval;

}

/*

* Skip over an expression at "*pp".

* Return FAIL for an error, OK otherwise.

*/

int

skip_expr(char_u **pp)

{

typval_T rettv;

*pp = skipwhite(*pp);

return eval1(pp, &rettv, FALSE);

}

/*

* Top level evaluation function, returning a string.

* When "convert" is TRUE convert a List into a sequence of lines and convert

* a Float to a String.

* Return pointer to allocated memory, or NULL for failure.

*/

char_u *

eval_to_string(

char_u *arg,

char_u **nextcmd,

int convert)

{

typval_T tv;

char_u *retval;

garray_T ga;

#ifdef FEAT_FLOAT

char_u numbuf[NUMBUFLEN];

#endif

if (eval0(arg, &tv, nextcmd, TRUE) == FAIL)

retval = NULL;

else

{

if (convert && tv.v_type == VAR_LIST)

{

ga_init2(&ga, (int)sizeof(char), 80);

if (tv.vval.v_list != NULL)

{

list_join(&ga, tv.vval.v_list, (char_u *)"\n", TRUE, FALSE, 0);

if (tv.vval.v_list->lv_len > 0)

ga_append(&ga, NL);

}

ga_append(&ga, NUL);

retval = (char_u *)ga.ga_data;

}

#ifdef FEAT_FLOAT

else if (convert && tv.v_type == VAR_FLOAT)

{

vim_snprintf((char *)numbuf, NUMBUFLEN, "%g", tv.vval.v_float);

retval = vim_strsave(numbuf);

}

#endif

else

retval = vim_strsave(tv_get_string(&tv));

clear_tv(&tv);

}

return retval;

}

/*

* Call eval_to_string() without using current local variables and using

* textlock. When "use_sandbox" is TRUE use the sandbox.

*/

char_u *

eval_to_string_safe(

char_u *arg,

char_u **nextcmd,

int use_sandbox)

{

char_u *retval;

funccal_entry_T funccal_entry;

save_funccal(&funccal_entry);

if (use_sandbox)

++sandbox;

++textlock;

retval = eval_to_string(arg, nextcmd, FALSE);

if (use_sandbox)

--sandbox;

--textlock;

restore_funccal();

return retval;

}

/*

* Top level evaluation function, returning a number.

* Evaluates "expr" silently.

* Returns -1 for an error.

*/

varnumber_T

eval_to_number(char_u *expr)

{

typval_T rettv;

varnumber_T retval;

char_u *p = skipwhite(expr);

++emsg_off;

if (eval1(&p, &rettv, TRUE) == FAIL)

retval = -1;

else

{

retval = tv_get_number_chk(&rettv, NULL);

clear_tv(&rettv);

}

--emsg_off;

return retval;

}

/*

* Top level evaluation function.

* Returns an allocated typval_T with the result.

* Returns NULL when there is an error.

*/

typval_T *

eval_expr(char_u *arg, char_u **nextcmd)

{

typval_T *tv;

tv = ALLOC_ONE(typval_T);

if (tv != NULL && eval0(arg, tv, nextcmd, TRUE) == FAIL)

VIM_CLEAR(tv);

return tv;

}

/*

* Call some Vim script function and return the result in "*rettv".

* Uses argv[0] to argv[argc - 1] for the function arguments. argv[argc]

* should have type VAR_UNKNOWN.

* Returns OK or FAIL.

*/

int

call_vim_function(

char_u *func,

int argc,

typval_T *argv,

typval_T *rettv)

{

int ret;

funcexe_T funcexe;

rettv->v_type = VAR_UNKNOWN; /* clear_tv() uses this */

vim_memset(&funcexe, 0, sizeof(funcexe));

funcexe.firstline = curwin->w_cursor.lnum;

funcexe.lastline = curwin->w_cursor.lnum;

funcexe.evaluate = TRUE;

ret = call_func(func, -1, rettv, argc, argv, &funcexe);

if (ret == FAIL)

clear_tv(rettv);

return ret;

}

/*

* Call Vim script function "func" and return the result as a number.

* Returns -1 when calling the function fails.

* Uses argv[0] to argv[argc - 1] for the function arguments. argv[argc] should

* have type VAR_UNKNOWN.

*/

varnumber_T

call_func_retnr(

char_u *func,

int argc,

typval_T *argv)

{

typval_T rettv;

varnumber_T retval;

if (call_vim_function(func, argc, argv, &rettv) == FAIL)

return -1;

retval = tv_get_number_chk(&rettv, NULL);

clear_tv(&rettv);

return retval;

}

/*

* Call Vim script function "func" and return the result as a string.

* Returns NULL when calling the function fails.

* Uses argv[0] to argv[argc - 1] for the function arguments. argv[argc] should

* have type VAR_UNKNOWN.

*/

void *

call_func_retstr(

char_u *func,

int argc,

typval_T *argv)

{

typval_T rettv;

char_u *retval;

if (call_vim_function(func, argc, argv, &rettv) == FAIL)

return NULL;

retval = vim_strsave(tv_get_string(&rettv));

clear_tv(&rettv);

return retval;

}

/*

* Call Vim script function "func" and return the result as a List.

* Uses argv[0] to argv[argc - 1] for the function arguments. argv[argc] should

* have type VAR_UNKNOWN.

* Returns NULL when there is something wrong.

*/

void *

call_func_retlist(

char_u *func,

int argc,

typval_T *argv)

{

typval_T rettv;

if (call_vim_function(func, argc, argv, &rettv) == FAIL)

return NULL;

if (rettv.v_type != VAR_LIST)

{

clear_tv(&rettv);

return NULL;

}

return rettv.vval.v_list;

}

#ifdef FEAT_FOLDING

/*

* Evaluate 'foldexpr'. Returns the foldlevel, and any character preceding

* it in "*cp". Doesn't give error messages.

*/

int

eval_foldexpr(char_u *arg, int *cp)

{

typval_T tv;

varnumber_T retval;

char_u *s;

int use_sandbox = was_set_insecurely((char_u *)"foldexpr",

OPT_LOCAL);

++emsg_off;

if (use_sandbox)

++sandbox;

++textlock;

*cp = NUL;

if (eval0(arg, &tv, NULL, TRUE) == FAIL)

retval = 0;

else

{

/* If the result is a number, just return the number. */

if (tv.v_type == VAR_NUMBER)

retval = tv.vval.v_number;

else if (tv.v_type != VAR_STRING || tv.vval.v_string == NULL)

retval = 0;

else

{

/* If the result is a string, check if there is a non-digit before

* the number. */

s = tv.vval.v_string;

if (!VIM_ISDIGIT(*s) && *s != '-')

*cp = *s++;

retval = atol((char *)s);

}

clear_tv(&tv);

}

--emsg_off;

if (use_sandbox)

--sandbox;

--textlock;

return (int)retval;

}

#endif

/*

* Get an lval: variable, Dict item or List item that can be assigned a value

* to: "name", "na{me}", "name[expr]", "name[expr:expr]", "name[expr][expr]",

* "name.key", "name.key[expr]" etc.

* Indexing only works if "name" is an existing List or Dictionary.

* "name" points to the start of the name.

* If "rettv" is not NULL it points to the value to be assigned.

* "unlet" is TRUE for ":unlet": slightly different behavior when something is

* wrong; must end in space or cmd separator.

*

* flags:

* GLV_QUIET: do not give error messages

* GLV_READ_ONLY: will not change the variable

* GLV_NO_AUTOLOAD: do not use script autoloading

*

* Returns a pointer to just after the name, including indexes.

* When an evaluation error occurs "lp->ll_name" is NULL;

* Returns NULL for a parsing error. Still need to free items in "lp"!

*/

char_u *

get_lval(

char_u *name,

typval_T *rettv,

lval_T *lp,

int unlet,

int skip,

int flags, /* GLV_ values */

int fne_flags) /* flags for find_name_end() */

{

char_u *p;

char_u *expr_start, *expr_end;

int cc;

dictitem_T *v;

typval_T var1;

typval_T var2;

int empty1 = FALSE;

listitem_T *ni;

char_u *key = NULL;

int len;

hashtab_T *ht;

int quiet = flags & GLV_QUIET;

/* Clear everything in "lp". */

vim_memset(lp, 0, sizeof(lval_T));

if (skip)

{

/* When skipping just find the end of the name. */

lp->ll_name = name;

return find_name_end(name, NULL, NULL, FNE_INCL_BR | fne_flags);

}

/* Find the end of the name. */

p = find_name_end(name, &expr_start, &expr_end, fne_flags);

if (expr_start != NULL)

{

/* Don't expand the name when we already know there is an error. */

if (unlet && !VIM_ISWHITE(*p) && !ends_excmd(*p)

&& *p != '[' && *p != '.')

{

emsg(_(e_trailing));

return NULL;

}

lp->ll_exp_name = make_expanded_name(name, expr_start, expr_end, p);

if (lp->ll_exp_name == NULL)

{

/* Report an invalid expression in braces, unless the

* expression evaluation has been cancelled due to an

* aborting error, an interrupt, or an exception. */

if (!aborting() && !quiet)

{

emsg_severe = TRUE;

semsg(_(e_invarg2), name);

return NULL;

}

}

lp->ll_name = lp->ll_exp_name;

}

else

lp->ll_name = name;

/* Without [idx] or .key we are done. */

if ((*p != '[' && *p != '.') || lp->ll_name == NULL)

return p;

cc = *p;

*p = NUL;

/* Only pass &ht when we would write to the variable, it prevents autoload

* as well. */

v = find_var(lp->ll_name, (flags & GLV_READ_ONLY) ? NULL : &ht,

flags & GLV_NO_AUTOLOAD);

if (v == NULL && !quiet)

semsg(_(e_undefvar), lp->ll_name);

*p = cc;

if (v == NULL)

return NULL;

/*

* Loop until no more [idx] or .key is following.

*/

lp->ll_tv = &v->di_tv;

var1.v_type = VAR_UNKNOWN;

var2.v_type = VAR_UNKNOWN;

while (*p == '[' || (*p == '.' && lp->ll_tv->v_type == VAR_DICT))

{

if (!(lp->ll_tv->v_type == VAR_LIST && lp->ll_tv->vval.v_list != NULL)

&& !(lp->ll_tv->v_type == VAR_DICT

&& lp->ll_tv->vval.v_dict != NULL)

&& !(lp->ll_tv->v_type == VAR_BLOB

&& lp->ll_tv->vval.v_blob != NULL))

{

if (!quiet)

emsg(_("E689: Can only index a List, Dictionary or Blob"));

return NULL;

}

if (lp->ll_range)

{

if (!quiet)

emsg(_("E708: [:] must come last"));

return NULL;

}

len = -1;

if (*p == '.')

{

key = p + 1;

for (len = 0; ASCII_ISALNUM(key[len]) || key[len] == '_'; ++len)

;

if (len == 0)

{

if (!quiet)

emsg(_(e_emptykey));

return NULL;

}

p = key + len;

}

else

{

/* Get the index [expr] or the first index [expr: ]. */

p = skipwhite(p + 1);

if (*p == ':')

empty1 = TRUE;

else

{

empty1 = FALSE;

if (eval1(&p, &var1, TRUE) == FAIL) /* recursive! */

return NULL;

if (tv_get_string_chk(&var1) == NULL)

{

/* not a number or string */

clear_tv(&var1);

return NULL;

}

}

/* Optionally get the second index [ :expr]. */

if (*p == ':')

{

if (lp->ll_tv->v_type == VAR_DICT)

{

if (!quiet)

emsg(_(e_dictrange));

clear_tv(&var1);

return NULL;

}

if (rettv != NULL

&& !(rettv->v_type == VAR_LIST

&& rettv->vval.v_list != NULL)

&& !(rettv->v_type == VAR_BLOB

&& rettv->vval.v_blob != NULL))

{

if (!quiet)

emsg(_("E709: [:] requires a List or Blob value"));

clear_tv(&var1);

return NULL;

}

p = skipwhite(p + 1);

if (*p == ']')

lp->ll_empty2 = TRUE;

else

{

lp->ll_empty2 = FALSE;

if (eval1(&p, &var2, TRUE) == FAIL) /* recursive! */

{

clear_tv(&var1);

return NULL;

}

if (tv_get_string_chk(&var2) == NULL)

{

/* not a number or string */

clear_tv(&var1);

clear_tv(&var2);

return NULL;

}

}

lp->ll_range = TRUE;

}

else

lp->ll_range = FALSE;

if (*p != ']')

{

if (!quiet)

emsg(_(e_missbrac));

clear_tv(&var1);

clear_tv(&var2);

return NULL;

}

/* Skip to past ']'. */

++p;

}

if (lp->ll_tv->v_type == VAR_DICT)

{

if (len == -1)

{

/* "[key]": get key from "var1" */

key = tv_get_string_chk(&var1); /* is number or string */

if (key == NULL)

{

clear_tv(&var1);

return NULL;

}

}

lp->ll_list = NULL;

lp->ll_dict = lp->ll_tv->vval.v_dict;

lp->ll_di = dict_find(lp->ll_dict, key, len);

/* When assigning to a scope dictionary check that a function and

* variable name is valid (only variable name unless it is l: or

* g: dictionary). Disallow overwriting a builtin function. */

if (rettv != NULL && lp->ll_dict->dv_scope != 0)

{

int prevval;

int wrong;

if (len != -1)

{

prevval = key[len];

key[len] = NUL;

}

else

prevval = 0; /* avoid compiler warning */

wrong = (lp->ll_dict->dv_scope == VAR_DEF_SCOPE

&& rettv->v_type == VAR_FUNC

&& var_check_func_name(key, lp->ll_di == NULL))

|| !valid_varname(key);

if (len != -1)

key[len] = prevval;

if (wrong)

return NULL;

}

if (lp->ll_di == NULL)

{

// Can't add "v:" or "a:" variable.

if (lp->ll_dict == get_vimvar_dict()

|| &lp->ll_dict->dv_hashtab == get_funccal_args_ht())

{

semsg(_(e_illvar), name);

clear_tv(&var1);

return NULL;

}

// Key does not exist in dict: may need to add it.

if (*p == '[' || *p == '.' || unlet)

{

if (!quiet)

semsg(_(e_dictkey), key);

clear_tv(&var1);

return NULL;

}

if (len == -1)

lp->ll_newkey = vim_strsave(key);

else

lp->ll_newkey = vim_strnsave(key, len);

clear_tv(&var1);

if (lp->ll_newkey == NULL)

p = NULL;

break;

}

/* existing variable, need to check if it can be changed */

else if ((flags & GLV_READ_ONLY) == 0

&& var_check_ro(lp->ll_di->di_flags, name, FALSE))

{

clear_tv(&var1);

return NULL;

}

clear_tv(&var1);

lp->ll_tv = &lp->ll_di->di_tv;

}

else if (lp->ll_tv->v_type == VAR_BLOB)

{

long bloblen = blob_len(lp->ll_tv->vval.v_blob);

/*

* Get the number and item for the only or first index of the List.

*/

if (empty1)

lp->ll_n1 = 0;

else

// is number or string

lp->ll_n1 = (long)tv_get_number(&var1);

clear_tv(&var1);

if (lp->ll_n1 < 0

|| lp->ll_n1 > bloblen

|| (lp->ll_range && lp->ll_n1 == bloblen))

{

if (!quiet)

semsg(_(e_blobidx), lp->ll_n1);

clear_tv(&var2);

return NULL;

}

if (lp->ll_range && !lp->ll_empty2)

{

lp->ll_n2 = (long)tv_get_number(&var2);

clear_tv(&var2);

if (lp->ll_n2 < 0

|| lp->ll_n2 >= bloblen

|| lp->ll_n2 < lp->ll_n1)

{

if (!quiet)

semsg(_(e_blobidx), lp->ll_n2);

return NULL;

}

}

lp->ll_blob = lp->ll_tv->vval.v_blob;

lp->ll_tv = NULL;

break;

}

else

{

/*

* Get the number and item for the only or first index of the List.

*/

if (empty1)

lp->ll_n1 = 0;

else

/* is number or string */

lp->ll_n1 = (long)tv_get_number(&var1);

clear_tv(&var1);

lp->ll_dict = NULL;

lp->ll_list = lp->ll_tv->vval.v_list;

lp->ll_li = list_find(lp->ll_list, lp->ll_n1);

if (lp->ll_li == NULL)

{

if (lp->ll_n1 < 0)

{

lp->ll_n1 = 0;

lp->ll_li = list_find(lp->ll_list, lp->ll_n1);

}

}

if (lp->ll_li == NULL)

{

clear_tv(&var2);

if (!quiet)

semsg(_(e_listidx), lp->ll_n1);

return NULL;

}

/*

* May need to find the item or absolute index for the second

* index of a range.

* When no index given: "lp->ll_empty2" is TRUE.

* Otherwise "lp->ll_n2" is set to the second index.

*/

if (lp->ll_range && !lp->ll_empty2)

{

lp->ll_n2 = (long)tv_get_number(&var2);

/* is number or string */

clear_tv(&var2);

if (lp->ll_n2 < 0)

{

ni = list_find(lp->ll_list, lp->ll_n2);

if (ni == NULL)

{

if (!quiet)

semsg(_(e_listidx), lp->ll_n2);

return NULL;

}

lp->ll_n2 = list_idx_of_item(lp->ll_list, ni);

}

/* Check that lp->ll_n2 isn't before lp->ll_n1. */

if (lp->ll_n1 < 0)

lp->ll_n1 = list_idx_of_item(lp->ll_list, lp->ll_li);

if (lp->ll_n2 < lp->ll_n1)

{

if (!quiet)

semsg(_(e_listidx), lp->ll_n2);

return NULL;

}

}