patch 8.0.0593: duplication of code for adding a list or dict return value

brammool · brammool · commit 45cf6e910c6d · 2017-04-30T20:25:19.000+02:00
Problem:    Duplication of code for adding a list or dict return value.
Solution:   Add rettv_dict_set() and rettv_list_set(). (Yegappan Lakshmanan)
diff --git a/src/dict.c b/src/dict.c
@@ -59,13 +59,23 @@ rettv_dict_alloc(typval_T *rettv)
     if (d == NULL)
 	return FAIL;
 
-    rettv->vval.v_dict = d;
-    rettv->v_type = VAR_DICT;
+    rettv_dict_set(rettv, d);
     rettv->v_lock = 0;
-    ++d->dv_refcount;
     return OK;
 }
 
+/*
+ * Set a dictionary as the return value
+ */
+    void
+rettv_dict_set(typval_T *rettv, dict_T *d)
+{
+    rettv->v_type = VAR_DICT;
+    rettv->vval.v_dict = d;
+    if (d != NULL)
+	++d->dv_refcount;
+}
+
 /*
  * Free a Dictionary, including all non-container items it contains.
  * Ignores the reference count.
@@ -646,11 +656,7 @@ get_dict_tv(char_u **arg, typval_T *rettv, int evaluate)
 
     *arg = skipwhite(*arg + 1);
     if (evaluate)
-    {
-	rettv->v_type = VAR_DICT;
-	rettv->vval.v_dict = d;
-	++d->dv_refcount;
-    }
+	rettv_dict_set(rettv, d);
 
     return OK;
 }
diff --git a/src/eval.c b/src/eval.c
@@ -4665,9 +4665,7 @@ eval_index(
 			item = item->li_next;
 		    }
 		    clear_tv(rettv);
-		    rettv->v_type = VAR_LIST;
-		    rettv->vval.v_list = l;
-		    ++l->lv_refcount;
+		    rettv_list_set(rettv, l);
 		}
 		else
 		{
@@ -8486,9 +8484,7 @@ getwinvar(
 
 		    if (opts != NULL)
 		    {
-			rettv->v_type = VAR_DICT;
-			rettv->vval.v_dict = opts;
-			++opts->dv_refcount;
+			rettv_dict_set(rettv, opts);
 			done = TRUE;
 		    }
 		}
diff --git a/src/evalfunc.c b/src/evalfunc.c
@@ -3005,8 +3005,7 @@ f_expand(typval_T *argvars, typval_T *rettv)
 	    && get_tv_number_chk(&argvars[2], &error)
 	    && !error)
     {
-	rettv->v_type = VAR_LIST;
-	rettv->vval.v_list = NULL;
+	rettv_list_set(rettv, NULL);
     }
 
     s = get_tv_string(&argvars[0]);
@@ -3909,12 +3908,7 @@ f_get(typval_T *argvars, typval_T *rettv)
 		}
 	    }
 	    else if (STRCMP(what, "dict") == 0)
-	    {
-		rettv->v_type = VAR_DICT;
-		rettv->vval.v_dict = pt->pt_dict;
-		if (pt->pt_dict != NULL)
-		    ++pt->pt_dict->dv_refcount;
-	    }
+		rettv_dict_set(rettv, pt->pt_dict);
 	    else if (STRCMP(what, "args") == 0)
 	    {
 		rettv->v_type = VAR_LIST;
@@ -4214,9 +4208,7 @@ f_getbufvar(typval_T *argvars, typval_T *rettv)
 
 		if (opts != NULL)
 		{
-		    rettv->v_type = VAR_DICT;
-		    rettv->vval.v_dict = opts;
-		    ++opts->dv_refcount;
+		    rettv_dict_set(rettv, opts);
 		    done = TRUE;
 		}
 	    }
@@ -5372,8 +5364,7 @@ f_glob(typval_T *argvars, typval_T *rettv)
 	{
 	    if (get_tv_number_chk(&argvars[2], &error))
 	    {
-		rettv->v_type = VAR_LIST;
-		rettv->vval.v_list = NULL;
+		rettv_list_set(rettv, NULL);
 	    }
 	    if (argvars[3].v_type != VAR_UNKNOWN
 				    && get_tv_number_chk(&argvars[3], &error))
@@ -5429,8 +5420,7 @@ f_globpath(typval_T *argvars, typval_T *rettv)
 	{
 	    if (get_tv_number_chk(&argvars[3], &error))
 	    {
-		rettv->v_type = VAR_LIST;
-		rettv->vval.v_list = NULL;
+		rettv_list_set(rettv, NULL);
 	    }
 	    if (argvars[4].v_type != VAR_UNKNOWN
 				    && get_tv_number_chk(&argvars[4], &error))
@@ -9152,9 +9142,7 @@ f_reverse(typval_T *argvars, typval_T *rettv)
 	    list_append(l, li);
 	    li = ni;
 	}
-	rettv->vval.v_list = l;
-	rettv->v_type = VAR_LIST;
-	++l->lv_refcount;
+	rettv_list_set(rettv, l);
 	l->lv_idx = l->lv_len - l->lv_idx - 1;
     }
 }
@@ -10742,9 +10730,7 @@ do_sort_uniq(typval_T *argvars, typval_T *rettv, int sort)
 	     (char_u *)(sort ? N_("sort() argument") : N_("uniq() argument")),
 									TRUE))
 	    goto theend;
-	rettv->vval.v_list = l;
-	rettv->v_type = VAR_LIST;
-	++l->lv_refcount;
+	rettv_list_set(rettv, l);
 
 	len = list_len(l);
 	if (len <= 1)
@@ -11832,8 +11818,7 @@ f_synconcealed(typval_T *argvars UNUSED, typval_T *rettv)
     char_u	str[NUMBUFLEN];
 #endif
 
-    rettv->v_type = VAR_LIST;
-    rettv->vval.v_list = NULL;
+    rettv_list_set(rettv, NULL);
 
 #if defined(FEAT_SYN_HL) && defined(FEAT_CONCEAL)
     lnum = get_tv_lnum(argvars);		/* -1 on type error */
