source: proto/pabloj/branches/refactor-experimental/input/test/pabloB/all/all.pablob @ 3192

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

Sweeping changes to sync branch with trunk.

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