vim: src/list.c comparison

comparison src/list.c @ 18800:f41b55f9357c v8.1.2388

patch 8.1.2388: using old C style comments Commit: https://github.com/vim/vim/commit/4ba37b5833de99db9e9afe8928b31c864182405c Author: Bram Moolenaar <Bram@vim.org> Date: Wed Dec 4 21:57:43 2019 +0100 patch 8.1.2388: using old C style comments Problem: Using old C style comments. Solution: Use // comments where appropriate.

author	Bram Moolenaar <Bram@vim.org>
date	Wed, 04 Dec 2019 22:00:04 +0100
parents	684a15da9929
children	09f28c17ac58

comparison

equal deleted inserted replaced

-:d7d0942e231b
+:f41b55f9357c
 #if defined(FEAT_EVAL) || defined(PROTO)
 static char *e_listblobarg = N_("E899: Argument of %s must be a List or Blob");
-/* List heads for garbage collection. */
+// List heads for garbage collection.
-static list_T		*first_list = NULL;	/* list of all lists */
+static list_T		*first_list = NULL;	// list of all lists
 /*
 * Add a watcher to a list.
 */
 void
 list_T  *l;
 l = ALLOC_CLEAR_ONE(list_T);
 if (l != NULL)
 {
-	/* Prepend the list to the list of lists for garbage collection. */
+	// Prepend the list to the list of lists for garbage collection.
 	if (first_list != NULL)
 	    first_list->lv_used_prev = l;
 	l->lv_used_prev = NULL;
 	l->lv_used_next = first_list;
 	first_list = l;
 {
 listitem_T *item;
 for (item = l->lv_first; item != NULL; item = l->lv_first)
 {
-	/* Remove the item before deleting it. */
+	// Remove the item before deleting it.
 	l->lv_first = item->li_next;
 	clear_tv(&item->li_tv);
 	vim_free(item);
 }
 }
 for (ll = first_list; ll != NULL; ll = ll->lv_used_next)
 	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
+	    // Free the List and ordinary items it contains, but don't recurse
-	     * into Lists and Dictionaries, they will be in the list of dicts
+	    // into Lists and Dictionaries, they will be in the list of dicts
-	     * or list of lists. */
+	    // or list of lists.
 	    list_free_contents(ll);
 	    did_free = TRUE;
 	}
 return did_free;
 }
 static void
 list_free_list(list_T  *l)
 {
-/* Remove the list from the list of lists for garbage collection. */
+// Remove the list from the list of lists for garbage collection.
 if (l->lv_used_prev == NULL)
 	first_list = l->lv_used_next;
 else
 	l->lv_used_prev->lv_used_next = l->lv_used_next;
 if (l->lv_used_next != NULL)
 {
 	ll_next = ll->lv_used_next;
 	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
+	    // Free the List and ordinary items it contains, but don't recurse
-	     * into Lists and Dictionaries, they will be in the list of dicts
+	    // into Lists and Dictionaries, they will be in the list of dicts
-	     * or list of lists. */
+	    // or list of lists.
 	    list_free_list(ll);
 	}
 }
 }
 */
 int
 list_equal(
 list_T	*l1,
 list_T	*l2,
-int		ic,	/* ignore case for strings */
+int		ic,	// ignore case for strings
-int		recursive)  /* TRUE when used recursively */
+int		recursive)  // TRUE when used recursively
 {
 listitem_T	*item1, *item2;
 if (l1 == NULL || l2 == NULL)
 	return FALSE;
 long	idx;
 if (l == NULL)
 	return NULL;
-/* Negative index is relative to the end. */
+// Negative index is relative to the end.
 if (n < 0)
 	n = l->lv_len + n;
-/* Check for index out of range. */
+// Check for index out of range.
 if (n < 0 || n >= l->lv_len)
 	return NULL;
-/* When there is a cached index may start search from there. */
+// When there is a cached index may start search from there.
 if (l->lv_idx_item != NULL)
 {
 	if (n < l->lv_idx / 2)
 	{
-	    /* closest to the start of the list */
+	    // closest to the start of the list
 	    item = l->lv_first;
 	    idx = 0;
 	}
 	else if (n > (l->lv_idx + l->lv_len) / 2)
 	{
-	    /* closest to the end of the list */
+	    // closest to the end of the list
 	    item = l->lv_last;
 	    idx = l->lv_len - 1;
 	}
 	else
 	{
-	    /* closest to the cached index */
+	    // closest to the cached index
 	    item = l->lv_idx_item;
 	    idx = l->lv_idx;
 	}
 }
 else
 {
 	if (n < l->lv_len / 2)
 	{
-	    /* closest to the start of the list */
+	    // closest to the start of the list
 	    item = l->lv_first;
 	    idx = 0;
 	}
 	else
 	{
-	    /* closest to the end of the list */
+	    // closest to the end of the list
 	    item = l->lv_last;
 	    idx = l->lv_len - 1;
 	}
 }
 while (n > idx)
 {
-	/* search forward */
+	// search forward
 	item = item->li_next;
 	++idx;
 }
 while (n < idx)
 {
-	/* search backward */
+	// search backward
 	item = item->li_prev;
 	--idx;
 }
-/* cache the used index */
+// cache the used index
 l->lv_idx = idx;
 l->lv_idx_item = item;
 return item;
 }
 */
 long
 list_find_nr(
 list_T	*l,
 long	idx,
-int		*errorp)	/* set to TRUE when something wrong */
+int		*errorp)	// set to TRUE when something wrong
 {
 listitem_T	*li;
 li = list_find(l, idx);
 if (li == NULL)
 void
 list_append(list_T *l, listitem_T *item)
 {
 if (l->lv_last == NULL)
 {
-	/* empty list */
+	// empty list
 	l->lv_first = item;
 	l->lv_last = item;
 	item->li_prev = NULL;
 }
 else
 void
 list_insert(list_T *l, listitem_T *ni, listitem_T *item)
 {
 if (item == NULL)
-	/* Append new item at end of list. */
+	// Append new item at end of list.
 	list_append(l, ni);
 else
 {
-	/* Insert new item before existing item. */
+	// Insert new item before existing item.
 	ni->li_prev = item->li_prev;
 	ni->li_next = item;
 	if (item->li_prev == NULL)
 	{
 	    l->lv_first = ni;
 list_extend(list_T *l1, list_T *l2, listitem_T *bef)
 {
 listitem_T	*item;
 int		todo = l2->lv_len;
-/* We also quit the loop when we have inserted the original item count of
+// We also quit the loop when we have inserted the original item count of
-* the list, avoid a hang when we extend a list with itself. */
+// the list, avoid a hang when we extend a list with itself.
 for (item = l2->lv_first; item != NULL && --todo >= 0; item = item->li_next)
 	if (list_insert_tv(l1, &item->li_tv, bef) == FAIL)
 	    return FAIL;
 return OK;
 }
 list_T	*l;
 if (l1 == NULL || l2 == NULL)
 	return FAIL;
-/* make a copy of the first list. */
+// make a copy of the first list.
 l = list_copy(l1, FALSE, 0);
 if (l == NULL)
 	return FAIL;
 tv->v_type = VAR_LIST;
 tv->vval.v_list = l;
-/* append all items from the second list */
+// append all items from the second list
 return list_extend(l, l2, NULL);
 }
 /*
 * Make a copy of list "orig".  Shallow if "deep" is FALSE.
 copy = list_alloc();
 if (copy != NULL)
 {
 	if (copyID != 0)
 	{
-	    /* Do this before adding the items, because one of the items may
+	    // Do this before adding the items, because one of the items may
-	     * refer back to this list. */
+	    // refer back to this list.
 	    orig->lv_copyID = copyID;
 	    orig->lv_copylist = copy;
 	}
 	for (item = orig->lv_first; item != NULL && !got_int;
 							 item = item->li_next)
 void
 vimlist_remove(list_T *l, listitem_T *item, listitem_T *item2)
 {
 listitem_T	*ip;
-/* notify watchers */
+// notify watchers
 for (ip = item; ip != NULL; ip = ip->li_next)
 {
 	--l->lv_len;
 	list_fix_watch(l, ip);
 	if (ip == item2)
 char_u	*tofree;
 } join_T;
 static int
 list_join_inner(
-garray_T	*gap,		/* to store the result in */
+garray_T	*gap,		// to store the result in
 list_T	*l,
 char_u	*sep,
 int		echo_style,
 int		restore_copyID,
 int		copyID,
-garray_T	*join_gap)	/* to keep each list item string */
+garray_T	*join_gap)	// to keep each list item string
 {
 int		i;
 join_T	*p;
 int		len;
 int		sumlen = 0;
 char_u	*tofree;
 char_u	numbuf[NUMBUFLEN];
 listitem_T	*item;
 char_u	*s;
-/* Stringify each item in the list. */
+// Stringify each item in the list.
 for (item = l->lv_first; item != NULL && !got_int; item = item->li_next)
 {
 	s = echo_string_core(&item->li_tv, &tofree, numbuf, copyID,
 				      echo_style, restore_copyID, !echo_style);
 	if (s == NULL)
 	    p->s = vim_strnsave(s, len);
 	    p->tofree = p->s;
 	}
 	line_breakcheck();
-	if (did_echo_string_emsg)  /* recursion error, bail out */
+	if (did_echo_string_emsg)  // recursion error, bail out
 	    break;
 }
-/* Allocate result buffer with its total size, avoid re-allocation and
+// Allocate result buffer with its total size, avoid re-allocation and
-* multiple copy operations.  Add 2 for a tailing ']' and NUL. */
+// multiple copy operations.  Add 2 for a tailing ']' and NUL.
 if (join_gap->ga_len >= 2)
 	sumlen += (int)STRLEN(sep) * (join_gap->ga_len - 1);
 if (ga_grow(gap, sumlen + 2) == FAIL)
 	return FAIL;
 int		retval;
 join_T	*p;
 int		i;
 if (l->lv_len < 1)
-	return OK; /* nothing to do */
+	return OK; // nothing to do
 ga_init2(&join_ga, (int)sizeof(join_T), l->lv_len);
 retval = list_join_inner(gap, l, sep, echo_style, restore_copyID,
 							    copyID, &join_ga);
-/* Dispose each item in join_ga. */
+// Dispose each item in join_ga.
 if (join_ga.ga_data != NULL)
 {
 	p = (join_T *)join_ga.ga_data;
 	for (i = 0; i < join_ga.ga_len; ++i)
 	{
 }
 *arg = skipwhite(*arg + 1);
 while (**arg != ']' && **arg != NUL)
 {
-	if (eval1(arg, &tv, evaluate) == FAIL)	/* recursive! */
+	if (eval1(arg, &tv, evaluate) == FAIL)	// recursive!
 	    goto failret;
 	if (evaluate)
 	{
 	    item = listitem_alloc();
 	    if (item != NULL)
 	semsg(_(e_listidx), idx);
 else
 {
 	if (argvars[2].v_type == VAR_UNKNOWN)
 	{
-	    /* Remove one item, return its value. */
+	    // Remove one item, return its value.
 	    vimlist_remove(l, item, item);
 	    *rettv = item->li_tv;
 	    vim_free(item);
 	}
 	else
 		{
 		    ++cnt;
 		    if (li == item2)
 			break;
 		}
-		if (li == NULL)  /* didn't find "item2" after "item" */
+		if (li == NULL)  // didn't find "item2" after "item"
 		    emsg(_(e_invrange));
 		else
 		{
 		    vimlist_remove(l, item, item2);
 		    if (rettv_list_alloc(rettv) == OK)
 }
 static int item_compare(const void *s1, const void *s2);
 static int item_compare2(const void *s1, const void *s2);
-/* struct used in the array that's given to qsort() */
+// struct used in the array that's given to qsort()
 typedef struct
 {
 listitem_T	*item;
 int		idx;
 } sortItem_T;
-/* struct storing information about current sort */
+// struct storing information about current sort
 typedef struct
 {
 int		item_compare_ic;
 int		item_compare_numeric;
 int		item_compare_numbers;
 	return v1 == v2 ? 0 : v1 > v2 ? 1 : -1;
 }
 #endif
-/* tv2string() puts quotes around a string and allocates memory.  Don't do
+// tv2string() puts quotes around a string and allocates memory.  Don't do
-* that for string variables. Use a single quote when comparing with a
+// that for string variables. Use a single quote when comparing with a
-* non-string to do what the docs promise. */
+// non-string to do what the docs promise.
 if (tv1->v_type == VAR_STRING)
 {
 	if (tv2->v_type != VAR_STRING || sortinfo->item_compare_numeric)
 	    p1 = (char_u *)"'";
 	else
 	n1 = strtod((char *)p1, (char **)&p1);
 	n2 = strtod((char *)p2, (char **)&p2);
 	res = n1 == n2 ? 0 : n1 > n2 ? 1 : -1;
 }
-/* When the result would be zero, compare the item indexes.  Makes the
+// When the result would be zero, compare the item indexes.  Makes the
-* sort stable. */
+// sort stable.
 if (res == 0 && !sortinfo->item_compare_keep_zero)
 	res = si1->idx > si2->idx ? 1 : -1;
 vim_free(tofree1);
 vim_free(tofree2);
 typval_T	argv[3];
 char_u	*func_name;
 partial_T	*partial = sortinfo->item_compare_partial;
 funcexe_T	funcexe;
-/* shortcut after failure in previous call; compare all items equal */
+// shortcut after failure in previous call; compare all items equal
 if (sortinfo->item_compare_func_err)
 	return 0;
 si1 = (sortItem_T *)s1;
 si2 = (sortItem_T *)s2;
 if (partial == NULL)
 	func_name = sortinfo->item_compare_func;
 else
 	func_name = partial_name(partial);
-/* Copy the values.  This is needed to be able to set v_lock to VAR_FIXED
+// Copy the values.  This is needed to be able to set v_lock to VAR_FIXED
-* in the copy without changing the original list items. */
+// in the copy without changing the original list items.
 copy_tv(&si1->item->li_tv, &argv[0]);
 copy_tv(&si2->item->li_tv, &argv[1]);
-rettv.v_type = VAR_UNKNOWN;		/* clear_tv() uses this */
+rettv.v_type = VAR_UNKNOWN;		// clear_tv() uses this
 vim_memset(&funcexe, 0, sizeof(funcexe));
 funcexe.evaluate = TRUE;
 funcexe.partial = partial;
 funcexe.selfdict = sortinfo->item_compare_selfdict;
 res = call_func(func_name, -1, &rettv, 2, argv, &funcexe);
 if (res == FAIL)
 	res = ITEM_COMPARE_FAIL;
 else
 	res = (int)tv_get_number_chk(&rettv, &sortinfo->item_compare_func_err);
 if (sortinfo->item_compare_func_err)
-	res = ITEM_COMPARE_FAIL;  /* return value has wrong type */
+	res = ITEM_COMPARE_FAIL;  // return value has wrong type
 clear_tv(&rettv);
-/* When the result would be zero, compare the pointers themselves.  Makes
+// When the result would be zero, compare the pointers themselves.  Makes
-* the sort stable. */
+// the sort stable.
 if (res == 0 && !sortinfo->item_compare_keep_zero)
 	res = si1->idx > si2->idx ? 1 : -1;
 return res;
 }
 sortinfo_T	*old_sortinfo;
 sortinfo_T	info;
 long	len;
 long	i;
-/* Pointer to current info struct used in compare function. Save and
+// Pointer to current info struct used in compare function. Save and
-* restore the current one for nested calls. */
+// restore the current one for nested calls.
 old_sortinfo = sortinfo;
 sortinfo = &info;
 if (argvars[0].v_type != VAR_LIST)
 	semsg(_(e_listarg), sort ? "sort()" : "uniq()");
 	    goto theend;
 	rettv_list_set(rettv, l);
 	len = list_len(l);
 	if (len <= 1)
-	    goto theend;	/* short list sorts pretty quickly */
+	    goto theend;	// short list sorts pretty quickly
 	info.item_compare_ic = FALSE;
 	info.item_compare_numeric = FALSE;
 	info.item_compare_numbers = FALSE;
 #ifdef FEAT_FLOAT
 	info.item_compare_func = NULL;
 	info.item_compare_partial = NULL;
 	info.item_compare_selfdict = NULL;
 	if (argvars[1].v_type != VAR_UNKNOWN)
 	{
-	    /* optional second argument: {func} */
+	    // optional second argument: {func}
 	    if (argvars[1].v_type == VAR_FUNC)
 		info.item_compare_func = argvars[1].vval.v_string;
 	    else if (argvars[1].v_type == VAR_PARTIAL)
 		info.item_compare_partial = argvars[1].vval.v_partial;
 	    else
 	    {
 		int	    error = FALSE;
 		i = (long)tv_get_number_chk(&argvars[1], &error);
 		if (error)
-		    goto theend;	/* type error; errmsg already given */
+		    goto theend;	// type error; errmsg already given
 		if (i == 1)
 		    info.item_compare_ic = TRUE;
 		else if (argvars[1].v_type != VAR_NUMBER)
 		    info.item_compare_func = tv_get_string(&argvars[1]);
 		else if (i != 0)
 		}
 		if (info.item_compare_func != NULL)
 		{
 		    if (*info.item_compare_func == NUL)
 		    {
-			/* empty string means default sort */
+			// empty string means default sort
 			info.item_compare_func = NULL;
 		    }
 		    else if (STRCMP(info.item_compare_func, "n") == 0)
 		    {
 			info.item_compare_func = NULL;
 		}
 	    }
 	    if (argvars[2].v_type != VAR_UNKNOWN)
 	    {
-		/* optional third argument: {dict} */
+		// optional third argument: {dict}
 		if (argvars[2].v_type != VAR_DICT)
 		{
 		    emsg(_(e_dictreq));
 		    goto theend;
 		}
 		info.item_compare_selfdict = argvars[2].vval.v_dict;
 	    }
 	}
-	/* Make an array with each entry pointing to an item in the List. */
+	// Make an array with each entry pointing to an item in the List.
 	ptrs = ALLOC_MULT(sortItem_T, len);
 	if (ptrs == NULL)
 	    goto theend;
 	i = 0;
 	if (sort)
 	{
-	    /* sort(): ptrs will be the list to sort */
+	    // sort(): ptrs will be the list to sort
 	    for (li = l->lv_first; li != NULL; li = li->li_next)
 	    {
 		ptrs[i].item = li;
 		ptrs[i].idx = i;
 		++i;
 	    }
 	    info.item_compare_func_err = FALSE;
 	    info.item_compare_keep_zero = FALSE;
-	    /* test the compare function */
+	    // test the compare function
 	    if ((info.item_compare_func != NULL
 					 || info.item_compare_partial != NULL)
 		    && item_compare2((void *)&ptrs[0], (void *)&ptrs[1])
 							 == ITEM_COMPARE_FAIL)
 		emsg(_("E702: Sort compare function failed"));
 	    else
 	    {
-		/* Sort the array with item pointers. */
+		// Sort the array with item pointers.
 		qsort((void *)ptrs, (size_t)len, sizeof(sortItem_T),
 		    info.item_compare_func == NULL
 					  && info.item_compare_partial == NULL
 					       ? item_compare : item_compare2);
 		if (!info.item_compare_func_err)
 		{
-		    /* Clear the List and append the items in sorted order. */
+		    // Clear the List and append the items in sorted order.
 		    l->lv_first = l->lv_last = l->lv_idx_item = NULL;
 		    l->lv_len = 0;
 		    for (i = 0; i < len; ++i)
 			list_append(l, ptrs[i].item);
 		}
 	}
 	else
 	{
 	    int	(*item_compare_func_ptr)(const void *, const void *);
-	    /* f_uniq(): ptrs will be a stack of items to remove */
+	    // f_uniq(): ptrs will be a stack of items to remove
 	    info.item_compare_func_err = FALSE;
 	    info.item_compare_keep_zero = TRUE;
 	    item_compare_func_ptr = info.item_compare_func != NULL
 					  || info.item_compare_partial != NULL
 					       ? item_compare2 : item_compare;
 f_add(typval_T *argvars, typval_T *rettv)
 {
 list_T	*l;
 blob_T	*b;
-rettv->vval.v_number = 1; /* Default: Failed */
+rettv->vval.v_number = 1; // Default: Failed
 if (argvars[0].v_type == VAR_LIST)
 {
 	if ((l = argvars[0].vval.v_list) != NULL
 		&& !var_check_lock(l->lv_lock,
 					 (char_u *)N_("add() argument"), TRUE)
 	{
 	    if (argvars[2].v_type != VAR_UNKNOWN)
 	    {
 		before = (long)tv_get_number_chk(&argvars[2], &error);
 		if (error)
-		    return;		/* type error; errmsg already given */
+		    return;		// type error; errmsg already given
 		if (before == l1->lv_len)
 		    item = NULL;
 		else
 		{
 	d1 = argvars[0].vval.v_dict;
 	d2 = argvars[1].vval.v_dict;
 	if (d1 != NULL && !var_check_lock(d1->dv_lock, arg_errmsg, TRUE)
 		&& d2 != NULL)
 	{
-	    /* Check the third argument. */
+	    // Check the third argument.
 	    if (argvars[2].v_type != VAR_UNKNOWN)
 	    {
 		static char *(av[]) = {"keep", "force", "error"};
 		action = tv_get_string_chk(&argvars[2]);
 		if (action == NULL)
-		    return;		/* type error; errmsg already given */
+		    return;		// type error; errmsg already given
 		for (i = 0; i < 3; ++i)
 		    if (STRCMP(action, av[i]) == 0)
 			break;
 		if (i == 3)
 		{
 				     (char_u *)N_("insert() argument"), TRUE))
 {
 	if (argvars[2].v_type != VAR_UNKNOWN)
 	    before = (long)tv_get_number_chk(&argvars[2], &error);
 	if (error)
-	    return;		/* type error; errmsg already given */
+	    return;		// type error; errmsg already given
 	if (before == l->lv_len)
 	    item = NULL;
 	else
 	{

Mercurial > vim

comparison src/list.c @ 18800:f41b55f9357c v8.1.2388