vim: src/misc2.c comparison

comparison src/misc2.c @ 16764:ef00b6bc186b v8.1.1384

patch 8.1.1384: using "int" for alloc() often results in compiler warnings commit https://github.com/vim/vim/commit/964b3746b9c81e65887e2ac9a335f181db2bb592 Author: Bram Moolenaar <Bram@vim.org> Date: Fri May 24 18:54:09 2019 +0200 patch 8.1.1384: using "int" for alloc() often results in compiler warnings Problem: Using "int" for alloc() often results in compiler warnings. Solution: Use "size_t" and remove type casts. Remove alloc_check(), Vim only works with 32 bit ints anyway.

author	Bram Moolenaar <Bram@vim.org>
date	Fri, 24 May 2019 19:00:07 +0200
parents	77bcb5055fec
children	fc58fee685e2

comparison

equal deleted inserted replaced

-:fccf84413b53
+:ef00b6bc186b
 {
 *sizep += sizeof(size_t);
 }
 static void
-mem_pre_alloc_l(long_u *sizep)
+mem_pre_alloc_l(size_t *sizep)
 {
 *sizep += sizeof(size_t);
 }
 static void
 #endif /* MEM_PROFILE */
 #ifdef FEAT_EVAL
 int
-alloc_does_fail(long_u size)
+alloc_does_fail(size_t size)
 {
 if (alloc_fail_countdown == 0)
 {
 	if (--alloc_fail_repeat <= 0)
 	    alloc_fail_id = 0;
 */
 #define KEEP_ROOM (2 * 8192L)
 #define KEEP_ROOM_KB (KEEP_ROOM / 1024L)
 /*
-* Note: if unsigned is 16 bits we can only allocate up to 64K with alloc().
+* The normal way to allocate memory.  This handles an out-of-memory situation
-* Use lalloc for larger blocks.
+* as well as possible, still returns NULL when we're completely out.
 */
 char_u *
-alloc(unsigned size)
+alloc(size_t size)
 {
-return (lalloc((long_u)size, TRUE));
+return lalloc(size, TRUE);
 }
 /*
 * alloc() with an ID for alloc_fail().
 */
 char_u *
-alloc_id(unsigned size, alloc_id_T id UNUSED)
+alloc_id(size_t size, alloc_id_T id UNUSED)
 {
 #ifdef FEAT_EVAL
-if (alloc_fail_id == id && alloc_does_fail((long_u)size))
+if (alloc_fail_id == id && alloc_does_fail(size))
 	return NULL;
 #endif
-return (lalloc((long_u)size, TRUE));
+return lalloc(size, TRUE);
 }
 /*
 * Allocate memory and set all bytes to zero.
 */
 char_u *
-alloc_clear(unsigned size)
+alloc_clear(size_t size)
 {
 char_u *p;
-p = lalloc((long_u)size, TRUE);
+p = lalloc(size, TRUE);
 if (p != NULL)
-	(void)vim_memset(p, 0, (size_t)size);
+	(void)vim_memset(p, 0, size);
 return p;
 }
 /*
 * Same as alloc_clear() but with allocation id for testing
 */
 char_u *
-alloc_clear_id(unsigned size, alloc_id_T id UNUSED)
+alloc_clear_id(size_t size, alloc_id_T id UNUSED)
 {
 #ifdef FEAT_EVAL
-if (alloc_fail_id == id && alloc_does_fail((long_u)size))
+if (alloc_fail_id == id && alloc_does_fail(size))
 	return NULL;
 #endif
 return alloc_clear(size);
 }
 /*
-* alloc() with check for maximum line length
+* Allocate memory like lalloc() and set all bytes to zero.
 */
 char_u *
-alloc_check(unsigned size)
+lalloc_clear(size_t size, int message)
-{
-#if !defined(UNIX)
-if (sizeof(int) == 2 && size > 0x7fff)
-{
-	/* Don't hide this message */
-	emsg_silent = 0;
-	emsg(_("E340: Line is becoming too long"));
-	return NULL;
-}
-#endif
-return (lalloc((long_u)size, TRUE));
-}
-/*
-* Allocate memory like lalloc() and set all bytes to zero.
-*/
-char_u *
-lalloc_clear(long_u size, int message)
 {
 char_u *p;
 p = (lalloc(size, message));
 if (p != NULL)
-	(void)vim_memset(p, 0, (size_t)size);
+	(void)vim_memset(p, 0, size);
 return p;
 }
 /*
 * Low level memory allocation function.
 * This is used often, KEEP IT FAST!
 */
 char_u *
-lalloc(long_u size, int message)
+lalloc(size_t size, int message)
 {
 char_u	*p;		    /* pointer to new storage space */
 static int	releasing = FALSE;  /* don't do mf_release_all() recursive */
 int		try_again;
 #if defined(HAVE_AVAIL_MEM)
-static long_u allocated = 0;    /* allocated since last avail check */
+static size_t allocated = 0;    /* allocated since last avail check */
 #endif
-/* Safety check for allocating zero bytes */
+// Safety check for allocating zero bytes
 if (size == 0)
 {
-	/* Don't hide this message */
+	// Don't hide this message
 	emsg_silent = 0;
-	siemsg(_("E341: Internal error: lalloc(%ld, )"), size);
+	iemsg(_("E341: Internal error: lalloc(0, )"));
 	return NULL;
 }
 #ifdef MEM_PROFILE
 mem_pre_alloc_l(&size);
 	 * 1. No check for available memory: Just return.
 	 * 2. Slow check for available memory: call mch_avail_mem() after
 	 *    allocating KEEP_ROOM amount of memory.
 	 * 3. Strict check for available memory: call mch_avail_mem()
 	 */
-	if ((p = (char_u *)malloc((size_t)size)) != NULL)
+	if ((p = (char_u *)malloc(size)) != NULL)
 	{
 #ifndef HAVE_AVAIL_MEM
 	    /* 1. No check for available memory: Just return. */
 	    goto theend;
 #else
 if (message && p == NULL)
 	do_outofmem_msg(size);
 theend:
 #ifdef MEM_PROFILE
-mem_post_alloc((void **)&p, (size_t)size);
+mem_post_alloc((void **)&p, size);
 #endif
 return p;
 }
 /*
 * lalloc() with an ID for alloc_fail().
 */
 #if defined(FEAT_SIGNS) || defined(PROTO)
 char_u *
-lalloc_id(long_u size, int message, alloc_id_T id UNUSED)
+lalloc_id(size_t size, int message, alloc_id_T id UNUSED)
 {
 #ifdef FEAT_EVAL
 if (alloc_fail_id == id && alloc_does_fail(size))
 	return NULL;
 #endif
-return (lalloc((long_u)size, message));
+return (lalloc(size, message));
 }
 #endif
 #if defined(MEM_PROFILE) || defined(PROTO)
 /*
 /*
 * Avoid repeating the error message many times (they take 1 second each).
 * Did_outofmem_msg is reset when a character is read.
 */
 void
-do_outofmem_msg(long_u size)
+do_outofmem_msg(size_t size)
 {
 if (!did_outofmem_msg)
 {
 	/* Don't hide this message */
 	emsg_silent = 0;
 	/* Must come first to avoid coming back here when printing the error
 	 * message fails, e.g. when setting v:errmsg. */
 	did_outofmem_msg = TRUE;
-	semsg(_("E342: Out of memory!  (allocating %lu bytes)"), size);
+	semsg(_("E342: Out of memory!  (allocating %lu bytes)"), (long_u)size);
 }
 }
 #if defined(EXITFREE) || defined(PROTO)
 */
 char_u *
 vim_strsave(char_u *string)
 {
 char_u	*p;
-unsigned	len;
+size_t	len;
-len = (unsigned)STRLEN(string) + 1;
+len = STRLEN(string) + 1;
 p = alloc(len);
 if (p != NULL)
-	mch_memmove(p, string, (size_t)len);
+	mch_memmove(p, string, len);
 return p;
 }
 /*
 * Copy up to "len" bytes of "string" into newly allocated memory and
 char_u *
 vim_strnsave(char_u *string, int len)
 {
 char_u	*p;
-p = alloc((unsigned)(len + 1));
+p = alloc((size_t)(len + 1));
 if (p != NULL)
 {
 	STRNCPY(p, string, len);
 	p[len] = NUL;
 }
 /*
 * Copy "p[len]" into allocated memory, ignoring NUL characters.
 * Returns NULL when out of memory.
 */
 char_u *
-vim_memsave(char_u *p, int len)
+vim_memsave(char_u *p, size_t len)
 {
-char_u *ret = alloc((unsigned)len);
+char_u *ret = alloc(len);
 if (ret != NULL)
-	mch_memmove(ret, p, (size_t)len);
+	mch_memmove(ret, p, len);
 return ret;
 }
 /*
 * Same as vim_strsave(), but any characters found in esc_chars are preceded
 		/* Reallocate string when byte count changes.  This is rare,
 		 * thus it's OK to do another malloc()/free(). */
 		newl = utf_char2len(uc);
 		if (newl != l)
 		{
-		    s = alloc((unsigned)STRLEN(res) + 1 + newl - l);
+		    s = alloc(STRLEN(res) + 1 + newl - l);
 		    if (s == NULL)
 		    {
 			vim_free(res);
 			return NULL;
 		    }
 		/* Reallocate string when byte count changes.  This is rare,
 		 * thus it's OK to do another malloc()/free(). */
 		newl = utf_char2len(lc);
 		if (newl != l)
 		{
-		    s = alloc((unsigned)STRLEN(res) + 1 + newl - l);
+		    s = alloc(STRLEN(res) + 1 + newl - l);
 		    if (s == NULL)
 		    {
 			vim_free(res);
 			return NULL;
 		    }
 {
 	if (n < gap->ga_growsize)
 	    n = gap->ga_growsize;
 	new_len = gap->ga_itemsize * (gap->ga_len + n);
 	pp = (gap->ga_data == NULL)
-	      ? alloc((unsigned)new_len) : vim_realloc(gap->ga_data, new_len);
+	      ? alloc(new_len) : vim_realloc(gap->ga_data, new_len);
 	if (pp == NULL)
 	    return FAIL;
 	old_len = gap->ga_itemsize * gap->ga_maxlen;
 	vim_memset(pp + old_len, 0, new_len - old_len);
 	gap->ga_maxlen = gap->ga_len + n;
 	    {
 		ecmd = vim_strsave_escaped_ext(cmd, p_sxe, '^', FALSE);
 		if (ecmd == NULL)
 		    ecmd = cmd;
 	    }
-	    ncmd = alloc((unsigned)(STRLEN(ecmd) + STRLEN(p_sxq) * 2 + 1));
+	    ncmd = alloc(STRLEN(ecmd) + STRLEN(p_sxq) * 2 + 1);
 	    if (ncmd != NULL)
 	    {
 		STRCPY(ncmd, p_sxq);
 		STRCAT(ncmd, ecmd);
 		/* When 'shellxquote' is ( append ).
 char_u	*p1;
 char_u	*p2;
 int		i, j;
 int		gap;
-buf = alloc((unsigned)elm_size);
+buf = alloc(elm_size);
 if (buf == NULL)
 	return;
 for (gap = elm_count / 2; gap > 0; gap /= 2)
 	for (i = gap; i < elm_count; ++i)
 	if (i >= (envsize - 1))
 	{			/* need new slot */
 	    if (moreenv() < 0)
 		return -1;
 	}
-	p = (char *)alloc((unsigned)(strlen(string) + 1));
+	p = (char *)alloc(strlen(string) + 1);
 	if (p == NULL)		/* not enough core */
 	    return -1;
 	environ[i + 1] = 0;	/* new end of env. */
 }
 else
 for (i = 0; environ[i]; i++)
 	;
 esize = i + EXTRASIZE + 1;
-env = (char **)alloc((unsigned)(esize * sizeof (elem)));
+env = (char **)alloc(esize * sizeof (elem));
 if (env == NULL)
 	return -1;
 for (i = 0; environ[i]; i++)
 {
-	elem = (char *)alloc((unsigned)(strlen(environ[i]) + 1));
+	elem = (char *)alloc(strlen(environ[i]) + 1);
 	if (elem == NULL)
 	    return -1;
 	env[i] = elem;
 	strcpy(elem, environ[i]);
 }
 char_u	*str;
 int		i;
 int		c;
 /* allocate memory */
-str = alloc((unsigned)cnt + 1);
+str = alloc(cnt + 1);
 if (str != NULL)
 {
 	/* Read the string.  Quit when running into the EOF. */
 	for (i = 0; i < cnt; ++i)
 	{
 		    ++*argc;
 		    p = skipwhite(p);
 		}
 	    }
-	    *argv = (char **)alloc((unsigned)((*argc + 4) * sizeof(char *)));
+	    *argv = (char **)alloc((*argc + 4) * sizeof(char *));
 	    if (*argv == NULL)	    /* out of memory */
 		return FAIL;
 	}
 }
 return OK;

Mercurial > vim

comparison src/misc2.c @ 16764:ef00b6bc186b v8.1.1384