source: proto/pabloj/trunk/input/test/pabloB/proto/parabix2_pablo.pablob @ 3004

Last change on this file since 3004 was 3004, checked in by ksherdy, 6 years ago

Implemented framework skeleton to support PabloB IDISA function call translation to C,C++,LLVM.

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