Commit | Line | Data |
---|---|---|
116a02e3 JG |
1 | /* |
2 | * MessagePack packing routine template | |
3 | * | |
4 | * Copyright (C) 2008-2010 FURUHASHI Sadayuki | |
5 | * | |
6 | * Distributed under the Boost Software License, Version 1.0. | |
7 | * (See accompanying file LICENSE_1_0.txt or copy at | |
8 | * http://www.boost.org/LICENSE_1_0.txt) | |
9 | */ | |
10 | ||
0c07860d MJ |
11 | #include "vendor/msgpack/lttng-config.h" |
12 | ||
116a02e3 JG |
13 | #if MSGPACK_ENDIAN_LITTLE_BYTE |
14 | #define TAKE8_8(d) ((uint8_t*)&d)[0] | |
15 | #define TAKE8_16(d) ((uint8_t*)&d)[0] | |
16 | #define TAKE8_32(d) ((uint8_t*)&d)[0] | |
17 | #define TAKE8_64(d) ((uint8_t*)&d)[0] | |
18 | #elif MSGPACK_ENDIAN_BIG_BYTE | |
19 | #define TAKE8_8(d) ((uint8_t*)&d)[0] | |
20 | #define TAKE8_16(d) ((uint8_t*)&d)[1] | |
21 | #define TAKE8_32(d) ((uint8_t*)&d)[3] | |
22 | #define TAKE8_64(d) ((uint8_t*)&d)[7] | |
23 | #else | |
24 | #error msgpack-c supports only big endian and little endian | |
25 | #endif | |
26 | ||
27 | #ifndef msgpack_pack_inline_func | |
28 | #error msgpack_pack_inline_func template is not defined | |
29 | #endif | |
30 | ||
31 | #ifndef msgpack_pack_user | |
32 | #error msgpack_pack_user type is not defined | |
33 | #endif | |
34 | ||
35 | #ifndef msgpack_pack_append_buffer | |
36 | #error msgpack_pack_append_buffer callback is not defined | |
37 | #endif | |
38 | ||
39 | #if defined(_MSC_VER) | |
40 | # pragma warning(push) | |
41 | # pragma warning(disable : 4204) /* nonstandard extension used: non-constant aggregate initializer */ | |
42 | #endif | |
43 | ||
44 | /* | |
45 | * Integer | |
46 | */ | |
47 | ||
48 | #define msgpack_pack_real_uint8(x, d) \ | |
49 | do { \ | |
50 | if(d < (1<<7)) { \ | |
51 | /* fixnum */ \ | |
52 | msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); \ | |
53 | } else { \ | |
54 | /* unsigned 8 */ \ | |
55 | unsigned char buf[2] = {0xcc, TAKE8_8(d)}; \ | |
56 | msgpack_pack_append_buffer(x, buf, 2); \ | |
57 | } \ | |
58 | } while(0) | |
59 | ||
60 | #define msgpack_pack_real_uint16(x, d) \ | |
61 | do { \ | |
62 | if(d < (1<<7)) { \ | |
63 | /* fixnum */ \ | |
64 | msgpack_pack_append_buffer(x, &TAKE8_16(d), 1); \ | |
65 | } else if(d < (1<<8)) { \ | |
66 | /* unsigned 8 */ \ | |
67 | unsigned char buf[2] = {0xcc, TAKE8_16(d)}; \ | |
68 | msgpack_pack_append_buffer(x, buf, 2); \ | |
69 | } else { \ | |
70 | /* unsigned 16 */ \ | |
71 | unsigned char buf[3]; \ | |
72 | buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ | |
73 | msgpack_pack_append_buffer(x, buf, 3); \ | |
74 | } \ | |
75 | } while(0) | |
76 | ||
77 | #define msgpack_pack_real_uint32(x, d) \ | |
78 | do { \ | |
79 | if(d < (1<<8)) { \ | |
80 | if(d < (1<<7)) { \ | |
81 | /* fixnum */ \ | |
82 | msgpack_pack_append_buffer(x, &TAKE8_32(d), 1); \ | |
83 | } else { \ | |
84 | /* unsigned 8 */ \ | |
85 | unsigned char buf[2] = {0xcc, TAKE8_32(d)}; \ | |
86 | msgpack_pack_append_buffer(x, buf, 2); \ | |
87 | } \ | |
88 | } else { \ | |
89 | if(d < (1<<16)) { \ | |
90 | /* unsigned 16 */ \ | |
91 | unsigned char buf[3]; \ | |
92 | buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ | |
93 | msgpack_pack_append_buffer(x, buf, 3); \ | |
94 | } else { \ | |
95 | /* unsigned 32 */ \ | |
96 | unsigned char buf[5]; \ | |
97 | buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \ | |
98 | msgpack_pack_append_buffer(x, buf, 5); \ | |
99 | } \ | |
100 | } \ | |
101 | } while(0) | |
102 | ||
103 | #define msgpack_pack_real_uint64(x, d) \ | |
104 | do { \ | |
105 | if(d < (1ULL<<8)) { \ | |
106 | if(d < (1ULL<<7)) { \ | |
107 | /* fixnum */ \ | |
108 | msgpack_pack_append_buffer(x, &TAKE8_64(d), 1); \ | |
109 | } else { \ | |
110 | /* unsigned 8 */ \ | |
111 | unsigned char buf[2] = {0xcc, TAKE8_64(d)}; \ | |
112 | msgpack_pack_append_buffer(x, buf, 2); \ | |
113 | } \ | |
114 | } else { \ | |
115 | if(d < (1ULL<<16)) { \ | |
116 | /* unsigned 16 */ \ | |
117 | unsigned char buf[3]; \ | |
118 | buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ | |
119 | msgpack_pack_append_buffer(x, buf, 3); \ | |
120 | } else if(d < (1ULL<<32)) { \ | |
121 | /* unsigned 32 */ \ | |
122 | unsigned char buf[5]; \ | |
123 | buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \ | |
124 | msgpack_pack_append_buffer(x, buf, 5); \ | |
125 | } else { \ | |
126 | /* unsigned 64 */ \ | |
127 | unsigned char buf[9]; \ | |
128 | buf[0] = 0xcf; _msgpack_store64(&buf[1], d); \ | |
129 | msgpack_pack_append_buffer(x, buf, 9); \ | |
130 | } \ | |
131 | } \ | |
132 | } while(0) | |
133 | ||
134 | #define msgpack_pack_real_int8(x, d) \ | |
135 | do { \ | |
136 | if(d < -(1<<5)) { \ | |
137 | /* signed 8 */ \ | |
138 | unsigned char buf[2] = {0xd0, TAKE8_8(d)}; \ | |
139 | msgpack_pack_append_buffer(x, buf, 2); \ | |
140 | } else { \ | |
141 | /* fixnum */ \ | |
142 | msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); \ | |
143 | } \ | |
144 | } while(0) | |
145 | ||
146 | #define msgpack_pack_real_int16(x, d) \ | |
147 | do { \ | |
148 | if(d < -(1<<5)) { \ | |
149 | if(d < -(1<<7)) { \ | |
150 | /* signed 16 */ \ | |
151 | unsigned char buf[3]; \ | |
152 | buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \ | |
153 | msgpack_pack_append_buffer(x, buf, 3); \ | |
154 | } else { \ | |
155 | /* signed 8 */ \ | |
156 | unsigned char buf[2] = {0xd0, TAKE8_16(d)}; \ | |
157 | msgpack_pack_append_buffer(x, buf, 2); \ | |
158 | } \ | |
159 | } else if(d < (1<<7)) { \ | |
160 | /* fixnum */ \ | |
161 | msgpack_pack_append_buffer(x, &TAKE8_16(d), 1); \ | |
162 | } else { \ | |
163 | if(d < (1<<8)) { \ | |
164 | /* unsigned 8 */ \ | |
165 | unsigned char buf[2] = {0xcc, TAKE8_16(d)}; \ | |
166 | msgpack_pack_append_buffer(x, buf, 2); \ | |
167 | } else { \ | |
168 | /* unsigned 16 */ \ | |
169 | unsigned char buf[3]; \ | |
170 | buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ | |
171 | msgpack_pack_append_buffer(x, buf, 3); \ | |
172 | } \ | |
173 | } \ | |
174 | } while(0) | |
175 | ||
176 | #define msgpack_pack_real_int32(x, d) \ | |
177 | do { \ | |
178 | if(d < -(1<<5)) { \ | |
179 | if(d < -(1<<15)) { \ | |
180 | /* signed 32 */ \ | |
181 | unsigned char buf[5]; \ | |
182 | buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); \ | |
183 | msgpack_pack_append_buffer(x, buf, 5); \ | |
184 | } else if(d < -(1<<7)) { \ | |
185 | /* signed 16 */ \ | |
186 | unsigned char buf[3]; \ | |
187 | buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \ | |
188 | msgpack_pack_append_buffer(x, buf, 3); \ | |
189 | } else { \ | |
190 | /* signed 8 */ \ | |
191 | unsigned char buf[2] = {0xd0, TAKE8_32(d)}; \ | |
192 | msgpack_pack_append_buffer(x, buf, 2); \ | |
193 | } \ | |
194 | } else if(d < (1<<7)) { \ | |
195 | /* fixnum */ \ | |
196 | msgpack_pack_append_buffer(x, &TAKE8_32(d), 1); \ | |
197 | } else { \ | |
198 | if(d < (1<<8)) { \ | |
199 | /* unsigned 8 */ \ | |
200 | unsigned char buf[2] = {0xcc, TAKE8_32(d)}; \ | |
201 | msgpack_pack_append_buffer(x, buf, 2); \ | |
202 | } else if(d < (1<<16)) { \ | |
203 | /* unsigned 16 */ \ | |
204 | unsigned char buf[3]; \ | |
205 | buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ | |
206 | msgpack_pack_append_buffer(x, buf, 3); \ | |
207 | } else { \ | |
208 | /* unsigned 32 */ \ | |
209 | unsigned char buf[5]; \ | |
210 | buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \ | |
211 | msgpack_pack_append_buffer(x, buf, 5); \ | |
212 | } \ | |
213 | } \ | |
214 | } while(0) | |
215 | ||
216 | #define msgpack_pack_real_int64(x, d) \ | |
217 | do { \ | |
218 | if(d < -(1LL<<5)) { \ | |
219 | if(d < -(1LL<<15)) { \ | |
220 | if(d < -(1LL<<31)) { \ | |
221 | /* signed 64 */ \ | |
222 | unsigned char buf[9]; \ | |
223 | buf[0] = 0xd3; _msgpack_store64(&buf[1], d); \ | |
224 | msgpack_pack_append_buffer(x, buf, 9); \ | |
225 | } else { \ | |
226 | /* signed 32 */ \ | |
227 | unsigned char buf[5]; \ | |
228 | buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); \ | |
229 | msgpack_pack_append_buffer(x, buf, 5); \ | |
230 | } \ | |
231 | } else { \ | |
232 | if(d < -(1<<7)) { \ | |
233 | /* signed 16 */ \ | |
234 | unsigned char buf[3]; \ | |
235 | buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \ | |
236 | msgpack_pack_append_buffer(x, buf, 3); \ | |
237 | } else { \ | |
238 | /* signed 8 */ \ | |
239 | unsigned char buf[2] = {0xd0, TAKE8_64(d)}; \ | |
240 | msgpack_pack_append_buffer(x, buf, 2); \ | |
241 | } \ | |
242 | } \ | |
243 | } else if(d < (1<<7)) { \ | |
244 | /* fixnum */ \ | |
245 | msgpack_pack_append_buffer(x, &TAKE8_64(d), 1); \ | |
246 | } else { \ | |
247 | if(d < (1LL<<16)) { \ | |
248 | if(d < (1<<8)) { \ | |
249 | /* unsigned 8 */ \ | |
250 | unsigned char buf[2] = {0xcc, TAKE8_64(d)}; \ | |
251 | msgpack_pack_append_buffer(x, buf, 2); \ | |
252 | } else { \ | |
253 | /* unsigned 16 */ \ | |
254 | unsigned char buf[3]; \ | |
255 | buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \ | |
256 | msgpack_pack_append_buffer(x, buf, 3); \ | |
257 | } \ | |
258 | } else { \ | |
259 | if(d < (1LL<<32)) { \ | |
260 | /* unsigned 32 */ \ | |
261 | unsigned char buf[5]; \ | |
262 | buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \ | |
263 | msgpack_pack_append_buffer(x, buf, 5); \ | |
264 | } else { \ | |
265 | /* unsigned 64 */ \ | |
266 | unsigned char buf[9]; \ | |
267 | buf[0] = 0xcf; _msgpack_store64(&buf[1], d); \ | |
268 | msgpack_pack_append_buffer(x, buf, 9); \ | |
269 | } \ | |
270 | } \ | |
271 | } \ | |
272 | } while(0) | |
273 | ||
274 | ||
275 | #ifdef msgpack_pack_inline_func_fixint | |
276 | ||
277 | msgpack_pack_inline_func_fixint(_uint8)(msgpack_pack_user x, uint8_t d) | |
278 | { | |
279 | unsigned char buf[2] = {0xcc, TAKE8_8(d)}; | |
280 | msgpack_pack_append_buffer(x, buf, 2); | |
281 | } | |
282 | ||
283 | msgpack_pack_inline_func_fixint(_uint16)(msgpack_pack_user x, uint16_t d) | |
284 | { | |
285 | unsigned char buf[3]; | |
286 | buf[0] = 0xcd; _msgpack_store16(&buf[1], d); | |
287 | msgpack_pack_append_buffer(x, buf, 3); | |
288 | } | |
289 | ||
290 | msgpack_pack_inline_func_fixint(_uint32)(msgpack_pack_user x, uint32_t d) | |
291 | { | |
292 | unsigned char buf[5]; | |
293 | buf[0] = 0xce; _msgpack_store32(&buf[1], d); | |
294 | msgpack_pack_append_buffer(x, buf, 5); | |
295 | } | |
296 | ||
297 | msgpack_pack_inline_func_fixint(_uint64)(msgpack_pack_user x, uint64_t d) | |
298 | { | |
299 | unsigned char buf[9]; | |
300 | buf[0] = 0xcf; _msgpack_store64(&buf[1], d); | |
301 | msgpack_pack_append_buffer(x, buf, 9); | |
302 | } | |
303 | ||
304 | msgpack_pack_inline_func_fixint(_int8)(msgpack_pack_user x, int8_t d) | |
305 | { | |
306 | unsigned char buf[2] = {0xd0, TAKE8_8(d)}; | |
307 | msgpack_pack_append_buffer(x, buf, 2); | |
308 | } | |
309 | ||
310 | msgpack_pack_inline_func_fixint(_int16)(msgpack_pack_user x, int16_t d) | |
311 | { | |
312 | unsigned char buf[3]; | |
313 | buf[0] = 0xd1; _msgpack_store16(&buf[1], d); | |
314 | msgpack_pack_append_buffer(x, buf, 3); | |
315 | } | |
316 | ||
317 | msgpack_pack_inline_func_fixint(_int32)(msgpack_pack_user x, int32_t d) | |
318 | { | |
319 | unsigned char buf[5]; | |
320 | buf[0] = 0xd2; _msgpack_store32(&buf[1], d); | |
321 | msgpack_pack_append_buffer(x, buf, 5); | |
322 | } | |
323 | ||
324 | msgpack_pack_inline_func_fixint(_int64)(msgpack_pack_user x, int64_t d) | |
325 | { | |
326 | unsigned char buf[9]; | |
327 | buf[0] = 0xd3; _msgpack_store64(&buf[1], d); | |
328 | msgpack_pack_append_buffer(x, buf, 9); | |
329 | } | |
330 | ||
331 | #undef msgpack_pack_inline_func_fixint | |
332 | #endif | |
333 | ||
334 | ||
335 | msgpack_pack_inline_func(_uint8)(msgpack_pack_user x, uint8_t d) | |
336 | { | |
337 | msgpack_pack_real_uint8(x, d); | |
338 | } | |
339 | ||
340 | msgpack_pack_inline_func(_uint16)(msgpack_pack_user x, uint16_t d) | |
341 | { | |
342 | msgpack_pack_real_uint16(x, d); | |
343 | } | |
344 | ||
345 | msgpack_pack_inline_func(_uint32)(msgpack_pack_user x, uint32_t d) | |
346 | { | |
347 | msgpack_pack_real_uint32(x, d); | |
348 | } | |
349 | ||
350 | msgpack_pack_inline_func(_uint64)(msgpack_pack_user x, uint64_t d) | |
351 | { | |
352 | msgpack_pack_real_uint64(x, d); | |
353 | } | |
354 | ||
355 | msgpack_pack_inline_func(_int8)(msgpack_pack_user x, int8_t d) | |
356 | { | |
357 | msgpack_pack_real_int8(x, d); | |
358 | } | |
359 | ||
360 | msgpack_pack_inline_func(_int16)(msgpack_pack_user x, int16_t d) | |
361 | { | |
362 | msgpack_pack_real_int16(x, d); | |
363 | } | |
364 | ||
365 | msgpack_pack_inline_func(_int32)(msgpack_pack_user x, int32_t d) | |
366 | { | |
367 | msgpack_pack_real_int32(x, d); | |
368 | } | |
369 | ||
370 | msgpack_pack_inline_func(_int64)(msgpack_pack_user x, int64_t d) | |
371 | { | |
372 | msgpack_pack_real_int64(x, d); | |
373 | } | |
374 | ||
375 | msgpack_pack_inline_func(_char)(msgpack_pack_user x, char d) | |
376 | { | |
377 | #if defined(CHAR_MIN) | |
378 | #if CHAR_MIN < 0 | |
379 | msgpack_pack_real_int8(x, d); | |
380 | #else | |
381 | msgpack_pack_real_uint8(x, d); | |
382 | #endif | |
383 | #else | |
384 | #error CHAR_MIN is not defined | |
385 | #endif | |
386 | } | |
387 | ||
388 | msgpack_pack_inline_func(_signed_char)(msgpack_pack_user x, signed char d) | |
389 | { | |
390 | msgpack_pack_real_int8(x, d); | |
391 | } | |
392 | ||
393 | msgpack_pack_inline_func(_unsigned_char)(msgpack_pack_user x, unsigned char d) | |
394 | { | |
395 | msgpack_pack_real_uint8(x, d); | |
396 | } | |
397 | ||
398 | #ifdef msgpack_pack_inline_func_cint | |
399 | ||
400 | msgpack_pack_inline_func_cint(_short)(msgpack_pack_user x, short d) | |
401 | { | |
402 | #if defined(SIZEOF_SHORT) | |
403 | #if SIZEOF_SHORT == 2 | |
404 | msgpack_pack_real_int16(x, d); | |
405 | #elif SIZEOF_SHORT == 4 | |
406 | msgpack_pack_real_int32(x, d); | |
407 | #else | |
408 | msgpack_pack_real_int64(x, d); | |
409 | #endif | |
410 | ||
411 | #elif defined(SHRT_MAX) | |
412 | #if SHRT_MAX == 0x7fff | |
413 | msgpack_pack_real_int16(x, d); | |
414 | #elif SHRT_MAX == 0x7fffffff | |
415 | msgpack_pack_real_int32(x, d); | |
416 | #else | |
417 | msgpack_pack_real_int64(x, d); | |
418 | #endif | |
419 | ||
420 | #else | |
421 | if(sizeof(short) == 2) { | |
422 | msgpack_pack_real_int16(x, d); | |
423 | } else if(sizeof(short) == 4) { | |
424 | msgpack_pack_real_int32(x, d); | |
425 | } else { | |
426 | msgpack_pack_real_int64(x, d); | |
427 | } | |
428 | #endif | |
429 | } | |
430 | ||
431 | msgpack_pack_inline_func_cint(_int)(msgpack_pack_user x, int d) | |
432 | { | |
433 | #if defined(SIZEOF_INT) | |
434 | #if SIZEOF_INT == 2 | |
435 | msgpack_pack_real_int16(x, d); | |
436 | #elif SIZEOF_INT == 4 | |
437 | msgpack_pack_real_int32(x, d); | |
438 | #else | |
439 | msgpack_pack_real_int64(x, d); | |
440 | #endif | |
441 | ||
442 | #elif defined(INT_MAX) | |
443 | #if INT_MAX == 0x7fff | |
444 | msgpack_pack_real_int16(x, d); | |
445 | #elif INT_MAX == 0x7fffffff | |
446 | msgpack_pack_real_int32(x, d); | |
447 | #else | |
448 | msgpack_pack_real_int64(x, d); | |
449 | #endif | |
450 | ||
451 | #else | |
452 | if(sizeof(int) == 2) { | |
453 | msgpack_pack_real_int16(x, d); | |
454 | } else if(sizeof(int) == 4) { | |
455 | msgpack_pack_real_int32(x, d); | |
456 | } else { | |
457 | msgpack_pack_real_int64(x, d); | |
458 | } | |
459 | #endif | |
460 | } | |
461 | ||
462 | msgpack_pack_inline_func_cint(_long)(msgpack_pack_user x, long d) | |
463 | { | |
464 | #if defined(SIZEOF_LONG) | |
465 | #if SIZEOF_LONG == 2 | |
466 | msgpack_pack_real_int16(x, d); | |
467 | #elif SIZEOF_LONG == 4 | |
468 | msgpack_pack_real_int32(x, d); | |
469 | #else | |
470 | msgpack_pack_real_int64(x, d); | |
471 | #endif | |
472 | ||
473 | #elif defined(LONG_MAX) | |
474 | #if LONG_MAX == 0x7fffL | |
475 | msgpack_pack_real_int16(x, d); | |
476 | #elif LONG_MAX == 0x7fffffffL | |
477 | msgpack_pack_real_int32(x, d); | |
478 | #else | |
479 | msgpack_pack_real_int64(x, d); | |
480 | #endif | |
481 | ||
482 | #else | |
483 | if(sizeof(long) == 2) { | |
484 | msgpack_pack_real_int16(x, d); | |
485 | } else if(sizeof(long) == 4) { | |
486 | msgpack_pack_real_int32(x, d); | |
487 | } else { | |
488 | msgpack_pack_real_int64(x, d); | |
489 | } | |
490 | #endif | |
491 | } | |
492 | ||
493 | msgpack_pack_inline_func_cint(_long_long)(msgpack_pack_user x, long long d) | |
494 | { | |
495 | #if defined(SIZEOF_LONG_LONG) | |
496 | #if SIZEOF_LONG_LONG == 2 | |
497 | msgpack_pack_real_int16(x, d); | |
498 | #elif SIZEOF_LONG_LONG == 4 | |
499 | msgpack_pack_real_int32(x, d); | |
500 | #else | |
501 | msgpack_pack_real_int64(x, d); | |
502 | #endif | |
503 | ||
504 | #elif defined(LLONG_MAX) | |
505 | #if LLONG_MAX == 0x7fffL | |
506 | msgpack_pack_real_int16(x, d); | |
507 | #elif LLONG_MAX == 0x7fffffffL | |
508 | msgpack_pack_real_int32(x, d); | |
509 | #else | |
510 | msgpack_pack_real_int64(x, d); | |
511 | #endif | |
512 | ||
513 | #else | |
514 | if(sizeof(long long) == 2) { | |
515 | msgpack_pack_real_int16(x, d); | |
516 | } else if(sizeof(long long) == 4) { | |
517 | msgpack_pack_real_int32(x, d); | |
518 | } else { | |
519 | msgpack_pack_real_int64(x, d); | |
520 | } | |
521 | #endif | |
522 | } | |
523 | ||
524 | msgpack_pack_inline_func_cint(_unsigned_short)(msgpack_pack_user x, unsigned short d) | |
525 | { | |
526 | #if defined(SIZEOF_SHORT) | |
527 | #if SIZEOF_SHORT == 2 | |
528 | msgpack_pack_real_uint16(x, d); | |
529 | #elif SIZEOF_SHORT == 4 | |
530 | msgpack_pack_real_uint32(x, d); | |
531 | #else | |
532 | msgpack_pack_real_uint64(x, d); | |
533 | #endif | |
534 | ||
535 | #elif defined(USHRT_MAX) | |
536 | #if USHRT_MAX == 0xffffU | |
537 | msgpack_pack_real_uint16(x, d); | |
538 | #elif USHRT_MAX == 0xffffffffU | |
539 | msgpack_pack_real_uint32(x, d); | |
540 | #else | |
541 | msgpack_pack_real_uint64(x, d); | |
542 | #endif | |
543 | ||
544 | #else | |
545 | if(sizeof(unsigned short) == 2) { | |
546 | msgpack_pack_real_uint16(x, d); | |
547 | } else if(sizeof(unsigned short) == 4) { | |
548 | msgpack_pack_real_uint32(x, d); | |
549 | } else { | |
550 | msgpack_pack_real_uint64(x, d); | |
551 | } | |
552 | #endif | |
553 | } | |
554 | ||
555 | msgpack_pack_inline_func_cint(_unsigned_int)(msgpack_pack_user x, unsigned int d) | |
556 | { | |
557 | #if defined(SIZEOF_INT) | |
558 | #if SIZEOF_INT == 2 | |
559 | msgpack_pack_real_uint16(x, d); | |
560 | #elif SIZEOF_INT == 4 | |
561 | msgpack_pack_real_uint32(x, d); | |
562 | #else | |
563 | msgpack_pack_real_uint64(x, d); | |
564 | #endif | |
565 | ||
566 | #elif defined(UINT_MAX) | |
567 | #if UINT_MAX == 0xffffU | |
568 | msgpack_pack_real_uint16(x, d); | |
569 | #elif UINT_MAX == 0xffffffffU | |
570 | msgpack_pack_real_uint32(x, d); | |
571 | #else | |
572 | msgpack_pack_real_uint64(x, d); | |
573 | #endif | |
574 | ||
575 | #else | |
576 | if(sizeof(unsigned int) == 2) { | |
577 | msgpack_pack_real_uint16(x, d); | |
578 | } else if(sizeof(unsigned int) == 4) { | |
579 | msgpack_pack_real_uint32(x, d); | |
580 | } else { | |
581 | msgpack_pack_real_uint64(x, d); | |
582 | } | |
583 | #endif | |
584 | } | |
585 | ||
586 | msgpack_pack_inline_func_cint(_unsigned_long)(msgpack_pack_user x, unsigned long d) | |
587 | { | |
588 | #if defined(SIZEOF_LONG) | |
589 | #if SIZEOF_LONG == 2 | |
590 | msgpack_pack_real_uint16(x, d); | |
591 | #elif SIZEOF_LONG == 4 | |
592 | msgpack_pack_real_uint32(x, d); | |
593 | #else | |
594 | msgpack_pack_real_uint64(x, d); | |
595 | #endif | |
596 | ||
597 | #elif defined(ULONG_MAX) | |
598 | #if ULONG_MAX == 0xffffUL | |
599 | msgpack_pack_real_uint16(x, d); | |
600 | #elif ULONG_MAX == 0xffffffffUL | |
601 | msgpack_pack_real_uint32(x, d); | |
602 | #else | |
603 | msgpack_pack_real_uint64(x, d); | |
604 | #endif | |
605 | ||
606 | #else | |
607 | if(sizeof(unsigned long) == 2) { | |
608 | msgpack_pack_real_uint16(x, d); | |
609 | } else if(sizeof(unsigned long) == 4) { | |
610 | msgpack_pack_real_uint32(x, d); | |
611 | } else { | |
612 | msgpack_pack_real_uint64(x, d); | |
613 | } | |
614 | #endif | |
615 | } | |
616 | ||
617 | msgpack_pack_inline_func_cint(_unsigned_long_long)(msgpack_pack_user x, unsigned long long d) | |
618 | { | |
619 | #if defined(SIZEOF_LONG_LONG) | |
620 | #if SIZEOF_LONG_LONG == 2 | |
621 | msgpack_pack_real_uint16(x, d); | |
622 | #elif SIZEOF_LONG_LONG == 4 | |
623 | msgpack_pack_real_uint32(x, d); | |
624 | #else | |
625 | msgpack_pack_real_uint64(x, d); | |
626 | #endif | |
627 | ||
628 | #elif defined(ULLONG_MAX) | |
629 | #if ULLONG_MAX == 0xffffUL | |
630 | msgpack_pack_real_uint16(x, d); | |
631 | #elif ULLONG_MAX == 0xffffffffUL | |
632 | msgpack_pack_real_uint32(x, d); | |
633 | #else | |
634 | msgpack_pack_real_uint64(x, d); | |
635 | #endif | |
636 | ||
637 | #else | |
638 | if(sizeof(unsigned long long) == 2) { | |
639 | msgpack_pack_real_uint16(x, d); | |
640 | } else if(sizeof(unsigned long long) == 4) { | |
641 | msgpack_pack_real_uint32(x, d); | |
642 | } else { | |
643 | msgpack_pack_real_uint64(x, d); | |
644 | } | |
645 | #endif | |
646 | } | |
647 | ||
648 | #undef msgpack_pack_inline_func_cint | |
649 | #endif | |
650 | ||
651 | ||
652 | ||
653 | /* | |
654 | * Float | |
655 | */ | |
656 | ||
657 | msgpack_pack_inline_func(_float)(msgpack_pack_user x, float d) | |
658 | { | |
659 | unsigned char buf[5]; | |
660 | union { float f; uint32_t i; } mem; | |
661 | mem.f = d; | |
662 | buf[0] = 0xca; _msgpack_store32(&buf[1], mem.i); | |
663 | msgpack_pack_append_buffer(x, buf, 5); | |
664 | } | |
665 | ||
666 | msgpack_pack_inline_func(_double)(msgpack_pack_user x, double d) | |
667 | { | |
668 | unsigned char buf[9]; | |
669 | union { double f; uint64_t i; } mem; | |
670 | mem.f = d; | |
671 | buf[0] = 0xcb; | |
672 | #if defined(TARGET_OS_IPHONE) | |
673 | // ok | |
674 | #elif defined(__arm__) && !(__ARM_EABI__) // arm-oabi | |
675 | // https://github.com/msgpack/msgpack-perl/pull/1 | |
676 | mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL); | |
677 | #endif | |
678 | _msgpack_store64(&buf[1], mem.i); | |
679 | msgpack_pack_append_buffer(x, buf, 9); | |
680 | } | |
681 | ||
682 | ||
683 | /* | |
684 | * Nil | |
685 | */ | |
686 | ||
687 | msgpack_pack_inline_func(_nil)(msgpack_pack_user x) | |
688 | { | |
689 | static const unsigned char d = 0xc0; | |
690 | msgpack_pack_append_buffer(x, &d, 1); | |
691 | } | |
692 | ||
693 | ||
694 | /* | |
695 | * Boolean | |
696 | */ | |
697 | ||
698 | msgpack_pack_inline_func(_true)(msgpack_pack_user x) | |
699 | { | |
700 | static const unsigned char d = 0xc3; | |
701 | msgpack_pack_append_buffer(x, &d, 1); | |
702 | } | |
703 | ||
704 | msgpack_pack_inline_func(_false)(msgpack_pack_user x) | |
705 | { | |
706 | static const unsigned char d = 0xc2; | |
707 | msgpack_pack_append_buffer(x, &d, 1); | |
708 | } | |
709 | ||
710 | ||
711 | /* | |
712 | * Array | |
713 | */ | |
714 | ||
715 | msgpack_pack_inline_func(_array)(msgpack_pack_user x, size_t n) | |
716 | { | |
717 | if(n < 16) { | |
718 | unsigned char d = 0x90 | (uint8_t)n; | |
719 | msgpack_pack_append_buffer(x, &d, 1); | |
720 | } else if(n < 65536) { | |
721 | unsigned char buf[3]; | |
722 | buf[0] = 0xdc; _msgpack_store16(&buf[1], (uint16_t)n); | |
723 | msgpack_pack_append_buffer(x, buf, 3); | |
724 | } else { | |
725 | unsigned char buf[5]; | |
726 | buf[0] = 0xdd; _msgpack_store32(&buf[1], (uint32_t)n); | |
727 | msgpack_pack_append_buffer(x, buf, 5); | |
728 | } | |
729 | } | |
730 | ||
731 | ||
732 | /* | |
733 | * Map | |
734 | */ | |
735 | ||
736 | msgpack_pack_inline_func(_map)(msgpack_pack_user x, size_t n) | |
737 | { | |
738 | if(n < 16) { | |
739 | unsigned char d = 0x80 | (uint8_t)n; | |
740 | msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); | |
741 | } else if(n < 65536) { | |
742 | unsigned char buf[3]; | |
743 | buf[0] = 0xde; _msgpack_store16(&buf[1], (uint16_t)n); | |
744 | msgpack_pack_append_buffer(x, buf, 3); | |
745 | } else { | |
746 | unsigned char buf[5]; | |
747 | buf[0] = 0xdf; _msgpack_store32(&buf[1], (uint32_t)n); | |
748 | msgpack_pack_append_buffer(x, buf, 5); | |
749 | } | |
750 | } | |
751 | ||
752 | ||
753 | /* | |
754 | * Str | |
755 | */ | |
756 | ||
757 | msgpack_pack_inline_func(_str)(msgpack_pack_user x, size_t l) | |
758 | { | |
759 | if(l < 32) { | |
760 | unsigned char d = 0xa0 | (uint8_t)l; | |
761 | msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); | |
762 | } else if(l < 256) { | |
763 | unsigned char buf[2]; | |
764 | buf[0] = 0xd9; buf[1] = (uint8_t)l; | |
765 | msgpack_pack_append_buffer(x, buf, 2); | |
766 | } else if(l < 65536) { | |
767 | unsigned char buf[3]; | |
768 | buf[0] = 0xda; _msgpack_store16(&buf[1], (uint16_t)l); | |
769 | msgpack_pack_append_buffer(x, buf, 3); | |
770 | } else { | |
771 | unsigned char buf[5]; | |
772 | buf[0] = 0xdb; _msgpack_store32(&buf[1], (uint32_t)l); | |
773 | msgpack_pack_append_buffer(x, buf, 5); | |
774 | } | |
775 | } | |
776 | ||
777 | msgpack_pack_inline_func(_str_body)(msgpack_pack_user x, const void* b, size_t l) | |
778 | { | |
779 | msgpack_pack_append_buffer(x, (const unsigned char*)b, l); | |
780 | } | |
781 | ||
782 | /* | |
783 | * Raw (V4) | |
784 | */ | |
785 | ||
786 | msgpack_pack_inline_func(_v4raw)(msgpack_pack_user x, size_t l) | |
787 | { | |
788 | if(l < 32) { | |
789 | unsigned char d = 0xa0 | (uint8_t)l; | |
790 | msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); | |
791 | } else if(l < 65536) { | |
792 | unsigned char buf[3]; | |
793 | buf[0] = 0xda; _msgpack_store16(&buf[1], (uint16_t)l); | |
794 | msgpack_pack_append_buffer(x, buf, 3); | |
795 | } else { | |
796 | unsigned char buf[5]; | |
797 | buf[0] = 0xdb; _msgpack_store32(&buf[1], (uint32_t)l); | |
798 | msgpack_pack_append_buffer(x, buf, 5); | |
799 | } | |
800 | } | |
801 | ||
802 | msgpack_pack_inline_func(_v4raw_body)(msgpack_pack_user x, const void* b, size_t l) | |
803 | { | |
804 | msgpack_pack_append_buffer(x, (const unsigned char*)b, l); | |
805 | } | |
806 | ||
807 | /* | |
808 | * Bin | |
809 | */ | |
810 | ||
811 | msgpack_pack_inline_func(_bin)(msgpack_pack_user x, size_t l) | |
812 | { | |
813 | if(l < 256) { | |
814 | unsigned char buf[2]; | |
815 | buf[0] = 0xc4; buf[1] = (uint8_t)l; | |
816 | msgpack_pack_append_buffer(x, buf, 2); | |
817 | } else if(l < 65536) { | |
818 | unsigned char buf[3]; | |
819 | buf[0] = 0xc5; _msgpack_store16(&buf[1], (uint16_t)l); | |
820 | msgpack_pack_append_buffer(x, buf, 3); | |
821 | } else { | |
822 | unsigned char buf[5]; | |
823 | buf[0] = 0xc6; _msgpack_store32(&buf[1], (uint32_t)l); | |
824 | msgpack_pack_append_buffer(x, buf, 5); | |
825 | } | |
826 | } | |
827 | ||
828 | msgpack_pack_inline_func(_bin_body)(msgpack_pack_user x, const void* b, size_t l) | |
829 | { | |
830 | msgpack_pack_append_buffer(x, (const unsigned char*)b, l); | |
831 | } | |
832 | ||
833 | /* | |
834 | * Ext | |
835 | */ | |
836 | ||
837 | msgpack_pack_inline_func(_ext)(msgpack_pack_user x, size_t l, int8_t type) | |
838 | { | |
839 | switch(l) { | |
840 | case 1: { | |
841 | unsigned char buf[2]; | |
842 | buf[0] = 0xd4; | |
843 | buf[1] = (unsigned char)type; | |
844 | msgpack_pack_append_buffer(x, buf, 2); | |
845 | } break; | |
846 | case 2: { | |
847 | unsigned char buf[2]; | |
848 | buf[0] = 0xd5; | |
849 | buf[1] = (unsigned char)type; | |
850 | msgpack_pack_append_buffer(x, buf, 2); | |
851 | } break; | |
852 | case 4: { | |
853 | unsigned char buf[2]; | |
854 | buf[0] = 0xd6; | |
855 | buf[1] = (unsigned char)type; | |
856 | msgpack_pack_append_buffer(x, buf, 2); | |
857 | } break; | |
858 | case 8: { | |
859 | unsigned char buf[2]; | |
860 | buf[0] = 0xd7; | |
861 | buf[1] = (unsigned char)type; | |
862 | msgpack_pack_append_buffer(x, buf, 2); | |
863 | } break; | |
864 | case 16: { | |
865 | unsigned char buf[2]; | |
866 | buf[0] = 0xd8; | |
867 | buf[1] = (unsigned char)type; | |
868 | msgpack_pack_append_buffer(x, buf, 2); | |
869 | } break; | |
870 | default: | |
871 | if(l < 256) { | |
872 | unsigned char buf[3]; | |
873 | buf[0] = 0xc7; | |
874 | buf[1] = (unsigned char)l; | |
875 | buf[2] = (unsigned char)type; | |
876 | msgpack_pack_append_buffer(x, buf, 3); | |
877 | } else if(l < 65536) { | |
878 | unsigned char buf[4]; | |
879 | buf[0] = 0xc8; | |
880 | _msgpack_store16(&buf[1], l); | |
881 | buf[3] = (unsigned char)type; | |
882 | msgpack_pack_append_buffer(x, buf, 4); | |
883 | } else { | |
884 | unsigned char buf[6]; | |
885 | buf[0] = 0xc9; | |
886 | _msgpack_store32(&buf[1], l); | |
887 | buf[5] = (unsigned char)type; | |
888 | msgpack_pack_append_buffer(x, buf, 6); | |
889 | } | |
890 | break; | |
891 | } | |
892 | } | |
893 | ||
894 | msgpack_pack_inline_func(_ext_body)(msgpack_pack_user x, const void* b, size_t l) | |
895 | { | |
896 | msgpack_pack_append_buffer(x, (const unsigned char*)b, l); | |
897 | } | |
898 | ||
899 | msgpack_pack_inline_func(_timestamp)(msgpack_pack_user x, const msgpack_timestamp* d) | |
900 | { | |
901 | if ((((int64_t)d->tv_sec) >> 34) == 0) { | |
902 | uint64_t data64 = ((uint64_t) d->tv_nsec << 34) | (uint64_t)d->tv_sec; | |
903 | if ((data64 & 0xffffffff00000000L) == 0) { | |
904 | // timestamp 32 | |
905 | char buf[4]; | |
906 | uint32_t data32 = (uint32_t)data64; | |
907 | msgpack_pack_ext(x, 4, -1); | |
908 | _msgpack_store32(buf, data32); | |
909 | msgpack_pack_append_buffer(x, buf, 4); | |
910 | } else { | |
911 | // timestamp 64 | |
912 | char buf[8]; | |
913 | msgpack_pack_ext(x, 8, -1); | |
914 | _msgpack_store64(buf, data64); | |
915 | msgpack_pack_append_buffer(x, buf, 8); | |
916 | } | |
917 | } else { | |
918 | // timestamp 96 | |
919 | char buf[12]; | |
920 | _msgpack_store32(&buf[0], d->tv_nsec); | |
921 | _msgpack_store64(&buf[4], d->tv_sec); | |
922 | msgpack_pack_ext(x, 12, -1); | |
923 | msgpack_pack_append_buffer(x, buf, 12); | |
924 | } | |
925 | } | |
926 | ||
927 | #undef msgpack_pack_inline_func | |
928 | #undef msgpack_pack_user | |
929 | #undef msgpack_pack_append_buffer | |
930 | ||
931 | #undef TAKE8_8 | |
932 | #undef TAKE8_16 | |
933 | #undef TAKE8_32 | |
934 | #undef TAKE8_64 | |
935 | ||
936 | #undef msgpack_pack_real_uint8 | |
937 | #undef msgpack_pack_real_uint16 | |
938 | #undef msgpack_pack_real_uint32 | |
939 | #undef msgpack_pack_real_uint64 | |
940 | #undef msgpack_pack_real_int8 | |
941 | #undef msgpack_pack_real_int16 | |
942 | #undef msgpack_pack_real_int32 | |
943 | #undef msgpack_pack_real_int64 | |
944 | ||
945 | #if defined(_MSC_VER) | |
946 | # pragma warning(pop) | |
947 | #endif |