source: proto/pabloj/trunk/output/cpplang/header.hpp @ 2834

Last change on this file since 2834 was 2834, checked in by ksherdy, 7 years ago

Migrated pablo to pabloj/trunk.

File size: 51.8 KB
Line 
1GENERATED CODE. DO NOT MODIFY.
2// header.hpp.templates
3//
4// (c) 2012 Robert D. Cameron, Ken Herdy
5// All rights reserved.
6// Licensed to International Characters, Inc. under Academic Free License 3.0
7//
8//////////////////////////////////////////////////////////////////////////////////////////
9// @ global - Global stream structure and stream function declarations.
10//
11//////////////////////////////////////////////////////////////////////////////////////////
12struct Basis_bits
13{
14        BitBlock bit_0;
15        BitBlock bit_1;
16        BitBlock bit_2;
17        BitBlock bit_3;
18        BitBlock bit_4;
19        BitBlock bit_5;
20        BitBlock bit_6;
21        BitBlock bit_7;
22}
23 
24 
25struct u8
26{
27        BitBlock unibyte;
28        BitBlock prefix;
29        BitBlock prefix2;
30        BitBlock prefix3;
31        BitBlock prefix4;
32        BitBlock suffix;
33        BitBlock badprefix;
34        BitBlock xE0;
35        BitBlock xED;
36        BitBlock xF0;
37        BitBlock xF4;
38        BitBlock xA0_xBF;
39        BitBlock x80_x9F;
40        BitBlock x90_xBF;
41        BitBlock x80_x8F;
42        BitBlock xEF;
43        BitBlock xBF;
44        BitBlock xBE;
45        BitBlock scope22;
46        BitBlock scope32;
47        BitBlock scope33;
48        BitBlock scope42;
49        BitBlock scope43;
50        BitBlock scope44;
51        BitBlock xE0_scope;
52        BitBlock xED_scope;
53        BitBlock xF0_scope;
54        BitBlock xF4_scope;
55        BitBlock xEF_scope;
56}
57 
58 
59struct Lex
60{
61        BitBlock CR;
62        BitBlock LF;
63        BitBlock HT;
64        BitBlock SP;
65        BitBlock CRLF;
66        BitBlock RefStart;
67        BitBlock Semicolon;
68        BitBlock Colon;
69        BitBlock LAngle;
70        BitBlock RAngle;
71        BitBlock LBracket;
72        BitBlock RBracket;
73        BitBlock Exclam;
74        BitBlock QMark;
75        BitBlock Hyphen;
76        BitBlock Equals;
77        BitBlock SQuote;
78        BitBlock DQuote;
79        BitBlock Slash;
80        BitBlock Hash;
81        BitBlock x;
82        BitBlock ASCII_name_start;
83        BitBlock ASCII_name_char;
84        BitBlock NameScan;
85        BitBlock Digit;
86        BitBlock Hex;
87        BitBlock WS;
88}
89 
90 
91struct Marker
92{
93        BitBlock LAngle_scope;
94        BitBlock Ref_opener;
95        BitBlock CD_closer;
96}
97 
98 
99struct CtCDPI_Callouts
100{
101        BitBlock Ct_starts;
102        BitBlock Ct_ends;
103        BitBlock CD_starts;
104        BitBlock CD_ends;
105        BitBlock PI_starts;
106        BitBlock PI_name_starts;
107        BitBlock PI_name_ends;
108        BitBlock PI_ends;
109}
110 
111 
112struct Ref_Callouts
113{
114        BitBlock GenRef_starts;
115        BitBlock GenRef_ends;
116        BitBlock DecRef_starts;
117        BitBlock DecRef_ends;
118        BitBlock HexRef_starts;
119        BitBlock HexRef_ends;
120}
121 
122 
123struct Tag_Callouts
124{
125        BitBlock ElemName_starts;
126        BitBlock ElemName_ends;
127        BitBlock AttName_starts;
128        BitBlock AttName_ends;
129        BitBlock AttVal_starts;
130        BitBlock AttVal_ends;
131        BitBlock AttVal_spans;
132        BitBlock EmptyTag_marks;
133        BitBlock EndTag_marks;
134}
135 
136 
137struct Check_streams
138{
139        BitBlock misc_mask;
140        BitBlock non_ascii_name_starts;
141        BitBlock non_ascii_names;
142        BitBlock tag_marks;
143        BitBlock name_follows;
144        BitBlock att_refs;
145}
146 
147 
148struct Classify_bytes_Validate_utf8
149{
150        IDISA_INLINE void do_block(struct Basis_bits & basis_bits, struct Lex & lex, struct U8 & u8)
151        {
152                BitBlock temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
153                BitBlock temp2 = simd_andc(basis_bits.bit_2, basis_bits.bit_3);
154                BitBlock temp3 = simd_andc(temp2, temp1);
155                BitBlock temp4 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
156                BitBlock temp5 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
157                BitBlock temp6 = simd_and(temp4, temp5);
158                lex.RefStart = simd_and(temp3, temp6);
159                BitBlock temp7 = simd_and(basis_bits.bit_2, basis_bits.bit_3);
160                BitBlock temp8 = simd_andc(temp7, temp1);
161                BitBlock temp9 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
162                BitBlock temp10 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
163                BitBlock temp11 = simd_and(temp9, temp10);
164                lex.Semicolon = simd_and(temp8, temp11);
165                BitBlock temp12 = simd_and(basis_bits.bit_4, basis_bits.bit_5);
166                BitBlock temp13 = simd_or(basis_bits.bit_6, basis_bits.bit_7);
167                BitBlock temp14 = simd_andc(temp12, temp13);
168                lex.LAngle = simd_and(temp8, temp14);
169                BitBlock temp15 = simd_and(temp12, temp5);
170                lex.RAngle = simd_and(temp8, temp15);
171                BitBlock temp16 = simd_andc(basis_bits.bit_1, basis_bits.bit_0);
172                BitBlock temp17 = simd_andc(basis_bits.bit_3, basis_bits.bit_2);
173                BitBlock temp18 = simd_and(temp16, temp17);
174                lex.LBracket = simd_and(temp18, temp11);
175                BitBlock temp19 = simd_andc(basis_bits.bit_7, basis_bits.bit_6);
176                BitBlock temp20 = simd_and(temp12, temp19);
177                lex.RBracket = simd_and(temp18, temp20);
178                BitBlock temp21 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
179                BitBlock temp22 = simd_andc(temp19, temp21);
180                lex.Exclam = simd_and(temp3, temp22);
181                BitBlock temp23 = simd_and(temp12, temp10);
182                lex.QMark = simd_and(temp8, temp23);
183                lex.Hyphen = simd_and(temp3, temp20);
184                lex.Equals = simd_and(temp8, temp20);
185                BitBlock temp24 = simd_and(temp4, temp10);
186                lex.SQuote = simd_and(temp3, temp24);
187                BitBlock temp25 = simd_andc(temp5, temp21);
188                lex.DQuote = simd_and(temp3, temp25);
189                lex.Slash = simd_and(temp3, temp23);
190                BitBlock temp26 = simd_andc(temp10, temp21);
191                lex.Hash = simd_and(temp3, temp26);
192                BitBlock temp27 = simd_and(temp16, temp7);
193                BitBlock temp28 = simd_andc(temp9, temp13);
194                lex.x = simd_and(temp27, temp28);
195                BitBlock temp29 = simd_and(temp9, temp5);
196                lex.Colon = simd_and(temp8, temp29);
197                BitBlock temp30 = simd_and(temp18, temp23);
198                BitBlock temp31 = simd_or(temp30, lex.Colon);
199                BitBlock temp32 = simd_andc(temp16, basis_bits.bit_2);
200                BitBlock temp33 = simd_or(basis_bits.bit_5, temp10);
201                BitBlock temp34 = simd_and(basis_bits.bit_4, temp33);
202                BitBlock temp35 = simd_not(temp34);
203                BitBlock temp36 = simd_or(temp21, temp13);
204                BitBlock temp37 = simd_or(simd_and(basis_bits.bit_3, temp35), simd_andc(temp36, basis_bits.bit_3));
205                BitBlock temp38 = simd_and(temp32, temp37);
206                BitBlock temp39 = simd_or(temp31, temp38);
207                BitBlock temp40 = simd_and(temp16, basis_bits.bit_2);
208                BitBlock temp41 = simd_and(temp40, temp37);
209                lex.ASCII_name_start = simd_or(temp39, temp41);
210                BitBlock temp42 = simd_or(temp30, lex.Hyphen);
211                BitBlock temp43 = simd_and(temp3, temp15);
212                BitBlock temp44 = simd_or(temp42, temp43);
213                BitBlock temp45 = simd_andc(temp8, temp34);
214                BitBlock temp46 = simd_or(temp44, temp45);
215                BitBlock temp47 = simd_or(temp46, temp38);
216                lex.ASCII_name_char = simd_or(temp47, temp41);
217                lex.NameScan = simd_or(lex.ASCII_name_char, basis_bits.bit_0);
218                BitBlock temp48 = simd_or(temp1, basis_bits.bit_2);
219                BitBlock x00_x1F = simd_not(temp48);
220                BitBlock temp49 = simd_or(basis_bits.bit_2, basis_bits.bit_3);
221                BitBlock temp50 = simd_or(temp1, temp49);
222                lex.CR = simd_andc(temp20, temp50);
223                lex.LF = simd_andc(temp29, temp50);
224                BitBlock temp51 = simd_and(temp9, temp19);
225                lex.HT = simd_andc(temp51, temp50);
226                lex.SP = simd_andc(temp3, temp36);
227                BitBlock temp52 = simd_or(temp20, temp29);
228                BitBlock temp53 = simd_or(temp52, temp51);
229                BitBlock temp54 = simd_andc(temp53, temp50);
230                lex.WS = simd_or(temp54, lex.SP);
231                BitBlock temp55 = simd_or(basis_bits.bit_5, basis_bits.bit_6);
232                BitBlock temp56 = simd_and(basis_bits.bit_4, temp55);
233                lex.Digit = simd_andc(temp8, temp56);
234                BitBlock temp57 = simd_andc(temp16, temp49);
235                BitBlock temp58 = simd_andc(temp57, basis_bits.bit_4);
236                BitBlock temp59 = simd_not(temp10);
237                BitBlock temp60 = simd_or(simd_and(basis_bits.bit_5, temp59), simd_andc(temp13, basis_bits.bit_5));
238                BitBlock temp61 = simd_and(temp58, temp60);
239                BitBlock temp62 = simd_or(lex.Digit, temp61);
240                BitBlock temp63 = simd_and(temp16, temp2);
241                BitBlock temp64 = simd_andc(temp63, basis_bits.bit_4);
242                BitBlock temp65 = simd_and(temp64, temp60);
243                lex.Hex = simd_or(temp62, temp65);
244                BitBlock lex_error = simd_andc(x00_x1F, lex.WS);
245                if (bitblock::any(bitblock::any(lex_error)))
246                {
247                        assert_0_error(lex_error, "Error: illegal character");
248                }
249                u8.unibyte = simd_not(basis_bits.bit_0);
250                u8.suffix = simd<1>::constant<0>();
251                BitBlock u8_error = simd<1>::constant<0>();
252                BitBlock u8_FFFE_FFFF = simd<1>::constant<0>();
253                BitBlock u8anyscope = simd<1>::constant<0>();
254                if (bitblock::any(simd_or(basis_bits.bit_0, carryQ.CarryTest(0, 10))))
255                {
256                        u8.prefix = simd_and(basis_bits.bit_0, basis_bits.bit_1);
257                        u8.prefix2 = simd_andc(u8.prefix, basis_bits.bit_2);
258                        u8.prefix3 = simd_and(u8.prefix, temp2);
259                        u8.prefix4 = simd_and(u8.prefix, temp7);
260                        u8.suffix = simd_andc(basis_bits.bit_0, basis_bits.bit_1);
261                        BitBlock temp66 = simd_andc(u8.prefix, temp49);
262                        BitBlock temp67 = simd_or(temp21, basis_bits.bit_6);
263                        BitBlock temp68 = simd_andc(temp66, temp67);
264                        BitBlock temp69 = simd_and(basis_bits.bit_5, temp13);
265                        BitBlock temp70 = simd_or(basis_bits.bit_4, temp69);
266                        BitBlock temp71 = simd_and(u8.prefix4, temp70);
267                        u8.badprefix = simd_or(temp68, temp71);
268                        u8_error = u8.badprefix;
269                        u8.scope22 = carryQ.BitBlock_advance_ci_co(u8.prefix2, carryQ.get_carry_in(0), 0);
270                        u8anyscope = u8.scope22;
271                        if (bitblock::any(simd_or((u8.prefix3) | (u8.prefix4), carryQ.CarryTest(1, 9))))
272                        {
273                                BitBlock xE0 = simd_andc(u8.prefix3, temp36);
274                                BitBlock xED = simd_and(u8.prefix3, temp20);
275                                BitBlock xF0 = simd_andc(u8.prefix4, temp36);
276                                BitBlock temp72 = simd_andc(temp4, temp13);
277                                BitBlock xF4 = simd_and(u8.prefix4, temp72);
278                                u8.xA0_xBF = simd_and(u8.suffix, basis_bits.bit_2);
279                                u8.x80_x9F = simd_andc(u8.suffix, basis_bits.bit_2);
280                                u8.x90_xBF = simd_and(u8.suffix, temp49);
281                                u8.x80_x8F = simd_andc(u8.suffix, temp49);
282                                BitBlock xEF = simd_and(u8.prefix3, temp23);
283                                BitBlock temp73 = simd_and(u8.suffix, temp7);
284                                u8.xBF = simd_and(temp73, temp23);
285                                u8.xBE = simd_and(temp73, temp15);
286                                u8.scope32 = carryQ.BitBlock_advance_ci_co(u8.prefix3, carryQ.get_carry_in(1), 1);
287                                u8.scope33 = carryQ.BitBlock_advance_ci_co(u8.scope32, carryQ.get_carry_in(2), 2);
288                                u8.scope42 = carryQ.BitBlock_advance_ci_co(u8.prefix4, carryQ.get_carry_in(3), 3);
289                                u8.scope43 = carryQ.BitBlock_advance_ci_co(u8.scope42, carryQ.get_carry_in(4), 4);
290                                u8.scope44 = carryQ.BitBlock_advance_ci_co(u8.scope43, carryQ.get_carry_in(5), 5);
291                                BitBlock E0_F0_scope = carryQ.BitBlock_advance_ci_co(simd_or(xE0, xF0), carryQ.get_carry_in(6), 6);
292                                BitBlock ED_F4_scope = carryQ.BitBlock_advance_ci_co(simd_or(xED, xF4), carryQ.get_carry_in(7), 7);
293                                u8.xE0_scope = simd_and(u8.scope32, E0_F0_scope);
294                                u8.xED_scope = simd_and(u8.scope32, ED_F4_scope);
295                                u8.xF0_scope = simd_and(u8.scope42, E0_F0_scope);
296                                u8.xF4_scope = simd_and(u8.scope42, ED_F4_scope);
297                                u8.xEF_scope = carryQ.BitBlock_advance_ci_co(xEF, carryQ.get_carry_in(8), 8);
298                                BitBlock u8lastscope = simd_or(simd_or(u8.scope22, u8.scope33), u8.scope44);
299                                u8anyscope = simd_or(simd_or(simd_or(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
300                                BitBlock u8error1 = simd_and(u8.xE0_scope, u8.x80_x9F);
301                                BitBlock u8error2 = simd_and(u8.xED_scope, u8.xA0_xBF);
302                                BitBlock u8error3 = simd_and(u8.xF0_scope, u8.x80_x8F);
303                                BitBlock u8error4 = simd_and(u8.xF4_scope, u8.x90_xBF);
304                                u8_error = simd_or(u8_error, (simd_or(simd_or(u8error1, u8error2), u8error3)) | u8error4);
305                                BitBlock EF_BF_pending = carryQ.BitBlock_advance_ci_co(simd_and(u8.xEF_scope, u8.xBF), carryQ.get_carry_in(9), 9);
306                                u8_FFFE_FFFF = simd_and(EF_BF_pending, simd_or(u8.xBE, u8.xBF));
307                        }
308                        else
309                        {
310                                carryQ.CarryDequeueEnqueue(1, 9);
311                        }
312                        BitBlock u8mismatch = simd_xor(u8anyscope, u8.suffix);
313                        if (bitblock::any(bitblock::any((simd_or(u8_error, u8mismatch)) | u8_FFFE_FFFF)))
314                        {
315                                assert_0_error(simd_or(simd_or(u8_error, u8mismatch), u8_FFFE_FFFF), "UTF-8 error found");
316                        }
317                }
318                else
319                {
320                        carryQ.CarryDequeueEnqueue(0, 10);
321                }
322                carryQ.CarryQ_Adjust(10);
323        }
324        IDISA_INLINE void do_final_block(struct Basis_bits & basis_bits, struct Lex & lex, struct U8 & u8, BitBlock & EOF_mask)
325        {
326                BitBlock temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
327                BitBlock temp2 = simd_andc(basis_bits.bit_2, basis_bits.bit_3);
328                BitBlock temp3 = simd_andc(temp2, temp1);
329                BitBlock temp4 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
330                BitBlock temp5 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
331                BitBlock temp6 = simd_and(temp4, temp5);
332                lex.RefStart = simd_and(temp3, temp6);
333                BitBlock temp7 = simd_and(basis_bits.bit_2, basis_bits.bit_3);
334                BitBlock temp8 = simd_andc(temp7, temp1);
335                BitBlock temp9 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
336                BitBlock temp10 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
337                BitBlock temp11 = simd_and(temp9, temp10);
338                lex.Semicolon = simd_and(temp8, temp11);
339                BitBlock temp12 = simd_and(basis_bits.bit_4, basis_bits.bit_5);
340                BitBlock temp13 = simd_or(basis_bits.bit_6, basis_bits.bit_7);
341                BitBlock temp14 = simd_andc(temp12, temp13);
342                lex.LAngle = simd_and(temp8, temp14);
343                BitBlock temp15 = simd_and(temp12, temp5);
344                lex.RAngle = simd_and(temp8, temp15);
345                BitBlock temp16 = simd_andc(basis_bits.bit_1, basis_bits.bit_0);
346                BitBlock temp17 = simd_andc(basis_bits.bit_3, basis_bits.bit_2);
347                BitBlock temp18 = simd_and(temp16, temp17);
348                lex.LBracket = simd_and(temp18, temp11);
349                BitBlock temp19 = simd_andc(basis_bits.bit_7, basis_bits.bit_6);
350                BitBlock temp20 = simd_and(temp12, temp19);
351                lex.RBracket = simd_and(temp18, temp20);
352                BitBlock temp21 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
353                BitBlock temp22 = simd_andc(temp19, temp21);
354                lex.Exclam = simd_and(temp3, temp22);
355                BitBlock temp23 = simd_and(temp12, temp10);
356                lex.QMark = simd_and(temp8, temp23);
357                lex.Hyphen = simd_and(temp3, temp20);
358                lex.Equals = simd_and(temp8, temp20);
359                BitBlock temp24 = simd_and(temp4, temp10);
360                lex.SQuote = simd_and(temp3, temp24);
361                BitBlock temp25 = simd_andc(temp5, temp21);
362                lex.DQuote = simd_and(temp3, temp25);
363                lex.Slash = simd_and(temp3, temp23);
364                BitBlock temp26 = simd_andc(temp10, temp21);
365                lex.Hash = simd_and(temp3, temp26);
366                BitBlock temp27 = simd_and(temp16, temp7);
367                BitBlock temp28 = simd_andc(temp9, temp13);
368                lex.x = simd_and(temp27, temp28);
369                BitBlock temp29 = simd_and(temp9, temp5);
370                lex.Colon = simd_and(temp8, temp29);
371                BitBlock temp30 = simd_and(temp18, temp23);
372                BitBlock temp31 = simd_or(temp30, lex.Colon);
373                BitBlock temp32 = simd_andc(temp16, basis_bits.bit_2);
374                BitBlock temp33 = simd_or(basis_bits.bit_5, temp10);
375                BitBlock temp34 = simd_and(basis_bits.bit_4, temp33);
376                BitBlock temp35 = simd_not(temp34);
377                BitBlock temp36 = simd_or(temp21, temp13);
378                BitBlock temp37 = simd_or(simd_and(basis_bits.bit_3, temp35), simd_andc(temp36, basis_bits.bit_3));
379                BitBlock temp38 = simd_and(temp32, temp37);
380                BitBlock temp39 = simd_or(temp31, temp38);
381                BitBlock temp40 = simd_and(temp16, basis_bits.bit_2);
382                BitBlock temp41 = simd_and(temp40, temp37);
383                lex.ASCII_name_start = simd_or(temp39, temp41);
384                BitBlock temp42 = simd_or(temp30, lex.Hyphen);
385                BitBlock temp43 = simd_and(temp3, temp15);
386                BitBlock temp44 = simd_or(temp42, temp43);
387                BitBlock temp45 = simd_andc(temp8, temp34);
388                BitBlock temp46 = simd_or(temp44, temp45);
389                BitBlock temp47 = simd_or(temp46, temp38);
390                lex.ASCII_name_char = simd_or(temp47, temp41);
391                lex.NameScan = simd_or(lex.ASCII_name_char, basis_bits.bit_0);
392                BitBlock temp48 = simd_or(temp1, basis_bits.bit_2);
393                BitBlock x00_x1F = simd_not(temp48);
394                BitBlock temp49 = simd_or(basis_bits.bit_2, basis_bits.bit_3);
395                BitBlock temp50 = simd_or(temp1, temp49);
396                lex.CR = simd_andc(temp20, temp50);
397                lex.LF = simd_andc(temp29, temp50);
398                BitBlock temp51 = simd_and(temp9, temp19);
399                lex.HT = simd_andc(temp51, temp50);
400                lex.SP = simd_andc(temp3, temp36);
401                BitBlock temp52 = simd_or(temp20, temp29);
402                BitBlock temp53 = simd_or(temp52, temp51);
403                BitBlock temp54 = simd_andc(temp53, temp50);
404                lex.WS = simd_or(temp54, lex.SP);
405                BitBlock temp55 = simd_or(basis_bits.bit_5, basis_bits.bit_6);
406                BitBlock temp56 = simd_and(basis_bits.bit_4, temp55);
407                lex.Digit = simd_andc(temp8, temp56);
408                BitBlock temp57 = simd_andc(temp16, temp49);
409                BitBlock temp58 = simd_andc(temp57, basis_bits.bit_4);
410                BitBlock temp59 = simd_not(temp10);
411                BitBlock temp60 = simd_or(simd_and(basis_bits.bit_5, temp59), simd_andc(temp13, basis_bits.bit_5));
412                BitBlock temp61 = simd_and(temp58, temp60);
413                BitBlock temp62 = simd_or(lex.Digit, temp61);
414                BitBlock temp63 = simd_and(temp16, temp2);
415                BitBlock temp64 = simd_andc(temp63, basis_bits.bit_4);
416                BitBlock temp65 = simd_and(temp64, temp60);
417                lex.Hex = simd_or(temp62, temp65);
418                BitBlock lex_error = simd_andc(x00_x1F, lex.WS);
419                if (bitblock::any(bitblock::any(simd_and(lex_error, EOF_mask))))
420                {
421                        assert_0_error(simd_and(lex_error, EOF_mask), "Error: illegal character");
422                }
423                u8.unibyte = simd_not(basis_bits.bit_0);
424                u8.suffix = simd<1>::constant<0>();
425                BitBlock u8_error = simd<1>::constant<0>();
426                BitBlock u8_FFFE_FFFF = simd<1>::constant<0>();
427                BitBlock u8anyscope = simd<1>::constant<0>();
428                if (bitblock::any(simd_or(basis_bits.bit_0, carryQ.CarryTest(0, 10))))
429                {
430                        u8.prefix = simd_and(basis_bits.bit_0, basis_bits.bit_1);
431                        u8.prefix2 = simd_andc(u8.prefix, basis_bits.bit_2);
432                        u8.prefix3 = simd_and(u8.prefix, temp2);
433                        u8.prefix4 = simd_and(u8.prefix, temp7);
434                        u8.suffix = simd_andc(basis_bits.bit_0, basis_bits.bit_1);
435                        BitBlock temp66 = simd_andc(u8.prefix, temp49);
436                        BitBlock temp67 = simd_or(temp21, basis_bits.bit_6);
437                        BitBlock temp68 = simd_andc(temp66, temp67);
438                        BitBlock temp69 = simd_and(basis_bits.bit_5, temp13);
439                        BitBlock temp70 = simd_or(basis_bits.bit_4, temp69);
440                        BitBlock temp71 = simd_and(u8.prefix4, temp70);
441                        u8.badprefix = simd_or(temp68, temp71);
442                        u8_error = u8.badprefix;
443                        u8.scope22 = carryQ.BitBlock_advance_ci_co(u8.prefix2, carryQ.get_carry_in(0), 0);
444                        u8anyscope = u8.scope22;
445                        if (bitblock::any(simd_or((u8.prefix3) | (u8.prefix4), carryQ.CarryTest(1, 9))))
446                        {
447                                BitBlock xE0 = simd_andc(u8.prefix3, temp36);
448                                BitBlock xED = simd_and(u8.prefix3, temp20);
449                                BitBlock xF0 = simd_andc(u8.prefix4, temp36);
450                                BitBlock temp72 = simd_andc(temp4, temp13);
451                                BitBlock xF4 = simd_and(u8.prefix4, temp72);
452                                u8.xA0_xBF = simd_and(u8.suffix, basis_bits.bit_2);
453                                u8.x80_x9F = simd_andc(u8.suffix, basis_bits.bit_2);
454                                u8.x90_xBF = simd_and(u8.suffix, temp49);
455                                u8.x80_x8F = simd_andc(u8.suffix, temp49);
456                                BitBlock xEF = simd_and(u8.prefix3, temp23);
457                                BitBlock temp73 = simd_and(u8.suffix, temp7);
458                                u8.xBF = simd_and(temp73, temp23);
459                                u8.xBE = simd_and(temp73, temp15);
460                                u8.scope32 = carryQ.BitBlock_advance_ci_co(u8.prefix3, carryQ.get_carry_in(1), 1);
461                                u8.scope33 = carryQ.BitBlock_advance_ci_co(u8.scope32, carryQ.get_carry_in(2), 2);
462                                u8.scope42 = carryQ.BitBlock_advance_ci_co(u8.prefix4, carryQ.get_carry_in(3), 3);
463                                u8.scope43 = carryQ.BitBlock_advance_ci_co(u8.scope42, carryQ.get_carry_in(4), 4);
464                                u8.scope44 = carryQ.BitBlock_advance_ci_co(u8.scope43, carryQ.get_carry_in(5), 5);
465                                BitBlock E0_F0_scope = carryQ.BitBlock_advance_ci_co(simd_or(xE0, xF0), carryQ.get_carry_in(6), 6);
466                                BitBlock ED_F4_scope = carryQ.BitBlock_advance_ci_co(simd_or(xED, xF4), carryQ.get_carry_in(7), 7);
467                                u8.xE0_scope = simd_and(u8.scope32, E0_F0_scope);
468                                u8.xED_scope = simd_and(u8.scope32, ED_F4_scope);
469                                u8.xF0_scope = simd_and(u8.scope42, E0_F0_scope);
470                                u8.xF4_scope = simd_and(u8.scope42, ED_F4_scope);
471                                u8.xEF_scope = carryQ.BitBlock_advance_ci_co(xEF, carryQ.get_carry_in(8), 8);
472                                BitBlock u8lastscope = simd_or(simd_or(u8.scope22, u8.scope33), u8.scope44);
473                                u8anyscope = simd_or(simd_or(simd_or(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
474                                BitBlock u8error1 = simd_and(u8.xE0_scope, u8.x80_x9F);
475                                BitBlock u8error2 = simd_and(u8.xED_scope, u8.xA0_xBF);
476                                BitBlock u8error3 = simd_and(u8.xF0_scope, u8.x80_x8F);
477                                BitBlock u8error4 = simd_and(u8.xF4_scope, u8.x90_xBF);
478                                u8_error = simd_or(u8_error, (simd_or(simd_or(u8error1, u8error2), u8error3)) | u8error4);
479                                BitBlock EF_BF_pending = carryQ.BitBlock_advance_ci_co(simd_and(u8.xEF_scope, u8.xBF), carryQ.get_carry_in(9), 9);
480                                u8_FFFE_FFFF = simd_and(EF_BF_pending, simd_or(u8.xBE, u8.xBF));
481                        }
482                        else
483                        {
484                                carryQ.CarryDequeueEnqueue(1, 9);
485                        }
486                        BitBlock u8mismatch = simd_xor(u8anyscope, u8.suffix);
487                        if (bitblock::any(bitblock::any((simd_or(u8_error, u8mismatch)) | u8_FFFE_FFFF)))
488                        {
489                                assert_0_error(simd_or(simd_or(u8_error, u8mismatch), u8_FFFE_FFFF), "UTF-8 error found");
490                        }
491                }
492                else
493                {
494                        carryQ.CarryDequeueEnqueue(0, 10);
495                }
496                carryQ.CarryQ_Adjust(10);
497        }
498        CarryArray<10,0> carryQ;
499}
500 
501struct Parse_CtCDPI
502{
503        IDISA_INLINE void do_block(struct Lex & lex, struct Marker & marker, struct CtCDPI_Callouts & ctCDPI_Callouts, struct Check_streams & check_streams)
504        {
505                ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
506                ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
507                ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
508                ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
509                ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
510                ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
511                ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
512                ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
513                BitBlock CtCDPI_starts = simd<1>::constant<0>();
514                BitBlock CtCDPI_ends = simd<1>::constant<0>();
515                BitBlock ctCDPI_mask = simd<1>::constant<0>();
516                BitBlock v = simd_or(lex.LAngle, lex.Hyphen);
517                BitBlock w = simd_or(lex.Hyphen, lex.QMark);
518                BitBlock v1 = carryQ.BitBlock_advance_n_<32>(v, 1, carryQ.get_pending64(0), 0);
519                BitBlock w1 = carryQ.BitBlock_advance_n_<32>(w, 1, carryQ.get_pending64(1), 1);
520                BitBlock LAngle_scope = simd_andc(v1, w1);
521                BitBlock PI_opener = simd_and(LAngle_scope, lex.QMark);
522                BitBlock CtCD_opener = simd_and(LAngle_scope, lex.Exclam);
523                BitBlock CtCDPI_opener = simd_or(PI_opener, CtCD_opener);
524                BitBlock CD_closer = simd<1>::constant<0>();
525                BitBlock DoubleHyphen = simd_and(simd_and(v1, w1), lex.Hyphen);
526                if (bitblock::any(simd_or(lex.RBracket, carryQ.CarryTest(0, 2))))
527                {
528                        BitBlock DoubleRBracket = simd_and(carryQ.BitBlock_advance_ci_co(lex.RBracket, carryQ.get_carry_in(0), 0), lex.RBracket);
529                        CD_closer = simd_and(carryQ.BitBlock_advance_ci_co(DoubleRBracket, carryQ.get_carry_in(1), 1), lex.RAngle);
530                }
531                else
532                {
533                        carryQ.CarryDequeueEnqueue(0, 2);
534                }
535                BitBlock PI_closer = simd_and(simd_andc(w1, v1), lex.RAngle);
536                BitBlock CtCDPI_Cursor = carryQ.BitBlock_scantofirst(CtCDPI_opener, carryQ.get_carry_in(2), 2);
537                while (bitblock::any(CtCDPI_Cursor))
538                {
539                        CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
540                        BitBlock PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
541                        BitBlock CD_Ct_Cursor = carryQ.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), carryQ.get_carry_in(3), 3);
542                        BitBlock CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
543                        BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
544                        if (bitblock::any(simd_or(PI_Cursor, carryQ.CarryTest(4, 4))))
545                        {
546                                ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
547                                PI_Cursor = carryQ.BitBlock_advance_ci_co(PI_Cursor, carryQ.get_carry_in(4), 4);
548                                ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
549                                BitBlock PI_name_end = carryQ.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, carryQ.get_carry_in(5), 5);
550                                BitBlock PI_error = simd_and(PI_Cursor, PI_name_end);
551                                BitBlock PI_noWS = simd_andc(PI_name_end, lex.WS);
552                                PI_error = simd_or(PI_error, (simd_andc(PI_noWS, lex.QMark)) | (simd_andc(carryQ.BitBlock_advance_ci_co(PI_noWS, carryQ.get_carry_in(6), 6), PI_closer)));
553                                if (bitblock::any(bitblock::any(PI_error)))
554                                {
555                                        assert_0_error(PI_error, "Error in PI syntax");
556                                }
557                                ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
558                                PI_Cursor = carryQ.BitBlock_scanto_ci_co(PI_name_end, PI_closer, carryQ.get_carry_in(7), 7);
559                                ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
560                                CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
561                        }
562                        else
563                        {
564                                carryQ.CarryDequeueEnqueue(4, 4);
565                        }
566                        if (bitblock::any(simd_or(CD_Cursor, carryQ.CarryTest(8, 1))))
567                        {
568                                ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
569                                CD_Cursor = carryQ.BitBlock_scanto_ci_co(CD_Cursor, CD_closer, carryQ.get_carry_in(8), 8);
570                                ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
571                                CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
572                        }
573                        else
574                        {
575                                carryQ.CarryDequeueEnqueue(8, 1);
576                        }
577                        if (bitblock::any(simd_or(Ct_Cursor, carryQ.CarryTest(9, 5))))
578                        {
579                                ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
580                                Ct_Cursor = carryQ.BitBlock_advance_ci_co(Ct_Cursor, carryQ.get_carry_in(9), 9);
581                                BitBlock Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
582                                Ct_Cursor = carryQ.BitBlock_advance_ci_co(carryQ.BitBlock_advance_ci_co(Ct_Cursor, carryQ.get_carry_in(10), 10), carryQ.get_carry_in(11), 11);
583                                Ct_Cursor = carryQ.BitBlock_advance_ci_co(carryQ.BitBlock_scanto_ci_co(Ct_Cursor, DoubleHyphen, carryQ.get_carry_in(12), 12), carryQ.get_carry_in(13), 13);
584                                if (bitblock::any(bitblock::any(Ct_error | (simd_andc(Ct_Cursor, lex.RAngle)))))
585                                {
586                                        assert_0_error(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)), "Error in comment syntax");
587                                }
588                                ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
589                                CtCDPI_ends = simd_or(CtCDPI_ends, Ct_Cursor);
590                        }
591                        else
592                        {
593                                carryQ.CarryDequeueEnqueue(9, 5);
594                        }
595                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
596                        ctCDPI_mask = carryQ.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, carryQ.get_carry_in(14), 14);
597                        if (bitblock::any(bitblock::any(simd<1>::constant<0>())))
598                        {
599                                assert_0_error(simd<1>::constant<0>(), "Error in comment, CDATA or processing instruction syntax");
600                        }
601                        CtCDPI_Cursor = carryQ.BitBlock_scanto_ci_co(CtCDPI_Cursor, CtCDPI_opener, carryQ.get_carry_in(15), 15);
602                }
603                check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS, lex.LAngle), carryQ.BitBlock_inclusive_span(simd_or(ctCDPI_Callouts.Ct_starts, ctCDPI_Callouts.PI_starts), simd_or(ctCDPI_Callouts.Ct_ends, ctCDPI_Callouts.PI_ends), carryQ.get_carry_in(16), 16)), CtCDPI_starts), EOF_mask);
604                marker.LAngle_scope = simd_andc(LAngle_scope, ctCDPI_mask);
605                marker.Ref_opener = simd_andc(lex.RefStart, ctCDPI_mask);
606                marker.CD_closer = simd_andc(CD_closer, ctCDPI_mask);
607                carryQ.CarryQ_Adjust(17);
608        }
609        IDISA_INLINE void do_final_block(struct Lex & lex, struct Marker & marker, struct CtCDPI_Callouts & ctCDPI_Callouts, struct Check_streams & check_streams, BitBlock & EOF_mask)
610        {
611                ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
612                ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
613                ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
614                ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
615                ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
616                ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
617                ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
618                ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
619                BitBlock CtCDPI_starts = simd<1>::constant<0>();
620                BitBlock CtCDPI_ends = simd<1>::constant<0>();
621                BitBlock ctCDPI_mask = simd<1>::constant<0>();
622                BitBlock v = simd_or(lex.LAngle, lex.Hyphen);
623                BitBlock w = simd_or(lex.Hyphen, lex.QMark);
624                BitBlock v1 = carryQ.BitBlock_advance_n_<32>(v, 1, carryQ.get_pending64(0), 0);
625                BitBlock w1 = carryQ.BitBlock_advance_n_<32>(w, 1, carryQ.get_pending64(1), 1);
626                BitBlock LAngle_scope = simd_andc(v1, w1);
627                BitBlock PI_opener = simd_and(LAngle_scope, lex.QMark);
628                BitBlock CtCD_opener = simd_and(LAngle_scope, lex.Exclam);
629                BitBlock CtCDPI_opener = simd_or(PI_opener, CtCD_opener);
630                BitBlock CD_closer = simd<1>::constant<0>();
631                BitBlock DoubleHyphen = simd_and(simd_and(v1, w1), lex.Hyphen);
632                if (bitblock::any(simd_or(lex.RBracket, carryQ.CarryTest(0, 2))))
633                {
634                        BitBlock DoubleRBracket = simd_and(carryQ.BitBlock_advance_ci_co(lex.RBracket, carryQ.get_carry_in(0), 0), lex.RBracket);
635                        CD_closer = simd_and(carryQ.BitBlock_advance_ci_co(DoubleRBracket, carryQ.get_carry_in(1), 1), lex.RAngle);
636                }
637                else
638                {
639                        carryQ.CarryDequeueEnqueue(0, 2);
640                }
641                BitBlock PI_closer = simd_and(simd_andc(w1, v1), lex.RAngle);
642                BitBlock CtCDPI_Cursor = carryQ.BitBlock_scantofirst(CtCDPI_opener, carryQ.get_carry_in(2), 2);
643                while (bitblock::any(CtCDPI_Cursor))
644                {
645                        CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
646                        BitBlock PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
647                        BitBlock CD_Ct_Cursor = carryQ.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), carryQ.get_carry_in(3), 3);
648                        BitBlock CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
649                        BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
650                        if (bitblock::any(simd_or(PI_Cursor, carryQ.CarryTest(4, 4))))
651                        {
652                                ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
653                                PI_Cursor = carryQ.BitBlock_advance_ci_co(PI_Cursor, carryQ.get_carry_in(4), 4);
654                                ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
655                                BitBlock PI_name_end = carryQ.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, carryQ.get_carry_in(5), 5);
656                                BitBlock PI_error = simd_and(PI_Cursor, PI_name_end);
657                                BitBlock PI_noWS = simd_andc(PI_name_end, lex.WS);
658                                PI_error = simd_or(PI_error, (simd_andc(PI_noWS, lex.QMark)) | (simd_andc(carryQ.BitBlock_advance_ci_co(PI_noWS, carryQ.get_carry_in(6), 6), PI_closer)));
659                                if (bitblock::any(bitblock::any(PI_error)))
660                                {
661                                        assert_0_error(PI_error, "Error in PI syntax");
662                                }
663                                ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
664                                PI_Cursor = carryQ.BitBlock_scanto_ci_co(PI_name_end, simd_andc(PI_closer, EOF_mask), carryQ.get_carry_in(7), 7);
665                                ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
666                                CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
667                        }
668                        else
669                        {
670                                carryQ.CarryDequeueEnqueue(4, 4);
671                        }
672                        if (bitblock::any(simd_or(CD_Cursor, carryQ.CarryTest(8, 1))))
673                        {
674                                ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
675                                CD_Cursor = carryQ.BitBlock_scanto_ci_co(CD_Cursor, simd_andc(CD_closer, EOF_mask), carryQ.get_carry_in(8), 8);
676                                ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
677                                CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
678                        }
679                        else
680                        {
681                                carryQ.CarryDequeueEnqueue(8, 1);
682                        }
683                        if (bitblock::any(simd_or(Ct_Cursor, carryQ.CarryTest(9, 5))))
684                        {
685                                ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
686                                Ct_Cursor = carryQ.BitBlock_advance_ci_co(Ct_Cursor, carryQ.get_carry_in(9), 9);
687                                BitBlock Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
688                                Ct_Cursor = carryQ.BitBlock_advance_ci_co(carryQ.BitBlock_advance_ci_co(Ct_Cursor, carryQ.get_carry_in(10), 10), carryQ.get_carry_in(11), 11);
689                                Ct_Cursor = carryQ.BitBlock_advance_ci_co(carryQ.BitBlock_scanto_ci_co(Ct_Cursor, simd_andc(DoubleHyphen, EOF_mask), carryQ.get_carry_in(12), 12), carryQ.get_carry_in(13), 13);
690                                if (bitblock::any(bitblock::any(Ct_error | (simd_andc(Ct_Cursor, lex.RAngle)))))
691                                {
692                                        assert_0_error(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle)), "Error in comment syntax");
693                                }
694                                ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
695                                CtCDPI_ends = simd_or(CtCDPI_ends, Ct_Cursor);
696                        }
697                        else
698                        {
699                                carryQ.CarryDequeueEnqueue(9, 5);
700                        }
701                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
702                        ctCDPI_mask = carryQ.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, carryQ.get_carry_in(14), 14);
703                        if (bitblock::any(bitblock::any(simd_andc(ctCDPI_mask, EOF_mask))))
704                        {
705                                assert_0_error(simd_andc(ctCDPI_mask, EOF_mask), "Error in comment, CDATA or processing instruction syntax");
706                        }
707                        CtCDPI_Cursor = carryQ.BitBlock_scanto_ci_co(CtCDPI_Cursor, simd_andc(CtCDPI_opener, EOF_mask), carryQ.get_carry_in(15), 15);
708                }
709                check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS, lex.LAngle), carryQ.BitBlock_inclusive_span(simd_or(ctCDPI_Callouts.Ct_starts, ctCDPI_Callouts.PI_starts), simd_or(ctCDPI_Callouts.Ct_ends, ctCDPI_Callouts.PI_ends), carryQ.get_carry_in(16), 16)), CtCDPI_starts), EOF_mask);
710                marker.LAngle_scope = simd_andc(LAngle_scope, ctCDPI_mask);
711                marker.Ref_opener = simd_andc(lex.RefStart, ctCDPI_mask);
712                marker.CD_closer = simd_andc(CD_closer, ctCDPI_mask);
713                carryQ.CarryQ_Adjust(17);
714        }
715        CarryArray<17,2> carryQ;
716}
717 
718struct Parse_tags
719{
720        IDISA_INLINE void do_block(struct Lex & lex, struct Marker & marker, struct Tag_Callouts & tag_Callouts)
721        {
722                BitBlock DQuoteDelim = simd_or(lex.DQuote, lex.LAngle);
723                BitBlock SQuoteDelim = simd_or(lex.SQuote, lex.LAngle);
724                BitBlock AttListDelim = simd_or(lex.Slash, lex.RAngle);
725                tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope, lex.Slash);
726                tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope, lex.Slash);
727                tag_Callouts.ElemName_ends = carryQ.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_starts, lex.NameScan, carryQ.get_carry_in(0), 0);
728                BitBlock ParseError = simd_and(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
729                tag_Callouts.AttName_starts = simd<1>::constant<0>();
730                tag_Callouts.AttName_ends = simd<1>::constant<0>();
731                tag_Callouts.AttVal_starts = simd<1>::constant<0>();
732                tag_Callouts.AttVal_ends = simd<1>::constant<0>();
733                if (bitblock::any(simd_or((tag_Callouts.ElemName_ends) & (lex.WS), carryQ.CarryTest(1, 8))))
734                {
735                        BitBlock AfterWS = carryQ.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_ends, lex.WS, carryQ.get_carry_in(1), 1);
736                        BitBlock AttListEnd = simd_and(AfterWS, AttListDelim);
737                        BitBlock AttNameStart = simd_andc(AfterWS, AttListDelim);
738                        while (bitblock::any(AttNameStart))
739                        {
740                                ParseError = simd_or(ParseError, AttNameStart & (simd_not(lex.NameScan)));
741                                tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
742                                BitBlock AttNameFollow = carryQ.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, carryQ.get_carry_in(2), 2);
743                                tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
744                                if (bitblock::any(simd_or(AttNameFollow & (lex.WS), carryQ.CarryTest(3, 1))))
745                                {
746                                        BitBlock EqExpected = carryQ.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, carryQ.get_carry_in(3), 3);
747                                }
748                                else
749                                {
750                                        BitBlock EqExpected = AttNameFollow;
751                                        carryQ.CarryDequeueEnqueue(3, 1);
752                                }
753                                ParseError = simd_or(ParseError, EqExpected & (simd_not(lex.Equals)));
754                                BitBlock AttValPos = carryQ.BitBlock_advance_then_scanthru(EqExpected, lex.WS, carryQ.get_carry_in(4), 4);
755                                tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
756                                BitBlock DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
757                                BitBlock SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
758                                BitBlock DQuoteAttEnd = carryQ.BitBlock_advance_then_scanto(DQuoteAttVal, DQuoteDelim, carryQ.get_carry_in(5), 5);
759                                BitBlock SQuoteAttEnd = carryQ.BitBlock_advance_then_scanto(SQuoteAttVal, SQuoteDelim, carryQ.get_carry_in(6), 6);
760                                BitBlock AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
761                                ParseError = simd_or(ParseError, (simd_or(AttValPos, AttValEnd)) & (simd_not(simd_or(lex.DQuote, lex.SQuote))));
762                                BitBlock AttValFollow = carryQ.BitBlock_advance_ci_co(AttValEnd, carryQ.get_carry_in(7), 7);
763                                tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
764                                if (bitblock::any(simd_or(AttValFollow & (lex.WS), carryQ.CarryTest(8, 1))))
765                                {
766                                        AfterWS = carryQ.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, carryQ.get_carry_in(8), 8);
767                                        AttListEnd = simd_or(AttListEnd, AfterWS & AttListDelim);
768                                        AttNameStart = simd_andc(AfterWS, AttListDelim);
769                                }
770                                else
771                                {
772                                        AttListEnd = simd_or(AttListEnd, AttValFollow & AttListDelim);
773                                        AttNameStart = simd_andc(AttValFollow, AttListDelim);
774                                        carryQ.CarryDequeueEnqueue(8, 1);
775                                }
776                                ParseError = simd_or(ParseError, AttValFollow & AttNameStart);
777                        }
778                }
779                else
780                {
781                        BitBlock AttListEnd = simd_and(tag_Callouts.ElemName_ends, AttListDelim);
782                        ParseError = simd_or(ParseError, (tag_Callouts.ElemName_ends) & (simd_not(AttListDelim)));
783                        carryQ.CarryDequeueEnqueue(1, 8);
784                }
785                BitBlock STagEnds = simd_and(AttListEnd, lex.RAngle);
786                tag_Callouts.EmptyTag_marks = carryQ.BitBlock_advance_ci_co(simd_and(AttListEnd, lex.Slash), carryQ.get_carry_in(9), 9);
787                ParseError = simd_or(ParseError, (tag_Callouts.EmptyTag_marks) & (simd_not(lex.RAngle)));
788                BitBlock EndTagEnds = carryQ.BitBlock_advance_then_scanthru(tag_Callouts.EndTag_marks, lex.NameScan, carryQ.get_carry_in(10), 10);
789                if (bitblock::any(simd_or(EndTagEnds & (lex.WS), carryQ.CarryTest(11, 1))))
790                {
791                        EndTagEnds = carryQ.BitBlock_scanthru_ci_co(EndTagEnds, lex.WS, carryQ.get_carry_in(11), 11);
792                }
793                else
794                {
795                        carryQ.CarryDequeueEnqueue(11, 1);
796                }
797                ParseError = simd_or(ParseError, EndTagEnds & (simd_not(lex.RAngle)));
798                if (bitblock::any(bitblock::any(ParseError)))
799                {
800                        assert_0_error(ParseError, "Tag parsing error found");
801                }
802                tag_Callouts.AttVal_spans = carryQ.BitBlock_span_upto(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends, carryQ.get_carry_in(12), 12);
803                carryQ.CarryQ_Adjust(13);
804        }
805        IDISA_INLINE void do_final_block(struct Lex & lex, struct Marker & marker, struct Tag_Callouts & tag_Callouts, BitBlock & EOF_mask)
806        {
807                BitBlock DQuoteDelim = simd_or(lex.DQuote, lex.LAngle);
808                BitBlock SQuoteDelim = simd_or(lex.SQuote, lex.LAngle);
809                BitBlock AttListDelim = simd_or(lex.Slash, lex.RAngle);
810                tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope, lex.Slash);
811                tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope, lex.Slash);
812                tag_Callouts.ElemName_ends = carryQ.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_starts, lex.NameScan, carryQ.get_carry_in(0), 0);
813                BitBlock ParseError = simd_and(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
814                tag_Callouts.AttName_starts = simd<1>::constant<0>();
815                tag_Callouts.AttName_ends = simd<1>::constant<0>();
816                tag_Callouts.AttVal_starts = simd<1>::constant<0>();
817                tag_Callouts.AttVal_ends = simd<1>::constant<0>();
818                if (bitblock::any(simd_or((tag_Callouts.ElemName_ends) & (lex.WS), carryQ.CarryTest(1, 8))))
819                {
820                        BitBlock AfterWS = carryQ.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_ends, lex.WS, carryQ.get_carry_in(1), 1);
821                        BitBlock AttListEnd = simd_and(AfterWS, AttListDelim);
822                        BitBlock AttNameStart = simd_andc(AfterWS, AttListDelim);
823                        while (bitblock::any(AttNameStart))
824                        {
825                                ParseError = simd_or(ParseError, AttNameStart & (simd_not(lex.NameScan)));
826                                tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
827                                BitBlock AttNameFollow = carryQ.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, carryQ.get_carry_in(2), 2);
828                                tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
829                                if (bitblock::any(simd_or(AttNameFollow & (lex.WS), carryQ.CarryTest(3, 1))))
830                                {
831                                        BitBlock EqExpected = carryQ.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, carryQ.get_carry_in(3), 3);
832                                }
833                                else
834                                {
835                                        BitBlock EqExpected = AttNameFollow;
836                                        carryQ.CarryDequeueEnqueue(3, 1);
837                                }
838                                ParseError = simd_or(ParseError, EqExpected & (simd_not(lex.Equals)));
839                                BitBlock AttValPos = carryQ.BitBlock_advance_then_scanthru(EqExpected, lex.WS, carryQ.get_carry_in(4), 4);
840                                tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
841                                BitBlock DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
842                                BitBlock SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
843                                BitBlock DQuoteAttEnd = carryQ.BitBlock_advance_then_scanto(DQuoteAttVal, simd_andc(DQuoteDelim, EOF_mask), carryQ.get_carry_in(5), 5);
844                                BitBlock SQuoteAttEnd = carryQ.BitBlock_advance_then_scanto(SQuoteAttVal, simd_andc(SQuoteDelim, EOF_mask), carryQ.get_carry_in(6), 6);
845                                BitBlock AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
846                                ParseError = simd_or(ParseError, (simd_or(AttValPos, AttValEnd)) & (simd_not(simd_or(lex.DQuote, lex.SQuote))));
847                                BitBlock AttValFollow = carryQ.BitBlock_advance_ci_co(AttValEnd, carryQ.get_carry_in(7), 7);
848                                tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
849                                if (bitblock::any(simd_or(AttValFollow & (lex.WS), carryQ.CarryTest(8, 1))))
850                                {
851                                        AfterWS = carryQ.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, carryQ.get_carry_in(8), 8);
852                                        AttListEnd = simd_or(AttListEnd, AfterWS & AttListDelim);
853                                        AttNameStart = simd_andc(AfterWS, AttListDelim);
854                                }
855                                else
856                                {
857                                        AttListEnd = simd_or(AttListEnd, AttValFollow & AttListDelim);
858                                        AttNameStart = simd_andc(AttValFollow, AttListDelim);
859                                        carryQ.CarryDequeueEnqueue(8, 1);
860                                }
861                                ParseError = simd_or(ParseError, AttValFollow & AttNameStart);
862                        }
863                }
864                else
865                {
866                        BitBlock AttListEnd = simd_and(tag_Callouts.ElemName_ends, AttListDelim);
867                        ParseError = simd_or(ParseError, (tag_Callouts.ElemName_ends) & (simd_not(AttListDelim)));
868                        carryQ.CarryDequeueEnqueue(1, 8);
869                }
870                BitBlock STagEnds = simd_and(AttListEnd, lex.RAngle);
871                tag_Callouts.EmptyTag_marks = carryQ.BitBlock_advance_ci_co(simd_and(AttListEnd, lex.Slash), carryQ.get_carry_in(9), 9);
872                ParseError = simd_or(ParseError, (tag_Callouts.EmptyTag_marks) & (simd_not(lex.RAngle)));
873                BitBlock EndTagEnds = carryQ.BitBlock_advance_then_scanthru(tag_Callouts.EndTag_marks, lex.NameScan, carryQ.get_carry_in(10), 10);
874                if (bitblock::any(simd_or(EndTagEnds & (lex.WS), carryQ.CarryTest(11, 1))))
875                {
876                        EndTagEnds = carryQ.BitBlock_scanthru_ci_co(EndTagEnds, lex.WS, carryQ.get_carry_in(11), 11);
877                }
878                else
879                {
880                        carryQ.CarryDequeueEnqueue(11, 1);
881                }
882                ParseError = simd_or(ParseError, EndTagEnds & (simd_not(lex.RAngle)));
883                if (bitblock::any(bitblock::any(ParseError)))
884                {
885                        assert_0_error(ParseError, "Tag parsing error found");
886                }
887                tag_Callouts.AttVal_spans = carryQ.BitBlock_span_upto(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends, carryQ.get_carry_in(12), 12);
888                carryQ.CarryQ_Adjust(13);
889        }
890        CarryArray<13,0> carryQ;
891}
892 
893struct Parse_refs
894{
895        IDISA_INLINE void do_block(struct Lex & lex, struct Marker & marker, struct Ref_Callouts & ref_Callouts)
896        {
897                ref_Callouts.GenRef_starts = simd<1>::constant<0>();
898                ref_Callouts.GenRef_ends = simd<1>::constant<0>();
899                ref_Callouts.DecRef_starts = simd<1>::constant<0>();
900                ref_Callouts.DecRef_ends = simd<1>::constant<0>();
901                ref_Callouts.HexRef_starts = simd<1>::constant<0>();
902                ref_Callouts.HexRef_ends = simd<1>::constant<0>();
903                BitBlock ref_error = simd<1>::constant<0>();
904                if (bitblock::any(simd_or(marker.Ref_opener, carryQ.CarryTest(0, 6))))
905                {
906                        BitBlock Ref_scope = carryQ.BitBlock_advance_ci_co(marker.Ref_opener, carryQ.get_carry_in(0), 0);
907                        BitBlock NumRef2 = simd_and(Ref_scope, lex.Hash);
908                        ref_Callouts.GenRef_starts = simd_andc(Ref_scope, lex.Hash);
909                        BitBlock NumRef3 = carryQ.BitBlock_advance_ci_co(NumRef2, carryQ.get_carry_in(1), 1);
910                        BitBlock HexRef3 = simd_and(NumRef3, lex.x);
911                        ref_Callouts.DecRef_starts = simd_andc(NumRef3, lex.x);
912                        ref_Callouts.HexRef_starts = carryQ.BitBlock_advance_ci_co(HexRef3, carryQ.get_carry_in(2), 2);
913                        ref_Callouts.GenRef_ends = carryQ.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts, lex.NameScan, carryQ.get_carry_in(3), 3);
914                        ref_Callouts.DecRef_ends = carryQ.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carryQ.get_carry_in(4), 4);
915                        ref_Callouts.HexRef_ends = carryQ.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carryQ.get_carry_in(5), 5);
916                        BitBlock ref_error1 = simd_andc(ref_Callouts.DecRef_starts, lex.Digit);
917                        BitBlock ref_error2 = simd_andc(ref_Callouts.HexRef_starts, lex.Hex);
918                        BitBlock ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
919                        BitBlock ref_error3 = simd_andc(ref_ends, lex.Semicolon);
920                        if (bitblock::any(bitblock::any((simd_or(ref_error1, ref_error2)) | ref_error3)))
921                        {
922                                assert_0_error(simd_or(simd_or(ref_error1, ref_error2), ref_error3), "Reference error found");
923                        }
924                }
925                else
926                {
927                        carryQ.CarryDequeueEnqueue(0, 6);
928                }
929                carryQ.CarryQ_Adjust(6);
930        }
931        IDISA_INLINE void do_final_block(struct Lex & lex, struct Marker & marker, struct Ref_Callouts & ref_Callouts, BitBlock & EOF_mask)
932        {
933                ref_Callouts.GenRef_starts = simd<1>::constant<0>();
934                ref_Callouts.GenRef_ends = simd<1>::constant<0>();
935                ref_Callouts.DecRef_starts = simd<1>::constant<0>();
936                ref_Callouts.DecRef_ends = simd<1>::constant<0>();
937                ref_Callouts.HexRef_starts = simd<1>::constant<0>();
938                ref_Callouts.HexRef_ends = simd<1>::constant<0>();
939                BitBlock ref_error = simd<1>::constant<0>();
940                if (bitblock::any(simd_or(marker.Ref_opener, carryQ.CarryTest(0, 6))))
941                {
942                        BitBlock Ref_scope = carryQ.BitBlock_advance_ci_co(marker.Ref_opener, carryQ.get_carry_in(0), 0);
943                        BitBlock NumRef2 = simd_and(Ref_scope, lex.Hash);
944                        ref_Callouts.GenRef_starts = simd_andc(Ref_scope, lex.Hash);
945                        BitBlock NumRef3 = carryQ.BitBlock_advance_ci_co(NumRef2, carryQ.get_carry_in(1), 1);
946                        BitBlock HexRef3 = simd_and(NumRef3, lex.x);
947                        ref_Callouts.DecRef_starts = simd_andc(NumRef3, lex.x);
948                        ref_Callouts.HexRef_starts = carryQ.BitBlock_advance_ci_co(HexRef3, carryQ.get_carry_in(2), 2);
949                        ref_Callouts.GenRef_ends = carryQ.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts, lex.NameScan, carryQ.get_carry_in(3), 3);
950                        ref_Callouts.DecRef_ends = carryQ.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carryQ.get_carry_in(4), 4);
951                        ref_Callouts.HexRef_ends = carryQ.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carryQ.get_carry_in(5), 5);
952                        BitBlock ref_error1 = simd_andc(ref_Callouts.DecRef_starts, lex.Digit);
953                        BitBlock ref_error2 = simd_andc(ref_Callouts.HexRef_starts, lex.Hex);
954                        BitBlock ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
955                        BitBlock ref_error3 = simd_andc(ref_ends, lex.Semicolon);
956                        if (bitblock::any(bitblock::any((simd_or(ref_error1, ref_error2)) | ref_error3)))
957                        {
958                                assert_0_error(simd_or(simd_or(ref_error1, ref_error2), ref_error3), "Reference error found");
959                        }
960                }
961                else
962                {
963                        carryQ.CarryDequeueEnqueue(0, 6);
964                }
965                carryQ.CarryQ_Adjust(6);
966        }
967        CarryArray<6,0> carryQ;
968}
969 
970struct Validate_xml_names
971{
972        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)
973        {
974                BitBlock PI_names = carryQ.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carryQ.get_carry_in(0), 0);
975                BitBlock GenRefs = carryQ.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carryQ.get_carry_in(1), 1);
976                BitBlock ElemNames = carryQ.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carryQ.get_carry_in(2), 2);
977                BitBlock AttNames = carryQ.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carryQ.get_carry_in(3), 3);
978                BitBlock qname_stream = simd_or(ElemNames, AttNames);
979                BitBlock ncname_stream = simd_or(PI_names, GenRefs);
980                BitBlock name_stream = simd_or(qname_stream, ncname_stream);
981                BitBlock name_start = simd_andc(name_stream, carryQ.BitBlock_advance_ci_co(name_stream, carryQ.get_carry_in(4), 4));
982                BitBlock name_cursor = simd_andc(name_stream, carryQ.BitBlock_advance_ci_co(name_stream, carryQ.get_carry_in(5), 5));
983                BitBlock void_prefix_err = simd_and(name_cursor, lex.Colon);
984                BitBlock namespace_sep = simd_and(carryQ.BitBlock_scanthru_ci_co(name_cursor, simd_andc(lex.NameScan, lex.Colon), carryQ.get_carry_in(6), 6), lex.Colon);
985                BitBlock local_part_start = carryQ.BitBlock_advance_ci_co(namespace_sep, carryQ.get_carry_in(7), 7);
986                BitBlock local_part_err = simd_andc(local_part_start, lex.NameScan);
987                BitBlock colon2_err = simd_and(carryQ.BitBlock_scanthru_ci_co(local_part_start, simd_andc(lex.NameScan, lex.Colon), carryQ.get_carry_in(8), 8), lex.Colon);
988                BitBlock ncname_err = simd_and(ncname_stream, lex.Colon);
989                if (bitblock::any(bitblock::any((simd_or(simd_or(void_prefix_err, local_part_err), colon2_err)) | ncname_err)))
990                {
991                        assert_0_error(simd_or(simd_or(simd_or(void_prefix_err, local_part_err), colon2_err), ncname_err), "name syntax error");
992                }
993                check_streams.non_ascii_name_starts = simd_andc(name_start, lex.ASCII_name_start);
994                check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream, name_start), lex.ASCII_name_char), u8.suffix);
995                carryQ.CarryQ_Adjust(9);
996        }
997        IDISA_INLINE 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)
998        {
999                BitBlock PI_names = carryQ.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carryQ.get_carry_in(0), 0);
1000                BitBlock GenRefs = carryQ.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carryQ.get_carry_in(1), 1);
1001                BitBlock ElemNames = carryQ.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carryQ.get_carry_in(2), 2);
1002                BitBlock AttNames = carryQ.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carryQ.get_carry_in(3), 3);
1003                BitBlock qname_stream = simd_or(ElemNames, AttNames);
1004                BitBlock ncname_stream = simd_or(PI_names, GenRefs);
1005                BitBlock name_stream = simd_or(qname_stream, ncname_stream);
1006                BitBlock name_start = simd_andc(name_stream, carryQ.BitBlock_advance_ci_co(name_stream, carryQ.get_carry_in(4), 4));
1007                BitBlock name_cursor = simd_andc(name_stream, carryQ.BitBlock_advance_ci_co(name_stream, carryQ.get_carry_in(5), 5));
1008                BitBlock void_prefix_err = simd_and(name_cursor, lex.Colon);
1009                BitBlock namespace_sep = simd_and(carryQ.BitBlock_scanthru_ci_co(name_cursor, simd_andc(lex.NameScan, lex.Colon), carryQ.get_carry_in(6), 6), lex.Colon);
1010                BitBlock local_part_start = carryQ.BitBlock_advance_ci_co(namespace_sep, carryQ.get_carry_in(7), 7);
1011                BitBlock local_part_err = simd_andc(local_part_start, lex.NameScan);
1012                BitBlock colon2_err = simd_and(carryQ.BitBlock_scanthru_ci_co(local_part_start, simd_andc(lex.NameScan, lex.Colon), carryQ.get_carry_in(8), 8), lex.Colon);
1013                BitBlock ncname_err = simd_and(ncname_stream, lex.Colon);
1014                if (bitblock::any(bitblock::any((simd_or(simd_or(void_prefix_err, local_part_err), colon2_err)) | ncname_err)))
1015                {
1016                        assert_0_error(simd_or(simd_or(simd_or(void_prefix_err, local_part_err), colon2_err), ncname_err), "name syntax error");
1017                }
1018                check_streams.non_ascii_name_starts = simd_andc(name_start, lex.ASCII_name_start);
1019                check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream, name_start), lex.ASCII_name_char), u8.suffix);
1020                carryQ.CarryQ_Adjust(9);
1021        }
1022        CarryArray<9,0> carryQ;
1023}
1024 
1025struct Do_check_streams
1026{
1027        IDISA_INLINE void do_block(struct Marker & marker, struct Tag_Callouts & tag_Callouts, struct Check_streams & check_streams)
1028        {
1029                if (bitblock::any(bitblock::any((marker.CD_closer) & (simd_not(tag_Callouts.AttVal_spans)))))
1030                {
1031                        assert_0_error(simd_andc(marker.CD_closer, tag_Callouts.AttVal_spans), "Error: ]]> in text");
1032                }
1033                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);
1034                check_streams.name_follows = simd_or(tag_Callouts.ElemName_ends, tag_Callouts.AttName_ends);
1035                check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans, marker.Ref_opener);
1036        }
1037        IDISA_INLINE void do_final_block(struct Marker & marker, struct Tag_Callouts & tag_Callouts, struct Check_streams & check_streams, BitBlock & EOF_mask)
1038        {
1039                if (bitblock::any(bitblock::any((marker.CD_closer) & (simd_not(tag_Callouts.AttVal_spans)))))
1040                {
1041                        assert_0_error(simd_andc(marker.CD_closer, tag_Callouts.AttVal_spans), "Error: ]]> in text");
1042                }
1043                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);
1044                check_streams.name_follows = simd_or(tag_Callouts.ElemName_ends, tag_Callouts.AttName_ends);
1045                check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans, marker.Ref_opener);
1046        }
1047        CarryArray<0,0> carryQ;
1048}
1049 
1050struct Main
1051{
1052        IDISA_INLINE void do_block(struct Basis_bits & basis_bits, struct Lex & lex, struct U8 & u8, struct Xml_char & xml_char, struct Scope1 & scope1, struct CtCDPI_Callouts & ctCDPI_Callouts, struct Ref_Callouts & ref_Callouts, struct Tag_Callouts & tag_Callouts, struct Masks & masks, struct Xml_names & xml_names, struct Check_streams & check_streams)
1053        {
1054                Classify_bytes_Validate_utf8(basis_bits, lex, u8);
1055                Parse_CtCDPI(lex, marker, ctCDPI_Callouts, check_streams);
1056                Parse_tags(lex, marker, tag_Callouts);
1057                Parse_refs(lex, marker, ref_Callouts);
1058                Validate_xml_names(ctCDPI_Callouts, ref_Callouts, tag_Callouts, lex, u8, check_streams);
1059                Do_check_streams(marker, tag_Callouts, check_streams);
1060        }
1061        IDISA_INLINE void do_final_block(struct Basis_bits & basis_bits, struct Lex & lex, struct U8 & u8, struct Xml_char & xml_char, struct Scope1 & scope1, struct CtCDPI_Callouts & ctCDPI_Callouts, struct Ref_Callouts & ref_Callouts, struct Tag_Callouts & tag_Callouts, struct Masks & masks, struct Xml_names & xml_names, struct Check_streams & check_streams, BitBlock & EOF_mask)
1062        {
1063                Classify_bytes_Validate_utf8(basis_bits, lex, u8);
1064                Parse_CtCDPI(lex, marker, ctCDPI_Callouts, check_streams);
1065                Parse_tags(lex, marker, tag_Callouts);
1066                Parse_refs(lex, marker, ref_Callouts);
1067                Validate_xml_names(ctCDPI_Callouts, ref_Callouts, tag_Callouts, lex, u8, check_streams);
1068                Do_check_streams(marker, tag_Callouts, check_streams);
1069        }
1070        CarryArray<0,0> carryQ;
1071}
1072 
1073
Note: See TracBrowser for help on using the repository browser.