| blob | 17835b3ad40fa49af8dd516f8833e9f75c756b1a |
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.7 1996/03/30 13:46:54 bostic Exp $ (Berkeley) $Date: 1996/03/30 13:46:54 $
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 void *L__bincp; \
17 if ((nlen) > llen) { \
18 if ((L__bincp = binc(sp, lp, &(llen), nlen)) == NULL) \
19 goto alloc_err; \
20 /* \
21 * !!! \
22 * Possible pointer conversion. \
24 lp = L__bincp; \
25 } \
26 }
27 #define BINC_RET(sp, lp, llen, nlen) { \
28 void *L__bincp; \
29 if ((nlen) > llen) { \
30 if ((L__bincp = binc(sp, lp, &(llen), nlen)) == NULL) \
31 return (1); \
32 /* \
33 * !!! \
34 * Possible pointer conversion. \
36 lp = L__bincp; \
37 } \
38 }
40 /*
41 * Get some temporary space, preferably from the global temporary buffer,
42 * from a malloc'd buffer otherwise. Two versions, one that returns, one
43 * that jumps to an error label.
44 */
45 #define GET_SPACE_GOTO(sp, bp, blen, nlen) { \
46 GS *L__gp = (sp) == NULL ? NULL : (sp)->gp; \
47 if (L__gp == NULL || F_ISSET(L__gp, G_TMP_INUSE)) { \
48 bp = NULL; \
49 blen = 0; \
50 BINC_GOTO(sp, bp, blen, nlen); \
51 } else { \
52 BINC_GOTO(sp, L__gp->tmp_bp, L__gp->tmp_blen, nlen); \
53 bp = L__gp->tmp_bp; \
54 blen = L__gp->tmp_blen; \
55 F_SET(L__gp, G_TMP_INUSE); \
56 } \
57 }
58 #define GET_SPACE_RET(sp, bp, blen, nlen) { \
59 GS *L__gp = (sp) == NULL ? NULL : (sp)->gp; \
60 if (L__gp == NULL || F_ISSET(L__gp, G_TMP_INUSE)) { \
61 bp = NULL; \
62 blen = 0; \
63 BINC_RET(sp, bp, blen, nlen); \
64 } else { \
65 BINC_RET(sp, L__gp->tmp_bp, L__gp->tmp_blen, nlen); \
66 bp = L__gp->tmp_bp; \
67 blen = L__gp->tmp_blen; \
68 F_SET(L__gp, G_TMP_INUSE); \
69 } \
70 }
72 /*
73 * Add space to a GET_SPACE returned buffer. Two versions, one that
74 * returns, one that jumps to an error label.
75 */
76 #define ADD_SPACE_GOTO(sp, bp, blen, nlen) { \
77 GS *L__gp = (sp) == NULL ? NULL : (sp)->gp; \
78 if (L__gp == NULL || bp == L__gp->tmp_bp) { \
79 F_CLR(L__gp, G_TMP_INUSE); \
80 BINC_GOTO(sp, L__gp->tmp_bp, L__gp->tmp_blen, nlen); \
81 bp = L__gp->tmp_bp; \
82 blen = L__gp->tmp_blen; \
83 F_SET(L__gp, G_TMP_INUSE); \
84 } else \
85 BINC_GOTO(sp, bp, blen, nlen); \
86 }
87 #define ADD_SPACE_RET(sp, bp, blen, nlen) { \
88 GS *L__gp = (sp) == NULL ? NULL : (sp)->gp; \
89 if (L__gp == NULL || bp == L__gp->tmp_bp) { \
90 F_CLR(L__gp, G_TMP_INUSE); \
91 BINC_RET(sp, L__gp->tmp_bp, L__gp->tmp_blen, nlen); \
92 bp = L__gp->tmp_bp; \
93 blen = L__gp->tmp_blen; \
94 F_SET(L__gp, G_TMP_INUSE); \
95 } else \
96 BINC_RET(sp, bp, blen, nlen); \
97 }
99 /* Free a GET_SPACE returned buffer. */
100 #define FREE_SPACE(sp, bp, blen) { \
101 GS *L__gp = (sp) == NULL ? NULL : (sp)->gp; \
102 if (L__gp != NULL && bp == L__gp->tmp_bp) \
103 F_CLR(L__gp, G_TMP_INUSE); \
104 else \
105 free(bp); \
106 }
108 /*
109 * Malloc a buffer, casting the return pointer. Various versions.
110 *
111 * !!!
112 * The cast should be unnecessary, malloc(3) and friends return void *'s,
113 * which is all we need. However, some systems that nvi needs to run on
114 * don't do it right yet, resulting in the compiler printing out roughly
115 * a million warnings. After awhile, it seemed easier to put the casts
116 * in instead of explaining it all the time.
117 */
118 #define CALLOC(sp, p, cast, nmemb, size) { \
119 if ((p = (cast)calloc(nmemb, size)) == NULL) \
120 msgq(sp, M_SYSERR, NULL); \
121 }
122 #define CALLOC_GOTO(sp, p, cast, nmemb, size) { \
123 if ((p = (cast)calloc(nmemb, size)) == NULL) \
124 goto alloc_err; \
125 }
126 #define CALLOC_NOMSG(sp, p, cast, nmemb, size) { \
127 p = (cast)calloc(nmemb, size); \
128 }
129 #define CALLOC_RET(sp, p, cast, nmemb, size) { \
130 if ((p = (cast)calloc(nmemb, size)) == NULL) { \
131 msgq(sp, M_SYSERR, NULL); \
132 return (1); \
133 } \
134 }
136 #define MALLOC(sp, p, cast, size) { \
137 if ((p = (cast)malloc(size)) == NULL) \
138 msgq(sp, M_SYSERR, NULL); \
139 }
140 #define MALLOC_GOTO(sp, p, cast, size) { \
141 if ((p = (cast)malloc(size)) == NULL) \
142 goto alloc_err; \
143 }
144 #define MALLOC_NOMSG(sp, p, cast, size) { \
145 p = (cast)malloc(size); \
146 }
147 #define MALLOC_RET(sp, p, cast, size) { \
148 if ((p = (cast)malloc(size)) == NULL) { \
149 msgq(sp, M_SYSERR, NULL); \
150 return (1); \
151 } \
152 }
153 /*
154 * XXX
155 * Don't depend on realloc(NULL, size) working.
156 */
157 #define REALLOC(sp, p, cast, size) { \
158 if ((p = (cast)(p == NULL ? \
159 malloc(size) : realloc(p, size))) == NULL) \
160 msgq(sp, M_SYSERR, NULL); \
161 }
163 /*
164 * Versions of memmove(3) and memset(3) that use the size of the
165 * initial pointer to figure out how much memory to manipulate.
166 */
167 #define MEMMOVE(p, t, len) memmove(p, t, (len) * sizeof(*(p)))
168 #define MEMSET(p, value, len) memset(p, value, (len) * sizeof(*(p)))