IntenseFinance/neovim
3
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-02-25 18:55:25 -06:00
Code Issues Packages Projects Releases Wiki Activity

Merge #6569 from justinmk/apierror

Browse Source 
api: Do not truncate errors <1 MB
This commit is contained in:
Justin M. Keyes 2017-04-24 02:14:14 +02:00 committed by GitHub
commit 7f6d3d3052
22 changed files with 243 additions and 184 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
scripts/gendispatch.lua
View File

@ -225,8 +225,7 @@ for i = 1, #functions do
end
output:write('\n')
output:write('\n if (args.size != '..#fn.parameters..') {')
output:write('\n snprintf(error->msg, sizeof(error->msg), "Wrong number of arguments: expecting '..#fn.parameters..' but got %zu", args.size);')
output:write('\n error->set = true;')
output:write('\n api_set_error(error, kErrorTypeException, "Wrong number of arguments: expecting '..#fn.parameters..' but got %zu", args.size);')
output:write('\n goto cleanup;')
output:write('\n }\n')
@ -251,8 +250,7 @@ for i = 1, #functions do
output:write('\n '..converted..' = (handle_T)args.items['..(j - 1)..'].data.integer;')
end
output:write('\n } else {')
output:write('\n snprintf(error->msg, sizeof(error->msg), "Wrong type for argument '..j..', expecting '..param[1]..'");')
output:write('\n error->set = true;')
output:write('\n api_set_error(error, kErrorTypeException, "Wrong type for argument '..j..', expecting '..param[1]..'");')
output:write('\n goto cleanup;')
output:write('\n }\n')
else
@ -292,7 +290,7 @@ for i = 1, #functions do
output:write('error);\n')
end
-- and check for the error
output:write('\n if (error->set) {')
output:write('\n if (ERROR_SET(error)) {')
output:write('\n goto cleanup;')
output:write('\n }\n')
else

50
src/nvim/api/buffer.c
View File

@ -65,7 +65,7 @@ String buffer_get_line(Buffer buffer, Integer index, Error *err)
index = convert_index(index);
Array slice = nvim_buf_get_lines(0, buffer, index, index+1, true, err);
if (!err->set && slice.size) {
if (!ERROR_SET(err) && slice.size) {
rv = slice.items[0].data.string;
}
@ -171,7 +171,7 @@ ArrayOf(String) nvim_buf_get_lines(uint64_t channel_id,
end = normalize_index(buf, end, &oob);
if (strict_indexing && oob) {
api_set_error(err, Validation, _("Index out of bounds"));
api_set_error(err, kErrorTypeValidation, "Index out of bounds");
return rv;
}
@ -187,7 +187,7 @@ ArrayOf(String) nvim_buf_get_lines(uint64_t channel_id,
int64_t lnum = start + (int64_t)i;
if (lnum > LONG_MAX) {
api_set_error(err, Validation, _("Line index is too high"));
api_set_error(err, kErrorTypeValidation, "Line index is too high");
goto end;
}
@ -203,7 +203,7 @@ ArrayOf(String) nvim_buf_get_lines(uint64_t channel_id,
}
end:
if (err->set) {
if (ERROR_SET(err)) {
for (size_t i = 0; i < rv.size; i++) {
xfree(rv.items[i].data.string.data);
}
@ -283,15 +283,15 @@ void nvim_buf_set_lines(uint64_t channel_id,
end = normalize_index(buf, end, &oob);
if (strict_indexing && oob) {
api_set_error(err, Validation, _("Index out of bounds"));
api_set_error(err, kErrorTypeValidation, "Index out of bounds");
return;
}
if (start > end) {
api_set_error(err,
Validation,
_("Argument \"start\" is higher than \"end\""));
kErrorTypeValidation,
"Argument \"start\" is higher than \"end\"");
return;
}
@ -305,8 +305,8 @@ void nvim_buf_set_lines(uint64_t channel_id,
for (size_t i = 0; i < new_len; i++) {
if (replacement.items[i].type != kObjectTypeString) {
api_set_error(err,
Validation,
_("All items in the replacement array must be strings"));
kErrorTypeValidation,
"All items in the replacement array must be strings");
goto end;
}
@ -317,7 +317,8 @@ void nvim_buf_set_lines(uint64_t channel_id,
lines[i] = xmallocz(l.size);
for (size_t j = 0; j < l.size; j++) {
if (l.data[j] == '\n' && channel_id != INTERNAL_CALL) {
api_set_error(err, Exception, _("string cannot contain newlines"));
api_set_error(err, kErrorTypeException,
"String cannot contain newlines");
new_len = i + 1;
goto end;
}
@ -330,7 +331,7 @@ void nvim_buf_set_lines(uint64_t channel_id,
switch_to_win_for_buf(buf, &save_curwin, &save_curtab, &save_curbuf);
if (u_save((linenr_T)(start - 1), (linenr_T)end) == FAIL) {
api_set_error(err, Exception, _("Failed to save undo information"));
api_set_error(err, kErrorTypeException, "Failed to save undo information");
goto end;
}
@ -340,7 +341,7 @@ void nvim_buf_set_lines(uint64_t channel_id,
size_t to_delete = (new_len < old_len) ? (size_t)(old_len - new_len) : 0;
for (size_t i = 0; i < to_delete; i++) {
if (ml_delete((linenr_T)start, false) == FAIL) {
api_set_error(err, Exception, _("Failed to delete line"));
api_set_error(err, kErrorTypeException, "Failed to delete line");
goto end;
}
}
@ -357,12 +358,12 @@ void nvim_buf_set_lines(uint64_t channel_id,
int64_t lnum = start + (int64_t)i;
if (lnum > LONG_MAX) {
api_set_error(err, Validation, _("Index value is too high"));
api_set_error(err, kErrorTypeValidation, "Index value is too high");
goto end;
}
if (ml_replace((linenr_T)lnum, (char_u *)lines[i], false) == FAIL) {
api_set_error(err, Exception, _("Failed to replace line"));
api_set_error(err, kErrorTypeException, "Failed to replace line");
goto end;
}
// Mark lines that haven't been passed to the buffer as they need
@ -375,12 +376,12 @@ void nvim_buf_set_lines(uint64_t channel_id,
int64_t lnum = start + (int64_t)i - 1;
if (lnum > LONG_MAX) {
api_set_error(err, Validation, _("Index value is too high"));
api_set_error(err, kErrorTypeValidation, "Index value is too high");
goto end;
}
if (ml_append((linenr_T)lnum, (char_u *)lines[i], 0, false) == FAIL) {
api_set_error(err, Exception, _("Failed to insert line"));
api_set_error(err, kErrorTypeException, "Failed to insert line");
goto end;
}
@ -627,7 +628,7 @@ void nvim_buf_set_name(Buffer buffer, String name, Error *err)
}
if (ren_ret == FAIL) {
api_set_error(err, Exception, _("Failed to rename buffer"));
api_set_error(err, kErrorTypeException, "Failed to rename buffer");
}
}
@ -639,7 +640,9 @@ Boolean nvim_buf_is_valid(Buffer buffer)
FUNC_API_SINCE(1)
{
Error stub = ERROR_INIT;
return find_buffer_by_handle(buffer, &stub) != NULL;
Boolean ret = find_buffer_by_handle(buffer, &stub) != NULL;
api_clear_error(&stub);
return ret;
}
/// Inserts a sequence of lines to a buffer at a certain index
@ -678,7 +681,8 @@ ArrayOf(Integer, 2) nvim_buf_get_mark(Buffer buffer, String name, Error *err)
}
if (name.size != 1) {
api_set_error(err, Validation, _("Mark name must be a single character"));
api_set_error(err, kErrorTypeValidation,
"Mark name must be a single character");
return rv;
}
@ -696,7 +700,7 @@ ArrayOf(Integer, 2) nvim_buf_get_mark(Buffer buffer, String name, Error *err)
}
if (posp == NULL) {
api_set_error(err, Validation, _("Invalid mark name"));
api_set_error(err, kErrorTypeValidation, "Invalid mark name");
return rv;
}
@ -751,11 +755,11 @@ Integer nvim_buf_add_highlight(Buffer buffer,
}
if (line < 0 || line >= MAXLNUM) {
api_set_error(err, Validation, _("Line number outside range"));
api_set_error(err, kErrorTypeValidation, "Line number outside range");
return 0;
}
if (col_start < 0 || col_start > MAXCOL) {
api_set_error(err, Validation, _("Column value outside range"));
api_set_error(err, kErrorTypeValidation, "Column value outside range");
return 0;
}
if (col_end < 0 || col_end > MAXCOL) {
@ -792,7 +796,7 @@ void nvim_buf_clear_highlight(Buffer buffer,
}
if (line_start < 0 || line_start >= MAXLNUM) {
api_set_error(err, Validation, _("Line number outside range"));
api_set_error(err, kErrorTypeValidation, "Line number outside range");
return;
}
if (line_end < 0 || line_end > MAXLNUM) {

8
src/nvim/api/private/defs.h
View File

@ -8,9 +8,11 @@
#define ARRAY_DICT_INIT {.size = 0, .capacity = 0, .items = NULL}
#define STRING_INIT {.data = NULL, .size = 0}
#define OBJECT_INIT { .type = kObjectTypeNil }
#define ERROR_INIT { .set = false }
#define ERROR_INIT { .type = kErrorTypeNone, .msg = NULL }
#define REMOTE_TYPE(type) typedef handle_T type
#define ERROR_SET(e) ((e)->type != kErrorTypeNone)
#ifdef INCLUDE_GENERATED_DECLARATIONS
# define ArrayOf(...) Array
# define DictionaryOf(...) Dictionary
@ -20,6 +22,7 @@ typedef int handle_T;
// Basic types
typedef enum {
kErrorTypeNone = -1,
kErrorTypeException,
kErrorTypeValidation
} ErrorType;
@ -38,8 +41,7 @@ typedef enum {
typedef struct {
ErrorType type;
char msg[1024];
bool set;
char *msg;
} Error;
typedef bool Boolean;

130
src/nvim/api/private/helpers.c
View File

@ -61,7 +61,7 @@ bool try_end(Error *err)
discard_current_exception();
}
api_set_error(err, Exception, _("Keyboard interrupt"));
api_set_error(err, kErrorTypeException, "Keyboard interrupt");
got_int = false;
} else if (msg_list != NULL && *msg_list != NULL) {
int should_free;
@ -69,19 +69,18 @@ bool try_end(Error *err)
ET_ERROR,
NULL,
&should_free);
xstrlcpy(err->msg, msg, sizeof(err->msg));
err->set = true;
api_set_error(err, kErrorTypeException, "%s", msg);
free_global_msglist();
if (should_free) {
xfree(msg);
}
} else if (did_throw) {
api_set_error(err, Exception, "%s", current_exception->value);
api_set_error(err, kErrorTypeException, "%s", current_exception->value);
discard_current_exception();
}
return err->set;
return ERROR_SET(err);
}
/// Recursively expands a vimscript value in a dict
@ -94,8 +93,8 @@ Object dict_get_value(dict_T *dict, String key, Error *err)
dictitem_T *const di = tv_dict_find(dict, key.data, (ptrdiff_t)key.size);
if (di == NULL) {
api_set_error(err, Validation, _("Key not found"));
return (Object) OBJECT_INIT;
api_set_error(err, kErrorTypeValidation, "Key not found");
return (Object)OBJECT_INIT;
}
return vim_to_object(&di->di_tv);
@ -118,17 +117,18 @@ Object dict_set_var(dict_T *dict, String key, Object value, bool del,
Object rv = OBJECT_INIT;
if (dict->dv_lock) {
api_set_error(err, Exception, _("Dictionary is locked"));
api_set_error(err, kErrorTypeException, "Dictionary is locked");
return rv;
}
if (key.size == 0) {
api_set_error(err, Validation, _("Empty variable names aren't allowed"));
api_set_error(err, kErrorTypeValidation,
"Empty variable names aren't allowed");
return rv;
}
if (key.size > INT_MAX) {
api_set_error(err, Validation, _("Key length is too high"));
api_set_error(err, kErrorTypeValidation, "Key length is too high");
return rv;
}
@ -136,13 +136,13 @@ Object dict_set_var(dict_T *dict, String key, Object value, bool del,
if (di != NULL) {
if (di->di_flags & DI_FLAGS_RO) {
api_set_error(err, Exception, _("Key is read-only: %s"), key.data);
api_set_error(err, kErrorTypeException, "Key is read-only: %s", key.data);
return rv;
} else if (di->di_flags & DI_FLAGS_FIX) {
api_set_error(err, Exception, _("Key is fixed: %s"), key.data);
api_set_error(err, kErrorTypeException, "Key is fixed: %s", key.data);
return rv;
} else if (di->di_flags & DI_FLAGS_LOCK) {
api_set_error(err, Exception, _("Key is locked: %s"), key.data);
api_set_error(err, kErrorTypeException, "Key is locked: %s", key.data);
return rv;
}
}
@ -151,7 +151,8 @@ Object dict_set_var(dict_T *dict, String key, Object value, bool del,
// Delete the key
if (di == NULL) {
// Doesn't exist, fail
api_set_error(err, Validation, _("Key \"%s\" doesn't exist"), key.data);
api_set_error(err, kErrorTypeValidation, "Key does not exist: %s",
key.data);
} else {
// Return the old value
if (retval) {
@ -203,7 +204,7 @@ Object get_option_from(void *from, int type, String name, Error *err)
Object rv = OBJECT_INIT;
if (name.size == 0) {
api_set_error(err, Validation, _("Empty option name"));
api_set_error(err, kErrorTypeValidation, "Empty option name");
return rv;
}
@ -215,8 +216,8 @@ Object get_option_from(void *from, int type, String name, Error *err)
if (!flags) {
api_set_error(err,
Validation,
_("Invalid option name \"%s\""),
kErrorTypeValidation,
"Invalid option name \"%s\"",
name.data);
return rv;
}
@ -234,14 +235,14 @@ Object get_option_from(void *from, int type, String name, Error *err)
rv.data.string.size = strlen(stringval);
} else {
api_set_error(err,
Exception,
_("Unable to get value for option \"%s\""),
kErrorTypeException,
"Unable to get value for option \"%s\"",
name.data);
}
} else {
api_set_error(err,
Exception,
_("Unknown type for option \"%s\""),
kErrorTypeException,
"Unknown type for option \"%s\"",
name.data);
}
@ -258,7 +259,7 @@ Object get_option_from(void *from, int type, String name, Error *err)
void set_option_to(void *to, int type, String name, Object value, Error *err)
{
if (name.size == 0) {
api_set_error(err, Validation, _("Empty option name"));
api_set_error(err, kErrorTypeValidation, "Empty option name");
return;
}
@ -266,8 +267,8 @@ void set_option_to(void *to, int type, String name, Object value, Error *err)
if (flags == 0) {
api_set_error(err,
Validation,
_("Invalid option name \"%s\""),
kErrorTypeValidation,
"Invalid option name \"%s\"",
name.data);
return;
}
@ -275,15 +276,15 @@ void set_option_to(void *to, int type, String name, Object value, Error *err)
if (value.type == kObjectTypeNil) {
if (type == SREQ_GLOBAL) {
api_set_error(err,
Exception,
_("Unable to unset option \"%s\""),
kErrorTypeException,
"Unable to unset option \"%s\"",
name.data);
return;
} else if (!(flags & SOPT_GLOBAL)) {
api_set_error(err,
Exception,
_("Cannot unset option \"%s\" "
"because it doesn't have a global value"),
kErrorTypeException,
"Cannot unset option \"%s\" "
"because it doesn't have a global value",
name.data);
return;
} else {
@ -297,8 +298,8 @@ void set_option_to(void *to, int type, String name, Object value, Error *err)
if (flags & SOPT_BOOL) {
if (value.type != kObjectTypeBoolean) {
api_set_error(err,
Validation,
_("Option \"%s\" requires a boolean value"),
kErrorTypeValidation,
"Option \"%s\" requires a boolean value",
name.data);
return;
}
@ -308,16 +309,16 @@ void set_option_to(void *to, int type, String name, Object value, Error *err)
} else if (flags & SOPT_NUM) {
if (value.type != kObjectTypeInteger) {
api_set_error(err,
Validation,
_("Option \"%s\" requires an integer value"),
kErrorTypeValidation,
"Option \"%s\" requires an integer value",
name.data);
return;
}
if (value.data.integer > INT_MAX || value.data.integer < INT_MIN) {
api_set_error(err,
Validation,
_("Value for option \"%s\" is outside range"),
kErrorTypeValidation,
"Value for option \"%s\" is outside range",
name.data);
return;
}
@ -327,8 +328,8 @@ void set_option_to(void *to, int type, String name, Object value, Error *err)
} else {
if (value.type != kObjectTypeString) {
api_set_error(err,
Validation,
_("Option \"%s\" requires a string value"),
kErrorTypeValidation,
"Option \"%s\" requires a string value",
name.data);
return;
}
@ -561,13 +562,13 @@ buf_T *find_buffer_by_handle(Buffer buffer, Error *err)
buf_T *rv = handle_get_buffer(buffer);
if (!rv) {
api_set_error(err, Validation, _("Invalid buffer id"));
api_set_error(err, kErrorTypeValidation, "Invalid buffer id");
}
return rv;
}
win_T * find_window_by_handle(Window window, Error *err)
win_T *find_window_by_handle(Window window, Error *err)
{
if (window == 0) {
return curwin;
@ -576,13 +577,13 @@ win_T * find_window_by_handle(Window window, Error *err)
win_T *rv = handle_get_window(window);
if (!rv) {
api_set_error(err, Validation, _("Invalid window id"));
api_set_error(err, kErrorTypeValidation, "Invalid window id");
}
return rv;
}
tabpage_T * find_tab_by_handle(Tabpage tabpage, Error *err)
tabpage_T *find_tab_by_handle(Tabpage tabpage, Error *err)
{
if (tabpage == 0) {
return curtab;
@ -591,7 +592,7 @@ tabpage_T * find_tab_by_handle(Tabpage tabpage, Error *err)
tabpage_T *rv = handle_get_tabpage(tabpage);
if (!rv) {
api_set_error(err, Validation, _("Invalid tabpage id"));
api_set_error(err, kErrorTypeValidation, "Invalid tabpage id");
}
return rv;
@ -659,7 +660,7 @@ bool object_to_vim(Object obj, typval_T *tv, Error *err)
case kObjectTypeInteger:
if (obj.data.integer > VARNUMBER_MAX
|| obj.data.integer < VARNUMBER_MIN) {
api_set_error(err, Validation, _("Integer value outside range"));
api_set_error(err, kErrorTypeValidation, "Integer value outside range");
return false;
}
@ -713,8 +714,8 @@ bool object_to_vim(Object obj, typval_T *tv, Error *err)
String key = item.key;
if (key.size == 0) {
api_set_error(err, Validation,
_("Empty dictionary keys aren't allowed"));
api_set_error(err, kErrorTypeValidation,
"Empty dictionary keys aren't allowed");
// cleanup
tv_dict_free(dict);
return false;
@ -801,6 +802,17 @@ void api_free_dictionary(Dictionary value)
xfree(value.items);
}
void api_clear_error(Error *value)
FUNC_ATTR_NONNULL_ALL
{
if (!ERROR_SET(value)) {
return;
}
xfree(value->msg);
value->msg = NULL;
value->type = kErrorTypeNone;
}
Dictionary api_metadata(void)
{
static Dictionary metadata = ARRAY_DICT_INIT;
@ -927,8 +939,8 @@ static void set_option_value_for(char *key,
return;
}
api_set_error(err,
Exception,
_("Problem while switching windows"));
kErrorTypeException,
"Problem while switching windows");
return;
}
set_option_value_err(key, numval, stringval, opt_flags, err);
@ -944,7 +956,7 @@ static void set_option_value_for(char *key,
break;
}
if (err->set) {
if (ERROR_SET(err)) {
return;
}
@ -965,6 +977,26 @@ static void set_option_value_err(char *key,
return;
}
api_set_error(err, Exception, "%s", errmsg);
api_set_error(err, kErrorTypeException, "%s", errmsg);
}
}
void api_set_error(Error *err, ErrorType errType, const char *format, ...)
FUNC_ATTR_NONNULL_ALL
{
assert(kErrorTypeNone != errType);
va_list args1;
va_list args2;
va_start(args1, format);
va_copy(args2, args1);
int len = vsnprintf(NULL, 0, format, args1);
va_end(args1);
assert(len >= 0);
// Limit error message to 1 MB.
size_t bufsize = MIN((size_t)len + 1, 1024 * 1024);
err->msg = xmalloc(bufsize);
vsnprintf(err->msg, bufsize, format, args2);
va_end(args2);
err->type = errType;
}

10
src/nvim/api/private/helpers.h
View File

@ -8,16 +8,6 @@
#include "nvim/memory.h"
#include "nvim/lib/kvec.h"
// -V:api_set_error:618
#define api_set_error(err, errtype, ...) \
do { \
snprintf((err)->msg, \
sizeof((err)->msg), \
__VA_ARGS__); \
(err)->set = true; \
(err)->type = kErrorType##errtype; \
} while (0)
#define OBJECT_OBJ(o) o
#define BOOLEAN_OBJ(b) ((Object) { \

4
src/nvim/api/tabpage.c
View File

@ -193,6 +193,8 @@ Boolean nvim_tabpage_is_valid(Tabpage tabpage)
FUNC_API_SINCE(1)
{
Error stub = ERROR_INIT;
return find_tab_by_handle(tabpage, &stub) != NULL;
Boolean ret = find_tab_by_handle(tabpage, &stub) != NULL;
api_clear_error(&stub);
return ret;
}

28
src/nvim/api/ui.c
View File

@ -55,13 +55,13 @@ void nvim_ui_attach(uint64_t channel_id, Integer width, Integer height,
FUNC_API_SINCE(1) FUNC_API_NOEVAL
{
if (pmap_has(uint64_t)(connected_uis, channel_id)) {
api_set_error(err, Exception, _("UI already attached for channel"));
api_set_error(err, kErrorTypeException, "UI already attached for channel");
return;
}
if (width <= 0 || height <= 0) {
api_set_error(err, Validation,
_("Expected width > 0 and height > 0"));
api_set_error(err, kErrorTypeValidation,
"Expected width > 0 and height > 0");
return;
}
UI *ui = xcalloc(1, sizeof(UI));
@ -97,7 +97,7 @@ void nvim_ui_attach(uint64_t channel_id, Integer width, Integer height,
for (size_t i = 0; i < options.size; i++) {
ui_set_option(ui, options.items[i].key, options.items[i].value, err);
if (err->set) {
if (ERROR_SET(err)) {
xfree(ui);
return;
}
@ -126,7 +126,7 @@ void nvim_ui_detach(uint64_t channel_id, Error *err)
FUNC_API_SINCE(1) FUNC_API_NOEVAL
{
if (!pmap_has(uint64_t)(connected_uis, channel_id)) {
api_set_error(err, Exception, _("UI is not attached for channel"));
api_set_error(err, kErrorTypeException, "UI is not attached for channel");
return;
}
remote_ui_disconnect(channel_id);
@ -138,13 +138,13 @@ void nvim_ui_try_resize(uint64_t channel_id, Integer width,
FUNC_API_SINCE(1) FUNC_API_NOEVAL
{
if (!pmap_has(uint64_t)(connected_uis, channel_id)) {
api_set_error(err, Exception, _("UI is not attached for channel"));
api_set_error(err, kErrorTypeException, "UI is not attached for channel");
return;
}
if (width <= 0 || height <= 0) {
api_set_error(err, Validation,
_("Expected width > 0 and height > 0"));
api_set_error(err, kErrorTypeValidation,
"Expected width > 0 and height > 0");
return;
}
@ -159,13 +159,13 @@ void nvim_ui_set_option(uint64_t channel_id, String name,
FUNC_API_SINCE(1) FUNC_API_NOEVAL
{
if (!pmap_has(uint64_t)(connected_uis, channel_id)) {
api_set_error(error, Exception, _("UI is not attached for channel"));
api_set_error(error, kErrorTypeException, "UI is not attached for channel");
return;
}
UI *ui = pmap_get(uint64_t)(connected_uis, channel_id);
ui_set_option(ui, name, value, error);
if (!error->set) {
if (!ERROR_SET(error)) {
ui_refresh();
}
}
@ -173,19 +173,19 @@ void nvim_ui_set_option(uint64_t channel_id, String name,
static void ui_set_option(UI *ui, String name, Object value, Error *error) {
if (strcmp(name.data, "rgb") == 0) {
if (value.type != kObjectTypeBoolean) {
api_set_error(error, Validation, _("rgb must be a Boolean"));
api_set_error(error, kErrorTypeValidation, "rgb must be a Boolean");
return;
}
ui->rgb = value.data.boolean;
} else if (strcmp(name.data, "popupmenu_external") == 0) {
if (value.type != kObjectTypeBoolean) {
api_set_error(error, Validation,
_("popupmenu_external must be a Boolean"));
api_set_error(error, kErrorTypeValidation,
"popupmenu_external must be a Boolean");
return;
}
ui->pum_external = value.data.boolean;
} else {
api_set_error(error, Validation, _("No such ui option"));
api_set_error(error, kErrorTypeValidation, "No such ui option");
}
}

54
src/nvim/api/vim.c
View File

@ -165,8 +165,8 @@ String nvim_command_output(String str, Error *err)
nvim_command(str, err);
do_cmdline_cmd("redir END");
if (err->set) {
return (String) STRING_INIT;
if (ERROR_SET(err)) {
return (String)STRING_INIT;
}
return cstr_to_string((char *)get_vim_var_str(VV_COMMAND_OUTPUT));
@ -188,7 +188,7 @@ Object nvim_eval(String expr, Error *err)
typval_T rettv;
if (eval0((char_u *)expr.data, &rettv, NULL, true) == FAIL) {
api_set_error(err, Exception, "Failed to evaluate expression");
api_set_error(err, kErrorTypeException, "Failed to evaluate expression");
}
if (!try_end(err)) {
@ -214,8 +214,8 @@ Object nvim_call_function(String fname, Array args, Error *err)
{
Object rv = OBJECT_INIT;
if (args.size > MAX_FUNC_ARGS) {
api_set_error(err, Validation,
_("Function called with too many arguments."));
api_set_error(err, kErrorTypeValidation,
"Function called with too many arguments.");
return rv;
}
@ -237,7 +237,7 @@ Object nvim_call_function(String fname, Array args, Error *err)
curwin->w_cursor.lnum, curwin->w_cursor.lnum, &dummy,
true, NULL, NULL);
if (r == FAIL) {
api_set_error(err, Exception, _("Error calling function."));
api_set_error(err, kErrorTypeException, "Error calling function.");
}
if (!try_end(err)) {
rv = vim_to_object(&rettv);
@ -262,7 +262,7 @@ Integer nvim_strwidth(String str, Error *err)
FUNC_API_SINCE(1)
{
if (str.size > INT_MAX) {
api_set_error(err, Validation, _("String length is too high"));
api_set_error(err, kErrorTypeValidation, "String length is too high");
return 0;
}
@ -318,7 +318,7 @@ void nvim_set_current_dir(String dir, Error *err)
FUNC_API_SINCE(1)
{
if (dir.size >= MAXPATHL) {
api_set_error(err, Validation, _("Directory string is too long"));
api_set_error(err, kErrorTypeValidation, "Directory string is too long");
return;
}
@ -330,7 +330,7 @@ void nvim_set_current_dir(String dir, Error *err)
if (vim_chdir((char_u *)string, kCdScopeGlobal)) {
if (!try_end(err)) {
api_set_error(err, Exception, _("Failed to change directory"));
api_set_error(err, kErrorTypeException, "Failed to change directory");
}
return;
}
@ -539,8 +539,8 @@ void nvim_set_current_buf(Buffer buffer, Error *err)
int result = do_buffer(DOBUF_GOTO, DOBUF_FIRST, FORWARD, buf->b_fnum, 0);
if (!try_end(err) && result == FAIL) {
api_set_error(err,
Exception,
_("Failed to switch to buffer %d"),
kErrorTypeException,
"Failed to switch to buffer %d",
buffer);
}
}
@ -592,8 +592,8 @@ void nvim_set_current_win(Window window, Error *err)
goto_tabpage_win(win_find_tabpage(win), win);
if (!try_end(err) && win != curwin) {
api_set_error(err,
Exception,
_("Failed to switch to window %d"),
kErrorTypeException,
"Failed to switch to window %d",
window);
}
}
@ -646,8 +646,8 @@ void nvim_set_current_tabpage(Tabpage tabpage, Error *err)
goto_tabpage_tp(tp, true, true);
if (!try_end(err) && tp != curtab) {
api_set_error(err,
Exception,
_("Failed to switch to tabpage %d"),
kErrorTypeException,
"Failed to switch to tabpage %d",
tabpage);
}
}
@ -745,30 +745,30 @@ Array nvim_call_atomic(uint64_t channel_id, Array calls, Error *err)
for (i = 0; i < calls.size; i++) {
if (calls.items[i].type != kObjectTypeArray) {
api_set_error(err,
Validation,
_("All items in calls array must be arrays"));
kErrorTypeValidation,
"All items in calls array must be arrays");
goto validation_error;
}
Array call = calls.items[i].data.array;
if (call.size != 2) {
api_set_error(err,
Validation,
_("All items in calls array must be arrays of size 2"));
kErrorTypeValidation,
"All items in calls array must be arrays of size 2");
goto validation_error;
}
if (call.items[0].type != kObjectTypeString) {
api_set_error(err,
Validation,
_("name must be String"));
kErrorTypeValidation,
"Name must be String");
goto validation_error;
}
String name = call.items[0].data.string;
if (call.items[1].type != kObjectTypeArray) {
api_set_error(err,
Validation,
_("args must be Array"));
kErrorTypeValidation,
"Args must be Array");
goto validation_error;
}
Array args = call.items[1].data.array;
@ -776,7 +776,7 @@ Array nvim_call_atomic(uint64_t channel_id, Array calls, Error *err)
MsgpackRpcRequestHandler handler = msgpack_rpc_get_handler_for(name.data,
name.size);
Object result = handler.fn(channel_id, args, &nested_error);
if (nested_error.set) {
if (ERROR_SET(&nested_error)) {
// error handled after loop
break;
}
@ -785,7 +785,7 @@ Array nvim_call_atomic(uint64_t channel_id, Array calls, Error *err)
}
ADD(rv, ARRAY_OBJ(results));
if (nested_error.set) {
if (ERROR_SET(&nested_error)) {
Array errval = ARRAY_DICT_INIT;
ADD(errval, INTEGER_OBJ((Integer)i));
ADD(errval, INTEGER_OBJ(nested_error.type));
@ -794,10 +794,12 @@ Array nvim_call_atomic(uint64_t channel_id, Array calls, Error *err)
} else {
ADD(rv, NIL);
}
return rv;
goto theend;
validation_error:
api_free_array(results);
theend:
api_clear_error(&nested_error);
return rv;
}

16
src/nvim/api/window.c
View File

@ -65,8 +65,8 @@ void nvim_win_set_cursor(Window window, ArrayOf(Integer, 2) pos, Error *err)
if (pos.size != 2 || pos.items[0].type != kObjectTypeInteger
|| pos.items[1].type != kObjectTypeInteger) {
api_set_error(err,
Validation,
_("Argument \"pos\" must be a [row, col] array"));
kErrorTypeValidation,
"Argument \"pos\" must be a [row, col] array");
return;
}
@ -78,12 +78,12 @@ void nvim_win_set_cursor(Window window, ArrayOf(Integer, 2) pos, Error *err)
int64_t col = pos.items[1].data.integer;
if (row <= 0 || row > win->w_buffer->b_ml.ml_line_count) {
api_set_error(err, Validation, _("Cursor position outside buffer"));
api_set_error(err, kErrorTypeValidation, "Cursor position outside buffer");
return;
}
if (col > MAXCOL || col < 0) {
api_set_error(err, Validation, _("Column value outside range"));
api_set_error(err, kErrorTypeValidation, "Column value outside range");
return;
}
@ -132,7 +132,7 @@ void nvim_win_set_height(Window window, Integer height, Error *err)
}
if (height > INT_MAX || height < INT_MIN) {
api_set_error(err, Validation, _("Height value outside range"));
api_set_error(err, kErrorTypeValidation, "Height value outside range");
return;
}
@ -177,7 +177,7 @@ void nvim_win_set_width(Window window, Integer width, Error *err)
}
if (width > INT_MAX || width < INT_MIN) {
api_set_error(err, Validation, _("Width value outside range"));
api_set_error(err, kErrorTypeValidation, "Width value outside range");
return;
}
@ -387,6 +387,8 @@ Boolean nvim_win_is_valid(Window window)
FUNC_API_SINCE(1)
{
Error stub = ERROR_INIT;
return find_window_by_handle(window, &stub) != NULL;
Boolean ret = find_window_by_handle(window, &stub) != NULL;
api_clear_error(&stub);
return ret;
}

10
src/nvim/eval.c
View File

@ -6512,7 +6512,7 @@ static void api_wrapper(typval_T *argvars, typval_T *rettv, FunPtr fptr)
Error err = ERROR_INIT;
Object result = fn(INTERNAL_CALL, args, &err);
if (err.set) {
if (ERROR_SET(&err)) {
nvim_err_writeln(cstr_as_string(err.msg));
goto end;
}
@ -6524,6 +6524,7 @@ static void api_wrapper(typval_T *argvars, typval_T *rettv, FunPtr fptr)
end:
api_free_array(args);
api_free_object(result);
api_clear_error(&err);
}
/*
@ -13783,7 +13784,7 @@ static void f_rpcrequest(typval_T *argvars, typval_T *rettv, FunPtr fptr)
restore_funccal(save_funccalp);
}
if (err.set) {
if (ERROR_SET(&err)) {
nvim_err_writeln(cstr_as_string(err.msg));
goto end;
}
@ -13794,6 +13795,7 @@ static void f_rpcrequest(typval_T *argvars, typval_T *rettv, FunPtr fptr)
end:
api_free_object(result);
api_clear_error(&err);
}
// "rpcstart()" function (DEPRECATED)
@ -16523,11 +16525,13 @@ static void f_termopen(typval_T *argvars, typval_T *rettv, FunPtr fptr)
curbuf->b_p_swf = false;
(void)setfname(curbuf, (char_u *)buf, NULL, true);
// Save the job id and pid in b:terminal_job_{id,pid}
Error err;
Error err = ERROR_INIT;
dict_set_var(curbuf->b_vars, cstr_as_string("terminal_job_id"),
INTEGER_OBJ(rettv->vval.v_number), false, false, &err);
api_clear_error(&err);
dict_set_var(curbuf->b_vars, cstr_as_string("terminal_job_pid"),
INTEGER_OBJ(pid), false, false, &err);
api_clear_error(&err);
Terminal *term = terminal_open(topts);
data->term = term;

22
src/nvim/msgpack_rpc/channel.c
View File

@ -192,7 +192,7 @@ Object channel_send_call(uint64_t id,
Channel *channel = NULL;
if (!(channel = pmap_get(uint64_t)(channels, id)) || channel->closed) {
api_set_error(err, Exception, _("Invalid channel \"%" PRIu64 "\""), id);
api_set_error(err, kErrorTypeException, "Invalid channel: %" PRIu64, id);
api_free_array(args);
return NIL;
}
@ -212,7 +212,8 @@ Object channel_send_call(uint64_t id,
if (frame.errored) {
if (frame.result.type == kObjectTypeString) {
api_set_error(err, Exception, "%s", frame.result.data.string.data);
api_set_error(err, kErrorTypeException, "%s",
frame.result.data.string.data);
} else if (frame.result.type == kObjectTypeArray) {
// Should be an error in the form [type, message]
Array array = frame.result.data.array;
@ -220,14 +221,13 @@ Object channel_send_call(uint64_t id,
&& (array.items[0].data.integer == kErrorTypeException
|| array.items[0].data.integer == kErrorTypeValidation)
&& array.items[1].type == kObjectTypeString) {
err->type = (ErrorType) array.items[0].data.integer;
xstrlcpy(err->msg, array.items[1].data.string.data, sizeof(err->msg));
err->set = true;
api_set_error(err, (ErrorType)array.items[0].data.integer, "%s",
array.items[1].data.string.data);
} else {
api_set_error(err, Exception, "%s", "unknown error");
api_set_error(err, kErrorTypeException, "%s", "unknown error");
}
} else {
api_set_error(err, Exception, "%s", "unknown error");
api_set_error(err, kErrorTypeException, "%s", "unknown error");
}
api_free_object(frame.result);
@ -398,7 +398,7 @@ static void handle_request(Channel *channel, msgpack_object *request)
Error error = ERROR_INIT;
msgpack_rpc_validate(&request_id, request, &error);
if (error.set) {
if (ERROR_SET(&error)) {
// Validation failed, send response with error
if (channel_write(channel,
serialize_response(channel->id,
@ -412,9 +412,9 @@ static void handle_request(Channel *channel, msgpack_object *request)
channel->id);
call_set_error(channel, buf);
}
api_clear_error(&error);
return;
}
// Retrieve the request handler
MsgpackRpcRequestHandler handler;
msgpack_object *method = msgpack_rpc_method(request);
@ -470,6 +470,7 @@ static void on_request_event(void **argv)
api_free_array(args);
decref(channel);
xfree(e);
api_clear_error(&error);
}
static bool channel_write(Channel *channel, WBuffer *buffer)
@ -512,12 +513,13 @@ static bool channel_write(Channel *channel, WBuffer *buffer)
static void send_error(Channel *channel, uint64_t id, char *err)
{
Error e = ERROR_INIT;
api_set_error(&e, Exception, "%s", err);
api_set_error(&e, kErrorTypeException, "%s", err);
channel_write(channel, serialize_response(channel->id,
id,
&e,
NIL,
&out_buffer));
api_clear_error(&e);
}
static void send_request(Channel *channel,

26
src/nvim/msgpack_rpc/helpers.c
View File

@ -475,8 +475,7 @@ Object msgpack_rpc_handle_missing_method(uint64_t channel_id,
Array args,
Error *error)
{
snprintf(error->msg, sizeof(error->msg), "Invalid method name");
error->set = true;
api_set_error(error, kErrorTypeException, "Invalid method name");
return NIL;
}
@ -485,8 +484,7 @@ Object msgpack_rpc_handle_invalid_arguments(uint64_t channel_id,
Array args,
Error *error)
{
snprintf(error->msg, sizeof(error->msg), "Invalid method arguments");
error->set = true;
api_set_error(error, kErrorTypeException, "Invalid method arguments");
return NIL;
}
@ -519,7 +517,7 @@ void msgpack_rpc_serialize_response(uint64_t response_id,
msgpack_pack_int(pac, 1);
msgpack_pack_uint64(pac, response_id);
if (err->set) {
if (ERROR_SET(err)) {
// error represented by a [type, message] array
msgpack_pack_array(pac, 2);
msgpack_rpc_from_integer(err->type, pac);
@ -572,49 +570,49 @@ void msgpack_rpc_validate(uint64_t *response_id,
*response_id = NO_RESPONSE;
// Validate the basic structure of the msgpack-rpc payload
if (req->type != MSGPACK_OBJECT_ARRAY) {
api_set_error(err, Validation, _("Message is not an array"));
api_set_error(err, kErrorTypeValidation, "Message is not an array");
return;
}
if (req->via.array.size == 0) {
api_set_error(err, Validation, _("Message is empty"));
api_set_error(err, kErrorTypeValidation, "Message is empty");
return;
}
if (req->via.array.ptr[0].type != MSGPACK_OBJECT_POSITIVE_INTEGER) {
api_set_error(err, Validation, _("Message type must be an integer"));
api_set_error(err, kErrorTypeValidation, "Message type must be an integer");
return;
}
uint64_t type = req->via.array.ptr[0].via.u64;
if (type != kMessageTypeRequest && type != kMessageTypeNotification) {
api_set_error(err, Validation, _("Unknown message type"));
api_set_error(err, kErrorTypeValidation, "Unknown message type");
return;
}
if ((type == kMessageTypeRequest && req->via.array.size != 4)
|| (type == kMessageTypeNotification && req->via.array.size != 3)) {
api_set_error(err, Validation, _("Request array size should be 4 (request) "
"or 3 (notification)"));
api_set_error(err, kErrorTypeValidation,
"Request array size must be 4 (request) or 3 (notification)");
return;
}
if (type == kMessageTypeRequest) {
msgpack_object *id_obj = msgpack_rpc_msg_id(req);
if (!id_obj) {
api_set_error(err, Validation, _("ID must be a positive integer"));
api_set_error(err, kErrorTypeValidation, "ID must be a positive integer");
return;
}
*response_id = id_obj->via.u64;
}
if (!msgpack_rpc_method(req)) {
api_set_error(err, Validation, _("Method must be a string"));
api_set_error(err, kErrorTypeValidation, "Method must be a string");
return;
}
if (!msgpack_rpc_args(req)) {
api_set_error(err, Validation, _("Parameters must be an array"));
api_set_error(err, kErrorTypeValidation, "Parameters must be an array");
return;
}
}

6
src/nvim/po/fi.po
View File

@ -116,7 +116,7 @@ msgstr "merkkijono ei saa sisältää rivinvaihtoja"
#. Doesn't exist, fail
#, fuzzy, c-format
#~ msgid "Key \"%s\" doesn't exist"
#~ msgid "Key does not exist: %s"
#~ msgstr "Tiedostoa %s ei ole"
#, fuzzy
@ -3986,7 +3986,7 @@ msgid "Calling shell to execute: \"%s\""
msgstr "Kutsutaan kuorta suorittamaan: %s"
#, c-format
#~ msgid "Invalid channel \"%<PRIu64>\""
#~ msgid "Invalid channel: %<PRIu64>"
#~ msgstr ""
#~ msgid "Message is not an array"
@ -4003,7 +4003,7 @@ msgstr "Kutsutaan kuorta suorittamaan: %s"
#~ msgid "Unknown message type"
#~ msgstr "E574: Tuntematon rekisterityyppi %d"
#~ msgid "Request array size should be 4 (request) or 3 (notification)"
#~ msgid "Request array size must be 4 (request) or 3 (notification)"
#~ msgstr ""
#~ msgid "ID must be a positive integer"

6
src/nvim/po/uk.po
View File

@ -82,7 +82,7 @@ msgid "Key length is too high"
msgstr "Довжина ключа завелика"
#, c-format
msgid "Key \"%s\" doesn't exist"
msgid "Key does not exist: %s"
msgstr "Ключ «%s» не існує"
msgid "Empty option name"
@ -3719,7 +3719,7 @@ msgid "Calling shell to execute: \"%s\""
msgstr "Викликається оболонка щоб виконати: «%s»"
#, c-format
msgid "Invalid channel \"%<PRIu64>\""
msgid "Invalid channel: %<PRIu64>"
msgstr "Некоректний канал «%<PRIu64>»"
msgid "Message is not an array"
@ -3734,7 +3734,7 @@ msgstr "Повідомлення має бути цілим числом"
msgid "Unknown message type"
msgstr "Невідомий тип повідомлення"
msgid "Request array size should be 4 (request) or 3 (notification)"
msgid "Request array size must be 4 (request) or 3 (notification)"
msgstr "Розмір масиву запиту має бути 4 (запит) чи 3 (повідомлення)"
msgid "ID must be a positive integer"

7
src/nvim/terminal.c
View File

@ -633,13 +633,14 @@ static int term_movecursor(VTermPos new, VTermPos old, int visible,
static void buf_set_term_title(buf_T *buf, char *title)
FUNC_ATTR_NONNULL_ALL
{
Error err;
Error err = ERROR_INIT;
dict_set_var(buf->b_vars,
STATIC_CSTR_AS_STRING("term_title"),
STRING_OBJ(cstr_as_string(title)),
false,
false,
&err);
api_clear_error(&err);
}
static int term_settermprop(VTermProp prop, VTermValue *val, void *data)
@ -1220,12 +1221,14 @@ static bool is_focused(Terminal *term)
#define GET_CONFIG_VALUE(k, o) \
do { \
Error err; \
Error err = ERROR_INIT; \
/* Only called from terminal_open where curbuf->terminal is the */ \
/* context */ \
o = dict_get_value(curbuf->b_vars, cstr_as_string(k), &err); \
api_clear_error(&err); \
if (o.type == kObjectTypeNil) { \
o = dict_get_value(&globvardict, cstr_as_string(k), &err); \
api_clear_error(&err); \
} \
} while (0)

8
src/nvim/tui/input.c
View File

@ -223,12 +223,14 @@ static int get_key_code_timeout(void)
{
Integer ms = -1;
// Check 'ttimeout' to determine if we should send ESC after 'ttimeoutlen'.
// See :help 'ttimeout' for more information
Error err = ERROR_INIT;
if (nvim_get_option(cstr_as_string("ttimeout"), &err).data.boolean) {
ms = nvim_get_option(cstr_as_string("ttimeoutlen"), &err).data.integer;
Object rv = nvim_get_option(cstr_as_string("ttimeoutlen"), &err);
if (!ERROR_SET(&err)) {
ms = rv.data.integer;
}
}
api_clear_error(&err);
return (int)ms;
}

2
test/functional/api/buffer_spec.lua
View File

@ -271,7 +271,7 @@ describe('api/buf', function()
eq(1, funcs.exists('b:lua'))
curbufmeths.del_var('lua')
eq(0, funcs.exists('b:lua'))
eq({false, 'Key "lua" doesn\'t exist'}, meth_pcall(curbufmeths.del_var, 'lua'))
eq({false, 'Key does not exist: lua'}, meth_pcall(curbufmeths.del_var, 'lua'))
curbufmeths.set_var('lua', 1)
command('lockvar b:lua')
eq({false, 'Key is locked: lua'}, meth_pcall(curbufmeths.del_var, 'lua'))

2
test/functional/api/tabpage_spec.lua
View File

@ -34,7 +34,7 @@ describe('api/tabpage', function()
eq(1, funcs.exists('t:lua'))
curtabmeths.del_var('lua')
eq(0, funcs.exists('t:lua'))
eq({false, 'Key "lua" doesn\'t exist'}, meth_pcall(curtabmeths.del_var, 'lua'))
eq({false, 'Key does not exist: lua'}, meth_pcall(curtabmeths.del_var, 'lua'))
curtabmeths.set_var('lua', 1)
command('lockvar t:lua')
eq({false, 'Key is locked: lua'}, meth_pcall(curtabmeths.del_var, 'lua'))

13
test/functional/api/vim_spec.lua
View File

@ -119,7 +119,7 @@ describe('api', function()
eq(1, funcs.exists('g:lua'))
meths.del_var('lua')
eq(0, funcs.exists('g:lua'))
eq({false, 'Key "lua" doesn\'t exist'}, meth_pcall(meths.del_var, 'lua'))
eq({false, 'Key does not exist: lua'}, meth_pcall(meths.del_var, 'lua'))
meths.set_var('lua', 1)
command('lockvar lua')
eq({false, 'Key is locked: lua'}, meth_pcall(meths.del_var, 'lua'))
@ -412,7 +412,7 @@ describe('api', function()
eq(5, meths.get_var('avar'))
end)
it('throws error on malformated arguments', function()
it('throws error on malformed arguments', function()
local req = {
{'nvim_set_var', {'avar', 1}},
{'nvim_set_var'},
@ -439,7 +439,7 @@ describe('api', function()
}
status, err = pcall(meths.call_atomic, req)
eq(false, status)
ok(err:match('args must be Array') ~= nil)
ok(err:match('Args must be Array') ~= nil)
-- call before was done, but not after
eq(1, meths.get_var('avar'))
eq({''}, meths.buf_get_lines(0, 0, -1, true))
@ -452,6 +452,13 @@ describe('api', function()
ok(err:match('Invalid option name') ~= nil)
end)
it('does not truncate error message <1 MB #5984', function()
local very_long_name = 'A'..('x'):rep(10000)..'Z'
local status, err = pcall(nvim, 'get_option', very_long_name)
eq(false, status)
eq(very_long_name, err:match('Ax+Z?'))
end)
it("doesn't leak memory on incorrect argument types", function()
local status, err = pcall(nvim, 'set_current_dir',{'not', 'a', 'dir'})
eq(false, status)

2
test/functional/api/window_spec.lua
View File

@ -139,7 +139,7 @@ describe('api/win', function()
eq(1, funcs.exists('w:lua'))
curwinmeths.del_var('lua')
eq(0, funcs.exists('w:lua'))
eq({false, 'Key "lua" doesn\'t exist'}, meth_pcall(curwinmeths.del_var, 'lua'))
eq({false, 'Key does not exist: lua'}, meth_pcall(curwinmeths.del_var, 'lua'))
curwinmeths.set_var('lua', 1)
command('lockvar w:lua')
eq({false, 'Key is locked: lua'}, meth_pcall(curwinmeths.del_var, 'lua'))

10
test/functional/provider/python3_spec.lua
View File

@ -2,6 +2,7 @@ local helpers = require('test.functional.helpers')(after_each)
local eval, command, feed = helpers.eval, helpers.command, helpers.feed
local eq, clear, insert = helpers.eq, helpers.clear, helpers.insert
local expect, write_file = helpers.expect, helpers.write_file
local feed_command = helpers.feed_command
do
clear()
@ -30,6 +31,15 @@ describe('python3 commands and functions', function()
eq({100, 0}, eval('g:set_by_python3'))
end)
it('does not truncate error message <1 MB', function()
-- XXX: Python limits the error name to 200 chars, so this test is
-- mostly bogus.
local very_long_symbol = string.rep('a', 1200)
feed_command(':silent! py3 print('..very_long_symbol..' b)')
-- Truncated error message would not contain this (last) line.
eq('SyntaxError: invalid syntax', eval('v:errmsg'))
end)
it('python3_execute with nested commands', function()
command([[python3 vim.command('python3 vim.command("python3 vim.command(\'let set_by_nested_python3 = 555\')")')]])
eq(555, eval('g:set_by_nested_python3'))

5
test/functional/ui/screen.lua
View File

@ -312,12 +312,13 @@ function Screen:_redraw(updates)
-- print(require('inspect')(update))
local method = update[1]
for i = 2, #update do
local handler = self['_handle_'..method]
local handler_name = '_handle_'..method
local handler = self[handler_name]
if handler ~= nil then
handler(self, unpack(update[i]))
else
assert(self._on_event,
"Add Screen:_handle_XXX method or call Screen:set_on_event_handler")
"Add Screen:"..handler_name.." or call Screen:set_on_event_handler")
self._on_event(method, update[i])
end
end