> > --- common/screen.c 12 Nov 2014 04:28:41 -0000 1.11
> > +++ common/screen.c 12 Nov 2014 07:20:51 -0000
> > @@ -84,16 +84,16 @@
> > goto mem;
> > sp->subre_len = orig->subre_len;
> > if (orig->repl != NULL && (sp->repl =
> > - v_strdup(sp, orig->repl, orig->repl_len)) == NULL)
> > - goto mem;
> > + v_strdup(sp, orig->repl, orig->repl_len)) == NULL) {
> > +mem: msgq(orig, M_SYSERR, NULL);
> > + goto err;
> > + }
> > sp->repl_len = orig->repl_len;
> > if (orig->newl_len) {
> > len = orig->newl_len * sizeof(size_t);
> > - MALLOC(sp, sp->newl, size_t *, len);
> > - if (sp->newl == NULL) {
> > -mem: msgq(orig, M_SYSERR, NULL);
> > + MALLOC(sp, sp->newl, len);
> > + if (sp->newl == NULL)
> > goto err;
> > - }
>
> I think this is better left as-is with the MALLOC converted to
> malloc(). Otherwise, msgq() is called with sp instead of orig.
Thank you for finding this issue! Updated diff below (including the removal
of the unused variables you've found).
cheers,
natano
Index: cl/cl_main.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/cl/cl_main.c,v
retrieving revision 1.23
diff -u -r1.23 cl_main.c
--- cl/cl_main.c 12 Nov 2014 16:29:04 -0000 1.23
+++ cl/cl_main.c 12 Nov 2014 18:39:27 -0000
@@ -151,11 +151,10 @@
name = p + 1;
/* Allocate the global structure. */
- CALLOC_NOMSG(NULL, gp, GS *, 1, sizeof(GS));
+ gp = calloc(1, sizeof(GS));
if (gp == NULL)
perr(name, NULL);
-
gp->progname = name;
return (gp);
}
@@ -171,7 +170,7 @@
int fd;
/* Allocate the CL private structure. */
- CALLOC_NOMSG(NULL, clp, CL_PRIVATE *, 1, sizeof(CL_PRIVATE));
+ clp = calloc(1, sizeof(CL_PRIVATE));
if (clp == NULL)
perr(gp->progname, NULL);
gp->cl_private = clp;
Index: cl/cl_screen.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/cl/cl_screen.c,v
retrieving revision 1.22
diff -u -r1.22 cl_screen.c
--- cl/cl_screen.c 12 Nov 2014 16:29:04 -0000 1.22
+++ cl/cl_screen.c 12 Nov 2014 18:39:27 -0000
@@ -501,7 +501,7 @@
if ((t = tigetstr(name)) != NULL &&
t != (char *)-1 && (len = strlen(t)) != 0) {
- MALLOC_RET(sp, *elementp, char *, len + 1);
+ MALLOC_RET(sp, *elementp, len + 1);
memmove(*elementp, t, len + 1);
}
return (0);
Index: common/api.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/common/api.c,v
retrieving revision 1.16
diff -u -r1.16 api.c
--- common/api.c 12 Nov 2014 04:28:41 -0000 1.16
+++ common/api.c 12 Nov 2014 18:39:27 -0000
@@ -380,7 +380,7 @@
case OPT_0BOOL:
case OPT_1BOOL:
len = strlen(op->name) + 2 + 1;
- MALLOC_RET(sp, *value, char *, len);
+ MALLOC_RET(sp, *value, len);
(void)snprintf(*value, len,
"%s%s", O_ISSET(sp, offset) ? "" : "no", op->name);
if (boolvalue != NULL)
@@ -388,17 +388,16 @@
break;
case OPT_NUM:
len = 20;
- MALLOC_RET(sp, *value, char *, len);
+ MALLOC_RET(sp, *value, len);
(void)snprintf(*value, len, "%lu", (u_long)O_VAL(sp, offset));
break;
case OPT_STR:
if (O_STR(sp, offset) == NULL) {
- MALLOC_RET(sp, *value, char *, 2);
+ MALLOC_RET(sp, *value, 1);
value[0] = '\0';
} else {
len = strlen(O_STR(sp, offset)) + 1;
- MALLOC_RET(sp,
- *value, char *, len);
+ MALLOC_RET(sp, *value, len);
(void)snprintf(*value, len, "%s", O_STR(sp, offset));
}
break;
Index: common/cut.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/common/cut.c,v
retrieving revision 1.13
diff -u -r1.13 cut.c
--- common/cut.c 12 Nov 2014 04:28:41 -0000 1.13
+++ common/cut.c 12 Nov 2014 18:39:27 -0000
@@ -119,7 +119,7 @@
* Otherwise, if it's not an append, free its current contents.
*/
if (cbp == NULL) {
- CALLOC_RET(sp, cbp, CB *, 1, sizeof(CB));
+ CALLOC_RET(sp, cbp, 1, sizeof(CB));
cbp->name = name;
TAILQ_INIT(&cbp->textq);
LIST_INSERT_HEAD(&sp->gp->cutq, cbp, q);
@@ -300,12 +300,12 @@
{
TEXT *tp;
- CALLOC(sp, tp, TEXT *, 1, sizeof(TEXT));
+ CALLOC(sp, tp, 1, sizeof(TEXT));
if (tp == NULL)
return (NULL);
/* ANSI C doesn't define a call to malloc(3) for 0 bytes. */
if ((tp->lb_len = total_len) != 0) {
- MALLOC(sp, tp->lb, CHAR_T *, tp->lb_len);
+ MALLOC(sp, tp->lb, tp->lb_len);
if (tp->lb == NULL) {
free(tp);
return (NULL);
Index: common/exf.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/common/exf.c,v
retrieving revision 1.31
diff -u -r1.31 exf.c
--- common/exf.c 12 Nov 2014 16:29:04 -0000 1.31
+++ common/exf.c 12 Nov 2014 18:39:27 -0000
@@ -85,7 +85,7 @@
}
/* Allocate and initialize the FREF structure. */
- CALLOC(sp, frp, FREF *, 1, sizeof(FREF));
+ CALLOC(sp, frp, 1, sizeof(FREF));
if (frp == NULL)
return (NULL);
@@ -152,7 +152,7 @@
* Default recover mail file fd to -1.
* Set initial EXF flag bits.
*/
- CALLOC_RET(sp, ep, EXF *, 1, sizeof(EXF));
+ CALLOC_RET(sp, ep, 1, sizeof(EXF));
ep->c_lno = ep->c_nlines = OOBLNO;
ep->rcv_fd = ep->fcntl_fd = -1;
F_SET(ep, F_FIRSTMODIFY);
@@ -496,7 +496,7 @@
/* If we found it, build a new pathname and discard the old one. */
if (found) {
- MALLOC_RET(sp, p, char *, len + 1);
+ MALLOC_RET(sp, p, len + 1);
memcpy(p, path, len + 1);
free(frp->name);
frp->name = p;
Index: common/key.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/common/key.c,v
retrieving revision 1.13
diff -u -r1.13 key.c
--- common/key.c 12 Nov 2014 04:28:41 -0000 1.13
+++ common/key.c 12 Nov 2014 18:39:27 -0000
@@ -347,8 +347,8 @@
if (total >= gp->i_nelem && v_event_grow(sp, MAX(total, 64)))
return (1);
if (gp->i_cnt)
- MEMMOVE(gp->i_event + TERM_PUSH_SHIFT + nitems,
- gp->i_event + gp->i_next, gp->i_cnt);
+ memmove(gp->i_event + TERM_PUSH_SHIFT + nitems,
+ gp->i_event + gp->i_next, gp->i_cnt * sizeof(EVENT));
gp->i_next = TERM_PUSH_SHIFT;
/* Put the new items into the queue. */
Index: common/main.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/common/main.c,v
retrieving revision 1.23
diff -u -r1.23 main.c
--- common/main.c 12 Nov 2014 04:28:41 -0000 1.23
+++ common/main.c 12 Nov 2014 18:44:01 -0000
@@ -346,15 +346,12 @@
*/
if (*argv != NULL) {
if (sp->frp != NULL) {
- size_t l;
/* Cheat -- we know we have an extra argv slot. */
- l = strlen(sp->frp->name) + 1;
- MALLOC_NOMSG(sp, *--argv, char *, l);
+ *--argv = strdup(sp->frp->name);
if (*argv == NULL) {
v_estr(gp->progname, errno, NULL);
goto err;
}
- (void)strlcpy(*argv, sp->frp->name, l);
}
sp->argv = sp->cargv = argv;
F_SET(sp, SC_ARGNOFREE);
@@ -531,9 +528,6 @@
static int
v_obsolete(char *name, char *argv[])
{
- size_t len;
- char *p;
-
/*
* Translate old style arguments into something getopt will like.
* Make sure it's not text space memory, because ex modifies the
@@ -554,14 +548,8 @@
if (argv[0] == NULL)
goto nomem;
} else {
- p = argv[0];
- len = strlen(argv[0]);
- MALLOC_NOMSG(NULL, argv[0], char *, len + 2);
- if (argv[0] == NULL)
+ if (asprintf(&argv[0], "-c%s", argv[0] + 1) ==
-1)
goto nomem;
- argv[0][0] = '-';
- argv[0][1] = 'c';
- (void)strlcpy(argv[0] + 2, p + 1, len);
}
} else if (argv[0][0] == '-') {
if (argv[0][1] == '\0') {
Index: common/mark.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/common/mark.c,v
retrieving revision 1.9
diff -u -r1.9 mark.c
--- common/mark.c 12 Nov 2014 04:28:41 -0000 1.9
+++ common/mark.c 12 Nov 2014 18:39:27 -0000
@@ -160,7 +160,7 @@
*/
lmp = mark_find(sp, key);
if (lmp == NULL || lmp->name != key) {
- MALLOC_RET(sp, lmt, LMARK *, sizeof(LMARK));
+ MALLOC_RET(sp, lmt, sizeof(LMARK));
if (lmp == NULL) {
LIST_INSERT_HEAD(&sp->ep->marks, lmt, q);
} else
Index: common/mem.h
===================================================================
RCS file: /cvs/src/usr.bin/vi/common/mem.h,v
retrieving revision 1.6
diff -u -r1.6 mem.h
--- common/mem.h 14 Oct 2014 22:23:12 -0000 1.6
+++ common/mem.h 12 Nov 2014 18:39:27 -0000
@@ -14,7 +14,7 @@
/* Increase the size of a malloc'd buffer. Two versions, one that
* returns, one that jumps to an error label.
*/
-#define BINC_GOTO(sp, lp, llen, nlen) {
\
+#define BINC_GOTO(sp, lp, llen, nlen) do {
\
void *L__bincp; \
if ((nlen) > (llen)) { \
if ((L__bincp = binc((sp), (lp), &(llen), (nlen))) \
@@ -26,8 +26,8 @@
*/ \
(lp) = L__bincp; \
} \
-}
-#define BINC_RET(sp, lp, llen, nlen) {
\
+} while (0)
+#define BINC_RET(sp, lp, llen, nlen) do {
\
void *L__bincp; \
if ((nlen) > (llen)) { \
if ((L__bincp = binc((sp), (lp), &(llen), (nlen))) \
@@ -39,14 +39,14 @@
*/ \
(lp) = L__bincp; \
} \
-}
+} while (0)
/*
* Get some temporary space, preferably from the global temporary buffer,
* from a malloc'd buffer otherwise. Two versions, one that returns, one
* that jumps to an error label.
*/
-#define GET_SPACE_GOTO(sp, bp, blen, nlen) {
\
+#define GET_SPACE_GOTO(sp, bp, blen, nlen) do {
\
GS *L__gp = (sp) == NULL ? NULL : (sp)->gp; \
if (L__gp == NULL || F_ISSET(L__gp, G_TMP_INUSE)) { \
(bp) = NULL; \
@@ -58,8 +58,8 @@
(blen) = L__gp->tmp_blen; \
F_SET(L__gp, G_TMP_INUSE); \
} \
-}
-#define GET_SPACE_RET(sp, bp, blen, nlen) {
\
+} while (0)
+#define GET_SPACE_RET(sp, bp, blen, nlen) do {
\
GS *L__gp = (sp) == NULL ? NULL : (sp)->gp; \
if (L__gp == NULL || F_ISSET(L__gp, G_TMP_INUSE)) { \
(bp) = NULL; \
@@ -71,13 +71,13 @@
(blen) = L__gp->tmp_blen; \
F_SET(L__gp, G_TMP_INUSE); \
} \
-}
+} while (0)
/*
* Add space to a GET_SPACE returned buffer. Two versions, one that
* returns, one that jumps to an error label.
*/
-#define ADD_SPACE_GOTO(sp, bp, blen, nlen) {
\
+#define ADD_SPACE_GOTO(sp, bp, blen, nlen) do {
\
GS *L__gp = (sp) == NULL ? NULL : (sp)->gp; \
if (L__gp == NULL || (bp) == L__gp->tmp_bp) { \
F_CLR(L__gp, G_TMP_INUSE); \
@@ -87,8 +87,8 @@
F_SET(L__gp, G_TMP_INUSE); \
} else \
BINC_GOTO((sp), (bp), (blen), (nlen)); \
-}
-#define ADD_SPACE_RET(sp, bp, blen, nlen) {
\
+} while (0)
+#define ADD_SPACE_RET(sp, bp, blen, nlen) do {
\
GS *L__gp = (sp) == NULL ? NULL : (sp)->gp; \
if (L__gp == NULL || (bp) == L__gp->tmp_bp) { \
F_CLR(L__gp, G_TMP_INUSE); \
@@ -98,76 +98,56 @@
F_SET(L__gp, G_TMP_INUSE); \
} else \
BINC_RET((sp), (bp), (blen), (nlen)); \
-}
+} while (0)
/* Free a GET_SPACE returned buffer. */
-#define FREE_SPACE(sp, bp, blen) {
\
+#define FREE_SPACE(sp, bp, blen) do {
\
GS *L__gp = (sp) == NULL ? NULL : (sp)->gp; \
if (L__gp != NULL && (bp) == L__gp->tmp_bp) \
F_CLR(L__gp, G_TMP_INUSE); \
else \
free(bp); \
-}
+} while (0)
/*
- * Malloc a buffer, casting the return pointer. Various versions.
- *
- * !!!
- * The cast should be unnecessary, malloc(3) and friends return void *'s,
- * which is all we need. However, some systems that nvi needs to run on
- * don't do it right yet, resulting in the compiler printing out roughly
- * a million warnings. After awhile, it seemed easier to put the casts
- * in instead of explaining it all the time.
+ * Malloc a buffer. Various versions.
*/
-#define CALLOC(sp, p, cast, nmemb, size) {
\
- if (((p) = (cast)calloc((nmemb), (size))) == NULL) \
+#define CALLOC(sp, p, nmemb, size) do {
\
+ if (((p) = calloc((nmemb), (size))) == NULL) \
msgq((sp), M_SYSERR, NULL); \
-}
-#define CALLOC_GOTO(sp, p, cast, nmemb, size) {
\
- if (((p) = (cast)calloc((nmemb), (size))) == NULL) \
+} while (0)
+#define CALLOC_GOTO(sp, p, nmemb, size) do {
\
+ if (((p) = calloc((nmemb), (size))) == NULL) \
goto alloc_err; \
-}
-#define CALLOC_NOMSG(sp, p, cast, nmemb, size) {
\
- (p) = (cast)calloc((nmemb), (size)); \
-}
-#define CALLOC_RET(sp, p, cast, nmemb, size) {
\
- if (((p) = (cast)calloc((nmemb), (size))) == NULL) { \
+} while (0)
+#define CALLOC_RET(sp, p, nmemb, size) do {
\
+ if (((p) = calloc((nmemb), (size))) == NULL) { \
msgq((sp), M_SYSERR, NULL); \
return (1); \
} \
-}
+} while (0)
-#define MALLOC(sp, p, cast, size) {
\
- if (((p) = (cast)malloc(size)) == NULL) \
+#define MALLOC(sp, p, size) do {
\
+ if (((p) = malloc(size)) == NULL) \
msgq((sp), M_SYSERR, NULL); \
-}
-#define MALLOC_GOTO(sp, p, cast, size) {
\
- if (((p) = (cast)malloc(size)) == NULL) \
+} while (0)
+#define MALLOC_GOTO(sp, p, size) do {
\
+ if (((p) = malloc(size)) == NULL) \
goto alloc_err; \
-}
-#define MALLOC_NOMSG(sp, p, cast, size) {
\
- (p) = (cast)malloc(size); \
-}
-#define MALLOC_RET(sp, p, cast, size) {
\
- if (((p) = (cast)malloc(size)) == NULL) { \
+} while (0)
+#define MALLOC_RET(sp, p, size) do {
\
+ if (((p) = malloc(size)) == NULL) { \
msgq((sp), M_SYSERR, NULL); \
return (1); \
} \
-}
+} while (0)
-#define REALLOC(sp, p, cast, size) {
\
- if (((p) = (cast)(realloc((p), (size)))) == NULL) \
+#define REALLOC(sp, p, size) do {
\
+ if (((p) = (realloc((p), (size)))) == NULL) \
msgq((sp), M_SYSERR, NULL); \
-}
+} while (0)
-#define REALLOCARRAY(sp, p, cast, nelem, size) {
\
- if (((p) = (cast)(reallocarray((p), (nelem), (size)))) == NULL) \
+#define REALLOCARRAY(sp, p, nelem, size) do {
\
+ if (((p) = (reallocarray((p), (nelem), (size)))) == NULL) \
msgq((sp), M_SYSERR, NULL); \
-}
-
-/*
- * Versions of memmove(3) and memset(3) that use the size of the
- * initial pointer to figure out how much memory to manipulate.
- */
-#define MEMMOVE(p, t, len) memmove((p), (t), (len) * sizeof(*(p)))
-#define MEMSET(p, value, len) memset((p), (value), (len) *
sizeof(*(p)))
+} while (0)
Index: common/screen.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/common/screen.c,v
retrieving revision 1.11
diff -u -r1.11 screen.c
--- common/screen.c 12 Nov 2014 04:28:41 -0000 1.11
+++ common/screen.c 12 Nov 2014 18:54:32 -0000
@@ -39,7 +39,7 @@
size_t len;
*spp = NULL;
- CALLOC_RET(orig, sp, SCR *, 1, sizeof(SCR));
+ CALLOC_RET(orig, sp, 1, sizeof(SCR));
*spp = sp;
/* INITIALIZED AT SCREEN CREATE. */
@@ -89,7 +89,7 @@
sp->repl_len = orig->repl_len;
if (orig->newl_len) {
len = orig->newl_len * sizeof(size_t);
- MALLOC(sp, sp->newl, size_t *, len);
+ sp->newl = malloc(len);
if (sp->newl == NULL) {
mem: msgq(orig, M_SYSERR, NULL);
goto err;
Index: common/seq.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/common/seq.c,v
retrieving revision 1.9
diff -u -r1.9 seq.c
--- common/seq.c 12 Nov 2014 04:28:41 -0000 1.9
+++ common/seq.c 12 Nov 2014 18:39:27 -0000
@@ -65,7 +65,7 @@
}
/* Allocate and initialize SEQ structure. */
- CALLOC(sp, qp, SEQ *, 1, sizeof(SEQ));
+ CALLOC(sp, qp, 1, sizeof(SEQ));
if (qp == NULL) {
sv_errno = errno;
goto mem1;
Index: common/util.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/common/util.c,v
retrieving revision 1.9
diff -u -r1.9 util.c
--- common/util.c 12 Nov 2014 04:28:41 -0000 1.9
+++ common/util.c 12 Nov 2014 18:39:27 -0000
@@ -40,7 +40,7 @@
return (bp);
csize = *bsizep + MAX(min, 256);
- REALLOC(sp, bp, void *, csize);
+ REALLOC(sp, bp, csize);
if (bp == NULL) {
/*
@@ -121,7 +121,7 @@
{
CHAR_T *copy;
- MALLOC(sp, copy, CHAR_T *, len + 1);
+ MALLOC(sp, copy, len + 1);
if (copy == NULL)
return (NULL);
memcpy(copy, str, len * sizeof(CHAR_T));
Index: ex/ex_args.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/ex/ex_args.c,v
retrieving revision 1.10
diff -u -r1.10 ex_args.c
--- ex/ex_args.c 12 Nov 2014 04:28:41 -0000 1.10
+++ ex/ex_args.c 12 Nov 2014 18:39:27 -0000
@@ -81,8 +81,7 @@
sp->cargv = NULL;
/* Create a new list. */
- CALLOC_RET(sp,
- sp->argv, char **, cmdp->argc + 1, sizeof(char *));
+ CALLOC_RET(sp, sp->argv, cmdp->argc + 1, sizeof(char *));
for (ap = sp->argv,
argv = cmdp->argv; argv[0]->len != 0; ++ap, ++argv)
if ((*ap =
@@ -292,7 +291,7 @@
char **ap, **s_argv;
argc = cmdp == NULL ? 1 : cmdp->argc;
- CALLOC(sp, s_argv, char **, argc + 1, sizeof(char *));
+ CALLOC(sp, s_argv, argc + 1, sizeof(char *));
if ((ap = s_argv) == NULL)
return (NULL);
Index: ex/ex_argv.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/ex/ex_argv.c,v
retrieving revision 1.16
diff -u -r1.16 ex_argv.c
--- ex/ex_argv.c 12 Nov 2014 16:29:04 -0000 1.16
+++ ex/ex_argv.c 12 Nov 2014 18:39:27 -0000
@@ -404,7 +404,7 @@
off = exp->argsoff;
if (exp->argscnt == 0 || off + 2 >= exp->argscnt - 1) {
cnt = exp->argscnt + INCREMENT;
- REALLOCARRAY(sp, exp->args, ARGS **, cnt, sizeof(ARGS *));
+ REALLOCARRAY(sp, exp->args, cnt, sizeof(ARGS *));
if (exp->args == NULL) {
(void)argv_free(sp);
goto mem;
@@ -415,7 +415,7 @@
/* First argument. */
if (exp->args[off] == NULL) {
- CALLOC(sp, exp->args[off], ARGS *, 1, sizeof(ARGS));
+ CALLOC(sp, exp->args[off], 1, sizeof(ARGS));
if (exp->args[off] == NULL)
goto mem;
}
@@ -425,7 +425,7 @@
ap->len = 0;
if (ap->blen < len + 1) {
ap->blen = len + 1;
- REALLOCARRAY(sp, ap->bp, CHAR_T *, ap->blen, sizeof(CHAR_T));
+ REALLOCARRAY(sp, ap->bp, ap->blen, sizeof(CHAR_T));
if (ap->bp == NULL) {
ap->bp = NULL;
ap->blen = 0;
@@ -438,7 +438,7 @@
/* Second argument. */
if (exp->args[++off] == NULL) {
- CALLOC(sp, exp->args[off], ARGS *, 1, sizeof(ARGS));
+ CALLOC(sp, exp->args[off], 1, sizeof(ARGS));
if (exp->args[off] == NULL)
goto mem;
}
Index: ex/ex_at.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/ex/ex_at.c,v
retrieving revision 1.11
diff -u -r1.11 ex_at.c
--- ex/ex_at.c 12 Nov 2014 04:28:41 -0000 1.11
+++ ex/ex_at.c 12 Nov 2014 18:39:27 -0000
@@ -79,9 +79,9 @@
* the range, continue to execute after a file/screen switch, which
* means @ buffers are still useful in a multi-screen environment.
*/
- CALLOC_RET(sp, ecp, EXCMD *, 1, sizeof(EXCMD));
+ CALLOC_RET(sp, ecp, 1, sizeof(EXCMD));
TAILQ_INIT(&ecp->rq);
- CALLOC_RET(sp, rp, RANGE *, 1, sizeof(RANGE));
+ CALLOC_RET(sp, rp, 1, sizeof(RANGE));
rp->start = cmdp->addr1.lno;
if (F_ISSET(cmdp, E_ADDR_DEF)) {
rp->stop = rp->start;
@@ -105,7 +105,7 @@
len += tp->len + 1;
}
- MALLOC_RET(sp, ecp->cp, char *, len * 2);
+ MALLOC_RET(sp, ecp->cp, len * 2);
ecp->o_cp = ecp->cp;
ecp->o_clen = len;
ecp->cp[len] = '\0';
Index: ex/ex_cscope.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/ex/ex_cscope.c,v
retrieving revision 1.22
diff -u -r1.22 ex_cscope.c
--- ex/ex_cscope.c 12 Nov 2014 16:29:04 -0000 1.22
+++ ex/ex_cscope.c 12 Nov 2014 18:39:27 -0000
@@ -241,7 +241,7 @@
/* Allocate a cscope connection structure and initialize its fields. */
len = strlen(dname);
- CALLOC_RET(sp, csc, CSC *, 1, sizeof(CSC) + len);
+ CALLOC_RET(sp, csc, 1, sizeof(CSC) + len);
csc->dname = csc->buf;
csc->dlen = len;
memcpy(csc->dname, dname, len);
@@ -301,7 +301,7 @@
if (stat(buf, &sb) == 0) {
/* Read in the CSCOPE_PATHS file. */
len = sb.st_size;
- MALLOC_RET(sp, csc->pbuf, char *, len + 1);
+ MALLOC_RET(sp, csc->pbuf, len + 1);
if ((fd = open(buf, O_RDONLY, 0)) < 0 ||
read(fd, csc->pbuf, len) != len) {
msgq_str(sp, M_SYSERR, buf, "%s");
@@ -318,8 +318,7 @@
++nentries;
/* Build an array of pointers to the paths. */
- CALLOC_GOTO(sp,
- csc->paths, char **, nentries + 1, sizeof(char **));
+ CALLOC_GOTO(sp, csc->paths, nentries + 1, sizeof(char **));
for (pathp = csc->paths, p = strtok(csc->pbuf, ":");
p != NULL; p = strtok(NULL, ":"))
*pathp++ = p;
@@ -334,7 +333,7 @@
msgq(sp, M_SYSERR, NULL);
return (1);
}
- CALLOC_GOTO(sp, csc->paths, char **, 2, sizeof(char *));
+ CALLOC_GOTO(sp, csc->paths, 2, sizeof(char *));
csc->paths[0] = csc->pbuf;
return (0);
@@ -445,11 +444,11 @@
rtqp = NULL;
if (TAILQ_EMPTY(&exp->tq)) {
/* Initialize the `local context' tag queue structure. */
- CALLOC_GOTO(sp, rtqp, TAGQ *, 1, sizeof(TAGQ));
+ CALLOC_GOTO(sp, rtqp, 1, sizeof(TAGQ));
TAILQ_INIT(&rtqp->tagq);
/* Initialize and link in its tag structure. */
- CALLOC_GOTO(sp, rtp, TAG *, 1, sizeof(TAG));
+ CALLOC_GOTO(sp, rtp, 1, sizeof(TAG));
TAILQ_INSERT_HEAD(&rtqp->tagq, rtp, q);
rtqp->current = rtp;
}
@@ -612,7 +611,7 @@
tlen = strlen(p);
/* Allocate and initialize the TAGQ structure. */
- CALLOC(sp, tqp, TAGQ *, 1, sizeof(TAGQ) + tlen + 3);
+ CALLOC(sp, tqp, 1, sizeof(TAGQ) + tlen + 3);
if (tqp == NULL)
return (NULL);
TAILQ_INIT(&tqp->tagq);
@@ -714,7 +713,7 @@
* length cscope information that follows it.
*/
CALLOC_RET(sp, tp,
- TAG *, 1, sizeof(TAG) + dlen + 2 + nlen + 1 + slen + 1);
+ 1, sizeof(TAG) + dlen + 2 + nlen + 1 + slen + 1);
tp->fname = tp->buf;
if (dlen != 0) {
memcpy(tp->fname, dname, dlen);
Index: ex/ex_global.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/ex/ex_global.c,v
retrieving revision 1.13
diff -u -r1.13 ex_global.c
--- ex/ex_global.c 12 Nov 2014 04:28:41 -0000 1.13
+++ ex/ex_global.c 12 Nov 2014 18:39:27 -0000
@@ -155,7 +155,7 @@
return (1);
/* Get an EXCMD structure. */
- CALLOC_RET(sp, ecp, EXCMD *, 1, sizeof(EXCMD));
+ CALLOC_RET(sp, ecp, 1, sizeof(EXCMD));
TAILQ_INIT(&ecp->rq);
/*
@@ -170,7 +170,7 @@
len = 1;
}
- MALLOC_RET(sp, ecp->cp, char *, len * 2);
+ CALLOC_RET(sp, ecp->cp, 2, len);
ecp->o_cp = ecp->cp;
ecp->o_clen = len;
memcpy(ecp->cp + len, p, len);
@@ -231,7 +231,7 @@
}
/* Allocate a new range, and append it to the list. */
- CALLOC(sp, rp, RANGE *, 1, sizeof(RANGE));
+ CALLOC(sp, rp, 1, sizeof(RANGE));
if (rp == NULL)
return (1);
rp->start = rp->stop = start;
@@ -297,7 +297,7 @@
free(rp);
}
} else {
- CALLOC_RET(sp, nrp, RANGE *, 1, sizeof(RANGE));
+ CALLOC_RET(sp, nrp, 1, sizeof(RANGE));
nrp->start = lno + 1;
nrp->stop = rp->stop + 1;
rp->stop = lno - 1;
Index: ex/ex_init.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/ex/ex_init.c,v
retrieving revision 1.13
diff -u -r1.13 ex_init.c
--- ex/ex_init.c 12 Nov 2014 16:29:04 -0000 1.13
+++ ex/ex_init.c 12 Nov 2014 18:39:27 -0000
@@ -45,7 +45,7 @@
EX_PRIVATE *oexp, *nexp;
/* Create the private ex structure. */
- CALLOC_RET(orig, nexp, EX_PRIVATE *, 1, sizeof(EX_PRIVATE));
+ CALLOC_RET(orig, nexp, 1, sizeof(EX_PRIVATE));
sp->ex_private = nexp;
/* Initialize queues. */
@@ -274,7 +274,7 @@
gp = sp->gp;
if (EXCMD_RUNNING(gp)) {
- CALLOC_RET(sp, ecp, EXCMD *, 1, sizeof(EXCMD));
+ CALLOC_RET(sp, ecp, 1, sizeof(EXCMD));
LIST_INSERT_HEAD(&gp->ecq, ecp, q);
} else
ecp = &gp->excmd;
Index: ex/ex_script.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/ex/ex_script.c,v
retrieving revision 1.21
diff -u -r1.21 ex_script.c
--- ex/ex_script.c 12 Nov 2014 16:29:04 -0000 1.21
+++ ex/ex_script.c 12 Nov 2014 18:39:27 -0000
@@ -88,7 +88,7 @@
if (opts_empty(sp, O_SHELL, 0))
return (1);
- MALLOC_RET(sp, sc, SCRIPT *, sizeof(SCRIPT));
+ MALLOC_RET(sp, sc, sizeof(SCRIPT));
sp->script = sc;
sc->sh_prompt = NULL;
sc->sh_prompt_len = 0;
@@ -360,11 +360,7 @@
TAILQ_FOREACH(tsp, &gp->dq, q)
if (F_ISSET(sp, SC_SCRIPT))
nfds++;
- pfd = calloc(nfds, sizeof(struct pollfd));
- if (pfd == NULL) {
- msgq(sp, M_SYSERR, "malloc");
- return (1);
- }
+ CALLOC_RET(sp, pfd, nfds, sizeof(struct pollfd));
/* Setup events bitmasks. */
pfd[0].fd = STDIN_FILENO;
@@ -431,11 +427,7 @@
nfds++;
if (nfds == 0)
return (0);
- pfd = calloc(nfds, sizeof(struct pollfd));
- if (pfd == NULL) {
- msgq(sp, M_SYSERR, "malloc");
- return (1);
- }
+ CALLOC_RET(sp, pfd, nfds, sizeof(struct pollfd));
/* Setup events bitmasks. */
nfds = 0;
@@ -572,7 +564,7 @@
sc = sp->script;
if (sc->sh_prompt)
free(sc->sh_prompt);
- MALLOC(sp, sc->sh_prompt, char *, len + 1);
+ MALLOC(sp, sc->sh_prompt, len + 1);
if (sc->sh_prompt == NULL) {
sscr_end(sp);
return (1);
Index: ex/ex_source.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/ex/ex_source.c,v
retrieving revision 1.9
diff -u -r1.9 ex_source.c
--- ex/ex_source.c 12 Nov 2014 04:28:41 -0000 1.9
+++ ex/ex_source.c 12 Nov 2014 18:39:27 -0000
@@ -58,7 +58,7 @@
goto err;
}
- MALLOC(sp, bp, char *, (size_t)sb.st_size + 1);
+ MALLOC(sp, bp, (size_t)sb.st_size + 1);
if (bp == NULL) {
(void)close(fd);
return (1);
Index: ex/ex_subst.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/ex/ex_subst.c,v
retrieving revision 1.21
diff -u -r1.21 ex_subst.c
--- ex/ex_subst.c 12 Nov 2014 04:28:41 -0000 1.21
+++ ex/ex_subst.c 12 Nov 2014 18:39:27 -0000
@@ -301,7 +301,7 @@
#define NEEDNEWLINE(sp) {
\
if ((sp)->newl_len == (sp)->newl_cnt) { \
(sp)->newl_len += 25; \
- REALLOCARRAY((sp), (sp)->newl, size_t *, \
+ REALLOCARRAY((sp), (sp)->newl, \
(sp)->newl_len, sizeof(size_t)); \
if ((sp)->newl == NULL) { \
(sp)->newl_len = 0; \
@@ -313,7 +313,7 @@
#define BUILD(sp, l, len) {
\
if (lbclen + (len) > lblen) { \
lblen += MAX(lbclen + (len), 256); \
- REALLOC((sp), lb, char *, lblen); \
+ REALLOC((sp), lb, lblen); \
if (lb == NULL) { \
lbclen = 0; \
return (1); \
@@ -326,7 +326,7 @@
#define NEEDSP(sp, len, pnt) {
\
if (lbclen + (len) > lblen) { \
lblen += MAX(lbclen + (len), 256); \
- REALLOC((sp), lb, char *, lblen); \
+ REALLOC((sp), lb, lblen); \
if (lb == NULL) { \
lbclen = 0; \
return (1); \
@@ -737,7 +737,7 @@
goto err;
if (db_get(sp, lno, DBG_FATAL, &s, &llen))
goto err;
- ADD_SPACE_RET(sp, bp, blen, llen)
+ ADD_SPACE_RET(sp, bp, blen, llen);
memcpy(bp, s, llen);
s = bp;
len = llen - offset;
@@ -949,7 +949,7 @@
* Regcomp isn't 8-bit clean, so the pattern is nul-terminated
* for now. There's just no other solution.
*/
- MALLOC(sp, *ptrnp, char *, plen + 1);
+ MALLOC(sp, *ptrnp, plen + 1);
if (*ptrnp != NULL) {
memcpy(*ptrnp, ptrn, plen);
(*ptrnp)[plen] = '\0';
Index: ex/ex_tag.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/ex/ex_tag.c,v
retrieving revision 1.20
diff -u -r1.20 ex_tag.c
--- ex/ex_tag.c 12 Nov 2014 16:29:04 -0000 1.20
+++ ex/ex_tag.c 12 Nov 2014 18:39:27 -0000
@@ -138,11 +138,11 @@
rtqp = NULL;
if (TAILQ_EMPTY(&exp->tq)) {
/* Initialize the `local context' tag queue structure. */
- CALLOC_GOTO(sp, rtqp, TAGQ *, 1, sizeof(TAGQ));
+ CALLOC_GOTO(sp, rtqp, 1, sizeof(TAGQ));
TAILQ_INIT(&rtqp->tagq);
/* Initialize and link in its tag structure. */
- CALLOC_GOTO(sp, rtp, TAG *, 1, sizeof(TAG));
+ CALLOC_GOTO(sp, rtp, 1, sizeof(TAG));
TAILQ_INSERT_HEAD(&rtqp->tagq, rtp, q);
rtqp->current = rtp;
}
@@ -666,7 +666,7 @@
{
TAGF *tfp;
- MALLOC_RET(sp, tfp, TAGF *, sizeof(TAGF));
+ MALLOC_RET(sp, tfp, sizeof(TAGF));
*tfp = *otfp;
/* XXX: Allocate as part of the TAGF structure!!! */
@@ -692,7 +692,7 @@
len = sizeof(TAGQ);
if (otqp->tag != NULL)
len += otqp->tlen + 1;
- MALLOC_RET(sp, tqp, TAGQ *, len);
+ MALLOC_RET(sp, tqp, len);
memcpy(tqp, otqp, len);
TAILQ_INIT(&tqp->tagq);
@@ -719,7 +719,7 @@
len += otp->fnlen + 1;
if (otp->search != NULL)
len += otp->slen + 1;
- MALLOC_RET(sp, tp, TAG *, len);
+ MALLOC_RET(sp, tp, len);
memcpy(tp, otp, len);
if (otp->fname != NULL)
@@ -828,8 +828,8 @@
for (p = t = str;; ++p) {
if (*p == '\0' || isblank(*p)) {
if ((len = p - t) > 1) {
- MALLOC_RET(sp, tfp, TAGF *, sizeof(TAGF));
- MALLOC(sp, tfp->name, char *, len + 1);
+ MALLOC_RET(sp, tfp, sizeof(TAGF));
+ MALLOC(sp, tfp->name, len + 1);
if (tfp->name == NULL) {
free(tfp);
return (1);
@@ -948,7 +948,7 @@
/* Allocate and initialize the tag queue structure. */
len = strlen(tag);
- CALLOC_GOTO(sp, tqp, TAGQ *, 1, sizeof(TAGQ) + len + 1);
+ CALLOC_GOTO(sp, tqp, 1, sizeof(TAGQ) + len + 1);
TAILQ_INIT(&tqp->tagq);
tqp->tag = tqp->buf;
memcpy(tqp->tag, tag, (tqp->tlen = len) + 1);
@@ -1094,7 +1094,7 @@
ctag_file(sp, tfp, name, &dname, &dlen);
CALLOC_GOTO(sp, tp,
- TAG *, 1, sizeof(TAG) + dlen + 2 + nlen + 1 + slen + 1);
+ 1, sizeof(TAG) + dlen + 2 + nlen + 1 + slen + 1);
tp->fname = tp->buf;
if (dlen != 0) {
memcpy(tp->fname, dname, dlen);
Index: perl_api/perlsfio.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/perl_api/perlsfio.c,v
retrieving revision 1.5
diff -u -r1.5 perlsfio.c
--- perl_api/perlsfio.c 12 Nov 2014 04:28:41 -0000 1.5
+++ perl_api/perlsfio.c 12 Nov 2014 18:39:27 -0000
@@ -62,7 +62,7 @@
{
Sfdisc_t* disc;
- MALLOC(scrp, disc, Sfdisc_t*, sizeof(Sfdisc_t));
+ MALLOC(scrp, disc, sizeof(Sfdisc_t));
if (!disc) return disc;
disc->readf = (Sfread_f)NULL;
Index: vi/v_init.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/vi/v_init.c,v
retrieving revision 1.6
diff -u -r1.6 v_init.c
--- vi/v_init.c 12 Nov 2014 04:28:41 -0000 1.6
+++ vi/v_init.c 12 Nov 2014 18:39:27 -0000
@@ -37,7 +37,7 @@
VI_PRIVATE *ovip, *nvip;
/* Create the private vi structure. */
- CALLOC_RET(orig, nvip, VI_PRIVATE *, 1, sizeof(VI_PRIVATE));
+ CALLOC_RET(orig, nvip, 1, sizeof(VI_PRIVATE));
sp->vi_private = nvip;
/* Invalidate the line size cache. */
@@ -50,7 +50,7 @@
/* User can replay the last input, but nothing else. */
if (ovip->rep_len != 0) {
- MALLOC_RET(orig, nvip->rep, EVENT *, ovip->rep_len);
+ MALLOC_RET(orig, nvip->rep, ovip->rep_len);
memmove(nvip->rep, ovip->rep, ovip->rep_len);
nvip->rep_len = ovip->rep_len;
}
Index: vi/v_paragraph.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/vi/v_paragraph.c,v
retrieving revision 1.7
diff -u -r1.7 v_paragraph.c
--- vi/v_paragraph.c 12 Nov 2014 04:28:41 -0000 1.7
+++ vi/v_paragraph.c 12 Nov 2014 18:39:27 -0000
@@ -323,7 +323,7 @@
if (p_len == 0 && s_len == 0)
return (0);
- MALLOC_RET(sp, p, char *, p_len + s_len + 1);
+ MALLOC_RET(sp, p, p_len + s_len + 1);
vip = VIP(sp);
if (vip->ps != NULL)
Index: vi/vi.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/vi/vi.c,v
retrieving revision 1.15
diff -u -r1.15 vi.c
--- vi/vi.c 12 Nov 2014 04:28:41 -0000 1.15
+++ vi/vi.c 12 Nov 2014 18:39:27 -0000
@@ -962,7 +962,7 @@
sp->woff = 0;
/* Create a screen map. */
- CALLOC_RET(sp, HMAP, SMAP *, SIZE_HMAP(sp), sizeof(SMAP));
+ CALLOC_RET(sp, HMAP, SIZE_HMAP(sp), sizeof(SMAP));
TMAP = HMAP + (sp->t_rows - 1);
HMAP->lno = sp->lno;
HMAP->coff = 0;
Index: vi/vs_msg.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/vi/vs_msg.c,v
retrieving revision 1.13
diff -u -r1.13 vs_msg.c
--- vi/vs_msg.c 12 Nov 2014 04:28:41 -0000 1.13
+++ vi/vs_msg.c 12 Nov 2014 18:39:27 -0000
@@ -876,8 +876,8 @@
* allocate memory here, we're genuinely screwed, dump the message
* to stderr in the (probably) vain hope that someone will see it.
*/
- CALLOC_GOTO(sp, mp_n, MSGS *, 1, sizeof(MSGS));
- MALLOC_GOTO(sp, mp_n->buf, char *, len);
+ CALLOC_GOTO(sp, mp_n, 1, sizeof(MSGS));
+ MALLOC_GOTO(sp, mp_n->buf, len);
memmove(mp_n->buf, p, len);
mp_n->len = len;
Index: vi/vs_split.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/vi/vs_split.c,v
retrieving revision 1.12
diff -u -r1.12 vs_split.c
--- vi/vs_split.c 12 Nov 2014 04:28:41 -0000 1.12
+++ vi/vs_split.c 12 Nov 2014 18:39:27 -0000
@@ -59,7 +59,7 @@
half = 6;
/* Get a new screen map. */
- CALLOC(sp, _HMAP(new), SMAP *, SIZE_HMAP(sp), sizeof(SMAP));
+ CALLOC(sp, _HMAP(new), SIZE_HMAP(sp), sizeof(SMAP));
if (_HMAP(new) == NULL)
return (1);
_HMAP(new)->lno = sp->lno;
@@ -422,7 +422,7 @@
nsp->defscroll = nsp->t_maxrows / 2;
/* Allocate a new screen map. */
- CALLOC_RET(nsp, _HMAP(nsp), SMAP *, SIZE_HMAP(nsp), sizeof(SMAP));
+ CALLOC_RET(nsp, _HMAP(nsp), SIZE_HMAP(nsp), sizeof(SMAP));
_TMAP(nsp) = _HMAP(nsp) + (nsp->t_rows - 1);
/* Fill the map. */