@@ -11890,8 +11875,7 @@ f_synstack(typval_T *argvars UNUSED, typval_T *rettv)
     int		id;
 #endif
 
-    rettv->v_type = VAR_LIST;
-    rettv->vval.v_list = NULL;
+    rettv_list_set(rettv, NULL);
 
 #ifdef FEAT_SYN_HL
     lnum = get_tv_lnum(argvars);		/* -1 on type error */
@@ -12057,9 +12041,7 @@ get_cmd_output_as_rettv(
 	    list_append(list, li);
 	}
 
-	++list->lv_refcount;
-	rettv->v_type = VAR_LIST;
-	rettv->vval.v_list = list;
+	rettv_list_set(rettv, list);
 	list = NULL;
     }
     else
@@ -12465,8 +12447,7 @@ f_test_null_channel(typval_T *argvars UNUSED, typval_T *rettv)
     static void
 f_test_null_dict(typval_T *argvars UNUSED, typval_T *rettv)
 {
-    rettv->v_type = VAR_DICT;
-    rettv->vval.v_dict = NULL;
+    rettv_dict_set(rettv, NULL);
 }
 
 #ifdef FEAT_JOB_CHANNEL
@@ -12481,8 +12462,7 @@ f_test_null_job(typval_T *argvars UNUSED, typval_T *rettv)
     static void
 f_test_null_list(typval_T *argvars UNUSED, typval_T *rettv)
 {
-    rettv->v_type = VAR_LIST;
-    rettv->vval.v_list = NULL;
+    rettv_list_set(rettv, NULL);
 }
 
     static void
diff --git a/src/if_perl.xs b/src/if_perl.xs
@@ -1136,9 +1136,7 @@ perl_to_vim(SV *sv, typval_T *rettv)
 		}
 	    }
 
-	    list->lv_refcount++;
-	    rettv->v_type	= VAR_LIST;
-	    rettv->vval.v_list	= list;
+	    rettv_list_set(rettv, list);
 	    break;
 	}
 	case SVt_PVHV:	/* dictionary */
@@ -1192,9 +1190,7 @@ perl_to_vim(SV *sv, typval_T *rettv)
 		}
 	    }
 
