generic-library/msgpack
1
0
Fork 0
mirror of https://github.com/msgpack/msgpack-c.git synced 2025-10-14 15:05:37 +02:00
Code Issues Projects Releases Wiki Activity

Revert "Fixed #637."

Browse Source 
This reverts commit 5ece2ef2c7.
This commit is contained in:
Takatoshi Kondo
2018-04-06 07:38:58 +09:00
parent 40539727e6
commit 427a6e7313
7 changed files with 37 additions and 338 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
include/msgpack/v1/unpack.hpp
View File

@@ -1392,11 +1392,12 @@ inline msgpack::object_handle unpack(
parse_return ret = detail::unpack_imp(
data, len, noff, *z, obj, referenced, f, user_data, limit);
off = noff;
switch(ret) {
case PARSE_SUCCESS:
off = noff;
return msgpack::object_handle(obj, msgpack::move(z));
case PARSE_EXTRA_BYTES:
off = noff;
return msgpack::object_handle(obj, msgpack::move(z));
case PARSE_CONTINUE:
throw msgpack::insufficient_bytes("insufficient bytes");
@@ -1448,13 +1449,14 @@ inline void unpack(
parse_return ret = detail::unpack_imp(
data, len, noff, *z, obj, referenced, f, user_data, limit);
off = noff;
switch(ret) {
case PARSE_SUCCESS:
off = noff;
result.set(obj);
result.zone() = msgpack::move(z);
return;
case PARSE_EXTRA_BYTES:
off = noff;
result.set(obj);
result.zone() = msgpack::move(z);
return;
@@ -1510,11 +1512,12 @@ inline msgpack::object unpack(
parse_return ret = detail::unpack_imp(
data, len, noff, z, obj, referenced, f, user_data, limit);
off = noff;
switch(ret) {
case PARSE_SUCCESS:
off = noff;
return obj;
case PARSE_EXTRA_BYTES:
off = noff;
return obj;
case PARSE_CONTINUE:
throw msgpack::insufficient_bytes("insufficient bytes");

38
include/msgpack/v2/parse.hpp
View File

@@ -58,6 +58,7 @@ private:
std::size_t& off) {
typename value<T>::type size;
load<T>(size, load_pos);
++m_current;
if (size == 0) {
if (!sv(size)) {
off = m_current - m_start;
@@ -67,7 +68,7 @@ private:
off = m_current - m_start;
return PARSE_STOP_VISITOR;
}
parse_return ret = m_stack.consume(holder(), m_current);
parse_return ret = m_stack.consume(holder());
if (ret != PARSE_CONTINUE) {
off = m_current - m_start;
return ret;
@@ -84,18 +85,17 @@ private:
return ret;
}
}
++m_current;
m_cs = MSGPACK_CS_HEADER;
return PARSE_CONTINUE;
}
parse_return after_visit_proc(bool visit_result, std::size_t& off) {
++m_current;
if (!visit_result) {
off = m_current - m_start;
return PARSE_STOP_VISITOR;
}
parse_return ret = m_stack.consume(holder(), m_current);
++m_current;
parse_return ret = m_stack.consume(holder());
if (ret != PARSE_CONTINUE) {
off = m_current - m_start;
}
@@ -161,21 +161,15 @@ private:
assert(0);
return PARSE_STOP_VISITOR;
}
parse_return consume(VisitorHolder& visitor_holder, char const*& current) {
parse_return consume(VisitorHolder& visitor_holder) {
while (!m_stack.empty()) {
stack_elem& e = m_stack.back();
switch (e.m_type) {
case MSGPACK_CT_ARRAY_ITEM:
if (!visitor_holder.visitor().end_array_item()) {
--current;
return PARSE_STOP_VISITOR;
}
if (!visitor_holder.visitor().end_array_item()) return PARSE_STOP_VISITOR;
if (--e.m_rest == 0) {
m_stack.pop_back();
if (!visitor_holder.visitor().end_array()) {
--current;
return PARSE_STOP_VISITOR;
}
if (!visitor_holder.visitor().end_array()) return PARSE_STOP_VISITOR;
}
else {
if (!visitor_holder.visitor().start_array_item()) return PARSE_STOP_VISITOR;
@@ -183,24 +177,15 @@ private:
}
break;
case MSGPACK_CT_MAP_KEY:
if (!visitor_holder.visitor().end_map_key()) {
--current;
return PARSE_STOP_VISITOR;
}
if (!visitor_holder.visitor().end_map_key()) return PARSE_STOP_VISITOR;
if (!visitor_holder.visitor().start_map_value()) return PARSE_STOP_VISITOR;
e.m_type = MSGPACK_CT_MAP_VALUE;
return PARSE_CONTINUE;
case MSGPACK_CT_MAP_VALUE:
if (!visitor_holder.visitor().end_map_value()) {
--current;
return PARSE_STOP_VISITOR;
}
if (!visitor_holder.visitor().end_map_value()) return PARSE_STOP_VISITOR;
if (--e.m_rest == 0) {
m_stack.pop_back();
if (!visitor_holder.visitor().end_map()) {
--current;
return PARSE_STOP_VISITOR;
}
if (!visitor_holder.visitor().end_map()) return PARSE_STOP_VISITOR;
}
else {
e.m_type = MSGPACK_CT_MAP_KEY;
@@ -1047,12 +1032,13 @@ parse_imp(const char* data, size_t len, size_t& off, Visitor& v) {
}
detail::parse_helper<Visitor> h(v);
parse_return ret = h.execute(data, len, noff);
off = noff;
switch (ret) {
case PARSE_CONTINUE:
off = noff;
v.insufficient_bytes(noff - 1, noff);
return ret;
case PARSE_SUCCESS:
off = noff;
if(noff < len) {
return PARSE_EXTRA_BYTES;
}

15
include/msgpack/v2/unpack.hpp
View File

@@ -152,13 +152,16 @@ inline msgpack::object_handle unpack(
msgpack::object obj;
msgpack::unique_ptr<msgpack::zone> z(new msgpack::zone);
referenced = false;
std::size_t noff = off;
parse_return ret = detail::unpack_imp(
data, len, off, *z, obj, referenced, f, user_data, limit);
data, len, noff, *z, obj, referenced, f, user_data, limit);
switch(ret) {
case PARSE_SUCCESS:
off = noff;
return msgpack::object_handle(obj, msgpack::move(z));
case PARSE_EXTRA_BYTES:
off = noff;
return msgpack::object_handle(obj, msgpack::move(z));
default:
break;
@@ -203,15 +206,18 @@ inline void unpack(
msgpack::object obj;
msgpack::unique_ptr<msgpack::zone> z(new msgpack::zone);
referenced = false;
std::size_t noff = off;
parse_return ret = detail::unpack_imp(
data, len, off, *z, obj, referenced, f, user_data, limit);
data, len, noff, *z, obj, referenced, f, user_data, limit);
switch(ret) {
case PARSE_SUCCESS:
off = noff;
result.set(obj);
result.zone() = msgpack::move(z);
return;
case PARSE_EXTRA_BYTES:
off = noff;
result.set(obj);
result.zone() = msgpack::move(z);
return;
@@ -259,14 +265,17 @@ inline msgpack::object unpack(
unpack_limit const& limit)
{
msgpack::object obj;
std::size_t noff = off;
referenced = false;
parse_return ret = detail::unpack_imp(
data, len, off, z, obj, referenced, f, user_data, limit);
data, len, noff, z, obj, referenced, f, user_data, limit);
switch(ret) {
case PARSE_SUCCESS:
off = noff;
return obj;
case PARSE_EXTRA_BYTES:
off = noff;
return obj;
default:
break;

6
src/unpack.c
View File

@@ -649,19 +649,19 @@ msgpack_unpack_next(msgpack_unpacked* result,
ctx.user.referenced = false;
e = template_execute(&ctx, data, len, &noff);
if(off != NULL) { *off = noff; }
if(e < 0) {
msgpack_zone_free(result->zone);
result->zone = NULL;
return e;
}
if(e == 0) {
return MSGPACK_UNPACK_CONTINUE;
}
if(off != NULL) { *off = noff; }
result->data = template_data(&ctx);
return MSGPACK_UNPACK_SUCCESS;

6
test/pack_unpack.cpp
View File

@@ -370,7 +370,7 @@ TEST(unpack, insufficient_bytes_ref)
}
catch (msgpack::insufficient_bytes const&) {
EXPECT_TRUE(true);
EXPECT_EQ(1u, off);
EXPECT_EQ(off, 0u);
}
}
@@ -387,7 +387,7 @@ TEST(unpack, insufficient_bytes_object_handle)
}
catch (msgpack::insufficient_bytes const&) {
EXPECT_TRUE(true);
EXPECT_EQ(1u, off);
EXPECT_EQ(off, 0u);
}
}
@@ -405,7 +405,7 @@ TEST(unpack, insufficient_bytes_zone)
}
catch (msgpack::insufficient_bytes const&) {
EXPECT_TRUE(true);
EXPECT_EQ(1u, off);
EXPECT_EQ(off, 0u);
}
}

2
test/pack_unpack_c.cpp
View File

@@ -83,7 +83,7 @@ TEST(pack, insufficient)
success = msgpack_unpack_next(&msg, sbuf->data, 1, &offset);
EXPECT_EQ(MSGPACK_UNPACK_CONTINUE, success);
EXPECT_EQ(1u, offset);
EXPECT_EQ(0u, offset);
msgpack_unpacked_destroy(&msg);

299
test/visitor.cpp
View File

@@ -115,7 +115,6 @@ TEST(visitor, parse_error)
bool ret = msgpack::v2::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_TRUE(called);
EXPECT_EQ(2u, off);
}
struct insuf_bytes_check_visitor : msgpack::v2::null_visitor {
@@ -137,304 +136,6 @@ TEST(visitor, insuf_bytes)
bool ret = msgpack::v2::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_TRUE(called);
EXPECT_EQ(3u, off);
}
struct return_false_array_val_visitor : msgpack::v2::null_visitor {
return_false_array_val_visitor(std::size_t& times):m_times(times) {}
bool visit_positive_integer(uint64_t) {
if (++m_times == 2) return false;
return true;
}
std::size_t& m_times;
};
TEST(visitor, return_false_array_val)
{
std::size_t times = 0;
return_false_array_val_visitor v(times);
std::size_t off = 0;
char const data[] = { static_cast<char>(0x93u), 0x01u, 0x02u, 0x03u };
bool ret = msgpack::v2::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_EQ(2u, times);
EXPECT_EQ(2u, off);
}
struct return_false_start_array_item_visitor : msgpack::v2::null_visitor {
return_false_start_array_item_visitor(std::size_t& times):m_times(times) {}
bool start_array_item() {
if (++m_times == 2) return false;
return true;
}
std::size_t& m_times;
};
TEST(visitor, return_false_start_array_item)
{
std::size_t times = 0;
return_false_start_array_item_visitor v(times);
std::size_t off = 0;
char const data[] = { static_cast<char>(0x93u), 0x01u, 0x02u, 0x03u };
bool ret = msgpack::v2::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_EQ(2u, times);
EXPECT_EQ(2u, off);
}
struct return_false_end_array_item_visitor : msgpack::v2::null_visitor {
return_false_end_array_item_visitor(std::size_t& times):m_times(times) {}
bool end_array_item() {
if (++m_times == 2) return false;
return true;
}
std::size_t& m_times;
};
TEST(visitor, return_false_end_array_item)
{
std::size_t times = 0;
return_false_end_array_item_visitor v(times);
std::size_t off = 0;
char const data[] = { static_cast<char>(0x93u), 0x01u, 0x02u, 0x03u };
bool ret = msgpack::v2::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_EQ(2u, times);
EXPECT_EQ(2u, off);
}
struct return_false_start_array_visitor : msgpack::v2::null_visitor {
bool start_array(uint32_t) {
return false;
}
};
TEST(visitor, return_false_start_array)
{
return_false_start_array_visitor v;
std::size_t off = 0;
char const data[] = { static_cast<char>(0x93u), 0x01u, 0x02u, 0x03u };
bool ret = msgpack::v2::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_EQ(0u, off);
}
struct return_false_start_array0_visitor : msgpack::v2::null_visitor {
bool start_array(uint32_t) {
return false;
}
};
TEST(visitor, return_false_start_array0)
{
return_false_start_array0_visitor v;
std::size_t off = 0;
char const data[] = { static_cast<char>(0x90u) };
bool ret = msgpack::v2::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_EQ(0u, off);
}
struct return_false_end_array_visitor : msgpack::v2::null_visitor {
bool end_array() {
return false;
}
};
TEST(visitor, return_false_end_array)
{
return_false_end_array_visitor v;
std::size_t off = 0;
char const data[] = { static_cast<char>(0x93u), 0x01u, 0x02u, 0x03u };
bool ret = msgpack::v2::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_EQ(3u, off);
}
struct return_false_end_array0_visitor : msgpack::v2::null_visitor {
bool end_array() {
return false;
}
};
TEST(visitor, return_false_end_array0)
{
return_false_end_array0_visitor v;
std::size_t off = 0;
char const data[] = { static_cast<char>(0x90u) };
bool ret = msgpack::v2::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_EQ(0u, off);
}
struct return_false_map_val_visitor : msgpack::v2::null_visitor {
return_false_map_val_visitor(std::size_t& times):m_times(times) {}
bool visit_positive_integer(uint64_t) {
if (++m_times == 2) return false;
return true;
}
std::size_t& m_times;
};
TEST(visitor, return_false_map_val)
{
std::size_t times = 0;
return_false_map_val_visitor v(times);
std::size_t off = 0;
char const data[] = { static_cast<char>(0x83u), 0x01u, 0x02u, 0x03u, 0x01u, 0x02u, 0x03u };
bool ret = msgpack::v2::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_EQ(2u, times);
EXPECT_EQ(2u, off);
}
struct return_false_start_map_key_visitor : msgpack::v2::null_visitor {
return_false_start_map_key_visitor(std::size_t& times):m_times(times) {}
bool start_map_key() {
if (++m_times == 2) return false;
return true;
}
std::size_t& m_times;
};
TEST(visitor, return_false_start_map_key)
{
std::size_t times = 0;
return_false_start_map_key_visitor v(times);
std::size_t off = 0;
char const data[] = { static_cast<char>(0x83u), 0x01u, 0x02u, 0x03u, 0x01u, 0x02u, 0x03u };
bool ret = msgpack::v2::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_EQ(2u, times);
EXPECT_EQ(3u, off);
}
struct return_false_end_map_key_visitor : msgpack::v2::null_visitor {
return_false_end_map_key_visitor(std::size_t& times):m_times(times) {}
bool end_map_key() {
if (++m_times == 2) return false;
return true;
}
std::size_t& m_times;
};
TEST(visitor, return_false_end_map_key)
{
std::size_t times = 0;
return_false_end_map_key_visitor v(times);
std::size_t off = 0;
char const data[] = { static_cast<char>(0x83u), 0x01u, 0x02u, 0x03u, 0x01u, 0x02u, 0x03u };
bool ret = msgpack::v2::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_EQ(2u, times);
EXPECT_EQ(3u, off);
}
struct return_false_start_map_value_visitor : msgpack::v2::null_visitor {
return_false_start_map_value_visitor(std::size_t& times):m_times(times) {}
bool start_map_value() {
if (++m_times == 2) return false;
return true;
}
std::size_t& m_times;
};
TEST(visitor, return_false_start_map_value)
{
std::size_t times = 0;
return_false_start_map_value_visitor v(times);
std::size_t off = 0;
char const data[] = { static_cast<char>(0x83u), 0x01u, 0x02u, 0x03u, 0x01u, 0x02u, 0x03u };
bool ret = msgpack::v2::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_EQ(2u, times);
EXPECT_EQ(4u, off);
}
struct return_false_end_map_value_visitor : msgpack::v2::null_visitor {
return_false_end_map_value_visitor(std::size_t& times):m_times(times) {}
bool end_map_value() {
if (++m_times == 2) return false;
return true;
}
std::size_t& m_times;
};
TEST(visitor, return_false_end_map_value)
{
std::size_t times = 0;
return_false_end_map_value_visitor v(times);
std::size_t off = 0;
char const data[] = { static_cast<char>(0x83u), 0x01u, 0x02u, 0x03u, 0x01u, 0x02u, 0x03u };
bool ret = msgpack::v2::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_EQ(2u, times);
EXPECT_EQ(4u, off);
}
struct return_false_start_map_visitor : msgpack::v2::null_visitor {
bool start_map(uint32_t) {
return false;
}
};
TEST(visitor, return_false_start_map)
{
return_false_start_map_visitor v;
std::size_t off = 0;
char const data[] = { static_cast<char>(0x83u), 0x01u, 0x02u, 0x03u, 0x01u, 0x02u, 0x03u };
bool ret = msgpack::v2::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_EQ(0u, off);
}
struct return_false_start_map0_visitor : msgpack::v2::null_visitor {
bool start_map(uint32_t) {
return false;
}
};
TEST(visitor, return_false_start_map0)
{
return_false_start_map0_visitor v;
std::size_t off = 0;
char const data[] = { static_cast<char>(0x80u) };
bool ret = msgpack::v2::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_EQ(0u, off);
}
struct return_false_end_map_visitor : msgpack::v2::null_visitor {
bool end_map() {
return false;
}
};
TEST(visitor, return_false_end_map)
{
return_false_end_map_visitor v;
std::size_t off = 0;
char const data[] = { static_cast<char>(0x83u), 0x01u, 0x02u, 0x03u, 0x01u, 0x02u, 0x03u };
bool ret = msgpack::v2::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_EQ(6u, off);
}
struct return_false_end_map0_visitor : msgpack::v2::null_visitor {
bool end_map() {
return false;
}
};
TEST(visitor, return_false_end_map0)
{
return_false_end_map0_visitor v;
std::size_t off = 0;
char const data[] = { static_cast<char>(0x80u) };
bool ret = msgpack::v2::parse(data, sizeof(data), off, v);
EXPECT_FALSE(ret);
EXPECT_EQ(0u, off);
}
#endif // MSGPACK_DEFAULT_API_VERSION >= 1