basic_parser_impl.hpp

98.3% Lines (1262/0/1284) 35.3% List of functions (1403/0/3971)

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

f(x) Functions (3971)

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