-	    dict->dv_refcount++;
-	    rettv->v_type	= VAR_DICT;
-	    rettv->vval.v_dict	= dict;
+	    rettv_dict_set(rettv, dict);
 	    break;
 	}
 	default:	/* not convertible */
diff --git a/src/list.c b/src/list.c
@@ -97,13 +97,23 @@ rettv_list_alloc(typval_T *rettv)
     if (l == NULL)
 	return FAIL;
 
-    rettv->vval.v_list = l;
-    rettv->v_type = VAR_LIST;
     rettv->v_lock = 0;
-    ++l->lv_refcount;
+    rettv_list_set(rettv, l);
     return OK;
 }
 
+/*
+ * Set a list as the return value
+ */
+    void
+rettv_list_set(typval_T *rettv, list_T *l)
+{
+    rettv->v_type = VAR_LIST;
+    rettv->vval.v_list = l;
+    if (l != NULL)
+	++l->lv_refcount;
+}
+
 /*
  * Unreference a list: decrement the reference count and free it when it
  * becomes zero.
@@ -875,11 +885,7 @@ get_list_tv(char_u **arg, typval_T *rettv, int evaluate)
 
     *arg = skipwhite(*arg + 1);
     if (evaluate)
-    {
-	rettv->v_type = VAR_LIST;
-	rettv->vval.v_list = l;
-	++l->lv_refcount;
-    }
+	rettv_list_set(rettv, l);
 
     return OK;
 }
diff --git a/src/proto/dict.pro b/src/proto/dict.pro
@@ -1,6 +1,7 @@
 /* dict.c */
 dict_T *dict_alloc(void);
 int rettv_dict_alloc(typval_T *rettv);
+void rettv_dict_set(typval_T *rettv, dict_T *d);
 void dict_unref(dict_T *d);
 int dict_free_nonref(int copyID);
 void dict_free_items(int copyID);
diff --git a/src/proto/list.pro b/src/proto/list.pro
@@ -4,6 +4,7 @@ void list_rem_watch(list_T *l, listwatch_T *lwrem);
 void list_fix_watch(list_T *l, listitem_T *item);
 list_T *list_alloc(void);
 int rettv_list_alloc(typval_T *rettv);
+void rettv_list_set(typval_T *rettv, list_T *l);
 void list_unref(list_T *l);
 int list_free_nonref(int copyID);
 void list_free_items(int copyID);
