basic_parser_impl.hpp

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