vim-patch:7.4.242

Problem:    getreg() does not distinguish between a NL used for a line
            break and a NL used for a NUL character.
Solution:   Add another argument to return a list. (ZyX)

https://code.google.com/p/vim/source/detail?r=v7-4-242

src/nvim/eval.c

@@ -1835,7 +1835,7 @@ ex_let_one (
 
       p = get_tv_string_chk(tv);
       if (p != NULL && op != NULL && *op == '.') {
-        s = get_reg_contents(*arg == '@' ? '"' : *arg, TRUE, TRUE);
+        s = get_reg_contents(*arg == '@' ? '"' : *arg, kGRegExprSrc);
         if (s != NULL) {
           p = ptofree = concat_str(s, p);
           free(s);
@@ -4076,7 +4076,7 @@ eval7 (
   case '@':   ++*arg;
     if (evaluate) {
       rettv->v_type = VAR_STRING;
-      rettv->vval.v_string = get_reg_contents(**arg, TRUE, TRUE);
+      rettv->vval.v_string = get_reg_contents(**arg, kGRegExprSrc);
     }
     if (**arg != NUL)
       ++*arg;
@@ -6466,7 +6466,7 @@ static struct fst {
   {"getpid",          0, 0, f_getpid},
   {"getpos",          1, 1, f_getpos},
   {"getqflist",       0, 0, f_getqflist},
-  {"getreg",          0, 2, f_getreg},
+  {"getreg",          0, 3, f_getreg},
   {"getregtype",      0, 1, f_getregtype},
   {"gettabvar",       2, 3, f_gettabvar},
   {"gettabwinvar",    3, 4, f_gettabwinvar},
@@ -9526,30 +9526,45 @@ static void f_getqflist(typval_T *argvars, typval_T *rettv)
   (void)get_errorlist(wp, rettv->vval.v_list);
 }
 
-/*
- * "getreg()" function
- */
+/// "getreg()" function
 static void f_getreg(typval_T *argvars, typval_T *rettv)
 {
   char_u      *strregname;
   int regname;
-  int arg2 = FALSE;
-  int error = FALSE;
+  int arg2 = false;
+  bool return_list = false;
+  int error = false;
 
   if (argvars[0].v_type != VAR_UNKNOWN) {
     strregname = get_tv_string_chk(&argvars[0]);
     error = strregname == NULL;
-    if (argvars[1].v_type != VAR_UNKNOWN)
+    if (argvars[1].v_type != VAR_UNKNOWN) {
       arg2 = get_tv_number_chk(&argvars[1], &error);
-  } else
+      if (!error && argvars[2].v_type != VAR_UNKNOWN) {
+        return_list = get_tv_number_chk(&argvars[2], &error);
+      }
+    }
+  } else {
     strregname = vimvars[VV_REG].vv_str;
+  }
+
+  if (error) {
+    return;
+  }
+
   regname = (strregname == NULL ? '"' : *strregname);
   if (regname == 0)
     regname = '"';
 
-  rettv->v_type = VAR_STRING;
-  rettv->vval.v_string = error ? NULL :
-                         get_reg_contents(regname, TRUE, arg2);
+  if (return_list) {
+    rettv->v_type = VAR_LIST;
+    rettv->vval.v_list = 
+      (list_T *)get_reg_contents(regname,
+                                 (arg2 ? kGRegExprSrc : 0) | kGRegList);
+  } else {
+    rettv->v_type = VAR_STRING;
+    rettv->vval.v_string = get_reg_contents(regname, arg2 ? kGRegExprSrc : 0);
+  }
 }
 
 /*

src/nvim/ops.c

@@ -4654,30 +4654,42 @@ char_u get_reg_type(int regname, long *reglen)
   return MAUTO;
 }
 
-/*
- * Return the contents of a register as a single allocated string.
- * Used for "@r" in expressions and for getreg().
- * Returns NULL for error.
- */
-char_u *
-get_reg_contents (
-    int regname,
-    int allowexpr,                  /* allow "=" register */
-    int expr_src                   /* get expression for "=" register */
-)
+/// When `flags` has `kGRegList` return a list with text `s`.
+/// Otherwise just return `s`.
+static char_u *get_reg_wrap_one_line(char_u *s, int flags)
+{
+  if (!(flags & kGRegList)) {
+    return s;
+  }
+  list_T *list = list_alloc();
+  list_append_string(list, NULL, -1);
+  list->lv_first->li_tv.vval.v_string = s;
+  return (char_u *)list;
+}
+
+/// Gets the contents of a register.
+/// @remark Used for `@r` in expressions and for `getreg()`.
+///
+/// @param regname  The register.
+/// @param flags    see @ref GRegFlags
+///
+/// @returns The contents of the register as an allocated string.
+/// @returns A linked list cast to a string when given @ref kGRegList.
+/// @returns NULL for error.
+// TODO(SplinterOfChaos): Maybe this should return a void*.
+char_u *get_reg_contents(int regname, int flags)
 {
   long i;
-  char_u      *retval;
-  int allocated;
 
-  /* Don't allow using an expression register inside an expression */
+  // Don't allow using an expression register inside an expression.
   if (regname == '=') {
-    if (allowexpr) {
-      if (expr_src)
-        return get_expr_line_src();
-      return get_expr_line();
+    if (flags & kGRegNoExpr) {
+      return NULL;
     }
-    return NULL;
+    if (flags & kGRegExprSrc) {
+      return get_reg_wrap_one_line(get_expr_line_src(), flags);
+    }
+    return get_reg_wrap_one_line(get_expr_line(), flags);
   }
 
   if (regname == '@')       /* "@@" is used for unnamed register */
@@ -4689,18 +4701,30 @@ get_reg_contents (
 
   get_clipboard(regname);
 
+  char_u *retval;
+  int allocated;
   if (get_spec_reg(regname, &retval, &allocated, FALSE)) {
     if (retval == NULL)
       return NULL;
-    if (!allocated)
-      retval = vim_strsave(retval);
-    return retval;
+    if (allocated) {
+      return get_reg_wrap_one_line(retval, flags);
+    }
+    return get_reg_wrap_one_line(vim_strsave(retval), flags);
   }
 
   get_yank_register(regname, FALSE);
   if (y_current->y_array == NULL)
     return NULL;
 
+  if (flags & kGRegList) {
+    list_T *list = list_alloc();
+    for (int i = 0; i < y_current->y_size; ++i) {
+      list_append_string(list, y_current->y_array[i], -1);
+    }
+
+    return (char_u *) list;
+  }
+
   /*
    * Compute length of resulting string.
    */

src/nvim/ops.h

@@ -47,6 +47,13 @@ typedef int (*Indenter)(void);
 #define OP_FORMAT2      26      /* "gw" format operator, keeps cursor pos */
 #define OP_FUNCTION     27      /* "g@" call 'operatorfunc' */
 
+/// Flags for get_reg_contents().
+enum GRegFlags {
+  kGRegNoExpr  = 1,  ///< Do not allow expression register.
+  kGRegExprSrc = 2,  ///< Return expression itself for "=" register.
+  kGRegList    = 4   ///< Return list.
+};
+
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "ops.h.generated.h"
 #endif

src/nvim/version.c

@@ -423,7 +423,7 @@ static int included_patches[] = {
   245,
   //244,
   //243,
-  //242,
+  242,
   241,
   240,
   239,