source: proto/pabloj/trunk/output/cpplang/pablo_definitions.hpp @ 2990

Last change on this file since 2990 was 2990, checked in by ksherdy, 5 years ago

Eliminated all carry 'strings' from the PabloS parser.

File size: 64.6 KB
Line 
1// GENERATED CODE. DO NOT MODIFY.
2//
3// This template includes the minimal set of runtime support libraries required
4// to support compilation of PabloJ generated C++ code (bitblock.hpp, carryQ.hpp,
5// pabloSupport.hpp, error_tracker.hpp)
6//
7// (c) 2012, 2013 Robert D. Cameron, Ken Herdy
8// All rights reserved.
9// Licensed to International Characters, Inc. under Academic Free License 3.0
10//
11//////////////////////////////////////////////////////////////////////////////////////////
12// @ global - Stream structure and stream function declarations.
13//
14//////////////////////////////////////////////////////////////////////////////////////////
15//
16#ifndef PABLO_DEFINITIONS_HPP
17#define PABLO_DEFINITIONS_HPP
18
19// runtime libraries
20#include <simd-lib/bitblock.hpp>
21#include <simd-lib/carryQ.hpp>
22#include <simd-lib/pabloSupport.hpp>
23
24// migrate error tracker, line/column tracker to compiler runtime
25#include <ErrorTracker.h>
26ErrorTracker error_tracker;
27
28#define assert_0_error(errkind, errstrm) error_tracker.NoteError(errkind, errstrm);
29BitBlock EOF_mask = simd<1>::constant<1>();
30
31// XMLWF application headers and definitions
32/*
33#include <stdio.h>
34#include <stdlib.h>
35#include <errno.h>
36#include <sys/types.h>
37#include <sys/stat.h>
38
39#include <simd-lib/s2p.hpp>
40#include <simd-lib/buffer.hpp>
41#include <simd-lib/bitblock_iterator.hpp>
42#include <simd-lib/perflib/perfsec.h>
43
44#include <xmldecl.h>
45#include <namechars.h>
46#include <LineColTracker.hpp>
47#include <XMLTestSuiteError.h>
48
49// Define the mappings for pablo.assert_0(strm, errkind) statements which
50// compile to the the form assert_0_error(errkind, strm)
51#include <ErrorTracker.h>
52
53ErrorTracker error_tracker;
54#define assert_0_error(errkind, errstrm) error_tracker.NoteError(errkind, errstrm);
55*/
56
57// namespace pablo
58// {
59struct Basis_bits
60{
61        BitBlock bit_0;
62        BitBlock bit_1;
63        BitBlock bit_2;
64        BitBlock bit_3;
65        BitBlock bit_4;
66        BitBlock bit_5;
67        BitBlock bit_6;
68        BitBlock bit_7;
69};
70 
71struct U8
72{
73        BitBlock unibyte;
74        BitBlock prefix;
75        BitBlock prefix2;
76        BitBlock prefix3;
77        BitBlock prefix4;
78        BitBlock suffix;
79        BitBlock badprefix;
80        BitBlock xE0;
81        BitBlock xED;
82        BitBlock xF0;
83        BitBlock xF4;
84        BitBlock xA0_xBF;
85        BitBlock x80_x9F;
86        BitBlock x90_xBF;
87        BitBlock x80_x8F;
88        BitBlock xEF;
89        BitBlock xBF;
90        BitBlock xBE;
91        BitBlock scope22;
92        BitBlock scope32;
93        BitBlock scope33;
94        BitBlock scope42;
95        BitBlock scope43;
96        BitBlock scope44;
97        BitBlock xE0_scope;
98        BitBlock xED_scope;
99        BitBlock xF0_scope;
100        BitBlock xF4_scope;
101        BitBlock xEF_scope;
102};
103 
104struct Lex
105{
106        BitBlock CR;
107        BitBlock LF;
108        BitBlock HT;
109        BitBlock SP;
110        BitBlock CRLF;
111        BitBlock RefStart;
112        BitBlock Semicolon;
113        BitBlock Colon;
114        BitBlock LAngle;
115        BitBlock RAngle;
116        BitBlock LBracket;
117        BitBlock RBracket;
118        BitBlock Exclam;
119        BitBlock QMark;
120        BitBlock Hyphen;
121        BitBlock Equals;
122        BitBlock SQuote;
123        BitBlock DQuote;
124        BitBlock Slash;
125        BitBlock Hash;
126        BitBlock x;
127        BitBlock ASCII_name_start;
128        BitBlock ASCII_name_char;
129        BitBlock NameScan;
130        BitBlock Digit;
131        BitBlock Hex;
132        BitBlock WS;
133};
134 
135struct Marker
136{
137        BitBlock LAngle_scope;
138        BitBlock Ref_opener;
139        BitBlock CD_closer;
140};
141 
142struct CtCDPI_Callouts
143{
144        BitBlock Ct_starts;
145        BitBlock Ct_ends;
146        BitBlock CD_starts;
147        BitBlock CD_ends;
148        BitBlock PI_starts;
149        BitBlock PI_name_starts;
150        BitBlock PI_name_ends;
151        BitBlock PI_ends;
152};
153 
154struct Ref_Callouts
155{
156        BitBlock GenRef_starts;
157        BitBlock GenRef_ends;
158        BitBlock DecRef_starts;
159        BitBlock DecRef_ends;
160        BitBlock HexRef_starts;
161        BitBlock HexRef_ends;
162};
163 
164struct Tag_Callouts
165{
166        BitBlock ElemName_starts;
167        BitBlock ElemName_ends;
168        BitBlock AttName_starts;
169        BitBlock AttName_ends;
170        BitBlock AttVal_starts;
171        BitBlock AttVal_ends;
172        BitBlock AttVal_spans;
173        BitBlock EmptyTag_marks;
174        BitBlock EndTag_marks;
175};
176 
177struct Check_streams
178{
179        BitBlock misc_mask;
180        BitBlock non_ascii_name_starts;
181        BitBlock non_ascii_names;
182        BitBlock tag_marks;
183        BitBlock name_follows;
184        BitBlock att_refs;
185};
186 
187struct Classify_bytes_Validate_utf8
188{
189        Classify_bytes_Validate_utf8()
190        {
191               
192        }
193         
194        IDISA_INLINE void do_block(struct Basis_bits & basis_bits, struct Lex & lex, struct U8 & u8)
195        {
196                BitBlock temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
197                BitBlock temp2 = simd_andc(basis_bits.bit_2, basis_bits.bit_3);
198                BitBlock temp3 = simd_andc(temp2, temp1);
199                BitBlock temp4 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
200                BitBlock temp5 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
201                BitBlock temp6 = simd_and(temp4, temp5);
202                lex.RefStart = simd_and(temp3, temp6);
203                BitBlock temp7 = simd_and(basis_bits.bit_2, basis_bits.bit_3);
204                BitBlock temp8 = simd_andc(temp7, temp1);
205                BitBlock temp9 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
206                BitBlock temp10 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
207                BitBlock temp11 = simd_and(temp9, temp10);
208                lex.Semicolon = simd_and(temp8, temp11);
209                BitBlock temp12 = simd_and(basis_bits.bit_4, basis_bits.bit_5);
210                BitBlock temp13 = simd_or(basis_bits.bit_6, basis_bits.bit_7);
211                BitBlock temp14 = simd_andc(temp12, temp13);
212                lex.LAngle = simd_and(temp8, temp14);
213                BitBlock temp15 = simd_and(temp12, temp5);
214                lex.RAngle = simd_and(temp8, temp15);
215                BitBlock temp16 = simd_andc(basis_bits.bit_1, basis_bits.bit_0);
216                BitBlock temp17 = simd_andc(basis_bits.bit_3, basis_bits.bit_2);
217                BitBlock temp18 = simd_and(temp16, temp17);
218                lex.LBracket = simd_and(temp18, temp11);
219                BitBlock temp19 = simd_andc(basis_bits.bit_7, basis_bits.bit_6);
220                BitBlock temp20 = simd_and(temp12, temp19);
221                lex.RBracket = simd_and(temp18, temp20);
222                BitBlock temp21 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
223                BitBlock temp22 = simd_andc(temp19, temp21);
224                lex.Exclam = simd_and(temp3, temp22);
225                BitBlock temp23 = simd_and(temp12, temp10);
226                lex.QMark = simd_and(temp8, temp23);
227                lex.Hyphen = simd_and(temp3, temp20);
228                lex.Equals = simd_and(temp8, temp20);
229                BitBlock temp24 = simd_and(temp4, temp10);
230                lex.SQuote = simd_and(temp3, temp24);
231                BitBlock temp25 = simd_andc(temp5, temp21);
232                lex.DQuote = simd_and(temp3, temp25);
233                lex.Slash = simd_and(temp3, temp23);
234                BitBlock temp26 = simd_andc(temp10, temp21);
235                lex.Hash = simd_and(temp3, temp26);
236                BitBlock temp27 = simd_and(temp16, temp7);
237                BitBlock temp28 = simd_andc(temp9, temp13);
238                lex.x = simd_and(temp27, temp28);
239                BitBlock temp29 = simd_and(temp9, temp5);
240                lex.Colon = simd_and(temp8, temp29);
241                BitBlock temp30 = simd_and(temp18, temp23);
242                BitBlock temp31 = simd_or(temp30, lex.Colon);
243                BitBlock temp32 = simd_andc(temp16, basis_bits.bit_2);
244                BitBlock temp33 = simd_or(basis_bits.bit_5, temp10);
245                BitBlock temp34 = simd_and(basis_bits.bit_4, temp33);
246                BitBlock temp35 = simd_not(temp34);
247                BitBlock temp36 = simd_or(temp21, temp13);
248                BitBlock temp37 = simd_or(simd_and(basis_bits.bit_3, temp35), simd_andc(temp36, basis_bits.bit_3));
249                BitBlock temp38 = simd_and(temp32, temp37);
250                BitBlock temp39 = simd_or(temp31, temp38);
251                BitBlock temp40 = simd_and(temp16, basis_bits.bit_2);
252                BitBlock temp41 = simd_and(temp40, temp37);
253                lex.ASCII_name_start = simd_or(temp39, temp41);
254                BitBlock temp42 = simd_or(temp30, lex.Hyphen);
255                BitBlock temp43 = simd_and(temp3, temp15);
256                BitBlock temp44 = simd_or(temp42, temp43);
257                BitBlock temp45 = simd_andc(temp8, temp34);
258                BitBlock temp46 = simd_or(temp44, temp45);
259                BitBlock temp47 = simd_or(temp46, temp38);
260                lex.ASCII_name_char = simd_or(temp47, temp41);
261                lex.NameScan = simd_or(lex.ASCII_name_char, basis_bits.bit_0);
262                BitBlock temp48 = simd_or(temp1, basis_bits.bit_2);
263                BitBlock x00_x1F = simd_not(temp48);
264                BitBlock temp49 = simd_or(basis_bits.bit_2, basis_bits.bit_3);
265                BitBlock temp50 = simd_or(temp1, temp49);
266                lex.CR = simd_andc(temp20, temp50);
267                lex.LF = simd_andc(temp29, temp50);
268                BitBlock temp51 = simd_and(temp9, temp19);
269                lex.HT = simd_andc(temp51, temp50);
270                lex.SP = simd_andc(temp3, temp36);
271                BitBlock temp52 = simd_or(temp20, temp29);
272                BitBlock temp53 = simd_or(temp52, temp51);
273                BitBlock temp54 = simd_andc(temp53, temp50);
274                lex.WS = simd_or(temp54, lex.SP);
275                BitBlock temp55 = simd_or(basis_bits.bit_5, basis_bits.bit_6);
276                BitBlock temp56 = simd_and(basis_bits.bit_4, temp55);
277                lex.Digit = simd_andc(temp8, temp56);
278                BitBlock temp57 = simd_andc(temp16, temp49);
279                BitBlock temp58 = simd_andc(temp57, basis_bits.bit_4);
280                BitBlock temp59 = simd_not(temp10);
281                BitBlock temp60 = simd_or(simd_and(basis_bits.bit_5, temp59), simd_andc(temp13, basis_bits.bit_5));
282                BitBlock temp61 = simd_and(temp58, temp60);
283                BitBlock temp62 = simd_or(lex.Digit, temp61);
284                BitBlock temp63 = simd_and(temp16, temp2);
285                BitBlock temp64 = simd_andc(temp63, basis_bits.bit_4);
286                BitBlock temp65 = simd_and(temp64, temp60);
287                lex.Hex = simd_or(temp62, temp65);
288                BitBlock lex_error = simd_andc(x00_x1F, lex.WS);
289                if (bitblock::any(lex_error))
290                {
291                        assert_0_error("Error: illegal character", lex_error);
292                }
293                u8.unibyte = simd_not(basis_bits.bit_0);
294                u8.suffix = simd<1>::constant<0>();
295                BitBlock u8_error = simd<1>::constant<0>();
296                BitBlock u8_FFFE_FFFF = simd<1>::constant<0>();
297                BitBlock u8anyscope = simd<1>::constant<0>();
298                if (bitblock::any(simd_or(basis_bits.bit_0, carry_set_0.CarryRange(0, 10))))
299                {
300                        u8.prefix = simd_and(basis_bits.bit_0, basis_bits.bit_1);
301                        u8.prefix2 = simd_andc(u8.prefix, basis_bits.bit_2);
302                        u8.prefix3 = simd_and(u8.prefix, temp2);
303                        u8.prefix4 = simd_and(u8.prefix, temp7);
304                        u8.suffix = simd_andc(basis_bits.bit_0, basis_bits.bit_1);
305                        BitBlock temp66 = simd_andc(u8.prefix, temp49);
306                        BitBlock temp67 = simd_or(temp21, basis_bits.bit_6);
307                        BitBlock temp68 = simd_andc(temp66, temp67);
308                        BitBlock temp69 = simd_and(basis_bits.bit_5, temp13);
309                        BitBlock temp70 = simd_or(basis_bits.bit_4, temp69);
310                        BitBlock temp71 = simd_and(u8.prefix4, temp70);
311                        u8.badprefix = simd_or(temp68, temp71);
312                        u8_error = u8.badprefix;
313                        u8.scope22 = carry_set_0.BitBlock_advance_ci_co(u8.prefix2, carry_set_0.GetCarry(0), 0);
314                        u8anyscope = u8.scope22;
315                        if (bitblock::any(simd_or(simd_or(u8.prefix3, u8.prefix4), carry_set_0.CarryRange(1, 9))))
316                        {
317                                BitBlock xE0 = simd_andc(u8.prefix3, temp36);
318                                BitBlock xED = simd_and(u8.prefix3, temp20);
319                                BitBlock xF0 = simd_andc(u8.prefix4, temp36);
320                                BitBlock temp72 = simd_andc(temp4, temp13);
321                                BitBlock xF4 = simd_and(u8.prefix4, temp72);
322                                u8.xA0_xBF = simd_and(u8.suffix, basis_bits.bit_2);
323                                u8.x80_x9F = simd_andc(u8.suffix, basis_bits.bit_2);
324                                u8.x90_xBF = simd_and(u8.suffix, temp49);
325                                u8.x80_x8F = simd_andc(u8.suffix, temp49);
326                                BitBlock xEF = simd_and(u8.prefix3, temp23);
327                                BitBlock temp73 = simd_and(u8.suffix, temp7);
328                                u8.xBF = simd_and(temp73, temp23);
329                                u8.xBE = simd_and(temp73, temp15);
330                                u8.scope32 = carry_set_0.BitBlock_advance_ci_co(u8.prefix3, carry_set_0.GetCarry(1), 1);
331                                u8.scope33 = carry_set_0.BitBlock_advance_ci_co(u8.scope32, carry_set_0.GetCarry(2), 2);
332                                u8.scope42 = carry_set_0.BitBlock_advance_ci_co(u8.prefix4, carry_set_0.GetCarry(3), 3);
333                                u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42, carry_set_0.GetCarry(4), 4);
334                                u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43, carry_set_0.GetCarry(5), 5);
335                                BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xE0, xF0), carry_set_0.GetCarry(6), 6);
336                                BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xED, xF4), carry_set_0.GetCarry(7), 7);
337                                u8.xE0_scope = simd_and(u8.scope32, E0_F0_scope);
338                                u8.xED_scope = simd_and(u8.scope32, ED_F4_scope);
339                                u8.xF0_scope = simd_and(u8.scope42, E0_F0_scope);
340                                u8.xF4_scope = simd_and(u8.scope42, ED_F4_scope);
341                                u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF, carry_set_0.GetCarry(8), 8);
342                                BitBlock u8lastscope = simd_or(simd_or(u8.scope22, u8.scope33), u8.scope44);
343                                u8anyscope = simd_or(simd_or(simd_or(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
344                                BitBlock u8error1 = simd_and(u8.xE0_scope, u8.x80_x9F);
345                                BitBlock u8error2 = simd_and(u8.xED_scope, u8.xA0_xBF);
346                                BitBlock u8error3 = simd_and(u8.xF0_scope, u8.x80_x8F);
347                                BitBlock u8error4 = simd_and(u8.xF4_scope, u8.x90_xBF);
348                                u8_error = simd_or(u8_error, simd_or(simd_or(simd_or(u8error1, u8error2), u8error3), u8error4));
349                                BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd_and(u8.xEF_scope, u8.xBF), carry_set_0.GetCarry(9), 9);
350                                u8_FFFE_FFFF = simd_and(EF_BF_pending, simd_or(u8.xBE, u8.xBF));
351                        }
352                        else
353                        {
354                                carry_set_0.CarryDequeueEnqueue(1, 9);
355                        }
356                        BitBlock u8mismatch = simd_xor(u8anyscope, u8.suffix);
357                        if (bitblock::any(simd_or(simd_or(u8_error, u8mismatch), u8_FFFE_FFFF)))
358                        {
359                                assert_0_error("UTF-8 error found", simd_or(simd_or(u8_error, u8mismatch), u8_FFFE_FFFF));
360                        }
361                }
362                else
363                {
364                        carry_set_0.CarryDequeueEnqueue(0, 10);
365                }
366                carry_set_0.CarryAdjust(10);
367        }
368       
369        void do_final_block(struct Basis_bits & basis_bits, struct Lex & lex, struct U8 & u8, BitBlock & EOF_mask)
370        {
371                BitBlock temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
372                BitBlock temp2 = simd_andc(basis_bits.bit_2, basis_bits.bit_3);
373                BitBlock temp3 = simd_andc(temp2, temp1);
374                BitBlock temp4 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
375                BitBlock temp5 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
376                BitBlock temp6 = simd_and(temp4, temp5);
377                lex.RefStart = simd_and(temp3, temp6);
378                BitBlock temp7 = simd_and(basis_bits.bit_2, basis_bits.bit_3);
379                BitBlock temp8 = simd_andc(temp7, temp1);
380                BitBlock temp9 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
381                BitBlock temp10 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
382                BitBlock temp11 = simd_and(temp9, temp10);
383                lex.Semicolon = simd_and(temp8, temp11);
384                BitBlock temp12 = simd_and(basis_bits.bit_4, basis_bits.bit_5);
385                BitBlock temp13 = simd_or(basis_bits.bit_6, basis_bits.bit_7);
386                BitBlock temp14 = simd_andc(temp12, temp13);
387                lex.LAngle = simd_and(temp8, temp14);
388                BitBlock temp15 = simd_and(temp12, temp5);
389                lex.RAngle = simd_and(temp8, temp15);
390                BitBlock temp16 = simd_andc(basis_bits.bit_1, basis_bits.bit_0);
391                BitBlock temp17 = simd_andc(basis_bits.bit_3, basis_bits.bit_2);
392                BitBlock temp18 = simd_and(temp16, temp17);
393                lex.LBracket = simd_and(temp18, temp11);
394                BitBlock temp19 = simd_andc(basis_bits.bit_7, basis_bits.bit_6);
395                BitBlock temp20 = simd_and(temp12, temp19);
396                lex.RBracket = simd_and(temp18, temp20);
397                BitBlock temp21 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
398                BitBlock temp22 = simd_andc(temp19, temp21);
399                lex.Exclam = simd_and(temp3, temp22);
400                BitBlock temp23 = simd_and(temp12, temp10);
401                lex.QMark = simd_and(temp8, temp23);
402                lex.Hyphen = simd_and(temp3, temp20);
403                lex.Equals = simd_and(temp8, temp20);
404                BitBlock temp24 = simd_and(temp4, temp10);
405                lex.SQuote = simd_and(temp3, temp24);
406                BitBlock temp25 = simd_andc(temp5, temp21);
407                lex.DQuote = simd_and(temp3, temp25);
408                lex.Slash = simd_and(temp3, temp23);
409                BitBlock temp26 = simd_andc(temp10, temp21);
410                lex.Hash = simd_and(temp3, temp26);
411                BitBlock temp27 = simd_and(temp16, temp7);
412                BitBlock temp28 = simd_andc(temp9, temp13);
413                lex.x = simd_and(temp27, temp28);
414                BitBlock temp29 = simd_and(temp9, temp5);
415                lex.Colon = simd_and(temp8, temp29);
416                BitBlock temp30 = simd_and(temp18, temp23);
417                BitBlock temp31 = simd_or(temp30, lex.Colon);
418                BitBlock temp32 = simd_andc(temp16, basis_bits.bit_2);
419                BitBlock temp33 = simd_or(basis_bits.bit_5, temp10);
420                BitBlock temp34 = simd_and(basis_bits.bit_4, temp33);
421                BitBlock temp35 = simd_not(temp34);
422                BitBlock temp36 = simd_or(temp21, temp13);
423                BitBlock temp37 = simd_or(simd_and(basis_bits.bit_3, temp35), simd_andc(temp36, basis_bits.bit_3));
424                BitBlock temp38 = simd_and(temp32, temp37);
425                BitBlock temp39 = simd_or(temp31, temp38);
426                BitBlock temp40 = simd_and(temp16, basis_bits.bit_2);
427                BitBlock temp41 = simd_and(temp40, temp37);
428                lex.ASCII_name_start = simd_or(temp39, temp41);
429                BitBlock temp42 = simd_or(temp30, lex.Hyphen);
430                BitBlock temp43 = simd_and(temp3, temp15);
431                BitBlock temp44 = simd_or(temp42, temp43);
432                BitBlock temp45 = simd_andc(temp8, temp34);
433                BitBlock temp46 = simd_or(temp44, temp45);
434                BitBlock temp47 = simd_or(temp46, temp38);
435                lex.ASCII_name_char = simd_or(temp47, temp41);
436                lex.NameScan = simd_or(lex.ASCII_name_char, basis_bits.bit_0);
437                BitBlock temp48 = simd_or(temp1, basis_bits.bit_2);
438                BitBlock x00_x1F = simd_not(temp48);
439                BitBlock temp49 = simd_or(basis_bits.bit_2, basis_bits.bit_3);
440                BitBlock temp50 = simd_or(temp1, temp49);
441                lex.CR = simd_andc(temp20, temp50);
442                lex.LF = simd_andc(temp29, temp50);
443                BitBlock temp51 = simd_and(temp9, temp19);
444                lex.HT = simd_andc(temp51, temp50);
445                lex.SP = simd_andc(temp3, temp36);
446                BitBlock temp52 = simd_or(temp20, temp29);
447                BitBlock temp53 = simd_or(temp52, temp51);
448                BitBlock temp54 = simd_andc(temp53, temp50);
449                lex.WS = simd_or(temp54, lex.SP);
450                BitBlock temp55 = simd_or(basis_bits.bit_5, basis_bits.bit_6);
451                BitBlock temp56 = simd_and(basis_bits.bit_4, temp55);
452                lex.Digit = simd_andc(temp8, temp56);
453                BitBlock temp57 = simd_andc(temp16, temp49);
454                BitBlock temp58 = simd_andc(temp57, basis_bits.bit_4);
455                BitBlock temp59 = simd_not(temp10);
456                BitBlock temp60 = simd_or(simd_and(basis_bits.bit_5, temp59), simd_andc(temp13, basis_bits.bit_5));
457                BitBlock temp61 = simd_and(temp58, temp60);
458                BitBlock temp62 = simd_or(lex.Digit, temp61);
459                BitBlock temp63 = simd_and(temp16, temp2);
460                BitBlock temp64 = simd_andc(temp63, basis_bits.bit_4);
461                BitBlock temp65 = simd_and(temp64, temp60);
462                lex.Hex = simd_or(temp62, temp65);
463                BitBlock lex_error = simd_andc(x00_x1F, lex.WS);
464                if (bitblock::any(simd_and(lex_error, EOF_mask)))
465                {
466                        assert_0_error("Error: illegal character", simd_and(lex_error, EOF_mask));
467                }
468                u8.unibyte = simd_not(basis_bits.bit_0);
469                u8.suffix = simd<1>::constant<0>();
470                BitBlock u8_error = simd<1>::constant<0>();
471                BitBlock u8_FFFE_FFFF = simd<1>::constant<0>();
472                BitBlock u8anyscope = simd<1>::constant<0>();
473                if (bitblock::any(simd_or(basis_bits.bit_0, carry_set_0.CarryRange(0, 10))))
474                {
475                        u8.prefix = simd_and(basis_bits.bit_0, basis_bits.bit_1);
476                        u8.prefix2 = simd_andc(u8.prefix, basis_bits.bit_2);
477                        u8.prefix3 = simd_and(u8.prefix, temp2);
478                        u8.prefix4 = simd_and(u8.prefix, temp7);
479                        u8.suffix = simd_andc(basis_bits.bit_0, basis_bits.bit_1);
480                        BitBlock temp66 = simd_andc(u8.prefix, temp49);
481                        BitBlock temp67 = simd_or(temp21, basis_bits.bit_6);
482                        BitBlock temp68 = simd_andc(temp66, temp67);
483                        BitBlock temp69 = simd_and(basis_bits.bit_5, temp13);
484                        BitBlock temp70 = simd_or(basis_bits.bit_4, temp69);
485                        BitBlock temp71 = simd_and(u8.prefix4, temp70);
486                        u8.badprefix = simd_or(temp68, temp71);
487                        u8_error = u8.badprefix;
488                        u8.scope22 = carry_set_0.BitBlock_advance_ci_co(u8.prefix2, carry_set_0.GetCarry(0), 0);
489                        u8anyscope = u8.scope22;
490                        if (bitblock::any(simd_or(simd_or(u8.prefix3, u8.prefix4), carry_set_0.CarryRange(1, 9))))
491                        {
492                                BitBlock xE0 = simd_andc(u8.prefix3, temp36);
493                                BitBlock xED = simd_and(u8.prefix3, temp20);
494                                BitBlock xF0 = simd_andc(u8.prefix4, temp36);
495                                BitBlock temp72 = simd_andc(temp4, temp13);
496                                BitBlock xF4 = simd_and(u8.prefix4, temp72);
497                                u8.xA0_xBF = simd_and(u8.suffix, basis_bits.bit_2);
498                                u8.x80_x9F = simd_andc(u8.suffix, basis_bits.bit_2);
499                                u8.x90_xBF = simd_and(u8.suffix, temp49);
500                                u8.x80_x8F = simd_andc(u8.suffix, temp49);
501                                BitBlock xEF = simd_and(u8.prefix3, temp23);
502                                BitBlock temp73 = simd_and(u8.suffix, temp7);
503                                u8.xBF = simd_and(temp73, temp23);
504                                u8.xBE = simd_and(temp73, temp15);
505                                u8.scope32 = carry_set_0.BitBlock_advance_ci_co(u8.prefix3, carry_set_0.GetCarry(1), 1);
506                                u8.scope33 = carry_set_0.BitBlock_advance_ci_co(u8.scope32, carry_set_0.GetCarry(2), 2);
507                                u8.scope42 = carry_set_0.BitBlock_advance_ci_co(u8.prefix4, carry_set_0.GetCarry(3), 3);
508                                u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42, carry_set_0.GetCarry(4), 4);
509                                u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43, carry_set_0.GetCarry(5), 5);
510                                BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xE0, xF0), carry_set_0.GetCarry(6), 6);
511                                BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xED, xF4), carry_set_0.GetCarry(7), 7);
512                                u8.xE0_scope = simd_and(u8.scope32, E0_F0_scope);
513                                u8.xED_scope = simd_and(u8.scope32, ED_F4_scope);
514                                u8.xF0_scope = simd_and(u8.scope42, E0_F0_scope);
515                                u8.xF4_scope = simd_and(u8.scope42, ED_F4_scope);
516                                u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF, carry_set_0.GetCarry(8), 8);
517                                BitBlock u8lastscope = simd_or(simd_or(u8.scope22, u8.scope33), u8.scope44);
518                                u8anyscope = simd_or(simd_or(simd_or(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
519                                BitBlock u8error1 = simd_and(u8.xE0_scope, u8.x80_x9F);
520                                BitBlock u8error2 = simd_and(u8.xED_scope, u8.xA0_xBF);
521                                BitBlock u8error3 = simd_and(u8.xF0_scope, u8.x80_x8F);
522                                BitBlock u8error4 = simd_and(u8.xF4_scope, u8.x90_xBF);
523                                u8_error = simd_or(u8_error, simd_or(simd_or(simd_or(u8error1, u8error2), u8error3), u8error4));
524                                BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd_and(u8.xEF_scope, u8.xBF), carry_set_0.GetCarry(9), 9);
525                                u8_FFFE_FFFF = simd_and(EF_BF_pending, simd_or(u8.xBE, u8.xBF));
526                        }
527                        else
528                        {
529                                carry_set_0.CarryDequeueEnqueue(1, 9);
530                        }
531                        BitBlock u8mismatch = simd_xor(u8anyscope, u8.suffix);
532                        if (bitblock::any(simd_or(simd_or(u8_error, u8mismatch), u8_FFFE_FFFF)))
533                        {
534                                assert_0_error("UTF-8 error found", simd_or(simd_or(u8_error, u8mismatch), u8_FFFE_FFFF));
535                        }
536                }
537                else
538                {
539                        carry_set_0.CarryDequeueEnqueue(0, 10);
540                }
541        }
542       
543        CarryDeclare(carry_set_0, 10, 0);
544};
545 
546struct Parse_CtCDPI
547{
548        Parse_CtCDPI()
549        {
550                carry_set_0.SetCarry(carry_set_0.CarryFlip(carry_set_0.GetCarry(2)), 2);
551        }
552         
553        IDISA_INLINE void do_block(struct Lex & lex, struct Marker & marker, struct CtCDPI_Callouts & ctCDPI_Callouts, struct Check_streams & check_streams)
554        {
555                ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
556                ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
557                ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
558                ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
559                ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
560                ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
561                ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
562                ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
563                BitBlock CtCDPI_starts = simd<1>::constant<0>();
564                BitBlock CtCDPI_ends = simd<1>::constant<0>();
565                BitBlock ctCDPI_mask = simd<1>::constant<0>();
566                BitBlock v = simd_or(lex.LAngle, lex.Hyphen);
567                BitBlock w = simd_or(lex.Hyphen, lex.QMark);
568                BitBlock v1 = carry_set_0.BitBlock_advance_n_<1>(v, carry_set_0.Pending64(0), 0);
569                BitBlock w1 = carry_set_0.BitBlock_advance_n_<1>(w, carry_set_0.Pending64(1), 1);
570                BitBlock LAngle_scope = simd_andc(v1, w1);
571                BitBlock PI_opener = simd_and(LAngle_scope, lex.QMark);
572                BitBlock CtCD_opener = simd_and(LAngle_scope, lex.Exclam);
573                BitBlock CtCDPI_opener = simd_or(PI_opener, CtCD_opener);
574                BitBlock CD_closer = simd<1>::constant<0>();
575                BitBlock DoubleHyphen = simd_and(simd_and(v1, w1), lex.Hyphen);
576                if (bitblock::any(simd_or(lex.RBracket, carry_set_0.CarryRange(0, 2))))
577                {
578                        BitBlock DoubleRBracket = simd_and(carry_set_0.BitBlock_advance_ci_co(lex.RBracket, carry_set_0.GetCarry(0), 0), lex.RBracket);
579                        CD_closer = simd_and(carry_set_0.BitBlock_advance_ci_co(DoubleRBracket, carry_set_0.GetCarry(1), 1), lex.RAngle);
580                }
581                else
582                {
583                        carry_set_0.CarryDequeueEnqueue(0, 2);
584                }
585                BitBlock PI_closer = simd_and(simd_andc(w1, v1), lex.RAngle);
586                BitBlock CtCDPI_Cursor = carry_set_0.BitBlock_scantofirst(CtCDPI_opener, carry_set_0.GetCarry(2), 2);
587                if (bitblock::any(simd_or(CtCDPI_Cursor, carry_set_0.CarryRange(3, 13))))
588                {
589                        CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
590                        BitBlock PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
591                        BitBlock CD_Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), carry_set_0.GetCarry(3), 3);
592                        BitBlock CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
593                        BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
594                        if (bitblock::any(simd_or(PI_Cursor, carry_set_0.CarryRange(4, 4))))
595                        {
596                                ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
597                                PI_Cursor = carry_set_0.BitBlock_advance_ci_co(PI_Cursor, carry_set_0.GetCarry(4), 4);
598                                ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
599                                BitBlock PI_name_end = carry_set_0.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, carry_set_0.GetCarry(5), 5);
600                                BitBlock PI_error = simd_and(PI_Cursor, PI_name_end);
601                                BitBlock PI_noWS = simd_andc(PI_name_end, lex.WS);
602                                PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(carry_set_0.BitBlock_advance_ci_co(PI_noWS, carry_set_0.GetCarry(6), 6), PI_closer)));
603                                if (bitblock::any(PI_error))
604                                {
605                                        assert_0_error("Error in PI syntax", PI_error);
606                                }
607                                ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
608                                PI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(PI_name_end, simd_not(PI_closer), carry_set_0.GetCarry(7), 7);
609                                ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
610                                CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
611                        }
612                        else
613                        {
614                                carry_set_0.CarryDequeueEnqueue(4, 4);
615                        }
616                        if (bitblock::any(simd_or(CD_Cursor, carry_set_0.CarryRange(8, 1))))
617                        {
618                                ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
619                                CD_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CD_Cursor, simd_not(CD_closer), carry_set_0.GetCarry(8), 8);
620                                ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
621                                CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
622                        }
623                        else
624                        {
625                                carry_set_0.CarryDequeueEnqueue(8, 1);
626                        }
627                        if (bitblock::any(simd_or(Ct_Cursor, carry_set_0.CarryRange(9, 5))))
628                        {
629                                ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
630                                Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(Ct_Cursor, carry_set_0.GetCarry(9), 9);
631                                BitBlock Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
632                                Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_advance_ci_co(Ct_Cursor, carry_set_0.GetCarry(10), 10), carry_set_0.GetCarry(11), 11);
633                                Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_scanthru_ci_co(Ct_Cursor, simd_not(DoubleHyphen), carry_set_0.GetCarry(12), 12), carry_set_0.GetCarry(13), 13);
634                                if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle))))
635                                {
636                                        assert_0_error("Error in comment syntax", simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)));
637                                }
638                                ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
639                                CtCDPI_ends = simd_or(CtCDPI_ends, Ct_Cursor);
640                        }
641                        else
642                        {
643                                carry_set_0.CarryDequeueEnqueue(9, 5);
644                        }
645                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
646                        ctCDPI_mask = carry_set_0.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, carry_set_0.GetCarry(14), 14);
647                        if (bitblock::any(simd<1>::constant<0>()))
648                        {
649                                assert_0_error("Error in comment, CDATA or processing instruction syntax", simd<1>::constant<0>());
650                        }
651                        CtCDPI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_not(CtCDPI_opener), carry_set_0.GetCarry(15), 15);
652                        while (bitblock::any(CtCDPI_Cursor))
653                        {
654                                CarryDeclare(carry_set_1, 13, 0);
655                                CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
656                                BitBlock PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
657                                BitBlock CD_Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), simd<1>::constant<0>(), 0);
658                                BitBlock CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
659                                BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
660                                if (bitblock::any(PI_Cursor))
661                                {
662                                        ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
663                                        PI_Cursor = carry_set_1.BitBlock_advance_ci_co(PI_Cursor, simd<1>::constant<0>(), 1);
664                                        ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
665                                        BitBlock PI_name_end = carry_set_1.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, simd<1>::constant<0>(), 2);
666                                        BitBlock PI_error = simd_and(PI_Cursor, PI_name_end);
667                                        BitBlock PI_noWS = simd_andc(PI_name_end, lex.WS);
668                                        PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(carry_set_1.BitBlock_advance_ci_co(PI_noWS, simd<1>::constant<0>(), 3), PI_closer)));
669                                        if (bitblock::any(PI_error))
670                                        {
671                                                assert_0_error("Error in PI syntax", PI_error);
672                                        }
673                                        ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
674                                        PI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(PI_name_end, simd_not(PI_closer), simd<1>::constant<0>(), 4);
675                                        ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
676                                        CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
677                                }
678                                if (bitblock::any(CD_Cursor))
679                                {
680                                        ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
681                                        CD_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CD_Cursor, simd_not(CD_closer), simd<1>::constant<0>(), 5);
682                                        ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
683                                        CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
684                                }
685                                if (bitblock::any(Ct_Cursor))
686                                {
687                                        ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
688                                        Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 6);
689                                        BitBlock Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
690                                        Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 7), simd<1>::constant<0>(), 8);
691                                        Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_scanthru_ci_co(Ct_Cursor, simd_not(DoubleHyphen), simd<1>::constant<0>(), 9), simd<1>::constant<0>(), 10);
692                                        if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle))))
693                                        {
694                                                assert_0_error("Error in comment syntax", simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)));
695                                        }
696                                        ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
697                                        CtCDPI_ends = simd_or(CtCDPI_ends, Ct_Cursor);
698                                }
699                                CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
700                                ctCDPI_mask = carry_set_1.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, simd<1>::constant<0>(), 11);
701                                if (bitblock::any(simd<1>::constant<0>()))
702                                {
703                                        assert_0_error("Error in comment, CDATA or processing instruction syntax", simd<1>::constant<0>());
704                                }
705                                CtCDPI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_not(CtCDPI_opener), simd<1>::constant<0>(), 12);
706                                LocalCarryCombine(carry_set_0, carry_set_1, 3, 13);
707                        }
708                }
709                else
710                {
711                        carry_set_0.CarryDequeueEnqueue(3, 13);
712                }
713                check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS, lex.LAngle), carry_set_0.BitBlock_inclusive_span(simd_or(ctCDPI_Callouts.Ct_starts, ctCDPI_Callouts.PI_starts), simd_or(ctCDPI_Callouts.Ct_ends, ctCDPI_Callouts.PI_ends), carry_set_0.GetCarry(16), 16)), CtCDPI_starts), EOF_mask);
714                marker.LAngle_scope = simd_andc(LAngle_scope, ctCDPI_mask);
715                marker.Ref_opener = simd_andc(lex.RefStart, ctCDPI_mask);
716                marker.CD_closer = simd_andc(CD_closer, ctCDPI_mask);
717                carry_set_0.CarryAdjust(17);
718        }
719       
720        void do_final_block(struct Lex & lex, struct Marker & marker, struct CtCDPI_Callouts & ctCDPI_Callouts, struct Check_streams & check_streams, BitBlock & EOF_mask)
721        {
722                ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
723                ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
724                ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
725                ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
726                ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
727                ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
728                ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
729                ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
730                BitBlock CtCDPI_starts = simd<1>::constant<0>();
731                BitBlock CtCDPI_ends = simd<1>::constant<0>();
732                BitBlock ctCDPI_mask = simd<1>::constant<0>();
733                BitBlock v = simd_or(lex.LAngle, lex.Hyphen);
734                BitBlock w = simd_or(lex.Hyphen, lex.QMark);
735                BitBlock v1 = carry_set_0.BitBlock_advance_n_<1>(v, carry_set_0.Pending64(0), 0);
736                BitBlock w1 = carry_set_0.BitBlock_advance_n_<1>(w, carry_set_0.Pending64(1), 1);
737                BitBlock LAngle_scope = simd_andc(v1, w1);
738                BitBlock PI_opener = simd_and(LAngle_scope, lex.QMark);
739                BitBlock CtCD_opener = simd_and(LAngle_scope, lex.Exclam);
740                BitBlock CtCDPI_opener = simd_or(PI_opener, CtCD_opener);
741                BitBlock CD_closer = simd<1>::constant<0>();
742                BitBlock DoubleHyphen = simd_and(simd_and(v1, w1), lex.Hyphen);
743                if (bitblock::any(simd_or(lex.RBracket, carry_set_0.CarryRange(0, 2))))
744                {
745                        BitBlock DoubleRBracket = simd_and(carry_set_0.BitBlock_advance_ci_co(lex.RBracket, carry_set_0.GetCarry(0), 0), lex.RBracket);
746                        CD_closer = simd_and(carry_set_0.BitBlock_advance_ci_co(DoubleRBracket, carry_set_0.GetCarry(1), 1), lex.RAngle);
747                }
748                else
749                {
750                        carry_set_0.CarryDequeueEnqueue(0, 2);
751                }
752                BitBlock PI_closer = simd_and(simd_andc(w1, v1), lex.RAngle);
753                BitBlock CtCDPI_Cursor = carry_set_0.BitBlock_scantofirst(CtCDPI_opener, carry_set_0.GetCarry(2), 2);
754                if (bitblock::any(simd_or(simd_and(CtCDPI_Cursor, EOF_mask), carry_set_0.CarryRange(3, 13))))
755                {
756                        CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
757                        BitBlock PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
758                        BitBlock CD_Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), carry_set_0.GetCarry(3), 3);
759                        BitBlock CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
760                        BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
761                        if (bitblock::any(simd_or(PI_Cursor, carry_set_0.CarryRange(4, 4))))
762                        {
763                                ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
764                                PI_Cursor = carry_set_0.BitBlock_advance_ci_co(PI_Cursor, carry_set_0.GetCarry(4), 4);
765                                ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
766                                BitBlock PI_name_end = carry_set_0.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, carry_set_0.GetCarry(5), 5);
767                                BitBlock PI_error = simd_and(PI_Cursor, PI_name_end);
768                                BitBlock PI_noWS = simd_andc(PI_name_end, lex.WS);
769                                PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(carry_set_0.BitBlock_advance_ci_co(PI_noWS, carry_set_0.GetCarry(6), 6), PI_closer)));
770                                if (bitblock::any(PI_error))
771                                {
772                                        assert_0_error("Error in PI syntax", PI_error);
773                                }
774                                ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
775                                PI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(PI_name_end, simd_andc(EOF_mask, PI_closer), carry_set_0.GetCarry(7), 7);
776                                ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
777                                CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
778                        }
779                        else
780                        {
781                                carry_set_0.CarryDequeueEnqueue(4, 4);
782                        }
783                        if (bitblock::any(simd_or(CD_Cursor, carry_set_0.CarryRange(8, 1))))
784                        {
785                                ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
786                                CD_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CD_Cursor, simd_andc(EOF_mask, CD_closer), carry_set_0.GetCarry(8), 8);
787                                ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
788                                CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
789                        }
790                        else
791                        {
792                                carry_set_0.CarryDequeueEnqueue(8, 1);
793                        }
794                        if (bitblock::any(simd_or(Ct_Cursor, carry_set_0.CarryRange(9, 5))))
795                        {
796                                ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
797                                Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(Ct_Cursor, carry_set_0.GetCarry(9), 9);
798                                BitBlock Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
799                                Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_advance_ci_co(Ct_Cursor, carry_set_0.GetCarry(10), 10), carry_set_0.GetCarry(11), 11);
800                                Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_scanthru_ci_co(Ct_Cursor, simd_andc(EOF_mask, DoubleHyphen), carry_set_0.GetCarry(12), 12), carry_set_0.GetCarry(13), 13);
801                                if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle))))
802                                {
803                                        assert_0_error("Error in comment syntax", simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)));
804                                }
805                                ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
806                                CtCDPI_ends = simd_or(CtCDPI_ends, Ct_Cursor);
807                        }
808                        else
809                        {
810                                carry_set_0.CarryDequeueEnqueue(9, 5);
811                        }
812                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
813                        ctCDPI_mask = carry_set_0.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, carry_set_0.GetCarry(14), 14);
814                        if (bitblock::any(simd_andc(ctCDPI_mask, EOF_mask)))
815                        {
816                                assert_0_error("Error in comment, CDATA or processing instruction syntax", simd_andc(ctCDPI_mask, EOF_mask));
817                        }
818                        CtCDPI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_andc(EOF_mask, CtCDPI_opener), carry_set_0.GetCarry(15), 15);
819                        while (bitblock::any(simd_and(CtCDPI_Cursor, EOF_mask)))
820                        {
821                                CarryDeclare(carry_set_1, 13, 0);
822                                CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
823                                BitBlock PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
824                                BitBlock CD_Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), simd<1>::constant<0>(), 0);
825                                BitBlock CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
826                                BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
827                                if (bitblock::any(PI_Cursor))
828                                {
829                                        ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
830                                        PI_Cursor = carry_set_1.BitBlock_advance_ci_co(PI_Cursor, simd<1>::constant<0>(), 1);
831                                        ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
832                                        BitBlock PI_name_end = carry_set_1.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, simd<1>::constant<0>(), 2);
833                                        BitBlock PI_error = simd_and(PI_Cursor, PI_name_end);
834                                        BitBlock PI_noWS = simd_andc(PI_name_end, lex.WS);
835                                        PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(carry_set_1.BitBlock_advance_ci_co(PI_noWS, simd<1>::constant<0>(), 3), PI_closer)));
836                                        if (bitblock::any(PI_error))
837                                        {
838                                                assert_0_error("Error in PI syntax", PI_error);
839                                        }
840                                        ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
841                                        PI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(PI_name_end, simd_andc(EOF_mask, PI_closer), simd<1>::constant<0>(), 4);
842                                        ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
843                                        CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
844                                }
845                                if (bitblock::any(CD_Cursor))
846                                {
847                                        ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
848                                        CD_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CD_Cursor, simd_andc(EOF_mask, CD_closer), simd<1>::constant<0>(), 5);
849                                        ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
850                                        CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
851                                }
852                                if (bitblock::any(Ct_Cursor))
853                                {
854                                        ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
855                                        Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 6);
856                                        BitBlock Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
857                                        Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 7), simd<1>::constant<0>(), 8);
858                                        Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_scanthru_ci_co(Ct_Cursor, simd_andc(EOF_mask, DoubleHyphen), simd<1>::constant<0>(), 9), simd<1>::constant<0>(), 10);
859                                        if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle))))
860                                        {
861                                                assert_0_error("Error in comment syntax", simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)));
862                                        }
863                                        ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
864                                        CtCDPI_ends = simd_or(CtCDPI_ends, Ct_Cursor);
865                                }
866                                CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
867                                ctCDPI_mask = carry_set_1.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, simd<1>::constant<0>(), 11);
868                                if (bitblock::any(simd_andc(ctCDPI_mask, EOF_mask)))
869                                {
870                                        assert_0_error("Error in comment, CDATA or processing instruction syntax", simd_andc(ctCDPI_mask, EOF_mask));
871                                }
872                                CtCDPI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_andc(EOF_mask, CtCDPI_opener), simd<1>::constant<0>(), 12);
873                                LocalCarryCombine(carry_set_0, carry_set_1, 3, 13);
874                        }
875                }
876                else
877                {
878                        carry_set_0.CarryDequeueEnqueue(3, 13);
879                }
880                check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS, lex.LAngle), carry_set_0.BitBlock_inclusive_span(simd_or(ctCDPI_Callouts.Ct_starts, ctCDPI_Callouts.PI_starts), simd_or(ctCDPI_Callouts.Ct_ends, ctCDPI_Callouts.PI_ends), carry_set_0.GetCarry(16), 16)), CtCDPI_starts), EOF_mask);
881                marker.LAngle_scope = simd_andc(LAngle_scope, ctCDPI_mask);
882                marker.Ref_opener = simd_andc(lex.RefStart, ctCDPI_mask);
883                marker.CD_closer = simd_andc(CD_closer, ctCDPI_mask);
884        }
885       
886        CarryDeclare(carry_set_0, 17, 2);
887};
888 
889struct Parse_tags
890{
891        Parse_tags()
892        {
893               
894        }
895         
896        IDISA_INLINE void do_block(struct Lex & lex, struct Marker & marker, struct Tag_Callouts & tag_Callouts)
897        {
898                BitBlock EqExpected = simd<1>::constant<0>();
899                BitBlock AttListEnd = simd<1>::constant<0>();
900                BitBlock DQuoteDelim = simd_or(lex.DQuote, lex.LAngle);
901                BitBlock SQuoteDelim = simd_or(lex.SQuote, lex.LAngle);
902                BitBlock AttListDelim = simd_or(lex.Slash, lex.RAngle);
903                tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope, lex.Slash);
904                tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope, lex.Slash);
905                tag_Callouts.ElemName_ends = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_starts, lex.NameScan, carry_set_0.GetCarry(0), 0);
906                BitBlock ParseError = simd_and(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
907                tag_Callouts.AttName_starts = simd<1>::constant<0>();
908                tag_Callouts.AttName_ends = simd<1>::constant<0>();
909                tag_Callouts.AttVal_starts = simd<1>::constant<0>();
910                tag_Callouts.AttVal_ends = simd<1>::constant<0>();
911                if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends, lex.WS), carry_set_0.CarryRange(1, 8))))
912                {
913                        BitBlock AfterWS = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_ends, lex.WS, carry_set_0.GetCarry(1), 1);
914                        AttListEnd = simd_and(AfterWS, AttListDelim);
915                        BitBlock AttNameStart = simd_andc(AfterWS, AttListDelim);
916                        if (bitblock::any(simd_or(AttNameStart, carry_set_0.CarryRange(2, 7))))
917                        {
918                                ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
919                                tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
920                                BitBlock AttNameFollow = carry_set_0.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, carry_set_0.GetCarry(2), 2);
921                                tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
922                                if (bitblock::any(simd_or(simd_and(AttNameFollow, lex.WS), carry_set_0.CarryRange(3, 1))))
923                                {
924                                        EqExpected = carry_set_0.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, carry_set_0.GetCarry(3), 3);
925                                }
926                                else
927                                {
928                                        EqExpected = AttNameFollow;
929                                        carry_set_0.CarryDequeueEnqueue(3, 1);
930                                }
931                                ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
932                                BitBlock AttValPos = carry_set_0.BitBlock_advance_then_scanthru(EqExpected, lex.WS, carry_set_0.GetCarry(4), 4);
933                                tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
934                                BitBlock DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
935                                BitBlock SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
936                                BitBlock DQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(DQuoteAttVal, simd_not(DQuoteDelim), carry_set_0.GetCarry(5), 5);
937                                BitBlock SQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(SQuoteAttVal, simd_not(SQuoteDelim), carry_set_0.GetCarry(6), 6);
938                                BitBlock AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
939                                ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
940                                BitBlock AttValFollow = carry_set_0.BitBlock_advance_ci_co(AttValEnd, carry_set_0.GetCarry(7), 7);
941                                tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
942                                if (bitblock::any(simd_or(simd_and(AttValFollow, lex.WS), carry_set_0.CarryRange(8, 1))))
943                                {
944                                        AfterWS = carry_set_0.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, carry_set_0.GetCarry(8), 8);
945                                        AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
946                                        AttNameStart = simd_andc(AfterWS, AttListDelim);
947                                }
948                                else
949                                {
950                                        AttListEnd = simd_or(AttListEnd, simd_and(AttValFollow, AttListDelim));
951                                        AttNameStart = simd_andc(AttValFollow, AttListDelim);
952                                        carry_set_0.CarryDequeueEnqueue(8, 1);
953                                }
954                                ParseError = simd_or(ParseError, simd_and(AttValFollow, AttNameStart));
955                                while (bitblock::any(AttNameStart))
956                                {
957                                        CarryDeclare(carry_set_1, 7, 0);
958                                        ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
959                                        tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
960                                        BitBlock AttNameFollow = carry_set_1.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, simd<1>::constant<0>(), 0);
961                                        tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
962                                        if (bitblock::any(simd_and(AttNameFollow, lex.WS)))
963                                        {
964                                                EqExpected = carry_set_1.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, simd<1>::constant<0>(), 1);
965                                        }
966                                        else
967                                        {
968                                                EqExpected = AttNameFollow;
969                                        }
970                                        ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
971                                        BitBlock AttValPos = carry_set_1.BitBlock_advance_then_scanthru(EqExpected, lex.WS, simd<1>::constant<0>(), 2);
972                                        tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
973                                        BitBlock DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
974                                        BitBlock SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
975                                        BitBlock DQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(DQuoteAttVal, simd_not(DQuoteDelim), simd<1>::constant<0>(), 3);
976                                        BitBlock SQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(SQuoteAttVal, simd_not(SQuoteDelim), simd<1>::constant<0>(), 4);
977                                        BitBlock AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
978                                        ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
979                                        BitBlock AttValFollow = carry_set_1.BitBlock_advance_ci_co(AttValEnd, simd<1>::constant<0>(), 5);
980                                        tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
981                                        if (bitblock::any(simd_and(AttValFollow, lex.WS)))
982                                        {
983                                                AfterWS = carry_set_1.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, simd<1>::constant<0>(), 6);
984                                                AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
985                                                AttNameStart = simd_andc(AfterWS, AttListDelim);
986                                        }
987                                        else
988                                        {
989                                                AttListEnd = simd_or(AttListEnd, simd_and(AttValFollow, AttListDelim));
990                                                AttNameStart = simd_andc(AttValFollow, AttListDelim);
991                                        }
992                                        ParseError = simd_or(ParseError, simd_and(AttValFollow, AttNameStart));
993                                        LocalCarryCombine(carry_set_0, carry_set_1, 2, 7);
994                                }
995                        }
996                        else
997                        {
998                                carry_set_0.CarryDequeueEnqueue(2, 7);
999                        }
1000                }
1001                else
1002                {
1003                        AttListEnd = simd_and(tag_Callouts.ElemName_ends, AttListDelim);
1004                        ParseError = simd_or(ParseError, simd_andc(tag_Callouts.ElemName_ends, AttListDelim));
1005                        carry_set_0.CarryDequeueEnqueue(1, 8);
1006                }
1007                BitBlock STagEnds = simd_and(AttListEnd, lex.RAngle);
1008                tag_Callouts.EmptyTag_marks = carry_set_0.BitBlock_advance_ci_co(simd_and(AttListEnd, lex.Slash), carry_set_0.GetCarry(9), 9);
1009                ParseError = simd_or(ParseError, simd_andc(tag_Callouts.EmptyTag_marks, lex.RAngle));
1010                BitBlock EndTagEnds = carry_set_0.BitBlock_advance_then_scanthru(tag_Callouts.EndTag_marks, lex.NameScan, carry_set_0.GetCarry(10), 10);
1011                if (bitblock::any(simd_or(simd_and(EndTagEnds, lex.WS), carry_set_0.CarryRange(11, 1))))
1012                {
1013                        EndTagEnds = carry_set_0.BitBlock_scanthru_ci_co(EndTagEnds, lex.WS, carry_set_0.GetCarry(11), 11);
1014                }
1015                else
1016                {
1017                        carry_set_0.CarryDequeueEnqueue(11, 1);
1018                }
1019                ParseError = simd_or(ParseError, simd_andc(EndTagEnds, lex.RAngle));
1020                if (bitblock::any(ParseError))
1021                {
1022                        assert_0_error("Tag parsing error found", ParseError);
1023                }
1024                tag_Callouts.AttVal_spans = carry_set_0.BitBlock_span_upto(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends, carry_set_0.GetCarry(12), 12);
1025                carry_set_0.CarryAdjust(13);
1026        }
1027       
1028        void do_final_block(struct Lex & lex, struct Marker & marker, struct Tag_Callouts & tag_Callouts, BitBlock & EOF_mask)
1029        {
1030                BitBlock EqExpected = simd<1>::constant<0>();
1031                BitBlock AttListEnd = simd<1>::constant<0>();
1032                BitBlock DQuoteDelim = simd_or(lex.DQuote, lex.LAngle);
1033                BitBlock SQuoteDelim = simd_or(lex.SQuote, lex.LAngle);
1034                BitBlock AttListDelim = simd_or(lex.Slash, lex.RAngle);
1035                tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope, lex.Slash);
1036                tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope, lex.Slash);
1037                tag_Callouts.ElemName_ends = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_starts, lex.NameScan, carry_set_0.GetCarry(0), 0);
1038                BitBlock ParseError = simd_and(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
1039                tag_Callouts.AttName_starts = simd<1>::constant<0>();
1040                tag_Callouts.AttName_ends = simd<1>::constant<0>();
1041                tag_Callouts.AttVal_starts = simd<1>::constant<0>();
1042                tag_Callouts.AttVal_ends = simd<1>::constant<0>();
1043                if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends, lex.WS), carry_set_0.CarryRange(1, 8))))
1044                {
1045                        BitBlock AfterWS = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_ends, lex.WS, carry_set_0.GetCarry(1), 1);
1046                        AttListEnd = simd_and(AfterWS, AttListDelim);
1047                        BitBlock AttNameStart = simd_andc(AfterWS, AttListDelim);
1048                        if (bitblock::any(simd_or(simd_and(AttNameStart, EOF_mask), carry_set_0.CarryRange(2, 7))))
1049                        {
1050                                ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
1051                                tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
1052                                BitBlock AttNameFollow = carry_set_0.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, carry_set_0.GetCarry(2), 2);
1053                                tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
1054                                if (bitblock::any(simd_or(simd_and(AttNameFollow, lex.WS), carry_set_0.CarryRange(3, 1))))
1055                                {
1056                                        EqExpected = carry_set_0.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, carry_set_0.GetCarry(3), 3);
1057                                }
1058                                else
1059                                {
1060                                        EqExpected = AttNameFollow;
1061                                        carry_set_0.CarryDequeueEnqueue(3, 1);
1062                                }
1063                                ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
1064                                BitBlock AttValPos = carry_set_0.BitBlock_advance_then_scanthru(EqExpected, lex.WS, carry_set_0.GetCarry(4), 4);
1065                                tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
1066                                BitBlock DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
1067                                BitBlock SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
1068                                BitBlock DQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(DQuoteAttVal, simd_andc(EOF_mask, DQuoteDelim), carry_set_0.GetCarry(5), 5);
1069                                BitBlock SQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(SQuoteAttVal, simd_andc(EOF_mask, SQuoteDelim), carry_set_0.GetCarry(6), 6);
1070                                BitBlock AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
1071                                ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
1072                                BitBlock AttValFollow = carry_set_0.BitBlock_advance_ci_co(AttValEnd, carry_set_0.GetCarry(7), 7);
1073                                tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
1074                                if (bitblock::any(simd_or(simd_and(AttValFollow, lex.WS), carry_set_0.CarryRange(8, 1))))
1075                                {
1076                                        AfterWS = carry_set_0.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, carry_set_0.GetCarry(8), 8);
1077                                        AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
1078                                        AttNameStart = simd_andc(AfterWS, AttListDelim);
1079                                }
1080                                else
1081                                {
1082                                        AttListEnd = simd_or(AttListEnd, simd_and(AttValFollow, AttListDelim));
1083                                        AttNameStart = simd_andc(AttValFollow, AttListDelim);
1084                                        carry_set_0.CarryDequeueEnqueue(8, 1);
1085                                }
1086                                ParseError = simd_or(ParseError, simd_and(AttValFollow, AttNameStart));
1087                                while (bitblock::any(simd_and(AttNameStart, EOF_mask)))
1088                                {
1089                                        CarryDeclare(carry_set_1, 7, 0);
1090                                        ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
1091                                        tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
1092                                        BitBlock AttNameFollow = carry_set_1.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, simd<1>::constant<0>(), 0);
1093                                        tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
1094                                        if (bitblock::any(simd_and(AttNameFollow, lex.WS)))
1095                                        {
1096                                                EqExpected = carry_set_1.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, simd<1>::constant<0>(), 1);
1097                                        }
1098                                        else
1099                                        {
1100                                                EqExpected = AttNameFollow;
1101                                        }
1102                                        ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
1103                                        BitBlock AttValPos = carry_set_1.BitBlock_advance_then_scanthru(EqExpected, lex.WS, simd<1>::constant<0>(), 2);
1104                                        tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
1105                                        BitBlock DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
1106                                        BitBlock SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
1107                                        BitBlock DQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(DQuoteAttVal, simd_andc(EOF_mask, DQuoteDelim), simd<1>::constant<0>(), 3);
1108                                        BitBlock SQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(SQuoteAttVal, simd_andc(EOF_mask, SQuoteDelim), simd<1>::constant<0>(), 4);
1109                                        BitBlock AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
1110                                        ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
1111                                        BitBlock AttValFollow = carry_set_1.BitBlock_advance_ci_co(AttValEnd, simd<1>::constant<0>(), 5);
1112                                        tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
1113                                        if (bitblock::any(simd_and(AttValFollow, lex.WS)))
1114                                        {
1115                                                AfterWS = carry_set_1.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, simd<1>::constant<0>(), 6);
1116                                                AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
1117                                                AttNameStart = simd_andc(AfterWS, AttListDelim);
1118                                        }
1119                                        else
1120                                        {
1121                                                AttListEnd = simd_or(AttListEnd, simd_and(AttValFollow, AttListDelim));
1122                                                AttNameStart = simd_andc(AttValFollow, AttListDelim);
1123                                        }
1124                                        ParseError = simd_or(ParseError, simd_and(AttValFollow, AttNameStart));
1125                                        LocalCarryCombine(carry_set_0, carry_set_1, 2, 7);
1126                                }
1127                        }
1128                        else
1129                        {
1130                                carry_set_0.CarryDequeueEnqueue(2, 7);
1131                        }
1132                }
1133                else
1134                {
1135                        AttListEnd = simd_and(tag_Callouts.ElemName_ends, AttListDelim);
1136                        ParseError = simd_or(ParseError, simd_andc(tag_Callouts.ElemName_ends, AttListDelim));
1137                        carry_set_0.CarryDequeueEnqueue(1, 8);
1138                }
1139                BitBlock STagEnds = simd_and(AttListEnd, lex.RAngle);
1140                tag_Callouts.EmptyTag_marks = carry_set_0.BitBlock_advance_ci_co(simd_and(AttListEnd, lex.Slash), carry_set_0.GetCarry(9), 9);
1141                ParseError = simd_or(ParseError, simd_andc(tag_Callouts.EmptyTag_marks, lex.RAngle));
1142                BitBlock EndTagEnds = carry_set_0.BitBlock_advance_then_scanthru(tag_Callouts.EndTag_marks, lex.NameScan, carry_set_0.GetCarry(10), 10);
1143                if (bitblock::any(simd_or(simd_and(EndTagEnds, lex.WS), carry_set_0.CarryRange(11, 1))))
1144                {
1145                        EndTagEnds = carry_set_0.BitBlock_scanthru_ci_co(EndTagEnds, lex.WS, carry_set_0.GetCarry(11), 11);
1146                }
1147                else
1148                {
1149                        carry_set_0.CarryDequeueEnqueue(11, 1);
1150                }
1151                ParseError = simd_or(ParseError, simd_andc(EndTagEnds, lex.RAngle));
1152                if (bitblock::any(ParseError))
1153                {
1154                        assert_0_error("Tag parsing error found", ParseError);
1155                }
1156                tag_Callouts.AttVal_spans = carry_set_0.BitBlock_span_upto(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends, carry_set_0.GetCarry(12), 12);
1157        }
1158       
1159        CarryDeclare(carry_set_0, 13, 0);
1160};
1161 
1162struct Parse_refs
1163{
1164        Parse_refs()
1165        {
1166               
1167        }
1168         
1169        IDISA_INLINE void do_block(struct Lex & lex, struct Marker & marker, struct Ref_Callouts & ref_Callouts)
1170        {
1171                ref_Callouts.GenRef_starts = simd<1>::constant<0>();
1172                ref_Callouts.GenRef_ends = simd<1>::constant<0>();
1173                ref_Callouts.DecRef_starts = simd<1>::constant<0>();
1174                ref_Callouts.DecRef_ends = simd<1>::constant<0>();
1175                ref_Callouts.HexRef_starts = simd<1>::constant<0>();
1176                ref_Callouts.HexRef_ends = simd<1>::constant<0>();
1177                BitBlock ref_error = simd<1>::constant<0>();
1178                if (bitblock::any(simd_or(marker.Ref_opener, carry_set_0.CarryRange(0, 6))))
1179                {
1180                        BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener, carry_set_0.GetCarry(0), 0);
1181                        BitBlock NumRef2 = simd_and(Ref_scope, lex.Hash);
1182                        ref_Callouts.GenRef_starts = simd_andc(Ref_scope, lex.Hash);
1183                        BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2, carry_set_0.GetCarry(1), 1);
1184                        BitBlock HexRef3 = simd_and(NumRef3, lex.x);
1185                        ref_Callouts.DecRef_starts = simd_andc(NumRef3, lex.x);
1186                        ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3, carry_set_0.GetCarry(2), 2);
1187                        ref_Callouts.GenRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts, lex.NameScan, carry_set_0.GetCarry(3), 3);
1188                        ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carry_set_0.GetCarry(4), 4);
1189                        ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carry_set_0.GetCarry(5), 5);
1190                        BitBlock ref_error1 = simd_andc(ref_Callouts.DecRef_starts, lex.Digit);
1191                        BitBlock ref_error2 = simd_andc(ref_Callouts.HexRef_starts, lex.Hex);
1192                        BitBlock ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
1193                        BitBlock ref_error3 = simd_andc(ref_ends, lex.Semicolon);
1194                        if (bitblock::any(simd_or(simd_or(ref_error1, ref_error2), ref_error3)))
1195                        {
1196                                assert_0_error("Reference error found", simd_or(simd_or(ref_error1, ref_error2), ref_error3));
1197                        }
1198                }
1199                else
1200                {
1201                        carry_set_0.CarryDequeueEnqueue(0, 6);
1202                }
1203                carry_set_0.CarryAdjust(6);
1204        }
1205       
1206        void do_final_block(struct Lex & lex, struct Marker & marker, struct Ref_Callouts & ref_Callouts, BitBlock & EOF_mask)
1207        {
1208                ref_Callouts.GenRef_starts = simd<1>::constant<0>();
1209                ref_Callouts.GenRef_ends = simd<1>::constant<0>();
1210                ref_Callouts.DecRef_starts = simd<1>::constant<0>();
1211                ref_Callouts.DecRef_ends = simd<1>::constant<0>();
1212                ref_Callouts.HexRef_starts = simd<1>::constant<0>();
1213                ref_Callouts.HexRef_ends = simd<1>::constant<0>();
1214                BitBlock ref_error = simd<1>::constant<0>();
1215                if (bitblock::any(simd_or(marker.Ref_opener, carry_set_0.CarryRange(0, 6))))
1216                {
1217                        BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener, carry_set_0.GetCarry(0), 0);
1218                        BitBlock NumRef2 = simd_and(Ref_scope, lex.Hash);
1219                        ref_Callouts.GenRef_starts = simd_andc(Ref_scope, lex.Hash);
1220                        BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2, carry_set_0.GetCarry(1), 1);
1221                        BitBlock HexRef3 = simd_and(NumRef3, lex.x);
1222                        ref_Callouts.DecRef_starts = simd_andc(NumRef3, lex.x);
1223                        ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3, carry_set_0.GetCarry(2), 2);
1224                        ref_Callouts.GenRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts, lex.NameScan, carry_set_0.GetCarry(3), 3);
1225                        ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carry_set_0.GetCarry(4), 4);
1226                        ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carry_set_0.GetCarry(5), 5);
1227                        BitBlock ref_error1 = simd_andc(ref_Callouts.DecRef_starts, lex.Digit);
1228                        BitBlock ref_error2 = simd_andc(ref_Callouts.HexRef_starts, lex.Hex);
1229                        BitBlock ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
1230                        BitBlock ref_error3 = simd_andc(ref_ends, lex.Semicolon);
1231                        if (bitblock::any(simd_or(simd_or(ref_error1, ref_error2), ref_error3)))
1232                        {
1233                                assert_0_error("Reference error found", simd_or(simd_or(ref_error1, ref_error2), ref_error3));
1234                        }
1235                }
1236                else
1237                {
1238                        carry_set_0.CarryDequeueEnqueue(0, 6);
1239                }
1240        }
1241       
1242        CarryDeclare(carry_set_0, 6, 0);
1243};
1244 
1245struct Validate_xml_names
1246{
1247        Validate_xml_names()
1248        {
1249               
1250        }
1251         
1252        IDISA_INLINE void do_block(struct CtCDPI_Callouts & ctCDPI_Callouts, struct Ref_Callouts & ref_Callouts, struct Tag_Callouts & tag_Callouts, struct Lex & lex, struct U8 & u8, struct Check_streams & check_streams)
1253        {
1254                BitBlock PI_names = carry_set_0.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carry_set_0.GetCarry(0), 0);
1255                BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carry_set_0.GetCarry(1), 1);
1256                BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carry_set_0.GetCarry(2), 2);
1257                BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carry_set_0.GetCarry(3), 3);
1258                BitBlock qname_stream = simd_or(ElemNames, AttNames);
1259                BitBlock ncname_stream = simd_or(PI_names, GenRefs);
1260                BitBlock name_stream = simd_or(qname_stream, ncname_stream);
1261                BitBlock name_start = simd_andc(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.GetCarry(4), 4));
1262                BitBlock name_cursor = simd_andc(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.GetCarry(5), 5));
1263                BitBlock void_prefix_err = simd_and(name_cursor, lex.Colon);
1264                BitBlock namespace_sep = simd_and(carry_set_0.BitBlock_scanthru_ci_co(name_cursor, simd_andc(lex.NameScan, lex.Colon), carry_set_0.GetCarry(6), 6), lex.Colon);
1265                BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep, carry_set_0.GetCarry(7), 7);
1266                BitBlock local_part_err = simd_andc(local_part_start, lex.NameScan);
1267                BitBlock colon2_err = simd_and(carry_set_0.BitBlock_scanthru_ci_co(local_part_start, simd_andc(lex.NameScan, lex.Colon), carry_set_0.GetCarry(8), 8), lex.Colon);
1268                BitBlock ncname_err = simd_and(ncname_stream, lex.Colon);
1269                if (bitblock::any(simd_or(simd_or(simd_or(void_prefix_err, local_part_err), colon2_err), ncname_err)))
1270                {
1271                        assert_0_error("name syntax error", simd_or(simd_or(simd_or(void_prefix_err, local_part_err), colon2_err), ncname_err));
1272                }
1273                check_streams.non_ascii_name_starts = simd_andc(name_start, lex.ASCII_name_start);
1274                check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream, name_start), lex.ASCII_name_char), u8.suffix);
1275                carry_set_0.CarryAdjust(9);
1276        }
1277       
1278        void do_final_block(struct CtCDPI_Callouts & ctCDPI_Callouts, struct Ref_Callouts & ref_Callouts, struct Tag_Callouts & tag_Callouts, struct Lex & lex, struct U8 & u8, struct Check_streams & check_streams, BitBlock & EOF_mask)
1279        {
1280                BitBlock PI_names = carry_set_0.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carry_set_0.GetCarry(0), 0);
1281                BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carry_set_0.GetCarry(1), 1);
1282                BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carry_set_0.GetCarry(2), 2);
1283                BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carry_set_0.GetCarry(3), 3);
1284                BitBlock qname_stream = simd_or(ElemNames, AttNames);
1285                BitBlock ncname_stream = simd_or(PI_names, GenRefs);
1286                BitBlock name_stream = simd_or(qname_stream, ncname_stream);
1287                BitBlock name_start = simd_andc(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.GetCarry(4), 4));
1288                BitBlock name_cursor = simd_andc(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.GetCarry(5), 5));
1289                BitBlock void_prefix_err = simd_and(name_cursor, lex.Colon);
1290                BitBlock namespace_sep = simd_and(carry_set_0.BitBlock_scanthru_ci_co(name_cursor, simd_andc(lex.NameScan, lex.Colon), carry_set_0.GetCarry(6), 6), lex.Colon);
1291                BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep, carry_set_0.GetCarry(7), 7);
1292                BitBlock local_part_err = simd_andc(local_part_start, lex.NameScan);
1293                BitBlock colon2_err = simd_and(carry_set_0.BitBlock_scanthru_ci_co(local_part_start, simd_andc(lex.NameScan, lex.Colon), carry_set_0.GetCarry(8), 8), lex.Colon);
1294                BitBlock ncname_err = simd_and(ncname_stream, lex.Colon);
1295                if (bitblock::any(simd_or(simd_or(simd_or(void_prefix_err, local_part_err), colon2_err), ncname_err)))
1296                {
1297                        assert_0_error("name syntax error", simd_or(simd_or(simd_or(void_prefix_err, local_part_err), colon2_err), ncname_err));
1298                }
1299                check_streams.non_ascii_name_starts = simd_andc(name_start, lex.ASCII_name_start);
1300                check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream, name_start), lex.ASCII_name_char), u8.suffix);
1301        }
1302       
1303        CarryDeclare(carry_set_0, 9, 0);
1304};
1305 
1306struct Do_check_streams
1307{
1308        Do_check_streams()
1309        {
1310               
1311        }
1312         
1313        IDISA_INLINE void do_block(struct Marker & marker, struct Tag_Callouts & tag_Callouts, struct Check_streams & check_streams)
1314        {
1315                if (bitblock::any(simd_andc(marker.CD_closer, tag_Callouts.AttVal_spans)))
1316                {
1317                        assert_0_error("Error: ]]> in text", simd_andc(marker.CD_closer, tag_Callouts.AttVal_spans));
1318                }
1319                check_streams.tag_marks = simd_or(simd_or(simd_or(tag_Callouts.EmptyTag_marks, tag_Callouts.ElemName_starts), tag_Callouts.EndTag_marks), tag_Callouts.AttName_starts);
1320                check_streams.name_follows = simd_or(tag_Callouts.ElemName_ends, tag_Callouts.AttName_ends);
1321                check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans, marker.Ref_opener);
1322        }
1323       
1324        void do_final_block(struct Marker & marker, struct Tag_Callouts & tag_Callouts, struct Check_streams & check_streams, BitBlock & EOF_mask)
1325        {
1326                if (bitblock::any(simd_andc(marker.CD_closer, tag_Callouts.AttVal_spans)))
1327                {
1328                        assert_0_error("Error: ]]> in text", simd_andc(marker.CD_closer, tag_Callouts.AttVal_spans));
1329                }
1330                check_streams.tag_marks = simd_or(simd_or(simd_or(tag_Callouts.EmptyTag_marks, tag_Callouts.ElemName_starts), tag_Callouts.EndTag_marks), tag_Callouts.AttName_starts);
1331                check_streams.name_follows = simd_or(tag_Callouts.ElemName_ends, tag_Callouts.AttName_ends);
1332                check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans, marker.Ref_opener);
1333        }
1334       
1335        CarryDeclare(carry_set_0, 0, 0);
1336};
1337 
1338
1339// } // pablo namespace
1340
1341#endif // PABLO_DEFINITIONS_HPP
Note: See TracBrowser for help on using the repository browser.