vim: src/eval.c comparison

comparison src/eval.c @ 1891:7a4ad3fb109d v7.2.188

updated for version 7.2-188

author	vimboss
date	Sun, 24 May 2009 11:40:58 +0000
parents	e5602d92da8c
children	afb740b5dfab

comparison

equal deleted inserted replaced

-:2928a6b338c3
+:7a4ad3fb109d
 static hashtab_T	compat_hashtab;
 /*
 * When recursively copying lists and dicts we need to remember which ones we
 * have done to avoid endless recursiveness.  This unique ID is used for that.
+* The last bit is used for previous_funccal, ignored when comparing.
 */
 static int current_copyID = 0;
+#define COPYID_INC 2
+#define COPYID_MASK (~0x1)
 /*
 * Array to hold the hashtab with variables local to each sourced script.
 * Each item holds a variable (nameless) that points to the dict_T.
 */
 static int list_concat __ARGS((list_T *l1, list_T *l2, typval_T *tv));
 static list_T *list_copy __ARGS((list_T *orig, int deep, int copyID));
 static void list_remove __ARGS((list_T *l, listitem_T *item, listitem_T *item2));
 static char_u *list2string __ARGS((typval_T *tv, int copyID));
 static int list_join __ARGS((garray_T *gap, list_T *l, char_u *sep, int echo, int copyID));
+static int free_unref_items __ARGS((int copyID));
 static void set_ref_in_ht __ARGS((hashtab_T *ht, int copyID));
 static void set_ref_in_list __ARGS((list_T *l, int copyID));
 static void set_ref_in_item __ARGS((typval_T *tv, int copyID));
 static void dict_unref __ARGS((dict_T *d));
 static void dict_free __ARGS((dict_T *d, int recurse));
 * Return TRUE if some memory was freed.
 */
 int
 garbage_collect()
 {
-dict_T	*dd;
+int		copyID;
-list_T	*ll;
-int		copyID = ++current_copyID;
 buf_T	*buf;
 win_T	*wp;
 int		i;
 funccall_T	*fc, **pfc;
-int		did_free = FALSE;
+int		did_free;
+int		did_free_funccal = FALSE;
 #ifdef FEAT_WINDOWS
 tabpage_T	*tp;
 #endif
 /* Only do this once. */
 want_garbage_collect = FALSE;
 may_garbage_collect = FALSE;
 garbage_collect_at_exit = FALSE;
+/* We advance by two because we add one for items referenced through
+* previous_funccal. */
+current_copyID += COPYID_INC;
+copyID = current_copyID;
 /*
 * 1. Go through all accessible variables and mark all lists and dicts
 *    with copyID.
 */
+/* Don't free variables in the previous_funccal list unless they are only
+* referenced through previous_funccal.  This must be first, because if
+* the item is referenced elsewhere it must not be freed. */
+for (fc = previous_funccal; fc != NULL; fc = fc->caller)
+{
+	set_ref_in_ht(&fc->l_vars.dv_hashtab, copyID + 1);
+	set_ref_in_ht(&fc->l_avars.dv_hashtab, copyID + 1);
+}
 /* script-local variables */
 for (i = 1; i <= ga_scripts.ga_len; ++i)
 	set_ref_in_ht(&SCRIPT_VARS(i), copyID);
 /* buffer-local variables */
 }
 /* v: vars */
 set_ref_in_ht(&vimvarht, copyID);
