Changeset 3761


Ignore:
Timestamp:
Mar 28, 2014, 12:53:17 AM (3 years ago)
Author:
ksherdy
Message:

Added clear function def to b2k kernels to support segment-at-a-time grep.

Location:
proto/s2k/trunk/framework
Files:
1 added
1 deleted
11 edited

Legend:

Unmodified
Added
Removed
  • proto/s2k/trunk/framework/input/grammar/scatter/b2k.scatter

    r3699 r3761  
    9090    // k e r n e l   d e c l a r a t i o n s
    9191    //
    92     kernelDef           ->     KERNEL kernelName LCURLY initDef funcDef (optFuncDef)? expr TERMINATOR RCURLY TERMINATOR? ; // KH: TODO - a temporary hack that appends a CarryDeclare node
     92    kernelDef           ->     KERNEL kernelName LCURLY initDef funcDef (funcDef)* carryDeclare TERMINATOR RCURLY TERMINATOR? ;
    9393    kernelName          #-> identifier ;
    9494
     
    111111    parameterName       #-> identifier ;
    112112    basicBlockStmt      #-> blockStmt ;
    113     optFuncDef          #-> funcDef ;
     113    //optFuncDef          #-> funcDef ;
     114    carryDeclare                #-> expr; // // KH: temp hack to append the CarryDeclare() macro
    114115
    115116    //
  • proto/s2k/trunk/framework/input/test/b2k/all/all.b2k

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

    r3760 r3761  
    161161                lex.LF = simd_andc(temp20,temp17);
    162162        }
    163 
     163       
    164164        void clear()
    165165        {
    166 
     166               
    167167        }
    168168       
     
    201201        void clear()
    202202        {
    203 
    204         }
    205 
     203               
     204        }
     205       
    206206        CarryDeclare(carry_set_0,5,0);
    207207};
     
    337337                carry_set_0.setCarry(carry_set_0.carryFlip(2),2);
    338338        }
    339 
     339       
    340340        CarryDeclare(carry_set_0,7,0);
    341341};
  • proto/s2k/trunk/framework/src/b2k/parser/Parser.java

    r3726 r3761  
    231231                        allChildren.add(child);
    232232                }
    233                 if( nowReading.isLextant(Lextant.FUNCTION) ) {
    234                         {
    235                                 ASTNode child = parseOptFuncDef();
    236                                 result.appendChild(child);
    237                                 allChildren.add(child);
    238                         }
    239                 }
    240                 {
    241                         ASTNode child = parseExpr();
     233                while( nowReading.isLextant(Lextant.FUNCTION) ) {
     234                        {
     235                                ASTNode child = parseFuncDef();
     236                                result.appendChild(child);
     237                                allChildren.add(child);
     238                        }
     239                }
     240                {
     241                        ASTNode child = parseCarryDeclare();
    242242                        result.appendChild(child);
    243243                        allChildren.add(child);
     
    555555        }
    556556         
    557         public ASTNode parseOptFuncDef() {
    558                 if( !(nowReading.isLextant(Lextant.FUNCTION)) ) {
    559                         return syntaxErrorNode("optFuncDef² [FUNCTION¹]");
     557        public ASTNode parseCarryDeclare() {
     558                if( !(nowReading.isLextant(Lextant.LROUND) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING))) ) {
     559                        return syntaxErrorNode("carryDeclare² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, SQ_STRING¹, STRING¹]");
    560560                }
    561561       
     
    565565                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    566566                {
    567                         ASTNode child = parseFuncDef();
     567                        ASTNode child = parseExpr();
    568568                        result.appendChild(child);
    569569                        allChildren.add(child);
  • proto/s2k/trunk/framework/src/toolchain/b2k/ast/Accessors.java

    r3701 r3761  
    5353       
    5454        public static boolean hasFinalBlockFuncDef(KernelDefNode node) {
    55                 if(node.nChildren() > 2 && (node.child(3) instanceof FuncDefNode)) {
     55                if(node.nChildren() > 3 && (node.child(3) instanceof FuncDefNode)) {
    5656                        return true;
    5757                }
  • proto/s2k/trunk/framework/src/toolchain/b2k/ast/Generators.java

    r3701 r3761  
    109109                        String name,
    110110                        InitDefNode initDefNode,
    111                         FuncDefNode funcDefNode,
    112                         FuncDefNode optFuncDefNode) {
     111                        FuncDefNode doBlockFuncDefNode,
     112                        FuncDefNode doFinalBlockFuncDefNode,
     113                        FuncDefNode clearFuncDefNode) {
    113114               
    114115                        LextantToken token = Generators.makeLextantToken(locator, Lextant.KERNEL);
     
    118119                        kernelDefNode.appendChild(identifierNode);
    119120                        kernelDefNode.appendChild(initDefNode);
    120                         kernelDefNode.appendChild(funcDefNode.deepCopy());
    121                         kernelDefNode.appendChild(optFuncDefNode.deepCopy());
     121                        kernelDefNode.appendChild(doBlockFuncDefNode.deepCopy());
     122                        kernelDefNode.appendChild(doFinalBlockFuncDefNode.deepCopy());
     123                        kernelDefNode.appendChild(clearFuncDefNode.deepCopy());
    122124                       
    123125                        return kernelDefNode;
     
    218220    // Function definitions
    219221    //
     222    public static FuncDefNode makeFuncDefNode(Locator locator, ASTNode returnType, String identifier) {
     223       
     224        LextantToken token = Generators.makeLextantToken(locator, Lextant.FUNCTION);
     225        FuncDefNode funcDef = new FuncDefNode(token);
     226        IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, identifier);
     227        BlockStmtNode blockStmtNode = Generators.makeBlockStmtNode(locator);
     228       
     229        funcDef.appendChild(returnType);
     230        funcDef.appendChild(identifierNode);
     231        funcDef.appendChild(blockStmtNode);
     232               
     233        return funcDef;
     234    }
     235   
    220236    public static void appendParameter(FuncDefNode funcDefNode, ParameterNode parameterNode) {
    221237       
     
    223239       
    224240        if(!Accessors.hasParameters(funcDefNode)) {
    225             parameterListNode = new ParameterListNode(parameterNode.getToken()); // likely needs a fix
     241            parameterListNode = new ParameterListNode(parameterNode.getToken()); // KH: refactor to force an parameter list node i.e. not optional ?
    226242            funcDefNode.insertAfterChild(Accessors.funcIdentifier(funcDefNode), parameterListNode);
    227243        } else {
     
    373389                return (IntConstantToken) IntConstantToken.makeArtifical(LexicalType.INTEGER_CONST, locator.getLocation(), n);
    374390        }                       
    375     public static StringConstantNode makeStringConstantNode(Locator locator, String string) {
     391
     392        public static StringConstantNode makeStringConstantNode(Locator locator, String string) {
    376393        StringConstantToken newToken = makeStringConstantToken(locator, string);
    377394        return new StringConstantNode(newToken);
    378395    }
    379     public static StringConstantToken makeStringConstantToken(Locator locator, String string) {
     396   
     397        public static StringConstantToken makeStringConstantToken(Locator locator, String string) {
    380398        return StringConstantToken.make(LexicalType.STRING, locator, string);
    381399    }
    382400   
     401    ///////////////////////////////////////////////////////////////////
     402    // Type nodes
     403    // 
     404    public static VoidTypeNode makeVoidTypeNode(Locator locator) {
     405            Token voidTypeToken = Generators.makeLextantToken(locator, b2k.lexicalAnalyzer.Lextant.VOID);
     406            return new VoidTypeNode(voidTypeToken);
     407    }
     408               
    383409    ///////////////////////////////////////////////////////////////////
    384410    // SIMD EOF_mask calls
  • proto/s2k/trunk/framework/src/toolchain/b2k/codeGenerator/visitors/Unparser.java

    r3702 r3761  
    123123                code.addAll(funcDefCodeStore, 0);
    124124               
    125                 if(Accessors.hasFinalBlockFuncDef(node)) {
     125                if(Accessors.hasFinalBlockFuncDef(node)) { // KH: refactor - eliminate has() calls
    126126                        CodeStore optFuncDefCodeStore = childResults.get(3);
    127127                        // optFuncDefCodeStore.prependToFirst("IDISA_INLINE ");
     
    129129                }
    130130
     131                //
     132                CodeStore clearFuncDefCodeStore = childResults.get(4);
     133                code.addAll(clearFuncDefCodeStore, 0);
     134               
    131135                CodeStore carryDeclareCodeStore;
    132136                if(Accessors.hasFinalBlockFuncDef(node)) {
    133                     carryDeclareCodeStore = childResults.get(4);
     137                    carryDeclareCodeStore = childResults.get(5);
    134138                } else {
    135                         carryDeclareCodeStore = childResults.get(3);
     139                        carryDeclareCodeStore = childResults.get(4);
    136140                }
    137141                code.addAll(carryDeclareCodeStore, 0);
  • proto/s2k/trunk/framework/src/toolchain/b2k/lang/B2KBuiltin.java

    r3699 r3761  
    1212      EOF_MASK("EOF_mask", CarryType.None, 0), // keywords
    1313      DO_BLOCK("do_block", CarryType.None, 0),
    14       DO_FINAL_BLOCK("do_final_block", CarryType.None, 0);
     14      DO_FINAL_BLOCK("do_final_block", CarryType.None, 0),
     15      CLEAR("clear", CarryType.None, 0);
    1516     
    1617      public enum CarryType{One, N, None};   
  • proto/s2k/trunk/framework/src/toolchain/b2k/lang/B2KBuiltins2C.java

    r3699 r3761  
    1717        b2k2CCode.put(B2KBuiltin.DO_BLOCK, "do_block");
    1818        b2k2CCode.put(B2KBuiltin.DO_FINAL_BLOCK, "do_final_block");
     19        b2k2CCode.put(B2KBuiltin.CLEAR, "clear");
    1920
    2021        for(B2KBuiltin builtin : B2KBuiltin.values()) {
  • proto/s2k/trunk/framework/src/toolchain/b2k/lang/B2KBuiltins2CPP.java

    r3699 r3761  
    1717        b2k2CPPCode.put(B2KBuiltin.DO_BLOCK, "do_block");
    1818        b2k2CPPCode.put(B2KBuiltin.DO_FINAL_BLOCK, "do_final_block");
     19        b2k2CPPCode.put(B2KBuiltin.CLEAR, "clear");
    1920               
    2021        for(B2KBuiltin builtin : B2KBuiltin.values()) {
  • proto/s2k/trunk/framework/src/toolchain/s2k/transformer/visitors/S2K2B2K/S2K2B2KTransformer.java

    r3708 r3761  
    2424import static toolchain.b2k.lang.B2KBuiltin.DO_BLOCK;
    2525import static toolchain.b2k.lang.B2KBuiltin.DO_FINAL_BLOCK;
     26import static toolchain.b2k.lang.B2KBuiltin.CLEAR;
    2627import static toolchain.b2k.lang.idisa.IDISABuiltin.*;
    2728import static toolchain.b2k.lang.types.PrimitiveType.BITBLOCK_SIZE;
     
    4849
    4950        // S2B final block mode
    50         Map<s2k.ast.ASTNode, PropertyInfoSet> finalBlockPropInfoSetMap   = PropertyInfoSetMapBuilder.forTree(s2kFinalBlockASTree);
    51         Context finalBlockContext                                        = new Context(builtinEncoder, carrySetEncoder, true, true, 0);
    52         S2K2B2KTranslator finalBlockS2BTranslator                        = new S2K2B2KTranslator(finalBlockPropInfoSetMap, finalBlockContext);
    53         ASTNode b2kFinalBlockASTree                                   = s2kFinalBlockASTree.accept(finalBlockS2BTranslator);
     51        Map<s2k.ast.ASTNode, PropertyInfoSet> finalBlockPropInfoSetMap  = PropertyInfoSetMapBuilder.forTree(s2kFinalBlockASTree);
     52        Context finalBlockContext                                       = new Context(builtinEncoder, carrySetEncoder, true, true, 0);
     53        S2K2B2KTranslator finalBlockS2BTranslator                       = new S2K2B2KTranslator(finalBlockPropInfoSetMap, finalBlockContext);
     54        ASTNode b2kFinalBlockASTree                                     = s2kFinalBlockASTree.accept(finalBlockS2BTranslator);
    5455       
    5556        List<s2k.ast.FuncDefNode> funcDefs = toolchain.s2k.ast.Accessors.funcDefs((s2k.ast.ProgramNode) s2kASTree);
     
    6061            Locator locator             = Generators.makeTextLocation(funcDef.getLocation());
    6162            PropertyInfoSet propInfoSet = propInfoSetMap.get(funcDef);
    62             InitDefNode initDef         = makeInitDefNode(locator, propInfoSet);
    63             addCarryInitFuncCall(locator, context, propInfoSet, initDef);
     63           
     64            List<FuncCallNode> carryInitFuncCalls       = makeCarryInitFuncCallNodes(locator, context, propInfoSet);
     65            InitDefNode initDef                                 = makeInitDefNode(locator, propInfoSet);
     66            addCarryInitFuncCallNodes(carryInitFuncCalls, initDef);
    6467           
    6568            FuncDefNode doBlockFuncDef      = Accessors.funcDefForName(b2kASTree, kernelName);
     
    6871            Mutators.rename(doBlockFuncDef, DO_BLOCK.b2kName());         
    6972            Mutators.rename(doFinalBlockFuncDef, DO_FINAL_BLOCK.b2kName());
     73           
     74            FuncDefNode clearFuncDef            = makeClearFuncDefNode(locator, CLEAR.b2kName());
     75            addCarryInitFuncCallNodes(carryInitFuncCalls, clearFuncDef);
    7076                       
    71             KernelDefNode kernelDef     = Generators.makeKernelDef(locator,
    72                                                                     kernelName,
    73                                                                     initDef,
    74                                                                     doBlockFuncDef,
    75                                                                     doFinalBlockFuncDef);
     77            KernelDefNode kernelDef             = Generators.makeKernelDef(locator,
     78                                                                            kernelName,
     79                                                                            initDef,
     80                                                                            doBlockFuncDef,
     81                                                                            doFinalBlockFuncDef,
     82                                                                            clearFuncDef);
    7683           
    7784            addCarryDeclareFuncCall(locator, context, propInfoSet, kernelDef);
     
    8289    }
    8390
    84     private static void addCarryInitFuncCall(Locator locator, Context context,
    85             PropertyInfoSet propInfoSet, InitDefNode kernelDef) {
    86        
     91    private static List<FuncCallNode> makeCarryInitFuncCallNodes(Locator locator, Context context,
     92            PropertyInfoSet propInfoSet) {
     93       
     94        List<FuncCallNode> funcCallNodes = new ArrayList<FuncCallNode>();
     95       
    8796        Integer [] values = arrayFromList(propInfoSet.carry1InitialValues);
    8897        for(int i = 0; i < values.length; i++) {   
    8998            if(values[i] > 0) {
    9099                FuncCallNode setCarryFuncCall = Generators.makeCarryFlipCall(locator, context, i);
    91                 kernelDef.appendChild(setCarryFuncCall);
    92             }
    93         }
     100                funcCallNodes.add(setCarryFuncCall);
     101                //kernelDef.appendChild(setCarryFuncCall);
     102            }
     103        }
     104       
     105        return funcCallNodes;
     106    }
     107
     108    private static void addCarryInitFuncCallNodes(List<FuncCallNode> carryInitFuncCallNodes, FuncDefNode funcDef) {
     109        for(FuncCallNode funcCall : carryInitFuncCallNodes) {
     110                Accessors.body(funcDef).appendChild(funcCall);
     111        }
     112    }
     113   
     114    private static void addCarryInitFuncCallNodes(List<FuncCallNode> carryInitFuncCallNodes, InitDefNode kernelDef) {
     115        for(FuncCallNode funcCall : carryInitFuncCallNodes) {
     116                kernelDef.appendChild(funcCall);
     117        }
    94118    }
    95119   
     
    144168       
    145169        return initDef;
     170    }
     171   
     172    private static FuncDefNode makeClearFuncDefNode(Locator locator, String funcName) {
     173       
     174        ASTNode returnType = Generators.makeVoidTypeNode(locator);     
     175        FuncDefNode funcDef = Generators.makeFuncDefNode(locator, returnType, funcName);
     176       
     177        return funcDef;
     178       
    146179    }
    147180   
     
    434467        private BlockStmtNode transformBody(s2k.ast.ASTNode snode, Context localContext) {
    435468
    436             Map<s2k.ast.ASTNode, PropertyInfoSet> propInfoSetMap     = PropertyInfoSetMapBuilder.forTree(snode);
     469            Map<s2k.ast.ASTNode, PropertyInfoSet> propInfoSetMap  = PropertyInfoSetMapBuilder.forTree(snode);
    437470            S2K2B2KTranslator S2BXTranslator                      = new S2K2B2KTranslator(propInfoSetMap, localContext);
    438             BlockStmtNode body                                          = (BlockStmtNode) snode.accept(S2BXTranslator); 
     471            BlockStmtNode body                                    = (BlockStmtNode) snode.accept(S2BXTranslator); 
    439472            return body;
    440473        }       
Note: See TracChangeset for help on using the changeset viewer.