1 /*
2 * MessagePack packing routine template
3 *
4 * Copyright (C) 2008-2010 FURUHASHI Sadayuki
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 */
18
19 #if defined(__LITTLE_ENDIAN__)
20 #define TAKE8_8(d) ((uint8_t*)&d)[0]
21 #define TAKE8_16(d) ((uint8_t*)&d)[0]
22 #define TAKE8_32(d) ((uint8_t*)&d)[0]
23 #define TAKE8_64(d) ((uint8_t*)&d)[0]
24 #elif defined(__BIG_ENDIAN__)
25 #define TAKE8_8(d) ((uint8_t*)&d)[0]
26 #define TAKE8_16(d) ((uint8_t*)&d)[1]
27 #define TAKE8_32(d) ((uint8_t*)&d)[3]
28 #define TAKE8_64(d) ((uint8_t*)&d)[7]
29 #endif
30
31 #ifndef msgpack_pack_append_buffer
32 #error msgpack_pack_append_buffer callback is not defined
33 #endif
34
35
36 /*
37 * Integer
38 */
39
40 #define msgpack_pack_real_uint8(x, d) \
41 do { \
42 if(d < (1<<7)) { \
43 /* fixnum */ \
44 msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); \
45 } else { \
46 /* unsigned 8 */ \
47 unsigned char buf[2] = {0xcc, TAKE8_8(d)}; \
48 msgpack_pack_append_buffer(x, buf, 2); \
49 } \
50 } while(0)
51
52 #define msgpack_pack_real_uint16(x, d) \
53 do { \
54 if(d < (1<<7)) { \
55 /* fixnum */ \
56 msgpack_pack_append_buffer(x, &TAKE8_16(d), 1); \
57 } else if(d < (1<<8)) { \
58 /* unsigned 8 */ \
59 unsigned char buf[2] = {0xcc, TAKE8_16(d)}; \
60 msgpack_pack_append_buffer(x, buf, 2); \
61 } else { \
62 /* unsigned 16 */ \
63 unsigned char buf[3]; \
64 buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
65 msgpack_pack_append_buffer(x, buf, 3); \
66 } \
67 } while(0)
68
69 #define msgpack_pack_real_uint32(x, d) \
70 do { \
71 if(d < (1<<8)) { \
72 if(d < (1<<7)) { \
73 /* fixnum */ \
74 msgpack_pack_append_buffer(x, &TAKE8_32(d), 1); \
75 } else { \
76 /* unsigned 8 */ \
77 unsigned char buf[2] = {0xcc, TAKE8_32(d)}; \
78 msgpack_pack_append_buffer(x, buf, 2); \
79 } \
80 } else { \
81 if(d < (1<<16)) { \
82 /* unsigned 16 */ \
83 unsigned char buf[3]; \
84 buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
85 msgpack_pack_append_buffer(x, buf, 3); \
86 } else { \
87 /* unsigned 32 */ \
88 unsigned char buf[5]; \
89 buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \
90 msgpack_pack_append_buffer(x, buf, 5); \
91 } \
92 } \
93 } while(0)
94
95 #define msgpack_pack_real_uint64(x, d) \
96 do { \
97 if(d < (1ULL<<8)) { \
98 if(d < (1ULL<<7)) { \
99 /* fixnum */ \
100 msgpack_pack_append_buffer(x, &TAKE8_64(d), 1); \
101 } else { \
102 /* unsigned 8 */ \
103 unsigned char buf[2] = {0xcc, TAKE8_64(d)}; \
104 msgpack_pack_append_buffer(x, buf, 2); \
105 } \
106 } else { \
107 if(d < (1ULL<<16)) { \
108 /* unsigned 16 */ \
109 unsigned char buf[3]; \
110 buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
111 msgpack_pack_append_buffer(x, buf, 3); \
112 } else if(d < (1ULL<<32)) { \
113 /* unsigned 32 */ \
114 unsigned char buf[5]; \
115 buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \
116 msgpack_pack_append_buffer(x, buf, 5); \
117 } else { \
118 /* unsigned 64 */ \
119 unsigned char buf[9]; \
120 buf[0] = 0xcf; _msgpack_store64(&buf[1], d); \
121 msgpack_pack_append_buffer(x, buf, 9); \
122 } \
123 } \
124 } while(0)
125
126 #define msgpack_pack_real_int8(x, d) \
127 do { \
128 if(d < -(1<<5)) { \
129 /* signed 8 */ \
130 unsigned char buf[2] = {0xd0, TAKE8_8(d)}; \
131 msgpack_pack_append_buffer(x, buf, 2); \
132 } else { \
133 /* fixnum */ \
134 msgpack_pack_append_buffer(x, &TAKE8_8(d), 1); \
135 } \
136 } while(0)
137
138 #define msgpack_pack_real_int16(x, d) \
139 do { \
140 if(d < -(1<<5)) { \
141 if(d < -(1<<7)) { \
142 /* signed 16 */ \
143 unsigned char buf[3]; \
144 buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \
145 msgpack_pack_append_buffer(x, buf, 3); \
146 } else { \
147 /* signed 8 */ \
148 unsigned char buf[2] = {0xd0, TAKE8_16(d)}; \
149 msgpack_pack_append_buffer(x, buf, 2); \
150 } \
151 } else if(d < (1<<7)) { \
152 /* fixnum */ \
153 msgpack_pack_append_buffer(x, &TAKE8_16(d), 1); \
154 } else { \
155 if(d < (1<<8)) { \
156 /* unsigned 8 */ \
157 unsigned char buf[2] = {0xcc, TAKE8_16(d)}; \
158 msgpack_pack_append_buffer(x, buf, 2); \
159 } else { \
160 /* unsigned 16 */ \
161 unsigned char buf[3]; \
162 buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
163 msgpack_pack_append_buffer(x, buf, 3); \
164 } \
165 } \
166 } while(0)
167
168 #define msgpack_pack_real_int32(x, d) \
169 do { \
170 if(d < -(1<<5)) { \
171 if(d < -(1<<15)) { \
172 /* signed 32 */ \
173 unsigned char buf[5]; \
174 buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); \
175 msgpack_pack_append_buffer(x, buf, 5); \
176 } else if(d < -(1<<7)) { \
177 /* signed 16 */ \
178 unsigned char buf[3]; \
179 buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \
180 msgpack_pack_append_buffer(x, buf, 3); \
181 } else { \
182 /* signed 8 */ \
183 unsigned char buf[2] = {0xd0, TAKE8_32(d)}; \
184 msgpack_pack_append_buffer(x, buf, 2); \
185 } \
186 } else if(d < (1<<7)) { \
187 /* fixnum */ \
188 msgpack_pack_append_buffer(x, &TAKE8_32(d), 1); \
189 } else { \
190 if(d < (1<<8)) { \
191 /* unsigned 8 */ \
192 unsigned char buf[2] = {0xcc, TAKE8_32(d)}; \
193 msgpack_pack_append_buffer(x, buf, 2); \
194 } else if(d < (1<<16)) { \
195 /* unsigned 16 */ \
196 unsigned char buf[3]; \
197 buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
198 msgpack_pack_append_buffer(x, buf, 3); \
199 } else { \
200 /* unsigned 32 */ \
201 unsigned char buf[5]; \
202 buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \
203 msgpack_pack_append_buffer(x, buf, 5); \
204 } \
205 } \
206 } while(0)
207
208 #define msgpack_pack_real_int64(x, d) \
209 do { \
210 if(d < -(1LL<<5)) { \
211 if(d < -(1LL<<15)) { \
212 if(d < -(1LL<<31)) { \
213 /* signed 64 */ \
214 unsigned char buf[9]; \
215 buf[0] = 0xd3; _msgpack_store64(&buf[1], d); \
216 msgpack_pack_append_buffer(x, buf, 9); \
217 } else { \
218 /* signed 32 */ \
219 unsigned char buf[5]; \
220 buf[0] = 0xd2; _msgpack_store32(&buf[1], (int32_t)d); \
221 msgpack_pack_append_buffer(x, buf, 5); \
222 } \
223 } else { \
224 if(d < -(1<<7)) { \
225 /* signed 16 */ \
226 unsigned char buf[3]; \
227 buf[0] = 0xd1; _msgpack_store16(&buf[1], (int16_t)d); \
228 msgpack_pack_append_buffer(x, buf, 3); \
229 } else { \
230 /* signed 8 */ \
231 unsigned char buf[2] = {0xd0, TAKE8_64(d)}; \
232 msgpack_pack_append_buffer(x, buf, 2); \
233 } \
234 } \
235 } else if(d < (1<<7)) { \
236 /* fixnum */ \
237 msgpack_pack_append_buffer(x, &TAKE8_64(d), 1); \
238 } else { \
239 if(d < (1LL<<16)) { \
240 if(d < (1<<8)) { \
241 /* unsigned 8 */ \
242 unsigned char buf[2] = {0xcc, TAKE8_64(d)}; \
243 msgpack_pack_append_buffer(x, buf, 2); \
244 } else { \
245 /* unsigned 16 */ \
246 unsigned char buf[3]; \
247 buf[0] = 0xcd; _msgpack_store16(&buf[1], (uint16_t)d); \
248 msgpack_pack_append_buffer(x, buf, 3); \
249 } \
250 } else { \
251 if(d < (1LL<<32)) { \
252 /* unsigned 32 */ \
253 unsigned char buf[5]; \
254 buf[0] = 0xce; _msgpack_store32(&buf[1], (uint32_t)d); \
255 msgpack_pack_append_buffer(x, buf, 5); \
256 } else { \
257 /* unsigned 64 */ \
258 unsigned char buf[9]; \
259 buf[0] = 0xcf; _msgpack_store64(&buf[1], d); \
260 msgpack_pack_append_buffer(x, buf, 9); \
261 } \
262 } \
263 } \
264 } while(0)
265
266
msgpack_pack_uint8(msgpack_packer * x,uint8_t d)267 static inline int msgpack_pack_uint8(msgpack_packer* x, uint8_t d)
268 {
269 msgpack_pack_real_uint8(x, d);
270 }
271
msgpack_pack_uint16(msgpack_packer * x,uint16_t d)272 static inline int msgpack_pack_uint16(msgpack_packer* x, uint16_t d)
273 {
274 msgpack_pack_real_uint16(x, d);
275 }
276
msgpack_pack_uint32(msgpack_packer * x,uint32_t d)277 static inline int msgpack_pack_uint32(msgpack_packer* x, uint32_t d)
278 {
279 msgpack_pack_real_uint32(x, d);
280 }
281
msgpack_pack_uint64(msgpack_packer * x,uint64_t d)282 static inline int msgpack_pack_uint64(msgpack_packer* x, uint64_t d)
283 {
284 msgpack_pack_real_uint64(x, d);
285 }
286
msgpack_pack_int8(msgpack_packer * x,int8_t d)287 static inline int msgpack_pack_int8(msgpack_packer* x, int8_t d)
288 {
289 msgpack_pack_real_int8(x, d);
290 }
291
msgpack_pack_int16(msgpack_packer * x,int16_t d)292 static inline int msgpack_pack_int16(msgpack_packer* x, int16_t d)
293 {
294 msgpack_pack_real_int16(x, d);
295 }
296
msgpack_pack_int32(msgpack_packer * x,int32_t d)297 static inline int msgpack_pack_int32(msgpack_packer* x, int32_t d)
298 {
299 msgpack_pack_real_int32(x, d);
300 }
301
msgpack_pack_int64(msgpack_packer * x,int64_t d)302 static inline int msgpack_pack_int64(msgpack_packer* x, int64_t d)
303 {
304 msgpack_pack_real_int64(x, d);
305 }
306
307
308 //#ifdef msgpack_pack_inline_func_cint
309
msgpack_pack_short(msgpack_packer * x,short d)310 static inline int msgpack_pack_short(msgpack_packer* x, short d)
311 {
312 #if defined(SIZEOF_SHORT)
313 #if SIZEOF_SHORT == 2
314 msgpack_pack_real_int16(x, d);
315 #elif SIZEOF_SHORT == 4
316 msgpack_pack_real_int32(x, d);
317 #else
318 msgpack_pack_real_int64(x, d);
319 #endif
320
321 #elif defined(SHRT_MAX)
322 #if SHRT_MAX == 0x7fff
323 msgpack_pack_real_int16(x, d);
324 #elif SHRT_MAX == 0x7fffffff
325 msgpack_pack_real_int32(x, d);
326 #else
327 msgpack_pack_real_int64(x, d);
328 #endif
329
330 #else
331 if(sizeof(short) == 2) {
332 msgpack_pack_real_int16(x, d);
333 } else if(sizeof(short) == 4) {
334 msgpack_pack_real_int32(x, d);
335 } else {
336 msgpack_pack_real_int64(x, d);
337 }
338 #endif
339 }
340
msgpack_pack_int(msgpack_packer * x,int d)341 static inline int msgpack_pack_int(msgpack_packer* x, int d)
342 {
343 #if defined(SIZEOF_INT)
344 #if SIZEOF_INT == 2
345 msgpack_pack_real_int16(x, d);
346 #elif SIZEOF_INT == 4
347 msgpack_pack_real_int32(x, d);
348 #else
349 msgpack_pack_real_int64(x, d);
350 #endif
351
352 #elif defined(INT_MAX)
353 #if INT_MAX == 0x7fff
354 msgpack_pack_real_int16(x, d);
355 #elif INT_MAX == 0x7fffffff
356 msgpack_pack_real_int32(x, d);
357 #else
358 msgpack_pack_real_int64(x, d);
359 #endif
360
361 #else
362 if(sizeof(int) == 2) {
363 msgpack_pack_real_int16(x, d);
364 } else if(sizeof(int) == 4) {
365 msgpack_pack_real_int32(x, d);
366 } else {
367 msgpack_pack_real_int64(x, d);
368 }
369 #endif
370 }
371
msgpack_pack_long(msgpack_packer * x,long d)372 static inline int msgpack_pack_long(msgpack_packer* x, long d)
373 {
374 #if defined(SIZEOF_LONG)
375 #if SIZEOF_LONG == 2
376 msgpack_pack_real_int16(x, d);
377 #elif SIZEOF_LONG == 4
378 msgpack_pack_real_int32(x, d);
379 #else
380 msgpack_pack_real_int64(x, d);
381 #endif
382
383 #elif defined(LONG_MAX)
384 #if LONG_MAX == 0x7fffL
385 msgpack_pack_real_int16(x, d);
386 #elif LONG_MAX == 0x7fffffffL
387 msgpack_pack_real_int32(x, d);
388 #else
389 msgpack_pack_real_int64(x, d);
390 #endif
391
392 #else
393 if(sizeof(long) == 2) {
394 msgpack_pack_real_int16(x, d);
395 } else if(sizeof(long) == 4) {
396 msgpack_pack_real_int32(x, d);
397 } else {
398 msgpack_pack_real_int64(x, d);
399 }
400 #endif
401 }
402
msgpack_pack_long_long(msgpack_packer * x,long long d)403 static inline int msgpack_pack_long_long(msgpack_packer* x, long long d)
404 {
405 #if defined(SIZEOF_LONG_LONG)
406 #if SIZEOF_LONG_LONG == 2
407 msgpack_pack_real_int16(x, d);
408 #elif SIZEOF_LONG_LONG == 4
409 msgpack_pack_real_int32(x, d);
410 #else
411 msgpack_pack_real_int64(x, d);
412 #endif
413
414 #elif defined(LLONG_MAX)
415 #if LLONG_MAX == 0x7fffL
416 msgpack_pack_real_int16(x, d);
417 #elif LLONG_MAX == 0x7fffffffL
418 msgpack_pack_real_int32(x, d);
419 #else
420 msgpack_pack_real_int64(x, d);
421 #endif
422
423 #else
424 if(sizeof(long long) == 2) {
425 msgpack_pack_real_int16(x, d);
426 } else if(sizeof(long long) == 4) {
427 msgpack_pack_real_int32(x, d);
428 } else {
429 msgpack_pack_real_int64(x, d);
430 }
431 #endif
432 }
433
msgpack_pack_unsigned_short(msgpack_packer * x,unsigned short d)434 static inline int msgpack_pack_unsigned_short(msgpack_packer* x, unsigned short d)
435 {
436 #if defined(SIZEOF_SHORT)
437 #if SIZEOF_SHORT == 2
438 msgpack_pack_real_uint16(x, d);
439 #elif SIZEOF_SHORT == 4
440 msgpack_pack_real_uint32(x, d);
441 #else
442 msgpack_pack_real_uint64(x, d);
443 #endif
444
445 #elif defined(USHRT_MAX)
446 #if USHRT_MAX == 0xffffU
447 msgpack_pack_real_uint16(x, d);
448 #elif USHRT_MAX == 0xffffffffU
449 msgpack_pack_real_uint32(x, d);
450 #else
451 msgpack_pack_real_uint64(x, d);
452 #endif
453
454 #else
455 if(sizeof(unsigned short) == 2) {
456 msgpack_pack_real_uint16(x, d);
457 } else if(sizeof(unsigned short) == 4) {
458 msgpack_pack_real_uint32(x, d);
459 } else {
460 msgpack_pack_real_uint64(x, d);
461 }
462 #endif
463 }
464
msgpack_pack_unsigned_int(msgpack_packer * x,unsigned int d)465 static inline int msgpack_pack_unsigned_int(msgpack_packer* x, unsigned int d)
466 {
467 #if defined(SIZEOF_INT)
468 #if SIZEOF_INT == 2
469 msgpack_pack_real_uint16(x, d);
470 #elif SIZEOF_INT == 4
471 msgpack_pack_real_uint32(x, d);
472 #else
473 msgpack_pack_real_uint64(x, d);
474 #endif
475
476 #elif defined(UINT_MAX)
477 #if UINT_MAX == 0xffffU
478 msgpack_pack_real_uint16(x, d);
479 #elif UINT_MAX == 0xffffffffU
480 msgpack_pack_real_uint32(x, d);
481 #else
482 msgpack_pack_real_uint64(x, d);
483 #endif
484
485 #else
486 if(sizeof(unsigned int) == 2) {
487 msgpack_pack_real_uint16(x, d);
488 } else if(sizeof(unsigned int) == 4) {
489 msgpack_pack_real_uint32(x, d);
490 } else {
491 msgpack_pack_real_uint64(x, d);
492 }
493 #endif
494 }
495
msgpack_pack_unsigned_long(msgpack_packer * x,unsigned long d)496 static inline int msgpack_pack_unsigned_long(msgpack_packer* x, unsigned long d)
497 {
498 #if defined(SIZEOF_LONG)
499 #if SIZEOF_LONG == 2
500 msgpack_pack_real_uint16(x, d);
501 #elif SIZEOF_LONG == 4
502 msgpack_pack_real_uint32(x, d);
503 #else
504 msgpack_pack_real_uint64(x, d);
505 #endif
506
507 #elif defined(ULONG_MAX)
508 #if ULONG_MAX == 0xffffUL
509 msgpack_pack_real_uint16(x, d);
510 #elif ULONG_MAX == 0xffffffffUL
511 msgpack_pack_real_uint32(x, d);
512 #else
513 msgpack_pack_real_uint64(x, d);
514 #endif
515
516 #else
517 if(sizeof(unsigned long) == 2) {
518 msgpack_pack_real_uint16(x, d);
519 } else if(sizeof(unsigned long) == 4) {
520 msgpack_pack_real_uint32(x, d);
521 } else {
522 msgpack_pack_real_uint64(x, d);
523 }
524 #endif
525 }
526
msgpack_pack_unsigned_long_long(msgpack_packer * x,unsigned long long d)527 static inline int msgpack_pack_unsigned_long_long(msgpack_packer* x, unsigned long long d)
528 {
529 #if defined(SIZEOF_LONG_LONG)
530 #if SIZEOF_LONG_LONG == 2
531 msgpack_pack_real_uint16(x, d);
532 #elif SIZEOF_LONG_LONG == 4
533 msgpack_pack_real_uint32(x, d);
534 #else
535 msgpack_pack_real_uint64(x, d);
536 #endif
537
538 #elif defined(ULLONG_MAX)
539 #if ULLONG_MAX == 0xffffUL
540 msgpack_pack_real_uint16(x, d);
541 #elif ULLONG_MAX == 0xffffffffUL
542 msgpack_pack_real_uint32(x, d);
543 #else
544 msgpack_pack_real_uint64(x, d);
545 #endif
546
547 #else
548 if(sizeof(unsigned long long) == 2) {
549 msgpack_pack_real_uint16(x, d);
550 } else if(sizeof(unsigned long long) == 4) {
551 msgpack_pack_real_uint32(x, d);
552 } else {
553 msgpack_pack_real_uint64(x, d);
554 }
555 #endif
556 }
557
558 //#undef msgpack_pack_inline_func_cint
559 //#endif
560
561
562
563 /*
564 * Float
565 */
566
msgpack_pack_float(msgpack_packer * x,float d)567 static inline int msgpack_pack_float(msgpack_packer* x, float d)
568 {
569 union { float f; uint32_t i; } mem;
570 mem.f = d;
571 unsigned char buf[5];
572 buf[0] = 0xca; _msgpack_store32(&buf[1], mem.i);
573 msgpack_pack_append_buffer(x, buf, 5);
574 }
575
msgpack_pack_double(msgpack_packer * x,double d)576 static inline int msgpack_pack_double(msgpack_packer* x, double d)
577 {
578 union { double f; uint64_t i; } mem;
579 mem.f = d;
580 unsigned char buf[9];
581 buf[0] = 0xcb;
582 #if defined(__arm__) && !(__ARM_EABI__) // arm-oabi
583 // https://github.com/msgpack/msgpack-perl/pull/1
584 mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL);
585 #endif
586 _msgpack_store64(&buf[1], mem.i);
587 msgpack_pack_append_buffer(x, buf, 9);
588 }
589
590
591 /*
592 * Nil
593 */
594
msgpack_pack_nil(msgpack_packer * x)595 static inline int msgpack_pack_nil(msgpack_packer* x)
596 {
597 static const unsigned char d = 0xc0;
598 msgpack_pack_append_buffer(x, &d, 1);
599 }
600
601
602 /*
603 * Boolean
604 */
605
msgpack_pack_true(msgpack_packer * x)606 static inline int msgpack_pack_true(msgpack_packer* x)
607 {
608 static const unsigned char d = 0xc3;
609 msgpack_pack_append_buffer(x, &d, 1);
610 }
611
msgpack_pack_false(msgpack_packer * x)612 static inline int msgpack_pack_false(msgpack_packer* x)
613 {
614 static const unsigned char d = 0xc2;
615 msgpack_pack_append_buffer(x, &d, 1);
616 }
617
618
619 /*
620 * Array
621 */
622
msgpack_pack_array(msgpack_packer * x,unsigned int n)623 static inline int msgpack_pack_array(msgpack_packer* x, unsigned int n)
624 {
625 if(n < 16) {
626 unsigned char d = 0x90 | n;
627 msgpack_pack_append_buffer(x, &d, 1);
628 } else if(n < 65536) {
629 unsigned char buf[3];
630 buf[0] = 0xdc; _msgpack_store16(&buf[1], (uint16_t)n);
631 msgpack_pack_append_buffer(x, buf, 3);
632 } else {
633 unsigned char buf[5];
634 buf[0] = 0xdd; _msgpack_store32(&buf[1], (uint32_t)n);
635 msgpack_pack_append_buffer(x, buf, 5);
636 }
637 }
638
639
640 /*
641 * Map
642 */
643
msgpack_pack_map(msgpack_packer * x,unsigned int n)644 static inline int msgpack_pack_map(msgpack_packer* x, unsigned int n)
645 {
646 if(n < 16) {
647 unsigned char d = 0x80 | n;
648 msgpack_pack_append_buffer(x, &TAKE8_8(d), 1);
649 } else if(n < 65536) {
650 unsigned char buf[3];
651 buf[0] = 0xde; _msgpack_store16(&buf[1], (uint16_t)n);
652 msgpack_pack_append_buffer(x, buf, 3);
653 } else {
654 unsigned char buf[5];
655 buf[0] = 0xdf; _msgpack_store32(&buf[1], (uint32_t)n);
656 msgpack_pack_append_buffer(x, buf, 5);
657 }
658 }
659
660
661 /*
662 * Raw
663 */
664
msgpack_pack_raw(msgpack_packer * x,size_t l)665 static inline int msgpack_pack_raw(msgpack_packer* x, size_t l)
666 {
667 if (l < 32) {
668 unsigned char d = 0xa0 | (uint8_t)l;
669 msgpack_pack_append_buffer(x, &TAKE8_8(d), 1);
670 } else if (x->use_bin_type && l < 256) { // str8 is new format introduced with bin.
671 unsigned char buf[2] = {0xd9, (uint8_t)l};
672 msgpack_pack_append_buffer(x, buf, 2);
673 } else if (l < 65536) {
674 unsigned char buf[3];
675 buf[0] = 0xda; _msgpack_store16(&buf[1], (uint16_t)l);
676 msgpack_pack_append_buffer(x, buf, 3);
677 } else {
678 unsigned char buf[5];
679 buf[0] = 0xdb; _msgpack_store32(&buf[1], (uint32_t)l);
680 msgpack_pack_append_buffer(x, buf, 5);
681 }
682 }
683
684 /*
685 * bin
686 */
msgpack_pack_bin(msgpack_packer * x,size_t l)687 static inline int msgpack_pack_bin(msgpack_packer *x, size_t l)
688 {
689 if (!x->use_bin_type) {
690 return msgpack_pack_raw(x, l);
691 }
692 if (l < 256) {
693 unsigned char buf[2] = {0xc4, (unsigned char)l};
694 msgpack_pack_append_buffer(x, buf, 2);
695 } else if (l < 65536) {
696 unsigned char buf[3] = {0xc5};
697 _msgpack_store16(&buf[1], (uint16_t)l);
698 msgpack_pack_append_buffer(x, buf, 3);
699 } else {
700 unsigned char buf[5] = {0xc6};
701 _msgpack_store32(&buf[1], (uint32_t)l);
702 msgpack_pack_append_buffer(x, buf, 5);
703 }
704 }
705
msgpack_pack_raw_body(msgpack_packer * x,const void * b,size_t l)706 static inline int msgpack_pack_raw_body(msgpack_packer* x, const void* b, size_t l)
707 {
708 if (l > 0) msgpack_pack_append_buffer(x, (const unsigned char*)b, l);
709 return 0;
710 }
711
712 /*
713 * Ext
714 */
msgpack_pack_ext(msgpack_packer * x,char typecode,size_t l)715 static inline int msgpack_pack_ext(msgpack_packer* x, char typecode, size_t l)
716 {
717 if (l == 1) {
718 unsigned char buf[2];
719 buf[0] = 0xd4;
720 buf[1] = (unsigned char)typecode;
721 msgpack_pack_append_buffer(x, buf, 2);
722 }
723 else if(l == 2) {
724 unsigned char buf[2];
725 buf[0] = 0xd5;
726 buf[1] = (unsigned char)typecode;
727 msgpack_pack_append_buffer(x, buf, 2);
728 }
729 else if(l == 4) {
730 unsigned char buf[2];
731 buf[0] = 0xd6;
732 buf[1] = (unsigned char)typecode;
733 msgpack_pack_append_buffer(x, buf, 2);
734 }
735 else if(l == 8) {
736 unsigned char buf[2];
737 buf[0] = 0xd7;
738 buf[1] = (unsigned char)typecode;
739 msgpack_pack_append_buffer(x, buf, 2);
740 }
741 else if(l == 16) {
742 unsigned char buf[2];
743 buf[0] = 0xd8;
744 buf[1] = (unsigned char)typecode;
745 msgpack_pack_append_buffer(x, buf, 2);
746 }
747 else if(l < 256) {
748 unsigned char buf[3];
749 buf[0] = 0xc7;
750 buf[1] = l;
751 buf[2] = (unsigned char)typecode;
752 msgpack_pack_append_buffer(x, buf, 3);
753 } else if(l < 65536) {
754 unsigned char buf[4];
755 buf[0] = 0xc8;
756 _msgpack_store16(&buf[1], (uint16_t)l);
757 buf[3] = (unsigned char)typecode;
758 msgpack_pack_append_buffer(x, buf, 4);
759 } else {
760 unsigned char buf[6];
761 buf[0] = 0xc9;
762 _msgpack_store32(&buf[1], (uint32_t)l);
763 buf[5] = (unsigned char)typecode;
764 msgpack_pack_append_buffer(x, buf, 6);
765 }
766
767 }
768
769
770
771 #undef msgpack_pack_append_buffer
772
773 #undef TAKE8_8
774 #undef TAKE8_16
775 #undef TAKE8_32
776 #undef TAKE8_64
777
778 #undef msgpack_pack_real_uint8
779 #undef msgpack_pack_real_uint16
780 #undef msgpack_pack_real_uint32
781 #undef msgpack_pack_real_uint64
782 #undef msgpack_pack_real_int8
783 #undef msgpack_pack_real_int16
784 #undef msgpack_pack_real_int32
785 #undef msgpack_pack_real_int64
786