1 files changed, 118 insertions, 0 deletions
diff --git a/src/nvim/eval/executor.c b/src/nvim/eval/executor.c
new file mode 100644
index 0000000000..99298cbbcf
--- /dev/null
+++ b/src/nvim/eval/executor.c
@@ -0,0 +1,118 @@
+// 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 "nvim/eval/typval.h"
+#include "nvim/eval/executor.h"
+#include "nvim/eval.h"
+#include "nvim/message.h"
+#include "nvim/vim.h"
+#include "nvim/globals.h"
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "eval/executor.c.generated.h"
+#endif
+
+static char *e_letwrong = N_("E734: Wrong variable type for %s=");
+
+char *e_listidx = N_("E684: list index out of range: %" PRId64);
+
+/// Hanle tv1 += tv2, -=, .=
+///
+/// @param[in,out]  tv1  First operand, modified typval.
+/// @param[in]  tv2  Second operand.
+/// @param[in]  op  Used operator.
+///
+/// @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_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) {
+    switch (tv1->v_type) {
+      case VAR_DICT:
+      case VAR_FUNC:
+      case VAR_PARTIAL:
+      case VAR_SPECIAL: {
+        break;
+      }
+      case VAR_LIST: {
+        if (*op != '+' || tv2->v_type != VAR_LIST) {
+          break;
+        }
+        // List += List
+        if (tv1->vval.v_list != NULL && tv2->vval.v_list != NULL) {
+          tv_list_extend(tv1->vval.v_list, tv2->vval.v_list, NULL);
+        }
+        return OK;
+      }
+      case VAR_NUMBER:
+      case VAR_STRING: {
+        if (tv2->v_type == VAR_LIST) {
+          break;
+        }
+        if (*op == '+' || *op == '-') {
+          // nr += nr  or  nr -= nr
+          varnumber_T n = tv_get_number(tv1);
+          if (tv2->v_type == VAR_FLOAT) {
+            float_T f = (float_T)n;
+
+            if (*op == '+') {
+              f += tv2->vval.v_float;
+            } else {
+              f -= tv2->vval.v_float;
+            }
+            tv_clear(tv1);
+            tv1->v_type = VAR_FLOAT;
+            tv1->vval.v_float = f;
+          } else {
+            if (*op == '+') {
+              n += tv_get_number(tv2);
+            } else {
+              n -= tv_get_number(tv2);
+            }
+            tv_clear(tv1);
+            tv1->v_type = VAR_NUMBER;
+            tv1->vval.v_number = n;
+          }
+        } else {
+          // str .= str
+          if (tv2->v_type == VAR_FLOAT) {
+            break;
+          }
+          const char *tvs = tv_get_string(tv1);
+          char numbuf[NUMBUFLEN];
+          char *const s = (char *)concat_str(
+              (const char_u *)tvs, (const char_u *)tv_get_string_buf(tv2,
+                                                                     numbuf));
+          tv_clear(tv1);
+          tv1->v_type = VAR_STRING;
+          tv1->vval.v_string = (char_u *)s;
+        }
+        return OK;
+      }
+      case VAR_FLOAT: {
+        if (*op == '.' || (tv2->v_type != VAR_FLOAT
+                           && tv2->v_type != VAR_NUMBER
+                           && tv2->v_type != VAR_STRING)) {
+          break;
+        }
+        const float_T f = (tv2->v_type == VAR_FLOAT
+                           ? tv2->vval.v_float
+                           : (float_T)tv_get_number(tv2));
+        if (*op == '+') {
+          tv1->vval.v_float += f;
+        } else {
+          tv1->vval.v_float -= f;
+        }
+        return OK;
+      }
+      case VAR_UNKNOWN: {
+        assert(false);
+      }
+    }
+  }
+
+  EMSG2(_(e_letwrong), op);
+  return FAIL;
+}