basic_parser_impl.hpp

99.2% Lines (1268 / 1278, 8 excl) 34.9% Functions (1412 / 4041)

[ ] prev/next file n p prev/next uncovered line

f(x) Functions (4041)

Function Calls Lines Blocks

Line	Hits	Source Code
1		//
2		// Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com)
3		// Copyright (c) 2020 Krystian Stasiowski (sdkrystian@gmail.com)
4		//
5		// Distributed under the Boost Software License, Version 1.0. (See accompanying
6		// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
7		//
8		// Official repository: https://github.com/boostorg/json
9		//
10
11		#ifndef BOOST_JSON_BASIC_PARSER_IMPL_HPP
12		#define BOOST_JSON_BASIC_PARSER_IMPL_HPP
13
14		#include <boost/json/detail/config.hpp>
15		#include <boost/json/detail/literals.hpp>
16		#include <boost/json/basic_parser.hpp>
17		#include <boost/json/error.hpp>
18		#include <boost/json/detail/buffer.hpp>
19		#include <boost/json/detail/charconv/from_chars.hpp>
20		#include <boost/json/detail/sse2.hpp>
21		#include <boost/mp11/algorithm.hpp>
22		#include <boost/mp11/integral.hpp>
23		#include <cmath>
24		#include <limits>
25		#include <cstring>
26
27		#ifdef _MSC_VER
28		#pragma warning(push)
29		#pragma warning(disable: 4702) // unreachable code
30		#pragma warning(disable: 4127) // conditional expression is constant
31		#endif
32
33		/* This file must be manually included to get the
34		function template definitions for basic_parser.
35		*/
36
37		/* Reference:
38
39		https://www.json.org/
40
41		RFC 7159: The JavaScript Object Notation (JSON) Data Interchange Format
42		https://tools.ietf.org/html/rfc7159
43
44		https://ampl.com/netlib/fp/dtoa.c
45		*/
46
47		#ifndef BOOST_JSON_DOCS
48
49		namespace boost {
50		namespace json {
51		namespace detail {
52
53		inline
54		double
55	1035607x	pow10(int exp) noexcept
56		{
57		static double const tab[618] = {
58		1e-308, 1e-307, 1e-306, 1e-305, 1e-304, 1e-303, 1e-302, 1e-301,
59
60		1e-300, 1e-299, 1e-298, 1e-297, 1e-296, 1e-295, 1e-294, 1e-293, 1e-292, 1e-291,
61		1e-290, 1e-289, 1e-288, 1e-287, 1e-286, 1e-285, 1e-284, 1e-283, 1e-282, 1e-281,
62		1e-280, 1e-279, 1e-278, 1e-277, 1e-276, 1e-275, 1e-274, 1e-273, 1e-272, 1e-271,
63		1e-270, 1e-269, 1e-268, 1e-267, 1e-266, 1e-265, 1e-264, 1e-263, 1e-262, 1e-261,
64		1e-260, 1e-259, 1e-258, 1e-257, 1e-256, 1e-255, 1e-254, 1e-253, 1e-252, 1e-251,
65		1e-250, 1e-249, 1e-248, 1e-247, 1e-246, 1e-245, 1e-244, 1e-243, 1e-242, 1e-241,
66		1e-240, 1e-239, 1e-238, 1e-237, 1e-236, 1e-235, 1e-234, 1e-233, 1e-232, 1e-231,
67		1e-230, 1e-229, 1e-228, 1e-227, 1e-226, 1e-225, 1e-224, 1e-223, 1e-222, 1e-221,
68		1e-220, 1e-219, 1e-218, 1e-217, 1e-216, 1e-215, 1e-214, 1e-213, 1e-212, 1e-211,
69		1e-210, 1e-209, 1e-208, 1e-207, 1e-206, 1e-205, 1e-204, 1e-203, 1e-202, 1e-201,
70
71		1e-200, 1e-199, 1e-198, 1e-197, 1e-196, 1e-195, 1e-194, 1e-193, 1e-192, 1e-191,
72		1e-190, 1e-189, 1e-188, 1e-187, 1e-186, 1e-185, 1e-184, 1e-183, 1e-182, 1e-181,
73		1e-180, 1e-179, 1e-178, 1e-177, 1e-176, 1e-175, 1e-174, 1e-173, 1e-172, 1e-171,
74		1e-170, 1e-169, 1e-168, 1e-167, 1e-166, 1e-165, 1e-164, 1e-163, 1e-162, 1e-161,
75		1e-160, 1e-159, 1e-158, 1e-157, 1e-156, 1e-155, 1e-154, 1e-153, 1e-152, 1e-151,
76		1e-150, 1e-149, 1e-148, 1e-147, 1e-146, 1e-145, 1e-144, 1e-143, 1e-142, 1e-141,
77		1e-140, 1e-139, 1e-138, 1e-137, 1e-136, 1e-135, 1e-134, 1e-133, 1e-132, 1e-131,
78		1e-130, 1e-129, 1e-128, 1e-127, 1e-126, 1e-125, 1e-124, 1e-123, 1e-122, 1e-121,
79		1e-120, 1e-119, 1e-118, 1e-117, 1e-116, 1e-115, 1e-114, 1e-113, 1e-112, 1e-111,
80		1e-110, 1e-109, 1e-108, 1e-107, 1e-106, 1e-105, 1e-104, 1e-103, 1e-102, 1e-101,
81
82		1e-100, 1e-099, 1e-098, 1e-097, 1e-096, 1e-095, 1e-094, 1e-093, 1e-092, 1e-091,
83		1e-090, 1e-089, 1e-088, 1e-087, 1e-086, 1e-085, 1e-084, 1e-083, 1e-082, 1e-081,
84		1e-080, 1e-079, 1e-078, 1e-077, 1e-076, 1e-075, 1e-074, 1e-073, 1e-072, 1e-071,
85		1e-070, 1e-069, 1e-068, 1e-067, 1e-066, 1e-065, 1e-064, 1e-063, 1e-062, 1e-061,
86		1e-060, 1e-059, 1e-058, 1e-057, 1e-056, 1e-055, 1e-054, 1e-053, 1e-052, 1e-051,
87		1e-050, 1e-049, 1e-048, 1e-047, 1e-046, 1e-045, 1e-044, 1e-043, 1e-042, 1e-041,
88		1e-040, 1e-039, 1e-038, 1e-037, 1e-036, 1e-035, 1e-034, 1e-033, 1e-032, 1e-031,
89		1e-030, 1e-029, 1e-028, 1e-027, 1e-026, 1e-025, 1e-024, 1e-023, 1e-022, 1e-021,
90		1e-020, 1e-019, 1e-018, 1e-017, 1e-016, 1e-015, 1e-014, 1e-013, 1e-012, 1e-011,
91		1e-010, 1e-009, 1e-008, 1e-007, 1e-006, 1e-005, 1e-004, 1e-003, 1e-002, 1e-001,
92
93		1e+000, 1e+001, 1e+002, 1e+003, 1e+004, 1e+005, 1e+006, 1e+007, 1e+008, 1e+009,
94		1e+010, 1e+011, 1e+012, 1e+013, 1e+014, 1e+015, 1e+016, 1e+017, 1e+018, 1e+019,
95		1e+020, 1e+021, 1e+022, 1e+023, 1e+024, 1e+025, 1e+026, 1e+027, 1e+028, 1e+029,
96		1e+030, 1e+031, 1e+032, 1e+033, 1e+034, 1e+035, 1e+036, 1e+037, 1e+038, 1e+039,
97		1e+040, 1e+041, 1e+042, 1e+043, 1e+044, 1e+045, 1e+046, 1e+047, 1e+048, 1e+049,
98		1e+050, 1e+051, 1e+052, 1e+053, 1e+054, 1e+055, 1e+056, 1e+057, 1e+058, 1e+059,
99		1e+060, 1e+061, 1e+062, 1e+063, 1e+064, 1e+065, 1e+066, 1e+067, 1e+068, 1e+069,
100		1e+070, 1e+071, 1e+072, 1e+073, 1e+074, 1e+075, 1e+076, 1e+077, 1e+078, 1e+079,
101		1e+080, 1e+081, 1e+082, 1e+083, 1e+084, 1e+085, 1e+086, 1e+087, 1e+088, 1e+089,
102		1e+090, 1e+091, 1e+092, 1e+093, 1e+094, 1e+095, 1e+096, 1e+097, 1e+098, 1e+099,
103
104		1e+100, 1e+101, 1e+102, 1e+103, 1e+104, 1e+105, 1e+106, 1e+107, 1e+108, 1e+109,
105		1e+110, 1e+111, 1e+112, 1e+113, 1e+114, 1e+115, 1e+116, 1e+117, 1e+118, 1e+119,
106		1e+120, 1e+121, 1e+122, 1e+123, 1e+124, 1e+125, 1e+126, 1e+127, 1e+128, 1e+129,
107		1e+130, 1e+131, 1e+132, 1e+133, 1e+134, 1e+135, 1e+136, 1e+137, 1e+138, 1e+139,
108		1e+140, 1e+141, 1e+142, 1e+143, 1e+144, 1e+145, 1e+146, 1e+147, 1e+148, 1e+149,
109		1e+150, 1e+151, 1e+152, 1e+153, 1e+154, 1e+155, 1e+156, 1e+157, 1e+158, 1e+159,
110		1e+160, 1e+161, 1e+162, 1e+163, 1e+164, 1e+165, 1e+166, 1e+167, 1e+168, 1e+169,
111		1e+170, 1e+171, 1e+172, 1e+173, 1e+174, 1e+175, 1e+176, 1e+177, 1e+178, 1e+179,
112		1e+180, 1e+181, 1e+182, 1e+183, 1e+184, 1e+185, 1e+186, 1e+187, 1e+188, 1e+189,
113		1e+190, 1e+191, 1e+192, 1e+193, 1e+194, 1e+195, 1e+196, 1e+197, 1e+198, 1e+199,
114
115		1e+200, 1e+201, 1e+202, 1e+203, 1e+204, 1e+205, 1e+206, 1e+207, 1e+208, 1e+209,
116		1e+210, 1e+211, 1e+212, 1e+213, 1e+214, 1e+215, 1e+216, 1e+217, 1e+218, 1e+219,
117		1e+220, 1e+221, 1e+222, 1e+223, 1e+224, 1e+225, 1e+226, 1e+227, 1e+228, 1e+229,
118		1e+230, 1e+231, 1e+232, 1e+233, 1e+234, 1e+235, 1e+236, 1e+237, 1e+238, 1e+239,
119		1e+240, 1e+241, 1e+242, 1e+243, 1e+244, 1e+245, 1e+246, 1e+247, 1e+248, 1e+249,
120		1e+250, 1e+251, 1e+252, 1e+253, 1e+254, 1e+255, 1e+256, 1e+257, 1e+258, 1e+259,
121		1e+260, 1e+261, 1e+262, 1e+263, 1e+264, 1e+265, 1e+266, 1e+267, 1e+268, 1e+269,
122		1e+270, 1e+271, 1e+272, 1e+273, 1e+274, 1e+275, 1e+276, 1e+277, 1e+278, 1e+279,
123		1e+280, 1e+281, 1e+282, 1e+283, 1e+284, 1e+285, 1e+286, 1e+287, 1e+288, 1e+289,
124		1e+290, 1e+291, 1e+292, 1e+293, 1e+294, 1e+295, 1e+296, 1e+297, 1e+298, 1e+299,
125
126		1e+300, 1e+301, 1e+302, 1e+303, 1e+304, 1e+305, 1e+306, 1e+307, 1e+308 };
127
128	1035607x	if( exp > 308 )
129		{
130	455x	return std::numeric_limits<double>::infinity();
131		}
132	1035152x	else if( exp < -308 )
133		{
134		// due to the way pow10 is used by dec_to_float,
135		// we can afford to return 0.0 here
136	151x	return 0.0;
137		}
138		else
139		{
140	1035001x	exp += 308;
141	1035001x	BOOST_ASSERT(exp >= 0 && exp < 618);
142	1035001x	return tab[exp];
143		}
144		}
145
146		inline
147		double
148	1043157x	dec_to_float(
149		std::uint64_t m,
150		std::int32_t e,
151		bool neg) noexcept
152		{
153		// convert to double explicitly to silence warnings
154	1043157x	double x = static_cast<double>(m);
155	1043157x	if(neg)
156	17069x	x = -x;
157
158		// pow10 returns infinity for large exponents,
159		// and zero times infinity is NaN
160	1043157x	if(m == 0)
161	7550x	return x;
162
163	1035607x	if(e < -305)
164		{
165	5269x	x *= 1e-305 ;
166	5269x	e += 305;
167		}
168
169	1035607x	if(e >= -22 && e < 0)
170	57637x	return x / pow10(-e);
171
172	977970x	return x * pow10(e);
173		}
174
175		inline
176		bool
177		is_control(char c) noexcept
178		{
179		return static_cast<unsigned char>(c) < 32;
180		}
181
182		inline
183		int
184	66931x	hex_digit(unsigned char c) noexcept
185		{
186		// by Peter Dimov
187	66931x	if( c >= '0' && c <= '9' )
188	35759x	return c - '0';
189	31172x	c &= ~0x20;
190	31172x	if( c >= 'A' && c <= 'F' )
191	30562x	return 10 + c - 'A';
192	610x	return -1;
193		}
194
195		} // detail
196
197		//----------------------------------------------------------
198
199		template< class Handler >
200		template< bool StackEmpty_, char First_ >
201		struct basic_parser<Handler>::
202		parse_number_helper
203		{
204		basic_parser* parser;
205		char const* p;
206
207		template< std::size_t N >
208		char const*
209	10515990x	operator()( mp11::mp_size_t<N> ) const
210		{
211	21026475x	return parser->parse_number(
212	10515990x	p,
213		std::integral_constant<bool, StackEmpty_>(),
214		std::integral_constant<char, First_>(),
215		std::integral_constant<
216	10510486x	number_precision, static_cast<number_precision>(N)>() );
217		}
218		};
219
220		//----------------------------------------------------------
221
222		template<class Handler>
223		void
224	8602432x	basic_parser<Handler>::
225		reserve()
226		{
227	8602432x	if(BOOST_JSON_LIKELY(
228		! st_.empty()))
229	37477x	return;
230		// Reserve the largest stack we need,
231		// to avoid reallocation during suspend.
232	17129910x	st_.reserve(
233		sizeof(state) + // document parsing state
234		(sizeof(state) +
235	8564955x	sizeof(std::size_t)) * depth() + // array and object state + size
236		sizeof(state) + // value parsing state
237		sizeof(std::size_t) + // string size
238		sizeof(state)); // comment state
239		}
240
241		//----------------------------------------------------------
242		//
243		// The sentinel value is returned by parse functions
244		// to indicate that the parser failed, or suspended.
245		// this is used as it is distinct from all valid values
246		// for data in write
247
248		template<class Handler>
249		const char*
250	47301147x	basic_parser<Handler>::
251		sentinel()
252		{
253		// the "+1" ensures that the returned pointer is unique even if
254		// the given input buffer borders on this object
255		return reinterpret_cast<
256	47301147x	const char*>(this) + 1;
257		}
258
259		template<class Handler>
260		bool
261	10851991x	basic_parser<Handler>::
262		incomplete(
263		const detail::const_stream_wrapper& cs)
264		{
265	10851991x	return cs.begin() == sentinel();
266		}
267
268		//----------------------------------------------------------
269		//
270		// These functions are declared with the BOOST_NOINLINE
271		// attribute to avoid polluting the parsers hot-path.
272		// They return the canary value to indicate suspension
273		// or failure.
274
275		template<class Handler>
276		const char*
277		basic_parser<Handler>::
278		suspend_or_fail(state st)
279		{
280		if(BOOST_JSON_LIKELY(
281		! ec_ && more_))
282		{
283		// suspend
284		reserve();
285		st_.push_unchecked(st);
286		}
287		return sentinel();
288		}
289
290		template<class Handler>
291		const char*
292	56179x	basic_parser<Handler>::
293		suspend_or_fail(
294		state st,
295		std::size_t n)
296		{
297	56179x	if(BOOST_JSON_LIKELY(
298		! ec_ && more_))
299		{
300		// suspend
301	35861x	reserve();
302	35861x	st_.push_unchecked(n);
303	35861x	st_.push_unchecked(st);
304		}
305	56179x	return sentinel();
306		}
307
308
309		template<class Handler>
310		const char*
311	19074x	basic_parser<Handler>::
312		fail(const char* p) noexcept
313		{
314	19074x	BOOST_ASSERT( p != sentinel() );
315	19074x	end_ = p;
316	19074x	return sentinel();
317		}
318
319		template<class Handler>
320		const char*
321	7781x	basic_parser<Handler>::
322		fail(
323		const char* p,
324		error ev,
325		source_location const* loc) noexcept
326		{
327	7781x	BOOST_ASSERT( p != sentinel() );
328	7781x	end_ = p;
329	7781x	ec_.assign(ev, loc);
330	7781x	return sentinel();
331		}
332
333		template<class Handler>
334		const char*
335	11323x	basic_parser<Handler>::
336		maybe_suspend(
337		const char* p,
338		state st)
339		{
340	11323x	if( p != sentinel() )
341	9445x	end_ = p;
342	11323x	if(BOOST_JSON_LIKELY(more_))
343		{
344		// suspend
345	11050x	reserve();
346	11050x	st_.push_unchecked(st);
347		}
348	11323x	return sentinel();
349		}
350
351		template<class Handler>
352		const char*
353	41250x	basic_parser<Handler>::
354		maybe_suspend(
355		const char* p,
356		state st,
357		std::size_t n)
358		{
359	41250x	BOOST_ASSERT( p != sentinel() );
360	41250x	end_ = p;
361	41250x	if(BOOST_JSON_LIKELY(more_))
362		{
363		// suspend
364	40842x	reserve();
365	40842x	st_.push_unchecked(n);
366	40842x	st_.push_unchecked(st);
367		}
368	41250x	return sentinel();
369		}
370
371		template<class Handler>
372		const char*
373	1132x	basic_parser<Handler>::
374		maybe_suspend(
375		const char* p,
376		state st,
377		const number& num)
378		{
379	1132x	BOOST_ASSERT( p != sentinel() );
380	1132x	end_ = p;
381	1132x	if(BOOST_JSON_LIKELY(more_))
382		{
383		// suspend
384	1132x	num_ = num;
385	1132x	reserve();
386	1132x	st_.push_unchecked(st);;
387		}
388	1132x	return sentinel();
389		}
390
391		template<class Handler>
392		const char*
393	88657x	basic_parser<Handler>::
394		suspend(
395		const char* p,
396		state st)
397		{
398	88657x	BOOST_ASSERT( p != sentinel() );
399	88657x	end_ = p;
400		// suspend
401	88657x	reserve();
402	88657x	st_.push_unchecked(st);
403	88657x	return sentinel();
404		}
405
406		template<class Handler>
407		const char*
408	8424890x	basic_parser<Handler>::
409		suspend(
410		const char* p,
411		state st,
412		const number& num)
413		{
414	8424890x	BOOST_ASSERT( p != sentinel() );
415	8424890x	end_ = p;
416		// suspend
417	8424890x	num_ = num;
418	8424890x	reserve();
419	8424890x	st_.push_unchecked(st);
420	8424890x	return sentinel();
421		}
422
423		template<class Handler>
424		template<
425		bool StackEmpty_/*,
426		bool Terminal_*/>
427		const char*
428	21764x	basic_parser<Handler>::
429		parse_comment(const char* p,
430		std::integral_constant<bool, StackEmpty_> stack_empty,
431		/std::integral_constant<bool, Terminal_>/ bool terminal)
432		{
433	21764x	detail::const_stream_wrapper cs(p, end_);
434	21764x	const char* start = cs.begin();
435		std::size_t remain;
436	21764x	if(! stack_empty && ! st_.empty())
437		{
438		state st;
439	3515x	st_.pop(st);
440	3515x	switch(st)
441		{
442	−	default: BOOST_JSON_UNREACHABLE(); // LCOV_EXCL_LINE
443	538x	case state::com1: goto do_com1;
444	2323x	case state::com2: goto do_com2;
445	438x	case state::com3: goto do_com3;
446	216x	case state::com4: goto do_com4;
447		}
448		}
449	18249x	BOOST_ASSERT(*cs == '/');
450	18249x	++cs;
451	18787x	do_com1:
452	18787x	if(BOOST_JSON_UNLIKELY(! cs))
453	555x	return maybe_suspend(cs.begin(), state::com1);
454	18232x	switch(*cs)
455		{
456	5x	default:
457		{
458		BOOST_STATIC_CONSTEXPR source_location loc
459		= BOOST_CURRENT_LOCATION;
460	5x	return fail(cs.begin(), error::syntax, &loc);
461		}
462	10543x	case '/':
463	10543x	++cs;
464	12866x	do_com2:
465		// KRYSTIAN TODO: this is a mess, we have to fix this
466	12866x	remain = cs.remain();
467	25732x	cs = remain ? static_cast<const char*>(
468	12866x	std::memchr(cs.begin(), '\n', remain)) : sentinel();
469	12866x	if(! cs.begin())
470	2143x	cs = sentinel();
471	12866x	if(BOOST_JSON_UNLIKELY(incomplete(cs)))
472		{
473		// if the doc does not terminate
474		// with a newline, treat it as the
475		// end of the comment
476	2574x	if(terminal && ! more_)
477		{
478	39x	if(BOOST_JSON_UNLIKELY(! h_.on_comment(
479		{start, cs.remain(start)}, ec_)))
480	2x	return fail(cs.end());
481	35x	return cs.end();
482		}
483	2535x	if(BOOST_JSON_UNLIKELY(! h_.on_comment_part(
484		{start, cs.remain(start)}, ec_)))
485	96x	return fail(cs.end());
486	2343x	if(terminal)
487	106x	return suspend(cs.end(), state::com2);
488	2237x	return maybe_suspend(cs.end(), state::com2);
489		}
490	10292x	break;
491	1684x	case '*':
492		do
493		{
494	9368x	++cs;
495	9806x	do_com3:
496		// KRYSTIAN TODO: this is a mess, we have to fix this
497	9806x	remain = cs.remain();
498	19612x	cs = remain ? static_cast<const char*>(
499	9806x	std::memchr(cs.begin(), '*', remain)) : sentinel();
500	9806x	if(! cs.begin())
501	242x	cs = sentinel();
502		// stopped inside a c comment
503	9806x	if(BOOST_JSON_UNLIKELY(incomplete(cs)))
504		{
505	503x	if(BOOST_JSON_UNLIKELY(! h_.on_comment_part(
506		{start, cs.remain(start)}, ec_)))
507	30x	return fail(cs.end());
508	443x	return maybe_suspend(cs.end(), state::com3);
509		}
510		// found a asterisk, check if the next char is a slash
511	9303x	++cs;
512	9519x	do_com4:
513	9519x	if(BOOST_JSON_UNLIKELY(! cs))
514		{
515	259x	if(BOOST_JSON_UNLIKELY(! h_.on_comment_part(
516		{start, cs.used(start)}, ec_)))
517	18x	return fail(cs.begin());
518	223x	return maybe_suspend(cs.begin(), state::com4);
519		}
520		}
521	9260x	while(*cs != '/');
522		}
523	17868x	++cs;
524	17868x	if(BOOST_JSON_UNLIKELY(! h_.on_comment(
525		{start, cs.used(start)}, ec_)))
526	968x	return fail(cs.begin());
527	15932x	return cs.begin();
528		}
529
530		template<class Handler>
531		template<bool StackEmpty_>
532		const char*
533	10710592x	basic_parser<Handler>::
534		parse_document(const char* p,
535		std::integral_constant<bool, StackEmpty_> stack_empty)
536		{
537	10710592x	detail::const_stream_wrapper cs(p, end_);
538	10710592x	if(! stack_empty && ! st_.empty())
539		{
540		state st;
541	8561473x	st_.peek(st);
542	8561473x	switch(st)
543		{
544	8475408x	default: goto do_doc2;
545	601x	case state::doc1:
546	601x	st_.pop(st);
547	601x	goto do_doc1;
548	85244x	case state::doc3:
549	85244x	st_.pop(st);
550	85244x	goto do_doc3;
551	220x	case state::com1: case state::com2:
552		case state::com3: case state::com4:
553	220x	goto do_doc4;
554		}
555		}
556	2149119x	do_doc1:
557	2149720x	cs = detail::count_whitespace(cs.begin(), cs.end());
558	2149720x	if(BOOST_JSON_UNLIKELY(! cs))
559	633x	return maybe_suspend(cs.begin(), state::doc1);
560	2149087x	do_doc2:
561	10624495x	switch(+opt_.allow_comments \|
562	10624495x	(opt_.allow_trailing_commas << 1) \|
563	10624495x	(opt_.allow_invalid_utf8 << 2))
564		{
565		// no extensions
566	10600782x	default:
567	10600782x	cs = parse_value(cs.begin(), stack_empty, std::false_type(), std::false_type(), std::false_type(), opt_.allow_invalid_utf16);
568	10585560x	break;
569		// comments
570	13582x	case 1:
571	13582x	cs = parse_value(cs.begin(), stack_empty, std::true_type(), std::false_type(), std::false_type(), opt_.allow_invalid_utf16);
572	11314x	break;
573		// trailing
574	6710x	case 2:
575	6710x	cs = parse_value(cs.begin(), stack_empty, std::false_type(), std::true_type(), std::false_type(), opt_.allow_invalid_utf16);
576	5117x	break;
577		// comments & trailing
578	761x	case 3:
579	761x	cs = parse_value(cs.begin(), stack_empty, std::true_type(), std::true_type(), std::false_type(), opt_.allow_invalid_utf16);
580	761x	break;
581		// skip validation
582	760x	case 4:
583	760x	cs = parse_value(cs.begin(), stack_empty, std::false_type(), std::false_type(), std::true_type(), opt_.allow_invalid_utf16);
584	760x	break;
585		// comments & skip validation
586	760x	case 5:
587	760x	cs = parse_value(cs.begin(), stack_empty, std::true_type(), std::false_type(), std::true_type(), opt_.allow_invalid_utf16);
588	760x	break;
589		// trailing & skip validation
590	760x	case 6:
591	760x	cs = parse_value(cs.begin(), stack_empty, std::false_type(), std::true_type(), std::true_type(), opt_.allow_invalid_utf16);
592	760x	break;
593		// comments & trailing & skip validation
594	380x	case 7:
595	380x	cs = parse_value(cs.begin(), stack_empty, std::true_type(), std::true_type(), std::true_type(), opt_.allow_invalid_utf16);
596	380x	break;
597		}
598	10605412x	if(BOOST_JSON_UNLIKELY(incomplete(cs)))
599		// the appropriate state has already been pushed into stack
600	8502706x	return sentinel();
601	2102706x	do_doc3:
602	2188282x	cs = detail::count_whitespace(cs.begin(), cs.end());
603	2188282x	if(BOOST_JSON_UNLIKELY(! cs))
604		{
605	2185684x	if(more_)
606	88551x	return suspend(cs.begin(), state::doc3);
607		}
608	2598x	else if(opt_.allow_comments && *cs == '/')
609		{
610	536x	do_doc4:
611	756x	cs = parse_comment(cs.begin(), stack_empty, std::true_type());
612	671x	if(BOOST_JSON_UNLIKELY(incomplete(cs)))
613	339x	return sentinel();
614	332x	goto do_doc3;
615		}
616	2099195x	return cs.begin();
617		}
618
619		template<class Handler>
620		template<
621		bool StackEmpty_,
622		bool AllowComments_/*,
623		bool AllowTrailing_,
624		bool AllowBadUTF8_*/>
625		const char*
626	10742129x	basic_parser<Handler>::
627		parse_value(const char* p,
628		std::integral_constant<bool, StackEmpty_> stack_empty,
629		std::integral_constant<bool, AllowComments_> allow_comments,
630		/std::integral_constant<bool, AllowTrailing_>/ bool allow_trailing,
631		/std::integral_constant<bool, AllowBadUTF8_>/ bool allow_bad_utf8,
632		bool allow_bad_utf16)
633		{
634	10742129x	if(stack_empty \|\| st_.empty())
635		{
636	2248335x	loop:
637	2253251x	switch(*p)
638		{
639	22761x	case '0':
640	22761x	return mp11::mp_with_index<3>(
641	22761x	static_cast<unsigned char>(opt_.numbers),
642	22100x	parse_number_helper<true, '0'>{ this, p });
643	25185x	case '-':
644	25185x	return mp11::mp_with_index<3>(
645	25185x	static_cast<unsigned char>(opt_.numbers),
646	24073x	parse_number_helper<true, '-'>{ this, p });
647	2042025x	case '1': case '2': case '3':
648		case '4': case '5': case '6':
649		case '7': case '8': case '9':
650	2042025x	return mp11::mp_with_index<3>(
651	2042025x	static_cast<unsigned char>(opt_.numbers),
652	2039149x	parse_number_helper<true, '+'>{ this, p });
653	11381x	case 'n':
654	11381x	return parse_literal( p, detail::literals_c<detail::literals::null>() );
655	664x	case 't':
656	664x	return parse_literal( p, detail::literals_c<detail::literals::true_>() );
657	722x	case 'f':
658	722x	return parse_literal( p, detail::literals_c<detail::literals::false_>() );
659	681x	case 'I':
660	681x	if( !opt_.allow_infinity_and_nan )
661		{
662		BOOST_STATIC_CONSTEXPR source_location loc
663		= BOOST_CURRENT_LOCATION;
664	24x	return fail(p, error::syntax, &loc);
665		}
666	657x	return parse_literal( p, detail::literals_c<detail::literals::infinity>() );
667	231x	case 'N':
668	231x	if( !opt_.allow_infinity_and_nan )
669		{
670		BOOST_STATIC_CONSTEXPR source_location loc
671		= BOOST_CURRENT_LOCATION;
672	30x	return fail(p, error::syntax, &loc);
673		}
674	201x	return parse_literal(p, detail::literals_c<detail::literals::nan>() );
675	47587x	case '"':
676	47587x	return parse_string(p, std::true_type(), std::false_type(), allow_bad_utf8, allow_bad_utf16);
677	20618x	case '[':
678	20618x	return parse_array(p, std::true_type(), allow_comments, allow_trailing, allow_bad_utf8, allow_bad_utf16);
679	74131x	case '{':
680	74131x	return parse_object(p, std::true_type(), allow_comments, allow_trailing, allow_bad_utf8, allow_bad_utf16);
681	6144x	case '/':
682	6144x	if(! allow_comments)
683		{
684		BOOST_STATIC_CONSTEXPR source_location loc
685		= BOOST_CURRENT_LOCATION;
686	284x	return fail(p, error::syntax, &loc);
687		}
688	5860x	p = parse_comment(p, stack_empty, std::false_type());
689		// KRYSTIAN NOTE: incomplete takes const_stream, we either
690		// can add an overload, change the existing one to take a pointer,
691		// or just leave it as is
692	5621x	if(BOOST_JSON_UNLIKELY(p == sentinel()))
693	602x	return maybe_suspend(p, state::val2);
694		BOOST_FALLTHROUGH;
695		case ' ':
696		case '\t':
697		case '\n':
698		case '\r':
699	5035x	p = detail::count_whitespace(p, end_);
700	5035x	if(BOOST_JSON_UNLIKELY(p == end_))
701	119x	return maybe_suspend(p, state::val1);
702	4916x	goto loop;
703	1105x	default:
704		{
705		BOOST_STATIC_CONSTEXPR source_location loc
706		= BOOST_CURRENT_LOCATION;
707	1105x	return fail(p, error::syntax, &loc);
708		}
709		}
710		}
711	8493794x	return resume_value(p, allow_comments, allow_trailing, allow_bad_utf8, allow_bad_utf16);
712		}
713
714		template<class Handler>
715		template<
716		bool AllowComments_/*,
717		bool AllowTrailing_,
718		bool AllowBadUTF8_*/>
719		const char*
720	8493794x	basic_parser<Handler>::
721		resume_value(const char* p,
722		std::integral_constant<bool, AllowComments_> allow_comments,
723		/std::integral_constant<bool, AllowTrailing_>/ bool allow_trailing,
724		/std::integral_constant<bool, AllowBadUTF8_>/ bool allow_bad_utf8,
725		bool allow_bad_utf16)
726		{
727		state st;
728	8493794x	st_.peek(st);
729	8493794x	switch(st)
730		{
731	−	default: BOOST_JSON_UNREACHABLE(); // LCOV_EXCL_LINE
732	1924x	case state::lit1:
733	1924x	return parse_literal(p, detail::literals_c<detail::literals::resume>() );
734
735	23268x	case state::str1: case state::str2:
736		case state::str8:
737	23268x	return parse_string(p, std::false_type(), std::false_type(), allow_bad_utf8, allow_bad_utf16);
738
739	5730x	case state::arr1: case state::arr2:
740		case state::arr3: case state::arr4:
741		case state::arr5: case state::arr6:
742	5730x	return parse_array(p, std::false_type(), allow_comments, allow_trailing, allow_bad_utf8, allow_bad_utf16);
743
744	35058x	case state::obj1: case state::obj2:
745		case state::obj3: case state::obj4:
746		case state::obj5: case state::obj6:
747		case state::obj7: case state::obj8:
748		case state::obj9: case state::obj10:
749		case state::obj11:
750	35058x	return parse_object(p, std::false_type(), allow_comments, allow_trailing, allow_bad_utf8, allow_bad_utf16);
751
752	8426019x	case state::num1: case state::num2:
753		case state::num3: case state::num4:
754		case state::num5: case state::num6:
755		case state::num7: case state::num8:
756		case state::exp1: case state::exp2:
757		case state::exp3:
758	8426019x	return mp11::mp_with_index<3>(
759	8426019x	static_cast<unsigned char>(opt_.numbers),
760	8425164x	parse_number_helper<false, 0>{ this, p });
761
762		// KRYSTIAN NOTE: these are special cases
763	112x	case state::val1:
764		{
765	112x	st_.pop(st);
766	112x	BOOST_ASSERT(st_.empty());
767	112x	p = detail::count_whitespace(p, end_);
768	112x	if(BOOST_JSON_UNLIKELY(p == end_))
769	4x	return maybe_suspend(p, state::val1);
770	108x	return parse_value(p, std::true_type(), allow_comments, allow_trailing, allow_bad_utf8, allow_bad_utf16);
771		}
772
773	1616x	case state::val2:
774		{
775	1616x	st_.pop(st);
776	1616x	p = parse_comment(p, std::false_type(), std::false_type());
777	1596x	if(BOOST_JSON_UNLIKELY(p == sentinel()))
778	1276x	return maybe_suspend(p, state::val2);
779	320x	if(BOOST_JSON_UNLIKELY( p == end_ ))
780	77x	return maybe_suspend(p, state::val3);
781	243x	BOOST_ASSERT(st_.empty());
782	243x	return parse_value(p, std::true_type(), std::true_type(), allow_trailing, allow_bad_utf8, allow_bad_utf16);
783		}
784
785	67x	case state::val3:
786		{
787	67x	st_.pop(st);
788	67x	return parse_value(p, std::true_type(), std::true_type(), allow_trailing, allow_bad_utf8, allow_bad_utf16);
789		}
790		}
791		}
792
793		template<class Handler>
794		template<class Literal>
795		const char*
796	16565x	basic_parser<Handler>::
797		parse_literal(const char* p, Literal)
798		{
799		using L = detail::literals;
800
801		std::size_t cur_lit;
802		std::size_t offset;
803
804	16565x	detail::const_stream_wrapper cs(p, end_);
805		BOOST_IF_CONSTEXPR( Literal::value != L::resume )
806		{
807	13634x	constexpr std::size_t index = literal_index(Literal::value);
808	13634x	constexpr char const* literal = detail::literal_strings[index];
809	13634x	constexpr std::size_t sz = detail::literal_sizes[index];
810
811	13634x	if(BOOST_JSON_LIKELY( cs.remain() >= sz ))
812		{
813	11984x	int const cmp = std::memcmp(cs.begin(), literal, sz);
814	11984x	if( cmp != 0 )
815		{
816		BOOST_STATIC_CONSTEXPR source_location loc = BOOST_CURRENT_LOCATION;
817	197x	return fail(cs.begin(), error::syntax, &loc);
818		}
819
820		BOOST_IF_CONSTEXPR( Literal::value == L::null )
821		{
822	10789x	if(BOOST_JSON_UNLIKELY(
823		! h_.on_null(ec_)))
824	161x	return fail(cs.begin());
825		}
826		else BOOST_IF_CONSTEXPR( Literal::value == L::true_ )
827		{
828	384x	if(BOOST_JSON_UNLIKELY(
829		! h_.on_bool(true, ec_)))
830	14x	return fail(cs.begin());
831		}
832		else BOOST_IF_CONSTEXPR( Literal::value == L::false_ )
833		{
834	406x	if(BOOST_JSON_UNLIKELY(
835		! h_.on_bool(false, ec_)))
836	13x	return fail(cs.begin());
837		}
838		else BOOST_IF_CONSTEXPR( Literal::value == L::infinity )
839		{
840	103x	if(BOOST_JSON_UNLIKELY(
841		! h_.on_double(
842		std::numeric_limits<double>::infinity(),
843		string_view(literal, sz),
844		ec_)))
845	13x	return fail(cs.begin());
846		}
847		else BOOST_IF_CONSTEXPR( Literal::value == L::neg_infinity )
848		{
849	9x	if(BOOST_JSON_UNLIKELY(
850		! h_.on_double(
851		-std::numeric_limits<double>::infinity(),
852		string_view(literal, sz),
853		ec_)))
854	1x	return fail(cs.begin());
855		}
856		else BOOST_IF_CONSTEXPR( Literal::value == L::nan )
857		{
858	96x	if(BOOST_JSON_UNLIKELY(
859		! h_.on_double(
860		std::numeric_limits<double>::quiet_NaN(),
861		string_view(literal, sz),
862		ec_)))
863	12x	return fail(cs.begin());
864		}
865		else
866		{
867		BOOST_JSON_UNREACHABLE(); // LCOV_EXCL_LINE
868		}
869
870	11363x	cs += sz;
871	11363x	return cs.begin();
872		}
873
874	1650x	offset = 0;
875	1650x	cur_lit = index;
876		}
877		else
878		{
879		state st;
880	2931x	st_.pop(st);
881	2931x	BOOST_ASSERT( st == state::lit1 );
882
883	2931x	cur_lit = cur_lit_;
884	2931x	offset = lit_offset_;
885		}
886
887	4581x	std::size_t const lit_size = detail::literal_sizes[cur_lit];
888	4581x	std::size_t const size = (std::min)( lit_size - offset, cs.remain() );
889	4581x	int cmp = 0;
890	4581x	if(BOOST_JSON_LIKELY( cs.begin() ))
891	4580x	cmp = std::memcmp(
892	4580x	cs.begin(), detail::literal_strings[cur_lit] + offset, size );
893	4581x	if( cmp != 0 )
894		{
895		BOOST_STATIC_CONSTEXPR source_location loc = BOOST_CURRENT_LOCATION;
896	699x	return fail(cs.begin(), error::syntax, &loc);
897		}
898
899	3882x	if(BOOST_JSON_UNLIKELY( offset + size < lit_size ))
900		{
901	1990x	BOOST_ASSERT( cur_lit < 256 );
902	1990x	cur_lit_ = static_cast<unsigned char>( cur_lit );
903	1990x	BOOST_ASSERT( offset + size < 256 );
904	1990x	lit_offset_ = static_cast<unsigned char>( offset + size );
905	1990x	return maybe_suspend(cs.begin() + size, state::lit1);
906		}
907
908	1892x	switch( static_cast<L>(cur_lit) )
909		{
910	472x	case L::null:
911	472x	if(BOOST_JSON_UNLIKELY(
912		! h_.on_null(ec_)))
913	61x	return fail(cs.begin());
914	351x	break;
915	152x	case L::true_:
916	152x	if(BOOST_JSON_UNLIKELY(
917		! h_.on_bool(true, ec_)))
918	22x	return fail(cs.begin());
919	109x	break;
920	198x	case L::false_:
921	198x	if(BOOST_JSON_UNLIKELY(
922		! h_.on_bool(false, ec_)))
923	28x	return fail(cs.begin());
924	142x	break;
925	308x	case L::infinity:
926	308x	if(BOOST_JSON_UNLIKELY(
927		! h_.on_double(
928		std::numeric_limits<double>::infinity(),
929		string_view(
930		detail::literal_strings[ literal_index(L::infinity) ],
931		detail::literal_sizes[ literal_index(L::infinity) ]),
932		ec_)))
933	49x	return fail(cs.begin());
934	210x	break;
935	686x	case L::neg_infinity:
936	686x	if(BOOST_JSON_UNLIKELY(
937		! h_.on_double(
938		-std::numeric_limits<double>::infinity(),
939		string_view(
940		detail::literal_strings[ literal_index(L::neg_infinity) ],
941		detail::literal_sizes[ literal_index(L::neg_infinity) ]),
942		ec_)))
943	102x	return fail(cs.begin());
944	482x	break;
945	76x	case L::nan:
946	76x	if(BOOST_JSON_UNLIKELY(
947		! h_.on_double(
948		std::numeric_limits<double>::quiet_NaN(),
949		string_view(
950		detail::literal_strings[ literal_index(L::nan) ],
951		detail::literal_sizes[ literal_index(L::nan) ]),
952		ec_)))
953	12x	return fail(cs.begin());
954	52x	break;
955	−	default: BOOST_JSON_UNREACHABLE(); // LCOV_EXCL_LINE
956		}
957
958	1346x	cs += size;
959	1346x	return cs.begin();
960		}
961
962		//----------------------------------------------------------
963
964		template<class Handler>
965		template<bool StackEmpty_, bool IsKey_>
966		const char*
967	164330x	basic_parser<Handler>::
968		parse_string(const char* p,
969		std::integral_constant<bool, StackEmpty_> stack_empty,
970		std::integral_constant<bool, IsKey_> is_key,
971		bool allow_bad_utf8,
972		bool allow_bad_utf16)
973		{
974	164330x	detail::const_stream_wrapper cs(p, end_);
975		std::size_t total;
976		char const* start;
977		std::size_t size;
978	164330x	if(! stack_empty && ! st_.empty())
979		{
980		state st;
981	35915x	st_.pop(st);
982	35915x	st_.pop(total);
983	35915x	switch(st)
984		{
985	−	default: BOOST_JSON_UNREACHABLE(); // LCOV_EXCL_LINE
986	3149x	case state::str2: goto do_str2;
987	1868x	case state::str8: goto do_str8;
988	30898x	case state::str1: break;
989		}
990		}
991		else
992		{
993	128415x	BOOST_ASSERT(*cs == '\x22'); // '"'
994	128415x	++cs;
995	128415x	total = 0;
996		}
997
998	167806x	do_str1:
999	167806x	start = cs.begin();
1000	335612x	cs = allow_bad_utf8?
1001	2177x	detail::count_valid<true>(cs.begin(), cs.end()):
1002	165629x	detail::count_valid<false>(cs.begin(), cs.end());
1003	167806x	size = cs.used(start);
1004	167806x	if(is_key)
1005		{
1006	46694x	BOOST_ASSERT(total <= Handler::max_key_size);
1007	94005x	if(BOOST_JSON_UNLIKELY(size >
1008		Handler::max_key_size - total))
1009		{
1010		BOOST_STATIC_CONSTEXPR source_location loc
1011		= BOOST_CURRENT_LOCATION;
1012	3x	return fail(cs.begin(), error::key_too_large, &loc);
1013		}
1014		}
1015		else
1016		{
1017	38330x	BOOST_ASSERT(total <= Handler::max_string_size);
1018	73801x	if(BOOST_JSON_UNLIKELY(size >
1019		Handler::max_string_size - total))
1020		{
1021		BOOST_STATIC_CONSTEXPR source_location loc
1022		= BOOST_CURRENT_LOCATION;
1023	3x	return fail(cs.begin(), error::string_too_large, &loc);
1024		}
1025		}
1026	167800x	total += size;
1027	167800x	if(BOOST_JSON_UNLIKELY(! cs))
1028		{
1029		// call handler if the string isn't empty
1030	33232x	if(BOOST_JSON_LIKELY(size))
1031		{
1032		{
1033	30066x	bool r = is_key?
1034	12404x	h_.on_key_part( {start, size}, total, ec_ ):
1035	18996x	h_.on_string_part( {start, size}, total, ec_ );
1036
1037	28958x	if(BOOST_JSON_UNLIKELY(!r))
1038		{
1039	1110x	return fail(cs.begin());
1040		}
1041		}
1042		}
1043	31014x	return maybe_suspend(cs.begin(), state::str1, total);
1044		}
1045		// at this point all valid characters have been skipped, so any remaining
1046		// if there are any more characters, they are either escaped, or incomplete
1047		// utf8, or invalid utf8
1048	134568x	if(BOOST_JSON_UNLIKELY(*cs != '\x22')) // '"'
1049		{
1050		// sequence is invalid or incomplete
1051	15081x	if((*cs & 0x80) && !allow_bad_utf8)
1052		{
1053	3472x	seq_.save(cs.begin(), cs.remain());
1054	3472x	if(BOOST_JSON_UNLIKELY(seq_.complete()))
1055		{
1056		BOOST_STATIC_CONSTEXPR source_location loc
1057		= BOOST_CURRENT_LOCATION;
1058	1557x	return fail(cs.begin(), error::syntax, &loc);
1059		}
1060	1915x	if(BOOST_JSON_LIKELY(size))
1061		{
1062	245x	bool const r = is_key?
1063	22x	h_.on_key_part( {start, size}, total, ec_ ):
1064	245x	h_.on_string_part( {start, size}, total, ec_ );
1065	223x	if(BOOST_JSON_UNLIKELY( !r ))
1066	22x	return fail( cs.begin() );
1067		}
1068	1871x	return maybe_suspend(cs.end(), state::str8, total);
1069		}
1070	11609x	else if(BOOST_JSON_LIKELY(*cs == '\\'))
1071		{
1072		// flush unescaped run from input
1073	11500x	if(BOOST_JSON_LIKELY(size))
1074		{
1075	4250x	bool const r = is_key?
1076	1226x	h_.on_key_part( {start, size}, total, ec_ ):
1077	3554x	h_.on_string_part( {start, size}, total, ec_ );
1078	3766x	if(BOOST_JSON_UNLIKELY( !r ))
1079	484x	return fail( cs.begin() );
1080		}
1081	7250x	do_str2:
1082	13681x	cs = parse_escaped(cs.begin(), total, stack_empty, is_key, allow_bad_utf16);
1083	12719x	if(BOOST_JSON_UNLIKELY( incomplete(cs) ))
1084	5476x	return suspend_or_fail(state::str2, total);
1085
1086	7243x	goto do_str1;
1087		}
1088		// illegal control
1089		BOOST_STATIC_CONSTEXPR source_location loc = BOOST_CURRENT_LOCATION;
1090	109x	return fail(cs.begin(), error::syntax, &loc);
1091		}
1092
1093		{
1094	119487x	bool r = is_key?
1095	84511x	h_.on_key( {start, size}, total, ec_ ):
1096	41985x	h_.on_string( {start, size}, total, ec_ );
1097
1098	115113x	if(BOOST_JSON_UNLIKELY(!r))
1099		{
1100	4318x	return fail(cs.begin());
1101		}
1102		}
1103
1104	110795x	++cs;
1105	110795x	return cs.begin();
1106
1107	1868x	do_str8:
1108	1868x	uint8_t needed = seq_.needed();
1109	1868x	if(BOOST_JSON_UNLIKELY( !seq_.append(cs.begin(), cs.remain()) ))
1110	4x	return maybe_suspend(cs.end(), state::str8, total);
1111	1864x	if(BOOST_JSON_UNLIKELY( !seq_.valid() ))
1112		{
1113		BOOST_STATIC_CONSTEXPR source_location loc = BOOST_CURRENT_LOCATION;
1114	210x	return fail(cs.begin(), error::syntax, &loc);
1115		}
1116		{
1117	1654x	std::size_t const n = seq_.length();
1118		bool r;
1119	1654x	if(is_key)
1120		{
1121	2x	BOOST_ASSERT(total <= Handler::max_key_size);
1122	2x	if(BOOST_JSON_UNLIKELY(n >
1123		Handler::max_key_size - total))
1124		{
1125		BOOST_STATIC_CONSTEXPR source_location loc
1126		= BOOST_CURRENT_LOCATION;
1127	1x	return fail(cs.begin(), error::key_too_large, &loc);
1128		}
1129	1x	total += n;
1130	1x	r = h_.on_key_part( {seq_.data(), n}, total, ec_ );
1131		}
1132		else
1133		{
1134	1x	BOOST_ASSERT(total <= Handler::max_string_size);
1135	1652x	if(BOOST_JSON_UNLIKELY(n >
1136		Handler::max_string_size - total))
1137		{
1138		BOOST_STATIC_CONSTEXPR source_location loc
1139		= BOOST_CURRENT_LOCATION;
1140	1x	return fail(cs.begin(), error::string_too_large, &loc);
1141		}
1142	1651x	total += n;
1143	1651x	r = h_.on_string_part( {seq_.data(), n}, total, ec_ );
1144		}
1145	1451x	if(BOOST_JSON_UNLIKELY( !r ))
1146	201x	return fail( cs.begin() );
1147		}
1148	1250x	cs += needed;
1149	1250x	goto do_str1;
1150		}
1151
1152		template<class Handler>
1153		template<bool StackEmpty_>
1154		const char*
1155	13681x	basic_parser<Handler>::
1156		parse_escaped(
1157		const char* p,
1158		std::size_t& total,
1159		std::integral_constant<bool, StackEmpty_> stack_empty,
1160		bool is_key,
1161		bool allow_bad_utf16)
1162		{
1163	13681x	constexpr unsigned urc = 0xFFFD; // Unicode replacement character
1164	13681x	auto const ev_too_large = is_key?
1165		error::key_too_large : error::string_too_large;
1166	13681x	auto const max_size = is_key?
1167		Handler::max_key_size : Handler::max_string_size;
1168		int digit;
1169
1170		//---------------------------------------------------------------
1171		//
1172		// To handle escapes, a local temporary buffer accumulates
1173		// the unescaped result. The algorithm attempts to fill the
1174		// buffer to capacity before invoking the handler.
1175		// In some cases the temporary buffer needs to be flushed
1176		// before it is full:
1177		// * When the closing double quote is seen
1178		// * When there in no more input (and more is expected later)
1179		// A goal of the algorithm is to call the handler as few times
1180		// as possible. Thus, when the first escape is encountered,
1181		// the algorithm attempts to fill the temporary buffer first.
1182		//
1183	13681x	detail::buffer<BOOST_JSON_STACK_BUFFER_SIZE> temp;
1184
1185		// Unescaped JSON is never larger than its escaped version.
1186		// To efficiently process only what will fit in the temporary buffer,
1187		// the size of the input stream is temporarily "clipped" to the size
1188		// of the temporary buffer.
1189		// handle escaped character
1190	13681x	detail::clipped_const_stream cs(p, end_);
1191	13681x	cs.clip(temp.max_size());
1192
1193	13681x	if(! stack_empty && ! st_.empty())
1194		{
1195		state st;
1196	3149x	st_.pop(st);
1197	3149x	switch(st)
1198		{
1199	−	default: BOOST_JSON_UNREACHABLE(); // LCOV_EXCL_LINE
1200	528x	case state::str3: goto do_str3;
1201	392x	case state::str4: goto do_str4;
1202	390x	case state::str5: goto do_str5;
1203	389x	case state::str6: goto do_str6;
1204	386x	case state::str7: goto do_str7;
1205	232x	case state::sur1: goto do_sur1;
1206	188x	case state::sur2: goto do_sur2;
1207	164x	case state::sur3: goto do_sur3;
1208	162x	case state::sur4: goto do_sur4;
1209	160x	case state::sur5: goto do_sur5;
1210	158x	case state::sur6: goto do_sur6;
1211		}
1212		}
1213
1214	3783x	while(true)
1215		{
1216	14315x	BOOST_ASSERT( temp.capacity() );
1217	14315x	BOOST_ASSERT(*cs == '\\');
1218	14315x	++cs;
1219	15174x	do_str3:
1220	15379x	if(BOOST_JSON_UNLIKELY(! cs))
1221		{
1222	562x	if(BOOST_JSON_LIKELY(! temp.empty()))
1223		{
1224	1x	BOOST_ASSERT(total <= max_size);
1225	101x	if(BOOST_JSON_UNLIKELY(
1226		temp.size() > max_size - total))
1227		{
1228		BOOST_STATIC_CONSTEXPR source_location loc
1229		= BOOST_CURRENT_LOCATION;
1230	1x	return fail(cs.begin(), ev_too_large, &loc);
1231		}
1232	100x	total += temp.size();
1233		{
1234	91x	bool r = is_key
1235	100x	? h_.on_key_part(temp.get(), total, ec_)
1236	100x	: h_.on_string_part(temp.get(), total, ec_);
1237
1238	91x	if(BOOST_JSON_UNLIKELY(!r))
1239		{
1240	9x	return fail(cs.begin());
1241		}
1242		}
1243	82x	temp.clear();
1244		}
1245	543x	cs.clip(temp.max_size());
1246	543x	if(BOOST_JSON_UNLIKELY(! cs))
1247	543x	return maybe_suspend(cs.begin(), state::str3);
1248		}
1249	14817x	switch(*cs)
1250		{
1251	191x	default:
1252		{
1253		BOOST_STATIC_CONSTEXPR source_location loc
1254		= BOOST_CURRENT_LOCATION;
1255	191x	return fail(cs.begin(), error::syntax, &loc);
1256		}
1257	265x	case '\x22': // '"'
1258	265x	temp.push_back('\x22');
1259	265x	++cs;
1260	265x	break;
1261	178x	case '\\':
1262	178x	temp.push_back('\\');
1263	178x	++cs;
1264	178x	break;
1265	96x	case '/':
1266	96x	temp.push_back('/');
1267	96x	++cs;
1268	96x	break;
1269	112x	case 'b':
1270	112x	temp.push_back('\x08');
1271	112x	++cs;
1272	112x	break;
1273	108x	case 'f':
1274	108x	temp.push_back('\x0c');
1275	108x	++cs;
1276	108x	break;
1277	1766x	case 'n':
1278	1766x	temp.push_back('\x0a');
1279	1766x	++cs;
1280	1766x	break;
1281	146x	case 'r':
1282	146x	temp.push_back('\x0d');
1283	146x	++cs;
1284	146x	break;
1285	266x	case 't':
1286	266x	temp.push_back('\x09');
1287	266x	++cs;
1288	266x	break;
1289	11689x	case 'u':
1290		// utf16 escape
1291		//
1292		// fast path only when the buffer
1293		// is large enough for 2 surrogates
1294	11689x	if(BOOST_JSON_LIKELY(cs.remain() > 10))
1295		{
1296		// KRYSTIAN TODO: this could be done
1297		// with fewer instructions
1298	11394x	digit = detail::load_little_endian<4>(
1299	5697x	cs.begin() + 1);
1300	5697x	int d4 = detail::hex_digit(static_cast<
1301	5697x	unsigned char>(digit >> 24));
1302	5697x	int d3 = detail::hex_digit(static_cast<
1303	5697x	unsigned char>(digit >> 16));
1304	5697x	int d2 = detail::hex_digit(static_cast<
1305	5697x	unsigned char>(digit >> 8));
1306	5697x	int d1 = detail::hex_digit(static_cast<
1307		unsigned char>(digit));
1308	5697x	if(BOOST_JSON_UNLIKELY(
1309		(d1 \| d2 \| d3 \| d4) == -1))
1310		{
1311	60x	if(d1 != -1)
1312	45x	++cs;
1313	60x	if(d2 != -1)
1314	30x	++cs;
1315	60x	if(d3 != -1)
1316	15x	++cs;
1317		BOOST_STATIC_CONSTEXPR source_location loc
1318		= BOOST_CURRENT_LOCATION;
1319	60x	return fail(cs.begin(), error::expected_hex_digit, &loc);
1320		}
1321		// 32 bit unicode scalar value
1322	5637x	unsigned u1 =
1323	5637x	(d1 << 12) + (d2 << 8) +
1324	5637x	(d3 << 4) + d4;
1325		// valid unicode scalar values are
1326		// [0, D7FF] and [E000, 10FFFF]
1327		// values within this range are valid utf-8
1328		// code points and invalid leading surrogates.
1329	5637x	if(BOOST_JSON_LIKELY(
1330		u1 < 0xd800 \|\| u1 > 0xdfff))
1331		{
1332	1340x	cs += 5;
1333	1340x	temp.append_utf8(u1);
1334	1340x	break;
1335		}
1336	4297x	if(BOOST_JSON_UNLIKELY(u1 > 0xdbff))
1337		{
1338		// If it's an illegal leading surrogate and
1339		// the parser does not allow it, return an error.
1340	707x	if(!allow_bad_utf16)
1341		{
1342		BOOST_STATIC_CONSTEXPR source_location loc
1343		= BOOST_CURRENT_LOCATION;
1344	122x	return fail(cs.begin(), error::illegal_leading_surrogate,
1345	122x	&loc);
1346		}
1347		// Otherwise, append the Unicode replacement character
1348		else
1349		{
1350	585x	cs += 5;
1351	585x	temp.append_utf8(urc);
1352	585x	break;
1353		}
1354		}
1355	3590x	cs += 5;
1356		// KRYSTIAN TODO: this can be a two byte load
1357		// and a single comparison. We lose error information,
1358		// but it's faster.
1359	3590x	if(BOOST_JSON_UNLIKELY(*cs != '\\'))
1360		{
1361		// If the next character is not a backslash and
1362		// the parser does not allow it, return a syntax error.
1363	156x	if(!allow_bad_utf16)
1364		{
1365		BOOST_STATIC_CONSTEXPR source_location loc
1366		= BOOST_CURRENT_LOCATION;
1367	15x	return fail(cs.begin(), error::syntax, &loc);
1368		}
1369		// Otherwise, append the Unicode replacement character since
1370		// the first code point is a valid leading surrogate
1371		else
1372		{
1373	141x	temp.append_utf8(urc);
1374	141x	break;
1375		}
1376		}
1377	3434x	++cs;
1378	3434x	if(BOOST_JSON_UNLIKELY(*cs != 'u'))
1379		{
1380	220x	if (!allow_bad_utf16)
1381		{
1382		BOOST_STATIC_CONSTEXPR source_location loc
1383		= BOOST_CURRENT_LOCATION;
1384	15x	return fail(cs.begin(), error::syntax, &loc);
1385		}
1386		// Otherwise, append the Unicode replacement character since
1387		// the first code point is a valid leading surrogate
1388		else
1389		{
1390	205x	temp.append_utf8(urc);
1391	205x	goto do_str3;
1392		}
1393		}
1394	3214x	++cs;
1395	3214x	digit = detail::load_little_endian<4>(cs.begin());
1396	3214x	d4 = detail::hex_digit(static_cast<
1397	3214x	unsigned char>(digit >> 24));
1398	3214x	d3 = detail::hex_digit(static_cast<
1399	3214x	unsigned char>(digit >> 16));
1400	3214x	d2 = detail::hex_digit(static_cast<
1401	3214x	unsigned char>(digit >> 8));
1402	3214x	d1 = detail::hex_digit(static_cast<
1403		unsigned char>(digit));
1404	3214x	if(BOOST_JSON_UNLIKELY(
1405		(d1 \| d2 \| d3 \| d4) == -1))
1406		{
1407	90x	if(d1 != -1)
1408	75x	++cs;
1409	90x	if(d2 != -1)
1410	45x	++cs;
1411	90x	if(d3 != -1)
1412	15x	++cs;
1413		BOOST_STATIC_CONSTEXPR source_location loc
1414		= BOOST_CURRENT_LOCATION;
1415	90x	return fail(cs.begin(), error::expected_hex_digit, &loc);
1416		}
1417	3124x	unsigned u2 =
1418	3124x	(d1 << 12) + (d2 << 8) +
1419	3124x	(d3 << 4) + d4;
1420		// Check if the second code point is a valid trailing surrogate.
1421		// Valid trailing surrogates are [DC00, DFFF]
1422	3124x	if(BOOST_JSON_UNLIKELY(
1423		u2 < 0xdc00 \|\| u2 > 0xdfff))
1424		{
1425		// If not valid and the parser does not allow it, return an error.
1426	1353x	if(!allow_bad_utf16)
1427		{
1428		BOOST_STATIC_CONSTEXPR source_location loc
1429		= BOOST_CURRENT_LOCATION;
1430	136x	return fail(cs.begin(), error::illegal_trailing_surrogate,
1431	136x	&loc);
1432		}
1433		// Append the replacement character for the
1434		// first leading surrogate.
1435	1217x	cs += 4;
1436	1217x	temp.append_utf8(urc);
1437		// Check if the second code point is a
1438		// valid unicode scalar value (invalid leading
1439		// or trailing surrogate)
1440	1217x	if (u2 < 0xd800 \|\| u2 > 0xdbff)
1441		{
1442	524x	temp.append_utf8(u2);
1443	524x	break;
1444		}
1445		// If it is a valid leading surrogate
1446		else
1447		{
1448	693x	u1_ = u2;
1449	693x	goto do_sur1;
1450		}
1451		}
1452	1771x	cs += 4;
1453		// Calculate the Unicode code point from the surrogate pair and
1454		// append the UTF-8 representation.
1455	1771x	unsigned cp =
1456	1771x	((u1 - 0xd800) << 10) +
1457		((u2 - 0xdc00)) +
1458		0x10000;
1459		// utf-16 surrogate pair
1460	1771x	temp.append_utf8(cp);
1461	1771x	break;
1462		}
1463		// flush
1464	5992x	if(BOOST_JSON_LIKELY(! temp.empty()))
1465		{
1466	4x	BOOST_ASSERT(total <= max_size);
1467	1723x	if(BOOST_JSON_UNLIKELY(
1468		temp.size() > max_size - total))
1469		{
1470		BOOST_STATIC_CONSTEXPR source_location loc
1471		= BOOST_CURRENT_LOCATION;
1472	1x	return fail(cs.begin(), ev_too_large, &loc);
1473		}
1474	1722x	total += temp.size();
1475		{
1476	1582x	bool r = is_key
1477	1722x	? h_.on_key_part(temp.get(), total, ec_)
1478	1722x	: h_.on_string_part(temp.get(), total, ec_);
1479
1480	1582x	if(BOOST_JSON_UNLIKELY(!r))
1481		{
1482	140x	return fail(cs.begin());
1483		}
1484		}
1485	1442x	temp.clear();
1486	1442x	cs.clip(temp.max_size());
1487		}
1488	5711x	++cs;
1489		// utf-16 escape
1490	6103x	do_str4:
1491	6103x	if(BOOST_JSON_UNLIKELY(! cs))
1492	392x	return maybe_suspend(cs.begin(), state::str4);
1493	5711x	digit = detail::hex_digit(*cs);
1494	5711x	if(BOOST_JSON_UNLIKELY(digit == -1))
1495		{
1496		BOOST_STATIC_CONSTEXPR source_location loc
1497		= BOOST_CURRENT_LOCATION;
1498	50x	return fail(cs.begin(), error::expected_hex_digit, &loc);
1499		}
1500	5661x	++cs;
1501	5661x	u1_ = digit << 12;
1502	6051x	do_str5:
1503	6051x	if(BOOST_JSON_UNLIKELY(! cs))
1504	390x	return maybe_suspend(cs.begin(), state::str5);
1505	5661x	digit = detail::hex_digit(*cs);
1506	5661x	if(BOOST_JSON_UNLIKELY(digit == -1))
1507		{
1508		BOOST_STATIC_CONSTEXPR source_location loc
1509		= BOOST_CURRENT_LOCATION;
1510	20x	return fail(cs.begin(), error::expected_hex_digit, &loc);
1511		}
1512	5641x	++cs;
1513	5641x	u1_ += digit << 8;
1514	6030x	do_str6:
1515	6030x	if(BOOST_JSON_UNLIKELY(! cs))
1516	389x	return maybe_suspend(cs.begin(), state::str6);
1517	5641x	digit = detail::hex_digit(*cs);
1518	5641x	if(BOOST_JSON_UNLIKELY(digit == -1))
1519		{
1520		BOOST_STATIC_CONSTEXPR source_location loc
1521		= BOOST_CURRENT_LOCATION;
1522	20x	return fail(cs.begin(), error::expected_hex_digit, &loc);
1523		}
1524	5621x	++cs;
1525	5621x	u1_ += digit << 4;
1526	6007x	do_str7:
1527	6007x	if(BOOST_JSON_UNLIKELY(! cs))
1528	386x	return maybe_suspend(cs.begin(), state::str7);
1529	5621x	digit = detail::hex_digit(*cs);
1530	5621x	if(BOOST_JSON_UNLIKELY(digit == -1))
1531		{
1532		BOOST_STATIC_CONSTEXPR source_location loc
1533		= BOOST_CURRENT_LOCATION;
1534	35x	return fail(cs.begin(), error::expected_hex_digit, &loc);
1535		}
1536	5586x	++cs;
1537	5586x	u1_ += digit;
1538	5586x	if(BOOST_JSON_LIKELY(
1539		u1_ < 0xd800 \|\| u1_ > 0xdfff))
1540		{
1541	1434x	BOOST_ASSERT(temp.empty());
1542		// utf-8 codepoint
1543	1434x	temp.append_utf8(u1_);
1544	1434x	break;
1545		}
1546	4152x	if(BOOST_JSON_UNLIKELY(u1_ > 0xdbff))
1547		{
1548		// If it's an illegal leading surrogate and
1549		// the parser does not allow it, return an error.
1550	1585x	if(!allow_bad_utf16)
1551		{
1552		BOOST_STATIC_CONSTEXPR source_location loc
1553		= BOOST_CURRENT_LOCATION;
1554	209x	return fail(cs.begin(), error::illegal_leading_surrogate, &loc);
1555		}
1556		// Otherwise, append the Unicode replacement character
1557		else
1558		{
1559	1376x	BOOST_ASSERT(temp.empty());
1560	1376x	temp.append_utf8(urc);
1561	1376x	break;
1562		}
1563		}
1564	2567x	do_sur1:
1565	3792x	if(BOOST_JSON_UNLIKELY(! cs))
1566	232x	return maybe_suspend(cs.begin(), state::sur1);
1567	3560x	if(BOOST_JSON_UNLIKELY(*cs != '\\'))
1568		{
1569		// If the next character is not a backslash and
1570		// the parser does not allow it, return a syntax error.
1571	952x	if(!allow_bad_utf16)
1572		{
1573		BOOST_STATIC_CONSTEXPR source_location loc
1574		= BOOST_CURRENT_LOCATION;
1575	149x	return fail(cs.begin(), error::syntax, &loc);
1576		}
1577		// Otherwise, append the Unicode replacement character since
1578		// the first code point is a valid leading surrogate
1579		else
1580		{
1581	803x	temp.append_utf8(urc);
1582	803x	break;
1583		}
1584		}
1585	2608x	++cs;
1586	2796x	do_sur2:
1587	2796x	if(BOOST_JSON_UNLIKELY(! cs))
1588	188x	return maybe_suspend(cs.begin(), state::sur2);
1589	2608x	if(BOOST_JSON_UNLIKELY(*cs != 'u'))
1590		{
1591	396x	if (!allow_bad_utf16)
1592		{
1593		BOOST_STATIC_CONSTEXPR source_location loc
1594		= BOOST_CURRENT_LOCATION;
1595	65x	return fail(cs.begin(), error::syntax, &loc);
1596		}
1597		// Otherwise, append the Unicode replacement character since
1598		// the first code point is a valid leading surrogate
1599		else
1600		{
1601	331x	temp.append_utf8(urc);
1602	331x	goto do_str3;
1603		}
1604		}
1605	2212x	++cs;
1606	2376x	do_sur3:
1607	2376x	if(BOOST_JSON_UNLIKELY(! cs))
1608	164x	return maybe_suspend(cs.begin(), state::sur3);
1609	2212x	digit = detail::hex_digit(*cs);
1610	2212x	if(BOOST_JSON_UNLIKELY(digit == -1))
1611		{
1612		BOOST_STATIC_CONSTEXPR source_location loc
1613		= BOOST_CURRENT_LOCATION;
1614	35x	return fail(cs.begin(), error::expected_hex_digit, &loc);
1615		}
1616	2177x	++cs;
1617	2177x	u2_ = digit << 12;
1618	2339x	do_sur4:
1619	2339x	if(BOOST_JSON_UNLIKELY(! cs))
1620	162x	return maybe_suspend(cs.begin(), state::sur4);
1621	2177x	digit = detail::hex_digit(*cs);
1622	2177x	if(BOOST_JSON_UNLIKELY(digit == -1))
1623		{
1624		BOOST_STATIC_CONSTEXPR source_location loc
1625		= BOOST_CURRENT_LOCATION;
1626	35x	return fail(cs.begin(), error::expected_hex_digit, &loc);
1627		}
1628	2142x	++cs;
1629	2142x	u2_ += digit << 8;
1630	2302x	do_sur5:
1631	2302x	if(BOOST_JSON_UNLIKELY(! cs))
1632	160x	return maybe_suspend(cs.begin(), state::sur5);
1633	2142x	digit = detail::hex_digit(*cs);
1634	2142x	if(BOOST_JSON_UNLIKELY(digit == -1))
1635		{
1636		BOOST_STATIC_CONSTEXPR source_location loc
1637		= BOOST_CURRENT_LOCATION;
1638	20x	return fail(cs.begin(), error::expected_hex_digit, &loc);
1639		}
1640	2122x	++cs;
1641	2122x	u2_ += digit << 4;
1642	2280x	do_sur6:
1643	2280x	if(BOOST_JSON_UNLIKELY(! cs))
1644	158x	return maybe_suspend(cs.begin(), state::sur6);
1645	2122x	digit = detail::hex_digit(*cs);
1646	2122x	if(BOOST_JSON_UNLIKELY(digit == -1))
1647		{
1648		BOOST_STATIC_CONSTEXPR source_location loc
1649		= BOOST_CURRENT_LOCATION;
1650	20x	return fail(cs.begin(), error::expected_hex_digit, &loc);
1651		}
1652	2102x	++cs;
1653	2102x	u2_ += digit;
1654		// Check if the second code point is a valid trailing surrogate.
1655		// Valid trailing surrogates are [DC00, DFFF]
1656	2102x	if(BOOST_JSON_UNLIKELY(
1657		u2_ < 0xdc00 \|\| u2_ > 0xdfff))
1658		{
1659		// If not valid and the parser does not allow it, return an error.
1660	580x	if(!allow_bad_utf16)
1661		{
1662		BOOST_STATIC_CONSTEXPR source_location loc
1663		= BOOST_CURRENT_LOCATION;
1664	60x	return fail(cs.begin(), error::illegal_trailing_surrogate, &loc);
1665		}
1666		// Append the replacement character for the
1667		// first leading surrogate.
1668	520x	temp.append_utf8(urc);
1669		// Check if the second code point is a
1670		// valid unicode scalar value (invalid leading
1671		// or trailing surrogate)
1672	520x	if (u2_ < 0xd800 \|\| u2_ > 0xdbff)
1673		{
1674	220x	temp.append_utf8(u2_);
1675	220x	break;
1676		}
1677		// If it is a valid leading surrogate
1678		else
1679		{
1680	300x	u1_ = u2_;
1681	300x	goto do_sur1;
1682		}
1683		}
1684		// Calculate the Unicode code point from the surrogate pair and
1685		// append the UTF-8 representation.
1686	1522x	unsigned cp =
1687	1522x	((u1_ - 0xd800) << 10) +
1688	1522x	((u2_ - 0xdc00)) +
1689		0x10000;
1690		// utf-16 surrogate pair
1691	1522x	temp.append_utf8(cp);
1692		}
1693
1694		// flush
1695	12653x	if(BOOST_JSON_UNLIKELY( !cs ) \|\| *cs != '\\')
1696	8870x	break;
1697		}
1698
1699	8870x	if(BOOST_JSON_LIKELY( temp.size() ))
1700		{
1701	434x	BOOST_ASSERT(total <= max_size);
1702	8870x	if(BOOST_JSON_UNLIKELY( temp.size() > max_size - total ))
1703		{
1704		BOOST_STATIC_CONSTEXPR source_location loc
1705		= BOOST_CURRENT_LOCATION;
1706	1x	return fail(cs.begin(), ev_too_large, &loc);
1707		}
1708
1709	8869x	total += temp.size();
1710	8056x	bool const r = is_key
1711	8869x	? h_.on_key_part(temp.get(), total, ec_)
1712	8152x	: h_.on_string_part(temp.get(), total, ec_);
1713	8056x	if(BOOST_JSON_UNLIKELY( !r ))
1714	813x	return fail( cs.begin() );
1715		}
1716
1717	7243x	return cs.begin();
1718		}
1719
1720		//----------------------------------------------------------
1721
1722		template<class Handler>
1723		template<
1724		bool StackEmpty_,
1725		bool AllowComments_/*,
1726		bool AllowTrailing_,
1727		bool AllowBadUTF8_*/>
1728		const char*
1729	109189x	basic_parser<Handler>::
1730		parse_object(const char* p,
1731		std::integral_constant<bool, StackEmpty_> stack_empty,
1732		std::integral_constant<bool, AllowComments_> allow_comments,
1733		/std::integral_constant<bool, AllowTrailing_>/ bool allow_trailing,
1734		/std::integral_constant<bool, AllowBadUTF8_>/ bool allow_bad_utf8,
1735		bool allow_bad_utf16)
1736		{
1737	109189x	detail::const_stream_wrapper cs(p, end_);
1738		std::size_t size;
1739	109189x	if(! stack_empty && ! st_.empty())
1740		{
1741		// resume
1742		state st;
1743	35058x	st_.pop(st);
1744	35058x	st_.pop(size);
1745	35058x	switch(st)
1746		{
1747	−	default: BOOST_JSON_UNREACHABLE(); // LCOV_EXCL_LINE
1748	1595x	case state::obj1: goto do_obj1;
1749	235x	case state::obj2: goto do_obj2;
1750	12647x	case state::obj3: goto do_obj3;
1751	1690x	case state::obj4: goto do_obj4;
1752	251x	case state::obj5: goto do_obj5;
1753	1591x	case state::obj6: goto do_obj6;
1754	15448x	case state::obj7: goto do_obj7;
1755	426x	case state::obj8: goto do_obj8;
1756	660x	case state::obj9: goto do_obj9;
1757	181x	case state::obj10: goto do_obj10;
1758	334x	case state::obj11: goto do_obj11;
1759		}
1760		}
1761	74131x	BOOST_ASSERT(*cs == '{');
1762	74131x	size = 0;
1763	74131x	if(BOOST_JSON_UNLIKELY(! depth_))
1764		{
1765		BOOST_STATIC_CONSTEXPR source_location loc = BOOST_CURRENT_LOCATION;
1766	3x	return fail(cs.begin(), error::too_deep, &loc);
1767		}
1768	74128x	--depth_;
1769	74128x	if(BOOST_JSON_UNLIKELY(
1770		! h_.on_object_begin(ec_)))
1771	2040x	return fail(cs.begin());
1772	70050x	++cs;
1773		// object:
1774		// '{' *ws '}'
1775		// '{' ws string ws ':' ws value ws [ ',' ws string ws ':' ws value *ws ] '}'
1776	73616x	do_obj1:
1777	73616x	cs = detail::count_whitespace(cs.begin(), cs.end());
1778	73616x	if(BOOST_JSON_UNLIKELY(! cs))
1779	1629x	return maybe_suspend(cs.begin(), state::obj1, size);
1780	71987x	if(BOOST_JSON_LIKELY(*cs != '}'))
1781		{
1782	69088x	if(BOOST_JSON_UNLIKELY(*cs != '\x22'))
1783		{
1784	2411x	if(allow_comments && *cs == '/')
1785		{
1786	2139x	do_obj2:
1787	2374x	cs = parse_comment(cs.begin(), stack_empty, std::false_type());
1788	2290x	if(BOOST_JSON_UNLIKELY(incomplete(cs)))
1789	319x	return suspend_or_fail(state::obj2, size);
1790	1971x	goto do_obj1;
1791		}
1792		BOOST_STATIC_CONSTEXPR source_location loc
1793		= BOOST_CURRENT_LOCATION;
1794	272x	return fail(cs.begin(), error::syntax, &loc);
1795		}
1796	66677x	loop:
1797	80829x	if(BOOST_JSON_UNLIKELY(++size >
1798		Handler::max_object_size))
1799		{
1800		BOOST_STATIC_CONSTEXPR source_location loc
1801		= BOOST_CURRENT_LOCATION;
1802	1x	return fail(cs.begin(), error::object_too_large, &loc);
1803		}
1804	80828x	do_obj3:
1805	93475x	cs = parse_string(cs.begin(), stack_empty, std::true_type(), allow_bad_utf8, allow_bad_utf16);
1806	90519x	if(BOOST_JSON_UNLIKELY(incomplete(cs)))
1807	15592x	return suspend_or_fail(state::obj3, size);
1808	74927x	do_obj4:
1809	79088x	cs = detail::count_whitespace(cs.begin(), cs.end());
1810	79088x	if(BOOST_JSON_UNLIKELY(! cs))
1811	1705x	return maybe_suspend(cs.begin(), state::obj4, size);
1812	77383x	if(BOOST_JSON_UNLIKELY(*cs != ':'))
1813		{
1814	2925x	if(allow_comments && *cs == '/')
1815		{
1816	2779x	do_obj5:
1817	3030x	cs = parse_comment(cs.begin(), stack_empty, std::false_type());
1818	2876x	if(BOOST_JSON_UNLIKELY(incomplete(cs)))
1819	405x	return suspend_or_fail(state::obj5, size);
1820	2471x	goto do_obj4;
1821		}
1822		BOOST_STATIC_CONSTEXPR source_location loc
1823		= BOOST_CURRENT_LOCATION;
1824	146x	return fail(cs.begin(), error::syntax, &loc);
1825		}
1826	74458x	++cs;
1827	76049x	do_obj6:
1828	76049x	cs = detail::count_whitespace(cs.begin(), cs.end());
1829	76049x	if(BOOST_JSON_UNLIKELY(! cs))
1830	1622x	return maybe_suspend(cs.begin(), state::obj6, size);
1831	74427x	do_obj7:
1832	89875x	cs = parse_value(cs.begin(), stack_empty, allow_comments, allow_trailing, allow_bad_utf8, allow_bad_utf16);
1833	82526x	if(BOOST_JSON_UNLIKELY(incomplete(cs)))
1834	23593x	return suspend_or_fail(state::obj7, size);
1835	58933x	do_obj8:
1836	61195x	cs = detail::count_whitespace(cs.begin(), cs.end());
1837	61195x	if(BOOST_JSON_UNLIKELY(! cs))
1838	441x	return maybe_suspend(cs.begin(), state::obj8, size);
1839	60754x	if(BOOST_JSON_LIKELY(*cs == ','))
1840		{
1841	17792x	++cs;
1842	19707x	do_obj9:
1843	19707x	cs = detail::count_whitespace(cs.begin(), cs.end());
1844	19707x	if(BOOST_JSON_UNLIKELY(! cs))
1845	690x	return maybe_suspend(cs.begin(), state::obj9, size);
1846
1847		// loop for next element
1848	19017x	if(BOOST_JSON_LIKELY(*cs == '\x22'))
1849	14152x	goto loop;
1850	4865x	if(! allow_trailing \|\| *cs != '}')
1851		{
1852	1644x	if(allow_comments && *cs == '/')
1853		{
1854	1433x	do_obj10:
1855	1614x	cs = parse_comment(cs.begin(), stack_empty, std::false_type());
1856	1525x	if(BOOST_JSON_UNLIKELY(incomplete(cs)))
1857	270x	return suspend_or_fail(state::obj10, size);
1858	1255x	goto do_obj9;
1859		}
1860		BOOST_STATIC_CONSTEXPR source_location loc
1861		= BOOST_CURRENT_LOCATION;
1862	211x	return fail(cs.begin(), error::syntax, &loc);
1863		}
1864		}
1865	42962x	else if(BOOST_JSON_UNLIKELY(*cs != '}'))
1866		{
1867	2325x	if(allow_comments && *cs == '/')
1868		{
1869	2172x	do_obj11:
1870	2506x	cs = parse_comment(cs.begin(), stack_empty, std::false_type());
1871	2338x	if(BOOST_JSON_UNLIKELY(incomplete(cs)))
1872	502x	return suspend_or_fail(state::obj11, size);
1873	1836x	goto do_obj8;
1874		}
1875		BOOST_STATIC_CONSTEXPR source_location loc
1876		= BOOST_CURRENT_LOCATION;
1877	153x	return fail(cs.begin(), error::syntax, &loc);
1878		}
1879		// got closing brace, fall through
1880		}
1881	46757x	if(BOOST_JSON_UNLIKELY(
1882		! h_.on_object_end(size, ec_)))
1883	1502x	return fail(cs.begin());
1884	43714x	++depth_;
1885	43714x	++cs;
1886	43714x	return cs.begin();
1887		}
1888
1889		//----------------------------------------------------------
1890
1891		template<class Handler>
1892		template<
1893		bool StackEmpty_,
1894		bool AllowComments_/*,
1895		bool AllowTrailing_,
1896		bool AllowBadUTF8_*/>
1897		const char*
1898	26348x	basic_parser<Handler>::
1899		parse_array(const char* p,
1900		std::integral_constant<bool, StackEmpty_> stack_empty,
1901		std::integral_constant<bool, AllowComments_> allow_comments,
1902		/std::integral_constant<bool, AllowTrailing_>/ bool allow_trailing,
1903		/std::integral_constant<bool, AllowBadUTF8_>/ bool allow_bad_utf8,
1904		bool allow_bad_utf16)
1905		{
1906	26348x	detail::const_stream_wrapper cs(p, end_);
1907		std::size_t size;
1908	26348x	if(! stack_empty && ! st_.empty())
1909		{
1910		// resume
1911		state st;
1912	5730x	st_.pop(st);
1913	5730x	st_.pop(size);
1914	5730x	switch(st)
1915		{
1916	−	default: BOOST_JSON_UNREACHABLE(); // LCOV_EXCL_LINE
1917	1052x	case state::arr1: goto do_arr1;
1918	384x	case state::arr2: goto do_arr2;
1919	2938x	case state::arr3: goto do_arr3;
1920	391x	case state::arr4: goto do_arr4;
1921	671x	case state::arr5: goto do_arr5;
1922	294x	case state::arr6: goto do_arr6;
1923		}
1924		}
1925	20618x	BOOST_ASSERT(*cs == '[');
1926	20618x	size = 0;
1927	20618x	if(BOOST_JSON_UNLIKELY(! depth_))
1928		{
1929		BOOST_STATIC_CONSTEXPR source_location loc = BOOST_CURRENT_LOCATION;
1930	34x	return fail(cs.begin(), error::too_deep, &loc);
1931		}
1932	20584x	--depth_;
1933	20584x	if(BOOST_JSON_UNLIKELY(
1934		! h_.on_array_begin(ec_)))
1935	812x	return fail(cs.begin());
1936	18966x	++cs;
1937		// array:
1938		// '[' *ws ']'
1939		// '[' ws value ws [ ',' ws value *ws ] ']'
1940	21551x	do_arr1:
1941	21551x	cs = detail::count_whitespace(cs.begin(), cs.end());
1942	21551x	if(BOOST_JSON_UNLIKELY(! cs))
1943	1073x	return maybe_suspend(cs.begin(), state::arr1, size);
1944	20478x	if(BOOST_JSON_LIKELY(*cs != ']'))
1945		{
1946	18730x	loop:
1947	26193x	if(allow_comments && *cs == '/')
1948		{
1949	1789x	do_arr2:
1950	2173x	cs = parse_comment(cs.begin(), stack_empty, std::false_type());
1951	2045x	if(BOOST_JSON_UNLIKELY(incomplete(cs)))
1952	512x	return suspend_or_fail(state::arr2, size);
1953	1533x	goto do_arr1;
1954		}
1955	24404x	if(BOOST_JSON_UNLIKELY(++size >
1956		Handler::max_array_size))
1957		{
1958		BOOST_STATIC_CONSTEXPR source_location loc
1959		= BOOST_CURRENT_LOCATION;
1960	1x	return fail(cs.begin(), error::array_too_large, &loc);
1961		}
1962	24403x	do_arr3:
1963		// array is not empty, value required
1964	27341x	cs = parse_value(cs.begin(), stack_empty, allow_comments, allow_trailing, allow_bad_utf8, allow_bad_utf16);
1965	24710x	if(BOOST_JSON_UNLIKELY(incomplete(cs)))
1966	9052x	return suspend_or_fail(state::arr3, size);
1967	15658x	do_arr4:
1968	17279x	cs = detail::count_whitespace(cs.begin(), cs.end());
1969	17279x	if(BOOST_JSON_UNLIKELY(! cs))
1970	500x	return maybe_suspend(cs.begin(), state::arr4, size);
1971	16779x	if(BOOST_JSON_LIKELY(*cs == ','))
1972		{
1973	9176x	++cs;
1974	9847x	do_arr5:
1975	9847x	cs = detail::count_whitespace(cs.begin(), cs.end());
1976	9847x	if(BOOST_JSON_UNLIKELY(! cs))
1977	701x	return maybe_suspend(cs.begin(), state::arr5, size);
1978		// loop for next element
1979	9146x	if(! allow_trailing \|\| *cs != ']')
1980	7463x	goto loop;
1981		}
1982	7603x	else if(BOOST_JSON_UNLIKELY(*cs != ']'))
1983		{
1984	1969x	if(allow_comments && *cs == '/')
1985		{
1986	1541x	do_arr6:
1987	1835x	cs = parse_comment(cs.begin(), stack_empty, std::false_type());
1988	1688x	if(BOOST_JSON_UNLIKELY(incomplete(cs)))
1989	458x	return suspend_or_fail(state::arr6, size);
1990	1230x	goto do_arr4;
1991		}
1992		BOOST_STATIC_CONSTEXPR source_location loc
1993		= BOOST_CURRENT_LOCATION;
1994	428x	return fail(cs.begin(), error::syntax, &loc);
1995		}
1996		// got closing bracket; fall through
1997		}
1998	9065x	if(BOOST_JSON_UNLIKELY(
1999		! h_.on_array_end(size, ec_)))
2000	547x	return fail(cs.begin());
2001	7939x	++depth_;
2002	7939x	++cs;
2003	7939x	return cs.begin();
2004		}
2005
2006		//----------------------------------------------------------
2007
2008		template<class Handler>
2009		template<bool StackEmpty_, char First_, number_precision Numbers_>
2010		const char*
2011	10515990x	basic_parser<Handler>::
2012		parse_number(const char* p,
2013		std::integral_constant<bool, StackEmpty_> stack_empty,
2014		std::integral_constant<char, First_> first,
2015		std::integral_constant<number_precision, Numbers_> mode)
2016		{
2017	10515990x	constexpr bool precise_parsing = mode == number_precision::precise;
2018	10515990x	constexpr bool no_parsing = mode == number_precision::none;
2019
2020		// only one of these will be true if we are not resuming
2021		// if negative then !zero_first && !nonzero_first
2022		// if zero_first then !nonzero_first && !negative
2023		// if nonzero_first then !zero_first && !negative
2024	10515990x	bool const negative = first == '-';
2025	10515990x	bool const zero_first = first == '0';
2026	10515990x	bool const nonzero_first = first == '+';
2027	10515990x	detail::const_stream_wrapper cs(p, end_);
2028		number num;
2029	10515990x	const char* begin = cs.begin();
2030	10515990x	if(stack_empty \|\| st_.empty())
2031		{
2032	2089971x	num.bias = 0;
2033	2089971x	num.exp = 0;
2034	2089971x	num.frac = false;
2035	2089971x	num_buf_.clear();
2036
2037		//----------------------------------
2038		//
2039		// '-'
2040		// leading minus sign
2041		//
2042	2089971x	BOOST_ASSERT(cs);
2043		if(negative)
2044	25185x	++cs;
2045
2046	2089971x	num.neg = negative;
2047	2089971x	num.frac = false;
2048	2089971x	num.exp = 0;
2049	2089971x	num.bias = 0;
2050
2051		// fast path
2052	2089971x	if( cs.remain() >= 16 + 1 + 16 ) // digits . digits
2053		{
2054		int n1;
2055
2056	9989x	if( nonzero_first \|\|
2057	9989x	(negative && *cs != '0') )
2058		{
2059	2007319x	n1 = detail::count_digits( cs.begin() );
2060	2007319x	BOOST_ASSERT(n1 >= 0 && n1 <= 16);
2061
2062	1837x	if( negative && n1 == 0 && opt_.allow_infinity_and_nan )
2063		{
2064	9x	return parse_literal(
2065		p - 1,
2066	8x	detail::literals_c<detail::literals::neg_infinity>());
2067		}
2068
2069	1828x	if( ! nonzero_first && n1 == 0 )
2070		{
2071		// digit required
2072		BOOST_STATIC_CONSTEXPR source_location loc
2073		= BOOST_CURRENT_LOCATION;
2074	2x	return fail(cs.begin(), error::syntax, &loc);
2075		}
2076
2077		BOOST_IF_CONSTEXPR( !no_parsing )
2078	2006460x	num.mant = detail::parse_unsigned( 0, cs.begin(), n1 );
2079		else
2080	848x	num.mant = 0;
2081
2082	2007308x	cs += n1;
2083
2084		// integer or floating-point with
2085		// >= 16 leading digits
2086	2007308x	if( n1 == 16 )
2087		{
2088	2001425x	goto do_num2;
2089		}
2090		}
2091		else
2092		{
2093		// 0. floating-point or 0e integer
2094	21187x	num.mant = 0;
2095	21187x	n1 = 0;
2096	21187x	++cs;
2097		}
2098
2099		{
2100	27070x	const char c = *cs;
2101	27070x	if(c != '.')
2102		{
2103	9871x	if((c \| 32) == 'e')
2104		{
2105	6576x	++cs;
2106	6576x	goto do_exp1;
2107		}
2108		BOOST_IF_CONSTEXPR( negative && !no_parsing )
2109	20x	num.mant = ~num.mant + 1;
2110	3295x	goto finish_signed;
2111		}
2112		}
2113
2114		// floating-point number
2115
2116	17199x	++cs;
2117
2118	17199x	int n2 = detail::count_digits( cs.begin() );
2119	17199x	BOOST_ASSERT(n2 >= 0 && n2 <= 16);
2120
2121	17199x	if( n2 == 0 )
2122		{
2123		// digit required
2124		BOOST_STATIC_CONSTEXPR source_location loc
2125		= BOOST_CURRENT_LOCATION;
2126	3x	return fail(cs.begin(), error::syntax, &loc);
2127		}
2128
2129		// floating-point mantissa overflow
2130	17196x	if( n1 + n2 >= 19 )
2131		{
2132	122x	goto do_num7;
2133		}
2134
2135		BOOST_IF_CONSTEXPR( !no_parsing )
2136	12855x	num.mant = detail::parse_unsigned( num.mant, cs.begin(), n2 );
2137
2138	17074x	BOOST_ASSERT(num.bias == 0);
2139
2140	17074x	num.bias -= n2;
2141
2142	17074x	cs += n2;
2143
2144	17074x	char ch = *cs;
2145
2146	17074x	if( (ch \| 32) == 'e' )
2147		{
2148	110x	++cs;
2149	110x	goto do_exp1;
2150		}
2151	16964x	else if( ch >= '0' && ch <= '9' )
2152		{
2153	10017x	goto do_num8;
2154		}
2155
2156	6947x	goto finish_dub;
2157		}
2158		}
2159		else
2160		{
2161	8426019x	num = num_;
2162		state st;
2163	8426019x	st_.pop(st);
2164	8426019x	switch(st)
2165		{
2166	−	default: BOOST_JSON_UNREACHABLE(); // LCOV_EXCL_LINE
2167	603x	case state::num1: goto do_num1;
2168	6460x	case state::num2: goto do_num2;
2169	4195112x	case state::num3: goto do_num3;
2170	52x	case state::num4: goto do_num4;
2171	4537x	case state::num5: goto do_num5;
2172	668x	case state::num6: goto do_num6;
2173	618x	case state::num7: goto do_num7;
2174	4205248x	case state::num8: goto do_num8;
2175	477x	case state::exp1: goto do_exp1;
2176	139x	case state::exp2: goto do_exp2;
2177	12105x	case state::exp3: goto do_exp3;
2178		}
2179		}
2180
2181		//----------------------------------
2182		//
2183		// DIGIT
2184		// first digit
2185		//
2186	62068x	do_num1:
2187	15799x	if(zero_first \|\| nonzero_first \|\|
2188	15799x	BOOST_JSON_LIKELY(cs))
2189		{
2190	61345x	char const c = *cs;
2191		if(zero_first)
2192		{
2193	9726x	++cs;
2194	9726x	num.mant = 0;
2195	9726x	goto do_num6;
2196		}
2197	15076x	else if(nonzero_first \|\| BOOST_JSON_LIKELY(
2198		c >= '1' && c <= '9'))
2199		{
2200	42790x	++cs;
2201	42790x	num.mant = c - '0';
2202		}
2203	8829x	else if(BOOST_JSON_UNLIKELY(
2204		c == '0'))
2205		{
2206	7634x	++cs;
2207	7634x	num.mant = 0;
2208	7634x	goto do_num6;
2209		}
2210	1195x	else if( (negative \|\| num.neg) && opt_.allow_infinity_and_nan )
2211		{
2212	1007x	st_.push(state::lit1);
2213	1007x	cur_lit_ = literal_index(detail::literals::neg_infinity);
2214	1007x	lit_offset_ = 1;
2215	1007x	return parse_literal(
2216	961x	cs.begin(), detail::literals_c<detail::literals::resume>() );
2217		}
2218		else
2219		{
2220		BOOST_STATIC_CONSTEXPR source_location loc
2221		= BOOST_CURRENT_LOCATION;
2222	188x	return fail(cs.begin(), error::syntax, &loc);
2223		}
2224		}
2225		else
2226		{
2227	723x	if(BOOST_JSON_UNLIKELY(
2228		! h_.on_number_part(
2229		{begin, cs.used(begin)}, ec_)))
2230	60x	return fail(cs.begin());
2231
2232		BOOST_IF_CONSTEXPR( precise_parsing )
2233	✗	num_buf_.append( begin, cs.used(begin) );
2234	603x	return maybe_suspend(
2235	603x	cs.begin(), state::num1, num);
2236		}
2237
2238		//----------------------------------
2239		//
2240		// 1*DIGIT
2241		// significant digits left of decimal
2242		//
2243	2050675x	do_num2:
2244	2044417x	if(negative \|\| (!stack_empty && num.neg))
2245		{
2246	22400x	for(;;)
2247		{
2248	30225x	if(BOOST_JSON_UNLIKELY(! cs))
2249		{
2250	1921x	if(BOOST_JSON_UNLIKELY(more_))
2251		{
2252	1469x	if(BOOST_JSON_UNLIKELY(
2253		! h_.on_number_part(
2254		{begin, cs.used(begin)}, ec_)))
2255	69x	return fail(cs.begin());
2256
2257		BOOST_IF_CONSTEXPR( precise_parsing )
2258	✗	num_buf_.append( begin, cs.used(begin) );
2259	1331x	return suspend(cs.begin(), state::num2, num);
2260		}
2261	452x	goto finish_int;
2262		}
2263	28304x	char const c = *cs;
2264	28304x	if(BOOST_JSON_LIKELY(
2265		c >= '0' && c <= '9'))
2266		{
2267	23223x	++cs;
2268		// 9223372036854775808 INT64_MIN
2269	23223x	if( num.mant > 922337203685477580 \|\| (
2270	22508x	num.mant == 922337203685477580 && c > '8'))
2271		break;
2272		BOOST_IF_CONSTEXPR( !no_parsing )
2273	22141x	num.mant = 10 * num.mant + ( c - '0' );
2274	22400x	continue;
2275		}
2276	5081x	goto do_num6; // [.eE]
2277		}
2278		}
2279		else
2280		{
2281	6889563x	for(;;)
2282		{
2283	8932413x	if(BOOST_JSON_UNLIKELY(! cs))
2284		{
2285	6588x	if(BOOST_JSON_UNLIKELY(more_))
2286		{
2287	5975x	if(BOOST_JSON_UNLIKELY(
2288		! h_.on_number_part(
2289		{begin, cs.used(begin)}, ec_)))
2290	426x	return fail(cs.begin());
2291
2292		BOOST_IF_CONSTEXPR( precise_parsing )
2293	✗	num_buf_.append( begin, cs.used(begin) );
2294	5129x	return suspend(cs.begin(), state::num2, num);
2295		}
2296	613x	goto finish_int;
2297		}
2298	8925825x	char const c = *cs;
2299	8925825x	if(BOOST_JSON_LIKELY(
2300		c >= '0' && c <= '9'))
2301		{
2302	6893607x	++cs;
2303		// 18446744073709551615 UINT64_MAX
2304	6893607x	if( num.mant > 1844674407370955161 \|\| (
2305	6889985x	num.mant == 1844674407370955161 && c > '5'))
2306		break;
2307		BOOST_IF_CONSTEXPR( !no_parsing )
2308	6883965x	num.mant = 10 * num.mant + ( c - '0' );
2309		}
2310		else
2311		{
2312	2032218x	goto do_num6; // [.eE]
2313		}
2314		}
2315		}
2316	4867x	++num.bias;
2317
2318		//----------------------------------
2319		//
2320		// 1*DIGIT
2321		// non-significant digits left of decimal
2322		//
2323	4199979x	do_num3:
2324	9894x	for(;;)
2325		{
2326	13992x	if(BOOST_JSON_UNLIKELY(! cs))
2327		{
2328	4195839x	if(BOOST_JSON_UNLIKELY(more_))
2329		{
2330	4195206x	if(BOOST_JSON_UNLIKELY(
2331		! h_.on_number_part(
2332		{begin, cs.used(begin)}, ec_)))
2333	47x	return fail(cs.begin());
2334
2335		BOOST_IF_CONSTEXPR( precise_parsing )
2336	✗	num_buf_.append( begin, cs.used(begin) );
2337	4195112x	return suspend(cs.begin(), state::num3, num);
2338		}
2339	633x	goto finish_dub;
2340		}
2341	13261x	char const c = *cs;
2342	13261x	if(BOOST_JSON_UNLIKELY(
2343		c >= '0' && c <= '9'))
2344		{
2345	9894x	if(BOOST_JSON_UNLIKELY( num.bias + 1 == INT_MAX ))
2346		{
2347		BOOST_STATIC_CONSTEXPR source_location loc
2348		= BOOST_CURRENT_LOCATION;
2349	1x	return fail(cs.begin(), error::exponent_overflow, &loc);
2350		}
2351	9894x	++cs;
2352	9894x	++num.bias;
2353		}
2354	4139x	else if(BOOST_JSON_LIKELY(
2355		c == '.'))
2356		{
2357	2028x	++cs;
2358	2028x	break;
2359		}
2360	2111x	else if((c \| 32) == 'e')
2361		{
2362	762x	++cs;
2363	762x	goto do_exp1;
2364		}
2365		else
2366		{
2367	1349x	goto finish_dub;
2368		}
2369		}
2370
2371		//----------------------------------
2372		//
2373		// DIGIT
2374		// first non-significant digit
2375		// to the right of decimal
2376		//
2377	2080x	do_num4:
2378		{
2379	2080x	if(BOOST_JSON_UNLIKELY(! cs))
2380		{
2381	64x	if(BOOST_JSON_UNLIKELY(
2382		! h_.on_number_part(
2383		{begin, cs.used(begin)}, ec_)))
2384	6x	return fail(cs.begin());
2385
2386		BOOST_IF_CONSTEXPR( precise_parsing )
2387	✗	num_buf_.append( begin, cs.used(begin) );
2388	52x	return maybe_suspend(
2389	52x	cs.begin(), state::num4, num);
2390		}
2391	2016x	char const c = *cs;
2392	2016x	if(BOOST_JSON_LIKELY(
2393		//static_cast<unsigned char>(c - '0') < 10))
2394		c >= '0' && c <= '9'))
2395		{
2396	1949x	++cs;
2397		}
2398		else
2399		{
2400		// digit required
2401		BOOST_STATIC_CONSTEXPR source_location loc
2402		= BOOST_CURRENT_LOCATION;
2403	67x	return fail(cs.begin(), error::syntax, &loc);
2404		}
2405		}
2406
2407		//----------------------------------
2408		//
2409		// 1*DIGIT
2410		// non-significant digits
2411		// to the right of decimal
2412		//
2413	2013470x	do_num5:
2414	37889832x	for(;;)
2415		{
2416	39903302x	if(BOOST_JSON_UNLIKELY(! cs))
2417		{
2418	6112x	if(BOOST_JSON_UNLIKELY(more_))
2419		{
2420	4577x	if(BOOST_JSON_UNLIKELY(
2421		! h_.on_number_part(
2422		{begin, cs.used(begin)}, ec_)))
2423	20x	return fail(cs.begin());
2424
2425		BOOST_IF_CONSTEXPR( precise_parsing )
2426	✗	num_buf_.append( begin, cs.used(begin) );
2427	4537x	return suspend(cs.begin(), state::num5, num);
2428		}
2429	1535x	goto finish_dub;
2430		}
2431	39897190x	char const c = *cs;
2432	39897190x	if(BOOST_JSON_LIKELY(
2433		c >= '0' && c <= '9'))
2434		{
2435	37889832x	++cs;
2436		}
2437	2007358x	else if((c \| 32) == 'e')
2438		{
2439	2003236x	++cs;
2440	2003236x	goto do_exp1;
2441		}
2442		else
2443		{
2444	4122x	goto finish_dub;
2445		}
2446		}
2447
2448		//----------------------------------
2449		//
2450		// [.eE]
2451		//
2452	2055327x	do_num6:
2453		{
2454	2055327x	if(BOOST_JSON_UNLIKELY(! cs))
2455		{
2456	800x	if(BOOST_JSON_UNLIKELY(more_))
2457		{
2458	753x	if(BOOST_JSON_UNLIKELY(
2459		! h_.on_number_part(
2460		{begin, cs.used(begin)}, ec_)))
2461	42x	return fail(cs.begin());
2462
2463		BOOST_IF_CONSTEXPR( precise_parsing )
2464	2x	num_buf_.append( begin, cs.used(begin) );
2465	669x	return suspend(cs.begin(), state::num6, num);
2466		}
2467	47x	goto finish_int;
2468		}
2469	2054527x	char const c = *cs;
2470	2054527x	if(BOOST_JSON_LIKELY(
2471		c == '.'))
2472		{
2473	2016099x	++cs;
2474		}
2475	38428x	else if((c \| 32) == 'e')
2476		{
2477	9153x	++cs;
2478	9153x	goto do_exp1;
2479		}
2480		else
2481		{
2482	29275x	goto finish_int;
2483		}
2484		}
2485
2486		//----------------------------------
2487		//
2488		// DIGIT
2489		// first significant digit
2490		// to the right of decimal
2491		//
2492	2016839x	do_num7:
2493		{
2494	2016839x	if(BOOST_JSON_UNLIKELY(! cs))
2495		{
2496	693x	if(BOOST_JSON_UNLIKELY(more_))
2497		{
2498	689x	if(BOOST_JSON_UNLIKELY(
2499		! h_.on_number_part(
2500		{begin, cs.used(begin)}, ec_)))
2501	35x	return fail(cs.begin());
2502
2503		BOOST_IF_CONSTEXPR( precise_parsing )
2504	✗	num_buf_.append( begin, cs.used(begin) );
2505	619x	return suspend(cs.begin(), state::num7, num);
2506		}
2507		// digit required
2508		BOOST_STATIC_CONSTEXPR source_location loc
2509		= BOOST_CURRENT_LOCATION;
2510	4x	return fail(cs.begin(), error::syntax, &loc);
2511		}
2512	2016146x	char const c = *cs;
2513	2016146x	if(BOOST_JSON_UNLIKELY(
2514		c < '0' \|\| c > '9'))
2515		{
2516		// digit required
2517		BOOST_STATIC_CONSTEXPR source_location loc
2518		= BOOST_CURRENT_LOCATION;
2519	169x	return fail(cs.begin(), error::syntax, &loc);
2520		}
2521		}
2522
2523		//----------------------------------
2524		//
2525		// 1*DIGIT
2526		// significant digits
2527		// to the right of decimal
2528		//
2529	6228742x	do_num8:
2530	1724577x	for(;;)
2531		{
2532	3750147x	if(BOOST_JSON_UNLIKELY(! cs))
2533		{
2534	4207120x	if(BOOST_JSON_UNLIKELY(more_))
2535		{
2536	4205384x	if(BOOST_JSON_UNLIKELY(
2537		! h_.on_number_part(
2538		{begin, cs.used(begin)}, ec_)))
2539	67x	return fail(cs.begin());
2540
2541		BOOST_IF_CONSTEXPR( precise_parsing )
2542	2x	num_buf_.append( begin, cs.used(begin) );
2543	4205249x	return suspend(cs.begin(), state::num8, num);
2544		}
2545	1736x	goto finish_dub;
2546		}
2547	3740249x	char const c = *cs;
2548	3740249x	if(BOOST_JSON_LIKELY(
2549		c >= '0' && c <= '9'))
2550		{
2551	3731099x	++cs;
2552	3726006x	if(!no_parsing && BOOST_JSON_LIKELY(
2553		num.mant <= 9007199254740991)) // 2^53-1
2554		{
2555	1724577x	if(BOOST_JSON_UNLIKELY( num.bias - 1 == INT_MIN ))
2556		{
2557		BOOST_STATIC_CONSTEXPR source_location loc
2558		= BOOST_CURRENT_LOCATION;
2559	1x	return fail(cs.begin(), error::exponent_overflow, &loc);
2560		}
2561	1724577x	--num.bias;
2562	1724577x	num.mant = 10 * num.mant + ( c - '0' );
2563		}
2564		else
2565		{
2566	2006984x	goto do_num5;
2567		}
2568		}
2569	17137x	else if((c \| 32) == 'e')
2570		{
2571	11134x	++cs;
2572	11134x	goto do_exp1;
2573		}
2574		else
2575		{
2576	6003x	goto finish_dub;
2577		}
2578		}
2579
2580		//----------------------------------
2581		//
2582		// *[+-]
2583		//
2584	2031448x	do_exp1:
2585	2031448x	if(BOOST_JSON_UNLIKELY(! cs))
2586		{
2587	575x	if(BOOST_JSON_UNLIKELY(
2588		! h_.on_number_part(
2589		{begin, cs.used(begin)}, ec_)))
2590	49x	return fail(cs.begin());
2591
2592		BOOST_IF_CONSTEXPR( precise_parsing )
2593	✗	num_buf_.append( begin, cs.used(begin) );
2594	477x	return maybe_suspend(
2595	477x	cs.begin(), state::exp1, num);
2596		}
2597	2030873x	if(*cs == '+')
2598		{
2599	2364x	++cs;
2600		}
2601	2028509x	else if(*cs == '-')
2602		{
2603	1001936x	++cs;
2604	1001936x	num.frac = true;
2605		}
2606
2607		//----------------------------------
2608		//
2609		// DIGIT
2610		// first digit of the exponent
2611		//
2612	1026573x	do_exp2:
2613		{
2614	2031012x	if(BOOST_JSON_UNLIKELY(! cs))
2615		{
2616	188x	if(BOOST_JSON_UNLIKELY(more_))
2617		{
2618	179x	if(BOOST_JSON_UNLIKELY(
2619		! h_.on_number_part(
2620		{begin, cs.used(begin)}, ec_)))
2621	20x	return fail(cs.begin());
2622
2623		BOOST_IF_CONSTEXPR( precise_parsing )
2624	✗	num_buf_.append( begin, cs.used(begin) );
2625	139x	return suspend(cs.begin(), state::exp2, num);
2626		}
2627		// digit required
2628		BOOST_STATIC_CONSTEXPR source_location loc
2629		= BOOST_CURRENT_LOCATION;
2630	9x	return fail(cs.begin(), error::syntax, &loc);
2631		}
2632	2030824x	char const c = *cs;
2633	2030824x	if(BOOST_JSON_UNLIKELY(
2634		c < '0' \|\| c > '9'))
2635		{
2636		// digit required
2637		BOOST_STATIC_CONSTEXPR source_location loc
2638		= BOOST_CURRENT_LOCATION;
2639	508x	return fail(cs.begin(), error::syntax, &loc);
2640		}
2641	2030316x	++cs;
2642	2030316x	num.exp = c - '0';
2643		}
2644
2645		//----------------------------------
2646		//
2647		// 1*DIGIT
2648		// subsequent digits in the exponent
2649		//
2650	2042421x	do_exp3:
2651	5468163x	for(;;)
2652		{
2653	7510584x	if(BOOST_JSON_UNLIKELY(! cs))
2654		{
2655	2020838x	if(BOOST_JSON_UNLIKELY(more_))
2656		{
2657	12277x	if(BOOST_JSON_UNLIKELY(
2658		! h_.on_number_part(
2659		{begin, cs.used(begin)}, ec_)))
2660	86x	return fail(cs.begin());
2661
2662		BOOST_IF_CONSTEXPR( precise_parsing )
2663	✗	num_buf_.append( begin, cs.used(begin) );
2664	12105x	return suspend(cs.begin(), state::exp3, num);
2665		}
2666		}
2667		else
2668		{
2669	5489746x	char const c = *cs;
2670	5489746x	if(BOOST_JSON_LIKELY( c >= '0' && c <= '9' ))
2671		{
2672	5468163x	if(BOOST_JSON_UNLIKELY(
2673		// 2147483647 INT_MAX
2674		num.exp > 214748364 \|\|
2675		(num.exp == 214748364 && c > '7')
2676		))
2677	3855x	num.exp = INT_MAX;
2678		else BOOST_IF_CONSTEXPR( !no_parsing )
2679	4923456x	num.exp = 10 * num.exp + ( c - '0' );
2680
2681	5468163x	++cs;
2682	5468163x	continue;
2683		}
2684		}
2685	2030144x	BOOST_ASSERT(num.exp >= 0);
2686	2030144x	if ( num.frac )
2687		{
2688	1001800x	if(BOOST_JSON_UNLIKELY( num.bias < (INT_MIN + num.exp) ))
2689		{
2690		// if exponent overflowed, bias is a very large negative
2691		// number, and mantissa isn't zero, then we cannot parse the
2692		// number correctly
2693	92x	if(BOOST_JSON_UNLIKELY(
2694		(num.exp == INT_MAX) &&
2695		(num.bias < 0) &&
2696		(num.exp + num.bias < 308) &&
2697		num.mant ))
2698		{
2699		BOOST_STATIC_CONSTEXPR source_location loc
2700		= BOOST_CURRENT_LOCATION;
2701	1x	return fail(cs.begin(), error::exponent_overflow, &loc);
2702		}
2703
2704	91x	num.bias = 0;
2705	91x	num.exp = INT_MAX;
2706		}
2707		}
2708	1028344x	else if (BOOST_JSON_UNLIKELY( num.bias > (INT_MAX - num.exp) ))
2709		{
2710		// if exponent overflowed, bias is a very large positive number,
2711		// and mantissa isn't zero, then we cannot parse the
2712		// number correctly
2713	194x	if(BOOST_JSON_UNLIKELY(
2714		(num.exp == INT_MAX) &&
2715		(num.bias > 0) &&
2716		(num.exp - num.bias < 308) &&
2717		num.mant ))
2718		{
2719		BOOST_STATIC_CONSTEXPR source_location loc
2720		= BOOST_CURRENT_LOCATION;
2721	1x	return fail(cs.begin(), error::exponent_overflow, &loc);
2722		}
2723
2724	193x	num.bias = 0;
2725	193x	num.exp = INT_MAX;
2726		}
2727	2030142x	goto finish_dub;
2728		}
2729
2730	30387x	finish_int:
2731	28458x	if(negative \|\| (!stack_empty && num.neg))
2732		{
2733	2531x	if(BOOST_JSON_UNLIKELY(
2734		! h_.on_int64(static_cast<
2735		int64_t>(~num.mant + 1), {begin, cs.used(begin)}, ec_)))
2736	310x	return fail(cs.begin());
2737	1913x	return cs.begin();
2738		}
2739	27856x	if(num.mant <= INT64_MAX)
2740		{
2741	27555x	finish_signed:
2742	30830x	if(BOOST_JSON_UNLIKELY(
2743		! h_.on_int64(static_cast<
2744		int64_t>(num.mant), {begin, cs.used(begin)}, ec_)))
2745	2267x	return fail(cs.begin());
2746	26303x	return cs.begin();
2747		}
2748	321x	if(BOOST_JSON_UNLIKELY(
2749		! h_.on_uint64(num.mant, {begin, cs.used(begin)}, ec_)))
2750	35x	return fail(cs.begin());
2751	254x	return cs.begin();
2752	2052467x	finish_dub:
2753		double d;
2754	2052467x	std::size_t const size = cs.used(begin);
2755	2052467x	BOOST_ASSERT( !num_buf_.size() \|\| precise_parsing );
2756		BOOST_IF_CONSTEXPR( precise_parsing )
2757		{
2758	1000052x	char const* data = begin;
2759	1000052x	std::size_t full_size = size;
2760		// if we previously suspended or if the current input ends with the
2761		// number, we need to copy the current part of the number to the
2762		// temporary buffer
2763	1000052x	if(BOOST_JSON_UNLIKELY( num_buf_.size() ))
2764		{
2765	1x	data = num_buf_.append( begin, size );
2766	1x	full_size = num_buf_.size();
2767		}
2768	1000052x	auto const err = detail::charconv::from_chars(
2769		data, data + full_size, d );
2770	1000052x	BOOST_ASSERT( err.ec != std::errc::invalid_argument );
2771	1000052x	BOOST_ASSERT( err.ptr == data + full_size );
2772		(void)err;
2773		}
2774		else BOOST_IF_CONSTEXPR( no_parsing )
2775	9258x	d = 0;
2776		else
2777	1043157x	d = detail::dec_to_float(
2778		num.mant,
2779	541045x	num.bias + (num.frac ?
2780	502112x	-num.exp : num.exp),
2781	1043157x	num.neg);
2782	2052467x	if(BOOST_JSON_UNLIKELY(
2783		! h_.on_double(d, {begin, size}, ec_)))
2784	1935x	return fail(cs.begin());
2785	2048597x	return cs.begin();
2786		}
2787
2788		//----------------------------------------------------------
2789
2790		template<class Handler>
2791		template<class... Args>
2792	2164987x	basic_parser<Handler>::
2793		basic_parser(
2794		parse_options const& opt,
2795		Args&&... args)
2796	2164978x	: h_(std::forward<Args>(args)...)
2797	2164987x	, opt_(opt)
2798		{
2799	2164987x	}
2800
2801		//----------------------------------------------------------
2802
2803		template<class Handler>
2804		void
2805	4153166x	basic_parser<Handler>::
2806		reset() noexcept
2807		{
2808	4153166x	ec_ = {};
2809	4153166x	st_.clear();
2810	4153166x	more_ = true;
2811	4153166x	done_ = false;
2812	4153166x	clean_ = true;
2813	4153166x	num_buf_.clear();
2814	4153166x	}
2815
2816		template<class Handler>
2817		void
2818	18x	basic_parser<Handler>::
2819		fail(system::error_code ec) noexcept
2820		{
2821	18x	if(! ec)
2822		{
2823		// assign an arbitrary
2824		// error code to prevent UB
2825	1x	BOOST_JSON_FAIL(ec_, error::incomplete);
2826		}
2827		else
2828		{
2829	17x	ec_ = ec;
2830		}
2831	18x	done_ = false;
2832	18x	}
2833
2834		//----------------------------------------------------------
2835
2836		template<class Handler>
2837		std::size_t
2838	10726454x	basic_parser<Handler>::
2839		write_some(
2840		bool more,
2841		char const* data,
2842		std::size_t size,
2843		system::error_code& ec)
2844		{
2845		// see if we exited via exception
2846		// on the last call to write_some
2847	10726454x	if(! clean_)
2848		{
2849		// prevent UB
2850	1x	if(! ec_)
2851		{
2852	1x	BOOST_JSON_FAIL(ec_, error::exception);
2853		}
2854		}
2855	10726454x	if(ec_)
2856		{
2857		// error is sticky
2858	5x	ec = ec_;
2859	5x	return 0;
2860		}
2861	10726449x	clean_ = false;
2862	10726449x	more_ = more;
2863	10726449x	end_ = data + size;
2864		const char* p;
2865	10726449x	if(BOOST_JSON_LIKELY(st_.empty()))
2866		{
2867		// first time
2868	2164976x	depth_ = opt_.max_depth;
2869	2164976x	if(BOOST_JSON_UNLIKELY(
2870		! h_.on_document_begin(ec_)))
2871		{
2872	7928x	ec = ec_;
2873	7928x	return 0;
2874		}
2875	2149119x	p = parse_document(data, std::true_type());
2876		}
2877		else
2878		{
2879	8561473x	p = parse_document(data, std::false_type());
2880		}
2881
2882	10691424x	if(BOOST_JSON_LIKELY(p != sentinel()))
2883		{
2884	2099195x	BOOST_ASSERT(! ec_);
2885	2099195x	if(! done_)
2886		{
2887	2031780x	done_ = true;
2888	2031780x	h_.on_document_end(ec_);
2889		}
2890		}
2891		else
2892		{
2893	8592229x	if(! ec_)
2894		{
2895	8565374x	if(! more_)
2896		{
2897	589x	BOOST_JSON_FAIL(ec_, error::incomplete);
2898		}
2899	8564785x	else if(! st_.empty())
2900		{
2901		// consume as much trailing whitespace in
2902		// the JSON document as possible, but still
2903		// consider the parse complete
2904		state st;
2905	8564785x	st_.peek(st);
2906	8564785x	if( st == state::doc3 &&
2907	88551x	! done_)
2908		{
2909	70724x	done_ = true;
2910	70724x	h_.on_document_end(ec_);
2911		}
2912		}
2913		}
2914	8590585x	p = end_;
2915		}
2916	10685788x	ec = ec_;
2917	10685788x	clean_ = true;
2918	10685788x	return p - data;
2919		}
2920
2921		template<class Handler>
2922		std::size_t
2923	1x	basic_parser<Handler>::
2924		write_some(
2925		bool more,
2926		char const* data,
2927		std::size_t size,
2928		std::error_code& ec)
2929		{
2930	1x	system::error_code jec;
2931	1x	std::size_t const result = write_some(more, data, size, jec);
2932	1x	ec = jec;
2933	1x	return result;
2934		}
2935
2936		#endif
2937
2938		} // namespace json
2939		} // namespace boost
2940
2941		#ifdef _MSC_VER
2942		#pragma warning(pop)
2943		#endif
2944
2945		#endif
2946