json_cursor

danielaparker · danielaparker · commit 4d65f2b6b2dc · 2025-03-09T14:48:12.000-04:00
diff --git a/include/jsoncons/json_cursor.hpp b/include/jsoncons/json_cursor.hpp
@@ -280,10 +280,14 @@ class basic_json_cursor : public basic_staj_cursor<CharT>, private virtual ser_c
     void read_to(basic_json_visitor<CharT>& visitor,
                  std::error_code& ec) override
     {
+        parser_.cursor_mode(false);
+        parser_.mark_level(parser_.level());
         if (cursor_visitor_.event().send_json_event(visitor, *this, ec))
         {
             read_next(visitor, ec);
         }
+        parser_.cursor_mode(true);
+        parser_.mark_level(0);
     }
 
     void next() override
diff --git a/include/jsoncons/json_parser.hpp b/include/jsoncons/json_parser.hpp
@@ -129,7 +129,7 @@ class basic_json_parser : public ser_context
     basic_json_decode_options<char_type> options_;
 
     std::function<bool(json_errc,const ser_context&)> err_handler_;
-    int nesting_depth_{0};
+    int level_{0};
     uint32_t cp_{0};
     uint32_t cp2_{0};
     std::size_t line_{1};
@@ -145,6 +145,7 @@ class basic_json_parser : public ser_context
     bool more_{true};
     bool done_{false};
     bool cursor_mode_{false};
+    int mark_level_{0};
 
     std::basic_string<char_type,std::char_traits<char_type>,char_allocator_type> string_buffer_;
     jsoncons::detail::chars_to to_double_;
@@ -207,6 +208,21 @@ class basic_json_parser : public ser_context
         cursor_mode_ = value;
     }
 
