Line data Source code
1 : /*
2 : * This Source Code Form is subject to the terms of the Mozilla Public
3 : * License, v. 2.0. If a copy of the MPL was not distributed with this
4 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
5 : *
6 : * Copyright 1997 - July 2008 CWI, August 2008 - 2021 MonetDB B.V.
7 : */
8 :
9 : #include "monetdb_config.h"
10 : #include "stream.h"
11 : #include "stream_internal.h"
12 :
13 :
14 :
15 : int
16 0 : mnstr_readChr(stream *restrict s, char *restrict val)
17 : {
18 0 : if (s == NULL || val == NULL)
19 : return -1;
20 0 : return (int) s->read(s, (void *) val, sizeof(*val), 1);
21 : }
22 :
23 : int
24 201 : mnstr_writeChr(stream *s, char val)
25 : {
26 201 : if (s == NULL || s->errkind != MNSTR_NO__ERROR)
27 : return 0;
28 201 : return s->write(s, (void *) &val, sizeof(val), 1) == 1;
29 : }
30 :
31 : int
32 54286 : mnstr_readBte(stream *restrict s, int8_t *restrict val)
33 : {
34 54286 : if (s == NULL || val == NULL)
35 : return -1;
36 54286 : return (int) s->read(s, (void *) val, sizeof(*val), 1);
37 : }
38 :
39 : int
40 57997 : mnstr_writeBte(stream *s, int8_t val)
41 : {
42 57997 : if (s == NULL || s->errkind != MNSTR_NO__ERROR)
43 : return 0;
44 57997 : return s->write(s, (void *) &val, sizeof(val), 1) == 1;
45 : }
46 :
47 : int
48 533818 : mnstr_readSht(stream *restrict s, int16_t *restrict val)
49 : {
50 533818 : if (s == NULL || val == NULL)
51 : return 0;
52 533818 : assert(s->binary);
53 533818 : switch (s->read(s, val, sizeof(*val), 1)) {
54 529213 : case 1:
55 529213 : if (s->swapbytes)
56 0 : *val = short_int_SWAP(*val);
57 : return 1;
58 : case 0:
59 : return 0;
60 17 : default: /* -1 */
61 17 : return -1;
62 : }
63 : }
64 :
65 : int
66 523952 : mnstr_writeSht(stream *s, int16_t val)
67 : {
68 523952 : if (s == NULL || s->errkind != MNSTR_NO__ERROR)
69 : return 0;
70 523952 : assert(s->binary);
71 523952 : if (s->swapbytes)
72 0 : val = short_int_SWAP(val);
73 523952 : return s->write(s, &val, sizeof(val), 1) == 1;
74 : }
75 :
76 : int
77 137856 : mnstr_readInt(stream *restrict s, int *restrict val)
78 : {
79 137856 : if (s == NULL || val == NULL)
80 : return 0;
81 137856 : assert(s->binary);
82 137856 : switch (s->read(s, val, sizeof(*val), 1)) {
83 137856 : case 1:
84 137856 : if (s->swapbytes)
85 0 : *val = normal_int_SWAP(*val);
86 : return 1;
87 : case 0:
88 : return 0;
89 0 : default: /* -1 */
90 0 : return -1;
91 : }
92 : }
93 :
94 : int
95 148283 : mnstr_writeInt(stream *s, int val)
96 : {
97 148283 : if (s == NULL || s->errkind != MNSTR_NO__ERROR)
98 : return 0;
99 148283 : assert(s->binary);
100 148283 : if (s->swapbytes)
101 0 : val = normal_int_SWAP(val);
102 148283 : return s->write(s, &val, sizeof(val), 1) == 1;
103 : }
104 :
105 : int
106 0 : mnstr_writeStr(stream *restrict s, const char *restrict val)
107 : {
108 0 : if (s == NULL || s->errkind != MNSTR_NO__ERROR)
109 : return 0;
110 0 : return s->write(s, (void *) val, strlen(val), (size_t) 1) == 1;
111 : }
112 :
113 : int
114 0 : mnstr_readStr(stream *restrict s, char *restrict val)
115 : {
116 0 : if (s == NULL || s->errkind != MNSTR_NO__ERROR)
117 : return 0;
118 : do {
119 0 : if (mnstr_readChr(s, val) != 1) {
120 : return -1;
121 : }
122 0 : val++;
123 0 : } while (*(val - 1) != '\0');
124 : return 1;
125 : }
126 :
127 :
128 : int
129 215809 : mnstr_readLng(stream *restrict s, int64_t *restrict val)
130 : {
131 215809 : if (s == NULL || val == NULL)
132 : return 0;
133 215809 : assert(s->binary);
134 215809 : switch (s->read(s, val, sizeof(*val), 1)) {
135 215809 : case 1:
136 215809 : if (s->swapbytes)
137 0 : *val = long_int_SWAP(*val);
138 : return 1;
139 : case 0:
140 : return 0;
141 0 : default: /* -1 */
142 0 : return -1;
143 : }
144 : }
145 :
146 : int
147 230010 : mnstr_writeLng(stream *s, int64_t val)
148 : {
149 230010 : if (s == NULL || s->errkind != MNSTR_NO__ERROR)
150 : return 0;
151 230010 : assert(s->binary);
152 230010 : if (s->swapbytes)
153 0 : val = long_int_SWAP(val);
154 230010 : return s->write(s, &val, sizeof(val), 1) == 1;
155 : }
156 :
157 : int
158 0 : mnstr_writeFlt(stream *s, float val)
159 : {
160 0 : if (s == NULL || s->errkind != MNSTR_NO__ERROR)
161 : return 0;
162 0 : assert(s->binary);
163 0 : return s->write(s, &val, sizeof(val), 1) == 1;
164 : }
165 :
166 : int
167 0 : mnstr_writeDbl(stream *s, double val)
168 : {
169 0 : if (s == NULL || s->errkind != MNSTR_NO__ERROR)
170 : return 0;
171 0 : assert(s->binary);
172 0 : return s->write(s, &val, sizeof(val), 1) == 1;
173 : }
174 :
175 :
176 : #ifdef HAVE_HGE
177 : int
178 0 : mnstr_readHge(stream *restrict s, hge *restrict val)
179 : {
180 0 : if (s == NULL || val == NULL)
181 : return 0;
182 0 : assert(s->binary);
183 0 : switch (s->read(s, val, sizeof(*val), 1)) {
184 0 : case 1:
185 0 : if (s->swapbytes)
186 0 : *val = huge_int_SWAP(*val);
187 : return 1;
188 : case 0:
189 : return 0;
190 0 : default: /* -1 */
191 0 : return -1;
192 : }
193 : }
194 :
195 : int
196 0 : mnstr_writeHge(stream *s, hge val)
197 : {
198 0 : if (s == NULL || s->errkind != MNSTR_NO__ERROR)
199 : return 0;
200 0 : assert(s->binary);
201 0 : if (s->swapbytes)
202 0 : val = huge_int_SWAP(val);
203 0 : return s->write(s, &val, sizeof(val), 1) == 1;
204 : }
205 : #endif
206 :
207 : int
208 2971 : mnstr_readBteArray(stream *restrict s, int8_t *restrict val, size_t cnt)
209 : {
210 2971 : if (s == NULL || val == NULL)
211 : return 0;
212 :
213 2971 : if (s->read(s, (void *) val, sizeof(*val), cnt) < (ssize_t) cnt) {
214 0 : if (s->errkind == MNSTR_NO__ERROR)
215 0 : mnstr_set_error(s, MNSTR_UNEXPECTED_EOF, NULL);
216 0 : return 0;
217 : }
218 :
219 : return 1;
220 : }
221 :
222 : int
223 3221 : mnstr_writeBteArray(stream *restrict s, const int8_t *restrict val, size_t cnt)
224 : {
225 3221 : if (s == NULL || s->errkind != MNSTR_NO__ERROR || val == NULL)
226 : return 0;
227 3221 : return s->write(s, val, sizeof(*val), cnt) == (ssize_t) cnt;
228 : }
229 :
230 : int
231 3234 : mnstr_readShtArray(stream *restrict s, int16_t *restrict val, size_t cnt)
232 : {
233 3234 : if (s == NULL || val == NULL)
234 : return 0;
235 3234 : assert(s->binary);
236 3234 : if (s->read(s, val, sizeof(*val), cnt) < (ssize_t) cnt) {
237 0 : if (s->errkind == MNSTR_NO__ERROR)
238 0 : mnstr_set_error(s, MNSTR_UNEXPECTED_EOF, NULL);
239 0 : return 0;
240 : }
241 3234 : if (s->swapbytes) {
242 0 : for (size_t i = 0; i < cnt; i++, val++)
243 0 : *val = short_int_SWAP(*val);
244 : }
245 : return 1;
246 : }
247 :
248 : int
249 3572 : mnstr_writeShtArray(stream *restrict s, const int16_t *restrict val, size_t cnt)
250 : {
251 3572 : if (s == NULL || s->errkind != MNSTR_NO__ERROR || val == NULL)
252 : return 0;
253 3572 : assert(s->binary);
254 3572 : if (s->swapbytes) {
255 0 : for (size_t i = 0; i < cnt; i++)
256 0 : if (!mnstr_writeSht(s, val[i]))
257 : return 0;
258 : return 1;
259 : }
260 3572 : return s->write(s, val, sizeof(*val), cnt) == (ssize_t) cnt;
261 : }
262 :
263 : int
264 24060 : mnstr_readIntArray(stream *restrict s, int *restrict val, size_t cnt)
265 : {
266 24060 : if (s == NULL || val == NULL)
267 : return 0;
268 24060 : assert(s->binary);
269 24060 : if (s->read(s, val, sizeof(*val), cnt) < (ssize_t) cnt) {
270 0 : if (s->errkind == MNSTR_NO__ERROR)
271 0 : mnstr_set_error(s, MNSTR_UNEXPECTED_EOF, NULL);
272 0 : return 0;
273 : }
274 24060 : if (s->swapbytes) {
275 0 : for (size_t i = 0; i < cnt; i++, val++)
276 0 : *val = normal_int_SWAP(*val);
277 : }
278 : return 1;
279 : }
280 :
281 : int
282 25347 : mnstr_writeIntArray(stream *restrict s, const int *restrict val, size_t cnt)
283 : {
284 25347 : if (s == NULL || s->errkind != MNSTR_NO__ERROR || val == NULL)
285 : return 0;
286 25347 : assert(s->binary);
287 25347 : if (s->swapbytes) {
288 0 : for (size_t i = 0; i < cnt; i++)
289 0 : if (!mnstr_writeInt(s, val[i]))
290 : return 0;
291 : return 1;
292 : }
293 25347 : return s->write(s, val, sizeof(*val), cnt) == (ssize_t) cnt;
294 : }
295 :
296 : int
297 14668 : mnstr_readLngArray(stream *restrict s, int64_t *restrict val, size_t cnt)
298 : {
299 14668 : if (s == NULL || val == NULL)
300 : return 0;
301 14668 : assert(s->binary);
302 14668 : if (s->read(s, val, sizeof(*val), cnt) < (ssize_t) cnt) {
303 0 : if (s->errkind == MNSTR_NO__ERROR)
304 0 : mnstr_set_error(s, MNSTR_UNEXPECTED_EOF, NULL);
305 0 : return 0;
306 : }
307 14668 : if (s->swapbytes) {
308 0 : for (size_t i = 0; i < cnt; i++, val++)
309 0 : *val = long_int_SWAP(*val);
310 : }
311 : return 1;
312 : }
313 :
314 : int
315 2079 : mnstr_writeLngArray(stream *restrict s, const int64_t *restrict val, size_t cnt)
316 : {
317 2079 : if (s == NULL || s->errkind != MNSTR_NO__ERROR || val == NULL)
318 : return 0;
319 2079 : assert(s->binary);
320 2079 : if (s->swapbytes) {
321 0 : for (size_t i = 0; i < cnt; i++)
322 0 : if (!mnstr_writeLng(s, val[i]))
323 : return 0;
324 : return 1;
325 : }
326 2079 : return s->write(s, val, sizeof(*val), cnt) == (ssize_t) cnt;
327 : }
328 :
329 : #ifdef HAVE_HGE
330 : int
331 485 : mnstr_readHgeArray(stream *restrict s, hge *restrict val, size_t cnt)
332 : {
333 485 : if (s == NULL || val == NULL)
334 : return 0;
335 485 : assert(s->binary);
336 485 : if (s->read(s, val, sizeof(*val), cnt) < (ssize_t) cnt) {
337 0 : if (s->errkind == MNSTR_NO__ERROR)
338 0 : mnstr_set_error(s, MNSTR_UNEXPECTED_EOF, NULL);
339 0 : return 0;
340 : }
341 485 : if (s->swapbytes) {
342 0 : for (size_t i = 0; i < cnt; i++, val++)
343 0 : *val = huge_int_SWAP(*val);
344 : }
345 : return 1;
346 : }
347 :
348 : int
349 489 : mnstr_writeHgeArray(stream *restrict s, const hge *restrict val, size_t cnt)
350 : {
351 489 : if (s == NULL || s->errkind != MNSTR_NO__ERROR || val == NULL)
352 : return 0;
353 489 : assert(s->binary);
354 489 : if (s->swapbytes) {
355 0 : for (size_t i = 0; i < cnt; i++)
356 0 : if (!mnstr_writeHge(s, val[i]))
357 : return 0;
358 : return 1;
359 : }
360 489 : return s->write(s, val, sizeof(*val), cnt) == (ssize_t) cnt;
361 : }
362 : #endif
363 :
364 : int
365 9448466 : mnstr_printf(stream *restrict s, const char *restrict format, ...)
366 : {
367 : char buf[512], *bf = buf;
368 : int i = 0;
369 : size_t bfsz = sizeof(buf);
370 : va_list ap;
371 :
372 9448466 : if (s == NULL || s->errkind != MNSTR_NO__ERROR)
373 : return -1;
374 :
375 9448426 : va_start(ap, format);
376 9448426 : i = vsnprintf(bf, bfsz, format, ap);
377 9448426 : va_end(ap);
378 9448786 : while (i < 0 || (size_t) i >= bfsz) {
379 360 : if (i >= 0) /* glibc 2.1 */
380 360 : bfsz = (size_t) i + 1; /* precisely what is needed */
381 : else /* glibc 2.0 */
382 0 : bfsz *= 2; /* twice the old size */
383 360 : if (bf != buf)
384 0 : free(bf);
385 360 : bf = malloc(bfsz);
386 360 : if (bf == NULL) {
387 0 : mnstr_set_error(s, MNSTR_WRITE_ERROR, "malloc failed");
388 0 : return -1;
389 : }
390 360 : va_start(ap, format);
391 360 : i = vsnprintf(bf, bfsz, format, ap);
392 360 : va_end(ap);
393 : }
394 9448426 : s->write(s, (void *) bf, (size_t) i, (size_t) 1);
395 9448426 : if (bf != buf)
396 360 : free(bf);
397 9448426 : return s->errkind == MNSTR_NO__ERROR ? i : -1;
398 : }
399 :
|
