Merge branch 'master' into option-fixes

7 files changed, 137 insertions, 88 deletions

diff --git a/src/nvim/eval/decode.c b/src/nvim/eval/decode.c
index 8905317f15..9c9c2c2dc8 100644
--- a/src/nvim/eval/decode.c
+++ b/src/nvim/eval/decode.c
@@ -11,6 +11,7 @@
 #include "nvim/ascii.h"
 #include "nvim/macros.h"
 #include "nvim/message.h"
+#include "nvim/globals.h"
 #include "nvim/charset.h"  // vim_str2nr
 #include "nvim/lib/kvec.h"
 #include "nvim/vim.h"  // OK, FAIL
@@ -223,6 +224,78 @@ static inline int json_decoder_pop(ValuesStackItem obj,
     } \
   } while (0)
 
+/// Create a new special dictionary that ought to represent a MAP
+///
+/// @param[out]  ret_tv  Address where new special dictionary is saved.
+///
+/// @return [allocated] list which should contain key-value pairs. Return value
+///                     may be safely ignored.
+list_T *decode_create_map_special_dict(typval_T *const ret_tv)
+  FUNC_ATTR_NONNULL_ALL
+{
+  list_T *const list = tv_list_alloc();
+  list->lv_refcount++;
+  create_special_dict(ret_tv, kMPMap, ((typval_T) {
+    .v_type = VAR_LIST,
+    .v_lock = VAR_UNLOCKED,
+    .vval = { .v_list = list },
+  }));
+  return list;
+}
+
+/// Convert char* string to typval_T
+///
+/// Depending on whether string has (no) NUL bytes, it may use a special
+/// dictionary or decode string to VAR_STRING.
+///
+/// @param[in]  s  String to decode.
+/// @param[in]  len  String length.
+/// @param[in]  hasnul  Whether string has NUL byte, not or it was not yet
+///                     determined.
+/// @param[in]  binary  If true, save special string type as kMPBinary,
+///                     otherwise kMPString.
+/// @param[in]  s_allocated  If true, then `s` was allocated and can be saved in
+///                          a returned structure. If it is not saved there, it
+///                          will be freed.
+///
+/// @return Decoded string.
+typval_T decode_string(const char *const s, const size_t len,
+                       const TriState hasnul, const bool binary,
+                       const bool s_allocated)
+  FUNC_ATTR_WARN_UNUSED_RESULT
+{
+  assert(s != NULL || len == 0);
+  const bool really_hasnul = (hasnul == kNone
+                              ? memchr(s, NUL, len) != NULL
+                              : (bool)hasnul);
+  if (really_hasnul) {
+    list_T *const list = tv_list_alloc();
+    list->lv_refcount++;
+    typval_T tv;
+    create_special_dict(&tv, binary ? kMPBinary : kMPString, ((typval_T) {
+      .v_type = VAR_LIST,
+      .v_lock = VAR_UNLOCKED,
+      .vval = { .v_list = list },
+    }));
+    const int elw_ret = encode_list_write((void *)list, s, len);
+    if (s_allocated) {
+      xfree((void *)s);
+    }
+    if (elw_ret == -1) {
+      tv_clear(&tv);
+      return (typval_T) { .v_type = VAR_UNKNOWN, .v_lock = VAR_UNLOCKED };
+    }
+    return tv;
+  } else {
+    return (typval_T) {
+      .v_type = VAR_STRING,
+      .v_lock = VAR_UNLOCKED,
+      .vval = { .v_string = (char_u *)(
+          s_allocated ? (char *)s : xmemdupz(s, len)) },
+    };
+  }
+}
+
 /// Parse JSON double-quoted string
 ///
 /// @param[in]  buf  Buffer being converted.
