10 #ifndef MSGPACK_V3_PARSE_HPP 11 #define MSGPACK_V3_PARSE_HPP 13 #if MSGPACK_DEFAULT_API_VERSION >= 2 27 template <
typename VisitorHolder>
31 :m_trail(0), m_cs(MSGPACK_CS_HEADER)
37 m_cs = MSGPACK_CS_HEADER;
40 holder().visitor().init();
47 static uint32_t next_cs(T p)
49 return static_cast<uint32_t
>(*p) & 0x1f;
52 VisitorHolder& holder() {
53 return static_cast<VisitorHolder&
>(*this);
56 template <
typename T,
typename StartVisitor,
typename EndVisitor>
58 StartVisitor
const& sv,
63 load<T>(
size, load_pos);
66 off = m_current - m_start;
70 off = m_current - m_start;
76 off = m_current - m_start;
82 off = m_current - m_start;
85 parse_return ret = m_stack.push(holder(), sv.type(),
static_cast<uint32_t
>(
size));
88 off = m_current - m_start;
92 m_cs = MSGPACK_CS_HEADER;
96 parse_return after_visit_proc(
bool visit_result, std::size_t& off) {
98 off = m_current - m_start;
101 parse_return ret = m_stack.consume(holder(), m_current);
104 off = m_current - m_start;
106 m_cs = MSGPACK_CS_HEADER;
111 array_sv(VisitorHolder& visitor_holder):m_visitor_holder(visitor_holder) {}
112 bool operator()(uint32_t size)
const {
113 return m_visitor_holder.visitor().start_array(size);
115 msgpack_container_type type()
const {
return MSGPACK_CT_ARRAY_ITEM; }
117 VisitorHolder& m_visitor_holder;
120 array_ev(VisitorHolder& visitor_holder):m_visitor_holder(visitor_holder) {}
121 bool operator()()
const {
122 return m_visitor_holder.visitor().end_array();
125 VisitorHolder& m_visitor_holder;
128 map_sv(VisitorHolder& visitor_holder):m_visitor_holder(visitor_holder) {}
129 bool operator()(uint32_t size)
const {
130 return m_visitor_holder.visitor().start_map(size);
132 msgpack_container_type type()
const {
return MSGPACK_CT_MAP_KEY; }
134 VisitorHolder& m_visitor_holder;
137 map_ev(VisitorHolder& visitor_holder):m_visitor_holder(visitor_holder) {}
138 bool operator()()
const {
139 return m_visitor_holder.visitor().end_map();
142 VisitorHolder& m_visitor_holder;
145 struct unpack_stack {
147 stack_elem(msgpack_container_type type, uint32_t rest):m_type(type), m_rest(rest) {}
148 msgpack_container_type m_type;
152 m_stack.reserve(MSGPACK_EMBED_STACK_SIZE);
154 parse_return push(VisitorHolder& visitor_holder, msgpack_container_type type, uint32_t rest) {
155 m_stack.push_back(stack_elem(type, rest));
157 case MSGPACK_CT_ARRAY_ITEM:
159 case MSGPACK_CT_MAP_KEY:
161 case MSGPACK_CT_MAP_VALUE:
168 parse_return consume(VisitorHolder& visitor_holder,
char const*& current) {
169 while (!m_stack.empty()) {
170 stack_elem& e = m_stack.back();
172 case MSGPACK_CT_ARRAY_ITEM:
173 if (!visitor_holder.visitor().end_array_item()) {
177 if (--e.m_rest == 0) {
179 if (!visitor_holder.visitor().end_array()) {
189 case MSGPACK_CT_MAP_KEY:
190 if (!visitor_holder.visitor().end_map_key()) {
195 e.m_type = MSGPACK_CT_MAP_VALUE;
197 case MSGPACK_CT_MAP_VALUE:
198 if (!visitor_holder.visitor().end_map_value()) {
202 if (--e.m_rest == 0) {
204 if (!visitor_holder.visitor().end_map()) {
210 e.m_type = MSGPACK_CT_MAP_KEY;
219 bool empty()
const {
return m_stack.empty(); }
220 void clear() { m_stack.clear(); }
222 std::vector<stack_elem> m_stack;
226 char const* m_current;
230 uint32_t m_num_elements;
231 unpack_stack m_stack;
234 template <std::
size_t N>
235 inline void check_ext_size(std::size_t ) {
239 inline void check_ext_size<4>(std::size_t
size) {
243 template <
typename VisitorHolder>
249 m_current = data + off;
250 const char*
const pe = data + len;
255 if(m_current == pe) {
256 off = m_current - m_start;
259 bool fixed_trail_again =
false;
261 if (m_cs == MSGPACK_CS_HEADER) {
262 fixed_trail_again =
false;
263 int selector = *
reinterpret_cast<const unsigned char*
>(m_current);
264 if (0x00 <= selector && selector <= 0x7f) {
265 uint8_t tmp = *
reinterpret_cast<const uint8_t*
>(m_current);
266 bool visret = holder().visitor().visit_positive_integer(tmp);
269 }
else if(0xe0 <= selector && selector <= 0xff) {
270 int8_t tmp = *
reinterpret_cast<const int8_t*
>(m_current);
271 bool visret = holder().visitor().visit_negative_integer(tmp);
274 }
else if (0xc4 <= selector && selector <= 0xdf) {
275 const uint32_t trail[] = {
305 m_trail = trail[selector - 0xc4];
306 m_cs = next_cs(m_current);
307 fixed_trail_again =
true;
308 }
else if(0xa0 <= selector && selector <= 0xbf) {
309 m_trail =
static_cast<uint32_t
>(*m_current) & 0x1f;
311 bool visret = holder().visitor().visit_str(n, static_cast<uint32_t>(m_trail));
316 m_cs = MSGPACK_ACS_STR_VALUE;
317 fixed_trail_again =
true;
319 }
else if(0x90 <= selector && selector <= 0x9f) {
320 parse_return ret = start_aggregate<fix_tag>(array_sv(holder()), array_ev(holder()), m_current, off);
322 }
else if(0x80 <= selector && selector <= 0x8f) {
323 parse_return ret = start_aggregate<fix_tag>(map_sv(holder()), map_ev(holder()), m_current, off);
325 }
else if(selector == 0xc2) {
326 bool visret = holder().visitor().visit_boolean(
false);
329 }
else if(selector == 0xc3) {
330 bool visret = holder().visitor().visit_boolean(
true);
333 }
else if(selector == 0xc0) {
334 bool visret = holder().visitor().visit_nil();
338 off = m_current - m_start;
339 holder().visitor().parse_error(off - 1, off);
344 if (m_cs != MSGPACK_CS_HEADER || fixed_trail_again) {
345 if (fixed_trail_again) {
347 fixed_trail_again =
false;
349 if(static_cast<std::size_t>(pe - m_current) < m_trail) {
350 off = m_current - m_start;
354 m_current += m_trail - 1;
358 case MSGPACK_CS_FLOAT: {
359 union { uint32_t i;
float f; } mem;
360 load<uint32_t>(mem.i, n);
361 bool visret = holder().visitor().visit_float32(mem.f);
365 case MSGPACK_CS_DOUBLE: {
366 union { uint64_t i;
double f; } mem;
367 load<uint64_t>(mem.i, n);
368 #if defined(TARGET_OS_IPHONE) 370 #elif defined(__arm__) && !(__ARM_EABI__) // arm-oabi 372 mem.i = (mem.i & 0xFFFFFFFFUL) << 32UL | (mem.i >> 32UL);
374 bool visret = holder().visitor().visit_float64(mem.f);
378 case MSGPACK_CS_UINT_8: {
380 load<uint8_t>(tmp, n);
381 bool visret = holder().visitor().visit_positive_integer(tmp);
385 case MSGPACK_CS_UINT_16: {
387 load<uint16_t>(tmp, n);
388 bool visret = holder().visitor().visit_positive_integer(tmp);
392 case MSGPACK_CS_UINT_32: {
394 load<uint32_t>(tmp, n);
395 bool visret = holder().visitor().visit_positive_integer(tmp);
399 case MSGPACK_CS_UINT_64: {
401 load<uint64_t>(tmp, n);
402 bool visret = holder().visitor().visit_positive_integer(tmp);
406 case MSGPACK_CS_INT_8: {
408 load<int8_t>(tmp, n);
409 bool visret = holder().visitor().visit_negative_integer(tmp);
413 case MSGPACK_CS_INT_16: {
415 load<int16_t>(tmp, n);
416 bool visret = holder().visitor().visit_negative_integer(tmp);
420 case MSGPACK_CS_INT_32: {
422 load<int32_t>(tmp, n);
423 bool visret = holder().visitor().visit_negative_integer(tmp);
427 case MSGPACK_CS_INT_64: {
429 load<int64_t>(tmp, n);
430 bool visret = holder().visitor().visit_negative_integer(tmp);
434 case MSGPACK_CS_FIXEXT_1: {
435 bool visret = holder().visitor().visit_ext(n, 1+1);
439 case MSGPACK_CS_FIXEXT_2: {
440 bool visret = holder().visitor().visit_ext(n, 2+1);
444 case MSGPACK_CS_FIXEXT_4: {
445 bool visret = holder().visitor().visit_ext(n, 4+1);
449 case MSGPACK_CS_FIXEXT_8: {
450 bool visret = holder().visitor().visit_ext(n, 8+1);
454 case MSGPACK_CS_FIXEXT_16: {
455 bool visret = holder().visitor().visit_ext(n, 16+1);
459 case MSGPACK_CS_STR_8: {
461 load<uint8_t>(tmp, n);
464 bool visret = holder().visitor().visit_str(n, static_cast<uint32_t>(m_trail));
469 m_cs = MSGPACK_ACS_STR_VALUE;
470 fixed_trail_again =
true;
473 case MSGPACK_CS_BIN_8: {
475 load<uint8_t>(tmp, n);
478 bool visret = holder().visitor().visit_bin(n, static_cast<uint32_t>(m_trail));
483 m_cs = MSGPACK_ACS_BIN_VALUE;
484 fixed_trail_again =
true;
487 case MSGPACK_CS_EXT_8: {
489 load<uint8_t>(tmp, n);
492 bool visret = holder().visitor().visit_ext(n, static_cast<uint32_t>(m_trail));
497 m_cs = MSGPACK_ACS_EXT_VALUE;
498 fixed_trail_again =
true;
501 case MSGPACK_CS_STR_16: {
503 load<uint16_t>(tmp, n);
506 bool visret = holder().visitor().visit_str(n, static_cast<uint32_t>(m_trail));
511 m_cs = MSGPACK_ACS_STR_VALUE;
512 fixed_trail_again =
true;
515 case MSGPACK_CS_BIN_16: {
517 load<uint16_t>(tmp, n);
520 bool visret = holder().visitor().visit_bin(n, static_cast<uint32_t>(m_trail));
525 m_cs = MSGPACK_ACS_BIN_VALUE;
526 fixed_trail_again =
true;
529 case MSGPACK_CS_EXT_16: {
531 load<uint16_t>(tmp, n);
534 bool visret = holder().visitor().visit_ext(n, static_cast<uint32_t>(m_trail));
539 m_cs = MSGPACK_ACS_EXT_VALUE;
540 fixed_trail_again =
true;
543 case MSGPACK_CS_STR_32: {
545 load<uint32_t>(tmp, n);
548 bool visret = holder().visitor().visit_str(n, static_cast<uint32_t>(m_trail));
553 m_cs = MSGPACK_ACS_STR_VALUE;
554 fixed_trail_again =
true;
557 case MSGPACK_CS_BIN_32: {
559 load<uint32_t>(tmp, n);
562 bool visret = holder().visitor().visit_bin(n, static_cast<uint32_t>(m_trail));
567 m_cs = MSGPACK_ACS_BIN_VALUE;
568 fixed_trail_again =
true;
571 case MSGPACK_CS_EXT_32: {
573 load<uint32_t>(tmp, n);
574 check_ext_size<sizeof(std::size_t)>(tmp);
578 bool visret = holder().visitor().visit_ext(n, static_cast<uint32_t>(m_trail));
583 m_cs = MSGPACK_ACS_EXT_VALUE;
584 fixed_trail_again =
true;
587 case MSGPACK_ACS_STR_VALUE: {
588 bool visret = holder().visitor().visit_str(n, static_cast<uint32_t>(m_trail));
592 case MSGPACK_ACS_BIN_VALUE: {
593 bool visret = holder().visitor().visit_bin(n, static_cast<uint32_t>(m_trail));
597 case MSGPACK_ACS_EXT_VALUE: {
598 bool visret = holder().visitor().visit_ext(n, static_cast<uint32_t>(m_trail));
602 case MSGPACK_CS_ARRAY_16: {
603 parse_return ret = start_aggregate<uint16_t>(array_sv(holder()), array_ev(holder()), n, off);
607 case MSGPACK_CS_ARRAY_32: {
608 parse_return ret = start_aggregate<uint32_t>(array_sv(holder()), array_ev(holder()), n, off);
611 case MSGPACK_CS_MAP_16: {
612 parse_return ret = start_aggregate<uint16_t>(map_sv(holder()), map_ev(holder()), n, off);
615 case MSGPACK_CS_MAP_32: {
616 parse_return ret = start_aggregate<uint32_t>(map_sv(holder()), map_ev(holder()), n, off);
620 off = m_current - m_start;
621 holder().visitor().parse_error(n - m_start - 1, n - m_start);
625 }
while(m_current != pe);
627 off = m_current - m_start;
631 template <
typename Visitor>
632 struct parse_helper : detail::context<parse_helper<Visitor> > {
633 parse_helper(Visitor& v):m_visitor(v) {}
635 return detail::context<parse_helper<Visitor> >
::execute(data, len, off);
637 Visitor& visitor()
const {
return m_visitor; }
641 template <
typename Visitor>
643 parse_imp(
const char* data,
size_t len,
size_t& off, Visitor& v) {
644 std::size_t noff = off;
647 v.insufficient_bytes(noff, noff);
650 detail::parse_helper<Visitor> h(v);
655 v.insufficient_bytes(noff - 1, noff);
675 #endif // MSGPACK_DEFAULT_API_VERSION >= 2 677 #endif // MSGPACK_V3_PARSE_HPP
parse_return
Definition: parse_return.hpp:23
void init()
Definition: unpack.hpp:312
Definition: parse_return.hpp:27
context(unpack_reference_func f, void *user_data, unpack_limit const &limit)
Definition: unpack.hpp:305
T type
Definition: unpack.hpp:271
Definition: adaptor_base.hpp:15
Definition: unpack_exception.hpp:97
Definition: parse_return.hpp:26
std::size_t size(T const &t)
Definition: size_equal_only.hpp:24
Definition: parse_return.hpp:28
Object class that corresponding to MessagePack format object.
Definition: object_fwd.hpp:75
#define MSGPACK_API_VERSION_NAMESPACE(ns)
Definition: versioning.hpp:58
Definition: parse_return.hpp:24
parse_return parse_imp(const char *data, size_t len, size_t &off, Visitor &v)
Definition: parse_return.hpp:25
msgpack::object const & data() const
Definition: unpack.hpp:320
#define MSGPACK_NULLPTR
Definition: cpp_config_decl.hpp:35
int execute(const char *data, std::size_t len, std::size_t &off)
Definition: unpack.hpp:452