Problem: Error messages are spread out.
Solution: Move more errors to errors.h.
vim_regfree(regmatch.regprog);
vim_free(p);
if (!didone)
- semsg(_(e_nomatch2), ((char_u **)new_ga.ga_data)[i]);
+ semsg(_(e_no_match_str_2), ((char_u **)new_ga.ga_data)[i]);
}
ga_clear(&new_ga);
}
ga_clear(&new_ga);
if (i == FAIL || exp_count == 0)
{
- emsg(_(e_nomatch));
+ emsg(_(e_no_match));
return FAIL;
}
if (STRNCMP(cmd, "++once", 6) == 0 && VIM_ISWHITE(cmd[6]))
{
if (once)
- semsg(_(e_duparg2), "++once");
+ semsg(_(e_duplicate_argument_str), "++once");
once = TRUE;
cmd = skipwhite(cmd + 6);
}
if ((STRNCMP(cmd, "++nested", 8) == 0 && VIM_ISWHITE(cmd[8])))
{
if (nested)
- semsg(_(e_duparg2), "++nested");
+ semsg(_(e_duplicate_argument_str), "++nested");
nested = TRUE;
cmd = skipwhite(cmd + 8);
}
if (STRNCMP(cmd, "nested", 6) == 0 && VIM_ISWHITE(cmd[6]))
{
if (nested)
- semsg(_(e_duparg2), "nested");
+ semsg(_(e_duplicate_argument_str), "nested");
nested = TRUE;
cmd = skipwhite(cmd + 6);
}
}
else
{
- semsg(_(e_blobidx), n1);
+ semsg(_(e_blob_index_out_of_range_nr), n1);
return FAIL;
}
}
if (n1 < 0 || n1 > bloblen)
{
if (!quiet)
- semsg(_(e_blobidx), n1);
+ semsg(_(e_blob_index_out_of_range_nr), n1);
return FAIL;
}
return OK;
if (n2 < 0 || n2 >= bloblen || n2 < n1)
{
if (!quiet)
- semsg(_(e_blobidx), n2);
+ semsg(_(e_blob_index_out_of_range_nr), n2);
return FAIL;
}
return OK;
idx = len + idx;
if (idx < 0 || idx >= len)
{
- semsg(_(e_blobidx), idx);
+ semsg(_(e_blob_index_out_of_range_nr), idx);
return;
}
if (argvars[2].v_type == VAR_UNKNOWN)
end = len + end;
if (end >= len || idx > end)
{
- semsg(_(e_blobidx), end);
+ semsg(_(e_blob_index_out_of_range_nr), end);
return;
}
newblob = blob_alloc();
if (newtv.v_type != VAR_NUMBER && newtv.v_type != VAR_BOOL)
{
clear_tv(&newtv);
- emsg(_(e_invalblob));
+ emsg(_(e_invalid_operation_for_blob));
break;
}
if (filtermap != FILTERMAP_FILTER)
{
if (b == NULL || b->bv_ga.ga_len == 0)
{
- semsg(_(e_reduceempty), "Blob");
+ semsg(_(e_reduce_of_an_empty_str_with_no_initial_value), "Blob");
return;
}
initial.v_type = VAR_NUMBER;
// If the 'fsync' option is FALSE, don't fsync(). Useful for laptops.
if (p_fs && vim_fsync(fd) != 0 && !device)
{
- errmsg = (char_u *)_(e_fsync);
+ errmsg = (char_u *)_(e_fsync_failed);
end = 0;
}
#endif
file = fopen((char *)fname, *opt == 'w' ? "w" : "a");
if (file == NULL)
{
- semsg(_(e_notopen), fname);
+ semsg(_(e_cant_open_file_str), fname);
return;
}
vim_free(log_name);
// are wildcards, the real problem is that there was no match,
// causing the pattern to be added, which has illegal characters.
if (!(options & WILD_SILENT) && (options & WILD_LIST_NOTFOUND))
- semsg(_(e_nomatch2), str);
+ semsg(_(e_no_match_str_2), str);
#endif
}
else if (xp->xp_numfiles == 0)
{
if (!(options & WILD_SILENT))
- semsg(_(e_nomatch2), str);
+ semsg(_(e_no_match_str_2), str);
}
else
{
di = dict_find(d, key, -1);
if (di == NULL)
{
- semsg(_(e_dictkey), key);
+ semsg(_(e_key_not_present_in_dictionary), key);
return;
}
if (argvars[0].v_type != VAR_DICT)
{
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
return;
}
if (argvars[0].v_type != VAR_DICT)
{
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
return;
}
if (argvars[0].vval.v_dict == NULL)
if (dirbuf[0] != NUL)
{
if (mch_chdir((char *)dirbuf) != 0)
- emsg(_(e_prev_dir));
+ emsg(_(e_cannot_go_back_to_previous_directory));
shorten_fnames(TRUE);
}
#endif
INIT(= N_("E149: Sorry, no help for %s"));
EXTERN char e_not_a_directory_str[]
INIT(= N_("E150: Not a directory: %s"));
-EXTERN char e_no_match_str[]
+EXTERN char e_no_match_str_1[]
INIT(= N_("E151: No match: %s"));
EXTERN char e_cannot_open_str_for_writing_1[]
INIT(= N_("E152: Cannot open %s for writing"));
EXTERN char e_cannot_start_the_GUI[]
INIT(= N_("E229: Cannot start the GUI"));
+#if defined(FEAT_GUI_GTK) || defined(FEAT_GUI_X11)
+EXTERN char e_cannot_open_display[]
+ INIT(= N_("E233: cannot open display"));
+#endif
#if defined(FEAT_GUI) && defined(FEAT_XFONTSET)
EXTERN char e_unknown_fontset_str[]
INIT(= N_("E234: Unknown fontset: %s"));
EXTERN char e_font_str_is_not_fixed_width[]
INIT(= N_("E236: Font \"%s\" is not fixed-width"));
#endif
+#ifdef FEAT_CLIENTSERVER
+EXTERN char e_no_registered_server_named_str[]
+ INIT(= N_("E247: no registered server named \"%s\""));
+#endif
EXTERN char e_window_layout_changed_unexpectedly[]
INIT(= N_("E249: window layout changed unexpectedly"));
#if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS)
INIT(= N_("E341: Internal error: lalloc(0, )"));
EXTERN char e_out_of_memory_allocating_nr_bytes[]
INIT(= N_("E342: Out of memory! (allocating %lu bytes)"));
+#ifdef FEAT_LIBCALL
+EXTERN char e_library_call_failed_for_str[]
+ INIT(= N_("E364: Library call failed for \"%s()\""));
+#endif
EXTERN char e_no_such_group_str[]
INIT(= N_("E367: No such group: \"%s\""));
+#ifdef USING_LOAD_LIBRARY
+EXTERN char e_could_not_load_library_str_str[]
+ INIT(= N_("E370: Could not load library %s: %s"));
+#endif
EXTERN char e_cannot_write_buftype_option_is_set[]
INIT(= N_("E382: Cannot write, 'buftype' option is set"));
+#ifdef USING_LOAD_LIBRARY
+EXTERN char e_could_not_load_library_function_str[]
+ INIT(= N_("E448: Could not load library function %s"));
+#endif
+#if defined(UNIX) || defined(FEAT_SESSION)
+EXTERN char e_cannot_go_back_to_previous_directory[]
+ INIT(= N_("E459: Cannot go back to previous directory"));
+#endif
+#ifdef FEAT_EVAL
+EXTERN char e_illegal_variable_name_str[]
+ INIT(= N_("E461: Illegal variable name: %s"));
+#endif
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_("E475: Invalid value for argument %s: %s"));
EXTERN char e_invalid_command[]
INIT(= N_("E476: Invalid command"));
+EXTERN char e_no_bang_allowed[]
+ INIT(= N_("E477: No ! allowed"));
#ifdef FEAT_EVAL
EXTERN char e_invalid_command_str[]
INIT(= N_("E476: Invalid command: %s"));
#endif
+EXTERN char e_cant_create_file_str[]
+ INIT(= N_("E482: Can't create file %s"));
+EXTERN char e_cant_get_temp_file_name[]
+ INIT(= N_("E483: Can't get temp file name"));
+EXTERN char e_cant_open_file_str[]
+ INIT(= N_("E484: Can't open file %s"));
+EXTERN char e_cant_read_file_str[]
+ INIT(= N_("E485: Can't read file %s"));
+EXTERN char e_pattern_not_found[]
+ INIT(= N_("E486: Pattern not found"));
+EXTERN char e_pattern_not_found_str[]
+ INIT(= N_("E486: Pattern not found: %s"));
+EXTERN char e_argument_must_be_positive[]
+ INIT(= N_("E487: Argument must be positive"));
+EXTERN char e_no_match[]
+ INIT(= N_("E479: No match"));
+EXTERN char e_no_match_str_2[]
+ INIT(= N_("E480: No match: %s"));
+EXTERN char e_no_range_allowed[]
+ INIT(= N_("E481: No range allowed"));
// E502
EXTERN char e_is_a_directory[]
EXTERN char e_partial_writes_disallowed_for_netbeans_buffers[]
INIT(= N_("Partial writes disallowed for NetBeans buffers"));
#endif
+#ifdef HAVE_FSYNC
+EXTERN char e_fsync_failed[]
+ INIT(= N_("E667: Fsync failed"));
+#endif
EXTERN char e_no_matching_autocommands_for_acwrite_buffer[]
INIT(= N_("E676: No matching autocommands for acwrite buffer"));
EXTERN char e_buffer_nr_invalid_buffer_number[]
INIT(= N_("E680: <buffer=%d>: invalid buffer number"));
#ifdef FEAT_EVAL
+EXTERN char e_list_index_out_of_range_nr[]
+ INIT(= N_("E684: list index out of range: %ld"));
+#endif
+EXTERN char e_internal_error_str[]
+ INIT(= N_("E685: Internal error: %s"));
+#ifdef FEAT_EVAL
EXTERN char e_cannot_index_a_funcref[]
INIT(= N_("E695: Cannot index a Funcref"));
+EXTERN char e_missing_end_of_list_rsb_str[]
+ INIT(= N_("E697: Missing end of List ']': %s"));
EXTERN char e_list_value_has_more_items_than_targets[]
INIT(= N_("E710: List value has more items than targets"));
EXTERN char e_list_value_does_not_have_enough_items[]
INIT(= N_("E711: List value does not have enough items"));
+EXTERN char e_argument_of_str_must_be_list_or_dictionary[]
+ INIT(= N_("E712: Argument of %s must be a List or Dictionary"));
+EXTERN char e_cannot_use_empty_key_for_dictionary[]
+ INIT(= N_("E713: Cannot use empty key for Dictionary"));
+EXTERN char e_list_required[]
+ INIT(= N_("E714: List required"));
+EXTERN char e_dictionary_required[]
+ INIT(= N_("E715: Dictionary required"));
+EXTERN char e_key_not_present_in_dictionary[]
+ INIT(= N_("E716: Key not present in Dictionary: \"%s\""));
EXTERN char e_cannot_slice_dictionary[]
INIT(= N_("E719: Cannot slice a Dictionary"));
+EXTERN char e_wrong_variable_type_for_str_equal[]
+ INIT(= N_("E734: Wrong variable type for %s="));
EXTERN char e_value_is_locked[]
INIT(= N_("E741: Value is locked"));
EXTERN char e_value_is_locked_str[]
INIT(= N_("E742: Cannot change value"));
EXTERN char e_cannot_change_value_of_str[]
INIT(= N_("E742: Cannot change value of %s"));
+#endif
+#ifdef FEAT_SPELL
+EXTERN char e_spell_checking_is_not_possible[]
+ INIT(= N_("E756: Spell checking is not possible"));
+#endif
+#ifdef FEAT_QUICKFIX
+EXTERN char e_no_location_list[]
+ INIT(= N_("E776: No location list"));
+#endif
+#ifdef FEAT_EVAL
EXTERN char e_cannot_set_variable_in_sandbox[]
INIT(= N_("E794: Cannot set variable in the sandbox"));
EXTERN char e_cannot_set_variable_in_sandbox_str[]
INIT(= N_("E795: Cannot delete variable %s"));
#endif
+#ifndef FEAT_ARABIC
+EXTERN char e_arabic_cannot_be_used_not_enabled_at_compile_time[]
+ INIT(= N_("E800: Arabic cannot be used: Not enabled at compile time\n"));
+#endif
+#ifdef FEAT_EVAL
+EXTERN char e_cannot_use_percent_with_float[]
+ INIT(= N_("E804: Cannot use '%' with Float"));
+#endif
EXTERN char e_blowfish_big_little_endian_use_wrong[]
INIT(= N_("E817: Blowfish big/little endian use wrong"));
EXTERN char e_sha256_test_failed[]
INIT(= N_("E834: Conflicts with value of 'listchars'"));
EXTERN char e_conflicts_with_value_of_fillchars[]
INIT(= N_("E835: Conflicts with value of 'fillchars'"));
+// E839 unused
EXTERN char e_autocommands_caused_command_to_abort[]
INIT(= N_("E855: Autocommands caused command to abort"));
#ifdef FEAT_EVAL
EXTERN char e_assert_fails_second_arg[]
INIT(= N_("E856: \"assert_fails()\" second argument must be a string or a list with one or two strings"));
+EXTERN char e_dictionary_key_str_required[]
+ INIT(= N_("E857: Dictionary key \"%s\" required"));
+#endif
+#ifdef FEAT_PROP_POPUP
+EXTERN char e_number_required[]
+ INIT(= N_("E889: Number required"));
+#endif
+#ifdef FEAT_EVAL
+EXTERN char e_argument_of_str_must_be_list_dictionary_or_blob[]
+ INIT(= N_("E896: Argument of %s must be a List, Dictionary or Blob"));
+EXTERN char e_list_or_blob_required[]
+ INIT(= N_("E897: List or Blob required"));
+#endif
+#ifdef FEAT_EVAL
EXTERN char e_using_invalid_value_as_string_str[]
INIT(= N_("E908: using an invalid value as a String: %s"));
EXTERN char e_cannot_index_special_variable[]
INIT(= N_("E909: Cannot index a special variable"));
+EXTERN char e_string_required[]
+ INIT(= N_("E928: String required"));
#endif
EXTERN char e_buffer_cannot_be_registered[]
INIT(= N_("E931: Buffer cannot be registered"));
+#ifdef FEAT_EVAL
+EXTERN char e_function_was_deleted_str[]
+ INIT(= N_("E933: Function was deleted: %s"));
+#endif
EXTERN char e_cannot_delete_current_group[]
INIT(= N_("E936: Cannot delete the current group"));
EXTERN char e_attempt_to_delete_buffer_that_is_in_use_str[]
INIT(= N_("E966: Invalid line number: %ld"));
EXTERN char e_blob_value_does_not_have_right_number_of_bytes[]
INIT(= N_("E972: Blob value does not have the right number of bytes"));
+#ifdef FEAT_EVAL
+EXTERN char e_invalid_operation_for_blob[]
+ INIT(= N_("E978: Invalid operation for Blob"));
+EXTERN char e_blob_index_out_of_range_nr[]
+ INIT(= N_("E979: Blob index out of range: %ld"));
+#endif
+EXTERN char e_duplicate_argument_str[]
+ INIT(= N_("E983: Duplicate argument: %s"));
+#ifdef FEAT_EVAL
+EXTERN char e_cannot_modify_existing_variable[]
+ INIT(= N_("E995: Cannot modify existing variable"));
+EXTERN char e_cannot_lock_an_option[]
+ INIT(= N_("E996: Cannot lock an option"));
+EXTERN char e_reduce_of_an_empty_str_with_no_initial_value[]
+ INIT(= N_("E998: Reduce of an empty %s with no initial value"));
+#endif
EXTERN char e_command_not_supported_in_vim9_script_missing_var_str[]
INIT(= N_("E1100: Command not supported in Vim9 script (missing :var?): %s"));
if (len == 0)
{
if (!quiet)
- emsg(_(e_emptykey));
+ emsg(_(e_cannot_use_empty_key_for_dictionary));
return NULL;
}
p = key + len;
if (lp->ll_dict == get_vimvar_dict()
|| &lp->ll_dict->dv_hashtab == get_funccal_args_ht())
{
- semsg(_(e_illvar), name);
+ semsg(_(e_illegal_variable_name_str), name);
clear_tv(&var1);
return NULL;
}
if (*p == '[' || *p == '.' || unlet)
{
if (!quiet)
- semsg(_(e_dictkey), key);
+ semsg(_(e_key_not_present_in_dictionary), key);
clear_tv(&var1);
return NULL;
}
if (op != NULL && *op != '=')
{
- semsg(_(e_letwrong), op);
+ semsg(_(e_wrong_variable_type_for_str_equal), op);
return;
}
if (value_check_lock(lp->ll_blob->bv_lock, lp->ll_name, FALSE))
if ((flags & (ASSIGN_CONST | ASSIGN_FINAL))
&& (flags & ASSIGN_FOR_LOOP) == 0)
{
- emsg(_(e_cannot_mod));
+ emsg(_(e_cannot_modify_existing_variable));
*endp = cc;
return;
}
{
if (op != NULL && *op != '=')
{
- semsg(_(e_dictkey), lp->ll_newkey);
+ semsg(_(e_key_not_present_in_dictionary), lp->ll_newkey);
return;
}
if (dict_wrong_func_name(lp->ll_tv->vval.v_dict, rettv,
}
}
- semsg(_(e_letwrong), op);
+ semsg(_(e_wrong_variable_type_for_str_equal), op);
return FAIL;
}
}
else
{
- emsg(_(e_modulus));
+ emsg(_(e_cannot_use_percent_with_float));
return FAIL;
}
rettv->v_type = VAR_FLOAT;
{
if (keylen > 0)
key[keylen] = NUL;
- semsg(_(e_dictkey), key);
+ semsg(_(e_key_not_present_in_dictionary), key);
}
return FAIL;
}
if (argvars[1].v_type != VAR_LIST)
{
- emsg(_(e_listreq));
+ emsg(_(e_list_required));
return;
}
if (argvars[1].vval.v_list == NULL)
{
if (argvars[2].v_type != VAR_DICT)
{
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
return;
}
selfdict = argvars[2].vval.v_dict;
}
}
else
- semsg(_(e_listdictblobarg), "get()");
+ semsg(_(e_argument_of_str_must_be_list_dictionary_or_blob), "get()");
if (tv == NULL)
{
}
else if (argvars[0].v_type != VAR_LIST)
{
- emsg(_(e_listblobreq));
+ emsg(_(e_list_or_blob_required));
return;
}
else if (lv.ll_range)
emsg(_("E786: Range not allowed"));
else if (lv.ll_newkey != NULL)
- semsg(_(e_dictkey), lv.ll_newkey);
+ semsg(_(e_key_not_present_in_dictionary), lv.ll_newkey);
else if (lv.ll_list != NULL)
// List item.
rettv->vval.v_number = tv_islocked(&lv.ll_li->li_tv);
}
}
else
- semsg(_(e_listdictarg), domax ? "max()" : "min()");
+ semsg(_(e_argument_of_str_must_be_list_or_dictionary), domax ? "max()" : "min()");
rettv->vval.v_number = n;
}
if (argvars[0].v_type != VAR_DICT)
{
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
return;
}
// second argument: dict with items to set in the tag stack
if (argvars[1].v_type != VAR_DICT)
{
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
return;
}
d = argvars[1].vval.v_dict;
}
else
{
- emsg(_(e_stringreq));
+ emsg(_(e_string_required));
return;
}
if (*curwin->w_s->b_p_spl == NUL)
{
- emsg(_(e_no_spell));
+ emsg(_(e_spell_checking_is_not_possible));
curwin->w_p_spell = wo_spell_save;
return;
}
if (*curwin->w_s->b_p_spl == NUL)
{
- emsg(_(e_no_spell));
+ emsg(_(e_spell_checking_is_not_possible));
curwin->w_p_spell = wo_spell_save;
return;
}
// ":let [v1, v2] = list" or ":for [v1, v2] in listlist"
if (tv->v_type != VAR_LIST || (l = tv->vval.v_list) == NULL)
{
- emsg(_(e_listreq));
+ emsg(_(e_list_required));
return FAIL;
}
else
{
if (op != NULL && vim_strchr((char_u *)"+-*/%", *op) != NULL)
- semsg(_(e_letwrong), op);
+ semsg(_(e_wrong_variable_type_for_str_equal), op);
else if (endchars != NULL
&& vim_strchr(endchars, *skipwhite(arg)) == NULL)
emsg(_(e_unexpected_characters_in_let));
if ((flags & (ASSIGN_CONST | ASSIGN_FINAL))
&& (flags & ASSIGN_FOR_LOOP) == 0)
{
- emsg(_(e_const_option));
+ emsg(_(e_cannot_lock_an_option));
return NULL;
}
if (((opt_type == gov_bool || opt_type == gov_number) && *op == '.')
|| (opt_type == gov_string && *op != '.'))
{
- semsg(_(e_letwrong), op);
+ semsg(_(e_wrong_variable_type_for_str_equal), op);
failed = TRUE; // don't set the value
}
arg_end = p;
}
else
- emsg(_(e_stringreq));
+ emsg(_(e_string_required));
}
*p = c1;
vim_free(stringval);
}
++arg;
if (op != NULL && vim_strchr((char_u *)"+-*/%", *op) != NULL)
- semsg(_(e_letwrong), op);
+ semsg(_(e_wrong_variable_type_for_str_equal), op);
else if (endchars != NULL
&& vim_strchr(endchars, *skipwhite(arg + 1)) == NULL)
emsg(_(e_unexpected_characters_in_let));
ht = find_var_ht(name, &varname);
if (ht == NULL || *varname == NUL)
{
- semsg(_(e_illvar), name);
+ semsg(_(e_illegal_variable_name_str), name);
goto failed;
}
is_script_local = ht == get_script_local_ht();
if ((flags & (ASSIGN_CONST | ASSIGN_FINAL))
&& (flags & ASSIGN_FOR_LOOP) == 0)
{
- emsg(_(e_cannot_mod));
+ emsg(_(e_cannot_modify_existing_variable));
goto failed;
}
// Can't add "v:" or "a:" variable.
if (ht == &vimvarht || ht == get_funccal_args_ht())
{
- semsg(_(e_illvar), name);
+ semsg(_(e_illegal_variable_name_str), name);
goto failed;
}
if (!eval_isnamec1(*p) && (p == varname || !VIM_ISDIGIT(*p))
&& !(autoload && *p == AUTOLOAD_CHAR))
{
- semsg(_(e_illvar), varname);
+ semsg(_(e_illegal_variable_name_str), varname);
return FALSE;
}
return TRUE;
if ((do_in && (itmp = vim_tempname('i', FALSE)) == NULL)
|| (do_out && (otmp = vim_tempname('o', FALSE)) == NULL))
{
- emsg(_(e_notmp));
+ emsg(_(e_cant_get_temp_file_name));
goto filterend;
}
#if defined(FEAT_EVAL)
if (!aborting())
#endif
- (void)semsg(_(e_notcreate), itmp); // will call wait_return
+ (void)semsg(_(e_cant_create_file_str), itmp); // will call wait_return
goto filterend;
}
if (curbuf != old_curbuf)
#endif
{
msg_putchar('\n');
- semsg(_(e_notread), otmp);
+ semsg(_(e_cant_read_file_str), otmp);
}
goto error;
}
else if (got_match) // did find something but nothing substituted
msg("");
else if (subflags.do_error) // nothing found
- semsg(_(e_patnotf2), get_search_pat());
+ semsg(_(e_pattern_not_found_str), get_search_pat());
}
#ifdef FEAT_FOLDING
if (!ni && !(ea.argt & EX_RANGE) && ea.addr_count > 0)
{
- // no range allowed
- errormsg = _(e_norange);
+ errormsg = _(e_no_range_allowed);
goto doend;
}
}
- if (!ni && !(ea.argt & EX_BANG) && ea.forceit) // no <!> allowed
+ if (!ni && !(ea.argt & EX_BANG) && ea.forceit)
{
- errormsg = _(e_nobang);
+ errormsg = _(e_no_bang_allowed);
goto doend;
}
addr_error(cmd_addr_T addr_type)
{
if (addr_type == ADDR_NONE)
- emsg(_(e_norange));
+ emsg(_(e_no_range_allowed));
else
emsg(_(e_invalid_range));
}
if (vim_regexec(®match, line, (colnr_T)0))
curwin->w_cursor.col = (colnr_T)(regmatch.startp[0] - line);
else
- emsg(_(e_nomatch));
+ emsg(_(e_no_match));
vim_regfree(regmatch.regprog);
vim_free(line);
}
#if defined(FEAT_EVAL)
if (!aborting())
#endif
- semsg(_(e_notopen), eap->arg);
+ semsg(_(e_cant_open_file_str), eap->arg);
}
else
{
#if (!defined(FEAT_GUI) || defined(VIMDLL)) && defined(MSWIN)
# define FEAT_VTP
#endif
+
+#if defined(DYNAMIC_PERL) \
+ || defined(DYNAMIC_PYTHON) || defined(DYNAMIC_PYTHON3) \
+ || defined(DYNAMIC_RUBY) \
+ || defined(DYNAMIC_TCL) \
+ || defined(DYNAMIC_ICONV) \
+ || defined(DYNAMIC_GETTEXT) \
+ || defined(DYNAMIC_MZSCHEME) \
+ || defined(DYNAMIC_LUA) \
+ || defined(FEAT_TERMINAL)
+# define USING_LOAD_LIBRARY
+#endif
if (!ok)
{
failed = TRUE;
- semsg(_(e_notopen), path);
+ semsg(_(e_cant_open_file_str), path);
}
else
{
if (dirp == NULL)
{
failed = TRUE;
- semsg(_(e_notopen), path);
+ semsg(_(e_cant_open_file_str), path);
}
else
{
if (tv->v_type != VAR_DICT)
{
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
return FAIL;
}
compare = dict_get_string(tv->vval.v_dict, (char_u *)"sort", FALSE);
else
{
- semsg(_(e_no_dict_key), "sort");
+ semsg(_(e_dictionary_key_str_required), "sort");
return FAIL;
}
}
if (*fname == NUL || (fd = mch_fopen((char *)fname, READBIN)) == NULL)
{
- semsg(_(e_notopen), *fname == NUL ? (char_u *)_("<empty>") : fname);
+ semsg(_(e_cant_open_file_str), *fname == NUL ? (char_u *)_("<empty>") : fname);
return;
}
{
if (read_blob(fd, rettv->vval.v_blob) == FAIL)
{
- semsg(_(e_notread), fname);
+ semsg(_(e_cant_read_file_str), fname);
// An empty blob is returned on error.
blob_free(rettv->vval.v_blob);
rettv->vval.v_blob = NULL;
if (*fname == NUL || (fd = mch_fopen((char *)fname,
append ? APPENDBIN : WRITEBIN)) == NULL)
{
- semsg(_(e_notcreate), *fname == NUL ? (char_u *)_("<empty>") : fname);
+ semsg(_(e_cant_create_file_str), *fname == NUL ? (char_u *)_("<empty>") : fname);
ret = -1;
}
else if (blob)
expand_env(name, NameBuff, MAXPATHL);
if ((scriptin[curscript] = mch_fopen((char *)NameBuff, READBIN)) == NULL)
{
- semsg(_(e_notopen), name);
+ semsg(_(e_cant_open_file_str), name);
if (curscript)
--curscript;
return;
* Some error messages that can be shared are included here.
* They should be moved to errors.h.
*/
-EXTERN char e_intern2[] INIT(= N_("E685: Internal error: %s"));
-EXTERN char e_duparg2[] INIT(= N_("E983: Duplicate argument: %s"));
-#ifdef FEAT_SPELL
-EXTERN char e_no_spell[] INIT(= N_("E756: Spell checking is not possible"));
-#endif
-#ifdef FEAT_LIBCALL
-EXTERN char e_libcall[] INIT(= N_("E364: Library call failed for \"%s()\""));
-#endif
-#ifdef HAVE_FSYNC
-EXTERN char e_fsync[] INIT(= N_("E667: Fsync failed"));
-#endif
-#if defined(DYNAMIC_PERL) \
- || defined(DYNAMIC_PYTHON) || defined(DYNAMIC_PYTHON3) \
- || defined(DYNAMIC_RUBY) \
- || defined(DYNAMIC_TCL) \
- || defined(DYNAMIC_ICONV) \
- || defined(DYNAMIC_GETTEXT) \
- || defined(DYNAMIC_MZSCHEME) \
- || defined(DYNAMIC_LUA) \
- || defined(FEAT_TERMINAL)
-EXTERN char e_loadlib[] INIT(= N_("E370: Could not load library %s: %s"));
-EXTERN char e_loadfunc[] INIT(= N_("E448: Could not load library function %s"));
-#endif
-EXTERN char e_nobang[] INIT(= N_("E477: No ! allowed"));
-#ifndef FEAT_ARABIC
-EXTERN char e_noarabic[] INIT(= N_("E800: Arabic cannot be used: Not enabled at compile time\n"));
-#endif
-EXTERN char e_nomatch[] INIT(= N_("E479: No match"));
-EXTERN char e_nomatch2[] INIT(= N_("E480: No match: %s"));
-EXTERN char e_norange[] INIT(= N_("E481: No range allowed"));
-#ifdef FEAT_CLIENTSERVER
-EXTERN char e_noserver[] INIT(= N_("E247: no registered server named \"%s\""));
-#endif
-EXTERN char e_notcreate[] INIT(= N_("E482: Can't create file %s"));
-EXTERN char e_notmp[] INIT(= N_("E483: Can't get temp file name"));
-EXTERN char e_notopen[] INIT(= N_("E484: Can't open file %s"));
-EXTERN char e_notread[] INIT(= N_("E485: Can't read file %s"));
-#if defined(FEAT_GUI_GTK) || defined(FEAT_GUI_X11)
-EXTERN char e_opendisp[] INIT(= N_("E233: cannot open display"));
-#endif
-EXTERN char e_patnotf[] INIT(= N_("Pattern not found"));
-EXTERN char e_patnotf2[] INIT(= N_("E486: Pattern not found: %s"));
-EXTERN char e_positive[] INIT(= N_("E487: Argument must be positive"));
-#if defined(UNIX) || defined(FEAT_SESSION)
-EXTERN char e_prev_dir[] INIT(= N_("E459: Cannot go back to previous directory"));
-#endif
-
-#ifdef FEAT_QUICKFIX
-EXTERN char e_loclist[] INIT(= N_("E776: No location list"));
-#endif
-#ifdef FEAT_EVAL
-EXTERN char e_letwrong[] INIT(= N_("E734: Wrong variable type for %s="));
-EXTERN char e_illvar[] INIT(= N_("E461: Illegal variable name: %s"));
-EXTERN char e_cannot_mod[] INIT(= N_("E995: Cannot modify existing variable"));
-EXTERN char e_stringreq[] INIT(= N_("E928: String required"));
-EXTERN char e_numberreq[] INIT(= N_("E889: Number required"));
-EXTERN char e_boolreq[] INIT(= N_("E839: Bool required"));
-EXTERN char e_emptykey[] INIT(= N_("E713: Cannot use empty key for Dictionary"));
-EXTERN char e_dictreq[] INIT(= N_("E715: Dictionary required"));
-EXTERN char e_listidx[] INIT(= N_("E684: list index out of range: %ld"));
-EXTERN char e_blobidx[] INIT(= N_("E979: Blob index out of range: %ld"));
-EXTERN char e_invalblob[] INIT(= N_("E978: Invalid operation for Blob"));
-EXTERN char e_func_deleted[] INIT(= N_("E933: Function was deleted: %s"));
-EXTERN char e_dictkey[] INIT(= N_("E716: Key not present in Dictionary: \"%s\""));
-EXTERN char e_listreq[] INIT(= N_("E714: List required"));
-EXTERN char e_listblobreq[] INIT(= N_("E897: List or Blob required"));
-EXTERN char e_list_end[] INIT(= N_("E697: Missing end of List ']': %s"));
-EXTERN char e_listdictarg[] INIT(= N_("E712: Argument of %s must be a List or Dictionary"));
-EXTERN char e_listdictblobarg[] INIT(= N_("E896: Argument of %s must be a List, Dictionary or Blob"));
-EXTERN char e_modulus[] INIT(= N_("E804: Cannot use '%' with Float"));
-EXTERN char e_const_option[] INIT(= N_("E996: Cannot lock an option"));
-EXTERN char e_reduceempty[] INIT(= N_("E998: Reduce of an empty %s with no initial value"));
-EXTERN char e_no_dict_key[] INIT(= N_("E857: Dictionary key \"%s\" required"));
-#endif
EXTERN char e_secure[] INIT(= N_("E523: Not allowed here"));
EXTERN char e_textlock[] INIT(= N_("E578: Not allowed to change text here"));
EXTERN char e_textwinlock[] INIT(= N_("E565: Not allowed to change text or change window"));
{
gui.dying = TRUE;
if (give_message)
- emsg(_((char *)e_opendisp));
+ emsg(_((char *)e_cannot_open_display));
return FAIL;
}
return OK;
if (!gtk_init_check(&gui_argc, &gui_argv))
{
gui.dying = TRUE;
- emsg(_((char *)e_opendisp));
+ emsg(_((char *)e_cannot_open_display));
return FAIL;
}
if (app_context == NULL || gui.dpy == NULL)
{
gui.dying = TRUE;
- emsg(_(e_opendisp));
+ emsg(_(e_cannot_open_display));
return FAIL;
}
return OK;
prt_ps_file_name = vim_tempname('p', TRUE);
if (prt_ps_file_name == NULL)
{
- emsg(_(e_notmp));
+ emsg(_(e_cant_get_temp_file_name));
return FAIL;
}
prt_ps_fd = mch_fopen((char *)prt_ps_file_name, WRITEBIN);
|| filecount == 0)
{
if (!got_int)
- semsg(_(e_no_match_str), NameBuff);
+ semsg(_(e_no_match_str_1), NameBuff);
return;
}
if (di->di_tv.v_type != VAR_STRING || di->di_tv.vval.v_string == NULL)
{
- emsg(_(e_stringreq));
+ emsg(_(e_string_required));
*error = TRUE;
return NULL;
}
if (di->di_tv.v_type != VAR_DICT || di->di_tv.vval.v_dict == NULL)
{
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
return FALSE;
}
{
if (li->li_tv.v_type != VAR_DICT)
{
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
return;
}
f = mch_fopen((char *)tmp, "w");
if (f == NULL)
- semsg(_(e_notopen), tmp);
+ semsg(_(e_cant_open_file_str), tmp);
else
{
cs_file_results(f, nummatches);
if (!hinstLua)
{
if (verbose)
- semsg(_(e_loadlib), libname, load_dll_error());
+ semsg(_(e_could_not_load_library_str_str), libname, load_dll_error());
return FAIL;
}
for (reg = luaV_dll; reg->func; reg++)
close_dll(hinstLua);
hinstLua = 0;
if (verbose)
- semsg(_(e_loadfunc), reg->name);
+ semsg(_(e_could_not_load_library_function_str), reg->name);
return FAIL;
}
}
if (!hMzGC)
{
if (verbose)
- semsg(_(e_loadlib), gc_dll, GetWin32Error());
+ semsg(_(e_could_not_load_library_str_str), gc_dll, GetWin32Error());
return FAIL;
}
if (!hMzSch)
{
if (verbose)
- semsg(_(e_loadlib), sch_dll, GetWin32Error());
+ semsg(_(e_could_not_load_library_str_str), sch_dll, GetWin32Error());
return FAIL;
}
FreeLibrary(hMzGC);
hMzGC = 0;
if (verbose)
- semsg(_(e_loadfunc), thunk->name);
+ semsg(_(e_could_not_load_library_function_str), thunk->name);
return FAIL;
}
}
FreeLibrary(hMzGC);
hMzGC = 0;
if (verbose)
- semsg(_(e_loadfunc), thunk->name);
+ semsg(_(e_could_not_load_library_function_str), thunk->name);
return FAIL;
}
}
close_dll(hPerlLib);
hPerlLib = NULL;
if (verbose)
- semsg((const char *)_(e_loadfunc), perl_funcname_table[i].name);
+ semsg((const char *)_(e_could_not_load_library_function_str), perl_funcname_table[i].name);
return FAIL;
}
}
if (!hinstPython)
{
if (verbose)
- semsg(_(e_loadlib), libname, load_dll_error());
+ semsg(_(e_could_not_load_library_str_str), libname, load_dll_error());
return FAIL;
}
close_dll(hinstPython);
hinstPython = 0;
if (verbose)
- semsg(_(e_loadfunc), python_funcname_table[i].name);
+ semsg(_(e_could_not_load_library_function_str), python_funcname_table[i].name);
return FAIL;
}
}
close_dll(hinstPython);
hinstPython = 0;
if (verbose)
- semsg(_(e_loadfunc), "PyUnicode_UCSX_*");
+ semsg(_(e_could_not_load_library_function_str), "PyUnicode_UCSX_*");
return FAIL;
}
if (!hinstPy3)
{
if (verbose)
- semsg(_(e_loadlib), libname, load_dll_error());
+ semsg(_(e_could_not_load_library_str_str), libname, load_dll_error());
return FAIL;
}
close_dll(hinstPy3);
hinstPy3 = 0;
if (verbose)
- semsg(_(e_loadfunc), py3_funcname_table[i].name);
+ semsg(_(e_could_not_load_library_function_str), py3_funcname_table[i].name);
return FAIL;
}
}
close_dll(hinstPy3);
hinstPy3 = 0;
if (verbose)
- semsg(_(e_loadfunc), "PyUnicode_UCSX_*");
+ semsg(_(e_could_not_load_library_function_str), "PyUnicode_UCSX_*");
return FAIL;
}
if (!hinstRuby)
{
if (verbose)
- semsg(_(e_loadlib), libname, load_dll_error());
+ semsg(_(e_could_not_load_library_str_str), libname, load_dll_error());
return FAIL;
}
close_dll(hinstRuby);
hinstRuby = NULL;
if (verbose)
- semsg(_(e_loadfunc), ruby_funcname_table[i].name);
+ semsg(_(e_could_not_load_library_function_str), ruby_funcname_table[i].name);
return FAIL;
}
}
if (!(hTclLib = load_dll(libname)))
{
if (verbose)
- semsg(_(e_loadlib), libname, load_dll_error());
+ semsg(_(e_could_not_load_library_str_str), libname, load_dll_error());
return FAIL;
}
for (i = 0; tcl_funcname_table[i].ptr; ++i)
close_dll(hTclLib);
hTclLib = NULL;
if (verbose)
- semsg(_(e_loadfunc), tcl_funcname_table[i].name);
+ semsg(_(e_could_not_load_library_function_str), tcl_funcname_table[i].name);
return FAIL;
}
}
if (w == None)
{
if (!silent)
- semsg(_(e_noserver), name);
+ semsg(_(e_no_registered_server_named_str), name);
return -1;
}
else if (loosename != NULL)
if (strtol((char *)cp, (char **)&end, 10) <= 0)
{
if (cp != end)
- emsg(_(e_positive));
+ emsg(_(e_argument_must_be_positive));
else
semsg(_(e_invalid_argument_str), cp);
return FAIL;
new_ts = getdigits(&ptr);
if (new_ts < 0 && *eap->arg == '-')
{
- emsg(_(e_positive));
+ emsg(_(e_argument_must_be_positive));
return;
}
if (new_ts < 0 || new_ts > 9999)
{
if (argvars[0].v_type != VAR_LIST)
{
- emsg(_(e_listreq));
+ emsg(_(e_list_required));
return;
}
what_list = argvars[0].vval.v_list;
{
edit_submode_extra = (compl_cont_status & CONT_ADDING)
&& compl_length > 1
- ? (char_u *)_(e_hitend) : (char_u *)_(e_patnotf);
+ ? (char_u *)_(e_hitend)
+ : (char_u *)_(e_pattern_not_found);
edit_submode_highl = HLF_E;
}
return OK;
if (tv->v_type != VAR_DICT)
{
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
return FAIL;
}
dict = tv->vval.v_dict;
li = list_find(l, idx - 1);
if (li == NULL)
{
- semsg(_(e_listidx), idx);
+ semsg(_(e_list_index_out_of_range_nr), idx);
return NULL;
}
return tv_get_string(&li->li_tv);
if (li == NULL)
{
if (!quiet)
- semsg(_(e_listidx), *n1);
+ semsg(_(e_list_index_out_of_range_nr), *n1);
return NULL;
}
}
if (ni == NULL)
{
if (!quiet)
- semsg(_(e_listidx), *n2);
+ semsg(_(e_list_index_out_of_range_nr), *n2);
return FAIL;
}
*n2 = list_idx_of_item(l, ni);
if (*n2 < *n1)
{
if (!quiet)
- semsg(_(e_listidx), *n2);
+ semsg(_(e_list_index_out_of_range_nr), *n2);
return FAIL;
}
return OK;
if (!range)
{
if (verbose)
- semsg(_(e_listidx), (long)n1_arg);
+ semsg(_(e_list_index_out_of_range_nr), (long)n1_arg);
return FAIL;
}
if (in_vim9script())
if (argvars[0].v_type != VAR_LIST)
{
- emsg(_(e_listreq));
+ emsg(_(e_list_required));
return;
}
rettv->v_type = VAR_STRING;
if (**arg != ']')
{
if (do_error)
- semsg(_(e_list_end), *arg);
+ semsg(_(e_missing_end_of_list_rsb_str), *arg);
failret:
if (evaluate)
list_free(l);
if ((item = list_find(l, idx)) == NULL)
{
- semsg(_(e_listidx), idx);
+ semsg(_(e_list_index_out_of_range_nr), idx);
return;
}
if ((item2 = list_find(l, end)) == NULL)
{
- semsg(_(e_listidx), end);
+ semsg(_(e_list_index_out_of_range_nr), end);
return;
}
// optional third argument: {dict}
if (argvars[2].v_type != VAR_DICT)
{
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
return FAIL;
}
info->item_compare_selfdict = argvars[2].vval.v_dict;
else if (argvars[0].v_type == VAR_BLOB)
blob_add(argvars, rettv);
else
- emsg(_(e_listblobreq));
+ emsg(_(e_list_or_blob_required));
}
/*
li = list_find(l, idx);
if (li == NULL)
{
- semsg(_(e_listidx), idx);
+ semsg(_(e_list_index_out_of_range_nr), idx);
return 0;
}
n = dict_count(argvars[0].vval.v_dict, &argvars[1], ic);
}
else
- semsg(_(e_listdictarg), "count()");
+ semsg(_(e_argument_of_str_must_be_list_or_dictionary), "count()");
rettv->vval.v_number = n;
}
item = list_find(l1, before);
if (item == NULL)
{
- semsg(_(e_listidx), before);
+ semsg(_(e_list_index_out_of_range_nr), before);
return;
}
}
else if (argvars[0].v_type == VAR_DICT && argvars[1].v_type == VAR_DICT)
dict_extend_func(argvars, type, func_name, arg_errmsg, is_new, rettv);
else
- semsg(_(e_listdictarg), func_name);
+ semsg(_(e_argument_of_str_must_be_list_or_dictionary), func_name);
if (type != NULL)
clear_type_list(&type_list);
item = list_find(l, before);
if (item == NULL)
{
- semsg(_(e_listidx), before);
+ semsg(_(e_list_index_out_of_range_nr), before);
l = NULL;
}
}
else if (argvars[0].v_type == VAR_LIST)
list_remove(argvars, rettv, arg_errmsg);
else
- semsg(_(e_listdictblobarg), "remove()");
+ semsg(_(e_argument_of_str_must_be_list_dictionary_or_blob), "remove()");
}
static void
{
if (l == NULL || l->lv_first == NULL)
{
- semsg(_(e_reduceempty), "List");
+ semsg(_(e_reduce_of_an_empty_str_with_no_initial_value), "List");
return;
}
initial = l->lv_first->li_tv;
#ifdef FEAT_ARABIC
set_option_value((char_u *)"arabic", 1L, NULL, 0);
#else
- mch_errmsg(_(e_noarabic));
+ mch_errmsg(_(e_arabic_cannot_be_used_not_enabled_at_compile_time));
mch_exit(2);
#endif
break;
if (argvars[2].v_type != VAR_DICT)
{
- emsg(_(e_dictkey));
+ emsg(_(e_key_not_present_in_dictionary));
return;
}
d = argvars[2].vval.v_dict;
if (tv->v_type != VAR_DICT)
{
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
return FAIL;
}
if (argvars[0].v_type != VAR_LIST)
{
- emsg(_(e_listreq));
+ emsg(_(e_list_required));
return;
}
win = get_optional_window(argvars, 1);
if (verbose && p_verbose > 0)
{
verbose_enter();
- semsg(_(e_loadlib),
+ semsg(_(e_could_not_load_library_str_str),
hIconvDLL == 0 ? DYNAMIC_ICONV_DLL : DYNAMIC_MSVCRT_DLL,
GetWin32Error());
verbose_leave();
if (verbose && p_verbose > 0)
{
verbose_enter();
- semsg(_(e_loadfunc), "for libiconv");
+ semsg(_(e_could_not_load_library_function_str), "for libiconv");
verbose_leave();
}
return FALSE;
if (argvars[0].v_type != VAR_LIST || argvars[0].vval.v_list == NULL)
{
- emsg(_(e_listreq));
+ emsg(_(e_list_required));
return;
}
l = argvars[0].vval.v_list;
void
internal_error(char *where)
{
- siemsg(_(e_intern2), where);
+ siemsg(_(e_internal_error_str), where);
}
/*
void
internal_error_no_abort(char *where)
{
- semsg(_(e_intern2), where);
+ semsg(_(e_internal_error_str), where);
}
// emsg3() and emsgn() are in misc2.c to avoid warnings for the prototypes.
verbose_fd = mch_fopen((char *)p_vfile, "a");
if (verbose_fd == NULL)
{
- semsg(_(e_notopen), p_vfile);
+ semsg(_(e_cant_open_file_str), p_vfile);
return FAIL;
}
}
if (!mch_chdir((char *)var) && mch_dirname(IObuff, IOSIZE) == OK)
var = IObuff;
if (mch_chdir((char *)NameBuff) != 0)
- emsg(_(e_prev_dir));
+ emsg(_(e_cannot_go_back_to_previous_directory));
}
#endif
homedir = vim_strsave(var);
// get a name for the temp file
if ((tempname = vim_tempname('o', FALSE)) == NULL)
{
- emsg(_(e_notmp));
+ emsg(_(e_cant_get_temp_file_name));
return NULL;
}
if (fd == NULL)
{
- semsg(_(e_notopen), tempname);
+ semsg(_(e_cant_open_file_str), tempname);
goto done;
}
#endif
if (i != len)
{
- semsg(_(e_notread), tempname);
+ semsg(_(e_cant_read_file_str), tempname);
VIM_CLEAR(buffer);
}
else if (ret_len == NULL)
*/
if ((infile = vim_tempname('i', TRUE)) == NULL)
{
- emsg(_(e_notmp));
+ emsg(_(e_cant_get_temp_file_name));
goto errret;
}
fd = mch_fopen((char *)infile, WRITEBIN);
if (fd == NULL)
{
- semsg(_(e_notopen), infile);
+ semsg(_(e_cant_open_file_str), infile);
goto errret;
}
if (argvars[1].v_type == VAR_NUMBER)
if (curbuf->b_p_sw < 0)
{
- errmsg = e_positive;
+ errmsg = e_argument_must_be_positive;
#ifdef FEAT_VARTABS
// Use the first 'vartabstop' value, or 'tabstop' if vts isn't in use.
curbuf->b_p_sw = tabstop_count(curbuf->b_p_vts_array) > 0
// 'winheight' and 'helpheight'
if (p_wh < 1)
{
- errmsg = e_positive;
+ errmsg = e_argument_must_be_positive;
p_wh = 1;
}
if (p_wmh > p_wh)
}
if (p_hh < 0)
{
- errmsg = e_positive;
+ errmsg = e_argument_must_be_positive;
p_hh = 0;
}
// 'winminheight'
if (p_wmh < 0)
{
- errmsg = e_positive;
+ errmsg = e_argument_must_be_positive;
p_wmh = 0;
}
if (p_wmh > p_wh)
// 'winwidth'
if (p_wiw < 1)
{
- errmsg = e_positive;
+ errmsg = e_argument_must_be_positive;
p_wiw = 1;
}
if (p_wmw > p_wiw)
// 'winminwidth'
if (p_wmw < 0)
{
- errmsg = e_positive;
+ errmsg = e_argument_must_be_positive;
p_wmw = 0;
}
if (p_wmw > p_wiw)
{
if (curwin->w_p_fdc < 0)
{
- errmsg = e_positive;
+ errmsg = e_argument_must_be_positive;
curwin->w_p_fdc = 0;
}
else if (curwin->w_p_fdc > 12)
{
if (p_titlelen < 0)
{
- errmsg = e_positive;
+ errmsg = e_argument_must_be_positive;
p_titlelen = 85;
}
if (starting != NO_SCREEN && old_value != p_titlelen)
{
if (p_ch < 1)
{
- errmsg = e_positive;
+ errmsg = e_argument_must_be_positive;
p_ch = 1;
}
if (p_ch > Rows - min_rows() + 1)
{
if (p_uc < 0)
{
- errmsg = e_positive;
+ errmsg = e_argument_must_be_positive;
p_uc = 100;
}
if (p_uc && !old_value)
{
if (curwin->w_p_cole < 0)
{
- errmsg = e_positive;
+ errmsg = e_argument_must_be_positive;
curwin->w_p_cole = 0;
}
else if (curwin->w_p_cole > 3)
{
if (curwin->w_p_nuw < 1)
{
- errmsg = e_positive;
+ errmsg = e_argument_must_be_positive;
curwin->w_p_nuw = 1;
}
if (curwin->w_p_nuw > 20)
{
if (curbuf->b_p_tw < 0)
{
- errmsg = e_positive;
+ errmsg = e_argument_must_be_positive;
curbuf->b_p_tw = 0;
}
#ifdef FEAT_SYN_HL
if (curbuf->b_p_ts <= 0)
{
- errmsg = e_positive;
+ errmsg = e_argument_must_be_positive;
curbuf->b_p_ts = 8;
}
if (p_tm < 0)
{
- errmsg = e_positive;
+ errmsg = e_argument_must_be_positive;
p_tm = 0;
}
if ((curwin->w_p_scr <= 0
}
if (p_hi < 0)
{
- errmsg = e_positive;
+ errmsg = e_argument_must_be_positive;
p_hi = 0;
}
else if (p_hi > 10000)
}
if (p_report < 0)
{
- errmsg = e_positive;
+ errmsg = e_argument_must_be_positive;
p_report = 1;
}
if ((p_sj < -100 || p_sj >= Rows) && full_screen)
}
if (p_so < 0 && full_screen)
{
- errmsg = e_positive;
+ errmsg = e_argument_must_be_positive;
p_so = 0;
}
if (p_siso < 0 && full_screen)
{
- errmsg = e_positive;
+ errmsg = e_argument_must_be_positive;
p_siso = 0;
}
#ifdef FEAT_CMDWIN
if (p_cwh < 1)
{
- errmsg = e_positive;
+ errmsg = e_argument_must_be_positive;
p_cwh = 1;
}
#endif
if (p_ut < 0)
{
- errmsg = e_positive;
+ errmsg = e_argument_must_be_positive;
p_ut = 2000;
}
if (p_ss < 0)
{
- errmsg = e_positive;
+ errmsg = e_argument_must_be_positive;
p_ss = 0;
}
idx = findoption(name);
if (idx < 0) // not found (should not happen)
{
- semsg(_(e_intern2), "set_string_option_direct()");
+ semsg(_(e_internal_error_str), "set_string_option_direct()");
siemsg(_("For option %s"), name);
return;
}
if (!fRunTimeLinkSuccess)
{
- semsg(_(e_libcall), funcname);
+ semsg(_(e_library_call_failed_for_str), funcname);
return FAIL;
}
if (target == 0)
{
if (!silent)
- semsg(_(e_noserver), name);
+ semsg(_(e_no_registered_server_named_str), name);
return -1;
}
#endif
l = mch_chdir((char *)olddir);
if (l != 0)
- emsg(_(e_prev_dir));
+ emsg(_(e_cannot_go_back_to_previous_directory));
}
#ifdef HAVE_FCHDIR
if (fd >= 0)
fd_in[0] = mch_open((char *)fname, O_RDONLY, 0);
if (fd_in[0] < 0)
{
- semsg(_(e_notopen), fname);
+ semsg(_(e_cant_open_file_str), fname);
goto failed;
}
}
fd_out[1] = mch_open((char *)fname, O_WRONLY | O_CREAT | O_TRUNC, 0644);
if (fd_out[1] < 0)
{
- semsg(_(e_notopen), fname);
+ semsg(_(e_cant_open_file_str), fname);
goto failed;
}
}
fd_err[1] = mch_open((char *)fname, O_WRONLY | O_CREAT | O_TRUNC, 0600);
if (fd_err[1] < 0)
{
- semsg(_(e_notopen), fname);
+ semsg(_(e_cant_open_file_str), fname);
goto failed;
}
}
*/
if ((tempname = vim_tempname('o', FALSE)) == NULL)
{
- emsg(_(e_notmp));
+ emsg(_(e_cant_get_temp_file_name));
return FAIL;
}
if (i != (int)len)
{
// unexpected read error
- semsg(_(e_notread), tempname);
+ semsg(_(e_cant_read_file_str), tempname);
vim_free(tempname);
vim_free(buffer);
return FAIL;
if (!success)
{
- semsg(_(e_libcall), funcname);
+ semsg(_(e_library_call_failed_for_str), funcname);
return FAIL;
}
if (p_verbose > 0)
{
verbose_enter();
- semsg(_(e_loadlib), GETTEXT_DLL, GetWin32Error());
+ semsg(_(e_could_not_load_library_str_str), GETTEXT_DLL, GetWin32Error());
verbose_leave();
}
return 0;
if (p_verbose > 0)
{
verbose_enter();
- semsg(_(e_loadfunc), libintl_entry[i].name);
+ semsg(_(e_could_not_load_library_function_str), libintl_entry[i].name);
verbose_leave();
}
return 0;
&saAttr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL);
if (ifd[0] == INVALID_HANDLE_VALUE)
{
- semsg(_(e_notopen), fname);
+ semsg(_(e_cant_open_file_str), fname);
goto failed;
}
}
&saAttr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL);
if (ofd[1] == INVALID_HANDLE_VALUE)
{
- semsg(_(e_notopen), fname);
+ semsg(_(e_cant_open_file_str), fname);
goto failed;
}
}
&saAttr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL);
if (efd[1] == INVALID_HANDLE_VALUE)
{
- semsg(_(e_notopen), fname);
+ semsg(_(e_cant_open_file_str), fname);
goto failed;
}
}
if (di != NULL)
{
if (di->di_tv.v_type != VAR_LIST)
- emsg(_(e_listreq));
+ emsg(_(e_list_required));
else
{
list_T *list = di->di_tv.vval.v_list;
if (di != NULL)
{
if (di->di_tv.v_type != VAR_LIST || di->di_tv.vval.v_list == NULL)
- emsg(_(e_listreq));
+ emsg(_(e_list_required));
else
{
list_T *list = di->di_tv.vval.v_list;
if (di != NULL)
{
if (di->di_tv.v_type != VAR_LIST)
- emsg(_(e_listreq));
+ emsg(_(e_list_required));
else
{
list_T *list = di->di_tv.vval.v_list;
{
if (li->li_tv.v_type != VAR_DICT)
{
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
return;
}
dict = li->li_tv.vval.v_dict;
{
if (di->di_tv.v_type != VAR_LIST)
{
- emsg(_(e_listreq));
+ emsg(_(e_list_required));
return;
}
plist = di->di_tv.vval.v_list;
{
if (pli->li_tv.v_type != VAR_DICT)
{
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
return;
}
dict = pli->li_tv.vval.v_dict;
}
if (argvars[1].v_type != VAR_DICT || argvars[1].vval.v_dict == NULL)
{
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
return NULL;
}
d = argvars[1].vval.v_dict;
if (argvars[1].v_type != VAR_DICT || argvars[1].vval.v_dict == NULL)
{
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
return;
}
dict = argvars[1].vval.v_dict;
if (argvars[1].v_type != VAR_DICT || argvars[1].vval.v_dict == NULL)
{
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
return;
}
dict = argvars[1].vval.v_dict;
{
fd = mch_fopen((char *)profile_fname, "w");
if (fd == NULL)
- semsg(_(e_notopen), profile_fname);
+ semsg(_(e_cant_open_file_str), profile_fname);
else
{
script_dump_profile(fd);
if (qi == NULL)
{
if (print_emsg)
- emsg(_(e_loclist));
+ emsg(_(e_no_location_list));
return NULL;
}
}
{
if (qi == NULL)
{
- emsg(_(e_loclist));
+ emsg(_(e_no_location_list));
return;
}
{
name = vim_tempname('e', FALSE);
if (name == NULL)
- emsg(_(e_notmp));
+ emsg(_(e_cant_get_temp_file_name));
return name;
}
if ((get_arglist_exp(p, &args->fcount, &args->fnames, TRUE) == FAIL) ||
args->fcount == 0)
{
- emsg(_(e_nomatch));
+ emsg(_(e_no_match));
return FAIL;
}
first_match_buf, target_dir);
}
else
- semsg(_(e_nomatch2), args.spat);
+ semsg(_(e_no_match_str_2), args.spat);
decr_quickfix_busy();
if (!qf_list_empty(qf_get_curlist(qi)))
qf_jump(qi, 0, 0, FALSE);
else
- semsg(_(e_nomatch2), eap->arg);
+ semsg(_(e_no_match_str_2), eap->arg);
decr_quickfix_busy();
qf_get_properties(wp, d, rettv->vval.v_dict);
}
else
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
}
}
}
# ifdef FEAT_QUICKFIX
if (list_arg->v_type != VAR_LIST)
- emsg(_(e_listreq));
+ emsg(_(e_list_required));
else if (recursive != 0)
emsg(_(e_au_recursive));
else
else if (action_arg->v_type == VAR_UNKNOWN)
action = ' ';
else
- emsg(_(e_stringreq));
+ emsg(_(e_string_required));
if (action_arg->v_type != VAR_UNKNOWN
&& what_arg->v_type != VAR_UNKNOWN)
what = what_arg->vval.v_dict;
else
{
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
valid_dict = FALSE;
}
}
// ":source" read ex commands
else if (do_source(fname, FALSE, DOSO_NONE, NULL) == FAIL)
- semsg(_(e_notopen), fname);
+ semsg(_(e_cant_open_file_str), fname);
}
/*
else if ((options & SEARCH_MSG) == SEARCH_MSG)
{
if (p_ws)
- semsg(_(e_patnotf2), mr_pattern);
+ semsg(_(e_pattern_not_found_str), mr_pattern);
else if (lnum == 0)
semsg(_("E384: search hit TOP without match for: %s"),
mr_pattern);
if (argvars[0].v_type != VAR_DICT || argvars[0].vval.v_dict == NULL)
{
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
return;
}
dict = argvars[0].vval.v_dict;
if (argvars[2].v_type != VAR_DICT || argvars[2].vval.v_dict == NULL)
{
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
return;
}
|| ((ssop_flags & SSOP_CURDIR) && globaldir != NULL)))
{
if (mch_chdir((char *)dirnow) != 0)
- emsg(_(e_prev_dir));
+ emsg(_(e_cannot_go_back_to_previous_directory));
shorten_fnames(TRUE);
}
vim_free(dirnow);
if (li->li_tv.v_type == VAR_DICT)
retval = sign_define_from_dict(NULL, li->li_tv.vval.v_dict);
else
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
list_append_number(retlist, retval);
}
}
if (argvars[1].v_type != VAR_UNKNOWN && argvars[1].v_type != VAR_DICT)
{
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
return;
}
if (argvars[1].v_type != VAR_DICT ||
((dict = argvars[1].vval.v_dict) == NULL))
{
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
return;
}
if ((di = dict_find(dict, (char_u *)"lnum", -1)) != NULL)
&& (argvars[4].v_type != VAR_DICT
|| ((dict = argvars[4].vval.v_dict) == NULL)))
{
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
return;
}
if (argvars[0].v_type != VAR_LIST)
{
- emsg(_(e_listreq));
+ emsg(_(e_list_required));
return;
}
sign_id = sign_place_from_dict(NULL, NULL, NULL, NULL,
li->li_tv.vval.v_dict);
else
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
list_append_number(rettv->vval.v_list, sign_id);
}
}
{
if (argvars[1].v_type != VAR_DICT)
{
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
return;
}
dict = argvars[1].vval.v_dict;
if (argvars[0].v_type != VAR_LIST)
{
- emsg(_(e_listreq));
+ emsg(_(e_list_required));
return;
}
if (li->li_tv.v_type == VAR_DICT)
retval = sign_unplace_from_dict(NULL, li->li_tv.vval.v_dict);
else
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
list_append_number(rettv->vval.v_list, retval);
}
}
if (!wp->w_p_spell || *wp->w_s->b_p_spl == NUL
|| wp->w_s->b_langp.ga_len == 0)
{
- emsg(_(e_no_spell));
+ emsg(_(e_spell_checking_is_not_possible));
return TRUE;
}
return FALSE;
if (fd == NULL)
{
if (!silent)
- semsg(_(e_notopen), fname);
+ semsg(_(e_cant_open_file_str), fname);
else if (p_verbose > 2)
{
verbose_enter();
- smsg((const char *)e_notopen, fname);
+ smsg((const char *)e_cant_open_file_str, fname);
verbose_leave();
}
goto endFAIL;
fd = mch_fopen((char *)fname, "r");
if (fd == NULL)
{
- semsg(_(e_notopen), fname);
+ semsg(_(e_cant_open_file_str), fname);
return NULL;
}
fd = mch_fopen((char *)fname, "r");
if (fd == NULL)
{
- semsg(_(e_notopen), fname);
+ semsg(_(e_cant_open_file_str), fname);
return FAIL;
}
fd = mch_fopen((char *)fname, "r");
if (fd == NULL)
{
- semsg(_(e_notopen), fname);
+ semsg(_(e_cant_open_file_str), fname);
return FAIL;
}
fd = mch_fopen((char *)fname, "w");
if (fd == NULL)
{
- semsg(_(e_notopen), fname);
+ semsg(_(e_cant_open_file_str), fname);
return FAIL;
}
fd = mch_fopen((char *)fname, "w");
if (fd == NULL)
{
- semsg(_(e_notopen), fname);
+ semsg(_(e_cant_open_file_str), fname);
return;
}
}
if (fd == NULL)
- semsg(_(e_notopen), fname);
+ semsg(_(e_cant_open_file_str), fname);
else
{
if (what == SPELL_ADD_BAD)
if (*curwin->w_s->b_p_spl == NUL)
{
- emsg(_(e_no_spell));
+ emsg(_(e_spell_checking_is_not_possible));
return;
}
fd = mch_fopen((char *)fname, "r");
if (fd == NULL)
{
- semsg(_(e_notopen), fname);
+ semsg(_(e_cant_open_file_str), fname);
return;
}
curwin->w_s->b_syn_topgrp = sgl_id;
if (source ? do_source(eap->arg, FALSE, DOSO_NONE, NULL) == FAIL
: source_runtime(eap->arg, DIP_ALL) == FAIL)
- semsg(_(e_notopen), eap->arg);
+ semsg(_(e_cant_open_file_str), eap->arg);
curwin->w_s->b_syn_topgrp = prev_toplvl_grp;
current_syn_inc_tag = prev_syn_inc_tag;
}
{
if (di->di_tv.v_type != VAR_LIST)
{
- emsg(_(e_listreq));
+ emsg(_(e_list_required));
return FAIL;
}
l = di->di_tv.vval.v_list;
if (argvars[2].v_type != VAR_DICT)
{
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
return;
}
d = argvars[2].vval.v_dict;
if (*fname == NUL || (fd = mch_fopen((char *)fname, WRITEBIN)) == NULL)
{
- semsg(_(e_notcreate), *fname == NUL ? (char_u *)_("<empty>") : fname);
+ semsg(_(e_cant_create_file_str), *fname == NUL ? (char_u *)_("<empty>") : fname);
return;
}
fd1 = mch_fopen((char *)fname1, READBIN);
if (fd1 == NULL)
{
- semsg(_(e_notread), fname1);
+ semsg(_(e_cant_read_file_str), fname1);
return;
}
if (do_diff)
if (fd2 == NULL)
{
fclose(fd1);
- semsg(_(e_notread), fname2);
+ semsg(_(e_cant_read_file_str), fname2);
return;
}
}
if (argvars[1].v_type != VAR_LIST || argvars[1].vval.v_list == NULL)
{
- emsg(_(e_listreq));
+ emsg(_(e_list_required));
return;
}
conpty_entry[i].name)) == NULL)
{
if (verbose)
- semsg(_(e_loadfunc), conpty_entry[i].name);
+ semsg(_(e_could_not_load_library_function_str), conpty_entry[i].name);
hKerneldll = NULL;
return FAIL;
}
ch_log(channel, "Opening output file %s", fname);
term->tl_out_fd = mch_fopen((char *)fname, WRITEBIN);
if (term->tl_out_fd == NULL)
- semsg(_(e_notopen), fname);
+ semsg(_(e_cant_open_file_str), fname);
}
return OK;
if (!hWinPtyDLL)
{
if (verbose)
- semsg(_(e_loadlib),
+ semsg(_(e_could_not_load_library_str_str),
(*p_winptydll != NUL ? p_winptydll : (char_u *)WINPTY_DLL),
GetWin32Error());
return FAIL;
winpty_entry[i].name)) == NULL)
{
if (verbose)
- semsg(_(e_loadfunc), winpty_entry[i].name);
+ semsg(_(e_could_not_load_library_function_str), winpty_entry[i].name);
hWinPtyDLL = NULL;
return FAIL;
}
ch_log(channel, "Opening output file %s", fname);
term->tl_out_fd = mch_fopen((char *)fname, WRITEBIN);
if (term->tl_out_fd == NULL)
- semsg(_(e_notopen), fname);
+ semsg(_(e_cant_open_file_str), fname);
}
return OK;
fd1 = mch_fopen((char *)fname1, READBIN);
if (fd1 == NULL)
{
- vim_snprintf((char *)IObuff, IOSIZE, (char *)e_notread, fname1);
+ vim_snprintf((char *)IObuff, IOSIZE, (char *)e_cant_read_file_str, fname1);
}
else
{
if (fd2 == NULL)
{
fclose(fd1);
- vim_snprintf((char *)IObuff, IOSIZE, (char *)e_notread, fname2);
+ vim_snprintf((char *)IObuff, IOSIZE, (char *)e_cant_read_file_str, fname2);
}
else
{
if (arg->v_type != VAR_DICT)
{
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
return FAIL;
}
if (arg->vval.v_dict == NULL)
}
if (argvars[2].v_type != VAR_DICT)
{
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
return;
}
if (argvars[1].vval.v_list == NULL)
{
- emsg(_(e_listreq));
+ emsg(_(e_list_required));
return;
}
{
if (li->li_tv.v_type != VAR_LIST || li->li_tv.vval.v_list == NULL)
{
- emsg(_(e_listreq));
+ emsg(_(e_list_required));
return;
}
if (argvars[0].v_type != VAR_DICT || argvars[0].vval.v_dict == NULL)
{
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
return;
}
dict = argvars[0].vval.v_dict;
{
if (li->li_tv.v_type != VAR_STRING)
{
- emsg(_(e_stringreq));
+ emsg(_(e_string_required));
goto errret;
}
name = li->li_tv.vval.v_string;
if (argvars[1].v_type != VAR_DICT)
{
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
return;
}
d = argvars[1].vval.v_dict;
{
if (di->di_tv.v_type != VAR_NUMBER)
{
- emsg(_(e_numberreq));
+ emsg(_(e_number_required));
return;
}
end_lnum = tv_get_number(&di->di_tv);
{
if (di->di_tv.v_type != VAR_LIST)
{
- emsg(_(e_listreq));
+ emsg(_(e_list_required));
return;
}
{
if (di->di_tv.v_type != VAR_LIST)
{
- emsg(_(e_listreq));
+ emsg(_(e_list_required));
goto errret;
}
if (tv1->v_type != tv2->v_type)
emsg(_("E977: Can only compare Blob with Blob"));
else
- emsg(_(e_invalblob));
+ emsg(_(e_invalid_operation_for_blob));
return FAIL;
}
else
N_("E276: Cannot use function as a method: %s"), name);
break;
case FCERR_DELETED:
- emsg_funcname(e_func_deleted, name);
+ emsg_funcname(e_function_was_deleted_str, name);
break;
case FCERR_TOOMANY:
emsg_funcname((char *)e_too_many_arguments_for_function_str,
if (!aborting())
{
if (!eap->skip && fudi.fd_newkey != NULL)
- semsg(_(e_dictkey), fudi.fd_newkey);
+ semsg(_(e_key_not_present_in_dictionary), fudi.fd_newkey);
vim_free(fudi.fd_newkey);
return NULL;
}
// In Vim9 script only global functions can be redefined.
if (vim9script && eap->forceit && !is_global)
{
- emsg(_(e_nobang));
+ emsg(_(e_no_bang_allowed));
goto ret_free;
}
if (fudi.fd_newkey != NULL)
{
// Still need to give an error message for missing key.
- semsg(_(e_dictkey), fudi.fd_newkey);
+ semsg(_(e_key_not_present_in_dictionary), fudi.fd_newkey);
vim_free(fudi.fd_newkey);
}
if (tofree == NULL)
static int included_patches[] =
{ /* Add new patch number below this line */
+/**/
+ 3967,
/**/
3966,
/**/
if (dfunc->df_deleted)
{
// don't use ufunc->uf_name, it may have been freed
- emsg_funcname(e_func_deleted,
+ emsg_funcname(e_function_was_deleted_str,
dfunc->df_name == NULL ? (char_u *)"unknown" : dfunc->df_name);
return FAIL;
}
lidx = list->lv_len + lidx;
if (lidx < 0 || lidx > list->lv_len)
{
- semsg(_(e_listidx), lidx);
+ semsg(_(e_list_index_out_of_range_nr), lidx);
goto on_error;
}
if (lidx < list->lv_len)
// Can add one byte at the end.
if (lidx < 0 || lidx > len)
{
- semsg(_(e_blobidx), lidx);
+ semsg(_(e_blob_index_out_of_range_nr), lidx);
goto on_error;
}
if (value_check_lock(blob->bv_lock,
if (di == NULL)
{
// NULL dict is equivalent to empty dict
- semsg(_(e_dictkey), key);
+ semsg(_(e_key_not_present_in_dictionary), key);
status = FAIL;
}
else if (var_check_fixed(di->di_flags,
if (li == NULL)
{
SOURCING_LNUM = iptr->isn_lnum;
- semsg(_(e_listidx), n);
+ semsg(_(e_list_index_out_of_range_nr), n);
status = FAIL;
}
else if (value_check_lock(li->li_tv.v_lock,
&& tv_idx2->v_type != VAR_SPECIAL
&& n2 < n1)
{
- semsg(_(e_listidx), n2);
+ semsg(_(e_list_index_out_of_range_nr), n2);
status = FAIL;
}
if (status != FAIL
case EXPR_SUB: f1 = f1 - f2; break;
case EXPR_ADD: f1 = f1 + f2; break;
default: SOURCING_LNUM = iptr->isn_lnum;
- emsg(_(e_modulus));
+ emsg(_(e_cannot_use_percent_with_float));
goto on_error;
}
clear_tv(tv1);
if ((di = dict_find(dict, key, -1)) == NULL)
{
SOURCING_LNUM = iptr->isn_lnum;
- semsg(_(e_dictkey), key);
+ semsg(_(e_key_not_present_in_dictionary), key);
// If :silent! is used we will continue, make sure the
// stack contents makes sense and the dict stack is
if (tv->v_type != VAR_DICT || tv->vval.v_dict == NULL)
{
SOURCING_LNUM = iptr->isn_lnum;
- emsg(_(e_dictreq));
+ emsg(_(e_dictionary_required));
goto on_error;
}
dict = tv->vval.v_dict;
== NULL)
{
SOURCING_LNUM = iptr->isn_lnum;
- semsg(_(e_dictkey), iptr->isn_arg.string);
+ semsg(_(e_key_not_present_in_dictionary), iptr->isn_arg.string);
goto on_error;
}
// Put the dict used on the dict stack, it might be used by
{
if (may_get_next_line(whitep, &p, cctx) == FAIL)
{
- semsg(_(e_list_end), *arg);
+ semsg(_(e_missing_end_of_list_rsb_str), *arg);
return FAIL;
}
if (*p == ',')
if (type->tt_type != VAR_LIST)
{
// cannot happen, caller has checked the type
- emsg(_(e_listreq));
+ emsg(_(e_list_required));
return FAIL;
}
item_type = type->tt_member;
case CMD_k:
if (eap->addr_count > 0)
{
- emsg(_(e_norange));
+ emsg(_(e_no_range_allowed));
return FAIL;
}
// FALLTHROUGH
projects / vim / commitdiff