| blob | b2b44b62ec8e66e892c88a61377984d1cd7aabe1 |
1 /*-
2 * Copyright (c) 1993, 1994
3 * The Regents of the University of California. All rights reserved.
4 * Copyright (c) 1993, 1994, 1995, 1996
5 * Keith Bostic. All rights reserved.
6 *
7 * See the LICENSE file for redistribution information.
8 *
9 * $Id: mem.h,v 10.17 2012/10/07 00:40:29 zy Exp $
10 */
12 #ifdef DEBUG
13 #define CHECK_TYPE(type, var) \
14 type L__lp __attribute__((unused)) = var;
15 #else
16 #define CHECK_TYPE(type, var)
17 #endif
19 /* Increase the size of a malloc'd buffer. Two versions, one that
20 * returns, one that jumps to an error label.
21 */
22 #define BINC_GOTO(sp, type, lp, llen, nlen) { \
23 CHECK_TYPE(type *, lp) \
24 void *L__bincp; \
25 if ((nlen) > llen) { \
26 if ((L__bincp = binc(sp, lp, &(llen), nlen)) == NULL) \
27 goto alloc_err; \
28 /* \
29 * !!! \
30 * Possible pointer conversion. \
32 lp = L__bincp; \
33 } \
34 }
35 #define BINC_GOTOC(sp, lp, llen, nlen) \
36 BINC_GOTO(sp, char, lp, llen, nlen)
37 #define BINC_GOTOW(sp, lp, llen, nlen) \
38 BINC_GOTO(sp, CHAR_T, lp, llen, (nlen) * sizeof(CHAR_T))
39 #define BINC_RET(sp, type, lp, llen, nlen) { \
40 CHECK_TYPE(type *, lp) \
41 void *L__bincp; \
42 if ((nlen) > llen) { \
43 if ((L__bincp = binc(sp, lp, &(llen), nlen)) == NULL) \
44 return (1); \
45 /* \
46 * !!! \
47 * Possible pointer conversion. \
49 lp = L__bincp; \
50 } \
51 }
52 #define BINC_RETC(sp, lp, llen, nlen) \
53 BINC_RET(sp, char, lp, llen, nlen)
54 #define BINC_RETW(sp, lp, llen, nlen) \
55 BINC_RET(sp, CHAR_T, lp, llen, (nlen) * sizeof(CHAR_T))
57 /*
58 * Get some temporary space, preferably from the global temporary buffer,
59 * from a malloc'd buffer otherwise. Two versions, one that returns, one
60 * that jumps to an error label.
61 */
62 #define GET_SPACE_GOTO(sp, type, bp, blen, nlen) { \
63 CHECK_TYPE(type *, bp) \
64 GS *L__gp = (sp) == NULL ? NULL : (sp)->gp; \
65 if (L__gp == NULL || F_ISSET(L__gp, G_TMP_INUSE)) { \
66 bp = NULL; \
67 blen = 0; \
68 BINC_GOTO(sp, type, bp, blen, nlen); \
69 } else { \
70 BINC_GOTOC(sp, L__gp->tmp_bp, L__gp->tmp_blen, nlen); \
71 bp = (type *) L__gp->tmp_bp; \
72 blen = L__gp->tmp_blen; \
73 F_SET(L__gp, G_TMP_INUSE); \
74 } \
75 }
76 #define GET_SPACE_GOTOC(sp, bp, blen, nlen) \
77 GET_SPACE_GOTO(sp, char, bp, blen, nlen)
78 #define GET_SPACE_GOTOW(sp, bp, blen, nlen) \
79 GET_SPACE_GOTO(sp, CHAR_T, bp, blen, (nlen) * sizeof(CHAR_T))
80 #define GET_SPACE_RET(sp, type, bp, blen, nlen) { \
81 CHECK_TYPE(type *, bp) \
82 GS *L__gp = (sp) == NULL ? NULL : (sp)->gp; \
83 if (L__gp == NULL || F_ISSET(L__gp, G_TMP_INUSE)) { \
84 bp = NULL; \
85 blen = 0; \
86 BINC_RET(sp, type, bp, blen, nlen); \
87 } else { \
88 BINC_RETC(sp, L__gp->tmp_bp, L__gp->tmp_blen, nlen); \
89 bp = (type *) L__gp->tmp_bp; \
90 blen = L__gp->tmp_blen; \
91 F_SET(L__gp, G_TMP_INUSE); \
92 } \
93 }
94 #define GET_SPACE_RETC(sp, bp, blen, nlen) \
95 GET_SPACE_RET(sp, char, bp, blen, nlen)
96 #define GET_SPACE_RETW(sp, bp, blen, nlen) \
97 GET_SPACE_RET(sp, CHAR_T, bp, blen, (nlen) * sizeof(CHAR_T))
99 /*
100 * Add space to a GET_SPACE returned buffer. Two versions, one that
101 * returns, one that jumps to an error label.
102 */
103 #define ADD_SPACE_GOTO(sp, type, bp, blen, nlen) { \
104 CHECK_TYPE(type *, bp) \
105 GS *L__gp = (sp) == NULL ? NULL : (sp)->gp; \
106 if (L__gp == NULL || bp == (type *)L__gp->tmp_bp) { \
107 F_CLR(L__gp, G_TMP_INUSE); \
108 BINC_GOTOC(sp, L__gp->tmp_bp, L__gp->tmp_blen, nlen); \
109 bp = (type *) L__gp->tmp_bp; \
110 blen = L__gp->tmp_blen; \
111 F_SET(L__gp, G_TMP_INUSE); \
112 } else \
113 BINC_GOTO(sp, type, bp, blen, nlen); \
114 }
115 #define ADD_SPACE_GOTOC(sp, bp, blen, nlen) \
116 ADD_SPACE_GOTO(sp, char, bp, blen, nlen)
117 #define ADD_SPACE_GOTOW(sp, bp, blen, nlen) \
118 ADD_SPACE_GOTO(sp, CHAR_T, bp, blen, (nlen) * sizeof(CHAR_T))
119 #define ADD_SPACE_RET(sp, type, bp, blen, nlen) { \
120 CHECK_TYPE(type *, bp) \
121 GS *L__gp = (sp) == NULL ? NULL : (sp)->gp; \
122 if (L__gp == NULL || bp == (type *)L__gp->tmp_bp) { \
123 F_CLR(L__gp, G_TMP_INUSE); \
124 BINC_RETC(sp, L__gp->tmp_bp, L__gp->tmp_blen, nlen); \
125 bp = (type *) L__gp->tmp_bp; \
126 blen = L__gp->tmp_blen; \
127 F_SET(L__gp, G_TMP_INUSE); \
128 } else \
129 BINC_RET(sp, type, bp, blen, nlen); \
130 }
131 #define ADD_SPACE_RETC(sp, bp, blen, nlen) \
132 ADD_SPACE_RET(sp, char, bp, blen, nlen)
133 #define ADD_SPACE_RETW(sp, bp, blen, nlen) \
134 ADD_SPACE_RET(sp, CHAR_T, bp, blen, (nlen) * sizeof(CHAR_T))
136 /* Free a GET_SPACE returned buffer. */
137 #define FREE_SPACE(sp, bp, blen) { \
138 GS *L__gp = (sp) == NULL ? NULL : (sp)->gp; \
139 if (L__gp != NULL && bp == L__gp->tmp_bp) \
140 F_CLR(L__gp, G_TMP_INUSE); \
141 else \
142 free(bp); \
143 }
144 #define FREE_SPACEW(sp, bp, blen) { \
145 CHECK_TYPE(CHAR_T *, bp) \
146 FREE_SPACE(sp, (char *)bp, blen); \
147 }
149 /*
150 * Malloc a buffer, casting the return pointer. Various versions.
151 *
152 * !!!
153 * The cast should be unnecessary, malloc(3) and friends return void *'s,
154 * which is all we need. However, some systems that nvi needs to run on
155 * don't do it right yet, resulting in the compiler printing out roughly
156 * a million warnings. After awhile, it seemed easier to put the casts
157 * in instead of explaining it all the time.
158 */
159 #define CALLOC(sp, p, cast, nmemb, size) { \
160 if ((p = (cast)calloc(nmemb, size)) == NULL) \
161 msgq(sp, M_SYSERR, NULL); \
162 }
163 #define CALLOC_GOTO(sp, p, cast, nmemb, size) { \
164 if ((p = (cast)calloc(nmemb, size)) == NULL) \
165 goto alloc_err; \
166 }
167 #define CALLOC_NOMSG(sp, p, cast, nmemb, size) { \
168 p = (cast)calloc(nmemb, size); \
169 }
170 #define CALLOC_RET(sp, p, cast, nmemb, size) { \
171 if ((p = (cast)calloc(nmemb, size)) == NULL) { \
172 msgq(sp, M_SYSERR, NULL); \
173 return (1); \
174 } \
175 }
177 #define MALLOC(sp, p, cast, size) { \
178 if ((p = (cast)malloc(size)) == NULL) \
179 msgq(sp, M_SYSERR, NULL); \
180 }
181 #define MALLOC_GOTO(sp, p, cast, size) { \
182 if ((p = (cast)malloc(size)) == NULL) \
183 goto alloc_err; \
184 }
185 #define MALLOC_NOMSG(sp, p, cast, size) { \
186 p = (cast)malloc(size); \
187 }
188 #define MALLOC_RET(sp, p, cast, size) { \
189 if ((p = (cast)malloc(size)) == NULL) { \
190 msgq(sp, M_SYSERR, NULL); \
191 return (1); \
192 } \
193 }
195 /*
196 * Resize a buffer, free any already held memory if we can't get more.
197 * FreeBSD's reallocf(3) does the same thing, but it's not portable yet.
198 */
199 #define REALLOC(sp, p, cast, size) { \
200 cast newp; \
201 if ((newp = (cast)realloc(p, size)) == NULL) { \
202 if (p != NULL) \
203 free(p); \
204 msgq(sp, M_SYSERR, NULL); \
205 } \
206 p = newp; \
207 }
209 /*
210 * Versions of bcopy(3) and bzero(3) that use the size of the
211 * initial pointer to figure out how much memory to manipulate.
212 */
213 #define BCOPY(p, t, len) bcopy(p, t, (len) * sizeof(*(p)))
214 #define BZERO(p, len) bzero(p, (len) * sizeof(*(p)))
216 /*
217 * p2roundup --
218 * Get next power of 2; convenient for realloc.
219 *
220 * Reference: FreeBSD /usr/src/lib/libc/stdio/getdelim.c
221 */
224 {
225 n--;
231 #if SIZE_T_MAX > 0xffffffffU
233 #endif
234 n++;
236 }
238 /* Additional TAILQ helper. */
239 #define TAILQ_ENTRY_ISVALID(elm, field) \
240 ((elm)->field.tqe_prev != NULL)