Context Navigation

source: icXML/icXML-devel/src/icxmlc/XMLUTF16CharacterSetAdapter.hpp @ 2774

Last change on this file since 2774 was 2774, checked in by cameron, 6 years ago
Various fixes
File size: 85.7 KB

Line
1	/*
2	* Copyright Â© 2012 International Characters.
3	* This software is licensed to the public under the Open Software License 3.0.
4	* icXML is a trademark of International Characters.
5	*/
6
7	/*
8	* @author Nigel Medforth, nigelm -at- interational-characters.com
9	* @version $Id: XMLUTF16CharacterSetAdapter.hpp 224 2012-12-12 03:31:56Z nigelm $
10	*
11	*/
12
13	#if !defined(XERCESC_INCLUDE_GUARD_XMLUTF16CHARACTERSETADAPTER_HPP)
14	#define XERCESC_INCLUDE_GUARD_XMLUTF16CHARACTERSETADAPTER_HPP
15
16	#include <xercesc/util/XercesDefs.hpp>
17	#include <icxercesc/util/TransService.hpp>
18	#include <icxercesc/internal/XMLReader.hpp>
19
20	#include <simd-lib/s2p.hpp>
21	#include <simd-lib/p2s.hpp>
22	#include <simd-lib/carryQ.hpp>
23	#include <icxmlc/XMLMultiliteral.h>
24	#include <icxmlc/XMLLineColTracker.hpp>
25	#include <icxmlc/XMLSymbolTable.hpp>
26	#include <icxmlc/XMLReferenceTable.hpp>
27	#include <icxmlc/XMLParserDefs.hpp>
28	// #include <icxmlc/XMLErrorTracker.hpp>
29	#include <icxmlc/XMLConfig.hpp>
30
31	XERCES_CPP_NAMESPACE_BEGIN
32
33
34	#define LocalCarryDeclare(name, count)\
35	CarryArray<count, 0> name;
36
37	class XMLUTF16CharacterSetAdapter : public XMLCharacterSetAdapter
38	{
39	public:
40
41	XMLUTF16CharacterSetAdapter
42	(
43	XMLTranscoder * transcoder
44	, MemoryManager * manager
45	)
46	: XMLCharacterSetAdapter(manager)
47	, fTranscoder(transcoder)
48	#ifdef TEST_ENTITY_EXPANSION
49	, fReferenceTable(transcoder, manager)
50	#endif
51	, fSwapped(transcoder->isSwapped())
52	{
53
54	}
55
56	XMLUTF16CharacterSetAdapter
57	(
58	XMLTranscoder * transcoder
59	, MemoryManager * manager
60	, bool swapped
61	)
62	: XMLCharacterSetAdapter(manager)
63	, fTranscoder(transcoder)
64	#ifdef TEST_ENTITY_EXPANSION
65	, fReferenceTable(transcoder, manager)
66	#endif
67	, fSwapped(swapped)
68	{
69
70	}
71
72	virtual ~XMLUTF16CharacterSetAdapter()
73	{
74
75	}
76
77	virtual XMLSize_t getCodeUnitSize()
78	{
79	return 2;
80	}
81
82	virtual XMLCh * parse
83	(
84	const XMLByte * const src
85	, const XMLSize_t offset
86	, const XMLSize_t avail
87	, const bool noMore
88	, ContentStream & contentStream
89	, XMLSize_t contentOffset
90	, unsigned int & markupCount
91	, SymbolArray & symbolArray
92	, unsigned int & symbolCount
93	, StringPtrArray & stringEndArray
94	, unsigned int & stringEndCount
95	, XMLLineColTracker & lineColTracker
96	, BitBlock * newLineOrSkipMaskStream
97	, BitBlock * delMaskStream
98	, unsigned int & incompleteMarkupBytes
99	, unsigned int & unusedSymbols
100	, unsigned int & unusedContent
101	, unsigned int & bytesEaten
102	);
103
104	/**
105	Specialized stream-lined method for parsing resolved entities and whole
106	sub-documents.
107	**/
108	XMLSize_t parseInternal
109	(
110	const XMLByte * const source
111	, const XMLSize_t avail
112	, ContentStream & contentStream
113	, unsigned int & markupCount
114	, SymbolArray & symbolArray
115	, unsigned int & symbolCount
116	, StringPtrArray & stringEndArray
117	, unsigned int & stringEndCount
118	);
119
120	private:
121
122	// -----------------------------------------------------------------------
123	// Unimplemented constructors and operators
124	// -----------------------------------------------------------------------
125	XMLUTF16CharacterSetAdapter(const XMLUTF16CharacterSetAdapter&);
126	XMLUTF16CharacterSetAdapter& operator=(const XMLUTF16CharacterSetAdapter&);
127
128	#define error_tracker_NoteError(x, y)
129	#define NoteXercesXMLErr(x, y)
130	struct Parameters {
131	BitBlock XML_11;
132	};
133
134	struct Basis_bits {
135	BitBlock bit_0;
136	BitBlock bit_1;
137	BitBlock bit_2;
138	BitBlock bit_3;
139	BitBlock bit_4;
140	BitBlock bit_5;
141	BitBlock bit_6;
142	BitBlock bit_7;
143	};
144
145	struct U16hi {
146	BitBlock bit_0;
147	BitBlock bit_1;
148	BitBlock bit_2;
149	BitBlock bit_3;
150	BitBlock bit_4;
151	BitBlock bit_5;
152	BitBlock bit_6;
153	BitBlock bit_7;
154	};
155
156	struct U16lo {
157	BitBlock bit_0;
158	BitBlock bit_1;
159	BitBlock bit_2;
160	BitBlock bit_3;
161	BitBlock bit_4;
162	BitBlock bit_5;
163	BitBlock bit_6;
164	BitBlock bit_7;
165	};
166
167	struct Lex {
168	BitBlock CR;
169	BitBlock LF;
170	BitBlock HT;
171	BitBlock SP;
172	BitBlock RefStart;
173	BitBlock Semicolon;
174	BitBlock Colon;
175	BitBlock LAngle;
176	BitBlock RAngle;
177	BitBlock LBracket;
178	BitBlock RBracket;
179	BitBlock Exclam;
180	BitBlock QMark;
181	BitBlock Hyphen;
182	BitBlock Equals;
183	BitBlock SQuote;
184	BitBlock DQuote;
185	BitBlock Slash;
186	BitBlock Hash;
187	BitBlock NameScan;
188	BitBlock Pct;
189	BitBlock RepOp;
190	BitBlock LContentDelim;
191	BitBlock WS;
192	BitBlock DEL;
193	BitBlock NEL;
194	BitBlock LS;
195	};
196
197	struct Marker {
198	BitBlock LAngle;
199	BitBlock Tag_opener;
200	BitBlock Ref_opener;
201	BitBlock Ref_closer;
202	BitBlock CD_closer;
203	};
204
205	struct Callouts {
206	BitBlock PI_openers;
207	BitBlock CtCD_openers;
208	BitBlock CtCDPI_closers;
209	BitBlock CtCDPI_content_starts;
210	BitBlock ctCDPI_mask;
211	BitBlock Symbol_starts;
212	BitBlock Symbol_ends;
213	BitBlock AttEq_marks;
214	BitBlock AttOpenQuotes;
215	BitBlock AttCloseQuotes;
216	BitBlock AttValSpan;
217	BitBlock StartTag_closers;
218	BitBlock EmptyTag_closers;
219	BitBlock EndTag_closers;
220	BitBlock Tag_closers;
221	BitBlock TagSpan;
222	BitBlock EndTag_marks;
223	BitBlock EmptyTag_marks;
224	BitBlock MarkupDelimiters;
225	BitBlock StringEnds;
226	BitBlock delmask;
227	BitBlock skipmask;
228	};
229
230	struct Errors {
231	BitBlock Unicode;
232	BitBlock Lexical;
233	BitBlock ExpectedCommentOrCDATA;
234	BitBlock PINameExpected;
235	BitBlock UnterminatedPI;
236	BitBlock IllegalSequenceInComment;
237	BitBlock UnterminatedCDATASection;
238	BitBlock UnterminatedComment;
239	BitBlock ExpectedElementName;
240	BitBlock ExpectedAttrName;
241	BitBlock ExpectedEqSign;
242	BitBlock ExpectedAttrValue;
243	BitBlock UnterminatedStartTag;
244	BitBlock ExpectedWhitespace;
245	BitBlock UnterminatedEndTag;
246	BitBlock UnterminatedEntityRef;
247	BitBlock BadSequenceInCharData;
248	};
249
250	struct Parse_refs {
251	Parse_refs() {
252	}
253	IDISA_ALWAYS_INLINE void do_block(Lex & lex, Marker & marker, Callouts & callouts, Errors & errors) {
254	BitBlock ref_error;
255
256	BitBlock tempvar0, tempvar1;
257
258
259	marker.Ref_closer = simd<1>::constant<0>();
260	errors.UnterminatedEntityRef = simd<1>::constant<0>();
261	if ((bitblock::any(marker.Ref_opener) \|\| carryQ.CarryTest(0, 3))) {
262	marker.Ref_closer = carryQ.BitBlock_scanthru_ci_co(marker.Ref_opener, simd_or(simd_or(lex.NameScan, marker.Ref_opener), lex.Hash), carryQ.get_carry_in(0), 0);
263	ref_error = simd_andc(marker.Ref_closer, lex.Semicolon);
264	errors.UnterminatedEntityRef = ref_error;
265	tempvar0 = carryQ.BitBlock_span_upto(marker.Ref_opener, marker.Ref_closer, carryQ.get_carry_in(1), 1);
266	tempvar1 = carryQ.BitBlock_advance_ci_co(tempvar0, carryQ.get_carry_in(2), 2);
267	callouts.delmask = simd_or(callouts.delmask, tempvar1);
268	}
269	else {
270	carryQ.CarryDequeueEnqueue(0, 3);
271	}
272	carryQ.CarryQ_Adjust(3);
273	}
274	IDISA_ALWAYS_INLINE void do_final_block(Lex & lex, Marker & marker, Callouts & callouts, Errors & errors, BitBlock EOF_mask) {
275	BitBlock ref_error;
276
277	BitBlock tempvar0, tempvar1;
278
279
280	marker.Ref_closer = simd<1>::constant<0>();
281	errors.UnterminatedEntityRef = simd<1>::constant<0>();
282	if ((bitblock::any(marker.Ref_opener) \|\| carryQ.CarryTest(0, 3))) {
283	marker.Ref_closer = carryQ.BitBlock_scanthru_ci_co(marker.Ref_opener, simd_or(simd_or(lex.NameScan, marker.Ref_opener), lex.Hash), carryQ.get_carry_in(0), 0);
284	ref_error = simd_andc(marker.Ref_closer, lex.Semicolon);
285	errors.UnterminatedEntityRef = ref_error;
286	tempvar0 = carryQ.BitBlock_span_upto(marker.Ref_opener, marker.Ref_closer, carryQ.get_carry_in(1), 1);
287	tempvar1 = carryQ.BitBlock_advance_ci_co(tempvar0, carryQ.get_carry_in(2), 2);
288	callouts.delmask = simd_or(callouts.delmask, tempvar1);
289	}
290	else {
291	carryQ.CarryDequeueEnqueue(0, 3);
292	}
293	}
294	void do_segment(Lex lex[], Marker marker[], Callouts callouts[], Errors errors[], int segment_blocks) {
295	int i;
296	for (i = 0; i < segment_blocks; i++)
297	do_block(lex[i], marker[i], callouts[i], errors[i]);
298	}
299	CarryArray<3, 0> carryQ;
300	};
301
302	struct Parse_tags {
303	Parse_tags() {
304	}
305	IDISA_ALWAYS_INLINE void do_block(Lex & lex, Marker & marker, Callouts & callouts, Errors & errors) {
306	BitBlock DQuoteDelim, SQuoteDelim, AttListDelim, ElemName_starts;
307	BitBlock elem_name_follows, NoElemNameErr, AfterWS, AttListEnd, AttNameStart;
308	BitBlock NoAttNameError, AttNameFollow, EqExpected, EqError, AttValPos;
309	BitBlock DQuoteAttVal, SQuoteAttVal, NoAttValErr, DQuoteAttEnd, SQuoteAttEnd;
310	BitBlock AttValEnd, AttValErr, AttValFollow, AttListEndErr, ParseError;
311	BitBlock EndTag_Name_starts, EndTag_Name_follows, EndTagCloseError;
312
313
314
315
316	DQuoteDelim = simd_or(lex.DQuote, lex.LAngle);
317	SQuoteDelim = simd_or(lex.SQuote, lex.LAngle);
318	AttListDelim = simd_or(lex.Slash, lex.RAngle);
319	ElemName_starts = simd_andc(marker.Tag_opener, lex.Slash);
320	callouts.Symbol_starts = simd_or(callouts.Symbol_starts, ElemName_starts);
321	callouts.EndTag_marks = simd_and(marker.Tag_opener, lex.Slash);
322	elem_name_follows = carryQ.BitBlock_scanthru_ci_co(ElemName_starts, lex.NameScan, carryQ.get_carry_in(0), 0);
323	callouts.Symbol_ends = simd_or(callouts.Symbol_ends, elem_name_follows);
324	NoElemNameErr = simd_and(ElemName_starts, elem_name_follows);
325	errors.ExpectedElementName = NoElemNameErr;
326	callouts.AttOpenQuotes = simd<1>::constant<0>();
327	callouts.AttCloseQuotes = simd<1>::constant<0>();
328	callouts.AttEq_marks = simd<1>::constant<0>();
329	errors.ExpectedAttrName = simd<1>::constant<0>();
330	errors.ExpectedEqSign = simd<1>::constant<0>();
331	errors.ExpectedAttrValue = simd<1>::constant<0>();
332	errors.UnterminatedStartTag = simd<1>::constant<0>();
333	errors.ExpectedWhitespace = simd<1>::constant<0>();
334	if ((bitblock::any(simd_and(elem_name_follows, lex.WS)) \|\| carryQ.CarryTest(1, 8))) {
335	AfterWS = carryQ.BitBlock_scanthru_ci_co(elem_name_follows, lex.WS, carryQ.get_carry_in(1), 1);
336	AttListEnd = simd_and(AfterWS, AttListDelim);
337	AttNameStart = simd_andc(AfterWS, AttListDelim);
338	if ((bitblock::any(AttNameStart) \|\| carryQ.CarryTest(2, 7))) {
339	NoAttNameError = simd_or(NoAttNameError, simd_andc(AttNameStart, lex.NameScan));
340	errors.ExpectedAttrName = simd_or(errors.ExpectedAttrName, NoAttNameError);
341	callouts.Symbol_starts = simd_or(callouts.Symbol_starts, AttNameStart);
342	AttNameFollow = carryQ.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, carryQ.get_carry_in(2), 2);
343	callouts.Symbol_ends = simd_or(callouts.Symbol_ends, AttNameFollow);
344	if ((bitblock::any(simd_and(AttNameFollow, lex.WS)) \|\| carryQ.CarryTest(3, 1))) {
345	EqExpected = carryQ.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, carryQ.get_carry_in(3), 3);
346	}
347	else {
348	EqExpected = AttNameFollow;
349	carryQ.CarryDequeueEnqueue(3, 1);
350	}
351	EqError = simd_andc(EqExpected, lex.Equals);
352	errors.ExpectedEqSign = simd_or(errors.ExpectedEqSign, EqError);
353	callouts.AttEq_marks = simd_or(callouts.AttEq_marks, EqExpected);
354	AttValPos = carryQ.BitBlock_scanthru_ci_co(EqExpected, simd_or(EqExpected, lex.WS), carryQ.get_carry_in(4), 4);
355	DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
356	SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
357	NoAttValErr = simd_andc(AttValPos, simd_or(lex.DQuote, lex.SQuote));
358	errors.ExpectedAttrValue = simd_or(errors.ExpectedAttrValue, NoAttValErr);
359	callouts.AttOpenQuotes = simd_or(callouts.AttOpenQuotes, AttValPos);
360	DQuoteAttEnd = carryQ.BitBlock_scanthru_ci_co(DQuoteAttVal, simd_not(simd_andc(DQuoteDelim, DQuoteAttVal)), carryQ.get_carry_in(5), 5);
361	SQuoteAttEnd = carryQ.BitBlock_scanthru_ci_co(SQuoteAttVal, simd_not(simd_andc(SQuoteDelim, SQuoteAttVal)), carryQ.get_carry_in(6), 6);
362	AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
363	AttValErr = simd_andc(AttValEnd, simd_or(lex.DQuote, lex.SQuote));
364	errors.UnterminatedStartTag = simd_or(errors.UnterminatedStartTag, AttValErr);
365	callouts.AttCloseQuotes = simd_or(callouts.AttCloseQuotes, AttValEnd);
366	AttValFollow = carryQ.BitBlock_advance_ci_co(AttValEnd, carryQ.get_carry_in(7), 7);
367	if ((bitblock::any(simd_and(AttValFollow, lex.WS)) \|\| carryQ.CarryTest(8, 1))) {
368	AfterWS = carryQ.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, carryQ.get_carry_in(8), 8);
369	}
370	else {
371	AfterWS = AttValFollow;
372	carryQ.CarryDequeueEnqueue(8, 1);
373	}
374	AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
375	AttNameStart = simd_andc(AfterWS, AttListDelim);
376	AttListEndErr = simd_and(AttValFollow, AttNameStart);
377	errors.ExpectedWhitespace = simd_or(errors.ExpectedWhitespace, AttListEndErr);
378	while (bitblock::any(AttNameStart)) {
379	LocalCarryDeclare(subcarryQ, 7);
380	NoAttNameError = simd_or(NoAttNameError, simd_andc(AttNameStart, lex.NameScan));
381	errors.ExpectedAttrName = simd_or(errors.ExpectedAttrName, NoAttNameError);
382	callouts.Symbol_starts = simd_or(callouts.Symbol_starts, AttNameStart);
383	AttNameFollow = subcarryQ.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, simd<1>::constant<0>(), 0);
384	callouts.Symbol_ends = simd_or(callouts.Symbol_ends, AttNameFollow);
385	if (bitblock::any(simd_and(AttNameFollow, lex.WS))) {
386	EqExpected = subcarryQ.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, simd<1>::constant<0>(), 1);
387	}
388	else {
389	EqExpected = AttNameFollow;
390	subcarryQ.CarryDequeueEnqueue(3, 1);
391	}
392	EqError = simd_andc(EqExpected, lex.Equals);
393	errors.ExpectedEqSign = simd_or(errors.ExpectedEqSign, EqError);
394	callouts.AttEq_marks = simd_or(callouts.AttEq_marks, EqExpected);
395	AttValPos = subcarryQ.BitBlock_scanthru_ci_co(EqExpected, simd_or(EqExpected, lex.WS), simd<1>::constant<0>(), 2);
396	DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
397	SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
398	NoAttValErr = simd_andc(AttValPos, simd_or(lex.DQuote, lex.SQuote));
399	errors.ExpectedAttrValue = simd_or(errors.ExpectedAttrValue, NoAttValErr);
400	callouts.AttOpenQuotes = simd_or(callouts.AttOpenQuotes, AttValPos);
401	DQuoteAttEnd = subcarryQ.BitBlock_scanthru_ci_co(DQuoteAttVal, simd_not(simd_andc(DQuoteDelim, DQuoteAttVal)), simd<1>::constant<0>(), 3);
402	SQuoteAttEnd = subcarryQ.BitBlock_scanthru_ci_co(SQuoteAttVal, simd_not(simd_andc(SQuoteDelim, SQuoteAttVal)), simd<1>::constant<0>(), 4);
403	AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
404	AttValErr = simd_andc(AttValEnd, simd_or(lex.DQuote, lex.SQuote));
405	errors.UnterminatedStartTag = simd_or(errors.UnterminatedStartTag, AttValErr);
406	callouts.AttCloseQuotes = simd_or(callouts.AttCloseQuotes, AttValEnd);
407	AttValFollow = subcarryQ.BitBlock_advance_ci_co(AttValEnd, simd<1>::constant<0>(), 5);
408	if (bitblock::any(simd_and(AttValFollow, lex.WS))) {
409	AfterWS = subcarryQ.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, simd<1>::constant<0>(), 6);
410	}
411	else {
412	AfterWS = AttValFollow;
413	subcarryQ.CarryDequeueEnqueue(8, 1);
414	}
415	AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
416	AttNameStart = simd_andc(AfterWS, AttListDelim);
417	AttListEndErr = simd_and(AttValFollow, AttNameStart);
418	errors.ExpectedWhitespace = simd_or(errors.ExpectedWhitespace, AttListEndErr);
419	carryQ.CarryCombine(subcarryQ.cq, 2, 7);
420	}
421	}
422	else {
423	carryQ.CarryDequeueEnqueue(2, 7);
424	}
425	}
426	else {
427	AttListEnd = simd_and(elem_name_follows, AttListDelim);
428	AttListEndErr = simd_andc(elem_name_follows, AttListDelim);
429	errors.ExpectedWhitespace = simd_or(errors.ExpectedWhitespace, AttListEndErr);
430	carryQ.CarryDequeueEnqueue(1, 8);
431	}
432	callouts.AttValSpan = carryQ.BitBlock_exclusive_span(callouts.AttOpenQuotes, callouts.AttCloseQuotes, carryQ.get_carry_in(9), 9);
433	callouts.StartTag_closers = simd_and(AttListEnd, lex.RAngle);
434	callouts.EmptyTag_marks = simd_and(AttListEnd, lex.Slash);
435	callouts.EmptyTag_closers = carryQ.BitBlock_advance_ci_co(callouts.EmptyTag_marks, carryQ.get_carry_in(10), 10);
436	ParseError = simd_or(ParseError, simd_andc(callouts.EmptyTag_closers, lex.RAngle));
437	errors.UnterminatedStartTag = simd_or(errors.UnterminatedStartTag, ParseError);
438	EndTag_Name_starts = carryQ.BitBlock_advance_ci_co(callouts.EndTag_marks, carryQ.get_carry_in(11), 11);
439	callouts.Symbol_starts = simd_or(callouts.Symbol_starts, EndTag_Name_starts);
440	EndTag_Name_follows = carryQ.BitBlock_scanthru_ci_co(EndTag_Name_starts, lex.NameScan, carryQ.get_carry_in(12), 12);
441	callouts.Symbol_ends = simd_or(callouts.Symbol_ends, EndTag_Name_follows);
442	callouts.EndTag_closers = EndTag_Name_follows;
443	if ((bitblock::any(simd_and(EndTag_Name_follows, lex.WS)) \|\| carryQ.CarryTest(13, 1))) {
444	callouts.EndTag_closers = carryQ.BitBlock_scanthru_ci_co(callouts.EndTag_closers, lex.WS, carryQ.get_carry_in(13), 13);
445	}
446	else {
447	carryQ.CarryDequeueEnqueue(13, 1);
448	}
449	EndTagCloseError = simd_andc(callouts.EndTag_closers, lex.RAngle);
450	errors.UnterminatedEndTag = EndTagCloseError;
451	callouts.Tag_closers = simd_or(simd_or(callouts.StartTag_closers, callouts.EmptyTag_closers), callouts.EndTag_closers);
452	callouts.TagSpan = carryQ.BitBlock_inclusive_span(marker.Tag_opener, callouts.Tag_closers, carryQ.get_carry_in(14), 14);
453	marker.CD_closer = simd_andc(marker.CD_closer, callouts.TagSpan);
454	carryQ.CarryQ_Adjust(15);
455	}
456	IDISA_ALWAYS_INLINE void do_final_block(Lex & lex, Marker & marker, Callouts & callouts, Errors & errors, BitBlock EOF_mask) {
457	BitBlock DQuoteDelim, SQuoteDelim, AttListDelim, ElemName_starts;
458	BitBlock elem_name_follows, NoElemNameErr, AfterWS, AttListEnd, AttNameStart;
459	BitBlock NoAttNameError, AttNameFollow, EqExpected, EqError, AttValPos;
460	BitBlock DQuoteAttVal, SQuoteAttVal, NoAttValErr, DQuoteAttEnd, SQuoteAttEnd;
461	BitBlock AttValEnd, AttValErr, AttValFollow, AttListEndErr, ParseError;
462	BitBlock EndTag_Name_starts, EndTag_Name_follows, EndTagCloseError;
463
464
465
466
467	DQuoteDelim = simd_or(lex.DQuote, lex.LAngle);
468	SQuoteDelim = simd_or(lex.SQuote, lex.LAngle);
469	AttListDelim = simd_or(lex.Slash, lex.RAngle);
470	ElemName_starts = simd_andc(marker.Tag_opener, lex.Slash);
471	callouts.Symbol_starts = simd_or(callouts.Symbol_starts, ElemName_starts);
472	callouts.EndTag_marks = simd_and(marker.Tag_opener, lex.Slash);
473	elem_name_follows = carryQ.BitBlock_scanthru_ci_co(ElemName_starts, lex.NameScan, carryQ.get_carry_in(0), 0);
474	callouts.Symbol_ends = simd_or(callouts.Symbol_ends, elem_name_follows);
475	NoElemNameErr = simd_and(ElemName_starts, elem_name_follows);
476	errors.ExpectedElementName = NoElemNameErr;
477	callouts.AttOpenQuotes = simd<1>::constant<0>();
478	callouts.AttCloseQuotes = simd<1>::constant<0>();
479	callouts.AttEq_marks = simd<1>::constant<0>();
480	errors.ExpectedAttrName = simd<1>::constant<0>();
481	errors.ExpectedEqSign = simd<1>::constant<0>();
482	errors.ExpectedAttrValue = simd<1>::constant<0>();
483	errors.UnterminatedStartTag = simd<1>::constant<0>();
484	errors.ExpectedWhitespace = simd<1>::constant<0>();
485	if ((bitblock::any(simd_and(elem_name_follows, lex.WS)) \|\| carryQ.CarryTest(1, 8))) {
486	AfterWS = carryQ.BitBlock_scanthru_ci_co(elem_name_follows, lex.WS, carryQ.get_carry_in(1), 1);
487	AttListEnd = simd_and(AfterWS, AttListDelim);
488	AttNameStart = simd_andc(AfterWS, AttListDelim);
489	if ((bitblock::any(simd_and(AttNameStart, EOF_mask)) \|\| carryQ.CarryTest(2, 7))) {
490	NoAttNameError = simd_or(NoAttNameError, simd_andc(AttNameStart, lex.NameScan));
491	errors.ExpectedAttrName = simd_or(errors.ExpectedAttrName, NoAttNameError);
492	callouts.Symbol_starts = simd_or(callouts.Symbol_starts, AttNameStart);
493	AttNameFollow = carryQ.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, carryQ.get_carry_in(2), 2);
494	callouts.Symbol_ends = simd_or(callouts.Symbol_ends, AttNameFollow);
495	if ((bitblock::any(simd_and(AttNameFollow, lex.WS)) \|\| carryQ.CarryTest(3, 1))) {
496	EqExpected = carryQ.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, carryQ.get_carry_in(3), 3);
497	}
498	else {
499	EqExpected = AttNameFollow;
500	carryQ.CarryDequeueEnqueue(3, 1);
501	}
502	EqError = simd_andc(EqExpected, lex.Equals);
503	errors.ExpectedEqSign = simd_or(errors.ExpectedEqSign, EqError);
504	callouts.AttEq_marks = simd_or(callouts.AttEq_marks, EqExpected);
505	AttValPos = carryQ.BitBlock_scanthru_ci_co(EqExpected, simd_or(EqExpected, lex.WS), carryQ.get_carry_in(4), 4);
506	DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
507	SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
508	NoAttValErr = simd_andc(AttValPos, simd_or(lex.DQuote, lex.SQuote));
509	errors.ExpectedAttrValue = simd_or(errors.ExpectedAttrValue, NoAttValErr);
510	callouts.AttOpenQuotes = simd_or(callouts.AttOpenQuotes, AttValPos);
511	DQuoteAttEnd = carryQ.BitBlock_scanthru_ci_co(DQuoteAttVal, simd_andc(EOF_mask, simd_andc(DQuoteDelim, DQuoteAttVal)), carryQ.get_carry_in(5), 5);
512	SQuoteAttEnd = carryQ.BitBlock_scanthru_ci_co(SQuoteAttVal, simd_andc(EOF_mask, simd_andc(SQuoteDelim, SQuoteAttVal)), carryQ.get_carry_in(6), 6);
513	AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
514	AttValErr = simd_andc(AttValEnd, simd_or(lex.DQuote, lex.SQuote));
515	errors.UnterminatedStartTag = simd_or(errors.UnterminatedStartTag, AttValErr);
516	callouts.AttCloseQuotes = simd_or(callouts.AttCloseQuotes, AttValEnd);
517	AttValFollow = carryQ.BitBlock_advance_ci_co(AttValEnd, carryQ.get_carry_in(7), 7);
518	if ((bitblock::any(simd_and(AttValFollow, lex.WS)) \|\| carryQ.CarryTest(8, 1))) {
519	AfterWS = carryQ.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, carryQ.get_carry_in(8), 8);
520	}
521	else {
522	AfterWS = AttValFollow;
523	carryQ.CarryDequeueEnqueue(8, 1);
524	}
525	AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
526	AttNameStart = simd_andc(AfterWS, AttListDelim);
527	AttListEndErr = simd_and(AttValFollow, AttNameStart);
528	errors.ExpectedWhitespace = simd_or(errors.ExpectedWhitespace, AttListEndErr);
529	while (bitblock::any(simd_and(AttNameStart, EOF_mask))) {
530	LocalCarryDeclare(subcarryQ, 7);
531	NoAttNameError = simd_or(NoAttNameError, simd_andc(AttNameStart, lex.NameScan));
532	errors.ExpectedAttrName = simd_or(errors.ExpectedAttrName, NoAttNameError);
533	callouts.Symbol_starts = simd_or(callouts.Symbol_starts, AttNameStart);
534	AttNameFollow = subcarryQ.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, simd<1>::constant<0>(), 0);
535	callouts.Symbol_ends = simd_or(callouts.Symbol_ends, AttNameFollow);
536	if (bitblock::any(simd_and(AttNameFollow, lex.WS))) {
537	EqExpected = subcarryQ.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, simd<1>::constant<0>(), 1);
538	}
539	else {
540	EqExpected = AttNameFollow;
541	subcarryQ.CarryDequeueEnqueue(3, 1);
542	}
543	EqError = simd_andc(EqExpected, lex.Equals);
544	errors.ExpectedEqSign = simd_or(errors.ExpectedEqSign, EqError);
545	callouts.AttEq_marks = simd_or(callouts.AttEq_marks, EqExpected);
546	AttValPos = subcarryQ.BitBlock_scanthru_ci_co(EqExpected, simd_or(EqExpected, lex.WS), simd<1>::constant<0>(), 2);
547	DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
548	SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
549	NoAttValErr = simd_andc(AttValPos, simd_or(lex.DQuote, lex.SQuote));
550	errors.ExpectedAttrValue = simd_or(errors.ExpectedAttrValue, NoAttValErr);
551	callouts.AttOpenQuotes = simd_or(callouts.AttOpenQuotes, AttValPos);
552	DQuoteAttEnd = subcarryQ.BitBlock_scanthru_ci_co(DQuoteAttVal, simd_andc(EOF_mask, simd_andc(DQuoteDelim, DQuoteAttVal)), simd<1>::constant<0>(), 3);
553	SQuoteAttEnd = subcarryQ.BitBlock_scanthru_ci_co(SQuoteAttVal, simd_andc(EOF_mask, simd_andc(SQuoteDelim, SQuoteAttVal)), simd<1>::constant<0>(), 4);
554	AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
555	AttValErr = simd_andc(AttValEnd, simd_or(lex.DQuote, lex.SQuote));
556	errors.UnterminatedStartTag = simd_or(errors.UnterminatedStartTag, AttValErr);
557	callouts.AttCloseQuotes = simd_or(callouts.AttCloseQuotes, AttValEnd);
558	AttValFollow = subcarryQ.BitBlock_advance_ci_co(AttValEnd, simd<1>::constant<0>(), 5);
559	if (bitblock::any(simd_and(AttValFollow, lex.WS))) {
560	AfterWS = subcarryQ.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, simd<1>::constant<0>(), 6);
561	}
562	else {
563	AfterWS = AttValFollow;
564	subcarryQ.CarryDequeueEnqueue(8, 1);
565	}
566	AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
567	AttNameStart = simd_andc(AfterWS, AttListDelim);
568	AttListEndErr = simd_and(AttValFollow, AttNameStart);
569	errors.ExpectedWhitespace = simd_or(errors.ExpectedWhitespace, AttListEndErr);
570	carryQ.CarryCombine(subcarryQ.cq, 2, 7);
571	}
572	}
573	else {
574	carryQ.CarryDequeueEnqueue(2, 7);
575	}
576	}
577	else {
578	AttListEnd = simd_and(elem_name_follows, AttListDelim);
579	AttListEndErr = simd_andc(elem_name_follows, AttListDelim);
580	errors.ExpectedWhitespace = simd_or(errors.ExpectedWhitespace, AttListEndErr);
581	carryQ.CarryDequeueEnqueue(1, 8);
582	}
583	callouts.AttValSpan = carryQ.BitBlock_exclusive_span(callouts.AttOpenQuotes, callouts.AttCloseQuotes, carryQ.get_carry_in(9), 9);
584	callouts.StartTag_closers = simd_and(AttListEnd, lex.RAngle);
585	callouts.EmptyTag_marks = simd_and(AttListEnd, lex.Slash);
586	callouts.EmptyTag_closers = carryQ.BitBlock_advance_ci_co(callouts.EmptyTag_marks, carryQ.get_carry_in(10), 10);
587	ParseError = simd_or(ParseError, simd_andc(callouts.EmptyTag_closers, lex.RAngle));
588	errors.UnterminatedStartTag = simd_or(errors.UnterminatedStartTag, ParseError);
589	EndTag_Name_starts = carryQ.BitBlock_advance_ci_co(callouts.EndTag_marks, carryQ.get_carry_in(11), 11);
590	callouts.Symbol_starts = simd_or(callouts.Symbol_starts, EndTag_Name_starts);
591	EndTag_Name_follows = carryQ.BitBlock_scanthru_ci_co(EndTag_Name_starts, lex.NameScan, carryQ.get_carry_in(12), 12);
592	callouts.Symbol_ends = simd_or(callouts.Symbol_ends, EndTag_Name_follows);
593	callouts.EndTag_closers = EndTag_Name_follows;
594	if ((bitblock::any(simd_and(EndTag_Name_follows, lex.WS)) \|\| carryQ.CarryTest(13, 1))) {
595	callouts.EndTag_closers = carryQ.BitBlock_scanthru_ci_co(callouts.EndTag_closers, lex.WS, carryQ.get_carry_in(13), 13);
596	}
597	else {
598	carryQ.CarryDequeueEnqueue(13, 1);
599	}
600	EndTagCloseError = simd_andc(callouts.EndTag_closers, lex.RAngle);
601	errors.UnterminatedEndTag = EndTagCloseError;
602	callouts.Tag_closers = simd_or(simd_or(callouts.StartTag_closers, callouts.EmptyTag_closers), callouts.EndTag_closers);
603	callouts.TagSpan = carryQ.BitBlock_inclusive_span(marker.Tag_opener, callouts.Tag_closers, carryQ.get_carry_in(14), 14);
604	marker.CD_closer = simd_andc(marker.CD_closer, callouts.TagSpan);
605	}
606	void do_segment(Lex lex[], Marker marker[], Callouts callouts[], Errors errors[], int segment_blocks) {
607	int i;
608	for (i = 0; i < segment_blocks; i++)
609	do_block(lex[i], marker[i], callouts[i], errors[i]);
610	}
611	CarryArray<15, 0> carryQ;
612	};
613
614	struct Init_Parameters {
615
616	IDISA_ALWAYS_INLINE void do_block(Parameters & parameters) {
617
618
619
620
621
622	parameters.XML_11 = simd<1>::constant<0>();
623	}
624	IDISA_ALWAYS_INLINE void do_final_block(Parameters & parameters, BitBlock EOF_mask) {
625
626
627
628
629
630	parameters.XML_11 = simd<1>::constant<0>();
631	}
632	void do_segment(Parameters parameters[], int segment_blocks) {
633	int i;
634	for (i = 0; i < segment_blocks; i++)
635	do_block(parameters[i]);
636	}
637
638	};
639
640	struct Parse_CtCDPI {
641	Parse_CtCDPI() {
642	carryQ.cq[4] = carryQ.carry_flip(carryQ.cq[4]);
643	}
644	IDISA_ALWAYS_INLINE void do_block(Lex & lex, Marker & marker, Callouts & callouts, Errors & errors) {
645	BitBlock CtCDPI_starts, v, w, v1, w1, LAngle_scope, CtCDPI_opener, CD_closer;
646	BitBlock DoubleHyphen, DoubleRBracket, PI_closer, CtCDPI_Cursor, PI_Cursor;
647	BitBlock CD_Ct_Cursor, CD_Cursor, Ct_Cursor, CD_Ct_Error, PI_name_end;
648	BitBlock PI_error, Ct_error;
649
650	BitBlock tempvar0, tempvar1, tempvar2, tempvar3, tempvar4, tempvar5;
651
652
653	callouts.Symbol_starts = simd<1>::constant<0>();
654	callouts.Symbol_ends = simd<1>::constant<0>();
655	callouts.CtCDPI_content_starts = simd<1>::constant<0>();
656	callouts.CtCDPI_closers = simd<1>::constant<0>();
657	callouts.delmask = simd<1>::constant<0>();
658	callouts.ctCDPI_mask = simd<1>::constant<0>();
659	errors.ExpectedCommentOrCDATA = simd<1>::constant<0>();
660	errors.PINameExpected = simd<1>::constant<0>();
661	errors.IllegalSequenceInComment = simd<1>::constant<0>();
662	errors.UnterminatedPI = simd<1>::constant<0>();
663	errors.UnterminatedCDATASection = simd<1>::constant<0>();
664	errors.UnterminatedComment = simd<1>::constant<0>();
665	CtCDPI_starts = simd<1>::constant<0>();
666	v = simd_or(lex.LAngle, lex.Hyphen);
667	w = simd_or(lex.Hyphen, lex.QMark);
668	v1 = carryQ.BitBlock_advance_ci_co(v, carryQ.get_carry_in(0), 0);
669	w1 = carryQ.BitBlock_advance_ci_co(w, carryQ.get_carry_in(1), 1);
670	LAngle_scope = simd_andc(v1, w1);
671	callouts.PI_openers = simd_and(LAngle_scope, lex.QMark);
672	callouts.CtCD_openers = simd<1>::constant<0>();
673	CtCDPI_opener = simd_or(simd_and(LAngle_scope, lex.Exclam), callouts.PI_openers);
674	CD_closer = simd<1>::constant<0>();
675	DoubleHyphen = simd_and(simd_and(v1, w1), lex.Hyphen);
676	if ((bitblock::any(lex.RBracket) \|\| carryQ.CarryTest(2, 2))) {
677	tempvar0 = carryQ.BitBlock_advance_ci_co(lex.RBracket, carryQ.get_carry_in(2), 2);
678	DoubleRBracket = simd_and(tempvar0, lex.RBracket);
679	tempvar1 = carryQ.BitBlock_advance_ci_co(DoubleRBracket, carryQ.get_carry_in(3), 3);
680	CD_closer = simd_and(tempvar1, lex.RAngle);
681	}
682	else {
683	carryQ.CarryDequeueEnqueue(2, 2);
684	}
685	PI_closer = simd_and(simd_andc(w1, v1), lex.RAngle);
686	CtCDPI_Cursor = carryQ.BitBlock_scantofirst(CtCDPI_opener, carryQ.get_carry_in(4), 4);
687	if ((bitblock::any(CtCDPI_Cursor) \|\| carryQ.CarryTest(5, 14))) {
688	CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
689	PI_Cursor = simd_and(CtCDPI_Cursor, callouts.PI_openers);
690	CD_Ct_Cursor = carryQ.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), carryQ.get_carry_in(5), 5);
691	callouts.CtCD_openers = simd_or(callouts.CtCD_openers, CD_Ct_Cursor);
692	CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
693	Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
694	CD_Ct_Error = simd_andc(CD_Ct_Cursor, simd_or(lex.LBracket, lex.Hyphen));
695	errors.ExpectedCommentOrCDATA = simd_or(errors.ExpectedCommentOrCDATA, CD_Ct_Error);
696	if ((bitblock::any(PI_Cursor) \|\| carryQ.CarryTest(6, 5))) {
697	PI_Cursor = carryQ.BitBlock_advance_ci_co(PI_Cursor, carryQ.get_carry_in(6), 6);
698	PI_name_end = carryQ.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, carryQ.get_carry_in(7), 7);
699	PI_error = simd_and(PI_Cursor, PI_name_end);
700	errors.PINameExpected = simd_or(errors.PINameExpected, PI_error);
701	tempvar2 = carryQ.BitBlock_advance_ci_co(simd_andc(PI_name_end, lex.WS), carryQ.get_carry_in(8), 8);
702	PI_error = simd_andc(tempvar2, PI_closer);
703	errors.UnterminatedPI = simd_or(errors.UnterminatedPI, PI_error);
704	callouts.CtCDPI_content_starts = simd_or(callouts.CtCDPI_content_starts, PI_Cursor);
705	callouts.CtCDPI_closers = simd_or(callouts.CtCDPI_closers, PI_name_end);
706	tempvar3 = carryQ.BitBlock_scanthru_ci_co(PI_name_end, lex.WS, carryQ.get_carry_in(9), 9);
707	callouts.CtCDPI_content_starts = simd_or(callouts.CtCDPI_content_starts, tempvar3);
708	PI_Cursor = carryQ.BitBlock_scanthru_ci_co(PI_name_end, simd_not(PI_closer), carryQ.get_carry_in(10), 10);
709	}
710	else {
711	carryQ.CarryDequeueEnqueue(6, 5);
712	}
713	if ((bitblock::any(CD_Cursor) \|\| carryQ.CarryTest(11, 1))) {
714	callouts.CtCDPI_content_starts = simd_or(callouts.CtCDPI_content_starts, CD_Cursor);
715	CD_Cursor = carryQ.BitBlock_scanthru_ci_co(CD_Cursor, simd_not(CD_closer), carryQ.get_carry_in(11), 11);
716	}
717	else {
718	carryQ.CarryDequeueEnqueue(11, 1);
719	}
720	if ((bitblock::any(Ct_Cursor) \|\| carryQ.CarryTest(12, 5))) {
721	Ct_Cursor = carryQ.BitBlock_advance_ci_co(Ct_Cursor, carryQ.get_carry_in(12), 12);
722	Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
723	Ct_Cursor = carryQ.BitBlock_advance_ci_co(Ct_Cursor, carryQ.get_carry_in(13), 13);
724	callouts.CtCDPI_content_starts = simd_or(callouts.CtCDPI_content_starts, Ct_Cursor);
725	Ct_Cursor = carryQ.BitBlock_advance_ci_co(Ct_Cursor, carryQ.get_carry_in(14), 14);
726	tempvar4 = carryQ.BitBlock_scanthru_ci_co(Ct_Cursor, simd_not(DoubleHyphen), carryQ.get_carry_in(15), 15);
727	Ct_Cursor = carryQ.BitBlock_advance_ci_co(tempvar4, carryQ.get_carry_in(16), 16);
728	Ct_error = simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle));
729	errors.IllegalSequenceInComment = simd_or(errors.IllegalSequenceInComment, Ct_error);
730	}
731	else {
732	carryQ.CarryDequeueEnqueue(12, 5);
733	}
734	CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
735	callouts.CtCDPI_closers = simd_or(callouts.CtCDPI_closers, CtCDPI_Cursor);
736	tempvar5 = carryQ.BitBlock_inclusive_span(CtCDPI_starts, callouts.CtCDPI_closers, carryQ.get_carry_in(17), 17);
737	callouts.ctCDPI_mask = simd_or(callouts.ctCDPI_mask, tempvar5);
738	if (bitblock::any(simd<1>::constant<0>())) {
739	if (bitblock::any(simd<1>::constant<0>())) {
740	errors.UnterminatedPI = simd_or(errors.UnterminatedPI, PI_Cursor);
741	}
742	if (bitblock::any(simd<1>::constant<0>())) {
743	errors.UnterminatedCDATASection = simd_or(errors.UnterminatedCDATASection, CD_Cursor);
744	}
745	if (bitblock::any(simd<1>::constant<0>())) {
746	errors.UnterminatedComment = simd_or(errors.UnterminatedComment, Ct_Cursor);
747	}
748	}
749	CtCDPI_Cursor = carryQ.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_not(CtCDPI_opener), carryQ.get_carry_in(18), 18);
750	while (bitblock::any(CtCDPI_Cursor)) {
751	LocalCarryDeclare(subcarryQ, 14);
752	CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
753	PI_Cursor = simd_and(CtCDPI_Cursor, callouts.PI_openers);
754	CD_Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), simd<1>::constant<0>(), 0);
755	callouts.CtCD_openers = simd_or(callouts.CtCD_openers, CD_Ct_Cursor);
756	CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
757	Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
758	CD_Ct_Error = simd_andc(CD_Ct_Cursor, simd_or(lex.LBracket, lex.Hyphen));
759	errors.ExpectedCommentOrCDATA = simd_or(errors.ExpectedCommentOrCDATA, CD_Ct_Error);
760	if (bitblock::any(PI_Cursor)) {
761	PI_Cursor = subcarryQ.BitBlock_advance_ci_co(PI_Cursor, simd<1>::constant<0>(), 1);
762	PI_name_end = subcarryQ.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, simd<1>::constant<0>(), 2);
763	PI_error = simd_and(PI_Cursor, PI_name_end);
764	errors.PINameExpected = simd_or(errors.PINameExpected, PI_error);
765	tempvar2 = subcarryQ.BitBlock_advance_ci_co(simd_andc(PI_name_end, lex.WS), simd<1>::constant<0>(), 3);
766	PI_error = simd_andc(tempvar2, PI_closer);
767	errors.UnterminatedPI = simd_or(errors.UnterminatedPI, PI_error);
768	callouts.CtCDPI_content_starts = simd_or(callouts.CtCDPI_content_starts, PI_Cursor);
769	callouts.CtCDPI_closers = simd_or(callouts.CtCDPI_closers, PI_name_end);
770	tempvar3 = subcarryQ.BitBlock_scanthru_ci_co(PI_name_end, lex.WS, simd<1>::constant<0>(), 4);
771	callouts.CtCDPI_content_starts = simd_or(callouts.CtCDPI_content_starts, tempvar3);
772	PI_Cursor = subcarryQ.BitBlock_scanthru_ci_co(PI_name_end, simd_not(PI_closer), simd<1>::constant<0>(), 5);
773	}
774	else {
775	subcarryQ.CarryDequeueEnqueue(6, 5);
776	}
777	if (bitblock::any(CD_Cursor)) {
778	callouts.CtCDPI_content_starts = simd_or(callouts.CtCDPI_content_starts, CD_Cursor);
779	CD_Cursor = subcarryQ.BitBlock_scanthru_ci_co(CD_Cursor, simd_not(CD_closer), simd<1>::constant<0>(), 6);
780	}
781	else {
782	subcarryQ.CarryDequeueEnqueue(11, 1);
783	}
784	if (bitblock::any(Ct_Cursor)) {
785	Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 7);
786	Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
787	Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 8);
788	callouts.CtCDPI_content_starts = simd_or(callouts.CtCDPI_content_starts, Ct_Cursor);
789	Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 9);
790	tempvar4 = subcarryQ.BitBlock_scanthru_ci_co(Ct_Cursor, simd_not(DoubleHyphen), simd<1>::constant<0>(), 10);
791	Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(tempvar4, simd<1>::constant<0>(), 11);
792	Ct_error = simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle));
793	errors.IllegalSequenceInComment = simd_or(errors.IllegalSequenceInComment, Ct_error);
794	}
795	else {
796	subcarryQ.CarryDequeueEnqueue(12, 5);
797	}
798	CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
799	callouts.CtCDPI_closers = simd_or(callouts.CtCDPI_closers, CtCDPI_Cursor);
800	tempvar5 = subcarryQ.BitBlock_inclusive_span(CtCDPI_starts, callouts.CtCDPI_closers, simd<1>::constant<0>(), 12);
801	callouts.ctCDPI_mask = simd_or(callouts.ctCDPI_mask, tempvar5);
802	if (bitblock::any(simd<1>::constant<0>())) {
803	if (bitblock::any(simd<1>::constant<0>())) {
804	errors.UnterminatedPI = simd_or(errors.UnterminatedPI, PI_Cursor);
805	}
806	if (bitblock::any(simd<1>::constant<0>())) {
807	errors.UnterminatedCDATASection = simd_or(errors.UnterminatedCDATASection, CD_Cursor);
808	}
809	if (bitblock::any(simd<1>::constant<0>())) {
810	errors.UnterminatedComment = simd_or(errors.UnterminatedComment, Ct_Cursor);
811	}
812	}
813	CtCDPI_Cursor = subcarryQ.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_not(CtCDPI_opener), simd<1>::constant<0>(), 13);
814	carryQ.CarryCombine(subcarryQ.cq, 5, 14);
815	}
816	carryQ.CarryCombine1(4, 18);
817	}
818	else {
819	carryQ.CarryDequeueEnqueue(5, 14);
820	}
821	marker.LAngle = simd_andc(lex.LAngle, callouts.ctCDPI_mask);
822	marker.Tag_opener = simd_andc(LAngle_scope, callouts.ctCDPI_mask);
823	marker.Ref_opener = simd_andc(lex.RefStart, callouts.ctCDPI_mask);
824	marker.CD_closer = simd_andc(CD_closer, callouts.ctCDPI_mask);
825	carryQ.CarryQ_Adjust(19);
826	}
827	IDISA_ALWAYS_INLINE void do_final_block(Lex & lex, Marker & marker, Callouts & callouts, Errors & errors, BitBlock EOF_mask) {
828	BitBlock CtCDPI_starts, v, w, v1, w1, LAngle_scope, CtCDPI_opener, CD_closer;
829	BitBlock DoubleHyphen, DoubleRBracket, PI_closer, CtCDPI_Cursor, PI_Cursor;
830	BitBlock CD_Ct_Cursor, CD_Cursor, Ct_Cursor, CD_Ct_Error, PI_name_end;
831	BitBlock PI_error, Ct_error;
832
833	BitBlock tempvar0, tempvar1, tempvar2, tempvar3, tempvar4, tempvar5;
834
835
836	callouts.Symbol_starts = simd<1>::constant<0>();
837	callouts.Symbol_ends = simd<1>::constant<0>();
838	callouts.CtCDPI_content_starts = simd<1>::constant<0>();
839	callouts.CtCDPI_closers = simd<1>::constant<0>();
840	callouts.delmask = simd<1>::constant<0>();
841	callouts.ctCDPI_mask = simd<1>::constant<0>();
842	errors.ExpectedCommentOrCDATA = simd<1>::constant<0>();
843	errors.PINameExpected = simd<1>::constant<0>();
844	errors.IllegalSequenceInComment = simd<1>::constant<0>();
845	errors.UnterminatedPI = simd<1>::constant<0>();
846	errors.UnterminatedCDATASection = simd<1>::constant<0>();
847	errors.UnterminatedComment = simd<1>::constant<0>();
848	CtCDPI_starts = simd<1>::constant<0>();
849	v = simd_or(lex.LAngle, lex.Hyphen);
850	w = simd_or(lex.Hyphen, lex.QMark);
851	v1 = carryQ.BitBlock_advance_ci_co(v, carryQ.get_carry_in(0), 0);
852	w1 = carryQ.BitBlock_advance_ci_co(w, carryQ.get_carry_in(1), 1);
853	LAngle_scope = simd_andc(v1, w1);
854	callouts.PI_openers = simd_and(LAngle_scope, lex.QMark);
855	callouts.CtCD_openers = simd<1>::constant<0>();
856	CtCDPI_opener = simd_or(simd_and(LAngle_scope, lex.Exclam), callouts.PI_openers);
857	CD_closer = simd<1>::constant<0>();
858	DoubleHyphen = simd_and(simd_and(v1, w1), lex.Hyphen);
859	if ((bitblock::any(lex.RBracket) \|\| carryQ.CarryTest(2, 2))) {
860	tempvar0 = carryQ.BitBlock_advance_ci_co(lex.RBracket, carryQ.get_carry_in(2), 2);
861	DoubleRBracket = simd_and(tempvar0, lex.RBracket);
862	tempvar1 = carryQ.BitBlock_advance_ci_co(DoubleRBracket, carryQ.get_carry_in(3), 3);
863	CD_closer = simd_and(tempvar1, lex.RAngle);
864	}
865	else {
866	carryQ.CarryDequeueEnqueue(2, 2);
867	}
868	PI_closer = simd_and(simd_andc(w1, v1), lex.RAngle);
869	CtCDPI_Cursor = carryQ.BitBlock_scantofirst(CtCDPI_opener, carryQ.get_carry_in(4), 4);
870	if ((bitblock::any(simd_and(CtCDPI_Cursor, EOF_mask)) \|\| carryQ.CarryTest(5, 14))) {
871	CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
872	PI_Cursor = simd_and(CtCDPI_Cursor, callouts.PI_openers);
873	CD_Ct_Cursor = carryQ.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), carryQ.get_carry_in(5), 5);
874	callouts.CtCD_openers = simd_or(callouts.CtCD_openers, CD_Ct_Cursor);
875	CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
876	Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
877	CD_Ct_Error = simd_andc(CD_Ct_Cursor, simd_or(lex.LBracket, lex.Hyphen));
878	errors.ExpectedCommentOrCDATA = simd_or(errors.ExpectedCommentOrCDATA, CD_Ct_Error);
879	if ((bitblock::any(PI_Cursor) \|\| carryQ.CarryTest(6, 5))) {
880	PI_Cursor = carryQ.BitBlock_advance_ci_co(PI_Cursor, carryQ.get_carry_in(6), 6);
881	PI_name_end = carryQ.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, carryQ.get_carry_in(7), 7);
882	PI_error = simd_and(PI_Cursor, PI_name_end);
883	errors.PINameExpected = simd_or(errors.PINameExpected, PI_error);
884	tempvar2 = carryQ.BitBlock_advance_ci_co(simd_andc(PI_name_end, lex.WS), carryQ.get_carry_in(8), 8);
885	PI_error = simd_andc(tempvar2, PI_closer);
886	errors.UnterminatedPI = simd_or(errors.UnterminatedPI, PI_error);
887	callouts.CtCDPI_content_starts = simd_or(callouts.CtCDPI_content_starts, PI_Cursor);
888	callouts.CtCDPI_closers = simd_or(callouts.CtCDPI_closers, PI_name_end);
889	tempvar3 = carryQ.BitBlock_scanthru_ci_co(PI_name_end, lex.WS, carryQ.get_carry_in(9), 9);
890	callouts.CtCDPI_content_starts = simd_or(callouts.CtCDPI_content_starts, tempvar3);
891	PI_Cursor = carryQ.BitBlock_scanthru_ci_co(PI_name_end, simd_andc(EOF_mask, PI_closer), carryQ.get_carry_in(10), 10);
892	}
893	else {
894	carryQ.CarryDequeueEnqueue(6, 5);
895	}
896	if ((bitblock::any(CD_Cursor) \|\| carryQ.CarryTest(11, 1))) {
897	callouts.CtCDPI_content_starts = simd_or(callouts.CtCDPI_content_starts, CD_Cursor);
898	CD_Cursor = carryQ.BitBlock_scanthru_ci_co(CD_Cursor, simd_andc(EOF_mask, CD_closer), carryQ.get_carry_in(11), 11);
899	}
900	else {
901	carryQ.CarryDequeueEnqueue(11, 1);
902	}
903	if ((bitblock::any(Ct_Cursor) \|\| carryQ.CarryTest(12, 5))) {
904	Ct_Cursor = carryQ.BitBlock_advance_ci_co(Ct_Cursor, carryQ.get_carry_in(12), 12);
905	Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
906	Ct_Cursor = carryQ.BitBlock_advance_ci_co(Ct_Cursor, carryQ.get_carry_in(13), 13);
907	callouts.CtCDPI_content_starts = simd_or(callouts.CtCDPI_content_starts, Ct_Cursor);
908	Ct_Cursor = carryQ.BitBlock_advance_ci_co(Ct_Cursor, carryQ.get_carry_in(14), 14);
909	tempvar4 = carryQ.BitBlock_scanthru_ci_co(Ct_Cursor, simd_andc(EOF_mask, DoubleHyphen), carryQ.get_carry_in(15), 15);
910	Ct_Cursor = carryQ.BitBlock_advance_ci_co(tempvar4, carryQ.get_carry_in(16), 16);
911	Ct_error = simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle));
912	errors.IllegalSequenceInComment = simd_or(errors.IllegalSequenceInComment, Ct_error);
913	}
914	else {
915	carryQ.CarryDequeueEnqueue(12, 5);
916	}
917	CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
918	callouts.CtCDPI_closers = simd_or(callouts.CtCDPI_closers, CtCDPI_Cursor);
919	tempvar5 = carryQ.BitBlock_inclusive_span(CtCDPI_starts, callouts.CtCDPI_closers, carryQ.get_carry_in(17), 17);
920	callouts.ctCDPI_mask = simd_or(callouts.ctCDPI_mask, tempvar5);
921	if (bitblock::any(simd_andc(callouts.ctCDPI_mask, EOF_mask))) {
922	if (bitblock::any(simd_andc(PI_Cursor, EOF_mask))) {
923	errors.UnterminatedPI = simd_or(errors.UnterminatedPI, PI_Cursor);
924	}
925	if (bitblock::any(simd_andc(CD_Cursor, EOF_mask))) {
926	errors.UnterminatedCDATASection = simd_or(errors.UnterminatedCDATASection, CD_Cursor);
927	}
928	if (bitblock::any(simd_andc(Ct_Cursor, EOF_mask))) {
929	errors.UnterminatedComment = simd_or(errors.UnterminatedComment, Ct_Cursor);
930	}
931	}
932	CtCDPI_Cursor = carryQ.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_andc(EOF_mask, CtCDPI_opener), carryQ.get_carry_in(18), 18);
933	while (bitblock::any(simd_and(CtCDPI_Cursor, EOF_mask))) {
934	LocalCarryDeclare(subcarryQ, 14);
935	CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
936	PI_Cursor = simd_and(CtCDPI_Cursor, callouts.PI_openers);
937	CD_Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), simd<1>::constant<0>(), 0);
938	callouts.CtCD_openers = simd_or(callouts.CtCD_openers, CD_Ct_Cursor);
939	CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
940	Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
941	CD_Ct_Error = simd_andc(CD_Ct_Cursor, simd_or(lex.LBracket, lex.Hyphen));
942	errors.ExpectedCommentOrCDATA = simd_or(errors.ExpectedCommentOrCDATA, CD_Ct_Error);
943	if (bitblock::any(PI_Cursor)) {
944	PI_Cursor = subcarryQ.BitBlock_advance_ci_co(PI_Cursor, simd<1>::constant<0>(), 1);
945	PI_name_end = subcarryQ.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, simd<1>::constant<0>(), 2);
946	PI_error = simd_and(PI_Cursor, PI_name_end);
947	errors.PINameExpected = simd_or(errors.PINameExpected, PI_error);
948	tempvar2 = subcarryQ.BitBlock_advance_ci_co(simd_andc(PI_name_end, lex.WS), simd<1>::constant<0>(), 3);
949	PI_error = simd_andc(tempvar2, PI_closer);
950	errors.UnterminatedPI = simd_or(errors.UnterminatedPI, PI_error);
951	callouts.CtCDPI_content_starts = simd_or(callouts.CtCDPI_content_starts, PI_Cursor);
952	callouts.CtCDPI_closers = simd_or(callouts.CtCDPI_closers, PI_name_end);
953	tempvar3 = subcarryQ.BitBlock_scanthru_ci_co(PI_name_end, lex.WS, simd<1>::constant<0>(), 4);
954	callouts.CtCDPI_content_starts = simd_or(callouts.CtCDPI_content_starts, tempvar3);
955	PI_Cursor = subcarryQ.BitBlock_scanthru_ci_co(PI_name_end, simd_andc(EOF_mask, PI_closer), simd<1>::constant<0>(), 5);
956	}
957	else {
958	subcarryQ.CarryDequeueEnqueue(6, 5);
959	}
960	if (bitblock::any(CD_Cursor)) {
961	callouts.CtCDPI_content_starts = simd_or(callouts.CtCDPI_content_starts, CD_Cursor);
962	CD_Cursor = subcarryQ.BitBlock_scanthru_ci_co(CD_Cursor, simd_andc(EOF_mask, CD_closer), simd<1>::constant<0>(), 6);
963	}
964	else {
965	subcarryQ.CarryDequeueEnqueue(11, 1);
966	}
967	if (bitblock::any(Ct_Cursor)) {
968	Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 7);
969	Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
970	Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 8);
971	callouts.CtCDPI_content_starts = simd_or(callouts.CtCDPI_content_starts, Ct_Cursor);
972	Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 9);
973	tempvar4 = subcarryQ.BitBlock_scanthru_ci_co(Ct_Cursor, simd_andc(EOF_mask, DoubleHyphen), simd<1>::constant<0>(), 10);
974	Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(tempvar4, simd<1>::constant<0>(), 11);
975	Ct_error = simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle));
976	errors.IllegalSequenceInComment = simd_or(errors.IllegalSequenceInComment, Ct_error);
977	}
978	else {
979	subcarryQ.CarryDequeueEnqueue(12, 5);
980	}
981	CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
982	callouts.CtCDPI_closers = simd_or(callouts.CtCDPI_closers, CtCDPI_Cursor);
983	tempvar5 = subcarryQ.BitBlock_inclusive_span(CtCDPI_starts, callouts.CtCDPI_closers, simd<1>::constant<0>(), 12);
984	callouts.ctCDPI_mask = simd_or(callouts.ctCDPI_mask, tempvar5);
985	if (bitblock::any(simd_andc(callouts.ctCDPI_mask, EOF_mask))) {
986	if (bitblock::any(simd_andc(PI_Cursor, EOF_mask))) {
987	errors.UnterminatedPI = simd_or(errors.UnterminatedPI, PI_Cursor);
988	}
989	if (bitblock::any(simd_andc(CD_Cursor, EOF_mask))) {
990	errors.UnterminatedCDATASection = simd_or(errors.UnterminatedCDATASection, CD_Cursor);
991	}
992	if (bitblock::any(simd_andc(Ct_Cursor, EOF_mask))) {
993	errors.UnterminatedComment = simd_or(errors.UnterminatedComment, Ct_Cursor);
994	}
995	}
996	CtCDPI_Cursor = subcarryQ.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_andc(EOF_mask, CtCDPI_opener), simd<1>::constant<0>(), 13);
997	carryQ.CarryCombine(subcarryQ.cq, 5, 14);
998	}
999	}
1000	else {
1001	carryQ.CarryDequeueEnqueue(5, 14);
1002	}
1003	marker.LAngle = simd_andc(lex.LAngle, callouts.ctCDPI_mask);
1004	marker.Tag_opener = simd_andc(LAngle_scope, callouts.ctCDPI_mask);
1005	marker.Ref_opener = simd_andc(lex.RefStart, callouts.ctCDPI_mask);
1006	marker.CD_closer = simd_andc(CD_closer, callouts.ctCDPI_mask);
1007	}
1008	void do_segment(Lex lex[], Marker marker[], Callouts callouts[], Errors errors[], int segment_blocks) {
1009	int i;
1010	for (i = 0; i < segment_blocks; i++)
1011	do_block(lex[i], marker[i], callouts[i], errors[i]);
1012	}
1013	CarryArray<19, 0> carryQ;
1014	};
1015
1016	struct Check_CD_end_error {
1017
1018	IDISA_ALWAYS_INLINE void do_block(Marker & marker, Callouts & callouts, Errors & errors) {
1019	BitBlock CD_end_error;
1020
1021
1022
1023
1024	CD_end_error = simd_andc(marker.CD_closer, callouts.AttValSpan);
1025	errors.BadSequenceInCharData = CD_end_error;
1026	}
1027	IDISA_ALWAYS_INLINE void do_final_block(Marker & marker, Callouts & callouts, Errors & errors, BitBlock EOF_mask) {
1028	BitBlock CD_end_error;
1029
1030
1031
1032
1033	CD_end_error = simd_andc(marker.CD_closer, callouts.AttValSpan);
1034	errors.BadSequenceInCharData = CD_end_error;
1035	}
1036	void do_segment(Marker marker[], Callouts callouts[], Errors errors[], int segment_blocks) {
1037	int i;
1038	for (i = 0; i < segment_blocks; i++)
1039	do_block(marker[i], callouts[i], errors[i]);
1040	}
1041
1042	};
1043
1044	struct Prepare_content_buffer {
1045	Prepare_content_buffer() {
1046	}
1047	IDISA_ALWAYS_INLINE void do_block(U16hi & u16hi, U16lo & u16lo, Lex & lex, Callouts & callouts, Marker & marker) {
1048	BitBlock CtCDPI_openers, transition_marks, zeromask;
1049
1050	BitBlock tempvar0, tempvar1;
1051
1052
1053	CtCDPI_openers = simd_or(callouts.PI_openers, callouts.CtCD_openers);
1054	transition_marks = simd_or(simd_or(simd_or(simd_or(CtCDPI_openers, callouts.AttEq_marks), callouts.StartTag_closers), callouts.EmptyTag_closers), callouts.EndTag_marks);
1055	callouts.MarkupDelimiters = simd_or(callouts.Tag_closers, callouts.CtCDPI_closers);
1056	callouts.StringEnds = simd_or(simd_or(callouts.CtCDPI_closers, callouts.AttCloseQuotes), marker.LAngle);
1057	callouts.delmask = simd_or(callouts.delmask, simd_andc(callouts.TagSpan, simd_or(simd_or(callouts.AttValSpan, transition_marks), callouts.StringEnds)));
1058	tempvar0 = carryQ.BitBlock_exclusive_span(CtCDPI_openers, callouts.CtCDPI_content_starts, carryQ.get_carry_in(0), 0);
1059	callouts.delmask = simd_or(callouts.delmask, tempvar0);
1060	tempvar1 = carryQ.BitBlock_advance_ci_co(marker.LAngle, carryQ.get_carry_in(1), 1);
1061	callouts.delmask = simd_or(callouts.delmask, simd_and(tempvar1, lex.Exclam));
1062	zeromask = simd_or(simd_or(callouts.delmask, callouts.StringEnds), transition_marks);
1063	u16hi.bit_0 = simd_andc(u16hi.bit_0, zeromask);
1064	u16hi.bit_1 = simd_andc(u16hi.bit_1, zeromask);
1065	u16hi.bit_2 = simd_andc(u16hi.bit_2, zeromask);
1066	u16hi.bit_3 = simd_andc(u16hi.bit_3, zeromask);
1067	u16hi.bit_4 = simd_andc(u16hi.bit_4, zeromask);
1068	u16hi.bit_5 = simd_andc(u16hi.bit_5, zeromask);
1069	u16hi.bit_6 = simd_andc(u16hi.bit_6, zeromask);
1070	u16hi.bit_7 = simd_andc(u16hi.bit_7, zeromask);
1071	u16lo.bit_0 = simd_andc(u16lo.bit_0, zeromask);
1072	u16lo.bit_1 = simd_andc(u16lo.bit_1, zeromask);
1073	u16lo.bit_2 = simd_andc(u16lo.bit_2, simd_or(zeromask, marker.Ref_opener));
1074	u16lo.bit_3 = simd_andc(u16lo.bit_3, zeromask);
1075	u16lo.bit_4 = simd_andc(u16lo.bit_4, simd_xor(zeromask, callouts.EmptyTag_closers));
1076	u16lo.bit_5 = simd_or(simd_andc(u16lo.bit_5, zeromask), CtCDPI_openers);
1077	u16lo.bit_6 = simd_andc(u16lo.bit_6, simd_xor(simd_xor(zeromask, callouts.EndTag_marks), callouts.CtCD_openers));
1078	u16lo.bit_7 = simd_andc(u16lo.bit_7, simd_xor(simd_xor(zeromask, callouts.CtCD_openers), callouts.AttEq_marks));
1079	carryQ.CarryQ_Adjust(2);
1080	}
1081	IDISA_ALWAYS_INLINE void do_final_block(U16hi & u16hi, U16lo & u16lo, Lex & lex, Callouts & callouts, Marker & marker, BitBlock EOF_mask) {
1082	BitBlock CtCDPI_openers, transition_marks, zeromask;
1083
1084	BitBlock tempvar0, tempvar1;
1085
1086
1087	CtCDPI_openers = simd_or(callouts.PI_openers, callouts.CtCD_openers);
1088	transition_marks = simd_or(simd_or(simd_or(simd_or(CtCDPI_openers, callouts.AttEq_marks), callouts.StartTag_closers), callouts.EmptyTag_closers), callouts.EndTag_marks);
1089	callouts.MarkupDelimiters = simd_or(callouts.Tag_closers, callouts.CtCDPI_closers);
1090	callouts.StringEnds = simd_or(simd_or(callouts.CtCDPI_closers, callouts.AttCloseQuotes), marker.LAngle);
1091	callouts.delmask = simd_or(callouts.delmask, simd_andc(callouts.TagSpan, simd_or(simd_or(callouts.AttValSpan, transition_marks), callouts.StringEnds)));
1092	tempvar0 = carryQ.BitBlock_exclusive_span(CtCDPI_openers, callouts.CtCDPI_content_starts, carryQ.get_carry_in(0), 0);
1093	callouts.delmask = simd_or(callouts.delmask, tempvar0);
1094	tempvar1 = carryQ.BitBlock_advance_ci_co(marker.LAngle, carryQ.get_carry_in(1), 1);
1095	callouts.delmask = simd_or(callouts.delmask, simd_and(tempvar1, lex.Exclam));
1096	zeromask = simd_or(simd_or(callouts.delmask, callouts.StringEnds), transition_marks);
1097	u16hi.bit_0 = simd_andc(u16hi.bit_0, zeromask);
1098	u16hi.bit_1 = simd_andc(u16hi.bit_1, zeromask);
1099	u16hi.bit_2 = simd_andc(u16hi.bit_2, zeromask);
1100	u16hi.bit_3 = simd_andc(u16hi.bit_3, zeromask);
1101	u16hi.bit_4 = simd_andc(u16hi.bit_4, zeromask);
1102	u16hi.bit_5 = simd_andc(u16hi.bit_5, zeromask);
1103	u16hi.bit_6 = simd_andc(u16hi.bit_6, zeromask);
1104	u16hi.bit_7 = simd_andc(u16hi.bit_7, zeromask);
1105	u16lo.bit_0 = simd_andc(u16lo.bit_0, zeromask);
1106	u16lo.bit_1 = simd_andc(u16lo.bit_1, zeromask);
1107	u16lo.bit_2 = simd_andc(u16lo.bit_2, simd_or(zeromask, marker.Ref_opener));
1108	u16lo.bit_3 = simd_andc(u16lo.bit_3, zeromask);
1109	u16lo.bit_4 = simd_andc(u16lo.bit_4, simd_xor(zeromask, callouts.EmptyTag_closers));
1110	u16lo.bit_5 = simd_or(simd_andc(u16lo.bit_5, zeromask), CtCDPI_openers);
1111	u16lo.bit_6 = simd_andc(u16lo.bit_6, simd_xor(simd_xor(zeromask, callouts.EndTag_marks), callouts.CtCD_openers));
1112	u16lo.bit_7 = simd_andc(u16lo.bit_7, simd_xor(simd_xor(zeromask, callouts.CtCD_openers), callouts.AttEq_marks));
1113	}
1114	void do_segment(U16hi u16hi[], U16lo u16lo[], Lex lex[], Callouts callouts[], Marker marker[], int segment_blocks) {
1115	int i;
1116	for (i = 0; i < segment_blocks; i++)
1117	do_block(u16hi[i], u16lo[i], lex[i], callouts[i], marker[i]);
1118	}
1119	CarryArray<2, 0> carryQ;
1120	};
1121
1122
1123	Parse_refs parse_refs;
1124	Parse_tags parse_tags;
1125	Init_Parameters init_Parameters;
1126	Parse_CtCDPI parse_CtCDPI;
1127	Check_CD_end_error check_CD_end_error;
1128	Prepare_content_buffer prepare_content_buffer;
1129
1130	struct Classify_bytes {
1131	Classify_bytes() {
1132	}
1133	IDISA_ALWAYS_INLINE void do_block(Parameters & parameters, U16hi & u16hi, U16lo & u16lo, Lex & lex, Callouts & callouts, Errors & errors) {
1134	BitBlock u16hitemp1, u16hitemp2, u16hitemp3, u16hitemp4, u16hitemp5;
1135	BitBlock u16hitemp6, u16hitemp7, u16hi_x00, u16hitemp8, u16hitemp9;
1136	BitBlock u16hitemp10, u16hitemp11, u16hi_hi_surrogate, u16hitemp12;
1137	BitBlock u16hi_lo_surrogate, u16hitemp13, u16hitemp14, u16hitemp15;
1138	BitBlock u16hitemp16, u16hi_xFF, u16hitemp17, u16hitemp18, u16hi_x20, temp1;
1139	BitBlock temp2, temp3, temp4, temp5, xFE_FF, temp6, temp7, x00_x1F, temp8;
1140	BitBlock temp9, temp10, temp11, temp12, temp13, temp14, temp15, temp16, temp17;
1141	BitBlock temp18, temp19, temp20, temp21, temp22, temp23, temp24, temp25;
1142	BitBlock temp26, temp27, temp28, temp29, temp30, temp31, temp32, temp33;
1143	BitBlock temp34, temp35, temp36, temp37, temp38, temp39, temp40, temp41;
1144	BitBlock temp42, temp43, temp44, temp45, temp46, temp47, temp48, temp49;
1145	BitBlock temp50, temp51, temp52, temp53, temp54, temp55, temp56, temp57;
1146	BitBlock temp58, temp59, temp60, temp61, temp62, DEL, temp63, x80_x9F, temp64;
1147	BitBlock temp65, x28, FFFE_FFFF, lexError;
1148
1149	BitBlock tempvar0;
1150
1151
1152	u16hitemp1 = simd_or(u16hi.bit_0, u16hi.bit_1);
1153	u16hitemp2 = simd_or(u16hi.bit_2, u16hi.bit_3);
1154	u16hitemp3 = simd_or(u16hitemp1, u16hitemp2);
1155	u16hitemp4 = simd_or(u16hi.bit_4, u16hi.bit_5);
1156	u16hitemp5 = simd_or(u16hi.bit_6, u16hi.bit_7);
1157	u16hitemp6 = simd_or(u16hitemp4, u16hitemp5);
1158	u16hitemp7 = simd_or(u16hitemp3, u16hitemp6);
1159	u16hi_x00 = simd_not(u16hitemp7);
1160	u16hitemp8 = simd_and(u16hi.bit_0, u16hi.bit_1);
1161	u16hitemp9 = simd_andc(u16hi.bit_3, u16hi.bit_2);
1162	u16hitemp10 = simd_and(u16hitemp8, u16hitemp9);
1163	u16hitemp11 = simd_andc(u16hi.bit_4, u16hi.bit_5);
1164	u16hi_hi_surrogate = simd_and(u16hitemp10, u16hitemp11);
1165	u16hitemp12 = simd_and(u16hi.bit_4, u16hi.bit_5);
1166	u16hi_lo_surrogate = simd_and(u16hitemp10, u16hitemp12);
1167	u16hitemp13 = simd_and(u16hi.bit_2, u16hi.bit_3);
1168	u16hitemp14 = simd_and(u16hitemp8, u16hitemp13);
1169	u16hitemp15 = simd_and(u16hi.bit_6, u16hi.bit_7);
1170	u16hitemp16 = simd_and(u16hitemp12, u16hitemp15);
1171	u16hi_xFF = simd_and(u16hitemp14, u16hitemp16);
1172	u16hitemp17 = simd_andc(u16hi.bit_2, u16hi.bit_3);
1173	u16hitemp18 = simd_andc(u16hitemp17, u16hitemp1);
1174	u16hi_x20 = simd_andc(u16hitemp18, u16hitemp6);
1175	temp1 = simd_and(u16lo.bit_0, u16lo.bit_1);
1176	temp2 = simd_and(u16lo.bit_2, u16lo.bit_3);
1177	temp3 = simd_and(temp1, temp2);
1178	temp4 = simd_and(u16lo.bit_4, u16lo.bit_5);
1179	temp5 = simd_and(temp4, u16lo.bit_6);
1180	xFE_FF = simd_and(temp3, temp5);
1181	temp6 = simd_or(u16lo.bit_0, u16lo.bit_1);
1182	temp7 = simd_or(temp6, u16lo.bit_2);
1183	x00_x1F = simd_not(temp7);
1184	temp8 = simd_or(u16lo.bit_2, u16lo.bit_3);
1185	temp9 = simd_or(temp6, temp8);
1186	temp10 = simd_andc(u16lo.bit_7, u16lo.bit_6);
1187	temp11 = simd_and(temp4, temp10);
1188	lex.CR = simd_andc(temp11, temp9);
1189	temp12 = simd_andc(u16lo.bit_4, u16lo.bit_5);
1190	temp13 = simd_andc(u16lo.bit_6, u16lo.bit_7);
1191	temp14 = simd_and(temp12, temp13);
1192	lex.LF = simd_andc(temp14, temp9);
1193	temp15 = simd_or(temp11, temp14);
1194	temp16 = simd_and(temp12, temp10);
1195	temp17 = simd_or(temp15, temp16);
1196	temp18 = simd_andc(temp17, temp9);
1197	temp19 = simd_andc(u16lo.bit_2, u16lo.bit_3);
1198	temp20 = simd_andc(temp19, temp6);
1199	temp21 = simd_or(u16lo.bit_4, u16lo.bit_5);
1200	temp22 = simd_or(u16lo.bit_6, u16lo.bit_7);
1201	temp23 = simd_or(temp21, temp22);
1202	temp24 = simd_andc(temp20, temp23);
1203	lex.WS = simd_or(temp18, temp24);
1204	temp25 = simd_andc(u16lo.bit_5, u16lo.bit_4);
1205	temp26 = simd_and(temp25, temp13);
1206	lex.RefStart = simd_and(temp20, temp26);
1207	temp27 = simd_andc(temp2, temp6);
1208	temp28 = simd_and(u16lo.bit_6, u16lo.bit_7);
1209	temp29 = simd_and(temp12, temp28);
1210	lex.Semicolon = simd_and(temp27, temp29);
1211	temp30 = simd_andc(temp4, temp22);
1212	lex.LAngle = simd_and(temp27, temp30);
1213	temp31 = simd_and(temp4, temp13);
1214	lex.RAngle = simd_and(temp27, temp31);
1215	temp32 = simd_andc(u16lo.bit_1, u16lo.bit_0);
1216	temp33 = simd_andc(u16lo.bit_3, u16lo.bit_2);
1217	temp34 = simd_and(temp32, temp33);
1218	lex.LBracket = simd_and(temp34, temp29);
1219	lex.RBracket = simd_and(temp34, temp11);
1220	temp35 = simd_andc(temp10, temp21);
1221	lex.Exclam = simd_and(temp20, temp35);
1222	temp36 = simd_and(temp4, temp28);
1223	lex.QMark = simd_and(temp27, temp36);
1224	lex.Hyphen = simd_and(temp20, temp11);
1225	lex.Equals = simd_and(temp27, temp11);
1226	temp37 = simd_and(temp25, temp28);
1227	lex.SQuote = simd_and(temp20, temp37);
1228	temp38 = simd_andc(temp13, temp21);
1229	lex.DQuote = simd_and(temp20, temp38);
1230	lex.Slash = simd_and(temp20, temp36);
1231	temp39 = simd_andc(temp28, temp21);
1232	lex.Hash = simd_and(temp20, temp39);
1233	temp40 = simd_and(temp34, temp36);
1234	temp41 = simd_or(lex.Hyphen, temp40);
1235	temp42 = simd_and(temp20, temp31);
1236	temp43 = simd_or(temp41, temp42);
1237	temp44 = simd_or(u16lo.bit_5, temp28);
1238	temp45 = simd_and(u16lo.bit_4, temp44);
1239	temp46 = simd_andc(temp27, temp45);
1240	temp47 = simd_or(temp43, temp46);
1241	temp48 = simd_andc(temp32, u16lo.bit_2);
1242	temp49 = simd_not(temp45);
1243	temp50 = simd_or(simd_and(u16lo.bit_3, temp49), simd_andc(temp23, u16lo.bit_3));
1244	temp51 = simd_and(temp48, temp50);
1245	temp52 = simd_or(temp47, temp51);
1246	temp53 = simd_and(temp32, u16lo.bit_2);
1247	temp54 = simd_and(temp53, temp50);
1248	lex.NameScan = simd_or(temp52, temp54);
1249	temp55 = simd_and(temp25, temp10);
1250	lex.Pct = simd_and(temp20, temp55);
1251	temp56 = simd_and(temp20, temp14);
1252	temp57 = simd_or(temp56, lex.QMark);
1253	temp58 = simd_and(temp20, temp29);
1254	lex.RepOp = simd_or(temp57, temp58);
1255	temp59 = simd_andc(u16lo.bit_4, temp22);
1256	temp60 = simd_and(temp20, temp59);
1257	temp61 = simd_and(temp32, temp2);
1258	temp62 = simd_and(temp61, temp30);
1259	lex.LContentDelim = simd_or(temp60, temp62);
1260	DEL = simd_and(temp61, temp36);
1261	temp63 = simd_andc(u16lo.bit_0, u16lo.bit_1);
1262	x80_x9F = simd_andc(temp63, u16lo.bit_2);
1263	temp64 = simd_andc(temp63, temp8);
1264	lex.NEL = simd_and(temp64, temp55);
1265	temp65 = simd_andc(temp12, temp22);
1266	x28 = simd_and(temp20, temp65);
1267	lex.LS = simd_and(u16hi_x20, x28);
1268	FFFE_FFFF = simd_and(u16hi_xFF, xFE_FF);
1269	errors.Unicode = simd<1>::constant<0>();
1270	errors.Lexical = simd<1>::constant<0>();
1271	if ((bitblock::any(simd_not(u16hi_x00)) \|\| carryQ.CarryTest(0, 1))) {
1272	if ((bitblock::any(simd_or(u16hi_hi_surrogate, u16hi_lo_surrogate)) \|\| carryQ.CarryTest(0, 1))) {
1273	tempvar0 = carryQ.BitBlock_advance_ci_co(u16hi_hi_surrogate, carryQ.get_carry_in(0), 0);
1274	errors.Unicode = simd_xor(tempvar0, u16hi_lo_surrogate);
1275	}
1276	else {
1277	carryQ.CarryDequeueEnqueue(0, 1);
1278	}
1279	lex.CR = simd_and(lex.CR, u16hi_x00);
1280	lex.LF = simd_and(lex.LF, u16hi_x00);
1281	lex.WS = simd_and(lex.WS, u16hi_x00);
1282	lex.RefStart = simd_and(lex.RefStart, u16hi_x00);
1283	lex.Semicolon = simd_and(lex.Semicolon, u16hi_x00);
1284	lex.LAngle = simd_and(lex.LAngle, u16hi_x00);
1285	lex.RAngle = simd_and(lex.RAngle, u16hi_x00);
1286	lex.LBracket = simd_and(lex.LBracket, u16hi_x00);
1287	lex.RBracket = simd_and(lex.RBracket, u16hi_x00);
1288	lex.Exclam = simd_and(lex.Exclam, u16hi_x00);
1289	lex.QMark = simd_and(lex.QMark, u16hi_x00);
1290	lex.Hyphen = simd_and(lex.Hyphen, u16hi_x00);
1291	lex.Equals = simd_and(lex.Equals, u16hi_x00);
1292	lex.SQuote = simd_and(lex.SQuote, u16hi_x00);
1293	lex.DQuote = simd_and(lex.DQuote, u16hi_x00);
1294	lex.Slash = simd_and(lex.Slash, u16hi_x00);
1295	lex.Hash = simd_and(lex.Hash, u16hi_x00);
1296	lex.NameScan = simd_and(lex.NameScan, u16hi_x00);
1297	lex.NEL = simd_and(lex.NEL, u16hi_x00);
1298	x00_x1F = simd_and(x00_x1F, u16hi_x00);
1299	x80_x9F = simd_and(x80_x9F, u16hi_x00);
1300	DEL = simd_and(DEL, u16hi_x00);
1301	callouts.skipmask = u16hi_hi_surrogate;
1302	lexError = simd_or(simd_andc(x00_x1F, lex.WS), FFFE_FFFF);
1303	if (bitblock::any(parameters.XML_11)) {
1304	lexError = simd_or(lexError, simd_andc(x80_x9F, lex.NEL));
1305	lexError = simd_or(lexError, DEL);
1306	lex.WS = simd_or(lex.WS, simd_or(lex.NEL, lex.LS));
1307	}
1308	if (bitblock::any(lexError)) {
1309	errors.Lexical = lexError;
1310	}
1311	}
1312	else {
1313	carryQ.CarryDequeueEnqueue(0, 1);
1314	}
1315	carryQ.CarryQ_Adjust(1);
1316	}
1317	IDISA_ALWAYS_INLINE void do_final_block(Parameters & parameters, U16hi & u16hi, U16lo & u16lo, Lex & lex, Callouts & callouts, Errors & errors, BitBlock EOF_mask) {
1318	BitBlock u16hitemp1, u16hitemp2, u16hitemp3, u16hitemp4, u16hitemp5;
1319	BitBlock u16hitemp6, u16hitemp7, u16hi_x00, u16hitemp8, u16hitemp9;
1320	BitBlock u16hitemp10, u16hitemp11, u16hi_hi_surrogate, u16hitemp12;
1321	BitBlock u16hi_lo_surrogate, u16hitemp13, u16hitemp14, u16hitemp15;
1322	BitBlock u16hitemp16, u16hi_xFF, u16hitemp17, u16hitemp18, u16hi_x20, temp1;
1323	BitBlock temp2, temp3, temp4, temp5, xFE_FF, temp6, temp7, x00_x1F, temp8;
1324	BitBlock temp9, temp10, temp11, temp12, temp13, temp14, temp15, temp16, temp17;
1325	BitBlock temp18, temp19, temp20, temp21, temp22, temp23, temp24, temp25;
1326	BitBlock temp26, temp27, temp28, temp29, temp30, temp31, temp32, temp33;
1327	BitBlock temp34, temp35, temp36, temp37, temp38, temp39, temp40, temp41;
1328	BitBlock temp42, temp43, temp44, temp45, temp46, temp47, temp48, temp49;
1329	BitBlock temp50, temp51, temp52, temp53, temp54, temp55, temp56, temp57;
1330	BitBlock temp58, temp59, temp60, temp61, temp62, DEL, temp63, x80_x9F, temp64;
1331	BitBlock temp65, x28, FFFE_FFFF, lexError;
1332
1333	BitBlock tempvar0;
1334
1335
1336	u16hitemp1 = simd_or(u16hi.bit_0, u16hi.bit_1);
1337	u16hitemp2 = simd_or(u16hi.bit_2, u16hi.bit_3);
1338	u16hitemp3 = simd_or(u16hitemp1, u16hitemp2);
1339	u16hitemp4 = simd_or(u16hi.bit_4, u16hi.bit_5);
1340	u16hitemp5 = simd_or(u16hi.bit_6, u16hi.bit_7);
1341	u16hitemp6 = simd_or(u16hitemp4, u16hitemp5);
1342	u16hitemp7 = simd_or(u16hitemp3, u16hitemp6);
1343	u16hi_x00 = simd_not(u16hitemp7);
1344	u16hitemp8 = simd_and(u16hi.bit_0, u16hi.bit_1);
1345	u16hitemp9 = simd_andc(u16hi.bit_3, u16hi.bit_2);
1346	u16hitemp10 = simd_and(u16hitemp8, u16hitemp9);
1347	u16hitemp11 = simd_andc(u16hi.bit_4, u16hi.bit_5);
1348	u16hi_hi_surrogate = simd_and(u16hitemp10, u16hitemp11);
1349	u16hitemp12 = simd_and(u16hi.bit_4, u16hi.bit_5);
1350	u16hi_lo_surrogate = simd_and(u16hitemp10, u16hitemp12);
1351	u16hitemp13 = simd_and(u16hi.bit_2, u16hi.bit_3);
1352	u16hitemp14 = simd_and(u16hitemp8, u16hitemp13);
1353	u16hitemp15 = simd_and(u16hi.bit_6, u16hi.bit_7);
1354	u16hitemp16 = simd_and(u16hitemp12, u16hitemp15);
1355	u16hi_xFF = simd_and(u16hitemp14, u16hitemp16);
1356	u16hitemp17 = simd_andc(u16hi.bit_2, u16hi.bit_3);
1357	u16hitemp18 = simd_andc(u16hitemp17, u16hitemp1);
1358	u16hi_x20 = simd_andc(u16hitemp18, u16hitemp6);
1359	temp1 = simd_and(u16lo.bit_0, u16lo.bit_1);
1360	temp2 = simd_and(u16lo.bit_2, u16lo.bit_3);
1361	temp3 = simd_and(temp1, temp2);
1362	temp4 = simd_and(u16lo.bit_4, u16lo.bit_5);
1363	temp5 = simd_and(temp4, u16lo.bit_6);
1364	xFE_FF = simd_and(temp3, temp5);
1365	temp6 = simd_or(u16lo.bit_0, u16lo.bit_1);
1366	temp7 = simd_or(temp6, u16lo.bit_2);
1367	x00_x1F = simd_not(temp7);
1368	temp8 = simd_or(u16lo.bit_2, u16lo.bit_3);
1369	temp9 = simd_or(temp6, temp8);
1370	temp10 = simd_andc(u16lo.bit_7, u16lo.bit_6);
1371	temp11 = simd_and(temp4, temp10);
1372	lex.CR = simd_andc(temp11, temp9);
1373	temp12 = simd_andc(u16lo.bit_4, u16lo.bit_5);
1374	temp13 = simd_andc(u16lo.bit_6, u16lo.bit_7);
1375	temp14 = simd_and(temp12, temp13);
1376	lex.LF = simd_andc(temp14, temp9);
1377	temp15 = simd_or(temp11, temp14);
1378	temp16 = simd_and(temp12, temp10);
1379	temp17 = simd_or(temp15, temp16);
1380	temp18 = simd_andc(temp17, temp9);
1381	temp19 = simd_andc(u16lo.bit_2, u16lo.bit_3);
1382	temp20 = simd_andc(temp19, temp6);
1383	temp21 = simd_or(u16lo.bit_4, u16lo.bit_5);
1384	temp22 = simd_or(u16lo.bit_6, u16lo.bit_7);
1385	temp23 = simd_or(temp21, temp22);
1386	temp24 = simd_andc(temp20, temp23);
1387	lex.WS = simd_or(temp18, temp24);
1388	temp25 = simd_andc(u16lo.bit_5, u16lo.bit_4);
1389	temp26 = simd_and(temp25, temp13);
1390	lex.RefStart = simd_and(temp20, temp26);
1391	temp27 = simd_andc(temp2, temp6);
1392	temp28 = simd_and(u16lo.bit_6, u16lo.bit_7);
1393	temp29 = simd_and(temp12, temp28);
1394	lex.Semicolon = simd_and(temp27, temp29);
1395	temp30 = simd_andc(temp4, temp22);
1396	lex.LAngle = simd_and(temp27, temp30);
1397	temp31 = simd_and(temp4, temp13);
1398	lex.RAngle = simd_and(temp27, temp31);
1399	temp32 = simd_andc(u16lo.bit_1, u16lo.bit_0);
1400	temp33 = simd_andc(u16lo.bit_3, u16lo.bit_2);
1401	temp34 = simd_and(temp32, temp33);
1402	lex.LBracket = simd_and(temp34, temp29);
1403	lex.RBracket = simd_and(temp34, temp11);
1404	temp35 = simd_andc(temp10, temp21);
1405	lex.Exclam = simd_and(temp20, temp35);
1406	temp36 = simd_and(temp4, temp28);
1407	lex.QMark = simd_and(temp27, temp36);
1408	lex.Hyphen = simd_and(temp20, temp11);
1409	lex.Equals = simd_and(temp27, temp11);
1410	temp37 = simd_and(temp25, temp28);
1411	lex.SQuote = simd_and(temp20, temp37);
1412	temp38 = simd_andc(temp13, temp21);
1413	lex.DQuote = simd_and(temp20, temp38);
1414	lex.Slash = simd_and(temp20, temp36);
1415	temp39 = simd_andc(temp28, temp21);
1416	lex.Hash = simd_and(temp20, temp39);
1417	temp40 = simd_and(temp34, temp36);
1418	temp41 = simd_or(lex.Hyphen, temp40);
1419	temp42 = simd_and(temp20, temp31);
1420	temp43 = simd_or(temp41, temp42);
1421	temp44 = simd_or(u16lo.bit_5, temp28);
1422	temp45 = simd_and(u16lo.bit_4, temp44);
1423	temp46 = simd_andc(temp27, temp45);
1424	temp47 = simd_or(temp43, temp46);
1425	temp48 = simd_andc(temp32, u16lo.bit_2);
1426	temp49 = simd_not(temp45);
1427	temp50 = simd_or(simd_and(u16lo.bit_3, temp49), simd_andc(temp23, u16lo.bit_3));
1428	temp51 = simd_and(temp48, temp50);
1429	temp52 = simd_or(temp47, temp51);
1430	temp53 = simd_and(temp32, u16lo.bit_2);
1431	temp54 = simd_and(temp53, temp50);
1432	lex.NameScan = simd_or(temp52, temp54);
1433	temp55 = simd_and(temp25, temp10);
1434	lex.Pct = simd_and(temp20, temp55);
1435	temp56 = simd_and(temp20, temp14);
1436	temp57 = simd_or(temp56, lex.QMark);
1437	temp58 = simd_and(temp20, temp29);
1438	lex.RepOp = simd_or(temp57, temp58);
1439	temp59 = simd_andc(u16lo.bit_4, temp22);
1440	temp60 = simd_and(temp20, temp59);
1441	temp61 = simd_and(temp32, temp2);
1442	temp62 = simd_and(temp61, temp30);
1443	lex.LContentDelim = simd_or(temp60, temp62);
1444	DEL = simd_and(temp61, temp36);
1445	temp63 = simd_andc(u16lo.bit_0, u16lo.bit_1);
1446	x80_x9F = simd_andc(temp63, u16lo.bit_2);
1447	temp64 = simd_andc(temp63, temp8);
1448	lex.NEL = simd_and(temp64, temp55);
1449	temp65 = simd_andc(temp12, temp22);
1450	x28 = simd_and(temp20, temp65);
1451	lex.LS = simd_and(u16hi_x20, x28);
1452	FFFE_FFFF = simd_and(u16hi_xFF, xFE_FF);
1453	errors.Unicode = simd<1>::constant<0>();
1454	errors.Lexical = simd<1>::constant<0>();
1455	if ((bitblock::any(simd_not(u16hi_x00)) \|\| carryQ.CarryTest(0, 1))) {
1456	if ((bitblock::any(simd_or(u16hi_hi_surrogate, u16hi_lo_surrogate)) \|\| carryQ.CarryTest(0, 1))) {
1457	tempvar0 = carryQ.BitBlock_advance_ci_co(u16hi_hi_surrogate, carryQ.get_carry_in(0), 0);
1458	errors.Unicode = simd_xor(tempvar0, u16hi_lo_surrogate);
1459	}
1460	else {
1461	carryQ.CarryDequeueEnqueue(0, 1);
1462	}
1463	lex.CR = simd_and(lex.CR, u16hi_x00);
1464	lex.LF = simd_and(lex.LF, u16hi_x00);
1465	lex.WS = simd_and(lex.WS, u16hi_x00);
1466	lex.RefStart = simd_and(lex.RefStart, u16hi_x00);
1467	lex.Semicolon = simd_and(lex.Semicolon, u16hi_x00);
1468	lex.LAngle = simd_and(lex.LAngle, u16hi_x00);
1469	lex.RAngle = simd_and(lex.RAngle, u16hi_x00);
1470	lex.LBracket = simd_and(lex.LBracket, u16hi_x00);
1471	lex.RBracket = simd_and(lex.RBracket, u16hi_x00);
1472	lex.Exclam = simd_and(lex.Exclam, u16hi_x00);
1473	lex.QMark = simd_and(lex.QMark, u16hi_x00);
1474	lex.Hyphen = simd_and(lex.Hyphen, u16hi_x00);
1475	lex.Equals = simd_and(lex.Equals, u16hi_x00);
1476	lex.SQuote = simd_and(lex.SQuote, u16hi_x00);
1477	lex.DQuote = simd_and(lex.DQuote, u16hi_x00);
1478	lex.Slash = simd_and(lex.Slash, u16hi_x00);
1479	lex.Hash = simd_and(lex.Hash, u16hi_x00);
1480	lex.NameScan = simd_and(lex.NameScan, u16hi_x00);
1481	lex.NEL = simd_and(lex.NEL, u16hi_x00);
1482	x00_x1F = simd_and(x00_x1F, u16hi_x00);
1483	x80_x9F = simd_and(x80_x9F, u16hi_x00);
1484	DEL = simd_and(DEL, u16hi_x00);
1485	callouts.skipmask = u16hi_hi_surrogate;
1486	lexError = simd_or(simd_andc(x00_x1F, lex.WS), FFFE_FFFF);
1487	if (bitblock::any(parameters.XML_11)) {
1488	lexError = simd_or(lexError, simd_andc(x80_x9F, lex.NEL));
1489	lexError = simd_or(lexError, DEL);
1490	lex.WS = simd_or(lex.WS, simd_or(lex.NEL, lex.LS));
1491	}
1492	if (bitblock::any(simd_and(lexError, EOF_mask))) {
1493	errors.Lexical = lexError;
1494	}
1495	}
1496	else {
1497	carryQ.CarryDequeueEnqueue(0, 1);
1498	}
1499	}
1500	void do_segment(Parameters parameters[], U16hi u16hi[], U16lo u16lo[], Lex lex[], Callouts callouts[], Errors errors[], int segment_blocks) {
1501	int i;
1502	for (i = 0; i < segment_blocks; i++)
1503	do_block(parameters[i], u16hi[i], u16lo[i], lex[i], callouts[i], errors[i]);
1504	}
1505	CarryArray<1, 0> carryQ;
1506	};
1507
1508	struct Normalize_WS {
1509	Normalize_WS() {
1510	}
1511	IDISA_ALWAYS_INLINE void do_block(Parameters & parameters, Lex & lex, U16hi & u16hi, U16lo & u16lo, Callouts & callouts, Marker & marker) {
1512	BitBlock CRLF, CRNEL, WS_in_AttVal;
1513
1514	BitBlock tempvar0, tempvar1;
1515
1516
1517	if ((bitblock::any(lex.CR) \|\| carryQ.CarryTest(0, 1))) {
1518	u16lo.bit_5 = simd_xor(u16lo.bit_5, lex.CR);
1519	u16lo.bit_6 = simd_xor(u16lo.bit_6, lex.CR);
1520	u16lo.bit_7 = simd_xor(u16lo.bit_7, lex.CR);
1521	tempvar0 = carryQ.BitBlock_advance_ci_co(lex.CR, carryQ.get_carry_in(0), 0);
1522	CRLF = simd_and(tempvar0, lex.LF);
1523	callouts.delmask = simd_or(callouts.delmask, CRLF);
1524	lex.LF = simd_or(lex.LF, lex.CR);
1525	lex.LF = simd_xor(lex.LF, CRLF);
1526	callouts.skipmask = simd_or(callouts.skipmask, CRLF);
1527	}
1528	else {
1529	carryQ.CarryDequeueEnqueue(0, 1);
1530	}
1531	if ((bitblock::any(parameters.XML_11) \|\| carryQ.CarryTest(1, 1))) {
1532	if ((bitblock::any(lex.NEL) \|\| carryQ.CarryTest(1, 1))) {
1533	u16lo.bit_0 = simd_xor(u16lo.bit_0, lex.NEL);
1534	u16lo.bit_5 = simd_xor(u16lo.bit_5, lex.NEL);
1535	u16lo.bit_6 = simd_xor(u16lo.bit_6, lex.NEL);
1536	u16lo.bit_7 = simd_xor(u16lo.bit_7, lex.NEL);
1537	lex.LF = simd_or(lex.LF, lex.NEL);
1538	if ((bitblock::any(lex.CR) \|\| carryQ.CarryTest(1, 1))) {
1539	tempvar1 = carryQ.BitBlock_advance_ci_co(lex.CR, carryQ.get_carry_in(1), 1);
1540	CRNEL = simd_and(tempvar1, lex.NEL);
1541	callouts.delmask = simd_or(callouts.delmask, CRNEL);
1542	lex.LF = simd_xor(lex.LF, CRNEL);
1543	callouts.skipmask = simd_or(callouts.skipmask, CRNEL);
1544	}
1545	else {
1546	carryQ.CarryDequeueEnqueue(1, 1);
1547	}
1548	}
1549	else {
1550	carryQ.CarryDequeueEnqueue(1, 1);
1551	}
1552	if (bitblock::any(lex.LS)) {
1553	u16hi.bit_2 = simd_xor(u16hi.bit_2, lex.LS);
1554	u16lo.bit_2 = simd_xor(u16lo.bit_2, lex.LS);
1555	u16lo.bit_6 = simd_xor(u16lo.bit_6, lex.LS);
1556	lex.LF = simd_or(lex.LF, lex.LS);
1557	}
1558	}
1559	else {
1560	carryQ.CarryDequeueEnqueue(1, 1);
1561	}
1562	WS_in_AttVal = simd_and(lex.WS, callouts.AttValSpan);
1563	if (bitblock::any(WS_in_AttVal)) {
1564	u16lo.bit_2 = simd_or(u16lo.bit_2, WS_in_AttVal);
1565	u16lo.bit_3 = simd_andc(u16lo.bit_3, WS_in_AttVal);
1566	u16lo.bit_4 = simd_andc(u16lo.bit_4, WS_in_AttVal);
1567	u16lo.bit_5 = simd_andc(u16lo.bit_5, WS_in_AttVal);
1568	u16lo.bit_6 = simd_andc(u16lo.bit_6, WS_in_AttVal);
1569	u16lo.bit_7 = simd_andc(u16lo.bit_7, WS_in_AttVal);
1570	}
1571	carryQ.CarryQ_Adjust(2);
1572	}
1573	IDISA_ALWAYS_INLINE void do_final_block(Parameters & parameters, Lex & lex, U16hi & u16hi, U16lo & u16lo, Callouts & callouts, Marker & marker, BitBlock EOF_mask) {
1574	BitBlock CRLF, CRNEL, WS_in_AttVal;
1575
1576	BitBlock tempvar0, tempvar1;
1577
1578
1579	if ((bitblock::any(lex.CR) \|\| carryQ.CarryTest(0, 1))) {
1580	u16lo.bit_5 = simd_xor(u16lo.bit_5, lex.CR);
1581	u16lo.bit_6 = simd_xor(u16lo.bit_6, lex.CR);
1582	u16lo.bit_7 = simd_xor(u16lo.bit_7, lex.CR);
1583	tempvar0 = carryQ.BitBlock_advance_ci_co(lex.CR, carryQ.get_carry_in(0), 0);
1584	CRLF = simd_and(tempvar0, lex.LF);
1585	callouts.delmask = simd_or(callouts.delmask, CRLF);
1586	lex.LF = simd_or(lex.LF, lex.CR);
1587	lex.LF = simd_xor(lex.LF, CRLF);
1588	callouts.skipmask = simd_or(callouts.skipmask, CRLF);
1589	}
1590	else {
1591	carryQ.CarryDequeueEnqueue(0, 1);
1592	}
1593	if ((bitblock::any(parameters.XML_11) \|\| carryQ.CarryTest(1, 1))) {
1594	if ((bitblock::any(lex.NEL) \|\| carryQ.CarryTest(1, 1))) {
1595	u16lo.bit_0 = simd_xor(u16lo.bit_0, lex.NEL);
1596	u16lo.bit_5 = simd_xor(u16lo.bit_5, lex.NEL);
1597	u16lo.bit_6 = simd_xor(u16lo.bit_6, lex.NEL);
1598	u16lo.bit_7 = simd_xor(u16lo.bit_7, lex.NEL);
1599	lex.LF = simd_or(lex.LF, lex.NEL);
1600	if ((bitblock::any(lex.CR) \|\| carryQ.CarryTest(1, 1))) {
1601	tempvar1 = carryQ.BitBlock_advance_ci_co(lex.CR, carryQ.get_carry_in(1), 1);
1602	CRNEL = simd_and(tempvar1, lex.NEL);
1603	callouts.delmask = simd_or(callouts.delmask, CRNEL);
1604	lex.LF = simd_xor(lex.LF, CRNEL);
1605	callouts.skipmask = simd_or(callouts.skipmask, CRNEL);
1606	}
1607	else {
1608	carryQ.CarryDequeueEnqueue(1, 1);
1609	}
1610	}
1611	else {
1612	carryQ.CarryDequeueEnqueue(1, 1);
1613	}
1614	if (bitblock::any(lex.LS)) {
1615	u16hi.bit_2 = simd_xor(u16hi.bit_2, lex.LS);
1616	u16lo.bit_2 = simd_xor(u16lo.bit_2, lex.LS);
1617	u16lo.bit_6 = simd_xor(u16lo.bit_6, lex.LS);
1618	lex.LF = simd_or(lex.LF, lex.LS);
1619	}
1620	}
1621	else {
1622	carryQ.CarryDequeueEnqueue(1, 1);
1623	}
1624	WS_in_AttVal = simd_and(lex.WS, callouts.AttValSpan);
1625	if (bitblock::any(WS_in_AttVal)) {
1626	u16lo.bit_2 = simd_or(u16lo.bit_2, WS_in_AttVal);
1627	u16lo.bit_3 = simd_andc(u16lo.bit_3, WS_in_AttVal);
1628	u16lo.bit_4 = simd_andc(u16lo.bit_4, WS_in_AttVal);
1629	u16lo.bit_5 = simd_andc(u16lo.bit_5, WS_in_AttVal);
1630	u16lo.bit_6 = simd_andc(u16lo.bit_6, WS_in_AttVal);
1631	u16lo.bit_7 = simd_andc(u16lo.bit_7, WS_in_AttVal);
1632	}
1633	}
1634	void do_segment(Parameters parameters[], Lex lex[], U16hi u16hi[], U16lo u16lo[], Callouts callouts[], Marker marker[], int segment_blocks) {
1635	int i;
1636	for (i = 0; i < segment_blocks; i++)
1637	do_block(parameters[i], lex[i], u16hi[i], u16lo[i], callouts[i], marker[i]);
1638	}
1639	CarryArray<2, 0> carryQ;
1640	};
1641
1642
1643	Classify_bytes classify_bytes;
1644	Normalize_WS normalize_WS;
1645
1646	#undef NoteXercesXMLErr
1647	#undef error_tracker_NoteError
1648
1649
1650	XMLCh * buildOutputStream
1651	(
1652	const Marker & marker
1653	, const Callouts & callouts
1654	, U16hi & u16hi
1655	, U16lo & u16lo
1656	, const XMLByte * source
1657	, const size_t offset
1658	, ContentStream & contentStream
1659	, XMLCh * contentStreamPtr
1660	, StringPtrArray & stringEndArray
1661	, const XMLCh ** & stringEndPtr
1662	, unsigned int & refMarkupCount
1663	, unsigned int & refSymbolCount
1664	, XMLComplexRefArray & complexRefArray
1665	, XMLSize_t & complexRefCount
1666	);
1667
1668	XMLCh * buildInternalOutputStream
1669	(
1670	const Marker & marker
1671	, const Callouts & callouts
1672	, U16hi & u16hi
1673	, U16lo & u16lo
1674	, const XMLCh * source
1675	, XMLCh * contentStreamPtr
1676	, StringPtrArray & stringEndArray
1677	, const XMLCh ** & stringEndPtr
1678	);
1679
1680
1681	IDISA_ALWAYS_INLINE
1682	void transpose(const BytePack * const in, U16hi & u16h, U16lo & u16l, const bool swapped)
1683	{
1684	BytePack h[8];
1685	BytePack l[8];
1686
1687	if (!swapped)
1688	{
1689	for(int i=0; i<8; i++)
1690	{
1691	const BytePack a = bitblock::load_unaligned(&in[i * 2]);
1692	const BytePack b = bitblock::load_unaligned(&in[i * 2 + 1]);
1693	h[i] = hsimd<16>::packh(b, a);
1694	l[i] = hsimd<16>::packl(b, a);
1695	}
1696	}
1697	else
1698	{
1699	for(int i=0; i<8; i++)
1700	{
1701	const BytePack a = bitblock::load_unaligned(&in[i * 2]);
1702	const BytePack b = bitblock::load_unaligned(&in[i * 2 + 1]);
1703	l[i] = hsimd<16>::packh(b, a);
1704	h[i] = hsimd<16>::packl(b, a);
1705	}
1706	}
1707
1708	s2p(h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7],
1709	u16h.bit_0, u16h.bit_1, u16h.bit_2, u16h.bit_3,
1710	u16h.bit_4, u16h.bit_5, u16h.bit_6, u16h.bit_7);
1711
1712	s2p(l[0], l[1], l[2], l[3], l[4], l[5], l[6], l[7],
1713	u16l.bit_0, u16l.bit_1, u16l.bit_2, u16l.bit_3,
1714	u16l.bit_4, u16l.bit_5, u16l.bit_6, u16l.bit_7);
1715	}
1716
1717	IDISA_ALWAYS_INLINE
1718	void transpose(const BytePack * const in, U16hi & u16h, U16lo & u16l, const BitBlock EOF_mask, const bool swapped)
1719	{
1720	transpose(in, u16h, u16l, swapped);
1721
1722	u16l.bit_0 = simd_and(u16l.bit_0, EOF_mask);
1723	u16l.bit_1 = simd_and(u16l.bit_1, EOF_mask);
1724	u16l.bit_2 = simd_and(u16l.bit_2, EOF_mask);
1725	u16l.bit_3 = simd_and(u16l.bit_3, EOF_mask);
1726	u16l.bit_4 = simd_and(u16l.bit_4, EOF_mask);
1727	u16l.bit_5 = simd_and(u16l.bit_5, EOF_mask);
1728	u16l.bit_6 = simd_and(u16l.bit_6, EOF_mask);
1729	u16l.bit_7 = simd_and(u16l.bit_7, EOF_mask);
1730
1731	u16h.bit_0 = simd_and(u16h.bit_0, EOF_mask);
1732	u16h.bit_1 = simd_and(u16h.bit_1, EOF_mask);
1733	u16h.bit_2 = simd_and(u16h.bit_2, EOF_mask);
1734	u16h.bit_3 = simd_and(u16h.bit_3, EOF_mask);
1735	u16h.bit_4 = simd_and(u16h.bit_4, EOF_mask);
1736	u16h.bit_5 = simd_and(u16h.bit_5, EOF_mask);
1737	u16h.bit_6 = simd_and(u16h.bit_6, EOF_mask);
1738	u16h.bit_7 = simd_and(u16h.bit_7, EOF_mask);
1739	}
1740
1741	#ifdef CALCULATE_COPY_BACK_POSITION
1742	static uint64_t calculateUnusedSymbols
1743	(
1744	const BitBlock * const symbolStream
1745	, const unsigned int avail
1746	, const unsigned int unused
1747	);
1748
1749	static uint64_t calculateUnusedContent
1750	(
1751	const BitBlock * const delMaskStream
1752	, const unsigned int avail
1753	, const unsigned int unused
1754	);
1755	#endif
1756
1757	void checkErrors(const XMLUTF16CharacterSetAdapter::Errors & errors, const XMLByte * source, XMLLineColTracker & lineCol);
1758
1759	void reportError(const BitBlock fatalErrors, const XMLUTF16CharacterSetAdapter::Errors & errors, const XMLByte * source, XMLLineColTracker & lineCol);
1760
1761	IDISA_ALWAYS_INLINE
1762	MemoryManager * getMemoryManager()
1763	{
1764	return fTranscoder->getMemoryManager();
1765	}
1766
1767	protected:
1768
1769	XMLTranscoder * const fTranscoder;
1770	XMLReferenceTable fReferenceTable;
1771	const bool fSwapped;
1772	};
1773
1774	#undef LocalCarryDeclare
1775
1776	XERCES_CPP_NAMESPACE_END
1777
1778	#if !defined(XERCES_TMPLSINC)
1779	#include <icxmlc/XMLReferenceTable.c>
1780	#endif
1781
1782	#endif

Note: See TracBrowser for help on using the repository browser.

Download in other formats: