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