Changeset 3750


Ignore:
Timestamp:
Mar 27, 2014, 5:49:08 PM (4 years ago)
Author:
ksherdy
Message:

Cleaned up CLI.

Location:
proto/s2k/trunk/framework/input
Files:
8 added
2 deleted
2 edited

Legend:

Unmodified
Added
Removed
  • proto/s2k/trunk/framework/input/templates/cpplang/definitions.template

    r3723 r3750  
    1414//////////////////////////////////////////////////////////////////////////////////////////
    1515//
    16 #ifndef PABLO_DEFINITIONS_HPP
    17 #define PABLO_DEFINITIONS_HPP
     16#ifndef PARABIX2_DEFINITIONS_HPP
     17#define PARABIX2_DEFINITIONS_HPP
    1818
    1919// runtime libraries
     
    6161// } // pablo namespace
    6262
    63 #endif // PABLO_DEFINITIONS_HPP
     63#endif // PARABIX2_DEFINITIONS_HPP
  • proto/s2k/trunk/framework/input/test/b2k/proto/parabix2_pablo.b2k

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