Bram Moolenaar | bc4c505 | 2020-08-13 22:47:35 +0200 | [diff] [blame] | 1 | /* vi:set ts=8 sts=4 sw=4 noet: |
| 2 | * |
| 3 | * VIM - Vi IMproved by Bram Moolenaar |
| 4 | * |
| 5 | * Do ":help uganda" in Vim to read copying and usage conditions. |
| 6 | * Do ":help credits" in Vim to see a list of people who contributed. |
| 7 | */ |
| 8 | |
| 9 | /* |
| 10 | * Definition of error messages, sorted on error number. |
| 11 | */ |
| 12 | |
Bram Moolenaar | 108010a | 2021-06-27 22:03:33 +0200 | [diff] [blame] | 13 | EXTERN char e_backslash_should_be_followed_by[] |
| 14 | INIT(= N_("E10: \\ should be followed by /, ? or &")); |
| 15 | #ifdef FEAT_CMDWIN |
| 16 | EXTERN char e_invalid_in_cmdline_window[] |
| 17 | INIT(= N_("E11: Invalid in command-line window; <CR> executes, CTRL-C quits")); |
| 18 | #endif |
| 19 | EXTERN char e_command_not_allowed_from_vimrc_in_current_dir_or_tag_search[] |
| 20 | INIT(= N_("E12: Command not allowed from exrc/vimrc in current dir or tag search")); |
| 21 | EXTERN char e_file_exists[] |
| 22 | INIT(= N_("E13: File exists (add ! to override)")); |
| 23 | #ifdef FEAT_EVAL |
| 24 | EXTERN char e_invalid_expression_str[] |
| 25 | INIT(= N_("E15: Invalid expression: \"%s\"")); |
| 26 | #endif |
| 27 | EXTERN char e_invalid_range[] |
| 28 | INIT(= N_("E16: Invalid range")); |
| 29 | #if defined(UNIX) || defined(FEAT_SYN_HL) || defined(FEAT_SPELL) |
| 30 | EXTERN char e_src_is_directory[] |
| 31 | INIT(= N_("E17: \"%s\" is a directory")); |
| 32 | #endif |
| 33 | #ifdef FEAT_EVAL |
| 34 | EXTERN char e_unexpected_characters_in_let[] |
| 35 | INIT(= N_("E18: Unexpected characters in :let")); |
| 36 | EXTERN char e_unexpected_characters_in_assignment[] |
| 37 | INIT(= N_("E18: Unexpected characters in assignment")); |
| 38 | #endif |
| 39 | EXTERN char e_mark_has_invalid_line_number[] |
| 40 | INIT(= N_("E19: Mark has invalid line number")); |
| 41 | EXTERN char e_mark_not_set[] |
| 42 | INIT(= N_("E20: Mark not set")); |
| 43 | EXTERN char e_cannot_make_changes_modifiable_is_off[] |
| 44 | INIT(= N_("E21: Cannot make changes, 'modifiable' is off")); |
| 45 | EXTERN char e_scripts_nested_too_deep[] |
| 46 | INIT(= N_("E22: Scripts nested too deep")); |
| 47 | EXTERN char e_no_alternate_file[] |
| 48 | INIT(= N_("E23: No alternate file")); |
| 49 | EXTERN char e_no_such_abbreviation[] |
| 50 | INIT(= N_("E24: No such abbreviation")); |
Bram Moolenaar | e29a27f | 2021-07-20 21:07:36 +0200 | [diff] [blame] | 51 | #if !defined(FEAT_GUI) || defined(VIMDLL) |
| 52 | EXTERN char e_gui_cannot_be_used_not_enabled_at_compile_time[] |
| 53 | INIT(= N_("E25: GUI cannot be used: Not enabled at compile time")); |
| 54 | #endif |
| 55 | #ifndef FEAT_RIGHTLEFT |
| 56 | EXTERN char e_hebrew_cannot_be_used_not_enabled_at_compile_time[] |
| 57 | INIT(= N_("E26: Hebrew cannot be used: Not enabled at compile time\n")); |
| 58 | #endif |
| 59 | EXTERN char e_farsi_support_has_been_removed[] |
| 60 | INIT(= N_("E27: Farsi support has been removed\n")); |
Bram Moolenaar | e29a27f | 2021-07-20 21:07:36 +0200 | [diff] [blame] | 61 | #if defined(FEAT_SEARCH_EXTRA) || defined(FEAT_SYN_HL) |
| 62 | EXTERN char e_no_such_highlight_group_name_str[] |
| 63 | INIT(= N_("E28: No such highlight group name: %s")); |
| 64 | #endif |
| 65 | EXTERN char e_no_inserted_text_yet[] |
| 66 | INIT(= N_("E29: No inserted text yet")); |
| 67 | EXTERN char e_no_previous_command_line[] |
| 68 | INIT(= N_("E30: No previous command line")); |
| 69 | EXTERN char e_no_such_mapping[] |
| 70 | INIT(= N_("E31: No such mapping")); |
| 71 | EXTERN char e_no_file_name[] |
| 72 | INIT(= N_("E32: No file name")); |
| 73 | EXTERN char e_no_previous_substitute_regular_expression[] |
| 74 | INIT(= N_("E33: No previous substitute regular expression")); |
| 75 | EXTERN char e_no_previous_command[] |
| 76 | INIT(= N_("E34: No previous command")); |
| 77 | EXTERN char e_no_previous_regular_expression[] |
| 78 | INIT(= N_("E35: No previous regular expression")); |
| 79 | EXTERN char e_not_enough_room[] |
| 80 | INIT(= N_("E36: Not enough room")); |
| 81 | EXTERN char e_no_write_since_last_change[] |
| 82 | INIT(= N_("E37: No write since last change")); |
| 83 | EXTERN char e_no_write_since_last_change_add_bang_to_override[] |
| 84 | INIT(= N_("E37: No write since last change (add ! to override)")); |
| 85 | EXTERN char e_null_argument[] |
| 86 | INIT(= N_("E38: Null argument")); |
| 87 | #if defined(FEAT_DIGRAPHS) || defined(FEAT_TIMERS) || defined(FEAT_EVAL) |
| 88 | EXTERN char e_number_expected[] |
| 89 | INIT(= N_("E39: Number expected")); |
| 90 | #endif |
| 91 | #ifdef FEAT_QUICKFIX |
| 92 | EXTERN char e_cant_open_errorfile_str[] |
| 93 | INIT(= N_("E40: Can't open errorfile %s")); |
| 94 | #endif |
| 95 | EXTERN char e_out_of_memory[] |
| 96 | INIT(= N_("E41: Out of memory!")); |
| 97 | #ifdef FEAT_QUICKFIX |
| 98 | EXTERN char e_no_errors[] |
| 99 | INIT(= N_("E42: No Errors")); |
| 100 | #endif |
| 101 | EXTERN char e_damaged_match_string[] |
| 102 | INIT(= N_("E43: Damaged match string")); |
| 103 | EXTERN char e_corrupted_regexp_program[] |
| 104 | INIT(= N_("E44: Corrupted regexp program")); |
| 105 | EXTERN char e_readonly_option_is_set_add_bang_to_override[] |
| 106 | INIT(= N_("E45: 'readonly' option is set (add ! to override)")); |
Bram Moolenaar | d8e4447 | 2021-07-21 22:20:33 +0200 | [diff] [blame] | 107 | #ifdef FEAT_EVAL |
Bram Moolenaar | 71b7685 | 2021-12-17 20:15:38 +0000 | [diff] [blame] | 108 | EXTERN char e_cannot_change_readonly_variable[] |
| 109 | INIT(= N_("E46: Cannot change read-only variable")); |
Bram Moolenaar | d8e4447 | 2021-07-21 22:20:33 +0200 | [diff] [blame] | 110 | EXTERN char e_cannot_change_readonly_variable_str[] |
| 111 | INIT(= N_("E46: Cannot change read-only variable \"%s\"")); |
| 112 | #endif |
| 113 | #ifdef FEAT_QUICKFIX |
| 114 | EXTERN char e_error_while_reading_errorfile[] |
| 115 | INIT(= N_("E47: Error while reading errorfile")); |
| 116 | #endif |
| 117 | #ifdef HAVE_SANDBOX |
| 118 | EXTERN char e_not_allowed_in_sandbox[] |
| 119 | INIT(= N_("E48: Not allowed in sandbox")); |
| 120 | #endif |
| 121 | EXTERN char e_invalid_scroll_size[] |
| 122 | INIT(= N_("E49: Invalid scroll size")); |
| 123 | EXTERN char e_too_many_z[] |
| 124 | INIT(= N_("E50: Too many \\z(")); |
| 125 | EXTERN char e_too_many_str_open[] |
| 126 | INIT(= N_("E51: Too many %s(")); |
| 127 | EXTERN char e_unmatched_z[] |
| 128 | INIT(= N_("E52: Unmatched \\z(")); |
| 129 | EXTERN char e_unmatched_str_percent_open[] |
| 130 | INIT(= N_("E53: Unmatched %s%%(")); |
| 131 | EXTERN char e_unmatched_str_open[] |
| 132 | INIT(= N_("E54: Unmatched %s(")); |
| 133 | EXTERN char e_unmatched_str_close[] |
| 134 | INIT(= N_("E55: Unmatched %s)")); |
| 135 | EXTERN char e_invalid_character_after_str_at[] |
| 136 | INIT(= N_("E59: invalid character after %s@")); |
| 137 | EXTERN char e_too_many_complex_str_curly[] |
| 138 | INIT(= N_("E60: Too many complex %s{...}s")); |
Bram Moolenaar | 12f3c1b | 2021-12-05 21:46:34 +0000 | [diff] [blame] | 139 | EXTERN char e_nested_str[] |
| 140 | INIT(= N_("E61: Nested %s*")); |
| 141 | EXTERN char e_nested_str_chr[] |
| 142 | INIT(= N_("E62: Nested %s%c")); |
| 143 | EXTERN char e_invalid_use_of_underscore[] |
| 144 | INIT(= N_("E63: invalid use of \\_")); |
| 145 | EXTERN char e_str_chr_follows_nothing[] |
| 146 | INIT(= N_("E64: %s%c follows nothing")); |
| 147 | EXTERN char e_illegal_back_reference[] |
| 148 | INIT(= N_("E65: Illegal back reference")); |
| 149 | #ifdef FEAT_SYN_HL |
| 150 | EXTERN char e_z_not_allowed_here[] |
| 151 | INIT(= N_("E66: \\z( not allowed here")); |
| 152 | EXTERN char e_z1_z9_not_allowed_here[] |
| 153 | INIT(= N_("E67: \\z1 - \\z9 not allowed here")); |
| 154 | #endif |
| 155 | EXTERN char e_missing_sb_after_str[] |
| 156 | INIT(= N_("E69: Missing ] after %s%%[")); |
| 157 | EXTERN char e_empty_str_brackets[] |
| 158 | INIT(= N_("E70: Empty %s%%[]")); |
| 159 | EXTERN char e_invalid_character_after_str[] |
| 160 | INIT(= N_("E71: Invalid character after %s%%")); |
| 161 | EXTERN char e_close_error_on_swap_file[] |
| 162 | INIT(= N_("E72: Close error on swap file")); |
| 163 | EXTERN char e_tag_stack_empty[] |
| 164 | INIT(= N_("E73: tag stack empty")); |
| 165 | EXTERN char e_command_too_complex[] |
| 166 | INIT(= N_("E74: Command too complex")); |
| 167 | EXTERN char e_name_too_long[] |
| 168 | INIT(= N_("E75: Name too long")); |
| 169 | EXTERN char e_too_many_brackets[] |
| 170 | INIT(= N_("E76: Too many [")); |
| 171 | EXTERN char e_too_many_file_names[] |
| 172 | INIT(= N_("E77: Too many file names")); |
Bram Moolenaar | 40bcec1 | 2021-12-05 22:19:27 +0000 | [diff] [blame] | 173 | EXTERN char e_unknown_mark[] |
| 174 | INIT(= N_("E78: Unknown mark")); |
| 175 | EXTERN char e_cannot_expand_wildcards[] |
| 176 | INIT(= N_("E79: Cannot expand wildcards")); |
| 177 | EXTERN char e_error_while_writing[] |
| 178 | INIT(= N_("E80: Error while writing")); |
| 179 | #ifdef FEAT_EVAL |
| 180 | EXTERN char e_using_sid_not_in_script_context[] |
| 181 | INIT(= N_("E81: Using <SID> not in a script context")); |
| 182 | #endif |
| 183 | EXTERN char e_cannot_allocate_any_buffer_exiting[] |
| 184 | INIT(= N_("E82: Cannot allocate any buffer, exiting...")); |
| 185 | EXTERN char e_cannot_allocate_buffer_using_other_one[] |
| 186 | INIT(= N_("E83: Cannot allocate buffer, using other one...")); |
| 187 | EXTERN char e_no_modified_buffer_found[] |
| 188 | INIT(= N_("E84: No modified buffer found")); |
| 189 | EXTERN char e_there_is_no_listed_buffer[] |
| 190 | INIT(= N_("E85: There is no listed buffer")); |
| 191 | EXTERN char e_buffer_nr_does_not_exist[] |
| 192 | INIT(= N_("E86: Buffer %ld does not exist")); |
| 193 | EXTERN char e_cannot_go_beyond_last_buffer[] |
| 194 | INIT(= N_("E87: Cannot go beyond last buffer")); |
| 195 | EXTERN char e_cannot_go_before_first_buffer[] |
| 196 | INIT(= N_("E88: Cannot go before first buffer")); |
| 197 | EXTERN char e_no_write_since_last_change_for_buffer_nr_add_bang_to_override[] |
| 198 | INIT(= N_("E89: No write since last change for buffer %d (add ! to override)")); |
| 199 | EXTERN char e_cannot_unload_last_buffer[] |
| 200 | INIT(= N_("E90: Cannot unload last buffer")); |
Bram Moolenaar | e124204 | 2021-12-16 20:56:57 +0000 | [diff] [blame] | 201 | EXTERN char e_shell_option_is_empty[] |
| 202 | INIT(= N_("E91: 'shell' option is empty")); |
| 203 | EXTERN char e_buffer_nr_not_found[] |
| 204 | INIT(= N_("E92: Buffer %d not found")); |
| 205 | EXTERN char e_more_than_one_match_for_str[] |
| 206 | INIT(= N_("E93: More than one match for %s")); |
| 207 | EXTERN char e_no_matching_buffer_for_str[] |
| 208 | INIT(= N_("E94: No matching buffer for %s")); |
| 209 | EXTERN char e_buffer_with_this_name_already_exists[] |
| 210 | INIT(= N_("E95: Buffer with this name already exists")); |
| 211 | #if defined(FEAT_DIFF) |
| 212 | EXTERN char e_cannot_diff_more_than_nr_buffers[] |
| 213 | INIT(= N_("E96: Cannot diff more than %d buffers")); |
| 214 | EXTERN char e_cannot_create_diffs[] |
| 215 | INIT(= N_("E97: Cannot create diffs")); |
| 216 | EXTERN char e_cannot_read_diff_output[] |
| 217 | INIT(= N_("E98: Cannot read diff output")); |
| 218 | EXTERN char e_current_buffer_is_not_in_diff_mode[] |
| 219 | INIT(= N_("E99: Current buffer is not in diff mode")); |
| 220 | EXTERN char e_no_other_buffer_in_diff_mode[] |
| 221 | INIT(= N_("E100: No other buffer in diff mode")); |
| 222 | EXTERN char e_more_than_two_buffers_in_diff_mode_dont_know_which_one_to_use[] |
| 223 | INIT(= N_("E101: More than two buffers in diff mode, don't know which one to use")); |
| 224 | EXTERN char e_cant_find_buffer_str[] |
| 225 | INIT(= N_("E102: Can't find buffer \"%s\"")); |
| 226 | EXTERN char e_buffer_str_is_not_in_diff_mode[] |
| 227 | INIT(= N_("E103: Buffer \"%s\" is not in diff mode")); |
| 228 | #endif |
| 229 | EXTERN char e_escape_not_allowed_in_digraph[] |
| 230 | INIT(= N_("E104: Escape not allowed in digraph")); |
| 231 | EXTERN char e_using_loadkeymap_not_in_sourced_file[] |
| 232 | INIT(= N_("E105: Using :loadkeymap not in a sourced file")); |
| 233 | // E106 unused |
| 234 | EXTERN char e_missing_parenthesis_str[] |
| 235 | INIT(= N_("E107: Missing parentheses: %s")); |
Bram Moolenaar | d8e4447 | 2021-07-21 22:20:33 +0200 | [diff] [blame] | 236 | #ifdef FEAT_EVAL |
Bram Moolenaar | e124204 | 2021-12-16 20:56:57 +0000 | [diff] [blame] | 237 | EXTERN char e_no_such_variable_str[] |
| 238 | INIT(= N_("E108: No such variable: \"%s\"")); |
| 239 | EXTERN char e_missing_colon_after_questionmark[] |
| 240 | INIT(= N_("E109: Missing ':' after '?'")); |
| 241 | EXTERN char e_missing_closing_paren[] |
| 242 | INIT(= N_("E110: Missing ')'")); |
| 243 | EXTERN char e_missing_closing_square_brace[] |
| 244 | INIT(= N_("E111: Missing ']'")); |
| 245 | #endif |
| 246 | EXTERN char e_option_name_missing_str[] |
| 247 | INIT(= N_("E112: Option name missing: %s")); |
| 248 | EXTERN char e_unknown_option_str[] |
| 249 | INIT(= N_("E113: Unknown option: %s")); |
| 250 | EXTERN char e_missing_double_quote_str[] |
| 251 | INIT(= N_("E114: Missing double quote: %s")); |
| 252 | EXTERN char e_missing_single_quote_str[] |
| 253 | INIT(= N_("E115: Missing single quote: %s")); |
| 254 | #ifdef FEAT_EVAL |
| 255 | EXTERN char e_invalid_arguments_for_function_str[] |
| 256 | INIT(= N_("E116: Invalid arguments for function %s")); |
| 257 | EXTERN char e_unknown_function_str[] |
| 258 | INIT(= N_("E117: Unknown function: %s")); |
| 259 | EXTERN char e_too_many_arguments_for_function_str[] |
| 260 | INIT(= N_("E118: Too many arguments for function: %s")); |
| 261 | EXTERN char e_not_enough_arguments_for_function_str[] |
| 262 | INIT(= N_("E119: Not enough arguments for function: %s")); |
| 263 | EXTERN char e_using_sid_not_in_script_context_str[] |
| 264 | INIT(= N_("E120: Using <SID> not in a script context: %s")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 265 | EXTERN char e_undefined_variable_str[] |
| 266 | INIT(= N_("E121: Undefined variable: %s")); |
| 267 | EXTERN char e_undefined_variable_char_str[] |
| 268 | INIT(= N_("E121: Undefined variable: %c:%s")); |
Bram Moolenaar | c553a21 | 2021-12-26 20:20:34 +0000 | [diff] [blame] | 269 | EXTERN char e_function_str_already_exists_add_excl_to_replace[] |
| 270 | INIT(= N_("E122: Function %s already exists, add ! to replace it")); |
| 271 | EXTERN char e_undefined_function_str[] |
| 272 | INIT(= N_("E123: Undefined function: %s")); |
| 273 | EXTERN char e_missing_paren_str[] |
| 274 | INIT(= N_("E124: Missing '(': %s")); |
| 275 | EXTERN char e_illegal_argument_str[] |
| 276 | INIT(= N_("E125: Illegal argument: %s")); |
| 277 | EXTERN char e_missing_endfunction[] |
| 278 | INIT(= N_("E126: Missing :endfunction")); |
| 279 | EXTERN char e_cannot_redefine_function_str_it_is_in_use[] |
| 280 | INIT(= N_("E127: Cannot redefine function %s: It is in use")); |
| 281 | EXTERN char e_function_name_must_start_with_capital_or_s_str[] |
| 282 | INIT(= N_("E128: Function name must start with a capital or \"s:\": %s")); |
| 283 | EXTERN char e_function_name_required[] |
| 284 | INIT(= N_("E129: Function name required")); |
| 285 | // E130 unused |
| 286 | EXTERN char e_cannot_delete_function_str_it_is_in_use[] |
| 287 | INIT(= N_("E131: Cannot delete function %s: It is in use")); |
| 288 | EXTERN char e_function_call_depth_is_higher_than_macfuncdepth[] |
| 289 | INIT(= N_("E132: Function call depth is higher than 'maxfuncdepth'")); |
| 290 | EXTERN char e_return_not_inside_function[] |
| 291 | INIT(= N_("E133: :return not inside a function")); |
Bram Moolenaar | d8e4447 | 2021-07-21 22:20:33 +0200 | [diff] [blame] | 292 | #endif |
Bram Moolenaar | c553a21 | 2021-12-26 20:20:34 +0000 | [diff] [blame] | 293 | EXTERN char e_cannot_move_range_of_lines_into_itself[] |
| 294 | INIT(= N_("E134: Cannot move a range of lines into itself")); |
| 295 | EXTERN char e_filter_autocommands_must_not_change_current_buffer[] |
| 296 | INIT(= N_("E135: *Filter* Autocommands must not change current buffer")); |
| 297 | #if defined(FEAT_VIMINFO) |
| 298 | EXTERN char e_viminfo_too_many_errors_skipping_rest_of_file[] |
| 299 | INIT(= N_("E136: viminfo: Too many errors, skipping rest of file")); |
| 300 | EXTERN char e_viminfo_file_is_not_writable_str[] |
| 301 | INIT(= N_("E137: Viminfo file is not writable: %s")); |
| 302 | EXTERN char e_cant_write_viminfo_file_str[] |
| 303 | INIT(= N_("E138: Can't write viminfo file %s!")); |
| 304 | #endif |
Bram Moolenaar | e124204 | 2021-12-16 20:56:57 +0000 | [diff] [blame] | 305 | |
Bram Moolenaar | bdcba24 | 2021-09-12 20:58:02 +0200 | [diff] [blame] | 306 | EXTERN char e_no_such_user_defined_command_str[] |
| 307 | INIT(= N_("E184: No such user-defined command: %s")); |
mityu | 6106504 | 2021-07-19 20:07:21 +0200 | [diff] [blame] | 308 | #ifndef FEAT_DIGRAPHS |
| 309 | EXTERN char e_no_digraphs_version[] |
| 310 | INIT(= N_("E196: No digraphs in this version")); |
| 311 | #endif |
Drew Vogel | e30d102 | 2021-10-24 20:35:07 +0100 | [diff] [blame] | 312 | #if defined(FEAT_GUI) || defined(FEAT_TERMGUICOLORS) |
| 313 | EXTERN char e_cannot_allocate_color_str[] |
| 314 | INIT(= N_("E254: Cannot allocate color %s")); |
| 315 | #endif |
Bram Moolenaar | d1510ee | 2021-01-04 16:15:58 +0100 | [diff] [blame] | 316 | EXTERN char e_ambiguous_use_of_user_defined_command[] |
| 317 | INIT(= N_("E464: Ambiguous use of user-defined command")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 318 | EXTERN char e_invalid_command[] |
| 319 | INIT(= N_("E476: Invalid command")); |
| 320 | #ifdef FEAT_EVAL |
| 321 | EXTERN char e_invalid_command_str[] |
| 322 | INIT(= N_("E476: Invalid command: %s")); |
Bram Moolenaar | f47c5a8 | 2021-12-19 15:17:21 +0000 | [diff] [blame] | 323 | EXTERN char e_cannot_index_a_funcref[] |
| 324 | INIT(= N_("E695: Cannot index a Funcref")); |
Bram Moolenaar | 792f786 | 2020-11-23 08:31:18 +0100 | [diff] [blame] | 325 | EXTERN char e_list_value_has_more_items_than_targets[] |
| 326 | INIT(= N_("E710: List value has more items than targets")); |
| 327 | EXTERN char e_list_value_does_not_have_enough_items[] |
| 328 | INIT(= N_("E711: List value does not have enough items")); |
Bram Moolenaar | cc673e7 | 2020-08-16 17:33:35 +0200 | [diff] [blame] | 329 | EXTERN char e_cannot_slice_dictionary[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 330 | INIT(= N_("E719: Cannot slice a Dictionary")); |
Bram Moolenaar | 71b7685 | 2021-12-17 20:15:38 +0000 | [diff] [blame] | 331 | EXTERN char e_value_is_locked[] |
| 332 | INIT(= N_("E741: Value is locked")); |
| 333 | EXTERN char e_value_is_locked_str[] |
| 334 | INIT(= N_("E741: Value is locked: %s")); |
| 335 | EXTERN char e_cannot_change_value[] |
| 336 | INIT(= N_("E742: Cannot change value")); |
| 337 | EXTERN char e_cannot_change_value_of_str[] |
| 338 | INIT(= N_("E742: Cannot change value of %s")); |
| 339 | EXTERN char e_cannot_set_variable_in_sandbox[] |
| 340 | INIT(= N_("E794: Cannot set variable in the sandbox")); |
| 341 | EXTERN char e_cannot_set_variable_in_sandbox_str[] |
| 342 | INIT(= N_("E794: Cannot set variable in the sandbox: \"%s\"")); |
| 343 | EXTERN char e_cannot_delete_variable[] |
| 344 | INIT(= N_("E795: Cannot delete variable")); |
| 345 | EXTERN char e_cannot_delete_variable_str[] |
| 346 | INIT(= N_("E795: Cannot delete variable %s")); |
zeertzjq | 09f7723 | 2021-10-20 17:21:24 +0100 | [diff] [blame] | 347 | #endif |
zeertzjq | 94358a1 | 2021-10-20 11:01:15 +0100 | [diff] [blame] | 348 | EXTERN char e_conflicts_with_value_of_listchars[] |
| 349 | INIT(= N_("E834: Conflicts with value of 'listchars'")); |
| 350 | EXTERN char e_conflicts_with_value_of_fillchars[] |
| 351 | INIT(= N_("E835: Conflicts with value of 'fillchars'")); |
zeertzjq | 09f7723 | 2021-10-20 17:21:24 +0100 | [diff] [blame] | 352 | #ifdef FEAT_EVAL |
Bram Moolenaar | 44d6652 | 2020-09-06 22:26:57 +0200 | [diff] [blame] | 353 | EXTERN char e_assert_fails_second_arg[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 354 | INIT(= N_("E856: \"assert_fails()\" second argument must be a string or a list with one or two strings")); |
Bram Moolenaar | 68db996 | 2021-05-09 23:19:22 +0200 | [diff] [blame] | 355 | EXTERN char e_using_invalid_value_as_string_str[] |
| 356 | INIT(= N_("E908: using an invalid value as a String: %s")); |
Bram Moolenaar | cc673e7 | 2020-08-16 17:33:35 +0200 | [diff] [blame] | 357 | EXTERN char e_cannot_index_special_variable[] |
| 358 | INIT(= N_("E909: Cannot index a special variable")); |
Bram Moolenaar | 9b8d622 | 2020-12-28 18:26:00 +0100 | [diff] [blame] | 359 | #endif |
| 360 | EXTERN char e_command_not_supported_in_vim9_script_missing_var_str[] |
| 361 | INIT(= N_("E1100: Command not supported in Vim9 script (missing :var?): %s")); |
| 362 | #ifdef FEAT_EVAL |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 363 | EXTERN char e_variable_not_found_str[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 364 | INIT(= N_("E1001: Variable not found: %s")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 365 | EXTERN char e_syntax_error_at_str[] |
| 366 | INIT(= N_("E1002: Syntax error at %s")); |
| 367 | EXTERN char e_missing_return_value[] |
| 368 | INIT(= N_("E1003: Missing return value")); |
Bram Moolenaar | e7a73e0 | 2021-01-01 19:17:55 +0100 | [diff] [blame] | 369 | EXTERN char e_white_space_required_before_and_after_str_at_str[] |
| 370 | INIT(= N_("E1004: White space required before and after '%s' at \"%s\"")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 371 | EXTERN char e_too_many_argument_types[] |
| 372 | INIT(= N_("E1005: Too many argument types")); |
| 373 | EXTERN char e_str_is_used_as_argument[] |
| 374 | INIT(= N_("E1006: %s is used as an argument")); |
| 375 | EXTERN char e_mandatory_argument_after_optional_argument[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 376 | INIT(= N_("E1007: Mandatory argument after optional argument")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 377 | EXTERN char e_missing_type[] |
| 378 | INIT(= N_("E1008: Missing <type>")); |
| 379 | EXTERN char e_missing_gt_after_type[] |
| 380 | INIT(= N_("E1009: Missing > after type")); |
| 381 | EXTERN char e_type_not_recognized_str[] |
| 382 | INIT(= N_("E1010: Type not recognized: %s")); |
| 383 | EXTERN char e_name_too_long_str[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 384 | INIT(= N_("E1011: Name too long: %s")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 385 | EXTERN char e_type_mismatch_expected_str_but_got_str[] |
Bram Moolenaar | 5e65423 | 2020-09-16 15:22:00 +0200 | [diff] [blame] | 386 | INIT(= N_("E1012: Type mismatch; expected %s but got %s")); |
Bram Moolenaar | 7a3fe3e | 2021-07-22 14:58:47 +0200 | [diff] [blame] | 387 | EXTERN char e_type_mismatch_expected_str_but_got_str_in_str[] |
| 388 | INIT(= N_("E1012: Type mismatch; expected %s but got %s in %s")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 389 | EXTERN char e_argument_nr_type_mismatch_expected_str_but_got_str[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 390 | INIT(= N_("E1013: Argument %d: type mismatch, expected %s but got %s")); |
Bram Moolenaar | 7a3fe3e | 2021-07-22 14:58:47 +0200 | [diff] [blame] | 391 | EXTERN char e_argument_nr_type_mismatch_expected_str_but_got_str_in_str[] |
| 392 | INIT(= N_("E1013: Argument %d: type mismatch, expected %s but got %s in %s")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 393 | EXTERN char e_invalid_key_str[] |
| 394 | INIT(= N_("E1014: Invalid key: %s")); |
Bram Moolenaar | e498429 | 2020-12-13 14:19:25 +0100 | [diff] [blame] | 395 | EXTERN char e_name_expected_str[] |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 396 | INIT(= N_("E1015: Name expected: %s")); |
Bram Moolenaar | bc4c505 | 2020-08-13 22:47:35 +0200 | [diff] [blame] | 397 | EXTERN char e_cannot_declare_a_scope_variable[] |
| 398 | INIT(= N_("E1016: Cannot declare a %s variable: %s")); |
| 399 | EXTERN char e_cannot_declare_an_environment_variable[] |
| 400 | INIT(= N_("E1016: Cannot declare an environment variable: %s")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 401 | EXTERN char e_variable_already_declared[] |
| 402 | INIT(= N_("E1017: Variable already declared: %s")); |
| 403 | EXTERN char e_cannot_assign_to_constant[] |
| 404 | INIT(= N_("E1018: Cannot assign to a constant: %s")); |
| 405 | EXTERN char e_can_only_concatenate_to_string[] |
| 406 | INIT(= N_("E1019: Can only concatenate to string")); |
| 407 | EXTERN char e_cannot_use_operator_on_new_variable[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 408 | INIT(= N_("E1020: Cannot use an operator on a new variable: %s")); |
Bram Moolenaar | bc4c505 | 2020-08-13 22:47:35 +0200 | [diff] [blame] | 409 | EXTERN char e_const_requires_a_value[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 410 | INIT(= N_("E1021: Const requires a value")); |
Bram Moolenaar | bc4c505 | 2020-08-13 22:47:35 +0200 | [diff] [blame] | 411 | EXTERN char e_type_or_initialization_required[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 412 | INIT(= N_("E1022: Type or initialization required")); |
Bram Moolenaar | d70840e | 2020-08-22 15:06:35 +0200 | [diff] [blame] | 413 | EXTERN char e_using_number_as_bool_nr[] |
Bram Moolenaar | 239f8d9 | 2021-01-17 13:21:20 +0100 | [diff] [blame] | 414 | INIT(= N_("E1023: Using a Number as a Bool: %lld")); |
Bram Moolenaar | cc673e7 | 2020-08-16 17:33:35 +0200 | [diff] [blame] | 415 | EXTERN char e_using_number_as_string[] |
| 416 | INIT(= N_("E1024: Using a Number as a String")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 417 | EXTERN char e_using_rcurly_outside_if_block_scope[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 418 | INIT(= N_("E1025: Using } outside of a block scope")); |
Bram Moolenaar | 9088784 | 2021-07-27 22:35:42 +0200 | [diff] [blame] | 419 | #endif |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 420 | EXTERN char e_missing_rcurly[] |
| 421 | INIT(= N_("E1026: Missing }")); |
Bram Moolenaar | 9088784 | 2021-07-27 22:35:42 +0200 | [diff] [blame] | 422 | #ifdef FEAT_EVAL |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 423 | EXTERN char e_missing_return_statement[] |
| 424 | INIT(= N_("E1027: Missing return statement")); |
Bram Moolenaar | e13bdec | 2020-10-16 23:16:47 +0200 | [diff] [blame] | 425 | EXTERN char e_compiling_def_function_failed[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 426 | INIT(= N_("E1028: Compiling :def function failed")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 427 | EXTERN char e_expected_str_but_got_str[] |
| 428 | INIT(= N_("E1029: Expected %s but got %s")); |
Bram Moolenaar | ea2d407 | 2020-11-12 12:08:51 +0100 | [diff] [blame] | 429 | EXTERN char e_using_string_as_number_str[] |
| 430 | INIT(= N_("E1030: Using a String as a Number: \"%s\"")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 431 | EXTERN char e_cannot_use_void_value[] |
| 432 | INIT(= N_("E1031: Cannot use void value")); |
| 433 | EXTERN char e_missing_catch_or_finally[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 434 | INIT(= N_("E1032: Missing :catch or :finally")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 435 | EXTERN char e_catch_unreachable_after_catch_all[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 436 | INIT(= N_("E1033: Catch unreachable after catch-all")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 437 | EXTERN char e_cannot_use_reserved_name[] |
| 438 | INIT(= N_("E1034: Cannot use reserved name %s")); |
| 439 | EXTERN char e_percent_requires_number_arguments[] |
| 440 | INIT(= N_("E1035: % requires number arguments")); |
| 441 | EXTERN char e_char_requires_number_or_float_arguments[] |
| 442 | INIT(= N_("E1036: %c requires number or float arguments")); |
| 443 | EXTERN char e_cannot_use_str_with_str[] |
| 444 | INIT(= N_("E1037: Cannot use \"%s\" with %s")); |
| 445 | EXTERN char e_vim9script_can_only_be_used_in_script[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 446 | INIT(= N_("E1038: \"vim9script\" can only be used in a script")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 447 | EXTERN char e_vim9script_must_be_first_command_in_script[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 448 | INIT(= N_("E1039: \"vim9script\" must be the first command in a script")); |
Bram Moolenaar | 9b8d622 | 2020-12-28 18:26:00 +0100 | [diff] [blame] | 449 | #endif |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 450 | EXTERN char e_cannot_use_scriptversion_after_vim9script[] |
| 451 | INIT(= N_("E1040: Cannot use :scriptversion after :vim9script")); |
Bram Moolenaar | 9b8d622 | 2020-12-28 18:26:00 +0100 | [diff] [blame] | 452 | #ifdef FEAT_EVAL |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 453 | EXTERN char e_redefining_script_item_str[] |
| 454 | INIT(= N_("E1041: Redefining script item %s")); |
| 455 | EXTERN char e_export_can_only_be_used_in_vim9script[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 456 | INIT(= N_("E1042: Export can only be used in vim9script")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 457 | EXTERN char e_invalid_command_after_export[] |
| 458 | INIT(= N_("E1043: Invalid command after :export")); |
| 459 | EXTERN char e_export_with_invalid_argument[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 460 | INIT(= N_("E1044: Export with invalid argument")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 461 | EXTERN char e_missing_as_after_star[] |
| 462 | INIT(= N_("E1045: Missing \"as\" after *")); |
| 463 | EXTERN char e_missing_comma_in_import[] |
| 464 | INIT(= N_("E1046: Missing comma in import")); |
Bram Moolenaar | a9e3d56 | 2021-09-08 12:31:35 +0200 | [diff] [blame] | 465 | EXTERN char e_syntax_error_in_import_str[] |
| 466 | INIT(= N_("E1047: Syntax error in import: %s")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 467 | EXTERN char e_item_not_found_in_script_str[] |
| 468 | INIT(= N_("E1048: Item not found in script: %s")); |
| 469 | EXTERN char e_item_not_exported_in_script_str[] |
| 470 | INIT(= N_("E1049: Item not exported in script: %s")); |
Bram Moolenaar | 6e2c2c5 | 2020-12-25 19:25:45 +0100 | [diff] [blame] | 471 | EXTERN char e_colon_required_before_range_str[] |
| 472 | INIT(= N_("E1050: Colon required before a range: %s")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 473 | EXTERN char e_wrong_argument_type_for_plus[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 474 | INIT(= N_("E1051: Wrong argument type for +")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 475 | EXTERN char e_cannot_declare_an_option[] |
| 476 | INIT(= N_("E1052: Cannot declare an option: %s")); |
| 477 | EXTERN char e_could_not_import_str[] |
| 478 | INIT(= N_("E1053: Could not import \"%s\"")); |
Bram Moolenaar | 057e84a | 2021-02-28 16:55:11 +0100 | [diff] [blame] | 479 | EXTERN char e_variable_already_declared_in_script_str[] |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 480 | INIT(= N_("E1054: Variable already declared in the script: %s")); |
| 481 | EXTERN char e_missing_name_after_dots[] |
| 482 | INIT(= N_("E1055: Missing name after ...")); |
| 483 | EXTERN char e_expected_type_str[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 484 | INIT(= N_("E1056: Expected a type: %s")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 485 | EXTERN char e_missing_enddef[] |
| 486 | INIT(= N_("E1057: Missing :enddef")); |
| 487 | EXTERN char e_function_nesting_too_deep[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 488 | INIT(= N_("E1058: Function nesting too deep")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 489 | EXTERN char e_no_white_space_allowed_before_colon_str[] |
| 490 | INIT(= N_("E1059: No white space allowed before colon: %s")); |
| 491 | EXTERN char e_expected_dot_after_name_str[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 492 | INIT(= N_("E1060: Expected dot after name: %s")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 493 | EXTERN char e_cannot_find_function_str[] |
| 494 | INIT(= N_("E1061: Cannot find function %s")); |
Bram Moolenaar | cc673e7 | 2020-08-16 17:33:35 +0200 | [diff] [blame] | 495 | EXTERN char e_cannot_index_number[] |
| 496 | INIT(= N_("E1062: Cannot index a Number")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 497 | EXTERN char e_type_mismatch_for_v_variable[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 498 | INIT(= N_("E1063: Type mismatch for v: variable")); |
Bram Moolenaar | 021ef35 | 2021-12-02 20:44:42 +0000 | [diff] [blame] | 499 | #endif |
Bram Moolenaar | 9ac3812 | 2021-12-02 18:42:33 +0000 | [diff] [blame] | 500 | EXTERN char e_yank_register_changed_while_using_it[] |
| 501 | INIT(= N_("E1064: Yank register changed while using it")); |
Bram Moolenaar | 021ef35 | 2021-12-02 20:44:42 +0000 | [diff] [blame] | 502 | #ifdef FEAT_EVAL |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 503 | // E1065 unused |
Bram Moolenaar | 7cb6fc2 | 2020-08-21 22:36:47 +0200 | [diff] [blame] | 504 | EXTERN char e_cannot_declare_a_register_str[] |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 505 | INIT(= N_("E1066: Cannot declare a register: %s")); |
Bram Moolenaar | 7cb6fc2 | 2020-08-21 22:36:47 +0200 | [diff] [blame] | 506 | EXTERN char e_separator_mismatch_str[] |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 507 | INIT(= N_("E1067: Separator mismatch: %s")); |
Bram Moolenaar | ba98fb5 | 2021-02-07 18:06:29 +0100 | [diff] [blame] | 508 | EXTERN char e_no_white_space_allowed_before_str_str[] |
| 509 | INIT(= N_("E1068: No white space allowed before '%s': %s")); |
Bram Moolenaar | c3fc75d | 2021-02-07 15:28:09 +0100 | [diff] [blame] | 510 | EXTERN char e_white_space_required_after_str_str[] |
| 511 | INIT(= N_("E1069: White space required after '%s': %s")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 512 | EXTERN char e_missing_from[] |
| 513 | INIT(= N_("E1070: Missing \"from\"")); |
| 514 | EXTERN char e_invalid_string_after_from[] |
| 515 | INIT(= N_("E1071: Invalid string after \"from\"")); |
| 516 | EXTERN char e_cannot_compare_str_with_str[] |
| 517 | INIT(= N_("E1072: Cannot compare %s with %s")); |
Bram Moolenaar | 7cb6fc2 | 2020-08-21 22:36:47 +0200 | [diff] [blame] | 518 | EXTERN char e_name_already_defined_str[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 519 | INIT(= N_("E1073: Name already defined: %s")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 520 | EXTERN char e_no_white_space_allowed_after_dot[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 521 | INIT(= N_("E1074: No white space allowed after dot")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 522 | EXTERN char e_namespace_not_supported_str[] |
| 523 | INIT(= N_("E1075: Namespace not supported: %s")); |
| 524 | EXTERN char e_this_vim_is_not_compiled_with_float_support[] |
| 525 | INIT(= N_("E1076: This Vim is not compiled with float support")); |
| 526 | EXTERN char e_missing_argument_type_for_str[] |
| 527 | INIT(= N_("E1077: Missing argument type for %s")); |
| 528 | // E1078 unused |
| 529 | // E1079 unused |
| 530 | // E1080 unused |
| 531 | EXTERN char e_cannot_unlet_str[] |
| 532 | INIT(= N_("E1081: Cannot unlet %s")); |
| 533 | EXTERN char e_cannot_use_namespaced_variable[] |
| 534 | INIT(= N_("E1082: Cannot use a namespaced variable: %s")); |
| 535 | EXTERN char e_missing_backtick[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 536 | INIT(= N_("E1083: Missing backtick")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 537 | EXTERN char e_cannot_delete_vim9_script_function_str[] |
| 538 | INIT(= N_("E1084: Cannot delete Vim9 script function %s")); |
| 539 | EXTERN char e_not_callable_type_str[] |
| 540 | INIT(= N_("E1085: Not a callable type: %s")); |
Bram Moolenaar | 293eb9b | 2021-11-29 10:36:19 +0000 | [diff] [blame] | 541 | EXTERN char e_function_reference_invalid[] |
| 542 | INIT(= N_("E1086: Function reference invalid")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 543 | EXTERN char e_cannot_use_index_when_declaring_variable[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 544 | INIT(= N_("E1087: Cannot use an index when declaring a variable")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 545 | // E1088 unused |
| 546 | EXTERN char e_unknown_variable_str[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 547 | INIT(= N_("E1089: Unknown variable: %s")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 548 | EXTERN char e_cannot_assign_to_argument[] |
| 549 | INIT(= N_("E1090: Cannot assign to argument %s")); |
| 550 | EXTERN char e_function_is_not_compiled_str[] |
| 551 | INIT(= N_("E1091: Function is not compiled: %s")); |
Bram Moolenaar | ab36e6a | 2021-11-30 16:14:49 +0000 | [diff] [blame] | 552 | // E1092 unused |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 553 | EXTERN char e_expected_nr_items_but_got_nr[] |
| 554 | INIT(= N_("E1093: Expected %d items but got %d")); |
| 555 | EXTERN char e_import_can_only_be_used_in_script[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 556 | INIT(= N_("E1094: Import can only be used in a script")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 557 | EXTERN char e_unreachable_code_after_return[] |
| 558 | INIT(= N_("E1095: Unreachable code after :return")); |
| 559 | EXTERN char e_returning_value_in_function_without_return_type[] |
| 560 | INIT(= N_("E1096: Returning a value in a function without a return type")); |
| 561 | EXTERN char e_line_incomplete[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 562 | INIT(= N_("E1097: Line incomplete")); |
Sean Dewar | 80d7395 | 2021-08-04 19:25:54 +0200 | [diff] [blame] | 563 | EXTERN char e_string_list_or_blob_required[] |
| 564 | INIT(= N_("E1098: String, List or Blob required")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 565 | EXTERN char e_unknown_error_while_executing_str[] |
| 566 | INIT(= N_("E1099: Unknown error while executing %s")); |
| 567 | EXTERN char e_cannot_declare_script_variable_in_function[] |
| 568 | INIT(= N_("E1101: Cannot declare a script variable in a function: %s")); |
| 569 | EXTERN char e_lambda_function_not_found_str[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 570 | INIT(= N_("E1102: Lambda function not found: %s")); |
Bram Moolenaar | bc4c505 | 2020-08-13 22:47:35 +0200 | [diff] [blame] | 571 | EXTERN char e_dictionary_not_set[] |
| 572 | INIT(= N_("E1103: Dictionary not set")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 573 | EXTERN char e_missing_gt[] |
| 574 | INIT(= N_("E1104: Missing >")); |
| 575 | EXTERN char e_cannot_convert_str_to_string[] |
| 576 | INIT(= N_("E1105: Cannot convert %s to string")); |
| 577 | EXTERN char e_one_argument_too_many[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 578 | INIT(= N_("E1106: One argument too many")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 579 | EXTERN char e_nr_arguments_too_many[] |
| 580 | INIT(= N_("E1106: %d arguments too many")); |
Bram Moolenaar | 56acb09 | 2020-08-16 14:48:19 +0200 | [diff] [blame] | 581 | EXTERN char e_string_list_dict_or_blob_required[] |
| 582 | INIT(= N_("E1107: String, List, Dict or Blob required")); |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 583 | EXTERN char e_item_not_found_str[] |
| 584 | INIT(= N_("E1108: Item not found: %s")); |
Bram Moolenaar | 08aac3c | 2020-08-28 21:04:24 +0200 | [diff] [blame] | 585 | EXTERN char e_list_item_nr_is_not_list[] |
| 586 | INIT(= N_("E1109: List item %d is not a List")); |
| 587 | EXTERN char e_list_item_nr_does_not_contain_3_numbers[] |
| 588 | INIT(= N_("E1110: List item %d does not contain 3 numbers")); |
| 589 | EXTERN char e_list_item_nr_range_invalid[] |
| 590 | INIT(= N_("E1111: List item %d range invalid")); |
| 591 | EXTERN char e_list_item_nr_cell_width_invalid[] |
| 592 | INIT(= N_("E1112: List item %d cell width invalid")); |
| 593 | EXTERN char e_overlapping_ranges_for_nr[] |
Bram Moolenaar | b06a6d5 | 2020-08-28 23:27:20 +0200 | [diff] [blame] | 594 | INIT(= N_("E1113: Overlapping ranges for 0x%lx")); |
Bram Moolenaar | 08aac3c | 2020-08-28 21:04:24 +0200 | [diff] [blame] | 595 | EXTERN char e_only_values_of_0x100_and_higher_supported[] |
| 596 | INIT(= N_("E1114: Only values of 0x100 and higher supported")); |
Bram Moolenaar | 44d6652 | 2020-09-06 22:26:57 +0200 | [diff] [blame] | 597 | EXTERN char e_assert_fails_fourth_argument[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 598 | INIT(= N_("E1115: \"assert_fails()\" fourth argument must be a number")); |
Bram Moolenaar | 44d6652 | 2020-09-06 22:26:57 +0200 | [diff] [blame] | 599 | EXTERN char e_assert_fails_fifth_argument[] |
Bram Moolenaar | 7707228 | 2020-09-16 17:55:40 +0200 | [diff] [blame] | 600 | INIT(= N_("E1116: \"assert_fails()\" fifth argument must be a string")); |
Bram Moolenaar | 8b848ca | 2020-09-10 22:28:01 +0200 | [diff] [blame] | 601 | EXTERN char e_cannot_use_bang_with_nested_def[] |
| 602 | INIT(= N_("E1117: Cannot use ! with nested :def")); |
Bram Moolenaar | 0b4c66c | 2020-09-14 21:39:44 +0200 | [diff] [blame] | 603 | EXTERN char e_cannot_change_list[] |
| 604 | INIT(= N_("E1118: Cannot change list")); |
| 605 | EXTERN char e_cannot_change_list_item[] |
| 606 | INIT(= N_("E1119: Cannot change list item")); |
| 607 | EXTERN char e_cannot_change_dict[] |
| 608 | INIT(= N_("E1120: Cannot change dict")); |
| 609 | EXTERN char e_cannot_change_dict_item[] |
| 610 | INIT(= N_("E1121: Cannot change dict item")); |
Bram Moolenaar | 916911f | 2020-09-16 21:41:53 +0200 | [diff] [blame] | 611 | EXTERN char e_variable_is_locked_str[] |
| 612 | INIT(= N_("E1122: Variable is locked: %s")); |
Bram Moolenaar | 10e4f12 | 2020-09-20 22:43:52 +0200 | [diff] [blame] | 613 | EXTERN char e_missing_comma_before_argument_str[] |
| 614 | INIT(= N_("E1123: Missing comma before argument: %s")); |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 615 | EXTERN char e_str_cannot_be_used_in_legacy_vim_script[] |
| 616 | INIT(= N_("E1124: \"%s\" cannot be used in legacy Vim script")); |
| 617 | EXTERN char e_final_requires_a_value[] |
| 618 | INIT(= N_("E1125: Final requires a value")); |
Bram Moolenaar | cfcd011 | 2020-09-27 15:19:27 +0200 | [diff] [blame] | 619 | EXTERN char e_cannot_use_let_in_vim9_script[] |
| 620 | INIT(= N_("E1126: Cannot use :let in Vim9 script")); |
Bram Moolenaar | c1f0066 | 2020-10-03 13:41:53 +0200 | [diff] [blame] | 621 | EXTERN char e_missing_name_after_dot[] |
| 622 | INIT(= N_("E1127: Missing name after dot")); |
Bram Moolenaar | 9becdf2 | 2020-10-10 21:33:48 +0200 | [diff] [blame] | 623 | EXTERN char e_endblock_without_block[] |
| 624 | INIT(= N_("E1128: } without {")); |
Bram Moolenaar | 1e021e6 | 2020-10-16 20:25:23 +0200 | [diff] [blame] | 625 | EXTERN char e_throw_with_empty_string[] |
| 626 | INIT(= N_("E1129: Throw with empty string")); |
Bram Moolenaar | 1dcae59 | 2020-10-19 19:02:42 +0200 | [diff] [blame] | 627 | EXTERN char e_cannot_add_to_null_list[] |
| 628 | INIT(= N_("E1130: Cannot add to null list")); |
Bram Moolenaar | 80b0e5e | 2020-10-19 20:45:36 +0200 | [diff] [blame] | 629 | EXTERN char e_cannot_add_to_null_blob[] |
| 630 | INIT(= N_("E1131: Cannot add to null blob")); |
Bram Moolenaar | 0d90e72 | 2020-11-03 18:20:19 +0100 | [diff] [blame] | 631 | EXTERN char e_missing_function_argument[] |
| 632 | INIT(= N_("E1132: Missing function argument")); |
Bram Moolenaar | 348be7e | 2020-11-04 11:36:35 +0100 | [diff] [blame] | 633 | EXTERN char e_cannot_extend_null_dict[] |
| 634 | INIT(= N_("E1133: Cannot extend a null dict")); |
| 635 | EXTERN char e_cannot_extend_null_list[] |
| 636 | INIT(= N_("E1134: Cannot extend a null list")); |
Bram Moolenaar | ea2d407 | 2020-11-12 12:08:51 +0100 | [diff] [blame] | 637 | EXTERN char e_using_string_as_bool_str[] |
| 638 | INIT(= N_("E1135: Using a String as a Bool: \"%s\"")); |
Bram Moolenaar | bc4c505 | 2020-08-13 22:47:35 +0200 | [diff] [blame] | 639 | #endif |
Bram Moolenaar | 957cf67 | 2020-11-12 14:21:06 +0100 | [diff] [blame] | 640 | EXTERN char e_cmd_mapping_must_end_with_cr_before_second_cmd[] |
Bram Moolenaar | 806da51 | 2021-12-24 19:54:52 +0000 | [diff] [blame] | 641 | INIT(= N_("E1136: <Cmd> mapping must end with <CR> before second <Cmd>")); |
Bram Moolenaar | 957cf67 | 2020-11-12 14:21:06 +0100 | [diff] [blame] | 642 | EXTERN char e_cmd_maping_must_not_include_str_key[] |
| 643 | INIT(= N_("E1137: <Cmd> mapping must not include %s key")); |
Bram Moolenaar | d92cc13 | 2020-11-18 17:17:15 +0100 | [diff] [blame] | 644 | EXTERN char e_using_bool_as_number[] |
| 645 | INIT(= N_("E1138: Using a Bool as a Number")); |
Bram Moolenaar | 2bede17 | 2020-11-19 18:53:18 +0100 | [diff] [blame] | 646 | EXTERN char e_missing_matching_bracket_after_dict_key[] |
| 647 | INIT(= N_("E1139: Missing matching bracket after dict key")); |
Bram Moolenaar | 792f786 | 2020-11-23 08:31:18 +0100 | [diff] [blame] | 648 | EXTERN char e_for_argument_must_be_sequence_of_lists[] |
Bram Moolenaar | 4d5dfe2 | 2021-06-26 13:59:29 +0200 | [diff] [blame] | 649 | INIT(= N_("E1140: :for argument must be a sequence of lists")); |
Bram Moolenaar | dc234ca | 2020-11-28 18:52:33 +0100 | [diff] [blame] | 650 | EXTERN char e_indexable_type_required[] |
| 651 | INIT(= N_("E1141: Indexable type required")); |
Bram Moolenaar | 2a9d5d3 | 2020-12-12 18:58:40 +0100 | [diff] [blame] | 652 | EXTERN char e_non_empty_string_required[] |
| 653 | INIT(= N_("E1142: Non-empty string required")); |
Bram Moolenaar | e498429 | 2020-12-13 14:19:25 +0100 | [diff] [blame] | 654 | EXTERN char e_empty_expression_str[] |
Bram Moolenaar | b5b9480 | 2020-12-13 17:50:20 +0100 | [diff] [blame] | 655 | INIT(= N_("E1143: Empty expression: \"%s\"")); |
Bram Moolenaar | b98cec2 | 2021-04-25 16:35:55 +0200 | [diff] [blame] | 656 | EXTERN char e_command_str_not_followed_by_white_space_str[] |
| 657 | INIT(= N_("E1144: Command \"%s\" is not followed by white space: %s")); |
Bram Moolenaar | b5b9480 | 2020-12-13 17:50:20 +0100 | [diff] [blame] | 658 | EXTERN char e_missing_heredoc_end_marker_str[] |
| 659 | INIT(= N_("E1145: Missing heredoc end marker: %s")); |
Bram Moolenaar | 52c124d | 2020-12-20 21:43:35 +0100 | [diff] [blame] | 660 | EXTERN char e_command_not_recognized_str[] |
| 661 | INIT(= N_("E1146: Command not recognized: %s")); |
Bram Moolenaar | 4f5e397 | 2020-12-21 17:30:50 +0100 | [diff] [blame] | 662 | EXTERN char e_list_not_set[] |
| 663 | INIT(= N_("E1147: List not set")); |
| 664 | EXTERN char e_cannot_index_str[] |
| 665 | INIT(= N_("E1148: Cannot index a %s")); |
Bram Moolenaar | 4aab88d | 2020-12-24 21:56:41 +0100 | [diff] [blame] | 666 | EXTERN char e_script_variable_invalid_after_reload_in_function_str[] |
| 667 | INIT(= N_("E1149: Script variable is invalid after reload in function %s")); |
Bram Moolenaar | 07a65d2 | 2020-12-26 20:09:15 +0100 | [diff] [blame] | 668 | EXTERN char e_script_variable_type_changed[] |
| 669 | INIT(= N_("E1150: Script variable type changed")); |
Bram Moolenaar | 5178b1b | 2021-01-01 18:43:51 +0100 | [diff] [blame] | 670 | EXTERN char e_mismatched_endfunction[] |
| 671 | INIT(= N_("E1151: Mismatched endfunction")); |
| 672 | EXTERN char e_mismatched_enddef[] |
| 673 | INIT(= N_("E1152: Mismatched enddef")); |
Bram Moolenaar | 0c35752 | 2021-07-18 14:43:43 +0200 | [diff] [blame] | 674 | EXTERN char e_invalid_operation_for_str[] |
| 675 | INIT(= N_("E1153: Invalid operation for %s")); |
Bram Moolenaar | 99880f9 | 2021-01-20 21:23:14 +0100 | [diff] [blame] | 676 | EXTERN char e_divide_by_zero[] |
| 677 | INIT(= N_("E1154: Divide by zero")); |
Bram Moolenaar | 9a046fd | 2021-01-28 13:47:59 +0100 | [diff] [blame] | 678 | EXTERN char e_cannot_define_autocommands_for_all_events[] |
| 679 | INIT(= N_("E1155: Cannot define autocommands for ALL events")); |
Bram Moolenaar | 6101516 | 2021-01-28 17:56:09 +0100 | [diff] [blame] | 680 | EXTERN char e_cannot_change_arglist_recursively[] |
| 681 | INIT(= N_("E1156: Cannot change the argument list recursively")); |
Bram Moolenaar | 0346b79 | 2021-01-31 22:18:29 +0100 | [diff] [blame] | 682 | EXTERN char e_missing_return_type[] |
| 683 | INIT(= N_("E1157: Missing return type")); |
Bram Moolenaar | 3b69006 | 2021-02-01 20:14:51 +0100 | [diff] [blame] | 684 | EXTERN char e_cannot_use_flatten_in_vim9_script[] |
| 685 | INIT(= N_("E1158: Cannot use flatten() in Vim9 script")); |
Bram Moolenaar | 983d83f | 2021-02-07 12:12:43 +0100 | [diff] [blame] | 686 | EXTERN char e_cannot_split_window_when_closing_buffer[] |
| 687 | INIT(= N_("E1159: Cannot split a window when closing the buffer")); |
Bram Moolenaar | a5a1ec1 | 2021-02-07 16:05:47 +0100 | [diff] [blame] | 688 | EXTERN char e_cannot_use_default_for_variable_arguments[] |
| 689 | INIT(= N_("E1160: Cannot use a default for variable arguments")); |
Bram Moolenaar | a853089 | 2021-02-08 21:53:09 +0100 | [diff] [blame] | 690 | EXTERN char e_cannot_json_encode_str[] |
| 691 | INIT(= N_("E1161: Cannot json encode a %s")); |
Bram Moolenaar | 418a29f | 2021-02-10 22:23:41 +0100 | [diff] [blame] | 692 | EXTERN char e_register_name_must_be_one_char_str[] |
| 693 | INIT(= N_("E1162: Register name must be one character: %s")); |
Bram Moolenaar | f785aa1 | 2021-02-11 21:19:34 +0100 | [diff] [blame] | 694 | EXTERN char e_variable_nr_type_mismatch_expected_str_but_got_str[] |
| 695 | INIT(= N_("E1163: Variable %d: type mismatch, expected %s but got %s")); |
Bram Moolenaar | 7a3fe3e | 2021-07-22 14:58:47 +0200 | [diff] [blame] | 696 | EXTERN char e_variable_nr_type_mismatch_expected_str_but_got_str_in_str[] |
| 697 | INIT(= N_("E1163: Variable %d: type mismatch, expected %s but got %s in %s")); |
Bram Moolenaar | 39f3b14 | 2021-02-14 12:57:36 +0100 | [diff] [blame] | 698 | EXTERN char e_vim9cmd_must_be_followed_by_command[] |
| 699 | INIT(= N_("E1164: vim9cmd must be followed by a command")); |
Bram Moolenaar | 5b5ae29 | 2021-02-20 17:04:02 +0100 | [diff] [blame] | 700 | EXTERN char e_cannot_use_range_with_assignment_str[] |
| 701 | INIT(= N_("E1165: Cannot use a range with an assignment: %s")); |
| 702 | EXTERN char e_cannot_use_range_with_dictionary[] |
| 703 | INIT(= N_("E1166: Cannot use a range with a dictionary")); |
Bram Moolenaar | 057e84a | 2021-02-28 16:55:11 +0100 | [diff] [blame] | 704 | EXTERN char e_argument_name_shadows_existing_variable_str[] |
| 705 | INIT(= N_("E1167: Argument name shadows existing variable: %s")); |
| 706 | EXTERN char e_argument_already_declared_in_script_str[] |
| 707 | INIT(= N_("E1168: Argument already declared in the script: %s")); |
Bram Moolenaar | cb4e80f | 2021-03-13 20:57:19 +0100 | [diff] [blame] | 708 | EXTERN char e_import_as_name_not_supported_here[] |
| 709 | INIT(= N_("E1169: 'import * as {name}' not supported here")); |
Bram Moolenaar | 4b3e196 | 2021-03-18 21:37:55 +0100 | [diff] [blame] | 710 | EXTERN char e_cannot_use_hash_curly_to_start_comment[] |
Bram Moolenaar | a0399ef | 2021-03-20 15:00:01 +0100 | [diff] [blame] | 711 | INIT(= N_("E1170: Cannot use #{ to start a comment")); |
Bram Moolenaar | 7a6eaa0 | 2021-03-21 20:53:29 +0100 | [diff] [blame] | 712 | EXTERN char e_missing_end_block[] |
| 713 | INIT(= N_("E1171: Missing } after inline function")); |
| 714 | EXTERN char e_cannot_use_default_values_in_lambda[] |
| 715 | INIT(= N_("E1172: Cannot use default values in a lambda")); |
Bram Moolenaar | 49f1e9e | 2021-03-22 20:49:02 +0100 | [diff] [blame] | 716 | EXTERN char e_text_found_after_enddef_str[] |
| 717 | INIT(= N_("E1173: Text found after enddef: %s")); |
Bram Moolenaar | f28f2ac | 2021-03-22 22:21:26 +0100 | [diff] [blame] | 718 | EXTERN char e_string_required_for_argument_nr[] |
| 719 | INIT(= N_("E1174: String required for argument %d")); |
| 720 | EXTERN char e_non_empty_string_required_for_argument_nr[] |
Bram Moolenaar | 3a0f092 | 2021-03-25 22:22:30 +0100 | [diff] [blame] | 721 | INIT(= N_("E1175: Non-empty string required for argument %d")); |
| 722 | EXTERN char e_misplaced_command_modifier[] |
| 723 | INIT(= N_("E1176: Misplaced command modifier")); |
Bram Moolenaar | 74e54fc | 2021-03-26 20:41:29 +0100 | [diff] [blame] | 724 | EXTERN char e_for_loop_on_str_not_supported[] |
| 725 | INIT(= N_("E1177: For loop on %s not supported")); |
Bram Moolenaar | b2cb6c8 | 2021-03-28 20:38:34 +0200 | [diff] [blame] | 726 | EXTERN char e_cannot_lock_unlock_local_variable[] |
| 727 | INIT(= N_("E1178: Cannot lock or unlock a local variable")); |
Bram Moolenaar | 9ea7e55 | 2021-03-29 21:06:04 +0200 | [diff] [blame] | 728 | EXTERN char e_failed_to_extract_pwd_from_str_check_your_shell_config[] |
| 729 | INIT(= N_("E1179: Failed to extract PWD from %s, check your shell's config related to OSC 7")); |
Bram Moolenaar | 2a38908 | 2021-04-09 20:24:31 +0200 | [diff] [blame] | 730 | EXTERN char e_variable_arguments_type_must_be_list_str[] |
| 731 | INIT(= N_("E1180: Variable arguments type must be a list: %s")); |
Bram Moolenaar | 962c43b | 2021-04-10 17:18:09 +0200 | [diff] [blame] | 732 | EXTERN char e_cannot_use_underscore_here[] |
| 733 | INIT(= N_("E1181: Cannot use an underscore here")); |
Bram Moolenaar | 6845217 | 2021-04-12 21:21:02 +0200 | [diff] [blame] | 734 | EXTERN char e_blob_required[] |
| 735 | INIT(= N_("E1182: Blob required")); |
Bram Moolenaar | 0e3ff19 | 2021-04-14 20:35:23 +0200 | [diff] [blame] | 736 | EXTERN char e_cannot_use_range_with_assignment_operator_str[] |
| 737 | INIT(= N_("E1183: Cannot use a range with an assignment operator: %s")); |
Bram Moolenaar | 51e9332 | 2021-04-17 20:44:56 +0200 | [diff] [blame] | 738 | EXTERN char e_blob_not_set[] |
| 739 | INIT(= N_("E1184: Blob not set")); |
Bram Moolenaar | 2d1c57e | 2021-04-19 20:50:03 +0200 | [diff] [blame] | 740 | EXTERN char e_cannot_nest_redir[] |
| 741 | INIT(= N_("E1185: Cannot nest :redir")); |
| 742 | EXTERN char e_missing_redir_end[] |
| 743 | INIT(= N_("E1185: Missing :redir END")); |
Bram Moolenaar | 68db996 | 2021-05-09 23:19:22 +0200 | [diff] [blame] | 744 | EXTERN char e_expression_does_not_result_in_value_str[] |
| 745 | INIT(= N_("E1186: Expression does not result in a value: %s")); |
Christian Brabandt | 1d3a14e | 2021-05-29 19:53:50 +0200 | [diff] [blame] | 746 | EXTERN char e_failed_to_source_defaults[] |
| 747 | INIT(= N_("E1187: Failed to source defaults.vim")); |
Bram Moolenaar | e5b4486 | 2021-05-30 13:54:03 +0200 | [diff] [blame] | 748 | EXTERN char e_cannot_open_terminal_from_command_line_window[] |
| 749 | INIT(= N_("E1188: Cannot open a terminal from the command line window")); |
Bram Moolenaar | c3cb1c9 | 2021-06-02 16:47:53 +0200 | [diff] [blame] | 750 | EXTERN char e_cannot_use_legacy_with_command_str[] |
| 751 | INIT(= N_("E1189: Cannot use :legacy with this command: %s")); |
Bram Moolenaar | 8da6d6d | 2021-06-05 18:15:09 +0200 | [diff] [blame] | 752 | EXTERN char e_one_argument_too_few[] |
| 753 | INIT(= N_("E1190: One argument too few")); |
| 754 | EXTERN char e_nr_arguments_too_few[] |
| 755 | INIT(= N_("E1190: %d arguments too few")); |
Bram Moolenaar | b55d618 | 2021-06-08 22:01:53 +0200 | [diff] [blame] | 756 | EXTERN char e_call_to_function_that_failed_to_compile_str[] |
| 757 | INIT(= N_("E1191: Call to function that failed to compile: %s")); |
Bram Moolenaar | 22db0d5 | 2021-06-12 12:16:55 +0200 | [diff] [blame] | 758 | EXTERN char e_empty_function_name[] |
| 759 | INIT(= N_("E1192: Empty function name")); |
Christian Brabandt | f573c6e | 2021-06-20 14:02:16 +0200 | [diff] [blame] | 760 | // libsodium |
| 761 | EXTERN char e_libsodium_not_built_in[] |
| 762 | INIT(= N_("E1193: cryptmethod xchacha20 not built into this Vim")); |
| 763 | EXTERN char e_libsodium_cannot_encrypt_header[] |
| 764 | INIT(= N_("E1194: Cannot encrypt header, not enough space")); |
| 765 | EXTERN char e_libsodium_cannot_encrypt_buffer[] |
| 766 | INIT(= N_("E1195: Cannot encrypt buffer, not enough space")); |
| 767 | EXTERN char e_libsodium_cannot_decrypt_header[] |
| 768 | INIT(= N_("E1196: Cannot decrypt header, not enough space")); |
| 769 | EXTERN char e_libsodium_cannot_allocate_buffer[] |
| 770 | INIT(= N_("E1197: Cannot allocate_buffer for encryption")); |
| 771 | EXTERN char e_libsodium_decryption_failed_header_incomplete[] |
| 772 | INIT(= N_("E1198: Decryption failed: Header incomplete!")); |
| 773 | EXTERN char e_libsodium_cannot_decrypt_buffer[] |
| 774 | INIT(= N_("E1199: Cannot decrypt buffer, not enough space")); |
Dominique Pelle | cb54bc6 | 2021-06-21 20:15:37 +0200 | [diff] [blame] | 775 | EXTERN char e_libsodium_decryption_failed[] |
Christian Brabandt | 226b28b | 2021-06-21 21:08:08 +0200 | [diff] [blame] | 776 | INIT(= N_("E1200: Decryption failed!")); |
Dominique Pelle | cb54bc6 | 2021-06-21 20:15:37 +0200 | [diff] [blame] | 777 | EXTERN char e_libsodium_decryption_failed_premature[] |
Christian Brabandt | f573c6e | 2021-06-20 14:02:16 +0200 | [diff] [blame] | 778 | INIT(= N_("E1201: Decryption failed: pre-mature end of file!")); |
Bram Moolenaar | 22480d1 | 2021-06-25 21:31:09 +0200 | [diff] [blame] | 779 | EXTERN char e_no_white_space_allowed_after_str_str[] |
| 780 | INIT(= N_("E1202: No white space allowed after '%s': %s")); |
Bram Moolenaar | 3a3b10e | 2021-06-26 15:00:59 +0200 | [diff] [blame] | 781 | EXTERN char e_dot_can_only_be_used_on_dictionary_str[] |
| 782 | INIT(= N_("E1203: Dot can only be used on a dictionary: %s")); |
Bram Moolenaar | 04db26b | 2021-07-05 20:15:23 +0200 | [diff] [blame] | 783 | EXTERN char e_regexp_number_after_dot_pos_search[] |
| 784 | INIT(= N_("E1204: No Number allowed after .: '\\%%%c'")); |
Bram Moolenaar | 1594f31 | 2021-07-08 16:40:13 +0200 | [diff] [blame] | 785 | EXTERN char e_no_white_space_allowed_between_option_and[] |
| 786 | INIT(= N_("E1205: No white space allowed between option and")); |
Yegappan Lakshmanan | 5b73992 | 2021-07-10 13:15:41 +0200 | [diff] [blame] | 787 | EXTERN char e_dict_required_for_argument_nr[] |
| 788 | INIT(= N_("E1206: Dictionary required for argument %d")); |
Bram Moolenaar | c323527 | 2021-07-10 19:42:03 +0200 | [diff] [blame] | 789 | EXTERN char e_expression_without_effect_str[] |
| 790 | INIT(= N_("E1207: Expression without an effect: %s")); |
Bram Moolenaar | 41a3485 | 2021-08-04 16:09:24 +0200 | [diff] [blame] | 791 | EXTERN char e_complete_used_without_allowing_arguments[] |
| 792 | INIT(= N_("E1208: -complete used without allowing arguments")); |
Bram Moolenaar | 0f1227f | 2021-07-11 16:01:58 +0200 | [diff] [blame] | 793 | EXTERN char e_invalid_value_for_line_number_str[] |
| 794 | INIT(= N_("E1209: Invalid value for a line number: \"%s\"")); |
Yegappan Lakshmanan | 1a71d31 | 2021-07-15 12:49:58 +0200 | [diff] [blame] | 795 | EXTERN char e_number_required_for_argument_nr[] |
| 796 | INIT(= N_("E1210: Number required for argument %d")); |
Yegappan Lakshmanan | a9a7c0c | 2021-07-17 19:11:07 +0200 | [diff] [blame] | 797 | EXTERN char e_list_required_for_argument_nr[] |
| 798 | INIT(= N_("E1211: List required for argument %d")); |
| 799 | EXTERN char e_bool_required_for_argument_nr[] |
Bram Moolenaar | 98c2eae | 2021-07-19 10:38:49 +0200 | [diff] [blame] | 800 | INIT(= N_("E1212: Bool required for argument %d")); |
Bram Moolenaar | 24e9316 | 2021-07-18 20:40:33 +0200 | [diff] [blame] | 801 | EXTERN char e_redefining_imported_item_str[] |
Bram Moolenaar | 6057935 | 2021-07-19 21:45:07 +0200 | [diff] [blame] | 802 | INIT(= N_("E1213: Redefining imported item \"%s\"")); |
mityu | 6106504 | 2021-07-19 20:07:21 +0200 | [diff] [blame] | 803 | #if defined(FEAT_DIGRAPHS) && defined(FEAT_EVAL) |
| 804 | EXTERN char e_digraph_must_be_just_two_characters_str[] |
| 805 | INIT(= N_("E1214: Digraph must be just two characters: %s")); |
| 806 | EXTERN char e_digraph_argument_must_be_one_character_str[] |
| 807 | INIT(= N_("E1215: Digraph must be one character: %s")); |
h-east | 29b8571 | 2021-07-26 21:54:04 +0200 | [diff] [blame] | 808 | EXTERN char e_digraph_setlist_argument_must_be_list_of_lists_with_two_items[] |
| 809 | INIT(= N_("E1216: digraph_setlist() argument must be a list of lists with two items")); |
mityu | 6106504 | 2021-07-19 20:07:21 +0200 | [diff] [blame] | 810 | #endif |
Yegappan Lakshmanan | 83494b4 | 2021-07-20 17:51:51 +0200 | [diff] [blame] | 811 | EXTERN char e_chan_or_job_required_for_argument_nr[] |
Yegappan Lakshmanan | 0ad871d | 2021-07-23 20:37:56 +0200 | [diff] [blame] | 812 | INIT(= N_("E1217: Channel or Job required for argument %d")); |
Yegappan Lakshmanan | 83494b4 | 2021-07-20 17:51:51 +0200 | [diff] [blame] | 813 | EXTERN char e_job_required_for_argument_nr[] |
Yegappan Lakshmanan | 0ad871d | 2021-07-23 20:37:56 +0200 | [diff] [blame] | 814 | INIT(= N_("E1218: Job required for argument %d")); |
Yegappan Lakshmanan | 4490ec4 | 2021-07-27 22:00:44 +0200 | [diff] [blame] | 815 | EXTERN char e_float_or_number_required_for_argument_nr[] |
| 816 | INIT(= N_("E1219: Float or Number required for argument %d")); |
| 817 | EXTERN char e_string_or_number_required_for_argument_nr[] |
| 818 | INIT(= N_("E1220: String or Number required for argument %d")); |
| 819 | EXTERN char e_string_or_blob_required_for_argument_nr[] |
| 820 | INIT(= N_("E1221: String or Blob required for argument %d")); |
| 821 | EXTERN char e_string_or_list_required_for_argument_nr[] |
| 822 | INIT(= N_("E1222: String or List required for argument %d")); |
| 823 | EXTERN char e_string_or_dict_required_for_argument_nr[] |
Bram Moolenaar | 78db17c | 2021-07-31 19:12:58 +0200 | [diff] [blame] | 824 | INIT(= N_("E1223: String or Dictionary required for argument %d")); |
| 825 | EXTERN char e_string_number_or_list_required_for_argument_nr[] |
| 826 | INIT(= N_("E1224: String, Number or List required for argument %d")); |
| 827 | EXTERN char e_string_list_or_dict_required_for_argument_nr[] |
| 828 | INIT(= N_("E1225: String, List or Dictionary required for argument %d")); |
Yegappan Lakshmanan | 4490ec4 | 2021-07-27 22:00:44 +0200 | [diff] [blame] | 829 | EXTERN char e_list_or_blob_required_for_argument_nr[] |
Bram Moolenaar | 78db17c | 2021-07-31 19:12:58 +0200 | [diff] [blame] | 830 | INIT(= N_("E1226: List or Blob required for argument %d")); |
Yegappan Lakshmanan | 4490ec4 | 2021-07-27 22:00:44 +0200 | [diff] [blame] | 831 | EXTERN char e_list_or_dict_required_for_argument_nr[] |
| 832 | INIT(= N_("E1227: List or Dictionary required for argument %d")); |
Bram Moolenaar | 78db17c | 2021-07-31 19:12:58 +0200 | [diff] [blame] | 833 | EXTERN char e_list_dict_or_blob_required_for_argument_nr[] |
| 834 | INIT(= N_("E1228: List, Dictionary or Blob required for argument %d")); |
Bram Moolenaar | d47c397 | 2021-07-28 20:52:13 +0200 | [diff] [blame] | 835 | EXTERN char e_expected_dictionary_for_using_key_str_but_got_str[] |
| 836 | INIT(= N_("E1229: Expected dictionary for using key \"%s\", but got %s")); |
Bram Moolenaar | 131530a | 2021-07-29 20:37:49 +0200 | [diff] [blame] | 837 | EXTERN char e_encryption_sodium_mlock_failed[] |
Bram Moolenaar | 63b9173 | 2021-08-05 20:40:03 +0200 | [diff] [blame] | 838 | INIT(= N_("E1230: Encryption: sodium_mlock() failed")); |
| 839 | EXTERN char e_cannot_use_bar_to_separate_commands_here_str[] |
| 840 | INIT(= N_("E1231: Cannot use a bar to separate commands here: %s")); |
Bram Moolenaar | 2673599 | 2021-08-08 14:43:22 +0200 | [diff] [blame] | 841 | EXTERN char e_argument_of_exists_compiled_must_be_literal_string[] |
| 842 | INIT(= N_("E1232: Argument of exists_compiled() must be a literal string")); |
| 843 | EXTERN char e_exists_compiled_can_only_be_used_in_def_function[] |
| 844 | INIT(= N_("E1233: exists_compiled() can only be used in a :def function")); |
Bram Moolenaar | dd9de50 | 2021-08-15 13:49:42 +0200 | [diff] [blame] | 845 | EXTERN char e_legacy_must_be_followed_by_command[] |
| 846 | INIT(= N_("E1234: legacy must be followed by a command")); |
Bram Moolenaar | c66f645 | 2021-08-19 21:08:30 +0200 | [diff] [blame] | 847 | EXTERN char e_function_reference_is_not_set[] |
| 848 | INIT(= N_("E1235: Function reference is not set")); |
Bram Moolenaar | 6853c38 | 2021-09-07 22:12:19 +0200 | [diff] [blame] | 849 | EXTERN char e_cannot_use_str_itself_it_is_imported_with_star[] |
| 850 | INIT(= N_("E1236: Cannot use %s itself, it is imported with '*'")); |
Bram Moolenaar | bdcba24 | 2021-09-12 20:58:02 +0200 | [diff] [blame] | 851 | EXTERN char e_no_such_user_defined_command_in_current_buffer_str[] |
| 852 | INIT(= N_("E1237: No such user-defined command in current buffer: %s")); |
Yegappan Lakshmanan | 5dfe467 | 2021-09-14 17:54:30 +0200 | [diff] [blame] | 853 | EXTERN char e_blob_required_for_argument_nr[] |
| 854 | INIT(= N_("E1238: Blob required for argument %d")); |
| 855 | EXTERN char e_invalid_value_for_blob_nr[] |
| 856 | INIT(= N_("E1239: Invalid value for blob: %d")); |
Bram Moolenaar | eeed1c7 | 2021-10-10 12:35:17 +0100 | [diff] [blame] | 857 | EXTERN char e_resulting_text_too_long[] |
| 858 | INIT(= N_("E1240: Resulting text too long")); |
Bram Moolenaar | 7b82926 | 2021-10-13 15:04:34 +0100 | [diff] [blame] | 859 | EXTERN char e_separator_not_supported_str[] |
| 860 | INIT(= N_("E1241: Separator not supported: %s")); |
| 861 | EXTERN char e_no_white_space_allowed_before_separator_str[] |
| 862 | INIT(= N_("E1242: No white space allowed before separator: %s")); |
Dusan Popovic | 4eeedc0 | 2021-10-16 20:52:05 +0100 | [diff] [blame] | 863 | EXTERN char e_ascii_code_not_in_range[] |
| 864 | INIT(= N_("E1243: ASCII code not in 32-127 range")); |
Drew Vogel | e30d102 | 2021-10-24 20:35:07 +0100 | [diff] [blame] | 865 | EXTERN char e_bad_color_string_str[] |
| 866 | INIT(= N_("E1244: Bad color string: %s")); |
Bram Moolenaar | c449271 | 2021-11-22 15:37:15 +0000 | [diff] [blame] | 867 | EXTERN char e_cannot_expand_sfile_in_vim9_function[] |
| 868 | INIT(= N_("E1245: Cannot expand <sfile> in a Vim9 function")); |
Bram Moolenaar | 04b568b | 2021-11-22 21:58:41 +0000 | [diff] [blame] | 869 | EXTERN char e_cannot_find_variable_to_unlock_str[] |
| 870 | INIT(= N_("E1246: Cannot find variable to (un)lock: %s")); |
Bram Moolenaar | 03725c5 | 2021-11-24 12:17:53 +0000 | [diff] [blame] | 871 | EXTERN char e_line_number_out_of_range[] |
| 872 | INIT(= N_("E1247: Line number out of range")); |
Bram Moolenaar | 69c7617 | 2021-12-02 16:38:52 +0000 | [diff] [blame] | 873 | EXTERN char e_closure_called_from_invalid_context[] |
| 874 | INIT(= N_("E1248: Closure called from invalid context")); |
erw7 | f7f7aaf | 2021-12-07 21:29:20 +0000 | [diff] [blame] | 875 | EXTERN char e_highlight_group_name_too_long[] |
| 876 | INIT(= N_("E1249: Highlight group name too long")); |
rbtnn | c479ce0 | 2021-12-15 19:14:54 +0000 | [diff] [blame] | 877 | EXTERN char e_argument_of_str_must_be_list_string_dictionary_or_blob[] |
| 878 | INIT(= N_("E1250: Argument of %s must be a List, String, Dictionary or Blob")); |
Bram Moolenaar | 2d87759 | 2021-12-16 08:21:09 +0000 | [diff] [blame] | 879 | EXTERN char e_list_dict_blob_or_string_required_for_argument_nr[] |
rbtnn | 0ccb584 | 2021-12-18 18:33:46 +0000 | [diff] [blame] | 880 | INIT(= N_("E1251: List, Dictionary, Blob or String required for argument %d")); |
| 881 | EXTERN char e_string_list_or_blob_required_for_argument_nr[] |
| 882 | INIT(= N_("E1252: String, List or Blob required for argument %d")); |
| 883 | EXTERN char e_string_expected_for_argument_nr[] |
| 884 | INIT(= N_("E1253: String expected for argument %d")); |
Bram Moolenaar | a99fb23 | 2021-12-20 12:25:03 +0000 | [diff] [blame] | 885 | EXTERN char e_cannot_use_script_variable_in_for_loop[] |
| 886 | INIT(= N_("E1254: Cannot use script variable in for loop")); |
Bram Moolenaar | 806da51 | 2021-12-24 19:54:52 +0000 | [diff] [blame] | 887 | EXTERN char e_cmd_mapping_must_end_with_cr[] |
| 888 | INIT(= N_("E1255: <Cmd> mapping must end with <CR>")); |
Bram Moolenaar | 223d0a6 | 2021-12-25 19:29:21 +0000 | [diff] [blame] | 889 | EXTERN char e_string_or_function_required_for_argument_nr[] |
| 890 | INIT(= N_("E1256: String or function required for argument %d")); |