Merge branch 'master' into luaviml'/lua

2025-09-23 03:28:33 +00:00 · 2017-05-08 15:43:45 +03:00
parent 1d7fde39a6 a9605bb4af
commit 09f849b600
790 changed files with 36546 additions and 39009 deletions
--- a/src/nvim/api/buffer.c
+++ b/src/nvim/api/buffer.c
@@ -1,3 +1,6 @@
+// This is an open source non-commercial project. Dear PVS-Studio, please check
+// it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
 // Much of this code was adapted from 'if_py_both.h' from the original
 // vim source
 #include <stdbool.h>
@@ -62,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;
  }

@@ -168,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;
  }

@@ -184,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;
    }

@@ -200,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);
    }
@@ -280,30 +283,31 @@ 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;
  }

  for (size_t i = 0; i < replacement.size; 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");
      return;
    }
    // Disallow newlines in the middle of the line.
    if (channel_id != VIML_INTERNAL_CALL) {
      const String l = replacement.items[i].data.string;
      if (memchr(l.data, NL, l.size)) {
-        api_set_error(err, Validation, _("string cannot contain newlines"));
+        api_set_error(err, kErrorTypeValidation,
+                      "String cannot contain newlines");
        return;
      }
    }
@@ -330,7 +334,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 +344,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 +361,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 +379,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;
    }

@@ -566,11 +570,15 @@ void nvim_buf_set_option(Buffer buffer, String name, Object value, Error *err)

 /// Gets the buffer number
 ///
+/// @deprecated The buffer number now is equal to the object id,
+///             so there is no need to use this function.
+///
 /// @param buffer     Buffer handle
 /// @param[out] err   Error details, if any
 /// @return Buffer number
 Integer nvim_buf_get_number(Buffer buffer, Error *err)
    FUNC_API_SINCE(1)
+    FUNC_API_DEPRECATED_SINCE(2)
 {
  Integer rv = 0;
  buf_T *buf = find_buffer_by_handle(buffer, err);
@@ -627,7 +635,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 +647,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 +688,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 +707,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 +762,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 +803,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) {
--- a/src/nvim/api/private/defs.h
+++ b/src/nvim/api/private/defs.h
@@ -10,9 +10,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
@@ -22,6 +24,7 @@ typedef int handle_T;

 // Basic types
 typedef enum {
+  kErrorTypeNone = -1,
  kErrorTypeException,
  kErrorTypeValidation
 } ErrorType;
@@ -59,8 +62,7 @@ static inline bool is_internal_call(const uint64_t channel_id)

 typedef struct {
  ErrorType type;
-  char msg[1024];
-  bool set;
+  char *msg;
 } Error;

 typedef bool Boolean;
--- a/src/nvim/api/private/dispatch.c
+++ b/src/nvim/api/private/dispatch.c
@@ -1,3 +1,6 @@
+// This is an open source non-commercial project. Dear PVS-Studio, please check
+// it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
 #include <inttypes.h>
 #include <stdbool.h>
 #include <stdint.h>
--- a/src/nvim/api/private/handle.c
+++ b/src/nvim/api/private/handle.c
@@ -1,3 +1,6 @@
+// This is an open source non-commercial project. Dear PVS-Studio, please check
+// it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
 #include <assert.h>
 #include <stdint.h>

--- a/src/nvim/api/private/helpers.c
+++ b/src/nvim/api/private/helpers.c
@@ -1,3 +1,6 @@
+// This is an open source non-commercial project. Dear PVS-Studio, please check
+// it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
 #include <assert.h>
 #include <inttypes.h>
 #include <stdbool.h>
@@ -58,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;
@@ -66,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
@@ -91,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);
@@ -115,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;
  }

@@ -133,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;
    }
  }
@@ -148,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) {
@@ -200,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;
  }

@@ -212,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;
  }
@@ -231,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);
  }

@@ -255,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;
  }

@@ -263,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;
  }
@@ -272,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 {
@@ -294,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;
    }
@@ -305,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;
    }
@@ -324,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;
    }
@@ -558,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;
@@ -573,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;
@@ -588,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;
@@ -656,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;
      }

@@ -710,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;
@@ -798,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 +942,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 +959,7 @@ static void set_option_value_for(char *key,
      break;
  }

