It's definitely time for these to go.
The allocation macros would probably be better as functions (e.g.
xmalloc) these days, too. I'll save that diff for another time, though.
No binary change.
ok?
Index: cl/cl_main.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/cl/cl_main.c,v
retrieving revision 1.26
diff -u -p -r1.26 cl_main.c
--- cl/cl_main.c 29 Mar 2015 01:04:23 -0000 1.26
+++ cl/cl_main.c 7 Dec 2015 19:49:11 -0000
@@ -151,7 +151,7 @@ gs_init(char *name)
name = p + 1;
/* Allocate the global structure. */
- CALLOC_NOMSG(NULL, gp, GS *, 1, sizeof(GS));
+ CALLOC_NOMSG(NULL, gp, 1, sizeof(GS));
if (gp == NULL)
perr(name, NULL);
@@ -171,7 +171,7 @@ cl_init(GS *gp)
int fd;
/* Allocate the CL private structure. */
- CALLOC_NOMSG(NULL, clp, CL_PRIVATE *, 1, sizeof(CL_PRIVATE));
+ CALLOC_NOMSG(NULL, clp, 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.23
diff -u -p -r1.23 cl_screen.c
--- cl/cl_screen.c 10 Apr 2015 18:05:51 -0000 1.23
+++ cl/cl_screen.c 7 Dec 2015 19:49:11 -0000
@@ -502,7 +502,7 @@ cl_getcap(SCR *sp, char *name, char **el
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/cut.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/common/cut.c,v
retrieving revision 1.13
diff -u -p -r1.13 cut.c
--- common/cut.c 12 Nov 2014 04:28:41 -0000 1.13
+++ common/cut.c 7 Dec 2015 19:49:11 -0000
@@ -119,7 +119,7 @@ copyloop:
* 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_init(SCR *sp, const char *p, size_t
{
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.38
diff -u -p -r1.38 exf.c
--- common/exf.c 19 Nov 2015 07:53:31 -0000 1.38
+++ common/exf.c 7 Dec 2015 19:49:11 -0000
@@ -86,7 +86,7 @@ file_add(SCR *sp, CHAR_T *name)
}
/* Allocate and initialize the FREF structure. */
- CALLOC(sp, frp, FREF *, 1, sizeof(FREF));
+ CALLOC(sp, frp, 1, sizeof(FREF));
if (frp == NULL)
return (NULL);
@@ -153,7 +153,7 @@ file_init(SCR *sp, FREF *frp, char *rcv_
* 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);
@@ -495,7 +495,7 @@ file_spath(SCR *sp, FREF *frp, struct st
/* 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/main.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/common/main.c,v
retrieving revision 1.30
diff -u -p -r1.30 main.c
--- common/main.c 20 Nov 2015 04:12:19 -0000 1.30
+++ common/main.c 7 Dec 2015 19:49:11 -0000
@@ -360,7 +360,7 @@ editor(GS *gp, int argc, char *argv[])
size_t l;
/* Cheat -- we know we have an extra argv slot. */
l = strlen(sp->frp->name) + 1;
- MALLOC_NOMSG(sp, *--argv, char *, l);
+ MALLOC_NOMSG(sp, *--argv, l);
if (*argv == NULL) {
v_estr(gp->progname, errno, NULL);
goto err;
@@ -563,7 +563,7 @@ v_obsolete(char *name, char *argv[])
} else {
p = argv[0];
len = strlen(argv[0]);
- MALLOC_NOMSG(NULL, argv[0], char *, len + 2);
+ MALLOC_NOMSG(NULL, argv[0], len + 2);
if (argv[0] == NULL)
goto nomem;
argv[0][0] = '-';
Index: common/mark.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/common/mark.c,v
retrieving revision 1.9
diff -u -p -r1.9 mark.c
--- common/mark.c 12 Nov 2014 04:28:41 -0000 1.9
+++ common/mark.c 7 Dec 2015 19:49:11 -0000
@@ -160,7 +160,7 @@ mark_set(SCR *sp, ARG_CHAR_T key, MARK *
*/
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 -p -r1.6 mem.h
--- common/mem.h 14 Oct 2014 22:23:12 -0000 1.6
+++ common/mem.h 7 Dec 2015 19:49:11 -0000
@@ -111,57 +111,50 @@
/*
* 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.
*/
-#define CALLOC(sp, p, cast, nmemb, size) {
\
- if (((p) = (cast)calloc((nmemb), (size))) == NULL) \
+#define CALLOC(sp, p, nmemb, size) {
\
+ 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) \
+#define CALLOC_GOTO(sp, p, nmemb, size) {
\
+ if (((p) = calloc((nmemb), (size))) == NULL) \
goto alloc_err; \
}
-#define CALLOC_NOMSG(sp, p, cast, nmemb, size) {
\
- (p) = (cast)calloc((nmemb), (size)); \
+#define CALLOC_NOMSG(sp, p, nmemb, size) {
\
+ (p) = calloc((nmemb), (size)); \
}
-#define CALLOC_RET(sp, p, cast, nmemb, size) {
\
- if (((p) = (cast)calloc((nmemb), (size))) == NULL) { \
+#define CALLOC_RET(sp, p, nmemb, size) {
\
+ if (((p) = calloc((nmemb), (size))) == NULL) { \
msgq((sp), M_SYSERR, NULL); \
return (1); \
} \
}
-#define MALLOC(sp, p, cast, size) {
\
- if (((p) = (cast)malloc(size)) == NULL) \
+#define MALLOC(sp, p, size) {
\
+ if (((p) = malloc(size)) == NULL) \
msgq((sp), M_SYSERR, NULL); \
}
-#define MALLOC_GOTO(sp, p, cast, size) {
\
- if (((p) = (cast)malloc(size)) == NULL) \
+#define MALLOC_GOTO(sp, p, size) {
\
+ if (((p) = malloc(size)) == NULL) \
goto alloc_err; \
}
-#define MALLOC_NOMSG(sp, p, cast, size) {
\
- (p) = (cast)malloc(size); \
+#define MALLOC_NOMSG(sp, p, size) {
\
+ (p) = malloc(size); \
}
-#define MALLOC_RET(sp, p, cast, size) {
\
- if (((p) = (cast)malloc(size)) == NULL) { \
+#define MALLOC_RET(sp, p, size) {
\
+ if (((p) = malloc(size)) == NULL) { \
msgq((sp), M_SYSERR, NULL); \
return (1); \
} \
}
-#define REALLOC(sp, p, cast, size) {
\
- if (((p) = (cast)(realloc((p), (size)))) == NULL) \
+#define REALLOC(sp, p, size) {
\
+ if (((p) = (realloc((p), (size)))) == NULL) \
msgq((sp), M_SYSERR, NULL); \
}
-#define REALLOCARRAY(sp, p, cast, nelem, size) {
\
- if (((p) = (cast)(reallocarray((p), (nelem), (size)))) == NULL) \
+#define REALLOCARRAY(sp, p, nelem, size) {
\
+ if (((p) = (reallocarray((p), (nelem), (size)))) == NULL) \
msgq((sp), M_SYSERR, NULL); \
}
Index: common/screen.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/common/screen.c,v
retrieving revision 1.12
diff -u -p -r1.12 screen.c
--- common/screen.c 20 Nov 2014 08:50:53 -0000 1.12
+++ common/screen.c 7 Dec 2015 19:49:11 -0000
@@ -39,7 +39,7 @@ screen_init(GS *gp, SCR *orig, SCR **spp
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 @@ screen_init(GS *gp, SCR *orig, SCR **spp
sp->repl_len = orig->repl_len;
if (orig->newl_len) {
len = orig->newl_len * sizeof(size_t);
- MALLOC(sp, sp->newl, size_t *, len);
+ MALLOC(sp, sp->newl, 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.10
diff -u -p -r1.10 seq.c
--- common/seq.c 16 Jan 2015 06:40:14 -0000 1.10
+++ common/seq.c 7 Dec 2015 19:49:11 -0000
@@ -66,7 +66,7 @@ seq_set(SCR *sp, CHAR_T *name, size_t nl
}
/* 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.11
diff -u -p -r1.11 util.c
--- common/util.c 28 Mar 2015 12:54:37 -0000 1.11
+++ common/util.c 7 Dec 2015 19:49:12 -0000
@@ -42,7 +42,7 @@ binc(SCR *sp, void *bp, size_t *bsizep,
return (bp);
csize = *bsizep + MAXIMUM(min, 256);
- REALLOC(sp, bp, void *, csize);
+ REALLOC(sp, bp, csize);
if (bp == NULL) {
/*
@@ -123,7 +123,7 @@ v_strdup(SCR *sp, const CHAR_T *str, siz
{
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 -p -r1.10 ex_args.c
--- ex/ex_args.c 12 Nov 2014 04:28:41 -0000 1.10
+++ ex/ex_args.c 7 Dec 2015 19:49:12 -0000
@@ -82,7 +82,7 @@ ex_next(SCR *sp, EXCMD *cmdp)
/* Create a new list. */
CALLOC_RET(sp,
- sp->argv, char **, cmdp->argc + 1, sizeof(char *));
+ sp->argv, cmdp->argc + 1, sizeof(char *));
for (ap = sp->argv,
argv = cmdp->argv; argv[0]->len != 0; ++ap, ++argv)
if ((*ap =
@@ -292,7 +292,7 @@ ex_buildargv(SCR *sp, EXCMD *cmdp, char
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 -p -r1.16 ex_argv.c
--- ex/ex_argv.c 12 Nov 2014 16:29:04 -0000 1.16
+++ ex/ex_argv.c 7 Dec 2015 19:49:12 -0000
@@ -404,7 +404,7 @@ argv_alloc(SCR *sp, size_t len)
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 @@ argv_alloc(SCR *sp, size_t len)
/* 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 @@ argv_alloc(SCR *sp, size_t len)
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 @@ mem: msgq(sp, M_SYSERR, NULL);
/* 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 -p -r1.11 ex_at.c
--- ex/ex_at.c 12 Nov 2014 04:28:41 -0000 1.11
+++ ex/ex_at.c 7 Dec 2015 19:49:12 -0000
@@ -79,9 +79,9 @@ ex_at(SCR *sp, EXCMD *cmdp)
* 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 @@ ex_at(SCR *sp, EXCMD *cmdp)
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_global.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/ex/ex_global.c,v
retrieving revision 1.13
diff -u -p -r1.13 ex_global.c
--- ex/ex_global.c 12 Nov 2014 04:28:41 -0000 1.13
+++ ex/ex_global.c 7 Dec 2015 19:49:12 -0000
@@ -155,7 +155,7 @@ usage: ex_emsg(sp, cmdp->cmd->usage, EX
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 @@ usage: ex_emsg(sp, cmdp->cmd->usage, EX
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;
memcpy(ecp->cp + len, p, len);
@@ -231,7 +231,7 @@ usage: ex_emsg(sp, cmdp->cmd->usage, EX
}
/* 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 @@ ex_g_insdel(SCR *sp, lnop_t op, recno_t
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.15
diff -u -p -r1.15 ex_init.c
--- ex/ex_init.c 19 Nov 2015 07:53:31 -0000 1.15
+++ ex/ex_init.c 7 Dec 2015 19:49:12 -0000
@@ -44,7 +44,7 @@ ex_screen_copy(SCR *orig, SCR *sp)
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. */
@@ -272,7 +272,7 @@ ex_run_str(SCR *sp, char *name, char *st
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 -p -r1.21 ex_script.c
--- ex/ex_script.c 12 Nov 2014 16:29:04 -0000 1.21
+++ ex/ex_script.c 7 Dec 2015 19:49:12 -0000
@@ -88,7 +88,7 @@ sscr_init(SCR *sp)
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;
@@ -572,7 +572,7 @@ sscr_setprompt(SCR *sp, char *buf, size_
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 -p -r1.9 ex_source.c
--- ex/ex_source.c 12 Nov 2014 04:28:41 -0000 1.9
+++ ex/ex_source.c 7 Dec 2015 19:49:12 -0000
@@ -58,7 +58,7 @@ ex_sourcefd(SCR *sp, EXCMD *cmdp, int fd
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.23
diff -u -p -r1.23 ex_subst.c
--- ex/ex_subst.c 19 Nov 2015 07:53:31 -0000 1.23
+++ ex/ex_subst.c 7 Dec 2015 19:49:12 -0000
@@ -301,7 +301,7 @@ ex_subtilde(SCR *sp, EXCMD *cmdp)
#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 @@ ex_subtilde(SCR *sp, EXCMD *cmdp)
#define BUILD(sp, l, len) {
\
if (lbclen + (len) > lblen) { \
lblen += MAXIMUM(lbclen + (len), 256); \
- REALLOC((sp), lb, char *, lblen); \
+ REALLOC((sp), lb, lblen); \
if (lb == NULL) { \
lbclen = 0; \
return (1); \
@@ -326,7 +326,7 @@ ex_subtilde(SCR *sp, EXCMD *cmdp)
#define NEEDSP(sp, len, pnt) {
\
if (lbclen + (len) > lblen) { \
lblen += MAXIMUM(lbclen + (len), 256); \
- REALLOC((sp), lb, char *, lblen); \
+ REALLOC((sp), lb, lblen); \
if (lb == NULL) { \
lbclen = 0; \
return (1); \
@@ -939,7 +939,7 @@ re_compile(SCR *sp, char *ptrn, size_t p
* 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.22
diff -u -p -r1.22 ex_tag.c
--- ex/ex_tag.c 19 Nov 2015 07:53:31 -0000 1.22
+++ ex/ex_tag.c 7 Dec 2015 19:49:12 -0000
@@ -137,11 +137,11 @@ ex_tag_push(SCR *sp, EXCMD *cmdp)
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;
}
@@ -661,7 +661,7 @@ tagf_copy(SCR *sp, TAGF *otfp, TAGF **tf
{
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!!! */
@@ -687,7 +687,7 @@ tagq_copy(SCR *sp, TAGQ *otqp, TAGQ **tq
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);
@@ -714,7 +714,7 @@ tag_copy(SCR *sp, TAG *otp, TAG **tpp)
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)
@@ -823,8 +823,8 @@ ex_tagf_alloc(SCR *sp, char *str)
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);
@@ -943,7 +943,7 @@ ctag_slist(SCR *sp, char *tag)
/* 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);
@@ -1089,7 +1089,7 @@ corrupt: p = msg_print(sp, tname, &nf1)
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: vi/v_init.c
===================================================================
RCS file: /cvs/src/usr.bin/vi/vi/v_init.c,v
retrieving revision 1.6
diff -u -p -r1.6 v_init.c
--- vi/v_init.c 12 Nov 2014 04:28:41 -0000 1.6
+++ vi/v_init.c 7 Dec 2015 19:49:12 -0000
@@ -37,7 +37,7 @@ v_screen_copy(SCR *orig, SCR *sp)
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 @@ v_screen_copy(SCR *orig, SCR *sp)
/* 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 -p -r1.7 v_paragraph.c
--- vi/v_paragraph.c 12 Nov 2014 04:28:41 -0000 1.7
+++ vi/v_paragraph.c 7 Dec 2015 19:49:12 -0000
@@ -323,7 +323,7 @@ v_buildps(SCR *sp, char *p_p, char *s_p)
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 -p -r1.15 vi.c
--- vi/vi.c 12 Nov 2014 04:28:41 -0000 1.15
+++ vi/vi.c 7 Dec 2015 19:49:12 -0000
@@ -962,7 +962,7 @@ v_init(SCR *sp)
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.14
diff -u -p -r1.14 vs_msg.c
--- vi/vs_msg.c 24 Apr 2015 21:48:31 -0000 1.14
+++ vi/vs_msg.c 7 Dec 2015 19:49:12 -0000
@@ -884,8 +884,8 @@ vs_msgsave(SCR *sp, mtype_t mt, char *p,
* 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 -p -r1.12 vs_split.c
--- vi/vs_split.c 12 Nov 2014 04:28:41 -0000 1.12
+++ vi/vs_split.c 7 Dec 2015 19:49:12 -0000
@@ -59,7 +59,7 @@ vs_split(SCR *sp, SCR *new, int ccl)
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 @@ vs_swap(SCR *sp, SCR **nspp, char *name)
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. */