+/* Free lists and dictionaries that are not referenced. */
+did_free = free_unref_items(copyID);
+/* check if any funccal can be freed now */
+for (pfc = &previous_funccal; *pfc != NULL; )
+{
+	if (can_free_funccal(*pfc, copyID))
+	{
+	    fc = *pfc;
+	    *pfc = fc->caller;
+	    free_funccal(fc, TRUE);
+	    did_free = TRUE;
+	    did_free_funccal = TRUE;
+	}
+	else
+	    pfc = &(*pfc)->caller;
+}
+if (did_free_funccal)
+	/* When a funccal was freed some more items might be garbage
+	 * collected, so run again. */
+	(void)garbage_collect();
+return did_free;
+}
+/*
+* Free lists and dictionaries that are no longer referenced.
+*/
+static int
+free_unref_items(copyID)
+int copyID;
+{
+dict_T	*dd;
+list_T	*ll;
+int		did_free = FALSE;
 /*
-* 2. Go through the list of dicts and free items without the copyID.
+* Go through the list of dicts and free items without the copyID.
 */
 for (dd = first_dict; dd != NULL; )
-	if (dd->dv_copyID != copyID)
+	if ((dd->dv_copyID & COPYID_MASK) != (copyID & COPYID_MASK))
 	{
 	    /* Free the Dictionary and ordinary items it contains, but don't
 	     * recurse into Lists and Dictionaries, they will be in the list
 	     * of dicts or list of lists. */
 	    dict_free(dd, FALSE);
 	}
 	else
 	    dd = dd->dv_used_next;
 /*
-* 3. Go through the list of lists and free items without the copyID.
+* Go through the list of lists and free items without the copyID.
-*    But don't free a list that has a watcher (used in a for loop), these
+* But don't free a list that has a watcher (used in a for loop), these
-*    are not referenced anywhere.
+* are not referenced anywhere.
 */
 for (ll = first_list; ll != NULL; )
-	if (ll->lv_copyID != copyID && ll->lv_watch == NULL)
+	if ((ll->lv_copyID & COPYID_MASK) != (copyID & COPYID_MASK)
+						      && ll->lv_watch == NULL)
 	{
 	    /* Free the List and ordinary items it contains, but don't recurse
 	     * into Lists and Dictionaries, they will be in the list of dicts
 	     * or list of lists. */
 	    list_free(ll, FALSE);
 	    /* restart, next list may also have been freed */
 	    ll = first_list;
 	}
 	else
 	    ll = ll->lv_used_next;
-/* check if any funccal can be freed now */
-for (pfc = &previous_funccal; *pfc != NULL; )
-{
-	if (can_free_funccal(*pfc, copyID))
-	{
-	    fc = *pfc;
-	    *pfc = fc->caller;
-	    free_funccal(fc, TRUE);
-	    did_free = TRUE;
-	}
-	else
-	    pfc = &(*pfc)->caller;
-}
 return did_free;
 }
 /*
 dict_T	*dict;
 dictitem_T	*dict_var;
 {
 hash_init(&dict->dv_hashtab);
 dict->dv_refcount = DO_NOT_FREE_CNT;
+dict->dv_copyID = 0;
 dict_var->di_tv.vval.v_dict = dict;
 dict_var->di_tv.v_type = VAR_DICT;
 dict_var->di_tv.v_lock = VAR_FIXED;
 dict_var->di_flags = DI_FLAGS_RO | DI_FLAGS_FIX;
 dict_var->di_key[0] = NUL;
 did_emsg |= save_did_emsg;
 current_funccal = fc->caller;
 --depth;
-/* if the a:000 list and the a: dict are not referenced we can free the
+/* If the a:000 list and the l: and a: dicts are not referenced we can
-* funccall_T and what's in it. */
+* free the funccall_T and what's in it. */
 if (fc->l_varlist.lv_refcount == DO_NOT_FREE_CNT
 	    && fc->l_vars.dv_refcount == DO_NOT_FREE_CNT
 	    && fc->l_avars.dv_refcount == DO_NOT_FREE_CNT)
 {
 	free_funccal(fc, FALSE);
 }
 }
 /*
 * Return TRUE if items in "fc" do not have "copyID".  That means they are not
-* referenced from anywhere.
+* referenced from anywhere that is in use.
 */
 static int
 can_free_funccal(fc, copyID)
 funccall_T	*fc;
 int		copyID;

Mercurial > vim

comparison src/eval.c @ 1891:7a4ad3fb109d v7.2.188