-  if (err->set) {
+  if (ERROR_SET(err)) {
    return;
  }

@@ -965,6 +980,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;
+}
--- a/src/nvim/api/private/helpers.h
+++ b/src/nvim/api/private/helpers.h
@@ -8,15 +8,6 @@
 #include "nvim/memory.h"
 #include "nvim/lib/kvec.h"

-#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) { \
--- a/src/nvim/api/tabpage.c
+++ b/src/nvim/api/tabpage.c
@@ -1,3 +1,6 @@
+// This is an open source non-commercial project. Dear PVS-Studio, please check
+// it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdlib.h>
@@ -190,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;
 }

--- a/src/nvim/api/ui.c
+++ b/src/nvim/api/ui.c
@@ -1,3 +1,6 @@
+// This is an open source non-commercial project. Dear PVS-Studio, please check
+// it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
 #include <assert.h>
 #include <stddef.h>
 #include <stdint.h>
@@ -52,25 +55,24 @@ 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));
  ui->width = (int)width;
  ui->height = (int)height;
  ui->rgb = true;
-  ui->pum_external = false;
  ui->resize = remote_ui_resize;
  ui->clear = remote_ui_clear;
  ui->eol_clear = remote_ui_eol_clear;
  ui->cursor_goto = remote_ui_cursor_goto;
-  ui->cursor_style_set = remote_ui_cursor_style_set;
+  ui->mode_info_set = remote_ui_mode_info_set;
  ui->update_menu = remote_ui_update_menu;
  ui->busy_start = remote_ui_busy_start;
  ui->busy_stop = remote_ui_busy_stop;
@@ -92,9 +94,11 @@ void nvim_ui_attach(uint64_t channel_id, Integer width, Integer height,
  ui->set_icon = remote_ui_set_icon;
  ui->event = remote_ui_event;

+  memset(ui->ui_ext, 0, sizeof(ui->ui_ext));
+
  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;
    }
@@ -123,7 +127,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);
@@ -135,13 +139,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;
  }

@@ -156,34 +160,58 @@ 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();
  }
 }

