1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
/* $OpenBSD: mem.h,v 1.8 2016/02/03 01:47:25 mmcc Exp $ */
/*-
* Copyright (c) 1993, 1994
* The Regents of the University of California. All rights reserved.
* Copyright (c) 1993, 1994, 1995, 1996
* Keith Bostic. All rights reserved.
*
* See the LICENSE file for redistribution information.
*
* @(#)mem.h 10.7 (Berkeley) 3/30/96
*/
/* 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) { \
void *L__bincp; \
if ((nlen) > (llen)) { \
if ((L__bincp = binc((sp), (lp), &(llen), (nlen))) \
== NULL) \
goto alloc_err; \
/* \
* !!! \
* Possible pointer conversion. \
*/ \
(lp) = L__bincp; \
} \
}
#define BINC_RET(sp, lp, llen, nlen) { \
void *L__bincp; \
if ((nlen) > (llen)) { \
if ((L__bincp = binc((sp), (lp), &(llen), (nlen))) \
== NULL) \
return (1); \
/* \
* !!! \
* Possible pointer conversion. \
*/ \
(lp) = L__bincp; \
} \
}
/*
* 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) { \
GS *L__gp = (sp) == NULL ? NULL : (sp)->gp; \
if (L__gp == NULL || F_ISSET(L__gp, G_TMP_INUSE)) { \
(bp) = NULL; \
(blen) = 0; \
BINC_GOTO((sp), (bp), (blen), (nlen)); \
} else { \
BINC_GOTO((sp), L__gp->tmp_bp, L__gp->tmp_blen, (nlen));\
(bp) = L__gp->tmp_bp; \
(blen) = L__gp->tmp_blen; \
F_SET(L__gp, G_TMP_INUSE); \
} \
}
#define GET_SPACE_RET(sp, bp, blen, nlen) { \
GS *L__gp = (sp) == NULL ? NULL : (sp)->gp; \
if (L__gp == NULL || F_ISSET(L__gp, G_TMP_INUSE)) { \
(bp) = NULL; \
(blen) = 0; \
BINC_RET((sp), (bp), (blen), (nlen)); \
} else { \
BINC_RET((sp), L__gp->tmp_bp, L__gp->tmp_blen, (nlen)); \
(bp) = L__gp->tmp_bp; \
(blen) = L__gp->tmp_blen; \
F_SET(L__gp, G_TMP_INUSE); \
} \
}
/*
* 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) { \
GS *L__gp = (sp) == NULL ? NULL : (sp)->gp; \
if (L__gp == NULL || (bp) == L__gp->tmp_bp) { \
F_CLR(L__gp, G_TMP_INUSE); \
BINC_GOTO((sp), L__gp->tmp_bp, L__gp->tmp_blen, (nlen));\
(bp) = L__gp->tmp_bp; \
(blen) = L__gp->tmp_blen; \
F_SET(L__gp, G_TMP_INUSE); \
} else \
BINC_GOTO((sp), (bp), (blen), (nlen)); \
}
#define ADD_SPACE_RET(sp, bp, blen, nlen) { \
GS *L__gp = (sp) == NULL ? NULL : (sp)->gp; \
if (L__gp == NULL || (bp) == L__gp->tmp_bp) { \
F_CLR(L__gp, G_TMP_INUSE); \
BINC_RET((sp), L__gp->tmp_bp, L__gp->tmp_blen, (nlen)); \
(bp) = L__gp->tmp_bp; \
(blen) = L__gp->tmp_blen; \
F_SET(L__gp, G_TMP_INUSE); \
} else \
BINC_RET((sp), (bp), (blen), (nlen)); \
}
/* Free a GET_SPACE returned buffer. */
#define FREE_SPACE(sp, bp, blen) { \
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); \
}
/*
* Malloc a buffer, casting the return pointer. Various versions.
*/
#define CALLOC(sp, p, nmemb, size) { \
if (((p) = calloc((nmemb), (size))) == NULL) \
msgq((sp), M_SYSERR, NULL); \
}
#define CALLOC_GOTO(sp, p, nmemb, size) { \
if (((p) = calloc((nmemb), (size))) == NULL) \
goto alloc_err; \
}
#define CALLOC_RET(sp, p, nmemb, size) { \
if (((p) = calloc((nmemb), (size))) == NULL) { \
msgq((sp), M_SYSERR, NULL); \
return (1); \
} \
}
#define MALLOC(sp, p, size) { \
if (((p) = malloc(size)) == NULL) \
msgq((sp), M_SYSERR, NULL); \
}
#define MALLOC_GOTO(sp, p, size) { \
if (((p) = malloc(size)) == NULL) \
goto alloc_err; \
}
#define MALLOC_RET(sp, p, size) { \
if (((p) = malloc(size)) == NULL) { \
msgq((sp), M_SYSERR, NULL); \
return (1); \
} \
}
#define REALLOC(sp, p, size) { \
if (((p) = (realloc((p), (size)))) == NULL) \
msgq((sp), M_SYSERR, NULL); \
}
#define REALLOCARRAY(sp, p, nelem, size) { \
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)))
|
