Ignore:
Timestamp:
May 21, 2013, 5:42:56 PM (6 years ago)
Author:
ksherdy
Message:

Minor grammar updates to handle terminators correctly. Updates to sample test files. Minor updates to temp pabloS type system classes.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/branches/refactor-experimental/output/cpplang/pablo_definitions.hpp

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