| blob | 6a68b58c0cdea560fd022eb4d2eaa103c4555fbb |
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.11 2000/08/20 09:12:59 skimo Exp $ (Berkeley) $Date: 2000/08/20 09:12:59 $
10 */
12 /* Increase the size of a malloc'd buffer. Two versions, one that
13 * returns, one that jumps to an error label.
14 */
15 #define BINC_GOTO(sp, lp, llen, nlen) { \
16 char *L__p = lp; \
17 void *L__bincp; \
18 if ((nlen) > llen) { \
19 if ((L__bincp = binc(sp, lp, &(llen), nlen)) == NULL) \
20 goto alloc_err; \
21 /* \
22 * !!! \
23 * Possible pointer conversion. \
25 lp = L__bincp; \
26 } \
27 }
28 #define BINC_GOTOW(sp, lp, llen, nlen) { \
29 CHAR_T *L__bp = lp; \
30 BINC_GOTO(sp, (char *)lp, llen, (nlen) * sizeof(CHAR_T)) \
31 }
32 #define BINC_RET(sp, lp, llen, nlen) { \
33 char *L__p = lp; \
34 void *L__bincp; \
35 if ((nlen) > llen) { \
36 if ((L__bincp = binc(sp, lp, &(llen), nlen)) == NULL) \
37 return (1); \
38 /* \
39 * !!! \
40 * Possible pointer conversion. \
42 lp = L__bincp; \
43 } \
44 }
45 #define BINC_RETW(sp, lp, llen, nlen) { \
46 CHAR_T *L__bp = lp; \
47 BINC_RET(sp, (char *)lp, llen, (nlen) * sizeof(CHAR_T)) \
48 }
50 /*
51 * Get some temporary space, preferably from the global temporary buffer,
52 * from a malloc'd buffer otherwise. Two versions, one that returns, one
53 * that jumps to an error label.
54 */
55 #define GET_SPACE_GOTO(sp, bp, blen, nlen) { \
56 WIN *L__wp = (sp) == NULL ? NULL : (sp)->wp; \
57 if (L__wp == NULL || F_ISSET(L__wp, W_TMP_INUSE)) { \
58 bp = NULL; \
59 blen = 0; \
60 BINC_GOTO(sp, bp, blen, nlen); \
61 } else { \
62 BINC_GOTO(sp, L__wp->tmp_bp, L__wp->tmp_blen, nlen); \
63 bp = L__wp->tmp_bp; \
64 blen = L__wp->tmp_blen; \
65 F_SET(L__wp, W_TMP_INUSE); \
66 } \
67 }
68 #define GET_SPACE_GOTOW(sp, bp, blen, nlen) { \
69 CHAR_T *L__bp = bp; \
70 GET_SPACE_GOTO(sp, (char *)bp, blen, (nlen) * sizeof(CHAR_T)) \
71 }
72 #define GET_SPACE_RET(sp, bp, blen, nlen) { \
73 WIN *L__wp = (sp) == NULL ? NULL : (sp)->wp; \
74 if (L__wp == NULL || F_ISSET(L__wp, W_TMP_INUSE)) { \
75 bp = NULL; \
76 blen = 0; \
77 BINC_RET(sp, bp, blen, nlen); \
78 } else { \
79 BINC_RET(sp, L__wp->tmp_bp, L__wp->tmp_blen, nlen); \
80 bp = L__wp->tmp_bp; \
81 blen = L__wp->tmp_blen; \
82 F_SET(L__wp, W_TMP_INUSE); \
83 } \
84 }
85 #define GET_SPACE_RETW(sp, bp, blen, nlen) { \
86 CHAR_T *L__bp = bp; \
87 GET_SPACE_RET(sp, (char *)bp, blen, (nlen) * sizeof(CHAR_T)) \
88 }
90 /*
91 * Add space to a GET_SPACE returned buffer. Two versions, one that
92 * returns, one that jumps to an error label.
93 */
94 #define ADD_SPACE_GOTO(sp, bp, blen, nlen) { \
95 WIN *L__wp = (sp) == NULL ? NULL : (sp)->wp; \
96 if (L__wp == NULL || bp == L__wp->tmp_bp) { \
97 F_CLR(L__wp, W_TMP_INUSE); \
98 BINC_GOTO(sp, L__wp->tmp_bp, L__wp->tmp_blen, nlen); \
99 bp = L__wp->tmp_bp; \
100 blen = L__wp->tmp_blen; \
101 F_SET(L__wp, W_TMP_INUSE); \
102 } else \
103 BINC_GOTO(sp, bp, blen, nlen); \
104 }
105 #define ADD_SPACE_GOTOW(sp, bp, blen, nlen) { \
106 CHAR_T *L__bp = bp; \
107 ADD_SPACE_GOTO(sp, (char *)bp, blen, (nlen) * sizeof(CHAR_T)) \
108 }
109 #define ADD_SPACE_RET(sp, bp, blen, nlen) { \
110 WIN *L__wp = (sp) == NULL ? NULL : (sp)->wp; \
111 if (L__wp == NULL || bp == L__wp->tmp_bp) { \
112 F_CLR(L__wp, W_TMP_INUSE); \
113 BINC_RET(sp, L__wp->tmp_bp, L__wp->tmp_blen, nlen); \
114 bp = L__wp->tmp_bp; \
115 blen = L__wp->tmp_blen; \
116 F_SET(L__wp, W_TMP_INUSE); \
117 } else \
118 BINC_RET(sp, bp, blen, nlen); \
119 }
120 #define ADD_SPACE_RETW(sp, bp, blen, nlen) { \
121 CHAR_T *L__bp = bp; \
122 ADD_SPACE_RET(sp, (char *)bp, blen, (nlen) * sizeof(CHAR_T)) \
123 }
125 /* Free a GET_SPACE returned buffer. */
126 #define FREE_SPACE(sp, bp, blen) { \
127 WIN *L__wp = (sp) == NULL ? NULL : (sp)->wp; \
128 if (L__wp != NULL && bp == L__wp->tmp_bp) \
129 F_CLR(L__wp, W_TMP_INUSE); \
130 else \
131 free(bp); \
132 }
133 #define FREE_SPACEW(sp, bp, blen) { \
134 CHAR_T *L__bp = bp; \
135 FREE_SPACE(sp, (char *)bp, blen); \
136 }
138 /*
139 * Malloc a buffer, casting the return pointer. Various versions.
140 *
141 * !!!
142 * The cast should be unnecessary, malloc(3) and friends return void *'s,
143 * which is all we need. However, some systems that nvi needs to run on
144 * don't do it right yet, resulting in the compiler printing out roughly
145 * a million warnings. After awhile, it seemed easier to put the casts
146 * in instead of explaining it all the time.
147 */
148 #define CALLOC(sp, p, cast, nmemb, size) { \
149 if ((p = (cast)calloc(nmemb, size)) == NULL) \
150 msgq(sp, M_SYSERR, NULL); \
151 }
152 #define CALLOC_GOTO(sp, p, cast, nmemb, size) { \
153 if ((p = (cast)calloc(nmemb, size)) == NULL) \
154 goto alloc_err; \
155 }
156 #define CALLOC_NOMSG(sp, p, cast, nmemb, size) { \
157 p = (cast)calloc(nmemb, size); \
158 }
159 #define CALLOC_RET(sp, p, cast, nmemb, size) { \
160 if ((p = (cast)calloc(nmemb, size)) == NULL) { \
161 msgq(sp, M_SYSERR, NULL); \
162 return (1); \
163 } \
164 }
166 #define MALLOC(sp, p, cast, size) { \
167 if ((p = (cast)malloc(size)) == NULL) \
168 msgq(sp, M_SYSERR, NULL); \
169 }
170 #define MALLOC_GOTO(sp, p, cast, size) { \
171 if ((p = (cast)malloc(size)) == NULL) \
172 goto alloc_err; \
173 }
174 #define MALLOC_NOMSG(sp, p, cast, size) { \
175 p = (cast)malloc(size); \
176 }
177 #define MALLOC_RET(sp, p, cast, size) { \
178 if ((p = (cast)malloc(size)) == NULL) { \
179 msgq(sp, M_SYSERR, NULL); \
180 return (1); \
181 } \
182 }
183 /*
184 * XXX
185 * Don't depend on realloc(NULL, size) working.
186 */
187 #define REALLOC(sp, p, cast, size) { \
188 if ((p = (cast)(p == NULL ? \
189 malloc(size) : realloc(p, size))) == NULL) \
190 msgq(sp, M_SYSERR, NULL); \
191 }
193 /*
194 * Versions of memmove(3) and memset(3) that use the size of the
195 * initial pointer to figure out how much memory to manipulate.
196 */
197 #define MEMMOVE(p, t, len) memmove(p, t, (len) * sizeof(*(p)))
198 #define MEMSET(p, value, len) memset(p, value, (len) * sizeof(*(p)))