Changeset 3720


Ignore:
Timestamp:
Mar 16, 2014, 10:48:23 PM (5 years ago)
Author:
ksherdy
Message:

Updated b2k test.

Location:
proto/pabloj/trunk/input/test/b2k
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/input/test/b2k/all/all.b2k

    r3699 r3720  
    8383        BitBlock r;
    8484
     85        /*
    8586        r = bitblock.any<128>(a);
     87        */
    8688       
     89       
     90        r = simd.add(abs);
    8791        /*
    88         r = simd.add(abs);
    8992        r = simd.neg(a);
    9093        r = simd.add_hl(a);
     
    109112    CarryDeclare(carry_set_0, 0, 0);
    110113}; 
    111 // KERNEL kernelName LCURLY funcDef (optFuncDef)? RCURLY TERMINATOR?;
    112                
    113 kernel 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        
    183 struct 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  
    195 struct 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  
    228 struct 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  
    259 struct Marker
    260 {
    261         BitBlock LAngle_scope;
    262         BitBlock Ref_opener;
    263         BitBlock CD_closer;
    264 };
    265  
    266 struct 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  
    278 struct 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  
    288 struct 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  
    301 struct 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                
    311 kernel Classify_bytes_Validate_utf8 
    312 {
    313         init
    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 
    670 kernel Parse_refs
    671 {
    672         init
    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 
    753 kernel Validate_xml_names
    754 {
    755         init
    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  
    814 kernel Do_check_streams
    815 {
    816         init
    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 };
  • proto/pabloj/trunk/input/test/b2k/proto/parabix2_pablo.b2k

    r3699 r3720  
    1 // KERNEL kernelName LCURLY funcDef (optFuncDef)? RCURLY TERMINATOR?;
    2        
    3 struct Basis_bits
    4 {
    5         BitBlock bit_0;
    6         BitBlock bit_1;
    7         BitBlock bit_2;
    8         BitBlock bit_3;
    9         BitBlock bit_4;
    10         BitBlock bit_5;
    11         BitBlock bit_6;
    12         BitBlock bit_7;
    13 };
    14  
    15 struct U8
    16 {
    17         BitBlock unibyte;
    18         BitBlock prefix;
    19         BitBlock prefix2;
    20         BitBlock prefix3;
    21         BitBlock prefix4;
    22         BitBlock suffix;
    23         BitBlock badprefix;
    24         BitBlock xE0;
    25         BitBlock xED;
    26         BitBlock xF0;
    27         BitBlock xF4;
    28         BitBlock xA0_xBF;
    29         BitBlock x80_x9F;
    30         BitBlock x90_xBF;
    31         BitBlock x80_x8F;
    32         BitBlock xEF;
    33         BitBlock xBF;
    34         BitBlock xBE;
    35         BitBlock scope22;
    36         BitBlock scope32;
    37         BitBlock scope33;
    38         BitBlock scope42;
    39         BitBlock scope43;
    40         BitBlock scope44;
    41         BitBlock xE0_scope;
    42         BitBlock xED_scope;
    43         BitBlock xF0_scope;
    44         BitBlock xF4_scope;
    45         BitBlock xEF_scope;
    46 };
    47  
    48 struct Lex
    49 {
    50         BitBlock CR;
    51         BitBlock LF;
    52         BitBlock HT;
    53         BitBlock SP;
    54         BitBlock CRLF;
    55         BitBlock RefStart;
    56         BitBlock Semicolon;
    57         BitBlock Colon;
    58         BitBlock LAngle;
    59         BitBlock RAngle;
    60         BitBlock LBracket;
    61         BitBlock RBracket;
    62         BitBlock Exclam;
    63         BitBlock QMark;
    64         BitBlock Hyphen;
    65         BitBlock Equals;
    66         BitBlock SQuote;
    67         BitBlock DQuote;
    68         BitBlock Slash;
    69         BitBlock Hash;
    70         BitBlock x;
    71         BitBlock ASCII_name_start;
    72         BitBlock ASCII_name_char;
    73         BitBlock NameScan;
    74         BitBlock Digit;
    75         BitBlock Hex;
    76         BitBlock WS;
    77 };
    78  
    79 struct Marker
    80 {
    81         BitBlock LAngle_scope;
    82         BitBlock Ref_opener;
    83         BitBlock CD_closer;
    84 };
    85  
    86 struct CtCDPI_Callouts
    87 {
    88         BitBlock Ct_starts;
    89         BitBlock Ct_ends;
    90         BitBlock CD_starts;
    91         BitBlock CD_ends;
    92         BitBlock PI_starts;
    93         BitBlock PI_name_starts;
    94         BitBlock PI_name_ends;
    95         BitBlock PI_ends;
    96 };
    97  
    98 struct Ref_Callouts
    99 {
    100         BitBlock GenRef_starts;
    101         BitBlock GenRef_ends;
    102         BitBlock DecRef_starts;
    103         BitBlock DecRef_ends;
    104         BitBlock HexRef_starts;
    105         BitBlock HexRef_ends;
    106 };
    107  
    108 struct Tag_Callouts
    109 {
    110         BitBlock ElemName_starts;
    111         BitBlock ElemName_ends;
    112         BitBlock AttName_starts;
    113         BitBlock AttName_ends;
    114         BitBlock AttVal_starts;
    115         BitBlock AttVal_ends;
    116         BitBlock AttVal_spans;
    117         BitBlock EmptyTag_marks;
    118         BitBlock EndTag_marks;
    119 };
    120  
    121 struct Check_streams
    122 {
    123         BitBlock misc_mask;
    124         BitBlock non_ascii_name_starts;
    125         BitBlock non_ascii_names;
    126         BitBlock tag_marks;
    127         BitBlock name_follows;
    128         BitBlock att_refs;
    129 };     
    130                
    131 kernel Classify_bytes_Validate_utf8 
    132 {
    133         init
    134         {
    135          
    136         }
    137 
    138         function void do_block(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8)
    139         {
    140                 BitBlock temp1 = simd.or<1>(basis_bits.bit_0, basis_bits.bit_1);
    141                 BitBlock temp2 = simd.andc<1>(basis_bits.bit_2, basis_bits.bit_3);
    142                 BitBlock temp3 = simd.andc<1>(temp2, temp1);
    143                 BitBlock temp4 = simd.andc<1>(basis_bits.bit_5, basis_bits.bit_4);
    144                 BitBlock temp5 = simd.andc<1>(basis_bits.bit_6, basis_bits.bit_7);
    145                 BitBlock temp6 = simd.and<1>(temp4, temp5);
    146                 lex.RefStart = simd.and<1>(temp3, temp6);
    147                 BitBlock temp7 = simd.and<1>(basis_bits.bit_2, basis_bits.bit_3);
    148                 BitBlock temp8 = simd.andc<1>(temp7, temp1);
    149                 BitBlock temp9 = simd.andc<1>(basis_bits.bit_4, basis_bits.bit_5);
    150                 BitBlock temp10 = simd.and<1>(basis_bits.bit_6, basis_bits.bit_7);
    151                 BitBlock temp11 = simd.and<1>(temp9, temp10);
    152                 lex.Semicolon = simd.and<1>(temp8, temp11);
    153                 BitBlock temp12 = simd.and<1>(basis_bits.bit_4, basis_bits.bit_5);
    154                 BitBlock temp13 = simd.or<1>(basis_bits.bit_6, basis_bits.bit_7);
    155                 BitBlock temp14 = simd.andc<1>(temp12, temp13);
    156                 lex.LAngle = simd.and<1>(temp8, temp14);
    157                 BitBlock temp15 = simd.and<1>(temp12, temp5);
    158                 lex.RAngle = simd.and<1>(temp8, temp15);
    159                 BitBlock temp16 = simd.andc<1>(basis_bits.bit_1, basis_bits.bit_0);
    160                 BitBlock temp17 = simd.andc<1>(basis_bits.bit_3, basis_bits.bit_2);
    161                 BitBlock temp18 = simd.and<1>(temp16, temp17);
    162                 lex.LBracket = simd.and<1>(temp18, temp11);
    163                 BitBlock temp19 = simd.andc<1>(basis_bits.bit_7, basis_bits.bit_6);
    164                 BitBlock temp20 = simd.and<1>(temp12, temp19);
    165                 lex.RBracket = simd.and<1>(temp18, temp20);
    166                 BitBlock temp21 = simd.or<1>(basis_bits.bit_4, basis_bits.bit_5);
    167                 BitBlock temp22 = simd.andc<1>(temp19, temp21);
    168                 lex.Exclam = simd.and<1>(temp3, temp22);
    169                 BitBlock temp23 = simd.and<1>(temp12, temp10);
    170                 lex.QMark = simd.and<1>(temp8, temp23);
    171                 lex.Hyphen = simd.and<1>(temp3, temp20);
    172                 lex.Equals = simd.and<1>(temp8, temp20);
    173                 BitBlock temp24 = simd.and<1>(temp4, temp10);
    174                 lex.SQuote = simd.and<1>(temp3, temp24);
    175                 BitBlock temp25 = simd.andc<1>(temp5, temp21);
    176                 lex.DQuote = simd.and<1>(temp3, temp25);
    177                 lex.Slash = simd.and<1>(temp3, temp23);
    178                 BitBlock temp26 = simd.andc<1>(temp10, temp21);
    179                 lex.Hash = simd.and<1>(temp3, temp26);
    180                 BitBlock temp27 = simd.and<1>(temp16, temp7);
    181                 BitBlock temp28 = simd.andc<1>(temp9, temp13);
    182                 lex.x = simd.and<1>(temp27, temp28);
    183                 BitBlock temp29 = simd.and<1>(temp9, temp5);
    184                 lex.Colon = simd.and<1>(temp8, temp29);
    185                 BitBlock temp30 = simd.and<1>(temp18, temp23);
    186                 BitBlock temp31 = simd.or<1>(temp30, lex.Colon);
    187                 BitBlock temp32 = simd.andc<1>(temp16, basis_bits.bit_2);
    188                 BitBlock temp33 = simd.or<1>(basis_bits.bit_5, temp10);
    189                 BitBlock temp34 = simd.and<1>(basis_bits.bit_4, temp33);
    190                 BitBlock temp35 = simd.not<1>(temp34);
    191                 BitBlock temp36 = simd.or<1>(temp21, temp13);
    192                 BitBlock temp37 = simd.or<1>(simd.and<1>(basis_bits.bit_3, temp35), simd.andc<1>(temp36, basis_bits.bit_3));
    193                 BitBlock temp38 = simd.and<1>(temp32, temp37);
    194                 BitBlock temp39 = simd.or<1>(temp31, temp38);
    195                 BitBlock temp40 = simd.and<1>(temp16, basis_bits.bit_2);
    196                 BitBlock temp41 = simd.and<1>(temp40, temp37);
    197                 lex.ASCII_name_start = simd.or<1>(temp39, temp41);
    198                 BitBlock temp42 = simd.or<1>(temp30, lex.Hyphen);
    199                 BitBlock temp43 = simd.and<1>(temp3, temp15);
    200                 BitBlock temp44 = simd.or<1>(temp42, temp43);
    201                 BitBlock temp45 = simd.andc<1>(temp8, temp34);
    202                 BitBlock temp46 = simd.or<1>(temp44, temp45);
    203                 BitBlock temp47 = simd.or<1>(temp46, temp38);
    204                 lex.ASCII_name_char = simd.or<1>(temp47, temp41);
    205                 lex.NameScan = simd.or<1>(lex.ASCII_name_char, basis_bits.bit_0);
    206                 BitBlock temp48 = simd.or<1>(temp1, basis_bits.bit_2);
    207                 BitBlock x00_x1F = simd.not<1>(temp48);
    208                 BitBlock temp49 = simd.or<1>(basis_bits.bit_2, basis_bits.bit_3);
    209                 BitBlock temp50 = simd.or<1>(temp1, temp49);
    210                 lex.CR = simd.andc<1>(temp20, temp50);
    211                 lex.LF = simd.andc<1>(temp29, temp50);
    212                 BitBlock temp51 = simd.and<1>(temp9, temp19);
    213                 lex.HT = simd.andc<1>(temp51, temp50);
    214                 lex.SP = simd.andc<1>(temp3, temp36);
    215                 BitBlock temp52 = simd.or<1>(temp20, temp29);
    216                 BitBlock temp53 = simd.or<1>(temp52, temp51);
    217                 BitBlock temp54 = simd.andc<1>(temp53, temp50);
    218                 lex.WS = simd.or<1>(temp54, lex.SP);
    219                 BitBlock temp55 = simd.or<1>(basis_bits.bit_5, basis_bits.bit_6);
    220                 BitBlock temp56 = simd.and<1>(basis_bits.bit_4, temp55);
    221                 lex.Digit = simd.andc<1>(temp8, temp56);
    222                 BitBlock temp57 = simd.andc<1>(temp16, temp49);
    223                 BitBlock temp58 = simd.andc<1>(temp57, basis_bits.bit_4);
    224                 BitBlock temp59 = simd.not<1>(temp10);
    225                 BitBlock temp60 = simd.or<1>(simd.and<1>(basis_bits.bit_5, temp59), simd.andc<1>(temp13, basis_bits.bit_5));
    226                 BitBlock temp61 = simd.and<1>(temp58, temp60);
    227                 BitBlock temp62 = simd.or<1>(lex.Digit, temp61);
    228                 BitBlock temp63 = simd.and<1>(temp16, temp2);
    229                 BitBlock temp64 = simd.andc<1>(temp63, basis_bits.bit_4);
    230                 BitBlock temp65 = simd.and<1>(temp64, temp60);
    231                 lex.Hex = simd.or<1>(temp62, temp65);
    232                 BitBlock lex_error = simd.andc<1>(x00_x1F, lex.WS);
    233 
    234                 if (bitblock.any<1>((lex_error)))
    235                 {
    236                         assert_0_error("Error: illegal character", lex_error);
    237                 }
    238                 u8.unibyte = simd.not<1>(basis_bits.bit_0);
    239                 u8.suffix = simd.constant<1>(0);
    240                 BitBlock u8_error = simd.constant<1>(0);
    241                 BitBlock u8_FFFE_FFFF = simd.constant<1>(0);
    242                 BitBlock u8anyscope = simd.constant<1>(0);
    243                 if (bitblock.any<1>((simd.or<1>(basis_bits.bit_0, carry_set_0.CarryRange(0, 10)))))
    244                 {
    245                         u8.prefix = simd.and<1>(basis_bits.bit_0, basis_bits.bit_1);
    246                         u8.prefix2 = simd.andc<1>(u8.prefix, basis_bits.bit_2);
    247                         u8.prefix3 = simd.and<1>(u8.prefix, temp2);
    248                         u8.prefix4 = simd.and<1>(u8.prefix, temp7);
    249                         u8.suffix = simd.andc<1>(basis_bits.bit_0, basis_bits.bit_1);
    250                         BitBlock temp66 = simd.andc<1>(u8.prefix, temp49);
    251                         BitBlock temp67 = simd.or<1>(temp21, basis_bits.bit_6);
    252                         BitBlock temp68 = simd.andc<1>(temp66, temp67);
    253                         BitBlock temp69 = simd.and<1>(basis_bits.bit_5, temp13);
    254                         BitBlock temp70 = simd.or<1>(basis_bits.bit_4, temp69);
    255                         BitBlock temp71 = simd.and<1>(u8.prefix4, temp70);
    256                         u8.badprefix = simd.or<1>(temp68, temp71);
    257                         u8_error = u8.badprefix;
    258                         u8.scope22 = carry_set_0.BitBlock_advance_ci_co(u8.prefix2, carry_set_0.CarryAt(0), 0);
    259                         u8anyscope = u8.scope22;
    260                         if (bitblock.any<1>((simd.or<1>(simd.or<1>(u8.prefix3, u8.prefix4), carry_set_0.CarryRange(1, 9)))))
    261                         {
    262                                 BitBlock xE0 = simd.andc<1>(u8.prefix3, temp36);
    263                                 BitBlock xED = simd.and<1>(u8.prefix3, temp20);
    264                                 BitBlock xF0 = simd.andc<1>(u8.prefix4, temp36);
    265                                 BitBlock temp72 = simd.andc<1>(temp4, temp13);
    266                                 BitBlock xF4 = simd.and<1>(u8.prefix4, temp72);
    267                                 u8.xA0_xBF = simd.and<1>(u8.suffix, basis_bits.bit_2);
    268                                 u8.x80_x9F = simd.andc<1>(u8.suffix, basis_bits.bit_2);
    269                                 u8.x90_xBF = simd.and<1>(u8.suffix, temp49);
    270                                 u8.x80_x8F = simd.andc<1>(u8.suffix, temp49);
    271                                 BitBlock xEF = simd.and<1>(u8.prefix3, temp23);
    272                                 BitBlock temp73 = simd.and<1>(u8.suffix, temp7);
    273                                 u8.xBF = simd.and<1>(temp73, temp23);
    274                                 u8.xBE = simd.and<1>(temp73, temp15);
    275                                 u8.scope32 = carry_set_0.BitBlock_advance_ci_co(u8.prefix3, carry_set_0.CarryAt(1), 1);
    276                                 u8.scope33 = carry_set_0.BitBlock_advance_ci_co(u8.scope32, carry_set_0.CarryAt(2), 2);
    277                                 u8.scope42 = carry_set_0.BitBlock_advance_ci_co(u8.prefix4, carry_set_0.CarryAt(3), 3);
    278                                 u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42, carry_set_0.CarryAt(4), 4);
    279                                 u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43, carry_set_0.CarryAt(5), 5);
    280                                 BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xE0, xF0), carry_set_0.CarryAt(6), 6);
    281                                 BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xED, xF4), carry_set_0.CarryAt(7), 7);
    282                                 u8.xE0_scope = simd.and<1>(u8.scope32, E0_F0_scope);
    283                                 u8.xED_scope = simd.and<1>(u8.scope32, ED_F4_scope);
    284                                 u8.xF0_scope = simd.and<1>(u8.scope42, E0_F0_scope);
    285                                 u8.xF4_scope = simd.and<1>(u8.scope42, ED_F4_scope);
    286                                 u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF, carry_set_0.CarryAt(8), 8);
    287                                 BitBlock u8lastscope = simd.or<1>(simd.or<1>(u8.scope22, u8.scope33), u8.scope44);
    288                                 u8anyscope = simd.or<1>(simd.or<1>(simd.or<1>(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
    289                                 BitBlock u8error1 = simd.and<1>(u8.xE0_scope, u8.x80_x9F);
    290                                 BitBlock u8error2 = simd.and<1>(u8.xED_scope, u8.xA0_xBF);
    291                                 BitBlock u8error3 = simd.and<1>(u8.xF0_scope, u8.x80_x8F);
    292                                 BitBlock u8error4 = simd.and<1>(u8.xF4_scope, u8.x90_xBF);
    293                                 u8_error = simd.or<1>(u8_error, simd.or<1>(simd.or<1>(simd.or<1>(u8error1, u8error2), u8error3), u8error4));
    294                                 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);
    295                                 u8_FFFE_FFFF = simd.and<1>(EF_BF_pending, simd.or<1>(u8.xBE, u8.xBF));
    296                         }
    297                         else
    298                         {
    299                                 carry_set_0.CarryDequeueEnqueue(1, 9);
    300                         }
    301                         BitBlock u8mismatch = simd.xor<1>(u8anyscope, u8.suffix);
    302                         if (bitblock.any<1>((simd.or<1>(simd.or<1>(u8_error, u8mismatch), u8_FFFE_FFFF))))
    303                         {
    304                                 assert_0_error("UTF-8 error found", simd.or<1>(simd.or<1>(u8_error, u8mismatch), u8_FFFE_FFFF));
    305                         }
    306                 }
    307                 else
    308                 {
    309                         carry_set_0.CarryDequeueEnqueue(0, 10);
    310                 }
    311                 carry_set_0.CarryAdjust(10);
    312 
    313         }
    314 
    315         function void do_final_block(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8, BitBlock EOF_mask) {
    316                 BitBlock temp1 = simd.or<1>(basis_bits.bit_0, basis_bits.bit_1);
    317                 BitBlock temp2 = simd.andc<1>(basis_bits.bit_2, basis_bits.bit_3);
    318                 BitBlock temp3 = simd.andc<1>(temp2, temp1);
    319                 BitBlock temp4 = simd.andc<1>(basis_bits.bit_5, basis_bits.bit_4);
    320                 BitBlock temp5 = simd.andc<1>(basis_bits.bit_6, basis_bits.bit_7);
    321                 BitBlock temp6 = simd.and<1>(temp4, temp5);
    322                 lex.RefStart = simd.and<1>(temp3, temp6);
    323                 BitBlock temp7 = simd.and<1>(basis_bits.bit_2, basis_bits.bit_3);
    324                 BitBlock temp8 = simd.andc<1>(temp7, temp1);
    325                 BitBlock temp9 = simd.andc<1>(basis_bits.bit_4, basis_bits.bit_5);
    326                 BitBlock temp10 = simd.and<1>(basis_bits.bit_6, basis_bits.bit_7);
    327                 BitBlock temp11 = simd.and<1>(temp9, temp10);
    328                 lex.Semicolon = simd.and<1>(temp8, temp11);
    329                 BitBlock temp12 = simd.and<1>(basis_bits.bit_4, basis_bits.bit_5);
    330                 BitBlock temp13 = simd.or<1>(basis_bits.bit_6, basis_bits.bit_7);
    331                 BitBlock temp14 = simd.andc<1>(temp12, temp13);
    332                 lex.LAngle = simd.and<1>(temp8, temp14);
    333                 BitBlock temp15 = simd.and<1>(temp12, temp5);
    334                 lex.RAngle = simd.and<1>(temp8, temp15);
    335                 BitBlock temp16 = simd.andc<1>(basis_bits.bit_1, basis_bits.bit_0);
    336                 BitBlock temp17 = simd.andc<1>(basis_bits.bit_3, basis_bits.bit_2);
    337                 BitBlock temp18 = simd.and<1>(temp16, temp17);
    338                 lex.LBracket = simd.and<1>(temp18, temp11);
    339                 BitBlock temp19 = simd.andc<1>(basis_bits.bit_7, basis_bits.bit_6);
    340                 BitBlock temp20 = simd.and<1>(temp12, temp19);
    341                 lex.RBracket = simd.and<1>(temp18, temp20);
    342                 BitBlock temp21 = simd.or<1>(basis_bits.bit_4, basis_bits.bit_5);
    343                 BitBlock temp22 = simd.andc<1>(temp19, temp21);
    344                 lex.Exclam = simd.and<1>(temp3, temp22);
    345                 BitBlock temp23 = simd.and<1>(temp12, temp10);
    346                 lex.QMark = simd.and<1>(temp8, temp23);
    347                 lex.Hyphen = simd.and<1>(temp3, temp20);
    348                 lex.Equals = simd.and<1>(temp8, temp20);
    349                 BitBlock temp24 = simd.and<1>(temp4, temp10);
    350                 lex.SQuote = simd.and<1>(temp3, temp24);
    351                 BitBlock temp25 = simd.andc<1>(temp5, temp21);
    352                 lex.DQuote = simd.and<1>(temp3, temp25);
    353                 lex.Slash = simd.and<1>(temp3, temp23);
    354                 BitBlock temp26 = simd.andc<1>(temp10, temp21);
    355                 lex.Hash = simd.and<1>(temp3, temp26);
    356                 BitBlock temp27 = simd.and<1>(temp16, temp7);
    357                 BitBlock temp28 = simd.andc<1>(temp9, temp13);
    358                 lex.x = simd.and<1>(temp27, temp28);
    359                 BitBlock temp29 = simd.and<1>(temp9, temp5);
    360                 lex.Colon = simd.and<1>(temp8, temp29);
    361                 BitBlock temp30 = simd.and<1>(temp18, temp23);
    362                 BitBlock temp31 = simd.or<1>(temp30, lex.Colon);
    363                 BitBlock temp32 = simd.andc<1>(temp16, basis_bits.bit_2);
    364                 BitBlock temp33 = simd.or<1>(basis_bits.bit_5, temp10);
    365                 BitBlock temp34 = simd.and<1>(basis_bits.bit_4, temp33);
    366                 BitBlock temp35 = simd.not<1>(temp34);
    367                 BitBlock temp36 = simd.or<1>(temp21, temp13);
    368                 BitBlock temp37 = simd.or<1>(simd.and<1>(basis_bits.bit_3, temp35), simd.andc<1>(temp36, basis_bits.bit_3));
    369                 BitBlock temp38 = simd.and<1>(temp32, temp37);
    370                 BitBlock temp39 = simd.or<1>(temp31, temp38);
    371                 BitBlock temp40 = simd.and<1>(temp16, basis_bits.bit_2);
    372                 BitBlock temp41 = simd.and<1>(temp40, temp37);
    373                 lex.ASCII_name_start = simd.or<1>(temp39, temp41);
    374                 BitBlock temp42 = simd.or<1>(temp30, lex.Hyphen);
    375                 BitBlock temp43 = simd.and<1>(temp3, temp15);
    376                 BitBlock temp44 = simd.or<1>(temp42, temp43);
    377                 BitBlock temp45 = simd.andc<1>(temp8, temp34);
    378                 BitBlock temp46 = simd.or<1>(temp44, temp45);
    379                 BitBlock temp47 = simd.or<1>(temp46, temp38);
    380                 lex.ASCII_name_char = simd.or<1>(temp47, temp41);
    381                 lex.NameScan = simd.or<1>(lex.ASCII_name_char, basis_bits.bit_0);
    382                 BitBlock temp48 = simd.or<1>(temp1, basis_bits.bit_2);
    383                 BitBlock x00_x1F = simd.not<1>(temp48);
    384                 BitBlock temp49 = simd.or<1>(basis_bits.bit_2, basis_bits.bit_3);
    385                 BitBlock temp50 = simd.or<1>(temp1, temp49);
    386                 lex.CR = simd.andc<1>(temp20, temp50);
    387                 lex.LF = simd.andc<1>(temp29, temp50);
    388                 BitBlock temp51 = simd.and<1>(temp9, temp19);
    389                 lex.HT = simd.andc<1>(temp51, temp50);
    390                 lex.SP = simd.andc<1>(temp3, temp36);
    391                 BitBlock temp52 = simd.or<1>(temp20, temp29);
    392                 BitBlock temp53 = simd.or<1>(temp52, temp51);
    393                 BitBlock temp54 = simd.andc<1>(temp53, temp50);
    394                 lex.WS = simd.or<1>(temp54, lex.SP);
    395                 BitBlock temp55 = simd.or<1>(basis_bits.bit_5, basis_bits.bit_6);
    396                 BitBlock temp56 = simd.and<1>(basis_bits.bit_4, temp55);
    397                 lex.Digit = simd.andc<1>(temp8, temp56);
    398                 BitBlock temp57 = simd.andc<1>(temp16, temp49);
    399                 BitBlock temp58 = simd.andc<1>(temp57, basis_bits.bit_4);
    400                 BitBlock temp59 = simd.not<1>(temp10);
    401                 BitBlock temp60 = simd.or<1>(simd.and<1>(basis_bits.bit_5, temp59), simd.andc<1>(temp13, basis_bits.bit_5));
    402                 BitBlock temp61 = simd.and<1>(temp58, temp60);
    403                 BitBlock temp62 = simd.or<1>(lex.Digit, temp61);
    404                 BitBlock temp63 = simd.and<1>(temp16, temp2);
    405                 BitBlock temp64 = simd.andc<1>(temp63, basis_bits.bit_4);
    406                 BitBlock temp65 = simd.and<1>(temp64, temp60);
    407                 lex.Hex = simd.or<1>(temp62, temp65);
    408                 BitBlock lex_error = simd.andc<1>(x00_x1F, lex.WS);
    409                 if (bitblock.any<1>((simd.and<1>(lex_error, EOF_mask))))
    410                 {
    411                         assert_0_error("Error: illegal character", simd.and<1>(lex_error, EOF_mask));
    412                 }
    413                 u8.unibyte = simd.not<1>(basis_bits.bit_0);
    414                 u8.suffix = simd.constant<1>(0);
    415                 BitBlock u8_error = simd.constant<1>(0);
    416                 BitBlock u8_FFFE_FFFF = simd.constant<1>(0);
    417                 BitBlock u8anyscope = simd.constant<1>(0);
    418                 if (bitblock.any<1>((simd.or<1>(basis_bits.bit_0, carry_set_0.CarryRange(0, 10)))))
    419                 {
    420                         u8.prefix = simd.and<1>(basis_bits.bit_0, basis_bits.bit_1);
    421                         u8.prefix2 = simd.andc<1>(u8.prefix, basis_bits.bit_2);
    422                         u8.prefix3 = simd.and<1>(u8.prefix, temp2);
    423                         u8.prefix4 = simd.and<1>(u8.prefix, temp7);
    424                         u8.suffix = simd.andc<1>(basis_bits.bit_0, basis_bits.bit_1);
    425                         BitBlock temp66 = simd.andc<1>(u8.prefix, temp49);
    426                         BitBlock temp67 = simd.or<1>(temp21, basis_bits.bit_6);
    427                         BitBlock temp68 = simd.andc<1>(temp66, temp67);
    428                         BitBlock temp69 = simd.and<1>(basis_bits.bit_5, temp13);
    429                         BitBlock temp70 = simd.or<1>(basis_bits.bit_4, temp69);
    430                         BitBlock temp71 = simd.and<1>(u8.prefix4, temp70);
    431                         u8.badprefix = simd.or<1>(temp68, temp71);
    432                         u8_error = u8.badprefix;
    433                         u8.scope22 = carry_set_0.BitBlock_advance_ci_co(u8.prefix2, carry_set_0.CarryAt(0), 0);
    434                         u8anyscope = u8.scope22;
    435                         if (bitblock.any<1>((simd.or<1>(simd.or<1>(u8.prefix3, u8.prefix4), carry_set_0.CarryRange(1, 9)))))
    436                         {
    437                                 BitBlock xE0 = simd.andc<1>(u8.prefix3, temp36);
    438                                 BitBlock xED = simd.and<1>(u8.prefix3, temp20);
    439                                 BitBlock xF0 = simd.andc<1>(u8.prefix4, temp36);
    440                                 BitBlock temp72 = simd.andc<1>(temp4, temp13);
    441                                 BitBlock xF4 = simd.and<1>(u8.prefix4, temp72);
    442                                 u8.xA0_xBF = simd.and<1>(u8.suffix, basis_bits.bit_2);
    443                                 u8.x80_x9F = simd.andc<1>(u8.suffix, basis_bits.bit_2);
    444                                 u8.x90_xBF = simd.and<1>(u8.suffix, temp49);
    445                                 u8.x80_x8F = simd.andc<1>(u8.suffix, temp49);
    446                                 BitBlock xEF = simd.and<1>(u8.prefix3, temp23);
    447                                 BitBlock temp73 = simd.and<1>(u8.suffix, temp7);
    448                                 u8.xBF = simd.and<1>(temp73, temp23);
    449                                 u8.xBE = simd.and<1>(temp73, temp15);
    450                                 u8.scope32 = carry_set_0.BitBlock_advance_ci_co(u8.prefix3, carry_set_0.CarryAt(1), 1);
    451                                 u8.scope33 = carry_set_0.BitBlock_advance_ci_co(u8.scope32, carry_set_0.CarryAt(2), 2);
    452                                 u8.scope42 = carry_set_0.BitBlock_advance_ci_co(u8.prefix4, carry_set_0.CarryAt(3), 3);
    453                                 u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42, carry_set_0.CarryAt(4), 4);
    454                                 u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43, carry_set_0.CarryAt(5), 5);
    455                                 BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xE0, xF0), carry_set_0.CarryAt(6), 6);
    456                                 BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xED, xF4), carry_set_0.CarryAt(7), 7);
    457                                 u8.xE0_scope = simd.and<1>(u8.scope32, E0_F0_scope);
    458                                 u8.xED_scope = simd.and<1>(u8.scope32, ED_F4_scope);
    459                                 u8.xF0_scope = simd.and<1>(u8.scope42, E0_F0_scope);
    460                                 u8.xF4_scope = simd.and<1>(u8.scope42, ED_F4_scope);
    461                                 u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF, carry_set_0.CarryAt(8), 8);
    462                                 BitBlock u8lastscope = simd.or<1>(simd.or<1>(u8.scope22, u8.scope33), u8.scope44);
    463                                 u8anyscope = simd.or<1>(simd.or<1>(simd.or<1>(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
    464                                 BitBlock u8error1 = simd.and<1>(u8.xE0_scope, u8.x80_x9F);
    465                                 BitBlock u8error2 = simd.and<1>(u8.xED_scope, u8.xA0_xBF);
    466                                 BitBlock u8error3 = simd.and<1>(u8.xF0_scope, u8.x80_x8F);
    467                                 BitBlock u8error4 = simd.and<1>(u8.xF4_scope, u8.x90_xBF);
    468                                 u8_error = simd.or<1>(u8_error, simd.or<1>(simd.or<1>(simd.or<1>(u8error1, u8error2), u8error3), u8error4));
    469                                 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);
    470                                 u8_FFFE_FFFF = simd.and<1>(EF_BF_pending, simd.or<1>(u8.xBE, u8.xBF));
    471                         }
    472                         else
    473                         {
    474                                 carry_set_0.CarryDequeueEnqueue(1, 9);
    475                         }
    476                         BitBlock u8mismatch = simd.xor<1>(u8anyscope, u8.suffix);
    477                         if (bitblock.any<1>((simd.or<1>(simd.or<1>(u8_error, u8mismatch), u8_FFFE_FFFF))))
    478                         {
    479                                 assert_0_error("UTF-8 error found", simd.or<1>(simd.or<1>(u8_error, u8mismatch), u8_FFFE_FFFF));
    480                         }
    481                 }
    482                 else
    483                 {
    484                         carry_set_0.CarryDequeueEnqueue(0, 10);
    485                 }       
    486         }
    487         CarryDeclare(carry_set_0, 10, 0);       
    488 };     
    489 
    490 kernel Parse_refs
    491 {
    492         init
    493         {
    494                
    495         }
    496          
    497         function void do_block(struct Lex lex, struct Marker marker, struct Ref_Callouts ref_Callouts)
    498         {
    499                 ref_Callouts.GenRef_starts = simd.constant<1>(0);
    500                 ref_Callouts.GenRef_ends = simd.constant<1>(0);
    501                 ref_Callouts.DecRef_starts = simd.constant<1>(0);
    502                 ref_Callouts.DecRef_ends = simd.constant<1>(0);
    503                 ref_Callouts.HexRef_starts = simd.constant<1>(0);
    504                 ref_Callouts.HexRef_ends = simd.constant<1>(0);
    505                 BitBlock ref_error = simd.constant<1>(0);
    506                 if (bitblock.any<1>((simd.or<1>(marker.Ref_opener, carry_set_0.CarryRange(0, 6)))))
    507                 {
    508                         BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener, carry_set_0.CarryAt(0), 0);
    509                         BitBlock NumRef2 = simd.and<1>(Ref_scope, lex.Hash);
    510                         ref_Callouts.GenRef_starts = simd.andc<1>(Ref_scope, lex.Hash);
    511                         BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2, carry_set_0.CarryAt(1), 1);
    512                         BitBlock HexRef3 = simd.and<1>(NumRef3, lex.x);
    513                         ref_Callouts.DecRef_starts = simd.andc<1>(NumRef3, lex.x);
    514                         ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3, carry_set_0.CarryAt(2), 2);
    515                         ref_Callouts.GenRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts, lex.NameScan, carry_set_0.CarryAt(3), 3);
    516                         ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carry_set_0.CarryAt(4), 4);
    517                         ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carry_set_0.CarryAt(5), 5);
    518                         BitBlock ref_error1 = simd.andc<1>(ref_Callouts.DecRef_starts, lex.Digit);
    519                         BitBlock ref_error2 = simd.andc<1>(ref_Callouts.HexRef_starts, lex.Hex);
    520                         BitBlock ref_ends = simd.or<1>(simd.or<1>(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
    521                         BitBlock ref_error3 = simd.andc<1>(ref_ends, lex.Semicolon);
    522                         if (bitblock.any<1>((simd.or<1>(simd.or<1>(ref_error1, ref_error2), ref_error3))))
    523                         {
    524                                 assert_0_error("Reference error found", simd.or<1>(simd.or<1>(ref_error1, ref_error2), ref_error3));
    525                         }
    526                 }
    527                 else
    528                 {
    529                         carry_set_0.CarryDequeueEnqueue(0, 6);
    530                 }
    531                 carry_set_0.CarryAdjust(6);
    532         }
    533        
    534         function void do_final_block(struct Lex lex, struct Marker marker, struct Ref_Callouts ref_Callouts, BitBlock EOF_mask)
    535         {
    536                 ref_Callouts.GenRef_starts = simd.constant<1>(0);
    537                 ref_Callouts.GenRef_ends = simd.constant<1>(0);
    538                 ref_Callouts.DecRef_starts = simd.constant<1>(0);
    539                 ref_Callouts.DecRef_ends = simd.constant<1>(0);
    540                 ref_Callouts.HexRef_starts = simd.constant<1>(0);
    541                 ref_Callouts.HexRef_ends = simd.constant<1>(0);
    542                 BitBlock ref_error = simd.constant<1>(0);
    543                 if (bitblock.any<1>((simd.or<1>(marker.Ref_opener, carry_set_0.CarryRange(0, 6)))))
    544                 {
    545                         BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener, carry_set_0.CarryAt(0), 0);
    546                         BitBlock NumRef2 = simd.and<1>(Ref_scope, lex.Hash);
    547                         ref_Callouts.GenRef_starts = simd.andc<1>(Ref_scope, lex.Hash);
    548                         BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2, carry_set_0.CarryAt(1), 1);
    549                         BitBlock HexRef3 = simd.and<1>(NumRef3, lex.x);
    550                         ref_Callouts.DecRef_starts = simd.andc<1>(NumRef3, lex.x);
    551                         ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3, carry_set_0.CarryAt(2), 2);
    552                         ref_Callouts.GenRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts, lex.NameScan, carry_set_0.CarryAt(3), 3);
    553                         ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carry_set_0.CarryAt(4), 4);
    554                         ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carry_set_0.CarryAt(5), 5);
    555                         BitBlock ref_error1 = simd.andc<1>(ref_Callouts.DecRef_starts, lex.Digit);
    556                         BitBlock ref_error2 = simd.andc<1>(ref_Callouts.HexRef_starts, lex.Hex);
    557                         BitBlock ref_ends = simd.or<1>(simd.or<1>(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
    558                         BitBlock ref_error3 = simd.andc<1>(ref_ends, lex.Semicolon);
    559                         if (bitblock.any<1>((simd.or<1>(simd.or<1>(ref_error1, ref_error2), ref_error3))))
    560                         {
    561                                 assert_0_error("Reference error found", simd.or<1>(simd.or<1>(ref_error1, ref_error2), ref_error3));
    562                         }
    563                 }
    564                 else
    565                 {
    566                         carry_set_0.CarryDequeueEnqueue(0, 6);
    567                 }
    568         }
    569        
    570         CarryDeclare(carry_set_0, 6, 0);
    571 };
    572 
    573 kernel Validate_xml_names
    574 {
    575         init
    576         {
    577                
    578         }
    579          
    580         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)
    581         {
    582                 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);
    583                 BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carry_set_0.CarryAt(1), 1);
    584                 BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carry_set_0.CarryAt(2), 2);
    585                 BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carry_set_0.CarryAt(3), 3);
    586                 BitBlock qname_stream = simd.or<1>(ElemNames, AttNames);
    587                 BitBlock ncname_stream = simd.or<1>(PI_names, GenRefs);
    588                 BitBlock name_stream = simd.or<1>(qname_stream, ncname_stream);
    589                 BitBlock name_start = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(4), 4));
    590                 BitBlock name_cursor = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(5), 5));
    591                 BitBlock void_prefix_err = simd.and<1>(name_cursor, lex.Colon);
    592                 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);
    593                 BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep, carry_set_0.CarryAt(7), 7);
    594                 BitBlock local_part_err = simd.andc<1>(local_part_start, lex.NameScan);
    595                 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);
    596                 BitBlock ncname_err = simd.and<1>(ncname_stream, lex.Colon);
    597                 if (bitblock.any<1>((simd.or<1>(simd.or<1>(simd.or<1>(void_prefix_err, local_part_err), colon2_err), ncname_err))))
    598                 {
    599                         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));
    600                 }
    601                 check_streams.non_ascii_name_starts = simd.andc<1>(name_start, lex.ASCII_name_start);
    602                 check_streams.non_ascii_names = simd.andc<1>(simd.andc<1>(simd.andc<1>(name_stream, name_start), lex.ASCII_name_char), u8.suffix);
    603                 carry_set_0.CarryAdjust(9);
    604         }
    605        
    606         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)
    607         {
    608                 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);
    609                 BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carry_set_0.CarryAt(1), 1);
    610                 BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carry_set_0.CarryAt(2), 2);
    611                 BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carry_set_0.CarryAt(3), 3);
    612                 BitBlock qname_stream = simd.or<1>(ElemNames, AttNames);
    613                 BitBlock ncname_stream = simd.or<1>(PI_names, GenRefs);
    614                 BitBlock name_stream = simd.or<1>(qname_stream, ncname_stream);
    615                 BitBlock name_start = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(4), 4));
    616                 BitBlock name_cursor = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(5), 5));
    617                 BitBlock void_prefix_err = simd.and<1>(name_cursor, lex.Colon);
    618                 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);
    619                 BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep, carry_set_0.CarryAt(7), 7);
    620                 BitBlock local_part_err = simd.andc<1>(local_part_start, lex.NameScan);
    621                 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);
    622                 BitBlock ncname_err = simd.and<1>(ncname_stream, lex.Colon);
    623                 if (bitblock.any<1>((simd.or<1>(simd.or<1>(simd.or<1>(void_prefix_err, local_part_err), colon2_err), ncname_err))))
    624                 {
    625                         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));
    626                 }
    627                 check_streams.non_ascii_name_starts = simd.andc<1>(name_start, lex.ASCII_name_start);
    628                 check_streams.non_ascii_names = simd.andc<1>(simd.andc<1>(simd.andc<1>(name_stream, name_start), lex.ASCII_name_char), u8.suffix);
    629         }
    630        
    631         CarryDeclare(carry_set_0, 9, 0);
    632 };
    633  
    634 kernel Do_check_streams
    635 {
    636         init
    637         {
    638                
    639         }
    640          
    641         function  void do_block(struct Marker marker, struct Tag_Callouts tag_Callouts, struct Check_streams check_streams)
    642         {
    643                 if (bitblock.any<1>((simd.andc<1>(marker.CD_closer, tag_Callouts.AttVal_spans))))
    644                 {
    645                         assert_0_error("Error: ]]> in text", simd.andc<1>(marker.CD_closer, tag_Callouts.AttVal_spans));
    646                 }
    647                 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);
    648                 check_streams.name_follows = simd.or<1>(tag_Callouts.ElemName_ends, tag_Callouts.AttName_ends);
    649                 check_streams.att_refs = simd.and<1>(tag_Callouts.AttVal_spans, marker.Ref_opener);
    650         }
    651        
    652         function void do_final_block(struct Marker marker, struct Tag_Callouts tag_Callouts, struct Check_streams check_streams, BitBlock EOF_mask)
    653         {
    654                 if (bitblock.any<1>((simd.andc<1>(marker.CD_closer, tag_Callouts.AttVal_spans))))
    655                 {
    656                         assert_0_error("Error: ]]> in text", simd.andc<1>(marker.CD_closer, tag_Callouts.AttVal_spans));
    657                 }
    658                 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);
    659                 check_streams.name_follows = simd.or<1>(tag_Callouts.ElemName_ends, tag_Callouts.AttName_ends);
    660                 check_streams.att_refs = simd.and<1>(tag_Callouts.AttVal_spans, marker.Ref_opener);
    661         }
    662        
    663         CarryDeclare(carry_set_0, 0, 0);
    664 };
Note: See TracChangeset for help on using the changeset viewer.