@@ -362,8 +435,8 @@ static inline int parse_json_string(const char *const buf, const size_t buf_len,
         case 'u': {
           const char ubuf[] = { t[1], t[2], t[3], t[4] };
           t += 4;
-          unsigned long ch;
-          vim_str2nr((char_u *) ubuf, NULL, NULL,
+          uvarnumber_T ch;
+          vim_str2nr((char_u *)ubuf, NULL, NULL,
                      STR2NR_HEX | STR2NR_FORCE, NULL, &ch, 4);
           if (ch == 0) {
             hasnul = true;
@@ -416,29 +489,13 @@ static inline int parse_json_string(const char *const buf, const size_t buf_len,
   }
   PUT_FST_IN_PAIR(fst_in_pair, str_end);
 #undef PUT_FST_IN_PAIR
-  if (hasnul) {
-    typval_T obj;
-    list_T *const list = tv_list_alloc();
-    list->lv_refcount++;
-    create_special_dict(&obj, kMPString, ((typval_T) {
-      .v_type = VAR_LIST,
-      .v_lock = VAR_UNLOCKED,
-      .vval = { .v_list = list },
-    }));
-    if (encode_list_write((void *) list, str, (size_t) (str_end - str))
-        == -1) {
-      tv_clear(&obj);
-      goto parse_json_string_fail;
-    }
-    xfree(str);
-    POP(obj, true);
-  } else {
-    *str_end = NUL;
-    POP(((typval_T) {
-      .v_type = VAR_STRING,
-      .vval = { .v_string = (char_u *) str },
-    }), false);
+  *str_end = NUL;
+  typval_T obj = decode_string(
+      str, (size_t)(str_end - str), hasnul ? kTrue : kFalse, false, true);
+  if (obj.v_type == VAR_UNKNOWN) {
+    goto parse_json_string_fail;
   }
+  POP(obj, obj.v_type != VAR_STRING);
   goto parse_json_string_ret;
 parse_json_string_fail:
   ret = FAIL;
@@ -552,7 +609,7 @@ parse_json_number_check:
     tv.v_type = VAR_FLOAT;
   } else {
     // Convert integer
-    long nr;
+    varnumber_T nr;
     int num_len;
     vim_str2nr((char_u *) s, NULL, &num_len, 0, &nr, NULL, (int) (p - s));
     if ((int) exp_num_len != num_len) {
@@ -560,7 +617,7 @@ parse_json_number_check:
               "to integer vim_str2nr consumed %i bytes in place of %zu"),
             (int) exp_num_len, s, num_len, exp_num_len);
     }
-    tv.vval.v_number = (varnumber_T) nr;
+    tv.vval.v_number = nr;
   }
   if (json_decoder_pop(OBJ(tv, false, *didcomma, *didcolon),
                        stack, container_stack,
@@ -812,13 +869,7 @@ json_decode_string_cycle_start:
         list_T *val_list = NULL;
         if (next_map_special) {
           next_map_special = false;
-          val_list = tv_list_alloc();
-          val_list->lv_refcount++;
-          create_special_dict(&tv, kMPMap, ((typval_T) {
-            .v_type = VAR_LIST,
-            .v_lock = VAR_UNLOCKED,
-            .vval = { .v_list = val_list },
-          }));
+          val_list = decode_create_map_special_dict(&tv);
         } else {
           dict_T *dict = tv_dict_alloc();
           dict->dv_refcount++;
@@ -971,37 +1022,17 @@ int msgpack_to_vim(const msgpack_object mobj, typval_T *const rettv)
       break;
     }
     case MSGPACK_OBJECT_STR: {
-      list_T *const list = tv_list_alloc();
-      list->lv_refcount++;
-      create_special_dict(rettv, kMPString, ((typval_T) {
-        .v_type = VAR_LIST,
-        .v_lock = VAR_UNLOCKED,
-        .vval = { .v_list = list },
-      }));
-      if (encode_list_write((void *) list, mobj.via.str.ptr, mobj.via.str.size)
-          == -1) {
+      *rettv = decode_string(mobj.via.bin.ptr, mobj.via.bin.size, kTrue, false,
+                             false);
+      if (rettv->v_type == VAR_UNKNOWN) {
         return FAIL;
       }
       break;
     }
     case MSGPACK_OBJECT_BIN: {
-      if (memchr(mobj.via.bin.ptr, NUL, mobj.via.bin.size) == NULL) {
-        *rettv = (typval_T) {
-          .v_type = VAR_STRING,
-          .v_lock = VAR_UNLOCKED,
-          .vval = { .v_string = xmemdupz(mobj.via.bin.ptr, mobj.via.bin.size) },
-        };
-        break;
-      }
-      list_T *const list = tv_list_alloc();
-      list->lv_refcount++;
-      create_special_dict(rettv, kMPBinary, ((typval_T) {
-        .v_type = VAR_LIST,
-        .v_lock = VAR_UNLOCKED,
-        .vval = { .v_list = list },
-      }));
-      if (encode_list_write((void *) list, mobj.via.bin.ptr, mobj.via.bin.size)
-          == -1) {
+      *rettv = decode_string(mobj.via.bin.ptr, mobj.via.bin.size, kNone, true,
+                             false);
+      if (rettv->v_type == VAR_UNKNOWN) {
         return FAIL;
       }
       break;
@@ -1058,13 +1089,7 @@ int msgpack_to_vim(const msgpack_object mobj, typval_T *const rettv)
       }
       break;
 msgpack_to_vim_generic_map: {}
-      list_T *const list = tv_list_alloc();
-      list->lv_refcount++;
-      create_special_dict(rettv, kMPMap, ((typval_T) {
-        .v_type = VAR_LIST,
-        .v_lock = VAR_UNLOCKED,
-        .vval = { .v_list = list },
-      }));
+      list_T *const list = decode_create_map_special_dict(rettv);
       for (size_t i = 0; i < mobj.via.map.size; i++) {
         list_T *const kv_pair = tv_list_alloc();
         tv_list_append_list(list, kv_pair);
diff --git a/src/nvim/eval/decode.h b/src/nvim/eval/decode.h
index c8e7a189e3..77fc4c78c2 100644
--- a/src/nvim/eval/decode.h
+++ b/src/nvim/eval/decode.h
@@ -6,6 +6,7 @@
 #include <msgpack.h>
 
 #include "nvim/eval/typval.h"
+#include "nvim/globals.h"
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "eval/decode.h.generated.h"
diff --git a/src/nvim/eval/encode.c b/src/nvim/eval/encode.c
index 742497c1ca..ef647b3ee4 100644
--- a/src/nvim/eval/encode.c
+++ b/src/nvim/eval/encode.c
@@ -253,9 +253,11 @@ int encode_read_from_list(ListReaderState *const state, char *const buf,
   char *const buf_end = buf + nbuf;
   char *p = buf;
   while (p < buf_end) {
+    assert(state->li_length == 0 || state->li->li_tv.vval.v_string != NULL);
     for (size_t i = state->offset; i < state->li_length && p < buf_end; i++) {
-      const char ch = (char) state->li->li_tv.vval.v_string[state->offset++];
-      *p++ = (char) ((char) ch == (char) NL ? (char) NUL : (char) ch);
+      assert(state->li->li_tv.vval.v_string != NULL);
+      const char ch = (char)state->li->li_tv.vval.v_string[state->offset++];
+      *p++ = (char)((char)ch == (char)NL ? (char)NUL : (char)ch);
     }
     if (p < buf_end) {
       state->li = state->li->li_next;
diff --git a/src/nvim/eval/executor.c b/src/nvim/eval/executor.c
index 91bb61323f..99298cbbcf 100644
--- a/src/nvim/eval/executor.c
+++ b/src/nvim/eval/executor.c
@@ -25,7 +25,7 @@ char *e_listidx = N_("E684: list index out of range: %" PRId64);
 /// @return OK or FAIL.
 int eexe_mod_op(typval_T *const tv1, const typval_T *const tv2,
                 const char *const op)
-  FUNC_ATTR_NONNULL_ALL
+  FUNC_ATTR_NONNULL_ALL FUNC_ATTR_NO_SANITIZE_UNDEFINED
 {
   // Can't do anything with a Funcref, a Dict or special value on the right.
   if (tv2->v_type != VAR_FUNC && tv2->v_type != VAR_DICT) {
@@ -55,7 +55,7 @@ int eexe_mod_op(typval_T *const tv1, const typval_T *const tv2,
           // nr += nr  or  nr -= nr
           varnumber_T n = tv_get_number(tv1);
           if (tv2->v_type == VAR_FLOAT) {
-            float_T f = n;
+            float_T f = (float_T)n;
 
             if (*op == '+') {
               f += tv2->vval.v_float;
@@ -99,7 +99,7 @@ int eexe_mod_op(typval_T *const tv1, const typval_T *const tv2,
         }
         const float_T f = (tv2->v_type == VAR_FLOAT
                            ? tv2->vval.v_float
-                           : tv_get_number(tv2));
+                           : (float_T)tv_get_number(tv2));
         if (*op == '+') {
           tv1->vval.v_float += f;
         } else {
diff --git a/src/nvim/eval/typval.c b/src/nvim/eval/typval.c
index 786b766689..4521085519 100644
--- a/src/nvim/eval/typval.c
+++ b/src/nvim/eval/typval.c
@@ -1210,7 +1210,8 @@ char *tv_dict_get_string(const dict_T *const d, const char *const key,
 ///
 /// @param[in]  d  Dictionary to get item from.
 /// @param[in]  key  Dictionary key.
-/// @param[in]  numbuf  Numbuf for.
+/// @param[in]  numbuf  Buffer for non-string items converted to strings, at
+///                     least of #NUMBUFLEN length.
 ///
 /// @return NULL if key does not exist, empty string in case of type error,
 ///         string item value otherwise.
@@ -1225,6 +1226,32 @@ const char *tv_dict_get_string_buf(const dict_T *const d, const char *const key,
   return tv_get_string_buf(&di->di_tv, numbuf);
 }
 
+/// Get a string item from a dictionary
+///
+/// @param[in]  d  Dictionary to get item from.
+/// @param[in]  key  Dictionary key.
+/// @param[in]  key_len  Key length.
+/// @param[in]  numbuf  Buffer for non-string items converted to strings, at
+///                     least of #NUMBUFLEN length.
+/// @param[in]  def  Default return when key does not exist.
+///
+/// @return `def` when key does not exist,
+///         NULL in case of type error,
+///         string item value in case of success.
+const char *tv_dict_get_string_buf_chk(const dict_T *const d,
+                                       const char *const key,
+                                       const ptrdiff_t key_len,
+                                       char *const numbuf,
+                                       const char *const def)
+  FUNC_ATTR_WARN_UNUSED_RESULT
+{
+  const dictitem_T *const di = tv_dict_find(d, key, key_len);
+  if (di == NULL) {
+    return def;
+  }
+  return tv_get_string_buf_chk(&di->di_tv, numbuf);
+}
+
 /// Get a function from a dictionary
 ///
 /// @param[in]  d  Dictionary to get callback from.
@@ -1869,7 +1896,7 @@ void tv_free(typval_T *tv)
       }
       case VAR_FUNC: {
         func_unref(tv->vval.v_string);
-        // FALLTHROUGH
+        FALLTHROUGH;
       }
       case VAR_STRING: {
         xfree(tv->vval.v_string);
@@ -2378,9 +2405,7 @@ varnumber_T tv_get_number_chk(const typval_T *const tv, bool *const ret_error)
     case VAR_STRING: {
       varnumber_T n = 0;
       if (tv->vval.v_string != NULL) {
-        long nr;
-        vim_str2nr(tv->vval.v_string, NULL, NULL, STR2NR_ALL, &nr, NULL, 0);
-        n = (varnumber_T)nr;
+        vim_str2nr(tv->vval.v_string, NULL, NULL, STR2NR_ALL, &n, NULL, 0);
       }
       return n;
     }
@@ -2417,7 +2442,7 @@ varnumber_T tv_get_number_chk(const typval_T *const tv, bool *const ret_error)
 linenr_T tv_get_lnum(const typval_T *const tv)
   FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT
 {
-  linenr_T lnum = tv_get_number_chk(tv, NULL);
+  linenr_T lnum = (linenr_T)tv_get_number_chk(tv, NULL);
   if (lnum == 0) {  // No valid number, try using same function as line() does.
     int fnum;
     pos_T *const fp = var2fpos(tv, true, &fnum);
diff --git a/src/nvim/eval/typval.h b/src/nvim/eval/typval.h
index 0f659727ee..3f8ed3b3f9 100644
--- a/src/nvim/eval/typval.h
+++ b/src/nvim/eval/typval.h
@@ -1,7 +1,7 @@
 #ifndef NVIM_EVAL_TYPVAL_H
 #define NVIM_EVAL_TYPVAL_H
 
-#include <limits.h>
+#include <inttypes.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
@@ -20,20 +20,21 @@
 #include "nvim/macros.h"
 
 /// Type used for VimL VAR_NUMBER values
-typedef int varnumber_T;
+typedef int64_t varnumber_T;
+typedef uint64_t uvarnumber_T;
 
 /// Type used for VimL VAR_FLOAT values
 typedef double float_T;
 
 /// Maximal possible value of varnumber_T variable
-#define VARNUMBER_MAX INT_MAX
+#define VARNUMBER_MAX INT64_MAX
+#define UVARNUMBER_MAX UINT64_MAX
 
 /// Mimimal possible value of varnumber_T variable
-#define VARNUMBER_MIN INT_MIN
-#define PRIdVARNUMBER "d"
+#define VARNUMBER_MIN INT64_MIN
 
 /// %d printf format specifier for varnumber_T
-#define PRIdVARNUMBER "d"
+#define PRIdVARNUMBER PRId64
 
 typedef struct listvar_S list_T;
 typedef struct dictvar_S dict_T;
diff --git a/src/nvim/eval/typval_encode.c.h b/src/nvim/eval/typval_encode.c.h
index b4a70fb188..a93ad2dbba 100644
--- a/src/nvim/eval/typval_encode.c.h
+++ b/src/nvim/eval/typval_encode.c.h
@@ -233,10 +233,6 @@
 ///
 /// This name will only be used by one of the above macros which are defined by
 /// the caller. Functions defined here do not use first argument directly.
-#ifndef NVIM_EVAL_TYPVAL_ENCODE_C_H
-#define NVIM_EVAL_TYPVAL_ENCODE_C_H
-#undef NVIM_EVAL_TYPVAL_ENCODE_C_H
-
 #include <stddef.h>
 #include <inttypes.h>
 #include <assert.h>
@@ -816,4 +812,3 @@ encode_vim_to__error_ret:
   // Prevent “unused label” warnings.
   goto typval_encode_stop_converting_one_item;  // -V779
 }
-#endif  // NVIM_EVAL_TYPVAL_ENCODE_C_H