+    int level() const
+    {
+        return level_;
+    }
+
+    int mark_level() const 
+    {
+        return mark_level_;
+    }
+
+    void mark_level(int value)
+    {
+        mark_level_ = value;
+    }
+
     bool source_exhausted() const
     {
         return input_ptr_ == end_input_;
@@ -341,7 +357,7 @@ class basic_json_parser : public ser_context
 
     void begin_object(basic_json_visitor<char_type>& visitor, std::error_code& ec)
     {
-        if (JSONCONS_UNLIKELY(++nesting_depth_ > options_.max_nesting_depth()))
+        if (JSONCONS_UNLIKELY(++level_ > options_.max_nesting_depth()))
         {
             more_ = err_handler_(json_errc::max_nesting_depth_exceeded, *this);
             if (!more_)
@@ -353,23 +369,24 @@ class basic_json_parser : public ser_context
 
         push_state(parse_state::object);
         state_ = parse_state::expect_member_name_or_end;
-        more_ = visitor.begin_object(semantic_tag::none, *this, ec);
+        visitor.begin_object(semantic_tag::none, *this, ec);
+        more_ = !cursor_mode_;
     }
 
     void end_object(basic_json_visitor<char_type>& visitor, std::error_code& ec)
     {
-        if (JSONCONS_UNLIKELY(nesting_depth_ < 1))
+        if (JSONCONS_UNLIKELY(level_ < 1))
         {
             err_handler_(json_errc::unexpected_rbrace, *this);
             ec = json_errc::unexpected_rbrace;
             more_ = false;
             return;
         }
-        --nesting_depth_;
+        --level_;
         state_ = pop_state();
         if (state_ == parse_state::object)
         {
-            more_ = visitor.end_object(*this, ec);
+            visitor.end_object(*this, ec);
         }
         else if (state_ == parse_state::array)
         {
@@ -394,11 +411,16 @@ class basic_json_parser : public ser_context
         {
             state_ = parse_state::expect_comma_or_end;
         }
+        more_ = !cursor_mode_;
+        if (level_ <= mark_level_)
+        {
+            more_ = false;
+        }
     }
 
     void begin_array(basic_json_visitor<char_type>& visitor, std::error_code& ec)
     {
-        if (++nesting_depth_ > options_.max_nesting_depth())
+        if (++level_ > options_.max_nesting_depth())
         {
             more_ = err_handler_(json_errc::max_nesting_depth_exceeded, *this);
             if (!more_)
@@ -410,23 +432,25 @@ class basic_json_parser : public ser_context
 
         push_state(parse_state::array);
         state_ = parse_state::expect_value_or_end;
-        more_ = visitor.begin_array(semantic_tag::none, *this, ec);
+        visitor.begin_array(semantic_tag::none, *this, ec);
+
+        more_ = !cursor_mode_;
     }
 
     void end_array(basic_json_visitor<char_type>& visitor, std::error_code& ec)
     {
-        if (nesting_depth_ < 1)
+        if (level_ < 1)
         {
             err_handler_(json_errc::unexpected_rbracket, *this);
             ec = json_errc::unexpected_rbracket;
             more_ = false;
             return;
         }
-        --nesting_depth_;
+        --level_;
         state_ = pop_state();
         if (state_ == parse_state::array)
         {
-            more_ = visitor.end_array(*this, ec);
+            visitor.end_array(*this, ec);
         }
         else if (state_ == parse_state::object)
         {
@@ -450,6 +474,12 @@ class basic_json_parser : public ser_context
         {
             state_ = parse_state::expect_comma_or_end;
         }
+
+        more_ = !cursor_mode_;
+        if (level_ <= mark_level_)
+        {
+            more_ = false;
+        }
     }
 
     void reinitialize()
@@ -474,7 +504,7 @@ class basic_json_parser : public ser_context
         line_ = 1;
         position_ = 0;
         mark_position_ = 0;
-        nesting_depth_ = 0;
+        level_ = 0;
     }
 
     void restart()
@@ -1394,7 +1424,7 @@ class basic_json_parser : public ser_context
                         case 'e':
                             ++input_ptr_;
                             ++position_;
-                            more_ = visitor.bool_value(true,  semantic_tag::none, *this, ec);
+                            visitor.bool_value(true,  semantic_tag::none, *this, ec);
                             if (parent() == parse_state::root)
                             {
                                 state_ = parse_state::accept;
@@ -1403,6 +1433,7 @@ class basic_json_parser : public ser_context
                             {
                                 state_ = parse_state::expect_comma_or_end;
                             }
+                            more_ = !cursor_mode_;
                             break;
                         default:
                             err_handler_(json_errc::invalid_value, *this);
@@ -1462,7 +1493,7 @@ class basic_json_parser : public ser_context
                         case 'e':
                             ++input_ptr_;
                             ++position_;
-                            more_ = visitor.bool_value(false, semantic_tag::none, *this, ec);
+                            visitor.bool_value(false, semantic_tag::none, *this, ec);
                             if (parent() == parse_state::root)
                             {
                                 state_ = parse_state::accept;
@@ -1471,6 +1502,7 @@ class basic_json_parser : public ser_context
                             {
                                 state_ = parse_state::expect_comma_or_end;
                             }
+                            more_ = !cursor_mode_;
                             break;
                         default:
                             err_handler_(json_errc::invalid_value, *this);
@@ -1514,7 +1546,7 @@ class basic_json_parser : public ser_context
                     switch (*input_ptr_)
                     {
                     case 'l':
-                        more_ = visitor.null_value(semantic_tag::none, *this, ec);
+                        visitor.null_value(semantic_tag::none, *this, ec);
                         if (parent() == parse_state::root)
                         {
                             state_ = parse_state::accept;
@@ -1523,6 +1555,7 @@ class basic_json_parser : public ser_context
                         {
                             state_ = parse_state::expect_comma_or_end;
                         }
+                        more_ = !cursor_mode_;
                         break;
                     default:
                         err_handler_(json_errc::invalid_value, *this);
@@ -1650,7 +1683,7 @@ class basic_json_parser : public ser_context
             {
                 input_ptr_ += 4;
                 position_ += 4;
-                more_ = visitor.bool_value(true, semantic_tag::none, *this, ec);
+                visitor.bool_value(true, semantic_tag::none, *this, ec);
                 if (parent() == parse_state::root)
                 {
                     state_ = parse_state::accept;
@@ -1659,6 +1692,7 @@ class basic_json_parser : public ser_context
                 {
                     state_ = parse_state::expect_comma_or_end;
                 }
+                more_ = !cursor_mode_;
             }
             else
             {
@@ -1685,7 +1719,8 @@ class basic_json_parser : public ser_context
             {
                 input_ptr_ += 4;
                 position_ += 4;
-                more_ = visitor.null_value(semantic_tag::none, *this, ec);
+                visitor.null_value(semantic_tag::none, *this, ec);
+                more_ = !cursor_mode_;
                 if (parent() == parse_state::root)
                 {
                     state_ = parse_state::accept;
@@ -1720,7 +1755,8 @@ class basic_json_parser : public ser_context
             {
                 input_ptr_ += 5;
                 position_ += 5;
-                more_ = visitor.bool_value(false, semantic_tag::none, *this, ec);
+                visitor.bool_value(false, semantic_tag::none, *this, ec);
+                more_ = !cursor_mode_;
                 if (parent() == parse_state::root)
                 {
                     state_ = parse_state::accept;
@@ -2624,11 +2660,13 @@ class basic_json_parser : public ser_context
         auto result = jsoncons::detail::to_integer_unchecked(string_buffer_.data(), string_buffer_.length(), val);
         if (result)
         {
-            more_ = visitor.int64_value(val, semantic_tag::none, *this, ec);
+            visitor.int64_value(val, semantic_tag::none, *this, ec);
+            more_ = !cursor_mode_;
         }
         else // Must be overflow
         {
-            more_ = visitor.string_value(string_buffer_, semantic_tag::bigint, *this, ec);
+            visitor.string_value(string_buffer_, semantic_tag::bigint, *this, ec);
+            more_ = !cursor_mode_;
         }
         after_value(ec);
     }
@@ -2639,11 +2677,13 @@ class basic_json_parser : public ser_context
         auto result = jsoncons::detail::to_integer_unchecked(string_buffer_.data(), string_buffer_.length(), val);
         if (result)
         {
-            more_ = visitor.uint64_value(val, semantic_tag::none, *this, ec);
+            visitor.uint64_value(val, semantic_tag::none, *this, ec);
+            more_ = !cursor_mode_;
         }
         else // Must be overflow
         {
-            more_ = visitor.string_value(string_buffer_, semantic_tag::bigint, *this, ec);
+            visitor.string_value(string_buffer_, semantic_tag::bigint, *this, ec);
+            more_ = !cursor_mode_;
         }
         after_value(ec);
     }
@@ -2654,12 +2694,14 @@ class basic_json_parser : public ser_context
         {
             if (options_.lossless_number())
             {
-                more_ = visitor.string_value(string_buffer_, semantic_tag::bigdec, *this, ec);
+                visitor.string_value(string_buffer_, semantic_tag::bigdec, *this, ec);
+                more_ = !cursor_mode_;
             }
             else
             {
                 double d = to_double_(string_buffer_.c_str(), string_buffer_.length());
-                more_ = visitor.double_value(d, semantic_tag::none, *this, ec);
+                visitor.double_value(d, semantic_tag::none, *this, ec);
+                more_ = !cursor_mode_;
             }
         }
         JSONCONS_CATCH(...)
@@ -2670,7 +2712,8 @@ class basic_json_parser : public ser_context
                 ec = json_errc::invalid_number;
                 return;
             }
-            more_ = visitor.null_value(semantic_tag::none, *this, ec); // recovery
+            visitor.null_value(semantic_tag::none, *this, ec); // recovery
+            more_ = !cursor_mode_;
         }
 
         after_value(ec);
@@ -2689,7 +2732,8 @@ class basic_json_parser : public ser_context
         switch (parent())
         {
         case parse_state::member_name:
-            more_ = visitor.key(sv, *this, ec);
+            visitor.key(sv, *this, ec);
+            more_ = !cursor_mode_;
             pop_state();
             state_ = parse_state::expect_colon;
             break;
@@ -2699,11 +2743,13 @@ class basic_json_parser : public ser_context
             auto it = std::find_if(string_double_map_.begin(), string_double_map_.end(), string_maps_to_double{ sv });
             if (it != string_double_map_.end())
             {
-                more_ = visitor.double_value((*it).second, semantic_tag::none, *this, ec);
+                visitor.double_value((*it).second, semantic_tag::none, *this, ec);
+                more_ = !cursor_mode_;
             }
             else
             {
-                more_ = visitor.string_value(sv, semantic_tag::none, *this, ec);
+                visitor.string_value(sv, semantic_tag::none, *this, ec);
+                more_ = !cursor_mode_;
             }
             state_ = parse_state::expect_comma_or_end;
             break;
@@ -2713,11 +2759,13 @@ class basic_json_parser : public ser_context
             auto it = std::find_if(string_double_map_.begin(),string_double_map_.end(),string_maps_to_double{sv});
             if (it != string_double_map_.end())
             {
-                more_ = visitor.double_value((*it).second, semantic_tag::none, *this, ec);
+                visitor.double_value((*it).second, semantic_tag::none, *this, ec);
+                more_ = !cursor_mode_;
             }
             else
             {
-                more_ = visitor.string_value(sv, semantic_tag::none, *this, ec);
+                visitor.string_value(sv, semantic_tag::none, *this, ec);
+                more_ = !cursor_mode_;
             }
             state_ = parse_state::accept;
             break;
@@ -2781,7 +2829,7 @@ class basic_json_parser : public ser_context
     void push_state(parse_state state)
     {
         state_stack_.push_back(state);
-        //std::cout << "max_nesting_depth: " << options_.max_nesting_depth() << ", capacity: " << state_stack_.capacity() << ", nesting_depth: " << nesting_depth_ << ", stack size: " << state_stack_.size() << "\n";
+        //std::cout << "max_nesting_depth: " << options_.max_nesting_depth() << ", capacity: " << state_stack_.capacity() << ", nesting_depth: " << level_ << ", stack size: " << state_stack_.size() << "\n";
     }
 
     parse_state pop_state()

Original file line number	Diff line number	Diff line change
`@@ -280,10 +280,14 @@ class basic_json_cursor : public basic_staj_cursor<CharT>, private virtual ser_c`
`280`	`280`	`void read_to(basic_json_visitor<CharT>& visitor,`
`281`	`281`	`std::error_code& ec) override`
`282`	`282`	`{`
	`283`	`+ parser_.cursor_mode(false);`
	`284`	`+ parser_.mark_level(parser_.level());`
`283`	`285`	`if (cursor_visitor_.event().send_json_event(visitor, *this, ec))`
`284`	`286`	`{`
`285`	`287`	`read_next(visitor, ec);`
`286`	`288`	`}`
	`289`	`+ parser_.cursor_mode(true);`
	`290`	`+ parser_.mark_level(0);`
`287`	`291`	`}`
`288`	`292`
`289`	`293`	`void next() override`
Original file line number	Diff line number	Diff line change
`@@ -129,7 +129,7 @@ class basic_json_parser : public ser_context`
`129`	`129`	`basic_json_decode_options<char_type> options_;`
`130`	`130`
`131`	`131`	`std::function<bool(json_errc,const ser_context&)> err_handler_;`
`132`		`- int nesting_depth_{0};`
	`132`	`+ int level_{0};`
`133`	`133`	`uint32_t cp_{0};`
`134`	`134`	`uint32_t cp2_{0};`
`135`	`135`	`std::size_t line_{1};`
`@@ -145,6 +145,7 @@ class basic_json_parser : public ser_context`
`145`	`145`	`bool more_{true};`
`146`	`146`	`bool done_{false};`
`147`	`147`	`bool cursor_mode_{false};`
	`148`	`+ int mark_level_{0};`
`148`	`149`
`149`	`150`	`std::basic_string<char_type,std::char_traits<char_type>,char_allocator_type> string_buffer_;`
`150`	`151`	`jsoncons::detail::chars_to to_double_;`
`@@ -207,6 +208,21 @@ class basic_json_parser : public ser_context`
`207`	`208`	`cursor_mode_ = value;`
`208`	`209`	`}`
`209`	`210`
	`211`	`+ int level() const`
	`212`	`+ {`
	`213`	`+ return level_;`
	`214`	`+ }`
	`215`	`+`
	`216`	`+ int mark_level() const`
	`217`	`+ {`
	`218`	`+ return mark_level_;`
	`219`	`+ }`
	`220`	`+`
	`221`	`+ void mark_level(int value)`
	`222`	`+ {`
	`223`	`+ mark_level_ = value;`
	`224`	`+ }`
	`225`	`+`
`210`	`226`	`bool source_exhausted() const`
`211`	`227`	`{`
`212`	`228`	`return input_ptr_ == end_input_;`
`@@ -341,7 +357,7 @@ class basic_json_parser : public ser_context`
`341`	`357`
`342`	`358`	`void begin_object(basic_json_visitor<char_type>& visitor, std::error_code& ec)`
`343`	`359`	`{`
`344`		`- if (JSONCONS_UNLIKELY(++nesting_depth_ > options_.max_nesting_depth()))`
	`360`	`+ if (JSONCONS_UNLIKELY(++level_ > options_.max_nesting_depth()))`
`345`	`361`	`{`
`346`	`362`	`more_ = err_handler_(json_errc::max_nesting_depth_exceeded, *this);`
`347`	`363`	`if (!more_)`
`@@ -353,23 +369,24 @@ class basic_json_parser : public ser_context`
`353`	`369`
`354`	`370`	`push_state(parse_state::object);`
`355`	`371`	`state_ = parse_state::expect_member_name_or_end;`
`356`		`- more_ = visitor.begin_object(semantic_tag::none, *this, ec);`
	`372`	`+ visitor.begin_object(semantic_tag::none, *this, ec);`
	`373`	`+ more_ = !cursor_mode_;`
`357`	`374`	`}`
`358`	`375`
`359`	`376`	`void end_object(basic_json_visitor<char_type>& visitor, std::error_code& ec)`
`360`	`377`	`{`
`361`		`- if (JSONCONS_UNLIKELY(nesting_depth_ < 1))`
	`378`	`+ if (JSONCONS_UNLIKELY(level_ < 1))`
`362`	`379`	`{`
`363`	`380`	`err_handler_(json_errc::unexpected_rbrace, *this);`
`364`	`381`	`ec = json_errc::unexpected_rbrace;`
`365`	`382`	`more_ = false;`
`366`	`383`	`return;`
`367`	`384`	`}`
`368`		`- --nesting_depth_;`
	`385`	`+ --level_;`
`369`	`386`	`state_ = pop_state();`
`370`	`387`	`if (state_ == parse_state::object)`
`371`	`388`	`{`
`372`		`- more_ = visitor.end_object(*this, ec);`
	`389`	`+ visitor.end_object(*this, ec);`
`373`	`390`	`}`
`374`	`391`	`else if (state_ == parse_state::array)`
`375`	`392`	`{`
`@@ -394,11 +411,16 @@ class basic_json_parser : public ser_context`
`394`	`411`	`{`
`395`	`412`	`state_ = parse_state::expect_comma_or_end;`
`396`	`413`	`}`
	`414`	`+ more_ = !cursor_mode_;`
	`415`	`+ if (level_ <= mark_level_)`
	`416`	`+ {`
	`417`	`+ more_ = false;`
	`418`	`+ }`
`397`	`419`	`}`
`398`	`420`
`399`	`421`	`void begin_array(basic_json_visitor<char_type>& visitor, std::error_code& ec)`
`400`	`422`	`{`
`401`		`- if (++nesting_depth_ > options_.max_nesting_depth())`
	`423`	`+ if (++level_ > options_.max_nesting_depth())`
`402`	`424`	`{`
`403`	`425`	`more_ = err_handler_(json_errc::max_nesting_depth_exceeded, *this);`
`404`	`426`	`if (!more_)`
`@@ -410,23 +432,25 @@ class basic_json_parser : public ser_context`
`410`	`432`
`411`	`433`	`push_state(parse_state::array);`
`412`	`434`	`state_ = parse_state::expect_value_or_end;`
`413`		`- more_ = visitor.begin_array(semantic_tag::none, *this, ec);`
	`435`	`+ visitor.begin_array(semantic_tag::none, *this, ec);`
	`436`	`+`
	`437`	`+ more_ = !cursor_mode_;`
`414`	`438`	`}`
`415`	`439`
`416`	`440`	`void end_array(basic_json_visitor<char_type>& visitor, std::error_code& ec)`
`417`	`441`	`{`
`418`		`- if (nesting_depth_ < 1)`
	`442`	`+ if (level_ < 1)`
`419`	`443`	`{`
`420`	`444`	`err_handler_(json_errc::unexpected_rbracket, *this);`
`421`	`445`	`ec = json_errc::unexpected_rbracket;`
`422`	`446`	`more_ = false;`
`423`	`447`	`return;`
`424`	`448`	`}`
`425`		`- --nesting_depth_;`
	`449`	`+ --level_;`
`426`	`450`	`state_ = pop_state();`
`427`	`451`	`if (state_ == parse_state::array)`
`428`	`452`	`{`
`429`		`- more_ = visitor.end_array(*this, ec);`
	`453`	`+ visitor.end_array(*this, ec);`
`430`	`454`	`}`
`431`	`455`	`else if (state_ == parse_state::object)`
`432`	`456`	`{`
`@@ -450,6 +474,12 @@ class basic_json_parser : public ser_context`
`450`	`474`	`{`
`451`	`475`	`state_ = parse_state::expect_comma_or_end;`
`452`	`476`	`}`
	`477`	`+`
	`478`	`+ more_ = !cursor_mode_;`
	`479`	`+ if (level_ <= mark_level_)`
	`480`	`+ {`
	`481`	`+ more_ = false;`
	`482`	`+ }`
`453`	`483`	`}`
`454`	`484`
`455`	`485`	`void reinitialize()`
`@@ -474,7 +504,7 @@ class basic_json_parser : public ser_context`
`474`	`504`	`line_ = 1;`
`475`	`505`	`position_ = 0;`
`476`	`506`	`mark_position_ = 0;`
`477`		`- nesting_depth_ = 0;`
	`507`	`+ level_ = 0;`
`478`	`508`	`}`
`479`	`509`
`480`	`510`	`void restart()`
`@@ -1394,7 +1424,7 @@ class basic_json_parser : public ser_context`
`1394`	`1424`	`case 'e':`
`1395`	`1425`	`++input_ptr_;`
`1396`	`1426`	`++position_;`
`1397`		`- more_ = visitor.bool_value(true, semantic_tag::none, *this, ec);`
	`1427`	`+ visitor.bool_value(true, semantic_tag::none, *this, ec);`
`1398`	`1428`	`if (parent() == parse_state::root)`
`1399`	`1429`	`{`
`1400`	`1430`	`state_ = parse_state::accept;`
`@@ -1403,6 +1433,7 @@ class basic_json_parser : public ser_context`
`1403`	`1433`	`{`
`1404`	`1434`	`state_ = parse_state::expect_comma_or_end;`
`1405`	`1435`	`}`
	`1436`	`+ more_ = !cursor_mode_;`
`1406`	`1437`	`break;`
`1407`	`1438`	`default:`
`1408`	`1439`	`err_handler_(json_errc::invalid_value, *this);`
`@@ -1462,7 +1493,7 @@ class basic_json_parser : public ser_context`
`1462`	`1493`	`case 'e':`
`1463`	`1494`	`++input_ptr_;`
`1464`	`1495`	`++position_;`
`1465`		`- more_ = visitor.bool_value(false, semantic_tag::none, *this, ec);`
	`1496`	`+ visitor.bool_value(false, semantic_tag::none, *this, ec);`
`1466`	`1497`	`if (parent() == parse_state::root)`
`1467`	`1498`	`{`
`1468`	`1499`	`state_ = parse_state::accept;`
`@@ -1471,6 +1502,7 @@ class basic_json_parser : public ser_context`
`1471`	`1502`	`{`
`1472`	`1503`	`state_ = parse_state::expect_comma_or_end;`
`1473`	`1504`	`}`
	`1505`	`+ more_ = !cursor_mode_;`
`1474`	`1506`	`break;`
`1475`	`1507`	`default:`
`1476`	`1508`	`err_handler_(json_errc::invalid_value, *this);`
`@@ -1514,7 +1546,7 @@ class basic_json_parser : public ser_context`
`1514`	`1546`	`switch (*input_ptr_)`
`1515`	`1547`	`{`
`1516`	`1548`	`case 'l':`
`1517`		`- more_ = visitor.null_value(semantic_tag::none, *this, ec);`
	`1549`	`+ visitor.null_value(semantic_tag::none, *this, ec);`
`1518`	`1550`	`if (parent() == parse_state::root)`
`1519`	`1551`	`{`
`1520`	`1552`	`state_ = parse_state::accept;`
`@@ -1523,6 +1555,7 @@ class basic_json_parser : public ser_context`
`1523`	`1555`	`{`
`1524`	`1556`	`state_ = parse_state::expect_comma_or_end;`
`1525`	`1557`	`}`
	`1558`	`+ more_ = !cursor_mode_;`
`1526`	`1559`	`break;`
`1527`	`1560`	`default:`
`1528`	`1561`	`err_handler_(json_errc::invalid_value, *this);`
`@@ -1650,7 +1683,7 @@ class basic_json_parser : public ser_context`
`1650`	`1683`	`{`
`1651`	`1684`	`input_ptr_ += 4;`
`1652`	`1685`	`position_ += 4;`
`1653`		`- more_ = visitor.bool_value(true, semantic_tag::none, *this, ec);`
	`1686`	`+ visitor.bool_value(true, semantic_tag::none, *this, ec);`
`1654`	`1687`	`if (parent() == parse_state::root)`
`1655`	`1688`	`{`
`1656`	`1689`	`state_ = parse_state::accept;`
`@@ -1659,6 +1692,7 @@ class basic_json_parser : public ser_context`
`1659`	`1692`	`{`
`1660`	`1693`	`state_ = parse_state::expect_comma_or_end;`
`1661`	`1694`	`}`
	`1695`	`+ more_ = !cursor_mode_;`
`1662`	`1696`	`}`
`1663`	`1697`	`else`
`1664`	`1698`	`{`
`@@ -1685,7 +1719,8 @@ class basic_json_parser : public ser_context`
`1685`	`1719`	`{`
`1686`	`1720`	`input_ptr_ += 4;`
`1687`	`1721`	`position_ += 4;`
`1688`		`- more_ = visitor.null_value(semantic_tag::none, *this, ec);`
	`1722`	`+ visitor.null_value(semantic_tag::none, *this, ec);`
	`1723`	`+ more_ = !cursor_mode_;`
`1689`	`1724`	`if (parent() == parse_state::root)`
`1690`	`1725`	`{`
`1691`	`1726`	`state_ = parse_state::accept;`
`@@ -1720,7 +1755,8 @@ class basic_json_parser : public ser_context`
`1720`	`1755`	`{`
`1721`	`1756`	`input_ptr_ += 5;`
`1722`	`1757`	`position_ += 5;`
`1723`		`- more_ = visitor.bool_value(false, semantic_tag::none, *this, ec);`
	`1758`	`+ visitor.bool_value(false, semantic_tag::none, *this, ec);`
	`1759`	`+ more_ = !cursor_mode_;`
`1724`	`1760`	`if (parent() == parse_state::root)`
`1725`	`1761`	`{`
`1726`	`1762`	`state_ = parse_state::accept;`
`@@ -2624,11 +2660,13 @@ class basic_json_parser : public ser_context`
`2624`	`2660`	`auto result = jsoncons::detail::to_integer_unchecked(string_buffer_.data(), string_buffer_.length(), val);`
`2625`	`2661`	`if (result)`
`2626`	`2662`	`{`
`2627`		`- more_ = visitor.int64_value(val, semantic_tag::none, *this, ec);`
	`2663`	`+ visitor.int64_value(val, semantic_tag::none, *this, ec);`
	`2664`	`+ more_ = !cursor_mode_;`
`2628`	`2665`	`}`
`2629`	`2666`	`else // Must be overflow`
`2630`	`2667`	`{`
`2631`		`- more_ = visitor.string_value(string_buffer_, semantic_tag::bigint, *this, ec);`
	`2668`	`+ visitor.string_value(string_buffer_, semantic_tag::bigint, *this, ec);`
	`2669`	`+ more_ = !cursor_mode_;`
`2632`	`2670`	`}`
`2633`	`2671`	`after_value(ec);`
`2634`	`2672`	`}`
`@@ -2639,11 +2677,13 @@ class basic_json_parser : public ser_context`
`2639`	`2677`	`auto result = jsoncons::detail::to_integer_unchecked(string_buffer_.data(), string_buffer_.length(), val);`
`2640`	`2678`	`if (result)`
`2641`	`2679`	`{`
`2642`		`- more_ = visitor.uint64_value(val, semantic_tag::none, *this, ec);`
	`2680`	`+ visitor.uint64_value(val, semantic_tag::none, *this, ec);`
	`2681`	`+ more_ = !cursor_mode_;`
`2643`	`2682`	`}`
`2644`	`2683`	`else // Must be overflow`
`2645`	`2684`	`{`
`2646`		`- more_ = visitor.string_value(string_buffer_, semantic_tag::bigint, *this, ec);`
	`2685`	`+ visitor.string_value(string_buffer_, semantic_tag::bigint, *this, ec);`
	`2686`	`+ more_ = !cursor_mode_;`
`2647`	`2687`	`}`
`2648`	`2688`	`after_value(ec);`
`2649`	`2689`	`}`
`@@ -2654,12 +2694,14 @@ class basic_json_parser : public ser_context`
`2654`	`2694`	`{`
`2655`	`2695`	`if (options_.lossless_number())`
`2656`	`2696`	`{`
`2657`		`- more_ = visitor.string_value(string_buffer_, semantic_tag::bigdec, *this, ec);`
	`2697`	`+ visitor.string_value(string_buffer_, semantic_tag::bigdec, *this, ec);`
	`2698`	`+ more_ = !cursor_mode_;`
`2658`	`2699`	`}`
`2659`	`2700`	`else`
`2660`	`2701`	`{`
`2661`	`2702`	`double d = to_double_(string_buffer_.c_str(), string_buffer_.length());`
`2662`		`- more_ = visitor.double_value(d, semantic_tag::none, *this, ec);`
	`2703`	`+ visitor.double_value(d, semantic_tag::none, *this, ec);`
	`2704`	`+ more_ = !cursor_mode_;`
`2663`	`2705`	`}`
`2664`	`2706`	`}`
`2665`	`2707`	`JSONCONS_CATCH(...)`
`@@ -2670,7 +2712,8 @@ class basic_json_parser : public ser_context`
`2670`	`2712`	`ec = json_errc::invalid_number;`
`2671`	`2713`	`return;`
`2672`	`2714`	`}`
`2673`		`- more_ = visitor.null_value(semantic_tag::none, *this, ec); // recovery`
	`2715`	`+ visitor.null_value(semantic_tag::none, *this, ec); // recovery`
	`2716`	`+ more_ = !cursor_mode_;`
`2674`	`2717`	`}`
`2675`	`2718`
`2676`	`2719`	`after_value(ec);`
`@@ -2689,7 +2732,8 @@ class basic_json_parser : public ser_context`
`2689`	`2732`	`switch (parent())`
`2690`	`2733`	`{`
`2691`	`2734`	`case parse_state::member_name:`
`2692`		`- more_ = visitor.key(sv, *this, ec);`
	`2735`	`+ visitor.key(sv, *this, ec);`
	`2736`	`+ more_ = !cursor_mode_;`
`2693`	`2737`	`pop_state();`
`2694`	`2738`	`state_ = parse_state::expect_colon;`
`2695`	`2739`	`break;`
`@@ -2699,11 +2743,13 @@ class basic_json_parser : public ser_context`
`2699`	`2743`	`auto it = std::find_if(string_double_map_.begin(), string_double_map_.end(), string_maps_to_double{ sv });`
`2700`	`2744`	`if (it != string_double_map_.end())`
`2701`	`2745`	`{`
`2702`		`- more_ = visitor.double_value((it).second, semantic_tag::none, this, ec);`
	`2746`	`+ visitor.double_value((it).second, semantic_tag::none, this, ec);`
	`2747`	`+ more_ = !cursor_mode_;`
`2703`	`2748`	`}`
`2704`	`2749`	`else`
`2705`	`2750`	`{`
`2706`		`- more_ = visitor.string_value(sv, semantic_tag::none, *this, ec);`
	`2751`	`+ visitor.string_value(sv, semantic_tag::none, *this, ec);`
	`2752`	`+ more_ = !cursor_mode_;`
`2707`	`2753`	`}`
`2708`	`2754`	`state_ = parse_state::expect_comma_or_end;`
`2709`	`2755`	`break;`
`@@ -2713,11 +2759,13 @@ class basic_json_parser : public ser_context`
`2713`	`2759`	`auto it = std::find_if(string_double_map_.begin(),string_double_map_.end(),string_maps_to_double{sv});`
`2714`	`2760`	`if (it != string_double_map_.end())`
`2715`	`2761`	`{`
`2716`		`- more_ = visitor.double_value((it).second, semantic_tag::none, this, ec);`
	`2762`	`+ visitor.double_value((it).second, semantic_tag::none, this, ec);`
	`2763`	`+ more_ = !cursor_mode_;`
`2717`	`2764`	`}`
`2718`	`2765`	`else`
`2719`	`2766`	`{`
`2720`		`- more_ = visitor.string_value(sv, semantic_tag::none, *this, ec);`
	`2767`	`+ visitor.string_value(sv, semantic_tag::none, *this, ec);`
	`2768`	`+ more_ = !cursor_mode_;`
`2721`	`2769`	`}`
`2722`	`2770`	`state_ = parse_state::accept;`
`2723`	`2771`	`break;`
`@@ -2781,7 +2829,7 @@ class basic_json_parser : public ser_context`
`2781`	`2829`	`void push_state(parse_state state)`
`2782`	`2830`	`{`
`2783`	`2831`	`state_stack_.push_back(state);`
`2784`		`- //std::cout << "max_nesting_depth: " << options_.max_nesting_depth() << ", capacity: " << state_stack_.capacity() << ", nesting_depth: " << nesting_depth_ << ", stack size: " << state_stack_.size() << "\n";`
	`2832`	`+ //std::cout << "max_nesting_depth: " << options_.max_nesting_depth() << ", capacity: " << state_stack_.capacity() << ", nesting_depth: " << level_ << ", stack size: " << state_stack_.size() << "\n";`
`2785`	`2833`	`}`
`2786`	`2834`
`2787`	`2835`	`parse_state pop_state()`