Problem: Error messages are spread out.
Solution: Move more errors to errors.h.
n = eap->line2 - eap->line1 + 1;
if (*eap->arg != NUL)
// Can't have both a range and an argument.
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
else if (n <= 0)
{
// Don't give an error for ":%argdel" if the list is empty.
if (del_group)
{
if (*arg == NUL)
- emsg(_(e_argreq));
+ emsg(_(e_argument_required));
else
au_del_group(arg);
}
return; // type error; errmsg already given
if (before < 0 || before > len)
{
- semsg(_(e_invarg2), tv_get_string(&argvars[2]));
+ semsg(_(e_invalid_argument_str), tv_get_string(&argvars[2]));
return;
}
}
return;
if (val < 0 || val > 255)
{
- semsg(_(e_invarg2), tv_get_string(&argvars[1]));
+ semsg(_(e_invalid_argument_str), tv_get_string(&argvars[1]));
return;
}
ui_breakcheck();
if (got_int)
{
- errmsg = (char_u *)_(e_interr);
+ errmsg = (char_u *)_(e_interrupted);
break;
}
}
ml_preserve(buf, FALSE);
if (got_int)
{
- errmsg = (char_u *)_(e_interr);
+ errmsg = (char_u *)_(e_interrupted);
goto restore_backup;
}
}
}
}
else if (got_int)
- errmsg = (char_u *)_(e_interr);
+ errmsg = (char_u *)_(e_interrupted);
else
errmsg = (char_u *)_(e_write_error_file_system_full);
}
// know we got the message.
if (got_int)
{
- msg(_(e_interr));
+ msg(_(e_interrupted));
out_flush();
}
if ((fd = mch_open((char *)backup, O_RDONLY | O_EXTRA, 0)) >= 0)
if (argvars[1].v_type != VAR_UNKNOWN
&& (argvars[1].v_type != VAR_DICT || argvars[1].vval.v_dict == NULL))
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return NULL;
}
p = vim_strchr(address + 1, ']');
if (p == NULL || *++p != ':')
{
- semsg(_(e_invarg2), address);
+ semsg(_(e_invalid_argument_str), address);
return NULL;
}
}
p = vim_strchr(address, ':');
if (p == NULL)
{
- semsg(_(e_invarg2), address);
+ semsg(_(e_invalid_argument_str), address);
return NULL;
}
}
port = strtol((char *)(p + 1), &rest, 10);
if (*address == NUL || port <= 0 || port >= 65536 || *rest != NUL)
{
- semsg(_(e_invarg2), address);
+ semsg(_(e_invalid_argument_str), address);
return NULL;
}
if (is_ipv6)
goto theend;
if (opt.jo_timeout < 0)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
goto theend;
}
}
else
{
- semsg(_(e_invarg2), tv_get_string(tv));
+ semsg(_(e_invalid_argument_str), tv_get_string(tv));
return NULL;
}
if (channel != NULL && reading)
p += 8;
new_exclude_prog = vim_regcomp(p, RE_MAGIC);
if (new_exclude_prog == NULL)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
break;
}
else
{
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
break;
}
if (*p == ',')
pat = tv_get_string(&argvars[0]);
if (argvars[1].v_type != VAR_STRING)
{
- semsg(_(e_invarg2), "type must be a string");
+ semsg(_(e_invalid_argument_str), "type must be a string");
return;
}
type = tv_get_string(&argvars[1]);
xpc.xp_context = cmdcomplete_str_to_type(type);
if (xpc.xp_context == EXPAND_NOTHING)
{
- semsg(_(e_invarg2), type);
+ semsg(_(e_invalid_argument_str), type);
return;
}
bp->dbg_type = DBG_EXPR;
else
{
- semsg(_(e_invarg2), p);
+ semsg(_(e_invalid_argument_str), p);
return FAIL;
}
p = skipwhite(p + 4);
|| (here && *p != NUL)
|| (bp->dbg_type == DBG_FUNC && strstr((char *)p, "()") != NULL))
{
- semsg(_(e_invarg2), arg);
+ semsg(_(e_invalid_argument_str), arg);
return FAIL;
}
return 0;
if (di->di_tv.v_type != VAR_NUMBER)
{
- semsg(_(e_invarg2), tv_get_string(&di->di_tv));
+ semsg(_(e_invalid_argument_str), tv_get_string(&di->di_tv));
return 0;
}
return tv_get_number(&di->di_tv);
break;
if (i == 3)
{
- semsg(_(e_invarg2), action);
+ semsg(_(e_invalid_argument_str), action);
return;
}
}
* Definition of error messages, sorted on error number.
*/
+EXTERN char e_interrupted[]
+ INIT(= N_("Interrupted"));
+
EXTERN char e_backslash_should_be_followed_by[]
INIT(= N_("E10: \\ should be followed by /, ? or &"));
#ifdef FEAT_CMDWIN
EXTERN char e_cannot_start_the_GUI[]
INIT(= N_("E229: Cannot start the GUI"));
-
+#if defined(FEAT_GUI) && defined(FEAT_XFONTSET)
+EXTERN char e_unknown_fontset_str[]
+ INIT(= N_("E234: Unknown fontset: %s"));
+#endif
+#if defined(FEAT_GUI_X11) || defined(FEAT_GUI_GTK) \
+ || defined(FEAT_GUI_PHOTON) || defined(FEAT_GUI_MSWIN) || defined(FEAT_GUI_HAIKU)
+EXTERN char e_unknown_font_str[]
+ INIT(= N_("E235: Unknown font: %s"));
+#endif
+#if defined(FEAT_GUI_X11) && !defined(FEAT_GUI_GTK)
+EXTERN char e_font_str_is_not_fixed_width[]
+ INIT(= N_("E236: Font \"%s\" is not fixed-width"));
+#endif
EXTERN char e_window_layout_changed_unexpectedly[]
INIT(= N_("E249: window layout changed unexpectedly"));
#if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)
EXTERN char e_ambiguous_use_of_user_defined_command[]
INIT(= N_("E464: Ambiguous use of user-defined command"));
+EXTERN char e_command_aborted[]
+ INIT(= N_("E470: Command aborted"));
+EXTERN char e_argument_required[]
+ INIT(= N_("E471: Argument required"));
+EXTERN char e_command_failed[]
+ INIT(= N_("E472: Command failed"));
+EXTERN char e_internal_error_in_regexp[]
+ INIT(= N_("E473: Internal error in regexp"));
+EXTERN char e_invalid_argument[]
+ INIT(= N_("E474: Invalid argument"));
+EXTERN char e_invalid_argument_str[]
+ INIT(= N_("E475: Invalid argument: %s"));
+EXTERN char e_invalid_value_for_argument_str[]
+ INIT(= N_("E475: Invalid value for argument %s"));
+EXTERN char e_invalid_value_for_argument_str_str[]
+ INIT(= N_("E475: Invalid value for argument %s: %s"));
EXTERN char e_invalid_command[]
INIT(= N_("E476: Invalid command"));
#ifdef FEAT_EVAL
INIT(= N_("E516: No buffers were deleted"));
EXTERN char e_no_buffers_were_wiped_out[]
INIT(= N_("E517: No buffers were wiped out"));
+#ifdef FEAT_EVAL
+EXTERN char e_endwhile_without_while[]
+ INIT(= N_("E588: :endwhile without :while"));
+EXTERN char e_endfor_without_for[]
+ INIT(= N_("E588: :endfor without :for"));
+EXTERN char e_missing_endtry[]
+ INIT(= N_("E600: Missing :endtry"));
+EXTERN char e_endtry_without_try[]
+ INIT(= N_("E602: :endtry without :try"));
+EXTERN char e_catch_without_try[]
+ INIT(= N_("E603: :catch without :try"));
+EXTERN char e_finally_without_try[]
+ INIT(= N_("E606: :finally without :try"));
+EXTERN char e_multiple_finally[]
+ INIT(= N_("E607: multiple :finally"));
+#endif
EXTERN char e_no_argument_to_delete[]
INIT(= N_("E610: No argument to delete"));
if (!aborting() && !quiet)
{
emsg_severe = TRUE;
- semsg(_(e_invarg2), name);
+ semsg(_(e_invalid_argument_str), name);
return NULL;
}
}
if (list2fpos(argvars, &pos, NULL, &curswant, charcol) == FAIL)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return;
}
line = pos.lnum;
{
line = tv_get_lnum(argvars);
if (line < 0)
- semsg(_(e_invarg2), tv_get_string(&argvars[0]));
+ semsg(_(e_invalid_argument_str), tv_get_string(&argvars[0]));
col = (long)tv_get_number_chk(&argvars[1], NULL);
if (charcol)
col = buf_charidx_to_byteidx(curbuf, line, col) + 1;
}
else
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return;
}
if (line < 0 || col < 0 || coladd < 0)
pid = (int)tv_get_number(&argvars[0]);
if (pid == 0)
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
else
{
HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, 0, pid);
}
if (s == NULL)
{
- semsg(_(e_invarg2), "NULL");
+ semsg(_(e_invalid_argument_str), "NULL");
return;
}
if (s == NULL || *s == NUL || (use_string && VIM_ISDIGIT(*s))
|| (is_funcref && trans_name == NULL))
- semsg(_(e_invarg2), use_string ? tv_get_string(&argvars[0]) : s);
+ semsg(_(e_invalid_argument_str), use_string ? tv_get_string(&argvars[0]) : s);
// Don't check an autoload name for existence here.
else if (trans_name != NULL && (is_funcref
? find_func(trans_name, is_global, NULL) == NULL
}
}
else
- semsg(_(e_invarg2), what);
+ semsg(_(e_invalid_argument_str), what);
// When {what} == "dict" and pt->pt_dict == NULL, evaluate the
// third argument
|| argvars[0].vval.v_string == NULL
|| *argvars[0].vval.v_string == NUL)
{
- semsg(_(e_invarg2), tv_get_string(&argvars[0]));
+ semsg(_(e_invalid_argument_str), tv_get_string(&argvars[0]));
}
else
{
if (*end != NUL)
{
semsg(_(lv.ll_name == lv.ll_name_end
- ? e_invarg2 : e_trailing_arg), end);
+ ? e_invalid_argument_str : e_trailing_arg), end);
}
else
{
return;
theend:
- semsg(_(e_invarg2), tv_get_string(&argvars[0]));
+ semsg(_(e_invalid_argument_str), tv_get_string(&argvars[0]));
rettv->v_type = VAR_NUMBER;
rettv->vval.v_number = -1;
}
}
if (mask == 0)
{
- semsg(_(e_invarg2), flags);
+ semsg(_(e_invalid_argument_str), flags);
dir = 0;
}
else
if (((flags & (SP_REPEAT | SP_RETCOUNT)) != 0)
|| ((flags & SP_NOMOVE) && (flags & SP_SETPCMARK)))
{
- semsg(_(e_invarg2), tv_get_string(&argvars[1]));
+ semsg(_(e_invalid_argument_str), tv_get_string(&argvars[1]));
goto theend;
}
if ((flags & (SP_END | SP_SUBPAT)) != 0
|| ((flags & SP_NOMOVE) && (flags & SP_SETPCMARK)))
{
- semsg(_(e_invarg2), tv_get_string(&argvars[3]));
+ semsg(_(e_invalid_argument_str), tv_get_string(&argvars[3]));
goto theend;
}
lnum_stop = (long)tv_get_number_chk(&argvars[5], NULL);
if (lnum_stop < 0)
{
- semsg(_(e_invarg2), tv_get_string(&argvars[5]));
+ semsg(_(e_invalid_argument_str), tv_get_string(&argvars[5]));
goto theend;
}
#ifdef FEAT_RELTIME
time_limit = (long)tv_get_number_chk(&argvars[6], NULL);
if (time_limit < 0)
{
- semsg(_(e_invarg2), tv_get_string(&argvars[6]));
+ semsg(_(e_invalid_argument_str), tv_get_string(&argvars[6]));
goto theend;
}
}
rettv->vval.v_number = 0;
}
else
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
}
}
}
return;
if (STRLEN(mode_str) != 9)
{
- semsg(_(e_invarg2), mode_str);
+ semsg(_(e_invalid_argument_str), mode_str);
return;
}
if (ret == FAIL || *++stropt != NUL)
{
- semsg(_(e_invargval), "value");
+ semsg(_(e_invalid_value_for_argument_str), "value");
return;
}
}
{
// ":let" without "=": list variables
if (*arg == '[')
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
else if (expr[0] == '.' && expr[1] == '=')
emsg(_("E985: .= is not supported with script version >= 2"));
else if (!ends_excmd2(eap->cmd, arg))
if (s == p)
{
if (!silent)
- semsg(_(e_invarg2), p);
+ semsg(_(e_invalid_argument_str), p);
return NULL;
}
++*var_count;
else if (*p != ',')
{
if (!silent)
- semsg(_(e_invarg2), p);
+ semsg(_(e_invalid_argument_str), p);
return NULL;
}
}
if (len < 0 && !aborting())
{
emsg_severe = TRUE;
- semsg(_(e_invarg2), arg);
+ semsg(_(e_invalid_argument_str), arg);
break;
}
error = TRUE;
name = arg;
len = get_env_len(&arg);
if (len == 0)
- semsg(_(e_invarg2), name - 1);
+ semsg(_(e_invalid_argument_str), name - 1);
else
{
if (op != NULL && vim_strchr((char_u *)"+-*/%", *op) != NULL)
clear_lval(&lv);
}
else
- semsg(_(e_invarg2), arg);
+ semsg(_(e_invalid_argument_str), arg);
return arg_end;
}
++arg;
if (get_env_len(&arg) == 0)
{
- semsg(_(e_invarg2), arg - 1);
+ semsg(_(e_invalid_argument_str), arg - 1);
return;
}
if (!error && !eap->skip
// Catch a bad name early.
if (!eval_isnamec1(*name))
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return FAIL;
}
// Trailing characters are present after the variable name
semsg(_(e_trailing_arg), redir_endp);
else
- semsg(_(e_invarg2), name);
+ semsg(_(e_invalid_argument_str), name);
redir_endp = NULL; // don't store a value, only cleanup
var_redir_stop();
return FAIL;
if (argvars[2].v_type != VAR_DICT || argvars[2].vval.v_dict == NULL)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return;
}
if (argvars[0].v_type != VAR_DICT
|| (dict = argvars[0].vval.v_dict) == NULL)
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
else
{
if (dict_find(dict, (char_u *)"lnum", -1) != NULL)
}
else
{
- semsg(_(e_invarg2), p);
+ semsg(_(e_invalid_argument_str), p);
goto sortend;
}
}
// Can only have one of 'n', 'b', 'o' and 'x'.
if (format_found > 1)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
goto sortend;
}
vim_free(sortbuf2);
vim_regfree(regmatch.regprog);
if (got_int)
- emsg(_(e_interr));
+ emsg(_(e_interrupted));
}
/*
|| eap->line2 > 0
|| eap->addr_count > 1))
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return;
}
{
if (eap->cmdidx == CMD_saveas)
{
- emsg(_(e_argreq));
+ emsg(_(e_argument_required));
goto theend;
}
other = FALSE;
else if (!global_busy)
{
if (got_int) // interrupted
- emsg(_(e_interr));
+ emsg(_(e_interrupted));
else if (got_match) // did find something but nothing substituted
msg("");
else if (subflags.do_error) // nothing found
}
if (got_int)
{
- emsg(_(e_interr));
+ emsg(_(e_interrupted));
return TRUE;
}
return FALSE;
* pass 2: execute the command for each line that has been marked
*/
if (got_int)
- msg(_(e_interr));
+ msg(_(e_interrupted));
else if (ndone == 0)
{
if (type == 'v')
&& !func_has_ended(real_cookie))))
{
if (cstack.cs_flags[cstack.cs_idx] & CSF_TRY)
- emsg(_(e_endtry));
+ emsg(_(e_missing_endtry));
else if (cstack.cs_flags[cstack.cs_idx] & CSF_WHILE)
emsg(_(e_missing_endwhile));
else if (cstack.cs_flags[cstack.cs_idx] & CSF_FOR)
while (ea.arg[0] == '+' && ea.arg[1] == '+')
if (getargopt(&ea) == FAIL && !ni)
{
- errormsg = _(e_invarg);
+ errormsg = _(e_invalid_argument);
goto doend;
}
if (!ni && (ea.argt & EX_NEEDARG) && *ea.arg == NUL)
{
- errormsg = _(e_argreq);
+ errormsg = _(e_argument_required);
goto doend;
}
tab_number = tabpage_index(lastused_tabpage);
else
{
- eap->errmsg = ex_errmsg(e_invargval, eap->arg);
+ eap->errmsg = ex_errmsg(e_invalid_value_for_argument_str, eap->arg);
tab_number = 0;
goto theend;
}
|| tab_number > LAST_TAB_NR)
{
// No numbers as argument.
- eap->errmsg = ex_errmsg(e_invarg2, eap->arg);
+ eap->errmsg = ex_errmsg(e_invalid_argument_str, eap->arg);
goto theend;
}
}
|| tab_number == 0)
{
// No numbers as argument.
- eap->errmsg = ex_errmsg(e_invarg2, eap->arg);
+ eap->errmsg = ex_errmsg(e_invalid_argument_str, eap->arg);
goto theend;
}
tab_number = tab_number * relative + tabpage_index(curtab);
--tab_number;
}
if (tab_number < unaccept_arg0 || tab_number > LAST_TAB_NR)
- eap->errmsg = ex_errmsg(e_invarg2, eap->arg);
+ eap->errmsg = ex_errmsg(e_invalid_argument_str, eap->arg);
}
else if (eap->addr_count > 0)
{
|| tab_number == 0)
{
// No numbers as argument.
- eap->errmsg = ex_errmsg(e_invarg2, eap->arg);
+ eap->errmsg = ex_errmsg(e_invalid_argument_str, eap->arg);
return;
}
}
|| pathcmp((char *)pdir, (char *)new_dir, -1) != 0;
if (dir_differs && vim_chdir(new_dir))
{
- emsg(_(e_failed));
+ emsg(_(e_command_failed));
vim_free(pdir);
}
else
{
case 'm': break;
case NUL: len *= 1000L; break;
- default: semsg(_(e_invarg2), eap->arg); return;
+ default: semsg(_(e_invalid_argument_str), eap->arg); return;
}
// Hide the cursor if invoked with !
if (!isdigit(*arg))
{
- semsg(_(e_invarg2), arg);
+ semsg(_(e_invalid_argument_str), arg);
return;
}
w = getdigits(&arg);
// CTRL-W g and CTRL-W CTRL-G have an extra command character
if (eap->arg[1] == NUL)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return;
}
xchar = eap->arg[1];
#endif
'"')
&& eap->nextcmd == NULL)
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
else if (!eap->skip)
{
// Pass flags on for ":vertical wincmd ]".
}
if (*p != NUL)
- semsg(_(e_invarg2), eap->arg);
+ semsg(_(e_invalid_argument_str), eap->arg);
else
undo_time(eap->cmdidx == CMD_earlier ? -count : count,
sec, file, FALSE);
if (*arg != NUL)
{
redir_reg = 0;
- semsg(_(e_invarg2), eap->arg);
+ semsg(_(e_invalid_argument_str), eap->arg);
}
}
else if (*arg == '=' && arg[1] == '>')
// TODO: redirect to a buffer
else
- semsg(_(e_invarg2), eap->arg);
+ semsg(_(e_invalid_argument_str), eap->arg);
}
// Make sure redirection is not off. Can happen for cmdline completion
return;
#endif
if (*eap->arg == NUL) // No argument?
- emsg(_(e_argreq));
+ emsg(_(e_argument_required));
else if (eap->arg[1] != NUL) // more than one character?
semsg(_(e_trailing_arg), eap->arg);
else
set_option_value((char_u *)"keymodel", 0L, (char_u *)"", 0);
}
else
- semsg(_(e_invarg2), eap->arg);
+ semsg(_(e_invalid_argument_str), eap->arg);
}
static int filetype_detect = FALSE;
}
}
else
- semsg(_(e_invarg2), arg);
+ semsg(_(e_invalid_argument_str), arg);
}
/*
* interrupt exception is catchable by the innermost try conditional and
* not replaced by an interrupt message error exception.
*/
- if (mesg == (char_u *)_(e_interr))
+ if (mesg == (char_u *)_(e_interrupted))
{
*ignore = TRUE;
return TRUE;
if (eap->cmdidx == CMD_endwhile)
{
- err = e_while;
+ err = e_endwhile_without_while;
csf = CSF_WHILE;
}
else
{
- err = e_for;
+ err = e_endfor_without_for;
csf = CSF_FOR;
}
if (!(fl & CSF_TRY))
eap->errmsg = _(e_missing_endif);
else if (fl & CSF_FINALLY)
- eap->errmsg = _(e_endtry);
+ eap->errmsg = _(e_missing_endtry);
// Try to find the matching ":while" and report what's missing.
for (idx = cstack->cs_idx; idx > 0; --idx)
{
value = eval_to_string_skip(arg, eap, eap->skip);
else
{
- emsg(_(e_argreq));
+ emsg(_(e_argument_required));
value = NULL;
}
if (cstack->cs_trylevel <= 0 || cstack->cs_idx < 0)
{
- eap->errmsg = _(e_catch);
+ eap->errmsg = _(e_catch_without_try);
give_up = TRUE;
}
else
*end = save_char;
p_cpo = save_cpo;
if (regmatch.regprog == NULL)
- semsg(_(e_invarg2), pat);
+ semsg(_(e_invalid_argument_str), pat);
else
{
/*
return;
if (cstack->cs_trylevel <= 0 || cstack->cs_idx < 0)
- eap->errmsg = _(e_finally);
+ eap->errmsg = _(e_finally_without_try);
else
{
if (!(cstack->cs_flags[cstack->cs_idx] & CSF_TRY))
if (cstack->cs_flags[idx] & CSF_FINALLY)
{
// Give up for a multiple ":finally" and ignore it.
- eap->errmsg = _(e_finally_dup);
+ eap->errmsg = _(e_multiple_finally);
return;
}
rewind_conditionals(cstack, idx, CSF_WHILE | CSF_FOR,
return;
if (cstack->cs_trylevel <= 0 || cstack->cs_idx < 0)
- eap->errmsg = _(e_no_endtry);
+ eap->errmsg = _(e_endtry_without_try);
else
{
/*
{
n = string_to_key(p_cedit, FALSE);
if (vim_isprintc(n))
- return e_invarg;
+ return e_invalid_argument;
cedit_key = n;
}
return NULL;
{
if (!(flags & READ_DUMMY))
{
- filemess(curbuf, sfname, (char_u *)_(e_interr), 0);
+ filemess(curbuf, sfname, (char_u *)_(e_interrupted), 0);
if (newfile)
curbuf->b_p_ro = TRUE; // must use "w!" now
}
name = tv_get_string(&argvars[0]);
if (name == NULL || *name == NUL)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return;
}
}
else
{
- semsg(_(e_invarg2),
+ semsg(_(e_invalid_argument_str),
_("writefile() first argument must be a List or a Blob"));
return;
}
#endif
/*
- * The error messages that can be shared are included here.
- * Excluded are errors that are only used once and debugging messages.
+ * Some error messages that can be shared are included here.
+ * They should be moved to errors.h.
*/
-EXTERN char e_abort[] INIT(= N_("E470: Command aborted"));
-EXTERN char e_argreq[] INIT(= N_("E471: Argument required"));
-#ifdef FEAT_EVAL
-EXTERN char e_catch[] INIT(= N_("E603: :catch without :try"));
-EXTERN char e_finally[] INIT(= N_("E606: :finally without :try"));
-EXTERN char e_finally_dup[] INIT(= N_("E607: multiple :finally"));
-EXTERN char e_endtry[] INIT(= N_("E600: Missing :endtry"));
-EXTERN char e_no_endtry[] INIT(= N_("E602: :endtry without :try"));
-EXTERN char e_while[] INIT(= N_("E588: :endwhile without :while"));
-EXTERN char e_for[] INIT(= N_("E588: :endfor without :for"));
-#endif
-EXTERN char e_failed[] INIT(= N_("E472: Command failed"));
-#if defined(FEAT_GUI) && defined(FEAT_XFONTSET)
-EXTERN char e_fontset[] INIT(= N_("E234: Unknown fontset: %s"));
-#endif
-#if defined(FEAT_GUI_X11) || defined(FEAT_GUI_GTK) \
- || defined(FEAT_GUI_PHOTON) || defined(FEAT_GUI_MSWIN) || defined(FEAT_GUI_HAIKU)
-EXTERN char e_font[] INIT(= N_("E235: Unknown font: %s"));
-#endif
-#if defined(FEAT_GUI_X11) && !defined(FEAT_GUI_GTK)
-EXTERN char e_fontwidth[] INIT(= N_("E236: Font \"%s\" is not fixed-width"));
-#endif
-EXTERN char e_internal[] INIT(= N_("E473: Internal error"));
EXTERN char e_intern2[] INIT(= N_("E685: Internal error: %s"));
-EXTERN char e_interr[] INIT(= N_("Interrupted"));
-EXTERN char e_invarg[] INIT(= N_("E474: Invalid argument"));
-EXTERN char e_invarg2[] INIT(= N_("E475: Invalid argument: %s"));
EXTERN char e_duparg2[] INIT(= N_("E983: Duplicate argument: %s"));
-EXTERN char e_invargval[] INIT(= N_("E475: Invalid value for argument %s"));
-EXTERN char e_invargNval[] INIT(= N_("E475: Invalid value for argument %s: %s"));
#ifdef FEAT_SPELL
EXTERN char e_no_spell[] INIT(= N_("E756: Spell checking is not possible"));
#endif
if (font == NULL)
{
if (report_error)
- semsg(_((char *)e_font), name);
+ semsg(_((char *)e_unknown_font_str), name);
return NULL;
}
if (name == 0 && be_fixed_font == 0) {
if (giveErrorIfMissing)
- semsg(_(e_font), name);
+ semsg(_(e_unknown_font_str), name);
return NOFONT;
}
if (count_font_styles(family) <= 0) {
if (giveErrorIfMissing)
- semsg(_(e_font), font->name);
+ semsg(_(e_unknown_font_str), font->name);
delete font;
return NOFONT;
}
}
if (report_error)
- semsg(e_font, vim_font_name);
+ semsg(e_unknown_font_str, vim_font_name);
return FAIL;
}
if (get_logfont(&lf, name, NULL, giveErrorIfMissing) == OK)
font = get_font_handle(&lf);
if (font == NOFONT && giveErrorIfMissing)
- semsg(_(e_font), name);
+ semsg(_(e_unknown_font_str), name);
return font;
}
if (font == NULL)
{
if (giveErrorIfMissing)
- semsg(_(e_font), name);
+ semsg(_(e_unknown_font_str), name);
return NOFONT;
}
if (font->max_bounds.width != font->min_bounds.width)
{
- semsg(_(e_fontwidth), name);
+ semsg(_(e_font_str_is_not_fixed_width), name);
XFreeFont(gui.dpy, font);
return NOFONT;
}
if (fontset == NULL)
{
if (giveErrorIfMissing)
- semsg(_(e_fontset), name);
+ semsg(_(e_unknown_fontset_str), name);
return NOFONTSET;
}
linep = vim_strchr(linep, '\'');
if (linep == NULL)
{
- semsg(_(e_invarg2), key_start);
+ semsg(_(e_invalid_argument_str), key_start);
error = TRUE;
break;
}
if (cp != end)
emsg(_(e_positive));
else
- semsg(_(e_invarg2), cp);
+ semsg(_(e_invalid_argument_str), cp);
return FAIL;
}
}
++valcount;
continue;
}
- semsg(_(e_invarg2), var);
+ semsg(_(e_invalid_argument_str), var);
return FAIL;
}
// Catch negative values, overflow and ridiculous big values.
if (n < 0 || n > 9999)
{
- semsg(_(e_invarg2), cp);
+ semsg(_(e_invalid_argument_str), cp);
vim_free(*array);
*array = NULL;
return FAIL;
}
if (new_ts < 0 || new_ts > 9999)
{
- semsg(_(e_invarg2), eap->arg);
+ semsg(_(e_invalid_argument_str), eap->arg);
return;
}
if (new_ts == 0)
line_breakcheck();
}
if (got_int)
- emsg(_(e_interr));
+ emsg(_(e_interrupted));
#ifdef FEAT_VARTABS
// If a single value was given then it can be considered equal to
}
}
+/*
+ * Fix indent for 'lisp' and 'cindent'.
+ */
void
fix_indent(void)
{
return;
if (argvars[1].v_type != VAR_LIST || argvars[1].vval.v_list == NULL)
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
else
{
startcol = (int)tv_get_number_chk(&argvars[0], NULL);
*modep = MODE_JSON;
else
{
- semsg(_(e_invarg2), val);
+ semsg(_(e_invalid_argument_str), val);
return FAIL;
}
return OK;
opt->jo_io[part] = JIO_OUT;
else
{
- semsg(_(e_invarg2), val);
+ semsg(_(e_invalid_argument_str), val);
return FAIL;
}
return OK;
opt->jo_io_buf[part] = tv_get_number(item);
if (opt->jo_io_buf[part] <= 0)
{
- semsg(_(e_invargNval), hi->hi_key, tv_get_string(item));
+ semsg(_(e_invalid_value_for_argument_str_str), hi->hi_key, tv_get_string(item));
return FAIL;
}
if (buflist_findnr(opt->jo_io_buf[part]) == NULL)
*lp = tv_get_number(item);
if (*lp < 0)
{
- semsg(_(e_invargNval), hi->hi_key, tv_get_string(item));
+ semsg(_(e_invalid_value_for_argument_str_str), hi->hi_key, tv_get_string(item));
return FAIL;
}
}
opt->jo_set |= JO_CHANNEL;
if (item->v_type != VAR_CHANNEL)
{
- semsg(_(e_invargval), "channel");
+ semsg(_(e_invalid_value_for_argument_str), "channel");
return FAIL;
}
opt->jo_channel = item->vval.v_channel;
opt->jo_callback = get_callback(item);
if (opt->jo_callback.cb_name == NULL)
{
- semsg(_(e_invargval), "callback");
+ semsg(_(e_invalid_value_for_argument_str), "callback");
return FAIL;
}
}
opt->jo_out_cb = get_callback(item);
if (opt->jo_out_cb.cb_name == NULL)
{
- semsg(_(e_invargval), "out_cb");
+ semsg(_(e_invalid_value_for_argument_str), "out_cb");
return FAIL;
}
}
opt->jo_err_cb = get_callback(item);
if (opt->jo_err_cb.cb_name == NULL)
{
- semsg(_(e_invargval), "err_cb");
+ semsg(_(e_invalid_value_for_argument_str), "err_cb");
return FAIL;
}
}
opt->jo_close_cb = get_callback(item);
if (opt->jo_close_cb.cb_name == NULL)
{
- semsg(_(e_invargval), "close_cb");
+ semsg(_(e_invalid_value_for_argument_str), "close_cb");
return FAIL;
}
}
never = TRUE;
else if (STRCMP(val, "auto") != 0)
{
- semsg(_(e_invargNval), "drop", val);
+ semsg(_(e_invalid_value_for_argument_str_str), "drop", val);
return FAIL;
}
opt->jo_drop_never = never;
opt->jo_exit_cb = get_callback(item);
if (opt->jo_exit_cb.cb_name == NULL)
{
- semsg(_(e_invargval), "exit_cb");
+ semsg(_(e_invalid_value_for_argument_str), "exit_cb");
return FAIL;
}
}
opt->jo_term_name_buf);
if (opt->jo_term_name == NULL)
{
- semsg(_(e_invargval), "term_name");
+ semsg(_(e_invalid_value_for_argument_str), "term_name");
return FAIL;
}
}
val = tv_get_string(item);
if (STRCMP(val, "open") != 0 && STRCMP(val, "close") != 0)
{
- semsg(_(e_invargNval), "term_finish", val);
+ semsg(_(e_invalid_value_for_argument_str_str), "term_finish", val);
return FAIL;
}
opt->jo_set2 |= JO2_TERM_FINISH;
}
if (p == NULL)
{
- semsg(_(e_invargval), "term_opencmd");
+ semsg(_(e_invalid_value_for_argument_str), "term_opencmd");
return FAIL;
}
}
opt->jo_eof_chars_buf);
if (opt->jo_eof_chars == NULL)
{
- semsg(_(e_invargval), "eof_chars");
+ semsg(_(e_invalid_value_for_argument_str), "eof_chars");
return FAIL;
}
}
return FAIL;
if (opt->jo_term_rows < 0 || opt->jo_term_rows > 1000)
{
- semsg(_(e_invargval), "term_rows");
+ semsg(_(e_invalid_value_for_argument_str), "term_rows");
return FAIL;
}
}
nr = tv_get_number(item);
if (nr <= 0)
{
- semsg(_(e_invargNval), hi->hi_key, tv_get_string(item));
+ semsg(_(e_invalid_value_for_argument_str_str), hi->hi_key, tv_get_string(item));
return FAIL;
}
opt->jo_bufnr_buf = buflist_findnr(nr);
if (opt->jo_bufnr_buf->b_nwindows == 0
|| opt->jo_bufnr_buf->b_term == NULL)
{
- semsg(_(e_invarg2), "bufnr");
+ semsg(_(e_invalid_argument_str), "bufnr");
return FAIL;
}
}
opt->jo_term_kill_buf);
if (opt->jo_term_kill == NULL)
{
- semsg(_(e_invargval), "term_kill");
+ semsg(_(e_invalid_value_for_argument_str), "term_kill");
return FAIL;
}
}
p = tv_get_string_chk(item);
if (p == NULL)
{
- semsg(_(e_invargval), "tty_type");
+ semsg(_(e_invalid_value_for_argument_str), "tty_type");
return FAIL;
}
// Allow empty string, "winpty", "conpty".
if (!(*p == NUL || STRCMP(p, "winpty") == 0
|| STRCMP(p, "conpty") == 0))
{
- semsg(_(e_invargval), "tty_type");
+ semsg(_(e_invalid_value_for_argument_str), "tty_type");
return FAIL;
}
opt->jo_tty_type = p[0];
if (item == NULL || item->v_type != VAR_LIST
|| item->vval.v_list == NULL)
{
- semsg(_(e_invargval), "ansi_colors");
+ semsg(_(e_invalid_value_for_argument_str), "ansi_colors");
return FAIL;
}
if (n != 16 || li != NULL)
{
- semsg(_(e_invargval), "ansi_colors");
+ semsg(_(e_invalid_value_for_argument_str), "ansi_colors");
return FAIL;
}
p = tv_get_string_buf_chk(item, opt->jo_term_highlight_buf);
if (p == NULL || *p == NUL)
{
- semsg(_(e_invargval), "term_highlight");
+ semsg(_(e_invalid_value_for_argument_str), "term_highlight");
return FAIL;
}
opt->jo_term_highlight = p;
opt->jo_term_api_buf);
if (opt->jo_term_api == NULL)
{
- semsg(_(e_invargval), "term_api");
+ semsg(_(e_invalid_value_for_argument_str), "term_api");
return FAIL;
}
}
break;
if (item->v_type != VAR_DICT)
{
- semsg(_(e_invargval), "env");
+ semsg(_(e_invalid_value_for_argument_str), "env");
return FAIL;
}
opt->jo_set2 |= JO2_ENV;
#endif
)
{
- semsg(_(e_invargval), "cwd");
+ semsg(_(e_invalid_value_for_argument_str), "cwd");
return FAIL;
}
opt->jo_set2 |= JO2_CWD;
opt->jo_part = PART_OUT;
else
{
- semsg(_(e_invargNval), "part", val);
+ semsg(_(e_invalid_value_for_argument_str_str), "part", val);
return FAIL;
}
}
opt->jo_stoponexit_buf);
if (opt->jo_stoponexit == NULL)
{
- semsg(_(e_invargval), "stoponexit");
+ semsg(_(e_invalid_value_for_argument_str), "stoponexit");
return FAIL;
}
}
}
if (todo > 0)
{
- semsg(_(e_invarg2), hi->hi_key);
+ semsg(_(e_invalid_argument_str), hi->hi_key);
return FAIL;
}
cmd = argvars[0].vval.v_string;
if (cmd == NULL || *skipwhite(cmd) == NUL)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
goto theend;
}
|| argvars[0].vval.v_list == NULL
|| argvars[0].vval.v_list->lv_len < 1)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
goto theend;
}
else
// Empty command is invalid.
if (argc == 0 || *skipwhite((char_u *)argv[0]) == NUL)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
goto theend;
}
#ifndef USE_ARGV
cmd = ga.ga_data;
if (cmd == NULL || *skipwhite(cmd) == NUL)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
goto theend;
}
#endif
arg = tv_get_string_chk(&argvars[1]);
if (arg == NULL)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return 0;
}
}
if (tv->v_type != VAR_JOB)
{
- semsg(_(e_invarg2), tv_get_string(tv));
+ semsg(_(e_invalid_argument_str), tv_get_string(tv));
return NULL;
}
job = tv->vval.v_job;
top_item->jd_key = tv_get_string_buf_chk(cur_item, key_buf);
if (top_item->jd_key == NULL)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
retval = FAIL;
goto theend;
}
reader.js_fill = NULL;
reader.js_used = 0;
if (json_decode_all(&reader, rettv, JSON_JS) != OK)
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
}
/*
if (argvars[0].v_type != VAR_LIST)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return;
}
info->item_compare_func = tv_get_string(&argvars[1]);
else if (nr != 0)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return FAIL;
}
}
{
if (argvars[2].v_type != VAR_UNKNOWN
&& argvars[3].v_type != VAR_UNKNOWN)
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
else
n = dict_count(argvars[0].vval.v_dict, &argvars[1], ic);
}
local = (STRCMP(arg, "<buffer>") == 0);
if (!local && *arg != NUL)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return;
}
switch (do_map((*cmdp == 'n') ? 2 : (*cmdp == 'u'),
eap->arg, mode, isabbrev))
{
- case 1: emsg(_(e_invarg));
+ case 1: emsg(_(e_invalid_argument));
break;
case 2: emsg((isabbrev ? _(e_no_such_abbreviation)
: _(e_no_such_mapping)));
// clear all marks
clrallmarks(curbuf);
else if (eap->forceit)
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
else if (*eap->arg == NUL)
- emsg(_(e_argreq));
+ emsg(_(e_argument_required));
else
{
// clear specified marks only
: ASCII_ISUPPER(p[2])))
|| to < from)
{
- semsg(_(e_invarg2), p);
+ semsg(_(e_invalid_argument_str), p);
return;
}
p += 2;
case '<': curbuf->b_visual.vi_start.lnum = 0; break;
case '>': curbuf->b_visual.vi_end.lnum = 0; break;
case ' ': break;
- default: semsg(_(e_invarg2), p);
+ default: semsg(_(e_invalid_argument_str), p);
return;
}
}
}
if (pat != NULL && (regprog = vim_regcomp(pat, RE_MAGIC)) == NULL)
{
- semsg(_(e_invarg2), pat);
+ semsg(_(e_invalid_argument_str), pat);
return -1;
}
if (li->li_tv.v_type != VAR_DICT
|| (d = li->li_tv.vval.v_dict) == NULL)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return;
}
if (!(dict_find(d, (char_u *)"group", -1) != NULL
&& dict_find(d, (char_u *)"priority", -1) != NULL
&& dict_find(d, (char_u *)"id", -1) != NULL))
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return;
}
li = li->li_next;
{
// There must be two arguments.
vim_free(g);
- semsg(_(e_invarg2), eap->arg);
+ semsg(_(e_invalid_argument_str), eap->arg);
return;
}
end = skip_regexp(p + 1, *p, TRUE);
if (*end != *p)
{
vim_free(g);
- semsg(_(e_invarg2), p);
+ semsg(_(e_invalid_argument_str), p);
return;
}
// Windows: accept only valid codepage numbers, check below.
if (p_enc[6] != 'c' || p_enc[7] != 'p'
|| (enc_dbcs_new = atoi((char *)p_enc + 8)) == 0)
- return e_invarg;
+ return e_invalid_argument;
#else
// Unix: accept any "2byte-" name, assume current locale.
enc_dbcs_new = DBCS_2BYTE;
}
}
else // Don't know what encoding this is, reject it.
- return e_invarg;
+ return e_invalid_argument;
if (enc_dbcs_new != 0)
{
menu_path = arg;
if (*menu_path == '.')
{
- semsg(_(e_invarg2), menu_path);
+ semsg(_(e_invalid_argument_str), menu_path);
goto theend;
}
case 't': mode_idx = MENU_INDEX_TERMINAL; break;
case 'i': mode_idx = MENU_INDEX_INSERT; break;
case 'c': mode_idx = MENU_INDEX_CMDLINE; break;
- default: semsg(_(e_invarg2), arg);
+ default: semsg(_(e_invalid_argument_str), arg);
return;
}
arg = skipwhite(arg + 2);
if (arg == to || ends_excmd2(eap->arg, from)
|| ends_excmd2(eap->arg, to)
|| !ends_excmd2(eap->arg, skipwhite(arg)))
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
else
{
if (ga_grow(&menutrans_ga, 1) == OK)
if (*eap->arg != NUL)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return;
}
vim_str2nr(bp + 5, NULL, &l, STR2NR_ALL, NULL, NULL, 0, TRUE);
if (l == 0)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return 0;
}
bp += l + 5;
&n, 0, TRUE);
if (l == 0)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return 0;
}
key = (int)n;
msg_silent = msg_silent_save;
if (n != 'y')
{
- emsg(_(e_abort));
+ emsg(_(e_command_aborted));
return FAIL;
}
}
}
if (arg[len] != '>')
{
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
goto skip;
}
arg[len] = NUL; // put NUL after name
{
if (nextchar == '=' || nextchar == ':')
{
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
goto skip;
}
if (vim_strchr((char_u *)"=:&<", nextchar) == NULL
|| prefix != 1)
{
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
goto skip;
}
value = string_to_key(arg, FALSE);
if (value == 0 && (long *)varp != &p_wcm)
{
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
goto skip;
}
}
}
else if (curwin->w_p_fdc > 12)
{
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
curwin->w_p_fdc = 12;
}
}
{
if (curbuf->b_p_iminsert < 0 || curbuf->b_p_iminsert > B_IMODE_LAST)
{
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
curbuf->b_p_iminsert = B_IMODE_NONE;
}
p_iminsert = curbuf->b_p_iminsert;
else if (pp == &p_imst)
{
if (p_imst != IM_ON_THE_SPOT && p_imst != IM_OVER_THE_SPOT)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
#endif
{
if (curbuf->b_p_imsearch < -1 || curbuf->b_p_imsearch > B_IMODE_LAST)
{
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
curbuf->b_p_imsearch = B_IMODE_NONE;
}
p_imsearch = curbuf->b_p_imsearch;
}
else if (curwin->w_p_cole > 3)
{
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
curwin->w_p_cole = 3;
}
}
else if (pp == &p_pyx)
{
if (p_pyx != 0 && p_pyx != 2 && p_pyx != 3)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
#endif
}
if (curwin->w_p_nuw > 20)
{
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
curwin->w_p_nuw = 20;
}
curwin->w_nrwidth_line_count = 0; // trigger a redraw
}
else if (p_hi > 10000)
{
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
p_hi = 10000;
}
if (p_re < 0 || p_re > 2)
{
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
p_re = 0;
}
if (p_report < 0)
? "/\\*?[|;&<>\r\n" : "/\\*?[<>\r\n")) != NULL)
|| ((get_option_flags(opt_idx) & P_NDNAME)
&& vim_strpbrk(*varp, (char_u *)"*?[|;&<>\r\n") != NULL))
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
// 'term'
else if (varp == &T_NAME)
else
{
if (opt_strings_flags(bkc, p_bkc_values, flags, TRUE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
if ((((int)*flags & BKC_AUTO) != 0)
+ (((int)*flags & BKC_YES) != 0)
+ (((int)*flags & BKC_NO) != 0) != 1)
{
// Must have exactly one of "auto", "yes" and "no".
(void)opt_strings_flags(oldval, p_bkc_values, flags, TRUE);
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
}
}
else if (varp == &curwin->w_p_briopt)
{
if (briopt_check(curwin) == FAIL)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
#endif
if (init_chartab() == FAIL)
{
did_chartab = TRUE; // need to restore it below
- errmsg = e_invarg; // error in value
+ errmsg = e_invalid_argument; // error in value
}
}
|| gvarp == &curwin->w_allbuf_opt.wo_culopt)
{
if (**varp == NUL || fill_culopt_flags(*varp, curwin) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
// 'colorcolumn'
{
if (s[1] == NUL || ((s[2] != ',' || s[3] == NUL) && s[2] != NUL))
{
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
break;
}
if (s[2] == NUL)
else if (varp == &p_hl)
{
if (highlight_changed() == FAIL)
- errmsg = e_invarg; // invalid flags
+ errmsg = e_invalid_argument; // invalid flags
}
// 'nrformats'
else if (gvarp == &p_nf)
{
if (check_opt_strings(*varp, p_nf_values, TRUE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
#ifdef FEAT_SESSION
else if (varp == &p_ssop)
{
if (opt_strings_flags(p_ssop, p_ssop_values, &ssop_flags, TRUE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
if ((ssop_flags & SSOP_CURDIR) && (ssop_flags & SSOP_SESDIR))
{
// Don't allow both "sesdir" and "curdir".
(void)opt_strings_flags(oldval, p_ssop_values, &ssop_flags, TRUE);
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
}
// 'viewoptions'
else if (varp == &p_vop)
{
if (opt_strings_flags(p_vop, p_ssop_values, &vop_flags, TRUE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
#endif
else if (varp == &p_sbo)
{
if (check_opt_strings(p_sbo, p_scbopt_values, TRUE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
// 'ambiwidth'
else if (varp == &p_ambw || varp == &p_emoji)
{
if (check_opt_strings(p_ambw, p_ambw_values, FALSE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
else if (set_chars_option(curwin, &p_fcs) != NULL)
errmsg = _(e_conflicts_with_value_of_fillchars);
else
#endif
}
else
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
// 'wildmode'
else if (varp == &p_wim)
{
if (check_opt_wim() == FAIL)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
// 'wildoptions'
else if (varp == &p_wop)
{
if (check_opt_strings(p_wop, p_wop_values, TRUE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
#ifdef FEAT_WAK
{
if (*p_wak == NUL
|| check_opt_strings(p_wak, p_wak_values, FALSE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
# ifdef FEAT_MENU
# ifdef FEAT_GUI_MOTIF
else if (gui.in_use)
else if (varp == &p_ei)
{
if (check_ei() == FAIL)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
// 'encoding', 'fileencoding', 'termencoding' and 'makeencoding'
else if (vim_strchr(*varp, ',') != NULL)
// No comma allowed in 'fileencoding'; catches confusing it
// with 'fileencodings'.
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
else
{
// May show a "+" in the title now.
{
semsg(_("E950: Cannot convert between %s and %s"),
p_tenc, p_enc);
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
}
else if (varp == &p_imak)
{
if (!im_xim_isvalid_imactivate())
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
#endif
else if (varp == &curbuf->b_p_keymap)
{
if (!valid_filetype(*varp))
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
else
{
int secure_save = secure;
if (!curbuf->b_p_ma && !(opt_flags & OPT_GLOBAL))
errmsg = e_cannot_make_changes_modifiable_is_off;
else if (check_opt_strings(*varp, p_ff_values, FALSE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
else
{
// may also change 'textmode'
else if (varp == &p_ffs)
{
if (check_opt_strings(p_ffs, p_ff_values, TRUE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
else
{
// also change 'textauto'
else
p = p_cm;
if (check_opt_strings(p, p_cm_values, TRUE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
else if (crypt_self_test() == FAIL)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
else
{
// When setting the global value to empty, make it "zip".
}
if (x2 != ':' || x3 == -1 || (*p != NUL && *p != ','))
{
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
break;
}
if (*p == NUL)
{
if (p[1] != ':' || p[2] == NUL || (p[3] != NUL && p[3] != ','))
{
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
break;
}
if (p[3] == NUL)
{
verbose_stop();
if (*p_vfile != NUL && verbose_open() == FAIL)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
#ifdef FEAT_VIMINFO
// that.
mch_setmouse(FALSE);
if (opt_strings_flags(p_ttym, p_ttym_values, &ttym_flags, FALSE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
else
check_mouse_termcode();
if (termcap_active)
{
if (*p_sel == NUL
|| check_opt_strings(p_sel, p_sel_values, FALSE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
// 'selectmode'
else if (varp == &p_slm)
{
if (check_opt_strings(p_slm, p_slm_values, TRUE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
#ifdef FEAT_BROWSE
{
if (check_opt_strings(p_bsdir, p_bsdir_values, FALSE) != OK
&& !mch_isdir(p_bsdir))
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
#endif
else if (varp == &p_km)
{
if (check_opt_strings(p_km, p_km_values, TRUE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
else
{
km_stopsel = (vim_strchr(p_km, 'o') != NULL);
else if (varp == &p_mousem)
{
if (check_opt_strings(p_mousem, p_mousem_values, FALSE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
#if defined(FEAT_GUI_MOTIF) && defined(FEAT_MENU) && (XmVersion <= 1002)
else if (*p_mousem != *oldval)
// Changed from "extend" to "popup" or "popup_setpos" or vv: need
else if (varp == &p_swb)
{
if (opt_strings_flags(p_swb, p_swb_values, &swb_flags, TRUE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
// 'debug'
else if (varp == &p_debug)
{
if (check_opt_strings(p_debug, p_debug_values, TRUE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
// 'display'
else if (varp == &p_dy)
{
if (opt_strings_flags(p_dy, p_dy_values, &dy_flags, TRUE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
else
(void)init_chartab();
else if (varp == &p_ead)
{
if (check_opt_strings(p_ead, p_ead_values, FALSE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
#ifdef FEAT_CLIPBOARD
if ((is_spellfile && !valid_spellfile(*varp))
|| (!is_spellfile && !valid_spelllang(*varp)))
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
else
errmsg = did_set_spell_option(is_spellfile);
}
else if (varp == &(curwin->w_s->b_p_spo))
{
if (**varp != NUL && STRCMP("camel", *varp) != 0)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
// 'spellsuggest'
else if (varp == &p_sps)
{
if (spell_check_sps() != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
// 'mkspellmem'
else if (varp == &p_msm)
{
if (spell_check_msm() != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
#endif
else if (gvarp == &p_bh)
{
if (check_opt_strings(curbuf->b_p_bh, p_bufhidden_values, FALSE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
// When 'buftype' is set, check for valid value.
else if (gvarp == &p_bt)
{
if (check_opt_strings(curbuf->b_p_bt, p_buftype_values, FALSE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
else
{
if (curwin->w_status_height)
else if (varp == &p_cot)
{
if (check_opt_strings(p_cot, p_cot_values, TRUE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
else
completeopt_was_set();
}
{
if (check_opt_strings(p_csl, p_csl_values, FALSE) != OK
|| check_opt_strings(curbuf->b_p_csl, p_csl_values, FALSE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
#endif
else if (varp == &curwin->w_p_scl)
{
if (check_opt_strings(*varp, p_scl_values, FALSE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
// When changing the 'signcolumn' to or from 'number', recompute the
// width of the number column if 'number' or 'relativenumber' is set.
if (((*oldval == 'n' && *(oldval + 1) == 'u')
{
if (opt_strings_flags(p_toolbar, p_toolbar_values,
&toolbar_flags, TRUE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
else
{
out_flush();
else if (varp == &p_tbis)
{
if (opt_strings_flags(p_tbis, p_tbis_values, &tbis_flags, FALSE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
else
{
out_flush();
if (VIM_ISDIGIT(*p_bs))
{
if (*p_bs > '3' || p_bs[1] != NUL)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
else if (check_opt_strings(p_bs, p_bs_values, TRUE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
else if (varp == &p_bo)
{
if (opt_strings_flags(p_bo, p_bo_values, &bo_flags, TRUE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
// 'tagcase'
*flags = 0;
else if (*p == NUL
|| opt_strings_flags(p, p_tc_values, flags, FALSE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
// 'casemap'
else if (varp == &p_cmp)
{
if (opt_strings_flags(p_cmp, p_cmp_values, &cmp_flags, TRUE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
#ifdef FEAT_DIFF
else if (varp == &p_dip)
{
if (diffopt_changed() == FAIL)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
#endif
{
if (check_opt_strings(*varp, p_fdm_values, FALSE) != OK
|| *curwin->w_p_fdm == NUL)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
else
{
foldUpdateAll(curwin);
if (p == NULL)
errmsg = N_("E536: comma required");
else if (p == *varp || p[1] == NUL)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
else if (foldmethodIsMarker(curwin))
foldUpdateAll(curwin);
}
else if (varp == &p_fdo)
{
if (opt_strings_flags(p_fdo, p_fdo_values, &fdo_flags, TRUE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
// 'foldclose'
else if (varp == &p_fcl)
{
if (check_opt_strings(p_fcl, p_fcl_values, TRUE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
// 'foldignore'
else if (gvarp == &curwin->w_allbuf_opt.wo_fdi)
else
{
if (opt_strings_flags(ve, p_ve_values, flags, TRUE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
else if (STRCMP(p_ve, oldval) != 0)
{
// Recompute cursor position in case the new 've' setting
|| vim_strchr((char_u *)CSQF_FLAGS, p[1]) == NULL
|| (p[2] != NUL && p[2] != ','))
{
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
break;
}
else if (p[2] == NUL)
else if (varp == &p_rop)
{
if (!gui_mch_set_rendering_options(p_rop))
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
#endif
else if (gvarp == &p_ft)
{
if (!valid_filetype(*varp))
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
else
{
value_changed = STRCMP(oldval, *varp) != 0;
else if (gvarp == &p_syn)
{
if (!valid_filetype(*varp))
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
else
{
value_changed = STRCMP(oldval, *varp) != 0;
{
if (*curwin->w_p_twk != NUL
&& string_to_key(curwin->w_p_twk, TRUE) == 0)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
// 'termwinsize'
else if (varp == &curwin->w_p_tws)
if (p == curwin->w_p_tws
|| (*p != 'x' && *p != '*')
|| *skipdigits(p + 1) != NUL)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
}
// 'wincolor'
else if (varp == &p_twt)
{
if (check_opt_strings(*varp, p_twt_values, FALSE) != OK)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
# endif
#endif
continue;
if (*cp == ',' && cp > *varp && *(cp-1) != ',')
continue;
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
break;
}
if (errmsg == NULL)
vim_free(oldarray);
}
else
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
}
}
continue;
if (*cp == ',' && cp > *varp && *(cp-1) != ',')
continue;
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
break;
}
if (errmsg == NULL)
#endif
}
else
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
}
}
else if (varp == &p_pvp)
{
if (parse_previewpopup(NULL) == FAIL)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
# ifdef FEAT_QUICKFIX
// 'completepopup'
else if (varp == &p_cpp)
{
if (parse_completepopup(NULL) == FAIL)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
else
popup_close_info();
}
else if (gvarp == &p_cfu)
{
if (set_completefunc_option() == FAIL)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
// 'omnifunc'
else if (gvarp == &p_ofu)
{
if (set_omnifunc_option() == FAIL)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
// 'thesaurusfunc'
else if (gvarp == &p_tsrfu)
{
if (set_thesaurusfunc_option() == FAIL)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
#endif
else if (gvarp == &p_imaf)
{
if (set_imactivatefunc_option() == FAIL)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
// 'imstatusfunc'
else if (gvarp == &p_imsf)
{
if (set_imstatusfunc_option() == FAIL)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
#endif
else if (varp == &p_opfunc)
{
if (set_operatorfunc_option() == FAIL)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
#ifdef FEAT_QUICKFIX
else if (varp == &p_qftf)
{
if (qf_process_qftf_option() == FAIL)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
#endif
else if (gvarp == &p_tfu)
{
if (set_tagfunc_option() == FAIL)
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
#endif
return poppos_entries[nr].pp_val;
if (give_error)
- semsg(_(e_invarg2), str);
+ semsg(_(e_invalid_argument_str), str);
return POPPOS_NONE;
}
if (nr <= 0)
nr = find_prop_type_id(str, NULL);
if (nr <= 0)
- semsg(_(e_invarg2), str);
+ semsg(_(e_invalid_argument_str), str);
else
wp->w_popup_prop_type = nr;
}
else if (STRCMP(s, "expr") == 0)
flags = FIND_IDENT | FIND_STRING | FIND_EVAL;
else if (STRCMP(s, "any") != 0)
- semsg(_(e_invarg2), s);
+ semsg(_(e_invalid_argument_str), s);
if (flags != 0)
{
if (mousemoved)
}
}
else
- semsg(_(e_invarg2), tv_get_string(&di->di_tv));
+ semsg(_(e_invalid_argument_str), tv_get_string(&di->di_tv));
}
static void
if (di != NULL)
{
if (di->di_tv.v_type != VAR_STRING)
- semsg(_(e_invargval), name);
+ semsg(_(e_invalid_value_for_argument_str), name);
else
{
str = tv_get_string(&di->di_tv);
else
ok = FALSE;
if (!ok)
- semsg(_(e_invargNval), "close", tv_get_string(&di->di_tv));
+ semsg(_(e_invalid_value_for_argument_str_str), "close", tv_get_string(&di->di_tv));
}
str = dict_get_string(dict, (char_u *)"highlight", FALSE);
VIM_CLEAR(wp->w_popup_mask_cells);
}
else
- semsg(_(e_invargval), "mask");
+ semsg(_(e_invalid_value_for_argument_str), "mask");
}
#if defined(FEAT_TIMERS)
if (wp != NULL)
{
if (argvars[1].v_type != VAR_STRING && argvars[1].v_type != VAR_LIST)
- semsg(_(e_invarg2), tv_get_string(&argvars[1]));
+ semsg(_(e_invalid_argument_str), tv_get_string(&argvars[1]));
else
{
popup_set_buffer_text(wp->w_buffer, argvars[1]);
// A dict argument cannot be specified with a non-empty list argument
if (list->lv_len != 0 && what != NULL)
{
- semsg(_(e_invarg2),
+ semsg(_(e_invalid_argument_str),
_("cannot have both a list and a \"what\" argument"));
return FAIL;
}
if (buf == NULL)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return FAIL;
}
s = p + len + 1;
c1 = get_encoded_char_adv(&s);
if (char2cells(c1) > 1)
- return e_invarg;
+ return e_invalid_argument;
if (tab[i].cp == &lcs_chars.tab2)
{
if (*s == NUL)
- return e_invarg;
+ return e_invalid_argument;
c2 = get_encoded_char_adv(&s);
if (char2cells(c2) > 1)
- return e_invarg;
+ return e_invalid_argument;
if (!(*s == ',' || *s == NUL))
{
c3 = get_encoded_char_adv(&s);
if (char2cells(c3) > 1)
- return e_invarg;
+ return e_invalid_argument;
}
}
{
c1 = get_encoded_char_adv(&s);
if (char2cells(c1) > 1)
- return e_invarg;
+ return e_invalid_argument;
++multispace_len;
}
if (multispace_len == 0)
// lcs-multispace cannot be an empty string
- return e_invarg;
+ return e_invalid_argument;
p = s;
}
else
}
}
else
- return e_invarg;
+ return e_invalid_argument;
}
if (*p == ',')
cmd_source(char_u *fname, exarg_T *eap)
{
if (*fname == NUL)
- emsg(_(e_argreq));
+ emsg(_(e_argument_required));
else if (eap != NULL && eap->forceit)
// ":source!": read Normal mode commands
#endif
if (got_int)
- emsg(_(e_interr));
+ emsg(_(e_interrupted));
ESTACK_CHECK_NOW
estack_pop();
if (p_verbose > 1)
{
// :script {scriptId}: edit the script
if (!SCRIPT_ID_VALID(eap->line2))
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
else
{
eap->arg = SCRIPT_ITEM(eap->line2)->sn_name;
nr = getdigits(&eap->arg);
if (nr == 0 || *eap->arg != NUL)
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
else if (nr > SCRIPT_VERSION_MAX)
semsg(_("E999: scriptversion not supported: %d"), nr);
else
if (!found) // did not find it
{
if (got_int)
- emsg(_(e_interr));
+ emsg(_(e_interrupted));
else if ((options & SEARCH_MSG) == SEARCH_MSG)
{
if (p_ws)
else if (!found && action != ACTION_EXPAND)
{
if (got_int || ins_compl_interrupted())
- emsg(_(e_interr));
+ emsg(_(e_interrupted));
else if (type == FIND_DEFINE)
emsg(_("E388: Couldn't find definition"));
else
{
if (di->di_tv.v_type != VAR_LIST)
{
- semsg(_(e_invarg2), "pos");
+ semsg(_(e_invalid_argument_str), "pos");
return;
}
if (list_len(di->di_tv.vval.v_list) != 3)
{
- semsg(_(e_invarg2), "List format should be [lnum, col, off]");
+ semsg(_(e_invalid_argument_str), "List format should be [lnum, col, off]");
return;
}
li = list_find(di->di_tv.vval.v_list, 0L);
if (argvars[1].v_type != VAR_STRING
|| argvars[1].vval.v_string == NULL)
{
- semsg(_(e_invarg2), tv_get_string(&argvars[1]));
+ semsg(_(e_invalid_argument_str), tv_get_string(&argvars[1]));
return;
}
|| di->di_tv.vval.v_string == NULL
|| *di->di_tv.vval.v_string == NUL)
{
- semsg(_(e_invarg2), tv_get_string(&di->di_tv));
+ semsg(_(e_invalid_argument_str), tv_get_string(&di->di_tv));
return;
}
key = tv_get_string(&di->di_tv);
cb = get_callback(&di->di_tv);
if (cb.cb_name == NULL)
{
- semsg(_(e_invargval), "text_cb");
+ semsg(_(e_invalid_value_for_argument_str), "text_cb");
return;
}
}
}
else
{
- semsg(_(e_invarg2), arg);
+ semsg(_(e_invalid_argument_str), arg);
failed = TRUE;
break;
}
// :sign place group=*
if (lnum >= 0 || sign_name != NULL
|| (group != NULL && *group == '\0'))
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
else
sign_list_placed(buf, group);
}
if (sign_name == NULL || buf == NULL
|| (group != NULL && *group == '\0'))
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return;
}
{
if (lnum >= 0 || sign_name != NULL || (group != NULL && *group == '\0'))
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return;
}
{
if (sign_name == NULL && group == NULL && id == -1)
{
- emsg(_(e_argreq));
+ emsg(_(e_argument_required));
return;
}
{
// File or buffer is not specified or an empty group is used
// or a line number or a sign name is specified.
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return;
}
(void)sign_jump(id, group, buf);
{
if (*signid != -1)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return FAIL;
}
*signid = -2;
}
else
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return FAIL;
}
arg = skipwhite(arg);
return;
if (sign_id <= 0)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return;
}
return -1;
if (sign_id < 0)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return -1;
}
}
lnum = tv_get_lnum(&di->di_tv);
if (lnum <= 0)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
goto cleanup;
}
}
sign_id = dict_get_number(dict, (char_u *)"id");
if (sign_id <= 0)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
goto cleanup;
}
}
if (argvars[0].v_type != VAR_STRING)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return;
}
l = (int)STRLEN(curwin->w_s->b_p_spf);
if (l > 0 && (l < 4
|| STRCMP(curwin->w_s->b_p_spf + l - 4, ".add") != 0))
- errmsg = e_invarg;
+ errmsg = e_invalid_argument;
}
if (errmsg == NULL)
if (synblock->b_cap_prog == NULL)
{
synblock->b_cap_prog = rp; // restore the previous program
- return e_invarg;
+ return e_invalid_argument;
}
}
}
}
if (incount <= 0)
- emsg(_(e_invarg)); // need at least output and input names
+ emsg(_(e_invalid_argument)); // need at least output and input names
else if (vim_strchr(gettail(wfname), '_') != NULL)
emsg(_("E751: Output file name must not have region name"));
else if (incount > MAXREGIONS)
&& argvars[2].v_type != VAR_NUMBER
&& argvars[2].v_type != VAR_BOOL))
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return;
}
base = (int)tv_get_number(&argvars[1]);
if (base != 2 && base != 8 && base != 10 && base != 16)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return;
}
if (argvars[2].v_type != VAR_UNKNOWN && tv_get_bool(&argvars[2]))
if (STRLEN(fromstr) != STRLEN(tostr))
{
error:
- semsg(_(e_invarg2), fromstr);
+ semsg(_(e_invalid_argument_str), fromstr);
ga_clear(&ga);
return;
}
if (argvars[1].v_type != VAR_UNKNOWN && argvars[1].v_type != VAR_STRING)
{
- semsg(_(e_invarg2), tv_get_string(&argvars[1]));
+ semsg(_(e_invalid_argument_str), tv_get_string(&argvars[1]));
return;
}
return;
if (dir < 0 || dir > 2)
{
- semsg(_(e_invarg2), tv_get_string(&argvars[2]));
+ semsg(_(e_invalid_argument_str), tv_get_string(&argvars[2]));
return;
}
}
if (rest != NULL)
set_nextcmd(eap, rest);
else
- semsg(_(e_invarg2), arg);
+ semsg(_(e_invalid_argument_str), arg);
redraw_curbuf_later(SOME_VALID);
syn_stack_free_all(curwin->w_s); // Need to recompute all syntax.
vim_free(syn_opt_arg.next_list);
if (rest == NULL && called_emsg == orig_called_emsg)
- semsg(_(e_invarg2), arg);
+ semsg(_(e_invalid_argument_str), arg);
}
/*
if (not_enough)
semsg(_("E399: Not enough arguments: syntax region %s"), arg);
else if (illegal || rest == NULL)
- semsg(_(e_invarg2), arg);
+ semsg(_(e_invalid_argument_str), arg);
}
}
clstr_list = NULL;
if (get_id_list(&rest, opt_len, &clstr_list, eap->skip) == FAIL)
{
- semsg(_(e_invarg2), rest);
+ semsg(_(e_invalid_argument_str), rest);
break;
}
if (scl_id >= 0)
if (!got_clstr)
emsg(_("E400: No cluster specified"));
if (rest == NULL || !ends_excmd2(eap->cmd, rest))
- semsg(_(e_invarg2), arg);
+ semsg(_(e_invalid_argument_str), arg);
}
/*
else if (STRCMP(eap->arg, "report") == 0)
syntime_report();
else
- semsg(_(e_invarg2), eap->arg);
+ semsg(_(e_invalid_argument_str), eap->arg);
}
static void
&& argvar->vval.v_list != NULL
&& argvar->vval.v_list->lv_first == &range_list_item))
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return NULL;
}
tty_type = 'c';
else
{
- semsg(e_invargval, "type");
+ semsg(e_invalid_value_for_argument_str, "type");
goto theend;
}
opt.jo_set2 |= JO2_TTY_TYPE;
|| var->di_tv.vval.v_list == NULL
|| var->di_tv.vval.v_list->lv_first == &range_list_item
|| set_ansi_colors_list(vterm, var->di_tv.vval.v_list) == FAIL))
- semsg(_(e_invarg2), "g:terminal_ansi_colors");
+ semsg(_(e_invalid_argument_str), "g:terminal_ansi_colors");
}
#endif
fname2 = tv_get_string_buf_chk(&argvars[1], buf2);
if (fname1 == NULL || (do_diff && fname2 == NULL))
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return;
}
fd1 = mch_fopen((char *)fname1, READBIN);
// With "bufnr" argument: enter the window with this buffer and make it
// empty.
if (wp == NULL)
- semsg(_(e_invarg2), "bufnr");
+ semsg(_(e_invalid_argument_str), "bufnr");
else
{
buf = curbuf;
p = buf->b_term->tl_job->jv_tty_in;
break;
default:
- semsg(_(e_invarg2), tv_get_string(&argvars[1]));
+ semsg(_(e_invalid_argument_str), tv_get_string(&argvars[1]));
return;
}
if (p != NULL)
}
if (set_ansi_colors_list(term->tl_vterm, argvars[1].vval.v_list) == FAIL)
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
}
#endif
}
if (cmd == NULL || *cmd == NUL)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
goto failed;
}
}
if (cmd == NULL || *cmd == NUL)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
goto failed;
}
|| argvars[1].v_type != VAR_NUMBER
|| argvars[1].vval.v_number < 0
|| argvars[2].v_type != VAR_NUMBER)
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
else
{
alloc_fail_id = argvars[0].vval.v_number;
if (alloc_fail_id >= aid_last)
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
alloc_fail_countdown = argvars[1].vval.v_number;
alloc_fail_repeat = argvars[2].vval.v_number;
did_outofmem_msg = FALSE;
return;
if (argvars[0].v_type != VAR_STRING)
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
else
{
char_u *name = tv_get_string(&argvars[0]);
if (STRCMP(name, (char_u *)"need_fileinfo") == 0)
rettv->vval.v_number = need_fileinfo;
else
- semsg(_(e_invarg2), name);
+ semsg(_(e_invalid_argument_str), name);
}
}
return;
if (argvars[0].v_type != VAR_STRING)
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
else
{
name = tv_get_string(&argvars[0]);
if (reset_option_was_set(name) == FAIL)
- semsg(_(e_invarg2), name);
+ semsg(_(e_invalid_argument_str), name);
}
}
if (argvars[0].v_type != VAR_STRING
|| (argvars[1].v_type) != VAR_NUMBER)
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
else
{
name = tv_get_string(&argvars[0]);
}
}
else
- semsg(_(e_invarg2), name);
+ semsg(_(e_invalid_argument_str), name);
}
}
return;
if (argvars[0].v_type != VAR_STRING)
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
else
ignore_error_for_testing(tv_get_string(&argvars[0]));
}
|| (argvars[1].v_type) != VAR_NUMBER
|| (argvars[2].v_type) != VAR_NUMBER)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return;
}
which = tv_get_string(&argvars[0]);
sb = &gui.bottom_sbar;
if (sb == NULL)
{
- semsg(_(e_invarg2), which);
+ semsg(_(e_invalid_argument_str), which);
return;
}
gui_drag_scrollbar(sb, value, dragging);
if (argvars[0].v_type != VAR_NUMBER || (argvars[1].v_type) != VAR_NUMBER)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return;
}
if (error || start_lnum <= 0 || start_col <= 0
|| end_lnum <= 0 || end_col <= 0)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return;
}
if (prop_add_one(buf, type_name, id, start_lnum, end_lnum,
end_lnum = dict_get_number(dict, (char_u *)"end_lnum");
if (end_lnum < start_lnum)
{
- semsg(_(e_invargval), "end_lnum");
+ semsg(_(e_invalid_value_for_argument_str), "end_lnum");
return;
}
}
if (length < 0 || end_lnum > start_lnum)
{
- semsg(_(e_invargval), "length");
+ semsg(_(e_invalid_value_for_argument_str), "length");
return;
}
end_col = start_col + length;
end_col = dict_get_number(dict, (char_u *)"end_col");
if (end_col <= 0)
{
- semsg(_(e_invargval), "end_col");
+ semsg(_(e_invalid_value_for_argument_str), "end_col");
return;
}
}
dir = -1;
else if (*dir_s != 'f')
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return;
}
}
if (argvars[0].v_type != VAR_DICT || argvars[0].vval.v_dict == NULL)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return;
}
name = tv_get_string(&argvars[0]);
if (*name == NUL)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return;
}
name = tv_get_string(&argvars[0]);
if (*name == NUL)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return;
}
name = tv_get_string(&argvars[0]);
if (*name == NUL)
{
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return;
}
if (rettv_dict_alloc(rettv) == OK)
if (list2proftime(&argvars[0], &res) == FAIL)
{
if (in_vim9script())
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return;
}
profile_end(&res);
|| list2proftime(&argvars[1], &res) == FAIL)
{
if (in_vim9script())
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
return;
}
profile_sub(&res, &start);
if (list2proftime(&argvars[0], &tm) == OK)
rettv->vval.v_float = profile_float(&tm);
else if (in_vim9script())
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
# endif
}
# endif
if (list2proftime(&argvars[0], &tm) == OK)
rettv->vval.v_string = vim_strsave((char_u *)profile_msg(&tm));
else if (in_vim9script())
- emsg(_(e_invarg));
+ emsg(_(e_invalid_argument));
# endif
}
if (argvars[2].v_type != VAR_DICT
|| (dict = argvars[2].vval.v_dict) == NULL)
{
- semsg(_(e_invarg2), tv_get_string(&argvars[2]));
+ semsg(_(e_invalid_argument_str), tv_get_string(&argvars[2]));
return;
}
if (dict_find(dict, (char_u *)"repeat", -1) != NULL)
if (mustend && *p != endchar)
{
if (!skip)
- semsg(_(e_invarg2), *argp);
+ semsg(_(e_invalid_argument_str), *argp);
goto err_ret;
}
if (*p == endchar)
if (!aborting())
{
if (end != NULL)
- semsg(_(e_invarg2), start);
+ semsg(_(e_invalid_argument_str), start);
}
else
*pp = find_name_end(start, NULL, NULL, FNE_INCL_BR);
: eval_isnamec(name_base[i])); ++i)
;
if (name_base[i] != NUL)
- emsg_funcname((char *)e_invarg2, arg);
+ emsg_funcname((char *)e_invalid_argument_str, arg);
// In Vim9 script a function cannot have the same name as a
// variable.
if (numbered_function(name) && fudi.fd_dict == NULL)
{
if (!eap->skip)
- semsg(_(e_invarg2), eap->arg);
+ semsg(_(e_invalid_argument_str), eap->arg);
vim_free(name);
return;
}
static int included_patches[] =
{ /* Add new patch number below this line */
+/**/
+ 3961,
/**/
3960,
/**/
if (scope == NULL || scope->se_type != FOR_SCOPE)
{
- emsg(_(e_for));
+ emsg(_(e_endfor_without_for));
return NULL;
}
forscope = &scope->se_u.se_for;
return NULL;
if (scope == NULL || scope->se_type != WHILE_SCOPE)
{
- emsg(_(e_while));
+ emsg(_(e_endwhile_without_while));
return NULL;
}
cctx->ctx_scope = scope->se_outer;
// Error if not in a :try scope
if (scope == NULL || scope->se_type != TRY_SCOPE)
{
- emsg(_(e_catch));
+ emsg(_(e_catch_without_try));
return NULL;
}
// Error if not in a :try scope
if (scope == NULL || scope->se_type != TRY_SCOPE)
{
- emsg(_(e_finally));
+ emsg(_(e_finally_without_try));
return NULL;
}
isn = ((isn_T *)instr->ga_data) + scope->se_u.se_try.ts_try_label;
if (isn->isn_arg.tryref.try_ref->try_finally != 0)
{
- emsg(_(e_finally_dup));
+ emsg(_(e_multiple_finally));
return NULL;
}
if (scope == NULL || scope->se_type != TRY_SCOPE)
{
if (scope == NULL)
- emsg(_(e_no_endtry));
+ emsg(_(e_endtry_without_try));
else if (scope->se_type == WHILE_SCOPE)
emsg(_(e_missing_endwhile));
else if (scope->se_type == FOR_SCOPE)
TFN_INT | TFN_QUIET | TFN_NO_AUTOLOAD, NULL, NULL, NULL);
if (fname == NULL)
{
- semsg(_(e_invarg2), eap->arg);
+ semsg(_(e_invalid_argument_str), eap->arg);
return;
}
}
if (!IS_WHITE_OR_NUL(*eap->arg) && STRCMP(eap->arg, "noclear") != 0)
{
- semsg(_(e_invarg2), eap->arg);
+ semsg(_(e_invalid_argument_str), eap->arg);
return;
}
if (si->sn_state == SN_STATE_RELOAD && IS_WHITE_OR_NUL(*eap->arg))
// Check for valid starting character.
if (!eval_isnamec1(*arg))
{
- semsg(_(e_invarg2), arg);
+ semsg(_(e_invalid_argument_str), arg);
return arg + STRLEN(arg);
}
col = (*s == '-') ? -1 : 1;
++s;
if (!VIM_ISDIGIT(*s))
- return e_invarg;
+ return e_invalid_argument;
col = col * getdigits(&s);
if (wp->w_buffer->b_p_tw == 0)
goto skip; // 'textwidth' not set, skip this item
else if (VIM_ISDIGIT(*s))
col = getdigits(&s);
else
- return e_invarg;
+ return e_invalid_argument;
color_cols[count++] = col - 1; // 1-based to 0-based
skip:
if (*s == NUL)
break;
if (*s != ',')
- return e_invarg;
+ return e_invalid_argument;
if (*++s == NUL)
- return e_invarg; // illegal trailing comma as in "set cc=80,"
+ return e_invalid_argument; // illegal trailing comma as in "set cc=80,"
}
vim_free(wp->w_p_cc_cols);
projects / vim / commitdiff