projects / lttng-tools.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Update vendored msgpack-c to 4.0.0
[lttng-tools.git] / src / vendor / msgpack / pack_template.h
CommitLineData
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) \
49do { \
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) \
61do { \
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) \
78do { \
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) \
104do { \
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) \
135do { \
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) \
147do { \
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) \
177do { \
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) \
217do { \
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
277msgpack_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
283msgpack_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
290msgpack_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
297msgpack_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
304msgpack_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
310msgpack_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
317msgpack_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
324msgpack_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
335msgpack_pack_inline_func(_uint8)(msgpack_pack_user x, uint8_t d)
336{
337 msgpack_pack_real_uint8(x, d);
338}
339
340msgpack_pack_inline_func(_uint16)(msgpack_pack_user x, uint16_t d)
341{
342 msgpack_pack_real_uint16(x, d);
343}
344
345msgpack_pack_inline_func(_uint32)(msgpack_pack_user x, uint32_t d)
346{
347 msgpack_pack_real_uint32(x, d);
348}
349
350msgpack_pack_inline_func(_uint64)(msgpack_pack_user x, uint64_t d)
351{
352 msgpack_pack_real_uint64(x, d);
353}
354
355msgpack_pack_inline_func(_int8)(msgpack_pack_user x, int8_t d)
356{
357 msgpack_pack_real_int8(x, d);
358}
359
360msgpack_pack_inline_func(_int16)(msgpack_pack_user x, int16_t d)
361{
362 msgpack_pack_real_int16(x, d);
363}
364
365msgpack_pack_inline_func(_int32)(msgpack_pack_user x, int32_t d)
366{
367 msgpack_pack_real_int32(x, d);
368}
369
370msgpack_pack_inline_func(_int64)(msgpack_pack_user x, int64_t d)
371{
372 msgpack_pack_real_int64(x, d);
373}
374
375msgpack_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
388msgpack_pack_inline_func(_signed_char)(msgpack_pack_user x, signed char d)
389{
390 msgpack_pack_real_int8(x, d);
391}
392
393msgpack_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
400msgpack_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
421if(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
431msgpack_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
452if(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
462msgpack_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
483if(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
493msgpack_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
514if(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
524msgpack_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
545if(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
555msgpack_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
576if(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
586msgpack_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
607if(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
617msgpack_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
638if(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
657msgpack_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
666msgpack_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
687msgpack_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
698msgpack_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
704msgpack_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
715msgpack_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
736msgpack_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
757msgpack_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
777msgpack_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
786msgpack_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
802msgpack_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
811msgpack_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
828msgpack_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
837msgpack_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
894msgpack_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
899msgpack_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
LTTng 2.0 tools and control repository
This page took 0.06004 seconds and 4 git commands to generate.