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 |
---|