diff --git a/src/version.c b/src/version.c
@@ -764,6 +764,8 @@ static char *(features[]) =
 
 static int included_patches[] =
 {   /* Add new patch number below this line */
+/**/
+    593,
 /**/
     592,
 /**/

Original file line number	Diff line number	Diff line change
`@@ -4665,9 +4665,7 @@ eval_index(`
`4665`	`4665`	`item = item->li_next;`
`4666`	`4666`	`}`
`4667`	`4667`	`clear_tv(rettv);`
`4668`		`- rettv->v_type = VAR_LIST;`
`4669`		`- rettv->vval.v_list = l;`
`4670`		`- ++l->lv_refcount;`
	`4668`	`+ rettv_list_set(rettv, l);`
`4671`	`4669`	`}`
`4672`	`4670`	`else`
`4673`	`4671`	`{`
`@@ -8486,9 +8484,7 @@ getwinvar(`
`8486`	`8484`
`8487`	`8485`	`if (opts != NULL)`
`8488`	`8486`	`{`
`8489`		`- rettv->v_type = VAR_DICT;`
`8490`		`- rettv->vval.v_dict = opts;`
`8491`		`- ++opts->dv_refcount;`
	`8487`	`+ rettv_dict_set(rettv, opts);`
`8492`	`8488`	`done = TRUE;`
`8493`	`8489`	`}`
`8494`	`8490`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3005,8 +3005,7 @@ f_expand(typval_T argvars, typval_T rettv)`
`3005`	`3005`	`&& get_tv_number_chk(&argvars[2], &error)`
`3006`	`3006`	`&& !error)`
`3007`	`3007`	`{`
`3008`		`- rettv->v_type = VAR_LIST;`
`3009`		`- rettv->vval.v_list = NULL;`
	`3008`	`+ rettv_list_set(rettv, NULL);`
`3010`	`3009`	`}`
`3011`	`3010`
`3012`	`3011`	`s = get_tv_string(&argvars[0]);`
`@@ -3909,12 +3908,7 @@ f_get(typval_T argvars, typval_T rettv)`
`3909`	`3908`	`}`
`3910`	`3909`	`}`
`3911`	`3910`	`else if (STRCMP(what, "dict") == 0)`
`3912`		`- {`
`3913`		`- rettv->v_type = VAR_DICT;`
`3914`		`- rettv->vval.v_dict = pt->pt_dict;`
`3915`		`- if (pt->pt_dict != NULL)`
`3916`		`- ++pt->pt_dict->dv_refcount;`
`3917`		`- }`
	`3911`	`+ rettv_dict_set(rettv, pt->pt_dict);`
`3918`	`3912`	`else if (STRCMP(what, "args") == 0)`
`3919`	`3913`	`{`
`3920`	`3914`	`rettv->v_type = VAR_LIST;`
`@@ -4214,9 +4208,7 @@ f_getbufvar(typval_T argvars, typval_T rettv)`
`4214`	`4208`
`4215`	`4209`	`if (opts != NULL)`
`4216`	`4210`	`{`
`4217`		`- rettv->v_type = VAR_DICT;`
`4218`		`- rettv->vval.v_dict = opts;`
`4219`		`- ++opts->dv_refcount;`
	`4211`	`+ rettv_dict_set(rettv, opts);`
`4220`	`4212`	`done = TRUE;`
`4221`	`4213`	`}`
`4222`	`4214`	`}`
`@@ -5372,8 +5364,7 @@ f_glob(typval_T argvars, typval_T rettv)`
`5372`	`5364`	`{`
`5373`	`5365`	`if (get_tv_number_chk(&argvars[2], &error))`
`5374`	`5366`	`{`
`5375`		`- rettv->v_type = VAR_LIST;`
`5376`		`- rettv->vval.v_list = NULL;`
	`5367`	`+ rettv_list_set(rettv, NULL);`
`5377`	`5368`	`}`
`5378`	`5369`	`if (argvars[3].v_type != VAR_UNKNOWN`
`5379`	`5370`	`&& get_tv_number_chk(&argvars[3], &error))`
`@@ -5429,8 +5420,7 @@ f_globpath(typval_T argvars, typval_T rettv)`
`5429`	`5420`	`{`
`5430`	`5421`	`if (get_tv_number_chk(&argvars[3], &error))`
`5431`	`5422`	`{`
`5432`		`- rettv->v_type = VAR_LIST;`
`5433`		`- rettv->vval.v_list = NULL;`
	`5423`	`+ rettv_list_set(rettv, NULL);`
`5434`	`5424`	`}`
`5435`	`5425`	`if (argvars[4].v_type != VAR_UNKNOWN`
`5436`	`5426`	`&& get_tv_number_chk(&argvars[4], &error))`
`@@ -9152,9 +9142,7 @@ f_reverse(typval_T argvars, typval_T rettv)`
`9152`	`9142`	`list_append(l, li);`
`9153`	`9143`	`li = ni;`
`9154`	`9144`	`}`
`9155`		`- rettv->vval.v_list = l;`
`9156`		`- rettv->v_type = VAR_LIST;`
`9157`		`- ++l->lv_refcount;`
	`9145`	`+ rettv_list_set(rettv, l);`
`9158`	`9146`	`l->lv_idx = l->lv_len - l->lv_idx - 1;`
`9159`	`9147`	`}`
`9160`	`9148`	`}`
`@@ -10742,9 +10730,7 @@ do_sort_uniq(typval_T argvars, typval_T rettv, int sort)`
`10742`	`10730`	`(char_u *)(sort ? N_("sort() argument") : N_("uniq() argument")),`
`10743`	`10731`	`TRUE))`
`10744`	`10732`	`goto theend;`
`10745`		`- rettv->vval.v_list = l;`
`10746`		`- rettv->v_type = VAR_LIST;`
`10747`		`- ++l->lv_refcount;`
	`10733`	`+ rettv_list_set(rettv, l);`
`10748`	`10734`
`10749`	`10735`	`len = list_len(l);`
`10750`	`10736`	`if (len <= 1)`
`@@ -11832,8 +11818,7 @@ f_synconcealed(typval_T argvars UNUSED, typval_T rettv)`
`11832`	`11818`	`char_u str[NUMBUFLEN];`
`11833`	`11819`	`#endif`
`11834`	`11820`
`11835`		`- rettv->v_type = VAR_LIST;`
`11836`		`- rettv->vval.v_list = NULL;`
	`11821`	`+ rettv_list_set(rettv, NULL);`
`11837`	`11822`
`11838`	`11823`	`#if defined(FEAT_SYN_HL) && defined(FEAT_CONCEAL)`
`11839`	`11824`	`lnum = get_tv_lnum(argvars); /* -1 on type error */`
`@@ -11890,8 +11875,7 @@ f_synstack(typval_T argvars UNUSED, typval_T rettv)`
`11890`	`11875`	`int id;`
`11891`	`11876`	`#endif`
`11892`	`11877`
`11893`		`- rettv->v_type = VAR_LIST;`
`11894`		`- rettv->vval.v_list = NULL;`
	`11878`	`+ rettv_list_set(rettv, NULL);`
`11895`	`11879`
`11896`	`11880`	`#ifdef FEAT_SYN_HL`
`11897`	`11881`	`lnum = get_tv_lnum(argvars); /* -1 on type error */`
`@@ -12057,9 +12041,7 @@ get_cmd_output_as_rettv(`
`12057`	`12041`	`list_append(list, li);`
`12058`	`12042`	`}`
`12059`	`12043`
`12060`		`- ++list->lv_refcount;`
`12061`		`- rettv->v_type = VAR_LIST;`
`12062`		`- rettv->vval.v_list = list;`
	`12044`	`+ rettv_list_set(rettv, list);`
`12063`	`12045`	`list = NULL;`
`12064`	`12046`	`}`
`12065`	`12047`	`else`
`@@ -12465,8 +12447,7 @@ f_test_null_channel(typval_T argvars UNUSED, typval_T rettv)`
`12465`	`12447`	`static void`
`12466`	`12448`	`f_test_null_dict(typval_T argvars UNUSED, typval_T rettv)`
`12467`	`12449`	`{`
`12468`		`- rettv->v_type = VAR_DICT;`
`12469`		`- rettv->vval.v_dict = NULL;`
	`12450`	`+ rettv_dict_set(rettv, NULL);`
`12470`	`12451`	`}`
`12471`	`12452`
`12472`	`12453`	`#ifdef FEAT_JOB_CHANNEL`
`@@ -12481,8 +12462,7 @@ f_test_null_job(typval_T argvars UNUSED, typval_T rettv)`
`12481`	`12462`	`static void`
`12482`	`12463`	`f_test_null_list(typval_T argvars UNUSED, typval_T rettv)`
`12483`	`12464`	`{`
`12484`		`- rettv->v_type = VAR_LIST;`
`12485`		`- rettv->vval.v_list = NULL;`
	`12465`	`+ rettv_list_set(rettv, NULL);`
`12486`	`12466`	`}`
`12487`	`12467`
`12488`	`12468`	`static void`
Original file line number	Diff line number	Diff line change
`@@ -1136,9 +1136,7 @@ perl_to_vim(SV sv, typval_T rettv)`
`1136`	`1136`	`}`
`1137`	`1137`	`}`
`1138`	`1138`
`1139`		`- list->lv_refcount++;`
`1140`		`- rettv->v_type = VAR_LIST;`
`1141`		`- rettv->vval.v_list = list;`
	`1139`	`+ rettv_list_set(rettv, list);`
`1142`	`1140`	`break;`
`1143`	`1141`	`}`
`1144`	`1142`	`case SVt_PVHV: /* dictionary */`
`@@ -1192,9 +1190,7 @@ perl_to_vim(SV sv, typval_T rettv)`
`1192`	`1190`	`}`
`1193`	`1191`	`}`
`1194`	`1192`
`1195`		`- dict->dv_refcount++;`
`1196`		`- rettv->v_type = VAR_DICT;`
`1197`		`- rettv->vval.v_dict = dict;`
	`1193`	`+ rettv_dict_set(rettv, dict);`
`1198`	`1194`	`break;`
`1199`	`1195`	`}`
`1200`	`1196`	`default: /* not convertible */`