-static void ui_set_option(UI *ui, String name, Object value, Error *error) {
-  if (strcmp(name.data, "rgb") == 0) {
+static void ui_set_option(UI *ui, String name, Object value, Error *error)
+{
+#define UI_EXT_OPTION(o, e) \
+  do { \
+    if (strequal(name.data, #o)) { \
+      if (value.type != kObjectTypeBoolean) { \
+        api_set_error(error, kErrorTypeValidation, #o " must be a Boolean"); \
+        return; \
+      } \
+      ui->ui_ext[(e)] = value.data.boolean; \
+      return; \
+    } \
+  } while (0)
+
+  if (strequal(name.data, "rgb")) {
    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) {
+    return;
+  }
+
+  UI_EXT_OPTION(ext_cmdline, kUICmdline);
+  UI_EXT_OPTION(ext_popupmenu, kUIPopupmenu);
+  UI_EXT_OPTION(ext_tabline, kUITabline);
+  UI_EXT_OPTION(ext_wildmenu, kUIWildmenu);
+
+  if (strequal(name.data, "popupmenu_external")) {
+    // LEGACY: Deprecated option, use `ui_ext` instead.
    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"));
+    ui->ui_ext[kUIPopupmenu] = value.data.boolean;
+    return;
  }
+
+  api_set_error(error, kErrorTypeValidation, "No such ui option");
+#undef UI_EXT_OPTION
 }

 static void push_call(UI *ui, char *name, Array args)
@@ -266,19 +294,14 @@ static void remote_ui_mouse_off(UI *ui)
  push_call(ui, "mouse_off", args);
 }

-static void remote_ui_mode_change(UI *ui, int mode)
+static void remote_ui_mode_change(UI *ui, int mode_idx)
 {
  Array args = ARRAY_DICT_INIT;
-  if (mode == INSERT) {
-    ADD(args, STRING_OBJ(cstr_to_string("insert")));
-  } else if (mode == REPLACE) {
-    ADD(args, STRING_OBJ(cstr_to_string("replace")));
-  } else if (mode == CMDLINE) {
-    ADD(args, STRING_OBJ(cstr_to_string("cmdline")));
-  } else {
-    assert(mode == NORMAL);
-    ADD(args, STRING_OBJ(cstr_to_string("normal")));
-  }
+
+  char *full_name = shape_table[mode_idx].full_name;
+  ADD(args, STRING_OBJ(cstr_to_string(full_name)));
+
+  ADD(args, INTEGER_OBJ(mode_idx));
  push_call(ui, "mode_change", args);
 }

@@ -300,12 +323,12 @@ static void remote_ui_scroll(UI *ui, int count)
  push_call(ui, "scroll", args);
 }

-static void remote_ui_cursor_style_set(UI *ui, bool enabled, Dictionary data)
+static void remote_ui_mode_info_set(UI *ui, bool guicursor_enabled, Array data)
 {
  Array args = ARRAY_DICT_INIT;
-  ADD(args, BOOLEAN_OBJ(enabled));
-  ADD(args, copy_object(DICTIONARY_OBJ(data)));
-  push_call(ui, "cursor_style_set", args);
+  ADD(args, BOOLEAN_OBJ(guicursor_enabled));
+  ADD(args, copy_object(ARRAY_OBJ(data)));
+  push_call(ui, "mode_info_set", args);
 }

 static void remote_ui_highlight_set(UI *ui, HlAttrs attrs)
@@ -393,8 +416,10 @@ static void remote_ui_update_sp(UI *ui, int sp)
 static void remote_ui_flush(UI *ui)
 {
  UIData *data = ui->data;
-  channel_send_event(data->channel_id, "redraw", data->buffer);
-  data->buffer = (Array)ARRAY_DICT_INIT;
+  if (data->buffer.size > 0) {
+    channel_send_event(data->channel_id, "redraw", data->buffer);
+    data->buffer = (Array)ARRAY_DICT_INIT;
+  }
 }

 static void remote_ui_suspend(UI *ui)
--- a/src/nvim/api/vim.c
+++ b/src/nvim/api/vim.c
@@ -1,3 +1,6 @@
+// This is an open source non-commercial project. Dear PVS-Studio, please check
+// it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
 #include <assert.h>
 #include <stdint.h>
 #include <inttypes.h>
@@ -24,6 +27,7 @@
 #include "nvim/eval.h"
 #include "nvim/eval/typval.h"
 #include "nvim/option.h"
+#include "nvim/state.h"
 #include "nvim/syntax.h"
 #include "nvim/getchar.h"
 #include "nvim/os/input.h"
@@ -162,8 +166,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));
@@ -185,7 +189,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)) {
@@ -212,8 +216,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;
  }

@@ -235,7 +239,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);
@@ -260,7 +264,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;
  }

@@ -316,7 +320,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;
  }

@@ -328,7 +332,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;
  }
@@ -537,8 +541,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);
  }
 }
@@ -590,8 +594,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);
  }
 }
@@ -644,8 +648,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);
  }
 }
@@ -699,6 +703,24 @@ Dictionary nvim_get_color_map(void)
 }


+/// Gets the current mode.
+/// mode:     Mode string. |mode()|
+/// blocking: true if Nvim is waiting for input.
+///
+/// @returns Dictionary { "mode": String, "blocking": Boolean }
+Dictionary nvim_get_mode(void)
+  FUNC_API_SINCE(2) FUNC_API_ASYNC
+{
+  Dictionary rv = ARRAY_DICT_INIT;
+  char *modestr = get_mode();
+  bool blocked = input_blocking();
+
+  PUT(rv, "mode", STRING_OBJ(cstr_as_string(modestr)));
+  PUT(rv, "blocking", BOOLEAN_OBJ(blocked));
+
+  return rv;
+}
+
 Array nvim_get_api_info(uint64_t channel_id)
    FUNC_API_SINCE(1) FUNC_API_ASYNC FUNC_API_NOEVAL
 {
@@ -743,30 +765,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;
@@ -774,7 +796,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;
    }
@@ -783,7 +805,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));
@@ -792,10 +814,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;
 }

--- a/src/nvim/api/window.c
+++ b/src/nvim/api/window.c
@@ -1,3 +1,6 @@
+// This is an open source non-commercial project. Dear PVS-Studio, please check
+// it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
+
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdlib.h>
@@ -62,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;
  }

@@ -75,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;
  }

@@ -129,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;
  }

@@ -174,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;
  }

@@ -384,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;
 }