source: proto/pabloj/trunk/input/test/b2k/all/all.b2k @ 3684

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

Renamed test files for s2k.

File size: 33.4 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        look_ahead = [0];
72        look_behind = [0];
73        carry_init = [0,0,1,1];
74    }
75
76    function void do_block()
77    {
78   
79        BitBlock a;
80        BitBlock b;
81        BitBlock c;
82        BitBlock k;
83        BitBlock r;
84
85        r = bitblock.any<128>(a);
86       
87        /*
88        r = simd.add(abs);
89        r = simd.neg(a);
90        r = simd.add_hl(a);
91        r = simd.xor_hl(a);
92        r = simd.slli(k);
93        r = simd.srli(k);
94        r = simd.srai(k);
95        r = simd.popcount(a);
96        r = simd.ctz(a);   
97        */
98
99       
100       
101    }
102
103    function void do_final_block()
104    {
105       
106       
107    }
108
109    CarryDeclare(carry_set_0, 0, 0);
110}; 
111// KERNEL kernelName LCURLY funcDef (optFuncDef)? RCURLY TERMINATOR?;
112               
113kernel KernelName
114{
115        init
116        {
117                       
118        }
119
120        function void do_block()
121        {
122       
123                BitBlock a;
124                BitBlock b;
125                BitBlock c;
126                BitBlock k;
127                BitBlock r;
128               
129                /*
130                r = simd.add(abs);
131                r = simd.neg(a);
132                r = simd.add_hl(a);
133                r = simd.xor_hl(a);
134                r = simd.slli(k);
135                r = simd.srli(k);
136                r = simd.srai(k);
137                r = simd.popcount(a);
138                r = simd.ctz(a);       
139                */
140
141                t = bitblock.any<1>(a);
142                r = bitblock.slli<1>(10, a);
143                bitblock.store_unaligned<1>(a, b);
144                r = bitblock.load_aligned<1>(b);
145               
146                r = simd.not<1>(a);             
147                r = simd.nor<1>(a, b);
148                r = simd.ifh<16>(a, b, c);                     
149               
150                r = simd.constant<2>(3);
151                r = simd.slli<8>(1, a);                 
152                r = esimd.mergh<8>(a,b,c);
153                r = simd.add<1>(a,b);
154                r = simd.sub<2>(a,b);
155                r = simd.mult<4>(a,b);
156                r = simd.eq<8>(a,b);
157                r = simd.gt<16>(a,b);
158                r = simd.ugt<32>(a,b);
159                r = simd.lt<64>(a,b);
160                r = simd.ult<128>(a,b);
161                r = simd.max<128>(a,b);
162                r = simd.umax<1>(a,b);
163                r = simd.min<2>(a,b);
164                r = simd.umin<4>(a,b);
165                r = simd.sll<64>(a,b);
166                r = simd.srl<64>(a,b);
167                //r = simd.srai<32>(10,a);
168               
169                //r = simd.if<128>(a,b,c);
170               
171        }
172
173        function void do_final_block()
174        {
175               
176               
177        }
178
179        CarryDeclare(carry_set_0, 0, 0);
180};     
181// KERNEL kernelName LCURLY funcDef (optFuncDef)? RCURLY TERMINATOR?;
182       
183struct Basis_bits
184{
185        BitBlock bit_0;
186        BitBlock bit_1;
187        BitBlock bit_2;
188        BitBlock bit_3;
189        BitBlock bit_4;
190        BitBlock bit_5;
191        BitBlock bit_6;
192        BitBlock bit_7;
193};
194 
195struct U8
196{
197        BitBlock unibyte;
198        BitBlock prefix;
199        BitBlock prefix2;
200        BitBlock prefix3;
201        BitBlock prefix4;
202        BitBlock suffix;
203        BitBlock badprefix;
204        BitBlock xE0;
205        BitBlock xED;
206        BitBlock xF0;
207        BitBlock xF4;
208        BitBlock xA0_xBF;
209        BitBlock x80_x9F;
210        BitBlock x90_xBF;
211        BitBlock x80_x8F;
212        BitBlock xEF;
213        BitBlock xBF;
214        BitBlock xBE;
215        BitBlock scope22;
216        BitBlock scope32;
217        BitBlock scope33;
218        BitBlock scope42;
219        BitBlock scope43;
220        BitBlock scope44;
221        BitBlock xE0_scope;
222        BitBlock xED_scope;
223        BitBlock xF0_scope;
224        BitBlock xF4_scope;
225        BitBlock xEF_scope;
226};
227 
228struct Lex
229{
230        BitBlock CR;
231        BitBlock LF;
232        BitBlock HT;
233        BitBlock SP;
234        BitBlock CRLF;
235        BitBlock RefStart;
236        BitBlock Semicolon;
237        BitBlock Colon;
238        BitBlock LAngle;
239        BitBlock RAngle;
240        BitBlock LBracket;
241        BitBlock RBracket;
242        BitBlock Exclam;
243        BitBlock QMark;
244        BitBlock Hyphen;
245        BitBlock Equals;
246        BitBlock SQuote;
247        BitBlock DQuote;
248        BitBlock Slash;
249        BitBlock Hash;
250        BitBlock x;
251        BitBlock ASCII_name_start;
252        BitBlock ASCII_name_char;
253        BitBlock NameScan;
254        BitBlock Digit;
255        BitBlock Hex;
256        BitBlock WS;
257};
258 
259struct Marker
260{
261        BitBlock LAngle_scope;
262        BitBlock Ref_opener;
263        BitBlock CD_closer;
264};
265 
266struct CtCDPI_Callouts
267{
268        BitBlock Ct_starts;
269        BitBlock Ct_ends;
270        BitBlock CD_starts;
271        BitBlock CD_ends;
272        BitBlock PI_starts;
273        BitBlock PI_name_starts;
274        BitBlock PI_name_ends;
275        BitBlock PI_ends;
276};
277 
278struct Ref_Callouts
279{
280        BitBlock GenRef_starts;
281        BitBlock GenRef_ends;
282        BitBlock DecRef_starts;
283        BitBlock DecRef_ends;
284        BitBlock HexRef_starts;
285        BitBlock HexRef_ends;
286};
287 
288struct Tag_Callouts
289{
290        BitBlock ElemName_starts;
291        BitBlock ElemName_ends;
292        BitBlock AttName_starts;
293        BitBlock AttName_ends;
294        BitBlock AttVal_starts;
295        BitBlock AttVal_ends;
296        BitBlock AttVal_spans;
297        BitBlock EmptyTag_marks;
298        BitBlock EndTag_marks;
299};
300 
301struct Check_streams
302{
303        BitBlock misc_mask;
304        BitBlock non_ascii_name_starts;
305        BitBlock non_ascii_names;
306        BitBlock tag_marks;
307        BitBlock name_follows;
308        BitBlock att_refs;
309};     
310               
311kernel Classify_bytes_Validate_utf8 
312{
313        state
314        {
315         
316        }
317
318        function void do_block(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8)
319        {
320                BitBlock temp1 = simd.or<1>(basis_bits.bit_0, basis_bits.bit_1);
321                BitBlock temp2 = simd.andc<1>(basis_bits.bit_2, basis_bits.bit_3);
322                BitBlock temp3 = simd.andc<1>(temp2, temp1);
323                BitBlock temp4 = simd.andc<1>(basis_bits.bit_5, basis_bits.bit_4);
324                BitBlock temp5 = simd.andc<1>(basis_bits.bit_6, basis_bits.bit_7);
325                BitBlock temp6 = simd.and<1>(temp4, temp5);
326                lex.RefStart = simd.and<1>(temp3, temp6);
327                BitBlock temp7 = simd.and<1>(basis_bits.bit_2, basis_bits.bit_3);
328                BitBlock temp8 = simd.andc<1>(temp7, temp1);
329                BitBlock temp9 = simd.andc<1>(basis_bits.bit_4, basis_bits.bit_5);
330                BitBlock temp10 = simd.and<1>(basis_bits.bit_6, basis_bits.bit_7);
331                BitBlock temp11 = simd.and<1>(temp9, temp10);
332                lex.Semicolon = simd.and<1>(temp8, temp11);
333                BitBlock temp12 = simd.and<1>(basis_bits.bit_4, basis_bits.bit_5);
334                BitBlock temp13 = simd.or<1>(basis_bits.bit_6, basis_bits.bit_7);
335                BitBlock temp14 = simd.andc<1>(temp12, temp13);
336                lex.LAngle = simd.and<1>(temp8, temp14);
337                BitBlock temp15 = simd.and<1>(temp12, temp5);
338                lex.RAngle = simd.and<1>(temp8, temp15);
339                BitBlock temp16 = simd.andc<1>(basis_bits.bit_1, basis_bits.bit_0);
340                BitBlock temp17 = simd.andc<1>(basis_bits.bit_3, basis_bits.bit_2);
341                BitBlock temp18 = simd.and<1>(temp16, temp17);
342                lex.LBracket = simd.and<1>(temp18, temp11);
343                BitBlock temp19 = simd.andc<1>(basis_bits.bit_7, basis_bits.bit_6);
344                BitBlock temp20 = simd.and<1>(temp12, temp19);
345                lex.RBracket = simd.and<1>(temp18, temp20);
346                BitBlock temp21 = simd.or<1>(basis_bits.bit_4, basis_bits.bit_5);
347                BitBlock temp22 = simd.andc<1>(temp19, temp21);
348                lex.Exclam = simd.and<1>(temp3, temp22);
349                BitBlock temp23 = simd.and<1>(temp12, temp10);
350                lex.QMark = simd.and<1>(temp8, temp23);
351                lex.Hyphen = simd.and<1>(temp3, temp20);
352                lex.Equals = simd.and<1>(temp8, temp20);
353                BitBlock temp24 = simd.and<1>(temp4, temp10);
354                lex.SQuote = simd.and<1>(temp3, temp24);
355                BitBlock temp25 = simd.andc<1>(temp5, temp21);
356                lex.DQuote = simd.and<1>(temp3, temp25);
357                lex.Slash = simd.and<1>(temp3, temp23);
358                BitBlock temp26 = simd.andc<1>(temp10, temp21);
359                lex.Hash = simd.and<1>(temp3, temp26);
360                BitBlock temp27 = simd.and<1>(temp16, temp7);
361                BitBlock temp28 = simd.andc<1>(temp9, temp13);
362                lex.x = simd.and<1>(temp27, temp28);
363                BitBlock temp29 = simd.and<1>(temp9, temp5);
364                lex.Colon = simd.and<1>(temp8, temp29);
365                BitBlock temp30 = simd.and<1>(temp18, temp23);
366                BitBlock temp31 = simd.or<1>(temp30, lex.Colon);
367                BitBlock temp32 = simd.andc<1>(temp16, basis_bits.bit_2);
368                BitBlock temp33 = simd.or<1>(basis_bits.bit_5, temp10);
369                BitBlock temp34 = simd.and<1>(basis_bits.bit_4, temp33);
370                BitBlock temp35 = simd.not<1>(temp34);
371                BitBlock temp36 = simd.or<1>(temp21, temp13);
372                BitBlock temp37 = simd.or<1>(simd.and<1>(basis_bits.bit_3, temp35), simd.andc<1>(temp36, basis_bits.bit_3));
373                BitBlock temp38 = simd.and<1>(temp32, temp37);
374                BitBlock temp39 = simd.or<1>(temp31, temp38);
375                BitBlock temp40 = simd.and<1>(temp16, basis_bits.bit_2);
376                BitBlock temp41 = simd.and<1>(temp40, temp37);
377                lex.ASCII_name_start = simd.or<1>(temp39, temp41);
378                BitBlock temp42 = simd.or<1>(temp30, lex.Hyphen);
379                BitBlock temp43 = simd.and<1>(temp3, temp15);
380                BitBlock temp44 = simd.or<1>(temp42, temp43);
381                BitBlock temp45 = simd.andc<1>(temp8, temp34);
382                BitBlock temp46 = simd.or<1>(temp44, temp45);
383                BitBlock temp47 = simd.or<1>(temp46, temp38);
384                lex.ASCII_name_char = simd.or<1>(temp47, temp41);
385                lex.NameScan = simd.or<1>(lex.ASCII_name_char, basis_bits.bit_0);
386                BitBlock temp48 = simd.or<1>(temp1, basis_bits.bit_2);
387                BitBlock x00_x1F = simd.not<1>(temp48);
388                BitBlock temp49 = simd.or<1>(basis_bits.bit_2, basis_bits.bit_3);
389                BitBlock temp50 = simd.or<1>(temp1, temp49);
390                lex.CR = simd.andc<1>(temp20, temp50);
391                lex.LF = simd.andc<1>(temp29, temp50);
392                BitBlock temp51 = simd.and<1>(temp9, temp19);
393                lex.HT = simd.andc<1>(temp51, temp50);
394                lex.SP = simd.andc<1>(temp3, temp36);
395                BitBlock temp52 = simd.or<1>(temp20, temp29);
396                BitBlock temp53 = simd.or<1>(temp52, temp51);
397                BitBlock temp54 = simd.andc<1>(temp53, temp50);
398                lex.WS = simd.or<1>(temp54, lex.SP);
399                BitBlock temp55 = simd.or<1>(basis_bits.bit_5, basis_bits.bit_6);
400                BitBlock temp56 = simd.and<1>(basis_bits.bit_4, temp55);
401                lex.Digit = simd.andc<1>(temp8, temp56);
402                BitBlock temp57 = simd.andc<1>(temp16, temp49);
403                BitBlock temp58 = simd.andc<1>(temp57, basis_bits.bit_4);
404                BitBlock temp59 = simd.not<1>(temp10);
405                BitBlock temp60 = simd.or<1>(simd.and<1>(basis_bits.bit_5, temp59), simd.andc<1>(temp13, basis_bits.bit_5));
406                BitBlock temp61 = simd.and<1>(temp58, temp60);
407                BitBlock temp62 = simd.or<1>(lex.Digit, temp61);
408                BitBlock temp63 = simd.and<1>(temp16, temp2);
409                BitBlock temp64 = simd.andc<1>(temp63, basis_bits.bit_4);
410                BitBlock temp65 = simd.and<1>(temp64, temp60);
411                lex.Hex = simd.or<1>(temp62, temp65);
412                BitBlock lex_error = simd.andc<1>(x00_x1F, lex.WS);
413
414                if (bitblock.any<1>((lex_error)))
415                {
416                        assert_0_error("Error: illegal character", lex_error);
417                }
418                u8.unibyte = simd.not<1>(basis_bits.bit_0);
419                u8.suffix = simd.constant<1>(0);
420                BitBlock u8_error = simd.constant<1>(0);
421                BitBlock u8_FFFE_FFFF = simd.constant<1>(0);
422                BitBlock u8anyscope = simd.constant<1>(0);
423                if (bitblock.any<1>((simd.or<1>(basis_bits.bit_0, carry_set_0.CarryRange(0, 10)))))
424                {
425                        u8.prefix = simd.and<1>(basis_bits.bit_0, basis_bits.bit_1);
426                        u8.prefix2 = simd.andc<1>(u8.prefix, basis_bits.bit_2);
427                        u8.prefix3 = simd.and<1>(u8.prefix, temp2);
428                        u8.prefix4 = simd.and<1>(u8.prefix, temp7);
429                        u8.suffix = simd.andc<1>(basis_bits.bit_0, basis_bits.bit_1);
430                        BitBlock temp66 = simd.andc<1>(u8.prefix, temp49);
431                        BitBlock temp67 = simd.or<1>(temp21, basis_bits.bit_6);
432                        BitBlock temp68 = simd.andc<1>(temp66, temp67);
433                        BitBlock temp69 = simd.and<1>(basis_bits.bit_5, temp13);
434                        BitBlock temp70 = simd.or<1>(basis_bits.bit_4, temp69);
435                        BitBlock temp71 = simd.and<1>(u8.prefix4, temp70);
436                        u8.badprefix = simd.or<1>(temp68, temp71);
437                        u8_error = u8.badprefix;
438                        u8.scope22 = carry_set_0.BitBlock_advance_ci_co(u8.prefix2, carry_set_0.CarryAt(0), 0);
439                        u8anyscope = u8.scope22;
440                        if (bitblock.any<1>((simd.or<1>(simd.or<1>(u8.prefix3, u8.prefix4), carry_set_0.CarryRange(1, 9)))))
441                        {
442                                BitBlock xE0 = simd.andc<1>(u8.prefix3, temp36);
443                                BitBlock xED = simd.and<1>(u8.prefix3, temp20);
444                                BitBlock xF0 = simd.andc<1>(u8.prefix4, temp36);
445                                BitBlock temp72 = simd.andc<1>(temp4, temp13);
446                                BitBlock xF4 = simd.and<1>(u8.prefix4, temp72);
447                                u8.xA0_xBF = simd.and<1>(u8.suffix, basis_bits.bit_2);
448                                u8.x80_x9F = simd.andc<1>(u8.suffix, basis_bits.bit_2);
449                                u8.x90_xBF = simd.and<1>(u8.suffix, temp49);
450                                u8.x80_x8F = simd.andc<1>(u8.suffix, temp49);
451                                BitBlock xEF = simd.and<1>(u8.prefix3, temp23);
452                                BitBlock temp73 = simd.and<1>(u8.suffix, temp7);
453                                u8.xBF = simd.and<1>(temp73, temp23);
454                                u8.xBE = simd.and<1>(temp73, temp15);
455                                u8.scope32 = carry_set_0.BitBlock_advance_ci_co(u8.prefix3, carry_set_0.CarryAt(1), 1);
456                                u8.scope33 = carry_set_0.BitBlock_advance_ci_co(u8.scope32, carry_set_0.CarryAt(2), 2);
457                                u8.scope42 = carry_set_0.BitBlock_advance_ci_co(u8.prefix4, carry_set_0.CarryAt(3), 3);
458                                u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42, carry_set_0.CarryAt(4), 4);
459                                u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43, carry_set_0.CarryAt(5), 5);
460                                BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xE0, xF0), carry_set_0.CarryAt(6), 6);
461                                BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xED, xF4), carry_set_0.CarryAt(7), 7);
462                                u8.xE0_scope = simd.and<1>(u8.scope32, E0_F0_scope);
463                                u8.xED_scope = simd.and<1>(u8.scope32, ED_F4_scope);
464                                u8.xF0_scope = simd.and<1>(u8.scope42, E0_F0_scope);
465                                u8.xF4_scope = simd.and<1>(u8.scope42, ED_F4_scope);
466                                u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF, carry_set_0.CarryAt(8), 8);
467                                BitBlock u8lastscope = simd.or<1>(simd.or<1>(u8.scope22, u8.scope33), u8.scope44);
468                                u8anyscope = simd.or<1>(simd.or<1>(simd.or<1>(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
469                                BitBlock u8error1 = simd.and<1>(u8.xE0_scope, u8.x80_x9F);
470                                BitBlock u8error2 = simd.and<1>(u8.xED_scope, u8.xA0_xBF);
471                                BitBlock u8error3 = simd.and<1>(u8.xF0_scope, u8.x80_x8F);
472                                BitBlock u8error4 = simd.and<1>(u8.xF4_scope, u8.x90_xBF);
473                                u8_error = simd.or<1>(u8_error, simd.or<1>(simd.or<1>(simd.or<1>(u8error1, u8error2), u8error3), u8error4));
474                                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);
475                                u8_FFFE_FFFF = simd.and<1>(EF_BF_pending, simd.or<1>(u8.xBE, u8.xBF));
476                        }
477                        else
478                        {
479                                carry_set_0.CarryDequeueEnqueue(1, 9);
480                        }
481                        BitBlock u8mismatch = simd.xor<1>(u8anyscope, u8.suffix);
482                        if (bitblock.any<1>((simd.or<1>(simd.or<1>(u8_error, u8mismatch), u8_FFFE_FFFF))))
483                        {
484                                assert_0_error("UTF-8 error found", simd.or<1>(simd.or<1>(u8_error, u8mismatch), u8_FFFE_FFFF));
485                        }
486                }
487                else
488                {
489                        carry_set_0.CarryDequeueEnqueue(0, 10);
490                }
491                carry_set_0.CarryAdjust(10);
492
493        }
494
495        function void do_final_block(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8, BitBlock EOF_mask) {
496                BitBlock temp1 = simd.or<1>(basis_bits.bit_0, basis_bits.bit_1);
497                BitBlock temp2 = simd.andc<1>(basis_bits.bit_2, basis_bits.bit_3);
498                BitBlock temp3 = simd.andc<1>(temp2, temp1);
499                BitBlock temp4 = simd.andc<1>(basis_bits.bit_5, basis_bits.bit_4);
500                BitBlock temp5 = simd.andc<1>(basis_bits.bit_6, basis_bits.bit_7);
501                BitBlock temp6 = simd.and<1>(temp4, temp5);
502                lex.RefStart = simd.and<1>(temp3, temp6);
503                BitBlock temp7 = simd.and<1>(basis_bits.bit_2, basis_bits.bit_3);
504                BitBlock temp8 = simd.andc<1>(temp7, temp1);
505                BitBlock temp9 = simd.andc<1>(basis_bits.bit_4, basis_bits.bit_5);
506                BitBlock temp10 = simd.and<1>(basis_bits.bit_6, basis_bits.bit_7);
507                BitBlock temp11 = simd.and<1>(temp9, temp10);
508                lex.Semicolon = simd.and<1>(temp8, temp11);
509                BitBlock temp12 = simd.and<1>(basis_bits.bit_4, basis_bits.bit_5);
510                BitBlock temp13 = simd.or<1>(basis_bits.bit_6, basis_bits.bit_7);
511                BitBlock temp14 = simd.andc<1>(temp12, temp13);
512                lex.LAngle = simd.and<1>(temp8, temp14);
513                BitBlock temp15 = simd.and<1>(temp12, temp5);
514                lex.RAngle = simd.and<1>(temp8, temp15);
515                BitBlock temp16 = simd.andc<1>(basis_bits.bit_1, basis_bits.bit_0);
516                BitBlock temp17 = simd.andc<1>(basis_bits.bit_3, basis_bits.bit_2);
517                BitBlock temp18 = simd.and<1>(temp16, temp17);
518                lex.LBracket = simd.and<1>(temp18, temp11);
519                BitBlock temp19 = simd.andc<1>(basis_bits.bit_7, basis_bits.bit_6);
520                BitBlock temp20 = simd.and<1>(temp12, temp19);
521                lex.RBracket = simd.and<1>(temp18, temp20);
522                BitBlock temp21 = simd.or<1>(basis_bits.bit_4, basis_bits.bit_5);
523                BitBlock temp22 = simd.andc<1>(temp19, temp21);
524                lex.Exclam = simd.and<1>(temp3, temp22);
525                BitBlock temp23 = simd.and<1>(temp12, temp10);
526                lex.QMark = simd.and<1>(temp8, temp23);
527                lex.Hyphen = simd.and<1>(temp3, temp20);
528                lex.Equals = simd.and<1>(temp8, temp20);
529                BitBlock temp24 = simd.and<1>(temp4, temp10);
530                lex.SQuote = simd.and<1>(temp3, temp24);
531                BitBlock temp25 = simd.andc<1>(temp5, temp21);
532                lex.DQuote = simd.and<1>(temp3, temp25);
533                lex.Slash = simd.and<1>(temp3, temp23);
534                BitBlock temp26 = simd.andc<1>(temp10, temp21);
535                lex.Hash = simd.and<1>(temp3, temp26);
536                BitBlock temp27 = simd.and<1>(temp16, temp7);
537                BitBlock temp28 = simd.andc<1>(temp9, temp13);
538                lex.x = simd.and<1>(temp27, temp28);
539                BitBlock temp29 = simd.and<1>(temp9, temp5);
540                lex.Colon = simd.and<1>(temp8, temp29);
541                BitBlock temp30 = simd.and<1>(temp18, temp23);
542                BitBlock temp31 = simd.or<1>(temp30, lex.Colon);
543                BitBlock temp32 = simd.andc<1>(temp16, basis_bits.bit_2);
544                BitBlock temp33 = simd.or<1>(basis_bits.bit_5, temp10);
545                BitBlock temp34 = simd.and<1>(basis_bits.bit_4, temp33);
546                BitBlock temp35 = simd.not<1>(temp34);
547                BitBlock temp36 = simd.or<1>(temp21, temp13);
548                BitBlock temp37 = simd.or<1>(simd.and<1>(basis_bits.bit_3, temp35), simd.andc<1>(temp36, basis_bits.bit_3));
549                BitBlock temp38 = simd.and<1>(temp32, temp37);
550                BitBlock temp39 = simd.or<1>(temp31, temp38);
551                BitBlock temp40 = simd.and<1>(temp16, basis_bits.bit_2);
552                BitBlock temp41 = simd.and<1>(temp40, temp37);
553                lex.ASCII_name_start = simd.or<1>(temp39, temp41);
554                BitBlock temp42 = simd.or<1>(temp30, lex.Hyphen);
555                BitBlock temp43 = simd.and<1>(temp3, temp15);
556                BitBlock temp44 = simd.or<1>(temp42, temp43);
557                BitBlock temp45 = simd.andc<1>(temp8, temp34);
558                BitBlock temp46 = simd.or<1>(temp44, temp45);
559                BitBlock temp47 = simd.or<1>(temp46, temp38);
560                lex.ASCII_name_char = simd.or<1>(temp47, temp41);
561                lex.NameScan = simd.or<1>(lex.ASCII_name_char, basis_bits.bit_0);
562                BitBlock temp48 = simd.or<1>(temp1, basis_bits.bit_2);
563                BitBlock x00_x1F = simd.not<1>(temp48);
564                BitBlock temp49 = simd.or<1>(basis_bits.bit_2, basis_bits.bit_3);
565                BitBlock temp50 = simd.or<1>(temp1, temp49);
566                lex.CR = simd.andc<1>(temp20, temp50);
567                lex.LF = simd.andc<1>(temp29, temp50);
568                BitBlock temp51 = simd.and<1>(temp9, temp19);
569                lex.HT = simd.andc<1>(temp51, temp50);
570                lex.SP = simd.andc<1>(temp3, temp36);
571                BitBlock temp52 = simd.or<1>(temp20, temp29);
572                BitBlock temp53 = simd.or<1>(temp52, temp51);
573                BitBlock temp54 = simd.andc<1>(temp53, temp50);
574                lex.WS = simd.or<1>(temp54, lex.SP);
575                BitBlock temp55 = simd.or<1>(basis_bits.bit_5, basis_bits.bit_6);
576                BitBlock temp56 = simd.and<1>(basis_bits.bit_4, temp55);
577                lex.Digit = simd.andc<1>(temp8, temp56);
578                BitBlock temp57 = simd.andc<1>(temp16, temp49);
579                BitBlock temp58 = simd.andc<1>(temp57, basis_bits.bit_4);
580                BitBlock temp59 = simd.not<1>(temp10);
581                BitBlock temp60 = simd.or<1>(simd.and<1>(basis_bits.bit_5, temp59), simd.andc<1>(temp13, basis_bits.bit_5));
582                BitBlock temp61 = simd.and<1>(temp58, temp60);
583                BitBlock temp62 = simd.or<1>(lex.Digit, temp61);
584                BitBlock temp63 = simd.and<1>(temp16, temp2);
585                BitBlock temp64 = simd.andc<1>(temp63, basis_bits.bit_4);
586                BitBlock temp65 = simd.and<1>(temp64, temp60);
587                lex.Hex = simd.or<1>(temp62, temp65);
588                BitBlock lex_error = simd.andc<1>(x00_x1F, lex.WS);
589                if (bitblock.any<1>((simd.and<1>(lex_error, EOF_mask))))
590                {
591                        assert_0_error("Error: illegal character", simd.and<1>(lex_error, EOF_mask));
592                }
593                u8.unibyte = simd.not<1>(basis_bits.bit_0);
594                u8.suffix = simd.constant<1>(0);
595                BitBlock u8_error = simd.constant<1>(0);
596                BitBlock u8_FFFE_FFFF = simd.constant<1>(0);
597                BitBlock u8anyscope = simd.constant<1>(0);
598                if (bitblock.any<1>((simd.or<1>(basis_bits.bit_0, carry_set_0.CarryRange(0, 10)))))
599                {
600                        u8.prefix = simd.and<1>(basis_bits.bit_0, basis_bits.bit_1);
601                        u8.prefix2 = simd.andc<1>(u8.prefix, basis_bits.bit_2);
602                        u8.prefix3 = simd.and<1>(u8.prefix, temp2);
603                        u8.prefix4 = simd.and<1>(u8.prefix, temp7);
604                        u8.suffix = simd.andc<1>(basis_bits.bit_0, basis_bits.bit_1);
605                        BitBlock temp66 = simd.andc<1>(u8.prefix, temp49);
606                        BitBlock temp67 = simd.or<1>(temp21, basis_bits.bit_6);
607                        BitBlock temp68 = simd.andc<1>(temp66, temp67);
608                        BitBlock temp69 = simd.and<1>(basis_bits.bit_5, temp13);
609                        BitBlock temp70 = simd.or<1>(basis_bits.bit_4, temp69);
610                        BitBlock temp71 = simd.and<1>(u8.prefix4, temp70);
611                        u8.badprefix = simd.or<1>(temp68, temp71);
612                        u8_error = u8.badprefix;
613                        u8.scope22 = carry_set_0.BitBlock_advance_ci_co(u8.prefix2, carry_set_0.CarryAt(0), 0);
614                        u8anyscope = u8.scope22;
615                        if (bitblock.any<1>((simd.or<1>(simd.or<1>(u8.prefix3, u8.prefix4), carry_set_0.CarryRange(1, 9)))))
616                        {
617                                BitBlock xE0 = simd.andc<1>(u8.prefix3, temp36);
618                                BitBlock xED = simd.and<1>(u8.prefix3, temp20);
619                                BitBlock xF0 = simd.andc<1>(u8.prefix4, temp36);
620                                BitBlock temp72 = simd.andc<1>(temp4, temp13);
621                                BitBlock xF4 = simd.and<1>(u8.prefix4, temp72);
622                                u8.xA0_xBF = simd.and<1>(u8.suffix, basis_bits.bit_2);
623                                u8.x80_x9F = simd.andc<1>(u8.suffix, basis_bits.bit_2);
624                                u8.x90_xBF = simd.and<1>(u8.suffix, temp49);
625                                u8.x80_x8F = simd.andc<1>(u8.suffix, temp49);
626                                BitBlock xEF = simd.and<1>(u8.prefix3, temp23);
627                                BitBlock temp73 = simd.and<1>(u8.suffix, temp7);
628                                u8.xBF = simd.and<1>(temp73, temp23);
629                                u8.xBE = simd.and<1>(temp73, temp15);
630                                u8.scope32 = carry_set_0.BitBlock_advance_ci_co(u8.prefix3, carry_set_0.CarryAt(1), 1);
631                                u8.scope33 = carry_set_0.BitBlock_advance_ci_co(u8.scope32, carry_set_0.CarryAt(2), 2);
632                                u8.scope42 = carry_set_0.BitBlock_advance_ci_co(u8.prefix4, carry_set_0.CarryAt(3), 3);
633                                u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42, carry_set_0.CarryAt(4), 4);
634                                u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43, carry_set_0.CarryAt(5), 5);
635                                BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xE0, xF0), carry_set_0.CarryAt(6), 6);
636                                BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xED, xF4), carry_set_0.CarryAt(7), 7);
637                                u8.xE0_scope = simd.and<1>(u8.scope32, E0_F0_scope);
638                                u8.xED_scope = simd.and<1>(u8.scope32, ED_F4_scope);
639                                u8.xF0_scope = simd.and<1>(u8.scope42, E0_F0_scope);
640                                u8.xF4_scope = simd.and<1>(u8.scope42, ED_F4_scope);
641                                u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF, carry_set_0.CarryAt(8), 8);
642                                BitBlock u8lastscope = simd.or<1>(simd.or<1>(u8.scope22, u8.scope33), u8.scope44);
643                                u8anyscope = simd.or<1>(simd.or<1>(simd.or<1>(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
644                                BitBlock u8error1 = simd.and<1>(u8.xE0_scope, u8.x80_x9F);
645                                BitBlock u8error2 = simd.and<1>(u8.xED_scope, u8.xA0_xBF);
646                                BitBlock u8error3 = simd.and<1>(u8.xF0_scope, u8.x80_x8F);
647                                BitBlock u8error4 = simd.and<1>(u8.xF4_scope, u8.x90_xBF);
648                                u8_error = simd.or<1>(u8_error, simd.or<1>(simd.or<1>(simd.or<1>(u8error1, u8error2), u8error3), u8error4));
649                                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);
650                                u8_FFFE_FFFF = simd.and<1>(EF_BF_pending, simd.or<1>(u8.xBE, u8.xBF));
651                        }
652                        else
653                        {
654                                carry_set_0.CarryDequeueEnqueue(1, 9);
655                        }
656                        BitBlock u8mismatch = simd.xor<1>(u8anyscope, u8.suffix);
657                        if (bitblock.any<1>((simd.or<1>(simd.or<1>(u8_error, u8mismatch), u8_FFFE_FFFF))))
658                        {
659                                assert_0_error("UTF-8 error found", simd.or<1>(simd.or<1>(u8_error, u8mismatch), u8_FFFE_FFFF));
660                        }
661                }
662                else
663                {
664                        carry_set_0.CarryDequeueEnqueue(0, 10);
665                }       
666        }
667        CarryDeclare(carry_set_0, 10, 0);       
668};     
669
670kernel Parse_refs
671{
672        state
673        {
674               
675        }
676         
677        function void do_block(struct Lex lex, struct Marker marker, struct Ref_Callouts ref_Callouts)
678        {
679                ref_Callouts.GenRef_starts = simd.constant<1>(0);
680                ref_Callouts.GenRef_ends = simd.constant<1>(0);
681                ref_Callouts.DecRef_starts = simd.constant<1>(0);
682                ref_Callouts.DecRef_ends = simd.constant<1>(0);
683                ref_Callouts.HexRef_starts = simd.constant<1>(0);
684                ref_Callouts.HexRef_ends = simd.constant<1>(0);
685                BitBlock ref_error = simd.constant<1>(0);
686                if (bitblock.any<1>((simd.or<1>(marker.Ref_opener, carry_set_0.CarryRange(0, 6)))))
687                {
688                        BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener, carry_set_0.CarryAt(0), 0);
689                        BitBlock NumRef2 = simd.and<1>(Ref_scope, lex.Hash);
690                        ref_Callouts.GenRef_starts = simd.andc<1>(Ref_scope, lex.Hash);
691                        BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2, carry_set_0.CarryAt(1), 1);
692                        BitBlock HexRef3 = simd.and<1>(NumRef3, lex.x);
693                        ref_Callouts.DecRef_starts = simd.andc<1>(NumRef3, lex.x);
694                        ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3, carry_set_0.CarryAt(2), 2);
695                        ref_Callouts.GenRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts, lex.NameScan, carry_set_0.CarryAt(3), 3);
696                        ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carry_set_0.CarryAt(4), 4);
697                        ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carry_set_0.CarryAt(5), 5);
698                        BitBlock ref_error1 = simd.andc<1>(ref_Callouts.DecRef_starts, lex.Digit);
699                        BitBlock ref_error2 = simd.andc<1>(ref_Callouts.HexRef_starts, lex.Hex);
700                        BitBlock ref_ends = simd.or<1>(simd.or<1>(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
701                        BitBlock ref_error3 = simd.andc<1>(ref_ends, lex.Semicolon);
702                        if (bitblock.any<1>((simd.or<1>(simd.or<1>(ref_error1, ref_error2), ref_error3))))
703                        {
704                                assert_0_error("Reference error found", simd.or<1>(simd.or<1>(ref_error1, ref_error2), ref_error3));
705                        }
706                }
707                else
708                {
709                        carry_set_0.CarryDequeueEnqueue(0, 6);
710                }
711                carry_set_0.CarryAdjust(6);
712        }
713       
714        function void do_final_block(struct Lex lex, struct Marker marker, struct Ref_Callouts ref_Callouts, BitBlock EOF_mask)
715        {
716                ref_Callouts.GenRef_starts = simd.constant<1>(0);
717                ref_Callouts.GenRef_ends = simd.constant<1>(0);
718                ref_Callouts.DecRef_starts = simd.constant<1>(0);
719                ref_Callouts.DecRef_ends = simd.constant<1>(0);
720                ref_Callouts.HexRef_starts = simd.constant<1>(0);
721                ref_Callouts.HexRef_ends = simd.constant<1>(0);
722                BitBlock ref_error = simd.constant<1>(0);
723                if (bitblock.any<1>((simd.or<1>(marker.Ref_opener, carry_set_0.CarryRange(0, 6)))))
724                {
725                        BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener, carry_set_0.CarryAt(0), 0);
726                        BitBlock NumRef2 = simd.and<1>(Ref_scope, lex.Hash);
727                        ref_Callouts.GenRef_starts = simd.andc<1>(Ref_scope, lex.Hash);
728                        BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2, carry_set_0.CarryAt(1), 1);
729                        BitBlock HexRef3 = simd.and<1>(NumRef3, lex.x);
730                        ref_Callouts.DecRef_starts = simd.andc<1>(NumRef3, lex.x);
731                        ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3, carry_set_0.CarryAt(2), 2);
732                        ref_Callouts.GenRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts, lex.NameScan, carry_set_0.CarryAt(3), 3);
733                        ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carry_set_0.CarryAt(4), 4);
734                        ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carry_set_0.CarryAt(5), 5);
735                        BitBlock ref_error1 = simd.andc<1>(ref_Callouts.DecRef_starts, lex.Digit);
736                        BitBlock ref_error2 = simd.andc<1>(ref_Callouts.HexRef_starts, lex.Hex);
737                        BitBlock ref_ends = simd.or<1>(simd.or<1>(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
738                        BitBlock ref_error3 = simd.andc<1>(ref_ends, lex.Semicolon);
739                        if (bitblock.any<1>((simd.or<1>(simd.or<1>(ref_error1, ref_error2), ref_error3))))
740                        {
741                                assert_0_error("Reference error found", simd.or<1>(simd.or<1>(ref_error1, ref_error2), ref_error3));
742                        }
743                }
744                else
745                {
746                        carry_set_0.CarryDequeueEnqueue(0, 6);
747                }
748        }
749       
750        CarryDeclare(carry_set_0, 6, 0);
751};
752
753kernel Validate_xml_names
754{
755        state
756        {
757               
758        }
759         
760        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)
761        {
762                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);
763                BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carry_set_0.CarryAt(1), 1);
764                BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carry_set_0.CarryAt(2), 2);
765                BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carry_set_0.CarryAt(3), 3);
766                BitBlock qname_stream = simd.or<1>(ElemNames, AttNames);
767                BitBlock ncname_stream = simd.or<1>(PI_names, GenRefs);
768                BitBlock name_stream = simd.or<1>(qname_stream, ncname_stream);
769                BitBlock name_start = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(4), 4));
770                BitBlock name_cursor = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(5), 5));
771                BitBlock void_prefix_err = simd.and<1>(name_cursor, lex.Colon);
772                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);
773                BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep, carry_set_0.CarryAt(7), 7);
774                BitBlock local_part_err = simd.andc<1>(local_part_start, lex.NameScan);
775                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);
776                BitBlock ncname_err = simd.and<1>(ncname_stream, lex.Colon);
777                if (bitblock.any<1>((simd.or<1>(simd.or<1>(simd.or<1>(void_prefix_err, local_part_err), colon2_err), ncname_err))))
778                {
779                        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));
780                }
781                check_streams.non_ascii_name_starts = simd.andc<1>(name_start, lex.ASCII_name_start);
782                check_streams.non_ascii_names = simd.andc<1>(simd.andc<1>(simd.andc<1>(name_stream, name_start), lex.ASCII_name_char), u8.suffix);
783                carry_set_0.CarryAdjust(9);
784        }
785       
786        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)
787        {
788                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);
789                BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carry_set_0.CarryAt(1), 1);
790                BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carry_set_0.CarryAt(2), 2);
791                BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carry_set_0.CarryAt(3), 3);
792                BitBlock qname_stream = simd.or<1>(ElemNames, AttNames);
793                BitBlock ncname_stream = simd.or<1>(PI_names, GenRefs);
794                BitBlock name_stream = simd.or<1>(qname_stream, ncname_stream);
795                BitBlock name_start = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(4), 4));
796                BitBlock name_cursor = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(5), 5));
797                BitBlock void_prefix_err = simd.and<1>(name_cursor, lex.Colon);
798                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);
799                BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep, carry_set_0.CarryAt(7), 7);
800                BitBlock local_part_err = simd.andc<1>(local_part_start, lex.NameScan);
801                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);
802                BitBlock ncname_err = simd.and<1>(ncname_stream, lex.Colon);
803                if (bitblock.any<1>((simd.or<1>(simd.or<1>(simd.or<1>(void_prefix_err, local_part_err), colon2_err), ncname_err))))
804                {
805                        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));
806                }
807                check_streams.non_ascii_name_starts = simd.andc<1>(name_start, lex.ASCII_name_start);
808                check_streams.non_ascii_names = simd.andc<1>(simd.andc<1>(simd.andc<1>(name_stream, name_start), lex.ASCII_name_char), u8.suffix);
809        }
810       
811        CarryDeclare(carry_set_0, 9, 0);
812};
813 
814kernel Do_check_streams
815{
816        state
817        {
818               
819        }
820         
821        function  void do_block(struct Marker marker, struct Tag_Callouts tag_Callouts, struct Check_streams check_streams)
822        {
823                if (bitblock.any<1>((simd.andc<1>(marker.CD_closer, tag_Callouts.AttVal_spans))))
824                {
825                        assert_0_error("Error: ]]> in text", simd.andc<1>(marker.CD_closer, tag_Callouts.AttVal_spans));
826                }
827                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);
828                check_streams.name_follows = simd.or<1>(tag_Callouts.ElemName_ends, tag_Callouts.AttName_ends);
829                check_streams.att_refs = simd.and<1>(tag_Callouts.AttVal_spans, marker.Ref_opener);
830        }
831       
832        function void do_final_block(struct Marker marker, struct Tag_Callouts tag_Callouts, struct Check_streams check_streams, BitBlock EOF_mask)
833        {
834                if (bitblock.any<1>((simd.andc<1>(marker.CD_closer, tag_Callouts.AttVal_spans))))
835                {
836                        assert_0_error("Error: ]]> in text", simd.andc<1>(marker.CD_closer, tag_Callouts.AttVal_spans));
837                }
838                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);
839                check_streams.name_follows = simd.or<1>(tag_Callouts.ElemName_ends, tag_Callouts.AttName_ends);
840                check_streams.att_refs = simd.and<1>(tag_Callouts.AttVal_spans, marker.Ref_opener);
841        }
842       
843        CarryDeclare(carry_set_0, 0, 0);
844};
Note: See TracBrowser for help on using the repository browser.